@omnia/velcron 8.0.322-dev → 8.0.323-dev

package/formatters/CapitalizeFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const capitalizeFormatter: InterpolationFormatter;

package/formatters/CapitalizeFormatter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFormatter = void 0;
+const parser_1 = require("../parser");
+exports.capitalizeFormatter = {
+    name: "capitalize",
+    format: (value) => {
+        if (typeof value === "string") {
+            return value.replace(/\b\w/g, (char) => char.toUpperCase());
+        }
+        return value;
+    }
+};
+parser_1.VelcronFormatters.registerFormatter(exports.capitalizeFormatter);

package/formatters/DateFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const dateFormatter: InterpolationFormatter;

package/formatters/DateFormatter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFormatter = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const parser_1 = require("../parser");
+exports.dateFormatter = {
+    name: "date",
+    format: (value, formatStr = "YYYY-MM-DD") => {
+        if (typeof value === "string" || value instanceof Date) {
+            const date = (0, dayjs_1.default)(value);
+            if (date.isValid()) {
+                return date.format(formatStr);
+            }
+        }
+        return value;
+    }
+};
+parser_1.VelcronFormatters.registerFormatter(exports.dateFormatter);

package/formatters/InterpolationFormatter.d.ts

@@ -0,0 +1,4 @@
+export interface InterpolationFormatter {
+    name: string;
+    format: (value: unknown, ...parameters: any) => string | number;
+}

package/formatters/InterpolationFormatter.js

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

package/formatters/JsonFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const jsonFormatter: InterpolationFormatter;

package/formatters/JsonFormatter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonFormatter = void 0;
+const parser_1 = require("../parser");
+exports.jsonFormatter = {
+    name: "json",
+    format: (value) => {
+        return JSON.stringify(value, null, 2);
+    },
+};
+parser_1.VelcronFormatters.registerFormatter(exports.jsonFormatter);

package/formatters/LengthFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const lengthFormatter: InterpolationFormatter;

package/formatters/LengthFormatter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lengthFormatter = void 0;
+const parser_1 = require("../parser");
+exports.lengthFormatter = {
+    name: "length",
+    format: (value) => {
+        if (typeof value === "string" || Array.isArray(value)) {
+            return value.length;
+        }
+        return 0;
+    },
+};
+parser_1.VelcronFormatters.registerFormatter(exports.lengthFormatter);

package/formatters/ReplaceFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const replaceFormatter: InterpolationFormatter;

package/formatters/ReplaceFormatter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceFormatter = void 0;
+const parser_1 = require("../parser");
+exports.replaceFormatter = {
+    name: "replace",
+    format: (value, search, replacement) => {
+        if (typeof value === "string") {
+            return value.split(search).join(replacement);
+        }
+        return value;
+    },
+};
+parser_1.VelcronFormatters.registerFormatter(exports.replaceFormatter);

package/formatters/SubStringFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const substringFormatter: InterpolationFormatter;

package/formatters/SubStringFormatter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substringFormatter = void 0;
+const parser_1 = require("../parser");
+exports.substringFormatter = {
+    name: "substring",
+    format: (value, start, end) => {
+        if (typeof value === "string") {
+            return value.substring(start, end);
+        }
+        return value;
+    },
+};
+parser_1.VelcronFormatters.registerFormatter(exports.substringFormatter);

package/formatters/TrimFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const trimFormatter: InterpolationFormatter;

package/formatters/TrimFormatter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimFormatter = void 0;
+const parser_1 = require("../parser");
+exports.trimFormatter = {
+    name: "trim",
+    format: (value, lengthStr = "100") => {
+        if (typeof value === "string") {
+            const maxLength = parseInt(lengthStr, 10);
+            if (isNaN(maxLength))
+                return value;
+            return value.length > maxLength ? value.substring(0, maxLength) + "..." : value;
+        }
+        return value;
+    }
+};
+parser_1.VelcronFormatters.registerFormatter(exports.trimFormatter);

package/formatters/UppercaseFormatter.d.ts

@@ -0,0 +1,2 @@
+import { InterpolationFormatter } from "./InterpolationFormatter";
+export declare const uppercaseFormatter: InterpolationFormatter;

package/formatters/UppercaseFormatter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uppercaseFormatter = void 0;
+const parser_1 = require("../parser");
+exports.uppercaseFormatter = {
+    name: "uppercase",
+    format: (value) => {
+        if (typeof value === "string") {
+            return value.toUpperCase();
+        }
+        return value;
+    }
+};
+parser_1.VelcronFormatters.registerFormatter(exports.uppercaseFormatter);

package/formatters/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./InterpolationFormatter";
+export * from "./DateFormatter";
+export * from "./CapitalizeFormatter";
+export * from "./UppercaseFormatter";
+export * from "./TrimFormatter";
+export * from "./JsonFormatter";
+export * from "./LengthFormatter";
+export * from "./ReplaceFormatter";
+export * from "./SubStringFormatter";

package/formatters/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./InterpolationFormatter"), exports);
+tslib_1.__exportStar(require("./DateFormatter"), exports);
+tslib_1.__exportStar(require("./CapitalizeFormatter"), exports);
+tslib_1.__exportStar(require("./UppercaseFormatter"), exports);
+tslib_1.__exportStar(require("./TrimFormatter"), exports);
+tslib_1.__exportStar(require("./JsonFormatter"), exports);
+tslib_1.__exportStar(require("./LengthFormatter"), exports);
+tslib_1.__exportStar(require("./ReplaceFormatter"), exports);
+tslib_1.__exportStar(require("./SubStringFormatter"), exports);

package/index.d.ts

@@ -7,3 +7,4 @@ export * from "./rules";
 export * from "./templatebuilder";
 export * from "./events";
 export * from "./providers";
+export * from "./formatters";

package/index.js

@@ -10,3 +10,4 @@ tslib_1.__exportStar(require("./rules"), exports);
 tslib_1.__exportStar(require("./templatebuilder"), exports);
 tslib_1.__exportStar(require("./events"), exports);
 tslib_1.__exportStar(require("./providers"), exports);
+tslib_1.__exportStar(require("./formatters"), exports);

package/package.json

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

package/parser/VelcronDataBinder.d.ts

@@ -1,12 +1,62 @@
 import { VelcronRenderContext } from "../models";
 import { VelcronBindableProp } from "..";
 export declare class VelcronDataBinder {
+    /**
+     * Binds a value based on the provided binding expression.
+     * @param renderContext The render context containing state and other data.
+     * @param bindTo The binding expression or value.
+     * @returns The bound value after applying formatters and other logic.
+     */
     static bind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T;
+    /**
+     * Interpolates tokens within a binding string and applies formatters.
+     * @param bindTo The binding string containing tokens.
+     * @param renderContext The render context.
+     * @returns The interpolated string with formatters applied.
+     */
     private static interpolateTokens;
+    /**
+     * Parses an interpolation string to extract the variable and its formatters.
+     * @param match The interpolation string, e.g., "{{ variable | formatter1:'arg1','arg2' | formatter2 }}"
+     * @returns An Interpolation object or null if parsing fails.
+     */
+    private static parseInterpolation;
+    /**
+     * Processes a token that might represent an action or a state variable.
+     * @param tokenWithoutBrackets The token string without the surrounding {{ }}.
+     * @param renderContext The render context.
+     * @returns The result of processing the token.
+     */
     private static processToken;
+    /**
+     * Evaluates a switch expression based on the render context.
+     * @param expression The switch expression object.
+     * @param renderContext The render context.
+     * @returns The result of the switch expression.
+     */
     private static evaluateSwitchExpression;
+    /**
+     * Recursively evaluates an expression which can be a string, object, or other types.
+     * @param expr The expression to evaluate.
+     * @param renderContext The render context.
+     * @returns The evaluated result.
+     */
     private static evaluateExpression;
+    /**
+     * Attempts to update a bound value in the render context.
+     * @param renderContext The render context.
+     * @param bindPath The binding path string.
+     * @param value The new value to set.
+     */
     static tryUpdateBoundValue(renderContext: VelcronRenderContext, bindPath: string, value: unknown): void;
+    /**
+     * Binds multiple properties at once based on the provided definitions.
+     * @param renderContext The render context.
+     * @param definition The binding definitions for each property.
+     * @param propertiesToBind The list of property keys to bind.
+     * @param objectToBindTo The target object where properties will be bound.
+     * @returns The object with bound properties.
+     */
     static bindMany<T>(renderContext: VelcronRenderContext, definition: {
         [P in keyof T]?: VelcronBindableProp<T[P]>;
     }, propertiesToBind: Array<keyof T>, objectToBindTo: Partial<T>): T;

package/parser/VelcronDataBinder.js

@@ -8,6 +8,12 @@ const __1 = require("..");
 // Precompiled regular expression for token replacement
 const TOKEN_REGEX = /\s*{{\s*|\s*}}\s*/g;
 class VelcronDataBinder {
+    /**
+     * Binds a value based on the provided binding expression.
+     * @param renderContext The render context containing state and other data.
+     * @param bindTo The binding expression or value.
+     * @returns The bound value after applying formatters and other logic.
+     */
     static bind(renderContext, bindTo) {
         if (typeof bindTo === "object" && bindTo !== null) {
             // Check if it's a switch expression
@@ -40,27 +46,104 @@ class VelcronDataBinder {
         // Computed String interpolation > {{@getName}}
         return VelcronDataBinder.interpolateTokens(bindTo, renderContext);
     }
+    /**
+     * Interpolates tokens within a binding string and applies formatters.
+     * @param bindTo The binding string containing tokens.
+     * @param renderContext The render context.
+     * @returns The interpolated string with formatters applied.
+     */
     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;
+        // Regex to match all interpolations like {{ variable | formatter1:'arg1','arg2' | formatter2 }}
+        const interpolationRegex = /{{\s*[^{}]*?}}/g;
+        return bindTo.replace(interpolationRegex, (match) => {
+            const interpolation = this.parseInterpolation(match);
+            if (!interpolation) {
+                console.warn(`Failed to parse interpolation: ${match}`);
+                return match; // Return as-is if parsing fails
+            }
+            let value = VelcronData_1.VelcronData.getOrSet(renderContext, interpolation.variable);
+            if (value === undefined || value === null) {
+                console.warn(`Variable "${interpolation.variable}" is not defined in the context.`);
+                return "";
+            }
+            console.log(`Initial value for "${interpolation.variable}":`, value);
+            for (const formatter of interpolation.formatters) {
+                const formatterObj = __1.VelcronFormatters.getFormatter(formatter.name);
+                if (!formatterObj) {
+                    console.warn(`Formatter "${formatter.name}" is not registered.`);
+                    continue; // Skip unknown formatter
+                }
+                try {
+                    value = formatterObj.format(value, ...formatter.args);
+                    console.log(`After formatter "${formatter.name}":`, value);
+                }
+                catch (error) {
+                    console.error(`Error applying formatter "${formatter.name}" to variable "${interpolation.variable}":`, error);
+                    value = ""; // Fallback to empty string on error
+                    break; // Optionally stop applying further formatters
+                }
+            }
+            if (value instanceof TextValue_1.TextValue) {
+                value = value.value;
             }
-            result += data;
-            lastIndex = tokenIndex + token.length;
+            return value !== undefined && value !== null ? String(value) : "";
         });
-        result += bindTo.substring(lastIndex);
-        return result;
     }
+    /**
+     * Parses an interpolation string to extract the variable and its formatters.
+     * @param match The interpolation string, e.g., "{{ variable | formatter1:'arg1','arg2' | formatter2 }}"
+     * @returns An Interpolation object or null if parsing fails.
+     */
+    static parseInterpolation(match) {
+        // Adjusted regex to handle variable names with special characters and spaces
+        const interpolationRegex = /^{{\s*([^|}]+?)\s*(\|.*)?}}$/;
+        const formatterRegex = /\|\s*(\w+)(?:\s*:\s*([^|]+))?/g;
+        const mainMatch = interpolationRegex.exec(match);
+        if (!mainMatch)
+            return null;
+        const variable = mainMatch[1].trim();
+        const formattersPart = mainMatch[2] || "";
+        const formatters = [];
+        let formatterMatch;
+        while ((formatterMatch = formatterRegex.exec(formattersPart)) !== null) {
+            const name = formatterMatch[1];
+            const rawArgs = formatterMatch[2] || "";
+            const args = [];
+            if (rawArgs) {
+                // Split arguments by comma and trim spaces
+                const argStrings = rawArgs.split(",").map(arg => arg.trim());
+                for (const argStr of argStrings) {
+                    // Detect and convert argument types
+                    let argValue;
+                    if (/^'(.*)'$/.test(argStr)) {
+                        // String argument enclosed in single quotes
+                        argValue = argStr.slice(1, -1);
+                    }
+                    else if (/^\d+(\.\d+)?$/.test(argStr)) {
+                        // Numeric argument
+                        argValue = parseFloat(argStr);
+                    }
+                    else if (/^(true|false)$/i.test(argStr)) {
+                        // Boolean argument
+                        argValue = argStr.toLowerCase() === "true";
+                    }
+                    else {
+                        // Treat as string (unquoted)
+                        argValue = argStr;
+                    }
+                    args.push(argValue);
+                }
+            }
+            formatters.push({ name, args });
+        }
+        return { variable, formatters };
+    }
+    /**
+     * Processes a token that might represent an action or a state variable.
+     * @param tokenWithoutBrackets The token string without the surrounding {{ }}.
+     * @param renderContext The render context.
+     * @returns The result of processing the token.
+     */
     static processToken(tokenWithoutBrackets, renderContext) {
         if (__1.VelcronActions.valueIsAction(tokenWithoutBrackets)) {
             let result;
@@ -94,6 +177,12 @@ class VelcronDataBinder {
             return VelcronData_1.VelcronData.getOrSet(renderContext, tokenWithoutBrackets);
         }
     }
+    /**
+     * Evaluates a switch expression based on the render context.
+     * @param expression The switch expression object.
+     * @param renderContext The render context.
+     * @returns The result of the switch expression.
+     */
     static evaluateSwitchExpression(expression, renderContext) {
         // Evaluate the switch expression
         const switchValue = VelcronDataBinder.evaluateExpression(expression.switch, renderContext);
@@ -104,7 +193,7 @@ class VelcronDataBinder {
             const caseValue = expression.cases[switchValueStr];
             if (typeof caseValue === "string") {
                 // If caseValue is a string, interpolate tokens
-                return VelcronDataBinder.evaluateExpression(this.interpolateTokens(caseValue, renderContext), renderContext);
+                return VelcronDataBinder.interpolateTokens(caseValue, renderContext);
             }
             else {
                 // If caseValue is an object, evaluate it directly
@@ -115,7 +204,7 @@ class VelcronDataBinder {
             const defaultValue = expression.default;
             if (typeof defaultValue === "string") {
                 // If defaultValue is a string, interpolate tokens
-                return VelcronDataBinder.evaluateExpression(this.interpolateTokens(defaultValue, renderContext), renderContext);
+                return VelcronDataBinder.interpolateTokens(defaultValue, renderContext);
             }
             else {
                 // If defaultValue is an object, evaluate it directly
@@ -126,11 +215,17 @@ class VelcronDataBinder {
             return undefined;
         }
     }
+    /**
+     * Recursively evaluates an expression which can be a string, object, or other types.
+     * @param expr The expression to evaluate.
+     * @param renderContext The render context.
+     * @returns The evaluated result.
+     */
     static evaluateExpression(expr, renderContext) {
         if (typeof expr === "string") {
             return VelcronDataBinder.bind(renderContext, expr);
         }
-        else if (typeof expr === "object") {
+        else if (typeof expr === "object" && expr !== null) {
             // If expr is another switch expression
             if ("switch" in expr) {
                 return VelcronDataBinder.evaluateSwitchExpression(expr, renderContext);
@@ -151,11 +246,25 @@ class VelcronDataBinder {
             return expr;
         }
     }
+    /**
+     * Attempts to update a bound value in the render context.
+     * @param renderContext The render context.
+     * @param bindPath The binding path string.
+     * @param value The new value to set.
+     */
     static tryUpdateBoundValue(renderContext, bindPath, value) {
         if (VelcronData_1.VelcronData.isBindable(bindPath)) {
             VelcronData_1.VelcronData.getOrSet(renderContext, VelcronData_1.VelcronData.getBindPath(bindPath), value);
         }
     }
+    /**
+     * Binds multiple properties at once based on the provided definitions.
+     * @param renderContext The render context.
+     * @param definition The binding definitions for each property.
+     * @param propertiesToBind The list of property keys to bind.
+     * @param objectToBindTo The target object where properties will be bound.
+     * @returns The object with bound properties.
+     */
     static bindMany(renderContext, definition, propertiesToBind, objectToBindTo) {
         propertiesToBind.forEach((property) => {
             const definitionValue = definition[property];
@@ -167,4 +276,5 @@ class VelcronDataBinder {
     }
 }
 exports.VelcronDataBinder = VelcronDataBinder;
+// Ensure the internal binding method uses the updated binder
 VelcronData_1.VelcronData.bindInternal = VelcronDataBinder.bind;

package/parser/VelcronFormatters.d.ts

@@ -0,0 +1,6 @@
+import { InterpolationFormatter } from "../formatters";
+export declare class VelcronFormatters {
+    static _formatters: Record<string, InterpolationFormatter>;
+    static registerFormatter(formatter: InterpolationFormatter): void;
+    static getFormatter(name: string): InterpolationFormatter | undefined;
+}

package/parser/VelcronFormatters.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VelcronFormatters = void 0;
+const VelcronLogger_1 = require("./VelcronLogger");
+class VelcronFormatters {
+    static { this._formatters = {}; }
+    static registerFormatter(formatter) {
+        const name = formatter.name.toLowerCase();
+        if (this._formatters && this._formatters[name]) {
+            VelcronLogger_1.VelcronLogger.logActionError(`The action handler with name ${name} is already registered`);
+        }
+        else if (this._formatters) {
+            this._formatters[name] = formatter;
+        }
+    }
+    static getFormatter(name) {
+        return this._formatters[name.toLowerCase()];
+    }
+}
+exports.VelcronFormatters = VelcronFormatters;

package/parser/index.d.ts

@@ -7,3 +7,4 @@ export * from "./VelcronRenderers";
 export * from "./TextValue";
 export * from "./VelcronPropertyEditors";
 export * from "./VelcronDataBinder";
+export * from "./VelcronFormatters";

package/parser/index.js

@@ -10,3 +10,4 @@ tslib_1.__exportStar(require("./VelcronRenderers"), exports);
 tslib_1.__exportStar(require("./TextValue"), exports);
 tslib_1.__exportStar(require("./VelcronPropertyEditors"), exports);
 tslib_1.__exportStar(require("./VelcronDataBinder"), exports);
+tslib_1.__exportStar(require("./VelcronFormatters"), exports);