@webiny/website-builder-sdk 0.0.0-unstable.7be00a75a9 → 0.0.0-unstable.7c2def32a7

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":";;AAQA,MAAMA,QAAQ,CAACC,KAAgB;QAAEA;QAAI,SAASA;QAAI,QAAQ;YAAE,OAAO,CAAC,CAAC,EAAEA,IAAI;QAAC;IAAE;AAE9E,SAASC,WAAWC,OAAoC,CAAC,CAAC;IACtD,OAAO;QACH,UAAUC,GAAG,EAAE,CAAC,OAAO,EAAEC,OAAO,EAAuB,GAAKL,MAAMK;QAClE,aAAaD,GAAG,EAAE,CAAC,UAAa;gBAC5B,MAAM;oBAACJ,MAAM;oBAAMA,MAAM;iBAAK;gBAC9B,MAAM;oBAAE,QAAQ;oBAAM,cAAc;oBAAM,YAAY;gBAAE;YAC5D;QACA,GAAGG,IAAI;IACX;AACJ;AAEAG,SAAS,0CAA0C;IAC/CC,GAAG,+BAA+B;QAC9B,MAAMC,SAASN;QACf,MAAMO,SAAS,MAAMC,yBAAyB;YAAE,IAAI;YAAM,SAAS;QAAO,GAAG,OAAOF;QACpFG,OAAOH,OAAO,QAAQ,EAAE,oBAAoB,CAAC;YAAE,SAAS;YAAQ,SAAS;QAAK;QAC9EG,OAAOF,QAAQ,OAAO,CAACT,MAAM;IACjC;IAEAO,GAAG,wCAAwC;QACvC,MAAMC,SAASN;QACf,MAAMO,SAAS,MAAMC,yBAAyB,MAAM,OAAOF;QAC3DG,OAAOF,QAAQ,QAAQ;QACvBE,OAAOH,OAAO,QAAQ,EAAE,GAAG,CAAC,gBAAgB;IAChD;IAEAD,GAAG,mDAAmD;QAClD,MAAMC,SAASN;QACf,MAAMO,SAAS,MAAMC,yBACjB;YACI;gBAAE,IAAI;gBAAK,SAAS;YAAO;YAC3B;gBAAE,IAAI;gBAAK,SAAS;YAAO;SAC9B,EACD,MACAF;QAEJG,OAAOH,OAAO,QAAQ,EAAE,qBAAqB,CAAC;QAC9CG,OAAOF,QAAQ,OAAO,CAAC;YAACT,MAAM;YAAMA,MAAM;SAAK;IACnD;IAEAO,GAAG,yDAAyD;QACxD,MAAMC,SAASN,WAAW;YACtB,UAAUE,GAAG,EAAE,CAAC,OAAO,EAAEC,OAAO,EAAuB,GACnDA,AAAY,QAAZA,UAAkB,OAAOL,MAAMK;QAEvC;QACA,MAAMI,SAAS,MAAMC,yBACjB;YACI;gBAAE,IAAI;gBAAK,SAAS;YAAO;YAC3B;gBAAE,IAAI;gBAAK,SAAS;YAAO;SAC9B,EACD,MACAF;QAEJG,OAAOF,QAAQ,OAAO,CAAC;YAACT,MAAM;SAAK;IACvC;IAEAO,GAAG,gDAAgD;QAC/C,MAAMC,SAASN;QACf,MAAMO,SAAS,MAAMC,yBAAyB,MAAM,MAAMF;QAC1DG,OAAOF,QAAQ,OAAO,CAAC,EAAE;QACzBE,OAAOH,OAAO,QAAQ,EAAE,GAAG,CAAC,gBAAgB;IAChD;AACJ;AAEAF,SAAS,yCAAyC;IAC9CC,GAAG,+CAA+C;QAC9C,MAAMC,SAASN;QACf,MAAMO,SAAS,MAAMC,yBACjB;YACI,SAAS;YACT,MAAM;gBAAE,OAAO;gBAAgB,OAAO;YAAM;YAC5C,OAAO;YACP,QAAQ;QACZ,GACA,OACAF;QAEJG,OAAOH,OAAO,WAAW,EAAE,oBAAoB,CAAC;YAC5C,SAAS;YACT,MAAM;gBAAE,cAAc;YAAM;YAC5B,OAAO;YACP,QAAQ;QACZ;QACAG,OAAOF,QAAQ,aAAa,CAAC;YACzB,OAAO;gBAACT,MAAM;gBAAMA,MAAM;aAAK;YAC/B,UAAU;gBAAE,QAAQ;gBAAM,SAAS;gBAAM,YAAY;YAAE;QAC3D;IACJ;IAEAO,GAAG,wCAAwC;QACvC,MAAMC,SAASN;QACf,MAAMO,SAAU,MAAMC,yBAClB;YAAE,SAAS;YAAQ,OAAO;QAAE,GAC5B,OACAF;QAEJG,OAAOF,OAAO,KAAK,EAAE,OAAO,CAAC;YACzB,SAAS;YACT,MAAMG;YACN,OAAO;YACP,QAAQA;QACZ;IACJ;IAEAL,GAAG,uCAAuC;QACtC,MAAMC,SAASN;QACf,MAAMQ,yBAAyB;YAAE,SAAS;QAAO,GAAG,OAAOF;QAC3DG,OAAOH,OAAO,WAAW,EAAE,oBAAoB,CAAC;YAC5C,SAAS;YACT,MAAMI;YACN,OAAOA;YACP,QAAQA;QACZ;IACJ;AACJ;AAEAN,SAAS,gBAAgB;IACrBC,GAAG,2CAA2C;QAC1CI,OAAOE,aAAa;YAAE,SAAS;QAAO,IAAI,IAAI,CAAC;QAC/CF,OAAOE,aAAa;YAAE,SAAS;YAAQ,MAAM;gBAAE,OAAO;gBAAK,OAAO;YAAM;QAAE,IAAI,IAAI,CAAC;IACvF;IAEAN,GAAG,wDAAwD;QACvDI,OAAOE,aAAa;YAAE,IAAI;YAAM,SAAS;QAAO,IAAI,IAAI,CAAC;IAC7D;IAEAN,GAAG,4CAA4C;QAC3CI,OAAOE,aAAa;YAAC;gBAAE,SAAS;YAAO;SAAE,GAAG,IAAI,CAAC;QACjDF,OAAOE,aAAa,OAAO,IAAI,CAAC;QAChCF,OAAOE,aAAa,WAAW,IAAI,CAAC;IACxC;AACJ;AAEAP,SAAS,qBAAqB;IAC1BC,GAAG,8CAA8C;QAC7CI,OAAOG,kBAAkB;YAAE,OAAO,EAAE;YAAE,UAAU,CAAC;QAAE,GAAG,QAAQ,IAAI,CAAC;IACvE;IAEAP,GAAG,+CAA+C;QAC9CI,OAAOG,kBAAkB;YAAC;gBAAE,QAAQ;oBAAE,OAAO;gBAAI;YAAE;SAAE,EAAE,OAAO,IAAI,CAAC;IACvE;IAEAP,GAAG,+CAA+C;QAC9CI,OAAOG,kBAAkB;YAAC;gBAAE,IAAI;gBAAK,SAAS;YAAO;SAAE,EAAE,OAAO,IAAI,CAAC;IACzE;IAEAP,GAAG,4CAA4C;QAC3CI,OAAOG,kBAAkB;YAAE,QAAQ;gBAAE,OAAO;YAAI;QAAE,GAAG,QAAQ,IAAI,CAAC;IACtE;IAEAP,GAAG,0BAA0B;QACzBI,OAAOG,kBAAkB,MAAM,QAAQ,IAAI,CAAC;QAC5CH,OAAOG,kBAAkB,MAAM,OAAO,IAAI,CAAC;IAC/C;AACJ"}

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/createContentClient.d.ts

@@ -0,0 +1,17 @@
+import { ContentSdk } from "./ContentSdk.js";
+import type { ContentSDKConfig } from "./ContentSdk.js";
+/**
+ * A configured content client. It exposes the same methods as `contentSdk`,
+ * except `init()`: a client's configuration is fixed when it is created.
+ */
+export type ContentClient = Omit<ContentSdk, "init">;
+/**
+ * Create a content client with its own configuration and its own API client, separate
+ * from the `contentSdk` singleton and from other clients. Use it when one process serves
+ * requests for different tenants or API hosts.
+ *
+ * Data fetching is per client, and so are the component registry, the content entry cache
+ * and the document store. The editing environment is module-level and shared by all
+ * clients and `contentSdk`.
+ */
+export declare function createContentClient(config: ContentSDKConfig): ContentClient;

package/createContentClient.js

@@ -0,0 +1,16 @@
+import { ContentSdk } from "./ContentSdk.js";
+import { ComponentRegistry } from "./ComponentRegistry.js";
+import { ContentEntryCache } from "./contentEntry/ContentEntryCache.js";
+import { DocumentStoreManager } from "./DocumentStoreManager.js";
+function createContentClient(config) {
+    const client = new ContentSdk({
+        componentRegistry: new ComponentRegistry(),
+        contentEntryCache: new ContentEntryCache(),
+        documentStoreManager: new DocumentStoreManager()
+    });
+    client.init(config);
+    return client;
+}
+export { createContentClient };
+
+//# sourceMappingURL=createContentClient.js.map

package/createContentClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createContentClient.js","sources":["../src/createContentClient.ts"],"sourcesContent":["import { ContentSdk } from \"./ContentSdk.js\";\nimport type { ContentSDKConfig } from \"./ContentSdk.js\";\nimport { ComponentRegistry } from \"./ComponentRegistry.js\";\nimport { ContentEntryCache } from \"./contentEntry/ContentEntryCache.js\";\nimport { DocumentStoreManager } from \"./DocumentStoreManager.js\";\n\n/**\n * A configured content client. It exposes the same methods as `contentSdk`,\n * except `init()`: a client's configuration is fixed when it is created.\n */\nexport type ContentClient = Omit<ContentSdk, \"init\">;\n\n/**\n * Create a content client with its own configuration and its own API client, separate\n * from the `contentSdk` singleton and from other clients. Use it when one process serves\n * requests for different tenants or API hosts.\n *\n * Data fetching is per client, and so are the component registry, the content entry cache\n * and the document store. The editing environment is module-level and shared by all\n * clients and `contentSdk`.\n */\nexport function createContentClient(config: ContentSDKConfig): ContentClient {\n    const client = new ContentSdk({\n        componentRegistry: new ComponentRegistry(),\n        contentEntryCache: new ContentEntryCache(),\n        documentStoreManager: new DocumentStoreManager()\n    });\n    client.init(config);\n    return client;\n}\n"],"names":["createContentClient","config","client","ContentSdk","ComponentRegistry","ContentEntryCache","DocumentStoreManager"],"mappings":";;;;AAqBO,SAASA,oBAAoBC,MAAwB;IACxD,MAAMC,SAAS,IAAIC,WAAW;QAC1B,mBAAmB,IAAIC;QACvB,mBAAmB,IAAIC;QACvB,sBAAsB,IAAIC;IAC9B;IACAJ,OAAO,IAAI,CAACD;IACZ,OAAOC;AACX"}

package/createContentClient.test.d.ts

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

package/createContentClient.test.js

@@ -0,0 +1,165 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createContentClient } from "./createContentClient.js";
+import { contentSdk } from "./ContentSdk.js";
+const pageResponse = (path)=>({
+        data: {
+            websiteBuilder: {
+                getPageByPath: {
+                    data: {
+                        id: `page:${path}`,
+                        properties: {
+                            id: `page:${path}`,
+                            path
+                        }
+                    },
+                    error: null
+                }
+            }
+        }
+    });
+describe("createContentClient", ()=>{
+    let requests;
+    let delays;
+    beforeEach(()=>{
+        requests = [];
+        delays = {};
+        const fetchMock = vi.fn(async (url, init)=>{
+            const headers = init.headers;
+            const body = JSON.parse(init.body);
+            const path = body.variables.path;
+            requests.push({
+                url,
+                tenant: headers["X-Tenant"],
+                authorization: headers["Authorization"],
+                path
+            });
+            const delay = delays[path] ?? 0;
+            await new Promise((resolve)=>setTimeout(resolve, delay));
+            return {
+                json: async ()=>pageResponse(path)
+            };
+        });
+        vi.stubGlobal("fetch", fetchMock);
+    });
+    afterEach(()=>{
+        vi.unstubAllGlobals();
+    });
+    it("sends each client's own tenant, host and key", async ()=>{
+        const clientA = createContentClient({
+            apiHost: "https://a.example.com",
+            apiKey: "key-a",
+            apiTenant: "tenant-a"
+        });
+        const clientB = createContentClient({
+            apiHost: "https://b.example.com",
+            apiKey: "key-b",
+            apiTenant: "tenant-b"
+        });
+        await clientA.getPage("/a");
+        await clientB.getPage("/b");
+        expect(requests).toEqual([
+            {
+                url: "https://a.example.com/graphql",
+                tenant: "tenant-a",
+                authorization: "Bearer key-a",
+                path: "/a"
+            },
+            {
+                url: "https://b.example.com/graphql",
+                tenant: "tenant-b",
+                authorization: "Bearer key-b",
+                path: "/b"
+            }
+        ]);
+    });
+    it("keeps clients isolated when their calls interleave", async ()=>{
+        const clientA = createContentClient({
+            apiHost: "https://a.example.com",
+            apiKey: "key-a",
+            apiTenant: "tenant-a"
+        });
+        const clientB = createContentClient({
+            apiHost: "https://b.example.com",
+            apiKey: "key-b",
+            apiTenant: "tenant-b"
+        });
+        delays["/a"] = 20;
+        delays["/b"] = 0;
+        const [pageA, pageB] = await Promise.all([
+            clientA.getPage("/a"),
+            clientB.getPage("/b")
+        ]);
+        expect(pageA?.properties.path).toBe("/a");
+        expect(pageB?.properties.path).toBe("/b");
+        const requestA = requests.find((request)=>"/a" === request.path);
+        const requestB = requests.find((request)=>"/b" === request.path);
+        expect(requestA).toMatchObject({
+            url: "https://a.example.com/graphql",
+            tenant: "tenant-a",
+            authorization: "Bearer key-a"
+        });
+        expect(requestB).toMatchObject({
+            url: "https://b.example.com/graphql",
+            tenant: "tenant-b",
+            authorization: "Bearer key-b"
+        });
+    });
+    it("does not change what the contentSdk singleton sends, and init() does not change a client", async ()=>{
+        contentSdk.init({
+            apiHost: "https://singleton.example.com",
+            apiKey: "key-singleton",
+            apiTenant: "root"
+        });
+        const client = createContentClient({
+            apiHost: "https://client.example.com",
+            apiKey: "key-client",
+            apiTenant: "tenant-client"
+        });
+        await contentSdk.getPage("/singleton");
+        contentSdk.init({
+            apiHost: "https://singleton-2.example.com",
+            apiKey: "key-singleton-2",
+            apiTenant: "root-2"
+        });
+        await client.getPage("/client");
+        await contentSdk.getPage("/singleton-2");
+        expect(requests).toEqual([
+            {
+                url: "https://singleton.example.com/graphql",
+                tenant: "root",
+                authorization: "Bearer key-singleton",
+                path: "/singleton"
+            },
+            {
+                url: "https://client.example.com/graphql",
+                tenant: "tenant-client",
+                authorization: "Bearer key-client",
+                path: "/client"
+            },
+            {
+                url: "https://singleton-2.example.com/graphql",
+                tenant: "root-2",
+                authorization: "Bearer key-singleton-2",
+                path: "/singleton-2"
+            }
+        ]);
+    });
+    it("keeps the preview flag per client", ()=>{
+        const live = createContentClient({
+            apiHost: "https://a.example.com",
+            apiKey: "key-a",
+            apiTenant: "tenant-a"
+        });
+        const preview = createContentClient({
+            apiHost: "https://a.example.com",
+            apiKey: "key-a",
+            apiTenant: "tenant-a",
+            preview: true,
+            previewParams: "wb.type=page&wb.path=/a&wb.id=page-1"
+        });
+        expect(live.isPreviewing()).toBe(false);
+        expect(preview.isPreviewing()).toBe(true);
+    });
+});
+
+//# sourceMappingURL=createContentClient.test.js.map