@omnia/velcron 7.0.36-preview

package/parser/VelcronData.js

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronData = void 0;
+const models_1 = require("../models");
+const VelcronConstants_1 = require("./VelcronConstants");
+const VelcronLogger_1 = require("./VelcronLogger");
+const TextValue_1 = require("./TextValue");
+class VelcronData {
+    static dataBind(renderContext, text) {
+        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;
+            if (data instanceof TextValue_1.TextValue) {
+                data = data.value;
+            }
+            text = text.replace(token, data);
+        });
+        return text;
+    }
+    static addCtxToVariableNames(template, skipIfNameStartsWith, skipIfNameMatches, overridePrefixWhenNameMatches) {
+        const re = new RegExp(/[^0-9a-z-.'$]/, "gi");
+        const results = [];
+        let match;
+        let lastIndex;
+        while (lastIndex = re.lastIndex, match = re.exec(template)) {
+            const text = template.substring(lastIndex, match.index);
+            if (text.length > 0 && text.startsWith("'") === false && text.endsWith("'") === false) {
+                results.push({ text: text, index: lastIndex });
+            }
+        }
+        results.push({ text: template.substring(lastIndex), index: lastIndex });
+        let appendedLenght = 0;
+        results.forEach((variableMatch) => {
+            //variable name cant start as a number
+            //'' is not allowed as variable name we used it in regex so if a value is set
+            //containing same name as a variable it will not be replaced
+            if (isNaN(variableMatch.text.substring(0, 1)) && (!variableMatch.text.startsWith("'")) && variableMatch.text.length > 0) {
+                if (skipIfNameStartsWith && variableMatch.text.startsWith(skipIfNameStartsWith) || skipIfNameMatches && skipIfNameMatches.filter(p => p === variableMatch.text).length > 0) { }
+                else {
+                    let subName = variableMatch.text;
+                    if (subName.startsWith(VelcronConstants_1.VelcronConstants.state.stateRootToken)) {
+                        subName = subName.substring(VelcronConstants_1.VelcronConstants.state.stateRootToken.length + 1);
+                    }
+                    let prefix = variableMatch.text.startsWith(VelcronConstants_1.VelcronConstants.state.stateRootToken) ? "rootCtx " : "currentCtx";
+                    if (overridePrefixWhenNameMatches && overridePrefixWhenNameMatches[variableMatch.text]) {
+                        prefix = overridePrefixWhenNameMatches[variableMatch.text];
+                    }
+                    else if (overridePrefixWhenNameMatches && variableMatch.text.indexOf(".") > -1) {
+                        //TODO: If this gets issues we need make overridePrefixWhenNameMatches to contain settings object
+                        const toMatch = variableMatch.text.substring(0, variableMatch.text.indexOf("."));
+                        if (overridePrefixWhenNameMatches[toMatch]) {
+                            prefix = overridePrefixWhenNameMatches[toMatch];
+                            subName = variableMatch.text.substring(toMatch.length + 1);
+                        }
+                    }
+                    const newName = `${prefix.trim()}.${subName}`;
+                    template = template.substring(0, (variableMatch.index + appendedLenght)) + newName + template.substring((variableMatch.index + appendedLenght) + variableMatch.text.length);
+                    appendedLenght = +prefix.length + 1;
+                }
+            }
+        });
+        return template;
+    }
+    static evauluateJs(template, renderContext, overrideNamesMatching = null) {
+        const obj = [];
+        const names = [];
+        let propertiesToEval = {};
+        if (renderContext.properties) {
+            //Custom component properties evaluation
+            propertiesToEval = {};
+            Object.keys(renderContext.properties).forEach((key) => {
+                propertiesToEval[key] = "properties";
+            });
+            names.push("properties");
+            obj.push(renderContext.properties);
+        }
+        else if (overrideNamesMatching) {
+            propertiesToEval = overrideNamesMatching;
+        }
+        const reservedWords = [
+            "null",
+            "return"
+        ];
+        template = VelcronData.addCtxToVariableNames(template, undefined, reservedWords, propertiesToEval);
+        names.push("rootCtx");
+        names.push("currentCtx");
+        obj.push(renderContext.rootContext);
+        obj.push(renderContext.currentContext);
+        //TODO we shouls try catch and return info 
+        const evalResult = Function(...names, "\"use strict\";return " + template)(...obj);
+        return evalResult;
+    }
+    static deleteVariables(id) {
+        if (VelcronData.variables[id]) {
+            delete VelcronData.variables[id];
+        }
+    }
+    static getVariable(name, renderContext) {
+        const variables = VelcronData.variables;
+        const result = { is: false, value: undefined };
+        if (renderContext.id &&
+            variables.hasOwnProperty(renderContext.id) &&
+            variables[renderContext.id].hasOwnProperty(name)) {
+            result.value = variables[renderContext.id][name];
+            result.is = true;
+        }
+        return result;
+    }
+    static setVariables(eventId, varsToSet) {
+        const variables = VelcronData.variables;
+        if (!variables[eventId]) {
+            variables[eventId] = {};
+        }
+        Object.keys(varsToSet).forEach((key) => {
+            variables[eventId][key] = varsToSet[key];
+        });
+    }
+    static evaluateSet(path, value, renderContext) {
+        const obj = [];
+        const names = [];
+        let assignOperator = models_1.AssignOperators.equals;
+        path = path.trim();
+        const variables = VelcronData.variables;
+        let isReturnValueSet = false;
+        let runEvaluation = true;
+        let runAssignment = true;
+        let directVariableAssignment = false;
+        let variableReassignmentFromPath = false;
+        let variableReassignmentFromValue = false;
+        let variableReassignmentFromValueIsFromVariable = false;
+        let pathSubLength = 0;
+        if (!path) {
+            return;
+        }
+        if (path === VelcronConstants_1.VelcronConstants.events.returnValueVariableName) {
+            isReturnValueSet = true;
+            path = value;
+        }
+        //Increment or decrement assignment
+        if (path.endsWith(models_1.AssignOperators.plusPlus) || path.endsWith(models_1.AssignOperators.minusMinus)) {
+            //increment or decrement after wont work since we dont operate on the real object
+            VelcronLogger_1.VelcronLogger.logActionError(`Only prefix increment/decrement operator is supported: ${path}`);
+            return;
+        }
+        else if (path.endsWith(models_1.AssignOperators.equalsPlus)) {
+            assignOperator = models_1.AssignOperators.equalsPlus;
+            path = path.substring(0, path.length - models_1.AssignOperators.equalsPlus.length);
+        }
+        else if (path.endsWith(models_1.AssignOperators.plusEquals)) {
+            assignOperator = models_1.AssignOperators.plusEquals;
+            path = path.substring(0, path.length - models_1.AssignOperators.plusEquals.length);
+        }
+        else if (path.endsWith(models_1.AssignOperators.equalsQuestion)) {
+            assignOperator = models_1.AssignOperators.equalsQuestion;
+            path = path.substring(0, path.length - models_1.AssignOperators.equalsQuestion.length);
+            runAssignment = false;
+        }
+        else if (path.startsWith(models_1.AssignOperators.plusPlus) || path.startsWith(models_1.AssignOperators.minusMinus)) {
+            assignOperator = path.substring(0, 2);
+            path = path.substring(2);
+        }
+        else if (path.endsWith(models_1.AssignOperators.equals)) {
+            assignOperator = models_1.AssignOperators.equals;
+            path = path.substring(0, path.length - models_1.AssignOperators.equals.length);
+        }
+        else if (path.endsWith(models_1.AssignOperators.equalsExclamation)) {
+            assignOperator = models_1.AssignOperators.equalsExclamation;
+            path = path.substring(0, path.length - models_1.AssignOperators.equalsExclamation.length);
+        }
+        path = path.trim();
+        //Support both var and let for local variables at the moment
+        if (path.startsWith("var ") || path.startsWith("let ")) {
+            pathSubLength = 4;
+            directVariableAssignment = true;
+        }
+        else if (renderContext.id &&
+            variables.hasOwnProperty(renderContext.id) &&
+            VelcronData.getOrSetObjectByPath(variables[renderContext.id], path) != undefined) {
+            variableReassignmentFromPath = true;
+            //value = VelcronData.getOrSetObjectByPath(variables[renderContext.id], value);
+        }
+        else if (renderContext.id &&
+            VelcronData.isString(value) &&
+            variables.hasOwnProperty(renderContext.id) &&
+            VelcronData.getOrSetObjectByPath(variables[renderContext.id], value) != undefined) {
+            variableReassignmentFromValue = true;
+            if (variables[renderContext.id] && variables[renderContext.id][path] != undefined) {
+                variableReassignmentFromValueIsFromVariable = true;
+            }
+        }
+        if (directVariableAssignment || variableReassignmentFromPath || variableReassignmentFromValue || isReturnValueSet) {
+            //Set result to temp variable
+            if (renderContext.id && !variables[renderContext.id]) {
+                variables[renderContext.id] = {};
+            }
+            if (VelcronData.isString(value) || value instanceof TextValue_1.TextValue) {
+                if (value instanceof TextValue_1.TextValue) {
+                    //If the text value is returned from an action
+                    //let text = 'Hello world' => return text
+                    //Then we create TextValue class so we know that it is a string
+                    //Action1 prints text from functions > Action2 returns text > Action 3 returns text
+                    //The support is in the DataBind to bind the text value from the TextValue class
+                }
+                else {
+                    let strValue = value.trim();
+                    //Direct string assignment remove the ' ' in the string
+                    if (strValue.startsWith("'") && strValue.endsWith(("'"))) {
+                        strValue = strValue.substring(1, strValue.length - 1);
+                        value = new TextValue_1.TextValue(VelcronData.dataBind(renderContext, strValue));
+                    }
+                    else if (renderContext.id && variableReassignmentFromValue) {
+                        //Get the variable from value = parameter value
+                        //@show(show): @data.loading = show
+                        //value = variables[renderContext.id][value];
+                        value = VelcronData.getOrSetObjectByPath(variables[renderContext.id], value);
+                    }
+                    else if (renderContext.id && variables[renderContext.id][path.substring(pathSubLength)]) {
+                        //Try to get from previously assigned variable
+                        value = variables[renderContext.id][path.substring(pathSubLength)];
+                    }
+                    else {
+                        //Try get value from rootContext or currentContext
+                        value = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                    }
+                }
+            }
+            if (renderContext?.parent?.id && isReturnValueSet) {
+                const toSet = {};
+                toSet[VelcronConstants_1.VelcronConstants.events.returnValueVariableName] = value;
+                VelcronData.setVariables(renderContext.parent.id, toSet);
+                //variables[renderContext.parent.id][VelcronConstants.events.returnValueVariableName] = value;
+            }
+            else if (renderContext.id && !variableReassignmentFromValue) {
+                variables[renderContext.id][path.substring(pathSubLength)] = value;
+            }
+            runEvaluation = false;
+            runAssignment = false;
+            if (variableReassignmentFromValue && !variableReassignmentFromValueIsFromVariable) {
+                //runAssignment = true;
+                runEvaluation = true;
+            }
+        }
+        const existingVal = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, path);
+        if (assignOperator === models_1.AssignOperators.equals || assignOperator === models_1.AssignOperators.equalsExclamation) {
+            //debugger;
+            if (typeof existingVal === "boolean" && typeof value !== "boolean") {
+                if (assignOperator === models_1.AssignOperators.equalsExclamation) {
+                    value = !existingVal;
+                }
+                const isBool = VelcronData.tryParseBoolean(value);
+                if (isBool.is) {
+                    value = isBool.value;
+                }
+                else {
+                    VelcronLogger_1.VelcronLogger.logDataError(`Error setting boolean value for property with path ${path} the source datatype is not a boolean`);
+                }
+            }
+            else if (typeof existingVal === "number" && typeof value !== "number") {
+                if (isNaN(value)) {
+                    VelcronLogger_1.VelcronLogger.logDataError(`The view model property ${path} is a number but the value tried to be set is a string. Its not allowed to change type of source property`);
+                }
+                value = parseInt(value);
+            }
+        }
+        if (runAssignment) {
+            if (VelcronData.isString(value) && value.startsWith("'") && value.endsWith("'")) {
+                //  Value is string assignment
+                // "$state.title = 'Hello'"
+                value = value.substring(1, value.length - 1);
+            }
+            else if (assignOperator && VelcronData.isString(value)) {
+                //Value is assignment from renderContext
+                // "$state.title = title" or "$state.title = $state.anotherTitle"
+                if (value === "this") {
+                    // $state.currentItem = this (this means currentContext)
+                    value = renderContext.currentContext;
+                }
+                else {
+                    if (value === "null") {
+                        //$state.currentItem = null;
+                        value = null;
+                    }
+                    else {
+                        //try get value from render context
+                        value = VelcronData.getOrSetObjectByPathUsingRenderContext(renderContext, value);
+                    }
+                }
+            }
+        }
+        if (runEvaluation) {
+            if (path.indexOf(VelcronConstants_1.VelcronConstants.state.stateRootToken) > -1) {
+                path = path.replace(VelcronConstants_1.VelcronConstants.state.stateRootToken, "rootCtx");
+            }
+            else {
+                path = path.replace(path, `currentCtx.${path}`);
+            }
+            if (renderContext.id &&
+                variables.hasOwnProperty(renderContext.id) &&
+                VelcronData.getOrSetObjectByPath(variables[renderContext.id], value) != undefined) {
+                value = VelcronData.getOrSetObjectByPath(variables[renderContext.id], value);
+            }
+            let template = path;
+            if (assignOperator === models_1.AssignOperators.plusPlus || assignOperator === models_1.AssignOperators.minusMinus) {
+                //++var or --var
+                template = assignOperator + path;
+            }
+            else if (assignOperator === models_1.AssignOperators.equalsPlus || assignOperator === models_1.AssignOperators.plusEquals) {
+                if (Array.isArray(existingVal)) {
+                    names.push("value");
+                    obj.push(value);
+                    const method = assignOperator === models_1.AssignOperators.equalsPlus ? "push" : "unshift";
+                    if (Array.isArray(value)) {
+                        template = `value.forEach((v)=>{ ${path}.${method}(v) })`;
+                    }
+                    else {
+                        template = `${path}.${method}(value)`;
+                    }
+                }
+            }
+            else if (assignOperator === models_1.AssignOperators.equalsQuestion) {
+                if (Array.isArray(existingVal)) {
+                    //fix this
+                    value = VelcronData.addCtxToVariableNames(value, ".");
+                    const pattern = /(?:^|\W)\.(\w+)(?!\w)/;
+                    const re = new RegExp(pattern, "g");
+                    let match;
+                    while ((match = re.exec(value)) != null) {
+                        if (match.index) {
+                            value = value.substring(0, (match.index)) + ` $$$obj${match[0].trim()}` + value.substring(match.index + match[0].length);
+                        }
+                    }
+                    template = `${template} = ${template}.filter($$$obj => ${value});`;
+                }
+            }
+            else {
+                //var = val
+                names.push("value");
+                obj.push(value);
+                template = `${path}=value`;
+            }
+            names.push("rootCtx");
+            names.push("currentCtx");
+            obj.push(renderContext.rootContext);
+            obj.push(renderContext.currentContext);
+            //TODO we shouls try catch and return info 
+            try {
+                const evalResult = Function(...names, "\"use strict\";" + template)(...obj);
+            }
+            catch (error) {
+                VelcronLogger_1.VelcronLogger.logDataError(`Error in VelcronData: ${error}`);
+            }
+        }
+    }
+    static evaluateArray(template, renderContext) {
+        let result = null;
+        const evalResult = VelcronData.evauluateJs(template, renderContext);
+        if (Array.isArray(evalResult)) {
+            result = evalResult;
+        }
+        else {
+            VelcronLogger_1.VelcronLogger.logDataError(`Cant evaluate ${template} to a Array`);
+        }
+        return result;
+    }
+    static evaluateBoolean(template, renderContext) {
+        if (VelcronData.isUndefined(template)) {
+            return false;
+        }
+        if (VelcronData.isBoolean(template)) {
+            return template;
+        }
+        const evalResult = VelcronData.evauluateJs(template, renderContext);
+        if (evalResult === null || VelcronData.isUndefined(evalResult)) {
+            return false;
+        }
+        const parseRes = this.tryParseBoolean(evalResult);
+        let result = null;
+        if (parseRes.is) {
+            result = parseRes.value;
+        }
+        else {
+            VelcronLogger_1.VelcronLogger.logDataError(`Cant evaluate ${template} to a boolean`);
+        }
+        return result;
+    }
+    static tryParseBoolean(bool) {
+        const result = {
+            is: false,
+            value: null
+        };
+        if (typeof bool === "boolean") {
+            result.value = bool;
+            result.is = true;
+        }
+        else if (typeof bool === "string") {
+            switch (bool.toLowerCase().trim()) {
+                case "true":
+                    result.value = true;
+                    result.is = true;
+                    break;
+                case "false":
+                case null:
+                    result.value = false;
+                    result.is = true;
+                    break;
+            }
+        }
+        return result;
+    }
+    static isString(text) {
+        return typeof text === "string" || text instanceof String;
+    }
+    static isBoolean(value) {
+        return typeof value === "boolean" ? true : false;
+    }
+    static isNumber(value) {
+        return !isNaN(value);
+    }
+    static isUndefined(value) {
+        return typeof value === "undefined";
+    }
+    static isArray(obj) {
+        return Array.isArray(obj);
+    }
+    static isObject(value) {
+        return typeof value === "object" &&
+            !Array.isArray(value) &&
+            value !== null;
+    }
+    static extendObject(obj) {
+        //Give objects some powerups
+        if (VelcronData.isUndefined(obj)) {
+            return obj;
+        }
+        if (VelcronData.isArray(obj)) {
+            //obj.take(5) => returns 5 items
+            obj.take = (amount) => {
+                return obj = obj.slice(0, amount);
+            };
+        }
+        return obj;
+    }
+    static getOrSetObjectByPath(object, path, value = undefined) {
+        if (typeof path !== "string") {
+            return null;
+        }
+        if (path === "") {
+            //If we pass $state = root we just return object
+            return object;
+        }
+        path = path.replace(/\[(\w+)\]/g, ".$1"); // convert indexes to properties
+        path = path.replace(/^\./, ""); // strip a leading dot
+        const a = path.split(".");
+        const lastParent = null;
+        for (let i = 0, n = a.length; i < n; ++i) {
+            const k = a[i];
+            if (object.hasOwnProperty(k)) {
+                //
+                if (typeof value !== "undefined" && (i + 1) == a.length) {
+                    if (Array.isArray(object[k]) && typeof value === "string" || value instanceof String) {
+                        //Support resetting Arrays
+                        if (value.trim() === "[]") {
+                            value = [];
+                        }
+                    }
+                    else if (typeof object[k] === "boolean") {
+                        const isBool = VelcronData.tryParseBoolean(value);
+                        if (isBool.is) {
+                            value = isBool.value;
+                        }
+                        else {
+                            VelcronLogger_1.VelcronLogger.logDataError(`Error setting boolean value for property with name ${k} the source datatype is not a boolean`);
+                        }
+                    }
+                    object[k] = VelcronData.extendObject(value);
+                }
+                object = VelcronData.extendObject(object[k]);
+            }
+            else {
+                //If the property does not exist we create it to make it reactive
+                //Todo this only works if the parent object exists already
+                //we should throw warning/exception
+                // if (value) {
+                //     Vue.set(object, k, value);
+                // }
+                return null;
+            }
+        }
+        return object;
+    }
+    static getOrSetObjectByPathUsingRenderContext(renderContext, path, value = undefined) {
+        let result;
+        if (VelcronData.isUndefined(path)) {
+            return result;
+        }
+        const variables = VelcronData.variables;
+        if (renderContext.id &&
+            variables.hasOwnProperty(renderContext.id) &&
+            variables[renderContext.id].hasOwnProperty(value)) {
+            result = variables[renderContext.id][value];
+        }
+        else if (renderContext.id &&
+            variables.hasOwnProperty(renderContext.id) &&
+            variables[renderContext.id].hasOwnProperty(path)) {
+            result = variables[renderContext.id][path];
+        }
+        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;
+            }
+            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;
+                }
+            }
+        }
+        return result;
+    }
+    static getTokens(template) {
+        const tokens = [];
+        if (template) {
+            template.replace(/(\${).+?(?=\})/g, (tokenWithVar, token) => {
+                tokens.push(tokenWithVar.substring(2));
+                return token;
+            });
+        }
+        return tokens;
+    }
+    static ensureEventId(event) {
+        return event.startsWith(VelcronConstants_1.VelcronConstants.events.idTokenStart) ?
+            event :
+            VelcronConstants_1.VelcronConstants.events.idTokenStart + VelcronData.generateId() + VelcronConstants_1.VelcronConstants.events.idTokenEnd + " " + event;
+    }
+    static ensureKeys(ui, generateNewKeys = false) {
+        if (!ui.key || generateNewKeys) {
+            ui.key = VelcronData.generateId();
+        }
+        if (ui.events) {
+            Object.keys(ui.events).forEach((key) => {
+                const evArr = ui.events ? ui.events[key] : [];
+                //Only the first item in the events array need id
+                if (evArr.length > 0 && !evArr[0].startsWith(VelcronConstants_1.VelcronConstants.events.idTokenStart)) {
+                    evArr[0] = VelcronData.ensureEventId(evArr[0]);
+                }
+            });
+        }
+        Object.keys(ui).forEach((key) => {
+            if (Array.isArray(ui[key])) {
+                ui[key].forEach((item) => {
+                    if (!item.key || generateNewKeys) {
+                        item.key = VelcronData.generateId();
+                    }
+                    VelcronData.ensureKeys(item, generateNewKeys);
+                });
+            }
+        });
+    }
+    static removeKeys(ui) {
+        if (ui.key) {
+            delete ui.key;
+        }
+        if (ui.events) {
+            Object.keys(ui.events).forEach((key) => {
+                const evArr = ui.events ? ui.events[key] : [];
+                if (evArr.length > 0 && evArr[0].startsWith(VelcronConstants_1.VelcronConstants.events.idTokenStart)) {
+                    evArr[0] = evArr[0].substring(VelcronConstants_1.VelcronConstants.events.idTokenStart.length + VelcronData.generateId().length + VelcronConstants_1.VelcronConstants.events.idTokenEnd.length).trim();
+                }
+            });
+        }
+        if (ui.actions) {
+            const appDef = ui;
+            if (appDef.actions) {
+                Object.keys(appDef.actions).forEach((key) => {
+                    const actionArr = appDef.actions ? appDef.actions[key] : [];
+                    if (actionArr.length > 0 && actionArr[0].startsWith(VelcronConstants_1.VelcronConstants.events.idTokenStart)) {
+                        actionArr[0] = actionArr[0].substring(VelcronConstants_1.VelcronConstants.events.idTokenStart.length + VelcronData.generateId().length + VelcronConstants_1.VelcronConstants.events.idTokenEnd.length).trim();
+                    }
+                });
+            }
+        }
+        Object.keys(ui).forEach((key) => {
+            if (Array.isArray(ui[key])) {
+                ui[key].forEach((item) => {
+                    if (item.key) {
+                        delete item.key;
+                    }
+                    VelcronData.removeKeys(item);
+                });
+            }
+        });
+    }
+    static generateId() {
+        const firstPart = (Math.random() * 46656) | 0;
+        const secondPart = (Math.random() * 46656) | 0;
+        return (("000" + firstPart.toString(36)).slice(-3) + ("000" + secondPart.toString(36)).slice(-3)).toString();
+    }
+    static createDeferredPromise() {
+        let resolve, reject;
+        const promise = new Promise((res, rej) => {
+            [resolve, reject] = [res, rej];
+        });
+        return { promise, reject, resolve };
+    }
+}
+exports.VelcronData = VelcronData;
+VelcronData.variables = {};

package/parser/VelcronLogger.d.ts

@@ -0,0 +1,6 @@
+export declare class VelcronLogger {
+    static logDataError(log: string): void;
+    static logActionError(log: string): void;
+    static logError(log: string): void;
+    static logCustomComponentError(log: string): void;
+}

package/parser/VelcronLogger.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronLogger = void 0;
+class VelcronLogger {
+    static logDataError(log) {
+        console.error(log);
+    }
+    static logActionError(log) {
+        console.error(log);
+    }
+    static logError(log) {
+        console.error(log);
+    }
+    static logCustomComponentError(log) {
+        console.error(log);
+    }
+}
+exports.VelcronLogger = VelcronLogger;