@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/esm/lib/validation/engine/schema/values.js

@@ -0,0 +1,164 @@
+/**
+ * Derived from the upstream lib/values.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { deepEqual, isArray } from '../utils/index.js';
+import { assert } from './assert.js';
+import * as Common from './common.js';
+function lowercases(from) {
+    const map = new Map();
+    if (from) {
+        for (const value of from) {
+            if (typeof value === 'string')
+                map.set(value.toLowerCase(), value);
+        }
+    }
+    return map;
+}
+/**
+ * A set of allowed (valid) or forbidden (invalid) values and references
+ */
+export class Values {
+    constructor(values, refs) {
+        this._values = new Set(values);
+        this._refs = new Set(refs);
+        this._lowercase = lowercases(values);
+        this._override = false;
+    }
+    get length() {
+        return this._values.size + this._refs.size;
+    }
+    add(value, refs) {
+        //Reference
+        if (Common.isResolvable(value)) {
+            if (!this._refs.has(value)) {
+                this._refs.add(value);
+                //Skipped in a merge
+                if (refs)
+                    refs.register(value);
+            }
+            return;
+        }
+        //Value
+        if (!this.has(value, null, null, false)) {
+            this._values.add(value);
+            if (typeof value === 'string')
+                this._lowercase.set(value.toLowerCase(), value);
+        }
+    }
+    static merge(target, source, remove) {
+        const merged = target || new Values();
+        if (source) {
+            if (source._override)
+                return source.clone();
+            for (const item of [...source._values, ...source._refs])
+                merged.add(item);
+        }
+        if (remove) {
+            for (const item of [...remove._values, ...remove._refs])
+                merged.remove(item);
+        }
+        return merged.length ? merged : null;
+    }
+    remove(value) {
+        //Reference
+        if (Common.isResolvable(value)) {
+            this._refs.delete(value);
+            return;
+        }
+        //Value
+        this._values.delete(value);
+        if (typeof value === 'string')
+            this._lowercase.delete(value.toLowerCase());
+    }
+    has(value, state, prefs, insensitive) {
+        return !!this.get(value, state, prefs, insensitive);
+    }
+    get(value, state, prefs, insensitive) {
+        if (!this.length)
+            return false;
+        //Simple match
+        if (this._values.has(value))
+            return { value };
+        //Case insensitive string match
+        if (typeof value === 'string' && value && insensitive) {
+            const found = this._lowercase.get(value.toLowerCase());
+            if (found)
+                return { value: found };
+        }
+        if (!this._refs.size && typeof value !== 'object')
+            return false;
+        //Objects
+        if (typeof value === 'object') {
+            for (const item of this._values) {
+                if (deepEqual(item, value))
+                    return { value: item };
+            }
+        }
+        //References
+        if (state) {
+            for (const ref of this._refs) {
+                const resolved = ref.resolve(value, state, prefs, null, { in: true });
+                if (resolved === undefined)
+                    continue;
+                const items = !ref.in || typeof resolved !== 'object'
+                    ? [resolved]
+                    : isArray(resolved) ? resolved : Object.keys(resolved);
+                for (const item of items) {
+                    if (typeof item !== typeof value)
+                        continue;
+                    if (insensitive && value && typeof value === 'string') {
+                        if (item.toLowerCase() === value.toLowerCase())
+                            return { value: item, ref };
+                    }
+                    else {
+                        if (deepEqual(item, value))
+                            return { value: item, ref };
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    override() {
+        this._override = true;
+    }
+    values(options) {
+        if (options && options.display) {
+            const values = [];
+            for (const item of [...this._values, ...this._refs]) {
+                if (item !== undefined)
+                    values.push(item);
+            }
+            return values;
+        }
+        return Array.from([...this._values, ...this._refs]);
+    }
+    clone() {
+        const set = new Values(this._values, this._refs);
+        set._override = this._override;
+        return set;
+    }
+    /**
+     * Alias of clone()
+     */
+    slice() {
+        return this.clone();
+    }
+    concat(source) {
+        assert(!source._override, 'Cannot concat override set of values');
+        const set = new Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
+        set._override = this._override;
+        return set;
+    }
+    describe() {
+        const normalized = [];
+        if (this._override)
+            normalized.push({ override: true });
+        for (const value of this._values.values())
+            normalized.push(value && typeof value === 'object' ? { value } : value);
+        for (const value of this._refs.values())
+            normalized.push(value.describe());
+        return normalized;
+    }
+}
+Object.defineProperty(Values.prototype, Common.symbols.values, { value: true, writable: true, enumerable: true, configurable: true });

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

@@ -0,0 +1,176 @@
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../utils/index.js';
+/**
+ * Keep arrays as they are, wrap a single value
+ * @param value
+ */
+function toArray(value) {
+    return [].concat(value);
+}
+function mergeSort(a, b) {
+    return a.sort === b.sort ? 0 : (a.sort < b.sort ? -1 : 1);
+}
+/**
+ * Topological sorter of nodes with group dependencies
+ */
+export class Sorter {
+    constructor() {
+        this.nodes = [];
+        this._items = [];
+    }
+    /**
+     * Add nodes, returning the sorted nodes
+     * @param nodes
+     * @param options
+     */
+    add(nodes, options) {
+        const settings = options ?? {};
+        //Validate rules
+        const before = toArray(settings.before ?? []);
+        const after = toArray(settings.after ?? []);
+        const group = settings.group ?? '?';
+        //Used for merging only
+        const sort = settings.sort ?? 0;
+        assert(!before.includes(group), `Item cannot come before itself: ${group}`);
+        assert(!before.includes('?'), 'Item cannot come before unassociated items');
+        assert(!after.includes(group), `Item cannot come after itself: ${group}`);
+        assert(!after.includes('?'), 'Item cannot come after unassociated items');
+        for (const node of toArray(nodes)) {
+            this._items.push({
+                seq: this._items.length,
+                sort,
+                before,
+                after,
+                group,
+                node
+            });
+        }
+        //Insert event
+        if (!settings.manual) {
+            const valid = this._sort();
+            assert(valid, 'item', group !== '?' ? `added into group ${group}` : '', 'created a dependencies error');
+        }
+        return this.nodes;
+    }
+    /**
+     * Merge other sorters into this one, returning the sorted nodes
+     * @param others
+     */
+    merge(others) {
+        for (const other of toArray(others)) {
+            if (other) {
+                //Shallow cloned
+                for (const item of other._items)
+                    this._items.push({ ...item });
+            }
+        }
+        //Sort items
+        this._items.sort(mergeSort);
+        for (let i = 0; i < this._items.length; ++i)
+            this._items[i].seq = i;
+        const valid = this._sort();
+        assert(valid, 'merge created a dependencies error');
+        return this.nodes;
+    }
+    /**
+     * Sort the nodes (when added with manual), returning the sorted nodes
+     */
+    sort() {
+        const valid = this._sort();
+        assert(valid, 'sort created a dependencies error');
+        return this.nodes;
+    }
+    _sort() {
+        //Construct graph (keys are item.seq values, stored as object keys like upstream)
+        const beforeGraph = {};
+        //A prototype can bungle lookups w/ false positives
+        const graphAfters = Object.create(null);
+        const groups = Object.create(null);
+        for (const item of this._items) {
+            //Unique across all items
+            const seq = item.seq;
+            const group = item.group;
+            //Determine Groups
+            groups[group] = groups[group] ?? [];
+            groups[group].push(seq);
+            //Build intermediary graph using 'before'
+            beforeGraph[seq] = item.before;
+            //Build second intermediary graph with 'after'
+            for (const after of item.after) {
+                graphAfters[after] = graphAfters[after] ?? [];
+                graphAfters[after].push(seq);
+            }
+        }
+        //Expand intermediary graph
+        const graph = {};
+        for (const node in beforeGraph) {
+            const expandedGroups = [];
+            for (const group of beforeGraph[node]) {
+                groups[group] = groups[group] ?? [];
+                expandedGroups.push(...groups[group]);
+            }
+            graph[node] = expandedGroups;
+        }
+        //Merge intermediary graph using graphAfters into final graph
+        for (const group in graphAfters) {
+            if (groups[group]) {
+                for (const node of groups[group])
+                    graph[node].push(...graphAfters[group]);
+            }
+        }
+        //Compile ancestors
+        const ancestors = {};
+        for (const node in graph) {
+            for (const child of graph[node]) {
+                ancestors[child] = ancestors[child] ?? [];
+                ancestors[child].push(node);
+            }
+        }
+        //Topological sort
+        const visited = {};
+        const sorted = [];
+        //Looping through item.seq values out of order
+        for (let i = 0; i < this._items.length; ++i) {
+            let next = i;
+            if (ancestors[i]) {
+                next = null;
+                //As above, these are item.seq values
+                for (let j = 0; j < this._items.length; ++j) {
+                    if (visited[j] === true)
+                        continue;
+                    if (!ancestors[j])
+                        ancestors[j] = [];
+                    const shouldSeeCount = ancestors[j].length;
+                    let seenCount = 0;
+                    for (let k = 0; k < shouldSeeCount; ++k) {
+                        if (visited[ancestors[j][k]])
+                            ++seenCount;
+                    }
+                    if (seenCount === shouldSeeCount) {
+                        next = j;
+                        break;
+                    }
+                }
+            }
+            if (next !== null) {
+                visited[next] = true;
+                sorted.push(next);
+            }
+        }
+        if (sorted.length !== this._items.length)
+            return false;
+        const seqIndex = {};
+        for (const item of this._items)
+            seqIndex[item.seq] = item;
+        this._items = [];
+        this.nodes = [];
+        for (const value of sorted) {
+            const sortedItem = seqIndex[value];
+            this.nodes.push(sortedItem.node);
+            this._items.push(sortedItem);
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Derived from the upstream src/index.ts (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { TLDS } from './tlds.js';
+export const tlds = new Set(TLDS.map((tld) => tld.toLowerCase()));