includio-cms 0.25.0 → 0.27.0

package/dist/admin/utils/entryLabel.js

@@ -1,18 +1,57 @@
 import { getAtPath } from './objectPath.js';
-export function getRawCollectionEntryLabel(entry, config, language) {
-    const publishedVersion = entry.publishedVersions[language];
-    if (publishedVersion) {
-        return config.entryAdminTitle
-            ? String(getAtPath(publishedVersion.data, config.entryAdminTitle) || entry.id)
-            : entry.id;
+/**
+ * Resolve the admin title for a raw collection entry.
+ *
+ * Prefers the requested `language` (published version, then draft). If that
+ * language has no usable title it falls back to any other language (published
+ * first, then draft). Returns the entry id as a last resort. `language` in the
+ * result tells callers which translation was used — useful for a "(en)" hint
+ * when it differs from what was asked for.
+ */
+export function getRawCollectionEntryLabelWithLanguage(entry, config, language) {
+    const path = config.entryAdminTitle;
+    if (!path)
+        return { label: entry.id, language: null };
+    const titleOf = (version) => {
+        if (!version)
+            return null;
+        const value = getAtPath(version.data, path);
+        return value == null || value === '' ? null : String(value);
+    };
+    // 1. requested language — published, then draft
+    for (const bucket of [entry.publishedVersions, entry.draftVersions]) {
+        const title = titleOf(bucket?.[language]);
+        if (title)
+            return { label: title, language };
+    }
+    // 2. any other language — published first, then draft
+    for (const bucket of [entry.publishedVersions, entry.draftVersions]) {
+        for (const [lang, version] of Object.entries(bucket ?? {})) {
+            if (lang === language)
+                continue;
+            const title = titleOf(version);
+            if (title)
+                return { label: title, language: lang };
+        }
     }
-    const draftVersion = entry.draftVersions[language];
-    if (draftVersion) {
-        return config.entryAdminTitle
-            ? String(getAtPath(draftVersion.data, config.entryAdminTitle) || entry.id)
-            : entry.id;
+    return { label: entry.id, language: null };
+}
+export function getRawCollectionEntryLabel(entry, config, language) {
+    return getRawCollectionEntryLabelWithLanguage(entry, config, language).label;
+}
+/**
+ * Display label for a raw collection entry in the admin UI.
+ *
+ * Like {@link getRawCollectionEntryLabel} but, when no title could be resolved
+ * in any language, returns a localized "(untitled)" placeholder instead of the
+ * raw entry id — so the entries list and the edit breadcrumb stay in sync.
+ */
+export function getCollectionEntryDisplayLabel(entry, config, language) {
+    const { label, language: resolvedLanguage } = getRawCollectionEntryLabelWithLanguage(entry, config, language);
+    if (resolvedLanguage === null) {
+        return language === 'pl' ? '(bez tytułu)' : '(untitled)';
     }
-    return entry.id;
+    return label;
 }
 export function getCollectionEntryLabel(entry, config) {
     return config.entryAdminTitle

package/dist/admin/utils/field-a11y.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Wejście dla `getFieldA11yProps`.
+ */
+export type FieldA11yInput = {
+    /** Bazowe ID kontrolki — używane do generowania `{id}-description` / `{id}-error`. */
+    id: string;
+    hasDescription?: boolean;
+    hasError?: boolean;
+    required?: boolean;
+};
+/**
+ * ARIA atrybuty dla kontrolki formularza wpinanej w `Form.Field` (formsnap)
+ * lub równoważny wrapper. Zwracany kształt jest gotowy do spread'u na `<input>`.
+ */
+export type FieldA11yProps = {
+    'aria-describedby'?: string;
+    'aria-invalid'?: 'true';
+    'aria-required'?: 'true';
+};
+/**
+ * Buduje atrybuty ARIA dla kontrolki — łączy ID-y description/error w `aria-describedby`,
+ * ustawia `aria-invalid` przy błędach, `aria-required` przy required.
+ *
+ * Powstał jako bridge między `ui/form` (formsnap-based, 8 superForm konsumentów)
+ * a wzorcem auto-aria z `ui/field` — bez breaking migracji (S3 koegzystencja).
+ *
+ * @public
+ */
+export declare function getFieldA11yProps(o: FieldA11yInput): FieldA11yProps;

package/dist/admin/utils/field-a11y.js

@@ -0,0 +1,23 @@
+/**
+ * Buduje atrybuty ARIA dla kontrolki — łączy ID-y description/error w `aria-describedby`,
+ * ustawia `aria-invalid` przy błędach, `aria-required` przy required.
+ *
+ * Powstał jako bridge między `ui/form` (formsnap-based, 8 superForm konsumentów)
+ * a wzorcem auto-aria z `ui/field` — bez breaking migracji (S3 koegzystencja).
+ *
+ * @public
+ */
+export function getFieldA11yProps(o) {
+    const ids = [
+        o.hasDescription ? `${o.id}-description` : null,
+        o.hasError ? `${o.id}-error` : null
+    ].filter((v) => v !== null);
+    const out = {};
+    if (ids.length)
+        out['aria-describedby'] = ids.join(' ');
+    if (o.hasError)
+        out['aria-invalid'] = 'true';
+    if (o.required)
+        out['aria-required'] = 'true';
+    return out;
+}

package/dist/admin/utils/fieldPathElement.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves a (possibly nested) field path to its closest rendered element.
+ *
+ * Tries the full dotted `data-field-path` first, then trims trailing segments
+ * so a leaf field without its own marker still resolves to the nearest
+ * rendered ancestor (e.g. `highlights.0.title` → `highlights.0` → `highlights`).
+ * Returns `null` when no segment prefix is rendered.
+ */
+export declare function findFieldPathElement(fieldPath: string): HTMLElement | null;

package/dist/admin/utils/fieldPathElement.js

@@ -0,0 +1,18 @@
+/**
+ * Resolves a (possibly nested) field path to its closest rendered element.
+ *
+ * Tries the full dotted `data-field-path` first, then trims trailing segments
+ * so a leaf field without its own marker still resolves to the nearest
+ * rendered ancestor (e.g. `highlights.0.title` → `highlights.0` → `highlights`).
+ * Returns `null` when no segment prefix is rendered.
+ */
+export function findFieldPathElement(fieldPath) {
+    const segments = fieldPath.split('.');
+    for (let end = segments.length; end > 0; end--) {
+        const candidate = segments.slice(0, end).join('.');
+        const el = document.querySelector(`[data-field-path="${candidate}"]`);
+        if (el instanceof HTMLElement)
+            return el;
+    }
+    return null;
+}

package/dist/admin/utils/fileDisplay.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Human-readable file size: "0 B" / "12 B" / "3 KB" / "1.42 MB".
+ * Bytes shown as integer; KB+ with 2 decimal places.
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Extract file extension from a URL (uppercased, no dot). Returns '' if missing or ambiguous.
+ * Examples: 'foo/bar.txt' -> 'TXT', 'image.JPEG' -> 'JPEG', 'no-ext' -> ''.
+ */
+export declare function getFileExtension(url: string | null | undefined): string;

package/dist/admin/utils/fileDisplay.js

@@ -0,0 +1,26 @@
+/**
+ * Human-readable file size: "0 B" / "12 B" / "3 KB" / "1.42 MB".
+ * Bytes shown as integer; KB+ with 2 decimal places.
+ */
+export function formatFileSize(bytes) {
+    if (!bytes || bytes <= 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const k = 1024;
+    const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(k)));
+    const size = bytes / Math.pow(k, i);
+    return `${size.toFixed(i > 0 ? 2 : 0)} ${units[i]}`;
+}
+/**
+ * Extract file extension from a URL (uppercased, no dot). Returns '' if missing or ambiguous.
+ * Examples: 'foo/bar.txt' -> 'TXT', 'image.JPEG' -> 'JPEG', 'no-ext' -> ''.
+ */
+export function getFileExtension(url) {
+    if (!url)
+        return '';
+    const fileName = url.split('/').pop() ?? '';
+    const dot = fileName.lastIndexOf('.');
+    if (dot <= 0 || dot === fileName.length - 1)
+        return '';
+    return fileName.slice(dot + 1).toUpperCase();
+}

package/dist/admin/utils/flattenFormErrors.d.ts

@@ -0,0 +1,19 @@
+import type { Field } from '../../types/fields.js';
+import type { InterfaceLanguage } from '../../types/languages.js';
+import type { FormErrorEntry } from '../components/forms/form-error-summary.svelte';
+/** Recursive validation-error tree (superforms `ValidationErrors` shape). */
+type ErrorTree = Record<string, unknown>;
+/**
+ * Flattens a nested superforms validation-error tree into a human-readable
+ * list for the error summary.
+ *
+ * Resolves localized field labels (never raw slugs), turns array/blocks item
+ * indices into `Element N` / `Item N` (1-based), descends into `object` /
+ * `blocks` / `array` fields, and surfaces container-level `_errors` (e.g. a
+ * `blocks` minItems constraint) so the user sees everything blocking the save.
+ *
+ * `data` is the parallel form data — required to resolve which block variant a
+ * `blocks` item index is (via its `_slug` discriminator).
+ */
+export declare function flattenFormErrors(errors: ErrorTree, fields: Field[], data: unknown, lang: InterfaceLanguage, prefix?: string, labelPrefix?: string): FormErrorEntry[];
+export {};

package/dist/admin/utils/flattenFormErrors.js

@@ -0,0 +1,102 @@
+import { getLocalizedLabel } from './collectionLabel.js';
+/** 1-based item label for array/blocks indices. */
+const indexWord = { pl: 'Element', en: 'Item' };
+/** Label for root-level (`_errors`) form errors. */
+const formWord = { pl: 'Formularz', en: 'Form' };
+function joinLabel(prefix, label) {
+    return prefix ? `${prefix} › ${label}` : label;
+}
+/**
+ * Flattens a nested superforms validation-error tree into a human-readable
+ * list for the error summary.
+ *
+ * Resolves localized field labels (never raw slugs), turns array/blocks item
+ * indices into `Element N` / `Item N` (1-based), descends into `object` /
+ * `blocks` / `array` fields, and surfaces container-level `_errors` (e.g. a
+ * `blocks` minItems constraint) so the user sees everything blocking the save.
+ *
+ * `data` is the parallel form data — required to resolve which block variant a
+ * `blocks` item index is (via its `_slug` discriminator).
+ */
+export function flattenFormErrors(errors, fields, data, lang, prefix = '', labelPrefix = '') {
+    const result = [];
+    for (const [key, value] of Object.entries(errors)) {
+        if (key === '_errors') {
+            // Container-level errors for this node itself (e.g. blocks minItems).
+            if (Array.isArray(value)) {
+                const label = labelPrefix || formWord[lang];
+                for (const message of value) {
+                    result.push({ path: prefix, label, message: String(message) });
+                }
+            }
+            continue;
+        }
+        const field = fields.find((f) => f.slug === key);
+        const path = prefix ? `${prefix}.${key}` : key;
+        const baseLabel = field ? getLocalizedLabel(field.label, lang) || field.slug : key;
+        const fullLabel = joinLabel(labelPrefix, baseLabel);
+        const fieldData = data && typeof data === 'object' && !Array.isArray(data)
+            ? data[key]
+            : undefined;
+        if (Array.isArray(value)) {
+            for (const message of value) {
+                result.push({ path, label: fullLabel, message: String(message) });
+            }
+            continue;
+        }
+        if (!value || typeof value !== 'object')
+            continue;
+        const childErrors = value;
+        if (field?.type === 'object') {
+            result.push(...flattenFormErrors(childErrors, field.fields, fieldData, lang, path, fullLabel));
+        }
+        else if (field?.type === 'blocks' || field?.type === 'array') {
+            result.push(...flattenItemErrors(childErrors, field, fieldData, lang, path, fullLabel));
+        }
+        else {
+            // Unknown / untyped nested object — recurse without field context.
+            result.push(...flattenFormErrors(childErrors, [], fieldData, lang, path, fullLabel));
+        }
+    }
+    return result;
+}
+/**
+ * Handles the index-keyed level of `blocks` / `array` errors: each numeric key
+ * becomes `Element N` / `Item N`, and for `blocks` the item's `_slug` selects
+ * the block variant whose `fields` resolve the nested labels.
+ */
+function flattenItemErrors(errors, field, data, lang, prefix, labelPrefix) {
+    const result = [];
+    for (const [key, value] of Object.entries(errors)) {
+        if (key === '_errors') {
+            if (Array.isArray(value)) {
+                for (const message of value) {
+                    result.push({ path: prefix, label: labelPrefix, message: String(message) });
+                }
+            }
+            continue;
+        }
+        const index = Number(key);
+        const itemPath = `${prefix}.${key}`;
+        const itemLabel = joinLabel(labelPrefix, `${indexWord[lang]} ${(Number.isNaN(index) ? 0 : index) + 1}`);
+        const itemData = Array.isArray(data) ? data[index] : undefined;
+        if (Array.isArray(value)) {
+            for (const message of value) {
+                result.push({ path: itemPath, label: itemLabel, message: String(message) });
+            }
+            continue;
+        }
+        if (!value || typeof value !== 'object')
+            continue;
+        const childErrors = value;
+        if (field.type === 'blocks') {
+            const slug = itemData?._slug;
+            const variant = field.of.find((def) => def.slug === slug);
+            result.push(...flattenFormErrors(childErrors, variant?.fields ?? [], itemData, lang, itemPath, itemLabel));
+        }
+        else {
+            result.push(...flattenFormErrors(childErrors, [], itemData, lang, itemPath, itemLabel));
+        }
+    }
+    return result;
+}

package/dist/admin/utils/formatters.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared admin formatters (date + price).
+ *
+ * @internal
+ */
+import type { InterfaceLanguage } from '../../types/languages.js';
+export declare function toLocaleCode(lang: string): string;
+export declare function formatRelativeDate(date: Date | string, lang?: InterfaceLanguage): string;
+export declare function formatShortDateOnly(date: Date | string | null, lang?: InterfaceLanguage): string;
+export declare function formatDateTime(date: Date | string, lang?: InterfaceLanguage): string;
+export declare function formatPlnPrice(pln: number): string;
+export declare function formatCentsPrice(cents: number, currency: string): string;

package/dist/admin/utils/{formatDate.js → formatters.js}

@@ -1,3 +1,8 @@
+/**
+ * Shared admin formatters (date + price).
+ *
+ * @internal
+ */
 export function toLocaleCode(lang) {
     const map = { pl: 'pl-PL', en: 'en-US' };
     return map[lang] ?? lang;
@@ -86,7 +91,9 @@ export function formatRelativeDate(date, lang = 'en') {
     }
     return labels[lang].justNow;
 }
-export function formatShortDate(date, lang = 'en') {
+export function formatShortDateOnly(date, lang = 'en') {
+    if (date === null)
+        return '';
     const d = typeof date === 'string' ? new Date(date) : date;
     return d.toLocaleDateString(toLocaleCode(lang), {
         year: 'numeric',
@@ -94,7 +101,7 @@ export function formatShortDate(date, lang = 'en') {
         day: 'numeric'
     });
 }
-export function formatAbsoluteDate(date, lang = 'en') {
+export function formatDateTime(date, lang = 'en') {
     const d = typeof date === 'string' ? new Date(date) : date;
     return d.toLocaleString(toLocaleCode(lang), {
         year: 'numeric',
@@ -104,3 +111,17 @@ export function formatAbsoluteDate(date, lang = 'en') {
         minute: '2-digit'
     });
 }
+export function formatPlnPrice(pln) {
+    return new Intl.NumberFormat('pl-PL', {
+        style: 'currency',
+        currency: 'PLN'
+    }).format(pln);
+}
+export function formatCentsPrice(cents, currency) {
+    const upper = currency.toUpperCase();
+    const locale = upper === 'PLN' ? 'pl-PL' : upper === 'EUR' ? 'de-DE' : 'en-US';
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency: upper
+    }).format(cents / 100);
+}

package/dist/admin/utils/scrollWithin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Scroll `target` into view within its nearest scrollable ancestor only — it
+ * does NOT bubble the scroll up to the page/document. Use this instead of
+ * `Element.scrollIntoView()` inside fixed-height panes (the entry editor, sheets)
+ * where a recursive scroll would push fixed headers out of view.
+ *
+ * @internal
+ */
+export declare function scrollIntoViewWithin(target: HTMLElement, block?: 'center' | 'nearest'): void;

package/dist/admin/utils/scrollWithin.js

@@ -0,0 +1,32 @@
+/**
+ * Scroll `target` into view within its nearest scrollable ancestor only — it
+ * does NOT bubble the scroll up to the page/document. Use this instead of
+ * `Element.scrollIntoView()` inside fixed-height panes (the entry editor, sheets)
+ * where a recursive scroll would push fixed headers out of view.
+ *
+ * @internal
+ */
+export function scrollIntoViewWithin(target, block = 'center') {
+    if (typeof getComputedStyle !== 'function')
+        return;
+    let scroller = target.parentElement;
+    while (scroller && scroller !== document.body && scroller !== document.documentElement) {
+        const overflowY = getComputedStyle(scroller).overflowY;
+        const scrollable = overflowY === 'auto' || overflowY === 'scroll' || overflowY === 'overlay';
+        if (scrollable && scroller.scrollHeight > scroller.clientHeight + 1)
+            break;
+        scroller = scroller.parentElement;
+    }
+    if (!scroller || scroller === document.body || scroller === document.documentElement) {
+        // No contained scroll parent — use the gentlest possible scroll.
+        target.scrollIntoView?.({ behavior: 'smooth', block: 'nearest' });
+        return;
+    }
+    const scrollerRect = scroller.getBoundingClientRect();
+    const targetRect = target.getBoundingClientRect();
+    const targetTopWithinScroller = scroller.scrollTop + (targetRect.top - scrollerRect.top);
+    const next = block === 'center'
+        ? targetTopWithinScroller - scroller.clientHeight / 2 + targetRect.height / 2
+        : targetTopWithinScroller;
+    scroller.scrollTo({ top: Math.max(0, next), behavior: 'smooth' });
+}

package/dist/admin/utils/tabActivation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Activate every tab panel that contains `el`, so a field on an inactive tab
+ * becomes visible before it is scrolled to / focused.
+ *
+ * DOM-driven (mirrors the accordion-open behaviour in entry-form): tab panels
+ * stay mounted in the DOM (the renderer uses bits-ui `forceMount`), so we can
+ * walk up from the target element, find each inactive ancestor panel and click
+ * its matching trigger. Works for nested layouts even though `tabs`/`tab` may
+ * not nest each other — a tab panel can still sit inside another tab via
+ * section/card/columns wrappers, so we climb the full ancestor chain.
+ */
+export declare function activateContainingTabs(el: HTMLElement): void;

package/dist/admin/utils/tabActivation.js

@@ -0,0 +1,24 @@
+/**
+ * Activate every tab panel that contains `el`, so a field on an inactive tab
+ * becomes visible before it is scrolled to / focused.
+ *
+ * DOM-driven (mirrors the accordion-open behaviour in entry-form): tab panels
+ * stay mounted in the DOM (the renderer uses bits-ui `forceMount`), so we can
+ * walk up from the target element, find each inactive ancestor panel and click
+ * its matching trigger. Works for nested layouts even though `tabs`/`tab` may
+ * not nest each other — a tab panel can still sit inside another tab via
+ * section/card/columns wrappers, so we climb the full ancestor chain.
+ */
+export function activateContainingTabs(el) {
+    let panel = el.closest('[data-slot="tabs-content"]');
+    while (panel) {
+        const inactive = panel.hasAttribute('hidden') || panel.getAttribute('data-state') === 'inactive';
+        if (inactive) {
+            const value = panel.getAttribute('data-tab-value');
+            const group = panel.getAttribute('data-tabs-group');
+            const trigger = document.querySelector(`[data-slot="tabs-trigger"][data-tab-value="${value}"][data-tabs-group="${group}"]`);
+            trigger?.click();
+        }
+        panel = panel.parentElement?.closest('[data-slot="tabs-content"]') ?? null;
+    }
+}

package/dist/cli/scaffold/admin.js

@@ -329,7 +329,7 @@ export const { POST } = createRetryPaymentHandler();
         {
             path: 'admin/api/[...path]/+server.ts',
             content: `${GENERATED_COMMENT_TS}
-import { createAdminApiHandler } from 'includio-cms/admin/api/handler';
+import { createAdminApiHandler } from 'includio-cms/sveltekit/server';
 
 export const { GET, POST, PATCH, PUT, DELETE } = createAdminApiHandler();
 `
@@ -337,7 +337,7 @@ export const { GET, POST, PATCH, PUT, DELETE } = createAdminApiHandler();
         {
             path: 'admin/api/rest/[...restPath]/+server.ts',
             content: `${GENERATED_COMMENT_TS}
-import { createRestApiHandler } from 'includio-cms/admin/api/rest/handler';
+import { createRestApiHandler } from 'includio-cms/sveltekit/server';
 
 export const { GET, POST, PUT, DELETE } = createRestApiHandler();
 `

package/dist/cms/runtime/schema.d.ts

@@ -1,2 +1,3 @@
 export * from 'includio-cms/db-postgres/schema-core';
 export * from 'includio-cms/auth-schema';
+export * from 'includio-cms/db-postgres/schema-shop';

package/dist/cms/runtime/schema.js

@@ -2,3 +2,4 @@
 // Point your drizzle.config.ts schema field at this file.
 export * from 'includio-cms/db-postgres/schema-core';
 export * from 'includio-cms/auth-schema';
+export * from 'includio-cms/db-postgres/schema-shop';

package/dist/cms/runtime/types.d.ts

@@ -1,4 +1,4 @@
-import type { ImageFieldData, VideoFieldData, StructuredContentDoc } from 'includio-cms/types';
+import type { MediaFile, ImageFieldData, VideoFieldData, StructuredContentDoc } from 'includio-cms/types';
 export type SingleSlug = "settings" | "image-showcase";
 export interface Settings {
     _id: string;
@@ -11,7 +11,7 @@ export interface Settings {
     logo?: ImageFieldData | VideoFieldData | null;
     favicon?: ImageFieldData | VideoFieldData | null;
     socialLinks?: ({
-        _slug: 'socialLink';
+        _slug: 'social-link';
         platform: string;
         url: {
             url: string;
@@ -33,7 +33,7 @@ export type SingleEntryMap = {
     settings: Settings;
     'image-showcase': ImageShowcase;
 };
-export type CollectionSlug = "blog-post" | "project" | "array-test";
+export type CollectionSlug = "blog-post" | "project" | "product" | "array-test";
 export interface BlogPost {
     _id: string;
     _slug: string;
@@ -42,9 +42,11 @@ export interface BlogPost {
     _url?: string;
     title: string;
     slug?: string;
+    featured?: boolean;
     cover?: ImageFieldData | VideoFieldData | null;
     rating: number;
     category: 'technology' | 'design' | 'business' | 'tutorial';
+    difficulty?: 'beginner' | 'intermediate' | 'advanced';
     publishedAt?: string;
     thumbnail?: ImageFieldData | VideoFieldData | null;
     content?: StructuredContentDoc;
@@ -58,10 +60,6 @@ export interface BlogPost {
         keywords?: string;
         customCode?: string;
     };
-    test?: ({
-        _slug: 'test-object';
-        dupa: string;
-    })[];
 }
 export interface Project {
     _id: string;
@@ -91,6 +89,41 @@ export interface Project {
         customCode?: string;
     };
 }
+export interface Product {
+    _id: string;
+    _slug: string;
+    _type: string;
+    _publishedAt: Date | null;
+    _url?: string;
+    title: string;
+    slug?: string;
+    category: 'apparel' | 'accessory' | 'print' | 'digital';
+    cover: ImageFieldData | VideoFieldData;
+    gallery?: (ImageFieldData | VideoFieldData)[] | null;
+    description?: StructuredContentDoc;
+    shop?: {
+        basePrice: number;
+        vatRate: number;
+        isActive: boolean;
+        variants: Array<{
+            id: string;
+            sku: string | null;
+            name: Record<string, string> | null;
+            priceDelta: number;
+            stock: number | null;
+            attributes: Record<string, string> | null;
+        }>;
+    } | null;
+    seo: {
+        slug: string;
+        canonicalUrl?: string;
+        title: string;
+        description?: string;
+        ogImage?: string;
+        keywords?: string;
+        customCode?: string;
+    };
+}
 export interface ArrayTest {
     _id: string;
     _slug: string;
@@ -98,6 +131,45 @@ export interface ArrayTest {
     _publishedAt: Date | null;
     _url?: string;
     name: string;
+    constrainedText?: string;
+    plainUrl?: {
+        url: string;
+    };
+    urlWithText?: {
+        url: string;
+        text?: string;
+    };
+    urlWithNewTab?: {
+        url: string;
+        newTab?: boolean;
+    };
+    urlRequired: {
+        url: string;
+        text?: string;
+        newTab?: boolean;
+    };
+    boundedNumber?: number;
+    eventAt?: string;
+    priority?: 'low' | 'medium' | 'high';
+    features?: ('comments' | 'sharing' | 'newsletter')[];
+    relatedProject?: Project;
+    relatedPosts?: BlogPost[];
+    attachment?: MediaFile | null;
+    attachments?: MediaFile[] | null;
+    attachmentList?: MediaFile | null;
+    attachmentsList?: MediaFile[] | null;
+    address?: {
+        _slug: 'address';
+        street: string;
+        city?: string;
+        country?: 'pl' | 'de' | 'us';
+        geo?: {
+            _slug: 'geo';
+            lat?: number;
+            lng?: number;
+        };
+    };
+    introVideo?: ImageFieldData | VideoFieldData | null;
     tags?: string[];
     localizedTags?: Record<string, string>[];
     scores?: number[];
@@ -121,6 +193,7 @@ export interface ArrayTest {
 export type CollectionEntryMap = {
     'blog-post': BlogPost;
     project: Project;
+    product: Product;
     'array-test': ArrayTest;
 };
 export type FormSlug = "contact";

package/dist/components/ui/accordion/accordion-content.svelte

@@ -8,15 +8,29 @@
 		children,
 		...restProps
 	}: WithoutChild<AccordionPrimitive.ContentProps> = $props();
+
+	// `forceMount` keeps the panel mounted while closed so form validation can
+	// reach fields inside a collapsed accordion. The one-shot `animate-accordion-*`
+	// keyframe reverts once it finishes, leaving a permanently-mounted panel
+	// visible — so for the forced case the collapse is driven by a
+	// `grid-template-rows` transition instead: it holds its end state, animates
+	// both ways, and never flashes on the initial render. Without `forceMount`
+	// bits-ui mounts/unmounts the panel and the keyframe path is correct, so it
+	// is left untouched.
+	const forced = $derived(restProps.forceMount === true);
 </script>
 
 <AccordionPrimitive.Content
 	bind:ref
 	data-slot="accordion-content"
-	class="data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down overflow-hidden text-sm"
+	class={forced
+		? "grid text-sm transition-[grid-template-rows] duration-200 ease-out data-[state=closed]:grid-rows-[0fr] data-[state=open]:grid-rows-[1fr]"
+		: "data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down overflow-hidden text-sm"}
 	{...restProps}
 >
-	<div class={cn("pb-4 pt-0", className)}>
-		{@render children?.()}
+	<div class={forced ? "min-h-0 overflow-hidden" : "contents"}>
+		<div class={cn("pb-4 pt-0", className)}>
+			{@render children?.()}
+		</div>
 	</div>
 </AccordionPrimitive.Content>