@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,131 @@
+/**
+ * Derived from the upstream lib/messages.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, isArray } from '../utils/index.js';
+import { assert } from './assert.js';
+import { Lazy } from './lazy.js';
+import { Template } from './template.js';
+/**
+ * Compile messages into templates, merged into a copy of target
+ * @param messages
+ * @param target
+ */
+export function compile(messages, target) {
+    //Single value string ('plain error message', 'template {error} message')
+    if (typeof messages === 'string') {
+        assert(!target, 'Cannot set single message string');
+        return new Template(messages);
+    }
+    //Single value template
+    if (Template.isTemplate(messages)) {
+        assert(!target, 'Cannot set single message template');
+        return messages;
+    }
+    //By error code { 'number.min': <string | template> }
+    assert(typeof messages === 'object' && !isArray(messages), 'Invalid message options');
+    const compiled = target ? clone(target) : {};
+    for (const code in messages) {
+        const message = messages[code];
+        if (code === 'root' || Template.isTemplate(message)) {
+            compiled[code] = message;
+            continue;
+        }
+        if (typeof message === 'string') {
+            compiled[code] = new Template(message);
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        assert(typeof message === 'object' && !isArray(message), 'Invalid message for', code);
+        const language = code;
+        compiled[language] = compiled[language] || {};
+        const languageMessages = compiled[language];
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root' || Template.isTemplate(localized)) {
+                languageMessages[languageCode] = localized;
+                continue;
+            }
+            assert(typeof localized === 'string', 'Invalid message for', languageCode, 'in', language);
+            languageMessages[languageCode] = new Template(localized);
+        }
+    }
+    return compiled;
+}
+/**
+ * Describe compiled messages
+ * @param messages
+ */
+export function decompile(messages) {
+    //By error code { 'number.min': <string | template> }
+    const target = {};
+    for (const code in messages) {
+        const message = messages[code];
+        if (code === 'root') {
+            target.root = message;
+            continue;
+        }
+        if (Template.isTemplate(message)) {
+            target[code] = message.describe({ compact: true });
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        const language = code;
+        const described = {};
+        target[language] = described;
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root') {
+                described.root = localized;
+                continue;
+            }
+            described[languageCode] = localized.describe({ compact: true });
+        }
+    }
+    return target;
+}
+/**
+ * Merge extended messages into (a copy of) base messages
+ * @param base
+ * @param extended
+ */
+export function merge(base, extended) {
+    if (!base)
+        return compile(extended);
+    if (!extended)
+        return base;
+    //Single value string
+    if (typeof extended === 'string')
+        return new Template(extended);
+    //Single value template
+    if (Template.isTemplate(extended))
+        return extended;
+    //By error code { 'number.min': <string | template> }
+    const target = clone(base);
+    for (const code in extended) {
+        const message = extended[code];
+        if (code === 'root' || Template.isTemplate(message)) {
+            target[code] = message;
+            continue;
+        }
+        if (typeof message === 'string') {
+            target[code] = new Template(message);
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        assert(typeof message === 'object' && !isArray(message), 'Invalid message for', code);
+        const language = code;
+        target[language] = target[language] || {};
+        const languageMessages = target[language];
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root' || Template.isTemplate(localized)) {
+                languageMessages[languageCode] = localized;
+                continue;
+            }
+            assert(typeof localized === 'string', 'Invalid message for', languageCode, 'in', language);
+            languageMessages[languageCode] = new Template(localized);
+        }
+    }
+    return target;
+}
+Lazy.messages = { compile: (messages, target) => compile(messages, target) };

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,186 @@
+/**
+ * Derived from the upstream lib/modify.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from './assert.js';
+import * as Common from './common.js';
+import * as Ref from './ref.js';
+/**
+ * The schemas of a schema, by id and by key
+ */
+export class Ids {
+    constructor() {
+        this._byId = new Map();
+        this._byKey = new Map();
+        this._schemaChain = false;
+    }
+    clone() {
+        const clone = new Ids();
+        clone._byId = new Map(this._byId);
+        clone._byKey = new Map(this._byKey);
+        clone._schemaChain = this._schemaChain;
+        return clone;
+    }
+    concat(source) {
+        if (source._schemaChain)
+            this._schemaChain = true;
+        for (const [id, value] of source._byId.entries()) {
+            assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
+            this._byId.set(id, value);
+        }
+        for (const [key, value] of source._byKey.entries()) {
+            assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
+            this._byKey.set(key, value);
+        }
+    }
+    fork(path, adjuster, root) {
+        const chain = this._collect(path);
+        chain.push({ schema: root });
+        const tail = chain.shift();
+        let adjusted = { id: tail.id, schema: adjuster(tail.schema) };
+        assert(Common.isSchema(adjusted.schema), 'adjuster function failed to return a schema');
+        for (const node of chain)
+            adjusted = { id: node.id, schema: fork(node.schema, adjusted.id, adjusted.schema) };
+        return adjusted.schema;
+    }
+    labels(path, behind = []) {
+        const current = path[0];
+        const node = this._get(current);
+        if (!node)
+            return [...behind, ...path].join('.');
+        const forward = path.slice(1);
+        behind = [...behind, node.schema._flags.label || current];
+        if (!forward.length)
+            return behind.join('.');
+        return node.schema._ids.labels(forward, behind);
+    }
+    reach(path, behind = []) {
+        const current = path[0];
+        const node = this._get(current);
+        assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
+        const forward = path.slice(1);
+        if (!forward.length)
+            return node.schema;
+        return node.schema._ids.reach(forward, [...behind, current]);
+    }
+    register(schema, { key } = {}) {
+        if (!schema || !Common.isSchema(schema))
+            return;
+        const registered = schema;
+        if (registered.$_property('schemaChain') || registered._ids._schemaChain)
+            this._schemaChain = true;
+        const id = registered._flags.id;
+        if (id) {
+            const existing = this._byId.get(id);
+            assert(!existing || existing.schema === registered, 'Cannot add different schemas with the same id:', id);
+            assert(!this._byKey.has(id), 'Schema id conflicts with existing key:', id);
+            this._byId.set(id, { schema: registered, id });
+        }
+        if (key) {
+            assert(!this._byKey.has(key), 'Schema already contains key:', key);
+            assert(!this._byId.has(key), 'Schema key conflicts with existing id:', key);
+            this._byKey.set(key, { schema: registered, id: key });
+        }
+    }
+    reset() {
+        this._byId = new Map();
+        this._byKey = new Map();
+        this._schemaChain = false;
+    }
+    _collect(path, behind = [], nodes = []) {
+        const current = path[0];
+        const node = this._get(current);
+        assert(node, 'Schema does not contain path', [...behind, ...path].join('.'));
+        nodes = [node, ...nodes];
+        const forward = path.slice(1);
+        if (!forward.length)
+            return nodes;
+        return node.schema._ids._collect(forward, [...behind, current], nodes);
+    }
+    _get(id) {
+        return this._byId.get(id) || this._byKey.get(id);
+    }
+}
+function fork(schema, id, replacement) {
+    const each = (item, { key }) => {
+        if (id === (item._flags.id || key))
+            return replacement;
+    };
+    const obj = modifySchema(schema, { each, ref: false });
+    return obj ? obj.$_mutateRebuild() : schema;
+}
+/**
+ * A modified clone of a schema, with the nested schemas and references replaced by each(),
+ * or undefined when nothing was replaced
+ * @param schema
+ * @param options
+ */
+function modifySchema(schema, options) {
+    let obj;
+    for (const name in schema._flags) {
+        if (name[0] === '_')
+            continue;
+        const result = scan(schema._flags[name], { source: 'flags', name }, options);
+        if (result !== undefined) {
+            obj = obj || schema.clone();
+            obj._flags[name] = result;
+        }
+    }
+    for (let i = 0; i < schema._rules.length; ++i) {
+        const rule = schema._rules[i];
+        const result = scan(rule.args, { source: 'rules', name: rule.name }, options);
+        if (result !== undefined) {
+            obj = obj || schema.clone();
+            const clone = Object.assign({}, rule);
+            clone.args = result;
+            obj._rules[i] = clone;
+            const existingUnique = obj._singleRules.get(rule.name);
+            if (existingUnique === rule)
+                obj._singleRules.set(rule.name, clone);
+        }
+    }
+    for (const name in schema.$_terms) {
+        if (name[0] === '_')
+            continue;
+        const result = scan(schema.$_terms[name], { source: 'terms', name }, options);
+        if (result !== undefined) {
+            obj = obj || schema.clone();
+            obj.$_terms[name] = result;
+        }
+    }
+    return obj;
+}
+export { modifySchema as schema };
+function scan(item, source, options, _path, _key) {
+    const path = _path || [];
+    if (item === null || typeof item !== 'object')
+        return;
+    let clone;
+    if (Array.isArray(item)) {
+        for (let i = 0; i < item.length; ++i) {
+            const key = source.source === 'terms' && source.name === 'keys' && item[i].key;
+            const result = scan(item[i], source, options, [i, ...path], key);
+            if (result !== undefined) {
+                clone = clone || item.slice();
+                clone[i] = result;
+            }
+        }
+        return clone;
+    }
+    if (options.schema !== false && Common.isSchema(item) || options.ref !== false && Ref.isRef(item)) {
+        const result = options.each(item, { ...source, path, key: _key });
+        if (result === item)
+            return;
+        return result;
+    }
+    const record = item;
+    for (const key in record) {
+        if (key[0] === '_')
+            continue;
+        const result = scan(record[key], source, options, [key, ...path], _key);
+        if (result !== undefined) {
+            clone = clone || Object.assign({}, record);
+            clone[key] = result;
+        }
+    }
+    return clone;
+}

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

@@ -0,0 +1,277 @@
+/**
+ * Derived from the upstream lib/ref.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, isArray, reach } from '../utils/index.js';
+import { assert } from './assert.js';
+import * as Common from './common.js';
+import { Lazy } from './lazy.js';
+let Template;
+const defaults = {
+    adjust: null,
+    in: false,
+    iterables: null,
+    map: null,
+    separator: '.',
+    type: 'value'
+};
+/**
+ * A reference to another value (sibling key, ancestor, global context or local value)
+ */
+export class Ref {
+    constructor(options) {
+        assert(typeof options === 'object', 'Invalid reference construction');
+        Common.assertOptions(options, [
+            //Copied
+            'adjust', 'ancestor', 'in', 'iterables', 'map', 'path', 'render', 'separator', 'type',
+            //Overridden
+            'depth', 'key', 'root', 'display'
+        ]);
+        assert([false, undefined].includes(options.separator) || typeof options.separator === 'string' && options.separator.length === 1, 'Invalid separator');
+        assert(!options.adjust || typeof options.adjust === 'function', 'options.adjust must be a function');
+        assert(!options.map || isArray(options.map), 'options.map must be an array');
+        assert(!options.map || !options.adjust, 'Cannot set both map and adjust options');
+        Object.assign(this, defaults, options);
+        assert(this.type === 'value' || this.ancestor === undefined, 'Non-value references cannot reference ancestors');
+        if (isArray(this.map))
+            this.map = new Map(this.map);
+        this.depth = this.path.length;
+        this.key = this.path.length ? this.path.join(this.separator) : null;
+        this.root = this.path[0];
+        this.updateDisplay();
+    }
+    resolve(value, state, prefs, local, options = {}) {
+        assert(!this.in || options.in, 'Invalid in() reference usage');
+        if (this.type === 'global')
+            return this._resolve(prefs.context, state, options);
+        if (this.type === 'local')
+            return this._resolve(local, state, options);
+        if (!this.ancestor)
+            return this._resolve(value, state, options);
+        if (this.ancestor === 'root')
+            return this._resolve(state.ancestors[state.ancestors.length - 1], state, options);
+        assert(this.ancestor <= state.ancestors.length, 'Invalid reference exceeds the schema root:', this.display);
+        return this._resolve(state.ancestors[this.ancestor - 1], state, options);
+    }
+    _resolve(target, state, options) {
+        let resolved;
+        //Like upstream: a value reference expects the state to have a mainstay
+        if (this.type === 'value' && state.mainstay.shadow && options.shadow !== false) {
+            resolved = state.mainstay.shadow.get(this.absolute(state));
+        }
+        if (resolved === undefined)
+            resolved = reach(target, this.path, { iterables: !!this.iterables, functions: true });
+        if (this.adjust)
+            resolved = this.adjust(resolved);
+        if (this.map) {
+            const mapped = this.map.get(resolved);
+            if (mapped !== undefined)
+                resolved = mapped;
+        }
+        if (state.mainstay)
+            state.mainstay.tracer.resolve(state, this, resolved);
+        return resolved;
+    }
+    toString() {
+        return this.display;
+    }
+    absolute(state) {
+        return [...state.path.slice(0, -this.ancestor), ...this.path];
+    }
+    clone() {
+        return new Ref(this);
+    }
+    describe() {
+        const ref = { path: this.path };
+        if (this.type !== 'value')
+            ref.type = this.type;
+        if (this.separator !== '.')
+            ref.separator = this.separator;
+        if (this.type === 'value' && this.ancestor !== 1)
+            ref.ancestor = this.ancestor;
+        if (this.map)
+            ref.map = [...this.map];
+        if (this.adjust !== null && this.adjust !== undefined)
+            ref.adjust = this.adjust;
+        if (this.iterables !== null && this.iterables !== undefined)
+            ref.iterables = this.iterables;
+        if (this.render !== null && this.render !== undefined)
+            ref.render = this.render;
+        if (this.in !== false)
+            ref.in = true;
+        return { ref };
+    }
+    updateDisplay() {
+        const key = this.key !== null ? this.key : '';
+        if (this.type !== 'value') {
+            this.display = `ref:${this.type}:${key}`;
+            return;
+        }
+        if (!this.separator) {
+            this.display = `ref:${key}`;
+            return;
+        }
+        if (!this.ancestor) {
+            this.display = `ref:${this.separator}${key}`;
+            return;
+        }
+        if (this.ancestor === 'root') {
+            this.display = `ref:root:${key}`;
+            return;
+        }
+        if (this.ancestor === 1) {
+            this.display = `ref:${key || '..'}`;
+            return;
+        }
+        const lead = new Array(this.ancestor + 1).fill(this.separator).join('');
+        this.display = `ref:${lead}${key || ''}`;
+    }
+}
+Object.defineProperty(Ref.prototype, Common.symbols.ref, { value: true, writable: true, enumerable: true, configurable: true });
+function context(key, separator, prefix = {}) {
+    key = key.trim();
+    if (prefix) {
+        const globalp = prefix.global === undefined ? '$' : prefix.global;
+        if (globalp !== separator && key.startsWith(globalp))
+            return { key: key.slice(globalp.length), type: 'global' };
+        const local = prefix.local === undefined ? '#' : prefix.local;
+        if (local !== separator && key.startsWith(local))
+            return { key: key.slice(local.length), type: 'local' };
+        const root = prefix.root === undefined ? '/' : prefix.root;
+        if (root !== separator && key.startsWith(root))
+            return { key: key.slice(root.length), type: 'value', root: true };
+    }
+    return { key, type: 'value' };
+}
+function ancestor(key, separator) {
+    //'a_b' -> 1 (parent)
+    if (!separator)
+        return [1, 0];
+    //'a.b' -> 1 (parent)
+    if (key[0] !== separator)
+        return [1, 0];
+    //'.a.b' -> 0 (self)
+    if (key[1] !== separator)
+        return [0, 1];
+    let i = 2;
+    while (key[i] === separator)
+        ++i;
+    //'...a.b.' -> 2 (grandparent)
+    return [i - 1, i];
+}
+/**
+ * Create a reference
+ * @param key
+ * @param options
+ */
+export function create(key, options = {}) {
+    assert(typeof key === 'string', 'Invalid reference key:', key);
+    Common.assertOptions(options, ['adjust', 'ancestor', 'in', 'iterables', 'map', 'prefix', 'render', 'separator']);
+    assert(!options.prefix || typeof options.prefix === 'object', 'options.prefix must be of type object');
+    const ref = Object.assign({}, defaults, options);
+    delete ref.prefix;
+    const separator = ref.separator;
+    const refContext = context(key, separator, options.prefix);
+    ref.type = refContext.type;
+    let refKey = refContext.key;
+    if (ref.type === 'value') {
+        if (refContext.root) {
+            assert(!separator || refKey[0] !== separator, 'Cannot specify relative path with root prefix');
+            ref.ancestor = 'root';
+            if (!refKey)
+                refKey = null;
+        }
+        if (separator && separator === refKey) {
+            refKey = null;
+            ref.ancestor = 0;
+        }
+        else {
+            if (ref.ancestor !== undefined) {
+                assert(!separator || !refKey || refKey[0] !== separator, 'Cannot combine prefix with ancestor option');
+            }
+            else {
+                const [refAncestor, slice] = ancestor(refKey, separator);
+                if (slice) {
+                    refKey = refKey.slice(slice);
+                    if (refKey === '')
+                        refKey = null;
+                }
+                ref.ancestor = refAncestor;
+            }
+        }
+    }
+    ref.path = separator ? (refKey === null ? [] : refKey.split(separator)) : [refKey];
+    return new Ref(ref);
+}
+export function isRef(ref) {
+    return ref ? !!ref[Common.symbols.ref] : false;
+}
+/**
+ * Create an in() reference (matching any item of the referenced array or any key of the referenced object)
+ * @param key
+ * @param options
+ */
+function inRef(key, options = {}) {
+    return create(key, { ...options, in: true });
+}
+export { inRef as in };
+/**
+ * Build a reference from its description
+ * @param desc
+ */
+export function build(desc) {
+    const settings = Object.assign({}, defaults, desc);
+    if (settings.type === 'value' && settings.ancestor === undefined)
+        settings.ancestor = 1;
+    return new Ref(settings);
+}
+export const toSibling = 0;
+export const toParent = 1;
+/**
+ * Tracks the references used by a schema (0: [self refs], 1: [parent refs], 2: [grandparent refs], ...)
+ */
+export class Manager {
+    constructor() {
+        this.refs = [];
+    }
+    register(source, target) {
+        if (!source)
+            return;
+        const targetLevel = target === undefined ? toParent : target;
+        //Array
+        if (isArray(source)) {
+            for (const ref of source)
+                this.register(ref, targetLevel);
+            return;
+        }
+        //Schema
+        if (Common.isSchema(source)) {
+            for (const item of source._refs.refs) {
+                if (item.ancestor - targetLevel >= 0)
+                    this.refs.push({ ancestor: item.ancestor - targetLevel, root: item.root });
+            }
+            return;
+        }
+        //Reference
+        if (isRef(source) && source.type === 'value' && source.ancestor - targetLevel >= 0) {
+            this.refs.push({ ancestor: source.ancestor - targetLevel, root: source.root });
+        }
+        //Template
+        Template = Template || Lazy.template;
+        if (Template.isTemplate(source))
+            this.register(source.refs(), targetLevel);
+    }
+    get length() {
+        return this.refs.length;
+    }
+    clone() {
+        const copy = new Manager();
+        copy.refs = clone(this.refs);
+        return copy;
+    }
+    reset() {
+        this.refs = [];
+    }
+    roots() {
+        return this.refs.filter((ref) => !ref.ancestor).map((ref) => ref.root);
+    }
+}