@fincity/kirun-js 2.5.0 → 2.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fincity/kirun-js",
-    "version": "2.5.0",
+    "version": "2.8.2",
     "description": "Javascript Runtime for Kinetic Instructions",
     "source": "src/index.ts",
     "main": "dist/index.js",
@@ -31,16 +31,17 @@
     "author": "Kiran Kumar Grandhi",
     "license": "MIT",
     "devDependencies": {
-        "@parcel/packager-ts": "^2.7.0",
+        "@parcel/packager-ts": "^2.12.0",
         "@parcel/transformer-typescript-types": "^2.7.0",
         "@tsconfig/recommended": "^1.0.1",
-        "@types/jest": "^28.1.8",
-        "jest": "^29.5.0",
+        "@types/jest": "^29.5.14",
+        "@types/luxon": "^3.4.2",
+        "jest": "^29.7.0",
         "parcel": "^2.7.0",
         "prettier": "2.7.1",
-        "ts-jest": "^29.1.0",
+        "ts-jest": "^29.2.5",
         "ts-loader": "^9.3.1",
-        "typescript": "^5.1.3"
+        "typescript": "^5.6.3"
     },
     "jest": {
         "transform": {
@@ -52,5 +53,9 @@
             "tsx",
             "js"
         ]
+    },
+    "dependencies": {
+        "@fincity/kirun-js": "file:",
+        "luxon": "^3.5.0"
     }
 }

package/src/engine/function/AbstractFunction.ts

@@ -100,7 +100,7 @@ export abstract class AbstractFunction implements Function {
         );
         context.setArguments(args);
         try {
-            return this.internalExecute(context);
+            return await this.internalExecute(context);
         } catch (err: any) {
             const signature = this.getSignature();
             throw new KIRuntimeException(

package/src/engine/function/system/Print.ts

@@ -1,5 +1,4 @@
 import { Schema } from '../../json/schema/Schema';
-import { SchemaType } from '../../json/schema/type/SchemaType';
 import { Event } from '../../model/Event';
 import { EventResult } from '../../model/EventResult';
 import { FunctionOutput } from '../../model/FunctionOutput';
@@ -11,21 +10,36 @@ import { AbstractFunction } from '../AbstractFunction';
 
 export class Print extends AbstractFunction {
     private static readonly VALUES: string = 'values';
+    private static readonly STREAM: string = 'stream';
+
+    private static readonly LOG: string = 'LOG';
+    private static readonly ERROR: string = 'ERROR';
 
     private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Print')
         .setNamespace(Namespaces.SYSTEM)
         .setParameters(
-            new Map([Parameter.ofEntry(Print.VALUES, Schema.ofAny(Print.VALUES), true)]),
-        );
+            new Map([
+                Parameter.ofEntry(Print.VALUES, Schema.ofAny(Print.VALUES), true),
+                Parameter.ofEntry(
+                    Print.STREAM,
+                    Schema.ofString(Print.STREAM)
+                        .setEnums([Print.LOG, Print.ERROR])
+                        .setDefaultValue(Print.LOG),
+                ),
+            ]),
+        )
+        .setEvents(new Map([Event.outputEventMapEntry(new Map())]));
 
     public getSignature(): FunctionSignature {
         return Print.SIGNATURE;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        var values = context.getArguments()?.get(Print.VALUES);
+        let values = context.getArguments()?.get(Print.VALUES);
+
+        const stream = context.getArguments()?.get(Print.STREAM);
 
-        console?.log(...values);
+        (stream === Print.LOG ? console?.log : console?.error)?.(...values);
 
         return new FunctionOutput([EventResult.outputOf(new Map())]);
     }

package/src/engine/function/system/Wait.ts

@@ -28,7 +28,7 @@ export class Wait extends AbstractFunction {
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        var condition = context.getArguments()?.get(Wait.MILLIS);
+        let condition = context.getArguments()?.get(Wait.MILLIS);
 
         await new Promise((resolve) => setTimeout(resolve, condition));
 

package/src/engine/function/system/array/AbstractArrayFunction.ts

@@ -150,9 +150,9 @@ export abstract class AbstractArrayFunction extends AbstractFunction {
         Schema.ofAny('element'),
     );
 
-    public static readonly PARAMETER_ANY_NOT_NULL: Parameter = Parameter.of(
+    public static readonly PARAMETER_ANY_ELEMENT_OBJECT: Parameter = Parameter.of(
         'elementObject',
-        Schema.ofAnyNotNull('elementObject'),
+        Schema.ofAny('elementObject'),
     );
 
     public static readonly PARAMETER_ANY_VAR_ARGS: Parameter = Parameter.of(
@@ -165,7 +165,7 @@ export abstract class AbstractArrayFunction extends AbstractFunction {
         Schema.ofArray('eachResult', Schema.ofAny('eachResult')),
     );
 
-    private signature: FunctionSignature;
+    private readonly signature: FunctionSignature;
 
     protected constructor(functionName: string, parameters: Parameter[], event: Event) {
         super();

package/src/engine/function/system/array/Fill.ts

@@ -18,7 +18,7 @@ export class Fill extends AbstractArrayFunction {
                 Fill.PARAMETER_INT_LENGTH,
                 Fill.PARAMETER_ANY,
             ],
-            Fill.EVENT_RESULT_EMPTY,
+            Fill.EVENT_RESULT_ARRAY,
         );
     }
 

package/src/engine/function/system/array/Frequency.ts

@@ -2,7 +2,6 @@ import { KIRuntimeException } from '../../../exception/KIRuntimeException';
 import { EventResult } from '../../../model/EventResult';
 import { FunctionOutput } from '../../../model/FunctionOutput';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
-import { isNullValue } from '../../../util/NullCheck';
 import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
 import { AbstractArrayFunction } from './AbstractArrayFunction';
 

package/src/engine/function/system/array/IndexOf.ts

@@ -2,7 +2,6 @@ import { KIRuntimeException } from '../../../exception/KIRuntimeException';
 import { EventResult } from '../../../model/EventResult';
 import { FunctionOutput } from '../../../model/FunctionOutput';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
-import { isNullValue } from '../../../util/NullCheck';
 import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
 import { AbstractArrayFunction } from './AbstractArrayFunction';
 
@@ -12,7 +11,7 @@ export class IndexOf extends AbstractArrayFunction {
             'IndexOf',
             [
                 IndexOf.PARAMETER_ARRAY_SOURCE,
-                IndexOf.PARAMETER_ANY_NOT_NULL,
+                IndexOf.PARAMETER_ANY_ELEMENT_OBJECT,
                 IndexOf.PARAMETER_INT_FIND_FROM,
             ],
             IndexOf.EVENT_RESULT_INTEGER,
@@ -24,7 +23,9 @@ export class IndexOf extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        var find = context?.getArguments()?.get(IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+        let find = context
+            ?.getArguments()
+            ?.get(IndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName());
 
         let len: number = context
             ?.getArguments()
@@ -34,7 +35,6 @@ export class IndexOf extends AbstractArrayFunction {
             return new FunctionOutput([
                 EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
-
         if (len < 0 || len > source.length)
             throw new KIRuntimeException(
                 'The size of the search index of the array is greater than the size of the array',

package/src/engine/function/system/array/LastIndexOf.ts

@@ -11,7 +11,7 @@ export class LastIndexOf extends AbstractArrayFunction {
             'LastIndexOf',
             [
                 LastIndexOf.PARAMETER_ARRAY_SOURCE,
-                LastIndexOf.PARAMETER_ANY_NOT_NULL,
+                LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT,
                 LastIndexOf.PARAMETER_INT_FIND_FROM,
             ],
             LastIndexOf.EVENT_RESULT_INTEGER,
@@ -23,9 +23,9 @@ export class LastIndexOf extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(LastIndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        var find = context
+        let find = context
             ?.getArguments()
-            ?.get(LastIndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+            ?.get(LastIndexOf.PARAMETER_ANY_ELEMENT_OBJECT.getParameterName());
 
         let len = context
             ?.getArguments()

package/src/engine/function/system/array/Rotate.ts

@@ -8,7 +8,7 @@ export class Rotate extends AbstractArrayFunction {
         super(
             'Rotate',
             [Rotate.PARAMETER_ARRAY_SOURCE, Rotate.PARAMETER_ROTATE_LENGTH],
-            Rotate.EVENT_RESULT_ANY,
+            Rotate.EVENT_RESULT_ARRAY,
         );
     }
 

package/src/engine/function/system/array/Shuffle.ts

@@ -5,7 +5,7 @@ import { AbstractArrayFunction } from './AbstractArrayFunction';
 
 export class Shuffle extends AbstractArrayFunction {
     public constructor() {
-        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ANY);
+        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ARRAY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/array/Sort.ts

@@ -17,7 +17,7 @@ export class Sort extends AbstractArrayFunction {
                 Sort.PARAMETER_BOOLEAN_ASCENDING,
                 Sort.PARAMETER_KEY_PATH,
             ],
-            Sort.EVENT_RESULT_ANY,
+            Sort.EVENT_RESULT_ARRAY,
         );
     }
 

package/src/engine/function/system/date/AbstractDateFunction.ts

@@ -1,54 +1,61 @@
-import { Schema } from "../../../json/schema/Schema";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Event } from "../../../model/Event";
-import { Parameter } from "../../../model/Parameter";
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { MapUtil } from "../../../util/MapUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { EventResult } from "../../../model/EventResult";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { Function } from "../../../../engine/function/Function";
+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';
+import { Function } from '../../Function';
 
 export abstract class AbstractDateFunction extends AbstractFunction {
+    private readonly signature: FunctionSignature;
 
-    private signature: FunctionSignature;
+    public static readonly PARAMETER_TIMESTAMP_NAME: string = 'isoTimeStamp';
 
-    public static readonly EVENT_RESULT_NAME: string = 'result';
-
-    public static readonly PARAMETER_DATE_NAME: string = 'isoDate';
+    public static readonly PARAMETER_TIMESTAMP_NAME_ONE: string = 'isoTimeStamp1';
+    public static readonly PARAMETER_TIMESTAMP_NAME_TWO: string = 'isoTimeStamp2';
 
-    public static readonly PARAMETER_FIELD_NAME: string = 'value';
+    public static readonly PARAMETER_UNIT_NAME: string = 'unit';
 
-    public static readonly PARAMETER_INT_NAME: string = "intValue";
+    public static readonly PARAMETER_NUMBER_NAME: string = 'number';
 
-	public static readonly PARAMETER_UNIT_NAME: string  = "unit";
-    
-    protected static readonly PARAMETER_DATE: Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_DATE_NAME,
-        Schema.ofString(this.PARAMETER_DATE_NAME).setRef(Namespaces.DATE + ".timeStamp")
+    public static readonly PARAMETER_TIMESTAMP: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_FIELD : Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_FIELD_NAME,
-        Schema.ofInteger(this.PARAMETER_FIELD_NAME)
+    public static readonly PARAMETER_TIMESTAMP_ONE: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_INT : Parameter = new Parameter(
-        AbstractDateFunction.PARAMETER_INT_NAME,
-        Schema.ofInteger(this.PARAMETER_INT_NAME)
+    public static readonly PARAMETER_TIMESTAMP_TWO: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO,
+        Schema.ofRef(Namespaces.DATE + '.Timestamp'),
     );
 
-    protected static readonly PARAMETER_UNIT : Parameter = new Parameter(
+    public static readonly PARAMETER_VARIABLE_UNIT: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_UNIT_NAME,
+        Schema.ofRef(Namespaces.DATE + '.Timeunit'),
+    ).setVariableArgument(true);
+
+    public static readonly PARAMETER_UNIT: Parameter = new Parameter(
         AbstractDateFunction.PARAMETER_UNIT_NAME,
-        Schema.ofString(this.PARAMETER_UNIT_NAME)
-        .setEnums(["YEAR" , "MONTH" , "DAY" , "HOUR" , "MINUTE" , "SECOND" , "MILLISECOND"])
+        Schema.ofRef(Namespaces.DATE + '.Timeunit'),
     );
 
-    protected static readonly EVENT_INT: Event = new Event(
+    public static readonly PARAMETER_NUMBER: Parameter = new Parameter(
+        AbstractDateFunction.PARAMETER_NUMBER_NAME,
+        Schema.ofInteger(AbstractDateFunction.PARAMETER_NUMBER_NAME),
+    );
+
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+    public static readonly EVENT_TIMESTAMP_NAME: string = 'isoTimeStamp';
+
+    public static readonly EVENT_INT: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
@@ -56,107 +63,218 @@ export abstract class AbstractDateFunction extends AbstractFunction {
         ),
     );
 
-    protected static readonly EVENT_BOOLEAN: Event = new Event(
+    public static readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_RESULT_NAME,
+            Schema.ofString(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_LONG: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
-            Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME)
-        )
+            Schema.ofLong(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
     );
 
-    protected static readonly EVENT_DATE : Event = new Event(
+    protected static readonly EVENT_BOOLEAN: Event = new Event(
         Event.OUTPUT,
         MapUtil.of(
             AbstractDateFunction.EVENT_RESULT_NAME,
-            Schema.ofString(AbstractDateFunction.EVENT_RESULT_NAME).setRef(Namespaces.DATE + ".timeStamp")
-        )
-    ); 
+            Schema.ofBoolean(AbstractDateFunction.EVENT_RESULT_NAME),
+        ),
+    );
+
+    public static readonly EVENT_TIMESTAMP: Event = new Event(
+        Event.OUTPUT,
+        MapUtil.of(
+            AbstractDateFunction.EVENT_TIMESTAMP_NAME,
+            Schema.ofRef(Namespaces.DATE + '.Timestamp'),
+        ),
+    );
 
     public getSignature(): FunctionSignature {
         return this.signature;
     }
 
-
-    constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-
+    constructor(functionName: string, event: Event, ...parameter: Parameter[]) {
         super();
-        const paramMap: Map<string, Parameter> = new Map();
-        parameter.forEach((e) => paramMap.set(e.getParameterName(), e));
 
         this.signature = new FunctionSignature(functionName)
-            .setNamespace(namespace)
-            .setParameters(paramMap)
+            .setNamespace(Namespaces.DATE)
             .setEvents(MapUtil.of(event.getName(), event));
 
-    }
-
-    public static ofEntryDateAndBooleanOutput(name: string, fun: ( date : string) => boolean) : [string, Function] {
-    
-        return [name, new (class extends AbstractDateFunction {
-
-            constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                super(namespace, functionName, event, ...parameter);
-            }
-
-            protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-                
-                const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-                
-                if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                    throw new KIRuntimeException("Please provide a valid date.");
-
-                return new FunctionOutput([EventResult.outputOf(MapUtil.of(AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))]);
+        if (!parameter?.length) return;
 
-            }
-
-
-        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_DATE)];
+        const paramMap: Map<string, Parameter> = new Map();
+        parameter.forEach((e) => paramMap.set(e.getParameterName(), e));
+        this.signature.setParameters(paramMap);
     }
 
-    public static ofEntryDateAndIntegerOutput(name: string, fun: (date: string) => number) : [string, Function] {
-        
-        return [name, new (class extends AbstractDateFunction {
-            constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                super(namespace, functionName, event, ...parameter);
-            }
-
-            protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-                const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-
-                if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                    throw new KIRuntimeException("Please provide a valid date object");
-
-                return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, fun(date)))])
-            }
-        })(Namespaces.DATE, name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_DATE)];
+    public static ofEntryTimestampAndIntegerOutput(
+        name: string,
+        fun: (isoTimestamp: string) => number,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(name, AbstractDateFunction.EVENT_INT, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
     }
 
-    public static ofEntryDateWithIntegerUnitWithOutputName( functionName: string, 
-        func: (date: string, amount: number, unit: string) => string): [string, Function] {
-            return [functionName, new (class extends AbstractDateFunction {
-                constructor(namespace: string, functionName: string, event: Event, ...parameter: Parameter[]) {
-                    super(namespace, functionName, event, ...parameter);
+    public static ofEntryTimestampAndBooleanOutput(
+        name: string,
+        fun: (isoTimestamp: string) => boolean,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
                 }
+            })(name, AbstractDateFunction.EVENT_BOOLEAN, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
+    }
 
-                protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-                    const date = context.getArguments()?.get(AbstractDateFunction.PARAMETER_DATE_NAME);
-    
-                    if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-                        throw new KIRuntimeException("Please provide a valid date object");
-
-                    const value = context.getArguments()?.get(AbstractDateFunction.PARAMETER_INT_NAME);
-
-                    const unit = context.getArguments()?.get(AbstractDateFunction.PARAMETER_UNIT_NAME);
-    
-                    return new FunctionOutput([EventResult.outputOf(MapUtil.of( AbstractDateFunction.EVENT_RESULT_NAME, func(date, value , unit)))]);
-
+    public static ofEntryTimestampAndStringOutput(
+        name: string,
+        fun: (isoTimestamp: string) => string,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
                 }
-            })(Namespaces.DATE, functionName, AbstractDateFunction.EVENT_DATE,
-                 AbstractDateFunction.PARAMETER_DATE, AbstractDateFunction.PARAMETER_INT, AbstractDateFunction.PARAMETER_UNIT)];
+            })(name, AbstractDateFunction.EVENT_STRING, AbstractDateFunction.PARAMETER_TIMESTAMP),
+        ];
+    }
 
-          
-        }
+    public static ofEntryTimestampIntegerAndTimestampOutput(
+        name: string,
+        fun: (isoTimestamp: string, integer: number) => string,
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME),
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_NUMBER_NAME),
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(
+                name,
+                AbstractDateFunction.EVENT_INT,
+                AbstractDateFunction.PARAMETER_TIMESTAMP,
+                AbstractDateFunction.PARAMETER_NUMBER,
+            ),
+        ];
+    }
 
-}
+    public static ofEntryTimestampTimestampAndTOutput<T>(
+        name: string,
+        event: Event,
+        fun: (ts1: string, ts2: string, ...parameters: any[]) => T,
+        ...parameters: Parameter[]
+    ): [string, Function] {
+        return [
+            name,
+            new (class extends AbstractDateFunction {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
+                    const args = [];
+
+                    if (parameters?.length) {
+                        args.push(
+                            ...parameters.map((e) =>
+                                context.getArguments()?.get(e.getParameterName()),
+                            ),
+                        );
+                    }
+
+                    return new FunctionOutput([
+                        EventResult.outputOf(
+                            MapUtil.of(
+                                AbstractDateFunction.EVENT_RESULT_NAME,
+                                fun(
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_ONE),
+                                    context
+                                        .getArguments()
+                                        ?.get(AbstractDateFunction.PARAMETER_TIMESTAMP_NAME_TWO),
+                                    args,
+                                ),
+                            ),
+                        ),
+                    ]);
+                }
+            })(
+                name,
+                event,
+                AbstractDateFunction.PARAMETER_TIMESTAMP_ONE,
+                AbstractDateFunction.PARAMETER_TIMESTAMP_TWO,
+                ...parameters,
+            ),
+        ];
+    }
+}