@lakutata/entrypoint 3.0.0-beta.0

package/dist/cjs/lib/UnsetValue.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Derived from index.js of unset-value 2.0.1, has-value 2.0.2, get-value 3.0.1, has-values 2.0.1, kind-of 6.0.3 and
+ * isobject 4.1.1 (MIT, see THIRD_PARTY_NOTICES.md): the removal of the properties of the patterns from the inputs of
+ * the actions, as 2.x
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsetValue = unsetValue;
+function isObjectValue(val) {
+    return val != null && typeof val === 'object' && !Array.isArray(val);
+}
+/**
+ * The type of a value (kind-of)
+ * @param val
+ */
+function kindOf(val) {
+    if (val === undefined)
+        return 'undefined';
+    if (val === null)
+        return 'null';
+    const type = typeof val;
+    if (type === 'boolean' || type === 'string' || type === 'number' || type === 'symbol')
+        return type;
+    if (type === 'function')
+        return ctorName(val) === 'GeneratorFunction' ? 'generatorfunction' : 'function';
+    if (Array.isArray(val))
+        return 'array';
+    if (val.constructor && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val))
+        return 'buffer';
+    if (isArguments(val))
+        return 'arguments';
+    if (val instanceof Date || (typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function'))
+        return 'date';
+    if (val instanceof Error || (typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number'))
+        return 'error';
+    if (val instanceof RegExp || (typeof val.flags === 'string' && typeof val.ignoreCase === 'boolean' && typeof val.multiline === 'boolean' && typeof val.global === 'boolean'))
+        return 'regexp';
+    switch (ctorName(val)) {
+        case 'Symbol':
+            return 'symbol';
+        case 'Promise':
+            return 'promise';
+        case 'WeakMap':
+            return 'weakmap';
+        case 'WeakSet':
+            return 'weakset';
+        case 'Map':
+            return 'map';
+        case 'Set':
+            return 'set';
+        case 'Int8Array':
+        case 'Uint8Array':
+        case 'Uint8ClampedArray':
+        case 'Int16Array':
+        case 'Uint16Array':
+        case 'Int32Array':
+        case 'Uint32Array':
+        case 'Float32Array':
+        case 'Float64Array':
+            return ctorName(val).toLowerCase();
+    }
+    if (typeof val.throw === 'function' && typeof val.return === 'function' && typeof val.next === 'function')
+        return 'generator';
+    const tag = Object.prototype.toString.call(val);
+    switch (tag) {
+        case '[object Object]':
+            return 'object';
+        case '[object Map Iterator]':
+            return 'mapiterator';
+        case '[object Set Iterator]':
+            return 'setiterator';
+        case '[object String Iterator]':
+            return 'stringiterator';
+        case '[object Array Iterator]':
+            return 'arrayiterator';
+    }
+    return tag.slice(8, -1).toLowerCase().replace(/\s/g, '');
+}
+function ctorName(val) {
+    return typeof val.constructor === 'function' ? val.constructor.name : null;
+}
+function isArguments(val) {
+    try {
+        if (typeof val.length === 'number' && typeof val.callee === 'function')
+            return true;
+    }
+    catch (error) {
+        if (error.message.indexOf('callee') !== -1)
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether a value has a value (has-values): not undefined, an empty string, array, object, map or set, an empty
+ * regular expression, buffer or error message
+ * @param val
+ */
+function hasValues(val) {
+    switch (kindOf(val)) {
+        case 'boolean':
+        case 'date':
+        case 'function':
+        case 'null':
+        case 'number':
+            return true;
+        case 'undefined':
+            return false;
+        case 'regexp':
+            return val.source !== '(?:)' && val.source !== '';
+        case 'buffer':
+            return val.toString() !== '';
+        case 'error':
+            return val.message !== '';
+        case 'string':
+        case 'arguments':
+            return val.length !== 0;
+        case 'file':
+        case 'map':
+        case 'set':
+            return val.size !== 0;
+        case 'array':
+        case 'object':
+            for (const key of Object.keys(val))
+                if (hasValues(val[key]))
+                    return true;
+            return false;
+        default:
+            return true;
+    }
+}
+function isValidObject(val) {
+    return isObjectValue(val) || Array.isArray(val) || typeof val === 'function';
+}
+/**
+ * The value of a path (get-value): a key holding the whole path first, the keys escaping their dots ("a\.b"), the keys
+ * containing dots
+ * @param target
+ * @param path
+ */
+function getValue(target, path) {
+    if (!isValidObject(target))
+        return target;
+    const isArray = Array.isArray(path);
+    if (typeof path !== 'string' && !isArray)
+        return target;
+    if (typeof path === 'string' && path in target)
+        return target[path];
+    const segs = isArray ? path : path.split('.');
+    const len = segs.length;
+    let idx = 0;
+    do {
+        let prop = segs[idx];
+        if (typeof prop === 'number')
+            prop = String(prop);
+        while (prop && prop.slice(-1) === '\\')
+            prop = prop.slice(0, -1) + '.' + (segs[++idx] || '');
+        if (prop in target) {
+            target = target[prop];
+        }
+        else {
+            let hasProp = false;
+            let n = idx + 1;
+            while (n < len) {
+                prop = prop + '.' + segs[n++];
+                if ((hasProp = prop in target)) {
+                    target = target[prop];
+                    idx = n - 1;
+                    break;
+                }
+            }
+            if (!hasProp)
+                return undefined;
+        }
+    } while (++idx < len && isValidObject(target));
+    return idx === len ? target : undefined;
+}
+/**
+ * Whether a path has a value (has-value)
+ * @param obj
+ * @param path
+ */
+function hasValue(obj, path) {
+    const isObject = obj != null && (typeof obj === 'object' || typeof obj === 'function');
+    if (isObject && (typeof path === 'string' || Array.isArray(path)))
+        return hasValues(getValue(obj, path));
+    return false;
+}
+/**
+ * Remove a property of an object by its path (unset-value): a key holding the whole path first, the keys escaping
+ * their dots ("a\.b"); a property without value (has-value) is kept
+ * @param obj
+ * @param prop
+ */
+function unsetValue(obj, prop) {
+    if (!isObjectValue(obj))
+        throw new TypeError('expected an object.');
+    const isArray = Array.isArray(prop);
+    if (!isArray && Object.prototype.hasOwnProperty.call(obj, prop)) {
+        delete obj[prop];
+        return true;
+    }
+    if (hasValue(obj, prop)) {
+        const segs = isArray ? prop.slice() : prop.split('.');
+        let last = segs.pop();
+        while (segs.length && segs[segs.length - 1].slice(-1) === '\\')
+            last = segs.pop().slice(0, -1) + '.' + last;
+        while (segs.length) {
+            const key = segs.shift();
+            if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+                throw new Error(`Cannot set unsafe key: "${key}"`);
+            obj = obj[key];
+        }
+        return delete obj[last];
+    }
+    return true;
+}

package/dist/cjs/lib/pattern/GlobPattern.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A glob of the value of a pattern: "*" matches any characters, "?" one character, "**" is a literal "*" and "*?" a
+ * literal "?". It matches a whole value, converted to a string
+ */
+export declare class GlobPattern {
+    #private;
+    readonly glob: unknown;
+    /**
+     * Whether a value of a pattern is a glob
+     * @param value
+     */
+    static isGlob(value: string): boolean;
+    /**
+     * @param glob the glob, nothing is matched without it
+     */
+    constructor(glob: unknown);
+    /**
+     * The regular expression of a glob
+     * @param glob
+     */
+    protected static expression(glob: string): RegExp;
+    /**
+     * Whether the glob matches a value converted to a string
+     * @param value
+     */
+    test(value: unknown): boolean;
+    /**
+     * Whether the glob matches the value of a subject: a missing value is not matched, a primitive value (a date, a
+     * regular expression) is matched as a string. An array or an object is always matched, as gex does (it gives back
+     * the collection of its matching elements, which is never null): the routing of the actions is the one of 2.x
+     * @param value
+     */
+    matches(value: unknown): boolean;
+}

package/dist/cjs/lib/pattern/GlobPattern.js

@@ -0,0 +1,68 @@
+"use strict";
+/*
+ * The glob matching of the values of the patterns, rewritten from gex (Copyright (c) 2011-2020 Richard Rodger, MIT
+ * License, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobPattern = void 0;
+/**
+ * A glob of the value of a pattern: "*" matches any characters, "?" one character, "**" is a literal "*" and "*?" a
+ * literal "?". It matches a whole value, converted to a string
+ */
+class GlobPattern {
+    /**
+     * The expression of the glob, undefined when it matches nothing (no glob)
+     */
+    #expression;
+    /**
+     * Whether a value of a pattern is a glob
+     * @param value
+     */
+    static isGlob(value) {
+        return /[*?]/.test(value);
+    }
+    /**
+     * @param glob the glob, nothing is matched without it
+     */
+    constructor(glob) {
+        this.glob = glob;
+        //NaN is the empty glob, as gex cleans it
+        this.#expression = glob === null || glob === undefined ? undefined : GlobPattern.expression(Number.isNaN(glob) ? '' : String(glob));
+    }
+    /**
+     * The regular expression of a glob
+     * @param glob
+     */
+    static expression(glob) {
+        let source = glob.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        //[\s\S] matches the line feeds too
+        source = source.replace(/\\\*/g, '[\\s\\S]*');
+        source = source.replace(/\\\?/g, '[\\s\\S]');
+        //"**" and "*?" are the literal "*" and "?"
+        source = source.replace(/\[\\s\\S\]\*\[\\s\\S\]\*/g, '\\*');
+        source = source.replace(/\[\\s\\S\]\*\[\\s\\S\]/g, '\\?');
+        return new RegExp(`^${source}$`);
+    }
+    /**
+     * Whether the glob matches a value converted to a string
+     * @param value
+     */
+    test(value) {
+        return !!this.#expression && this.#expression.test(String(value));
+    }
+    /**
+     * Whether the glob matches the value of a subject: a missing value is not matched, a primitive value (a date, a
+     * regular expression) is matched as a string. An array or an object is always matched, as gex does (it gives back
+     * the collection of its matching elements, which is never null): the routing of the actions is the one of 2.x
+     * @param value
+     */
+    matches(value) {
+        if (value === null || value === undefined)
+            return false;
+        const type = typeof value;
+        if (type === 'string' || type === 'number' || type === 'boolean' || value instanceof Date || value instanceof RegExp)
+            return this.test(value);
+        return true;
+    }
+}
+exports.GlobPattern = GlobPattern;

package/dist/cjs/lib/pattern/PatternManager.d.ts

@@ -0,0 +1,103 @@
+import { GlobPattern } from './GlobPattern.js';
+/**
+ * A pattern: its values are compared as strings
+ */
+export type Pattern = Record<string, any>;
+/**
+ * A glob of a key of a node, and the node of the patterns it matches
+ */
+type GlobBranch = {
+    glob: GlobPattern;
+    node: PatternNode;
+};
+/**
+ * A node of the decision tree: the patterns having its key are found by its value (or by a glob of it), the patterns
+ * without it are in its "star" node. The keys are ordered along the tree, as the keys of the patterns
+ */
+type PatternNode = {
+    /**
+     * The key the node decides on
+     */
+    key?: string;
+    /**
+     * The nodes of the values of the key
+     */
+    values?: Record<string, PatternNode>;
+    /**
+     * The nodes of the globs of the key
+     */
+    globs?: Record<string, GlobBranch[]>;
+    /**
+     * The node of the patterns without the key
+     */
+    star?: PatternNode;
+    /**
+     * The object of the pattern ending at the node
+     */
+    data?: unknown;
+    hasData?: boolean;
+};
+export type PatternManagerOptions = {
+    /**
+     * The values of the patterns having "*" or "?" are globs, true by default
+     */
+    globMatch?: boolean;
+};
+/**
+ * The patterns of the actions and the objects they give: a subject is matched by the most specific pattern whose
+ * properties it has (the unknown properties of the subject are ignored)
+ */
+export declare class PatternManager {
+    #private;
+    constructor(options?: PatternManagerOptions);
+    /**
+     * The glob of a value of a pattern, undefined when it is not one
+     * @param value
+     */
+    protected glob(value: string): GlobPattern | undefined;
+    /**
+     * The node of a glob of a key of a node, added once
+     * @param node
+     * @param key
+     * @param glob
+     */
+    protected globNode(node: PatternNode, key: string, glob: GlobPattern): PatternNode;
+    /**
+     * Register a pattern, and the object that will be returned if an input matches.
+     * Both keys and values are considered to be strings.
+     * Other types are converted to strings.
+     * @param pattern
+     * @param obj
+     */
+    add(pattern: Pattern, obj: any): this;
+    /**
+     * Remove this pattern, and it's object, from the matcher.
+     * @param pattern
+     */
+    remove(pattern: Pattern): this;
+    /**
+     * Return the unique match for this subject, or null if not found.
+     * The properties of the subject are matched against the patterns previously added, and the most specifc pattern wins.
+     * Unknown properties in the subject are ignored.
+     * If exact is true, then all properties of the subject must match.
+     * @param subject
+     * @param exact
+     */
+    find(subject: Pattern, exact?: boolean): any;
+    /**
+     * Return the list of registered patterns that contain this partial pattern.
+     * You can use wildcards for property values.
+     * Omitted values are not equivalent to a wildcard of "*", you must specify each property explicitly.
+     * @param partialPattern
+     * @param exact the omitted properties match nothing
+     */
+    list(partialPattern?: Pattern, exact?: boolean): {
+        match: Record<string, any>;
+        data: any;
+    }[];
+    /**
+     * Generate a string representation of the decision tree for debugging.
+     */
+    toJSON(): string;
+}
+export {};

package/dist/cjs/lib/pattern/PatternManager.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternManager = void 0;
+/*
+ * The matching of the patterns, rewritten from patrun (Copyright (c) 2013-2022 Richard Rodger, MIT License, see
+ * THIRD_PARTY_NOTICES.md): the same decision tree, the same results
+ */
+const GlobPattern_js_1 = require("./GlobPattern.js");
+/**
+ * A dictionary without prototype: the values of the subjects are never the properties of Object ("constructor"…)
+ */
+function dictionary() {
+    return Object.create(null);
+}
+/**
+ * The patterns of the actions and the objects they give: a subject is matched by the most specific pattern whose
+ * properties it has (the unknown properties of the subject are ignored)
+ */
+class PatternManager {
+    #globMatch;
+    #top = {};
+    constructor(options = { globMatch: true }) {
+        this.#globMatch = !!options.globMatch;
+    }
+    /**
+     * The glob of a value of a pattern, undefined when it is not one
+     * @param value
+     */
+    glob(value) {
+        return this.#globMatch && GlobPattern_js_1.GlobPattern.isGlob(value) ? new GlobPattern_js_1.GlobPattern(value) : undefined;
+    }
+    /**
+     * The node of a glob of a key of a node, added once
+     * @param node
+     * @param key
+     * @param glob
+     */
+    globNode(node, key, glob) {
+        const globs = node.globs ??= dictionary();
+        const branches = globs[key] ??= [];
+        let branch = branches.find((candidate) => candidate.glob.glob === glob.glob);
+        if (!branch)
+            branches.push(branch = { glob: glob, node: {} });
+        return branch.node;
+    }
+    /**
+     * Register a pattern, and the object that will be returned if an input matches.
+     * Both keys and values are considered to be strings.
+     * Other types are converted to strings.
+     * @param pattern
+     * @param obj
+     */
+    add(pattern, obj) {
+        const keys = Object.keys(pattern).filter((key) => pattern[key] !== null && pattern[key] !== undefined).sort();
+        const values = Object.fromEntries(keys.map((key) => [key, String(pattern[key])]));
+        let node = this.#top;
+        //The keys of the path are ordered: a key is inserted before the next key of the path, or follows the star nodes
+        for (let index = 0; index < keys.length; index++) {
+            const key = keys[index];
+            const value = values[key];
+            const glob = this.glob(value);
+            if (node.values && node.key === key) {
+                //The key of the node
+                node = glob ? this.globNode(node, key, glob) : node.values[value] ??= {};
+            }
+            else if (!node.key) {
+                //The end of the path: the key is the last one
+                node.key = key;
+                node.values = dictionary();
+                node = glob ? this.globNode(node, key, glob) : node.values[value] = {};
+            }
+            else if (key < node.key) {
+                //The key orders before the key of the node: the node moves to the star node of the key
+                const { star, globs } = node;
+                node.star = { key: node.key, values: node.values };
+                if (star)
+                    node.star.star = star;
+                if (globs)
+                    node.star.globs = globs;
+                if (node.globs)
+                    node.globs = dictionary();
+                node.key = key;
+                node.values = dictionary();
+                node = glob ? this.globNode(node, key, glob) : node.values[value] = {};
+            }
+            else {
+                //The key orders after the key of the node: it is in the path of the patterns without the key of the node
+                node = node.star ??= {};
+                index--;
+            }
+        }
+        if (obj !== undefined) {
+            node.data = obj;
+            node.hasData = true;
+        }
+        return this;
+    }
+    /**
+     * Remove this pattern, and it's object, from the matcher.
+     * @param pattern
+     */
+    remove(pattern) {
+        let node = this.#top;
+        let data = undefined;
+        let hasData = false;
+        let last = undefined;
+        do {
+            const key = node.key;
+            if (node.values || node.globs) {
+                let next = node.values?.[pattern[key]];
+                if (next)
+                    last = next;
+                if (!next && node.globs) {
+                    const branch = (node.globs[key] ?? []).find((candidate) => candidate.glob.glob === pattern[key]);
+                    if (branch)
+                        last = next = branch.node;
+                }
+                if (next) {
+                    data = next.data;
+                    hasData = !!next.hasData;
+                    node = next;
+                }
+                else {
+                    node = node.star;
+                }
+            }
+            else {
+                node = undefined;
+            }
+        } while (node);
+        if (hasData && data !== undefined && last) {
+            delete last.data;
+            delete last.hasData;
+        }
+        return this;
+    }
+    /**
+     * Return the unique match for this subject, or null if not found.
+     * The properties of the subject are matched against the patterns previously added, and the most specifc pattern wins.
+     * Unknown properties in the subject are ignored.
+     * If exact is true, then all properties of the subject must match.
+     * @param subject
+     * @param exact
+     */
+    find(subject, exact = false) {
+        if (subject === null || subject === undefined)
+            return null;
+        const top = this.#top;
+        let node = top;
+        let data = top.hasData ? top.data : null;
+        const stars = [];
+        const found = exact ? new Set() : undefined;
+        do {
+            const key = node.key;
+            if (node.values) {
+                const value = subject[key];
+                //The value itself (converted to a string, as the key of a dictionary), else a glob of it
+                let next = node.values[value];
+                if (!next && node.globs?.[key])
+                    next = node.globs[key].find((branch) => branch.glob.matches(value))?.node;
+                if (next) {
+                    found?.add(key);
+                    if (node.star)
+                        stars.push(node.star);
+                    data = next.hasData ? next.data : (exact ? null : data);
+                    node = next;
+                }
+                else {
+                    //The patterns without the key
+                    node = node.star;
+                }
+            }
+            else {
+                node = undefined;
+            }
+            //The wider patterns, when the narrower ones gave nothing
+            if (!node && stars.length && (data === null || data === undefined))
+                node = stars.pop();
+        } while (node);
+        if (exact) {
+            if (found.size !== Object.keys(subject).length)
+                data = null;
+        }
+        else if ((data === null || data === undefined) && top.hasData) {
+            //The object of the empty pattern matches everything
+            data = top.data;
+        }
+        return data;
+    }
+    /**
+     * Return the list of registered patterns that contain this partial pattern.
+     * You can use wildcards for property values.
+     * Omitted values are not equivalent to a wildcard of "*", you must specify each property explicitly.
+     * @param partialPattern
+     * @param exact the omitted properties match nothing
+     */
+    list(partialPattern, exact = false) {
+        const pattern = partialPattern ?? {};
+        const results = [];
+        const descend = (node, match, missing) => {
+            if (!node.values)
+                return;
+            const key = node.key;
+            const glob = new GlobPattern_js_1.GlobPattern(pattern[key] === null || pattern[key] === undefined ? (exact ? null : '*') : pattern[key]);
+            for (const value in node.values) {
+                //The empty value is not matched by a glob (gex gives back the matched value, which is falsy)
+                if (value === pattern[key] || (!exact && (pattern[key] === null || pattern[key] === undefined)) || (value !== '' && glob.test(value))) {
+                    const valueMatch = { ...match, [key]: value };
+                    const valueMissing = { ...missing };
+                    delete valueMissing[key];
+                    const next = node.values[value];
+                    if (!Object.keys(valueMissing).length && next.hasData && next.data)
+                        results.push({ match: valueMatch, data: next.data });
+                    if (next.values)
+                        descend(next, { ...valueMatch }, { ...valueMissing });
+                }
+            }
+            if (node.star)
+                descend(node.star, { ...match }, { ...missing });
+        };
+        if (this.#top.hasData && this.#top.data)
+            results.push({ match: {}, data: this.#top.data });
+        descend(this.#top, {}, { ...pattern });
+        return results;
+    }
+    /**
+     * Generate a string representation of the decision tree for debugging.
+     */
+    toJSON() {
+        return JSON.stringify(this.#top, (key, value) => value instanceof GlobPattern_js_1.GlobPattern ? String(value.glob) : (key === 'hasData' ? undefined : value));
+    }
+}
+exports.PatternManager = PatternManager;