affinirum 1.0.0

package/dst/Affinirum.js

@@ -0,0 +1,536 @@
+import { funcOr, funcAnd, funcNot } from './constant/Boolean.js';
+import { funcAdd } from './constant/Enumerable.js';
+import { funcAt } from './constant/Iterable.js';
+import { funcGreaterThan, funcLessThan, funcGreaterOrEqual, funcLessOrEqual, funcSubtract, funcMultiply, funcDivide, funcRemainder, funcPower, funcNegate } from './constant/Number.js';
+import { funcCoalesce, funcEqual, funcNotEqual } from './constant/Unknown.js';
+import { Constant } from './Constant.js';
+import { Variable } from './Variable.js';
+import { Type } from './Type.js';
+import { Keywords } from './Keywords.js';
+import { Constants } from './Constants.js';
+import { Functions } from './Functions.js';
+import { ArrayNode } from './node/ArrayNode.js';
+import { BlockNode } from './node/BlockNode.js';
+import { ConstantNode } from './node/ConstantNode.js';
+import { CallNode } from './node/CallNode.js';
+import { LoopNode } from './node/LoopNode.js';
+import { ObjectNode } from './node/ObjectNode.js';
+import { SwitchNode } from './node/SwitchNode.js';
+import { VariableNode } from './node/VariableNode.js';
+import { ParserState } from './ParserState.js';
+import { StaticScope } from './StaticScope.js';
+export class Affinirum {
+    static keywords = [...Keywords, ...Constants.map((c) => c[0])];
+    _script;
+    _strict;
+    _root;
+    _vframes = new Map();
+    _variables = new Map();
+    _constants = new Map(Constants);
+    _functions = new Map(Functions);
+    _scope = new StaticScope();
+    /**
+        Creates compiled expression. Any parsed token not recognized as a constant or a function will be compiled as a variable.
+        @param script Math expression to compile.
+        @param config Optional expected type, strict mode, variable types, constant values and functions to add for the compilation.
+            If expected type is provided then expression return type is matched against it.
+            If strict mode is set then undeclared variables will not be allowed in expression.
+    */
+    constructor(script, config) {
+        this._script = script;
+        this._strict = config?.strict ?? false;
+        if (config?.variables) {
+            for (const v in config.variables) {
+                this._variables.set(v, new Variable(config.variables[v]));
+            }
+        }
+        const state = new ParserState(this._script);
+        this._root = this._block(state.next(), this._scope);
+        if (!state.isVoid) {
+            state.throwError('unexpected expression token or expression end');
+        }
+        this._root = this._root.compile(config?.type ?? Type.Unknown);
+    }
+    /**
+        Returns original script text.
+    */
+    get script() {
+        return this._script;
+    }
+    /**
+        Returns compiled expression return value type.
+    */
+    get type() {
+        return this._root.type;
+    }
+    /**
+        Returns string representing parsed node tree structure.
+        @returns Parsed expression string.
+    */
+    toString() {
+        return this._root.toString();
+    }
+    /**
+        Returns record with compiled variable names and expected types.
+        @returns Record with variable names and types.
+    */
+    variables() {
+        const types = {};
+        const variables = this._scope.variables();
+        for (const name in variables) {
+            types[name] = variables[name].type;
+        }
+        return types;
+    }
+    /**
+        Evaluates compiled expression using provided variable values.
+        @param values Record with variable names and values.
+        @returns Calculated value.
+    */
+    evaluate(values) {
+        const variables = this._scope.variables();
+        for (const name in variables) {
+            if (!Object.prototype.hasOwnProperty.call(values, name)) {
+                this._vframes.get(name)?.throwError(`undefined variable ${name}:\n`);
+            }
+            const variable = variables[name];
+            const value = values?.[name] ?? undefined;
+            if (!variable.type.match(Type.of(value))) {
+                this._vframes.get(name)?.throwError(`unexpected type ${Type.of(value)} for variable ${name} of type ${variable.type}:\n`);
+            }
+            variable.value = value;
+        }
+        return this._root.evaluate();
+    }
+    _block(state, scope) {
+        const frame = state.starts();
+        const nodes = [this._unit(state, scope)];
+        while (state.isSemicolonSeparator) {
+            nodes.push(this._unit(state.next(), scope));
+        }
+        return new BlockNode(frame.ends(state), nodes);
+    }
+    _unit(state, scope) {
+        return this._disjunction(state, scope);
+    }
+    _disjunction(state, scope) {
+        let node = this._conjunction(state, scope);
+        while (state.operator === funcOr) {
+            node = this._call(state.starts(), state.operator, [node, this._conjunction(state.next(), scope)]);
+        }
+        return node;
+    }
+    _conjunction(state, scope) {
+        let node = this._comparison(state, scope);
+        while (state.operator === funcAnd) {
+            node = this._call(state.starts(), state.operator, [node, this._comparison(state.next(), scope)]);
+        }
+        return node;
+    }
+    _comparison(state, scope) {
+        const frame = state.starts();
+        let not = false;
+        while (state.operator === funcNot) {
+            not = !not;
+            frame.starts(state);
+            state.next();
+        }
+        let node = this._aggregate(state, scope);
+        while (state.operator === funcGreaterThan || state.operator === funcLessThan
+            || state.operator === funcGreaterOrEqual || state.operator === funcLessOrEqual
+            || state.operator === funcEqual || state.operator === funcNotEqual) {
+            node = this._call(state.starts(), state.operator, [node, this._aggregate(state.next(), scope)]);
+        }
+        if (not) {
+            node = this._call(frame.ends(state), funcNot, [node]);
+        }
+        return node;
+    }
+    _aggregate(state, scope) {
+        let node = this._product(state, scope);
+        while (state.operator === funcAdd || state.operator === funcSubtract) {
+            node = this._call(state.starts(), state.operator, [node, this._product(state.next(), scope)]);
+        }
+        return node;
+    }
+    _product(state, scope) {
+        let node = this._factor(state, scope);
+        while (state.operator === funcMultiply || state.operator === funcDivide || state.operator === funcRemainder) {
+            node = this._call(state.starts(), state.operator, [node, this._factor(state.next(), scope)]);
+        }
+        return node;
+    }
+    _factor(state, scope) {
+        const frame = state.starts();
+        let neg = false;
+        while (state.operator === funcSubtract) {
+            neg = !neg;
+            frame.starts(state);
+            state.next();
+        }
+        let node = this._coalescence(state, scope);
+        while (state.operator === funcPower) {
+            node = this._call(state.starts(), state.operator, [node, this._coalescence(state.next(), scope)]);
+        }
+        if (neg) {
+            node = this._call(frame.ends(state), funcNegate, [node]);
+        }
+        return node;
+    }
+    _coalescence(state, scope) {
+        let node = this._accessor(state, scope);
+        while (state.operator === funcCoalesce) {
+            node = this._call(state.starts(), state.operator, [node, this._accessor(state.next(), scope)]);
+        }
+        return node;
+    }
+    _accessor(state, scope) {
+        let node = this._term(state, scope);
+        while (state.operator === funcAt || state.isParenthesesOpen || state.isBracketsOpen) {
+            const frame = state.starts();
+            if (state.operator === funcAt) {
+                if (state.next().isLiteral && (typeof state.literalValue === 'string' || typeof state.literalValue === 'bigint')) {
+                    node = this._call(frame.ends(state), funcAt, [node, new ConstantNode(state, new Constant(state.literalValue))]);
+                    state.next();
+                }
+                else if (state.isToken) {
+                    frame.ends(state);
+                    const func = this._functions.get(state.token);
+                    if (func) {
+                        if (state.next().isParenthesesOpen) {
+                            const subnodes = [node];
+                            while (!state.next().isParenthesesClose) {
+                                subnodes.push(this._unit(state, scope));
+                                if (!state.isCommaSeparator) {
+                                    break;
+                                }
+                            }
+                            node = this._call(frame.ends(state), func, subnodes);
+                            state.closeParentheses().next();
+                        }
+                        else {
+                            node = this._call(frame, func, [node]);
+                        }
+                    }
+                    else {
+                        node = this._call(frame, funcAt, [node, new ConstantNode(state, new Constant(state.token))]);
+                        state.next();
+                    }
+                }
+                else {
+                    state.throwError('missing array or object index');
+                }
+            }
+            else if (state.isParenthesesOpen) {
+                const subnodes = [];
+                while (!state.next().isParenthesesClose) {
+                    subnodes.push(this._unit(state, scope));
+                    if (!state.isCommaSeparator) {
+                        break;
+                    }
+                }
+                node = new CallNode(frame.ends(state), node, subnodes);
+                state.closeParentheses().next();
+            }
+            else if (state.isBracketsOpen) {
+                node = this._call(frame, funcAt, [node, this._unit(state.next(), scope)]);
+                state.closeBrackets().next();
+            }
+        }
+        return node;
+    }
+    _term(state, scope) {
+        if (state.isLiteral) {
+            const frame = state.starts();
+            const constant = new Constant(state.literalValue);
+            state.next();
+            return new ConstantNode(frame, constant);
+        }
+        else if (state.isToken) {
+            const frame = state.starts();
+            const constants = this._constants.get(state.token);
+            if (constants != null) {
+                if (state.next().operator !== funcAt) {
+                    state.throwError('missing constant accessor operator');
+                }
+                if (!state.next().isToken) {
+                    state.throwError('missing constant name');
+                }
+                const constant = constants[state.token];
+                if (!constant) {
+                    state.throwError(`unknown constant ${state.token}`);
+                }
+                state.next();
+                return new ConstantNode(frame, constant);
+            }
+            let variable = scope.get(state.token);
+            if (variable == null) {
+                variable = this._variables.get(state.token);
+                if (variable == null) {
+                    if (this._strict) {
+                        state.throwError(`undefined variable ${state.token} in strict mode`);
+                    }
+                    else {
+                        variable = new Variable();
+                    }
+                }
+                scope.global(state.token, variable);
+            }
+            if (!this._vframes.has(state.token)) {
+                this._vframes.set(state.token, state.starts());
+            }
+            if (state.next().isAssignment) {
+                if (variable.constant) {
+                    state.throwError('illegal constant assignment');
+                }
+                if (state.assignmentOperator) {
+                    const operator = state.assignmentOperator;
+                    const subnodes = [new VariableNode(frame, variable), this._unit(state.next(), scope)];
+                    return new VariableNode(frame, variable, this._call(frame, operator, subnodes));
+                }
+                else {
+                    return new VariableNode(frame, variable, this._unit(state.next(), scope));
+                }
+            }
+            return new VariableNode(frame, variable);
+        }
+        else if (state.isBracesOpen) {
+            const node = this._block(state.next(), scope);
+            state.closeBraces().next();
+            return node;
+        }
+        else if (state.isBracesClose) {
+            state.throwError('unexpected closing braces');
+        }
+        else if (state.isParenthesesOpen) {
+            const node = this._unit(state.next(), scope);
+            state.closeParentheses().next();
+            return node;
+        }
+        else if (state.isParenthesesClose) {
+            state.throwError('unexpected closing parentheses');
+        }
+        else if (state.isBracketsOpen) {
+            const frame = state.starts();
+            const subnodes = [];
+            let index = 0, colon = false;
+            while (!state.next().isBracketsClose) {
+                if (state.isColonSeparator) {
+                    colon = true;
+                    state.next();
+                    break;
+                }
+                const node = this._unit(state, scope);
+                if (state.isColonSeparator) {
+                    colon = true;
+                    subnodes.push([node, this._unit(state.next(), scope)]);
+                }
+                else {
+                    subnodes.push([index++, node]);
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            frame.ends(state);
+            state.closeBrackets().next();
+            if (colon) {
+                return new ObjectNode(frame, subnodes.map(([k, v]) => [typeof k === 'number' ? new ConstantNode(v, new Constant(String(k))) : k, v]));
+            }
+            return new ArrayNode(frame, subnodes.map(([, v]) => v));
+        }
+        else if (state.isBracketsClose) {
+            state.throwError('unexpected closing brackets');
+        }
+        else if (state.isVariableDefinition || state.isConstantDefinition) {
+            const constant = state.isConstantDefinition;
+            if (!state.next().isToken) {
+                state.throwError(`missing ${constant ? 'constant' : 'variable'} name`);
+            }
+            const token = state.token;
+            if (scope.has(token)) {
+                state.throwError(`illegal redefinition of ${constant ? 'constant' : 'variable'} ${token}`);
+            }
+            const frame = state.starts();
+            let type;
+            if (state.next().isColonSeparator) {
+                type = this._type(state.next(), scope);
+            }
+            const variable = new Variable(type, constant);
+            scope.local(token, variable);
+            if (state.isAssignment) {
+                if (state.assignmentOperator) {
+                    state.throwError(`illegal assignment to ${constant ? 'constant' : 'variable'} ${token}`);
+                }
+                return new VariableNode(frame, variable, this._unit(state.next(), scope));
+            }
+            return new VariableNode(frame, variable);
+        }
+        else if (state.isTildaMark) {
+            return this._function(state, scope);
+        }
+        else if (state.isWhile) {
+            return this._loop(state, scope);
+        }
+        else if (state.isIf) {
+            return this._switch(state, scope);
+        }
+        else if (state.isVoid) {
+            state.throwError('unexpected end of expression');
+        }
+        state.throwError('unexpected expression token');
+    }
+    _function(state, scope) {
+        const frame = state.starts();
+        let retType = undefined;
+        if (!state.next().isParenthesesOpen) {
+            retType = this._type(state, scope);
+            state.openParentheses();
+        }
+        let variadic = false;
+        const variables = new Map();
+        while (!state.next().isParenthesesClose) {
+            if (!state.isToken) {
+                state.throwError('missing function argument name');
+            }
+            const token = state.token;
+            if (scope.get(token)) {
+                state.throwError('variable redefinition');
+            }
+            let argType = Type.Unknown;
+            if (state.next().isColonSeparator) {
+                argType = this._type(state.next(), scope);
+            }
+            variables.set(token, new Variable(argType));
+            if (argType.isArray && state.isVariadicFunction) {
+                variadic = true;
+                state.next();
+                break;
+            }
+            if (!state.isCommaSeparator) {
+                break;
+            }
+        }
+        state.closeParentheses();
+        frame.ends(state);
+        state.next().openBraces().next();
+        const subnode = this._block(state, scope.subscope(variables));
+        state.closeBraces().next();
+        const args = Array.from(variables.values());
+        const value = (...values) => {
+            args.forEach((arg, ix) => arg.value = values[ix]);
+            return subnode.evaluate();
+        };
+        if (!retType && args.length) {
+            retType = Type.Unknown;
+        }
+        const constant = new Constant(value, Type.functionType(retType, args.map((v) => v.type), variadic));
+        return new ConstantNode(frame, constant, subnode);
+    }
+    _loop(state, scope) {
+        const frame = state.starts();
+        const cnode = this._unit(state.next(), scope);
+        frame.ends(state);
+        state.openBraces().next();
+        const subnode = this._block(state, scope);
+        state.closeBraces().next();
+        return new LoopNode(frame, cnode, subnode);
+    }
+    _switch(state, scope) {
+        const frame = state.starts();
+        const cnode = this._unit(state.next(), scope);
+        frame.ends(state);
+        const subnodes = [];
+        state.openBraces().next();
+        subnodes.push(this._block(state, scope));
+        state.closeBraces().next();
+        if (state.isElse) {
+            state.next().openBraces().next();
+            subnodes.push(this._block(state, scope));
+            state.closeBraces().next();
+        }
+        else {
+            subnodes.push(new ConstantNode(state.starts(), Constant.Null));
+        }
+        return new SwitchNode(frame, cnode, subnodes);
+    }
+    _call(frame, func, subnodes) {
+        return new CallNode(frame, new ConstantNode(frame, func), subnodes);
+    }
+    _type(state, scope) {
+        if (state.isType) {
+            let type = state.type;
+            if (state.next().isOptionalType) {
+                type = type.toOptional();
+                state.next();
+            }
+            if (state.operator === funcOr) { // type union
+                return Type.union(type, this._type(state.next(), scope));
+            }
+            return type;
+        }
+        else if (state.isBracketsOpen) { // array or object type
+            const itemPropTypes = [];
+            let index = 0, colon = false;
+            while (!state.next().isBracketsClose) {
+                if (state.isColonSeparator) { // default object type
+                    colon = true;
+                    state.next();
+                    break;
+                }
+                if (state.isType) {
+                    itemPropTypes.push([index++, this._type(state, scope)]);
+                }
+                else if (state.isToken) {
+                    const token = state.token;
+                    state.next().separateByColon().next();
+                    itemPropTypes.push([token, this._type(state, scope)]);
+                }
+                else {
+                    state.throwError('missing type or property name');
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            state.closeBrackets().next();
+            return colon
+                ? Type.objectType(Object.fromEntries(itemPropTypes.map(([prop, type]) => [prop, type])))
+                : Type.arrayType(itemPropTypes.map(([, v]) => v));
+        }
+        else if (state.isTildaMark) { // function type
+            let retType = undefined;
+            if (!state.next().isParenthesesOpen) {
+                retType = this._type(state, scope);
+                state.openParentheses();
+            }
+            let variadic = false;
+            const argTypes = [];
+            while (!state.next().isParenthesesClose) {
+                const argType = this._type(state, scope);
+                argTypes.push(argType);
+                if (state.isVariadicFunction) {
+                    if (argType.isArray) {
+                        variadic = true;
+                        state.next();
+                        break;
+                    }
+                    else {
+                        state.throwError('variadic function argument must be an array type');
+                    }
+                }
+                if (!state.isCommaSeparator) {
+                    break;
+                }
+            }
+            state.closeParentheses().next();
+            if (!retType && argTypes.length) {
+                retType = Type.Unknown;
+            }
+            return Type.functionType(retType, argTypes, variadic);
+        }
+        else {
+            state.throwError('missing type name');
+        }
+    }
+}

package/dst/Constant.d.ts

@@ -0,0 +1,15 @@
+import { Value } from './Value.js';
+import { Type } from './Type.js';
+export declare class Constant {
+    protected readonly _value: Value;
+    protected _type: Type;
+    protected readonly _deterministic: boolean;
+    constructor(_value: Value, _type?: Type, _deterministic?: boolean);
+    get value(): Value;
+    get type(): Type;
+    set type(type: Type);
+    get deterministic(): boolean;
+    static Null: Constant;
+    static EmptyArray: Constant;
+    static EmptyObject: Constant;
+}

package/dst/Constant.js

@@ -0,0 +1,26 @@
+import { Type } from './Type.js';
+export class Constant {
+    _value;
+    _type;
+    _deterministic;
+    constructor(_value, _type = Type.of(_value), _deterministic = true) {
+        this._value = _value;
+        this._type = _type;
+        this._deterministic = _deterministic;
+    }
+    get value() {
+        return this._value;
+    }
+    get type() {
+        return Type.isPrimitiveType(this._value) ? Type.of(this._value) : this._type;
+    }
+    set type(type) {
+        this._type = type;
+    }
+    get deterministic() {
+        return this._deterministic;
+    }
+    static Null = new Constant(undefined);
+    static EmptyArray = new Constant([]);
+    static EmptyObject = new Constant({});
+}

package/dst/Constants.d.ts

@@ -0,0 +1,2 @@
+import { Constant } from './Constant.js';
+export declare const Constants: [string, Record<string, Constant>][];

package/dst/Constants.js

@@ -0,0 +1,22 @@
+import { constArray } from './constant/Array.js';
+import { constBoolean } from './constant/Boolean.js';
+import { constBuffer } from './constant/Buffer.js';
+import { constInteger } from './constant/Integer.js';
+import { constFloat } from './constant/Float.js';
+import { constObject } from './constant/Object.js';
+import { constString } from './constant/String.js';
+import { constTimestamp } from './constant/Timestamp.js';
+import { constAN } from './constant/notation/AN.js';
+import { constJSON } from './constant/notation/JSON.js';
+export const Constants = [
+    ['Array', constArray],
+    ['Boolean', constBoolean],
+    ['Buffer', constBuffer],
+    ['Float', constFloat],
+    ['Integer', constInteger],
+    ['Object', constObject],
+    ['String', constString],
+    ['Timestamp', constTimestamp],
+    ['AN', constAN],
+    ['JSON', constJSON],
+];

package/dst/Functions.d.ts

@@ -0,0 +1,2 @@
+import { Constant } from './Constant.js';
+export declare const Functions: [string, Constant][];

package/dst/Functions.js

@@ -0,0 +1,85 @@
+import { funcFirst, funcLast, funcFirstIndex, funcLastIndex, funcEvery, funcAny, funcFlatten, funcReverse, funcMutate, funcFilter, funcReduce, funcCompose, funcPrepend, funcAppend } from './constant/Array.js';
+import { funcByte } from './constant/Buffer.js';
+import { funcAdd, funcSlice, funcSplice, funcInject } from './constant/Enumerable.js';
+import { funcLength, funcAt } from './constant/Iterable.js';
+import { funcGreaterThan, funcLessThan, funcGreaterOrEqual, funcLessOrEqual, funcSubtract, funcMultiply, funcDivide, funcRemainder, funcModulo, funcPower, funcRoot, funcNegate, funcCast } from './constant/Number.js';
+import { funcEntries, funcKeys, funcValues } from './constant/Object.js';
+import { funcLike, funcUnlike, funcContains, funcStartsWith, funcEndsWith, funcChar, funcCharCode, funcTrim, funcTrimStart, funcTrimEnd, funcLowerCase, funcUpperCase, funcSplit } from './constant/String.js';
+import { funcYear, funcMonth, funcMonthIndex, funcWeekdayIndex, funcDay, funcHour, funcMinute, funcSecond, funcMillisecond, funcEpochTime } from './constant/Timestamp.js';
+import { funcCoalesce, funcEqual, funcNotEqual, funcEncode, funcFormat } from './constant/Unknown.js';
+export const Functions = [
+    // Array
+    ['First', funcFirst],
+    ['Last', funcLast],
+    ['FirstIndex', funcFirstIndex],
+    ['LastIndex', funcLastIndex],
+    ['Any', funcAny],
+    ['Every', funcEvery],
+    ['Flatten', funcFlatten],
+    ['Reverse', funcReverse],
+    ['Mutate', funcMutate],
+    ['Filter', funcFilter],
+    ['Reduce', funcReduce],
+    ['Compose', funcCompose],
+    ['Prepend', funcPrepend],
+    ['Append', funcAppend],
+    // Buffer
+    ['Byte', funcByte],
+    // Enumerable
+    ['Add', funcAdd],
+    ['Slice', funcSlice],
+    ['Splice', funcSplice],
+    ['Inject', funcInject],
+    // Iterable
+    ['Length', funcLength],
+    ['At', funcAt],
+    // Number
+    ['GreaterThan', funcGreaterThan],
+    ['LessThan', funcLessThan],
+    ['GreaterOrEqual', funcGreaterOrEqual],
+    ['LessOrEqual', funcLessOrEqual],
+    ['Subtract', funcSubtract],
+    ['Multiply', funcMultiply],
+    ['Divide', funcDivide],
+    ['Remainder', funcRemainder],
+    ['Modulo', funcModulo],
+    ['Power', funcPower],
+    ['Root', funcRoot],
+    ['Negate', funcNegate],
+    ['Cast', funcCast],
+    // Object
+    ['Entries', funcEntries],
+    ['Keys', funcKeys],
+    ['Values', funcValues],
+    // String
+    ['Like', funcLike],
+    ['Unlike', funcUnlike],
+    ['Contains', funcContains],
+    ['StartsWith', funcStartsWith],
+    ['EndsWith', funcEndsWith],
+    ['Char', funcChar],
+    ['CharCode', funcCharCode],
+    ['Trim', funcTrim],
+    ['TrimStart', funcTrimStart],
+    ['TrimEnd', funcTrimEnd],
+    ['LowerCase', funcLowerCase],
+    ['UpperCase', funcUpperCase],
+    ['Split', funcSplit],
+    // Timestamp
+    ['Year', funcYear],
+    ['Month', funcMonth],
+    ['MonthIndex', funcMonthIndex],
+    ['WeekdayIndex', funcWeekdayIndex],
+    ['Day', funcDay],
+    ['Hour', funcHour],
+    ['Minute', funcMinute],
+    ['Second', funcSecond],
+    ['Millisecond', funcMillisecond],
+    ['EpochTime', funcEpochTime],
+    // Unknown
+    ['Coalesce', funcCoalesce],
+    ['Equal', funcEqual],
+    ['Unequal', funcNotEqual],
+    ['Encode', funcEncode],
+    ['Format', funcFormat],
+];