@fincity/kirun-js 1.0.0

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

@@ -0,0 +1,72 @@
+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 { AbstractFunction } from '../../AbstractFunction';
+
+export class InsertAtGivenPosition extends AbstractFunction {
+    public static readonly PARAMETER_STRING_NAME: string = 'string';
+
+    public static readonly PARAMETER_AT_POSITION_NAME: string = 'position';
+
+    public static readonly PARAMETER_INSERT_STRING_NAME: string = 'insertString';
+
+    protected readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected readonly PARAMETER_STRING: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_STRING_NAME,Schema.ofString(InsertAtGivenPosition.PARAMETER_STRING_NAME));
+
+    protected readonly PARAMETER_AT_POSITION: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME,Schema.ofInteger(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME));
+
+    protected readonly PARAMETER_INSERT_STRING: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME,Schema.ofString(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME));
+
+    protected readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
+            new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
+        );
+
+    private signature: FunctionSignature = new FunctionSignature('InsertAtGivenPosition')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [this.PARAMETER_STRING.getParameterName(), this.PARAMETER_STRING],
+                [this.PARAMETER_AT_POSITION.getParameterName(), this.PARAMETER_AT_POSITION],
+                [this.PARAMETER_INSERT_STRING.getParameterName(), this.PARAMETER_INSERT_STRING],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
+                ),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let inputString: string = context
+            ?.getArguments()
+            ?.get(InsertAtGivenPosition.PARAMETER_STRING_NAME);
+        let at: number = context
+            ?.getArguments()
+            ?.get(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME);
+        let insertString: string = context
+            ?.getArguments()
+            ?.get(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME);
+
+        let outputString: string = '';
+
+        outputString += inputString.substring(0, at);
+        outputString += insertString;
+        outputString += inputString.substring(at);
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[this.EVENT_RESULT_NAME, outputString]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,83 @@
+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 { AbstractFunction } from '../../AbstractFunction';
+
+export class PostPad extends AbstractFunction {
+    protected static readonly PARAMETER_STRING_NAME: string = 'string';
+
+    protected static readonly PARAMETER_POSTPAD_STRING_NAME: string = 'postpadString';
+
+    protected static readonly PARAMETER_LENGTH_NAME: string = 'length';
+
+    protected static readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected static PARAMETER_STRING: Parameter =new Parameter(PostPad.PARAMETER_STRING_NAME,Schema.ofString(PostPad.PARAMETER_STRING_NAME));
+
+    protected static PARAMETER_POSTPAD_STRING: Parameter =new Parameter(PostPad.PARAMETER_POSTPAD_STRING_NAME,Schema.ofString(PostPad.PARAMETER_POSTPAD_STRING_NAME));
+
+    protected static PARAMETER_LENGTH: Parameter =new Parameter(PostPad.PARAMETER_LENGTH_NAME,Schema.ofInteger(PostPad.PARAMETER_LENGTH_NAME));
+
+    protected static EVENT_STRING: Event =new Event(Event.OUTPUT,
+            new Map([[PostPad.EVENT_RESULT_NAME, Schema.ofString(PostPad.EVENT_RESULT_NAME)]]),
+        );
+
+    private signature: FunctionSignature = new FunctionSignature('PostPad')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [PostPad.PARAMETER_STRING.getParameterName(), PostPad.PARAMETER_STRING],
+                [
+                    PostPad.PARAMETER_POSTPAD_STRING.getParameterName(),
+                    PostPad.PARAMETER_POSTPAD_STRING,
+                ],
+                [PostPad.PARAMETER_LENGTH.getParameterName(), PostPad.PARAMETER_LENGTH],
+            ]),
+        )
+        .setEvents(new Map([[PostPad.EVENT_STRING.getName(), PostPad.EVENT_STRING]]));
+
+    public constructor() {
+        super();
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let inputString: string = context.getArguments()?.get(PostPad.PARAMETER_STRING_NAME);
+        let postpadString: string = context
+            ?.getArguments()
+            ?.get(PostPad.PARAMETER_POSTPAD_STRING_NAME);
+
+        let length: number = context.getArguments()?.get(PostPad.PARAMETER_LENGTH_NAME);
+        let outputString: string = '';
+        let prepadStringLength: number = postpadString.length;
+
+        outputString += inputString;
+
+        while (prepadStringLength <= length) {
+            outputString += postpadString;
+            prepadStringLength += postpadString.length;
+        }
+
+        if (outputString.length - inputString.length < length) {
+            outputString += postpadString.substring(
+                0,
+                length - (outputString.length - inputString.length),
+            );
+        }
+
+        return new FunctionOutput([
+            EventResult.of(
+                PostPad.EVENT_RESULT_NAME,
+                new Map([[PostPad.EVENT_RESULT_NAME, outputString.toString()]]),
+            ),
+        ]);
+    }
+}

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

@@ -0,0 +1,73 @@
+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 { AbstractFunction } from '../../AbstractFunction';
+
+export class PrePad extends AbstractFunction {
+    public static readonly PARAMETER_STRING_NAME: string = 'string';
+
+    public static readonly PARAMETER_PREPAD_STRING_NAME: string = 'prepadString';
+
+    public static readonly PARAMETER_LENGTH_NAME: string = 'length';
+
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected static readonly PARAMETER_STRING: Parameter =new Parameter(PrePad.PARAMETER_STRING_NAME,Schema.ofString(PrePad.PARAMETER_STRING_NAME));
+
+    protected static readonly PARAMETER_PREPAD_STRING: Parameter =new Parameter(PrePad.PARAMETER_PREPAD_STRING_NAME,Schema.ofString(PrePad.PARAMETER_PREPAD_STRING_NAME));
+
+    protected static readonly PARAMETER_LENGTH: Parameter =new Parameter(PrePad.PARAMETER_LENGTH_NAME,Schema.ofInteger(PrePad.PARAMETER_LENGTH_NAME));
+
+    protected static readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
+            new Map([[PrePad.EVENT_RESULT_NAME, Schema.ofString(PrePad.EVENT_RESULT_NAME)]]),
+        );
+
+    private readonly signature: FunctionSignature = new FunctionSignature('PrePad')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [PrePad.PARAMETER_STRING.getParameterName(), PrePad.PARAMETER_STRING],
+                [PrePad.PARAMETER_PREPAD_STRING.getParameterName(), PrePad.PARAMETER_PREPAD_STRING],
+                [PrePad.PARAMETER_LENGTH.getParameterName(), PrePad.PARAMETER_LENGTH],
+            ]),
+        )
+        .setEvents(new Map([[PrePad.EVENT_STRING.getName(), PrePad.EVENT_STRING]]));
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    public constructor() {
+        super();
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let inputString: string = context.getArguments()?.get(PrePad.PARAMETER_STRING_NAME);
+        let prepadString: string = context.getArguments()?.get(PrePad.PARAMETER_PREPAD_STRING_NAME);
+        let length: number = context.getArguments()?.get(PrePad.PARAMETER_LENGTH_NAME);
+        let outputString: string = '';
+        let prepadStringLength: number = prepadString.length;
+
+        while (prepadStringLength <= length) {
+            outputString += prepadString;
+            prepadStringLength += prepadString.length;
+        }
+
+        if (outputString.length < length) {
+            outputString += prepadString.substring(0, length - outputString.length);
+        }
+
+        outputString += inputString;
+        return new FunctionOutput([
+            EventResult.of(
+                PrePad.EVENT_RESULT_NAME,
+                new Map([[PrePad.EVENT_RESULT_NAME, outputString]]),
+            ),
+        ]);
+    }
+}

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

@@ -0,0 +1,119 @@
+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 { AbstractFunction } from '../../AbstractFunction';
+
+export class RegionMatches extends AbstractFunction {
+    public static readonly PARAMETER_STRING_NAME: string = 'string';
+
+    public static readonly PARAMETER_BOOLEAN_NAME: string = 'boolean';
+
+    public static readonly PARAMETER_FIRST_OFFSET_NAME: string = 'firstOffset';
+
+    public static readonly PARAMETER_OTHER_STRING_NAME: string = 'otherString';
+
+    public static readonly PARAMETER_SECOND_OFFSET_NAME: string = 'secondOffset';
+
+    public static readonly PARAMETER_INTEGER_NAME: string = 'length';
+
+    public static readonly EVENT_RESULT_NAME: string = 'result';
+
+    public static PARAMETER_STRING: Parameter =new Parameter(RegionMatches.PARAMETER_STRING_NAME,Schema.ofString(RegionMatches.PARAMETER_STRING_NAME));
+
+    protected static PARAMETER_OTHER_STRING: Parameter =new Parameter(RegionMatches.PARAMETER_OTHER_STRING_NAME,Schema.ofString(RegionMatches.PARAMETER_OTHER_STRING_NAME));
+
+    protected static PARAMETER_FIRST_OFFSET: Parameter =new Parameter(RegionMatches.PARAMETER_FIRST_OFFSET_NAME,Schema.ofInteger(RegionMatches.PARAMETER_FIRST_OFFSET_NAME));
+
+    protected static PARAMETER_SECOND_OFFSET: Parameter =new Parameter(RegionMatches.PARAMETER_SECOND_OFFSET_NAME,Schema.ofInteger(RegionMatches.PARAMETER_SECOND_OFFSET_NAME));
+
+    protected static PARAMETER_INTEGER: Parameter =new Parameter(RegionMatches.PARAMETER_INTEGER_NAME,Schema.ofInteger(RegionMatches.PARAMETER_INTEGER_NAME));
+
+    protected static PARAMETER_BOOLEAN: Parameter =new Parameter(RegionMatches.PARAMETER_BOOLEAN_NAME,Schema.ofBoolean(RegionMatches.PARAMETER_BOOLEAN_NAME));
+
+    protected static EVENT_BOOLEAN: Event =new Event(Event.OUTPUT,
+            new Map([
+                [
+                    RegionMatches.EVENT_RESULT_NAME,
+                    Schema.ofBoolean(RegionMatches.EVENT_RESULT_NAME),
+                ],
+            ]),
+        );
+
+    private signature: FunctionSignature = new FunctionSignature('RegionMatches')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [RegionMatches.PARAMETER_STRING.getParameterName(), RegionMatches.PARAMETER_STRING],
+                [
+                    RegionMatches.PARAMETER_BOOLEAN.getParameterName(),
+                    RegionMatches.PARAMETER_BOOLEAN,
+                ],
+                [
+                    RegionMatches.PARAMETER_FIRST_OFFSET.getParameterName(),
+                    RegionMatches.PARAMETER_FIRST_OFFSET,
+                ],
+                [
+                    RegionMatches.PARAMETER_OTHER_STRING.getParameterName(),
+                    RegionMatches.PARAMETER_OTHER_STRING,
+                ],
+                [
+                    RegionMatches.PARAMETER_SECOND_OFFSET.getParameterName(),
+                    RegionMatches.PARAMETER_SECOND_OFFSET,
+                ],
+                [
+                    RegionMatches.PARAMETER_INTEGER.getParameterName(),
+                    RegionMatches.PARAMETER_INTEGER,
+                ],
+            ]),
+        )
+        .setEvents(new Map([[RegionMatches.EVENT_BOOLEAN.getName(), RegionMatches.EVENT_BOOLEAN]]));
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    public constructor() {
+        super();
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let inputString: string = context.getArguments()?.get(RegionMatches.PARAMETER_STRING_NAME);
+        let ignoreCase: boolean = context.getArguments()?.get(RegionMatches.PARAMETER_BOOLEAN_NAME);
+        let toffSet: number = context.getArguments()?.get(RegionMatches.PARAMETER_FIRST_OFFSET_NAME);
+        let otherString: string = context
+            ?.getArguments()
+            ?.get(RegionMatches.PARAMETER_OTHER_STRING_NAME);
+        let oOffSet: number = context
+            ?.getArguments()
+            ?.get(RegionMatches.PARAMETER_SECOND_OFFSET_NAME);
+        let length: number = context.getArguments()?.get(RegionMatches.PARAMETER_INTEGER_NAME);
+
+        let matches: boolean = false;
+
+        if (
+            toffSet < 0 ||
+            oOffSet < 0 ||
+            toffSet + length > inputString.length ||
+            oOffSet + length > otherString.length
+        )
+            matches = false;
+        else if (ignoreCase) {
+            inputString = inputString.substring(toffSet, toffSet + length).toUpperCase();
+            let s2: string = otherString.substring(oOffSet, oOffSet + length).toUpperCase();
+            matches = inputString == s2;
+        } else {
+            inputString = inputString.substring(toffSet, toffSet + length);
+            let s2: string = otherString.substring(oOffSet, length);
+            matches = inputString == s2;
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[RegionMatches.EVENT_RESULT_NAME, matches]])),
+        ]);
+    }
+}

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

@@ -0,0 +1,101 @@
+import { AbstractFunction, Namespaces, Schema } from '../../../..';
+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 { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { StringBuilder } from '../../../util/string/StringBuilder';
+
+export class ReplaceAtGivenPosition extends AbstractFunction {
+    protected static readonly PARAMETER_STRING_NAME: string = 'string';
+
+    protected static readonly PARAMETER_AT_START_NAME: string = 'startPosition';
+
+    protected static readonly PARAMETER_AT_LENGTH_NAME: string = 'lengthPosition';
+
+    protected static readonly PARAMETER_REPLACE_STRING_NAME: string = 'replaceString';
+
+    protected static readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected static PARAMETER_STRING: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_STRING_NAME,Schema.ofString(ReplaceAtGivenPosition.PARAMETER_STRING_NAME));
+
+    protected static PARAMETER_AT_START: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME,Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME));
+
+    protected static PARAMETER_AT_LENGTH: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME,Schema.ofInteger(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME));
+
+    protected static PARAMETER_REPLACE_STRING: Parameter =new Parameter(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME,Schema.ofString(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME));
+
+    protected static EVENT_STRING: Event =new Event(Event.OUTPUT,
+            new Map([
+                [
+                    ReplaceAtGivenPosition.EVENT_RESULT_NAME,
+                    Schema.ofString(ReplaceAtGivenPosition.EVENT_RESULT_NAME),
+                ],
+            ]),
+        );
+
+    private signature: FunctionSignature = new FunctionSignature('ReplaceAtGivenPosition')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [
+                    ReplaceAtGivenPosition.PARAMETER_STRING.getParameterName(),
+                    ReplaceAtGivenPosition.PARAMETER_STRING,
+                ],
+                [
+                    ReplaceAtGivenPosition.PARAMETER_AT_START.getParameterName(),
+                    ReplaceAtGivenPosition.PARAMETER_AT_START,
+                ],
+                [
+                    ReplaceAtGivenPosition.PARAMETER_AT_LENGTH.getParameterName(),
+                    ReplaceAtGivenPosition.PARAMETER_AT_LENGTH,
+                ],
+                [
+                    ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING.getParameterName(),
+                    ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING,
+                ],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                [
+                    ReplaceAtGivenPosition.EVENT_STRING.getName(),
+                    ReplaceAtGivenPosition.EVENT_STRING,
+                ],
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return this.signature;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let inputString: string = context
+            ?.getArguments()
+            ?.get(ReplaceAtGivenPosition.PARAMETER_STRING_NAME);
+        let startPosition: number = context
+            ?.getArguments()
+            ?.get(ReplaceAtGivenPosition.PARAMETER_AT_START_NAME);
+        let length: number = context
+            ?.getArguments()
+            ?.get(ReplaceAtGivenPosition.PARAMETER_AT_LENGTH_NAME);
+        let replaceString: string = context
+            ?.getArguments()
+            ?.get(ReplaceAtGivenPosition.PARAMETER_REPLACE_STRING_NAME);
+        let inputStringLength: number = inputString.length;
+
+        if (startPosition < length) {
+            let outputString: string = '';
+            outputString += inputString.substring(0, startPosition);
+            outputString += replaceString;
+            outputString += inputString.substring(startPosition + length);
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(
+                new Map([[ReplaceAtGivenPosition.EVENT_RESULT_NAME, inputString]]),
+            ),
+        ]);
+    }
+}

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

@@ -0,0 +1,62 @@
+import { Schema } from '../../../json/schema/Schema';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { AbstractFunction } from '../../AbstractFunction';
+import { MapUtil } from '../../../util/MapUtil';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { TypeUtil } from '../../../json/schema/type/TypeUtil';
+import { SchemaType } from '../../../json/schema/type/SchemaType';
+
+export class Reverse extends AbstractFunction {
+    protected readonly VALUE: string = 'value';
+
+    private readonly SIGNATURE: FunctionSignature = new FunctionSignature('Reverse')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [
+                    this.VALUE,
+                   new Parameter(this.VALUE,Schema.ofString(this.VALUE))
+                        .setVariableArgument(true),
+                ],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    new Map([
+                        [
+                            this.VALUE,
+                            new Schema()
+                                .setType(TypeUtil.of(SchemaType.STRING))
+                                .setName(this.VALUE),
+                        ],
+                    ]),
+                ),
+            ]),
+        );
+
+    public constructor() {
+        super();
+    }
+
+    public getSignature(): FunctionSignature {
+        return this.SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let acutalString: string = context.getArguments()?.get(this.VALUE);
+        let stringLength: number = acutalString.length - 1;
+        let reversedString: string = '';
+
+        while (stringLength >= 0) {
+            reversedString += acutalString.charAt(stringLength--);
+        }
+
+        return new FunctionOutput([EventResult.outputOf(MapUtil.of(this.VALUE, reversedString))]);
+    }
+}

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

@@ -0,0 +1,53 @@
+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 Split extends AbstractFunction {
+    protected readonly PARAMETER_STRING_NAME: string = 'string';
+    protected readonly PARAMETER_SPLIT_STRING_NAME: string = 'searchString';
+    protected readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected readonly PARAMETER_STRING: Parameter =new Parameter(this.PARAMETER_STRING_NAME,Schema.ofString(this.PARAMETER_STRING_NAME));
+
+    protected readonly PARAMETER_SPLIT_STRING: Parameter =new Parameter(this.PARAMETER_SPLIT_STRING_NAME,Schema.ofString(this.PARAMETER_SPLIT_STRING_NAME));
+
+    protected readonly EVENT_ARRAY: Event =new Event(Event.OUTPUT,MapUtil.of(this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)));
+
+    public getSignature(): FunctionSignature {
+        return new FunctionSignature('Split')
+            .setNamespace(Namespaces.STRING)
+            .setParameters(
+                new Map([
+                    [this.PARAMETER_STRING_NAME, this.PARAMETER_STRING],
+                    [this.PARAMETER_SPLIT_STRING_NAME, this.PARAMETER_SPLIT_STRING],
+                ]),
+            )
+            .setEvents(
+                new Map([
+                    Event.outputEventMapEntry(
+                        new Map([[this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)]]),
+                    ) as [string, Event],
+                ]),
+            );
+    }
+
+    public constructor() {
+        super();
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let s1: string = context.getArguments()?.get(this.PARAMETER_STRING_NAME);
+        let s2: string = context.getArguments()?.get(this.PARAMETER_SPLIT_STRING_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(MapUtil.of(this.EVENT_ARRAY.getName(), s1.split(s2))),
+        ]);
+    }
+}

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

@@ -0,0 +1,60 @@
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { Repository } from '../../../Repository';
+import { MapUtil } from '../../../util/MapUtil';
+import { Function } from '../../Function';
+import { AbstractStringFunction } from './AbstractStringFunction';
+
+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('Blank', (e) => e.trim() == ''),
+        AbstractStringFunction.ofEntryStringBooleanOutput('Empty', (e) => e == ''),
+
+        AbstractStringFunction.ofEntryAsStringBooleanOutput(
+            'Contains',
+            (a, b) => a.indexOf(b) != -1,
+        ),
+        AbstractStringFunction.ofEntryAsStringBooleanOutput('EndsWith', (a, b) => a.endsWith(b)),
+        AbstractStringFunction.ofEntryAsStringBooleanOutput(
+            'EqualsIgnoreCase',
+            (a, b) => a.toUpperCase() == b.toUpperCase(),
+        ),
+        AbstractStringFunction.ofEntryAsStringBooleanOutput('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.ofEntryAsStringAndIntegerStringOutput('Repeat', (a, b) =>
+            a.repeat(b),
+        ),
+
+        AbstractStringFunction.ofEntryAsStringStringIntegerIntegerOutput(
+            'IndexOfWithStartPoint',
+            (a, b, c) => a.indexOf(b, c),
+        ),
+        AbstractStringFunction.ofEntryAsStringStringIntegerIntegerOutput(
+            'LastIndexOfWithStartPoint',
+            (a, b, c) => a.lastIndexOf(b, c),
+        ),
+        AbstractStringFunction.ofEntryAsStringStringStringStringOutput('Replace', (a, b, c) => {
+            return a;
+        }),
+        AbstractStringFunction.ofEntryAsStringStringStringStringOutput('ReplaceFirst', (a, b, c) =>
+            a.replace(b, c),
+        ),
+        AbstractStringFunction.ofEntryAsStringIntegerIntegerStringOutput('SubString', (a, b, c) =>
+            a.substring(b, c),
+        ),
+    );
+
+    public find(namespace: string, name: string): Function | undefined {
+        if (namespace != Namespaces.STRING) {
+            return undefined;
+        }
+        return StringFunctionRepository.repoMap.get(name);
+    }
+}

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

@@ -0,0 +1,45 @@
+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 { AbstractFunction } from '../../AbstractFunction';
+
+export class ToString extends AbstractFunction {
+    protected readonly PARAMETER_INPUT_ANYTYPE_NAME: string = 'anytype';
+
+    protected readonly EVENT_RESULT_NAME: string = 'result';
+
+    protected readonly PARAMETER_INPUT_ANYTYPE: Parameter =new Parameter(this.PARAMETER_INPUT_ANYTYPE_NAME,Schema.ofAny(this.PARAMETER_INPUT_ANYTYPE_NAME));
+
+    protected readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
+            new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return new FunctionSignature('ToString')
+            .setNamespace(Namespaces.STRING)
+            .setParameters(
+                new Map([
+                    [this.PARAMETER_INPUT_ANYTYPE.getParameterName(), this.PARAMETER_INPUT_ANYTYPE],
+                ]),
+            )
+            .setEvents(new Map([[this.EVENT_STRING.getName(), this.EVENT_STRING]]));
+    }
+
+    public constructor() {
+        super();
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let input: any = context.getArguments()?.get(this.PARAMETER_INPUT_ANYTYPE_NAME);
+        let output: string = input + '';
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[this.EVENT_RESULT_NAME, output]])),
+        ]);
+    }
+}