@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/features/modelBuilder/LayoutBuilder.js

@@ -0,0 +1,75 @@
+class LayoutBuilder {
+    constructor(existingLayout = []){
+        this.modifiers = [];
+        this.layout = existingLayout.map((row)=>[
+                ...row
+            ]);
+    }
+    setLayout(layout) {
+        this.layout = layout.map((row)=>[
+                ...row
+            ]);
+        this.modifiers = [];
+        return this;
+    }
+    addModifier(modifier) {
+        this.modifiers.push(modifier);
+        return this;
+    }
+    addField(field, position) {
+        const target = "after" in position ? position.after : position.before;
+        const pos = this.findFieldPosition(target);
+        if (!pos) throw new Error(`Cannot add field "${field}": target field "${target}" not found in layout`);
+        const { rowIndex, colIndex } = pos;
+        const insertIndex = "after" in position ? colIndex + 1 : colIndex;
+        this.layout[rowIndex].splice(insertIndex, 0, field);
+        return this;
+    }
+    addRow(fields) {
+        this.layout.push([
+            ...fields
+        ]);
+        return this;
+    }
+    insertRow(fields, position) {
+        const target = "after" in position ? position.after : position.before;
+        const pos = this.findFieldPosition(target);
+        if (!pos) throw new Error(`Cannot insert row: target field "${target}" not found in layout`);
+        const { rowIndex } = pos;
+        const insertIndex = "after" in position ? rowIndex + 1 : rowIndex;
+        this.layout.splice(insertIndex, 0, [
+            ...fields
+        ]);
+        return this;
+    }
+    getSnapshot() {
+        return {
+            layout: this.layout.map((row)=>[
+                    ...row
+                ]),
+            modifiers: [
+                ...this.modifiers
+            ]
+        };
+    }
+    build() {
+        for (const modifier of this.modifiers)modifier(this);
+        this.modifiers = [];
+        return this.layout.map((row)=>[
+                ...row
+            ]);
+    }
+    findFieldPosition(field) {
+        for(let rowIndex = 0; rowIndex < this.layout.length; rowIndex++){
+            const colIndex = this.layout[rowIndex].indexOf(field);
+            if (-1 !== colIndex) return {
+                rowIndex,
+                colIndex
+            };
+        }
+        return null;
+    }
+}
+export { LayoutBuilder };
+
+//# sourceMappingURL=LayoutBuilder.js.map

package/features/modelBuilder/LayoutBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/LayoutBuilder.js","sources":["../../../src/features/modelBuilder/LayoutBuilder.ts"],"sourcesContent":["type LayoutModifier = (builder: LayoutBuilder) => LayoutBuilder | void;\n\n/**\n * LayoutBuilder provides a fluent API for modifying field layouts.\n * Supports adding fields to existing rows and inserting new rows at specific positions.\n * Callbacks can be queued and executed lazily for efficient composition.\n */\nexport class LayoutBuilder {\n    private layout: string[][];\n    private modifiers: LayoutModifier[] = [];\n\n    constructor(existingLayout: string[][] = []) {\n        // Deep clone to avoid mutating the original\n        this.layout = existingLayout.map(row => [...row]);\n    }\n\n    /**\n     * Set the layout from an array.\n     * This replaces the current layout and clears any queued modifiers.\n     */\n    setLayout(layout: string[][]): this {\n        this.layout = layout.map(row => [...row]);\n        // Clear modifiers when directly setting layout\n        this.modifiers = [];\n        return this;\n    }\n\n    /**\n     * Add a layout modifier callback to be executed later.\n     * Modifiers are queued and executed only when build() is called.\n     */\n    addModifier(modifier: LayoutModifier): this {\n        this.modifiers.push(modifier);\n        return this;\n    }\n\n    /**\n     * Add a field to the same row as the target field.\n     *\n     * @param field - The field to add\n     * @param position - Position relative to target field\n     * @throws Error if target field is not found\n     */\n    addField(field: string, position: { after: string } | { before: string }): this {\n        const target = \"after\" in position ? position.after : position.before;\n        const pos = this.findFieldPosition(target);\n\n        if (!pos) {\n            throw new Error(\n                `Cannot add field \"${field}\": target field \"${target}\" not found in layout`\n            );\n        }\n\n        const { rowIndex, colIndex } = pos;\n        const insertIndex = \"after\" in position ? colIndex + 1 : colIndex;\n\n        this.layout[rowIndex].splice(insertIndex, 0, field);\n\n        return this;\n    }\n\n    /**\n     * Add a new row at the end of the layout.\n     *\n     * @param fields - Array of field IDs for the new row\n     */\n    addRow(fields: string[]): this {\n        this.layout.push([...fields]);\n        return this;\n    }\n\n    /**\n     * Insert a new row before or after the row containing the target field.\n     *\n     * @param fields - Array of field IDs for the new row\n     * @param position - Position relative to target field's row\n     * @throws Error if target field is not found\n     */\n    insertRow(fields: string[], position: { after: string } | { before: string }): this {\n        const target = \"after\" in position ? position.after : position.before;\n        const pos = this.findFieldPosition(target);\n\n        if (!pos) {\n            throw new Error(`Cannot insert row: target field \"${target}\" not found in layout`);\n        }\n\n        const { rowIndex } = pos;\n        const insertIndex = \"after\" in position ? rowIndex + 1 : rowIndex;\n\n        this.layout.splice(insertIndex, 0, [...fields]);\n\n        return this;\n    }\n\n    /**\n     * Get the current layout without executing modifiers.\n     * Used for cloning the builder state.\n     */\n    getSnapshot(): { layout: string[][]; modifiers: LayoutModifier[] } {\n        return {\n            layout: this.layout.map(row => [...row]),\n            modifiers: [...this.modifiers]\n        };\n    }\n\n    /**\n     * Build the final layout array.\n     * Executes all queued modifiers before building.\n     */\n    build(): string[][] {\n        // Execute all queued modifiers\n        for (const modifier of this.modifiers) {\n            modifier(this);\n        }\n        // Clear modifiers after execution\n        this.modifiers = [];\n\n        return this.layout.map(row => [...row]);\n    }\n\n    /**\n     * Find the position of a field in the layout.\n     *\n     * @param field - The field ID to find\n     * @returns Position object or null if not found\n     */\n    private findFieldPosition(field: string): { rowIndex: number; colIndex: number } | null {\n        for (let rowIndex = 0; rowIndex < this.layout.length; rowIndex++) {\n            const colIndex = this.layout[rowIndex].indexOf(field);\n            if (colIndex !== -1) {\n                return { rowIndex, colIndex };\n            }\n        }\n        return null;\n    }\n}\n"],"names":["LayoutBuilder","existingLayout","row","layout","modifier","field","position","target","pos","Error","rowIndex","colIndex","insertIndex","fields"],"mappings":"AAOO,MAAMA;IAIT,YAAYC,iBAA6B,EAAE,CAAE;aAFrC,SAAS,GAAqB,EAAE;QAIpC,IAAI,CAAC,MAAM,GAAGA,eAAe,GAAG,CAACC,CAAAA,MAAO;mBAAIA;aAAI;IACpD;IAMA,UAAUC,MAAkB,EAAQ;QAChC,IAAI,CAAC,MAAM,GAAGA,OAAO,GAAG,CAACD,CAAAA,MAAO;mBAAIA;aAAI;QAExC,IAAI,CAAC,SAAS,GAAG,EAAE;QACnB,OAAO,IAAI;IACf;IAMA,YAAYE,QAAwB,EAAQ;QACxC,IAAI,CAAC,SAAS,CAAC,IAAI,CAACA;QACpB,OAAO,IAAI;IACf;IASA,SAASC,KAAa,EAAEC,QAAgD,EAAQ;QAC5E,MAAMC,SAAS,WAAWD,WAAWA,SAAS,KAAK,GAAGA,SAAS,MAAM;QACrE,MAAME,MAAM,IAAI,CAAC,iBAAiB,CAACD;QAEnC,IAAI,CAACC,KACD,MAAM,IAAIC,MACN,CAAC,kBAAkB,EAAEJ,MAAM,iBAAiB,EAAEE,OAAO,qBAAqB,CAAC;QAInF,MAAM,EAAEG,QAAQ,EAAEC,QAAQ,EAAE,GAAGH;QAC/B,MAAMI,cAAc,WAAWN,WAAWK,WAAW,IAAIA;QAEzD,IAAI,CAAC,MAAM,CAACD,SAAS,CAAC,MAAM,CAACE,aAAa,GAAGP;QAE7C,OAAO,IAAI;IACf;IAOA,OAAOQ,MAAgB,EAAQ;QAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;eAAIA;SAAO;QAC5B,OAAO,IAAI;IACf;IASA,UAAUA,MAAgB,EAAEP,QAAgD,EAAQ;QAChF,MAAMC,SAAS,WAAWD,WAAWA,SAAS,KAAK,GAAGA,SAAS,MAAM;QACrE,MAAME,MAAM,IAAI,CAAC,iBAAiB,CAACD;QAEnC,IAAI,CAACC,KACD,MAAM,IAAIC,MAAM,CAAC,iCAAiC,EAAEF,OAAO,qBAAqB,CAAC;QAGrF,MAAM,EAAEG,QAAQ,EAAE,GAAGF;QACrB,MAAMI,cAAc,WAAWN,WAAWI,WAAW,IAAIA;QAEzD,IAAI,CAAC,MAAM,CAAC,MAAM,CAACE,aAAa,GAAG;eAAIC;SAAO;QAE9C,OAAO,IAAI;IACf;IAMA,cAAmE;QAC/D,OAAO;YACH,QAAQ,IAAI,CAAC,MAAM,CAAC,GAAG,CAACX,CAAAA,MAAO;uBAAIA;iBAAI;YACvC,WAAW;mBAAI,IAAI,CAAC,SAAS;aAAC;QAClC;IACJ;IAMA,QAAoB;QAEhB,KAAK,MAAME,YAAY,IAAI,CAAC,SAAS,CACjCA,SAAS,IAAI;QAGjB,IAAI,CAAC,SAAS,GAAG,EAAE;QAEnB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAACF,CAAAA,MAAO;mBAAIA;aAAI;IAC1C;IAQQ,kBAAkBG,KAAa,EAAiD;QACpF,IAAK,IAAIK,WAAW,GAAGA,WAAW,IAAI,CAAC,MAAM,CAAC,MAAM,EAAEA,WAAY;YAC9D,MAAMC,WAAW,IAAI,CAAC,MAAM,CAACD,SAAS,CAAC,OAAO,CAACL;YAC/C,IAAIM,AAAa,OAAbA,UACA,OAAO;gBAAED;gBAAUC;YAAS;QAEpC;QACA,OAAO;IACX;AACJ"}

package/features/modelBuilder/abstractions.d.ts

@@ -0,0 +1,41 @@
+import type { PrivateModelBuilder } from "./models/PrivateModelBuilder.js";
+import type { PublicModelBuilder } from "./models/PublicModelBuilder.js";
+import type { IModelBuilderPrivateInput, IModelBuilderPublicInput } from "./models/ModelBuilder.js";
+/**
+ * Augmentable field builder registry. Provides access to all registered field types.
+ */
+export interface IFieldBuilderRegistry {
+    /**
+     * Mark the next field creation as an extension.
+     * When extending, the registry will create a temporary builder marked with _extendMode,
+     * and BaseModelBuilder will merge its operations into the existing field.
+     */
+    extend(): this;
+}
+/**
+ * @internal Do not export this abstraction. We don't want external developers to use it.
+ */
+export declare const FieldBuilderRegistry: import("@webiny/di").Abstraction<FieldBuilderRegistry.Interface>;
+export declare namespace FieldBuilderRegistry {
+    interface Interface extends IFieldBuilderRegistry {
+    }
+}
+/**
+ * Unified Model abstraction
+ * External developers implement this to provide both public and private models
+ */
+export interface IModelBuilder {
+    private(input: IModelBuilderPrivateInput): PrivateModelBuilder;
+    public(input: IModelBuilderPublicInput): PublicModelBuilder;
+}
+export interface IModelFactory {
+    execute(builder: IModelBuilder): Promise<PrivateModelBuilder[] | PublicModelBuilder[]>;
+}
+/** Provide code-defined content models. */
+export declare const ModelFactory: import("@webiny/di").Abstraction<IModelFactory>;
+export declare namespace ModelFactory {
+    type Interface = IModelFactory;
+    type Return = Promise<PrivateModelBuilder[] | PublicModelBuilder[]>;
+    type Builder = IModelBuilder;
+    type FieldBuilder = FieldBuilderRegistry.Interface;
+}

package/features/modelBuilder/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const FieldBuilderRegistry = createAbstraction("FieldBuilderRegistry");
+const ModelFactory = createAbstraction("Cms/ModelFactory");
+export { FieldBuilderRegistry, ModelFactory };
+
+//# sourceMappingURL=abstractions.js.map

package/features/modelBuilder/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/abstractions.js","sources":["../../../src/features/modelBuilder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { PrivateModelBuilder } from \"./models/PrivateModelBuilder.js\";\nimport type { PublicModelBuilder } from \"./models/PublicModelBuilder.js\";\nimport type { IModelBuilderPrivateInput, IModelBuilderPublicInput } from \"./models/ModelBuilder.js\";\n\n/**\n * Augmentable field builder registry. Provides access to all registered field types.\n */\nexport interface IFieldBuilderRegistry {\n    /**\n     * Mark the next field creation as an extension.\n     * When extending, the registry will create a temporary builder marked with _extendMode,\n     * and BaseModelBuilder will merge its operations into the existing field.\n     */\n    extend(): this;\n\n    // Field types will be added via module augmentation by field type implementations\n    // Example: text(): ITextFieldBuilder;\n}\n\n/**\n * @internal Do not export this abstraction. We don't want external developers to use it.\n */\nexport const FieldBuilderRegistry =\n    createAbstraction<FieldBuilderRegistry.Interface>(\"FieldBuilderRegistry\");\n\nexport namespace FieldBuilderRegistry {\n    export interface Interface extends IFieldBuilderRegistry {}\n}\n\n/**\n * Unified Model abstraction\n * External developers implement this to provide both public and private models\n */\n\nexport interface IModelBuilder {\n    private(input: IModelBuilderPrivateInput): PrivateModelBuilder;\n    public(input: IModelBuilderPublicInput): PublicModelBuilder;\n}\n\nexport interface IModelFactory {\n    execute(builder: IModelBuilder): Promise<PrivateModelBuilder[] | PublicModelBuilder[]>;\n}\n\n/** Provide code-defined content models. */\nexport const ModelFactory = createAbstraction<IModelFactory>(\"Cms/ModelFactory\");\nexport namespace ModelFactory {\n    export type Interface = IModelFactory;\n    export type Return = Promise<PrivateModelBuilder[] | PublicModelBuilder[]>;\n    export type Builder = IModelBuilder;\n    export type FieldBuilder = FieldBuilderRegistry.Interface;\n}\n"],"names":["FieldBuilderRegistry","createAbstraction","ModelFactory"],"mappings":";AAuBO,MAAMA,uBACTC,kBAAkD;AAqB/C,MAAMC,eAAeD,kBAAiC"}

package/features/modelBuilder/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const ModelBuilderFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/modelBuilder/feature.js

@@ -0,0 +1,52 @@
+import { createFeature } from "@webiny/feature/api";
+import { FieldBuilderRegistry } from "./fields/FieldBuilderRegistry.js";
+import { TextFieldType } from "./fields/TextFieldType.js";
+import { LongTextFieldType } from "./fields/LongTextFieldType.js";
+import { RichTextFieldType } from "./fields/RichTextFieldType.js";
+import { ObjectFieldType } from "./fields/ObjectFieldType.js";
+import { RefFieldType } from "./fields/RefFieldType.js";
+import { DynamicZoneFieldType } from "./fields/DynamicZoneFieldType.js";
+import { NumberFieldType } from "./fields/NumberFieldType.js";
+import { BooleanFieldType } from "./fields/BooleanFieldType.js";
+import { FileFieldType } from "./fields/FileFieldType.js";
+import { DateTimeFieldType } from "./fields/DateTimeFieldType.js";
+import { JsonFieldType } from "./fields/JsonFieldType.js";
+import { SearchableJsonFieldType } from "./fields/SearchableJsonFieldType.js";
+import { FieldBuilderRegistry as external_abstractions_js_FieldBuilderRegistry, ModelFactory } from "./abstractions.js";
+import { AccessControl } from "../shared/abstractions.js";
+import { ModelsProvider } from "./models/abstractions.js";
+import { ModelsProvider as ModelsProvider_js_ModelsProvider } from "./models/ModelsProvider.js";
+import { UiSeparatorFieldType } from "./fields/UiSeparatorFieldType.js";
+import { UiAlertFieldType } from "./fields/UiAlertFieldType.js";
+import { UiTabsFieldType } from "./fields/UiTabsFieldType.js";
+const ModelBuilderFeature = createFeature({
+    name: "ModelBuilder",
+    register (container) {
+        container.register(TextFieldType);
+        container.register(LongTextFieldType);
+        container.register(RichTextFieldType);
+        container.register(ObjectFieldType);
+        container.register(RefFieldType);
+        container.register(DynamicZoneFieldType);
+        container.register(NumberFieldType);
+        container.register(BooleanFieldType);
+        container.register(FileFieldType);
+        container.register(DateTimeFieldType);
+        container.register(JsonFieldType);
+        container.register(SearchableJsonFieldType);
+        container.register(UiSeparatorFieldType);
+        container.register(UiAlertFieldType);
+        container.register(UiTabsFieldType);
+        container.register(FieldBuilderRegistry).inSingletonScope();
+        container.registerFactory(ModelsProvider, ()=>{
+            let accessControl;
+            try {
+                accessControl = container.resolve(AccessControl);
+            } catch  {}
+            return new ModelsProvider_js_ModelsProvider(()=>container.resolveAll(ModelFactory), container.resolve(external_abstractions_js_FieldBuilderRegistry), accessControl);
+        });
+    }
+});
+export { ModelBuilderFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/modelBuilder/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/feature.js","sources":["../../../src/features/modelBuilder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FieldBuilderRegistry } from \"./fields/FieldBuilderRegistry.js\";\nimport { TextFieldType } from \"./fields/TextFieldType.js\";\nimport { LongTextFieldType } from \"./fields/LongTextFieldType.js\";\nimport { RichTextFieldType } from \"./fields/RichTextFieldType.js\";\nimport { ObjectFieldType } from \"./fields/ObjectFieldType.js\";\nimport { RefFieldType } from \"./fields/RefFieldType.js\";\nimport { DynamicZoneFieldType } from \"./fields/DynamicZoneFieldType.js\";\nimport { NumberFieldType } from \"./fields/NumberFieldType.js\";\nimport { BooleanFieldType } from \"./fields/BooleanFieldType.js\";\nimport { FileFieldType } from \"./fields/FileFieldType.js\";\nimport { DateTimeFieldType } from \"./fields/DateTimeFieldType.js\";\nimport { JsonFieldType } from \"./fields/JsonFieldType.js\";\nimport { SearchableJsonFieldType } from \"./fields/SearchableJsonFieldType.js\";\n// import { LocationFieldType } from \"./fields/LocationFieldType.js\";\nimport { FieldBuilderRegistry as FieldsRegistryAbstraction, ModelFactory } from \"./abstractions.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { ModelsProvider as ModelsProviderAbstraction } from \"./models/abstractions.js\";\nimport { ModelsProvider } from \"./models/ModelsProvider.js\";\nimport { UiSeparatorFieldType } from \"./fields/UiSeparatorFieldType.js\";\nimport { UiAlertFieldType } from \"./fields/UiAlertFieldType.js\";\nimport { UiTabsFieldType } from \"./fields/UiTabsFieldType.js\";\n\nexport const ModelBuilderFeature = createFeature({\n    name: \"ModelBuilder\",\n    register(container) {\n        // Register core field types\n        container.register(TextFieldType);\n        container.register(LongTextFieldType);\n        container.register(RichTextFieldType);\n        container.register(ObjectFieldType);\n        container.register(RefFieldType);\n        container.register(DynamicZoneFieldType);\n        container.register(NumberFieldType);\n        container.register(BooleanFieldType);\n        container.register(FileFieldType);\n        container.register(DateTimeFieldType);\n        container.register(JsonFieldType);\n        container.register(SearchableJsonFieldType);\n        container.register(UiSeparatorFieldType);\n        container.register(UiAlertFieldType);\n        container.register(UiTabsFieldType);\n        // container.register(LocationFieldType);\n\n        // Register field builder registry (will automatically get all FieldType implementations)\n        container.register(FieldBuilderRegistry).inSingletonScope();\n\n        // Register unified models provider\n        container.registerFactory(ModelsProviderAbstraction, () => {\n            let accessControl: AccessControl.Interface | undefined = undefined;\n            try {\n                // TODO: add `container.resolveOptional`\n                accessControl = container.resolve(AccessControl);\n            } catch {\n                // It's an optional dependency!\n            }\n\n            return new ModelsProvider(\n                // TODO: introduce a `lazy: true` dependency modifier, which will inject a getter.\n                () => container.resolveAll(ModelFactory),\n                container.resolve(FieldsRegistryAbstraction),\n                accessControl\n            );\n        });\n    }\n});\n"],"names":["ModelBuilderFeature","createFeature","container","TextFieldType","LongTextFieldType","RichTextFieldType","ObjectFieldType","RefFieldType","DynamicZoneFieldType","NumberFieldType","BooleanFieldType","FileFieldType","DateTimeFieldType","JsonFieldType","SearchableJsonFieldType","UiSeparatorFieldType","UiAlertFieldType","UiTabsFieldType","FieldBuilderRegistry","ModelsProviderAbstraction","accessControl","AccessControl","ModelsProvider","ModelFactory","FieldsRegistryAbstraction"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuBO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QACnBV,UAAU,QAAQ,CAACW;QACnBX,UAAU,QAAQ,CAACY;QACnBZ,UAAU,QAAQ,CAACa;QACnBb,UAAU,QAAQ,CAACc;QACnBd,UAAU,QAAQ,CAACe;QAInBf,UAAU,QAAQ,CAACgB,sBAAsB,gBAAgB;QAGzDhB,UAAU,eAAe,CAACiB,gBAA2B;YACjD,IAAIC;YACJ,IAAI;gBAEAA,gBAAgBlB,UAAU,OAAO,CAACmB;YACtC,EAAE,OAAM,CAER;YAEA,OAAO,IAAIC,iCAEP,IAAMpB,UAAU,UAAU,CAACqB,eAC3BrB,UAAU,OAAO,CAACsB,gDAClBJ;QAER;IACJ;AACJ"}

package/features/modelBuilder/fields/BaseFieldBuilder.d.ts

@@ -0,0 +1,39 @@
+import type { CmsModelField, CmsModelLayoutCell } from "../../../types/index.js";
+export interface DataFieldBuildResult {
+    type: "data";
+    field: CmsModelField;
+}
+export interface LayoutFieldBuildResult {
+    type: "layout";
+    layoutCell: CmsModelLayoutCell;
+    fields?: CmsModelField[];
+}
+export type FieldBuildResult = DataFieldBuildResult | LayoutFieldBuildResult;
+export interface BaseFieldBuilderConfig {
+    label: string;
+    help?: string | null;
+    description?: string | null;
+    note?: string | null;
+    _fieldId?: string;
+}
+/**
+ * Minimal shared base class for all field builders (data and layout).
+ */
+export declare abstract class BaseFieldBuilder<TType extends string = string> {
+    readonly type: TType;
+    private _fieldSubType?;
+    protected config: BaseFieldBuilderConfig;
+    get subType(): string | undefined;
+    constructor(type: TType, label?: string);
+    label(text: string): this;
+    help(text: string): this;
+    description(text: string): this;
+    note(text: string): this;
+    fieldId(id: string): this;
+    protected setSubType(subType: string): this;
+    /**
+     * Build the final field result.
+     * @internal
+     */
+    abstract build(): FieldBuildResult;
+}

package/features/modelBuilder/fields/BaseFieldBuilder.js

@@ -0,0 +1,41 @@
+class BaseFieldBuilder {
+    get subType() {
+        return this._fieldSubType;
+    }
+    constructor(type, label){
+        this.type = type;
+        this.config = {
+            label: label || "",
+            help: null,
+            description: null,
+            note: null
+        };
+    }
+    label(text) {
+        this.config.label = text;
+        return this;
+    }
+    help(text) {
+        this.config.help = text;
+        return this;
+    }
+    description(text) {
+        this.config.description = text;
+        return this;
+    }
+    note(text) {
+        this.config.note = text;
+        return this;
+    }
+    fieldId(id) {
+        this.config._fieldId = id;
+        return this;
+    }
+    setSubType(subType) {
+        this._fieldSubType = subType;
+        return this;
+    }
+}
+export { BaseFieldBuilder };
+
+//# sourceMappingURL=BaseFieldBuilder.js.map

package/features/modelBuilder/fields/BaseFieldBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/BaseFieldBuilder.js","sources":["../../../../src/features/modelBuilder/fields/BaseFieldBuilder.ts"],"sourcesContent":["import type { CmsModelField, CmsModelLayoutCell } from \"~/types/index.js\";\n\nexport interface DataFieldBuildResult {\n    type: \"data\";\n    field: CmsModelField;\n}\n\nexport interface LayoutFieldBuildResult {\n    type: \"layout\";\n    layoutCell: CmsModelLayoutCell;\n    fields?: CmsModelField[];\n}\n\nexport type FieldBuildResult = DataFieldBuildResult | LayoutFieldBuildResult;\n\nexport interface BaseFieldBuilderConfig {\n    label: string;\n    help?: string | null;\n    description?: string | null;\n    note?: string | null;\n    _fieldId?: string;\n}\n\n/**\n * Minimal shared base class for all field builders (data and layout).\n */\nexport abstract class BaseFieldBuilder<TType extends string = string> {\n    public readonly type: TType;\n    private _fieldSubType?: string;\n    protected config: BaseFieldBuilderConfig;\n\n    public get subType(): string | undefined {\n        return this._fieldSubType;\n    }\n\n    public constructor(type: TType, label?: string) {\n        this.type = type;\n        this.config = {\n            label: label || \"\",\n            help: null,\n            description: null,\n            note: null\n        };\n    }\n\n    public label(text: string): this {\n        this.config.label = text;\n        return this;\n    }\n\n    public help(text: string): this {\n        this.config.help = text;\n        return this;\n    }\n\n    public description(text: string): this {\n        this.config.description = text;\n        return this;\n    }\n\n    public note(text: string): this {\n        this.config.note = text;\n        return this;\n    }\n\n    public fieldId(id: string): this {\n        this.config._fieldId = id;\n        return this;\n    }\n\n    protected setSubType(subType: string): this {\n        this._fieldSubType = subType;\n        return this;\n    }\n\n    /**\n     * Build the final field result.\n     * @internal\n     */\n    public abstract build(): FieldBuildResult;\n}\n"],"names":["BaseFieldBuilder","type","label","text","id","subType"],"mappings":"AA0BO,MAAeA;IAKlB,IAAW,UAA8B;QACrC,OAAO,IAAI,CAAC,aAAa;IAC7B;IAEA,YAAmBC,IAAW,EAAEC,KAAc,CAAE;QAC5C,IAAI,CAAC,IAAI,GAAGD;QACZ,IAAI,CAAC,MAAM,GAAG;YACV,OAAOC,SAAS;YAChB,MAAM;YACN,aAAa;YACb,MAAM;QACV;IACJ;IAEO,MAAMC,IAAY,EAAQ;QAC7B,IAAI,CAAC,MAAM,CAAC,KAAK,GAAGA;QACpB,OAAO,IAAI;IACf;IAEO,KAAKA,IAAY,EAAQ;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,GAAGA;QACnB,OAAO,IAAI;IACf;IAEO,YAAYA,IAAY,EAAQ;QACnC,IAAI,CAAC,MAAM,CAAC,WAAW,GAAGA;QAC1B,OAAO,IAAI;IACf;IAEO,KAAKA,IAAY,EAAQ;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,GAAGA;QACnB,OAAO,IAAI;IACf;IAEO,QAAQC,EAAU,EAAQ;QAC7B,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAGA;QACvB,OAAO,IAAI;IACf;IAEU,WAAWC,OAAe,EAAQ;QACxC,IAAI,CAAC,aAAa,GAAGA;QACrB,OAAO,IAAI;IACf;AAOJ"}

package/features/modelBuilder/fields/BooleanFieldType.d.ts

@@ -0,0 +1,18 @@
+import { type IFieldTypeFactory } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+export interface IBooleanFieldBuilder extends DataFieldBuilder<"boolean"> {
+    defaultValue(value: boolean): this;
+}
+declare class BooleanFieldTypeFactory implements IFieldTypeFactory {
+    readonly type = "boolean";
+    create(): IBooleanFieldBuilder;
+}
+export declare const BooleanFieldType: typeof BooleanFieldTypeFactory & {
+    __abstraction: import("@webiny/di").Abstraction<IFieldTypeFactory>;
+};
+declare module "../abstractions.js" {
+    interface IFieldBuilderRegistry {
+        boolean(): IBooleanFieldBuilder;
+    }
+}
+export {};

package/features/modelBuilder/fields/BooleanFieldType.js

@@ -0,0 +1,27 @@
+import { FieldType } from "./abstractions.js";
+import { DataFieldBuilder } from "./FieldBuilder.js";
+class BooleanFieldBuilder extends DataFieldBuilder {
+    constructor(){
+        super("boolean");
+    }
+    defaultValue(value) {
+        this.config.settings = this.config.settings || {};
+        this.config.settings.defaultValue = value;
+        return this;
+    }
+}
+class BooleanFieldTypeFactory {
+    create() {
+        return new BooleanFieldBuilder();
+    }
+    constructor(){
+        this.type = "boolean";
+    }
+}
+const BooleanFieldType = FieldType.createImplementation({
+    implementation: BooleanFieldTypeFactory,
+    dependencies: []
+});
+export { BooleanFieldType };
+
+//# sourceMappingURL=BooleanFieldType.js.map

package/features/modelBuilder/fields/BooleanFieldType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/modelBuilder/fields/BooleanFieldType.js","sources":["../../../../src/features/modelBuilder/fields/BooleanFieldType.ts"],"sourcesContent":["import { FieldType, type IFieldTypeFactory } from \"./abstractions.js\";\nimport { DataFieldBuilder } from \"./FieldBuilder.js\";\n\nexport interface IBooleanFieldBuilder extends DataFieldBuilder<\"boolean\"> {\n    defaultValue(value: boolean): this;\n}\n\nclass BooleanFieldBuilder extends DataFieldBuilder<\"boolean\"> implements IBooleanFieldBuilder {\n    public constructor() {\n        super(\"boolean\");\n    }\n\n    override defaultValue(value: boolean): this {\n        this.config.settings = this.config.settings || {};\n        this.config.settings.defaultValue = value;\n        return this;\n    }\n}\n\nclass BooleanFieldTypeFactory implements IFieldTypeFactory {\n    readonly type = \"boolean\";\n\n    create(): IBooleanFieldBuilder {\n        return new BooleanFieldBuilder();\n    }\n}\n\nexport const BooleanFieldType = FieldType.createImplementation({\n    implementation: BooleanFieldTypeFactory,\n    dependencies: []\n});\n\n// Module augmentation for TypeScript autocomplete\ndeclare module \"../abstractions.js\" {\n    interface IFieldBuilderRegistry {\n        boolean(): IBooleanFieldBuilder;\n    }\n}\n"],"names":["BooleanFieldBuilder","DataFieldBuilder","value","BooleanFieldTypeFactory","BooleanFieldType","FieldType"],"mappings":";;AAOA,MAAMA,4BAA4BC;IAC9B,aAAqB;QACjB,KAAK,CAAC;IACV;IAES,aAAaC,KAAc,EAAQ;QACxC,IAAI,CAAC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC;QAChD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,GAAGA;QACpC,OAAO,IAAI;IACf;AACJ;AAEA,MAAMC;IAGF,SAA+B;QAC3B,OAAO,IAAIH;IACf;;aAJS,IAAI,GAAG;;AAKpB;AAEO,MAAMI,mBAAmBC,UAAU,oBAAoB,CAAC;IAC3D,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/modelBuilder/fields/DataFieldBuilder.d.ts

@@ -0,0 +1,221 @@
+import type { CmsModelField, CmsModelFieldPredefinedValues, CmsModelFieldValidation } from "../../../types/index.js";
+import { BaseFieldBuilder, type DataFieldBuildResult } from "./BaseFieldBuilder.js";
+export interface FieldBuilderConfig extends Omit<CmsModelField, "id" | "fieldId" | "storageId" | "type"> {
+    _storageId?: string;
+    _fieldId?: string;
+    description?: string | null;
+    note?: string | null;
+}
+/**
+ * Augmentable renderer registry. Each entry maps a renderer name to its applicable field type(s) and settings.
+ */
+export interface IFieldRendererRegistry {
+    switch: {
+        fieldType: "boolean";
+        settings: undefined;
+    };
+    checkboxes: {
+        fieldType: "text" | "number";
+        settings: undefined;
+    };
+    dateTimeInput: {
+        fieldType: "datetime";
+        settings: undefined;
+    };
+    dateTimeInputs: {
+        fieldType: "datetime";
+        settings?: {
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    dynamicZone: {
+        fieldType: "dynamicZone";
+        settings?: {
+            open?: boolean;
+        };
+    };
+    hidden: {
+        fieldType: string;
+        settings: undefined;
+    };
+    lexicalEditor: {
+        fieldType: "rich-text";
+        settings: undefined;
+    };
+    lexicalEditors: {
+        fieldType: "rich-text";
+        settings?: {
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    textarea: {
+        fieldType: "long-text";
+        settings: undefined;
+    };
+    textareas: {
+        fieldType: "long-text";
+        settings: {
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    numberInput: {
+        fieldType: "number";
+        settings: undefined;
+    };
+    numberInputs: {
+        fieldType: "number";
+        settings?: {
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    objectAccordionSingle: {
+        fieldType: "object";
+        settings?: {
+            open?: boolean;
+        };
+    };
+    objectAccordionMultiple: {
+        fieldType: "object";
+        settings?: {
+            open?: boolean;
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    passthrough: {
+        fieldType: string;
+        settings: undefined;
+    };
+    radioButtons: {
+        fieldType: "text" | "number";
+        settings: undefined;
+    };
+    refDialogSingle: {
+        fieldType: "ref";
+        settings: undefined;
+    };
+    refDialogMultiple: {
+        fieldType: "ref";
+        settings?: {
+            newItemPosition?: "first" | "last";
+        };
+    };
+    refAutocompleteSingle: {
+        fieldType: "ref";
+        settings: undefined;
+    };
+    refAutocompleteMultiple: {
+        fieldType: "ref";
+        settings: undefined;
+    };
+    refCheckboxes: {
+        fieldType: "ref";
+        settings: undefined;
+    };
+    refRadioButtons: {
+        fieldType: "ref";
+        settings: undefined;
+    };
+    dropdown: {
+        fieldType: "text" | "number";
+        settings: undefined;
+    };
+    tags: {
+        fieldType: "text";
+        settings: undefined;
+    };
+    textInput: {
+        fieldType: "text";
+        settings: undefined;
+    };
+    textInputs: {
+        fieldType: "text";
+        settings?: {
+            multiValue?: {
+                addValueButtonLabel?: string;
+            };
+        };
+    };
+    file: {
+        fieldType: "file";
+        settings?: {
+            imagesOnly?: boolean;
+        };
+    };
+    files: {
+        fieldType: "file";
+        settings?: {
+            imagesOnly?: boolean;
+        };
+    };
+    uiSeparator: {
+        fieldType: "ui";
+        settings: undefined;
+    };
+    uiAlert: {
+        fieldType: "ui";
+        settings: {
+            type: "info" | "success" | "warning" | "danger";
+        };
+    };
+    uiTabs: {
+        fieldType: "ui";
+        settings: undefined;
+    };
+}
+/**
+ * Extracts renderer names valid for the given field type.
+ * When TType is a broad `string`, all renderer names are returned.
+ */
+export type FieldRendererName<TType extends string = string> = string extends TType ? keyof IFieldRendererRegistry & string : {
+    [K in keyof IFieldRendererRegistry]: TType extends IFieldRendererRegistry[K]["fieldType"] ? K : never;
+}[keyof IFieldRendererRegistry] & string;
+export type FieldRendererSettings<TName extends string> = TName extends keyof IFieldRendererRegistry ? IFieldRendererRegistry[TName]["settings"] : Record<string, any> | undefined;
+/**
+ * DataFieldBuilder class for data fields that produce CmsModelField instances.
+ * Provides storageId, list, validation, renderer, and other data-field methods.
+ */
+export declare class DataFieldBuilder<TType extends string = string> extends BaseFieldBuilder<TType> {
+    protected config: FieldBuilderConfig;
+    constructor(type: TType, label?: string);
+    placeholder(text: string): this;
+    storageId(id: string): this;
+    defaultValue(value: any): this;
+    list(): this;
+    tags(tags: string[]): this;
+    /**
+     * List validators - these methods are available after calling list()
+     */
+    listMinLength(value: number, message?: string): this;
+    listMaxLength(value: number, message?: string): this;
+    /**
+     * Add a validation rule to this field.
+     * This method is protected and should only be used by field-specific validator methods.
+     * @internal
+     */
+    protected validation(validation: CmsModelFieldValidation): this;
+    /**
+     * Add a list validation rule to this field (for list fields).
+     * This method is protected and should only be used by field-specific validator methods.
+     * @internal
+     */
+    protected listValidation(validation: CmsModelFieldValidation): this;
+    predefinedValues(values: CmsModelFieldPredefinedValues["values"]): this;
+    renderer<TName extends FieldRendererName<TType>>(name: TName, ...args: undefined extends FieldRendererSettings<TName> ? [settings?: FieldRendererSettings<TName>] : FieldRendererSettings<TName> extends undefined ? [] : [settings: FieldRendererSettings<TName>]): this;
+    settings(settings: Record<string, any>): this;
+    /**
+     * Build the final CmsModelField
+     * @internal
+     */
+    build(): DataFieldBuildResult;
+    private getFieldType;
+}