includio-cms 0.1.4 → 0.5.1

package/dist/components/ui/toggle/toggle.stories.svelte

@@ -0,0 +1,22 @@
+<script module>
+	import { defineMeta } from '@storybook/addon-svelte-csf';
+	import { Toggle } from './index.js';
+
+	const { Story } = defineMeta({
+		title: 'UI/Actions/Toggle',
+		component: Toggle,
+		tags: ['autodocs'],
+	});
+</script>
+
+<Story name="Default">
+	<Toggle aria-label="Wyróżniony artykuł">
+		<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"/></svg>
+	</Toggle>
+</Story>
+
+<Story name="Pressed">
+	<Toggle pressed aria-label="Wyróżniony artykuł">
+		<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><polygon points="12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2"/></svg>
+	</Toggle>
+</Story>

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

@@ -0,0 +1,27 @@
+export default Toggle;
+type Toggle = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const Toggle: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+import { Toggle } 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/components/ui/toggle-group/toggle-group.stories.svelte

@@ -0,0 +1,17 @@
+<script module>
+	import { defineMeta } from '@storybook/addon-svelte-csf';
+	import { ToggleGroup, ToggleGroupItem } from './index.js';
+
+	const { Story } = defineMeta({
+		title: 'UI/Actions/ToggleGroup',
+		component: ToggleGroup,
+		tags: ['autodocs'],
+	});
+</script>
+
+<Story name="Language Toggle">
+	<ToggleGroup type="single" value="pl">
+		<ToggleGroupItem value="pl" style="font-weight:600;font-size:12px;">PL</ToggleGroupItem>
+		<ToggleGroupItem value="en" style="font-weight:600;font-size:12px;">EN</ToggleGroupItem>
+	</ToggleGroup>
+</Story>

package/dist/components/ui/toggle-group/toggle-group.stories.svelte.d.ts

@@ -0,0 +1,27 @@
+export default ToggleGroup;
+type ToggleGroup = SvelteComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}> & {
+    $$bindings?: string | undefined;
+};
+declare const ToggleGroup: $$__sveltets_2_IsomorphicComponent<{
+    [x: string]: never;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+import { ToggleGroup } 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/components/ui/tooltip/tooltip.stories.svelte

@@ -0,0 +1,26 @@
+<script module>
+	import { defineMeta } from '@storybook/addon-svelte-csf';
+	import { Tooltip, TooltipContent, TooltipTrigger, TooltipProvider } from './index.js';
+	import { Button } from '../button/index.js';
+
+	const { Story } = defineMeta({
+		title: 'UI/Feedback/Tooltip',
+		component: Tooltip,
+		tags: ['autodocs'],
+	});
+</script>
+
+<Story name="Plum Tooltip">
+	<TooltipProvider>
+		<Tooltip>
+			<TooltipTrigger>
+				<Button variant="ghost" size="icon">
+					<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+				</Button>
+			</TooltipTrigger>
+			<TooltipContent>
+				<p>Historia</p>
+			</TooltipContent>
+		</Tooltip>
+	</TooltipProvider>
+</Story>

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;