@omnia/velcron 8.0.99-vnext → 8.0.101-vnext

package/actions/Date.d.ts

@@ -1,3 +1,3 @@
 import { IActionHandler } from "./IActionHandler";
 export declare const dateFormat: IActionHandler;
-export declare const dateCountDown: IActionHandler;
+export declare const diff: IActionHandler;

package/actions/Date.js

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateCountDown = exports.dateFormat = void 0;
+exports.diff = exports.dateFormat = void 0;
 const tslib_1 = require("tslib");
 const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
-const duration_1 = tslib_1.__importDefault(require("dayjs/plugin/duration"));
-dayjs_1.default.extend(duration_1.default);
 exports.dateFormat = {
     name: "@date.format",
     action: (action, value) => {
         return Promise.resolve((0, dayjs_1.default)().format(value));
     }
 };
-exports.dateCountDown = {
+exports.diff = {
     name: "@date.diff",
     action: (action, date, past = false) => {
         const now = (0, dayjs_1.default)();

package/models/VelcronPropertyEditorDefinitions.d.ts

@@ -1,4 +1,4 @@
-import { VelcronImageRatios } from "@omnia/fx-models";
+import { TypographySize, TypographyType, VelcronImageRatios } from "@omnia/fx-models";
 export interface ResolvedPropertyEditor {
     editor: VelcronPropertyEditor;
 }
@@ -78,16 +78,43 @@ export interface VelcronMarkdownPropertyEditor extends VelcronPropertyEditor<any
 export interface VelcronImagePropertyEditor extends VelcronPropertyEditor<any> {
     type: "image";
 }
+export interface VelcronState {
+    images?: VelcronImagesState;
+    styling?: VelcronStylingState;
+    colorSchema?: VelcronColorSchemaState;
+    content?: VelcronContentState;
+    properties?: VelcronPropertiesState;
+}
+export interface VelcronTextState {
+    text: string;
+    typography?: VelcronTypographyState;
+}
+export interface VelcronTypographyState {
+    type?: TypographyType;
+    size?: TypographySize;
+    toned?: boolean;
+}
 export interface VelcronContentState {
-    content: {
-        caption?: string;
-        main?: string;
-    };
+    caption?: VelcronTextState;
+    main?: VelcronTextState;
+    title?: VelcronTextState;
+    summary?: VelcronTextState;
 }
 export interface VelcronPropertiesState {
-    propertyItems: Array<any>;
+    user: any;
+    mappings: Array<any>;
+}
+export interface VelcronImagesState {
+    main?: VelcronImageState;
 }
 export interface VelcronImageState {
     url?: string;
     ratio?: VelcronImageRatios;
+    caption?: VelcronTextState;
+}
+export interface VelcronStylingState {
+}
+export interface VelcronColorSchemaState {
+    type?: string;
+    filled?: boolean;
 }

package/package.json

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

package/templatebuilder/editor/VelcronContentEditor.d.ts

@@ -2,13 +2,37 @@ 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: {
-        add: () => VelcronContentEditorBuilder;
+        addContentEditor: () => VelcronContentEditorBuilder;
+        addPropertyMappingEditor: (title?: string) => VelcronContentEditorBuilder;
+        addTypographyEditor: (title?: string, type?: "text" | "title") => VelcronContentEditorBuilder;
     };
     caption: {
-        add: () => VelcronContentEditorBuilder;
+        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

@@ -6,26 +6,156 @@ class VelcronContentEditorBuilder extends VelcronEditorBuilderBase_1.VelcronEdit
     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 = {
-            add: () => {
+            addContentEditor: () => {
                 if (!this.mainEditor) {
                     this.mainEditor = {
                         name: "Body",
                         type: "markdown",
-                        stateMapping: "content.main"
+                        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 = {
-            add: () => {
+            addContentEditor: () => {
                 if (!this.captionEditor) {
                     this.captionEditor = {
                         name: "Caption",
                         type: "text",
-                        stateMapping: "content.caption"
+                        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;
@@ -37,9 +167,39 @@ class VelcronContentEditorBuilder extends VelcronEditorBuilderBase_1.VelcronEdit
         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;
     }
 }

package/templatebuilder/editor/VelcronPropertyMappingEditorBuilder.js

@@ -12,7 +12,7 @@ class VelcronPropertyMappingEditorBuilder extends VelcronEditorBuilderBase_1.Vel
             this.editor = {
                 name: "Properties",
                 type: "enterprise-property",
-                stateMapping: "propertyItems",
+                stateMapping: "properties.mappings",
                 propertyMapping: true,
                 multiple: true,
             };

package/templatebuilder/state/VelcronColorSchemaBuilder.d.ts

@@ -1,11 +1,16 @@
-import { ColorSchemaType } from "@omnia/fx-models";
+import { ColorSchemaType, VelcronState } from "@omnia/fx-models";
 import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
 export declare class VelcronColorSchemaStateBuilder extends VelcronStateBuilderBase {
     private colorSchema;
+    private filledValue;
     constructor(stateBuilder: any);
-    add(colorSchema?: ColorSchemaType): VelcronColorSchemaStateBuilder;
-    bind: string;
-    protected internalBuild(): {
-        colorSchemaType: "info" | "error" | "primary" | "secondary" | "accent1" | "accent2" | "accent3" | "neutral" | "background";
+    type: {
+        add(colorSchema?: ColorSchemaType): VelcronColorSchemaStateBuilder;
+        bind: string;
     };
+    filled: {
+        add(filled: boolean): VelcronColorSchemaStateBuilder;
+        bind: any;
+    };
+    protected internalBuild(): VelcronState;
 }

package/templatebuilder/state/VelcronColorSchemaBuilder.js

@@ -5,15 +5,27 @@ const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
 class VelcronColorSchemaStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderBase {
     constructor(stateBuilder) {
         super(stateBuilder);
-        this.bind = "{{colorSchemaType}}";
-    }
-    add(colorSchema) {
-        this.colorSchema = colorSchema;
-        return this;
+        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 {
-            colorSchemaType: this.colorSchema
+            colorSchema: {
+                type: this.colorSchema,
+                filled: this.filledValue
+            }
         };
     }
 }

package/templatebuilder/state/VelcronContentStateBuilder.d.ts

@@ -1,17 +1,11 @@
+import { VelcronState } from "@omnia/fx-models";
 import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
+import { VelcronTextContentBuilder } from "./VelcronTextContentBuilder";
 export declare class VelcronContentStateBuilder extends VelcronStateBuilderBase {
-    private mainContent;
-    private captionContent;
+    main: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    caption: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    title: VelcronTextContentBuilder<VelcronContentStateBuilder>;
+    summary: VelcronTextContentBuilder<VelcronContentStateBuilder>;
     constructor(stateBuilder: any);
-    main: {
-        add: (value?: string) => VelcronContentStateBuilder;
-        bind: string;
-    };
-    caption: {
-        add: (value?: string) => VelcronContentStateBuilder;
-        bind: string;
-    };
-    protected internalBuild(): {
-        content: {};
-    };
+    protected internalBuild(): VelcronState;
 }

package/templatebuilder/state/VelcronContentStateBuilder.js

@@ -2,34 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VelcronContentStateBuilder = void 0;
 const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
+const VelcronTextContentBuilder_1 = require("./VelcronTextContentBuilder");
+// title?: VelcronTextState;
+// summary?: VelcronTextState;
 class VelcronContentStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderBase {
     constructor(stateBuilder) {
         super(stateBuilder);
-        this.main = {
-            add: (value) => {
-                this.mainContent = value;
-                return this;
-            },
-            bind: "$state.content.main"
-        };
-        this.caption = {
-            add: (value) => {
-                this.captionContent = value;
-                return this;
-            },
-            bind: "{{content.caption}}"
-        };
+        this.main = new VelcronTextContentBuilder_1.VelcronTextContentBuilder(this, "content.main");
+        this.caption = new VelcronTextContentBuilder_1.VelcronTextContentBuilder(this, "content.caption");
+        this.title = new VelcronTextContentBuilder_1.VelcronTextContentBuilder(this, "content.title");
+        this.summary = new VelcronTextContentBuilder_1.VelcronTextContentBuilder(this, "content.summary");
     }
     internalBuild() {
         const resultValue = {};
         let hasContent = false;
-        if (this.mainContent) {
-            resultValue["main"] = this.mainContent;
+        const mainContent = this.main.internalBuild();
+        const captionContent = this.caption.internalBuild();
+        const titleContent = this.title.internalBuild();
+        const summaryContent = this.summary.internalBuild();
+        if (mainContent) {
+            hasContent = true;
+            resultValue.main = mainContent;
+        }
+        if (captionContent) {
             hasContent = true;
+            resultValue.caption = captionContent;
         }
-        if (this.captionContent) {
-            resultValue["caption"] = this.captionContent;
+        if (titleContent) {
             hasContent = true;
+            resultValue.title = titleContent;
+        }
+        if (summaryContent) {
+            hasContent = true;
+            resultValue.summary = summaryContent;
+        }
+        if (!hasContent) {
+            return null;
         }
         return {
             content: resultValue

package/templatebuilder/state/VelcronImageStateBuilder.d.ts

@@ -1,4 +1,4 @@
-import { VelcronImageRatios } from "../../models";
+import { VelcronImageRatios, VelcronState } from "@omnia/fx-models";
 import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
 export declare class VelcronImageStateBuilder extends VelcronStateBuilderBase {
     private mainImageUrl;
@@ -14,7 +14,5 @@ export declare class VelcronImageStateBuilder extends VelcronStateBuilderBase {
             bind: string;
         };
     };
-    protected internalBuild(): {
-        "main-image": {};
-    };
+    protected internalBuild(): VelcronState;
 }

package/templatebuilder/state/VelcronImageStateBuilder.js

@@ -11,14 +11,14 @@ class VelcronImageStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBui
                     this.mainImageUrl = url;
                     return this;
                 },
-                bind: "{{main-image.url}}"
+                bind: "{{images.main.url}}"
             },
             ratio: {
                 add: (ratio) => {
                     this.mainImageRatio = ratio;
                     return this;
                 },
-                bind: "{{main-image.ratio}}"
+                bind: "{{images.main.ratio}}"
             }
         };
     }
@@ -26,16 +26,22 @@ class VelcronImageStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBui
         if (!this.mainImageUrl) {
             return null;
         }
+        let hasContent = false;
         const resultValue = {};
         if (this.mainImageRatio) {
             resultValue["ratio"] = this.mainImageRatio;
+            hasContent = true;
         }
         if (this.mainImageUrl) {
             resultValue["url"] = this.mainImageUrl;
+            hasContent = true;
+        }
+        if (!hasContent) {
+            return null;
         }
         return {
-            "main-image": {
-                ...resultValue
+            images: {
+                main: resultValue
             }
         };
     }

package/templatebuilder/state/VelcronPropertyMappingStateBuilder.d.ts

@@ -1,11 +1,12 @@
+import { VelcronState } from "@omnia/fx-models";
 import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
 export declare class VelcronPropertyMappingStateBuilder extends VelcronStateBuilderBase {
     private propertyItemsValue;
     constructor(stateBuilder: any);
-    propertyItems: {
+    items: {
         add: (items?: any[]) => VelcronPropertyMappingStateBuilder;
         bind: string;
         foreach: string;
     };
-    protected internalBuild(): {};
+    protected internalBuild(): VelcronState;
 }

package/templatebuilder/state/VelcronPropertyMappingStateBuilder.js

@@ -6,23 +6,30 @@ class VelcronPropertyMappingStateBuilder extends VelcronStateBuilderBase_1.Velcr
     constructor(stateBuilder) {
         super(stateBuilder);
         this.propertyItemsValue = [];
-        this.propertyItems = {
+        this.items = {
             add: (items) => {
                 this.propertyItemsValue = items;
                 return this;
             },
-            bind: "$propertyItems",
-            foreach: "propertyItems"
+            bind: "$properties.mappings",
+            foreach: "properties.mappings"
         };
     }
     internalBuild() {
         const resultValue = {};
         let hasContent = false;
         if (this.propertyItemsValue) {
-            resultValue.propertyItems = this.propertyItemsValue;
+            resultValue.mappings = this.propertyItemsValue;
             hasContent = true;
         }
-        return resultValue;
+        if (!hasContent) {
+            return null;
+        }
+        return {
+            properties: {
+                ...resultValue
+            }
+        };
     }
 }
 exports.VelcronPropertyMappingStateBuilder = VelcronPropertyMappingStateBuilder;

package/templatebuilder/state/VelcronStateBuilder.d.ts

@@ -1,3 +1,4 @@
+import { VelcronState } from "@omnia/fx-models";
 import { VelcronColorSchemaStateBuilder } from "./VelcronColorSchemaBuilder";
 import { VelcronContentStateBuilder } from "./VelcronContentStateBuilder";
 import { VelcronImageStateBuilder } from "./VelcronImageStateBuilder";
@@ -11,5 +12,5 @@ export declare class VelcronStateBuilder {
     image(): VelcronImageStateBuilder;
     colorSchemaType(): VelcronColorSchemaStateBuilder;
     properties(): VelcronPropertyMappingStateBuilder;
-    build(): any;
+    build(): VelcronState;
 }

package/templatebuilder/state/VelcronStateBuilderBase.d.ts

@@ -1,8 +1,12 @@
 import { VelcronStateBuilder } from "./VelcronStateBuilder";
-export declare abstract class VelcronStateBuilderBase {
+export declare abstract class VelcronStateBuilderStrategy {
+    abstract done(): any;
+    protected abstract internalBuild(): any;
+}
+export declare abstract class VelcronStateBuilderBase extends VelcronStateBuilderStrategy {
     protected stateBuilder: VelcronStateBuilder;
-    constructor(stateBulder: VelcronStateBuilder);
+    constructor(stateBuilder: VelcronStateBuilder);
     done(): VelcronStateBuilder;
-    build(): any;
+    build(): import("@omnia/fx-models").VelcronState;
     protected abstract internalBuild(): any;
 }

package/templatebuilder/state/VelcronStateBuilderBase.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VelcronStateBuilderBase = void 0;
-class VelcronStateBuilderBase {
-    constructor(stateBulder) {
-        this.stateBuilder = stateBulder;
+exports.VelcronStateBuilderBase = exports.VelcronStateBuilderStrategy = void 0;
+class VelcronStateBuilderStrategy {
+}
+exports.VelcronStateBuilderStrategy = VelcronStateBuilderStrategy;
+class VelcronStateBuilderBase extends VelcronStateBuilderStrategy {
+    constructor(stateBuilder) {
+        super();
+        this.stateBuilder = stateBuilder;
     }
     done() {
         return this.stateBuilder;

package/templatebuilder/state/VelcronTextContentBuilder.d.ts

@@ -0,0 +1,32 @@
+import { TypographySize, TypographyType, VelcronTextState, VelcronTypographyState } from "@omnia/fx-models";
+import { VelcronStateBuilderStrategy } from "./VelcronStateBuilderBase";
+export declare class VelcronTextContentBuilder<TBaseBuilder> extends VelcronStateBuilderStrategy {
+    private _textState;
+    private bindingContextValue;
+    private _typographyState;
+    private baseBuilder;
+    constructor(baseBuilder: TBaseBuilder, bind: string);
+    get typographyState(): VelcronTypographyState;
+    get textState(): VelcronTextState;
+    get bindingContext(): string;
+    text: {
+        add: (value: string) => VelcronTextContentBuilder<TBaseBuilder>;
+        bind: () => string;
+    };
+    typography: {
+        type: {
+            add: (type: TypographyType) => VelcronTextContentBuilder<TBaseBuilder>;
+            bind: () => string;
+        };
+        size: {
+            add: (size: TypographySize) => VelcronTextContentBuilder<TBaseBuilder>;
+            bind: () => string;
+        };
+        toned: {
+            add: (toned: boolean) => VelcronTextContentBuilder<TBaseBuilder>;
+            bind: () => string;
+        };
+    };
+    done(): TBaseBuilder;
+    protected internalBuild(): VelcronTextState;
+}

package/templatebuilder/state/VelcronTextContentBuilder.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronTextContentBuilder = void 0;
+const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
+// export interface VelcronTextState {
+//     text:string,
+//     typography?:{
+//       type?: TypographyType,
+//       size?:TypographySize  
+//       toned?:boolean;
+//     }
+// }
+class VelcronTextContentBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderStrategy {
+    constructor(baseBuilder, bind) {
+        super();
+        this._textState = undefined;
+        this.bindingContextValue = undefined;
+        this._typographyState = undefined;
+        // :VelcronTextContentBuilder<TBaseBuilder>
+        this.text = {
+            add: (value) => {
+                this.textState.text = value;
+                return this;
+            },
+            bind: () => { return `{{ ${this.bindingContextValue}.text }}`; }
+        };
+        this.typography = {
+            type: {
+                add: (type) => {
+                    this.typographyState.type = type;
+                    return this;
+                },
+                bind: () => { return `{{ ${this.bindingContextValue}.typography.type }}`; }
+            },
+            size: {
+                add: (size) => {
+                    this.typographyState.size = size;
+                    return this;
+                },
+                bind: () => { return `{{ ${this.bindingContextValue}.typography.size }}`; }
+            },
+            toned: {
+                add: (toned) => {
+                    this.typographyState.toned = toned;
+                    return this;
+                },
+                bind: () => { return `{{ ${this.bindingContextValue}.typography.toned }}`; }
+            }
+        };
+        this.baseBuilder = baseBuilder;
+        this.bindingContextValue = bind;
+    }
+    get typographyState() {
+        if (!this._typographyState) {
+            this._typographyState = {};
+        }
+        return this._typographyState;
+    }
+    get textState() {
+        if (!this._textState) {
+            this._textState = {};
+        }
+        return this._textState;
+    }
+    get bindingContext() {
+        return this.bindingContextValue;
+    }
+    // typography(type?: TypographyType,size?:TypographySize,toned?:boolean):VelcronTextContentBuilder<TBaseBuilder>{
+    //     this.textState.typography = {
+    //         type:type,
+    //         size:size,
+    //         toned:toned
+    //     };
+    //     return this;
+    // }
+    done() {
+        return this.baseBuilder;
+    }
+    internalBuild() {
+        const resultValue = {};
+        let hasContent = false;
+        // if(this.mainContent){
+        //     resultValue["main"] = this.mainContent;
+        //     hasContent = true;
+        // }
+        // if(this.captionContent){
+        //     resultValue["caption"] = this.captionContent;
+        //     hasContent = true;
+        // }
+        // if(!hasContent){
+        //     return null;
+        // }
+        // return <VelcronState>{
+        //     content: resultValue as VelcronContentState
+        // };       
+        if (this._textState) {
+            hasContent = true;
+            resultValue.text = this._textState.text;
+        }
+        if (this._typographyState) {
+            hasContent = true;
+            resultValue.typography = this._typographyState;
+        }
+        if (!hasContent) {
+            return null;
+        }
+        return resultValue;
+    }
+}
+exports.VelcronTextContentBuilder = VelcronTextContentBuilder;