@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/validation/engine/expression/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Value of a expression constant
+ */
+export type ExpressionConstant = string | number | boolean | null;
+/**
+ * Function evaluating a expression part against a context
+ */
+export type ExpressionEvaluator = (context: unknown) => unknown;
+/**
+ * Function callable from a expression, `this` is the evaluation context
+ */
+export type ExpressionFunction = (this: unknown, ...args: unknown[]) => unknown;
+export interface ParserOptions {
+    /**
+     * Constants the expression may reference by name
+     */
+    readonly constants?: Record<string, ExpressionConstant>;
+    /**
+     * Regular expression every reference must match
+     */
+    readonly tokenRx?: RegExp;
+    /**
+     * Resolver of references, defaults to reading the reference from the context
+     */
+    readonly reference?: (name: string) => ExpressionEvaluator;
+    /**
+     * Functions the expression may call by name
+     */
+    readonly functions?: Record<string, ExpressionFunction>;
+}
+declare const settingsSymbol: unique symbol;
+interface ParserSettings extends ParserOptions {
+    readonly [settingsSymbol]: true;
+    readonly constants: Record<string, ExpressionConstant>;
+    readonly functions: Record<string, ExpressionFunction>;
+}
+/**
+ * A prefix operator ('!' or 'n', the internal negative operator), kept as a part until evaluation
+ */
+interface PrefixOperator {
+    type: 'operator';
+    value: string;
+}
+/**
+ * A processed part: an infix operator (string), a prefix operator, or an operand
+ */
+type ProcessedPart = string | PrefixOperator | ExpressionConstant | Parser | ExpressionEvaluator;
+/**
+ * A expression parsed into parts, evaluated against a context
+ */
+export declare class Parser<T = unknown> {
+    settings: ParserSettings;
+    single: {
+        type: 'reference' | 'value';
+        value: unknown;
+    } | null;
+    protected _parts: ProcessedPart[] | null;
+    constructor(string: string, options?: ParserOptions | ParserSettings);
+    protected _parse(string: string): void;
+    protected _subExpression(string: string, name: string): ExpressionEvaluator;
+    /**
+     * Evaluate the expression against a context
+     * @param context
+     */
+    evaluate(context?: unknown): T;
+}
+export {};

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

@@ -0,0 +1,356 @@
+"use strict";
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+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
+ */
+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);
+    }
+}
+exports.Parser = Parser;
+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/cjs/lib/validation/engine/json-schema/combinations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 declare function combinations<T>(a: T[], min?: number, max?: number): T[][];

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

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Derived from combinations 1.0.0 index.js (MIT, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combinations = combinations;
+/**
+ * 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
+ */
+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;
+}

package/dist/cjs/lib/validation/engine/json-schema/helpers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Native equivalents of the lodash 4.17.21 collection functions used by the upstream JSON Schema conversion (see
+ * UPSTREAM.md; lodash and the upstream library: MIT, see THIRD_PARTY_NOTICES.md). Each function keeps the lodash
+ * semantics for the values the parsers pass
+ * (plain objects, arrays, strings, null and undefined); merge() follows lodash's merge algorithm.
+ */
+/**
+ * The value at a dotted path, or undefined when a segment is missing (a key present as is in the object wins)
+ * @param object
+ * @param path
+ */
+export declare function get(object: unknown, path: string): unknown;
+/**
+ * Set the value at a dotted path, creating the missing objects (arrays for index segments)
+ * @param object
+ * @param path
+ * @param value
+ */
+export declare function set<T extends object>(object: T, path: string, value: unknown): T;
+/**
+ * Whether a value is empty: no length (array-likes), no size (maps, sets) or no own enumerable key (objects)
+ * @param value
+ */
+export declare function isEmpty(value: unknown): boolean;
+/**
+ * Map a collection (array-likes by index, objects by own enumerable key); nothing for null or undefined
+ * @param collection
+ * @param iteratee
+ */
+export declare function map<T, R>(collection: readonly T[] | Record<string, T> | null | undefined, iteratee: (value: T, key: number | string) => R): R[];
+/**
+ * Iterate a collection (array-likes by index, objects by own enumerable key), until the iteratee returns false
+ * @param collection
+ * @param iteratee
+ */
+export declare function each<T>(collection: readonly T[] | Record<string, T> | null | undefined, iteratee: (value: T, key: number | string) => unknown): void;
+/**
+ * The number of items of a collection (length, size or own enumerable keys)
+ * @param collection
+ */
+export declare function size(collection: unknown): number;
+/**
+ * The unique values of an array (SameValueZero), in order
+ * @param array
+ */
+export declare function uniq<T>(array: readonly T[] | null | undefined): T[];
+/**
+ * Remove (in place) the items of an array matching a predicate, returning them
+ * @param array
+ * @param predicate
+ */
+export declare function remove<T>(array: T[] | null | undefined, predicate: (value: T, index: number, array: T[]) => unknown): T[];
+/**
+ * The truthy items of an array
+ * @param array
+ */
+export declare function compact<T>(array: readonly (T | null | undefined | false | 0 | '')[] | null | undefined): T[];
+/**
+ * Whether an item of an array matches a predicate
+ * @param array
+ * @param predicate
+ */
+export declare function some<T>(array: readonly T[] | null | undefined, predicate: (value: T) => unknown): boolean;
+/**
+ * The properties (own and inherited enumerable) of an object matching a predicate
+ * @param object
+ * @param predicate
+ */
+export declare function pickBy<T extends object>(object: T | null | undefined, predicate: (value: unknown, key: string) => unknown): Partial<T>;
+/**
+ * Deep merge the sources into the object (lodash merge): plain objects and arrays are merged recursively (into the
+ * existing value when it is an object), other values are assigned; undefined does not replace an existing key
+ * @param object
+ * @param sources
+ */
+export declare function merge<T extends object>(object: T, ...sources: unknown[]): T;