@webiny/website-builder-sdk 0.0.0-unstable.e6f0dc8ca7 → 0.0.0-unstable.eb81deee7e

package/contentEntry/resolveContentEntry.d.ts

@@ -0,0 +1,74 @@
+import type { ContentEntryReference, ContentEntryQueryValue } from "../types.js";
+/**
+ * Minimal CMS data loader the content-entry resolver depends on. Injected by the
+ * caller (the render layer passes the CMS `contentSdk`) so this module stays
+ * decoupled from `@webiny/cms-sdk`.
+ */
+export interface ContentEntryLoader {
+    getEntry(params: {
+        modelId: string;
+        entryId: string;
+    }): Promise<unknown | null>;
+    listEntries(params: {
+        modelId: string;
+        sort?: Record<string, "asc" | "desc">;
+        limit?: number;
+        search?: string;
+        after?: string;
+    }): Promise<{
+        data: unknown[];
+        meta: {
+            cursor: string | null;
+            hasMoreItems: boolean;
+            totalCount: number;
+        };
+    }>;
+}
+/**
+ * The query params used to produce a page. Embedded in the query result so the
+ * client can fetch further pages (loadMore) from `pageInfo.cursor`.
+ */
+export interface ContentEntryQuerySpec {
+    modelId: string;
+    sort?: Record<string, "asc" | "desc">;
+    limit?: number;
+    search?: string;
+}
+export interface ResolvedContentEntryQuery<T = unknown> {
+    items: T[];
+    pageInfo: {
+        cursor: string | null;
+        hasMore: boolean;
+        totalCount: number;
+    };
+    /** Continuation params for loadMore. */
+    query?: ContentEntryQuerySpec;
+}
+/**
+ * The shape passed to a component for a content-entry input:
+ * - manual, single  -> the resolved entry (or null)
+ * - manual, list    -> an array of resolved entries
+ * - query           -> `{ items, pageInfo, query? }`
+ */
+export type ResolvedContentEntry = unknown | unknown[] | ResolvedContentEntryQuery | null;
+/**
+ * Detect whether a raw binding value is a `ContentEntryQueryValue` (query mode)
+ * rather than a manual `ContentEntryReference`.
+ *
+ * Query values carry `modelId` but NOT `id`; manual references carry both.
+ */
+export declare function isQueryValue(value: unknown): value is ContentEntryQueryValue;
+/**
+ * Detect whether a content-entry input's value is already a resolved CMS entry
+ * rather than a bare reference that needs fetching.
+ */
+export declare function isAlreadyResolved(value: unknown, list: boolean): boolean;
+/**
+ * Resolve a content-entry binding value into CMS entries. Works entirely from
+ * the value shape — no component manifest needed.
+ *
+ * - `{ id, modelId }` → fetch single entry
+ * - `[{ id, modelId }, ...]` → fetch multiple entries
+ * - `{ modelId, sort?, limit?, search? }` → list query
+ */
+export declare function resolveContentEntryValue(value: ContentEntryReference | ContentEntryReference[] | ContentEntryQueryValue | null | undefined, list: boolean, loader: ContentEntryLoader): Promise<ResolvedContentEntry>;

package/contentEntry/resolveContentEntry.js

@@ -0,0 +1,53 @@
+function isQueryValue(value) {
+    return "object" == typeof value && null !== value && "modelId" in value && !("id" in value) && !Array.isArray(value);
+}
+function isAlreadyResolved(value, list) {
+    if (null == value) return false;
+    if ("object" == typeof value && "items" in value) return true;
+    if (list && Array.isArray(value) && value.length > 0) {
+        const first = value[0];
+        return "object" == typeof first && null !== first && "values" in first;
+    }
+    if (!list && "object" == typeof value && "values" in value) return true;
+    return false;
+}
+async function resolveContentEntryValue(value, list, loader) {
+    if (null == value) return list ? [] : null;
+    if (isQueryValue(value)) {
+        const query = value;
+        const listParams = {
+            modelId: query.modelId,
+            sort: query.sort ? {
+                [query.sort.field]: query.sort.order
+            } : void 0,
+            limit: query.limit,
+            search: query.search
+        };
+        const result = await loader.listEntries(listParams);
+        return {
+            items: result.data,
+            pageInfo: {
+                cursor: result.meta.cursor,
+                hasMore: result.meta.hasMoreItems,
+                totalCount: result.meta.totalCount
+            },
+            query: listParams
+        };
+    }
+    if (Array.isArray(value)) {
+        const refs = value;
+        const entries = await Promise.all(refs.map((ref)=>loader.getEntry({
+                modelId: ref.modelId,
+                entryId: ref.id
+            })));
+        return entries.filter((entry)=>null !== entry);
+    }
+    const ref = value;
+    return loader.getEntry({
+        modelId: ref.modelId,
+        entryId: ref.id
+    });
+}
+export { isAlreadyResolved, isQueryValue, resolveContentEntryValue };
+
+//# sourceMappingURL=resolveContentEntry.js.map

package/contentEntry/resolveContentEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentEntry/resolveContentEntry.js","sources":["../../src/contentEntry/resolveContentEntry.ts"],"sourcesContent":["import type { ContentEntryReference, ContentEntryQueryValue } from \"~/types.js\";\n\n/**\n * Minimal CMS data loader the content-entry resolver depends on. Injected by the\n * caller (the render layer passes the CMS `contentSdk`) so this module stays\n * decoupled from `@webiny/cms-sdk`.\n */\nexport interface ContentEntryLoader {\n    getEntry(params: { modelId: string; entryId: string }): Promise<unknown | null>;\n    listEntries(params: {\n        modelId: string;\n        sort?: Record<string, \"asc\" | \"desc\">;\n        limit?: number;\n        search?: string;\n        after?: string;\n    }): Promise<{\n        data: unknown[];\n        meta: { cursor: string | null; hasMoreItems: boolean; totalCount: number };\n    }>;\n}\n\n/**\n * The query params used to produce a page. Embedded in the query result so the\n * client can fetch further pages (loadMore) from `pageInfo.cursor`.\n */\nexport interface ContentEntryQuerySpec {\n    modelId: string;\n    sort?: Record<string, \"asc\" | \"desc\">;\n    limit?: number;\n    search?: string;\n}\n\nexport interface ResolvedContentEntryQuery<T = unknown> {\n    items: T[];\n    pageInfo: { cursor: string | null; hasMore: boolean; totalCount: number };\n    /** Continuation params for loadMore. */\n    query?: ContentEntryQuerySpec;\n}\n\n/**\n * The shape passed to a component for a content-entry input:\n * - manual, single  -> the resolved entry (or null)\n * - manual, list    -> an array of resolved entries\n * - query           -> `{ items, pageInfo, query? }`\n */\nexport type ResolvedContentEntry = unknown | unknown[] | ResolvedContentEntryQuery | null;\n\n/**\n * Detect whether a raw binding value is a `ContentEntryQueryValue` (query mode)\n * rather than a manual `ContentEntryReference`.\n *\n * Query values carry `modelId` but NOT `id`; manual references carry both.\n */\nexport function isQueryValue(value: unknown): value is ContentEntryQueryValue {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        \"modelId\" in value &&\n        !(\"id\" in value) &&\n        !Array.isArray(value)\n    );\n}\n\n/**\n * Detect whether a content-entry input's value is already a resolved CMS entry\n * rather than a bare reference that needs fetching.\n */\nexport function isAlreadyResolved(value: unknown, list: boolean): boolean {\n    if (value == null) {\n        return false;\n    }\n    // Query result — already resolved if it has `items`.\n    if (typeof value === \"object\" && \"items\" in (value as any)) {\n        return true;\n    }\n    // List of resolved entries — each has `values` (CMS entry shape).\n    if (list && Array.isArray(value) && value.length > 0) {\n        const first = value[0];\n        return typeof first === \"object\" && first !== null && \"values\" in first;\n    }\n    // Single resolved entry.\n    if (!list && typeof value === \"object\" && \"values\" in (value as any)) {\n        return true;\n    }\n    return false;\n}\n\n/**\n * Resolve a content-entry binding value into CMS entries. Works entirely from\n * the value shape — no component manifest needed.\n *\n * - `{ id, modelId }` → fetch single entry\n * - `[{ id, modelId }, ...]` → fetch multiple entries\n * - `{ modelId, sort?, limit?, search? }` → list query\n */\nexport async function resolveContentEntryValue(\n    value:\n        | ContentEntryReference\n        | ContentEntryReference[]\n        | ContentEntryQueryValue\n        | null\n        | undefined,\n    list: boolean,\n    loader: ContentEntryLoader\n): Promise<ResolvedContentEntry> {\n    if (value == null) {\n        return list ? [] : null;\n    }\n\n    // Query mode: value is `{ modelId, sort?, limit?, search? }`.\n    if (isQueryValue(value)) {\n        const query = value;\n        const listParams: ContentEntryQuerySpec = {\n            modelId: query.modelId,\n            sort: query.sort ? { [query.sort.field]: query.sort.order } : undefined,\n            limit: query.limit,\n            search: query.search\n        };\n        const result = await loader.listEntries(listParams);\n        return {\n            items: result.data,\n            pageInfo: {\n                cursor: result.meta.cursor,\n                hasMore: result.meta.hasMoreItems,\n                totalCount: result.meta.totalCount\n            },\n            query: listParams\n        };\n    }\n\n    // Manual list: value is `[{ id, modelId }, ...]`.\n    if (Array.isArray(value)) {\n        const refs = value as ContentEntryReference[];\n        const entries = await Promise.all(\n            refs.map(ref => loader.getEntry({ modelId: ref.modelId, entryId: ref.id }))\n        );\n        return entries.filter(entry => entry !== null);\n    }\n\n    // Manual single: value is `{ id, modelId }`.\n    const ref = value as ContentEntryReference;\n    return loader.getEntry({ modelId: ref.modelId, entryId: ref.id });\n}\n"],"names":["isQueryValue","value","Array","isAlreadyResolved","list","first","resolveContentEntryValue","loader","query","listParams","undefined","result","refs","entries","Promise","ref","entry"],"mappings":"AAqDO,SAASA,aAAaC,KAAc;IACvC,OACI,AAAiB,YAAjB,OAAOA,SACPA,AAAU,SAAVA,SACA,aAAaA,SACb,CAAE,SAAQA,KAAI,KACd,CAACC,MAAM,OAAO,CAACD;AAEvB;AAMO,SAASE,kBAAkBF,KAAc,EAAEG,IAAa;IAC3D,IAAIH,AAAS,QAATA,OACA,OAAO;IAGX,IAAI,AAAiB,YAAjB,OAAOA,SAAsB,WAAYA,OACzC,OAAO;IAGX,IAAIG,QAAQF,MAAM,OAAO,CAACD,UAAUA,MAAM,MAAM,GAAG,GAAG;QAClD,MAAMI,QAAQJ,KAAK,CAAC,EAAE;QACtB,OAAO,AAAiB,YAAjB,OAAOI,SAAsBA,AAAU,SAAVA,SAAkB,YAAYA;IACtE;IAEA,IAAI,CAACD,QAAQ,AAAiB,YAAjB,OAAOH,SAAsB,YAAaA,OACnD,OAAO;IAEX,OAAO;AACX;AAUO,eAAeK,yBAClBL,KAKe,EACfG,IAAa,EACbG,MAA0B;IAE1B,IAAIN,AAAS,QAATA,OACA,OAAOG,OAAO,EAAE,GAAG;IAIvB,IAAIJ,aAAaC,QAAQ;QACrB,MAAMO,QAAQP;QACd,MAAMQ,aAAoC;YACtC,SAASD,MAAM,OAAO;YACtB,MAAMA,MAAM,IAAI,GAAG;gBAAE,CAACA,MAAM,IAAI,CAAC,KAAK,CAAC,EAAEA,MAAM,IAAI,CAAC,KAAK;YAAC,IAAIE;YAC9D,OAAOF,MAAM,KAAK;YAClB,QAAQA,MAAM,MAAM;QACxB;QACA,MAAMG,SAAS,MAAMJ,OAAO,WAAW,CAACE;QACxC,OAAO;YACH,OAAOE,OAAO,IAAI;YAClB,UAAU;gBACN,QAAQA,OAAO,IAAI,CAAC,MAAM;gBAC1B,SAASA,OAAO,IAAI,CAAC,YAAY;gBACjC,YAAYA,OAAO,IAAI,CAAC,UAAU;YACtC;YACA,OAAOF;QACX;IACJ;IAGA,IAAIP,MAAM,OAAO,CAACD,QAAQ;QACtB,MAAMW,OAAOX;QACb,MAAMY,UAAU,MAAMC,QAAQ,GAAG,CAC7BF,KAAK,GAAG,CAACG,CAAAA,MAAOR,OAAO,QAAQ,CAAC;gBAAE,SAASQ,IAAI,OAAO;gBAAE,SAASA,IAAI,EAAE;YAAC;QAE5E,OAAOF,QAAQ,MAAM,CAACG,CAAAA,QAASA,AAAU,SAAVA;IACnC;IAGA,MAAMD,MAAMd;IACZ,OAAOM,OAAO,QAAQ,CAAC;QAAE,SAASQ,IAAI,OAAO;QAAE,SAASA,IAAI,EAAE;IAAC;AACnE"}

package/contentEntry/resolveContentEntry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/contentEntry/resolveContentEntry.test.js

@@ -0,0 +1,213 @@
+import { describe, expect, it, vi } from "vitest";
+import { isAlreadyResolved, isQueryValue, resolveContentEntryValue } from "./resolveContentEntry.js";
+const entry = (id)=>({
+        id,
+        entryId: id,
+        values: {
+            title: `T${id}`
+        }
+    });
+function makeLoader(over = {}) {
+    return {
+        getEntry: vi.fn(async ({ entryId })=>entry(entryId)),
+        listEntries: vi.fn(async ()=>({
+                data: [
+                    entry("1"),
+                    entry("2")
+                ],
+                meta: {
+                    cursor: "c1",
+                    hasMoreItems: true,
+                    totalCount: 5
+                }
+            })),
+        ...over
+    };
+}
+describe("resolveContentEntryValue — manual mode", ()=>{
+    it("resolves a single reference", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue({
+            id: "42",
+            modelId: "blog"
+        }, false, loader);
+        expect(loader.getEntry).toHaveBeenCalledWith({
+            modelId: "blog",
+            entryId: "42"
+        });
+        expect(result).toEqual(entry("42"));
+    });
+    it("returns null for a null single value", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue(null, false, loader);
+        expect(result).toBeNull();
+        expect(loader.getEntry).not.toHaveBeenCalled();
+    });
+    it("resolves a list of references, preserving order", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue([
+            {
+                id: "1",
+                modelId: "blog"
+            },
+            {
+                id: "2",
+                modelId: "blog"
+            }
+        ], true, loader);
+        expect(loader.getEntry).toHaveBeenCalledTimes(2);
+        expect(result).toEqual([
+            entry("1"),
+            entry("2")
+        ]);
+    });
+    it("filters out unresolved (deleted) references in a list", async ()=>{
+        const loader = makeLoader({
+            getEntry: vi.fn(async ({ entryId })=>"2" === entryId ? null : entry(entryId))
+        });
+        const result = await resolveContentEntryValue([
+            {
+                id: "1",
+                modelId: "blog"
+            },
+            {
+                id: "2",
+                modelId: "blog"
+            }
+        ], true, loader);
+        expect(result).toEqual([
+            entry("1")
+        ]);
+    });
+    it("returns an empty array for a null list value", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue(null, true, loader);
+        expect(result).toEqual([]);
+        expect(loader.getEntry).not.toHaveBeenCalled();
+    });
+});
+describe("resolveContentEntryValue — query mode", ()=>{
+    it("runs the query and returns items + pageInfo", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue({
+            modelId: "blog",
+            sort: {
+                field: "values_title",
+                order: "asc"
+            },
+            limit: 5,
+            search: "cat"
+        }, false, loader);
+        expect(loader.listEntries).toHaveBeenCalledWith({
+            modelId: "blog",
+            sort: {
+                values_title: "asc"
+            },
+            limit: 5,
+            search: "cat"
+        });
+        expect(result).toMatchObject({
+            items: [
+                entry("1"),
+                entry("2")
+            ],
+            pageInfo: {
+                cursor: "c1",
+                hasMore: true,
+                totalCount: 5
+            }
+        });
+    });
+    it("always embeds the continuation query", async ()=>{
+        const loader = makeLoader();
+        const result = await resolveContentEntryValue({
+            modelId: "blog",
+            limit: 4
+        }, false, loader);
+        expect(result.query).toEqual({
+            modelId: "blog",
+            sort: void 0,
+            limit: 4,
+            search: void 0
+        });
+    });
+    it("runs a minimal query (modelId only)", async ()=>{
+        const loader = makeLoader();
+        await resolveContentEntryValue({
+            modelId: "blog"
+        }, false, loader);
+        expect(loader.listEntries).toHaveBeenCalledWith({
+            modelId: "blog",
+            sort: void 0,
+            limit: void 0,
+            search: void 0
+        });
+    });
+});
+describe("isQueryValue", ()=>{
+    it("returns true for { modelId } without id", ()=>{
+        expect(isQueryValue({
+            modelId: "blog"
+        })).toBe(true);
+        expect(isQueryValue({
+            modelId: "blog",
+            sort: {
+                field: "a",
+                order: "asc"
+            }
+        })).toBe(true);
+    });
+    it("returns false for a manual reference { id, modelId }", ()=>{
+        expect(isQueryValue({
+            id: "42",
+            modelId: "blog"
+        })).toBe(false);
+    });
+    it("returns false for arrays and non-objects", ()=>{
+        expect(isQueryValue([
+            {
+                modelId: "blog"
+            }
+        ])).toBe(false);
+        expect(isQueryValue(null)).toBe(false);
+        expect(isQueryValue("string")).toBe(false);
+    });
+});
+describe("isAlreadyResolved", ()=>{
+    it("returns true for a query result with items", ()=>{
+        expect(isAlreadyResolved({
+            items: [],
+            pageInfo: {}
+        }, false)).toBe(true);
+    });
+    it("returns true for a list of resolved entries", ()=>{
+        expect(isAlreadyResolved([
+            {
+                values: {
+                    title: "x"
+                }
+            }
+        ], true)).toBe(true);
+    });
+    it("returns false for a list of bare references", ()=>{
+        expect(isAlreadyResolved([
+            {
+                id: "1",
+                modelId: "blog"
+            }
+        ], true)).toBe(false);
+    });
+    it("returns true for a single resolved entry", ()=>{
+        expect(isAlreadyResolved({
+            values: {
+                title: "x"
+            }
+        }, false)).toBe(true);
+    });
+    it("returns false for null", ()=>{
+        expect(isAlreadyResolved(null, false)).toBe(false);
+        expect(isAlreadyResolved(null, true)).toBe(false);
+    });
+});
+
+//# sourceMappingURL=resolveContentEntry.test.js.map

package/contentEntry/resolveContentEntry.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentEntry/resolveContentEntry.test.js","sources":["../../src/contentEntry/resolveContentEntry.test.ts"],"sourcesContent":["import { describe, it, expect, vi } from \"vitest\";\nimport {\n    resolveContentEntryValue,\n    isQueryValue,\n    isAlreadyResolved,\n    type ContentEntryLoader\n} from \"./resolveContentEntry.js\";\n\nconst entry = (id: string) => ({ id, entryId: id, values: { title: `T${id}` } });\n\nfunction makeLoader(over: Partial<ContentEntryLoader> = {}): ContentEntryLoader {\n    return {\n        getEntry: vi.fn(async ({ entryId }: { entryId: string }) => entry(entryId)),\n        listEntries: vi.fn(async () => ({\n            data: [entry(\"1\"), entry(\"2\")],\n            meta: { cursor: \"c1\", hasMoreItems: true, totalCount: 5 }\n        })),\n        ...over\n    };\n}\n\ndescribe(\"resolveContentEntryValue — manual mode\", () => {\n    it(\"resolves a single reference\", async () => {\n        const loader = makeLoader();\n        const result = await resolveContentEntryValue({ id: \"42\", modelId: \"blog\" }, false, loader);\n        expect(loader.getEntry).toHaveBeenCalledWith({ modelId: \"blog\", entryId: \"42\" });\n        expect(result).toEqual(entry(\"42\"));\n    });\n\n    it(\"returns null for a null single value\", async () => {\n        const loader = makeLoader();\n        const result = await resolveContentEntryValue(null, false, loader);\n        expect(result).toBeNull();\n        expect(loader.getEntry).not.toHaveBeenCalled();\n    });\n\n    it(\"resolves a list of references, preserving order\", async () => {\n        const loader = makeLoader();\n        const result = await resolveContentEntryValue(\n            [\n                { id: \"1\", modelId: \"blog\" },\n                { id: \"2\", modelId: \"blog\" }\n            ],\n            true,\n            loader\n        );\n        expect(loader.getEntry).toHaveBeenCalledTimes(2);\n        expect(result).toEqual([entry(\"1\"), entry(\"2\")]);\n    });\n\n    it(\"filters out unresolved (deleted) references in a list\", async () => {\n        const loader = makeLoader({\n            getEntry: vi.fn(async ({ entryId }: { entryId: string }) =>\n                entryId === \"2\" ? null : entry(entryId)\n            )\n        });\n        const result = await resolveContentEntryValue(\n            [\n                { id: \"1\", modelId: \"blog\" },\n                { id: \"2\", modelId: \"blog\" }\n            ],\n            true,\n            loader\n        );\n        expect(result).toEqual([entry(\"1\")]);\n    });\n\n    it(\"returns an empty array for a null list value\", async () => {\n        const loader = makeLoader();\n        const result = await resolveContentEntryValue(null, true, loader);\n        expect(result).toEqual([]);\n        expect(loader.getEntry).not.toHaveBeenCalled();\n    });\n});\n\ndescribe(\"resolveContentEntryValue — query mode\", () => {\n    it(\"runs the query and returns items + pageInfo\", async () => {\n        const loader = makeLoader();\n        const result = await resolveContentEntryValue(\n            {\n                modelId: \"blog\",\n                sort: { field: \"values_title\", order: \"asc\" },\n                limit: 5,\n                search: \"cat\"\n            },\n            false,\n            loader\n        );\n        expect(loader.listEntries).toHaveBeenCalledWith({\n            modelId: \"blog\",\n            sort: { values_title: \"asc\" },\n            limit: 5,\n            search: \"cat\"\n        });\n        expect(result).toMatchObject({\n            items: [entry(\"1\"), entry(\"2\")],\n            pageInfo: { cursor: \"c1\", hasMore: true, totalCount: 5 }\n        });\n    });\n\n    it(\"always embeds the continuation query\", async () => {\n        const loader = makeLoader();\n        const result = (await resolveContentEntryValue(\n            { modelId: \"blog\", limit: 4 },\n            false,\n            loader\n        )) as Record<string, unknown>;\n        expect(result.query).toEqual({\n            modelId: \"blog\",\n            sort: undefined,\n            limit: 4,\n            search: undefined\n        });\n    });\n\n    it(\"runs a minimal query (modelId only)\", async () => {\n        const loader = makeLoader();\n        await resolveContentEntryValue({ modelId: \"blog\" }, false, loader);\n        expect(loader.listEntries).toHaveBeenCalledWith({\n            modelId: \"blog\",\n            sort: undefined,\n            limit: undefined,\n            search: undefined\n        });\n    });\n});\n\ndescribe(\"isQueryValue\", () => {\n    it(\"returns true for { modelId } without id\", () => {\n        expect(isQueryValue({ modelId: \"blog\" })).toBe(true);\n        expect(isQueryValue({ modelId: \"blog\", sort: { field: \"a\", order: \"asc\" } })).toBe(true);\n    });\n\n    it(\"returns false for a manual reference { id, modelId }\", () => {\n        expect(isQueryValue({ id: \"42\", modelId: \"blog\" })).toBe(false);\n    });\n\n    it(\"returns false for arrays and non-objects\", () => {\n        expect(isQueryValue([{ modelId: \"blog\" }])).toBe(false);\n        expect(isQueryValue(null)).toBe(false);\n        expect(isQueryValue(\"string\")).toBe(false);\n    });\n});\n\ndescribe(\"isAlreadyResolved\", () => {\n    it(\"returns true for a query result with items\", () => {\n        expect(isAlreadyResolved({ items: [], pageInfo: {} }, false)).toBe(true);\n    });\n\n    it(\"returns true for a list of resolved entries\", () => {\n        expect(isAlreadyResolved([{ values: { title: \"x\" } }], true)).toBe(true);\n    });\n\n    it(\"returns false for a list of bare references\", () => {\n        expect(isAlreadyResolved([{ id: \"1\", modelId: \"blog\" }], true)).toBe(false);\n    });\n\n    it(\"returns true for a single resolved entry\", () => {\n        expect(isAlreadyResolved({ values: { title: \"x\" } }, false)).toBe(true);\n    });\n\n    it(\"returns false for null\", () => {\n        expect(isAlreadyResolved(null, false)).toBe(false);\n        expect(isAlreadyResolved(null, true)).toBe(false);\n    });\n});\n"],"names":["entry","id","makeLoader","over","vi","entryId","describe","it","loader","result","resolveContentEntryValue","expect","undefined","isQueryValue","isAlreadyResolved"],"mappings":"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"}

package/createComponent.d.ts

@@ -0,0 +1,5 @@
+import type { Component, ComponentManifestInput } from "./types.js";
+export type ExtractInputs<T> = T extends {
+    inputs: infer I;
+} ? I : never;
+export declare function createComponent<TComponent extends (props: any) => any, TInputs extends ExtractInputs<Parameters<TComponent>[0]>>(component: TComponent, manifest: ComponentManifestInput<TInputs>): Component;

package/createComponent.js

@@ -0,0 +1,32 @@
+import { createSlotInput } from "./createInput.js";
+function createComponent(component, manifest) {
+    const inputs = [];
+    if (Array.isArray(manifest.inputs)) inputs.push(...manifest.inputs);
+    else {
+        const inputsObject = manifest.inputs ?? {};
+        Object.keys(inputsObject).forEach((name)=>{
+            inputs.push({
+                ...inputsObject[name],
+                name
+            });
+        });
+    }
+    const acceptsChildren = manifest.acceptsChildren;
+    if (acceptsChildren) {
+        const hasChildren = inputs.some((input)=>"children" === input.name);
+        if (!hasChildren) inputs.push(createSlotInput({
+            name: "children"
+        }));
+    }
+    return {
+        component,
+        manifest: {
+            ...manifest,
+            tags: manifest.tags ?? [],
+            inputs
+        }
+    };
+}
+export { createComponent };
+
+//# sourceMappingURL=createComponent.js.map

package/createComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createComponent.js","sources":["../src/createComponent.ts"],"sourcesContent":["import type {\n    Component,\n    ComponentInput,\n    ComponentManifest,\n    ComponentManifestInput\n} from \"./types.js\";\nimport type { InputFactory } from \"./createInput.js\";\nimport { createSlotInput } from \"./createInput.js\";\n\nexport type ExtractInputs<T> = T extends { inputs: infer I } ? I : never;\n\nexport function createComponent<\n    TComponent extends (props: any) => any,\n    TInputs extends ExtractInputs<Parameters<TComponent>[0]>\n>(component: TComponent, manifest: ComponentManifestInput<TInputs>): Component {\n    const inputs: ComponentInput[] = [];\n\n    if (Array.isArray(manifest.inputs)) {\n        inputs.push(...manifest.inputs);\n    } else {\n        const inputsObject: Record<string, InputFactory<any>> = manifest.inputs ?? {};\n        Object.keys(inputsObject).forEach((name: string) => {\n            inputs.push({ ...inputsObject[name], name });\n        });\n    }\n\n    const acceptsChildren = manifest.acceptsChildren;\n\n    if (acceptsChildren) {\n        const hasChildren = inputs.some(input => input.name === \"children\");\n        if (!hasChildren) {\n            inputs.push(createSlotInput({ name: \"children\" }));\n        }\n    }\n\n    return {\n        component,\n        manifest: { ...manifest, tags: manifest.tags ?? [], inputs } as ComponentManifest\n    };\n}\n"],"names":["createComponent","component","manifest","inputs","Array","inputsObject","Object","name","acceptsChildren","hasChildren","input","createSlotInput"],"mappings":";AAWO,SAASA,gBAGdC,SAAqB,EAAEC,QAAyC;IAC9D,MAAMC,SAA2B,EAAE;IAEnC,IAAIC,MAAM,OAAO,CAACF,SAAS,MAAM,GAC7BC,OAAO,IAAI,IAAID,SAAS,MAAM;SAC3B;QACH,MAAMG,eAAkDH,SAAS,MAAM,IAAI,CAAC;QAC5EI,OAAO,IAAI,CAACD,cAAc,OAAO,CAAC,CAACE;YAC/BJ,OAAO,IAAI,CAAC;gBAAE,GAAGE,YAAY,CAACE,KAAK;gBAAEA;YAAK;QAC9C;IACJ;IAEA,MAAMC,kBAAkBN,SAAS,eAAe;IAEhD,IAAIM,iBAAiB;QACjB,MAAMC,cAAcN,OAAO,IAAI,CAACO,CAAAA,QAASA,AAAe,eAAfA,MAAM,IAAI;QACnD,IAAI,CAACD,aACDN,OAAO,IAAI,CAACQ,gBAAgB;YAAE,MAAM;QAAW;IAEvD;IAEA,OAAO;QACHV;QACA,UAAU;YAAE,GAAGC,QAAQ;YAAE,MAAMA,SAAS,IAAI,IAAI,EAAE;YAAEC;QAAO;IAC/D;AACJ"}

package/createElement.js

@@ -1,8 +1,7 @@
-export const createElement = params => {
-  return {
-    action: "CreateElement",
-    params
-  };
-};
+const createElement = (params)=>({
+        action: "CreateElement",
+        params
+    });
+export { createElement };
 
 //# sourceMappingURL=createElement.js.map

package/createElement.js.map

@@ -1 +1 @@
-{"version":3,"names":["createElement","params","action"],"sources":["createElement.ts"],"sourcesContent":["import type { ResponsiveStyles } from \"~/types.js\";\n\nexport interface CreateElementParams {\n    component: string;\n    inputs?: Record<string, any>;\n    styles?: ResponsiveStyles;\n}\n\nexport const createElement = (params: CreateElementParams) => {\n    return {\n        action: \"CreateElement\",\n        params\n    };\n};\n"],"mappings":"AAQA,OAAO,MAAMA,aAAa,GAAIC,MAA2B,IAAK;EAC1D,OAAO;IACHC,MAAM,EAAE,eAAe;IACvBD;EACJ,CAAC;AACL,CAAC","ignoreList":[]}
+{"version":3,"file":"createElement.js","sources":["../src/createElement.ts"],"sourcesContent":["import type { ResponsiveStyles } from \"~/types.js\";\n\nexport interface CreateElementParams {\n    component: string;\n    inputs?: Record<string, any>;\n    styles?: ResponsiveStyles;\n}\n\nexport const createElement = (params: CreateElementParams) => {\n    return {\n        action: \"CreateElement\",\n        params\n    };\n};\n"],"names":["createElement","params"],"mappings":"AAQO,MAAMA,gBAAgB,CAACC,SACnB;QACH,QAAQ;QACRA;IACJ"}

package/createInput.d.ts

@@ -1,5 +1,5 @@
-import type { TextInput, LongTextInput, NumberInput, BooleanInput, ColorInput, FileInput, LexicalInput, SelectInput, RadioInput, ObjectInput, DateTimeInput, ComponentInput, TagsInput, SlotInput } from "./types.js";
-export type InputFactory<Name extends string> = ReturnType<typeof createTextInput<Name>> | ReturnType<typeof createLongTextInput<Name>> | ReturnType<typeof createNumberInput<Name>> | ReturnType<typeof createBooleanInput<Name>> | ReturnType<typeof createColorInput<Name>> | ReturnType<typeof createFileInput<Name>> | ReturnType<typeof createDateInput<Name>> | ReturnType<typeof createLexicalInput<Name>> | ReturnType<typeof createSelectInput<Name>> | ReturnType<typeof createRadioInput<Name>> | ReturnType<typeof createObjectInput<Name>> | ReturnType<typeof createTagsInput<Name>> | ReturnType<typeof createSlotInput<Name>>;
+import type { TextInput, LongTextInput, NumberInput, BooleanInput, ColorInput, FileInput, LexicalInput, SelectInput, RadioInput, ObjectInput, DateTimeInput, ComponentInput, TagsInput, SlotInput, ContentEntryInput } from "./types.js";
+export type InputFactory<Name extends string> = ReturnType<typeof createTextInput<Name>> | ReturnType<typeof createLongTextInput<Name>> | ReturnType<typeof createNumberInput<Name>> | ReturnType<typeof createBooleanInput<Name>> | ReturnType<typeof createColorInput<Name>> | ReturnType<typeof createFileInput<Name>> | ReturnType<typeof createDateInput<Name>> | ReturnType<typeof createLexicalInput<Name>> | ReturnType<typeof createSelectInput<Name>> | ReturnType<typeof createRadioInput<Name>> | ReturnType<typeof createObjectInput<Name>> | ReturnType<typeof createTagsInput<Name>> | ReturnType<typeof createSlotInput<Name>> | ReturnType<typeof createContentEntryInput<Name>>;
 /**
  * TypeScript Overload Resolution and Input Factory Design
  *
@@ -122,4 +122,12 @@ export declare function createSlotInput<TName extends string>(input: {
 export declare function createSlotInput<TName extends string>(input: Omit<SlotInput, "type" | "name">): SlotInput & {
     name: TName;
 };
+export declare function createContentEntryInput<TName extends string>(input: {
+    name: TName;
+} & Omit<ContentEntryInput, "type" | "name">): ContentEntryInput & {
+    name: TName;
+};
+export declare function createContentEntryInput<TName extends string>(input: Omit<ContentEntryInput, "type" | "name">): ContentEntryInput & {
+    name: TName;
+};
 export declare function createInput(input: ComponentInput): ComponentInput;