@webiny/website-builder-sdk 6.4.12-beta.4 → 6.5.0-beta.0

package/contentEntry/ContentEntryBindingsResolver.js

@@ -0,0 +1,45 @@
+import { contentEntryCache } from "./ContentEntryCache.js";
+import { environment } from "../Environment.js";
+class ContentEntryBindingsResolver {
+    constructor(inner, resolvedEntries = new Map()){
+        this.inner = inner;
+        this.resolvedEntries = resolvedEntries;
+    }
+    resolveElement(params) {
+        const results = this.inner.resolveElement(params);
+        for (const instance of results)this.enrichContentEntryInputs(params.element.id, params.inputAst, instance.inputs);
+        return results;
+    }
+    enrichContentEntryInputs(elementId, ast, inputs) {
+        for (const node of ast){
+            if ("contentEntry" === node.input.type) {
+                const key = `${elementId}:${node.name}`;
+                const rawValue = inputs[node.name];
+                const list = node.input.list ?? false;
+                if (this.resolvedEntries.has(key)) {
+                    inputs[node.name] = this.resolvedEntries.get(key);
+                    continue;
+                }
+                if (contentEntryCache.has(key)) {
+                    inputs[node.name] = contentEntryCache.get(key);
+                    continue;
+                }
+                if (environment.isClient() && contentEntryCache.getLoader()) {
+                    const cacheKey = `${key}:${JSON.stringify(rawValue ?? null)}`;
+                    contentEntryCache.resolve(cacheKey, rawValue, list);
+                    const cached = contentEntryCache.get(cacheKey);
+                    if (void 0 !== cached) inputs[node.name] = cached;
+                }
+            }
+            if (node.children.length > 0) {
+                const value = inputs[node.name];
+                if (node.list && Array.isArray(value)) {
+                    for (const item of value)if ("object" == typeof item && null !== item) this.enrichContentEntryInputs(elementId, node.children, item);
+                } else if ("object" == typeof value && null !== value && !Array.isArray(value)) this.enrichContentEntryInputs(elementId, node.children, value);
+            }
+        }
+    }
+}
+export { ContentEntryBindingsResolver };
+
+//# sourceMappingURL=ContentEntryBindingsResolver.js.map

package/contentEntry/ContentEntryBindingsResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentEntry/ContentEntryBindingsResolver.js","sources":["../../src/contentEntry/ContentEntryBindingsResolver.ts"],"sourcesContent":["import type { ResolvedElement } from \"~/types.js\";\nimport type { IBindingsResolver, ResolveElementParams } from \"~/BindingsResolver.js\";\nimport type { InputAstNode } from \"~/ComponentManifestToAstConverter.js\";\nimport { contentEntryCache } from \"./ContentEntryCache.js\";\nimport { environment } from \"~/Environment.js\";\n\n/**\n * Decorator for `IBindingsResolver` that resolves `contentEntry` inputs.\n *\n * The inner resolver evaluates binding expressions against the document state,\n * producing raw values (`{ id, modelId }` references or query params). This\n * decorator then replaces those raw values with pre-resolved CMS entries from\n * a supplied map, or (on the client) triggers async resolution via the\n * `contentEntryCache` singleton.\n *\n * **Server path**: `resolveContentEntries()` pre-fetches all entries, builds\n * the `resolvedEntries` map, and passes it here. The decorator synchronously\n * swaps raw values for resolved entries during render.\n *\n * **Client path (editor preview)**: `resolvedEntries` may be empty. The\n * decorator falls back to `contentEntryCache.resolve()` which kicks off an\n * async fetch; the mobx-observable cache triggers re-render when it lands.\n */\nexport class ContentEntryBindingsResolver implements IBindingsResolver {\n    constructor(\n        private readonly inner: IBindingsResolver,\n        private readonly resolvedEntries: ReadonlyMap<string, unknown> = new Map()\n    ) {}\n\n    resolveElement(params: ResolveElementParams): ResolvedElement[] {\n        const results = this.inner.resolveElement(params);\n\n        for (const instance of results) {\n            this.enrichContentEntryInputs(params.element.id, params.inputAst, instance.inputs);\n        }\n\n        return results;\n    }\n\n    /**\n     * Walk the input AST and replace raw content-entry values with resolved\n     * entries from the map or the module-level cache.\n     */\n    private enrichContentEntryInputs(\n        elementId: string,\n        ast: InputAstNode[],\n        inputs: Record<string, any>\n    ): void {\n        for (const node of ast) {\n            if (node.input.type === \"contentEntry\") {\n                const key = `${elementId}:${node.name}`;\n                const rawValue = inputs[node.name];\n                const list = node.input.list ?? false;\n\n                // 1. Pre-resolved entries map (seeded by server pre-pass).\n                if (this.resolvedEntries.has(key)) {\n                    inputs[node.name] = this.resolvedEntries.get(key);\n                    continue;\n                }\n\n                // 2. Module-level cache (populated by previous renders or\n                //    async resolves on the client).\n                if (contentEntryCache.has(key)) {\n                    inputs[node.name] = contentEntryCache.get(key);\n                    continue;\n                }\n\n                // 3. Client-side async resolution: trigger a background fetch.\n                //    The observable cache write will cause a re-render.\n                if (environment.isClient() && contentEntryCache.getLoader()) {\n                    const cacheKey = `${key}:${JSON.stringify(rawValue ?? null)}`;\n                    contentEntryCache.resolve(cacheKey, rawValue, list);\n                    const cached = contentEntryCache.get(cacheKey);\n                    if (cached !== undefined) {\n                        inputs[node.name] = cached;\n                    }\n                }\n            }\n\n            // Recurse into children (object / object-list nodes).\n            if (node.children.length > 0) {\n                const value = inputs[node.name];\n                if (node.list && Array.isArray(value)) {\n                    for (const item of value) {\n                        if (typeof item === \"object\" && item !== null) {\n                            this.enrichContentEntryInputs(elementId, node.children, item);\n                        }\n                    }\n                } else if (typeof value === \"object\" && value !== null && !Array.isArray(value)) {\n                    this.enrichContentEntryInputs(elementId, node.children, value);\n                }\n            }\n        }\n    }\n}\n"],"names":["ContentEntryBindingsResolver","inner","resolvedEntries","Map","params","results","instance","elementId","ast","inputs","node","key","rawValue","list","contentEntryCache","environment","cacheKey","JSON","cached","undefined","value","Array","item"],"mappings":";;AAuBO,MAAMA;IACT,YACqBC,KAAwB,EACxBC,kBAAgD,IAAIC,KAAK,CAC5E;aAFmBF,KAAK,GAALA;aACAC,eAAe,GAAfA;IAClB;IAEH,eAAeE,MAA4B,EAAqB;QAC5D,MAAMC,UAAU,IAAI,CAAC,KAAK,CAAC,cAAc,CAACD;QAE1C,KAAK,MAAME,YAAYD,QACnB,IAAI,CAAC,wBAAwB,CAACD,OAAO,OAAO,CAAC,EAAE,EAAEA,OAAO,QAAQ,EAAEE,SAAS,MAAM;QAGrF,OAAOD;IACX;IAMQ,yBACJE,SAAiB,EACjBC,GAAmB,EACnBC,MAA2B,EACvB;QACJ,KAAK,MAAMC,QAAQF,IAAK;YACpB,IAAIE,AAAoB,mBAApBA,KAAK,KAAK,CAAC,IAAI,EAAqB;gBACpC,MAAMC,MAAM,GAAGJ,UAAU,CAAC,EAAEG,KAAK,IAAI,EAAE;gBACvC,MAAME,WAAWH,MAAM,CAACC,KAAK,IAAI,CAAC;gBAClC,MAAMG,OAAOH,KAAK,KAAK,CAAC,IAAI,IAAI;gBAGhC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAACC,MAAM;oBAC/BF,MAAM,CAACC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAACC;oBAC7C;gBACJ;gBAIA,IAAIG,kBAAkB,GAAG,CAACH,MAAM;oBAC5BF,MAAM,CAACC,KAAK,IAAI,CAAC,GAAGI,kBAAkB,GAAG,CAACH;oBAC1C;gBACJ;gBAIA,IAAII,YAAY,QAAQ,MAAMD,kBAAkB,SAAS,IAAI;oBACzD,MAAME,WAAW,GAAGL,IAAI,CAAC,EAAEM,KAAK,SAAS,CAACL,YAAY,OAAO;oBAC7DE,kBAAkB,OAAO,CAACE,UAAUJ,UAAUC;oBAC9C,MAAMK,SAASJ,kBAAkB,GAAG,CAACE;oBACrC,IAAIE,AAAWC,WAAXD,QACAT,MAAM,CAACC,KAAK,IAAI,CAAC,GAAGQ;gBAE5B;YACJ;YAGA,IAAIR,KAAK,QAAQ,CAAC,MAAM,GAAG,GAAG;gBAC1B,MAAMU,QAAQX,MAAM,CAACC,KAAK,IAAI,CAAC;gBAC/B,IAAIA,KAAK,IAAI,IAAIW,MAAM,OAAO,CAACD,QAC3B;oBAAA,KAAK,MAAME,QAAQF,MACf,IAAI,AAAgB,YAAhB,OAAOE,QAAqBA,AAAS,SAATA,MAC5B,IAAI,CAAC,wBAAwB,CAACf,WAAWG,KAAK,QAAQ,EAAEY;gBAEhE,OACG,IAAI,AAAiB,YAAjB,OAAOF,SAAsBA,AAAU,SAAVA,SAAkB,CAACC,MAAM,OAAO,CAACD,QACrE,IAAI,CAAC,wBAAwB,CAACb,WAAWG,KAAK,QAAQ,EAAEU;YAEhE;QACJ;IACJ;AACJ"}

package/contentEntry/ContentEntryCache.d.ts

@@ -0,0 +1,46 @@
+import { type ContentEntryLoader, type ResolvedContentEntry } from "./resolveContentEntry.js";
+type RawValue = unknown | unknown[] | null | undefined;
+/**
+ * SDK-level mobx cache for resolved content-entry inputs. Mirrors the CMS
+ * `RefCache` pattern: a singleton observable store that both the server
+ * pre-pass (`resolveAutoLoad`) and the editor preview path can seed / read.
+ *
+ * - **Server / SSR**: `resolveAutoLoad` calls `set(key, resolved)` for every
+ *   entry it pre-resolves. `BindingsResolver.resolveSingleInstance` reads via
+ *   `get(key)` synchronously during render — no React context needed.
+ *
+ * - **Editor preview**: `resolve(key, input, value, loader)` triggers an async
+ *   fetch whose result is written inside a mobx action, so `observer`
+ *   components re-render once it lands. Keyed by a signature of the raw value,
+ *   so when the editor changes the selection/query the key changes and the
+ *   entry is re-resolved.
+ */
+declare class ContentEntryCacheImpl {
+    private cache;
+    private loader;
+    constructor();
+    get(key: string): ResolvedContentEntry | undefined;
+    has(key: string): boolean;
+    set(key: string, value: ResolvedContentEntry): void;
+    /**
+     * Register the CMS data loader that `resolve()` will use for async fetches.
+     * Called once during initialisation (e.g. by `resolveAutoLoad`). The loader
+     * is **not** mobx-observable — it's a plain service reference.
+     */
+    setLoader(loader: ContentEntryLoader): void;
+    /**
+     * Return the registered loader, if any.
+     */
+    getLoader(): ContentEntryLoader | undefined;
+    /**
+     * Lazily resolve `value` under `key`. Idempotent and safe to call during
+     * render: the observable write happens later, inside an action.
+     *
+     * Uses the loader registered via `setLoader()`. If no loader is registered,
+     * the call is a no-op (the raw value will be used instead).
+     */
+    resolve(key: string, value: RawValue, list: boolean): void;
+    clear(): void;
+}
+export declare const contentEntryCache: ContentEntryCacheImpl;
+export {};

package/contentEntry/ContentEntryCache.js

@@ -0,0 +1,50 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { resolveContentEntryValue } from "./resolveContentEntry.js";
+const pending = new Set();
+class ContentEntryCacheImpl {
+    constructor(){
+        this.cache = new Map();
+        makeAutoObservable(this, {
+            setLoader: false,
+            getLoader: false
+        });
+    }
+    get(key) {
+        return this.cache.get(key);
+    }
+    has(key) {
+        return this.cache.has(key);
+    }
+    set(key, value) {
+        runInAction(()=>{
+            this.cache.set(key, value);
+        });
+    }
+    setLoader(loader) {
+        this.loader = loader;
+    }
+    getLoader() {
+        return this.loader;
+    }
+    resolve(key, value, list) {
+        if (this.cache.has(key) || pending.has(key) || !this.loader) return;
+        pending.add(key);
+        resolveContentEntryValue(value, list, this.loader).then((resolved)=>{
+            runInAction(()=>{
+                this.cache.set(key, resolved);
+            });
+            pending.delete(key);
+        }).catch(()=>{
+            pending.delete(key);
+        });
+    }
+    clear() {
+        runInAction(()=>{
+            this.cache.clear();
+        });
+    }
+}
+const contentEntryCache = new ContentEntryCacheImpl();
+export { contentEntryCache };
+
+//# sourceMappingURL=ContentEntryCache.js.map

package/contentEntry/ContentEntryCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentEntry/ContentEntryCache.js","sources":["../../src/contentEntry/ContentEntryCache.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport {\n    resolveContentEntryValue,\n    type ContentEntryLoader,\n    type ResolvedContentEntry\n} from \"./resolveContentEntry.js\";\n\ntype RawValue = unknown | unknown[] | null | undefined;\n\n// Non-observable dedupe set (kept out of the observable class so touching it\n// during render never counts as a mobx mutation-in-render).\nconst pending = new Set<string>();\n\n/**\n * SDK-level mobx cache for resolved content-entry inputs. Mirrors the CMS\n * `RefCache` pattern: a singleton observable store that both the server\n * pre-pass (`resolveAutoLoad`) and the editor preview path can seed / read.\n *\n * - **Server / SSR**: `resolveAutoLoad` calls `set(key, resolved)` for every\n *   entry it pre-resolves. `BindingsResolver.resolveSingleInstance` reads via\n *   `get(key)` synchronously during render — no React context needed.\n *\n * - **Editor preview**: `resolve(key, input, value, loader)` triggers an async\n *   fetch whose result is written inside a mobx action, so `observer`\n *   components re-render once it lands. Keyed by a signature of the raw value,\n *   so when the editor changes the selection/query the key changes and the\n *   entry is re-resolved.\n */\nclass ContentEntryCacheImpl {\n    private cache = new Map<string, ResolvedContentEntry>();\n    private loader: ContentEntryLoader | undefined;\n\n    constructor() {\n        makeAutoObservable(this, {\n            // The loader is a plain service reference, not an observable value.\n            setLoader: false,\n            getLoader: false\n        });\n    }\n\n    get(key: string): ResolvedContentEntry | undefined {\n        return this.cache.get(key);\n    }\n\n    has(key: string): boolean {\n        return this.cache.has(key);\n    }\n\n    set(key: string, value: ResolvedContentEntry): void {\n        runInAction(() => {\n            this.cache.set(key, value);\n        });\n    }\n\n    /**\n     * Register the CMS data loader that `resolve()` will use for async fetches.\n     * Called once during initialisation (e.g. by `resolveAutoLoad`). The loader\n     * is **not** mobx-observable — it's a plain service reference.\n     */\n    setLoader(loader: ContentEntryLoader): void {\n        this.loader = loader;\n    }\n\n    /**\n     * Return the registered loader, if any.\n     */\n    getLoader(): ContentEntryLoader | undefined {\n        return this.loader;\n    }\n\n    /**\n     * Lazily resolve `value` under `key`. Idempotent and safe to call during\n     * render: the observable write happens later, inside an action.\n     *\n     * Uses the loader registered via `setLoader()`. If no loader is registered,\n     * the call is a no-op (the raw value will be used instead).\n     */\n    resolve(key: string, value: RawValue, list: boolean): void {\n        if (this.cache.has(key) || pending.has(key) || !this.loader) {\n            return;\n        }\n        pending.add(key);\n        resolveContentEntryValue(value as any, list, this.loader)\n            .then(resolved => {\n                runInAction(() => {\n                    this.cache.set(key, resolved);\n                });\n                pending.delete(key);\n            })\n            .catch(() => {\n                pending.delete(key);\n            });\n    }\n\n    clear(): void {\n        runInAction(() => {\n            this.cache.clear();\n        });\n    }\n}\n\nexport const contentEntryCache = new ContentEntryCacheImpl();\n"],"names":["pending","Set","ContentEntryCacheImpl","Map","makeAutoObservable","key","value","runInAction","loader","list","resolveContentEntryValue","resolved","contentEntryCache"],"mappings":";;AAWA,MAAMA,UAAU,IAAIC;AAiBpB,MAAMC;IAIF,aAAc;aAHN,KAAK,GAAG,IAAIC;QAIhBC,mBAAmB,IAAI,EAAE;YAErB,WAAW;YACX,WAAW;QACf;IACJ;IAEA,IAAIC,GAAW,EAAoC;QAC/C,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA;IAC1B;IAEA,IAAIA,GAAW,EAAW;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA;IAC1B;IAEA,IAAIA,GAAW,EAAEC,KAA2B,EAAQ;QAChDC,YAAY;YACR,IAAI,CAAC,KAAK,CAAC,GAAG,CAACF,KAAKC;QACxB;IACJ;IAOA,UAAUE,MAA0B,EAAQ;QACxC,IAAI,CAAC,MAAM,GAAGA;IAClB;IAKA,YAA4C;QACxC,OAAO,IAAI,CAAC,MAAM;IACtB;IASA,QAAQH,GAAW,EAAEC,KAAe,EAAEG,IAAa,EAAQ;QACvD,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAACJ,QAAQL,QAAQ,GAAG,CAACK,QAAQ,CAAC,IAAI,CAAC,MAAM,EACvD;QAEJL,QAAQ,GAAG,CAACK;QACZK,yBAAyBJ,OAAcG,MAAM,IAAI,CAAC,MAAM,EACnD,IAAI,CAACE,CAAAA;YACFJ,YAAY;gBACR,IAAI,CAAC,KAAK,CAAC,GAAG,CAACF,KAAKM;YACxB;YACAX,QAAQ,MAAM,CAACK;QACnB,GACC,KAAK,CAAC;YACHL,QAAQ,MAAM,CAACK;QACnB;IACR;IAEA,QAAc;QACVE,YAAY;YACR,IAAI,CAAC,KAAK,CAAC,KAAK;QACpB;IACJ;AACJ;AAEO,MAAMK,oBAAoB,IAAIV"}

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/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;

package/createInput.js

@@ -93,10 +93,17 @@ function createSlotInput(input) {
         ...input
     });
 }
+function createContentEntryInput(input) {
+    return createInput({
+        type: "contentEntry",
+        renderer: "Webiny/ContentEntry",
+        ...input
+    });
+}
 function createInput(input) {
     if (input.onChange) input.onChange = functionConverter.serialize(input.onChange);
     return input;
 }
-export { createBooleanInput, createColorInput, createDateInput, createFileInput, createInput, createLexicalInput, createLongTextInput, createNumberInput, createObjectInput, createRadioInput, createSelectInput, createSlotInput, createTagsInput, createTextInput };
+export { createBooleanInput, createColorInput, createContentEntryInput, createDateInput, createFileInput, createInput, createLexicalInput, createLongTextInput, createNumberInput, createObjectInput, createRadioInput, createSelectInput, createSlotInput, createTagsInput, createTextInput };
 
 //# sourceMappingURL=createInput.js.map