includio-cms 0.24.1 → 0.26.0

package/dist/core/fields/fieldSchemaToTs.js

@@ -1,4 +1,29 @@
 import { z } from 'zod';
+import { buildSeoZodShape } from './seoFieldDescriptor.js';
+import { isValidUrlValue } from './urlUtils.js';
+/**
+ * Localized generic validation messages. `generateZodSchemaFromField` gets the
+ * preferred language via `options.messageLanguage` (the interface language on
+ * the client); server-side / seed schemas leave it undefined → Polish.
+ */
+function validationMessages(messageLanguage) {
+    const en = messageLanguage === 'en';
+    return {
+        required: en ? 'This field is required' : 'Pole wymagane',
+        minChars: (n) => (en ? `At least ${n} characters` : `Minimum ${n} znaków`),
+        maxChars: (n) => (en ? `At most ${n} characters` : `Maksimum ${n} znaków`),
+        invalidFormat: en ? 'Invalid format' : 'Nieprawidłowy format',
+        numberRequired: en ? 'A number is required' : 'Wymagana liczba',
+        minValue: (n) => `Minimum: ${n}`,
+        maxValue: (n) => (en ? `Maximum: ${n}` : `Maksimum: ${n}`),
+        exactItems: (n) => en ? `Exactly ${n} items required` : `Wymagane dokładnie ${n} elementów`,
+        minItems: (n) => (en ? `At least ${n} items` : `Minimum ${n} elementów`),
+        maxItems: (n) => (en ? `At most ${n} items` : `Maksimum ${n} elementów`),
+        invalidUrl: en ? 'Invalid URL' : 'Nieprawidłowy adres URL',
+        unknownBlock: (t) => (en ? `Unknown block type: ${t}` : `Nieznany typ bloku: ${t}`),
+        invalidBlock: en ? 'Invalid block data' : 'Nieprawidłowe dane bloku'
+    };
+}
 let _customFieldsOverride = null;
 /**
  * Set custom fields map for client-side use (where getCMS() is unavailable).
@@ -27,20 +52,39 @@ export function generateZodSchemaFromField(field, languages, options = {
     parentRequired: true
 }) {
     const localized = options.localized !== false;
+    const msg = validationMessages(options.messageLanguage);
     switch (field.type) {
         case 'text': {
             let schema = z.string();
             if (field.required && options.parentRequired && field.minLength === undefined)
-                schema = schema.min(1, { message: 'Pole wymagane' });
+                schema = schema.min(1, { message: msg.required });
             if (field.minLength !== undefined)
-                schema = schema.min(field.minLength, { message: `Minimum ${field.minLength} znaków` });
+                schema = schema.min(field.minLength, { message: msg.minChars(field.minLength) });
             if (field.maxLength !== undefined)
-                schema = schema.max(field.maxLength, { message: `Maksimum ${field.maxLength} znaków` });
-            if (field.pattern !== undefined)
-                schema = schema.regex(new RegExp(field.pattern), { message: 'Nieprawidłowy format' });
-            if (!localized)
-                return schema;
-            return z.object(Object.fromEntries(languages.map((lang) => [lang, schema])));
+                schema = schema.max(field.maxLength, { message: msg.maxChars(field.maxLength) });
+            if (field.pattern !== undefined) {
+                // Localized = `Partial<Record<lang, string>> | string` (union),
+                // so TS can't index it by a free `string`. Resolve via a local
+                // view to pick the preferred-language message, with a fallback
+                // to the first available entry.
+                const localized = field.patternError;
+                const patternMsg = (typeof localized === 'object' &&
+                    localized &&
+                    options.messageLanguage &&
+                    localized[options.messageLanguage]) ||
+                    (typeof localized === 'object' && localized && Object.values(localized)[0]) ||
+                    (typeof localized === 'string' && localized) ||
+                    msg.invalidFormat;
+                schema = schema.regex(new RegExp(field.pattern), { message: patternMsg });
+            }
+            if (!localized) {
+                return field.required ? schema : schema.optional().default('');
+            }
+            const localizedSchema = z.object(Object.fromEntries(languages.map((lang) => [lang, schema])));
+            if (field.required)
+                return localizedSchema;
+            const emptyLang = Object.fromEntries(languages.map((lang) => [lang, '']));
+            return localizedSchema.optional().default(emptyLang);
         }
         case 'content': {
             const markSchema = z.object({
@@ -64,7 +108,8 @@ export function generateZodSchemaFromField(field, languages, options = {
                 for (const blockDef of field.inlineBlocks) {
                     blockSchemas.set(blockDef.slug, generateZodSchemaFromFields(blockDef.fields, languages, {
                         parentRequired: false,
-                        localized: false
+                        localized: false,
+                        messageLanguage: options.messageLanguage
                     }));
                 }
                 docSchema = z
@@ -83,7 +128,7 @@ export function generateZodSchemaFromField(field, languages, options = {
                         if (!schema) {
                             ctx.addIssue({
                                 code: z.ZodIssueCode.custom,
-                                message: `Nieznany typ bloku: ${blockType}`,
+                                message: msg.unknownBlock(blockType),
                                 path: ['content', i, 'attrs', 'blockType']
                             });
                             continue;
@@ -96,7 +141,7 @@ export function generateZodSchemaFromField(field, languages, options = {
                             catch {
                                 ctx.addIssue({
                                     code: z.ZodIssueCode.custom,
-                                    message: 'Nieprawidłowe dane bloku',
+                                    message: msg.invalidBlock,
                                     path: ['content', i, 'attrs', 'blockData']
                                 });
                                 continue;
@@ -119,59 +164,81 @@ export function generateZodSchemaFromField(field, languages, options = {
             return z.object(Object.fromEntries(languages.map((lang) => [lang, docSchema])));
         }
         case 'number': {
-            let schema = z.number({ message: 'Wymagana liczba' });
+            let schema = z.number({ message: msg.numberRequired });
             if (field.min !== undefined)
-                schema = schema.min(field.min, { message: `Minimum: ${field.min}` });
+                schema = schema.min(field.min, { message: msg.minValue(field.min) });
             if (field.max !== undefined)
-                schema = schema.max(field.max, { message: `Maksimum: ${field.max}` });
-            return schema;
+                schema = schema.max(field.max, { message: msg.maxValue(field.max) });
+            return field.required ? schema : schema.optional();
         }
         case 'boolean':
-            return z.boolean();
+            // A non-required toggle absent from the data must not fail
+            // validation — treat missing as `false` (matches the UI toggle's
+            // off state). Same class of bug as non-required select/radio.
+            return field.required ? z.boolean() : z.boolean().optional().default(false);
         case 'date':
-        case 'datetime':
-            return z.string().datetime();
+        case 'datetime': {
+            const dt = z.string().datetime();
+            if (field.required)
+                return dt;
+            // Empty string is the editor's "no value" state; accept it and
+            // default to '' so missing fields don't fail validation.
+            return z.union([z.literal(''), dt]).optional().default('');
+        }
         case 'file':
         case 'media': {
             const singleSchema = field.required
-                ? z.string().uuid({ message: 'Pole wymagane' })
-                : z.string();
-            return field.multiple ? z.array(singleSchema).default([]) : singleSchema;
+                ? z.string().uuid({ message: msg.required })
+                : z.string().optional().default('');
+            return field.multiple ? z.array(z.string()).default([]) : singleSchema;
         }
         case 'select':
         case 'radio': {
             const enumValues = field.options.map((o) => o.value);
             const enumObject = z.enum(enumValues);
             if (field.type === 'select' && field.multiple) {
-                return z.array(enumObject);
+                return z.array(enumObject).default([]);
             }
-            return field.required ? enumObject : enumObject.or(z.literal(''));
+            // Non-required: union of enum + '' sentinel. Superforms requires a
+            // multi-type union to carry a default, so anchor it on the '' sentinel.
+            return field.required ? enumObject : enumObject.or(z.literal('')).default('');
         }
         case 'checkboxes': {
-            const checkValues = field.options.map((o) => JSON.stringify(o.value)).join(', ');
-            return z.array(z.enum([checkValues])).default([]);
+            const enumValues = field.options.map((o) => o.value);
+            return z.array(z.enum(enumValues)).default([]);
         }
         case 'relation': {
-            let baseSchema = z.string();
+            if (field.multiple) {
+                return z.array(z.string()).default([]);
+            }
             if (field.required) {
-                baseSchema = baseSchema.uuid({ message: 'Pole wymagane' });
+                return z.string().uuid({ message: msg.required });
             }
-            return field.multiple ? z.array(baseSchema).default([]) : baseSchema;
+            return z.string().optional().default('');
         }
         case 'object': {
+            // Children's `required` is enforced when the object itself is required OR
+            // a parent context (e.g. a blocks item) says it must be validated.
             const data = generateZodSchemaFromFields(field.fields, languages, {
-                parentRequired: field.required,
-                localized: options.localized
+                parentRequired: !!field.required || options.parentRequired === true,
+                localized: options.localized,
+                messageLanguage: options.messageLanguage
             });
+            // An optional object stays `.partial()` (a non-required field may be
+            // absent); a present field that is `required` still has to satisfy its
+            // `.min(1)`/etc. constraint.
             const base = !field.required ? data.partial() : data;
             return base.extend({
                 _slug: z.literal(field.slug)
             });
         }
         case 'blocks': {
+            // Each block item, once added, should have its own required fields filled
+            // (validation runs only on publish, drafts are unvalidated).
             const schemas = field.of.map((f) => generateZodSchemaFromField(f, languages, {
-                parentRequired: field.required,
-                localized: options.localized
+                parentRequired: true,
+                localized: options.localized,
+                messageLanguage: options.messageLanguage
             }));
             const itemSchema = schemas.length > 1
                 ? z.discriminatedUnion('_slug', schemas)
@@ -182,17 +249,17 @@ export function generateZodSchemaFromField(field, languages, options = {
                 field.minItems === field.maxItems &&
                 field.minItems > 0) {
                 schema = schema.length(field.minItems, {
-                    message: `Wymagane dokładnie ${field.minItems} elementów`
+                    message: msg.exactItems(field.minItems)
                 });
             }
             else {
                 if (field.minItems !== undefined)
                     schema = schema.min(field.minItems, {
-                        message: `Minimum ${field.minItems} elementów`
+                        message: msg.minItems(field.minItems)
                     });
                 if (field.maxItems !== undefined)
                     schema = schema.max(field.maxItems, {
-                        message: `Maksimum ${field.maxItems} elementów`
+                        message: msg.maxItems(field.maxItems)
                     });
             }
             return schema.default([]); // Default to empty array if not required
@@ -208,53 +275,83 @@ export function generateZodSchemaFromField(field, languages, options = {
                 case 'number':
                     itemSchema = z.number();
                     break;
-                case 'url':
-                    itemSchema = z.object({
-                        id: z.string().optional(),
-                        url: z.record(z.string(), z.string()),
-                        text: z.record(z.string(), z.string()).optional(),
-                        newTab: z.boolean().optional()
-                    });
+                case 'url': {
+                    // Harmonized with the standalone url field: same shape, same
+                    // superRefine. Each item carries url/id/text/newTab/rel,
+                    // respects `localized` like the rest of the schema, and
+                    // rejects malformed values via isValidUrlValue.
+                    if (!localized) {
+                        itemSchema = z
+                            .object({
+                            url: z.string().default(''),
+                            id: z.string().optional(),
+                            text: z.string().default('').optional(),
+                            newTab: z.boolean().optional(),
+                            rel: z.string().optional()
+                        })
+                            .superRefine((data, ctx) => {
+                            const isLinked = typeof data.id === 'string' && data.id.length > 0;
+                            if (isLinked)
+                                return;
+                            if (!isValidUrlValue(data.url ?? '')) {
+                                ctx.addIssue({
+                                    code: z.ZodIssueCode.custom,
+                                    message: msg.invalidUrl,
+                                    path: ['url']
+                                });
+                            }
+                        });
+                    }
+                    else {
+                        const langString = z.string().default('');
+                        itemSchema = z
+                            .object({
+                            url: z.object(Object.fromEntries(languages.map((lang) => [lang, langString]))),
+                            id: z.string().optional(),
+                            text: z
+                                .object(Object.fromEntries(languages.map((lang) => [lang, langString])))
+                                .optional(),
+                            newTab: z.boolean().optional(),
+                            rel: z.string().optional()
+                        })
+                            .superRefine((data, ctx) => {
+                            const isLinked = typeof data.id === 'string' && data.id.length > 0;
+                            if (isLinked)
+                                return;
+                            for (const lang of languages) {
+                                const val = data.url[lang] ?? '';
+                                if (!isValidUrlValue(val)) {
+                                    ctx.addIssue({
+                                        code: z.ZodIssueCode.custom,
+                                        message: msg.invalidUrl,
+                                        path: ['url', lang]
+                                    });
+                                }
+                            }
+                        });
+                    }
                     break;
+                }
             }
             let schema = z.array(itemSchema);
             if (field.minItems !== undefined)
                 schema = schema.min(field.minItems, {
-                    message: `Minimum ${field.minItems} elementów`
+                    message: msg.minItems(field.minItems)
                 });
             if (field.maxItems !== undefined)
                 schema = schema.max(field.maxItems, {
-                    message: `Maksimum ${field.maxItems} elementów`
+                    message: msg.maxItems(field.maxItems)
                 });
             return schema.default([]);
         }
         case 'slug': {
-            let schema = z.string();
-            if (field.required)
-                schema = schema.min(1, { message: 'Pole wymagane' });
-            return schema;
+            if (field.required) {
+                return z.string().min(1, { message: msg.required });
+            }
+            return z.string().optional().default('');
         }
         case 'seo': {
-            if (!localized) {
-                return z.object({
-                    slug: z.string(),
-                    canonicalUrl: z.string().optional(),
-                    title: z.string(),
-                    description: z.string(),
-                    keywords: z.string().optional(),
-                    ogImage: z.string(),
-                    customCode: z.string().optional()
-                });
-            }
-            return z.object({
-                slug: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string()]))),
-                canonicalUrl: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string().optional()]))),
-                title: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string()]))),
-                description: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string()]))),
-                keywords: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string().optional()]))),
-                ogImage: z.string(),
-                customCode: z.object(Object.fromEntries(languages.map((lang) => [lang, z.string().optional()])))
-            });
+            return z.object(buildSeoZodShape(languages, localized));
         }
         case 'shop': {
             // Shop data is stored in shop_products table (keyed by entry_id), not in entry.data.
@@ -271,7 +368,36 @@ export function generateZodSchemaFromField(field, languages, options = {
                     flatShape.text = z.string().default('');
                 if (field.newTab)
                     flatShape.newTab = z.boolean().optional();
-                return z.object(flatShape);
+                const flatSchema = z.object(flatShape).superRefine((data, ctx) => {
+                    const isLinked = typeof data.id === 'string' && data.id.length > 0;
+                    if (isLinked)
+                        return;
+                    const url = typeof data.url === 'string' ? data.url : '';
+                    if (field.required && url.trim() === '') {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.too_small,
+                            minimum: 1,
+                            type: 'string',
+                            inclusive: true,
+                            message: msg.required,
+                            path: ['url']
+                        });
+                        return;
+                    }
+                    if (!isValidUrlValue(url)) {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.custom,
+                            message: msg.invalidUrl,
+                            path: ['url']
+                        });
+                    }
+                });
+                if (field.required)
+                    return flatSchema;
+                const flatDefault = { url: '' };
+                if (field.text)
+                    flatDefault.text = '';
+                return flatSchema.optional().default(flatDefault);
             }
             const langString = z.string().default('');
             const urlShape = {
@@ -284,27 +410,39 @@ export function generateZodSchemaFromField(field, languages, options = {
             if (field.newTab) {
                 urlShape.newTab = z.boolean().optional();
             }
-            const schema = z.object(urlShape);
-            if (field.required) {
-                return schema.superRefine((data, ctx) => {
-                    const isLinked = data.id != null && data.id.length > 0;
-                    if (isLinked)
-                        return;
-                    for (const lang of languages) {
-                        if (!data.url[lang]) {
-                            ctx.addIssue({
-                                code: z.ZodIssueCode.too_small,
-                                minimum: 1,
-                                type: 'string',
-                                inclusive: true,
-                                message: 'Pole wymagane',
-                                path: ['url', lang]
-                            });
-                        }
+            const localizedSchema = z.object(urlShape).superRefine((data, ctx) => {
+                const isLinked = data.id != null && data.id.length > 0;
+                if (isLinked)
+                    return;
+                for (const lang of languages) {
+                    const val = data.url[lang] ?? '';
+                    if (field.required && val.trim() === '') {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.too_small,
+                            minimum: 1,
+                            type: 'string',
+                            inclusive: true,
+                            message: msg.required,
+                            path: ['url', lang]
+                        });
+                        continue;
                     }
-                });
-            }
-            return schema;
+                    if (!isValidUrlValue(val)) {
+                        ctx.addIssue({
+                            code: z.ZodIssueCode.custom,
+                            message: msg.invalidUrl,
+                            path: ['url', lang]
+                        });
+                    }
+                }
+            });
+            if (field.required)
+                return localizedSchema;
+            const emptyLangMap = Object.fromEntries(languages.map((l) => [l, '']));
+            const localizedDefault = { url: emptyLangMap };
+            if (field.text)
+                localizedDefault.text = emptyLangMap;
+            return localizedSchema.optional().default(localizedDefault);
         }
         case 'custom': {
             const customDef = getCustomFieldDef(field.fieldType);
@@ -317,9 +455,15 @@ export function generateZodSchemaFromField(field, languages, options = {
     }
 }
 export function generateZodSchemaFromFields(fields, languages, options = {}) {
+    // Top-level fields are required-validated by default (consistent with the
+    // single-field default). Nested callers (object/blocks/content) always pass
+    // an explicit `parentRequired`; entry-level callers only pass `localized`,
+    // so without this merge a top-level `required` text field never got
+    // `.min(1)` and empty values slipped through validation.
+    const resolvedOptions = { parentRequired: true, ...options };
     return z.object({
         ...Object.fromEntries(fields.map((f) => {
-            let schema = generateZodSchemaFromField(f, languages, options);
+            let schema = generateZodSchemaFromField(f, languages, resolvedOptions);
             // Fields with showWhen are conditionally visible — make them optional
             // so hidden fields don't block validation
             if (f.showWhen) {

package/dist/core/fields/layoutUtils.d.ts

@@ -31,9 +31,12 @@ export declare function getDistributedObjectSlugs(nodes: LayoutNode[], fields: F
  */
 export declare function buildFormPath(dotPath: string): string;
 export interface LayoutValidationError {
-    type: 'missing_field' | 'duplicate_field' | 'depth_exceeded' | 'columns_mismatch';
+    type: 'missing_field' | 'duplicate_field' | 'depth_exceeded' | 'columns_mismatch' | 'nested_tabs' | 'invalid_tabs_structure';
     message: string;
 }
+/** Expand layout field references (incl. dot-notation & whole objects) into
+ *  concrete leaf paths. Used by the renderer to map a tab subtree → its fields. */
+export declare function collectLeafPathsForNodes(nodes: LayoutNode[], fields: Field[]): string[];
 /** Validate layout against fields — returns errors or empty array.
  *  Supports dot-notation paths (e.g. 'hero.title'). */
 export declare function validateLayout(nodes: LayoutNode[], fields: Field[]): LayoutValidationError[];

package/dist/core/fields/layoutUtils.js

@@ -109,6 +109,15 @@ export function buildFormPath(dotPath) {
 function columnCount(ratio) {
     return ratio.split(' ').length;
 }
+/** Expand layout field references (incl. dot-notation & whole objects) into
+ *  concrete leaf paths. Used by the renderer to map a tab subtree → its fields. */
+export function collectLeafPathsForNodes(nodes, fields) {
+    const leaves = [];
+    for (const ref of collectFieldSlugs(nodes)) {
+        leaves.push(...expandToLeafPaths(ref, fields));
+    }
+    return leaves;
+}
 /** Validate layout against fields — returns errors or empty array.
  *  Supports dot-notation paths (e.g. 'hero.title'). */
 export function validateLayout(nodes, fields) {
@@ -140,13 +149,41 @@ export function validateLayout(nodes, fields) {
             seenLeaves.add(leaf);
         }
     }
-    // Check depth + columns
-    function walk(nodeList, depth) {
+    // Check depth + columns + tabs structure.
+    // `tabs`/`tab` are structural wrappers — they do NOT count toward visual
+    // nesting depth, but `tabs` may not be nested inside another `tab`/`tabs`.
+    function walk(nodeList, depth, insideTabs) {
         if (depth > 2) {
             errors.push({ type: 'depth_exceeded', message: `Nesting depth ${depth} exceeds max of 2` });
             return;
         }
         for (const node of nodeList) {
+            if (node.type === 'tabs') {
+                if (insideTabs) {
+                    errors.push({ type: 'nested_tabs', message: 'Nested tabs are not allowed' });
+                }
+                for (const child of node.children) {
+                    if (child.type !== 'tab') {
+                        errors.push({
+                            type: 'invalid_tabs_structure',
+                            message: `"tabs" children must be "tab" nodes, got "${child.type}"`
+                        });
+                    }
+                }
+                for (const child of node.children) {
+                    if (child.type === 'tab' && isLayoutBranch(child)) {
+                        walk(child.children, depth, true);
+                    }
+                }
+                continue;
+            }
+            if (node.type === 'tab') {
+                errors.push({
+                    type: 'invalid_tabs_structure',
+                    message: '"tab" is only valid as a direct child of "tabs"'
+                });
+                continue;
+            }
             if (node.type === 'columns') {
                 const expected = columnCount(node.ratio);
                 const actual = node.children?.length ?? 0;
@@ -158,11 +195,11 @@ export function validateLayout(nodes, fields) {
                 }
             }
             if (isLayoutBranch(node)) {
-                walk(node.children, depth + 1);
+                walk(node.children, depth + 1, insideTabs);
             }
         }
     }
-    walk(nodes, 0);
+    walk(nodes, 0, false);
     return errors;
 }
 /** Expand a preset into LayoutNode[] */

package/dist/core/fields/resolveSeo.d.ts

@@ -0,0 +1,70 @@
+import type { SeoFieldData } from '../../types/fields.js';
+import type { MediaFile } from '../../types/media.js';
+/**
+ * Normalized SEO data — localized values flattened by `language`. A stable
+ * read-path over the v1.0-frozen `entry.seo.*` contract. Use it to build a
+ * custom `<head>` or to feed the `<Seo>` component.
+ *
+ * @remarks
+ * Every field is optional, even though `slug` and `title` are *required* in
+ * {@link SeoFieldData}: a missing, partial, or garbage `entry.seo` resolves to
+ * an all-`undefined` shape rather than throwing.
+ *
+ * `ogImage` is special. The frozen SEO Zod schema treats it as a flat
+ * `z.string()` (never per-language localized), so at rest it is a media-UUID
+ * string. After server media-hydration it becomes a {@link MediaFile} object.
+ * `resolveSeo` therefore passes `ogImage` through unchanged — it may be a
+ * `MediaFile` (hydrated) or a string (raw), and is never language-flattened.
+ *
+ * @public
+ */
+export type ResolvedSeo = {
+    [K in keyof SeoFieldData]: K extends 'ogImage' ? string | MediaFile | undefined : string | undefined;
+};
+/**
+ * Resolve `entry.seo` into flat fields, flattening localized objects by
+ * `language`.
+ *
+ * For each of the six text keys: a `string` value passes through; a localized
+ * `{ lang: string }` object resolves to `obj[language]` (or `undefined` if the
+ * requested language is missing); anything else resolves to `undefined`.
+ *
+ * `ogImage` is exempt from flattening: it passes through unchanged as a string
+ * or a {@link MediaFile} object (only `null`/`undefined` → `undefined`).
+ *
+ * The name `resolveSeo` is a deliberate, v1.0-frozen choice — it aligns with
+ * the `resolveEntryUrl` / `resolveMedia*` resolver family.
+ *
+ * @param entry - The (possibly resolved/hydrated) entry, or any object with an
+ * optional `seo` property. A non-object or missing `seo` yields all-`undefined`.
+ * @param language - The active language code. Required to flatten localized
+ * `{ lang: string }` values; localized fields resolve to `undefined` without it.
+ * @returns A {@link ResolvedSeo} — all keys present, each `string`/`MediaFile`
+ * (only `ogImage`) or `undefined`.
+ * @public
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { resolveSeo } from 'includio-cms/core';
+ *   import { Seo } from 'includio-cms';
+ *   let { entry, language } = $props();
+ *   const seo = $derived(resolveSeo(entry, language));
+ * </script>
+ *
+ * <svelte:head>
+ *   {#if seo.title}<title>{seo.title}</title>{/if}
+ *   {#if seo.canonicalUrl}<link rel="canonical" href={seo.canonicalUrl} />{/if}
+ * </svelte:head>
+ *
+ * <Seo
+ *   title={seo.title}
+ *   description={seo.description}
+ *   keywords={seo.keywords}
+ *   ogImage={seo.ogImage}
+ *   canonicalUrl={seo.canonicalUrl}
+ * />
+ * ```
+ */
+export declare function resolveSeo(entry: {
+    seo?: Record<string, unknown>;
+} | Record<string, unknown>, language?: string): ResolvedSeo;