@humaan/payload-plugin-ai-assistant 0.0.0-stage → 0.1.1

package/dist/schema/fields.js

@@ -0,0 +1,1036 @@
+import { slugify } from './slugify.js';
+/** Set by the site or by the editor, never by the assistant. Publishing is always the editor's decision. */ const derivedNames = new Set([
+    '_status',
+    'collectionSlug',
+    'isNavigableCollection',
+    'path',
+    'slug',
+    'slugToggle',
+    'wordCount'
+]);
+const unsupportedTypes = new Set([
+    'code',
+    'json',
+    'point'
+]);
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function fieldAdmin(field) {
+    if (!field.admin) {
+        return undefined;
+    }
+    return field.admin;
+}
+/**
+ * The field's `admin.condition`, run the way the admin runs it, against the values beside it.
+ * A condition that throws counts as shown, so a field is never wrongly treated as optional.
+ */ function conditionOf(field) {
+    const condition = fieldAdmin(field)?.condition;
+    if (typeof condition !== 'function') {
+        return undefined;
+    }
+    return (siblingData)=>{
+        try {
+            return Boolean(condition({}, siblingData, {
+                blockData: siblingData,
+                operation: 'create',
+                path: [],
+                user: null
+            }));
+        } catch  {
+            return true;
+        }
+    };
+}
+function isSkipped(field) {
+    const admin = fieldAdmin(field);
+    if (admin?.hidden === true || admin?.readOnly === true) {
+        return true;
+    }
+    if ('virtual' in field && field.virtual === true) {
+        return true;
+    }
+    if ('name' in field && typeof field.name === 'string' && derivedNames.has(field.name)) {
+        return true;
+    }
+    return false;
+}
+function labelOf(field) {
+    if (!('label' in field) || typeof field.label !== 'string') {
+        return undefined;
+    }
+    return field.label;
+}
+function descriptionOf(field) {
+    const description = fieldAdmin(field)?.description;
+    if (typeof description !== 'string') {
+        return undefined;
+    }
+    const trimmed = description.replace(/\s+/g, ' ').trim();
+    return trimmed.length > 240 ? `${trimmed.slice(0, 237)}...` : trimmed;
+}
+/**
+ * Guidance for the assistant that editors do not need to see: a string at `custom.aiAssistant` on a field,
+ * block, collection, or global. Guidance that helps editors too belongs in `admin.description`, which the
+ * guide also includes.
+ */ export function assistantNote(config) {
+    const custom = config.custom;
+    if (!custom || typeof custom !== 'object' || !('aiAssistant' in custom)) {
+        return undefined;
+    }
+    const note = custom.aiAssistant;
+    return typeof note === 'string' && note.trim() ? note.replace(/\s+/g, ' ').trim() : undefined;
+}
+function requiredOf(field) {
+    return 'required' in field && field.required === true;
+}
+function hasManyOf(field) {
+    return 'hasMany' in field && field.hasMany === true;
+}
+function relationToOf(field) {
+    if (!('relationTo' in field)) {
+        return [];
+    }
+    const relationTo = field.relationTo;
+    if (typeof relationTo === 'string') {
+        return [
+            relationTo
+        ];
+    }
+    if (Array.isArray(relationTo)) {
+        return relationTo.map((item)=>String(item));
+    }
+    return [];
+}
+function optionValues(field) {
+    if (!('options' in field) || !Array.isArray(field.options)) {
+        return [];
+    }
+    return field.options.flatMap((option)=>{
+        if (typeof option === 'string') {
+            return [
+                option
+            ];
+        }
+        if (option && typeof option === 'object' && 'value' in option) {
+            return typeof option.value === 'string' ? [
+                option.value
+            ] : [];
+        }
+        return [];
+    });
+}
+function childFields(field) {
+    if ('fields' in field && Array.isArray(field.fields)) {
+        return field.fields;
+    }
+    return [];
+}
+function containsUnsupported(fields) {
+    return fields.some((field)=>{
+        if (isSkipped(field)) {
+            return false;
+        }
+        if (unsupportedTypes.has(field.type)) {
+            return true;
+        }
+        if (field.type === 'tabs') {
+            return field.tabs.some((tab)=>containsUnsupported(tabFields(tab)));
+        }
+        const nested = childFields(field);
+        return nested.length > 0 && containsUnsupported(nested);
+    });
+}
+function tabFields(tab) {
+    return 'fields' in tab && Array.isArray(tab.fields) ? tab.fields : [];
+}
+function named(field) {
+    return 'name' in field && typeof field.name === 'string' ? field.name : undefined;
+}
+function meta(field, name) {
+    return {
+        name,
+        label: labelOf(field),
+        description: descriptionOf(field),
+        note: assistantNote(field),
+        condition: conditionOf(field),
+        required: requiredOf(field)
+    };
+}
+/** Fields the model is allowed to fill. JSON, code, and point fields are left out. Every block in the schema is included. */ export function compileFields(fields) {
+    const compiled = [];
+    for (const field of fields){
+        const next = compileField(field);
+        if (Array.isArray(next)) {
+            compiled.push(...next);
+        } else if (next) {
+            compiled.push(next);
+        }
+    }
+    return compiled;
+}
+function blockLabelOf(block) {
+    const labels = block.labels;
+    if (!labels || typeof labels !== 'object' || !('singular' in labels)) {
+        return undefined;
+    }
+    return typeof labels.singular === 'string' ? labels.singular : undefined;
+}
+function compileBlocks(field) {
+    const name = named(field);
+    if (!name) {
+        return null;
+    }
+    const blocks = field.blocks.flatMap((block)=>{
+        const nested = compileFields(block.fields);
+        if (nested.length === 0) {
+            return [];
+        }
+        return [
+            {
+                slug: block.slug,
+                label: blockLabelOf(block),
+                note: assistantNote(block),
+                fields: nested
+            }
+        ];
+    });
+    if (blocks.length === 0) {
+        return null;
+    }
+    return {
+        ...meta(field, name),
+        kind: 'blocks',
+        blocks,
+        maxRows: typeof field.maxRows === 'number' ? field.maxRows : undefined,
+        minRows: typeof field.minRows === 'number' ? field.minRows : undefined
+    };
+}
+function compileField(field) {
+    if (isSkipped(field)) {
+        return null;
+    }
+    if (field.type === 'blocks') {
+        return compileBlocks(field);
+    }
+    if (unsupportedTypes.has(field.type)) {
+        return null;
+    }
+    switch(field.type){
+        case 'array':
+            {
+                if (containsUnsupported(childFields(field))) {
+                    return null;
+                }
+                const name = named(field);
+                const nested = compileFields(childFields(field));
+                if (!name || nested.length === 0) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'array',
+                    fields: nested,
+                    maxRows: typeof field.maxRows === 'number' ? field.maxRows : undefined,
+                    minRows: typeof field.minRows === 'number' ? field.minRows : undefined
+                };
+            }
+        case 'checkbox':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'checkbox'
+                };
+            }
+        case 'collapsible':
+        case 'row':
+            {
+                const nested = compileFields(childFields(field));
+                if (nested.length === 0) {
+                    return null;
+                }
+                return {
+                    kind: 'flatten',
+                    fields: nested,
+                    condition: conditionOf(field)
+                };
+            }
+        case 'date':
+        case 'email':
+        case 'text':
+        case 'textarea':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: field.type,
+                    hasMany: hasManyOf(field)
+                };
+            }
+        case 'group':
+            {
+                const nested = compileFields(childFields(field));
+                if (nested.length === 0) {
+                    return null;
+                }
+                const name = named(field);
+                if (!name) {
+                    return {
+                        kind: 'flatten',
+                        fields: nested,
+                        condition: conditionOf(field)
+                    };
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'group',
+                    fields: nested
+                };
+            }
+        case 'number':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'number',
+                    hasMany: hasManyOf(field)
+                };
+            }
+        case 'radio':
+        case 'select':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'select',
+                    options: optionValues(field),
+                    hasMany: field.type === 'select' && hasManyOf(field)
+                };
+            }
+        case 'relationship':
+        case 'upload':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: field.type,
+                    relationTo: relationToOf(field),
+                    hasMany: hasManyOf(field)
+                };
+            }
+        case 'richText':
+            {
+                const name = named(field);
+                if (!name) {
+                    return null;
+                }
+                return {
+                    ...meta(field, name),
+                    kind: 'richText',
+                    field
+                };
+            }
+        case 'tabs':
+            {
+                const compiled = [];
+                for (const tab of field.tabs){
+                    const nested = compileFields(tabFields(tab));
+                    if (nested.length === 0) {
+                        continue;
+                    }
+                    if ('name' in tab && typeof tab.name === 'string' && tab.name) {
+                        compiled.push({
+                            kind: 'group',
+                            name: tab.name,
+                            label: typeof tab.label === 'string' ? tab.label : undefined,
+                            description: typeof tab.description === 'string' ? tab.description : undefined,
+                            required: false,
+                            fields: nested
+                        });
+                    } else {
+                        compiled.push({
+                            kind: 'flatten',
+                            fields: nested,
+                            condition: conditionOf(tab)
+                        });
+                    }
+                }
+                return compiled;
+            }
+        default:
+            return null;
+    }
+}
+function heading(field) {
+    if (field.kind === 'flatten') {
+        return '';
+    }
+    const bits = [
+        field.label ? `${field.name} (${field.label})` : field.name
+    ];
+    return bits[0];
+}
+function listingHint(field) {
+    if (field.kind === 'flatten') {
+        return '';
+    }
+    if (field.name === 'cardImage' || field.name === 'cardDescription') {
+        return '. Fill this when creating a document';
+    }
+    if (field.name === 'seo' && field.kind === 'group') {
+        return '. Fill title, description, and image when creating a document';
+    }
+    return '';
+}
+function kindLabel(field) {
+    switch(field.kind){
+        case 'array':
+            return `array${field.maxRows ? `, max ${field.maxRows}` : ''}${field.minRows ? `, min ${field.minRows}` : ''}`;
+        case 'blocks':
+            return `blocks${field.maxRows ? `, max ${field.maxRows}` : ''}${field.minRows ? `, min ${field.minRows}` : ''}. Each item is an object with blockType`;
+        case 'checkbox':
+            return 'boolean';
+        case 'flatten':
+            return '';
+        case 'group':
+            return 'group';
+        case 'relationship':
+        case 'upload':
+            {
+                const target = field.relationTo.join(' | ') || 'unknown';
+                const many = field.hasMany ? ', many' : '';
+                const shape = field.relationTo.length > 1 ? field.hasMany ? 'array of { relationTo, value }' : '{ relationTo, value }' : field.hasMany ? 'ids' : 'id';
+                return `${field.kind} to ${target}${many}; ${shape}`;
+            }
+        case 'richText':
+            return 'markdown';
+        case 'select':
+            return `one of: ${field.options.join(', ')}${field.hasMany ? ' (many)' : ''}`;
+        default:
+            return field.hasMany ? `${field.kind}, many` : field.kind;
+    }
+}
+/**
+ * Compact field guide the model fills. Names match the collection schema.
+ * Block definitions are most of a page's schema, so only the blocks asked for are expanded.
+ */ export function formatFieldGuide(fields, options = {}) {
+    return formatCompiled(compileFields(fields), 0, new Set(options.blocks ?? [])).trim();
+}
+/** The field a dotted path points at, through groups, tabs, and rows. Lists and blocks end the walk. */ export function compiledFieldAtPath(fields, path) {
+    let level = compileFields(fields);
+    let found;
+    for (const name of path.split('.')){
+        found = findCompiled(level, name);
+        if (!found) {
+            return undefined;
+        }
+        level = found.kind === 'group' ? found.fields : [];
+    }
+    return found;
+}
+function findCompiled(fields, name) {
+    for (const field of fields){
+        if (field.kind === 'flatten') {
+            const nested = findCompiled(field.fields, name);
+            if (nested) {
+                return nested;
+            }
+        } else if (field.name === name) {
+            return field;
+        }
+    }
+    return undefined;
+}
+/**
+ * Keys in a set that match no field. Writes drop unknown keys, so these must be rejected
+ * before the editor sees a plan that would quietly skip them.
+ */ export function unknownFieldPaths(fields, set) {
+    const walk = (level, values, prefix)=>Object.entries(values).flatMap(([key, item])=>{
+            const path = prefix ? `${prefix}.${key}` : key;
+            const field = findCompiled(level, key);
+            if (!field) {
+                return [
+                    path
+                ];
+            }
+            if (field.kind === 'group' && isRecord(item)) {
+                return walk(field.fields, item, path);
+            }
+            return [];
+        });
+    return walk(compileFields(fields), set, '');
+}
+/** Every block slug in the guide, so the model can be told which ones it can ask about. */ export function blockSlugs(fields) {
+    const slugs = new Set();
+    const visit = (compiled)=>{
+        for (const field of compiled){
+            if (field.kind === 'flatten' || field.kind === 'group' || field.kind === 'array') {
+                visit(field.fields);
+            }
+            if (field.kind === 'blocks') {
+                for (const block of field.blocks){
+                    slugs.add(block.slug);
+                    visit(block.fields);
+                }
+            }
+        }
+    };
+    visit(compileFields(fields));
+    return [
+        ...slugs
+    ];
+}
+function formatCompiled(fields, depth, expand) {
+    const pad = '  '.repeat(depth);
+    return fields.map((field)=>{
+        if (field.kind === 'flatten') {
+            return formatCompiled(field.fields, depth, expand);
+        }
+        const required = 'required' in field && field.required ? field.condition ? ', required when shown' : ', required' : '';
+        const listing = listingHint(field);
+        const description = 'description' in field && field.description ? `. ${field.description}` : '';
+        const base = `${pad}- ${heading(field)}: ${kindLabel(field)}${required}${listing}${description}`;
+        const note = 'note' in field && field.note ? `${/[.!?]$/.test(base) ? '' : '.'} Note: ${field.note}` : '';
+        const line = `${base}${note}`;
+        if (field.kind === 'group' || field.kind === 'array') {
+            const nested = formatCompiled(field.fields, depth + 1, expand);
+            return nested ? `${line}\n${nested}` : line;
+        }
+        if (field.kind === 'blocks') {
+            const nested = field.blocks.map((block)=>{
+                const name = block.label ? `${block.slug} (${block.label})` : block.slug;
+                // The note shows even when the block is only listed, so it can help choose between blocks.
+                const title = block.note ? `${name}: ${block.note}` : name;
+                if (!expand.has(block.slug)) {
+                    return `${pad}  - ${title}`;
+                }
+                const body = formatCompiled(block.fields, depth + 2, expand);
+                return body ? `${pad}  - ${title}\n${body}` : `${pad}  - ${title}`;
+            }).join('\n');
+            return nested ? `${line}\n${nested}` : line;
+        }
+        return line;
+    }).filter(Boolean).join('\n');
+}
+export function exampleValues(fields) {
+    return exampleCompiled(compileFields(fields));
+}
+function exampleCompiled(fields) {
+    const example = {};
+    for (const field of fields){
+        if (field.kind === 'flatten') {
+            Object.assign(example, exampleCompiled(field.fields));
+            continue;
+        }
+        example[field.name] = exampleValue(field);
+    }
+    return example;
+}
+function exampleValue(field) {
+    switch(field.kind){
+        case 'array':
+            return [
+                exampleCompiled(field.fields)
+            ];
+        case 'blocks':
+            {
+                const block = field.blocks[0];
+                if (!block) {
+                    return [];
+                }
+                return [
+                    {
+                        blockType: block.slug,
+                        ...exampleCompiled(block.fields)
+                    }
+                ];
+            }
+        case 'checkbox':
+            return false;
+        case 'flatten':
+            return undefined;
+        case 'group':
+            return exampleCompiled(field.fields);
+        case 'number':
+            return field.hasMany ? [
+                0
+            ] : 0;
+        case 'relationship':
+        case 'upload':
+            if (field.relationTo.length > 1) {
+                const value = {
+                    relationTo: field.relationTo[0] ?? '',
+                    value: 'id'
+                };
+                return field.hasMany ? [
+                    value
+                ] : value;
+            }
+            return field.hasMany ? [
+                'id'
+            ] : 'id';
+        case 'richText':
+            return 'Markdown. Headings start at h2.';
+        case 'select':
+            return field.hasMany ? field.options.slice(0, 1) : field.options[0] ?? '';
+        default:
+            return field.hasMany ? [
+                ''
+            ] : '';
+    }
+}
+export async function applyFields(fields, values, context) {
+    if (!isRecord(values)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: '',
+                    message: 'Values must be an object.'
+                }
+            ]
+        };
+    }
+    const errors = [];
+    const data = await applyCompiled(compileFields(fields), values, '', context, errors);
+    if (errors.length > 0) {
+        return {
+            ok: false,
+            errors
+        };
+    }
+    return {
+        ok: true,
+        data
+    };
+}
+/**
+ * `hidden` is true inside a row or tab whose condition hides it. A hidden field is not required,
+ * as in the admin, but a value sent for it is still kept.
+ */ async function applyCompiled(fields, source, prefix, context, errors, hidden = false) {
+    const data = {};
+    for (const field of fields){
+        const fieldHidden = hidden || (field.condition ? !field.condition(source) : false);
+        if (field.kind === 'flatten') {
+            Object.assign(data, await applyCompiled(field.fields, source, prefix, context, errors, fieldHidden));
+            continue;
+        }
+        const path = prefix ? `${prefix}.${field.name}` : field.name;
+        const raw = source[field.name];
+        if (raw === undefined || raw === null) {
+            if (!context.partial && !fieldHidden && 'required' in field && field.required) {
+                errors.push({
+                    path,
+                    message: 'This field is required.'
+                });
+            }
+            continue;
+        }
+        const value = await readValue(field, raw, path, context, errors);
+        if (value !== undefined) {
+            data[field.name] = value;
+        }
+    }
+    return data;
+}
+async function readValue(field, raw, path, context, errors) {
+    switch(field.kind){
+        case 'array':
+            return readArray(field, raw, path, context, errors);
+        case 'blocks':
+            return readBlocks(field, raw, path, context, errors);
+        case 'checkbox':
+            if (typeof raw !== 'boolean') {
+                errors.push({
+                    path,
+                    message: 'Expected true or false.'
+                });
+                return undefined;
+            }
+            return raw;
+        case 'date':
+        case 'email':
+        case 'text':
+        case 'textarea':
+            return readStrings(raw, path, field.hasMany, field.required, errors);
+        case 'group':
+            {
+                if (!isRecord(raw)) {
+                    errors.push({
+                        path,
+                        message: 'Expected an object.'
+                    });
+                    return undefined;
+                }
+                return applyCompiled(field.fields, raw, path, context, errors);
+            }
+        case 'number':
+            return readNumbers(raw, path, field.hasMany, field.required, errors);
+        case 'relationship':
+        case 'upload':
+            return readRelation(raw, path, field.relationTo, field.hasMany, field.required, errors);
+        case 'richText':
+            return readRichText(field.field, raw, path, field.required, context, errors);
+        case 'select':
+            return readSelect(raw, path, field.options, field.hasMany, field.required, errors);
+        default:
+            return undefined;
+    }
+}
+function readStrings(raw, path, hasMany, required, errors) {
+    if (hasMany) {
+        if (!Array.isArray(raw) || raw.some((item)=>typeof item !== 'string')) {
+            errors.push({
+                path,
+                message: 'Expected a list of strings.'
+            });
+            return undefined;
+        }
+        const values = raw.map((item)=>item.trim()).filter(Boolean);
+        if (required && values.length === 0) {
+            errors.push({
+                path,
+                message: 'This field is required.'
+            });
+        }
+        return values;
+    }
+    if (typeof raw !== 'string') {
+        errors.push({
+            path,
+            message: 'Expected a string.'
+        });
+        return undefined;
+    }
+    const value = raw.trim();
+    if (required && !value) {
+        errors.push({
+            path,
+            message: 'This field is required.'
+        });
+    }
+    return value;
+}
+function readNumbers(raw, path, hasMany, required, errors) {
+    const valid = (value)=>typeof value === 'number' && Number.isFinite(value);
+    if (hasMany) {
+        if (!Array.isArray(raw) || !raw.every(valid)) {
+            errors.push({
+                path,
+                message: 'Expected a list of numbers.'
+            });
+            return undefined;
+        }
+        if (required && raw.length === 0) {
+            errors.push({
+                path,
+                message: 'This field is required.'
+            });
+        }
+        return raw;
+    }
+    if (!valid(raw)) {
+        errors.push({
+            path,
+            message: 'Expected a number.'
+        });
+        return undefined;
+    }
+    return raw;
+}
+function readSelect(raw, path, options, hasMany, required, errors) {
+    const known = new Set(options);
+    const accept = (value)=>typeof value === 'string' && (known.size === 0 || known.has(value));
+    if (hasMany) {
+        if (!Array.isArray(raw) || !raw.every(accept)) {
+            errors.push({
+                path,
+                message: `Expected values from: ${options.join(', ')}.`
+            });
+            return undefined;
+        }
+        if (required && raw.length === 0) {
+            errors.push({
+                path,
+                message: 'This field is required.'
+            });
+        }
+        return raw;
+    }
+    if (!accept(raw)) {
+        errors.push({
+            path,
+            message: `Expected one of: ${options.join(', ')}.`
+        });
+        return undefined;
+    }
+    return raw;
+}
+async function readRichText(field, raw, path, required, context, errors) {
+    if (typeof raw !== 'string') {
+        errors.push({
+            path,
+            message: 'Expected markdown.'
+        });
+        return undefined;
+    }
+    const markdown = stripFence(raw);
+    if (!markdown) {
+        if (required) {
+            errors.push({
+                path,
+                message: 'This field is required.'
+            });
+        }
+        return undefined;
+    }
+    return context.toLexical(field, markdown);
+}
+function readRelation(raw, path, relationTo, hasMany, required, errors) {
+    const readOne = (value, itemPath)=>{
+        if (relationTo.length > 1) {
+            if (!isRecord(value) || typeof value.relationTo !== 'string' || !isId(value.value)) {
+                errors.push({
+                    path: itemPath,
+                    message: 'Expected { relationTo, value }.'
+                });
+                return undefined;
+            }
+            if (!relationTo.includes(value.relationTo)) {
+                errors.push({
+                    path: itemPath,
+                    message: `relationTo must be one of: ${relationTo.join(', ')}.`
+                });
+                return undefined;
+            }
+            return {
+                relationTo: value.relationTo,
+                value: normaliseId(value.value)
+            };
+        }
+        if (!isId(value)) {
+            errors.push({
+                path: itemPath,
+                message: 'Expected an id.'
+            });
+            return undefined;
+        }
+        return normaliseId(value);
+    };
+    if (hasMany) {
+        if (!Array.isArray(raw)) {
+            errors.push({
+                path,
+                message: 'Expected a list of ids.'
+            });
+            return undefined;
+        }
+        const values = raw.map((item, index)=>readOne(item, `${path}.${index}`)).filter((item)=>item !== undefined);
+        if (required && values.length === 0) {
+            errors.push({
+                path,
+                message: 'This field is required.'
+            });
+        }
+        return values;
+    }
+    return readOne(raw, path);
+}
+async function readArray(field, raw, path, context, errors) {
+    if (!Array.isArray(raw)) {
+        errors.push({
+            path,
+            message: 'Expected a list.'
+        });
+        return undefined;
+    }
+    if (field.maxRows !== undefined && raw.length > field.maxRows) {
+        errors.push({
+            path,
+            message: `Use at most ${field.maxRows}.`
+        });
+        return undefined;
+    }
+    if (field.minRows !== undefined && raw.length < field.minRows) {
+        errors.push({
+            path,
+            message: `Use at least ${field.minRows}.`
+        });
+    }
+    const rows = [];
+    for (const [index, row] of raw.entries()){
+        if (!isRecord(row)) {
+            errors.push({
+                path: `${path}.${index}`,
+                message: 'Expected an object.'
+            });
+            continue;
+        }
+        rows.push(await applyCompiled(field.fields, row, `${path}.${index}`, context, errors));
+    }
+    return rows;
+}
+async function readBlocks(field, raw, path, context, errors) {
+    if (!Array.isArray(raw)) {
+        errors.push({
+            path,
+            message: 'Expected a list of blocks.'
+        });
+        return undefined;
+    }
+    if (field.maxRows !== undefined && raw.length > field.maxRows) {
+        errors.push({
+            path,
+            message: `Use at most ${field.maxRows} blocks.`
+        });
+        return undefined;
+    }
+    if (field.minRows !== undefined && raw.length < field.minRows) {
+        errors.push({
+            path,
+            message: `Use at least ${field.minRows} blocks.`
+        });
+    }
+    const known = new Map(field.blocks.map((block)=>[
+            block.slug,
+            block
+        ]));
+    const rows = [];
+    for (const [index, row] of raw.entries()){
+        const rowPath = `${path}.${index}`;
+        if (!isRecord(row) || typeof row.blockType !== 'string') {
+            errors.push({
+                path: rowPath,
+                message: 'Expected an object with blockType.'
+            });
+            continue;
+        }
+        const block = known.get(row.blockType);
+        if (!block) {
+            errors.push({
+                path: rowPath,
+                message: `blockType must be one of: ${[
+                    ...known.keys()
+                ].join(', ')}.`
+            });
+            continue;
+        }
+        const values = await applyCompiled(block.fields, row, rowPath, context, errors);
+        rows.push({
+            ...values,
+            blockType: block.slug
+        });
+    }
+    return rows;
+}
+function isId(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function normaliseId(value) {
+    return typeof value === 'string' ? value.trim() : value;
+}
+function stripFence(value) {
+    const trimmed = value.trim();
+    const fenced = trimmed.match(/^```(?:markdown|md)?([\s\S]*?)```$/i);
+    return (fenced?.[1] ?? trimmed).trim();
+}
+/** Fills slug, path, and hidden defaults the editor never types, so create validation can pass. */ /**
+ * The slug a renamed document gets when its "Use title" toggle is on, matching the slug field in the editor,
+ * which rebuilds the slug from the title as it changes. Undefined when the slug stays as it is.
+ * The path field's own hook then rebuilds the URL from the slug and adds a redirect if the page was published.
+ */ export function followedSlug(fields, current, nextTitle) {
+    if (!findNamed(fields, 'slug') || !findNamed(fields, 'slugToggle')) {
+        return undefined;
+    }
+    if (!isRecord(current) || current.slugToggle !== 'title') {
+        return undefined;
+    }
+    if (typeof nextTitle !== 'string' || nextTitle === current.title) {
+        return undefined;
+    }
+    const slug = slugify(nextTitle);
+    return slug && slug !== current.slug ? slug : undefined;
+}
+export function withDerivedValues(fields, data, options) {
+    const next = {
+        ...data
+    };
+    const slugField = findNamed(fields, 'slug');
+    if (slugField && (typeof next.slug !== 'string' || next.slug.trim() === '')) {
+        const title = typeof next.title === 'string' ? next.title : '';
+        const slug = slugify(title);
+        if (slug) {
+            next.slug = slug;
+            // Keep the generated slug. The "use title" toggle would rewrite it in the editor.
+            if (findNamed(fields, 'slugToggle')) {
+                next.slugToggle = 'manual';
+            }
+        }
+    }
+    const pathField = findNamed(fields, 'path');
+    if (pathField && (typeof next.path !== 'string' || next.path.trim() === '') && typeof next.slug === 'string') {
+        const path = documentPath(options?.prependPath, next.slug);
+        if (path) {
+            next.path = path;
+        }
+    }
+    const collectionSlug = findNamed(fields, 'collectionSlug');
+    if (collectionSlug && next.collectionSlug === undefined && 'defaultValue' in collectionSlug && typeof collectionSlug.defaultValue === 'string') {
+        next.collectionSlug = collectionSlug.defaultValue;
+    }
+    return next;
+}
+function documentPath(prepend, slug) {
+    const trimmed = slug.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const prefix = prepend?.trim() ?? '';
+    const joined = `${prefix}/${trimmed}`.replace(/\/+/g, '/');
+    return joined.length > 1 ? joined.replace(/\/+$/, '') : '/';
+}
+function findNamed(fields, name) {
+    for (const field of fields){
+        if ('name' in field && field.name === name) {
+            return field;
+        }
+        if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                const found = findNamed(tabFields(tab), name);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        const nested = childFields(field);
+        if (nested.length > 0) {
+            const found = findNamed(nested, name);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=fields.js.map