@fincity/kirun-js 2.9.0 → 2.11.0

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

@@ -2,41 +2,45 @@ import { ExecutionException } from '../../exception/ExecutionException';
 import { LinkedList } from '../../util/LinkedList';
 import { StringBuilder } from '../../util/string/StringBuilder';
 import { StringFormatter } from '../../util/string/StringFormatter';
-import { FunctionExecutionParameters } from '../FunctionExecutionParameters';
 import { ExpressionEvaluationException } from './exception/ExpressionEvaluationException';
 import { Expression } from './Expression';
 import { ExpressionToken } from './ExpressionToken';
 import { ExpressionTokenValue } from './ExpressionTokenValue';
 import { Operation } from './Operation';
-import { LogicalNullishCoalescingOperator } from './operators/binary/LogicalNullishCoalescingOperator';
-import { ArithmeticAdditionOperator } from './operators/binary/ArithmeticAdditionOperator';
-import { ArithmeticDivisionOperator } from './operators/binary/ArithmeticDivisionOperator';
-import { ArithmeticIntegerDivisionOperator } from './operators/binary/ArithmeticInetgerDivisionOperator';
-import { ArithmeticModulusOperator } from './operators/binary/ArithmeticModulusOperator';
-import { ArithmeticMultiplicationOperator } from './operators/binary/ArithmeticMultiplicationOperator';
-import { ArithmeticSubtractionOperator } from './operators/binary/ArithmeticSubtractionOperator';
-import { ArrayOperator } from './operators/binary/ArrayOperator';
-import { BinaryOperator } from './operators/binary/BinaryOperator';
-import { BitwiseAndOperator } from './operators/binary/BitwiseAndOperator';
-import { BitwiseLeftShiftOperator } from './operators/binary/BitwiseLeftShiftOperator';
-import { BitwiseOrOperator } from './operators/binary/BitwiseOrOperator';
-import { BitwiseRightShiftOperator } from './operators/binary/BitwiseRightShiftOperator';
-import { BitwiseUnsignedRightShiftOperator } from './operators/binary/BitwiseUnsignedRightShiftOperator';
-import { BitwiseXorOperator } from './operators/binary/BitwiseXorOperator';
-import { LogicalAndOperator } from './operators/binary/LogicalAndOperator';
-import { LogicalEqualOperator } from './operators/binary/LogicalEqualOperator';
-import { LogicalGreaterThanEqualOperator } from './operators/binary/LogicalGreaterThanEqualOperator';
-import { LogicalGreaterThanOperator } from './operators/binary/LogicalGreaterThanOperator';
-import { LogicalLessThanEqualOperator } from './operators/binary/LogicalLessThanEqualOperator';
-import { LogicalLessThanOperator } from './operators/binary/LogicalLessThanOperator';
-import { LogicalNotEqualOperator } from './operators/binary/LogicalNotEqualOperator';
-import { LogicalOrOperator } from './operators/binary/LogicalOrOperator';
-import { ObjectOperator } from './operators/binary/ObjectOperator';
-import { ArithmeticUnaryMinusOperator } from './operators/unary/ArithmeticUnaryMinusOperator';
-import { ArithmeticUnaryPlusOperator } from './operators/unary/ArithmeticUnaryPlusOperator';
-import { BitwiseComplementOperator } from './operators/unary/BitwiseComplementOperator';
-import { LogicalNotOperator } from './operators/unary/LogicalNotOperator';
-import { UnaryOperator } from './operators/unary/UnaryOperator';
+import { LogicalNullishCoalescingOperator } from './operators/binary';
+import {
+    ArithmeticAdditionOperator,
+    ArithmeticDivisionOperator,
+    ArithmeticIntegerDivisionOperator,
+    ArithmeticModulusOperator,
+    ArithmeticMultiplicationOperator,
+    ArithmeticSubtractionOperator,
+    ArrayOperator,
+    ArrayRangeOperator,
+    BinaryOperator,
+    BitwiseAndOperator,
+    BitwiseLeftShiftOperator,
+    BitwiseOrOperator,
+    BitwiseRightShiftOperator,
+    BitwiseUnsignedRightShiftOperator,
+    BitwiseXorOperator,
+    LogicalAndOperator,
+    LogicalEqualOperator,
+    LogicalGreaterThanEqualOperator,
+    LogicalGreaterThanOperator,
+    LogicalLessThanEqualOperator,
+    LogicalLessThanOperator,
+    LogicalNotEqualOperator,
+    LogicalOrOperator,
+    ObjectOperator,
+} from './operators/binary/';
+import {
+    ArithmeticUnaryMinusOperator,
+    ArithmeticUnaryPlusOperator,
+    BitwiseComplementOperator,
+    LogicalNotOperator,
+    UnaryOperator,
+} from './operators/unary';
 import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
 import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
 import { Tuple2 } from '../../util/Tuples';
@@ -82,6 +86,7 @@ export class ExpressionEvaluator {
         [Operation.NULLISH_COALESCING_OPERATOR, new LogicalNullishCoalescingOperator()],
 
         [Operation.ARRAY_OPERATOR, new ArrayOperator()],
+        [Operation.ARRAY_RANGE_INDEX_OPERATOR, new ArrayRangeOperator()],
         [Operation.OBJECT_OPERATOR, new ObjectOperator()],
     ]);
 
@@ -315,7 +320,7 @@ export class ExpressionEvaluator {
         if (key.length > 2 && valuesMap.has(key))
             tokens.push(new ExpressionTokenValue(str, this.getValue(str, valuesMap)));
         else {
-            let v: any = undefined;
+            let v: any;
             try {
                 v = LiteralTokenValueExtractor.INSTANCE.getValue(str);
             } catch (err) {

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

@@ -30,6 +30,7 @@ export class Operation {
     public static readonly UNARY_BITWISE_COMPLEMENT: Operation = new Operation('UN: ~', '~');
 
     public static readonly ARRAY_OPERATOR: Operation = new Operation('[');
+    public static readonly ARRAY_RANGE_INDEX_OPERATOR: Operation = new Operation('..');
     public static readonly OBJECT_OPERATOR: Operation = new Operation('.');
 
     public static readonly NULLISH_COALESCING_OPERATOR: Operation = new Operation('??');
@@ -39,7 +40,7 @@ export class Operation {
     private static readonly VALUE_OF: Map<string, Operation> = new Map([
         ['MULTIPLICATION', Operation.MULTIPLICATION],
         ['DIVISION', Operation.DIVISION],
-        ['INTEGER_DIVISON', Operation.INTEGER_DIVISION],
+        ['INTEGER_DIVISION', Operation.INTEGER_DIVISION],
         ['MOD', Operation.MOD],
         ['ADDITION', Operation.ADDITION],
         ['SUBTRACTION', Operation.SUBTRACTION],
@@ -64,6 +65,7 @@ export class Operation {
         ['UNARY_LOGICAL_NOT', Operation.UNARY_LOGICAL_NOT],
         ['UNARY_BITWISE_COMPLEMENT', Operation.UNARY_BITWISE_COMPLEMENT],
         ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
+        ['ARRAY_RANGE_INDEX_OPERATOR', Operation.ARRAY_RANGE_INDEX_OPERATOR],
         ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
         ['NULLISH_COALESCING_OPERATOR', Operation.NULLISH_COALESCING_OPERATOR],
         ['CONDITIONAL_TERNARY_OPERATOR', Operation.CONDITIONAL_TERNARY_OPERATOR],
@@ -123,6 +125,7 @@ export class Operation {
         [Operation.UNARY_BITWISE_COMPLEMENT, 1],
         [Operation.ARRAY_OPERATOR, 1],
         [Operation.OBJECT_OPERATOR, 1],
+        [Operation.ARRAY_RANGE_INDEX_OPERATOR, 2],
         [Operation.MULTIPLICATION, 2],
         [Operation.DIVISION, 2],
         [Operation.INTEGER_DIVISION, 2],
@@ -153,6 +156,7 @@ export class Operation {
             ...Array.from(Operation.LOGICAL_OPERATORS),
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
+            Operation.ARRAY_RANGE_INDEX_OPERATOR,
             Operation.OBJECT_OPERATOR,
             ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ].map((e) => e.getOperator()),
@@ -164,6 +168,7 @@ export class Operation {
             ...Array.from(Operation.LOGICAL_OPERATORS),
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
+            Operation.ARRAY_RANGE_INDEX_OPERATOR,
             Operation.OBJECT_OPERATOR,
             ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ]
@@ -192,9 +197,10 @@ export class Operation {
         .map((e) => e.length)
         .reduce((a, c) => (a > c ? a : c), 0);
 
-    private operator: string;
-    private operatorName: string;
-    private _shouldBeWrappedInSpace: boolean;
+    private readonly operator: string;
+    private readonly operatorName: string;
+    private readonly _shouldBeWrappedInSpace: boolean;
+
     public constructor(
         operator: string,
         operatorName?: string,

package/src/engine/runtime/expression/operators/binary/ArrayRangeOperator.ts

@@ -0,0 +1,7 @@
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArrayRangeOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        return `${t ?? ''}..${u ?? ''}`;
+    }
+}

package/src/engine/runtime/expression/operators/binary/index.ts

@@ -22,3 +22,4 @@ export * from './LogicalLessThanOperator';
 export * from './LogicalOrOperator';
 export * from './ObjectOperator';
 export * from './LogicalNullishCoalescingOperator';
+export * from './ArrayRangeOperator';

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

@@ -6,7 +6,7 @@ import { ExpressionEvaluationException } from '../exception/ExpressionEvaluation
 
 export abstract class TokenValueExtractor {
     public static readonly REGEX_SQUARE_BRACKETS: RegExp = /[\[\]]/;
-    public static readonly REGEX_DOT: RegExp = /\./;
+    public static readonly REGEX_DOT: RegExp = /(?<!\.)\.(?!\.)/;
 
     public getValue(token: string): any {
         let prefix: string = this.getPrefix();
@@ -71,7 +71,8 @@ export abstract class TokenValueExtractor {
 
         if (cPart === 'length') return this.getLength(token, cElement);
 
-        if (Array.isArray(cElement)) return this.handleArrayAccess(token, cPart, cElement);
+        if (typeof cElement == 'string' || Array.isArray(cElement))
+            return this.handleArrayAccess(token, cPart, cElement);
 
         return this.handleObjectAccess(token, parts, partNumber, cPart, cElement);
     }
@@ -91,8 +92,29 @@ export abstract class TokenValueExtractor {
         );
     }
 
-    private handleArrayAccess(token: string, cPart: string, cArray: any[]): any {
-        const index: number = parseInt(cPart);
+    private handleArrayAccess(token: string, cPart: string, cArray: any[] | string): any {
+        const dotDotIndex = cPart.indexOf('..');
+        if (dotDotIndex >= 0) {
+            const startIndex = cPart.substring(0, dotDotIndex);
+            const endIndex = cPart.substring(dotDotIndex + 2);
+
+            let intStart = startIndex.length == 0 ? 0 : parseInt(startIndex);
+            let intEnd = endIndex.length == 0 ? cArray.length : parseInt(endIndex);
+
+            if (isNaN(intStart) || isNaN(intEnd)) return undefined;
+
+            while (intStart < 0) intStart += cArray.length;
+            while (intEnd < 0) intEnd += cArray.length;
+
+            const cArrayType = typeof cArray;
+            if (intStart >= intEnd) return cArrayType == 'string' ? '' : [];
+
+            return cArrayType == 'string'
+                ? (cArray as string).substring(intStart, intEnd)
+                : cArray.slice(intStart, intEnd);
+        }
+
+        let index: number = parseInt(cPart);
 
         if (isNaN(index)) {
             throw new ExpressionEvaluationException(
@@ -101,7 +123,8 @@ export abstract class TokenValueExtractor {
             );
         }
 
-        if (index < 0 || index >= cArray.length) {
+        while (index < 0) index = cArray.length + index;
+        if (index >= cArray.length) {
             return undefined;
         }
 
@@ -137,7 +160,11 @@ export abstract class TokenValueExtractor {
         partNumber: number,
         jsonElement: any,
     ): void {
-        if (typeof jsonElement != 'object' || Array.isArray(jsonElement))
+        const jsonElementType = typeof jsonElement;
+        if (
+            (jsonElementType != 'object' && jsonElementType != 'string') ||
+            Array.isArray(jsonElement)
+        )
             throw new ExpressionEvaluationException(
                 token,
                 StringFormatter.format(