@fincity/kirun-js 3.2.2 → 3.4.0

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -747,11 +747,9 @@ export class ExpressionEvaluator {
         if (key.length > 2 && valuesMap.has(key))
             workingStack.push(new ExpressionTokenValue(str, this.getValue(str, valuesMap)));
         else {
-            let v: any;
-            try {
-                v = LiteralTokenValueExtractor.INSTANCE.getValue(str);
-            } catch (err) {
-                // Check if this is a literal (number, string, boolean, null) with property access
+            let v: any = LiteralTokenValueExtractor.INSTANCE.tryGetValue(str);
+            if (LiteralTokenValueExtractor.isFailed(v)) {
+                // Not a valid literal — check if it's a literal with property access
                 // e.g., "2.val" should evaluate to undefined (accessing .val on number 2)
                 v = this.evaluateLiteralPropertyAccess(str);
             }
@@ -774,11 +772,9 @@ export class ExpressionEvaluator {
         const basePart = str.substring(0, dotIdx);
         const propPart = str.substring(dotIdx + 1);
         
-        // Try to parse the base as a literal
-        let baseValue: any;
-        try {
-            baseValue = LiteralTokenValueExtractor.INSTANCE.getValue(basePart);
-        } catch (err) {
+        // Try to parse the base as a literal without throwing
+        const baseValue: any = LiteralTokenValueExtractor.INSTANCE.tryGetValue(basePart);
+        if (LiteralTokenValueExtractor.isFailed(baseValue)) {
             // Not a valid literal, return the original string
             return str;
         }

package/src/engine/runtime/expression/exception/ExpressionEvaluationException.ts

@@ -1,14 +1,25 @@
-import { StringFormatter } from '../../../util/string/StringFormatter';
-
 export class ExpressionEvaluationException extends Error {
     cause?: Error;
+    private readonly _expression: string;
+    private readonly _msg: string;
 
     constructor(expression: string, message: string, err?: Error) {
-        super(StringFormatter.format('$ : $', expression, message));
-
+        // Temporarily disable stack trace capture — this exception is used as control flow
+        // in hot paths, and V8 stack trace capture is very expensive.
+        const prevLimit = (Error as any).stackTraceLimit;
+        (Error as any).stackTraceLimit = 0;
+        super();
+        (Error as any).stackTraceLimit = prevLimit;
+        this._expression = expression;
+        this._msg = message;
         this.cause = err;
     }
 
+    // Lazy message formatting — only computed when actually read (e.g. logging)
+    override get message(): string {
+        return this._expression + ' : ' + this._msg;
+    }
+
     public getCause(): Error | undefined {
         return this.cause;
     }

package/src/engine/runtime/expression/tokenextractor/LiteralTokenValueExtractor.ts

@@ -13,6 +13,11 @@ const KEYWORDS: Map<string, any> = new Map([
 export class LiteralTokenValueExtractor extends TokenValueExtractor {
     public static readonly INSTANCE: LiteralTokenValueExtractor = new LiteralTokenValueExtractor();
 
+    public static readonly FAILED: unique symbol = Symbol('LITERAL_PARSE_FAILED');
+
+    // Cache for number parsing: stores the parsed number, or FAILED symbol for non-numeric tokens
+    private static readonly numberCache: Map<string, number | symbol> = new Map();
+
     protected getValueInternal(token: string): any {
         if (StringUtil.isNullOrBlank(token)) return undefined;
 
@@ -27,20 +32,52 @@ export class LiteralTokenValueExtractor extends TokenValueExtractor {
         return this.processNumbers(token);
     }
 
-    private processNumbers(token: string): any {
-        try {
-            let v = Number(token);
+    /**
+     * Non-throwing version of getValueInternal. Returns FAILED symbol instead of throwing.
+     * This is the hot-path method — avoids ExpressionEvaluationException creation entirely.
+     */
+    private tryGetValueInternal(token: string): any {
+        if (StringUtil.isNullOrBlank(token)) return undefined;
+
+        token = token.trim();
+
+        if (KEYWORDS.has(token)) return KEYWORDS.get(token);
+
+        if (token.startsWith('"')) {
+            if (!token.endsWith('"')) return LiteralTokenValueExtractor.FAILED;
+            return token.substring(1, token.length - 1);
+        }
 
-            if (isNaN(v)) throw new Error('Parse number error');
+        return this.tryProcessNumbers(token);
+    }
 
-            return v;
-        } catch (err: any) {
+    private processNumbers(token: string): any {
+        const result = this.tryProcessNumbers(token);
+        if (result === LiteralTokenValueExtractor.FAILED) {
             throw new ExpressionEvaluationException(
                 token,
-                StringFormatter.format('Unable to parse the literal or expression $', token),
-                err,
+                'Unable to parse the literal or expression ' + token,
             );
         }
+        return result;
+    }
+
+    /**
+     * Non-throwing number parser. Returns FAILED symbol for non-numeric tokens.
+     * Results are cached so each unique token is parsed at most once.
+     */
+    private tryProcessNumbers(token: string): number | symbol {
+        const cached = LiteralTokenValueExtractor.numberCache.get(token);
+        if (cached !== undefined) return cached;
+
+        const v = Number(token);
+        if (Number.isNaN(v) || token.trim() === '') {
+            LiteralTokenValueExtractor.numberCache.set(token, LiteralTokenValueExtractor.FAILED);
+            return LiteralTokenValueExtractor.FAILED;
+        }
+
+        LiteralTokenValueExtractor.numberCache.set(token, v);
+        return v;
     }
 
     private processString(token: string): any {
@@ -61,6 +98,23 @@ export class LiteralTokenValueExtractor extends TokenValueExtractor {
         return undefined;
     }
 
+    /**
+     * Try to get a literal value without throwing or creating any exception objects.
+     * Returns FAILED symbol if not a valid literal.
+     */
+    public tryGetValue(token: string): any {
+        const prefix = this.getPrefix();
+        if (prefix && !token.startsWith(prefix)) return LiteralTokenValueExtractor.FAILED;
+        return this.tryGetValueInternal(token);
+    }
+
+    /**
+     * Check if a result from tryGetValue indicates failure.
+     */
+    public static isFailed(value: any): boolean {
+        return value === LiteralTokenValueExtractor.FAILED;
+    }
+
     public getValueFromExtractors(token: string, maps: Map<string, TokenValueExtractor>): any {
         if (maps.has(token + '.')) return maps.get(token + '.')?.getStore();
         return this.getValue(token);

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -7,6 +7,7 @@ import { ExpressionEvaluationException } from '../exception/ExpressionEvaluation
 export abstract class TokenValueExtractor {
     public static readonly REGEX_SQUARE_BRACKETS: RegExp = /[\[\]]/;
     public static readonly REGEX_DOT: RegExp = /(?<!\.)\.(?!\.)/;
+    private static readonly REGEX_INTEGER: RegExp = /^-?\d+$/;
 
     // Cache for parsed paths to avoid repeated regex splits
     private static pathCache: Map<string, string[]> = new Map();
@@ -177,7 +178,7 @@ export abstract class TokenValueExtractor {
             
             // Only use fast path for pure integer strings (no range operators like '..')
             // Note: parseInt('2..4', 10) incorrectly returns 2, so we need to validate first
-            if (/^-?\d+$/.test(segment)) {
+            if (TokenValueExtractor.REGEX_INTEGER.test(segment)) {
                 const idx = Number.parseInt(segment, 10);
                 const actualIdx = idx < 0 ? element.length + idx : idx;
                 return actualIdx >= 0 && actualIdx < element.length ? element[actualIdx] : undefined;
@@ -188,7 +189,7 @@ export abstract class TokenValueExtractor {
         if (typeof element === 'string') {
             if (segment === 'length') return element.length;
             // Only use fast path for pure integer strings
-            if (/^-?\d+$/.test(segment)) {
+            if (TokenValueExtractor.REGEX_INTEGER.test(segment)) {
                 const idx = Number.parseInt(segment, 10);
                 const actualIdx = idx < 0 ? element.length + idx : idx;
                 return actualIdx >= 0 && actualIdx < element.length ? element[actualIdx] : undefined;