@fincity/kirun-js 1.0.1 → 1.0.2

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);