@fincity/kirun-js 1.0.0 → 1.0.3

package/src/engine/function/system/string/AbstractStringFunction.ts

@@ -25,45 +25,67 @@ export abstract class AbstractStringFunction extends AbstractFunction {
 
     public static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected static readonly PARAMETER_STRING: Parameter =new Parameter(AbstractStringFunction.PARAMETER_STRING_NAME,Schema.ofString(AbstractStringFunction.PARAMETER_STRING_NAME));
-
-    protected static readonly PARAMETER_SECOND_STRING: Parameter =new Parameter(AbstractStringFunction.PARAMETER_SECOND_STRING_NAME,Schema.ofString(AbstractStringFunction.PARAMETER_SECOND_STRING_NAME));
-
-    protected static readonly PARAMETER_THIRD_STRING: Parameter =new Parameter(AbstractStringFunction.PARAMETER_THIRD_STRING_NAME,Schema.ofString(AbstractStringFunction.PARAMETER_THIRD_STRING_NAME));
-
-    protected static readonly PARAMETER_INDEX: Parameter =new Parameter(AbstractStringFunction.PARAMETER_INDEX_NAME,Schema.ofInteger(AbstractStringFunction.PARAMETER_INDEX_NAME));
-
-    protected static readonly PARAMETER_SECOND_INDEX: Parameter =new Parameter(AbstractStringFunction.PARAMETER_SECOND_INDEX_NAME,Schema.ofInteger(AbstractStringFunction.PARAMETER_SECOND_INDEX_NAME));
-
-    protected static readonly PARAMETER_SEARCH_STRING: Parameter =new Parameter(AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,Schema.ofString(AbstractStringFunction.PARAMETER_STRING_NAME));
-
-    protected static readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            MapUtil.of(
-                AbstractStringFunction.EVENT_RESULT_NAME,
-                Schema.ofString(AbstractStringFunction.EVENT_RESULT_NAME),
-            ),
-        );
-
-    protected static readonly EVENT_BOOLEAN: Event =new Event(Event.OUTPUT,
-            MapUtil.of(
-                AbstractStringFunction.EVENT_RESULT_NAME,
-                Schema.ofBoolean(AbstractStringFunction.EVENT_RESULT_NAME),
-            ),
-        );
-
-    protected static readonly EVENT_INT: Event =new Event(Event.OUTPUT,
-            MapUtil.of(
-                AbstractStringFunction.EVENT_RESULT_NAME,
-                Schema.ofInteger(AbstractStringFunction.EVENT_RESULT_NAME),
-            ),
-        );
-
-    protected static readonly EVENT_ARRAY: Event =new Event(Event.OUTPUT,
-            MapUtil.of(
-                AbstractStringFunction.EVENT_RESULT_NAME,
-                Schema.ofArray(AbstractStringFunction.EVENT_RESULT_NAME),
-            ),
-        );
+    protected static readonly PARAMETER_STRING: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_STRING_NAME,
+        Schema.ofString(AbstractStringFunction.PARAMETER_STRING_NAME),
+    );
+
+    protected static readonly PARAMETER_SECOND_STRING: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_SECOND_STRING_NAME,
+        Schema.ofString(AbstractStringFunction.PARAMETER_SECOND_STRING_NAME),
+    );
+
+    protected static readonly PARAMETER_THIRD_STRING: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_THIRD_STRING_NAME,
+        Schema.ofString(AbstractStringFunction.PARAMETER_THIRD_STRING_NAME),
+    );
+
+    protected static readonly PARAMETER_INDEX: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_INDEX_NAME,
+        Schema.ofInteger(AbstractStringFunction.PARAMETER_INDEX_NAME),
+    );
+
+    protected static readonly PARAMETER_SECOND_INDEX: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_SECOND_INDEX_NAME,
+        Schema.ofInteger(AbstractStringFunction.PARAMETER_SECOND_INDEX_NAME),
+    );
+
+    protected static readonly PARAMETER_SEARCH_STRING: Parameter = new Parameter(
+        AbstractStringFunction.PARAMETER_SEARCH_STRING_NAME,
+        Schema.ofString(AbstractStringFunction.PARAMETER_STRING_NAME),
+    );
+
+    protected static readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractStringFunction.EVENT_RESULT_NAME,
+            Schema.ofString(AbstractStringFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    protected static readonly EVENT_BOOLEAN: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractStringFunction.EVENT_RESULT_NAME,
+            Schema.ofBoolean(AbstractStringFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    protected static readonly EVENT_INT: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractStringFunction.EVENT_RESULT_NAME,
+            Schema.ofInteger(AbstractStringFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    protected static readonly EVENT_ARRAY: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractStringFunction.EVENT_RESULT_NAME,
+            Schema.ofArray(AbstractStringFunction.EVENT_RESULT_NAME),
+        ),
+    );
 
     private signature: FunctionSignature;
 

package/src/engine/function/system/string/StringFunctionRepository.ts

@@ -9,8 +9,8 @@ export class StringFunctionRepository implements Repository<Function> {
         AbstractStringFunction.ofEntryString('Trim', (e) => e.trim()),
         AbstractStringFunction.ofEntryString('LowerCase', (e) => e.toLocaleLowerCase()),
         AbstractStringFunction.ofEntryString('UpperCase', (e) => e.toUpperCase()),
-        AbstractStringFunction.ofEntryStringBooleanOutput('Blank', (e) => e.trim() == ''),
-        AbstractStringFunction.ofEntryStringBooleanOutput('Empty', (e) => e == ''),
+        AbstractStringFunction.ofEntryStringBooleanOutput('IsBlank', (e) => e.trim() === ''),
+        AbstractStringFunction.ofEntryStringBooleanOutput('IsEmpty', (e) => e === ''),
 
         AbstractStringFunction.ofEntryAsStringBooleanOutput(
             'Contains',

package/src/engine/json/schema/validator/StringValidator.ts

@@ -18,7 +18,7 @@ export class StringValidator {
         if (isNullValue(element))
             throw new SchemaValidationException(
                 SchemaValidator.path(parents),
-                'Expected a string but found null',
+                'Expected a string but found ' + element,
             );
 
         if (typeof element !== 'string')

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

@@ -134,7 +134,7 @@ export class Expression extends ExpressionToken {
 
         for (let size = start; size > 0; size--) {
             let op: string = this.expression.substring(i, i + size);
-            if (Operation.OPERATORS.has(op)) {
+            if (Operation.OPERATORS_WITHOUT_SPACE_WRAP.has(op)) {
                 if (!StringUtil.isNullOrBlank(buff)) {
                     this.tokens.push(new ExpressionToken(buff));
                     isPrevOp = false;
@@ -236,14 +236,12 @@ export class Expression extends ExpressionToken {
         op: Operation | undefined,
         isPrevOp: boolean,
     ): void {
-        if(!op) return;
+        if (!op) return;
         if (isPrevOp || tokens.isEmpty()) {
-            if (Operation.UNARY_OPERATORS.has(op)){
+            if (Operation.UNARY_OPERATORS.has(op)) {
                 const x = Operation.UNARY_MAP.get(op);
-                if(x)
-                    ops.push(x);  
-            } 
-            else
+                if (x) ops.push(x);
+            } else
                 throw new ExpressionEvaluationException(
                     this.expression,
                     StringFormatter.format('Extra operator $ found.', op),
@@ -269,7 +267,7 @@ export class Expression extends ExpressionToken {
     private hasPrecedence(op1: Operation, op2: Operation): boolean {
         let pre1: number | undefined = Operation.OPERATOR_PRIORITY.get(op1);
         let pre2: number | undefined = Operation.OPERATOR_PRIORITY.get(op2);
-        if(!pre1 || !pre2) {
+        if (!pre1 || !pre2) {
             throw new Error('Unknown operators provided');
         }
         return pre2 < pre1;

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

@@ -6,9 +6,9 @@ export class Operation {
     public static readonly ADDITION: Operation = new Operation('+');
     public static readonly SUBTRACTION: Operation = new Operation('-');
 
-    public static readonly NOT: Operation = new Operation('not');
-    public static readonly AND: Operation = new Operation('and');
-    public static readonly OR: Operation = new Operation('or');
+    public static readonly NOT: Operation = new Operation('not', undefined, true);
+    public static readonly AND: Operation = new Operation('and', undefined, true);
+    public static readonly OR: Operation = new Operation('or', undefined, true);
     public static readonly LESS_THAN: Operation = new Operation('<');
     public static readonly LESS_THAN_EQUAL: Operation = new Operation('<=');
     public static readonly GREATER_THAN: Operation = new Operation('>');
@@ -144,6 +144,18 @@ export class Operation {
         ].map((e) => e.getOperator()),
     );
 
+    public static readonly OPERATORS_WITHOUT_SPACE_WRAP: Set<string> = new Set(
+        [
+            ...Array.from(Operation.ARITHMETIC_OPERATORS),
+            ...Array.from(Operation.LOGICAL_OPERATORS),
+            ...Array.from(Operation.BITWISE_OPERATORS),
+            Operation.ARRAY_OPERATOR,
+            Operation.OBJECT_OPERATOR,
+        ]
+            .filter((e) => !e.shouldBeWrappedInSpace())
+            .map((e) => e.getOperator()),
+    );
+
     public static readonly OPERATION_VALUE_OF: Map<string, Operation> = new Map(
         Array.from(Operation.VALUE_OF.entries()).map(([_, o]) => [o.getOperator(), o]),
     );
@@ -167,9 +179,15 @@ export class Operation {
 
     private operator: string;
     private operatorName: string;
-    public constructor(operator: string, operatorName?: string) {
+    private _shouldBeWrappedInSpace: boolean;
+    public constructor(
+        operator: string,
+        operatorName?: string,
+        shouldBeWrappedInSpace: boolean = false,
+    ) {
         this.operator = operator;
         this.operatorName = operatorName ?? operator;
+        this._shouldBeWrappedInSpace = shouldBeWrappedInSpace;
     }
 
     public getOperator(): string {
@@ -180,6 +198,10 @@ export class Operation {
         return this.operatorName;
     }
 
+    public shouldBeWrappedInSpace(): boolean {
+        return this._shouldBeWrappedInSpace;
+    }
+
     public valueOf(str: string): Operation | undefined {
         return Operation.VALUE_OF.get(str);
     }

package/src/engine/util/MapUtil.ts

@@ -25,25 +25,25 @@ export class MapUtil {
     ): Map<K, V> {
         const map: Map<K, V> = new Map();
 
-        if (k1 && v1) map.set(k1, v1);
+        if (!isNullValue(k1) && !isNullValue(v1)) map.set(k1!, v1!);
 
-        if (k2 && v2) map.set(k2, v2);
+        if (!isNullValue(k2) && !isNullValue(v2)) map.set(k2!, v2!);
 
-        if (k3 && v3) map.set(k3, v3);
+        if (!isNullValue(k3) && !isNullValue(v3)) map.set(k3!, v3!);
 
-        if (k4 && v4) map.set(k4, v4);
+        if (!isNullValue(k4) && !isNullValue(v4)) map.set(k4!, v4!);
 
-        if (k5 && v5) map.set(k5, v5);
+        if (!isNullValue(k5) && !isNullValue(v5)) map.set(k5!, v5!);
 
-        if (k6 && v6) map.set(k6, v6);
+        if (!isNullValue(k6) && !isNullValue(v6)) map.set(k6!, v6!);
 
-        if (k7 && v7) map.set(k7, v7);
+        if (!isNullValue(k7) && !isNullValue(v7)) map.set(k7!, v7!);
 
-        if (k8 && v8) map.set(k8, v8);
+        if (!isNullValue(k8) && !isNullValue(v8)) map.set(k8!, v8!);
 
-        if (k9 && v9) map.set(k9, v9);
+        if (!isNullValue(k9) && !isNullValue(v9)) map.set(k9!, v9!);
 
-        if (k10 && v10) map.set(k10, v10);
+        if (!isNullValue(k10) && !isNullValue(v10)) map.set(k10!, v10!);
 
         return map;
     }

package/src/engine/util/primitive/PrimitiveUtil.ts

@@ -83,7 +83,7 @@ export class PrimitiveUtil {
         if (isNullValue(a) || isNullValue(b)) return isNullValue(a) ? -1 : 1;
 
         if (Array.isArray(a) || Array.isArray(b)) {
-            if (Array.isArray(a) || Array.isArray(b)) {
+            if (Array.isArray(a) && Array.isArray(b)) {
                 if (a.length != b.length) return a.length - b.length;
                 for (let i = 0; i < a.length; i++) {
                     let cmp: number = this.compare(a[i], b[i]);
@@ -104,6 +104,7 @@ export class PrimitiveUtil {
                     if (cmp != 0) return cmp;
                 });
             }
+            return typofa === 'object' ? -1 : 1;
         }
 
         return this.comparePrimitive(a, b);

package/src/index.ts

@@ -11,3 +11,14 @@ export * from './engine/function/Function';
 export * from './engine/function/AbstractFunction';
 export * from './engine/namespaces/Namespaces';
 export * from './engine/runtime/KIRuntime';
+export * from './engine/runtime/expression/Expression';
+export * from './engine/runtime/expression/ExpressionEvaluator';
+export * from './engine/runtime/expression/tokenextractor/TokenValueExtractor';
+export * from './engine/runtime/expression/exception/ExpressionEvaluationException';
+export * from './engine/runtime/expression/ExpressionToken';
+export * from './engine/runtime/expression/ExpressionTokenValue';
+export * from './engine/runtime/expression/Operation';
+export * from './engine/util/LinkedList';
+export * from './engine/util/NullCheck';
+export * from './engine/util/string/StringFormatter';
+export * from './engine/util/string/StringUtil';