@caelo-cms/shared 0.10.71 → 0.11.0

package/dist/lists/list-type.d.ts

@@ -0,0 +1,401 @@
+/**
+ * List types — the definition part of a list (epic #1107,
+ * `docs/lists.md` §3). A list type names the entry kinds (`nodes`), the
+ * fields each carries, what may hang under what, and which nodes are
+ * filled from a source instead of stored children. Every form of list
+ * is expressed with it: a flat link group, a three-level menu, a mega
+ * dropdown with columns, teasers and a "latest news" block, an unbounded
+ * category tree.
+ */
+import { z } from "zod";
+import { type ListIssue } from "./fields.js";
+/** Hard ceiling for any tree, recursive or not. */
+export declare const LIST_MAX_DEPTH = 8;
+/** Entries per list (all levels together). */
+export declare const LIST_MAX_ITEMS = 500;
+/** Entries one query may return. */
+export declare const LIST_QUERY_MAX_LIMIT = 50;
+export declare const QUERY_KNOBS: readonly ["page_type", "terms", "terms_mode", "parent", "exclude_current", "order", "limit"];
+export type QueryKnob = (typeof QUERY_KNOBS)[number];
+export declare const SYSTEM_SOURCE_NAMES: readonly ["breadcrumbs", "children", "siblings", "page_terms", "term_pages"];
+export type SystemSourceName = (typeof SYSTEM_SOURCE_NAMES)[number];
+/** A query over pages. Resolved at render time; nothing is stored. */
+export declare const pageQuerySchema: z.ZodObject<{
+    page_type: z.ZodOptional<z.ZodString>;
+    terms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    terms_mode: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>>;
+    parent: z.ZodOptional<z.ZodString>;
+    exclude_current: z.ZodOptional<z.ZodBoolean>;
+    order: z.ZodUnion<readonly [z.ZodEnum<{
+        published_desc: "published_desc";
+        published_asc: "published_asc";
+        title_asc: "title_asc";
+    }>, z.ZodString]>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+export type PageQuery = z.infer<typeof pageQuerySchema>;
+/** Partial query: defaults on a node, or the knobs an entry overrides. */
+export declare const pageQueryPartialSchema: z.ZodObject<{
+    page_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    terms: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    terms_mode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>>>;
+    parent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    exclude_current: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    order: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        published_desc: "published_desc";
+        published_asc: "published_asc";
+        title_asc: "title_asc";
+    }>, z.ZodString]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const sourceDefSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"query">;
+    editable: z.ZodArray<z.ZodEnum<{
+        page_type: "page_type";
+        terms: "terms";
+        terms_mode: "terms_mode";
+        parent: "parent";
+        exclude_current: "exclude_current";
+        order: "order";
+        limit: "limit";
+    }>>;
+    defaults: z.ZodObject<{
+        page_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        terms: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        terms_mode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            any: "any";
+            all: "all";
+        }>>>;
+        parent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        exclude_current: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        order: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            published_desc: "published_desc";
+            published_asc: "published_asc";
+            title_asc: "title_asc";
+        }>, z.ZodString]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"system">;
+    name: z.ZodEnum<{
+        breadcrumbs: "breadcrumbs";
+        children: "children";
+        siblings: "siblings";
+        page_terms: "page_terms";
+        term_pages: "term_pages";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"plugin">;
+    name: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type SourceDef = z.infer<typeof sourceDefSchema>;
+export declare const nodeDefSchema: z.ZodObject<{
+    label: z.ZodString;
+    fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"richtext">;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"link">;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"media">;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"select">;
+        options: z.ZodArray<z.ZodString>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"boolean">;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"number">;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"date">;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"icon">;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"module">;
+        accepts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"term">;
+        list: z.ZodString;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodString;
+        label: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>], "type">>;
+    children: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        allow: z.ZodArray<z.ZodString>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    current_from: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"query">;
+        editable: z.ZodArray<z.ZodEnum<{
+            page_type: "page_type";
+            terms: "terms";
+            terms_mode: "terms_mode";
+            parent: "parent";
+            exclude_current: "exclude_current";
+            order: "order";
+            limit: "limit";
+        }>>;
+        defaults: z.ZodObject<{
+            page_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            terms: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            terms_mode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                any: "any";
+                all: "all";
+            }>>>;
+            parent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            exclude_current: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            order: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                published_desc: "published_desc";
+                published_asc: "published_asc";
+                title_asc: "title_asc";
+            }>, z.ZodString]>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"system">;
+        name: z.ZodEnum<{
+            breadcrumbs: "breadcrumbs";
+            children: "children";
+            siblings: "siblings";
+            page_terms: "page_terms";
+            term_pages: "term_pages";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"plugin">;
+        name: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type NodeDef = z.infer<typeof nodeDefSchema>;
+export declare const LIST_TYPE_ROLES: readonly ["navigation", "vocabulary", "content"];
+export type ListTypeRole = (typeof LIST_TYPE_ROLES)[number];
+export declare const listTypeDefSchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    purpose: z.ZodString;
+    role: z.ZodEnum<{
+        navigation: "navigation";
+        vocabulary: "vocabulary";
+        content: "content";
+    }>;
+    root: z.ZodObject<{
+        allow: z.ZodArray<z.ZodString>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        fields: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"richtext">;
+            maxLength: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"link">;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"media">;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"select">;
+            options: z.ZodArray<z.ZodString>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"boolean">;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"number">;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"date">;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"icon">;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"module">;
+            accepts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"term">;
+            list: z.ZodString;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            name: z.ZodString;
+            label: z.ZodString;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>], "type">>;
+        children: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            allow: z.ZodArray<z.ZodString>;
+            max: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        current_from: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"query">;
+            editable: z.ZodArray<z.ZodEnum<{
+                page_type: "page_type";
+                terms: "terms";
+                terms_mode: "terms_mode";
+                parent: "parent";
+                exclude_current: "exclude_current";
+                order: "order";
+                limit: "limit";
+            }>>;
+            defaults: z.ZodObject<{
+                page_type: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                terms: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+                terms_mode: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                    any: "any";
+                    all: "all";
+                }>>>;
+                parent: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                exclude_current: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                order: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    published_desc: "published_desc";
+                    published_asc: "published_asc";
+                    title_asc: "title_asc";
+                }>, z.ZodString]>>;
+                limit: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"system">;
+            name: z.ZodEnum<{
+                breadcrumbs: "breadcrumbs";
+                children: "children";
+                siblings: "siblings";
+                page_terms: "page_terms";
+                term_pages: "term_pages";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"plugin">;
+            name: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        ext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    max_depth: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ListTypeDef = z.infer<typeof listTypeDefSchema>;
+/**
+ * Static checks Zod cannot express. Returns every issue found so the AI
+ * fixes a definition in one round instead of one error per call.
+ */
+export declare function checkListTypeDef(def: ListTypeDef): ListIssue[];
+/** True when some node kind can (transitively) contain itself. */
+export declare function hasRecursion(def: ListTypeDef): boolean;
+/**
+ * Effective depth limit of a type: `max_depth` when set, else the
+ * longest non-recursive path (bounded by {@link LIST_MAX_DEPTH}).
+ */
+export declare function effectiveMaxDepth(def: ListTypeDef): number;
+//# sourceMappingURL=list-type.d.ts.map

package/dist/lists/list-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-type.d.ts","sourceRoot":"","sources":["../../src/lists/list-type.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAML,KAAK,SAAS,EAEf,MAAM,aAAa,CAAC;AAErB,mDAAmD;AACnD,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,8CAA8C;AAC9C,eAAO,MAAM,cAAc,MAAM,CAAC;AAClC,oCAAoC;AACpC,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAEvC,eAAO,MAAM,WAAW,8FAQd,CAAC;AACX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAErD,eAAO,MAAM,mBAAmB,8EAMtB,CAAC;AACX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAOpE,sEAAsE;AACtE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;kBAmBjB,CAAC;AACZ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,0EAA0E;AAC1E,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;kBAA4B,CAAC;AAEhE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA2B1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAWxD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWf,CAAC;AACZ,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,eAAe,kDAAmD,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAenB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,EAAE,CA8G9D;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAetD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,CAY1D"}

package/dist/lists/list-type.js

@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: MPL-2.0
+/**
+ * List types — the definition part of a list (epic #1107,
+ * `docs/lists.md` §3). A list type names the entry kinds (`nodes`), the
+ * fields each carries, what may hang under what, and which nodes are
+ * filled from a source instead of stored children. Every form of list
+ * is expressed with it: a flat link group, a three-level menu, a mega
+ * dropdown with columns, teasers and a "latest news" block, an unbounded
+ * category tree.
+ */
+import { z } from "zod";
+import { checkFieldDef, fieldDefSchema, fieldExtSchema, isReservedListName, listNameSchema, } from "./fields.js";
+/** Hard ceiling for any tree, recursive or not. */
+export const LIST_MAX_DEPTH = 8;
+/** Entries per list (all levels together). */
+export const LIST_MAX_ITEMS = 500;
+/** Entries one query may return. */
+export const LIST_QUERY_MAX_LIMIT = 50;
+export const QUERY_KNOBS = [
+    "page_type",
+    "terms",
+    "terms_mode",
+    "parent",
+    "exclude_current",
+    "order",
+    "limit",
+];
+export const SYSTEM_SOURCE_NAMES = [
+    "breadcrumbs",
+    "children",
+    "siblings",
+    "page_terms",
+    "term_pages",
+];
+const queryOrderSchema = z.union([
+    z.enum(["published_desc", "published_asc", "title_asc"]),
+    z.string().regex(/^prop_(?:desc|asc):[a-z][a-z0-9_]{0,63}$/),
+]);
+/** A query over pages. Resolved at render time; nothing is stored. */
+export const pageQuerySchema = z
+    .object({
+    page_type: z
+        .string()
+        .regex(/^[a-z0-9-]+$/)
+        .optional(),
+    terms: z
+        .array(z.string().regex(/^caelo:term\/[0-9a-f-]{36}\/[0-9a-f-]{36}$/))
+        .max(20)
+        .optional(),
+    terms_mode: z.enum(["any", "all"]).optional(),
+    parent: z
+        .string()
+        .regex(/^caelo:page\/[0-9a-f-]{36}$/)
+        .optional(),
+    exclude_current: z.boolean().optional(),
+    order: queryOrderSchema,
+    limit: z.number().int().min(1).max(LIST_QUERY_MAX_LIMIT),
+})
+    .strict();
+/** Partial query: defaults on a node, or the knobs an entry overrides. */
+export const pageQueryPartialSchema = pageQuerySchema.partial();
+export const sourceDefSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("query"),
+        /** Which query parts an editor (or the AI) may set per entry/placement. */
+        editable: z.array(z.enum(QUERY_KNOBS)).max(QUERY_KNOBS.length),
+        defaults: pageQueryPartialSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("system"),
+        // The AI reached for {kind:"system", name:"consent_categories"} in the
+        // PR #1121 e2e run: name the plugin form in the refusal itself.
+        name: z.enum(SYSTEM_SOURCE_NAMES, {
+            error: () => `system sources are ${SYSTEM_SOURCE_NAMES.join(", ")} — a plugin's list source (consent_categories, language_links, …) is {kind:"plugin", name:"<source>"}, and a module that only iterates it needs no field at all: {{#<source>}}…{{/<source>}}.`,
+        }),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("plugin"),
+        /** The list-source name an active plugin declared. */
+        name: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
+    })
+        .strict(),
+]);
+const childrenSchema = z
+    .object({
+    /** Loop name in templates (`{{#columns}}`). Storage always uses `children`. */
+    name: listNameSchema,
+    allow: z.array(listNameSchema).min(1).max(32),
+    max: z.number().int().min(1).max(LIST_MAX_ITEMS).optional(),
+})
+    .strict();
+export const nodeDefSchema = z
+    .object({
+    label: z.string().min(1).max(128),
+    fields: z.array(fieldDefSchema).max(32),
+    children: childrenSchema.optional(),
+    /** Link field that decides `is_current` / `is_ancestor`. */
+    current_from: listNameSchema.optional(),
+    /** Generated children (`items`) instead of stored ones. */
+    source: sourceDefSchema.optional(),
+    ext: fieldExtSchema.optional(),
+})
+    .strict();
+export const LIST_TYPE_ROLES = ["navigation", "vocabulary", "content"];
+export const listTypeDefSchema = z
+    .object({
+    slug: z.string().regex(/^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/),
+    name: z.string().min(1).max(200),
+    purpose: z.string().min(1).max(1000),
+    role: z.enum(LIST_TYPE_ROLES),
+    root: z
+        .object({
+        allow: z.array(listNameSchema).min(1).max(32),
+        max: z.number().int().min(1).max(LIST_MAX_ITEMS).optional(),
+    })
+        .strict(),
+    nodes: z.record(listNameSchema, nodeDefSchema),
+    max_depth: z.number().int().min(1).max(LIST_MAX_DEPTH).optional(),
+})
+    .strict();
+/**
+ * Static checks Zod cannot express. Returns every issue found so the AI
+ * fixes a definition in one round instead of one error per call.
+ */
+export function checkListTypeDef(def) {
+    const issues = [];
+    const kinds = new Set(Object.keys(def.nodes));
+    if (kinds.size === 0) {
+        issues.push({ path: "nodes", message: "a list type needs at least one node kind." });
+    }
+    const checkAllow = (allow, path) => {
+        for (const k of allow) {
+            if (!kinds.has(k)) {
+                issues.push({
+                    path,
+                    message: `node kind "${k}" is not defined — add it under nodes or remove it from allow.`,
+                });
+            }
+        }
+    };
+    checkAllow(def.root.allow, "root.allow");
+    for (const [kind, node] of Object.entries(def.nodes)) {
+        const at = `nodes.${kind}`;
+        if (isReservedListName(kind)) {
+            issues.push({ path: at, message: `node kind "${kind}" is a reserved name — rename it.` });
+        }
+        const seen = new Set();
+        node.fields.forEach((f, i) => {
+            const fp = `${at}.fields[${i}]`;
+            if (seen.has(f.name))
+                issues.push({ path: fp, message: `duplicate field name "${f.name}".` });
+            seen.add(f.name);
+            issues.push(...checkFieldDef(f, fp));
+        });
+        if (node.children) {
+            if (isReservedListName(node.children.name)) {
+                issues.push({
+                    path: `${at}.children.name`,
+                    message: `children name "${node.children.name}" is reserved — pick another loop name.`,
+                });
+            }
+            if (seen.has(node.children.name)) {
+                issues.push({
+                    path: `${at}.children.name`,
+                    message: `children name "${node.children.name}" collides with a field of the same node.`,
+                });
+            }
+            checkAllow(node.children.allow, `${at}.children.allow`);
+        }
+        if (node.children && node.source) {
+            issues.push({
+                path: at,
+                message: "a node has either stored children or a source, not both — remove one.",
+            });
+        }
+        if (node.current_from !== undefined) {
+            const target = node.fields.find((f) => f.name === node.current_from);
+            if (target?.type !== "link") {
+                issues.push({
+                    path: `${at}.current_from`,
+                    message: `current_from must name a link field of this node ("${node.current_from}" is not one).`,
+                });
+            }
+        }
+        if (node.source?.kind === "query") {
+            const q = pageQueryPartialSchema.safeParse(node.source.defaults);
+            if (!q.success) {
+                issues.push({ path: `${at}.source.defaults`, message: "query defaults are invalid." });
+            }
+            else if (node.source.defaults.order === undefined &&
+                !node.source.editable.includes("order")) {
+                issues.push({
+                    path: `${at}.source`,
+                    message: 'a query source needs a default "order" or "order" in editable.',
+                });
+            }
+            else if (node.source.defaults.limit === undefined &&
+                !node.source.editable.includes("limit")) {
+                issues.push({
+                    path: `${at}.source`,
+                    message: 'a query source needs a default "limit" or "limit" in editable.',
+                });
+            }
+        }
+    }
+    if (hasRecursion(def) && def.max_depth === undefined) {
+        issues.push({
+            path: "max_depth",
+            message: "this type nests a node kind inside itself — set max_depth (1–8).",
+        });
+    }
+    if (def.role === "vocabulary") {
+        const rootKinds = def.root.allow;
+        for (const k of rootKinds) {
+            const node = def.nodes[k];
+            if (!node)
+                continue;
+            const hasText = (n) => node.fields.some((f) => f.name === n && f.type === "text");
+            if (!hasText("name") || !hasText("slug")) {
+                issues.push({
+                    path: `nodes.${k}`,
+                    message: 'vocabulary entries need a text field "name" and a text field "slug".',
+                });
+            }
+            if (node.source) {
+                issues.push({ path: `nodes.${k}`, message: "vocabulary entries cannot have a source." });
+            }
+        }
+    }
+    return issues;
+}
+/** True when some node kind can (transitively) contain itself. */
+export function hasRecursion(def) {
+    const edges = new Map();
+    for (const [k, n] of Object.entries(def.nodes))
+        edges.set(k, n.children?.allow ?? []);
+    const visiting = new Set();
+    const done = new Set();
+    const visit = (k) => {
+        if (visiting.has(k))
+            return true;
+        if (done.has(k))
+            return false;
+        visiting.add(k);
+        for (const c of edges.get(k) ?? [])
+            if (visit(c))
+                return true;
+        visiting.delete(k);
+        done.add(k);
+        return false;
+    };
+    return [...edges.keys()].some(visit);
+}
+/**
+ * Effective depth limit of a type: `max_depth` when set, else the
+ * longest non-recursive path (bounded by {@link LIST_MAX_DEPTH}).
+ */
+export function effectiveMaxDepth(def) {
+    if (def.max_depth !== undefined)
+        return def.max_depth;
+    const longest = (k, seen) => {
+        if (seen.has(k))
+            return LIST_MAX_DEPTH;
+        const next = new Set(seen).add(k);
+        const kids = def.nodes[k]?.children?.allow ?? [];
+        return 1 + kids.reduce((m, c) => Math.max(m, longest(c, next)), 0);
+    };
+    return Math.min(LIST_MAX_DEPTH, def.root.allow.reduce((m, k) => Math.max(m, longest(k, new Set())), 0));
+}
+//# sourceMappingURL=list-type.js.map