@fincity/kirun-js 1.3.1 → 1.4.2

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

@@ -40,6 +40,8 @@ import { UnaryOperator } from './operators/unary/UnaryOperator';
 import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
 import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
 import { Tuple2 } from '../../util/Tuples';
+import { ConditionalTernaryOperator } from './operators/ternary';
+import { TernaryOperator } from './operators/ternary/TernaryOperator';
 
 export class ExpressionEvaluator {
     private static readonly UNARY_OPERATORS_MAP: Map<Operation, UnaryOperator> = new Map([
@@ -49,6 +51,10 @@ export class ExpressionEvaluator {
         [Operation.UNARY_PLUS, new ArithmeticUnaryPlusOperator()],
     ]);
 
+    private static readonly TERNARY_OPERATORS_MAP: Map<Operation, TernaryOperator> = new Map([
+        [Operation.CONDITIONAL_TERNARY_OPERATOR, new ConditionalTernaryOperator()],
+    ]);
+
     private static readonly BINARY_OPERATORS_MAP: Map<Operation, BinaryOperator> = new Map([
         [Operation.ADDITION, new ArithmeticAdditionOperator()],
         [Operation.DIVISION, new ArithmeticDivisionOperator()],
@@ -195,6 +201,13 @@ export class ExpressionEvaluator {
                 operator == Operation.ARRAY_OPERATOR
             ) {
                 this.processObjectOrArrayOperator(valuesMap, ops, tokens, operator, token);
+            } else if (operator == Operation.CONDITIONAL_TERNARY_OPERATOR) {
+                const token2: ExpressionToken = tokens.pop();
+                const token3: ExpressionToken = tokens.pop();
+                var v1 = this.getValueFromToken(valuesMap, token3);
+                var v2 = this.getValueFromToken(valuesMap, token2);
+                var v3 = this.getValueFromToken(valuesMap, token);
+                tokens.push(this.applyTernaryOperation(operator, v1, v2, v3));
             } else {
                 const token2: ExpressionToken = tokens.pop();
                 var v1 = this.getValueFromToken(valuesMap, token2);
@@ -295,6 +308,19 @@ export class ExpressionEvaluator {
         }
     }
 
+    private applyTernaryOperation(operator: Operation, v1: any, v2: any, v3: any): ExpressionToken {
+        let op: TernaryOperator | undefined =
+            ExpressionEvaluator.TERNARY_OPERATORS_MAP.get(operator);
+
+        if (!op)
+            throw new ExpressionEvaluationException(
+                this.expression,
+                StringFormatter.format('No operator found to evaluate $', this.getExpression()),
+            );
+
+        return new ExpressionTokenValue(operator.toString(), op.apply(v1, v2, v3));
+    }
+
     private applyBinaryOperation(operator: Operation, v1: any, v2: any): ExpressionToken {
         let typv1: string = typeof v1;
         let typv2: string = typeof v2;

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

@@ -34,6 +34,8 @@ export class Operation {
 
     public static readonly NULLISH_COALESCING_OPERATOR: Operation = new Operation('??');
 
+    public static readonly CONDITIONAL_TERNARY_OPERATOR: Operation = new Operation('?');
+
     private static readonly VALUE_OF: Map<string, Operation> = new Map([
         ['MULTIPLICATION', Operation.MULTIPLICATION],
         ['DIVISION', Operation.DIVISION],
@@ -64,6 +66,7 @@ export class Operation {
         ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
         ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
         ['NULLISH_COALESCING_OPERATOR', Operation.NULLISH_COALESCING_OPERATOR],
+        ['CONDITIONAL_TERNARY_OPERATOR', Operation.CONDITIONAL_TERNARY_OPERATOR],
     ]);
 
     public static readonly UNARY_OPERATORS: Set<Operation> = new Set([
@@ -109,6 +112,10 @@ export class Operation {
         Operation.BITWISE_XOR,
     ]);
 
+    public static readonly CONDITIONAL_OPERATORS: Set<Operation> = new Set([
+        Operation.CONDITIONAL_TERNARY_OPERATOR,
+    ]);
+
     public static readonly OPERATOR_PRIORITY: Map<Operation, number> = new Map([
         [Operation.UNARY_PLUS, 1],
         [Operation.UNARY_MINUS, 1],
@@ -137,6 +144,7 @@ export class Operation {
         [Operation.AND, 10],
         [Operation.OR, 11],
         [Operation.NULLISH_COALESCING_OPERATOR, 11],
+        [Operation.CONDITIONAL_TERNARY_OPERATOR, 12],
     ]);
 
     public static readonly OPERATORS: Set<string> = new Set(
@@ -146,6 +154,7 @@ export class Operation {
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
             Operation.OBJECT_OPERATOR,
+            ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ].map((e) => e.getOperator()),
     );
 
@@ -156,6 +165,7 @@ export class Operation {
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
             Operation.OBJECT_OPERATOR,
+            ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ]
             .filter((e) => !e.shouldBeWrappedInSpace())
             .map((e) => e.getOperator()),

package/src/engine/runtime/expression/operators/ternary/ConditionalTernaryOperator.ts

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

package/src/engine/runtime/expression/operators/ternary/TernaryOperator.ts

@@ -0,0 +1,15 @@
+import { ExecutionException } from '../../../../exception/ExecutionException';
+import { isNullValue } from '../../../../util/NullCheck';
+import { StringFormatter } from '../../../../util/string/StringFormatter';
+import { Operation } from '../../Operation';
+
+export abstract class TernaryOperator {
+    public abstract apply(t: any, u: any, v: any): any;
+
+    public nullCheck(e1: any, e2: any, e3: any, op: Operation): void {
+        if (isNullValue(e1) || isNullValue(e2) || isNullValue(e3))
+            throw new ExecutionException(
+                StringFormatter.format('$ cannot be applied to a null value', op.getOperatorName()),
+            );
+    }
+}

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

@@ -0,0 +1 @@
+export * from './ConditionalTernaryOperator';

package/src/index.ts

@@ -53,7 +53,6 @@ export * from './engine/json/schema/type/TypeUtil';
 export * from './engine/json/schema/type/MultipleType';
 export * from './engine/json/schema/type/Type';
 export * from './engine/json/schema/type/SchemaType';
-export * from './engine/json/schema/object/AdditionalPropertiesType';
 export * from './engine/json/schema/SchemaUtil';
 export * from './engine/json/schema/string/StringFormat';
 export * from './engine/HybridRepository';
@@ -77,3 +76,4 @@ export * from './engine/exception/ExecutionException';
 export * from './engine/exception/KIRuntimeException';
 export * from './engine/runtime/expression/operators/unary';
 export * from './engine/runtime/expression/operators/binary';
+export * from './engine/runtime/expression/operators/ternary';

package/src/engine/json/schema/object/AdditionalPropertiesType.ts

@@ -1,32 +0,0 @@
-import { Schema } from '../Schema';
-
-export class AdditionalPropertiesType {
-    private booleanValue?: boolean;
-    private schemaValue?: Schema;
-
-    public getBooleanValue(): boolean | undefined {
-        return this.booleanValue;
-    }
-
-    public getSchemaValue(): Schema | undefined {
-        return this.schemaValue;
-    }
-
-    public setBooleanValue(booleanValue: boolean): AdditionalPropertiesType {
-        this.booleanValue = booleanValue;
-        return this;
-    }
-
-    public setSchemaValue(schemaValue: Schema): AdditionalPropertiesType {
-        this.schemaValue = schemaValue;
-        return this;
-    }
-
-    public static from(obj: any): AdditionalPropertiesType | undefined {
-        if (!obj) return undefined;
-        const ad = new AdditionalPropertiesType();
-        ad.booleanValue = obj.booleanValue;
-        ad.schemaValue = obj.schemaValue;
-        return ad;
-    }
-}