@omnia/velcron 8.0.293-dev → 8.0.295-dev

package/parser/VelcronData.js

@@ -6,38 +6,49 @@ const VelcronConstants_1 = require("./VelcronConstants");
 const VelcronLogger_1 = require("./VelcronLogger");
 const TextValue_1 = require("./TextValue");
 class VelcronData {
-    static dataBind(renderContext, bindTo) {
-        if (!VelcronData.isString(bindTo)) {
-            return bindTo;
-        }
-        //Bound to one state property and supports 2 way data binding > $bind: $state.title
-        if (bindTo.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken)) {
-            bindTo = bindTo.substring(VelcronConstants_1.VelcronConstants.state.bindToken.length).trim();
-            return VelcronData.getOrSet(renderContext, bindTo);
-        }
-        //Built-in context tokens
-        if (bindTo === VelcronConstants_1.VelcronConstants.context.editModeToken) {
+    static { this.bindInternal = null; }
+    // static dataBind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T {
+    //     if (!VelcronData.isString(bindTo)) {
+    //         return bindTo;
+    //     }
+    //     //Bound to one state property and supports 2 way data binding > $bind: $state.title
+    //     if (bindTo.startsWith(VelcronConstants.state.bindToken)) {
+    //         bindTo = bindTo.substring(VelcronConstants.state.bindToken.length).trim();
+    //         return VelcronData.getOrSet(renderContext, bindTo);
+    //     }
+    //     //Built-in context tokens
+    //     const contextValue = VelcronData.getContextTokenValue<T>(renderContext, bindTo);
+    //     if (contextValue !== undefined) {
+    //         return contextValue;
+    //     }
+    //     //String interpolation > {{ $state.title }} and {{ $state.description }}
+    //     const tokens = this.getTokens(bindTo, false);
+    //     tokens.forEach((token) => {
+    //         let data = this.getOrSet<any>(renderContext, token.replace(/\s*{{\s*|\s*}}\s*/g, ""));
+    //         if (data instanceof TextValue) {
+    //             data = (data as TextValue).value;
+    //         }
+    //         bindTo = bindTo.replace(token, data);
+    //     });
+    //     return bindTo as T;
+    // }
+    static getContextTokenValue(renderContext, token) {
+        const { editModeToken, displayToken, activeToken, thisToken } = VelcronConstants_1.VelcronConstants.context;
+        if (token === editModeToken || token.startsWith(`${editModeToken}.`)) {
             return renderContext.$editmode;
         }
-        else if (bindTo === VelcronConstants_1.VelcronConstants.context.displayToken) {
+        else if (token === displayToken || token.startsWith(`${displayToken}.`)) {
             return renderContext.$display;
         }
-        else if (bindTo === VelcronConstants_1.VelcronConstants.context.activeToken) {
+        else if (token === activeToken || token.startsWith(`${activeToken}.`)) {
             return renderContext.$active;
         }
-        else if (bindTo === VelcronConstants_1.VelcronConstants.context.thisToken) {
+        else if (token === thisToken || token.startsWith(`${thisToken}.`)) {
             return renderContext.currentContext;
         }
-        //String interpolation > {{ $state.title }} and {{ $state.description }}
-        const tokens = this.getTokens(bindTo, 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;
-            }
-            bindTo = bindTo.replace(token, data);
-        });
-        return bindTo;
+        else {
+            return undefined;
+        }
     }
     static isBindable(bindable) {
         if (!VelcronData.isString(bindable)) {
@@ -53,49 +64,138 @@ class VelcronData {
         return text;
     }
     static addCtxToVariableNames(template, skipIfNameStartsWith, skipIfNameMatches, overridePrefixWhenNameMatches) {
-        const re = new RegExp(/[^0-9a-z-.'$]/, "gi");
+        let isInsideString = false;
+        let isEscapeChar = false;
         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 });
+        let variableName = "";
+        let variableStartIndex = -1;
+        const appendedLength = 0;
+        for (let i = 0; i < template.length; i++) {
+            const c = template.charAt(i);
+            if (isEscapeChar) {
+                isEscapeChar = false;
+                continue;
+            }
+            if (c === "\\") {
+                isEscapeChar = true;
+                continue;
+            }
+            if (c === "'") {
+                isInsideString = !isInsideString;
+                continue;
+            }
+            if (isInsideString) {
+                continue;
+            }
+            // If c is a valid variable name character
+            if (/[0-9a-z-.'$]/i.test(c)) {
+                if (variableName.length === 0) {
+                    variableStartIndex = i;
+                }
+                variableName += c;
             }
+            else {
+                // Non-variable character
+                if (variableName.length > 0) {
+                    // Process the variableName
+                    results.push({ text: variableName, index: variableStartIndex });
+                    variableName = "";
+                    variableStartIndex = -1;
+                }
+            }
+        }
+        // Process any remaining variableName
+        if (variableName.length > 0) {
+            results.push({ text: variableName, index: variableStartIndex });
         }
-        results.push({ text: template.substring(lastIndex), index: lastIndex });
-        let appendedLenght = 0;
+        // Now process the results
+        let adjustedTemplate = template;
+        let offset = 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) { }
+            const text = variableMatch.text;
+            const index = variableMatch.index + offset;
+            // Variable name can't start with a number and should not be empty
+            if (isNaN(parseInt(text.charAt(0), 10)) &&
+                text.length > 0) {
+                if ((skipIfNameStartsWith && text.startsWith(skipIfNameStartsWith)) ||
+                    (skipIfNameMatches && skipIfNameMatches.includes(text))) {
+                    // Skip variable names that match the conditions
+                }
                 else {
-                    let subName = variableMatch.text;
+                    let subName = 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];
+                    let prefix = text.startsWith(VelcronConstants_1.VelcronConstants.state.stateRootToken)
+                        ? "rootCtx "
+                        : "currentCtx";
+                    if (overridePrefixWhenNameMatches &&
+                        overridePrefixWhenNameMatches[text]) {
+                        prefix = overridePrefixWhenNameMatches[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("."));
+                    else if (overridePrefixWhenNameMatches &&
+                        text.indexOf(".") > -1) {
+                        const toMatch = text.substring(0, text.indexOf("."));
                         if (overridePrefixWhenNameMatches[toMatch]) {
                             prefix = overridePrefixWhenNameMatches[toMatch];
-                            subName = variableMatch.text.substring(toMatch.length + 1);
+                            subName = 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;
+                    adjustedTemplate =
+                        adjustedTemplate.substring(0, index) +
+                            newName +
+                            adjustedTemplate.substring(index + text.length);
+                    offset += newName.length - text.length;
                 }
             }
         });
-        return template;
+        return adjustedTemplate;
     }
+    // static addCtxToVariableNames(template: string, skipIfNameStartsWith?: string, skipIfNameMatches?: Array<string>, overridePrefixWhenNameMatches?: { [name: string]: string }): string {
+    //     const re = new RegExp(/[^0-9a-z-.'$]/, "gi");
+    //     const results: Array<{ text: string, index: number }> = [];
+    //     let match: RegExpExecArray | null;
+    //     let lastIndex: number;
+    //     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) as any as number) && (!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.state.stateRootToken)) {
+    //                     subName = subName.substring(VelcronConstants.state.stateRootToken.length + 1);
+    //                 }
+    //                 let prefix = variableMatch.text.startsWith(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 = [];
@@ -134,8 +234,10 @@ class VelcronData {
         obj.push(renderContext.rootContext);
         obj.push(renderContext.currentContext);
         obj.push(renderContext);
-        //TODO we shouls try catch and return info 
+        //TODO we shouls try catch and return info
         const evalResult = Function(...names, "\"use strict\";return " + template)(...obj);
+        // console.dir("Eval result");
+        // console.dir(evalResult);
         return evalResult;
     }
     static { this.variables = {}; }
@@ -252,7 +354,7 @@ class VelcronData {
                     //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));
+                        value = new TextValue_1.TextValue(VelcronData.bindInternal(renderContext, strValue));
                     }
                     else if (renderContext.id && variableReassignmentFromValue) {
                         //Get the variable from value = parameter value
@@ -595,7 +697,7 @@ class VelcronData {
             const propObj = VelcronData.getOrSetObjectByPath(renderContext.properties, path);
             if (VelcronData.isString(propObj)) {
                 const propString = propObj;
-                path = VelcronData.dataBind(renderContext, propString);
+                path = VelcronData.bindInternal(renderContext, propString);
                 result = path;
             }
             result = propObj;
@@ -605,25 +707,32 @@ class VelcronData {
             result = renderContext.currentContext;
         }
         else {
+            const contextValue = VelcronData.getContextTokenValue(renderContext, path);
             const tokens = VelcronData.getTokens(path, true);
             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
+                // Fetch from the data object
                 object = renderContext.rootContext;
-                path = path.substring(6);
+                path = path.substring(VelcronConstants_1.VelcronConstants.state.stateRootToken.length + 1);
+            }
+            else if (contextValue !== undefined) {
+                object = contextValue;
+                if (path.indexOf(".") > -1) {
+                    path = path.substring(path.indexOf(".") + 1);
+                }
             }
             else {
-                //Fetch from current ctx
+                // Fetch from current context
                 object = renderContext.currentContext;
             }
             if (VelcronData.isObject(object) && 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
+                // For example, if you bind to an array of ["string"], the currentContext is only a string, so we just return the object without mapping path
                 result = object;
             }
         }

package/parser/VelcronDataBinder.d.ts

@@ -0,0 +1,13 @@
+import { VelcronRenderContext } from "../models";
+import { VelcronBindableProp } from "..";
+export declare class VelcronDataBinder {
+    static bind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T;
+    private static interpolateTokens;
+    private static processToken;
+    private static evaluateSwitchExpression;
+    private static evaluateExpression;
+    static tryUpdateBoundValue(renderContext: VelcronRenderContext, bindPath: string, value: unknown): void;
+    static bindMany<T>(renderContext: VelcronRenderContext, definition: {
+        [P in keyof T]?: VelcronBindableProp<T[P]>;
+    }, propertiesToBind: Array<keyof T>, state: Partial<T>): void;
+}

package/parser/VelcronDataBinder.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronDataBinder = void 0;
+const TextValue_1 = require("./TextValue");
+const VelcronConstants_1 = require("./VelcronConstants");
+const VelcronData_1 = require("./VelcronData");
+const __1 = require("..");
+// Precompiled regular expression for token replacement
+const TOKEN_REGEX = /\s*{{\s*|\s*}}\s*/g;
+class VelcronDataBinder {
+    static bind(renderContext, bindTo) {
+        if (typeof bindTo === "object" && bindTo !== null) {
+            // Check if it's a switch expression
+            if ("switch" in bindTo) {
+                return this.evaluateSwitchExpression(bindTo, renderContext);
+            }
+            // Handle other object types if necessary
+            return bindTo;
+        }
+        if (!VelcronData_1.VelcronData.isString(bindTo)) {
+            return bindTo;
+        }
+        // Bound to one state property and supports 2 way data binding > $bind: $state.title
+        if (bindTo.startsWith(VelcronConstants_1.VelcronConstants.state.bindToken)) {
+            const trimmedBindTo = bindTo.substring(VelcronConstants_1.VelcronConstants.state.bindToken.length).trim();
+            return VelcronData_1.VelcronData.getOrSet(renderContext, trimmedBindTo);
+        }
+        // Process bindTo if it is an action
+        if (__1.VelcronActions.valueIsAction(bindTo)) {
+            return this.processToken(bindTo, renderContext);
+        }
+        // Built-in context tokens
+        const contextValue = VelcronData_1.VelcronData.getContextTokenValue(renderContext, bindTo);
+        if (contextValue !== undefined) {
+            return bindTo.includes(".")
+                ? VelcronData_1.VelcronData.getOrSetObjectByPath(contextValue, bindTo.substring(bindTo.indexOf(".") + 1))
+                : contextValue;
+        }
+        // String interpolation > {{ $state.title }} and {{ $state.description }}
+        // Computed String interpolation > {{@getName}}
+        return this.interpolateTokens(bindTo, renderContext);
+    }
+    static interpolateTokens(bindTo, renderContext) {
+        const tokens = VelcronData_1.VelcronData.getTokens(bindTo, false);
+        if (tokens.length === 0) {
+            return bindTo;
+        }
+        let result = "";
+        let lastIndex = 0;
+        tokens.forEach((token) => {
+            const tokenIndex = bindTo.indexOf(token, lastIndex);
+            result += bindTo.substring(lastIndex, tokenIndex);
+            const tokenWithoutBrackets = token.replace(TOKEN_REGEX, "");
+            let data = this.processToken(tokenWithoutBrackets, renderContext);
+            if (data instanceof TextValue_1.TextValue) {
+                data = data.value;
+            }
+            result += data;
+            lastIndex = tokenIndex + token.length;
+        });
+        result += bindTo.substring(lastIndex);
+        return result;
+    }
+    static processToken(tokenWithoutBrackets, renderContext) {
+        if (__1.VelcronActions.valueIsAction(tokenWithoutBrackets)) {
+            let result;
+            const paramValues = [];
+            const template = tokenWithoutBrackets.includes("(")
+                ? tokenWithoutBrackets.substring(0, tokenWithoutBrackets.indexOf("("))
+                : tokenWithoutBrackets;
+            __1.VelcronActions.parseFunction(renderContext.computed, template, renderContext, paramValues, (acName, params) => {
+                const funcContent = renderContext.computed[acName];
+                // Prepare params for evaluation
+                Object.keys(params).forEach((key) => {
+                    params[key] = "currentCtx";
+                });
+                // Check if funcContent is an array
+                if (Array.isArray(funcContent)) {
+                    const c = funcContent[0];
+                    result = VelcronData_1.VelcronData.evauluateJs(c, renderContext, params);
+                }
+                // Check if funcContent is a switch expression
+                else if (funcContent && typeof funcContent === "object" && "switch" in funcContent) {
+                    result = VelcronDataBinder.evaluateSwitchExpression(funcContent, renderContext);
+                }
+                // Handle other possible function types if necessary
+                else {
+                    result = undefined;
+                }
+            });
+            return result;
+        }
+        else {
+            return VelcronData_1.VelcronData.getOrSet(renderContext, tokenWithoutBrackets);
+        }
+    }
+    static evaluateSwitchExpression(expression, renderContext) {
+        // Evaluate the switch expression
+        const switchValue = VelcronDataBinder.evaluateExpression(expression.switch, renderContext);
+        // Convert switchValue to string to match case keys
+        const switchValueStr = String(switchValue);
+        // Check if the case matches
+        if (switchValueStr in expression.cases) {
+            const caseValue = expression.cases[switchValueStr];
+            return VelcronDataBinder.evaluateExpression(this.interpolateTokens(caseValue, renderContext), renderContext);
+        }
+        else if ("default" in expression) {
+            return VelcronDataBinder.evaluateExpression(this.interpolateTokens(expression.default, renderContext), renderContext);
+        }
+        else {
+            return undefined;
+        }
+    }
+    static evaluateExpression(expr, renderContext) {
+        if (typeof expr === "string") {
+            return VelcronDataBinder.bind(renderContext, expr);
+        }
+        else if (typeof expr === "object") {
+            // If expr is another switch expression
+            if ("switch" in expr) {
+                return VelcronDataBinder.evaluateSwitchExpression(expr, renderContext);
+            }
+            else {
+                // If the expression is an object, evaluate its values if they are bindings
+                const evaluatedObject = {};
+                for (const key in expr) {
+                    if (expr.hasOwnProperty(key)) {
+                        evaluatedObject[key] = VelcronDataBinder.evaluateExpression(expr[key], renderContext);
+                    }
+                }
+                return evaluatedObject;
+            }
+        }
+        else {
+            // Return the value as-is (number, boolean, etc.)
+            return expr;
+        }
+    }
+    static tryUpdateBoundValue(renderContext, bindPath, value) {
+        if (VelcronData_1.VelcronData.isBindable(bindPath)) {
+            VelcronData_1.VelcronData.getOrSet(renderContext, VelcronData_1.VelcronData.getBindPath(bindPath), value);
+        }
+    }
+    static bindMany(renderContext, definition, propertiesToBind, state) {
+        propertiesToBind.forEach((property) => {
+            const definitionValue = definition[property];
+            if (definitionValue !== undefined) {
+                state[property] = VelcronDataBinder.bind(renderContext, definitionValue);
+            }
+        });
+    }
+}
+exports.VelcronDataBinder = VelcronDataBinder;
+VelcronData_1.VelcronData.bindInternal = VelcronDataBinder.bind;

package/parser/VelcronRenderers.js

@@ -99,7 +99,7 @@ class VelcronRenderers {
             subApp: currentRenderCtx.subApp
         };
         if (VelcronRenderers.definitionContainsCustomColorSchema(definition)) {
-            const colorSchemaType = __1.VelcronData.dataBind(currentRenderCtx, definition.colorSchemaType);
+            const colorSchemaType = __1.VelcronDataBinder.bind(currentRenderCtx, definition.colorSchemaType);
             if (colorSchemaType && colorSchemaType !== "" && result.colors.state.colorSchemaType !== colorSchemaType) {
                 const colorSchemaStore = (0, __1.useVelcronColorSchemaStore)(definition.key.toString());
                 colorSchemaStore.actions.setThemeStore(currentRenderCtx.theming, colorSchemaType);

package/parser/VelcronStyles.d.ts

@@ -23,7 +23,7 @@ export declare class VelcronStyles {
     static registerEffectsProvider(fn: (effects: VelcronEffects, renderCtx: VelcronRenderContext) => VelcronEffects): void;
     static applyEffects(definition: VelcronDefinitionHasEffects, renderCtx: VelcronRenderContext, applyTo: (effects: VelcronEffects) => any): any;
     static insertBackgroundColor(styleBase: any, color: VelcronColorStyling, renderCtx: VelcronRenderContext): void;
-    static insertBorderRadiusStyles(styleBase: any, settings: VelcronDimensions): void;
+    static insertBorderRadiusStyles(styleBase: any, settings: VelcronDimensions, renderCtx: VelcronRenderContext): void;
     static insertBorderStyles(styleBase: any, borderSettings: VelcronBorder, renderCtx: VelcronRenderContext): void;
     static create(definition: VelcronDefinition, renderCtx: VelcronRenderContext): object | string;
     static applySpacingDimension(value: string | number, spacing: SpacingBlueprint): string | number;