@brixter/brix-builder 0.0.1

package/dist/core.js

@@ -0,0 +1,758 @@
+import yaml from 'yaml';
+const { parse: parseYaml, stringify: stringifyYaml } = yaml;
+export function createRichTextValue(mode, html = '') {
+    return {
+        kind: 'richtext',
+        mode,
+        html,
+        json: null
+    };
+}
+export function isRichTextValue(value) {
+    return (isRecord(value) &&
+        value.kind === 'richtext' &&
+        (value.mode === 'inline' || value.mode === 'block') &&
+        typeof value.html === 'string' &&
+        (value.json === null || isRecord(value.json)));
+}
+export function inferBuilderFieldKind(field) {
+    if (field.kind) {
+        return field.kind;
+    }
+    if (field.fields) {
+        return 'object';
+    }
+    if (field.item) {
+        return 'array';
+    }
+    if (typeof field.default === 'boolean') {
+        return 'boolean';
+    }
+    if (typeof field.default === 'number') {
+        return 'number';
+    }
+    return 'text';
+}
+export function createBuilderDefaultsFromFields(fields) {
+    return Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, createBuilderFieldDefault(field)]));
+}
+export function createBuilderFallbackProps(definition, props = definition.defaults) {
+    return mergeFallbackValues(createBuilderFallbackPropsFromFields(definition.fields), props);
+}
+function createBuilderFallbackPropsFromFields(fields) {
+    return Object.fromEntries(Object.entries(fields).map(([key, field]) => [key, createBuilderFallbackValue(field, key)]));
+}
+function createBuilderFallbackValue(field, key) {
+    const kind = inferBuilderFieldKind(field);
+    if (kind === 'richtext-inline') {
+        return createRichTextValue('inline', getFallbackText(key));
+    }
+    if (kind === 'richtext-block') {
+        return createRichTextValue('block', `<p>${getFallbackText(key)}</p>`);
+    }
+    if (kind === 'object') {
+        return field.fields ? createBuilderFallbackPropsFromFields(field.fields) : {};
+    }
+    if (kind === 'array') {
+        const item = field.item ? createBuilderFallbackValue(field.item, field.itemLabel ?? key) : {};
+        return [item, cloneValue(item), cloneValue(item)];
+    }
+    if (kind === 'boolean') {
+        return true;
+    }
+    if (kind === 'number') {
+        return 3;
+    }
+    if (kind === 'image') {
+        return createImageFallback();
+    }
+    if (kind === 'icon') {
+        return createIconFallback();
+    }
+    if (isHrefKey(key)) {
+        return '#';
+    }
+    return getFallbackText(key);
+}
+function mergeFallbackValues(fallbackValue, value) {
+    if (!hasRenderableValue(value)) {
+        return fallbackValue;
+    }
+    if (isRichTextValue(value)) {
+        return value.html.trim() ? value : fallbackValue;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value : fallbackValue;
+    }
+    if (isRecord(value) && isRecord(fallbackValue)) {
+        return {
+            ...value,
+            ...Object.fromEntries(Object.entries(fallbackValue).map(([key, fallbackEntry]) => [
+                key,
+                mergeFallbackValues(fallbackEntry, value[key])
+            ]))
+        };
+    }
+    return value;
+}
+function hasRenderableValue(value) {
+    if (isRichTextValue(value)) {
+        return value.html.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    return value !== null && value !== undefined;
+}
+export function createBuilderCollectionsFromFields(fields, basePath = '') {
+    const collections = [];
+    for (const [name, field] of Object.entries(fields)) {
+        const path = basePath ? `${basePath}.${name}` : name;
+        const kind = inferBuilderFieldKind(field);
+        if (kind === 'array' && field.item) {
+            const defaultItem = createBuilderFieldDefault(field.item);
+            const previewField = findPreviewImageField(field.item);
+            if (isRecord(defaultItem)) {
+                const summaryField = field.summaryField ?? inferSummaryField(field.item);
+                collections.push({
+                    path,
+                    label: field.label ?? humanizeKey(name),
+                    itemLabel: field.itemLabel ?? humanizeKey(name).replace(/i$/i, 'o'),
+                    defaultItem,
+                    summaryField,
+                    imageField: field.imageField ?? previewField?.path,
+                    previewSelector: field.previewSelector ?? getCollectionPreviewSelector(path)
+                });
+            }
+            continue;
+        }
+        if (kind === 'object' && field.fields) {
+            collections.push(...createBuilderCollectionsFromFields(field.fields, path));
+        }
+    }
+    return collections;
+}
+export function createBuilderPreviewBindingsFromFields(fields, basePath = '') {
+    const bindings = [];
+    for (const [name, field] of Object.entries(fields)) {
+        const kind = inferBuilderFieldKind(field);
+        const path = basePath ? `${basePath}.${name}` : name;
+        const selector = getFieldPreviewSelector(field, path);
+        if (kind === 'image' && selector) {
+            bindings.push({
+                type: 'image',
+                selector,
+                path,
+                label: field.previewLabel ??
+                    (field.label ? `Sostituisci ${field.label.toLowerCase()}` : undefined)
+            });
+            continue;
+        }
+        if (kind === 'icon' && selector) {
+            bindings.push({
+                type: 'icon',
+                selector,
+                path,
+                label: field.previewLabel ?? field.label
+            });
+            continue;
+        }
+        if ((kind === 'richtext-inline' || kind === 'richtext-block') && selector) {
+            bindings.push({
+                type: 'richtext',
+                selector,
+                path,
+                label: field.previewLabel ?? field.label,
+                richTextMode: kind === 'richtext-inline' ? 'inline' : 'block'
+            });
+            continue;
+        }
+        if (kind === 'text' && selector) {
+            bindings.push({
+                type: 'text',
+                selector,
+                path,
+                label: field.previewLabel ?? field.label
+            });
+            continue;
+        }
+        if (kind === 'object' && field.fields) {
+            bindings.push(...createBuilderPreviewBindingsFromFields(field.fields, path));
+            continue;
+        }
+        if (kind === 'array' && field.item) {
+            const itemPath = `${path}[]`;
+            if (field.item.fields) {
+                bindings.push(...createBuilderPreviewBindingsFromFields(field.item.fields, itemPath));
+            }
+        }
+    }
+    return bindings;
+}
+export function createInspectorFieldsFromFields(fields) {
+    return Object.fromEntries(Object.entries(fields)
+        .map(([key, field]) => [key, createInspectorField(field)])
+        .filter((entry) => Boolean(entry[1])));
+}
+function createInspectorField(field) {
+    const kind = inferBuilderFieldKind(field);
+    const isPreviewEditable = Boolean(field.previewSelector || field.previewInMarkup) &&
+        (kind === 'text' ||
+            kind === 'image' ||
+            kind === 'icon' ||
+            kind === 'richtext-inline' ||
+            kind === 'richtext-block');
+    if (isPreviewEditable) {
+        return null;
+    }
+    if (kind === 'object' && field.fields) {
+        const nestedFields = createInspectorFieldsFromFields(field.fields);
+        if (Object.keys(nestedFields).length === 0) {
+            return null;
+        }
+        return {
+            ...field,
+            fields: nestedFields
+        };
+    }
+    if (kind === 'array' && field.item?.fields) {
+        const nestedItemFields = createInspectorFieldsFromFields(field.item.fields);
+        if (Object.keys(nestedItemFields).length === 0) {
+            return null;
+        }
+        return {
+            ...field,
+            item: {
+                ...field.item,
+                fields: nestedItemFields
+            }
+        };
+    }
+    return cloneValue(field);
+}
+export function normalizeBuilderPropsForRender(value) {
+    if (isRichTextValue(value)) {
+        return value.html;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeBuilderPropsForRender(entry));
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeBuilderPropsForRender(entry)]));
+    }
+    return value;
+}
+export function createBuilderDocument(definitions) {
+    const markdownBlock = definitions.find((definition) => definition.mode === 'markdown');
+    const firstComponentBlock = definitions.find((definition) => definition.mode === 'component');
+    const initialBlocks = [];
+    if (markdownBlock) {
+        initialBlocks.push(markdownBlock);
+    }
+    if (firstComponentBlock) {
+        initialBlocks.push(firstComponentBlock);
+    }
+    return {
+        title: 'Pagina Brixter',
+        description: 'Bozza generata da Brixter.',
+        metadata: {},
+        blocks: initialBlocks.map((definition) => createBlock(definition.type, definitions))
+    };
+}
+export function createBlock(type, definitions) {
+    const definition = getDefinition(type, definitions);
+    return {
+        id: createId(),
+        type: definition.type,
+        props: cloneValue(createBuilderFallbackProps(definition))
+    };
+}
+export function getDefinition(type, definitions) {
+    const definition = definitions.find((entry) => entry.type === type);
+    if (!definition) {
+        throw new Error(`Unknown brik type: ${type}`);
+    }
+    return definition;
+}
+export function getPropsDraft(block) {
+    return JSON.stringify(block.props, null, 2);
+}
+export function parsePropsDraft(value) {
+    if (!value.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(value);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new Error('Le props devono essere un oggetto JSON.');
+    }
+    return parsed;
+}
+export function updatePropsAtPath(props, path, value) {
+    const clone = cloneValue(props);
+    const segments = parsePath(path);
+    if (segments.length === 0) {
+        throw new Error('Path non valido.');
+    }
+    let current = clone;
+    for (let index = 0; index < segments.length - 1; index++) {
+        const segment = segments[index];
+        const nextSegment = segments[index + 1];
+        if (typeof segment === 'number') {
+            if (!Array.isArray(current)) {
+                throw new Error(`Il segmento ${segment} richiede un array.`);
+            }
+            if (current[segment] === undefined) {
+                current[segment] = typeof nextSegment === 'number' ? [] : {};
+            }
+            current = current[segment];
+            continue;
+        }
+        if (!current || typeof current !== 'object' || Array.isArray(current)) {
+            throw new Error(`Il segmento "${segment}" richiede un oggetto.`);
+        }
+        const record = current;
+        if (record[segment] === undefined) {
+            record[segment] = typeof nextSegment === 'number' ? [] : {};
+        }
+        current = record[segment];
+    }
+    const lastSegment = segments.at(-1);
+    if (lastSegment === undefined) {
+        throw new Error('Path non valido.');
+    }
+    if (typeof lastSegment === 'number') {
+        if (!Array.isArray(current)) {
+            throw new Error(`Il segmento ${lastSegment} richiede un array.`);
+        }
+        current[lastSegment] = value;
+        return clone;
+    }
+    if (!current || typeof current !== 'object' || Array.isArray(current)) {
+        throw new Error(`Il segmento "${lastSegment}" richiede un oggetto.`);
+    }
+    current[lastSegment] = value;
+    return clone;
+}
+export function getValueAtPath(props, path) {
+    const segments = parsePath(path);
+    let current = props;
+    for (const segment of segments) {
+        if (typeof segment === 'number') {
+            if (!Array.isArray(current)) {
+                return undefined;
+            }
+            current = current[segment];
+            continue;
+        }
+        if (!current || typeof current !== 'object' || Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+export function getCollectionItems(props, collection) {
+    const value = getValueAtPath(props, collection.path);
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+export function addCollectionItem(props, collection) {
+    const items = getCollectionItems(props, collection);
+    return updatePropsAtPath(props, collection.path, [...items, cloneValue(collection.defaultItem)]);
+}
+export function removeCollectionItem(props, collection, index) {
+    const items = getCollectionItems(props, collection);
+    if (index < 0 || index >= items.length) {
+        return props;
+    }
+    return updatePropsAtPath(props, collection.path, items.filter((_, itemIndex) => itemIndex !== index));
+}
+export function moveCollectionItem(props, collection, index, direction) {
+    return reorderCollectionItem(props, collection, index, index + direction);
+}
+export function reorderCollectionItem(props, collection, fromIndex, toIndex) {
+    const items = [...getCollectionItems(props, collection)];
+    if (fromIndex < 0 ||
+        fromIndex >= items.length ||
+        toIndex < 0 ||
+        toIndex >= items.length ||
+        fromIndex === toIndex) {
+        return props;
+    }
+    const [item] = items.splice(fromIndex, 1);
+    items.splice(toIndex, 0, item);
+    return updatePropsAtPath(props, collection.path, items);
+}
+export function getCollectionItemSummary(item, collection, index) {
+    if (collection.summaryField) {
+        const summary = getValueAtPath(item, collection.summaryField);
+        if (typeof summary === 'string' && summary.trim()) {
+            return summary;
+        }
+    }
+    return `${collection.itemLabel} ${index + 1}`;
+}
+export function getCollectionItemImagePath(collection, index) {
+    if (!collection.imageField) {
+        return null;
+    }
+    return `${collection.path}[${index}].${collection.imageField}`;
+}
+export function serializeToMdsvex(document, definitions) {
+    const sections = [
+        '---',
+        `title: ${document.title}`,
+        `description: ${document.description}`,
+        '---'
+    ];
+    const componentBlocks = document.blocks
+        .map((block, index) => ({ block, index, definition: getDefinition(block.type, definitions) }))
+        .filter((entry) => entry.definition.mode === 'component');
+    if (componentBlocks.length > 0) {
+        const scriptLines = ['<script>'];
+        const importedTypes = new Set();
+        for (const { definition } of componentBlocks) {
+            if (importedTypes.has(definition.type))
+                continue;
+            scriptLines.push(`\timport ${definition.type} from '${definition.path}';`);
+            importedTypes.add(definition.type);
+        }
+        for (const { block, index } of componentBlocks) {
+            scriptLines.push(`\tconst blockProps${index + 1} = ${JSON.stringify(normalizeBuilderPropsForRender(block.props), null, 2)};`);
+        }
+        scriptLines.push('</script>');
+        sections.push(scriptLines.join('\n'));
+    }
+    for (const [index, block] of document.blocks.entries()) {
+        const definition = getDefinition(block.type, definitions);
+        if (definition.mode === 'markdown') {
+            const content = typeof block.props.content === 'string' ? block.props.content : '';
+            sections.push(content.trim() || '<!-- Brik markdown vuoto -->');
+            continue;
+        }
+        sections.push(`<${definition.type} {...blockProps${index + 1}} />`);
+    }
+    return sections.join('\n\n');
+}
+export function parseBrixYamlDocument(source, definitions) {
+    const parsed = parseYaml(source);
+    const rawDocument = isRecord(parsed) ? parsed : {};
+    const components = Array.isArray(rawDocument.components) ? rawDocument.components : [];
+    const metadata = getBrixYamlMetadata(rawDocument);
+    const title = typeof rawDocument.title === 'string' ? rawDocument.title : 'Pagina Brixter';
+    const description = typeof rawDocument.description === 'string'
+        ? rawDocument.description
+        : 'Bozza generata da Brixter.';
+    const layout = typeof rawDocument.layout === 'string' && rawDocument.layout.trim()
+        ? rawDocument.layout.trim()
+        : undefined;
+    const blocks = [];
+    for (const component of components) {
+        if (!isRecord(component) || typeof component.type !== 'string') {
+            continue;
+        }
+        const definition = findDefinitionForBrixType(component.type, definitions);
+        if (!definition || definition.mode !== 'component') {
+            continue;
+        }
+        blocks.push({
+            id: createId(),
+            type: definition.type,
+            props: hydrateBuilderProps(isRecord(component.props) ? component.props : {}, definition.fields, definition.defaults)
+        });
+    }
+    return {
+        title,
+        description,
+        layout,
+        metadata,
+        blocks
+    };
+}
+export function serializeToBrixYaml(document, definitions) {
+    const output = {
+        title: document.title,
+        description: document.description
+    };
+    for (const [key, value] of Object.entries(document.metadata ?? {})) {
+        if (key === 'title' || key === 'description' || key === 'layout' || key === 'components') {
+            continue;
+        }
+        output[key] = cloneValue(value);
+    }
+    if (document.layout) {
+        output.layout = document.layout;
+    }
+    output.components = document.blocks
+        .map((block) => ({ block, definition: getDefinition(block.type, definitions) }))
+        .filter((entry) => entry.definition.mode === 'component')
+        .map(({ block }) => ({
+        type: block.type,
+        props: normalizeBuilderPropsForRender(block.props)
+    }));
+    return stringifyYaml(output).trimEnd() + '\n';
+}
+function cloneValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function getBrixYamlMetadata(document) {
+    return Object.fromEntries(Object.entries(document)
+        .filter(([key]) => key !== 'title' && key !== 'description' && key !== 'layout' && key !== 'components')
+        .map(([key, value]) => [key, cloneValue(value)]));
+}
+function findDefinitionForBrixType(type, definitions) {
+    const normalized = toComponentName(type);
+    return definitions.find((definition) => definition.type === type || definition.type === normalized);
+}
+function toComponentName(value) {
+    const normalized = value.trim().replace(/\.(svelte|ts|js)$/i, '');
+    if (/^[A-Z][A-Za-z0-9]*$/.test(normalized))
+        return normalized;
+    return normalized
+        .split(/[-_\s/]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function hydrateBuilderProps(props, fields, defaults) {
+    const hydrated = cloneValue(defaults);
+    for (const [key, value] of Object.entries(props)) {
+        const field = fields[key];
+        hydrated[key] = field ? hydrateBuilderValue(value, field, defaults[key]) : cloneValue(value);
+    }
+    return hydrated;
+}
+function hydrateBuilderValue(value, field, defaultValue) {
+    const kind = inferBuilderFieldKind(field);
+    if (kind === 'richtext-inline' || kind === 'richtext-block') {
+        if (isRichTextValue(value)) {
+            return cloneValue(value);
+        }
+        return createRichTextValue(kind === 'richtext-inline' ? 'inline' : 'block', asString(value));
+    }
+    if (kind === 'object') {
+        const nestedDefaults = isRecord(defaultValue)
+            ? defaultValue
+            : field.fields
+                ? createBuilderDefaultsFromFields(field.fields)
+                : {};
+        if (!isRecord(value)) {
+            return cloneValue(nestedDefaults);
+        }
+        return field.fields
+            ? hydrateBuilderProps(value, field.fields, nestedDefaults)
+            : cloneValue(value);
+    }
+    if (kind === 'array') {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((entry) => field.item ? hydrateBuilderValue(entry, field.item, undefined) : cloneValue(entry));
+    }
+    return cloneValue(value);
+}
+function createBuilderFieldDefault(field, defaultValue = field.default) {
+    const kind = inferBuilderFieldKind(field);
+    if (kind === 'richtext-inline' || kind === 'richtext-block') {
+        return createRichTextValue(kind === 'richtext-inline' ? 'inline' : 'block', asString(defaultValue));
+    }
+    if (kind === 'object') {
+        const nestedDefaults = field.fields ? createBuilderDefaultsFromFields(field.fields) : {};
+        if (!isRecord(defaultValue)) {
+            return nestedDefaults;
+        }
+        const mergedDefaults = { ...nestedDefaults };
+        for (const [key, value] of Object.entries(defaultValue)) {
+            const nestedField = field.fields?.[key];
+            mergedDefaults[key] = nestedField
+                ? createBuilderFieldDefault(nestedField, value)
+                : cloneValue(value);
+        }
+        return mergedDefaults;
+    }
+    if (kind === 'array') {
+        if (!Array.isArray(defaultValue)) {
+            return [];
+        }
+        return defaultValue.map((entry) => field.item ? createBuilderFieldDefault(field.item, entry) : cloneValue(entry));
+    }
+    return cloneValue(defaultValue ?? getPrimitiveDefault(kind));
+}
+function findPreviewImageField(field, basePath = '') {
+    const kind = inferBuilderFieldKind(field);
+    if (kind === 'image') {
+        return {
+            path: basePath,
+            previewSelector: getFieldPreviewSelector(field, basePath),
+            hasPreviewBinding: Boolean(field.previewSelector || field.previewInMarkup)
+        };
+    }
+    if (kind === 'object' && field.fields) {
+        for (const [name, nestedField] of Object.entries(field.fields)) {
+            const nestedPath = basePath ? `${basePath}.${name}` : name;
+            const result = findPreviewImageField(nestedField, nestedPath);
+            if (result) {
+                return result;
+            }
+        }
+    }
+    return null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function getPrimitiveDefault(kind) {
+    if (kind === 'boolean') {
+        return false;
+    }
+    if (kind === 'number') {
+        return 0;
+    }
+    return '';
+}
+export function getFallbackText(key) {
+    const normalized = key.toLowerCase();
+    if (normalized.includes('eyebrow'))
+        return 'Launch smarter';
+    if (normalized.includes('headline') || normalized.includes('title')) {
+        return 'Build better pages faster';
+    }
+    if (normalized.includes('subtitle') ||
+        normalized.includes('description') ||
+        normalized.includes('text')) {
+        return 'A focused preview with realistic content so you can recognize this brik.';
+    }
+    if (normalized.includes('label'))
+        return 'Get started';
+    if (normalized.includes('note'))
+        return 'No setup required.';
+    if (normalized.includes('author') || normalized.includes('name'))
+        return 'Alex Morgan';
+    if (normalized.includes('role'))
+        return 'Product lead';
+    if (normalized.includes('quote'))
+        return 'This section gives the page structure immediately.';
+    if (normalized.includes('claim'))
+        return 'Simple pages, edited visually.';
+    if (normalized.includes('brand'))
+        return 'Brixter';
+    return humanizeKey(key);
+}
+function isHrefKey(key) {
+    return key.toLowerCase() === 'href' || key.toLowerCase().endsWith('url');
+}
+function createImageFallback() {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 240" role="img" aria-hidden="true">
+	<g transform="translate(160 120)" stroke="#a3a3a3" fill="none" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+		<g transform="translate(-12 -12)">
+			<rect width="18" height="18" x="3" y="3" rx="2" ry="2"/>
+			<circle cx="9" cy="9" r="2"/>
+			<path d="m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"/>
+		</g>
+	</g>
+</svg>`;
+    return `data:image/svg+xml,${encodeURIComponent(svg)}`;
+}
+function parsePath(path) {
+    const segments = [];
+    for (const part of path.split('.')) {
+        const matches = part.match(/([^\[\]]+)|\[(\d+)\]/g) ?? [];
+        for (const match of matches) {
+            if (match.startsWith('[') && match.endsWith(']')) {
+                segments.push(Number(match.slice(1, -1)));
+                continue;
+            }
+            segments.push(match);
+        }
+    }
+    return segments;
+}
+function asString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function getFieldPreviewSelector(field, path) {
+    return (field.previewSelector ??
+        (field.previewInMarkup ? inferFieldPreviewSelector(field, path) : undefined));
+}
+function inferFieldPreviewSelector(field, path) {
+    const kind = inferBuilderFieldKind(field);
+    if (kind === 'text' ||
+        kind === 'image' ||
+        kind === 'icon' ||
+        kind === 'richtext-inline' ||
+        kind === 'richtext-block') {
+        return `[data-builder-field="${path}"]`;
+    }
+    return undefined;
+}
+function getCollectionPreviewSelector(path) {
+    return `[data-builder-collection-item="${path}"]`;
+}
+function inferSummaryField(field) {
+    if (!field?.fields) {
+        return undefined;
+    }
+    for (const candidate of ['title', 'name', 'label', 'alt']) {
+        if (field.fields[candidate]) {
+            return candidate;
+        }
+    }
+    return Object.entries(field.fields).find(([, nestedField]) => {
+        const kind = inferBuilderFieldKind(nestedField);
+        return kind === 'text' || kind === 'richtext-inline' || kind === 'richtext-block';
+    })?.[0];
+}
+function humanizeKey(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[-_]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^\w/, (match) => match.toUpperCase());
+}
+function createId() {
+    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+        return crypto.randomUUID();
+    }
+    return `block-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createIconFallback() {
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-help-circle"><circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><line x1="12" x2="12.01" y1="17" y2="17"/></svg>`;
+}
+export function getFieldByRawPath(fields, rawPath) {
+    const segments = rawPath.split('.');
+    let currentFields = fields;
+    let currentField = null;
+    for (const segment of segments) {
+        if (!currentFields) {
+            return null;
+        }
+        const isArray = segment.endsWith('[]');
+        const name = isArray ? segment.slice(0, -2) : segment;
+        const field = currentFields[name];
+        if (!field) {
+            return null;
+        }
+        currentField = field;
+        if (isArray && field.item?.fields) {
+            currentFields = field.item.fields;
+        }
+        else if (field.fields) {
+            currentFields = field.fields;
+        }
+        else {
+            currentFields = undefined;
+        }
+    }
+    return currentField;
+}
+export function getFieldByPath(fields, path) {
+    const rawPath = path.replace(/\[\d+\]/g, '[]');
+    return getFieldByRawPath(fields, rawPath);
+}
+//# sourceMappingURL=core.js.map