@omnia/velcron 8.0.82-vnext → 8.0.83-dev

package/templatebuilder/state/VelcronContentStateBuilder.js

@@ -0,0 +1,47 @@
+"use strict";
+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 = 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;
+        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 (titleContent) {
+            hasContent = true;
+            resultValue.title = titleContent;
+        }
+        if (summaryContent) {
+            hasContent = true;
+            resultValue.summary = summaryContent;
+        }
+        if (!hasContent) {
+            return null;
+        }
+        return {
+            content: resultValue
+        };
+    }
+}
+exports.VelcronContentStateBuilder = VelcronContentStateBuilder;

package/templatebuilder/state/VelcronImageStateBuilder.d.ts

@@ -0,0 +1,18 @@
+import { VelcronImageRatios, VelcronState } from "@omnia/fx-models";
+import { VelcronStateBuilderBase } from "./VelcronStateBuilderBase";
+export declare class VelcronImageStateBuilder extends VelcronStateBuilderBase {
+    private mainImageUrl;
+    private mainImageRatio;
+    constructor(stateBuilder: any);
+    main: {
+        url: {
+            add: (url: string) => VelcronImageStateBuilder;
+            bind: string;
+        };
+        ratio: {
+            add: (ratio: VelcronImageRatios) => VelcronImageStateBuilder;
+            bind: string;
+        };
+    };
+    protected internalBuild(): VelcronState;
+}

package/templatebuilder/state/VelcronImageStateBuilder.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronImageStateBuilder = void 0;
+const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
+class VelcronImageStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderBase {
+    constructor(stateBuilder) {
+        super(stateBuilder);
+        this.main = {
+            url: {
+                add: (url) => {
+                    this.mainImageUrl = url;
+                    return this;
+                },
+                bind: "{{images.main.url}}"
+            },
+            ratio: {
+                add: (ratio) => {
+                    this.mainImageRatio = ratio;
+                    return this;
+                },
+                bind: "{{images.main.ratio}}"
+            }
+        };
+    }
+    internalBuild() {
+        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 {
+            images: {
+                main: resultValue
+            }
+        };
+    }
+}
+exports.VelcronImageStateBuilder = VelcronImageStateBuilder;

package/templatebuilder/state/VelcronPropertyMappingStateBuilder.d.ts

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

package/templatebuilder/state/VelcronPropertyMappingStateBuilder.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronPropertyMappingStateBuilder = void 0;
+const VelcronStateBuilderBase_1 = require("./VelcronStateBuilderBase");
+class VelcronPropertyMappingStateBuilder extends VelcronStateBuilderBase_1.VelcronStateBuilderBase {
+    constructor(stateBuilder) {
+        super(stateBuilder);
+        this.propertyItemsValue = [];
+        this.items = {
+            add: (items) => {
+                this.propertyItemsValue = items;
+                return this;
+            },
+            bind: "$properties.mappings",
+            foreach: "properties.mappings"
+        };
+    }
+    internalBuild() {
+        const resultValue = {};
+        let hasContent = false;
+        if (this.propertyItemsValue) {
+            resultValue.mappings = this.propertyItemsValue;
+            hasContent = true;
+        }
+        if (!hasContent) {
+            return null;
+        }
+        return {
+            properties: {
+                ...resultValue
+            }
+        };
+    }
+}
+exports.VelcronPropertyMappingStateBuilder = VelcronPropertyMappingStateBuilder;

package/templatebuilder/state/VelcronStateBuilder.d.ts

@@ -0,0 +1,16 @@
+import { VelcronState } from "@omnia/fx-models";
+import { VelcronColorSchemaStateBuilder } from "./VelcronColorSchemaBuilder";
+import { VelcronContentStateBuilder } from "./VelcronContentStateBuilder";
+import { VelcronImageStateBuilder } from "./VelcronImageStateBuilder";
+import { VelcronPropertyMappingStateBuilder } from "./VelcronPropertyMappingStateBuilder";
+export declare class VelcronStateBuilder {
+    private contentStateBuilder;
+    private imageStateBuilder;
+    private colorSchemaStateBuilder;
+    private propertyMappingStateBuilder;
+    content(): VelcronContentStateBuilder;
+    image(): VelcronImageStateBuilder;
+    colorSchemaType(): VelcronColorSchemaStateBuilder;
+    properties(): VelcronPropertyMappingStateBuilder;
+    build(): VelcronState;
+}

package/templatebuilder/state/VelcronStateBuilder.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronStateBuilder = void 0;
+const VelcronColorSchemaBuilder_1 = require("./VelcronColorSchemaBuilder");
+const VelcronContentStateBuilder_1 = require("./VelcronContentStateBuilder");
+const VelcronImageStateBuilder_1 = require("./VelcronImageStateBuilder");
+const VelcronPropertyMappingStateBuilder_1 = require("./VelcronPropertyMappingStateBuilder");
+class VelcronStateBuilder {
+    content() {
+        if (!this.contentStateBuilder) {
+            this.contentStateBuilder = new VelcronContentStateBuilder_1.VelcronContentStateBuilder(this);
+        }
+        return this.contentStateBuilder;
+    }
+    image() {
+        if (!this.imageStateBuilder) {
+            this.imageStateBuilder = new VelcronImageStateBuilder_1.VelcronImageStateBuilder(this);
+        }
+        return this.imageStateBuilder;
+    }
+    colorSchemaType() {
+        if (!this.colorSchemaStateBuilder) {
+            this.colorSchemaStateBuilder = new VelcronColorSchemaBuilder_1.VelcronColorSchemaStateBuilder(this);
+        }
+        return this.colorSchemaStateBuilder;
+    }
+    properties() {
+        if (!this.propertyMappingStateBuilder) {
+            this.propertyMappingStateBuilder = new VelcronPropertyMappingStateBuilder_1.VelcronPropertyMappingStateBuilder(this);
+        }
+        return this.propertyMappingStateBuilder;
+    }
+    build() {
+        return {
+            ...this?.contentStateBuilder?.internalBuild(),
+            ...this?.imageStateBuilder?.internalBuild(),
+            ...this?.colorSchemaStateBuilder?.internalBuild(),
+            ...this?.propertyMappingStateBuilder?.internalBuild(),
+        };
+    }
+}
+exports.VelcronStateBuilder = VelcronStateBuilder;

package/templatebuilder/state/VelcronStateBuilderBase.d.ts

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

package/templatebuilder/state/VelcronStateBuilderBase.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+    }
+    build() {
+        return this.stateBuilder.build();
+    }
+}
+exports.VelcronStateBuilderBase = VelcronStateBuilderBase;

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;

package/templatebuilder/useVelcronEditorBuilder.d.ts

@@ -0,0 +1,2 @@
+import { VelcronEditorBuilder2 } from "./editor/VelcronEditorBuilder2";
+export declare function useVelcronEditorBuilder(): VelcronEditorBuilder2;

package/templatebuilder/useVelcronEditorBuilder.js

@@ -0,0 +1,9 @@
+"use strict";
+// import { VelcronContentState,  VelcronImagePropertyEditor,  VelcronImageRatios, VelcronImageState, VelcronMarkdownPropertyEditor, VelcronTextPropertyEditor} from "@omnia/fx-models";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVelcronEditorBuilder = void 0;
+const VelcronEditorBuilder2_1 = require("./editor/VelcronEditorBuilder2");
+function useVelcronEditorBuilder() {
+    return new VelcronEditorBuilder2_1.VelcronEditorBuilder2();
+}
+exports.useVelcronEditorBuilder = useVelcronEditorBuilder;

package/templatebuilder/useVelcronTemplateBuilder.d.ts

@@ -0,0 +1,6 @@
+import { VelcronEditorBuilder } from "./editor/VelcronEditorBuilder";
+import { VelcronStateBuilder } from "./state/VelcronStateBuilder";
+export declare function useVelcronTemplateBuilder(): {
+    state: VelcronStateBuilder;
+    editor: VelcronEditorBuilder;
+};

package/templatebuilder/useVelcronTemplateBuilder.js

@@ -0,0 +1,13 @@
+"use strict";
+// import { VelcronContentState,  VelcronImagePropertyEditor,  VelcronImageRatios, VelcronImageState, VelcronMarkdownPropertyEditor, VelcronTextPropertyEditor} from "@omnia/fx-models";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVelcronTemplateBuilder = void 0;
+const VelcronEditorBuilder_1 = require("./editor/VelcronEditorBuilder");
+const VelcronStateBuilder_1 = require("./state/VelcronStateBuilder");
+function useVelcronTemplateBuilder() {
+    return {
+        state: new VelcronStateBuilder_1.VelcronStateBuilder(),
+        editor: new VelcronEditorBuilder_1.VelcronEditorBuilder()
+    };
+}
+exports.useVelcronTemplateBuilder = useVelcronTemplateBuilder;

package/internal-do-not-import-from-here/shared/models/Bring.d.ts

@@ -1,23 +0,0 @@
-export type BringMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
-export type BringCacheOptions = "no-cache" | "reload" | "force-cache" | "only-if-cached";
-export type BringCredentials = "include" | "omit" | "same-origin";
-export interface BringInterceptOptions {
-    beforeRequest?: (request: BringConfig) => BringConfig;
-    afterRequest?: <T>(response: BringResponse<T>, request: BringConfig) => BringResponse<T>;
-}
-export interface BringConfig {
-    baseUrl?: string;
-    headers?: {
-        [key: string]: string;
-    };
-    cache?: BringCacheOptions;
-    interceptors?: BringInterceptOptions;
-    abortable?: boolean;
-    credentials?: BringCredentials;
-}
-export interface BringResponse<TData> {
-    data?: TData;
-    status: Number;
-    statusText: String;
-    ok: Boolean;
-}

package/stores/VelcronBlueprint.d.ts

@@ -1,39 +0,0 @@
-import { BlueprintDefinition, BlueprintItemDefinition, BlueprintType, BlueprintTypes, SpacingBlueprint, TypographyBlueprint, VelcronBlueprintDefintionType } from "@omnia/fx-models";
-import { useVelcronThemingStore } from ".";
-export declare const useVelcronBlueprintStore: (newStateWithName?: string) => {
-    state: {
-        blueprint: BlueprintDefinition;
-        blueprintType: BlueprintType | BlueprintTypes;
-        themeStore: {
-            state: {
-                currentTheme: import("@omnia/fx-models").ThemeDefinitionV2;
-            };
-            get: {
-                blueprint: (blueprintType: BlueprintType | BlueprintTypes) => BlueprintDefinition;
-                colorSchema: (colorSchemaType: import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType) => import("@omnia/fx-models").ColorSchema;
-                typography: (typographyType: import("@omnia/fx-models").TypographyType | import("@omnia/fx-models").TypographyTypes, size: import("@omnia/fx-models").TypographySize | import("@omnia/fx-models").TypographySizes) => import("@omnia/fx-models").TypographyTypeDefinition;
-                color: (colorSchemaType: import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType, colorType: import("@omnia/fx-models").ColorType | import("@omnia/fx-models").ColorTypes) => string;
-                colorDefinition: (colorSchemaType: import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType, colorType: import("@omnia/fx-models").ColorType | import("@omnia/fx-models").ColorTypes) => import("@omnia/fx-models").ColorDefinition;
-                complementaryColorType: (colorType: import("@omnia/fx-models").ColorType | import("@omnia/fx-models").ColorTypes) => import("@omnia/fx-models").ColorTypes;
-                complementaryColor: (colorSchemaType: import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType, colorType: import("@omnia/fx-models").ColorType | import("@omnia/fx-models").ColorTypes) => string;
-                complementaryColorDefinition: (colorSchemaType: import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType, colorType: import("@omnia/fx-models").ColorType | import("@omnia/fx-models").ColorTypes) => import("@omnia/fx-models").ColorDefinition;
-                currentTheme: () => import("@omnia/fx-models").ThemeDefinitionV2;
-            };
-            actions: {
-                setTheme(newTheme: import("@omnia/fx-models").ThemeDefinitionV2): void;
-            };
-        };
-    };
-    get: {
-        readonly all: BlueprintDefinition;
-        byType: <TType extends BlueprintItemDefinition>(type: VelcronBlueprintDefintionType | VelcronBlueprintDefintionType) => TType;
-        readonly typography: TypographyBlueprint;
-        spacing: {
-            readonly inner: SpacingBlueprint;
-        };
-    };
-    actions: {
-        setThemeStore: (themeStoreInstance: ReturnType<typeof useVelcronThemingStore>, blueprintType?: BlueprintTypes | BlueprintType) => void;
-        setBlueprint: (type: BlueprintTypes | BlueprintType) => void;
-    };
-};

package/stores/VelcronBlueprint.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useVelcronBlueprintStore = void 0;
-const fx_models_1 = require("@omnia/fx-models");
-const _1 = require(".");
-exports.useVelcronBlueprintStore = (0, _1.defineVelcronStore)("BlueprintStore", {
-    setup() {
-        return {
-            state: {
-                blueprint: {},
-                blueprintType: fx_models_1.BlueprintTypes.default,
-                themeStore: undefined,
-            }
-        };
-    },
-    getters(state) {
-        function allDefinitions() {
-            return state.blueprint;
-        }
-        function byType(type) {
-            return state.blueprint.definitions.find(x => x.type === type);
-        }
-        return {
-            get all() {
-                return allDefinitions();
-            },
-            byType,
-            get typography() {
-                return byType(fx_models_1.VelcronBlueprintDefintionTypes.typography);
-            },
-            spacing: {
-                get inner() {
-                    return byType(fx_models_1.VelcronBlueprintDefintionTypes.innerspacing);
-                },
-            }
-        };
-    },
-    actions(state) {
-        function setBlueprint(type) {
-            const blueprint = state.themeStore.get.blueprint(type);
-            if (blueprint) {
-                state.blueprint = blueprint;
-                state.blueprintType = type;
-            }
-        }
-        function setThemeStore(themeStoreInstance, blueprintType) {
-            state.themeStore = themeStoreInstance;
-            setBlueprint(blueprintType);
-        }
-        return {
-            setThemeStore,
-            setBlueprint
-        };
-    }
-});