
Blockstudio 7 jest już dostępny. To największe wydanie w historii projektu: kompletny, gruntowny rewrite całej bazy kodu. Każda klasa, każdy hook i każda linia kodu zostały napisane od nowa z myślą o nowoczesnym PHP, standardach programowania WordPress i łatwym utrzymaniu w długiej perspektywie.

To jednak nie tylko refaktoryzacja. Blockstudio 7 wprowadza ważne nowe funkcje, takie jak strony i wzorce oparte na plikach, system przechowywania metadanych wpisów, integrację z SEO oraz zupełnie nowy parser HTML na bloki, który napędza te rozwiązania. Ponadto Blockstudio jest teraz całkowicie darmowy i otwartoźródłowy.

Przyjrzyjmy się wszystkim nowościom.

## Darmowy i otwartoźródłowy

Pracuję nad Blockstudio od 2020, przez lata wydając dziesiątki kolejnych wersji. Użytkownicy je cenili, ale znalezienie odpowiedniego rynku dla komercyjnego frameworka bloków WordPress zawsze było wyzwaniem.

Sytuację zmieniły LLM-y. Asystenci programistyczni AI potrafią już dobrze pisać kod bloków, ale potrzebują przejrzystych struktur opartych na plikach. Oznaczenia bloków WordPress są nieuporządkowane: serializowane komentarze HTML z osadzonymi atrybutami JSON, przemieszane ze strukturą DOM. Ludziom trudno się w tym odnaleźć, a LLM-om jeszcze trudniej poprawnie to odtworzyć.

Podejście Blockstudio, w którym punktem wyjścia są pliki, od początku miało upraszczać pracę: plik `block.json` i szablon PHP w jednym folderze. Bez wpisów w bazie danych, bez React i bez etapu budowania. Dzięki v7 ta filozofia idzie jeszcze dalej. Parser HTML na bloki pozwala pisać zwykły HTML, który jest automatycznie konwertowany na prawidłowe oznaczenia bloków. Wszystko pozostaje w systemie plików. Zapis do bazy danych następuje tylko podczas synchronizacji stron jawnie uruchomionej przez PHP API lub CLI, a synchronizacją sterują szablony plików.

Udostępnienie Blockstudio jako open source to naturalny kolejny krok. Im więcej modeli LLM trenuje na kodzie Blockstudio, tym lepiej radzą sobie z jego generowaniem. Otwarty kod, otwarta dokumentacja i gotowy plik kontekstu AI [, który może wykorzystać dowolne narzędzie](https://blockstudio.dev/pl/docs/dev/ai/) — tak tworzy się najlepsze środowisko do programowania wspomaganego przez AI.WordPress

Cała wtyczka jest dostępna na [GitHub](https://github.com/inline0/blockstudio). Każdy może jej używać, tworzyć forki i współtworzyć projekt. Bez kluczy licencyjnych, płatnych blokad i ograniczeń funkcji.

## Nowe funkcje

### Strony oparte na plikach

To jedna z największych nowości w wersji 7.0. Możesz teraz definiować całe strony WordPress jako szablony plików, które po uruchomieniu synchronizacji stron przez API lub CLI są synchronizowane z bazą danych jako natywna zawartość bloków.

Utwórz folder z plikiem `page.json` i plikiem szablonu:

```json title="page.json"
{
  "name": "about",
  "title": "About Us",
  "slug": "about",
  "postStatus": "publish"
}
```

```php title="index.php"
<div class="about-page">
  <h1>About Us</h1>
  <p>Welcome to our site.</p>
</div>
```

Uruchom `wp bs pages sync`, aby Blockstudio przetworzył HTML na bloki WordPress i utworzył lub zaktualizował stronę w bazie danych.

#### Łączenie bloków według klucza

Podczas synchronizacji szablonów zmiany użytkowników zwykle byłyby nadpisywane. Atrybut `key` rozwiązuje ten problem, zachowując treść użytkownika podczas synchronizacji:

```html title="index.php"
<h1 key="hero-title">Default Title</h1>
<p key="hero-description">Default description.</p>
```

Bloki o pasujących kluczach zachowują treść zmienioną przez użytkownika po aktualizacji szablonu. Bloki bez kluczy są w całości zastępowane.

#### Powiązania bloków

Zamiast kluczy możesz użyć WordPress core [Block Bindings API](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/), aby bezpośrednio połączyć bloki z metadanymi wpisu. To nie jest funkcja Blockstudio, lecz natywne WordPress API. Blockstudio po prostu przekazuje atrybut `metadata` do wygenerowanych oznaczeń bloków. Treść znajduje się w metadanych, a nie w oznaczeniach bloków, więc synchronizacja szablonów nigdy nie usuwa zmian użytkownika. Dane można też wyszukiwać za pomocą `WP_Query` i uzyskać do nich dostęp przez REST API.

```html title="index.php"
<h1 metadata='{"bindings":{"content":{"source":"core/post-meta","args":{"key":"hero_title"}}}}'>
  Default Title
</h1>
```

Oba podejścia można stosować w tym samym szablonie.

#### Ustawienia edycji

Strony obsługują `blockEditingMode` i `templateLock`, które określają, co użytkownicy mogą zmieniać:

```json title="page.json"
{
  "name": "landing",
  "title": "Landing Page",
  "blockEditingMode": "contentOnly",
  "templateLock": "all"
}
```

Blokuje to strukturę strony, jednocześnie pozwalając użytkownikom edytować tekst i multimedia. Poszczególne elementy mogą zastąpić ustawienie dla całej strony za pomocą atrybutu `blockEditingMode` w szablonie.

#### Przypisywanie do identyfikatorów wpisów

Użyj `postId`, aby powiązać szablon strony z istniejącym wpisem WordPress. Zapobiegnie to tworzeniu duplikatów stron i zapewni, że szablon zawsze aktualizuje właściwy wpis:

```json title="page.json"
{
  "name": "home",
  "title": "Home",
  "postId": 2
}
```

Szczegółowe informacje znajdziesz w dokumentacji [stron](https://blockstudio.dev/pl/docs/pages-and-patterns/pages/).

### Wzorce oparte na plikach

Podobnie jak strony, wzorce bloków można teraz definiować jako szablony plików. Zapisz wzorzec w HTML, a Blockstudio przekształci go w oznaczenia bloków i zarejestruje jako natywny wzorzec bloku WordPress. Wzorce pojawią się w narzędziu wstawiania bloków, a użytkownicy będą mogli umieszczać je w dowolnym miejscu.

```json title="pattern.json"
{
  "name": "hero-section",
  "title": "Hero Section",
  "categories": ["featured"],
  "keywords": ["hero", "banner"]
}
```

```html title="index.php"
<div class="hero">
  <h1>Welcome</h1>
  <p>Get started today.</p>
</div>
```

W przeciwieństwie do stron wzorce nie tworzą wpisów w bazie danych. Są rejestrowane w pamięci przy każdym wczytaniu strony. Zobacz dokumentację [wzorców](https://blockstudio.dev/pl/docs/pages-and-patterns/patterns/).

### Parser HTML na bloki

Zarówno strony, jak i wzorce korzystają z nowego parsera HTML, który przekształca standardowe szablony HTML w oznaczenia bloków WordPress. Automatycznie obsługuje bloki kontenerowe, takie jak grupy i kolumny, oraz bloki liściowe, takie jak akapity i nagłówki. Parser korzysta z architektury renderera opartej na traitach, dzięki czemu można go łatwo rozszerzyć o obsługę dodatkowych typów bloków za pomocą filtra `blockstudio/parser/renderers`:

```php title="functions.php"
add_filter( 'blockstudio/parser/renderers', function ( $renderers, $parser ) {
    $renderers['acme/hero'] = function ( $element, $attrs, $parser ) {
        $content = $parser->get_inner_html( $element );
        $html    = '<div class="acme-hero">' . $content . '</div>';

        return array(
            'blockName'    => 'acme/hero',
            'attrs'        => $attrs,
            'innerBlocks'  => array(),
            'innerHTML'    => $html,
            'innerContent' => array( $html ),
        );
    };

    return $renderers;
}, 10, 2 );
```

Po zarejestrowaniu bloku możesz używać go w szablonie dowolnej strony lub wzorca:

```html title="index.php"
<block name="acme/hero" background="/hero.jpg">
  <h1>Welcome to our site</h1>
</block>
```

### Pamięć masowa

Pola mogą teraz przechowywać wartości w metadanych wpisów lub opcjach witryny, a także w atrybutach bloków. To ważna zmiana:

```json title="block.json"
{
  "id": "subtitle",
  "type": "text",
  "label": "Subtitle",
  "storage": {
    "type": "postMeta"
  }
}
```

Wartości zapisane w metadanych wpisów pozwalają:

- Wyszukiwać wpisy według wartości pól za pomocą `WP_Query` i `meta_query`
- Uzyskiwać dostęp do danych pól przez REST API w konfiguracjach headless
- Udostępniać dane innym wtyczkom, takim jak narzędzia SEO, oraz warstwom pamięci podręcznej

Wartości można też zapisywać w tabeli opcji, aby przechowywać ustawienia globalne dla całej witryny:

```json title="block.json"
{
  "id": "phone",
  "type": "text",
  "label": "Phone Number",
  "storage": {
    "type": "option",
    "optionKey": "company_phone"
  }
}
```

Pełny API znajdziesz w dokumentacji [przechowywania danych](https://blockstudio.dev/pl/docs/blocks/storage/).

### Pola niestandardowe

Wielokrotnego użytku definicje pól można teraz współdzielić między wieloma blokami. Zdefiniuj zestaw pól raz, a następnie odwołuj się do niego z dowolnego bloku. Pozwala to uniknąć powtarzania definicji, gdy kilka bloków korzysta z takiej samej struktury pól.

Utwórz `field.json` w katalogu blockstudio:

```json title="fields/hero/field.json"
{
  "name": "hero",
  "title": "Hero Section",
  "attributes": [
    { "id": "heading", "type": "text", "label": "Heading", "default": "Hello World" },
    { "id": "description", "type": "textarea", "label": "Description" }
  ]
}
```

Następnie odwołaj się do niego z dowolnego bloku, używając prefiksu `custom/`:

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      { "type": "custom/hero", "idStructure": "hero_{id}" }
    ]
  }
}
```

Właściwość `idStructure` dodaje prefiks do identyfikatora każdego pola, więc `heading` staje się `hero_heading`. Możesz też nadpisywać właściwości poszczególnych pól dla konkretnego bloku za pomocą klucza `overrides`.

Zobacz dokumentację [pól niestandardowych](https://blockstudio.dev/pl/docs/blocks/attributes/custom-fields/).

### Tailwind CSS v4

Obsługa Tailwind została całkowicie przebudowana dla v4. Zamiast kompilować kod po stronie klienta za pomocą CDN i zapisywać go na dysku po zapisaniu wpisu (podejście v6), Blockstudio 7 kompiluje Tailwind po stronie serwera przy każdym żądaniu frontendu za pomocą [TailwindPHP](https://github.com/dnnsjsk/tailwindphp). Bez Node.js, bez CLI i bez etapu budowania.

Kompilacja korzysta z pamięci podręcznej opartej na kandydatach: Blockstudio pobiera wszystkie nazwy klas CSS z końcowego HTML, sortuje je i tworzy ich skrót wraz z konfiguracją CSS, a następnie sprawdza, czy plik znajduje się w pamięci podręcznej. Te same klasy dają ten sam wynik z pamięci podręcznej, nawet gdy otaczające je HTML się zmienia (wartości nonce, znaczniki czasu, treść dynamiczna).

Konfiguracja używa składni Tailwind v4, w której CSS jest na pierwszym miejscu. Zdefiniuj własne motywy i klasy narzędziowe bezpośrednio w pliku `blockstudio.json` lub za pomocą filtra `blockstudio/tailwind/css`:

```php title="functions.php"
add_filter('blockstudio/tailwind/css', function ($css) {
  return $css . '
    @theme {
      --color-brand: #4f46e5;
    }

    @layer utilities {
      .container-narrow {
        max-width: 48rem;
        margin-inline: auto;
      }
    }
  ';
});
```

W edytorze bloków dołączony skrypt Tailwind CDN zapewnia podgląd na żywo podczas pisania. Typ pola `classes` podpowiada wszystkie klasy narzędziowe Tailwind. Frontend zawsze korzysta z skompilowanego po stronie serwera CSS, wstawianego jako wbudowany tag stylu przed `</head>`.

Pełną konfigurację znajdziesz w dokumentacji [Tailwind](https://blockstudio.dev/pl/docs/tailwind/).

### Interaktywność API

Blockstudio obsługuje teraz [WordPress Interactivity API](https://developer.wordpress.org/block-editor/reference-guides/interactivity-api/). Włącz ją w block.json:

```json title="block.json"
{
  "blockstudio": {
    "interactivity": true
  }
}
```

Dodaj dyrektywy `data-wp-*` do szablonu:

```php title="index.php"
<div useBlockProps
     data-wp-interactive="myBlock"
     data-wp-context='{ "isOpen": false }'>
  <button data-wp-on--click="actions.toggle"
          data-wp-bind--aria-expanded="context.isOpen">
    Toggle
  </button>
  <div data-wp-bind--hidden="!context.isOpen">
    This content is toggled by the button.
  </div>
</div>
```

Utwórz też `script.js` z logiką swojego magazynu danych:

```javascript title="script.js"
import { store, getContext } from '@wordpress/interactivity';

store('myBlock', {
  actions: {
    toggle: () => {
      const context = getContext();
      context.isOpen = !context.isOpen;
    },
  },
});
```

Blockstudio obsługuje importmapę, ładowanie modułów i przetwarzanie dyrektyw zarówno w frontendzie, jak i edytorze bloków. Bloki korzystające wyłącznie z deklaratywnych dyrektyw z `data-wp-context`, takich jak `data-wp-bind--hidden` lub `data-wp-text`, działają bez JavaScript. Stan po stronie serwera przez `wp_interactivity_state()` jest również obsługiwany w frontendzie.

Pełną konfigurację opisano w dokumentacji [interaktywności](https://blockstudio.dev/pl/docs/blocks/interactivity/).

### Analiza treści SEO

Bloki Blockstudio są dynamiczne, więc ich zawartość pól jest domyślnie niewidoczna dla wtyczek SEO. Blockstudio 7 rozwiązuje ten problem dzięki automatycznej integracji z Yoast SEO, Rank Math i SEOPress. Wartości tekstowe z pól `text`, `textarea`, `richtext`, `wysiwyg` i `link` (w tym zagnieżdżone wiersze pól powtarzalnych) są wyodrębniane i przekazywane do analizy treści każdej wtyczki. Wtyczki SEO mogą teraz prawidłowo analizować zawartość bloków pod kątem gęstości słów kluczowych, czytelności i innych wskaźników. Konfiguracja nie jest wymagana.

### Domyślne wiersze pól powtarzalnych

Pola powtarzalne obsługują teraz właściwość `default` zawierającą tablicę wstępnie wypełnionych wierszy. Po wstawieniu bloku pole powtarzalne zostaje wypełnione określonymi wierszami i ich wartościami, zarówno w edytorze, jak i w frontendzie:

```json title="block.json"
{
  "id": "features",
  "type": "repeater",
  "label": "Features",
  "default": [
    { "title": "Fast", "icon": "bolt" },
    { "title": "Secure", "icon": "shield" }
  ],
  "attributes": [
    { "id": "title", "type": "text", "label": "Title" },
    { "id": "icon", "type": "text", "label": "Icon" }
  ]
}
```

Właściwość `min` obsługuje również wartości domyślne na poziomie pól: jeśli pole powtarzalne ma `min: 3`, a jego pola wewnętrzne mają wartości `default`, automatycznie wygenerowane wiersze zostaną wstępnie wypełnione tymi wartościami zamiast pozostać puste.

## Ulepszenia i poprawki

- **`min` repeatera z wartościami domyślnymi pól**: wiersze generowane automatycznie dla minimalnej liczby pozycji używają teraz wartości domyślnych poszczególnych pól zarówno na stronie, jak i w edytorze
- **Style Tailwind w edytorze**: skompilowany Tailwind CSS jest teraz wstrzykiwany do iframe edytora bloków obok CDN, dzięki czemu własne reguły `@apply` i konfiguracja motywu działają w edytorze
- **[Plik kontekstu AI](https://blockstudio.dev/pl/docs/dev/ai/)**: `blockstudio-llm.txt` przebudowano jako plik statyczny złożony z pełnej dokumentacji v7 i schematów JSON bez duplikatów (~48k tokenów), zastępując dynamiczne generowanie z v6
- **Osobne okno pola kodu**: pole kodu można teraz otworzyć w osobnym oknie z niezależnym cofaniem i ponawianiem oraz podświetlaniem składni JavaScript
- **Kompilacja Tailwind v4 po stronie serwera**: zobacz powyższą [sekcję Tailwind](#tailwind-css-v4)
- **Wersja API 3**: bloki renderują się teraz poprawnie w edytorze osadzonym w iframe, w tym w edytorze witryny i podglądach responsywnych
- **Notacja kropkowa zasobów**: czytelniejsze nazewnictwo sufiksów zasobów (`*.inline.css`, `*.editor.js`, `*.scoped.css`)
- Naprawiono ostrzeżenie `bs_render_block()` z `WP_Block_Supports` przy użyciu `useBlockProps`
- Naprawiono ignorowanie wartości domyślnych przez pola warunkowe przy pierwszym wczytaniu
- Naprawiono usuwanie znaków dolara z treści `<RichText />` na stronie
- Naprawiono działanie `populate` z taksonomiami rejestrowanymi przez inne wtyczki
- Naprawiono błąd null w `optionsPopulate` w kontekstach WPML

## Szczegóły techniczne

### Całkowite przepisanie

To nie jest refaktoryzacja ani porządkowanie kodu. Każda klasa została napisana od nowa. W efekcie powstała bardziej przejrzysta i modułowa baza kodu, którą łatwiej utrzymywać i rozszerzać.

### Nowoczesne PHP

Blockstudio 7 wymaga PHP 8.2+ i wszędzie używa nowoczesnych deklaracji typów.

## Zmiany niezgodne

Wersja 7.0, jako główne wydanie, wprowadza kilka zmian niezgodnych wstecz. Większość ma rozwiązania zastępcze zapewniające zgodność wstecz, ale przed aktualizacją należy się z nimi zapoznać. Pełny przewodnik migracji znajdziesz w dokumentacji migracji [v7](https://blockstudio.dev/pl/docs/dev/migration/v7/).

### Nazwy hooków są teraz zapisywane w snake_case

Wszystkie hooki PHP zmieniły nazwy z camelCase na snake_case, zgodnie z konwencjami core WordPress:

```php title="functions.php"
// Before (v6)
add_filter('blockstudio/settings/blockEditor/cssClasses', function() {
    return ['my-stylesheet'];
});

// After (v7)
add_filter('blockstudio/settings/block_editor/css_classes', function() {
    return ['my-stylesheet'];
});
```

Stare nazwy camelCase nadal działają, ale zalecamy ich aktualizację.

### Przełącznik pola jest domyślnie wyłączony

Właściwość `switch` ma teraz domyślnie wartość `false` zamiast `true`. W v6 każde pole miało niewidoczny przełącznik przy lewej krawędzi, domyślnie włączony. W v7 przełącznik jest opcjonalny i używa widocznej ikony oka w etykiecie pola. Jeśli korzystasz z domyślnego działania przełącznika, dodaj `"switch": true` do definicji pól.

### Nazwy plików zasobów używają notacji kropkowej

Przyrostki zasobów używają teraz kropek zamiast myślników (`style.inline.css` zamiast `style-inline.css`). Stara notacja z myślnikami nadal działa, ale zalecamy używanie notacji kropkowej.

### Prefiks importu npm

Importy modułów ES używają teraz `npm:` zamiast `blockstudio/`:

```javascript title="script.js"
// Before (v6)
import confetti from "blockstudio/canvas-confetti@1.6.0";

// After (v7)
import confetti from "npm:canvas-confetti@1.6.0";
```

Prefiks `blockstudio/` jest nadal obsługiwany w celu zachowania zgodności wstecz.

### Usunięte funkcje

**Panel administracyjny i edytor kodu.** Usunięto stronę ustawień administracyjnych WordPress oraz wbudowany edytor kodu bloków. Konfiguracja odbywa się teraz za pomocą filtrów `blockstudio.json` i PHP, dzięki czemu ustawienia projektu znajdują się w systemie kontroli wersji razem z blokami.

Edytor kodu był przydatny w poprzednich wersjach do podglądu bloków, ale nigdy nie dorównał prawdziwemu środowisku programistycznemu. Przez lata kilka funkcji wtyczki nie mogło zostać udostępnionych, ponieważ nie dało się ich obsłużyć w samodzielnym edytorze. Nie miał też zastąpić pełnego IDE. Jego usunięcie pozwala wtyczce skupić się w pełni na programowaniu opartym na plikach.

**Klucz licencyjny.** Nie jest już potrzebny. Blockstudio jest darmowy i otwartoźródłowy.

**Biblioteka bloków.** Usunięto wbudowaną bibliotekę „Blockstudio Elements” (Gallery, Slider, Image Comparison, Code, Icon). Były to gotowe bloki przykładowe dołączane do wtyczki. Jeśli ich używasz, skopiuj foldery bloków z v6 do katalogu blockstudio w swoim motywie.

## Pierwsze kroki

Zainstaluj Blockstudio 7 i utwórz pierwszy blok w kilka minut. Zapoznaj się z przewodnikiem [Pierwsze kroki](https://blockstudio.dev/pl/docs/general/getting-started/), który zawiera instrukcje krok po kroku, lub z przewodnikiem migracji [v7](https://blockstudio.dev/pl/docs/dev/migration/v7/), jeśli aktualizujesz z v6.

Pełny kod źródłowy znajdziesz na [GitHub](https://github.com/inline0/blockstudio). Zgłoszenia problemów, PR-y i opinie są mile widziane.
