@fincity/kirun-js 2.5.0 → 2.8.2

package/__tests__/engine/function/system/date/SubtractTimeTest.ts

@@ -1,95 +0,0 @@
-import { FunctionExecutionParameters, KIRunFunctionRepository, KIRunSchemaRepository, Namespaces } from "../../../../../src";
-import { AbstractDateFunction } from "../../../../../src/engine/function/system/date/AbstractDateFunction";
-import { DateFunctionRepository } from "../../../../../src/engine/function/system/date/DateFunctionRepository";
-
-
-const dfr : DateFunctionRepository = new DateFunctionRepository();
-
-const fep : FunctionExecutionParameters = new FunctionExecutionParameters(
-    new KIRunFunctionRepository(),
-    new KIRunSchemaRepository());
-
-test('check for invalid dates', async () => {
-
-    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
-
-    if (!subtractTimeFunction) {
-        throw new Error("Function not found");
-    }
-   
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2029-15-05T06:04:18.073Z'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
-    ]));
-
-    await expect( () => subtractTimeFunction.execute(fep)).rejects.toThrow();
-});
-
-test('Subtract Time 1', async () => {
-
-    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
-
-    if (!subtractTimeFunction) {
-        throw new Error("Function not found");
-    }
-    
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 10],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MINUTE']
-    ]));
-
-    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:42:34.633-05:30');
-});
-
-test('Subtract Time 2', async () => {
-
-    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
-
-    if (!subtractTimeFunction) {
-        throw new Error("Function not found");
-    }
-    
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 13],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'MONTH']
-    ]));
-
-    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2023-08-13T23:52:34.633-05:30');
-});
-
-test('Subtract Time 3', async () => {
-
-    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
-
-    if (!subtractTimeFunction) {
-        throw new Error("Function not found");
-    }
-    
-    fep.setArguments(new Map<string, any>([
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 70],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'SECOND']
-    ]));
-
-    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2024-09-13T23:51:24.633-05:30');
-});
-
-test('Subtract Time 4', async () => {
-
-    const subtractTimeFunction = await dfr.find(Namespaces.DATE, 'SubtractTime');
-
-    if (!subtractTimeFunction) {
-        throw new Error("Function not found");
-    }
-    
-    fep.setArguments(new Map<string, any>([ 
-        [AbstractDateFunction.PARAMETER_DATE_NAME, '2024-09-13T23:52:34.633-05:30'],
-        [AbstractDateFunction.PARAMETER_INT_NAME, 5],
-        [AbstractDateFunction.PARAMETER_UNIT_NAME, 'YEAR']
-    ]));
-
-    expect((await subtractTimeFunction.execute(fep)).allResults()[0].getResult().get('result')).toBe('2019-09-13T23:52:34.633-05:30');
-});

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

@@ -1,39 +0,0 @@
-import { Schema } from "../../../json/schema/Schema";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Event } from '../../../model/Event';
-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 { isNullValue } from "../../../util/NullCheck";
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { EventResult } from "../../../model/EventResult";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-
-const OUTPUT : string = "result";
-
-const VALUE : string = "isoDate";
-
-export class DateToEpoch extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-
-        return  new FunctionSignature('DateToEpoch')
-        .setNamespace(Namespaces.DATE)
-        .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE,Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
-        .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT, Schema.ofLong(OUTPUT)]]))]));
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-        var date = context.getArguments()?.get(VALUE);
-
-        if(isNullValue(date) || !ValidDateTimeUtil.validate(date))
-            throw new KIRuntimeException("Please provide a valid date object");
-
-        const epochMillis = new Date(date).getTime();
-        return new FunctionOutput([ EventResult.of(OUTPUT , MapUtil.of( OUTPUT  , epochMillis))]);
-    }
-}

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

@@ -1,45 +0,0 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { Schema } from "../../../json/schema/Schema";
-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 { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-
-const DATE_ONE: string = "isoDateOne";
-const DATE_TWO: string = "isoDateTwo";
-const OUTPUT: string = "result";
-
-const SIGNATURE: FunctionSignature = new FunctionSignature('DifferenceOfTimestamps')
-    .setNamespace(Namespaces.DATE)
-    .setParameters(
-        new Map([
-            [DATE_ONE, new Parameter(DATE_ONE, Schema.ofString(DATE_ONE).setRef(Namespaces.DATE+".timeStamp"))],
-            [DATE_TWO, new Parameter(DATE_TWO, Schema.ofString(DATE_TWO).setRef(Namespaces.DATE+".timeStamp"))]
-        ])
-    );;
-
-export class DifferenceOfTimestamps extends AbstractFunction {
-
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-        const firstDate:string = context?.getArguments()?.get(DATE_ONE);
-        const secondDate:string = context?.getArguments()?.get(DATE_TWO);
-
-        if(!ValidDateTimeUtil.validate(firstDate) || !ValidDateTimeUtil.validate(secondDate)) 
-            throw new KIRuntimeException("Please provide valid ISO date for both the given dates.");
-
-        const fDate: Date = new Date(firstDate);
-        const sDate: Date = new Date(secondDate);
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, (sDate.getTime() - fDate.getTime())/60000]]))]);
-    }
-
-}

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

@@ -1,76 +0,0 @@
-import { Schema } from "../../../json/schema/Schema";
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Event } from '../../../model/Event';
-import { Parameter } from "../../../model/Parameter";
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { AbstractFunction } from "../../AbstractFunction";
-import { isNullValue } from "../../../util/NullCheck";
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { EventResult } from "../../../model/EventResult";
-
-
-const VALUE = 'epoch';
-const OUTPUT = 'date';
-const  ERROR_MSG: string = "Please provide a valid value for epoch.";
-
-const SIGNATURE = new FunctionSignature('EpochToDate')
-    .setNamespace(Namespaces.DATE)
-    .setParameters(
-        new Map([
-            [
-                VALUE,
-                new Parameter(
-                    VALUE,
-                    new Schema().setAnyOf([
-                        Schema.ofInteger(VALUE),
-                        Schema.ofLong(VALUE),
-                        Schema.ofString(VALUE),
-                    ]),
-                ),
-            ],
-        ]),
-    )
-    .setEvents(
-        new Map([
-            Event.outputEventMapEntry(
-                new Map([[OUTPUT, Schema.ofRef(`${Namespaces.DATE}.timeStamp`)]]),
-            ),
-        ]),
-    );
-
-export class EpochToDate extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-      return SIGNATURE;
-    }
-    
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-
-       var epoch : any =  context.getArguments()?.get(VALUE);
-
-       if(isNullValue(epoch))
-        throw new KIRuntimeException(ERROR_MSG);
-
-       if(typeof epoch === 'boolean')
-            throw new KIRuntimeException(ERROR_MSG);
-
-       if(typeof epoch === 'string')
-            epoch  = parseInt(epoch)
-
-       if(isNaN(epoch))
-        throw new KIRuntimeException(ERROR_MSG);
-
-       epoch = epoch > 999999999999 ? epoch : epoch * 1000;
-
-      
-       return new FunctionOutput([
-           EventResult.outputOf(new Map([
-            [OUTPUT, new Date(epoch).toISOString()]
-            ]))
-       ]);
-
-    }
-    
-}

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

@@ -1,36 +0,0 @@
-import { FunctionOutput } from "../../../model/FunctionOutput";
-import { FunctionSignature } from "../../../model/FunctionSignature";
-import { Event } from '../../../model/Event';
-import { Namespaces } from "../../../namespaces/Namespaces";
-import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
-import { AbstractFunction } from "../../AbstractFunction";
-import { Schema } from "../../../json/schema/Schema";
-import { EventResult } from "../../../model/EventResult";
-
-
-const OUTPUT = 'date';
-
-const SIGNATURE: FunctionSignature = new FunctionSignature("GetCurrentTimeStamp")
-                                        .setNamespace(Namespaces.DATE)
-                                        .setParameters(new Map([]))
-                                        .setEvents(new Map([
-                                            Event.outputEventMapEntry(
-                                                new Map([[OUTPUT, Schema.ofRef(`${Namespaces.DATE}.timeStamp`)]]),
-                                            ),
-                                        ]));
-
-export class GetCurrentTimeStamp extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-
-        return SIGNATURE;        
-    }
-    
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        
-        const date : string = new Date(Date.now()).toISOString();
-        
-        return new FunctionOutput([EventResult.of(OUTPUT, new Map([ [OUTPUT, date]]))]);
-    }
-}

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

@@ -1,48 +0,0 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { ArraySchemaType } from "../../../json/schema/array/ArraySchemaType";
-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 { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-
-
-const VALUE:string = "isoDate";
-
-const OUTPUT:string = "result";
-
-const SIGNATURE = new FunctionSignature('GetTimeAsArray')
-    .setNamespace(Namespaces.DATE)
-    .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT , Schema.ofArray(OUTPUT).setItems(ArraySchemaType.of(Schema.ofNumber("number")))]]))]))
-
-
-export class GetTimeAsArray extends AbstractFunction{
-    
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
-    }
-    
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-         
-        var inputDate = context.getArguments()?.get(VALUE);
-
-        if(isNullValue(inputDate) || !ValidDateTimeUtil.validate(inputDate))
-            throw new KIRuntimeException("Please provide a valid date object");
-
-        const date = new Date(inputDate);
-
-        const outputArray = [ date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()
-            , date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()];
-        
-        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT , outputArray]]))]);
-    }
-
-}

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

@@ -1,66 +0,0 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { ArraySchemaType } from "../../../json/schema/array/ArraySchemaType";
-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 { isNullValue } from "../../../util/NullCheck";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-
-
-const VALUE:string = "isoDate";
-
-const OUTPUT:string = "result";
-
-const SIGNATURE = new FunctionSignature('GetTimeAsObject')
-    .setNamespace(Namespaces.DATE)
-    .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT , 
-        Schema.ofObject(OUTPUT).setProperties(new Map(
-            [
-                ["year", Schema.ofNumber("year")],
-                ["month", Schema.ofNumber("month")],
-                ["day", Schema.ofNumber("day")],
-                ["hours", Schema.ofNumber("hours")],
-                ["minutes", Schema.ofNumber("minutes")],
-                ["seconds", Schema.ofNumber("seconds")],
-                ["milliseconds", Schema.ofNumber("milliseconds")]
-            ]
-        ))]]))])); 
-
-
-export class GetTimeAsObject extends AbstractFunction{
-    
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
-    }
-    
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-         
-        var inputDate = context.getArguments()?.get(VALUE);
-
-        if(isNullValue(inputDate) || !ValidDateTimeUtil.validate(inputDate))
-            throw new KIRuntimeException("Please provide a valid date object");
-
-        const date = new Date(inputDate);
-
-        const outputObject = {
-            year: date.getUTCFullYear(),
-            month: date.getUTCMonth() + 1,
-            day: date.getUTCDate(),
-            hours: date.getUTCHours(),
-            minutes: date.getUTCMinutes(),
-            seconds: date.getUTCSeconds(),
-            milliseconds: date.getUTCMilliseconds()
-        };
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT , outputObject]]))]);
-    }
-
-}

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

@@ -1,73 +0,0 @@
-import { Schema } from "../../../json/schema/Schema";
-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 { AbstractFunction } from "../../AbstractFunction";
-import { Event } from "../../../model/Event";
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { EventResult } from "../../../model/EventResult";
-
-const VALUE = "isoDates";
-
-const OUTPUT = "result";
-
-const ERROR_MESSAGE = "Please provide a valid date";
-
-
-
-const SIGNATURE : FunctionSignature = new FunctionSignature('MaximumTimestamp')
-    .setNamespace(Namespaces.DATE)
-    .setParameters(new Map([[VALUE, Parameter.of(VALUE, Schema.ofString(VALUE).setRef(Namespaces.DATE + ".timeStamp")).setVariableArgument(true)]]))
-    .setEvents(new Map([[OUTPUT, new Event(OUTPUT, new Map([[OUTPUT, Schema.ofString(OUTPUT).setRef(Namespaces.DATE + ".timeStamp")]]))]]));
-
-export class MaximumTimestamp extends AbstractFunction {
-
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        
-        const dates = context?.getArguments()?.get(VALUE);
-
-        const size = dates.length;
-
-        if(size === 0){
-            throw new KIRuntimeException(ERROR_MESSAGE)
-        }
-
-        else if (size == 1) {
-
-            const firstDate: string = dates[0];
-
-            if (!ValidDateTimeUtil.validate(firstDate))
-
-                throw new KIRuntimeException(ERROR_MESSAGE);
-
-            return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, firstDate]]))]);
-        }
-
-        let maxIndex: number = 0;
-        let max : number = new Date(dates[0]).getTime();
-
-        for(let i=1;i<size;i++){
-
-            const date: string = dates[i];
-
-            if(!ValidDateTimeUtil.validate(date))
-                throw new KIRuntimeException(ERROR_MESSAGE);
-            
-            const current: number = new Date(date).getTime();
-
-            if(current > max){
-                max = current;
-                maxIndex = i;
-            }
-        }
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, dates[maxIndex]]]))]);
-    }
-}

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

@@ -1,74 +0,0 @@
-import { KIRuntimeException } from "../../../exception/KIRuntimeException";
-import { Schema } from "../../../json/schema/Schema";
-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 { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
-import { AbstractFunction } from "../../AbstractFunction";
-import { EventResult } from "../../../model/EventResult";
-import { Event } from "../../../model/Event";
-
-
-
-const VALUE: string = "isoDates";
-
-const OUTPUT: string = "result";
-
-const ERROR_MESSAGE: string = "Please provide a valid date";
-
-const SIGNATURE : FunctionSignature = new FunctionSignature('MinimumTimestamp')
-        .setNamespace(Namespaces.DATE)
-        .setParameters(new Map([[VALUE, Parameter.of(VALUE, Schema.ofString(VALUE).setRef(Namespaces.DATE + ".timeStamp")).setVariableArgument(true)]]))
-        .setEvents(new Map([[OUTPUT , new Event(OUTPUT, new Map([[OUTPUT, Schema.ofString(OUTPUT).setRef(Namespaces.DATE + ".timeStamp")]]))]]));
-
-export class MinimumTimestamp extends AbstractFunction{
-
-    public getSignature(): FunctionSignature {
-        return SIGNATURE;
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-           
-        const dates = context?.getArguments()?.get(VALUE);
-
-        const size = dates.length;
-
-        if(size === 0){
-            throw new KIRuntimeException(ERROR_MESSAGE)
-        }
-
-        else if (size == 1) {
-
-            const firstDate: string = dates[0];
-
-            if (!ValidDateTimeUtil.validate(firstDate))
-
-                throw new KIRuntimeException(ERROR_MESSAGE);
-
-            return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, firstDate]]))]);
-        }
-
-        let minIndex: number = 0;
-        let min : number = new Date(dates[0]).getTime();
-
-        for(let i=1;i<size;i++){
-
-            const date: string = dates[i];
-
-            if(!ValidDateTimeUtil.validate(date))
-                throw new KIRuntimeException(ERROR_MESSAGE);
-            
-            const current: number = new Date(date).getTime();
-
-            if(current < min){
-                min = current;
-                minIndex = i;
-            }
-        }
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, dates[minIndex]]]))]);
-    }
-
-}

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

@@ -1,56 +0,0 @@
-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 RandomFloat extends AbstractFunction {
-    public static readonly MIN_VALUE = 'minValue';
-
-    public static readonly MAX_VALUE = 'maxValue';
-
-    public static readonly VALUE = 'value';
-
-    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('RandomFloat')
-        .setParameters(
-            MapUtil.of(
-                RandomFloat.MIN_VALUE,
-                Parameter.of(
-                    RandomFloat.MIN_VALUE,
-                    Schema.ofFloat(RandomFloat.MIN_VALUE).setDefaultValue(0),
-                ),
-                RandomFloat.MAX_VALUE,
-                Parameter.of(
-                    RandomFloat.MAX_VALUE,
-                    Schema.ofFloat(RandomFloat.MAX_VALUE).setDefaultValue(2147483647),
-                ),
-            ),
-        )
-        .setNamespace(Namespaces.MATH)
-        .setEvents(
-            new Map<string, Event>([
-                Event.outputEventMapEntry(
-                    MapUtil.of(RandomFloat.VALUE, Schema.ofFloat(RandomFloat.VALUE)),
-                ),
-            ]),
-        );
-
-    public getSignature(): FunctionSignature {
-        return RandomFloat.SIGNATURE;
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        let min: number = context.getArguments()?.get(RandomFloat.MIN_VALUE);
-
-        let max: number = context.getArguments()?.get(RandomFloat.MAX_VALUE);
-
-        let num: number = Math.random() * (max - min) + min;
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[RandomFloat.VALUE, num]]))]);
-    }
-}

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

@@ -1,56 +0,0 @@
-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 RandomInt extends AbstractFunction {
-    public static readonly MIN_VALUE = 'minValue';
-
-    public static readonly MAX_VALUE = 'maxValue';
-
-    public static readonly VALUE = 'value';
-
-    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('RandomInt')
-        .setParameters(
-            MapUtil.of(
-                RandomInt.MIN_VALUE,
-                Parameter.of(
-                    RandomInt.MIN_VALUE,
-                    Schema.ofInteger(RandomInt.MIN_VALUE).setDefaultValue(0),
-                ),
-                RandomInt.MAX_VALUE,
-                Parameter.of(
-                    RandomInt.MAX_VALUE,
-                    Schema.ofInteger(RandomInt.MAX_VALUE).setDefaultValue(2147483647),
-                ),
-            ),
-        )
-        .setNamespace(Namespaces.MATH)
-        .setEvents(
-            new Map<string, Event>([
-                Event.outputEventMapEntry(
-                    MapUtil.of(RandomInt.VALUE, Schema.ofInteger(RandomInt.VALUE)),
-                ),
-            ]),
-        );
-
-    public getSignature(): FunctionSignature {
-        return RandomInt.SIGNATURE;
-    }
-
-    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
-        let min: number = context.getArguments()?.get(RandomInt.MIN_VALUE);
-
-        let max: number = context.getArguments()?.get(RandomInt.MAX_VALUE);
-
-        let num: number = Math.floor(Math.random() * (max - min) + min);
-
-        return new FunctionOutput([EventResult.outputOf(new Map([[RandomInt.VALUE, num]]))]);
-    }
-}