@omnia/velcron 8.0.162-dev → 8.0.164-dev

package/models/VelcronState.d.ts

@@ -0,0 +1,186 @@
+import { BackgroundDefinition, ContainerBlueprint, ContainerVariant, TextBlueprint, TypographySize, TypographyType, VelcronSpacing } from "@omnia/velcron/internal-do-not-import-from-here/shared/models";
+import { VelcronImageRatios } from "./VelcronDefinitions";
+export interface VelcronState {
+    images?: VelcronImagesState;
+    container?: {
+        colorSchemaType?: string;
+        spacing?: VelcronSpacing;
+        blueprint?: ContainerBlueprint | ContainerVariant;
+        background?: BackgroundDefinition;
+    };
+    grid?: VelcronGridState;
+    colorSchemas?: VelcronColorSchemasState;
+    content?: VelcronContentState;
+    header?: VelcronHeaderState;
+    properties?: VelcronPropertiesState;
+    spacing?: VelcronSpacingState;
+}
+export interface VelcronGridState {
+    columnWidth?: number;
+    columns?: Array<object>;
+    gap?: string | number;
+}
+export interface VelcronSpacingState {
+    container?: VelcronSpacing;
+}
+export interface VelcronHeaderState {
+    title?: VelcronTextState;
+    icon?: string;
+}
+export interface VelcronTextState {
+    text?: string;
+    placeholder?: string;
+    typography?: VelcronTypographyState;
+}
+export interface VelcronTypographyState {
+    type?: TypographyType;
+    size?: TypographySize;
+    toned?: boolean;
+}
+export interface VelcronContentState {
+    caption?: VelcronTextState;
+    main?: VelcronTextState;
+    title?: VelcronTextState;
+    summary?: VelcronTextState;
+}
+export interface VelcronPropertiesState {
+    user: any;
+    mappings: Array<any>;
+}
+export interface VelcronImagesState {
+    main?: VelcronImageState;
+    alt1?: VelcronImageState;
+    alt2?: VelcronImageState;
+}
+export interface VelcronImageState {
+    url?: string;
+    ratio?: VelcronImageRatios;
+    caption?: VelcronTextState;
+    width?: number;
+    height?: number;
+}
+export interface VelcronStylingState {
+}
+export interface VelcronColorSchemasState {
+    main: string;
+}
+export declare const VelcronImagesStateBinding: {
+    main: {
+        editor: string;
+        url: string;
+        ratio: string;
+        caption: string;
+        width: string;
+        height: string;
+    };
+    alt1: {
+        editor: string;
+        url: string;
+        ratio: string;
+        caption: string;
+        width: string;
+        height: string;
+    };
+    alt2: {
+        editor: string;
+        url: string;
+        ratio: string;
+        caption: string;
+        width: string;
+        height: string;
+    };
+};
+export declare const VelcronStateMapping: {
+    grid: {
+        columns: string;
+    };
+};
+export declare const VelcronStateBinding: {
+    colorSchemas: {
+        main_depricated: {
+            value: string;
+            type: string;
+            filled: string;
+        };
+    };
+    container: {
+        colorSchemaType: string;
+        spacing: string;
+        blueprint: string;
+        background: {
+            value: string;
+            media: string;
+        };
+    };
+    images: {
+        main: {
+            editor: string;
+            url: string;
+            ratio: string;
+            caption: string;
+            width: string;
+            height: string;
+        };
+        alt1: {
+            editor: string;
+            url: string;
+            ratio: string;
+            caption: string;
+            width: string;
+            height: string;
+        };
+        alt2: {
+            editor: string;
+            url: string;
+            ratio: string;
+            caption: string;
+            width: string;
+            height: string;
+        };
+    };
+    content: {
+        title: {
+            text: string;
+            placeholder: string;
+            blueprint: import("@omnia/velcron/internal-do-not-import-from-here/shared/models").VelcronBindableProp<TextBlueprint>;
+        };
+        main: {
+            text: string;
+            placeholder: string;
+            blueprint: import("@omnia/velcron/internal-do-not-import-from-here/shared/models").VelcronBindableProp<TextBlueprint>;
+        };
+        caption: {
+            text: string;
+            placeholder: string;
+            blueprint: import("@omnia/velcron/internal-do-not-import-from-here/shared/models").VelcronBindableProp<TextBlueprint>;
+        };
+        summary: {
+            text: string;
+            placeholder: string;
+            blueprint: import("@omnia/velcron/internal-do-not-import-from-here/shared/models").VelcronBindableProp<TextBlueprint>;
+        };
+    };
+    grid: {
+        value: string;
+        columnWidth: string;
+        columns: string;
+        gap: string;
+    };
+    header: {
+        title: {
+            text: string;
+            placeholder: string;
+            blueprint: import("@omnia/velcron/internal-do-not-import-from-here/shared/models").VelcronBindableProp<TextBlueprint>;
+        };
+        icon: string;
+    };
+    spacing: {
+        container: {
+            value: string;
+            top: string;
+            right: string;
+            bottom: string;
+            left: string;
+        };
+    };
+};

package/models/VelcronState.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronStateBinding = exports.VelcronStateMapping = exports.VelcronImagesStateBinding = void 0;
+const models_1 = require("@omnia/velcron/internal-do-not-import-from-here/shared/models");
+exports.VelcronImagesStateBinding = {
+    main: {
+        editor: "{{images.main.url}}",
+        url: "{{images.main.url}}",
+        ratio: "{{images.main.ratio}}",
+        caption: "{{images.main.caption}}",
+        width: "{{images.main.width}}",
+        height: "{{images.main.height}}",
+    },
+    alt1: {
+        editor: "{{images.alt1.url}}",
+        url: "{{images.alt1.url}}",
+        ratio: "{{images.alt1.ratio}}",
+        caption: "{{images.alt1.caption}}",
+        width: "{{images.alt1.width}}",
+        height: "{{images.alt1.height}}",
+    },
+    alt2: {
+        editor: "{{images.alt2.url}}",
+        url: "{{images.alt2.url}}",
+        ratio: "{{images.alt2.ratio}}",
+        caption: "{{images.alt2.caption}}",
+        width: "{{images.alt2.width}}",
+        height: "{{images.alt2.height}}",
+    },
+};
+const VelcronContentStateBinding = {
+    title: {
+        text: (0, models_1.velcronBind)("content.title.text"),
+        placeholder: (0, models_1.velcronBind)("content.title.placeholder"),
+        blueprint: (0, models_1.velcronBind)("content.title.blueprint")
+    },
+    main: {
+        text: (0, models_1.velcronBind)("content.main.text"),
+        placeholder: (0, models_1.velcronBind)("content.main.placeholder"),
+        blueprint: (0, models_1.velcronBind)("content.main.blueprint")
+    },
+    caption: {
+        text: (0, models_1.velcronBind)("content.caption.text"),
+        placeholder: (0, models_1.velcronBind)("content.caption.placeholder"),
+        blueprint: (0, models_1.velcronBind)("content.caption.blueprint")
+    },
+    summary: {
+        text: (0, models_1.velcronBind)("content.summary.text"),
+        placeholder: (0, models_1.velcronBind)("content.summary.placeholder"),
+        blueprint: (0, models_1.velcronBind)("content.summary.blueprint")
+    },
+};
+exports.VelcronStateMapping = {
+    grid: {
+        columns: "grid.columns",
+    },
+};
+exports.VelcronStateBinding = {
+    colorSchemas: {
+        main_depricated: {
+            value: (0, models_1.velcronBind)("colorSchemas.main"),
+            type: (0, models_1.velcronBind)("colorSchemas.main.type"),
+            filled: (0, models_1.velcronBind)("colorSchemas.main.filled")
+        }
+    },
+    container: {
+        colorSchemaType: (0, models_1.velcronBind)("$state.container.colorSchemaType"),
+        spacing: (0, models_1.velcronBind)("$state.container.spacing"),
+        blueprint: (0, models_1.velcronBind)("$state.container.blueprint"),
+        background: {
+            value: (0, models_1.velcronBind)("$state.container.background"),
+            media: (0, models_1.velcronBind)("$state.container.background.media")
+        }
+    },
+    images: exports.VelcronImagesStateBinding,
+    content: VelcronContentStateBinding,
+    grid: {
+        value: (0, models_1.velcronBind)("$state.grid"),
+        columnWidth: (0, models_1.velcronBind)("$state.grid.columnWidth"),
+        columns: (0, models_1.velcronBind)("$state.grid.columns"),
+        gap: (0, models_1.velcronBind)("$state.grid.gap"),
+        //rows:velcronBind("grid.rows"),
+    },
+    header: {
+        title: {
+            text: (0, models_1.velcronBind)("$state.header.title.text"),
+            placeholder: (0, models_1.velcronBind)("$state.header.title.placeholder"),
+            blueprint: (0, models_1.velcronBind)("$state.content.title.blueprint")
+        },
+        icon: (0, models_1.velcronBind)("$state.header.icon")
+    },
+    spacing: {
+        container: {
+            value: (0, models_1.velcronBind)("$state.spacing.chrome"),
+            top: (0, models_1.velcronBind)("{{spacing.chrome.top}}"),
+            right: (0, models_1.velcronBind)("{{spacing.chrome.right}}"),
+            bottom: (0, models_1.velcronBind)("{{spacing.chrome.bottom}}"),
+            left: (0, models_1.velcronBind)("{{spacing.chrome.left}}"),
+        }
+    }
+    //properties?:VelcronPropertiesState,    
+};

package/models/index.d.ts

@@ -5,3 +5,4 @@ export * from "./Enums";
 export * from "./VelcronUnitProvider";
 export * from "./VelcronPropertyEditorDefinitions";
 export * from "./ActionHooks";
+export * from "./VelcronState";

package/models/index.js

@@ -8,3 +8,4 @@ tslib_1.__exportStar(require("./Enums"), exports);
 tslib_1.__exportStar(require("./VelcronUnitProvider"), exports);
 tslib_1.__exportStar(require("./VelcronPropertyEditorDefinitions"), exports);
 tslib_1.__exportStar(require("./ActionHooks"), exports);
+tslib_1.__exportStar(require("./VelcronState"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/velcron",
   "license": "MIT",
-  "version": "8.0.162-dev",
+  "version": "8.0.164-dev",
   "description": "Provide Omnia Velcron Stuffs.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/parser/VelcronData.d.ts

@@ -1,12 +1,12 @@
-import { VelcronRenderContext } from "../models";
+import { VelcronRenderContext, VelcronDataTypes } from "../models";
 import { VelcronAppDefinition, VelcronBindableProp, VelcronDefinition } from "..";
 export interface ParseResult<T> {
     is: boolean;
     value: T;
 }
 export declare class VelcronData {
-    static dataBind<T = string>(renderContext: VelcronRenderContext, text: VelcronBindableProp<any>): T;
-    static hasTwoWayBinding(text: string): boolean;
+    static dataBind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T;
+    static isBindable<T = string>(bindable: VelcronBindableProp<T>): boolean;
     static getBindPath(text: string): string;
     static addCtxToVariableNames(template: string, skipIfNameStartsWith?: string, skipIfNameMatches?: Array<string>, overridePrefixWhenNameMatches?: {
         [name: string]: string;
@@ -20,12 +20,13 @@ export declare class VelcronData {
     static evaluateArray(template: string, renderContext: VelcronRenderContext): Array<any> | null;
     static evaluateBoolean(template: string | Boolean, renderContext: VelcronRenderContext): boolean | null;
     static tryParseBoolean(bool: any): ParseResult<boolean | null>;
-    static isString(text: any): boolean;
-    static isBoolean(value: any): boolean;
-    static isNumber(value: any): boolean;
+    static isString(text: any): text is string;
+    static isBoolean(value: any): value is boolean;
+    static isNumber(value: any): value is number;
     static isUndefined(value: any): boolean;
     static isArray(obj: any): obj is ExtendArray;
-    static isObject(value: any): boolean;
+    static isObject(value: any): value is object;
+    static getDataType(value: any): VelcronDataTypes;
     static extendObject(obj: any): any;
     static propertyPathExists(obj: object, path: string): boolean;
     static getOrSetObjectByPath<T>(object: Object, path: string, value?: any): T | null;

package/parser/VelcronData.js

@@ -6,35 +6,38 @@ const VelcronConstants_1 = require("./VelcronConstants");
 const VelcronLogger_1 = require("./VelcronLogger");
 const TextValue_1 = require("./TextValue");
 class VelcronData {
-    static dataBind(renderContext, text) {
-        if (!VelcronData.isString(text)) {
-            return text;
+    static dataBind(renderContext, bindTo) {
+        if (!VelcronData.isString(bindTo)) {
+            return bindTo;
         }
         //Bound to one state property and supports 2 way data binding > $bind: $state.title
-        if (text.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken)) {
-            text = text.substring(VelcronConstants_1.VelcronConstants.state.bindToken.length).trim();
-            return VelcronData.getOrSet(renderContext, text);
+        if (bindTo.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken)) {
+            bindTo = bindTo.substring(VelcronConstants_1.VelcronConstants.state.bindToken.length).trim();
+            return VelcronData.getOrSet(renderContext, bindTo);
         }
         //Built-in context tokens
-        if (text === VelcronConstants_1.VelcronConstants.context.editModeToken) {
+        if (bindTo === VelcronConstants_1.VelcronConstants.context.editModeToken) {
             return renderContext.$editmode;
         }
-        else if (text === VelcronConstants_1.VelcronConstants.context.activeToken) {
+        else if (bindTo === VelcronConstants_1.VelcronConstants.context.activeToken) {
             return renderContext.$active;
         }
         //String interpolation > {{ $state.title }} and {{ $state.description }}
-        const tokens = this.getTokens(text, false);
+        const tokens = this.getTokens(bindTo, false);
         tokens.forEach((token) => {
             let data = this.getOrSet(renderContext, token.replace(/\s*{{\s*|\s*}}\s*/g, ""));
             if (data instanceof TextValue_1.TextValue) {
                 data = data.value;
             }
-            text = text.replace(token, data);
+            bindTo = bindTo.replace(token, data);
         });
-        return text;
+        return bindTo;
     }
-    static hasTwoWayBinding(text) {
-        return text?.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken);
+    static isBindable(bindable) {
+        if (!VelcronData.isString(bindable)) {
+            return false;
+        }
+        return bindable?.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken);
     }
     static getBindPath(text) {
         return text?.substring(VelcronConstants_1.VelcronConstants.state.bindToken.length).trim();
@@ -461,6 +464,22 @@ class VelcronData {
             !Array.isArray(value) &&
             value !== null;
     }
+    static getDataType(value) {
+        if (value === null)
+            return models_1.VelcronDataTypes.unknown;
+        else if (Array.isArray(value))
+            return models_1.VelcronDataTypes.array;
+        else if (VelcronData.isObject(value))
+            return models_1.VelcronDataTypes.object;
+        else if (VelcronData.isString(value))
+            return models_1.VelcronDataTypes.text;
+        else if (VelcronData.isNumber(value))
+            return models_1.VelcronDataTypes.number;
+        else if (VelcronData.isBoolean(value))
+            return models_1.VelcronDataTypes.boolean;
+        else
+            return models_1.VelcronDataTypes.unknown;
+    }
     static extendObject(obj) {
         //Give objects some powerups
         if (VelcronData.isUndefined(obj)) {

package/parser/VelcronStyles.js

@@ -157,16 +157,16 @@ class VelcronStyles {
         }
         else if (definition.type === VelcronConstants_1.VelcronConstants.components.row) {
             const flexDefinition = definition;
+            const spacing = renderCtx.theming.get.spacing();
             let alignX = null;
             let alignY = null;
-            const gapX = flexDefinition.gapX ? flexDefinition.gapX : flexDefinition.gapY;
-            const gapY = flexDefinition.gapY ? flexDefinition.gapY : flexDefinition.gapX;
+            const gapX = flexDefinition.gapX || flexDefinition?.gapX?.toString() === "0" ? (0, __1.getSpacingValueFromBlueprint)(VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.gapX), spacing) : (0, __1.getSpacingValueFromBlueprint)(VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.gapY), spacing);
+            const gapY = flexDefinition.gapY || flexDefinition?.gapY?.toString() === "0" ? (0, __1.getSpacingValueFromBlueprint)(VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.gapY), spacing) : gapX;
             const width = VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.width);
             const minWidth = VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.minWidth);
             const height = VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.height);
             const minHeight = VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.minHeight);
             if (flexDefinition.absolute) {
-                const spacing = renderCtx.theming.get.spacing();
                 styleBase["position"] = "absolute";
                 /**Use margin to position the element since flex does not support absolute positioning */
                 styleBase["marginTop"] = this.unitProvider.formatDimension((0, __1.getSpacingValueFromBlueprint)(VelcronData_1.VelcronData.dataBind(renderCtx, flexDefinition.absolute.top), spacing));
@@ -200,8 +200,8 @@ class VelcronStyles {
             styleBase["flexWrap"] = flexDefinition.wrap ? "wrap" : null;
             styleBase["justifyContent"] = alignX;
             styleBase["alignItems"] = alignY;
-            styleBase["rowGap"] = gapY;
-            styleBase["columnGap"] = gapX;
+            styleBase["rowGap"] = this.unitProvider.formatDimension(gapY);
+            styleBase["columnGap"] = this.unitProvider.formatDimension(gapX);
             styleBase["flexBasis"] = flexDefinition.height ? this.unitProvider.formatDimension(height) : undefined;
             styleBase["width"] = this.unitProvider.formatDimension(width);
             styleBase["maxWidth"] = this.unitProvider.formatDimension(width);

package/rules/IsEditMode.js

@@ -22,7 +22,7 @@ const parser_1 = require("../parser");
  */
 function isEditMode(definition, bindableProp, renderContext) {
     //A bind property must exist for the definition to be editable
-    if (parser_1.VelcronData.hasTwoWayBinding(definition[bindableProp]) === false) {
+    if (parser_1.VelcronData.isBindable(definition[bindableProp]) === false) {
         return false;
     }
     let result = false;

package/stores/VelcronColorSchema.d.ts

@@ -8,7 +8,7 @@ export declare const useVelcronColorSchemaStore: (newStateWithName?: string) =>
         onContainer: ColorDefinition;
         isContainer: boolean;
         name: string;
-        colorSchemaType: "primary" | "secondary" | ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "neutral" | "warning" | "notification" | "background" | "error" | "info" | "dynamic";
+        colorSchemaType: "background" | "primary" | "secondary" | ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "neutral" | "warning" | "notification" | "error" | "info" | "dynamic";
         id: import("@omnia/fx-models").GuidValue;
     };
     get: {

package/templatebuilder/VelcronEditorBuilder.d.ts

@@ -0,0 +1,18 @@
+import { TypographyType, VelcronEditor, VelcronTypographyEditorSettings } from "@omnia/fx-models";
+export declare class VelcronEditorBuilder {
+    private editors;
+    private formatStateMapping;
+    add(): {
+        blueprintEditor: (name: string, stateMapping: string, type: "container") => VelcronEditorBuilder;
+        spacingEditor: (name: string, stateMapping: string, individualSelection?: boolean) => VelcronEditorBuilder;
+        imageEditor: (name: string, stateMapping: string) => VelcronEditorBuilder;
+        colorSchemaEditor: (name: string, stateMapping: string) => VelcronEditorBuilder;
+        markdownEditor: (name: string, stateMapping: string, placeholder?: string) => VelcronEditorBuilder;
+        textEditor: (name: string, stateMapping: string, typographyType: TypographyType, placeholder?: string) => VelcronEditorBuilder;
+        blockHeaderEditor: () => VelcronEditorBuilder;
+        typographyEditor: (stateMapping: string, settings: VelcronTypographyEditorSettings) => VelcronEditorBuilder;
+        backgroundEditor: (name: string, stateMapping: string, type: "image" | "video") => VelcronEditorBuilder;
+        gridEditor: (name: string, stateMapping: string) => VelcronEditorBuilder;
+    };
+    build(): VelcronEditor<any>[];
+}

package/templatebuilder/{editor/VelcronEditorBuilder2.js → VelcronEditorBuilder.js}

@@ -1,20 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VelcronEditorBuilder2 = void 0;
-class VelcronEditorBuilder2 {
+exports.VelcronEditorBuilder = void 0;
+const parser_1 = require("../parser");
+class VelcronEditorBuilder {
     constructor() {
         this.editors = [];
     }
     formatStateMapping(stateMapping) {
-        return stateMapping.replace("{{", "").replace("}}", "");
+        return stateMapping
+            .replace(parser_1.VelcronConstants.properties.tokenStart, "")
+            .replace(parser_1.VelcronConstants.properties.tokenEnd, "")
+            .replace(parser_1.VelcronConstants.state.bindToken, "")
+            .replace(parser_1.VelcronConstants.state.stateRootToken + ".", "")
+            .trim();
     }
     add() {
         return {
+            blueprintEditor: (name, stateMapping, type) => {
+                this.editors.push({
+                    name: name,
+                    type: "blueprint",
+                    state: this.formatStateMapping(stateMapping),
+                    settings: {
+                        type: type
+                    }
+                });
+                return this;
+            },
             spacingEditor: (name, stateMapping, individualSelection) => {
                 this.editors.push({
                     name: name,
                     type: "spacing",
-                    stateMapping: this.formatStateMapping(stateMapping),
+                    state: this.formatStateMapping(stateMapping),
                     settings: {
                         individualSelection: individualSelection
                     }
@@ -25,7 +42,7 @@ class VelcronEditorBuilder2 {
                 this.editors.push({
                     name: name,
                     type: "image",
-                    stateMapping: this.formatStateMapping(stateMapping),
+                    state: this.formatStateMapping(stateMapping),
                 });
                 return this;
             },
@@ -33,7 +50,7 @@ class VelcronEditorBuilder2 {
                 this.editors.push({
                     name: name,
                     type: "color-schema-type",
-                    stateMapping: this.formatStateMapping(stateMapping),
+                    state: this.formatStateMapping(stateMapping),
                 });
                 return this;
             },
@@ -41,7 +58,7 @@ class VelcronEditorBuilder2 {
                 this.editors.push({
                     name: name,
                     type: "markdown",
-                    stateMapping: this.formatStateMapping(stateMapping),
+                    state: this.formatStateMapping(stateMapping),
                     settings: {
                         placeholder: placeholder
                     }
@@ -52,7 +69,7 @@ class VelcronEditorBuilder2 {
                 this.editors.push({
                     name: name,
                     type: "text",
-                    stateMapping: this.formatStateMapping(stateMapping),
+                    state: this.formatStateMapping(stateMapping),
                     settings: {
                         type: typographyType,
                         placeholder: placeholder
@@ -75,12 +92,31 @@ class VelcronEditorBuilder2 {
                 this.editors.push({
                     name: "Typography",
                     type: "typography",
-                    stateMapping: stateMapping,
+                    state: stateMapping,
                     settings: settings ? settings : {
                         type: "text"
                     }
                 });
                 return this;
+            },
+            backgroundEditor: (name, stateMapping, type) => {
+                this.editors.push({
+                    name: name,
+                    type: "background",
+                    state: this.formatStateMapping(stateMapping),
+                    settings: {
+                        type: type
+                    }
+                });
+                return this;
+            },
+            gridEditor: (name, stateMapping) => {
+                this.editors.push({
+                    name: name,
+                    type: "grid",
+                    state: this.formatStateMapping(stateMapping),
+                });
+                return this;
             }
         };
     }
@@ -102,4 +138,4 @@ class VelcronEditorBuilder2 {
         // return result;
     }
 }
-exports.VelcronEditorBuilder2 = VelcronEditorBuilder2;
+exports.VelcronEditorBuilder = VelcronEditorBuilder;

package/templatebuilder/{editor → old/editor}/VelcronColorSchemaEditor.d.ts

@@ -1,9 +1,9 @@
-import { VelcronStateEditor } from "@omnia/fx-models";
+import { VelcronEditor } from "@omnia/fx-models";
 import { VelcronEditorBuilder } from "./VelcronEditorBuilder";
 import { VelcronEditorBuilderBase } from "./VelcronEditorBuilderBase";
 export declare class VelcronColorSchemaEditorBuilder extends VelcronEditorBuilderBase {
     private editor;
     constructor(builder: any);
     add(): VelcronEditorBuilder;
-    protected internalBuild(): VelcronStateEditor<any>[];
+    protected internalBuild(): VelcronEditor<any>[];
 }

package/templatebuilder/{editor → old/editor}/VelcronContentEditor.d.ts

@@ -1,4 +1,4 @@
-import { VelcronStateEditor } from "@omnia/fx-models";
+import { VelcronEditor } from "@omnia/fx-models";
 import { VelcronEditorBuilderBase } from "./VelcronEditorBuilderBase";
 export declare class VelcronContentEditorBuilder extends VelcronEditorBuilderBase {
     private mainEditor;
@@ -34,5 +34,5 @@ export declare class VelcronContentEditorBuilder extends VelcronEditorBuilderBas
         addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
         addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
     };
-    protected internalBuild(): VelcronStateEditor<any>[];
+    protected internalBuild(): VelcronEditor<any>[];
 }