@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/esm/lib/validation/engine/expression/index.js

@@ -0,0 +1,352 @@
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const settingsSymbol = Symbol('settings');
+const expressionSymbol = Symbol('expression');
+const operators = ['!', '^', '*', '/', '%', '+', '-', '<', '<=', '>', '>=', '==', '!=', '&&', '||', '??'];
+const operatorCharacters = ['!', '^', '*', '/', '%', '+', '-', '<', '=', '>', '&', '|', '?'];
+const operatorsOrder = [['^'], ['*', '/', '%'], ['+', '-'], ['<', '<=', '>', '>='], ['==', '!='], ['&&'], ['||', '??']];
+const operatorsPrefix = ['!', 'n'];
+const literals = {
+    '"': '"',
+    '`': '`',
+    '\'': '\'',
+    '[': ']'
+};
+const numberRx = /^(?:[0-9]*(\.[0-9]*)?){1}$/;
+const tokenRx = /^[\w\$\#\.\@\:\{\}]+$/;
+/**
+ * A expression parsed into parts, evaluated against a context
+ */
+export class Parser {
+    constructor(string, options = {}) {
+        this.single = null;
+        this._parts = null;
+        if (!options[settingsSymbol] && options.constants) {
+            for (const constant in options.constants) {
+                const value = options.constants[constant];
+                if (value !== null && !['boolean', 'number', 'string'].includes(typeof value)) {
+                    throw new Error(`Expression constant ${constant} contains invalid ${typeof value} value type`);
+                }
+            }
+        }
+        this.settings = options[settingsSymbol] ? options : { [settingsSymbol]: true, constants: {}, functions: {}, ...options };
+        this._parse(string);
+    }
+    _parse(string) {
+        let parts = [];
+        let current = '';
+        let parenthesis = 0;
+        let literal = false;
+        const flush = (inner) => {
+            if (parenthesis)
+                throw new Error('Expression missing closing parenthesis');
+            const last = parts.length ? parts[parts.length - 1] : null;
+            if (!literal && !current && !inner)
+                return;
+            //Function
+            if (last && last.type === 'reference' && inner === ')') {
+                parts[parts.length - 1] = { type: 'function', value: this._subExpression(current, last.value) };
+                current = '';
+                return;
+            }
+            if (inner === ')') {
+                //Segment
+                const sub = new Parser(current, this.settings);
+                parts.push({ type: 'segment', value: sub });
+            }
+            else if (literal) {
+                //Reference
+                if (literal === ']') {
+                    parts.push({ type: 'reference', value: current });
+                    current = '';
+                    return;
+                }
+                //Literal
+                parts.push({ type: 'literal', value: current });
+            }
+            else if (operatorCharacters.includes(current)) {
+                //Operator, 2 characters operator
+                if (last && last.type === 'operator' && operators.includes(last.value + current)) {
+                    last.value += current;
+                }
+                else {
+                    parts.push({ type: 'operator', value: current });
+                }
+            }
+            else if (current.match(numberRx)) {
+                //Number
+                parts.push({ type: 'constant', value: parseFloat(current) });
+            }
+            else if (this.settings.constants[current] !== undefined) {
+                //Constant
+                parts.push({ type: 'constant', value: this.settings.constants[current] });
+            }
+            else {
+                //Reference
+                if (!current.match(tokenRx))
+                    throw new Error(`Expression contains invalid token: ${current}`);
+                parts.push({ type: 'reference', value: current });
+            }
+            current = '';
+        };
+        for (const c of string) {
+            if (literal) {
+                if (c === literal) {
+                    flush();
+                    literal = false;
+                }
+                else {
+                    current += c;
+                }
+            }
+            else if (parenthesis) {
+                if (c === '(') {
+                    current += c;
+                    ++parenthesis;
+                }
+                else if (c === ')') {
+                    --parenthesis;
+                    if (!parenthesis) {
+                        flush(c);
+                    }
+                    else {
+                        current += c;
+                    }
+                }
+                else {
+                    current += c;
+                }
+            }
+            else if (c in literals) {
+                literal = literals[c];
+            }
+            else if (c === '(') {
+                flush();
+                ++parenthesis;
+            }
+            else if (operatorCharacters.includes(c)) {
+                flush();
+                current = c;
+                flush();
+            }
+            else if (c !== ' ') {
+                current += c;
+            }
+            else {
+                flush();
+            }
+        }
+        flush();
+        //Replace prefix - to internal negative operator
+        parts = parts.map((part, i) => {
+            if (part.type !== 'operator' || part.value !== '-' || i && parts[i - 1].type !== 'operator')
+                return part;
+            return { type: 'operator', value: 'n' };
+        });
+        //Validate tokens order
+        let operator = false;
+        for (const part of parts) {
+            if (part.type === 'operator') {
+                if (operatorsPrefix.includes(part.value))
+                    continue;
+                if (!operator)
+                    throw new Error('Expression contains an operator in invalid position');
+                if (!operators.includes(part.value))
+                    throw new Error(`Expression contains an unknown operator ${part.value}`);
+            }
+            else if (operator) {
+                throw new Error('Expression missing expected operator');
+            }
+            operator = !operator;
+        }
+        if (!operator)
+            throw new Error('Expression contains invalid trailing operator');
+        //Identify single part
+        if (parts.length === 1 && ['reference', 'literal', 'constant'].includes(parts[0].type)) {
+            this.single = { type: parts[0].type === 'reference' ? 'reference' : 'value', value: parts[0].value };
+        }
+        //Process parts
+        this._parts = parts.map((part) => {
+            //Operators
+            if (part.type === 'operator')
+                return operatorsPrefix.includes(part.value) ? part : part.value;
+            //Literals, constants, segments
+            if (part.type !== 'reference')
+                return part.value;
+            //References
+            if (this.settings.tokenRx && !this.settings.tokenRx.test(part.value))
+                throw new Error(`Expression contains invalid reference ${part.value}`);
+            if (this.settings.reference)
+                return this.settings.reference(part.value);
+            return reference(part.value);
+        });
+    }
+    _subExpression(string, name) {
+        const method = this.settings.functions[name];
+        if (typeof method !== 'function')
+            throw new Error(`Expression contains unknown function ${name}`);
+        const rawArgs = [];
+        if (string) {
+            let current = '';
+            let parenthesis = 0;
+            let literal = false;
+            const flush = () => {
+                if (!current)
+                    throw new Error(`Expression contains function ${name} with invalid arguments ${string}`);
+                rawArgs.push(current);
+                current = '';
+            };
+            for (let i = 0; i < string.length; ++i) {
+                const c = string[i];
+                if (literal) {
+                    current += c;
+                    if (c === literal)
+                        literal = false;
+                }
+                else if (c in literals && !parenthesis) {
+                    current += c;
+                    literal = literals[c];
+                }
+                else if (c === ',' && !parenthesis) {
+                    flush();
+                }
+                else {
+                    current += c;
+                    if (c === '(') {
+                        ++parenthesis;
+                    }
+                    else if (c === ')') {
+                        --parenthesis;
+                    }
+                }
+            }
+            flush();
+        }
+        const args = rawArgs.map((arg) => new Parser(arg, this.settings));
+        return function (context) {
+            const innerValues = [];
+            for (const arg of args)
+                innerValues.push(arg.evaluate(context));
+            return method.call(context, ...innerValues);
+        };
+    }
+    /**
+     * Evaluate the expression against a context
+     * @param context
+     */
+    evaluate(context) {
+        const parts = this._parts.slice();
+        //Prefix operators
+        for (let i = parts.length - 2; i >= 0; --i) {
+            const part = parts[i];
+            if (isPrefixOperator(part)) {
+                const current = parts[i + 1];
+                parts.splice(i + 1, 1);
+                const value = evaluatePart(current, context);
+                parts[i] = single(part.value, value);
+            }
+        }
+        //Left-right operators
+        operatorsOrder.forEach((set) => {
+            for (let i = 1; i < parts.length - 1;) {
+                if (set.includes(parts[i])) {
+                    const operator = parts[i];
+                    const left = evaluatePart(parts[i - 1], context);
+                    const right = evaluatePart(parts[i + 1], context);
+                    parts.splice(i, 2);
+                    const result = calculate(operator, left, right);
+                    //Convert -0
+                    parts[i - 1] = result === 0 ? 0 : result;
+                }
+                else {
+                    i += 2;
+                }
+            }
+        });
+        return evaluatePart(parts[0], context);
+    }
+}
+Object.defineProperty(Parser.prototype, expressionSymbol, { value: true, writable: true, enumerable: true, configurable: true });
+function isPrefixOperator(part) {
+    return !!part && part.type === 'operator';
+}
+function reference(name) {
+    return function (context) {
+        return context && context[name] !== undefined ? context[name] : null;
+    };
+}
+function evaluatePart(part, context) {
+    if (part === null)
+        return null;
+    if (typeof part === 'function')
+        return part(context);
+    if (part[expressionSymbol])
+        return part.evaluate(context);
+    return part;
+}
+function single(operator, value) {
+    if (operator === '!')
+        return value ? false : true;
+    //operator === 'n'
+    const negative = -value;
+    //Override -0
+    if (negative === 0)
+        return 0;
+    return negative;
+}
+function exists(value) {
+    return value !== null && value !== undefined;
+}
+/**
+ * Apply an infix operator, with JavaScript's operand coercion
+ * @param operator
+ * @param left
+ * @param right
+ */
+function calculate(operator, left, right) {
+    if (operator === '??')
+        return exists(left) ? left : right;
+    //Operands are coerced by JavaScript at runtime, the number casts only satisfy the type checker
+    const l = left;
+    const r = right;
+    if (typeof left === 'string' || typeof right === 'string') {
+        if (operator === '+')
+            return (exists(left) ? left : '') + (exists(right) ? right : '');
+    }
+    else {
+        switch (operator) {
+            case '^':
+                return Math.pow(l, r);
+            case '*':
+                return l * r;
+            case '/':
+                return l / r;
+            case '%':
+                return l % r;
+            case '+':
+                return l + r;
+            case '-':
+                return l - r;
+        }
+    }
+    switch (operator) {
+        case '<':
+            return l < r;
+        case '<=':
+            return l <= r;
+        case '>':
+            return l > r;
+        case '>=':
+            return l >= r;
+        case '==':
+            return left === right;
+        case '!=':
+            return left !== right;
+        case '&&':
+            return left && right;
+        case '||':
+            return left || right;
+    }
+    return null;
+}

package/dist/esm/lib/validation/engine/json-schema/combinations.js

@@ -0,0 +1,30 @@
+/**
+ * Derived from combinations 1.0.0 index.js (MIT, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * The combinations of the items of an array, by increasing size (from min to the size below the array length),
+ * then the array itself when max reaches its length
+ * @param a
+ * @param min
+ * @param max
+ */
+export function combinations(a, min, max) {
+    min = min || 1;
+    //Like upstream: max only decides whether the whole array (the same array, not a copy) is added
+    max = max < a.length ? max : a.length;
+    const fn = (n, src, got, all) => {
+        if (n == 0) {
+            if (got.length > 0)
+                all[all.length] = got;
+            return;
+        }
+        for (let j = 0; j < src.length; j++)
+            fn(n - 1, src.slice(j + 1), got.concat([src[j]]), all);
+    };
+    const all = [];
+    for (let i = min; i < a.length; i++)
+        fn(i, a, [], all);
+    if (a.length == max)
+        all.push(a);
+    return all;
+}