Treci la conținut

Dennis · 23 iulie 2026

Blockstudio 7.5

Blockstudio Versiunea 7.5 completează fluxul de lucru bazat pe fișiere al Blockstudio: tipuri de câmpuri personalizate, șabloane Site Editor bazate pe fișiere, insule de blocuri, stocare în baza de date Storh, surse logice de descoperire, etichete de bloc compozabile și căi mai rapide de implementare și execuție.

Câmpurile personalizate reutilizabile permit deja proiectelor să definească o singură dată un grup de câmpuri existente și să îl reutilizeze cu type: "custom/{name}". Tipurile de câmpuri personalizate rezolvă o problemă diferită. Acestea permit unei teme sau unui plugin să înregistreze un nou tip de câmp cu spațiu de nume propriu, să furnizeze propriul control de editare și să stocheze valoarea ca date Blockstudio obișnuite.

Pe scurt:

  • Surse logice de descoperire: mediile de execuție pot furniza un inventar logic compus al temei, inclusiv proveniența și identitatea cache-ului, în timp ce Blockstudio păstrează responsabilitatea pentru descoperire, rezolvarea fișierelor surori, activele generate, Canvas și comportamentul Tailwind.
  • Registrul de tipuri de câmp PHP: temele și pluginurile pot înregistra tipuri de câmp cu spațiu de nume, precum acme/dimensions cu bs_register_field_type() sau filtrul blockstudio/field_types.
  • Registrul controalelor editorului: scripturile personalizate ale editorului pot apela window.blockstudio.registerFieldType() și pot reda controlul React corespunzător în UI normal al câmpului Blockstudio.
  • Valori structurate: câmpurile personalizate pot stoca șiruri, numere, valori booleene, tablouri sau obiecte fără a converti valorile obiectelor prin normalizarea câmpurilor de opțiuni.
  • Suport pentru stocare: câmpurile personalizate din meta-ul postărilor și cele bazate pe opțiuni își pot declara tipul valorii și schema REST, inclusiv pentru valori de tip obiect și tablou.
  • Integrare nativă: tipurile de câmp personalizate funcționează în grupuri, file, repetoare, câmpuri personalizate reutilizabile, șabloane și căi de șabloane pentru extensii.
  • Șabloane pentru editorul site-ului: temele pot defini surse wp_template și wp_template_part din fișierele de șablon template.json, part.json și Blockstudio.
  • Insule de blocuri: blocurile pot reda mai întâi un cadru sigur pentru cache, apoi pot hidrata sau prelua în lot fragmente specifice cererii după încărcarea paginii.
  • Stocare în baza de date Storh: bs.db poate folosi în uploads un depozit indexat, cu câte un fișier pentru fiecare înregistrare, păstrând ID-urile întregi publice și migrarea de la JSONC la Storh prin WP-CLI.
  • Îmbunătățiri pentru parser și bsui: paragrafele richtext mapate necesită mai puțin cod personalizat pentru parser, InnerBlocks poate folosi allowedBlocks tokenizat, rezultatul bs_render_block() imbricat corespunde redării din frontend în previzualizările editorului, iar bsui/button oferă pictograme și opțiuni mai simple de stilizare.
  • Etichete de bloc compozabile: etichetele cu prefix se pot rezolva printr-un alt prefix (<theme-ui-input> către bsui/input), iar etichetele cu prefix și alias se redau în rezultatul șabloanelor de bloc, nu doar în conținutul paginii.
  • Cache-uri de build sigure pentru gazdă: cache-urile mediului de execuție și ale editorului se află implicit în afara uploads, acceptă locații configurabile și elimină intrările învechite, astfel încât proiectele de lungă durată să nu acumuleze fișiere cache.
  • Reconciliere incrementală a paginilor: instrumentele de implementare pot reconcilia inventarul complet al paginilor din fișiere, pot sări peste postările neschimbate, pot raporta exact ce s-a modificat și pot salva o identitate verificată a sursei după activare.
  • Redare la cald mai rapidă: cache-urile valide ale mediului de execuție se hidratează înainte de descoperire, cererile concurente fără cache publică un singur rezultat atomic, iar Tailwind păstrează un cache de dimensiunea site-ului cu starea compilatorului reutilizabilă.
  • Redare sigură în lot: exportatoarele pot reseta starea de redare asociată cererii între documente fără a reconstrui descoperirea și pot colecta dependențele surselor în timpul redării blocurilor.

Funcționalități noi

Versiunea 7.5 aduce o gamă largă de capabilități noi pentru descoperire, șabloane și stocare.

Surse logice de descoperire

În mod normal, Blockstudio descoperă fișierele din directoarele fizice ale temei. Versiunea 7.5 adaugă o sursă de nivel inferior API pentru mediile de execuție care asamblează o temă din suprapuneri, previzualizări, fișiere generate, montări la distanță sau alte inventare compuse.

O integrare poate furniza un arbore logic final de fișiere, iar Blockstudio păstrează responsabilitatea pentru comportamentul blocurilor, câmpurilor, paginilor, modelelor, editorului site-ului, Canvas, activelor și Tailwind:

PHP
use Blockstudio\Inventory_Discovery_Source;

add_filter(
    'blockstudio/discovery/sources',
    function (array $sources, string $context): array {
        if ('blocks' !== $context) {
            return $sources;
        }

        return [
            new Inventory_Discovery_Source(
                'preview:feature-card',
                '/runtime-preview/feature-card/blockstudio',
                [
                    'card/block.json' => [
                        'path' => '/theme/blockstudio/card/block.json',
                        'provenance' => ['layer' => 'parent'],
                    ],
                    'card/index.php' => [
                        'path' => '/runtime-preview/feature-card/blockstudio/card/index.php',
                        'provenance' => ['layer' => 'preview'],
                    ],
                ],
                'preview-fingerprint'
            ),
        ];
    },
    10,
    2
);

Căile logice rămân stabile chiar și atunci când fișierele surori provin din rădăcini fizice diferite. ID-urile surselor și amprentele contribuie la identitățile cache-urilor mediului de execuție și Tailwind, intrările urmărite le invalidează, iar proveniența controlează unde pot fi scrise fișierele generate. Sursa implicită din sistemul de fișiere rămâne neschimbată pentru temele obișnuite.

Șabloane ale editorului site-ului bazate pe fișiere

Paginile și modelele le permit deja echipelor să păstreze structurile de conținut în fișiere. Versiunea 7.5 extinde acest model chiar la editorul site-ului.

Text
theme/
  templates/
    front-page/
      template.json
      index.php
  parts/
    header/
      part.json
      index.php
JSON
{
  "slug": "front-page",
  "title": "Front Page"
}
PHP
<div class="site-shell">
  <block name="core/template-part" slug="header" />

  <main>
    <h1>Welcome</h1>
    <block name="core/post-content" />
  </main>
</div>

Blockstudio compilează sursa prin același parser folosit de pagini și modele, apoi expune rezultatul către WordPress ca șablon obișnuit sau parte de șablon pentru editorul site-ului. Editorul site-ului afișează șablonul, frontend-ul îl poate reda, iar WordPress păstrează în continuare controlul asupra personalizărilor.

Ultima parte este importantă. Șabloanele bazate pe fișiere sunt sursa de rezervă. Dacă un utilizator salvează un șablon în editorul site-ului, WordPress creează personalizarea obișnuită wp_template sau wp_template_part în baza de date, iar acea versiune are prioritate. Resetați personalizarea și sursa actualizată din fișier devine din nou vizibilă.

Implementare incrementală a paginilor

În versiunea 7.5, paginile bazate pe fișiere au primit o API de reconciliere pentru implementare. Începând cu 7.6.2, acestea sunt singurele puncte explicite de sincronizare: API și wp bs pages sync. Cererile obișnuite nu aplică niciodată modificări ale sursei:

PHP
$report = Blockstudio\Pages::reconcile([
  'authoritative' => true,
  'plan_valid' => true,
  'source' => [
    'commit' => $commit,
    'dirtyHash' => $dirtyHash,
  ],
]);

Procesul descoperă inventarul complet de pagini dorit, compară conținutul și amprentele motorului de sincronizare și raportează paginile create, actualizate, nemodificate, eliminate și eșuate. Paginile cu amprente identice nu generează scrieri pentru postări sau postmeta. Paginile administrate care lipsesc sunt eliminate doar după ce descoperirea se încheie fără erori.

Reconcilierea returnează o identitate deterministă a sursei, dar nu marchează o implementare drept reușită. Instrumentele de implementare salvează acea identitate doar după ce fișierele și rutele corespunzătoare sunt active și verificate. Inițializarea obișnuită a WP-CLI înregistrează tipurile de postări și rescrierile colecțiilor din cache fără a descoperi și sincroniza fiecare pagină.

Insule de blocuri

Majoritatea blocurilor Blockstudio sunt redate pe server. Acest lucru se potrivește bine cu WordPress, dar creează o problemă cunoscută de cache: un singur bloc personalizat poate face dificilă stocarea în cache a întregii pagini.

Insulele de blocuri delimitează această problemă la nivelul blocului.

JSON
{
  "name": "acme/cart-count",
  "blockstudio": {
    "island": "dynamic"
  }
}

O insulă dinamică redă doar un substituent sigur pentru cache în primul răspuns. Apoi, browserul trimite o singură cerere în lot pentru toate insulele dinamice disponibile pe pagină, iar Blockstudio redă aceste fragmente în contextul real al cererii vizitatorului.

Astfel, un cache complet al paginii poate stoca cadrul paginii, în timp ce numărul produselor din coș, comenzile contului, UI cu acces restricționat prin permisiuni sau alte elemente specifice fiecărui utilizator rămân actualizate.

PHP
<div class="cart-count-placeholder">Loading cart...</div>
PHP
<div class="cart-count">
  <?php echo esc_html(acme_cart_count()); ?>
</div>

Pentru blocurile care redau deja HTML sigure pentru cache și au nevoie doar de un semnal de montare în frontend, folosiți o insulă hidratată:

JSON
{
  "name": "acme/tabs",
  "blockstudio": {
    "island": "hydrate"
  }
}

Insulele hidratate nu fac o cerere REST. Se redau normal și primesc un eveniment blockstudio:island:hydrate în frontend.

Insulele dinamice funcționează și prin căile de redare programatice:

PHP
bs_render_block([
  'name' => 'acme/cart-count',
  'data' => ['productId' => 42],
]);

Și prin etichetele de bloc:

HTML
<bs:acme-cart-count product-id="42" />

Punctul final este intenționat limitat. Redă doar blocuri Blockstudio înregistrate, care sunt dinamice și marcate explicit drept insule dinamice. Atributele sunt filtrate conform schemei blocului și listei permise pentru insule, iar fiecare marcator include o semnătură generată de site-ul WordPress care deservește cererea.

Stocarea în baza de date Storh

Stratul de bază de date al Blockstudio acceptă deja tabele, SQLite, JSONC, post meta și tipuri de postări personalizate. Versiunea 7.5 adaugă storage: "storh" pentru proiectele care doresc un depozit bazat pe fișiere, cu scrieri concurente mai sigure și indexuri derivate din schemă, dar nu vor să salveze înregistrările active alături de fișierele sursă ale blocurilor.

PHP
return [
    'storage' => 'storh',
    'fields'  => [
        'title'  => ['type' => 'string', 'required' => true],
        'status' => ['type' => 'string'],
        'count'  => ['type' => 'integer'],
    ],
];

Înregistrările Storh se află în uploads:

Text
wp-content/uploads/blockstudio/db/my-theme-my-block/default/

API-ul public API rămâne neschimbat. bs.db(), REST și Db::get() returnează în continuare valori întregi id. În interior, Blockstudio asociază aceste ID-uri cu ID-urile documentelor UUIDv7 ale Storh, astfel încât codul client existent nu trebuie modificat.

Fiecare câmp declarat în schemă este indexat pentru filtre de egalitate, câmpurile numerice și cele de tip dată primesc indexuri de interval, iar indiciile explicite de unicitate sunt transmise mai departe. Pentru proiectele începute cu fișiere seed JSONC, noua migrare CLI păstrează fișierul sursă și scrie un depozit Storh echivalent:

Shell
wp bs db migrate my-theme/app subscribers --to=storh

Astfel, JSONC capătă un rol mai clar ca format simplu, ușor de salvat în controlul versiunilor, pentru seed și configurare, în timp ce Storh devine backend-ul implicit mai potrivit pentru date de producție care pot fi scrise.

Îmbunătățiri pentru parser și bsui

Versiunea 7.5 mai finisează și componente mai mici, care devin utile când un proiect se bazează mai mult pe șabloane bazate pe fișiere și pe UI incluse.

Maparea elementelor poate gestiona acum cazul obișnuit al paragrafelor richtext fără un constructor personalizat. Dacă <p> se mapează la un bloc Blockstudio înregistrat, care nu este de bază și are un atribut richtext content, textul interior simplu este copiat în acel atribut. Etichetele imbricate și elementele copil mapate sunt în continuare analizate ca blocuri interioare.

InnerBlocks acceptă în șabloane allowedBlocks cu tokenuri:

PHP
<InnerBlocks allowedBlocks="<?php echo esc_attr(wp_json_encode([
  'core/paragraph',
  'category:content',
  'bsui/field',
])); ?>" />

Tokenurile acceptate sunt namespace/*, category:<slug> și @theme. Sunt extinse pe server înainte ca editorul să primească șablonul, astfel încât calea de redare în frontend rămâne neschimbată.

Încorporările programatice sunt și mai previzibile. bs_render_block() și bs_block() redau acum blocurile încorporate ca HTML rezolvate de frontend, chiar și când sunt apelate din previzualizarea în editor a unui alt bloc. Astfel, blocurile imbricate nu mai expun pseudo-componente <RichText /> sau <InnerBlocks /> brute în marcajul previzualizării.

Pentru UI incluse, bsui/button acceptă acum un atribut icon și iconPosition. Stilurile inline bsui/* incluse sunt emise într-un strat de cascadă @layer bsui, iar variantele de butoane pot fi extinse cu blockstudio/ui/button/variants-style și filtrul existent blockstudio/blocks/attributes.

Etichetele de bloc se pot compune și mai mult. Un prefix se poate rezolva prin alt prefix, astfel încât <theme-ui-input /> cu prefixul de proiect theme peste spațiul de nume ui se rezolvă la bsui/input. Etichetele cu prefix și alias înregistrate se redau acum și în rezultatul șabloanelor de bloc, nu doar în conținutul paginii, astfel încât un șablon le poate emite direct în loc să apeleze bs_render_block().

Constructorii de blocuri personalizați înregistrați prin blockstudio/block_tags/builders participă și ei în mod consecvent la analiza etichetelor și a elementelor mapate. Filtrele explicite pentru redare rulează ulterior și pot înlocui constructorul.

Cereri la cald și exporturi mai rapide

Cache-urile mediului de execuție și ale editorului se află acum implicit în wp-content/blockstudio/cache, în loc de uploads. Locația poate fi schimbată prin cache.path sau blockstudio/cache/dir, ceea ce menține disponibilă stocarea persistentă în cache pe gazdele care blochează payload-urile PHP în uploads. Cache-urile mediului de execuție, ale activelor editorului și Tailwind elimină automat și intrările învechite, astfel încât proiectele de lungă durată nu mai acumulează pe disc fișiere cache fără limită.

Cererile calde din frontend hidratează acum un registru valid al mediului de execuție înainte de a construi sursele de descoperire. Astfel, sunt sărite descoperirea recursivă a surselor, construirea blocurilor, analiza câmpurilor și parcurgerile repetate ale arborelui pentru cheile cache-ului. În mod implicit, cererile din producție și staging se bazează timp de 20 de secunde pe un instantaneu validat al fișierelor urmărite, în timp ce mediile locale și de dezvoltare verifică la fiecare cerere.

Crearea cache-ului fără date inițiale are un singur flux de execuție. O cerere construiește și publică atomic payload-ul, iar cererile concurente așteaptă rezultatul finalizat. Acum, Tailwind păstrează timp de 30 de zile, în mod implicit, până la 1,000 de intrări compilate și reutilizează starea inițială de construire a compilatorului, astfel încât un set de rute de dimensiunea unui site nu mai aglomerează un cache minuscul.

Exportatoarele care rulează mult timp pot apela Blockstudio\Batch_Render::reset() între documente. Acest lucru șterge contoarele, activele, insulele, aspectele și generarea Tailwind asociate cererii, fără a reconstrui descoperirea. Filtrul blockstudio/render/dependencies expune căile șabloanelor și activelor folosite de fiecare bloc redat pentru grafurile de dependențe.

Fiabilitate și compatibilitate

Mai multe remedieri completează această versiune:

  • Definițiile câmpurilor modificate prin blockstudio/blocks/attributes controlează acum validarea opțiunilor la redare, precum și schema editorului. Valorile numerice și booleene tipizate pentru opțiuni se rezolvă, de asemenea, în mod consecvent.
  • Învelișurile blocurilor din editor folosesc aceleași clase generate ca redările din frontend, iar Canvas poate copia clasele body configurate pentru frontend prin noul filtru blockstudio/editor/canvas/body_class.
  • Content Sync validează întregul plan sursă înainte de scrieri distructive, menține operațiunile de eliminare în setul de conținut configurat și raportează eșecurile de scriere a fișierelor fără a avansa starea de sincronizare a entității respective.
  • Pachetele Composer incluse în temele active sau părinte legate simbolic rezolvă activele editorului din URL public al temei.
  • Paginile din fișiere cu chei păstrează valorile câmpurilor Blockstudio gestionate de editor, migrează la sincronizare structura mai veche cu chei imbricate și acceptă zero numeric ca valoare validă a cheii.
  • Insulele dinamice verifică semnăturile înainte de filtrele atributelor cererii, ignoră contextul cererii nesemnat, restabilesc vizitatorii autentificați de aceeași origine și evită coliziunile de cache anonime specifice utilizatorului.
  • Punctele finale brute Markdown pentru pagini respectă acum vizibilitatea postărilor și protecția prin parolă.
  • Controalele editorului gestionează mai fiabil condițiile goale, valorile comutării tuturor casetelor de selectare, reîmprospătările asincrone ale opțiunilor, ordinea redării dinamice și starea RichText sau WYSIWYG a repetoarelor.

Tipuri de câmp personalizate

Mai multe despre tipurile de câmp personalizate prezentate mai sus.

De ce tipuri de câmp personalizate?

Blockstudio ar trebui să fie util imediat după instalare, dar proiectele reale au adesea controale specifice domeniului: selectoare de tokenuri pentru spațiere, roluri de culoare ale sistemului de design, dimensiuni responsive, surse de pictograme, selectoare de produse sau controale editoriale care corespund unei valori structurate.

Înainte de versiunea 7.5, aceste proiecte puteau fie să combine mai multe câmpuri încorporate, fie să creeze o ramură separată a editorului. Versiunea 7.5 oferă o soluție de mijloc acceptată oficial: Blockstudio gestionează ciclul de viață al câmpului, iar proiectul gestionează controlul.

PHP
add_action('init', function () {
    wp_register_script(
        'acme-field-dimensions',
        get_stylesheet_directory_uri() . '/fields/dimensions.js',
        ['blockstudio-blocks', 'wp-components', 'wp-element'],
        '1.0.0',
        true
    );

    bs_register_field_type('acme/dimensions', [
        'attribute'     => 'object',
        'default'       => [],
        'editor_script' => 'acme-field-dimensions',
        'storage'       => [
            'type'        => 'object',
            'rest_schema' => [
                'type'                 => 'object',
                'additionalProperties' => ['type' => 'string'],
            ],
        ],
    ]);
});
JavaScript
const { createElement: el } = wp.element;
const { TextControl } = wp.components;

window.blockstudio.registerFieldType('acme/dimensions', {
  component(props) {
    const value =
      props.value &&
      typeof props.value === 'object' &&
      !Array.isArray(props.value)
        ? props.value
        : {};
    const sides = props.sides || ['top', 'right', 'bottom', 'left'];

    return el(
      'div',
      {},
      sides.map((side) =>
        el(TextControl, {
          key: side,
          label: side,
          value: value[side] || '',
          onChange(nextValue) {
            props.onChange({
              ...value,
              [side]: nextValue,
            });
          },
        }),
      ),
    );
  },
});

Apoi, câmpul poate fi folosit în block.json ca un câmp nativ:

JSON
{
  "blockstudio": {
    "attributes": [
      {
        "id": "margin",
        "type": "acme/dimensions",
        "label": "Margin",
        "sides": ["top", "bottom"],
        "default": {
          "top": "md",
          "bottom": "md"
        }
      }
    ]
  }
}

Valori normale în șabloane

Valoarea salvată este disponibilă în PHP, Twig și Blade ca orice alt atribut Blockstudio.

PHP
<div class="<?php echo esc_attr('mt-' . ($a['margin']['top'] ?? '')); ?>">
  <?php echo esc_html($a['title'] ?? ''); ?>
</div>

Aceleași căi către obiecte funcționează și în șabloanele extensiilor:

JSON
{
  "blockstudio": {
    "extend": "core/group",
    "attributes": [
      {
        "id": "margin",
        "type": "acme/dimensions",
        "set": [
          {
            "attribute": "class",
            "value": "mt-{attributes.margin.top} mb-{attributes.margin.bottom}"
          }
        ]
      }
    ]
  }
}

Note de compatibilitate

Tipurile de câmp încorporate existente rămân neschimbate. Grupurile de câmpuri reutilizabile custom/{name} existente rămân și ele neschimbate. Numele tipurilor de câmp personalizate trebuie să fie cu litere mici și să aibă spațiu de nume, de exemplu acme/dimensions; spațiile de nume custom/ și blockstudio/ rămân rezervate.

Dacă PHP înregistrează un tip de câmp, dar scriptul editorului său nu înregistrează controlul corespunzător, Blockstudio păstrează valoarea salvată și afișează în editor o notificare care nu poate fi editată. Dacă un tip de câmp nu este înregistrat în PHP, Blockstudio îl exclude din atributele WordPress generate.

Actualizare de mentenanță 7.5.1

7.5.1 elimină un avertisment privind conversia din tablou în șir, emis la pregătirea valorilor cu selecție multiplă pentru redare. Valorile salvate și redate erau deja corecte, dar jurnalele de depanare puteau primi câte un avertisment la fiecare redare a unui câmp.

Actualizarea blockstudio/phpstan v0.1.7 asociată recunoaște și câmpurile imbricate în grupuri anonime în PHP, Twig, Blade și formele deduse ale atributelor șabloanelor. Proiectele existente pot primi remedierea acelui pachet cu composer update blockstudio/phpstan.