@fincity/kirun-js 1.6.17 → 1.8.0

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

@@ -13,7 +13,7 @@ export class Delete extends AbstractArrayFunction {
                 AbstractArrayFunction.PARAMETER_ARRAY_SOURCE,
                 AbstractArrayFunction.PARAMETER_ANY_VAR_ARGS,
             ],
-            AbstractArrayFunction.EVENT_RESULT_EMPTY,
+            AbstractArrayFunction.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -37,7 +37,6 @@ export class Delete extends AbstractArrayFunction {
             );
 
         let indexes = new Set<number>();
-        let duplicateResource: any[] = [];
 
         for (let i: number = source.length - 1; i >= 0; i--) {
             for (let j: number = 0; j < receivedArgs.length; j++) {
@@ -46,10 +45,15 @@ export class Delete extends AbstractArrayFunction {
             }
         }
 
-        duplicateResource = source.filter((value) => !indexes.has(value));
-
-        source.splice(0, source.length, ...duplicateResource);
-
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(
+                new Map([
+                    [
+                        AbstractArrayFunction.EVENT_RESULT_NAME,
+                        source.filter((value) => !indexes.has(value)),
+                    ],
+                ]),
+            ),
+        ]);
     }
 }

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

@@ -6,7 +6,7 @@ import { AbstractArrayFunction } from './AbstractArrayFunction';
 
 export class DeleteFirst extends AbstractArrayFunction {
     public constructor() {
-        super('DeleteFirst', [DeleteFirst.PARAMETER_ARRAY_SOURCE], DeleteFirst.EVENT_RESULT_EMPTY);
+        super('DeleteFirst', [DeleteFirst.PARAMETER_ARRAY_SOURCE], DeleteFirst.EVENT_RESULT_ARRAY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -16,7 +16,10 @@ export class DeleteFirst extends AbstractArrayFunction {
 
         if (source.length == 0) throw new KIRuntimeException('Given source array is empty');
 
+        source = [...source];
         source.shift();
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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

@@ -13,7 +13,7 @@ export class DeleteFrom extends AbstractArrayFunction {
                 DeleteFrom.PARAMETER_INT_SOURCE_FROM,
                 DeleteFrom.PARAMETER_INT_LENGTH,
             ],
-            DeleteFrom.EVENT_RESULT_EMPTY,
+            DeleteFrom.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -32,6 +32,7 @@ export class DeleteFrom extends AbstractArrayFunction {
 
         if (source.length == 0) throw new KIRuntimeException('There are no elements to be deleted');
 
+        source = [...source];
         if (start >= source.length || start < 0)
             throw new KIRuntimeException(
                 'The int source for the array should be in between 0 and length of the array ',
@@ -46,6 +47,8 @@ export class DeleteFrom extends AbstractArrayFunction {
 
         source.splice(start, len);
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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

@@ -6,7 +6,7 @@ import { AbstractArrayFunction } from './AbstractArrayFunction';
 
 export class DeleteLast extends AbstractArrayFunction {
     public constructor() {
-        super('DeleteLast', [DeleteLast.PARAMETER_ARRAY_SOURCE], DeleteLast.EVENT_RESULT_EMPTY);
+        super('DeleteLast', [DeleteLast.PARAMETER_ARRAY_SOURCE], DeleteLast.EVENT_RESULT_ARRAY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -16,8 +16,11 @@ export class DeleteLast extends AbstractArrayFunction {
 
         if (source.length == 0) throw new KIRuntimeException('Given source array is empty');
 
+        source = [...source];
         source.pop();
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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

@@ -74,12 +74,8 @@ export class Disjoint extends AbstractArrayFunction {
             if (!set1.has(element)) set3.add(element);
         });
 
-        let disjointArray: any[] = [];
-
-        set3.forEach((element) => disjointArray.push(element));
-
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[Disjoint.EVENT_RESULT_ARRAY.getName(), disjointArray]])),
+            EventResult.outputOf(new Map([[Disjoint.EVENT_RESULT_NAME, [...set3]]])),
         ]);
     }
 }

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

@@ -4,6 +4,7 @@ import { FunctionOutput } from '../../../model/FunctionOutput';
 import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
 import { MapUtil } from '../../../util/MapUtil';
 import { isNullValue } from '../../../util/NullCheck';
+import { duplicate } from '../../../util/duplicate';
 import { StringFormatter } from '../../../util/string/StringFormatter';
 import { AbstractArrayFunction } from './AbstractArrayFunction';
 
@@ -38,14 +39,17 @@ export class Fill extends AbstractArrayFunction {
 
         let add = srcfrom + length - source.length;
 
+        source = [...source];
         if (add > 0) {
             for (let i = 0; i < add; i++) source.push();
         }
 
         for (let i = srcfrom; i < srcfrom + length; i++) {
-            source[i] = isNullValue(element) ? element : JSON.parse(JSON.stringify(element));
+            source[i] = isNullValue(element) ? element : duplicate(element);
         }
 
-        return new FunctionOutput([EventResult.outputOf(MapUtil.of())]);
+        return new FunctionOutput([
+            EventResult.outputOf(MapUtil.of(AbstractArrayFunction.EVENT_RESULT_NAME, source)),
+        ]);
     }
 }

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

@@ -39,15 +39,12 @@ export class Frequency extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), 0]])),
+                EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_NAME, 0]])),
             ]);
 
         if (start > source.length)
             throw new KIRuntimeException('Given start point is more than the size of source');
 
-        if (isNullValue(find))
-            throw new KIRuntimeException('Given find was null. Hence cannot be found in the array');
-
         let end: number = start + length;
 
         if (length == -1) end = source.length - start;
@@ -62,7 +59,7 @@ export class Frequency extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), frequency]])),
+            EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_NAME, frequency]])),
         ]);
     }
 }

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

@@ -32,7 +32,7 @@ export class IndexOf extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (len < 0 || len > source.length)
@@ -50,7 +50,7 @@ export class IndexOf extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

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

@@ -33,7 +33,7 @@ export class IndexOfArray extends AbstractArrayFunction {
 
         if (source.length == 0 || secondSource.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (from < 0 || from > source.length || source.length < secondSource.length)
@@ -61,7 +61,7 @@ export class IndexOfArray extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

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

@@ -10,7 +10,7 @@ export class Insert extends AbstractArrayFunction {
         super(
             'Insert',
             [Insert.PARAMETER_ARRAY_SOURCE, Insert.PARAMETER_INT_OFFSET, Insert.PARAMETER_ANY],
-            Insert.EVENT_RESULT_EMPTY,
+            Insert.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -28,9 +28,13 @@ export class Insert extends AbstractArrayFunction {
         if (isNullValue(output) || isNullValue(offset) || offset > source.length)
             throw new KIRuntimeException('Please valid resouces to insert at the correct location');
 
+        source = [...source];
+
         if (source.length == 0) {
             if (offset == 0) source.push(output);
-            return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
         }
 
         source.push(output);
@@ -43,6 +47,8 @@ export class Insert extends AbstractArrayFunction {
             source[len--] = temp;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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

@@ -0,0 +1,31 @@
+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 { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class InsertLast extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'InsertLast',
+            [InsertLast.PARAMETER_ARRAY_SOURCE, InsertLast.PARAMETER_ANY],
+            InsertLast.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(InsertLast.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        var output = context?.getArguments()?.get(InsertLast.PARAMETER_ANY.getParameterName());
+
+        source = [...source];
+
+        source.push(output);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
+    }
+}

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

@@ -33,7 +33,7 @@ export class LastIndexOf extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+                EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (len < 0 || len > source.length)
@@ -43,11 +43,6 @@ export class LastIndexOf extends AbstractArrayFunction {
 
         let index: number = -1;
 
-        if (typeof find == null || typeof find == undefined)
-            throw new KIRuntimeException(
-                'Please provide the valid find object or primitive in order to verify',
-            );
-
         for (let i: number = source.length - 1; i >= len; i--) {
             if (PrimitiveUtil.compare(source[i], find) == 0) {
                 index = i;
@@ -56,7 +51,7 @@ export class LastIndexOf extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[LastIndexOf.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

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

@@ -33,9 +33,7 @@ export class LastIndexOfArray extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(
-                    new Map([[LastIndexOfArray.EVENT_RESULT_ARRAY.getName(), -1]]),
-                ),
+                EventResult.outputOf(new Map([[LastIndexOfArray.EVENT_RESULT_NAME, -1]])),
             ]);
 
         if (from < 0 || from > source.length || secondSource.length > source.length)
@@ -62,9 +60,7 @@ export class LastIndexOfArray extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(
-                new Map([[LastIndexOfArray.EVENT_RESULT_INTEGER.getName(), index]]),
-            ),
+            EventResult.outputOf(new Map([[LastIndexOfArray.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

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

@@ -24,8 +24,6 @@ export class Max extends AbstractArrayFunction {
             max = y;
         }
 
-        return new FunctionOutput([
-            EventResult.outputOf(new Map([[Max.EVENT_RESULT_ANY.getName(), max]])),
-        ]);
+        return new FunctionOutput([EventResult.outputOf(new Map([[Max.EVENT_RESULT_NAME, max]]))]);
     }
 }

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

@@ -25,8 +25,6 @@ export class Min extends AbstractArrayFunction {
                 min = source[i];
         }
 
-        return new FunctionOutput([
-            EventResult.outputOf(new Map([[Min.EVENT_RESULT_ANY.getName(), min]])),
-        ]);
+        return new FunctionOutput([EventResult.outputOf(new Map([[Min.EVENT_RESULT_NAME, min]]))]);
     }
 }

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

@@ -60,7 +60,7 @@ export class MisMatch extends AbstractArrayFunction {
         }
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[MisMatch.EVENT_RESULT_INTEGER.getName(), index]])),
+            EventResult.outputOf(new Map([[MisMatch.EVENT_RESULT_NAME, index]])),
         ]);
     }
 }

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

@@ -0,0 +1,64 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { isNullValue } from '../../../util/NullCheck';
+import { deepEqual } from '../../../util/deepEqual';
+import { duplicate } from '../../../util/duplicate';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class RemoveDuplicates extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'RemoveDuplicates',
+            [
+                RemoveDuplicates.PARAMETER_ARRAY_SOURCE,
+                RemoveDuplicates.PARAMETER_INT_SOURCE_FROM,
+                RemoveDuplicates.PARAMETER_INT_LENGTH,
+            ],
+            RemoveDuplicates.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        var source = context
+            ?.getArguments()
+            ?.get(RemoveDuplicates.PARAMETER_ARRAY_SOURCE.getParameterName());
+        var srcfrom = context
+            ?.getArguments()
+            ?.get(RemoveDuplicates.PARAMETER_INT_SOURCE_FROM.getParameterName());
+        var length = context
+            ?.getArguments()
+            ?.get(RemoveDuplicates.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (length == -1) length = source.length - srcfrom;
+
+        if (srcfrom + length > source.length)
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Array has no elements from $ to $ as the array size is $',
+                    srcfrom,
+                    srcfrom + length,
+                    source.length,
+                ),
+            );
+
+        const ja: any[] = [...source];
+        const to = srcfrom + length;
+
+        for (let i = to - 1; i >= srcfrom; i--) {
+            for (let j = i - 1; j >= srcfrom; j--) {
+                if (deepEqual(ja[i], ja[j])) {
+                    ja.splice(i, 1);
+                    break;
+                }
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(MapUtil.of(RemoveDuplicates.EVENT_RESULT_NAME, ja)),
+        ]);
+    }
+}

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

@@ -13,7 +13,7 @@ export class Reverse extends AbstractArrayFunction {
                 Reverse.PARAMETER_INT_SOURCE_FROM,
                 Reverse.PARAMETER_INT_LENGTH,
             ],
-            Reverse.EVENT_RESULT_EMPTY,
+            Reverse.EVENT_RESULT_ARRAY,
         );
     }
 
@@ -37,6 +37,8 @@ export class Reverse extends AbstractArrayFunction {
                 'Please provide start point between the start and end indexes or provide the length which was less than the source size ',
             );
 
+        source = [...source];
+
         let endpoint: number = st + len - 1;
         while (st <= endpoint) {
             let first: any = source[st];
@@ -45,6 +47,8 @@ export class Reverse extends AbstractArrayFunction {
             source[endpoint--] = first;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Reverse.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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_EMPTY,
+            Rotate.EVENT_RESULT_ANY,
         );
     }
 
@@ -21,7 +21,12 @@ export class Rotate extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(Rotate.PARAMETER_ROTATE_LENGTH.getParameterName());
 
-        if (source.length == 0) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
+
+        source = [...source];
 
         let size: number = source.length;
         rotLen = rotLen % size;
@@ -30,7 +35,9 @@ export class Rotate extends AbstractArrayFunction {
         this.rotate(source, rotLen, size - 1);
         this.rotate(source, 0, size - 1);
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 
     private rotate(elements: any[], start: number, end: number): void {

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_EMPTY);
+        super('Shuffle', [Shuffle.PARAMETER_ARRAY_SOURCE], Shuffle.EVENT_RESULT_ANY);
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -13,8 +13,12 @@ export class Shuffle extends AbstractArrayFunction {
             ?.getArguments()
             ?.get(Shuffle.PARAMETER_ARRAY_SOURCE.getParameterName());
 
-        if (source.length <= 1) return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        if (source.length <= 1)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+            ]);
 
+        source = [...source];
         let x: number = 0;
         let size: number = source.length;
 
@@ -26,6 +30,8 @@ export class Shuffle extends AbstractArrayFunction {
             x = y;
         }
 
-        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
+        ]);
     }
 }

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

@@ -15,7 +15,7 @@ export class Sort extends AbstractArrayFunction {
                 Sort.PARAMETER_INT_LENGTH,
                 Sort.PARAMETER_BOOLEAN_ASCENDING,
             ],
-            Sort.EVENT_RESULT_EMPTY,
+            Sort.EVENT_RESULT_ANY,
         );
     }
 
@@ -38,9 +38,10 @@ export class Sort extends AbstractArrayFunction {
 
         if (source.length == 0)
             return new FunctionOutput([
-                EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+                EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
             ]);
 
+        source = [...source];
         if (len == -1) len = source.length - start;
 
         if (start < 0 || start >= source.length || start + len > source.length)
@@ -55,7 +56,7 @@ export class Sort extends AbstractArrayFunction {
         source.splice(start, len, ...slicedArray);
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[Sort.EVENT_RESULT_EMPTY.getName(), source]])),
+            EventResult.outputOf(new Map([[AbstractArrayFunction.EVENT_RESULT_NAME, source]])),
         ]);
     }
 }

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

@@ -42,7 +42,7 @@ export class SubArray extends AbstractArrayFunction {
         let slicedArray: any[] = source.slice(start, start + len);
 
         return new FunctionOutput([
-            EventResult.outputOf(new Map([[SubArray.EVENT_RESULT_ARRAY.getName(), slicedArray]])),
+            EventResult.outputOf(new Map([[SubArray.EVENT_RESULT_NAME, slicedArray]])),
         ]);
     }
 }

package/src/engine/function/system/loop/Break.ts

@@ -0,0 +1,31 @@
+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';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractFunction } from '../../AbstractFunction';
+
+const STEP_NAME = 'stepName';
+
+const SIGNATURE = new FunctionSignature('Break')
+    .setNamespace(Namespaces.SYSTEM_LOOP)
+    .setParameters(new Map([Parameter.ofEntry(STEP_NAME, Schema.of(STEP_NAME, SchemaType.STRING))]))
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([]))]));
+
+export class Break extends AbstractFunction {
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let stepName: string = context.getArguments()?.get(STEP_NAME);
+
+        context.getExecutionContext().set(stepName, true);
+
+        return new FunctionOutput([EventResult.outputOf(new Map())]);
+    }
+}

package/src/engine/function/system/loop/CountLoop.ts

@@ -34,11 +34,17 @@ export class CountLoop extends AbstractFunction {
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let count: number = context.getArguments()?.get(COUNT);
         let current = 0;
+        let statementName = context.getStatementExecution()?.getStatement()?.getStatementName();
 
         return new FunctionOutput({
             next(): EventResult {
-                if (current >= count) {
-                    return EventResult.outputOf(new Map([[VALUE, count]]));
+                if (
+                    current >= count ||
+                    (statementName && context.getExecutionContext()?.get(statementName))
+                ) {
+                    // check for break;
+                    if (statementName) context.getExecutionContext()?.delete(statementName);
+                    return EventResult.outputOf(new Map([[VALUE, current]]));
                 }
 
                 const eve = EventResult.of(Event.ITERATION, new Map([[INDEX, current]]));