@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,143 @@
+import { ExecutionException } from '../../exception/ExecutionException';
+import { KIRuntimeException } from '../../exception/KIRuntimeException';
+import { JsonExpression } from '../../json/JsonExpression';
+import { SchemaType } from '../../json/schema/type/SchemaType';
+import { isNullValue } from '../NullCheck';
+import { StringFormatter } from '../string/StringFormatter';
+import { Tuple2 } from '../Tuples';
+
+export class PrimitiveUtil {
+    public static findPrimitiveNullAsBoolean(element: any): Tuple2<SchemaType, any> {
+        if (!element) return new Tuple2(SchemaType.BOOLEAN, false);
+
+        let typof: string = typeof element;
+        if (typof === 'object')
+            throw new ExecutionException(
+                StringFormatter.format('$ is not a primitive type', element),
+            );
+
+        let value: any = element;
+
+        if (typof === 'boolean') return new Tuple2(SchemaType.BOOLEAN, value);
+
+        if (typof === 'string') return new Tuple2(SchemaType.STRING, value);
+
+        return PrimitiveUtil.findPrimitiveNumberType(value);
+    }
+
+    public static findPrimitive(element: any): Tuple2<SchemaType, any> {
+        if (isNullValue(element)) return new Tuple2(SchemaType.NULL, undefined);
+
+        let typof: string = typeof element;
+
+        if (typof === 'object')
+            throw new ExecutionException(
+                StringFormatter.format('$ is not a primitive type', element),
+            );
+
+        let value: any = element;
+
+        if (typof === 'boolean') return new Tuple2(SchemaType.BOOLEAN, value);
+
+        if (typof === 'string') return new Tuple2(SchemaType.STRING, value);
+
+        return PrimitiveUtil.findPrimitiveNumberType(value);
+    }
+
+    public static findPrimitiveNumberType(element: any): Tuple2<SchemaType, any> {
+        if (isNullValue(element) || Array.isArray(element) || typeof element == 'object')
+            throw new ExecutionException(
+                StringFormatter.format('Unable to convert $ to a number.', element),
+            );
+
+        let value: any = element;
+
+        // I think we should not forcibly convert a string to number, it was needed in java as we were using GSON.
+        // if (typeof value === "string") {
+        //     if (!/^[\d]{0,}[.]{0,1}[\d]{1,}$/.test(value)) //Don't do this, I need to enhance to accommadate the exponent form.
+        //     throw new ExecutionException(StringFormatter.format("Unable to convert $ to a number.", value));
+        //     let fv = parseFloat(value);
+        //     let iv = parseInt(value);
+
+        //     if (iv === fv)
+        //         return new Tuple2(SchemaType.LONG, iv);
+        //     else
+        //     return new Tuple2(SchemaType.DOUBLE, fv);
+        // }
+
+        try {
+            let num: number = value as number;
+            if (Number.isInteger(num)) return new Tuple2(SchemaType.LONG, num);
+            else return new Tuple2(SchemaType.DOUBLE, num);
+        } catch (err: any) {
+            throw new ExecutionException(
+                StringFormatter.format('Unable to convert $ to a number.', value),
+                err,
+            );
+        }
+    }
+
+    public static compare(a: any, b: any): number {
+        if (a == b) return 0;
+
+        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 (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]);
+                    if (cmp != 0) return cmp;
+                }
+                return 0;
+            }
+            return Array.isArray(a) ? -1 : 1;
+        }
+
+        const typofa = typeof a;
+        const typofb = typeof b;
+
+        if (typofa === 'object' || typofb === 'object') {
+            if (typofa === 'object' && typofb === 'object') {
+                Object.keys(a).forEach((key) => {
+                    let cmp = this.compare(a[key], b[key]);
+                    if (cmp != 0) return cmp;
+                });
+            }
+        }
+
+        return this.comparePrimitive(a, b);
+    }
+
+    public static comparePrimitive(oa: any, ob: any): number {
+        if (isNullValue(oa) || isNullValue(ob)) {
+            if (isNullValue(oa) && isNullValue(ob)) return 0;
+            return isNullValue(oa) ? -1 : 1;
+        }
+
+        if (oa == ob) return 0;
+
+        if (typeof oa == 'boolean' || typeof ob == 'boolean') return oa ? -1 : 1;
+
+        if (typeof oa == 'string' || typeof ob == 'string') {
+            return oa + '' < ob + '' ? -1 : 1;
+        }
+
+        if (typeof oa == 'number' || typeof ob == 'number') {
+            return oa - ob;
+        }
+
+        return 0;
+    }
+
+    private static baseNumberType(num: number): SchemaType {
+        if (Number.isInteger(num)) return SchemaType.LONG;
+        else return SchemaType.DOUBLE;
+    }
+
+    public static toPrimitiveType(e: any): number {
+        return e as number;
+    }
+
+    private constructor() {}
+}

package/src/engine/util/string/StringBuilder.ts

@@ -0,0 +1,59 @@
+import { KIRunConstants } from '../../constant/KIRunConstants';
+import { KIRuntimeException } from '../../exception/KIRuntimeException';
+
+export class StringBuilder {
+    private str: string;
+
+    public constructor(str?: string) {
+        this.str = str ?? '';
+    }
+
+    public append(x: any): StringBuilder {
+        this.str += x;
+        return this;
+    }
+
+    public toString(): string {
+        return '' + this.str;
+    }
+
+    public trim(): StringBuilder {
+        this.str = this.str.trim();
+        return this;
+    }
+
+    public setLength(num: number): StringBuilder {
+        this.str = this.str.substring(0, num);
+        return this;
+    }
+
+    public length(): number {
+        return this.str.length;
+    }
+
+    public charAt(index: number): string {
+        return this.str.charAt(index);
+    }
+
+    public deleteCharAt(index: number): StringBuilder {
+        this.checkIndex(index);
+        this.str = this.str.substring(0, index) + this.str.substring(index + 1);
+        return this;
+    }
+
+    public insert(index: number, str: string): StringBuilder {
+        this.str = this.str.substring(0, index) + str + this.str.substring(index);
+        return this;
+    }
+
+    private checkIndex(index: number): void {
+        if (index >= this.str.length)
+            throw new KIRuntimeException(
+                `Index ${index} is greater than or equal to ${this.str.length}`,
+            );
+    }
+
+    public substring(start: number, end: number): string {
+        return this.str.substring(start, end);
+    }
+}

package/src/engine/util/string/StringFormatter.ts

@@ -0,0 +1,25 @@
+export class StringFormatter {
+    public static format(formatString: string, ...params: any[]): string {
+        if (!params || params.length == 0) return formatString;
+
+        let sb: string = '';
+        let ind: number = 0;
+        let chr: string = '';
+        let prevchar: string = chr;
+        let length: number = formatString.length;
+
+        for (let i = 0; i < length; i++) {
+            chr = formatString.charAt(i);
+
+            if (chr == '$' && prevchar == '\\') sb = sb.substring(0, i - 1) + chr;
+            else if (chr == '$' && ind < params.length) sb += params[ind++];
+            else sb += chr;
+
+            prevchar = chr;
+        }
+
+        return sb.toString();
+    }
+
+    private constructor() {}
+}

package/src/engine/util/string/StringUtil.ts

@@ -0,0 +1,48 @@
+import { KIRuntimeException } from '../../exception/KIRuntimeException';
+import { StringFormatter } from './StringFormatter';
+
+export class StringUtil {
+    private constructor() {}
+
+    public static nthIndex(str: string, c: string, from: number = 0, occurance: number): number {
+        if (!str) throw new KIRuntimeException('String cannot be null');
+
+        if (from < 0 || from >= str.length)
+            throw new KIRuntimeException(
+                StringFormatter.format('Cannot search from index : $', from),
+            );
+
+        if (occurance <= 0 || occurance > str.length)
+            throw new KIRuntimeException(
+                StringFormatter.format('Cannot search for occurance : $', occurance),
+            );
+
+        while (from < str.length) {
+            if (str.charAt(from) == c) {
+                --occurance;
+                if (occurance == 0) return from;
+            }
+
+            ++from;
+        }
+
+        return -1;
+    }
+
+    public static splitAtFirstOccurance(
+        str: string,
+        c: string,
+    ): [string | undefined, string | undefined] {
+        if (!str) return [undefined, undefined];
+
+        let index: number = str.indexOf(c);
+
+        if (index == -1) return [str, undefined];
+
+        return [str.substring(0, index), str.substring(index + 1)];
+    }
+
+    public static isNullOrBlank(str: string | undefined): boolean {
+        return !str || str.trim() == '';
+    }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from './engine/util/Tuples';
+export * from './engine/Repository';
+export * from './engine/HybridRepository';
+export * from './engine/json/schema/Schema';
+export * from './engine/json/schema/type/SchemaType';
+export * from './engine/json/schema/validator/SchemaValidator';
+export * from './engine/constant/KIRunConstants';
+export * from './engine/exception/ExecutionException';
+export * from './engine/exception/KIRuntimeException';
+export * from './engine/function/Function';
+export * from './engine/function/AbstractFunction';
+export * from './engine/namespaces/Namespaces';
+export * from './engine/runtime/KIRuntime';

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "extends": "@tsconfig/recommended/tsconfig.json",
+    "compilerOptions": {
+        "lib": ["es2020"]
+    }
+}