@omnia/velcron 7.0.499-dev → 7.0.501-dev

package/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./models";
 export * from "./parser";
 export * from "./actions";
+export * from "./stores";
+export * from "@omnia/velcron/internal-do-not-import-from-here/shared/models";

package/index.js

@@ -4,3 +4,5 @@ const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./models"), exports);
 tslib_1.__exportStar(require("./parser"), exports);
 tslib_1.__exportStar(require("./actions"), exports);
+tslib_1.__exportStar(require("./stores"), exports);
+tslib_1.__exportStar(require("@omnia/velcron/internal-do-not-import-from-here/shared/models"), exports);

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

@@ -0,0 +1,23 @@
+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/internal-do-not-import-from-here/shared/models/Bring.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,25 @@
+import { Topic } from "./Topic";
+export declare enum BroadcastTopicScopes {
+    localUi = "localUi",
+    localWorker = "localWorker",
+    localAll = "localAll",
+    globalUi = "globalUi",
+    globalWorker = "globalWorker",
+    globalAll = "globalAll"
+}
+export interface BroadcastTopic<TMessage> extends Topic<TMessage> {
+    scope: BroadcastTopicScopes;
+}
+export interface BroadcastInvokeTopic<TMessage, TReturnValue> extends Topic<TMessage> {
+    scope: BroadcastTopicScopes;
+}
+export interface BroadcastMessage<TMessage> extends BroadcastTopic<TMessage> {
+    message: TMessage;
+}
+export interface BroadcastInvokeMessage<TMessage, TReturnValue> extends BroadcastInvokeTopic<TMessage, TReturnValue> {
+    messageId: string;
+    message: TMessage;
+    type: "request" | "response";
+    error?: string;
+    response?: TReturnValue;
+}

package/internal-do-not-import-from-here/shared/models/Broadcasting.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastTopicScopes = void 0;
+var BroadcastTopicScopes;
+(function (BroadcastTopicScopes) {
+    BroadcastTopicScopes["localUi"] = "localUi";
+    BroadcastTopicScopes["localWorker"] = "localWorker";
+    BroadcastTopicScopes["localAll"] = "localAll";
+    BroadcastTopicScopes["globalUi"] = "globalUi";
+    BroadcastTopicScopes["globalWorker"] = "globalWorker";
+    BroadcastTopicScopes["globalAll"] = "globalAll";
+})(BroadcastTopicScopes = exports.BroadcastTopicScopes || (exports.BroadcastTopicScopes = {}));

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

@@ -0,0 +1,44 @@
+export declare class Future<T> extends Promise<T> {
+    resolve: (value: T) => void;
+    reject: (reason: any) => void;
+    resolving: boolean;
+    private _resolved;
+    private _rejected;
+    private onAborted;
+    constructor(executor: (resolve: (value: T) => void, reject: (reason?: any) => void, onAborted: (cb: (reason?: any) => void) => void) => void);
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    tryCatch(): Future<[success: T, error: Error]>;
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
+    abort(reason?: any): void;
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    static all<T extends readonly unknown[] | []>(values: T): Promise<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }>;
+    get resolved(): boolean;
+    get rejected(): boolean;
+    static get [Symbol.species](): PromiseConstructor;
+    get [Symbol.toStringTag](): string;
+    static new<TReturnValue>(): Future<TReturnValue>;
+}
+export declare class ResponsePromise<T> extends Promise<T> {
+    cancelCb: (() => void);
+    constructor(executor: any);
+    cancel(): void;
+}

package/internal-do-not-import-from-here/shared/models/Future.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsePromise = exports.Future = void 0;
+class Future extends Promise {
+    constructor(executor) {
+        let resolveLocal;
+        let rejectLocal;
+        const onAborted = (cb) => {
+            setTimeout(() => {
+                this.onAborted = cb;
+            });
+        };
+        const exec = (resolve, reject) => {
+            // assign to local to prevent error assignbefore call super;
+            resolveLocal = resolve;
+            rejectLocal = reject;
+        };
+        super(exec);
+        this.resolving = false;
+        this._resolved = false;
+        this._rejected = false;
+        this.resolve = (value) => {
+            this.resolving = false;
+            this._resolved = true;
+            resolveLocal(value);
+        };
+        this.reject = (reason) => {
+            this.resolving = false;
+            this._rejected = true;
+            rejectLocal(reason);
+        };
+        if (executor) {
+            executor(this.resolve, this.reject, onAborted);
+        }
+    }
+    /**
+     * Handles success / rejection from Promise and returns the result as an object.
+     * If the promise is rejected, the error will be in the error property.
+     * No need to try/catch the promise when using this method.
+     *
+     * @return {*}  {Future<{ success?: T, error?: Error; }>}
+     * @memberof Future
+     */
+    //tryCatch(): Future<{ success?: T, error?: Error; }> {
+    tryCatch() {
+        return new Future(async (resolve) => {
+            try {
+                const data = await this;
+                resolve([data, undefined]);
+            }
+            catch (err) {
+                resolve([undefined, err]);
+            }
+        });
+    }
+    /**
+     * Aborts the request
+     *
+     * @param {*} [reason]
+     * @memberof Future
+     */
+    abort(reason) {
+        if (this.onAborted) {
+            this.onAborted(reason);
+        }
+        else {
+            throw "Failed calling abort() => The future has no onAborted callback or you tried to call abort immediately after the future was created.";
+        }
+    }
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    static all(values) {
+        // have issue with Promise.all not working when promises is mixin Future and promise
+        // so implement Future.all to make a wrapper promise to Future to resolve that issue.
+        const promises = values.map(p => p instanceof Future ? new Promise((resolve, reject) => p.then(resolve, reject)) : p);
+        return Promise.all(promises);
+    }
+    get resolved() {
+        return this._resolved;
+    }
+    get rejected() {
+        return this._rejected;
+    }
+    static get [Symbol.species]() {
+        return Promise;
+    }
+    get [Symbol.toStringTag]() {
+        // return Object value to make vue can build get/set reactive.
+        return "Object";
+    }
+    static new() {
+        return new Future(() => { });
+    }
+}
+exports.Future = Future;
+class ResponsePromise extends Promise {
+    constructor(executor) {
+        const onCancel = (cb) => {
+            //using nextTick because we cant use "this" before super()
+            setTimeout(() => {
+                this.cancelCb = cb;
+            });
+        };
+        const oExecutor = (resolve, reject) => {
+            executor(resolve, reject, onCancel);
+        };
+        super(oExecutor);
+    }
+    cancel() {
+        if (this.cancelCb) {
+            this.cancelCb();
+        }
+        else {
+            console.warn("onCancel not provided");
+        }
+    }
+}
+exports.ResponsePromise = ResponsePromise;

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

@@ -0,0 +1,17 @@
+export interface GuidValue {
+    toString: () => string;
+}
+/**
+ * Class to create a guid
+ */
+export declare class Guid implements GuidValue {
+    private static _empty;
+    static newGuid(): GuidValue;
+    static get empty(): GuidValue;
+    static isValid(guid: string | GuidValue): boolean;
+    private value;
+    constructor(guid: string);
+    toString(): string;
+    toJSON: () => string;
+    valueOf(): string;
+}

package/internal-do-not-import-from-here/shared/models/Guid.js

@@ -0,0 +1,51 @@
+"use strict";
+//export interface GuidValue {
+//    :string;
+//}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guid = void 0;
+/**
+ * Class to create a guid
+ */
+class Guid {
+    static newGuid() {
+        return new Guid("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
+            const r = Math.random() * 16 | 0;
+            const v = (c == "x") ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        }));
+    }
+    static get empty() {
+        return this._empty;
+    }
+    static isValid(guid) {
+        if (guid === undefined || guid === null) {
+            return false;
+        }
+        const validRegex = /^[{]?[0-9a-fA-F]{8}[-]?([0-9a-fA-F]{4}[-]?){3}[0-9a-fA-F]{12}[}]?$/;
+        return validRegex.test(guid.toString());
+    }
+    constructor(guid) {
+        this.value = Guid._empty;
+        //We serialize as string value
+        this.toJSON = () => {
+            return this.value.toLowerCase();
+        };
+        if (guid) {
+            if (Guid.isValid(guid)) {
+                this.value = guid;
+            }
+            else {
+                throw `The string '${guid}' is not a valid Guid`;
+            }
+        }
+    }
+    toString() {
+        return this.value.toLowerCase();
+    }
+    valueOf() {
+        return this.value.toLowerCase();
+    }
+}
+exports.Guid = Guid;
+Guid._empty = "00000000-0000-0000-0000-000000000000";

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

@@ -0,0 +1,25 @@
+import { OmniaToken } from ".";
+import { Guid, GuidValue } from "./Guid";
+import { TenantIdentifier } from "./Tenant";
+export interface OmniaSharedBootstrapData {
+    uiThreadId: GuidValue;
+    workerThreadId: GuidValue;
+    customDomain?: string;
+    defaultDomain: string;
+    routePrefixes: string[];
+    language: string;
+    /**
+     * The tokenKey is only avilable if we are running ITP or Dev intent
+     */
+    tokenKey?: OmniaToken;
+    tokenRef: GuidValue;
+    licenses: Array<Guid>;
+    hubDev?: boolean;
+    realtimeDevPort?: string;
+    tenant: TenantIdentifier;
+    servingMode?: boolean;
+    serviceDnsMapping: OmniaServiceToDnsMapping;
+}
+export interface OmniaServiceToDnsMapping {
+    [serviceId: string]: string;
+}

package/internal-do-not-import-from-here/shared/models/OmniaSharedBootstrapData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,40 @@
+import { Guid, GuidValue } from "./Guid";
+export declare abstract class RealtimeChannel {
+    /**
+     * Construct a unique channel id that can be targeted to users who are set to be in that channel on the client
+     * @returns id
+     */
+    abstract getId(): string;
+}
+export declare class BusinuessProfileChannel extends RealtimeChannel {
+    private _profileId;
+    constructor(profileId: Guid);
+    getId(): string;
+}
+export declare abstract class RealtimeData<TRealtimeChannel extends RealtimeChannel, TRealtimeData> {
+    private _channel;
+    private _value;
+    get channel(): TRealtimeChannel;
+    get value(): TRealtimeData;
+    abstract getId(): GuidValue;
+    constructor(channel: TRealtimeChannel, value?: TRealtimeData);
+}
+export declare class PageChatRealtimeData extends RealtimeData<BusinuessProfileChannel, {
+    x: number;
+    y: number;
+}> {
+    constructor(channel: BusinuessProfileChannel);
+    getId(): GuidValue;
+}
+export type RealtimeChannelUpdateTypes = "activate" | "deactivate";
+export interface RealtimeChannelUpdateMessage extends RealtimChannelMessage {
+    threadId: GuidValue;
+    type: RealtimeChannelUpdateTypes;
+}
+export interface RealtimeSendMessage extends RealtimChannelMessage {
+    dataId: GuidValue;
+    data: any;
+}
+export interface RealtimChannelMessage {
+    channelId: string;
+}

package/internal-do-not-import-from-here/shared/models/Realtime.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageChatRealtimeData = exports.RealtimeData = exports.BusinuessProfileChannel = exports.RealtimeChannel = void 0;
+const Guid_1 = require("./Guid");
+class RealtimeChannel {
+}
+exports.RealtimeChannel = RealtimeChannel;
+class BusinuessProfileChannel extends RealtimeChannel {
+    constructor(profileId) {
+        super();
+        this._profileId = profileId;
+    }
+    getId() {
+        return this._profileId.toString();
+    }
+}
+exports.BusinuessProfileChannel = BusinuessProfileChannel;
+class RealtimeData {
+    get channel() {
+        return this._channel;
+    }
+    get value() {
+        return this._value;
+    }
+    constructor(channel, value) {
+        this._channel = channel;
+        this._value = value;
+    }
+}
+exports.RealtimeData = RealtimeData;
+//FIXME: This is a test implementation remove when tested
+class PageChatRealtimeData extends RealtimeData {
+    constructor(channel) {
+        super(channel);
+    }
+    getId() {
+        return new Guid_1.Guid("0366c62b-da25-4ed1-b5dc-de7e9934249f");
+    }
+}
+exports.PageChatRealtimeData = PageChatRealtimeData;

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

@@ -0,0 +1,5 @@
+export declare const SharedConstants: {
+    broadcast: {
+        channelName: string;
+    };
+};

package/internal-do-not-import-from-here/shared/models/SharedConstants.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedConstants = void 0;
+//TODO: Consider moving Constants from fx models here and merge them
+exports.SharedConstants = {
+    broadcast: {
+        channelName: "omnia-fx-broadcast"
+    },
+};

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

@@ -0,0 +1,6 @@
+declare global {
+    interface StringConstructor {
+        empty: string;
+    }
+}
+export {};

package/internal-do-not-import-from-here/shared/models/StringExtensions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+String.empty = "";

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

@@ -0,0 +1,4 @@
+import { GuidValue } from "./Guid";
+export interface TenantIdentifier {
+    id: GuidValue;
+}

package/internal-do-not-import-from-here/shared/models/Tenant.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import { GuidValue } from "./Guid";
+export interface OmniaToken {
+    tokenKey: string;
+    tokenRef: GuidValue;
+    loginName: string;
+    expires: number;
+    forDevIntent: boolean;
+}
+export interface OmniaTokenRefWithTenant {
+    tenantId: GuidValue;
+    tokenRef: GuidValue;
+    localDev: boolean;
+}

package/internal-do-not-import-from-here/shared/models/Tokens.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,10 @@
+export interface Topic<T> {
+    namespace: string;
+    name: string;
+}
+export interface TopicSettings {
+    caching?: TopicCacheSettings;
+}
+export interface TopicCacheSettings {
+    size: number;
+}

package/internal-do-not-import-from-here/shared/models/Topic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,8 @@
+import { Guid } from "./Guid";
+import { WorkerProxyFunction } from "./Workers";
+export declare const WorkerProxyFuncs: {
+    ui: {
+        loadManifests: WorkerProxyFunction<Guid[], Guid[]>;
+    };
+    worker: {};
+};

package/internal-do-not-import-from-here/shared/models/WorkerProxyFuncs.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerProxyFuncs = void 0;
+const Guid_1 = require("./Guid");
+exports.WorkerProxyFuncs = {
+    //Worker to Ui functions
+    ui: {
+        loadManifests: {
+            id: new Guid_1.Guid("8fb843b7-936f-4fec-a462-77c087adb7de")
+        }
+    },
+    //Ui to worker functions
+    worker: {}
+};

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

@@ -0,0 +1,29 @@
+import { GuidValue } from "./Guid";
+import { OmniaSharedBootstrapData } from "./OmniaSharedBootstrapData";
+export interface WorkerProxyAction<TParamType> {
+    id: GuidValue;
+}
+export interface WorkerProxyFunction<TParamType, TReturnType> extends WorkerProxyAction<TParamType> {
+}
+export interface WorkerProxyMessage<T> {
+    id: GuidValue;
+    data: T;
+    handlerId: GuidValue;
+    initiator: WorkerProxyFunctionInitiators;
+}
+export declare enum WorkerProxyFunctionInitiators {
+    ui = "main",
+    worker = "worker"
+}
+export interface LoadManifestsMessage extends PostMessageWithType {
+    type: "loadManifests";
+    resourceUrls: Array<string>;
+}
+export interface BootWorkerMessage {
+    type: "bootWorker";
+    loadManifests: LoadManifestsMessage;
+    bootData: OmniaSharedBootstrapData;
+}
+export interface PostMessageWithType {
+    type: "bootWorker" | "loadManifests";
+}

package/internal-do-not-import-from-here/shared/models/Workers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerProxyFunctionInitiators = void 0;
+var WorkerProxyFunctionInitiators;
+(function (WorkerProxyFunctionInitiators) {
+    WorkerProxyFunctionInitiators["ui"] = "main";
+    WorkerProxyFunctionInitiators["worker"] = "worker";
+})(WorkerProxyFunctionInitiators = exports.WorkerProxyFunctionInitiators || (exports.WorkerProxyFunctionInitiators = {}));

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

@@ -0,0 +1,14 @@
+export * from "./Guid";
+export * from "./Broadcasting";
+export * from "./Topic";
+export * from "./Workers";
+export * from "./SharedConstants";
+export * from "./WorkerProxyFuncs";
+export * from "./Bring";
+export * from "./Future";
+export * from "./Tokens";
+export * from "./Tenant";
+export * from "./Realtime";
+export * from "./OmniaSharedBootstrapData";
+export * from "./StringExtensions";
+export * from "./theming";

package/internal-do-not-import-from-here/shared/models/index.js

@@ -0,0 +1,18 @@
+"use strict";
+//! <omnia-transform-resource path="9a75501c-254b-46d1-9010-7b13681e06f4" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./Guid"), exports);
+tslib_1.__exportStar(require("./Broadcasting"), exports);
+tslib_1.__exportStar(require("./Topic"), exports);
+tslib_1.__exportStar(require("./Workers"), exports);
+tslib_1.__exportStar(require("./SharedConstants"), exports);
+tslib_1.__exportStar(require("./WorkerProxyFuncs"), exports);
+tslib_1.__exportStar(require("./Bring"), exports);
+tslib_1.__exportStar(require("./Future"), exports);
+tslib_1.__exportStar(require("./Tokens"), exports);
+tslib_1.__exportStar(require("./Tenant"), exports);
+tslib_1.__exportStar(require("./Realtime"), exports);
+tslib_1.__exportStar(require("./OmniaSharedBootstrapData"), exports);
+tslib_1.__exportStar(require("./StringExtensions"), exports);
+tslib_1.__exportStar(require("./theming"), exports);

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

@@ -0,0 +1,60 @@
+import { Guid } from "../Guid";
+import { TypographyDefinition } from "./TypographyDefinition";
+export interface ColorDefinition {
+    dark: boolean;
+    color: string;
+    colorToned: string;
+    colorStyles: ColorStyles;
+    colorTonedStyles: ColorStyles;
+}
+export interface ColorStyles {
+    background: object;
+    color: object;
+    all: object;
+}
+export interface ColorSchema {
+    name: string;
+    base: ColorDefinition;
+    onBase: ColorDefinition;
+    container: ColorDefinition;
+    onContainer: ColorDefinition;
+}
+export interface ColorGroup {
+    dark: ColorSchema;
+    light: ColorSchema;
+}
+export interface ThemeDefinitionV2 {
+    id: Guid;
+    dark: boolean;
+    primary: ColorSchema;
+    secondary: ColorSchema;
+    accent1: ColorSchema;
+    accent2: ColorSchema;
+    accent3: ColorSchema;
+    neutral: ColorSchema;
+    background: ColorSchema;
+    error: ColorSchema;
+    info: ColorSchema;
+    typography: TypographyDefinition;
+}
+export declare const ColorSchemaTypes: {
+    primary: string;
+    secondary: string;
+    accent1: string;
+    accent2: string;
+    accent3: string;
+    neutral: string;
+    background: string;
+    error: string;
+    info: string;
+};
+export declare const ColorTypes: {
+    base: string;
+    baseTone: string;
+    onBase: string;
+    onBaseTone: string;
+    container: string;
+    containerTone: string;
+    onContainer: string;
+    onContainerTone: string;
+};

package/internal-do-not-import-from-here/shared/models/theming/ThemeDefinitionV2.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorTypes = exports.ColorSchemaTypes = void 0;
+exports.ColorSchemaTypes = {
+    primary: "primary",
+    secondary: "secondary",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    neutral: "neutral",
+    background: "background",
+    error: "error",
+    info: "info",
+};
+exports.ColorTypes = {
+    base: "base",
+    baseTone: "baseTone",
+    onBase: "onBase",
+    onBaseTone: "onBaseTone",
+    container: "container",
+    containerTone: "containerTone",
+    onContainer: "onContainer",
+    onContainerTone: "onContainerTone",
+};

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

@@ -0,0 +1,29 @@
+import { Guid } from "../Guid";
+export interface TypographyDefinition {
+    id: Guid;
+    h1: TypographyType;
+    h2: TypographyType;
+    h3: TypographyType;
+    text: TypographyType;
+    caption: TypographyType;
+    link: TypographyType;
+}
+export interface TypographyType {
+    decoration?: string;
+    large: TypographyTypeBreakPoint;
+    medium?: TypographyTypeBreakPoint;
+    small?: TypographyTypeBreakPoint;
+}
+export interface TypographyTypeBreakPoint {
+    weight: number;
+    size: number;
+    lineHeight: number;
+}
+export declare const TypographyTypes: {
+    h1: string;
+    h2: string;
+    h3: string;
+    text: string;
+    caption: string;
+    link: string;
+};

package/internal-do-not-import-from-here/shared/models/theming/TypographyDefinition.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypographyTypes = void 0;
+exports.TypographyTypes = {
+    h1: "h1",
+    h2: "h2",
+    h3: "h3",
+    text: "text",
+    caption: "caption",
+    link: "link",
+};

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

@@ -0,0 +1,2 @@
+export * from "./ThemeDefinitionV2";
+export * from "./TypographyDefinition";

package/internal-do-not-import-from-here/shared/models/theming/index.js

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

package/models/Enums.d.ts

@@ -38,8 +38,10 @@ export declare enum VelcronDescriptorTypes {
 }
 export declare enum VelcronComponentPropertyEditors {
     text = 0,
-    colorPicker = 1,
-    slider = 2
+    colorSchemaPicker = 1,
+    slider = 2,
+    colorPicker = 3,
+    typographyPicker = 4
 }
 export declare enum VelcronDataTypes {
     unknown = "unknown",

package/models/Enums.js

@@ -49,8 +49,10 @@ var VelcronDescriptorTypes;
 var VelcronComponentPropertyEditors;
 (function (VelcronComponentPropertyEditors) {
     VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["text"] = 0] = "text";
-    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["colorPicker"] = 1] = "colorPicker";
+    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["colorSchemaPicker"] = 1] = "colorSchemaPicker";
     VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["slider"] = 2] = "slider";
+    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["colorPicker"] = 3] = "colorPicker";
+    VelcronComponentPropertyEditors[VelcronComponentPropertyEditors["typographyPicker"] = 4] = "typographyPicker";
 })(VelcronComponentPropertyEditors = exports.VelcronComponentPropertyEditors || (exports.VelcronComponentPropertyEditors = {}));
 var VelcronDataTypes;
 (function (VelcronDataTypes) {

package/models/VelcronDefinitions.d.ts

@@ -23,7 +23,7 @@ export interface BuiltInComponentRenderers {
 }
 export type DynamicViewModel = object;
 export interface OnItemRenderedHookResult {
-    cssClass?: Object;
+    cssClass: string;
     containerRenderer?: VelcronContainerRenderer;
 }
 export interface VelcronRenderContext {
@@ -155,7 +155,7 @@ export interface VelcronTextDefinition extends VelcronDefinition {
     type: "Text";
     text: string;
     color?: string;
-    size?: number;
+    typography?: string;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronImageDefinition extends VelcronDefinition {
@@ -166,6 +166,7 @@ export interface VelcronImageDefinition extends VelcronDefinition {
 export interface VelcronButtonDefinition extends VelcronDefinition {
     type: "Button";
     text: string;
+    color: string;
     icon?: VelcronIcon;
     disabled?: boolean;
     events?: VelcronOnPressEvent;
@@ -206,6 +207,7 @@ export interface VelcronFlexViewDefinition extends VelcronDefinition {
     horizontalAlignment?: VelcronHorizontalAlignments;
     verticalAlignment?: VerticalAlignments;
     grow?: number;
+    colorSchema?: string;
     width?: "auto" | "stretch" | number | string;
 }
 export interface VelcronSectionColumnWidth {

package/package.json

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

package/parser/VelcronData.d.ts

@@ -28,7 +28,7 @@ export declare class VelcronData {
     static getOrSetObjectByPathUsingRenderContext<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
     static getTokens(template: any): string[];
     static ensureEventId(event: string): string;
-    static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition): void;
+    static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition, generateNewKeys?: boolean): void;
     static removeKeys(ui: VelcronDefinition | VelcronAppDefinition): void;
     static generateId(): string;
     static createDeferredPromise<T>(): DeferredPromise<T>;

package/parser/VelcronData.js

@@ -556,8 +556,8 @@ class VelcronData {
             event :
             VelcronConstants_1.VelcronConstants.events.idTokenStart + VelcronData.generateId() + VelcronConstants_1.VelcronConstants.events.idTokenEnd + " " + event;
     }
-    static ensureKeys(ui) {
-        if (!ui.key) {
+    static ensureKeys(ui, generateNewKeys = false) {
+        if (!ui.key || generateNewKeys) {
             ui.key = VelcronData.generateId();
         }
         if (ui.events) {
@@ -572,10 +572,10 @@ class VelcronData {
         Object.keys(ui).forEach((key) => {
             if (Array.isArray(ui[key])) {
                 ui[key].forEach((item) => {
-                    if (!item.key) {
+                    if (!item.key || generateNewKeys) {
                         item.key = VelcronData.generateId();
                     }
-                    VelcronData.ensureKeys(item);
+                    VelcronData.ensureKeys(item, generateNewKeys);
                 });
             }
         });

package/parser/VelcronStyles.d.ts

@@ -1,9 +1,19 @@
 import { VelcronDefinition, VelcronRenderContext } from "../models";
+export declare enum VelcronSizeUnits {
+    Pixels = 1,
+    Numbers = 2
+}
+export interface VelcronStyleSettings {
+    sizeUnit: VelcronSizeUnits;
+}
 export declare class VelcronStyles {
+    private static styleSettings;
     static create(definition: VelcronDefinition, renderCtx: VelcronRenderContext): any;
     private static createStylesForText;
     private static createStylesForImage;
     private static createStylesForFlexbox;
     private static createStylesForLayoutColumnComponent;
     private static dataBindStyles;
+    private static setUnitForValue;
+    private static setup;
 }

package/parser/VelcronStyles.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VelcronStyles = void 0;
+exports.VelcronStyles = exports.VelcronSizeUnits = void 0;
 const VelcronData_1 = require("./VelcronData");
 const models_1 = require("../models");
 const VelcronConstants_1 = require("./VelcronConstants");
+var VelcronSizeUnits;
+(function (VelcronSizeUnits) {
+    VelcronSizeUnits[VelcronSizeUnits["Pixels"] = 1] = "Pixels";
+    VelcronSizeUnits[VelcronSizeUnits["Numbers"] = 2] = "Numbers";
+})(VelcronSizeUnits = exports.VelcronSizeUnits || (exports.VelcronSizeUnits = {}));
 class VelcronStyles {
     static create(definition, renderCtx) {
         let result = { ...definition.style };
@@ -26,20 +31,25 @@ class VelcronStyles {
         return result;
     }
     static createStylesForText(textDefinition, styles) {
-        if (textDefinition.color) {
-            styles["color"] = textDefinition.color;
-        }
-        if (textDefinition.size) {
-            styles["fontSize"] = textDefinition.size + "px";
-        }
+        // const themeStore = useInject(ThemeStore);
+        // if (textDefinition.color && textDefinition.color != "") {
+        //     styles["color"] = themeStore.getters.getColor(textDefinition.color);
+        // }
+        // else {
+        //     styles["color"] = themeStore.getters.activeSchema().onBase.color;
+        // }
+        // const typography = themeStore.getters.typography(textDefinition.typography);
+        // styles["fontSize"] = this.setUnitForValue(typography.large.size);
+        // styles["font-weight"] = typography.large.weight;
+        // styles["line-height"] = this.setUnitForValue(typography.large.lineHeight);
         return styles;
     }
     static createStylesForImage(imageDef, styles) {
         if (!styles.width) {
-            styles.width = 200;
+            styles.width = this.setUnitForValue(200);
         }
         if (!styles.height) {
-            styles.height = 400;
+            styles.height = this.setUnitForValue(400);
         }
         styles.flex = "0 0 auto!important";
         return styles;
@@ -50,44 +60,51 @@ class VelcronStyles {
     //     styles["flex-direction"] = sectionDef.column ? "column" : "row";
     //     return styles;
     // }
-    static createStylesForFlexbox(columnDef, styles) {
-        const flexGrow = columnDef.grow ? columnDef.grow : 1;
+    static createStylesForFlexbox(flexViewDefinition, styles) {
+        const flexGrow = flexViewDefinition.grow ? flexViewDefinition.grow : 1;
         const flextShrink = flexGrow;
         styles.display = "flex";
-        styles.flex = `${flexGrow}`;
+        styles.flex = flexGrow;
         styles["max-width"] = "100%";
-        styles["flex-direction"] = columnDef.column ? "column" : "row";
+        styles["flex-direction"] = flexViewDefinition.column ? "column" : "row";
         //Auto
-        if (columnDef.width && columnDef.width === models_1.VelcronSectionColumnWidthTypes.auto) {
+        if (flexViewDefinition.width && flexViewDefinition.width === models_1.VelcronSectionColumnWidthTypes.auto) {
             styles["flex"] = `${flexGrow} ${flextShrink} auto`;
         }
         //Pixels
-        else if (columnDef.width && VelcronData_1.VelcronData.isString(columnDef.width) && columnDef.width.endsWith("px")) {
+        else if (flexViewDefinition.width && VelcronData_1.VelcronData.isString(flexViewDefinition.width) && flexViewDefinition.width.endsWith("px")) {
             //width["flex"] = `${flexGrow} ${flextShrink} ${columnDef.width}`;
-            styles["max-width"] = columnDef.width;
+            styles["max-width"] = this.setUnitForValue(flexViewDefinition.width);
         }
         //Percentage
-        else if (columnDef.width && (isNaN(columnDef.width) === false)) {
-            styles["flex"] = `${flexGrow} ${flextShrink} ${columnDef.width}%`;
+        else if (flexViewDefinition.width && (isNaN(flexViewDefinition.width) === false)) {
+            styles["flex"] = `${flexGrow} ${flextShrink} ${flexViewDefinition.width}%`;
         }
         // if (columnDef.horizontalAlignment && columnDef.horizontalAlignment !== VelcronHorizontalAlignments.left) {
         //     //Need to add this to make horizontalAlignment work for child div
         //     result["flex-direction"] = "column";
         // }
-        if (columnDef.horizontalAlignment) {
+        if (flexViewDefinition.horizontalAlignment) {
             //Need to add this to make horizontalAlignment work for child div
-            styles["justify-content"] = columnDef.horizontalAlignment;
+            styles["justify-content"] = flexViewDefinition.horizontalAlignment;
         }
-        if (columnDef.verticalAlignment) {
-            if (columnDef.verticalAlignment === models_1.VerticalAlignments.center) {
+        if (flexViewDefinition.verticalAlignment) {
+            if (flexViewDefinition.verticalAlignment === models_1.VerticalAlignments.center) {
                 //result["flex-direction"] = "column";
                 styles["align-items"] = "center";
             }
-            else if (columnDef.verticalAlignment === models_1.VerticalAlignments.bottom) {
+            else if (flexViewDefinition.verticalAlignment === models_1.VerticalAlignments.bottom) {
                 //result["flex-direction"] = "column";
                 styles["align-items"] = "flex-end";
             }
         }
+        // if (flexViewDefinition.colorSchema && flexViewDefinition.colorSchema != "") {
+        //     const themeStore = useInject(ThemeStore);
+        //     styles["background-color"] = themeStore.getters.activeSchema().base.color;
+        // }
+        //Color
+        //if(flexViewDefinition.co)
+        //const { theming } =  useTheme();
         return styles;
     }
     static createStylesForLayoutColumnComponent(layoutDef, columnDef, styles) {
@@ -111,5 +128,17 @@ class VelcronStyles {
         });
         return styles;
     }
+    static setUnitForValue(value) {
+        if (this.styleSettings.sizeUnit === VelcronSizeUnits.Pixels) {
+            return value + "px";
+        }
+        return value;
+    }
+    static setup(settings) {
+        this.styleSettings = settings;
+    }
 }
 exports.VelcronStyles = VelcronStyles;
+VelcronStyles.styleSettings = {
+    sizeUnit: VelcronSizeUnits.Pixels
+};

package/stores/VelcronStore.d.ts

@@ -0,0 +1,12 @@
+export declare class VelcronStore {
+    static makeReactive: (obj: any) => unknown;
+    static reactivityCreator(fn: (obj: any) => unknown): void;
+    state<T>(obj: T): T;
+    mutation(fn: () => void): void;
+}
+export declare class TestStore extends VelcronStore {
+    test: {
+        title: string;
+    };
+    increment: (text: string) => string;
+}

package/stores/VelcronStore.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestStore = exports.VelcronStore = void 0;
+class VelcronStore {
+    static reactivityCreator(fn) {
+        VelcronStore.makeReactive = fn;
+    }
+    state(obj) {
+        if (!VelcronStore.makeReactive) {
+            throw new Error("Reactivity creator not set");
+        }
+        return VelcronStore.makeReactive(obj);
+    }
+    mutation(fn) {
+        fn();
+    }
+}
+exports.VelcronStore = VelcronStore;
+class TestStore extends VelcronStore {
+    constructor() {
+        super(...arguments);
+        this.test = this.state({ title: "Hello" });
+        this.increment = (text) => this.test.title = text;
+    }
+}
+exports.TestStore = TestStore;

package/stores/index.d.ts

@@ -0,0 +1 @@
+export * from "./VelcronStore";

package/stores/index.js

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