@omnia/velcron 8.0.81-vnext → 8.0.82-dev

package/templatebuilder/editor/VelcronContentEditor.d.ts

@@ -0,0 +1,38 @@
+import { VelcronPropertyEditor } from "@omnia/fx-models";
+import { VelcronEditorBuilderBase } from "./VelcronEditorBuilderBase";
+export declare class VelcronContentEditorBuilder extends VelcronEditorBuilderBase {
+    private mainEditor;
+    private mainPropertyEditor;
+    private mainTypographyEditor;
+    private captionEditor;
+    private captionTypographyEditor;
+    private captionPropertyEditor;
+    private titleEditor;
+    private titlePropertyEditor;
+    private titleTypographyEditor;
+    private summaryEditor;
+    private summaryPropertyEditor;
+    private summaryTypographyEditor;
+    constructor(builder: any);
+    main: {
+        addContentEditor: () => VelcronContentEditorBuilder;
+        addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
+        addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
+    };
+    caption: {
+        addContentEditor: () => VelcronContentEditorBuilder;
+        addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
+        addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
+    };
+    title: {
+        addContentEditor: () => VelcronContentEditorBuilder;
+        addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
+        addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
+    };
+    summary: {
+        addContentEditor: () => VelcronContentEditorBuilder;
+        addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
+        addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
+    };
+    protected internalBuild(): VelcronPropertyEditor<any>[];
+}

package/templatebuilder/editor/VelcronContentEditor.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronContentEditorBuilder = void 0;
+const VelcronEditorBuilderBase_1 = require("./VelcronEditorBuilderBase");
+class VelcronContentEditorBuilder extends VelcronEditorBuilderBase_1.VelcronEditorBuilderBase {
+    constructor(builder) {
+        super(builder);
+        this.mainEditor = null;
+        this.mainPropertyEditor = null;
+        this.mainTypographyEditor = null;
+        this.captionEditor = null;
+        this.captionTypographyEditor = null;
+        this.captionPropertyEditor = null;
+        this.titleEditor = null;
+        this.titlePropertyEditor = null;
+        this.titleTypographyEditor = null;
+        this.summaryEditor = null;
+        this.summaryPropertyEditor = null;
+        this.summaryTypographyEditor = null;
+        this.main = {
+            addContentEditor: () => {
+                if (!this.mainEditor) {
+                    this.mainEditor = {
+                        name: "Body",
+                        type: "markdown",
+                        stateMapping: "content.main.text"
+                    };
+                }
+                return this;
+            },
+            addPropertyMappingEditor: (title) => {
+                if (!this.mainPropertyEditor) {
+                    this.mainPropertyEditor = {
+                        name: title ? title : "Main",
+                        type: "text",
+                        stateMapping: "content.main.text",
+                        propertyMapping: true
+                    };
+                }
+                return this;
+            },
+            addTypographyEditor: (title, type) => {
+                if (!this.mainTypographyEditor) {
+                    this.mainTypographyEditor = {
+                        name: title ? title : "Main formatting",
+                        type: "typography",
+                        stateMapping: "content.main.text",
+                        settings: {
+                            type: type ? type : "text"
+                        }
+                    };
+                }
+                return this;
+            }
+        };
+        this.caption = {
+            addContentEditor: () => {
+                if (!this.captionEditor) {
+                    this.captionEditor = {
+                        name: "Caption",
+                        type: "text",
+                        stateMapping: "content.caption.text"
+                    };
+                }
+                return this;
+            },
+            addPropertyMappingEditor: (title) => {
+                if (!this.captionPropertyEditor) {
+                    this.captionPropertyEditor = {
+                        name: title ? title : "Caption",
+                        type: "text",
+                        stateMapping: "content.caption.text",
+                        propertyMapping: true
+                    };
+                }
+                return this;
+            },
+            addTypographyEditor: (title, type) => {
+                if (!this.captionTypographyEditor) {
+                    this.captionTypographyEditor = {
+                        name: title ? title : "Caption formatting",
+                        type: "typography",
+                        stateMapping: "content.caption.text",
+                        settings: {
+                            type: type ? type : "text"
+                        }
+                    };
+                }
+                return this;
+            }
+        };
+        this.title = {
+            addContentEditor: () => {
+                if (!this.titleEditor) {
+                    this.titleEditor = {
+                        name: "Title",
+                        type: "text",
+                        stateMapping: "content.title.text"
+                    };
+                }
+                return this;
+            },
+            addPropertyMappingEditor: (title) => {
+                if (!this.titlePropertyEditor) {
+                    this.titlePropertyEditor = {
+                        name: title ? title : "Title",
+                        type: "text",
+                        stateMapping: "content.title.text",
+                        propertyMapping: true
+                    };
+                }
+                return this;
+            },
+            addTypographyEditor: (title, type) => {
+                if (!this.titleTypographyEditor) {
+                    this.titleTypographyEditor = {
+                        name: title ? title : "Title formatting",
+                        type: "typography",
+                        stateMapping: "content.title.text",
+                        settings: {
+                            type: type ? type : "title"
+                        }
+                    };
+                }
+                return this;
+            }
+        };
+        this.summary = {
+            addContentEditor: () => {
+                if (!this.summaryEditor) {
+                    this.summaryEditor = {
+                        name: "Summary",
+                        type: "text",
+                        stateMapping: "content.summary.text"
+                    };
+                }
+                return this;
+            },
+            addPropertyMappingEditor: (title) => {
+                if (!this.summaryPropertyEditor) {
+                    this.summaryPropertyEditor = {
+                        name: title ? title : "Summary",
+                        type: "text",
+                        stateMapping: "content.summary.text",
+                        propertyMapping: true
+                    };
+                }
+                return this;
+            },
+            addTypographyEditor: (title, type) => {
+                if (!this.summaryTypographyEditor) {
+                    this.summaryTypographyEditor = {
+                        name: title ? title : "Summary formatting",
+                        type: "typography",
+                        stateMapping: "content.summary.text",
+                        settings: {
+                            type: type ? type : "text"
+                        }
+                    };
+                }
+                return this;
+            }
+        };
+    }
+    internalBuild() {
+        const result = [];
+        if (this.mainEditor) {
+            result.push(this.mainEditor);
+        }
+        if (this.mainPropertyEditor) {
+            result.push(this.mainPropertyEditor);
+        }
+        if (this.mainTypographyEditor) {
+            result.push(this.mainTypographyEditor);
+        }
+        if (this.titleEditor) {
+            result.push(this.titleEditor);
+        }
+        if (this.titlePropertyEditor) {
+            result.push(this.titlePropertyEditor);
+        }
+        if (this.titleTypographyEditor) {
+            result.push(this.titleTypographyEditor);
+        }
+        if (this.summaryEditor) {
+            result.push(this.summaryEditor);
+        }
+        if (this.summaryPropertyEditor) {
+            result.push(this.summaryPropertyEditor);
+        }
+        if (this.summaryTypographyEditor) {
+            result.push(this.summaryTypographyEditor);
+        }
+        if (this.captionEditor) {
+            result.push(this.captionEditor);
+        }
+        if (this.captionTypographyEditor) {
+            result.push(this.captionTypographyEditor);
+        }
+        if (this.captionPropertyEditor) {
+            result.push(this.captionPropertyEditor);
+        }
+        return result;
+    }
+}
+exports.VelcronContentEditorBuilder = VelcronContentEditorBuilder;

package/templatebuilder/editor/VelcronEditorBuilder.d.ts

@@ -0,0 +1,16 @@
+import { VelcronPropertyEditor } from "@omnia/fx-models";
+import { VelcronContentEditorBuilder } from "./VelcronContentEditor";
+import { VelcronColorSchemaEditorBuilder } from "./VelcronColorSchemaEditor";
+import { VelcronImageEditorBuilder } from "./VelcronImageEditor";
+import { VelcronPropertyMappingEditorBuilder } from "./VelcronPropertyMappingEditorBuilder";
+export declare class VelcronEditorBuilder {
+    private contentEditorBuilder;
+    private colorSchemaEditorBuilder;
+    private imageEditorBuilder;
+    private propertyMappingBuilder;
+    content(): VelcronContentEditorBuilder;
+    colorSchemaType(): VelcronColorSchemaEditorBuilder;
+    image(): VelcronImageEditorBuilder;
+    properties(): VelcronPropertyMappingEditorBuilder;
+    build(): VelcronPropertyEditor<any>[];
+}

package/templatebuilder/editor/VelcronEditorBuilder.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronEditorBuilder = void 0;
+const VelcronContentEditor_1 = require("./VelcronContentEditor");
+const VelcronColorSchemaEditor_1 = require("./VelcronColorSchemaEditor");
+const VelcronImageEditor_1 = require("./VelcronImageEditor");
+const VelcronPropertyMappingEditorBuilder_1 = require("./VelcronPropertyMappingEditorBuilder");
+class VelcronEditorBuilder {
+    content() {
+        if (!this.contentEditorBuilder) {
+            this.contentEditorBuilder = new VelcronContentEditor_1.VelcronContentEditorBuilder(this);
+        }
+        return this.contentEditorBuilder;
+    }
+    colorSchemaType() {
+        if (!this.colorSchemaEditorBuilder) {
+            this.colorSchemaEditorBuilder = new VelcronColorSchemaEditor_1.VelcronColorSchemaEditorBuilder(this);
+        }
+        return this.colorSchemaEditorBuilder;
+    }
+    image() {
+        if (!this.imageEditorBuilder) {
+            this.imageEditorBuilder = new VelcronImageEditor_1.VelcronImageEditorBuilder(this);
+        }
+        return this.imageEditorBuilder;
+    }
+    properties() {
+        if (!this.propertyMappingBuilder) {
+            this.propertyMappingBuilder = new VelcronPropertyMappingEditorBuilder_1.VelcronPropertyMappingEditorBuilder(this);
+        }
+        return this.propertyMappingBuilder;
+    }
+    build() {
+        const result = [];
+        if (this.colorSchemaEditorBuilder) {
+            result.push(...this.colorSchemaEditorBuilder.internalBuild());
+        }
+        if (this.contentEditorBuilder) {
+            result.push(...this.contentEditorBuilder.internalBuild());
+        }
+        if (this.imageEditorBuilder) {
+            result.push(...this.imageEditorBuilder.internalBuild());
+        }
+        if (this.propertyMappingBuilder) {
+            result.push(...this.propertyMappingBuilder.internalBuild());
+        }
+        return result;
+    }
+}
+exports.VelcronEditorBuilder = VelcronEditorBuilder;

package/templatebuilder/editor/VelcronEditorBuilder2.d.ts

@@ -0,0 +1,15 @@
+import { TypographyType, VelcronPropertyEditor, VelcronTypographyEditorSettings } from "@omnia/fx-models";
+export declare class VelcronEditorBuilder2 {
+    private editors;
+    private formatStateMapping;
+    add(): {
+        spacingEditor: (name: string, stateMapping: string, individualSelection?: boolean) => VelcronEditorBuilder2;
+        imageEditor: (name: string, stateMapping: string) => VelcronEditorBuilder2;
+        colorSchemaEditor: (name: string, stateMapping: string) => VelcronEditorBuilder2;
+        markdownEditor: (name: string, stateMapping: string, placeholder?: string) => VelcronEditorBuilder2;
+        textEditor: (name: string, stateMapping: string, typographyType: TypographyType, placeholder?: string) => VelcronEditorBuilder2;
+        blockHeaderEditor: () => VelcronEditorBuilder2;
+        typographyEditor: (stateMapping: string, settings: VelcronTypographyEditorSettings) => VelcronEditorBuilder2;
+    };
+    build(): VelcronPropertyEditor<any>[];
+}

package/templatebuilder/editor/VelcronEditorBuilder2.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronEditorBuilder2 = void 0;
+const fx_models_1 = require("@omnia/fx-models");
+class VelcronEditorBuilder2 {
+    constructor() {
+        this.editors = [];
+    }
+    formatStateMapping(stateMapping) {
+        return stateMapping.replace("{{", "").replace("}}", "");
+    }
+    add() {
+        return {
+            spacingEditor: (name, stateMapping, individualSelection) => {
+                this.editors.push({
+                    name: name,
+                    type: "spacing",
+                    stateMapping: this.formatStateMapping(stateMapping),
+                    settings: {
+                        individualSelection: individualSelection
+                    }
+                });
+                return this;
+            },
+            imageEditor: (name, stateMapping) => {
+                this.editors.push({
+                    name: name,
+                    type: "image",
+                    stateMapping: this.formatStateMapping(stateMapping),
+                });
+                return this;
+            },
+            colorSchemaEditor: (name, stateMapping) => {
+                this.editors.push({
+                    name: name,
+                    type: "color-schema-type",
+                    stateMapping: this.formatStateMapping(stateMapping),
+                });
+                return this;
+            },
+            markdownEditor: (name, stateMapping, placeholder) => {
+                this.editors.push({
+                    name: name,
+                    type: "markdown",
+                    stateMapping: this.formatStateMapping(stateMapping),
+                    settings: {
+                        placeholder: placeholder
+                    }
+                });
+                return this;
+            },
+            textEditor: (name, stateMapping, typographyType, placeholder) => {
+                this.editors.push({
+                    name: name,
+                    type: "text",
+                    stateMapping: this.formatStateMapping(stateMapping),
+                    settings: {
+                        type: typographyType,
+                        placeholder: placeholder
+                    }
+                });
+                return this;
+            },
+            blockHeaderEditor: () => {
+                this.editors.push({
+                    name: "Typography",
+                    type: "typography",
+                    stateMapping: fx_models_1.VelcronHeaderStateBinding.title.typography.editor,
+                    settings: {
+                        type: "title"
+                    }
+                });
+                return this;
+            },
+            typographyEditor: (stateMapping, settings) => {
+                this.editors.push({
+                    name: "Typography",
+                    type: "typography",
+                    stateMapping: stateMapping,
+                    settings: settings ? settings : {
+                        type: "text"
+                    }
+                });
+                return this;
+            }
+        };
+    }
+    build() {
+        // const result = [] as Array<VelcronPropertyEditor>;
+        // if(this.colorSchemaEditorBuilder){
+        //     result.push(...this.colorSchemaEditorBuilder.internalBuild());            
+        // }
+        // if(this.contentEditorBuilder){
+        //     result.push(...this.contentEditorBuilder.internalBuild());            
+        // }
+        // if(this.imageEditorBuilder){
+        //     result.push(...this.imageEditorBuilder.internalBuild());            
+        // }
+        // if(this.propertyMappingBuilder){
+        //     result.push(...this.propertyMappingBuilder.internalBuild());            
+        // }
+        return this.editors;
+        // return result;
+    }
+}
+exports.VelcronEditorBuilder2 = VelcronEditorBuilder2;

package/templatebuilder/editor/VelcronEditorBuilderBase.d.ts

@@ -0,0 +1,9 @@
+import { VelcronPropertyEditor } from "@omnia/fx-models";
+import { VelcronEditorBuilder } from "./VelcronEditorBuilder";
+export declare abstract class VelcronEditorBuilderBase {
+    protected builder: VelcronEditorBuilder;
+    constructor(builder: VelcronEditorBuilder);
+    done(): VelcronEditorBuilder;
+    build(): VelcronPropertyEditor<any>[];
+    protected abstract internalBuild(): Array<VelcronPropertyEditor>;
+}

package/templatebuilder/editor/VelcronEditorBuilderBase.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronEditorBuilderBase = void 0;
+class VelcronEditorBuilderBase {
+    constructor(builder) {
+        this.builder = null;
+        this.builder = builder;
+    }
+    done() {
+        return this.builder;
+    }
+    build() {
+        return this.builder.build();
+    }
+}
+exports.VelcronEditorBuilderBase = VelcronEditorBuilderBase;

package/templatebuilder/editor/VelcronImageEditor.d.ts

@@ -0,0 +1,11 @@
+import { VelcronPropertyEditor } from "@omnia/fx-models";
+import { VelcronEditorBuilder } from "./VelcronEditorBuilder";
+import { VelcronEditorBuilderBase } from "./VelcronEditorBuilderBase";
+export declare class VelcronImageEditorBuilder extends VelcronEditorBuilderBase {
+    private mainEditor;
+    constructor(builder: any);
+    main: {
+        add: () => VelcronEditorBuilder;
+    };
+    protected internalBuild(): VelcronPropertyEditor<any>[];
+}

package/templatebuilder/editor/VelcronImageEditor.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronImageEditorBuilder = void 0;
+const VelcronEditorBuilderBase_1 = require("./VelcronEditorBuilderBase");
+class VelcronImageEditorBuilder extends VelcronEditorBuilderBase_1.VelcronEditorBuilderBase {
+    constructor(builder) {
+        super(builder);
+        this.mainEditor = null;
+        this.main = {
+            add: () => {
+                if (!this.mainEditor) {
+                    this.mainEditor = {
+                        name: "Select Main Image",
+                        type: "image",
+                        stateMapping: "main-image"
+                    };
+                }
+                return this.builder;
+            }
+        };
+    }
+    internalBuild() {
+        const result = [];
+        if (this.mainEditor) {
+            result.push(this.mainEditor);
+        }
+        return result;
+    }
+}
+exports.VelcronImageEditorBuilder = VelcronImageEditorBuilder;

package/templatebuilder/editor/VelcronPropertyMappingEditorBuilder.d.ts

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

package/templatebuilder/editor/VelcronPropertyMappingEditorBuilder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronPropertyMappingEditorBuilder = void 0;
+const VelcronEditorBuilderBase_1 = require("./VelcronEditorBuilderBase");
+class VelcronPropertyMappingEditorBuilder extends VelcronEditorBuilderBase_1.VelcronEditorBuilderBase {
+    constructor(builder) {
+        super(builder);
+        this.editor = null;
+    }
+    add() {
+        if (!this.editor) {
+            this.editor = {
+                name: "Properties",
+                type: "enterprise-property",
+                stateMapping: "properties.mappings",
+                propertyMapping: true,
+                multiple: true,
+            };
+        }
+        return this.builder;
+    }
+    internalBuild() {
+        const result = [];
+        if (this.editor) {
+            result.push(this.editor);
+        }
+        return result;
+    }
+}
+exports.VelcronPropertyMappingEditorBuilder = VelcronPropertyMappingEditorBuilder;

package/templatebuilder/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./useVelcronTemplateBuilder";
+export * from "./useVelcronEditorBuilder";

package/templatebuilder/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./useVelcronTemplateBuilder"), exports);
+tslib_1.__exportStar(require("./useVelcronEditorBuilder"), exports);

package/templatebuilder/state/VelcronBlockHeaderStateBuilder.js

@@ -0,0 +1,38 @@
+// import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
+// import { VelcronTextContentBuilder } from "./VelcronTextContentBuilder";
+// export class VelcronBlockHeaderStateBuilder extends VelcronStateBuilderBase {
+//     title = new VelcronTextContentBuilder<VelcronBlockHeaderStateBuilder>(this,"content.title");
+//     constructor(stateBuilder) {
+//         super(stateBuilder);
+//     }
+//     protected internalBuild() {
+//         const resultValue = {} as VelcronContentState;
+//         let hasContent = false;
+//         const mainContent = (this.main as any).internalBuild();
+//         const captionContent = (this.caption as any).internalBuild();
+//         const titleContent = (this.title as any).internalBuild();
+//         const summaryContent = (this.summary as any).internalBuild();
+//         if(mainContent){
+//             hasContent = true;
+//             resultValue.main = mainContent;
+//         }
+//         if(captionContent){
+//             hasContent = true;
+//             resultValue.caption = captionContent;
+//         }
+//         if(titleContent){
+//             hasContent = true;
+//             resultValue.title = titleContent;
+//         }
+//         if(summaryContent){
+//             hasContent = true;
+//             resultValue.summary = summaryContent;
+//         }
+//         if(!hasContent){
+//             return null;
+//         }  
+//         return <VelcronState>{
+//             content: resultValue
+//         };        
+//     }
+// }

package/templatebuilder/state/VelcronColorSchemaBuilder.d.ts

@@ -0,0 +1,16 @@
+import { ColorSchemaType, VelcronState } from "@omnia/fx-models";
+import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
+export declare class VelcronColorSchemaStateBuilder extends VelcronStateBuilderBase {
+    private colorSchema;
+    private filledValue;
+    constructor(stateBuilder: any);
+    type: {
+        add(colorSchema?: ColorSchemaType): VelcronColorSchemaStateBuilder;
+        bind: string;
+    };
+    filled: {
+        add(filled: boolean): VelcronColorSchemaStateBuilder;
+        bind: any;
+    };
+    protected internalBuild(): VelcronState;
+}

package/templatebuilder/state/VelcronColorSchemaBuilder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronColorSchemaStateBuilder = void 0;
+const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
+class VelcronColorSchemaStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderBase {
+    constructor(stateBuilder) {
+        super(stateBuilder);
+        this.type = {
+            add(colorSchema) {
+                this.colorSchema = colorSchema;
+                return this;
+            },
+            bind: "{{colorSchemaType.type}}"
+        };
+        this.filled = {
+            add(filled) {
+                this.filledValue = filled;
+                return this;
+            },
+            bind: "{{colorSchemaType.filled}}"
+        };
+    }
+    internalBuild() {
+        return {
+            colorSchema: {
+                type: this.colorSchema,
+                filled: this.filledValue
+            }
+        };
+    }
+}
+exports.VelcronColorSchemaStateBuilder = VelcronColorSchemaStateBuilder;

package/templatebuilder/state/VelcronContentStateBuilder.d.ts

@@ -0,0 +1,11 @@
+import { VelcronState } from "@omnia/fx-models";
+import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
+import { VelcronTextContentBuilder } from "./VelcronTextContentBuilder";
+export declare class VelcronContentStateBuilder extends VelcronStateBuilderBase {
+    main: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    caption: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    title: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    summary: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    constructor(stateBuilder: any);
+    protected internalBuild(): VelcronState;
+}