
Blockstudio 7.1 ir pirmais funkciju laidiens kopš v7 pārrakstīšanas. Kamēr v7 atjaunoja pamatus, 7.1 pievieno iespējas, kas pārvērš blokus par kaut ko vairāk: datubāzes slāni, servera funkcijas, ieplānotos uzdevumus un CLI. Tagad bloka mape var būt pilnvērtīga lietotne.

Lūk, viss jaunais.

## Komponenti

Vienmēr pastāvējusi pretruna starp blokiem, ko redaktori izmanto ievietotājā, un blokiem, ko izstrādātāji izmanto kā pamatelementus citām lietām. Kartīte, emblēma, statistikas logrīks, veidlapas ievades lauks. Tiem nepieciešams viss Blockstudio process (atribūti, veidnes, resursi, Tailwind), taču tiem nav jāparādās ievietotājā.

7.1 ievieš komponentus, lai to atrisinātu. Iestatiet `"component": true` savā block.json, un bloks izies visu būvēšanas procesu, taču netiks reģistrēts WordPress bloku tipu reģistrā. Tas neparādās ievietotājā un netiek iekļauts redaktora datos, kas tiek nosūtīti uz JavaScript, taču ir pilnībā pieejams programmatiskai renderēšanai.

```json title="block.json"
{
  "name": "my-theme/card",
  "title": "Card",
  "blockstudio": {
    "component": true,
    "attributes": [
      { "id": "title", "type": "text" },
      { "id": "description", "type": "textarea" }
    ]
  }
}
```

Renderējiet tos no PHP:

```php
bs_render_block([
  'name' => 'my-theme/card',
  'data' => ['title' => 'My Card', 'description' => 'Card content.'],
]);
```

Vai arī izmantojot jauno HTML tagu sintaksi:

```html
<bs:my-theme-card title="My Card" description="Card content." />
```

## Bloku tagi

Tagad blokus var iegult kā HTML tagus, izmantojot divas savstarpēji aizvietojamas sintakses:

```html
<bs:acme-hero title="Welcome" />
<block name="acme/hero" title="Welcome" />
```

Abas veido vienādu izvadi. Abas darbojas ar Blockstudio blokiem un pamata WordPress blokiem. Bloku veidnēs tie tiek renderēti automātiski, bez papildu iestatījumiem. Tas nozīmē, ka veidnē varat tieši veidot pilnus izkārtojumus no citiem blokiem:

```twig title="index.twig"
<div class="my-page">
  <bs:mytheme-card title="Featured" />
  <block name="core/separator" />
  <bs:core-heading level="2">Section Title</bs:core-heading>
  <block name="core/group">
    <block name="core/paragraph">Inside a core group block.</block>
    <bs:mytheme-cta variant="primary" />
  </block>
</div>
```

Abas sintakses var brīvi ligzdot vienu otrā. Blockstudio bloki tiek renderēti, izmantojot visu procesu (veidnes, Tailwind, resursi). Pamata bloki tiek renderēti, izmantojot WordPress un tos pašus renderētājus, kas nodrošina [Lapas un raksti](https://blockstudio.dev/lv/docs/pages-and-patterns/).

Lai renderētu lapas līmenī (ieraksta saturu, logrīku apgabalus), iespējojiet to sadaļā `blockstudio.json`:

```json
{ "blockTags": { "enabled": true } }
```

Atļaušanas un liegšanas saraksti ar aizstājējzīmju rakstiem nosaka, kurus blokus var renderēt, izmantojot tagus. Atribūti `data-*` un `html-*` tiek nodoti renderētā bloka saknes HTML elementam. Pielāgotus renderētājus var reģistrēt, izmantojot filtru `blockstudio/block_tags/renderers`.

Tagu parsētājs ir jauns, viegls virkņu skeneris, kas pilnībā aizstāj DOMDocument. Tas apstrādā ligzdotus tagus, sekojot ligzdošanas dziļumam, rekursīvus konteinera blokus un jauktu sintaksi vienā piegājienā. Veiktspējas testos tas parsē 1,000 vienkāršus tagus 2.4ms un 100 ligzdošanas līmeņus 3.7ms laikā, vienmēr pārspējot gan DOMDocument, gan WordPress `WP_HTML_Tag_Processor`. Tas pats parsētājs apstrādā arī neapstrādātu HTML elementu parsēšanu [Lapām un rakstiem](https://blockstudio.dev/lv/docs/pages-and-patterns/), aizstājot uz DOMDocument balstīto parsētāju, kas iepriekš apstrādāja `<p>`, `<div>` un citus HTML elementus.

## Jauni lauku tipi

### Bloks

Jauns `block` lauka tips, kas ļauj atsaukties uz citu Blockstudio bloku kā atribūtu. Atsauktā bloka lauki tiek izvērsti iekļauti, izmantojot `idStructure` un `overrides`, gluži kā pielāgotie lauki. Atšķirība: veidnē, piekļūstot vērtībai, tiek atgriezta renderētā bloka izvade.

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      {
        "id": "card",
        "type": "block",
        "block": "mytheme/card",
        "idStructure": "card_{id}"
      }
    ]
  }
}
```

Ja `mytheme/card` ir lauki `heading` un `content`, saimniekblokam sānjoslā tiek parādīti `card_heading` un `card_content`. Veidnē `{{ a.card }}` izvada renderēto kartīti. Darbojas gan ar parastiem blokiem, gan komponentiem.

### HTML tags

Katrā tēmā ir bloki, kuros virsraksta līmenim jāmainās atkarībā no konteksta. H1 sākumlapā, H2 iekšējās lapās. Tā vietā, lai ikreiz veidotu atlases lauku ar iepriekš noteiktām opcijām, tagad ir īpašs `html-tag` lauka tips ar iebūvētiem sākotnējiem iestatījumiem.

```json
{
  "id": "tag",
  "type": "html-tag",
  "default": "h2",
  "tags": "heading",
  "exclude": ["h5", "h6"]
}
```

Sākotnējie iestatījumi: `heading` (h1-h6), `text` (virsraksti un p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Varat arī nodot pielāgotu masīvu. `exclude` izņem konkrētus tagus no jebkura sākotnējā iestatījuma.

```twig
<{{ a.tag }}>{{ a.title }}</{{ a.tag }}>
```

## Datubāze

Šis ir laidiena centrālais jaunums. Pievienojiet jebkurai bloka mapei failu `db.php`, un Blockstudio ģenerēs piecus REST CRUD galapunktus, pārbaudīs katru rakstīšanas darbību atbilstoši shēmai, automātiski pārvaldīs krātuves aizmugursistēmu un nodrošinās gan JavaScript klientu (`bs.db()`), gan PHP API (`Db::get()`). Nav vajadzīgi migrāciju faili, kontrolieru klases vai maršrutu reģistrācija.

```php title="db.php"
return [
    'subscribers' => [
        'storage'    => 'table',
        'capability' => [
            'create' => true,
            'read'   => true,
            'update' => 'edit_posts',
            'delete' => 'manage_options',
        ],
        'fields' => [
            'email' => [
                'type'     => 'string',
                'format'   => 'email',
                'required' => true,
                'validate' => function ($value) {
                    if (str_ends_with($value, '@spam.com')) {
                        return 'This domain is blocked.';
                    }
                    return true;
                },
            ],
            'name' => ['type' => 'string', 'maxLength' => 100],
            'plan' => ['type' => 'string', 'enum' => ['free', 'pro']],
        ],
    ],
];
```

Ar šo shēmu vien pietiek, lai izveidotu pilnībā darbspējīgu API ar izveides, saraksta, izgūšanas, atjaunināšanas un dzēšanas galapunktiem, kuriem visiem ir ievades validācija.

### Krātuve

Piecas krātuves aizmugursistēmas, katra piemērota atšķirīgiem lietojumiem:

- **`table`**: Pielāgota MySQL tabula, ko pārvalda `dbDelta()`. Pievienojot laukus shēmai, kolonnas tiek pievienotas nākamajā lapas ielādes reizē. Noklusējuma izvēle produkcijas videi.
- **`sqlite`**: Viens SQLite fails bloka `db/` mapē. Īsti SQL vaicājumi, WAL režīms vienlaicīgai lasīšanai un pilnīga pārnesamība. Kopējiet mapi, kopējiet datubāzi.
- **`jsonc`**: Viens JSON objekts katrā rindā vienkāršā failā. Cilvēkam lasāms, versiju kontrolei piemērots, git draudzīgs.
- **`meta`**: JSON masīvs WordPress ziņas metadatos, piesaistīts konkrētai ziņai.
- **`post_type`**: Katrs ieraksts kļūst par WordPress ziņu pielāgotā ziņu veidā. Lauki tiek glabāti kā atsevišķi ziņas metadatu ieraksti, un tos var pilnībā izgūt ar `WP_Query`.

### Klienti

JavaScript pusē `bs.db()` nodrošina pilnvērtīgu CRUD klientu:

```js
const db = bs.db('my-theme/block', 'subscribers');
const record = await db.create({ email: 'a@b.com', plan: 'pro' });
const pros = await db.list({ plan: 'pro' });
await db.update(record.id, { plan: 'free' });
await db.delete(record.id);
```

Līdztekus tam ir pieejamas trīs palīgutilītas:

- **`bs.cache`**: atmiņā glabāta vaicājumu kešatmiņa ar `get`, `set`, `invalidate` un `clear`. Koplietota visiem vaicājumiem un izmaiņu pieprasījumiem.
- **`bs.query(key, fn, options)`**: aptver jebkuru asinhronu funkciju ar kešošanu, pieprasījumu dublēšanās novēršanu un konfigurējamu `staleTime`. Vairāki izsaukumi ar vienādu atslēgu, kamēr pieprasījums tiek apstrādāts, atgriež vienu un to pašu solījumu.
- **`bs.mutate(options)`**: apstrādā optimistiskas izmaiņas ar automātisku atcelšanu. Nododiet reaktīvu stāvokļa objektu, darbību (`create`, `update`, `delete`) un optimistiskos datus. UI tiek atjaunināts uzreiz. Ja servera izsaukums neizdodas, stāvoklis tiek atjaunots tādam, kāds tas bija pirms izmaiņām.

Kopā tie aptver visu lasīšanas un rakstīšanas ciklu: `bs.query` kešotiem lasījumiem, `bs.mutate` optimistiskām rakstīšanas darbībām, `bs.cache` manuālai vadībai.

PHP pusē `Db` klase nodrošina tās pašas darbības:

```php
use Blockstudio\Db;

$db = Db::get('my-theme/block', 'subscribers');
$db->create(['email' => 'a@b.com', 'plan' => 'pro']);
$db->list(['plan' => 'pro']);
```

### Validācija

Validācijas kļūdas tiek atgrieztas kā katra lauka kļūdu masīvi, un formāts ir veidots pēc Zod `fieldErrors` parauga. Vienam laukam var neizpildīties vairāki noteikumi, un šāda struktūra atvieglo kļūdu sasaisti ar veidlapas laukiem frontend pusē:

```json
{
  "data": {
    "status": 400,
    "errors": {
      "email": ["Must be a valid email address.", "This domain is blocked."],
      "plan": ["Must be one of: free, pro."]
    }
  }
}
```

Pielāgotie `validate` atzvanīšanas izsaukumi servera pusē apstrādā visu, ko nevar pārbaudīt ar iebūvētajiem noteikumiem: domēnu bloķēšanu, savstarpēji atkarīgu lauku validāciju un ārējus vaicājumus.

### Lietotājam piesaistīti dati

Lietotāja datiem, piemēram, uzdevumu sarakstiem, izlasei vai melnrakstiem, iestatiet `userScoped` uz `true`, un Blockstudio paveiks pārējo. Tiks pievienota kolonna `user_id`, kas tiek automātiski iestatīta izveides laikā, un visi vaicājumi tiks filtrēti pēc pašreizējā lietotāja. Atjaunināšanas un dzēšanas darbībās tiek pārbaudīta īpašumtiesība. Nav manuāli jānorāda lauks `user_id`, nav vajadzīgs hooks `before_create` un nav jāfiltrē RPC. Pietiek ar vienu konfigurācijas rindu. Izmantojot `post_type` krātuvi, `userScoped` tiek piesaistīts `post_author`, nevis glabāts atsevišķā kolonnā.

```php
return [
    'storage'    => 'sqlite',
    'userScoped' => true,
    'fields'     => [ /* ... */ ],
];
```

### Reāllaika aptauja

Iestatiet shēmā `'realtime' => true`, un klients automātiski aptaujās izmaiņas. Kad serverī kaut kas mainās, Interactivity API krātuve tiek atjaunināta, un UI tiek renderēts no jauna bez izmaiņām JavaScript jūsu pusē. Konfigurējiet ar `'realtime' => ['key' => 'todos', 'interval' => 5000]`, lai iestatītu pielāgotas stāvokļa atslēgas un intervālus. Aptaujā tiek izmantots jaucējvērtību salīdzinājums, lai pieprasījumi būtu viegli, un tā tiek apturēta, kad pārlūka cilne ir paslēpta.

### Drošība, āķi un pārnesamība

Publiskos galapunktus aizsargā automātiski pievienota `X-BS-Token` CSRF galvene. Izmantojiet `'open'`, ja nepieciešama piekļuve bez autentifikācijas, piemēram, ienākošajiem tīmekļa āķiem.

Dzīves cikla āķi tiek izsaukti pirms un pēc katras rakstīšanas darbības. Definējiet tos iekļautus `db.php` vai globāli, izmantojot WordPress darbības.

Laukos var definēt atslēgu `component`, lai veidlapas tiktu attēlotas pēc shēmas, izmantojot `bs_db_form()`.

Izmantojot SQLite vai JSONC krātuvi, visa lietotne atrodas vienā mapē: kods, loģika, piekļuves kontrole un dati. Nokopējiet mapi, lai izvietotu lietotni.

## RPC

Dažkārt ar CRUD nepietiek. Jums nepieciešama pielāgota servera loģika, piemēram, uzdevuma pārslēgšana, paziņojuma nosūtīšana vai statistikas apkopošana. Tam paredzēts `rpc.php`. Definējiet PHP funkciju, izsauciet to frontend pusē ar `bs.fn()`, un Blockstudio apstrādās galapunktu REST, autentifikāciju, CSRF aizsardzību un JSON serializāciju. Šis risinājuma modelis veidots pēc [tRPC](https://trpc.io) parauga: procedūras definē servera pusē un izsauc klients pēc nosaukuma.

```php title="rpc.php"
return [
    'subscribe' => function (array $params): array {
        $email = sanitize_email($params['email']);
        return ['success' => true];
    },
];
```

```js
const result = await bs.fn('subscribe', { email: 'user@example.com' });
```

Iekļautie skripti (`script-inline.js`) automātiski nosaka bloka nosaukumu pēc atribūta `data-block` savā skripta tagā, tāpēc tas nav jānorāda manuāli. Moduļu skripti to nodod kā trešo argumentu.

Piekļuves kontroles opcijās ietilpst `public` (ar CSRF), `'open'` (bez aizsardzības), iespēju virknes vai masīvi. Tiek atbalstīta arī katrai funkcijai atsevišķa HTTP metodes kontrole, dzīves cikla āķi un savstarpēji izsaukumi starp blokiem gan no JS, gan PHP.

## Cron

Fona uzdevumi tiek definēti failā `cron.php`. Iestatiet grafiku un atzvanīšanas funkciju, un Blockstudio inicializācijas laikā reģistrēs tos WordPress Cron. Deaktivizējot spraudni, visi uzdevumi tiek pareizi atcelti.

```php title="cron.php"
return [
    'cleanup' => [
        'schedule' => 'daily',
        'callback' => function () {
            $db = Db::get('my-theme/app', 'logs');
            // delete old entries
        },
    ],
    'sync' => [
        'schedule' => 'hourly',
        'callback' => function () {
            // pull from external API
        },
    ],
];
```

Tiek atbalstīti visi iebūvētie WordPress grafiki, kā arī pielāgoti intervāli, izmantojot filtru `cron_schedules`.

## CLI

Jauna komanda `wp bs` aptver visu Blockstudio funkciju kopumu: blokus, datubāzi, RPC, cron, iestatījumus, Tailwind kompilēšanu, SCSS kompilēšanu, pielāgotos laukus un resursu pārvaldību.

```bash
wp bs blocks list --components
wp bs db schemas
wp bs db create my-theme/app subs --email=a@b.com
wp bs db list my-theme/app subs --plan=pro --format=json
wp bs rpc call my-theme/app subscribe --email=a@b.com
wp bs cron run my-theme/app cleanup
wp bs tailwind compile --file=template.html
wp bs scss compile --file=style.scss
wp bs fields list
wp bs assets list --type=global
wp bs settings get tailwind/enabled
```

Visas komandas atbalsta `--format=json` skriptēšanai.

## Atkārtotāju uzlabojumi

### textMinimized objektu laukiem

Tagad sakļautās atkārtotāja rindās objektu lauku vērtības tiek apstrādātas pareizi. Iepriekš, norādot `textMinimized` uz saites lauku, tika parādīts `[object Object]`. Tagad Blockstudio automātiski nolasa pareizo apakšīpašību atbilstoši lauka tipam: saitēm — `title`, krāsām un gradientiem — `value`, ikonām — `icon`. Varat arī iestatīt īpašību `key`, lai nolasītu jebkuru vajadzīgo apakšīpašību.

```json
{
  "type": "repeater",
  "textMinimized": { "id": "href", "fallback": "Add a link" },
  "attributes": [{ "id": "href", "type": "link" }]
}
```

### RichText un MediaPlaceholder

Abi veidņu komponenti tagad darbojas atkārtotāja laukos, izmantojot kvadrātiekavu pierakstu, lai atlasītu pareizo rindu. Katrā atkārtotāja rindā var iekļaut virsrakstus un rindkopas, ko rediģēt iekļauti, kā arī multivides augšupielādes zonas.

```twig
{% for item in a.items %}
  <div class="card">
    <MediaPlaceholder attribute="items[{{ loop.index0 }}].image" />
    <RichText tag="h2" attribute="items[{{ loop.index0 }}].heading" />
    <RichText tag="p" attribute="items[{{ loop.index0 }}].content" />
  </div>
{% endfor %}
```

## Pielāgoto lauku nosacījumi ar idStructure

Izmantojot pielāgotu lauku ar `idStructure`, nosacījumu ID lauka definīcijā tagad tiek automātiski pārrakstīti, lai tie atbilstu izvērstajiem nosaukumiem. Ja fonta lieluma lauku grupai ir nosacījums `enable` un to izvēršat ar `idStructure: "title_font_{id}"`, nosacījumā tagad pareizi tiek izmantots `title_font_enable`, nevis sākotnējais `enable`.

Tiek atbalstīti arī atsauces līmeņa nosacījumi. Pievienojiet `conditions` pielāgotā lauka atsaucei, lai tos vienlaikus piemērotu katram izvērstajam laukam.

## Dinamiskie populate argumenti

Tagad populate argumentos var izmantot atsauces uz citiem bloka atribūtiem, izmantojot sintaksi `{attributes.*}`. Mainoties atsauktajam atribūtam, atlases lauks automātiski ielādē opcijas no jauna. Apvienojiet atlases laukus ķēdē: viens ļauj izvēlēties ieraksta veidu, otrs ielādē šī veida ierakstus.

```json
{
  "id": "selected_post",
  "type": "select",
  "populate": {
    "type": "query",
    "query": "posts",
    "arguments": {
      "post_type": "{attributes.post_type}"
    }
  }
}
```

Mainiet `post_type` uz "page", un otrais atlases lauks ielādēs lapas. Mainiet to uz "post", un tas ielādēs ierakstus. Darbojas ar jebkuru populate tipu un jebkuru atribūtu.

## Composer

Tagad Blockstudio darbojas, ja tas ielādēts jebkurā vietā zem `wp-content/`, ne tikai spraudņu mapē. Resursu URL tiek atrisinātas, izmantojot konstanti `BLOCKSTUDIO_URL`, nevis `plugins_url()`, tāpēc instalācijas, kur tēma ir komplektā ar spraudni, darbojas uzreiz:

```php title="functions.php"
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/vendor/blockstudio/blockstudio/blockstudio.php';
```

`composer.json` izpildlaika atkarības ir sakoptas. Scoped pakotnes (TailwindPHP, ScssPhp, Minify), kas jau ir iekļautas `lib/`, vairs nav norādītas kā izpildlaika atkarības. Palikušas tikai `php >= 8.2` un `plugin-update-checker`.

Visas trīs instalēšanas metodes (spraudņa ZIP arhīvs, spraudnis ar Composer, tēma ar komplektā iekļautu spraudni, izmantojot Composer) nodrošina vienādu rezultātu: pilnu WordPress aktivizēšanu, bloku reģistrāciju un renderēšanu frontend pusē.

Iestatīšanas norādījumus skatiet [Composer dokumentācijā](https://blockstudio.dev/lv/docs/dev/composer/).

## Veiktspējas profilētājs

Pievienojiet `?blockstudio-perf` jebkurai lapai URL, un apakšā tiks parādīts atkļūdošanas panelis ar katra bloka renderēšanas laiku, fāžu sadalījumu un kešatmiņas trāpījumu biežumu. Laika dati tiek nosūtīti arī Server-Timing galvenēs, kas redzamas pārlūka DevTools Network cilnē.

```json title="blockstudio.json"
{ "dev": { "perf": true } }
```

Iespējojiet to pastāvīgi iestatījumos, lai profilētu katru lapas ielādi. Redzams tikai pieteikušiem lietotājiem ar iespēju `edit_posts`.

Arī pašaizverošie bloku tagi tagad tiek kešoti atmiņā. Ja vienā lapā vairākas reizes parādās viens un tas pats bloks ar identiskiem atribūtiem, nākamajās renderēšanas reizēs tiek izlaists viss veidņu apstrādes process.

## Kļūdu labojumi

- **PHP 8.4 novecojušo funkciju brīdinājumi**: novērsti novecojušo funkciju brīdinājumi `strpos()` un `str_replace()`, ko izraisīja `null` nodošana funkcijai `add_submenu_page()`.

## Vēl

- **SCSS koda lauki**: koda lauki atbalsta `language: "scss"`. Vērtības tiek kompilētas caur ScssPhp gan redaktorā, gan frontend pusē.
- **Standarta WordPress bloki**: Blockstudio mapēs var ietvert `@wordpress/create-block` izvadi līdzās Blockstudio blokiem. Tie tiek reģistrēti automātiski, bez atsevišķa spraudņa koda.

---

Ja vēlaties redzēt pilna steka risinājumu darbībā, ceļvedī [Pilna steka bloki](https://blockstudio.dev/lv/guides/full-stack-blocks/) soli pa solim parādīts, kā no nulles izveidot lietotājam paredzētu uzdevumu lietotni un publisku reģistrēšanās formu jaunumu saņemšanai.
