371 lines
8.9 KiB
PHP
371 lines
8.9 KiB
PHP
<?php
|
|
|
|
namespace Kirby\Form\Field;
|
|
|
|
use Kirby\Cms\App;
|
|
use Kirby\Cms\Blueprint;
|
|
use Kirby\Cms\Fieldset;
|
|
use Kirby\Cms\Layout;
|
|
use Kirby\Cms\Layouts;
|
|
use Kirby\Data\Data;
|
|
use Kirby\Data\Json;
|
|
use Kirby\Exception\InvalidArgumentException;
|
|
use Kirby\Form\Form;
|
|
use Kirby\Toolkit\Str;
|
|
use Throwable;
|
|
|
|
class LayoutField extends BlocksField
|
|
{
|
|
protected array|null $layouts;
|
|
protected array|null $selector;
|
|
protected Fieldset|null $settings;
|
|
|
|
public function __construct(array $params)
|
|
{
|
|
$this->setModel($params['model'] ?? App::instance()->site());
|
|
$this->setLayouts($params['layouts'] ?? ['1/1']);
|
|
$this->setSelector($params['selector'] ?? null);
|
|
$this->setSettings($params['settings'] ?? null);
|
|
|
|
parent::__construct($params);
|
|
}
|
|
|
|
/**
|
|
* @psalm-suppress MethodSignatureMismatch
|
|
* @todo Remove psalm suppress after https://github.com/vimeo/psalm/issues/8673 is fixed
|
|
*/
|
|
public function fill(mixed $value): static
|
|
{
|
|
$attrs = $this->attrsForm();
|
|
$value = Data::decode($value, type: 'json', fail: false);
|
|
$layouts = Layouts::factory($value, ['parent' => $this->model])->toArray();
|
|
|
|
foreach ($layouts as $layoutIndex => $layout) {
|
|
if ($this->settings !== null) {
|
|
$layouts[$layoutIndex]['attrs'] = $attrs->reset()->fill($layout['attrs'])->toFormValues();
|
|
}
|
|
|
|
foreach ($layout['columns'] as $columnIndex => $column) {
|
|
$layouts[$layoutIndex]['columns'][$columnIndex]['blocks'] = $this->blocksToValues($column['blocks']);
|
|
}
|
|
}
|
|
|
|
$this->value = $layouts;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function attrsForm(): Form
|
|
{
|
|
return new Form(
|
|
fields: $this->settings()?->fields() ?? [],
|
|
model: $this->model
|
|
);
|
|
}
|
|
|
|
public function layouts(): array|null
|
|
{
|
|
return $this->layouts;
|
|
}
|
|
|
|
/**
|
|
* Creates form values for each layout
|
|
*/
|
|
public function layoutsToValues(array $layouts): array
|
|
{
|
|
foreach ($layouts as &$layout) {
|
|
$layout['id'] ??= Str::uuid();
|
|
$layout['columns'] ??= [];
|
|
|
|
array_walk($layout['columns'], function (&$column) {
|
|
$column['id'] ??= Str::uuid();
|
|
$column['blocks'] = $this->blocksToValues($column['blocks'] ?? []);
|
|
});
|
|
}
|
|
|
|
return $layouts;
|
|
}
|
|
|
|
/**
|
|
* Paste action for layouts:
|
|
* - generates new uuids for layout, column and blocks
|
|
* - filters only supported layouts
|
|
* - filters only supported fieldsets
|
|
*/
|
|
public function pasteLayouts(array $layouts): array
|
|
{
|
|
$layouts = $this->layoutsToValues($layouts);
|
|
|
|
foreach ($layouts as $layoutIndex => &$layout) {
|
|
$layout['id'] = Str::uuid();
|
|
|
|
// remove the row if layout not available for the pasted layout field
|
|
$columns = array_column($layout['columns'], 'width');
|
|
if (in_array($columns, $this->layouts(), true) === false) {
|
|
unset($layouts[$layoutIndex]);
|
|
continue;
|
|
}
|
|
|
|
array_walk($layout['columns'], function (&$column) {
|
|
$column['id'] = Str::uuid();
|
|
|
|
array_walk($column['blocks'], function (&$block, $index) use ($column) {
|
|
$block['id'] = Str::uuid();
|
|
|
|
// remove the block if it's not available
|
|
try {
|
|
$this->fieldset($block['type']);
|
|
} catch (Throwable) {
|
|
unset($column['blocks'][$index]);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
return $layouts;
|
|
}
|
|
|
|
public function props(): array
|
|
{
|
|
return [
|
|
...parent::props(),
|
|
'layouts' => $this->layouts(),
|
|
'selector' => $this->selector(),
|
|
'settings' => $this->settings()?->toArray()
|
|
];
|
|
}
|
|
|
|
public function routes(): array
|
|
{
|
|
$field = $this;
|
|
$routes = parent::routes();
|
|
|
|
$routes[] = [
|
|
'pattern' => 'layout',
|
|
'method' => 'POST',
|
|
'action' => function () use ($field): array {
|
|
$request = App::instance()->request();
|
|
|
|
$columns = $request->get('columns') ?? ['1/1'];
|
|
$form = $field->attrsForm();
|
|
|
|
$form->fill(input: $form->defaults());
|
|
$form->submit(input: $request->get('attrs') ?? []);
|
|
|
|
return Layout::factory([
|
|
'attrs' => $form->toFormValues(),
|
|
'columns' => array_map(fn ($width) => [
|
|
'blocks' => [],
|
|
'id' => Str::uuid(),
|
|
'width' => $width,
|
|
], $columns)
|
|
])->toArray();
|
|
},
|
|
];
|
|
|
|
$routes[] = [
|
|
'pattern' => 'layout/paste',
|
|
'method' => 'POST',
|
|
'action' => function () use ($field): array {
|
|
$request = App::instance()->request();
|
|
$value = Layouts::parse($request->get('json'));
|
|
$layouts = Layouts::factory($value);
|
|
|
|
return $field->pasteLayouts($layouts->toArray());
|
|
}
|
|
];
|
|
|
|
$routes[] = [
|
|
'pattern' => 'fields/(:any)/(:all?)',
|
|
'method' => 'ALL',
|
|
'action' => function (
|
|
string $fieldName,
|
|
string|null $path = null
|
|
) use ($field): array {
|
|
$form = $field->attrsForm();
|
|
$field = $form->field($fieldName);
|
|
|
|
$fieldApi = $this->clone([
|
|
'routes' => $field->api(),
|
|
'data' => [
|
|
...$this->data(),
|
|
'field' => $field
|
|
]
|
|
]);
|
|
|
|
return $fieldApi->call(
|
|
$path,
|
|
$this->requestMethod(),
|
|
$this->requestData()
|
|
);
|
|
}
|
|
];
|
|
|
|
return $routes;
|
|
}
|
|
|
|
public function selector(): array|null
|
|
{
|
|
return $this->selector;
|
|
}
|
|
|
|
protected function setDefault(mixed $default = null): void
|
|
{
|
|
// set id for layouts, columns and blocks within layout if not exists
|
|
if (is_array($default) === true) {
|
|
array_walk($default, function (&$layout) {
|
|
$layout['id'] ??= Str::uuid();
|
|
|
|
// set columns id within layout
|
|
if (isset($layout['columns']) === true) {
|
|
array_walk($layout['columns'], function (&$column) {
|
|
$column['id'] ??= Str::uuid();
|
|
|
|
// set blocks id within column
|
|
if (isset($column['blocks']) === true) {
|
|
array_walk($column['blocks'], function (&$block) {
|
|
$block['id'] ??= Str::uuid();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
parent::setDefault($default);
|
|
}
|
|
|
|
protected function setLayouts(array $layouts = []): void
|
|
{
|
|
$this->layouts = array_map(
|
|
fn ($layout) => Str::split($layout),
|
|
$layouts
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Layout selector's styles such as size (`small`, `medium`, `large` or `huge`) and columns
|
|
*/
|
|
protected function setSelector(array|null $selector = null): void
|
|
{
|
|
$this->selector = $selector;
|
|
}
|
|
|
|
protected function setSettings(array|string|null $settings = null): void
|
|
{
|
|
if (empty($settings) === true) {
|
|
$this->settings = null;
|
|
return;
|
|
}
|
|
|
|
$settings = Blueprint::extend($settings);
|
|
|
|
$settings['icon'] = 'dashboard';
|
|
$settings['type'] = 'layout';
|
|
$settings['parent'] = $this->model();
|
|
|
|
$this->settings = Fieldset::factory($settings);
|
|
}
|
|
|
|
public function settings(): Fieldset|null
|
|
{
|
|
return $this->settings;
|
|
}
|
|
|
|
public function toStoredValue(bool $default = false): mixed
|
|
{
|
|
$attrs = $this->attrsForm();
|
|
$value = $this->toFormValue($default);
|
|
$value = Layouts::factory($value, ['parent' => $this->model])->toArray();
|
|
|
|
// returns empty string to avoid storing empty array as string `[]`
|
|
// and to consistency work with `$field->isEmpty()`
|
|
if ($value === []) {
|
|
return '';
|
|
}
|
|
|
|
foreach ($value as $layoutIndex => $layout) {
|
|
if ($this->settings !== null) {
|
|
$value[$layoutIndex]['attrs'] = $attrs->reset()->fill($layout['attrs'])->toStoredValues();
|
|
}
|
|
|
|
foreach ($layout['columns'] as $columnIndex => $column) {
|
|
$value[$layoutIndex]['columns'][$columnIndex]['blocks'] = $this->blocksToValues($column['blocks'] ?? [], 'content');
|
|
}
|
|
}
|
|
|
|
return Json::encode($value, pretty: $this->pretty());
|
|
}
|
|
|
|
public function validations(): array
|
|
{
|
|
return [
|
|
'layout' => function ($value) {
|
|
$attrsForm = $this->attrsForm();
|
|
$blockForms = [];
|
|
$layoutIndex = 0;
|
|
|
|
foreach ($value as $layout) {
|
|
$layoutIndex++;
|
|
|
|
// validate settings form
|
|
$form = $attrsForm->reset()->fill($layout['attrs'] ?? []);
|
|
|
|
foreach ($form->fields() as $field) {
|
|
$errors = $field->errors();
|
|
|
|
if (count($errors) > 0) {
|
|
throw new InvalidArgumentException(
|
|
key:'layout.validation.settings',
|
|
data: ['index' => $layoutIndex]
|
|
);
|
|
}
|
|
}
|
|
|
|
// validate blocks in the layout
|
|
$blockIndex = 0;
|
|
|
|
foreach ($layout['columns'] ?? [] as $column) {
|
|
foreach ($column['blocks'] ?? [] as $block) {
|
|
$blockIndex++;
|
|
$blockType = $block['type'];
|
|
|
|
if (isset($blockForms[$blockType]) === false) {
|
|
try {
|
|
$fieldset = $this->fieldset($blockType);
|
|
$fields = $this->fields($blockType) ?? [];
|
|
$blockForms[$blockType] = $this->form($fields);
|
|
} catch (Throwable) {
|
|
// skip invalid blocks
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// overwrite the content with the serialized form
|
|
$form = $blockForms[$blockType]->reset()->fill($block['content']);
|
|
|
|
foreach ($form->fields() as $field) {
|
|
$errors = $field->errors();
|
|
|
|
// rough first validation
|
|
if (count($errors) > 0) {
|
|
throw new InvalidArgumentException(
|
|
key: 'layout.validation.block',
|
|
data: [
|
|
'blockIndex' => $blockIndex,
|
|
'field' => $field->label(),
|
|
'fieldset' => $fieldset->name(),
|
|
'layoutIndex' => $layoutIndex
|
|
]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
];
|
|
}
|
|
}
|