@omnia/velcron 8.0.81-vnext → 8.0.82-dev

package/models/VelcronPropertyEditorDefinitions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuiltInPropertyEditorTypes = void 0;
+exports.VelcronStateBinding = exports.VelcronSpacingStateBinding = exports.VelcronColorSchemasStateBinding = exports.VelcronContentStateBinding = exports.VelcronHeaderStateBinding = exports.VelcronImagesStateBinding = exports.BuiltInPropertyEditorTypes = void 0;
+// export type BuiltInPropertyEditorType = "text" | "slider" | "switch" | "alignment" | "color" | "markdown" | "icon" | "image" | "typography" | "color-schema-type" | "spacing" ;
 var BuiltInPropertyEditorTypes;
 (function (BuiltInPropertyEditorTypes) {
     BuiltInPropertyEditorTypes["text"] = "text";
@@ -11,4 +12,117 @@ var BuiltInPropertyEditorTypes;
     BuiltInPropertyEditorTypes["markdown"] = "markdown";
     BuiltInPropertyEditorTypes["icon"] = "icon";
     BuiltInPropertyEditorTypes["image"] = "image";
-})(BuiltInPropertyEditorTypes = exports.BuiltInPropertyEditorTypes || (exports.BuiltInPropertyEditorTypes = {}));
+    BuiltInPropertyEditorTypes["typography"] = "typography";
+    BuiltInPropertyEditorTypes["spacing"] = "spacing";
+    BuiltInPropertyEditorTypes["color-schema-type"] = "color-schema-type";
+})(BuiltInPropertyEditorTypes || (exports.BuiltInPropertyEditorTypes = BuiltInPropertyEditorTypes = {}));
+exports.VelcronImagesStateBinding = {
+    main: {
+        editor: "{{images.main.url}}",
+        url: "{{images.main.url}}",
+        ratio: "{{images.main.ratio}}",
+        caption: "{{images.main.caption}}",
+        width: "{{images.main.width}}",
+        height: "{{images.main.height}}",
+    },
+    alt1: {
+        editor: "{{images.alt1.url}}",
+        url: "{{images.alt1.url}}",
+        ratio: "{{images.alt1.ratio}}",
+        caption: "{{images.alt1.caption}}",
+        width: "{{images.alt1.width}}",
+        height: "{{images.alt1.height}}",
+    },
+    alt2: {
+        editor: "{{images.alt2.url}}",
+        url: "{{images.alt2.url}}",
+        ratio: "{{images.alt2.ratio}}",
+        caption: "{{images.alt2.caption}}",
+        width: "{{images.alt2.width}}",
+        height: "{{images.alt2.height}}",
+    },
+};
+exports.VelcronHeaderStateBinding = {
+    title: {
+        text: "{{header.title.text}}",
+        placeholder: "{{header.title.placeholder}}",
+        typography: {
+            editor: "header.title.typography",
+            type: "{{header.title.typography.type}}",
+            size: "{{header.title.typography.size}}",
+            toned: "{{header.title.typography.toned}}",
+        }
+    },
+    icon: "{{header.icon}}"
+};
+exports.VelcronContentStateBinding = {
+    title: {
+        text: "{{content.title.text}}",
+        placeholder: "{{content.title.placeholder}}",
+        typography: {
+            editor: "content.title.typography",
+            type: "{{content.title.typography.type}}",
+            size: "{{content.title.typography.size}}",
+            toned: "{{content.title.typography.toned}}",
+        }
+    },
+    main: {
+        text: "{{content.main.text}}",
+        placeholder: "{{content.main.placeholder}}",
+        typography: {
+            editor: "content.main.typography",
+            type: "{{content.main.typography.type}}",
+            size: "{{content.main.typography.size}}",
+            toned: "{{content.main.typography.toned}}",
+        }
+    },
+    caption: {
+        text: "{{content.caption.text}}",
+        placeholder: "{{content.caption.placeholder}}",
+        typography: {
+            editor: "content.caption.typography",
+            type: "{{content.caption.typography.type}}",
+            size: "{{content.caption.typography.size}}",
+            toned: "{{content.caption.typography.toned}}",
+        }
+    },
+    summary: {
+        text: "{{content.summary.text}}",
+        placeholder: "{{content.summary.placeholder}}",
+        typography: {
+            editor: "content.summary.typography",
+            type: "{{content.summary.typography.type}}",
+            size: "{{content.summary.typography.size}}",
+            toned: "{{content.summary.typography.toned}}",
+        }
+    },
+};
+exports.VelcronColorSchemasStateBinding = {
+    main: {
+        type: "{{colorSchemas.main.type}}",
+        filled: "{{colorSchemas.main.filled}}"
+    }
+};
+exports.VelcronSpacingStateBinding = {
+    chrome: {
+        "top": "{{spacing.chrome.top}}",
+        "right": "{{spacing.chrome.right}}",
+        "bottom": "{{spacing.chrome.bottom}}",
+        "left": "{{spacing.chrome.left}}",
+    }
+};
+// export interface VelcronSpacingState {
+//     chrome?: VelcronDimensionState 
+// }
+// export interface VelcronDimensionState {
+//     margin?: VelcronSpacing;
+//     padding?: VelcronSpacing;
+// } 
+exports.VelcronStateBinding = {
+    colorSchemas: exports.VelcronColorSchemasStateBinding,
+    images: exports.VelcronImagesStateBinding,
+    content: exports.VelcronContentStateBinding,
+    header: exports.VelcronHeaderStateBinding,
+    spacing: exports.VelcronSpacingStateBinding
+    //properties?:VelcronPropertiesState,    
+};

package/models/VelcronTypes.d.ts

@@ -1,4 +1,4 @@
-import { VelcronDefinition } from "./VelcronDefinitions";
+import { VelcronDefinition } from "@omnia/fx-models";
 export type VelcronPrimitiveType = string | number | boolean;
 export type VelcronArrayType<T> = Array<T>;
 export type VelcronObjectType<T extends Object> = T;

package/models/ViewModelAndContext.d.ts

@@ -1,4 +1,4 @@
-import { VelcronAppDefinition } from "./VelcronDefinitions";
+import { VelcronAppDefinition } from "@omnia/fx-models";
 export interface AppJson {
     app: VelcronAppDefinition;
 }

package/models/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./VelcronDefinitions";
 export * from "./ViewModelAndContext";
-export * from "./VelcronEvents";
 export * from "./VelcronTypes";
 export * from "./Enums";
 export * from "./VelcronUnitProvider";
 export * from "./VelcronPropertyEditorDefinitions";
+export * from "./ActionHooks";

package/models/index.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./VelcronDefinitions"), exports);
 tslib_1.__exportStar(require("./ViewModelAndContext"), exports);
-tslib_1.__exportStar(require("./VelcronEvents"), exports);
 tslib_1.__exportStar(require("./VelcronTypes"), exports);
 tslib_1.__exportStar(require("./Enums"), exports);
 tslib_1.__exportStar(require("./VelcronUnitProvider"), exports);
 tslib_1.__exportStar(require("./VelcronPropertyEditorDefinitions"), exports);
+tslib_1.__exportStar(require("./ActionHooks"), exports);

package/package.json

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

package/parser/VelcronActions.d.ts

@@ -1,13 +1,16 @@
-import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise } from "../models";
+import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise, VelcronActionHooks } from "../models";
 import { IActionHandler } from "../actions";
 export declare class VelcronActions {
     static _actionHandlers: {
         [name: string]: IActionHandler;
     } | null;
+    static actionHooks: {
+        [name: string]: VelcronActionHooks;
+    };
     static registerAction(name: string, handler: IActionHandler): void;
     static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): void;
     static parseFunction(target: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;
     static getActionFromTemplate(partialTemplate: string, eventId: string, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): VelcronAction;
     static valueIsAction(value: string): boolean;
@@ -15,6 +18,9 @@ export declare class VelcronActions {
     static executeAction(awAction: VelcronActionWithAutoAwait, callback: (continueExecution: boolean) => void): void;
     static dataBindComputed(renderContext: VelcronRenderContext, template: string): string;
     static parseAndExecuteComputed(renderContext: VelcronRenderContext, template: string): string;
+    static registerActionHook<TBefore, TAfter>(actionName: string, handler: VelcronActionHooks<TBefore, TAfter>): void;
+    static tryTriggerBeforeActionHook<T>(actionName: string, args: T): T;
+    static tryTriggerAfterActionHook<T>(actionName: string, args: T): T;
     private static extractParameterValues;
 }
 interface VelcronActionParameterValue {

package/parser/VelcronActions.js

@@ -271,6 +271,9 @@ class VelcronActions {
             if (VelcronActions._actionHandlers[actionName]) {
                 //Built in handler
                 promise = VelcronActions._actionHandlers[actionName].action(awAction, ...paramValues);
+                if (VelcronActions._actionHandlers[actionName].dispose) {
+                    awAction.disposers.push(VelcronActions._actionHandlers[actionName].dispose(awAction));
+                }
             }
             else {
                 //Custom handler
@@ -331,7 +334,7 @@ class VelcronActions {
         return text;
     }
     static parseAndExecuteComputed(renderContext, template) {
-        VelcronData_1.VelcronData.getTokens(template).forEach(token => {
+        VelcronData_1.VelcronData.getTokens(template, false).forEach(token => {
             const paramValues = [];
             VelcronActions.parseFunction(renderContext.computed, token, renderContext, paramValues, (acName, params) => {
                 const funcContent = renderContext.computed[acName];
@@ -348,6 +351,22 @@ class VelcronActions {
         });
         return template;
     }
+    static registerActionHook(actionName, handler) {
+        VelcronActions.actionHooks ?? (VelcronActions.actionHooks = {});
+        VelcronActions.actionHooks[actionName] = handler;
+    }
+    static tryTriggerBeforeActionHook(actionName, args) {
+        if (VelcronActions.actionHooks && VelcronActions.actionHooks[actionName] && VelcronActions.actionHooks[actionName].beforeHandler) {
+            return VelcronActions.actionHooks[actionName].beforeHandler(args);
+        }
+        return args;
+    }
+    static tryTriggerAfterActionHook(actionName, args) {
+        if (VelcronActions.actionHooks && VelcronActions.actionHooks[actionName] && VelcronActions.actionHooks[actionName].afterHandler) {
+            return VelcronActions.actionHooks[actionName].afterHandler(args);
+        }
+        return args;
+    }
     static extractParameterValues(template, action) {
         const params = [];
         let hasMoreParams = true;
@@ -414,7 +433,7 @@ class VelcronActions {
                     }
                     else {
                         //Try get it from ViewModel
-                        castedValue = VelcronData_1.VelcronData.getOrSetObjectByPathUsingRenderContext(action, castedValue);
+                        castedValue = VelcronData_1.VelcronData.getOrSet(action, castedValue);
                     }
                 }
                 params.push({ dataType: dataType, value: castedValue });
@@ -432,12 +451,13 @@ class VelcronActions {
         return params;
     }
 }
-VelcronActions._actionHandlers = null;
 exports.VelcronActions = VelcronActions;
+VelcronActions._actionHandlers = null;
+VelcronActions.actionHooks = {};
 var VelcronActionParameterDataType;
 (function (VelcronActionParameterDataType) {
     VelcronActionParameterDataType[VelcronActionParameterDataType["text"] = 0] = "text";
     VelcronActionParameterDataType[VelcronActionParameterDataType["number"] = 1] = "number";
     VelcronActionParameterDataType[VelcronActionParameterDataType["boolean"] = 2] = "boolean";
     VelcronActionParameterDataType[VelcronActionParameterDataType["pointer"] = 3] = "pointer";
-})(VelcronActionParameterDataType = exports.VelcronActionParameterDataType || (exports.VelcronActionParameterDataType = {}));
+})(VelcronActionParameterDataType || (exports.VelcronActionParameterDataType = VelcronActionParameterDataType = {}));

package/parser/VelcronConstants.d.ts

@@ -1,18 +1,26 @@
 export declare const VelcronConstants: {
     components: {
-        appDefinition: string;
-        view: string;
+        velcron: string;
+        flex: string;
+        row: string;
+        column: string;
         card: string;
         text: string;
         image: string;
+        video: string;
         button: string;
-        textInput: string;
-        progress: string;
-        webView: string;
+        "text-input": string;
+        "progress-circle": string;
+        "web-view": string;
+        "custom-component": string;
         dialog: string;
         icon: string;
         chip: string;
         markdown: string;
+        slot: string;
+        property: string;
+        checkbox: string;
+        reference: string;
     };
     events: {
         idTokenStart: string;
@@ -25,5 +33,9 @@ export declare const VelcronConstants: {
     properties: {
         tokenStart: string;
         tokenEnd: string;
+        propsToken: string;
+    };
+    context: {
+        thisToken: string;
     };
 };

package/parser/VelcronConstants.js

@@ -3,19 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VelcronConstants = void 0;
 exports.VelcronConstants = {
     components: {
-        appDefinition: "velcron",
-        view: "view",
+        velcron: "velcron",
+        flex: "flex",
+        row: "row",
+        column: "column",
         card: "card",
         text: "text",
         image: "image",
+        video: "video",
         button: "button",
-        textInput: "text-input",
-        progress: "progress",
-        webView: "web-view",
+        "text-input": "text-input",
+        "progress-circle": "progress-circle",
+        "web-view": "web-view",
+        "custom-component": "custom-component",
         dialog: "dialog",
         icon: "icon",
         chip: "chip",
         markdown: "markdown",
+        slot: "slot",
+        property: "property",
+        checkbox: "checkbox",
+        reference: "reference"
     },
     events: {
         idTokenStart: "$ev{",
@@ -26,7 +34,11 @@ exports.VelcronConstants = {
         stateRootToken: "$state"
     },
     properties: {
-        tokenStart: "${",
-        tokenEnd: "}"
+        tokenStart: "{{",
+        tokenEnd: "}}",
+        propsToken: "$props"
+    },
+    context: {
+        thisToken: "$this"
     }
 };

package/parser/VelcronData.d.ts

@@ -1,4 +1,5 @@
-import { VelcronAppDefinition, VelcronDefinition, VelcronRenderContext, DeferredPromise, VelcronBindableProp } from "../models";
+import { VelcronRenderContext, DeferredPromise, VelcronBindableProp } from "../models";
+import { VelcronAppDefinition, VelcronDefinition } from "..";
 export interface ParseResult<T> {
     is: boolean;
     value: T;
@@ -25,8 +26,8 @@ export declare class VelcronData {
     static isObject(value: any): boolean;
     static extendObject(obj: any): any;
     static getOrSetObjectByPath<T>(object: Object, path: string, value?: any): T | null;
-    static getOrSetObjectByPathUsingRenderContext<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
-    static getTokens(template: any): string[];
+    static getOrSet<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
+    static getTokens(template: any, removeBrackets: boolean): string[];
     static ensureEventId(event: string): string;
     static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition, generateNewKeys?: boolean): void;
     static removeKeys(ui: VelcronDefinition | VelcronAppDefinition): void;

package/parser/VelcronData.js

@@ -10,10 +10,9 @@ class VelcronData {
         if (!VelcronData.isString(text)) {
             return text;
         }
-        const tokens = this.getTokens(text);
-        tokens.forEach((name) => {
-            let data = this.getOrSetObjectByPathUsingRenderContext(renderContext, name);
-            const token = VelcronConstants_1.VelcronConstants.properties.tokenStart + name + VelcronConstants_1.VelcronConstants.properties.tokenEnd;
+        const tokens = this.getTokens(text, false);
+        tokens.forEach((token) => {
+            let data = this.getOrSet(renderContext, token.replace(/\s*{{\s*|\s*}}\s*/g, ""));
             if (data instanceof TextValue_1.TextValue) {
                 data = data.value;
             }
@@ -71,11 +70,11 @@ class VelcronData {
         let propertiesToEval = {};
         if (renderContext.properties) {
             //Custom component properties evaluation
-            propertiesToEval = {};
-            Object.keys(renderContext.properties).forEach((key) => {
-                propertiesToEval[key] = "properties";
-            });
-            names.push("properties");
+            // propertiesToEval = {};
+            // Object.keys(renderContext.properties).forEach((key) => {
+            //     propertiesToEval[key] = VelcronConstants.properties.propsToken;
+            // });
+            names.push(VelcronConstants_1.VelcronConstants.properties.propsToken);
             obj.push(renderContext.properties);
         }
         else if (overrideNamesMatching) {
@@ -85,7 +84,8 @@ class VelcronData {
             "null",
             "return"
         ];
-        template = VelcronData.addCtxToVariableNames(template, undefined, reservedWords, propertiesToEval);
+        const skipName = "$props";
+        template = VelcronData.addCtxToVariableNames(template, skipName, reservedWords, propertiesToEval);
         names.push("rootCtx");
         names.push("currentCtx");
         obj.push(renderContext.rootContext);
@@ -224,7 +224,7 @@ class VelcronData {
                     }
                     else {
                         //Try get value from rootContext or currentContext
-                        value = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                        value = VelcronData.getOrSet(renderContext, value);
                     }
                 }
             }
@@ -244,7 +244,7 @@ class VelcronData {
                 runEvaluation = true;
             }
         }
-        const existingVal = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, path);
+        const existingVal = VelcronData.getOrSet(renderContext, path);
         if (assignOperator === models_1.AssignOperators.equals || assignOperator === models_1.AssignOperators.equalsExclamation) {
             //debugger;
             if (typeof existingVal === "boolean" && typeof value !== "boolean") {
@@ -275,7 +275,7 @@ class VelcronData {
             else if (assignOperator && VelcronData.isString(value)) {
                 //Value is assignment from renderContext
                 // "$state.title = title" or "$state.title = $state.anotherTitle"
-                if (value === "this") {
+                if (value === "$this") {
                     // $state.currentItem = this (this means currentContext)
                     value = renderContext.currentContext;
                 }
@@ -286,7 +286,10 @@ class VelcronData {
                     }
                     else {
                         //try get value from render context
-                        value = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                        const localVal = VelcronData.getOrSet(renderContext, value);
+                        if (localVal !== undefined && localVal !== null) {
+                            value = localVal;
+                        }
                     }
                 }
             }
@@ -492,7 +495,7 @@ class VelcronData {
         }
         return object;
     }
-    static getOrSetObjectByPathUsingRenderContext(renderContext, path, value = undefined) {
+    static getOrSet(renderContext, path, value = undefined) {
         let result;
         if (VelcronData.isUndefined(path)) {
             return result;
@@ -508,52 +511,53 @@ class VelcronData {
             variables[renderContext.id].hasOwnProperty(path)) {
             result = variables[renderContext.id][path];
         }
+        else if (path.startsWith(VelcronConstants_1.VelcronConstants.properties.propsToken + ".")) {
+            //props in a custom component $props.
+            path = path.substring(VelcronConstants_1.VelcronConstants.properties.propsToken.length + 1);
+            const propObj = VelcronData.getOrSetObjectByPath(renderContext.properties, path);
+            if (VelcronData.isString(propObj)) {
+                const propString = propObj;
+                path = VelcronData.dataBind(renderContext, propString);
+                result = path;
+            }
+            result = propObj;
+        }
+        else if (path === VelcronConstants_1.VelcronConstants.context.thisToken) {
+            //Eg foreach loop and binding to the whole object in binding use $this
+            result = renderContext.currentContext;
+        }
         else {
-            let pathIsPropertyValue = false;
-            if (renderContext.properties?.hasOwnProperty(path)) {
-                pathIsPropertyValue = true;
-                const propObj = renderContext.properties[path];
-                if (VelcronData.isString(propObj)) {
-                    const propString = propObj;
-                    path = VelcronData.dataBind(renderContext, propString);
-                }
-                result = propObj;
+            const tokens = VelcronData.getTokens(path, true);
+            if (tokens.length > 0) {
+                path = tokens[0];
             }
-            if (!result || VelcronData.isString(result)) {
-                const tokens = VelcronData.getTokens(path);
-                if (tokens.length > 0) {
-                    path = tokens[0];
-                }
-                let object = null;
-                if (path.startsWith(`${VelcronConstants_1.VelcronConstants.state.stateRootToken}.`) || path === VelcronConstants_1.VelcronConstants.state.stateRootToken) {
-                    //Fetch from the data object
-                    object = renderContext.rootContext;
-                    path = path.substring(6);
-                }
-                else {
-                    //Fetch from current ctx
-                    object = renderContext.currentContext;
-                }
-                if (VelcronData.isObject(object)) {
-                    result = VelcronData.getOrSetObjectByPath(object, path, value);
-                }
-                else {
-                    //For example if you bind to Array of ["string"] the currentContext is only a string so we just return the object without mapping path
-                    result = object;
-                }
-                if (typeof result === "undefined" && pathIsPropertyValue) {
-                    result = path;
-                }
+            let object = null;
+            if (path.startsWith(`${VelcronConstants_1.VelcronConstants.state.stateRootToken}.`) || path === VelcronConstants_1.VelcronConstants.state.stateRootToken) {
+                //Fetch from the data object
+                object = renderContext.rootContext;
+                path = path.substring(6);
+            }
+            else {
+                //Fetch from current ctx
+                object = renderContext.currentContext;
+            }
+            if (VelcronData.isObject(object)) {
+                result = VelcronData.getOrSetObjectByPath(object, path, value);
+            }
+            else {
+                //For example if you bind to Array of ["string"] the currentContext is only a string so we just return the object without mapping path
+                result = object;
             }
         }
         return result;
     }
-    static getTokens(template) {
+    static getTokens(template, removeBrackets) {
         const tokens = [];
         if (template) {
-            template.replace(/(\${).+?(?=\})/g, (tokenWithVar, token) => {
-                tokens.push(tokenWithVar.substring(2));
-                return token;
+            template.replace(removeBrackets ? /{{\s*(.+?)\s*}}/g : /(\{{.+?\}})/g, (foundToken, token) => {
+                const tokenWithVar = removeBrackets ? token : foundToken;
+                tokens.push(tokenWithVar);
+                return tokenWithVar;
             });
         }
         return tokens;
@@ -634,5 +638,5 @@ class VelcronData {
         return { promise, reject, resolve };
     }
 }
-VelcronData.variables = {};
 exports.VelcronData = VelcronData;
+VelcronData.variables = {};

package/parser/VelcronPropertyEditors.d.ts

@@ -0,0 +1,9 @@
+import { BuiltInPropertyEditors, ResolvedPropertyEditor } from "../models";
+export declare class VelcronPropertyEditors {
+    private static editors;
+    static registerEditor(type: string, editor: any): void;
+    static hasEditors(): boolean;
+    static hasEditor(type: string): any;
+    static registerEditors(editors: BuiltInPropertyEditors): void;
+    static getEditor(editor: string): ResolvedPropertyEditor;
+}

package/parser/VelcronPropertyEditors.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronPropertyEditors = void 0;
+class VelcronPropertyEditors {
+    static registerEditor(type, editor) {
+        type = type.toLowerCase();
+        if (!this.editors[type]) {
+            this.editors[type] = editor;
+        }
+        else {
+            throw `Velcron Property Editor of type ${type} is already registered`;
+        }
+    }
+    static hasEditors() {
+        return Object.keys(this.editors).length > 0;
+    }
+    static hasEditor(type) {
+        type = type.toLowerCase();
+        return this.editors[type];
+    }
+    static registerEditors(editors) {
+        Object.keys(editors).forEach((key) => {
+            this.registerEditor(key, editors[key]);
+        });
+    }
+    static getEditor(editor) {
+        let result;
+        if (this.editors[editor.toLowerCase()]) {
+            result = {
+                editor: this.editors[editor.toLowerCase()],
+            };
+        }
+        else {
+            throw "Cant find property editor";
+        }
+        return result;
+    }
+}
+exports.VelcronPropertyEditors = VelcronPropertyEditors;
+VelcronPropertyEditors.editors = {};

package/parser/VelcronRenderers.d.ts

@@ -1,4 +1,5 @@
-import { BuiltInComponentRenderers, DynamicState, ResolvedComponentRenderer, VelcronDefinition, VelcronRenderContext } from "../models";
+import { BuiltInComponentRenderers, ResolvedComponentRenderer, VelcronRenderContext } from "../models";
+import { DynamicState, VelcronDefinition } from "..";
 export declare class VelcronRenderers {
     private static components;
     static registerComponent(type: string, component: any): void;