includio-cms 0.1.3 → 0.5.0

package/dist/components/ui/tooltip/tooltip.stories.svelte.d.ts

@@ -0,0 +1,27 @@
+export default Tooltip;
+type Tooltip = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const Tooltip: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+import { Tooltip } from './index.js';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import("svelte").ComponentConstructorOptions<Props>): import("svelte").SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}

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

@@ -3,6 +3,7 @@ import { z } from 'zod';
 type AnyZodObject = z.ZodObject<any, any>;
 interface GenerateZodSchemaOptions {
     parentRequired?: boolean;
+    localized?: boolean;
 }
 export declare function generateZodSchemaFromField(field: Field, languages: string[], options?: GenerateZodSchemaOptions): z.ZodType;
 export declare function generateZodSchemaFromFields(fields: Field[], languages: string[], options?: GenerateZodSchemaOptions): AnyZodObject;

package/dist/core/fields/fieldSchemaToTs.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 export function generateZodSchemaFromField(field, languages, options = {
     parentRequired: true
 }) {
+    const localized = options.localized !== false;
     switch (field.type) {
         case 'text': {
             let schema = z.string();
@@ -13,14 +14,92 @@ export function generateZodSchemaFromField(field, languages, options = {
                 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])));
         }
         case 'richtext': {
             let schema = z.string();
             if (field.required)
                 schema = schema.min(1, { message: 'Pole wymagane' });
+            if (!localized)
+                return schema;
             return z.object(Object.fromEntries(languages.map((lang) => [lang, schema])));
         }
+        case 'content': {
+            const markSchema = z.object({
+                type: z.string(),
+                attrs: z.record(z.string(), z.unknown()).optional()
+            });
+            const nodeSchema = z.lazy(() => z.object({
+                type: z.string(),
+                attrs: z.record(z.string(), z.unknown()).optional(),
+                content: z.array(nodeSchema).optional(),
+                marks: z.array(markSchema).optional(),
+                text: z.string().optional()
+            }));
+            let docSchema = z.object({
+                type: z.literal('doc'),
+                content: z.array(nodeSchema)
+            });
+            // If inline blocks defined, validate their blockData
+            if (field.inlineBlocks && field.inlineBlocks.length > 0) {
+                const blockSchemas = new Map();
+                for (const blockDef of field.inlineBlocks) {
+                    blockSchemas.set(blockDef.slug, generateZodSchemaFromFields(blockDef.fields, languages, {
+                        parentRequired: false,
+                        localized: false
+                    }));
+                }
+                docSchema = z
+                    .object({
+                    type: z.literal('doc'),
+                    content: z.array(nodeSchema)
+                })
+                    .superRefine((doc, ctx) => {
+                    for (let i = 0; i < doc.content.length; i++) {
+                        const node = doc.content[i];
+                        if (node.type !== 'inlineBlock')
+                            continue;
+                        const blockType = node.attrs?.blockType;
+                        const blockData = node.attrs?.blockData;
+                        const schema = blockSchemas.get(blockType);
+                        if (!schema) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: `Nieznany typ bloku: ${blockType}`,
+                                path: ['content', i, 'attrs', 'blockType']
+                            });
+                            continue;
+                        }
+                        let data = blockData;
+                        if (typeof data === 'string') {
+                            try {
+                                data = JSON.parse(data);
+                            }
+                            catch {
+                                ctx.addIssue({
+                                    code: z.ZodIssueCode.custom,
+                                    message: 'Nieprawidłowe dane bloku',
+                                    path: ['content', i, 'attrs', 'blockData']
+                                });
+                                continue;
+                            }
+                        }
+                        const result = schema.safeParse(data);
+                        if (!result.success) {
+                            for (const issue of result.error.issues) {
+                                ctx.addIssue({
+                                    ...issue,
+                                    path: ['content', i, 'attrs', 'blockData', ...issue.path]
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+            return z.object(Object.fromEntries(languages.map((lang) => [lang, docSchema])));
+        }
         case 'number': {
             let schema = z.number({ message: 'Wymagana liczba' });
             if (field.min !== undefined)
@@ -68,7 +147,7 @@ export function generateZodSchemaFromField(field, languages, options = {
                 data: finalData
             });
         }
-        case 'array': {
+        case 'blocks': {
             const schemas = field.of.map((f) => generateZodSchemaFromField(f, languages, { parentRequired: field.required }));
             const itemSchema = schemas.length > 1
                 ? z.discriminatedUnion('slug', schemas)
@@ -94,6 +173,37 @@ export function generateZodSchemaFromField(field, languages, options = {
             }
             return schema.default([]); // Default to empty array if not required
         }
+        case 'array': {
+            let itemSchema;
+            switch (field.of) {
+                case 'text':
+                    itemSchema = field.localized
+                        ? z.record(z.string(), z.string())
+                        : z.string();
+                    break;
+                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()
+                    });
+                    break;
+            }
+            let schema = z.array(itemSchema);
+            if (field.minItems !== undefined)
+                schema = schema.min(field.minItems, {
+                    message: `Minimum ${field.minItems} elementów`
+                });
+            if (field.maxItems !== undefined)
+                schema = schema.max(field.maxItems, {
+                    message: `Maksimum ${field.maxItems} elementów`
+                });
+            return schema.default([]);
+        }
         case 'slug': {
             let schema = z.string();
             if (field.required)
@@ -101,6 +211,17 @@ export function generateZodSchemaFromField(field, languages, options = {
             return schema;
         }
         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()]))),
@@ -112,6 +233,17 @@ export function generateZodSchemaFromField(field, languages, options = {
             });
         }
         case 'url': {
+            if (!localized) {
+                const flatShape = {
+                    url: z.string().default(''),
+                    id: z.string().optional()
+                };
+                if (field.text)
+                    flatShape.text = z.string().default('');
+                if (field.newTab)
+                    flatShape.newTab = z.boolean().optional();
+                return z.object(flatShape);
+            }
             const langString = z.string().default('');
             const urlShape = {
                 url: z.object(Object.fromEntries(languages.map((lang) => [lang, langString]))),

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

@@ -0,0 +1,17 @@
+import type { Field } from '../../types/fields.js';
+import type { ConfigBase } from '../../types/config.js';
+import type { Layout, LayoutNode } from '../../types/layout.js';
+export declare function getFieldsFromConfig(config: ConfigBase): Field[];
+export declare function hasLayout(config: ConfigBase): boolean;
+/** Collect all field slugs referenced in layout nodes (depth-first order) */
+export declare function collectFieldSlugs(nodes: LayoutNode[]): string[];
+export interface LayoutValidationError {
+    type: 'missing_field' | 'duplicate_field' | 'depth_exceeded' | 'columns_mismatch';
+    message: string;
+}
+/** Validate layout against fields — returns errors or empty array */
+export declare function validateLayout(nodes: LayoutNode[], fields: Field[]): LayoutValidationError[];
+/** Expand a preset into LayoutNode[] */
+export declare function resolveLayout(layout: Layout, fields: Field[]): LayoutNode[];
+/** Resolve layout + append orphan fields in a trailing section */
+export declare function resolveLayoutWithOrphans(config: ConfigBase): LayoutNode[];

package/dist/core/fields/layoutUtils.js

@@ -0,0 +1,149 @@
+import { isLayoutBranch, isLayoutLeaf } from '../../types/layout.js';
+export function getFieldsFromConfig(config) {
+    return config.fields;
+}
+export function hasLayout(config) {
+    return !!config.layout;
+}
+/** Collect all field slugs referenced in layout nodes (depth-first order) */
+export function collectFieldSlugs(nodes) {
+    const slugs = [];
+    for (const node of nodes) {
+        if (isLayoutLeaf(node)) {
+            slugs.push(...node.fields);
+        }
+        if (isLayoutBranch(node)) {
+            slugs.push(...collectFieldSlugs(node.children));
+        }
+    }
+    return slugs;
+}
+/** Count columns expected by a ratio string */
+function columnCount(ratio) {
+    return ratio.split(' ').length;
+}
+/** Validate layout against fields — returns errors or empty array */
+export function validateLayout(nodes, fields) {
+    const errors = [];
+    const fieldSlugs = new Set(fields.map((f) => f.slug));
+    const referencedSlugs = collectFieldSlugs(nodes);
+    // Check for missing fields
+    for (const slug of referencedSlugs) {
+        if (!fieldSlugs.has(slug)) {
+            errors.push({ type: 'missing_field', message: `Field "${slug}" not found in fields[]` });
+        }
+    }
+    // Check for duplicates
+    const seen = new Set();
+    for (const slug of referencedSlugs) {
+        if (seen.has(slug)) {
+            errors.push({ type: 'duplicate_field', message: `Field "${slug}" referenced multiple times` });
+        }
+        seen.add(slug);
+    }
+    // Check depth + columns
+    function walk(nodeList, depth) {
+        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 === 'columns') {
+                const expected = columnCount(node.ratio);
+                const actual = node.children?.length ?? 0;
+                if (actual !== expected) {
+                    errors.push({
+                        type: 'columns_mismatch',
+                        message: `Columns ratio "${node.ratio}" expects ${expected} children, got ${actual}`
+                    });
+                }
+            }
+            if (isLayoutBranch(node)) {
+                walk(node.children, depth + 1);
+            }
+        }
+    }
+    walk(nodes, 0);
+    return errors;
+}
+/** Expand a preset into LayoutNode[] */
+export function resolveLayout(layout, fields) {
+    if (Array.isArray(layout))
+        return layout;
+    return expandPreset(layout, fields);
+}
+/** Resolve layout + append orphan fields in a trailing section */
+export function resolveLayoutWithOrphans(config) {
+    if (!config.layout) {
+        // No layout — single section with all fields
+        return [
+            {
+                type: 'section',
+                label: { en: 'Fields', pl: 'Pola' },
+                fields: config.fields.map((f) => f.slug)
+            }
+        ];
+    }
+    const nodes = resolveLayout(config.layout, config.fields);
+    const referenced = new Set(collectFieldSlugs(nodes));
+    const orphans = config.fields.filter((f) => !referenced.has(f.slug)).map((f) => f.slug);
+    if (orphans.length === 0)
+        return nodes;
+    return [
+        ...nodes,
+        {
+            type: 'section',
+            label: { en: 'Other', pl: 'Pozostałe' },
+            fields: orphans
+        }
+    ];
+}
+function expandPreset(preset, fields) {
+    const allSlugs = fields.map((f) => f.slug);
+    if (preset === 'sidebar-right') {
+        // Heuristic: last 2 fields → sidebar
+        const sidebarSlugs = allSlugs.slice(-2);
+        const mainSlugs = allSlugs.slice(0, -2);
+        return buildSidebarRight(mainSlugs, sidebarSlugs);
+    }
+    if (preset === 'two-column') {
+        const half = Math.ceil(allSlugs.length / 2);
+        return buildTwoColumn(allSlugs.slice(0, half), allSlugs.slice(half));
+    }
+    if (typeof preset === 'object' && preset.preset === 'sidebar-right') {
+        const sidebarSet = new Set(preset.sidebar);
+        const mainSlugs = allSlugs.filter((s) => !sidebarSet.has(s));
+        return buildSidebarRight(mainSlugs, preset.sidebar);
+    }
+    if (typeof preset === 'object' && preset.preset === 'two-column') {
+        const leftSet = new Set(preset.left ?? []);
+        const left = preset.left ?? allSlugs.slice(0, Math.ceil(allSlugs.length / 2));
+        const right = allSlugs.filter((s) => !leftSet.has(s));
+        return buildTwoColumn(left, right);
+    }
+    return [];
+}
+function buildSidebarRight(main, sidebar) {
+    return [
+        {
+            type: 'columns',
+            ratio: '2fr 1fr',
+            children: [
+                { type: 'stack', fields: main },
+                { type: 'stack', fields: sidebar }
+            ]
+        }
+    ];
+}
+function buildTwoColumn(left, right) {
+    return [
+        {
+            type: 'columns',
+            ratio: '1fr 1fr',
+            children: [
+                { type: 'stack', fields: left },
+                { type: 'stack', fields: right }
+            ]
+        }
+    ];
+}

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

@@ -0,0 +1,9 @@
+import type { StructuredContentDoc } from '../../types/structured-content.js';
+export interface StructuredToHtmlOptions {
+    /** Custom renderer for inline blocks. Return HTML string. */
+    inlineBlock?: (blockType: string, blockData: Record<string, unknown>) => string;
+    /** Base URL prefix for relative URLs (useful for RSS feeds). */
+    baseUrl?: string;
+}
+/** Convert a StructuredContentDoc to an HTML string. */
+export declare function structuredToHtml(doc: StructuredContentDoc, options?: StructuredToHtmlOptions): string;

package/dist/core/fields/structuredToHtml.js

@@ -0,0 +1,161 @@
+const VOID_TAGS = new Set(['hr', 'br', 'img']);
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function resolveUrl(url, baseUrl) {
+    if (!baseUrl || !url)
+        return url;
+    if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith('//'))
+        return url;
+    return `${baseUrl.replace(/\/$/, '')}${url.startsWith('/') ? '' : '/'}${url}`;
+}
+function renderMarks(text, marks, options) {
+    if (!marks?.length)
+        return escapeHtml(text);
+    let html = escapeHtml(text);
+    for (const mark of marks) {
+        switch (mark.type) {
+            case 'bold':
+                html = `<strong>${html}</strong>`;
+                break;
+            case 'italic':
+                html = `<em>${html}</em>`;
+                break;
+            case 'underline':
+                html = `<u>${html}</u>`;
+                break;
+            case 'strike':
+                html = `<s>${html}</s>`;
+                break;
+            case 'code':
+                html = `<code>${html}</code>`;
+                break;
+            case 'highlight':
+                html = `<mark>${html}</mark>`;
+                break;
+            case 'link': {
+                const attrs = mark.attrs ?? {};
+                const href = resolveUrl(attrs.href ?? '', options.baseUrl);
+                const target = attrs.target;
+                const title = attrs.title;
+                const ariaLabel = attrs['aria-label'];
+                let attrStr = ` href="${escapeHtml(href)}"`;
+                if (target === '_blank') {
+                    attrStr += ` target="_blank" rel="noopener noreferrer"`;
+                }
+                else if (target) {
+                    attrStr += ` target="${escapeHtml(target)}"`;
+                }
+                if (title)
+                    attrStr += ` title="${escapeHtml(title)}"`;
+                if (ariaLabel)
+                    attrStr += ` aria-label="${escapeHtml(ariaLabel)}"`;
+                html = `<a${attrStr}>${html}</a>`;
+                break;
+            }
+        }
+    }
+    return html;
+}
+function renderNode(node, options) {
+    const children = node.content?.map((c) => renderNode(c, options)).join('') ?? '';
+    switch (node.type) {
+        case 'doc':
+            return children;
+        case 'text':
+            return renderMarks(node.text ?? '', node.marks, options);
+        case 'paragraph':
+            return `<p>${children}</p>`;
+        case 'heading': {
+            const level = node.attrs?.level ?? 2;
+            return `<h${level}>${children}</h${level}>`;
+        }
+        case 'blockquote':
+            return `<blockquote>${children}</blockquote>`;
+        case 'bulletList':
+            return `<ul>${children}</ul>`;
+        case 'orderedList':
+            return `<ol>${children}</ol>`;
+        case 'listItem':
+            return `<li>${children}</li>`;
+        case 'codeBlock': {
+            const lang = node.attrs?.language;
+            const langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : '';
+            return `<pre><code${langAttr}>${children}</code></pre>`;
+        }
+        case 'horizontalRule':
+            return '<hr>';
+        case 'hardBreak':
+            return '<br>';
+        case 'figure': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const alt = escapeHtml(attrs.alt ?? '');
+            const caption = attrs.caption;
+            const width = attrs.width;
+            const height = attrs.height;
+            let imgAttrs = ` src="${escapeHtml(src)}" alt="${alt}"`;
+            if (width)
+                imgAttrs += ` width="${width}"`;
+            if (height)
+                imgAttrs += ` height="${height}"`;
+            let html = `<figure><img${imgAttrs}>`;
+            if (caption)
+                html += `<figcaption>${escapeHtml(caption)}</figcaption>`;
+            html += '</figure>';
+            return html;
+        }
+        case 'image': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const alt = escapeHtml(attrs.alt ?? '');
+            const width = attrs.width;
+            const height = attrs.height;
+            let imgAttrs = ` src="${escapeHtml(src)}" alt="${alt}"`;
+            if (width)
+                imgAttrs += ` width="${width}"`;
+            if (height)
+                imgAttrs += ` height="${height}"`;
+            return `<img${imgAttrs}>`;
+        }
+        case 'video': {
+            const attrs = node.attrs ?? {};
+            const src = resolveUrl(attrs.src ?? '', options.baseUrl);
+            const poster = attrs.poster;
+            const width = attrs.width;
+            const height = attrs.height;
+            let videoAttrs = ' controls';
+            if (poster)
+                videoAttrs += ` poster="${escapeHtml(resolveUrl(poster, options.baseUrl))}"`;
+            if (width)
+                videoAttrs += ` width="${width}"`;
+            if (height)
+                videoAttrs += ` height="${height}"`;
+            return `<video${videoAttrs}><source src="${escapeHtml(src)}"></video>`;
+        }
+        case 'table':
+            return `<table>${children}</table>`;
+        case 'tableRow':
+            return `<tr>${children}</tr>`;
+        case 'tableCell':
+            return `<td>${children}</td>`;
+        case 'tableHeader':
+            return `<th>${children}</th>`;
+        case 'inlineBlock': {
+            const attrs = node.attrs ?? {};
+            const blockType = attrs.blockType;
+            const blockData = attrs.blockData ?? {};
+            return options.inlineBlock?.(blockType, blockData) ?? '';
+        }
+        default:
+            return children;
+    }
+}
+/** Convert a StructuredContentDoc to an HTML string. */
+export function structuredToHtml(doc, options = {}) {
+    return renderNode(doc, options);
+}

package/dist/core/server/entries/operations/create.js

@@ -4,6 +4,7 @@ import { entryTypes } from '../../../../types/entries.js';
 import z from 'zod';
 import { getDbEntryOrThrow } from './get.js';
 import { generateZodSchemaFromFields } from '../../../fields/fieldSchemaToTs.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 export const createEntrySchema = z.object({
     slug: z.string(),
     type: z.enum(entryTypes)
@@ -32,7 +33,7 @@ export const createEntryVersion = async (data, options) => {
         const entry = await getDbEntryOrThrow({ id: data.entryId });
         const config = getCMS().getBySlug(entry.slug);
         const languages = getCMS().languages;
-        const schema = generateZodSchemaFromFields(config.fields, languages);
+        const schema = generateZodSchemaFromFields(getFieldsFromConfig(config), languages);
         const parsedData = schema.safeParse(data.data);
         if (!parsedData.success) {
             throw Error('Invalid data: ' + JSON.stringify(parsedData.error.flatten()));

package/dist/core/server/entries/operations/get.js

@@ -1,5 +1,6 @@
 import { getCMS } from '../../../cms.js';
 import { populateEntryData } from '../../fields/populateEntry.js';
+import { getFieldsFromConfig } from '../../../fields/layoutUtils.js';
 // Helper function to transform string values to localized objects
 function transformDataValuesToLocalized(dataValues, defaultLanguage) {
     const result = {};
@@ -70,16 +71,17 @@ export const getRawEntries = async (options) => {
             const scheduledVersion = publishedOrScheduledVersion && isScheduled
                 ? publishedOrScheduledVersion
                 : null;
-            // Draft = latest version by versionNumber
-            const draftVersions = versions
-                .sort((a, b) => b.versionNumber - a.versionNumber);
+            // Draft = latest non-published version by versionNumber
+            const draftVersion = versions
+                .filter((v) => v.id !== entry.publishedVersionId)
+                .sort((a, b) => b.versionNumber - a.versionNumber)[0] || null;
             return {
                 ...entry,
                 collection: getCMS().getBySlug(entry.slug),
                 versions: versions.sort((a, b) => b.versionNumber - a.versionNumber),
                 publishedVersion,
                 scheduledVersion,
-                draftVersion: draftVersions[0] || null
+                draftVersion
             };
         }
         catch {
@@ -237,7 +239,7 @@ export const getEntries = async (options = {}) => {
             const config = getCMS().getBySlug(dbEntry.slug);
             return {
                 ...dbEntry,
-                data: await populateEntryData(version.data, config.fields, language),
+                data: await populateEntryData(version.data, getFieldsFromConfig(config), language),
                 status,
                 publishedAt: dbEntry.publishedAt,
                 populated: true
@@ -295,7 +297,7 @@ export const getEntryVersion = async (options) => {
         const config = getCMS().getBySlug(dbEntry.slug);
         return {
             ...dbEntry,
-            data: await populateEntryData(dbEntryVersion.data, config.fields, language)
+            data: await populateEntryData(dbEntryVersion.data, getFieldsFromConfig(config), language)
         };
     }
     catch (error) {

package/dist/core/server/entries/operations/update.d.ts

@@ -17,4 +17,7 @@ export declare const updateEntryVersion: (id: string, data: Partial<DbEntryVersi
 export declare const updateEntryVersionCommandTypes: readonly ["draft", "published-now", "published-scheduled", "cancel-published"];
 export type UpdateEntryVersionCommandType = (typeof updateEntryVersionCommandTypes)[number];
 export declare const pruneOldDraftVersions: (entryId: string) => Promise<void>;
+export declare const upsertDraftVersion: (entryId: string, data: Record<string, unknown>, options?: {
+    skipValidation?: boolean;
+}) => Promise<DbEntryVersion>;
 export declare const unpublishEntry: (entryId: string) => Promise<void>;