@fincity/kirun-js 2.7.0 → 2.8.2

package/src/engine/function/system/math/RandomAny.ts

@@ -0,0 +1,57 @@
+import { Schema } from '../../../json/schema/Schema';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+
+export class RandomAny extends AbstractFunction {
+    public static readonly MIN_VALUE = 'minValue';
+
+    public static readonly MAX_VALUE = 'maxValue';
+
+    public static readonly VALUE = 'value';
+
+    private readonly signature: FunctionSignature;
+
+    private readonly randomFunction: (min: number, max: number) => number;
+
+    public constructor(
+        name: string,
+        minParameter: Parameter,
+        maxParameter: Parameter,
+        outputSchema: Schema,
+        randomFunction: (min: number, max: number) => number,
+    ) {
+        super();
+        this.signature = new FunctionSignature(name)
+            .setParameters(
+                MapUtil.of(RandomAny.MIN_VALUE, minParameter, RandomAny.MAX_VALUE, maxParameter),
+            )
+            .setNamespace(Namespaces.MATH)
+            .setEvents(
+                new Map<string, Event>([
+                    Event.outputEventMapEntry(MapUtil.of(RandomAny.VALUE, outputSchema)),
+                ]),
+            );
+        this.randomFunction = randomFunction;
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let min: number = context.getArguments()?.get(RandomAny.MIN_VALUE);
+
+        let max: number = context.getArguments()?.get(RandomAny.MAX_VALUE);
+
+        let num: number = this.randomFunction(min, max);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[RandomAny.VALUE, num]]))]);
+    }
+}

package/src/engine/function/system/object/ObjectConvert.ts

@@ -19,8 +19,7 @@ import { ParameterType } from '../../../model/ParameterType';
 import { KIRuntimeException } from '../../../exception/KIRuntimeException';
 
 export class ObjectConvert extends AbstractFunction {
-
-    private static readonly SOURCE: string = 'SOURCE';
+    private static readonly SOURCE: string = 'source';
     private static readonly SCHEMA: string = 'schema';
     private static readonly VALUE: string = 'value';
     private static readonly CONVERSION_MODE: string = 'conversionMode';
@@ -28,31 +27,45 @@ export class ObjectConvert extends AbstractFunction {
     getSignature(): FunctionSignature {
         return new FunctionSignature('ObjectConvert')
             .setNamespace(Namespaces.SYSTEM_OBJECT)
-            .setParameters(new Map([
-                Parameter.ofEntry(ObjectConvert.SOURCE, Schema.ofAny(ObjectConvert.SCHEMA)),
-                Parameter.ofEntry(ObjectConvert.SCHEMA, Schema.SCHEMA, false, ParameterType.CONSTANT),
-                Parameter.ofEntry(ObjectConvert.CONVERSION_MODE, Schema.ofString(ObjectConvert.CONVERSION_MODE)
-                    .setEnums(getConversionModes())),
-            ]))
-            .setEvents(new Map([
-                    Event.outputEventMapEntry(MapUtil.of(ObjectConvert.VALUE, Schema.ofAny(ObjectConvert.VALUE))),
+            .setParameters(
+                new Map([
+                    Parameter.ofEntry(ObjectConvert.SOURCE, Schema.ofAny(ObjectConvert.SCHEMA)),
+                    Parameter.ofEntry(
+                        ObjectConvert.SCHEMA,
+                        Schema.SCHEMA,
+                        false,
+                        ParameterType.CONSTANT,
+                    ),
+                    Parameter.ofEntry(
+                        ObjectConvert.CONVERSION_MODE,
+                        Schema.ofString(ObjectConvert.CONVERSION_MODE).setEnums(
+                            getConversionModes(),
+                        ),
+                    ),
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    Event.outputEventMapEntry(
+                        MapUtil.of(ObjectConvert.VALUE, Schema.ofAny(ObjectConvert.VALUE)),
+                    ),
                 ]),
             );
     }
 
-    protected internalExecute(
-        context: FunctionExecutionParameters,
-    ): Promise<FunctionOutput> {
-
+    protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let element: any = context.getArguments()?.get(ObjectConvert.SOURCE);
-        let schema: Schema | undefined = Schema.from(context?.getArguments()?.get(ObjectConvert.SCHEMA));
+        let schema: Schema | undefined = Schema.from(
+            context?.getArguments()?.get(ObjectConvert.SCHEMA),
+        );
 
         if (!schema) {
             throw new KIRuntimeException('Schema is not supplied.');
         }
 
-        const mode: ConversionMode = genericValueOf(context.getArguments()?.get(ObjectConvert.CONVERSION_MODE))
-            || ConversionMode.STRICT;
+        const mode: ConversionMode =
+            genericValueOf(context.getArguments()?.get(ObjectConvert.CONVERSION_MODE)) ||
+            ConversionMode.STRICT;
 
         return this.convertToSchema(schema, context.getSchemaRepository(), element, mode);
     }
@@ -64,8 +77,21 @@ export class ObjectConvert extends AbstractFunction {
         mode: ConversionMode,
     ): Promise<FunctionOutput> {
         try {
-            return new FunctionOutput([EventResult.outputOf(MapUtil.of(ObjectConvert.VALUE,
-                SchemaValidator.validate([], targetSchema, targetSchemaRepository, element, true, mode)))]);
+            return new FunctionOutput([
+                EventResult.outputOf(
+                    MapUtil.of(
+                        ObjectConvert.VALUE,
+                        SchemaValidator.validate(
+                            [],
+                            targetSchema,
+                            targetSchemaRepository,
+                            element,
+                            true,
+                            mode,
+                        ),
+                    ),
+                ),
+            ]);
         } catch (error: any) {
             throw new KIRuntimeException(error?.message);
         }

package/src/engine/function/system/object/ObjectFunctionRepository.ts

@@ -1,8 +1,8 @@
-import { SchemaType } from '../../../json/schema/type/SchemaType';
 import { Namespaces } from '../../../namespaces/Namespaces';
 import { Repository } from '../../../Repository';
 import { AbstractFunction } from '../../AbstractFunction';
 import { Function } from '../../Function';
+import { ObjectConvert } from './ObjectConvert';
 import { ObjectDeleteKey } from './ObjectDeleteKey';
 import { ObjectEntries } from './ObjectEntries';
 import { ObjectKeys } from './ObjectKeys';
@@ -15,6 +15,7 @@ const functionObjectsIndex: { [key: string]: AbstractFunction } = {
     ObjectEntries: new ObjectEntries(),
     ObjectDeleteKey: new ObjectDeleteKey(),
     ObjectPutValue: new ObjectPutValue(),
+    ObjectConvert: new ObjectConvert(),
 };
 
 const filterableNames = Object.values(functionObjectsIndex).map((e) =>

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

@@ -87,7 +87,7 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ),
     );
 
-    private signature: FunctionSignature;
+    private readonly signature: FunctionSignature;
 
     constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
         super();
@@ -104,22 +104,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         return this.signature;
     }
 
-    public static ofEntryAsStringBooleanOutput(
+    public static ofEntryStringStringAndBooleanOutput(
         name: string,
         fun: (a: string, b: string) => boolean,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -146,22 +137,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryAsStringAndIntegerStringOutput(
+    public static ofEntryStringIntegerAndStringOutput(
         name: string,
         fun: (a: string, b: number) => string,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -188,22 +170,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryAsStringIntegerOutput(
+    public static ofEntryStringStringAndIntegerOutput(
         name: string,
         fun: (a: string, b: string) => number,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -230,19 +203,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryString(name: string, fun: (a: string) => string): [string, Function] {
+    public static ofEntryStringAndStringOutput(
+        name: string,
+        fun: (a: string) => string,
+    ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -264,22 +231,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
             ),
         ];
     }
-    public static ofEntryStringBooleanOutput(
+    public static ofEntryStringAndBooleanOutput(
         name: string,
         fun: (a: string) => boolean,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -302,22 +260,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryAsStringStringIntegerIntegerOutput(
+    public static ofEntryStringStringIntegerAndIntegerOutput(
         name: string,
         fun: (a: string, b: string, c: number) => number,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -349,22 +298,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryAsStringIntegerIntegerStringOutput(
+    public static ofEntryStringIntegerIntegerAndStringOutput(
         name: string,
         fun: (a: string, b: number, c: number) => string,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -391,7 +331,7 @@ export abstract class AbstractStringFunction extends AbstractFunction {
             })(
                 Namespaces.STRING,
                 name,
-                AbstractStringFunction.EVENT_INT,
+                AbstractStringFunction.EVENT_STRING,
                 AbstractStringFunction.PARAMETER_STRING,
                 AbstractStringFunction.PARAMETER_INDEX,
                 AbstractStringFunction.PARAMETER_SECOND_INDEX,
@@ -399,22 +339,13 @@ export abstract class AbstractStringFunction extends AbstractFunction {
         ];
     }
 
-    public static ofEntryAsStringStringStringStringOutput(
+    public static ofEntryStringStringStringAndStringOutput(
         name: string,
         fun: (a: string, b: string, c: string) => string,
     ): [string, Function] {
         return [
             name,
             new (class extends AbstractStringFunction {
-                constructor(
-                    namespace: string,
-                    functionName: string,
-                    event: Event,
-                    ...parameter: Parameter[]
-                ) {
-                    super(namespace, functionName, event, ...parameter);
-                }
-
                 protected async internalExecute(
                     context: FunctionExecutionParameters,
                 ): Promise<FunctionOutput> {
@@ -444,4 +375,33 @@ export abstract class AbstractStringFunction extends AbstractFunction {
             ),
         ];
     }
+
+    public static ofEntryStringAndIntegerOutput(
+        name: string,
+        fun: (a: string) => number,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractStringFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    let s: string = context
+                        ?.getArguments()
+                        ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
+
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(AbstractStringFunction.EVENT_RESULT_NAME, fun(s)),
+                        ),
+                    ]);
+                }
+            })(
+                Namespaces.STRING,
+                name,
+                AbstractStringFunction.EVENT_INT,
+                AbstractStringFunction.PARAMETER_STRING,
+            ),
+        ];
+    }
 }

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

@@ -19,50 +19,69 @@ import { TrimTo } from './TrimTo';
 
 export class StringFunctionRepository implements Repository<Function> {
     private static readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
-        AbstractStringFunction.ofEntryString('Trim', (e) => e.trim()),
-        AbstractStringFunction.ofEntryString('LowerCase', (e) => e.toLocaleLowerCase()),
-        AbstractStringFunction.ofEntryString('UpperCase', (e) => e.toUpperCase()),
-        AbstractStringFunction.ofEntryStringBooleanOutput('IsBlank', (e) => e.trim() === ''),
-        AbstractStringFunction.ofEntryStringBooleanOutput('IsEmpty', (e) => e === ''),
+        AbstractStringFunction.ofEntryStringAndStringOutput('Trim', (e) => e.trim()),
+        AbstractStringFunction.ofEntryStringAndStringOutput('TrimStart', (e) => e.trimStart()),
+        AbstractStringFunction.ofEntryStringAndStringOutput('TrimEnd', (e) => e.trimEnd()),
 
-        AbstractStringFunction.ofEntryAsStringBooleanOutput(
+        AbstractStringFunction.ofEntryStringAndIntegerOutput('Length', (e) => e.length),
+
+        AbstractStringFunction.ofEntryStringStringAndIntegerOutput('Frequency', (a, b) => {
+            let count = 0;
+            let index = a.indexOf(b);
+            while (index != -1) {
+                count++;
+                index = a.indexOf(b, index + 1);
+            }
+            return count;
+        }),
+
+        AbstractStringFunction.ofEntryStringAndStringOutput('LowerCase', (e) =>
+            e.toLocaleLowerCase(),
+        ),
+        AbstractStringFunction.ofEntryStringAndStringOutput('UpperCase', (e) => e.toUpperCase()),
+        AbstractStringFunction.ofEntryStringAndBooleanOutput('IsBlank', (e) => e.trim() === ''),
+        AbstractStringFunction.ofEntryStringAndBooleanOutput('IsEmpty', (e) => e === ''),
+
+        AbstractStringFunction.ofEntryStringStringAndBooleanOutput(
             'Contains',
             (a, b) => a.indexOf(b) != -1,
         ),
-        AbstractStringFunction.ofEntryAsStringBooleanOutput('EndsWith', (a, b) => a.endsWith(b)),
-        AbstractStringFunction.ofEntryAsStringBooleanOutput('StartsWith', (a, b) =>
+        AbstractStringFunction.ofEntryStringStringAndBooleanOutput('EndsWith', (a, b) =>
+            a.endsWith(b),
+        ),
+        AbstractStringFunction.ofEntryStringStringAndBooleanOutput('StartsWith', (a, b) =>
             a.startsWith(b),
         ),
-        AbstractStringFunction.ofEntryAsStringBooleanOutput(
+        AbstractStringFunction.ofEntryStringStringAndBooleanOutput(
             'EqualsIgnoreCase',
             (a, b) => a.toUpperCase() == b.toUpperCase(),
         ),
-        AbstractStringFunction.ofEntryAsStringBooleanOutput('Matches', (a, b) =>
+        AbstractStringFunction.ofEntryStringStringAndBooleanOutput('Matches', (a, b) =>
             new RegExp(b).test(a),
         ),
-        AbstractStringFunction.ofEntryAsStringIntegerOutput('IndexOf', (a, b) => a.indexOf(b)),
-        AbstractStringFunction.ofEntryAsStringIntegerOutput('LastIndexOf', (a, b) =>
-            a.lastIndexOf(b),
+        AbstractStringFunction.ofEntryStringStringAndIntegerOutput('IndexOf', (a, b) =>
+            a.indexOf(b),
         ),
-        AbstractStringFunction.ofEntryAsStringAndIntegerStringOutput('Repeat', (a, b) =>
-            a.repeat(b),
+        AbstractStringFunction.ofEntryStringStringAndIntegerOutput('LastIndexOf', (a, b) =>
+            a.lastIndexOf(b),
         ),
+        AbstractStringFunction.ofEntryStringIntegerAndStringOutput('Repeat', (a, b) => a.repeat(b)),
 
-        AbstractStringFunction.ofEntryAsStringStringIntegerIntegerOutput(
+        AbstractStringFunction.ofEntryStringStringIntegerAndIntegerOutput(
             'IndexOfWithStartPoint',
             (a, b, c) => a.indexOf(b, c),
         ),
-        AbstractStringFunction.ofEntryAsStringStringIntegerIntegerOutput(
+        AbstractStringFunction.ofEntryStringStringIntegerAndIntegerOutput(
             'LastIndexOfWithStartPoint',
             (a, b, c) => a.lastIndexOf(b, c),
         ),
-        AbstractStringFunction.ofEntryAsStringStringStringStringOutput('Replace', (a, b, c) => {
+        AbstractStringFunction.ofEntryStringStringStringAndStringOutput('Replace', (a, b, c) => {
             return a.replaceAll(b, c);
         }),
-        AbstractStringFunction.ofEntryAsStringStringStringStringOutput('ReplaceFirst', (a, b, c) =>
+        AbstractStringFunction.ofEntryStringStringStringAndStringOutput('ReplaceFirst', (a, b, c) =>
             a.replace(b, c),
         ),
-        AbstractStringFunction.ofEntryAsStringIntegerIntegerStringOutput('SubString', (a, b, c) =>
+        AbstractStringFunction.ofEntryStringIntegerIntegerAndStringOutput('SubString', (a, b, c) =>
             a.substring(b, c),
         ),
         mapEntry(new Concatenate()),

package/src/engine/json/schema/SchemaUtil.ts

@@ -149,7 +149,7 @@ export class SchemaUtil {
         let nms = StringUtil.splitAtFirstOccurance(ref ?? '', '/');
         if (!nms[0]) return Promise.resolve(undefined);
 
-        let nmspnm = StringUtil.splitAtFirstOccurance(nms[0], '.');
+        let nmspnm = StringUtil.splitAtLastOccurance(nms[0], '.');
         if (!nmspnm[0] || !nmspnm[1]) return Promise.resolve(undefined);
 
         let schema = await sRepository.find(nmspnm[0], nmspnm[1]);

package/src/engine/repository/KIRunSchemaRepository.ts

@@ -1,7 +1,8 @@
-import { Schema } from '../json/schema/Schema';
+import { AdditionalType, Schema } from '../json/schema/Schema';
 import { Parameter } from '../model/Parameter';
 import { Namespaces } from '../namespaces/Namespaces';
 import { Repository } from '../Repository';
+import { MapUtil } from '../util/MapUtil';
 
 const map: Map<string, Schema> = new Map([
     ['any', Schema.ofAny('any').setNamespace(Namespaces.SYSTEM)],
@@ -12,7 +13,59 @@ const map: Map<string, Schema> = new Map([
     ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
     ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
     ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
-    ['Date.timeStamp', Schema.ofString('timeStamp').setNamespace(Namespaces.DATE)],
+    ['Timestamp', Schema.ofString('Timestamp').setNamespace(Namespaces.DATE)],
+    [
+        'Timeunit',
+        Schema.ofString('Timeunit')
+            .setNamespace(Namespaces.DATE)
+            .setEnums([
+                'YEARS',
+                'QUARTERS',
+                'MONTHS',
+                'WEEKS',
+                'DAYS',
+                'HOURS',
+                'MINUTES',
+                'SECONDS',
+                'MILLISECONDS',
+            ]),
+    ],
+    [
+        'Duration',
+        Schema.ofObject('Duration')
+            .setNamespace(Namespaces.DATE)
+            .setProperties(
+                MapUtil.ofArrayEntries(
+                    ['years', Schema.ofInteger('years')],
+                    ['quarters', Schema.ofInteger('quarters')],
+                    ['months', Schema.ofInteger('months')],
+                    ['weeks', Schema.ofInteger('weeks')],
+                    ['days', Schema.ofInteger('days')],
+                    ['hours', Schema.ofInteger('hours')],
+                    ['minutes', Schema.ofInteger('minutes')],
+                    ['seconds', Schema.ofLong('seconds')],
+                    ['milliseconds', Schema.ofLong('milliseconds')],
+                ),
+            )
+            .setAdditionalItems(AdditionalType.from(false)!),
+    ],
+    [
+        'TimeObject',
+        Schema.ofObject('TimeObject')
+            .setNamespace(Namespaces.DATE)
+            .setProperties(
+                MapUtil.ofArrayEntries(
+                    ['year', Schema.ofInteger('year')],
+                    ['month', Schema.ofInteger('month')],
+                    ['day', Schema.ofInteger('day')],
+                    ['hour', Schema.ofInteger('hour')],
+                    ['minute', Schema.ofInteger('minute')],
+                    ['second', Schema.ofLong('second')],
+                    ['millisecond', Schema.ofLong('millisecond')],
+                ),
+            )
+            .setAdditionalItems(AdditionalType.from(false)!),
+    ],
     [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
     [Schema.NULL.getName()!, Schema.NULL],
     [Schema.SCHEMA.getName()!, Schema.SCHEMA],
@@ -22,7 +75,8 @@ const filterableNames = Array.from(map.values()).map((e) => e.getFullName());
 
 export class KIRunSchemaRepository implements Repository<Schema> {
     public async find(namespace: string, name: string): Promise<Schema | undefined> {
-        if (Namespaces.SYSTEM != namespace) return Promise.resolve(undefined);
+        if (Namespaces.SYSTEM != namespace && Namespaces.DATE != namespace)
+            return Promise.resolve(undefined);
 
         return Promise.resolve(map.get(name));
     }

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

@@ -42,6 +42,18 @@ export class StringUtil {
         return [str.substring(0, index), str.substring(index + 1)];
     }
 
+    public static splitAtLastOccurance(
+        str: string,
+        c: string,
+    ): [string | undefined, string | undefined] {
+        if (!str) return [undefined, undefined];
+
+        let index: number = str.lastIndexOf(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/tsconfig.json

@@ -5,7 +5,6 @@
         "esModuleInterop": true,
         "skipLibCheck": true,
         "forceConsistentCasingInFileNames": true,
-        "lib": ["ES2022"],
-        "target": "ES2022"
+        "lib": ["ES2022"]
     }
 }