@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,262 @@
+import Engine from './index.js';
+import { Lazy } from './lazy.js';
+const schemas = {};
+let built = false;
+/**
+ * The schemas are built on first use: building them needs the fully loaded root (index.js), which imports this
+ * module (CommonJS upstream required it lazily for the same reason)
+ */
+export default function getSchemas() {
+    if (!built) {
+        built = true;
+        build();
+    }
+    return schemas;
+}
+function build() {
+    //Preferences
+    const wrap = Engine.string()
+        .min(1)
+        .max(2)
+        .allow(false);
+    schemas.preferences = Engine.object({
+        allowUnknown: Engine.boolean(),
+        abortEarly: Engine.boolean(),
+        artifacts: Engine.boolean(),
+        cache: Engine.boolean(),
+        context: Engine.object(),
+        convert: Engine.boolean(),
+        dateFormat: Engine.valid('date', 'iso', 'string', 'time', 'utc'),
+        debug: Engine.boolean(),
+        errors: {
+            escapeHtml: Engine.boolean(),
+            label: Engine.valid('path', 'key', false),
+            language: [
+                Engine.string(),
+                Engine.object().ref()
+            ],
+            render: Engine.boolean(),
+            stack: Engine.boolean(),
+            wrap: {
+                label: wrap,
+                array: wrap,
+                string: wrap
+            }
+        },
+        externals: Engine.boolean(),
+        messages: Engine.object(),
+        noDefaults: Engine.boolean(),
+        nonEnumerables: Engine.boolean(),
+        presence: Engine.valid('required', 'optional', 'forbidden'),
+        skipFunctions: Engine.boolean(),
+        stripUnknown: Engine.object({
+            arrays: Engine.boolean(),
+            objects: Engine.boolean()
+        })
+            .or('arrays', 'objects')
+            .allow(true, false),
+        warnings: Engine.boolean()
+    })
+        .strict();
+    //Extensions
+    const nameRx = /^[a-zA-Z0-9]\w*$/;
+    const rule = Engine.object({
+        alias: Engine.array().items(Engine.string().pattern(nameRx)).single(),
+        args: Engine.array().items(Engine.string(), Engine.object({
+            name: Engine.string().pattern(nameRx).required(),
+            ref: Engine.boolean(),
+            assert: Engine.alternatives([
+                Engine.function(),
+                Engine.object().schema()
+            ])
+                .conditional('ref', { is: true, then: Engine.required() }),
+            normalize: Engine.function(),
+            message: Engine.string().when('assert', { is: Engine.function(), then: Engine.required() })
+        })),
+        convert: Engine.boolean(),
+        manifest: Engine.boolean(),
+        method: Engine.function().allow(false),
+        multi: Engine.boolean(),
+        validate: Engine.function()
+    });
+    schemas.extension = Engine.object({
+        type: Engine.alternatives([
+            Engine.string(),
+            Engine.object().regex()
+        ])
+            .required(),
+        args: Engine.function(),
+        cast: Engine.object().pattern(nameRx, Engine.object({
+            from: Engine.function().maxArity(1).required(),
+            to: Engine.function().minArity(1).maxArity(2).required()
+        })),
+        base: Engine.object().schema()
+            .when('type', { is: Engine.object().regex(), then: Engine.forbidden() }),
+        coerce: [
+            Engine.function().maxArity(3),
+            Engine.object({ method: Engine.function().maxArity(3).required(), from: Engine.array().items(Engine.string()).single() })
+        ],
+        flags: Engine.object().pattern(nameRx, Engine.object({
+            setter: Engine.string(),
+            default: Engine.any()
+        })),
+        manifest: {
+            build: Engine.function().arity(2)
+        },
+        messages: [Engine.object(), Engine.string()],
+        modifiers: Engine.object().pattern(nameRx, Engine.function().minArity(1).maxArity(2)),
+        overrides: Engine.object().pattern(nameRx, Engine.function()),
+        prepare: Engine.function().maxArity(3),
+        rebuild: Engine.function().arity(1),
+        rules: Engine.object().pattern(nameRx, rule),
+        terms: Engine.object().pattern(nameRx, Engine.object({
+            init: Engine.array().allow(null).required(),
+            manifest: Engine.object().pattern(/.+/, [
+                Engine.valid('schema', 'single'),
+                Engine.object({
+                    mapped: Engine.object({
+                        from: Engine.string().required(),
+                        to: Engine.string().required()
+                    })
+                        .required()
+                })
+            ])
+        })),
+        validate: Engine.function().maxArity(3)
+    })
+        .strict();
+    schemas.extensions = Engine.array().items(Engine.object(), Engine.function().arity(1)).strict();
+    //Manifest
+    const desc = {
+        buffer: Engine.object({
+            buffer: Engine.string()
+        }),
+        func: Engine.object({
+            function: Engine.function().required(),
+            options: {
+                literal: true
+            }
+        }),
+        override: Engine.object({
+            override: true
+        }),
+        ref: Engine.object({
+            ref: Engine.object({
+                type: Engine.valid('value', 'global', 'local'),
+                path: Engine.array().required(),
+                separator: Engine.string().length(1).allow(false),
+                ancestor: Engine.number().min(0).integer().allow('root'),
+                map: Engine.array().items(Engine.array().length(2)).min(1),
+                adjust: Engine.function(),
+                iterables: Engine.boolean(),
+                in: Engine.boolean(),
+                render: Engine.boolean()
+            })
+                .required()
+        }),
+        regex: Engine.object({
+            regex: Engine.string().min(3)
+        }),
+        special: Engine.object({
+            special: Engine.valid('deep').required()
+        }),
+        template: Engine.object({
+            template: Engine.string().required(),
+            options: Engine.object()
+        }),
+        value: Engine.object({
+            value: Engine.alternatives([Engine.object(), Engine.array()]).required()
+        })
+    };
+    desc.entity = Engine.alternatives([
+        Engine.array().items(Engine.link('...')),
+        Engine.boolean(),
+        Engine.function(),
+        Engine.number(),
+        Engine.string(),
+        desc.buffer,
+        desc.func,
+        desc.ref,
+        desc.regex,
+        desc.special,
+        desc.template,
+        desc.value,
+        Engine.link('/')
+    ]);
+    desc.values = Engine.array()
+        .items(null, Engine.boolean(), Engine.function(), Engine.number().allow(Infinity, -Infinity), Engine.string().allow(''), Engine.symbol(), desc.buffer, desc.func, desc.override, desc.ref, desc.regex, desc.template, desc.value);
+    desc.messages = Engine.object()
+        .pattern(/.+/, [
+        Engine.string(),
+        desc.template,
+        Engine.object().pattern(/.+/, [Engine.string(), desc.template])
+    ]);
+    schemas.description = Engine.object({
+        type: Engine.string().required(),
+        flags: Engine.object({
+            cast: Engine.string(),
+            default: Engine.any(),
+            description: Engine.string(),
+            empty: Engine.link('/'),
+            failover: desc.entity,
+            id: Engine.string(),
+            label: Engine.string(),
+            only: true,
+            presence: ['optional', 'required', 'forbidden'],
+            result: ['raw', 'strip'],
+            strip: Engine.boolean(),
+            unit: Engine.string()
+        })
+            .unknown(),
+        preferences: {
+            allowUnknown: Engine.boolean(),
+            abortEarly: Engine.boolean(),
+            artifacts: Engine.boolean(),
+            cache: Engine.boolean(),
+            convert: Engine.boolean(),
+            dateFormat: ['date', 'iso', 'string', 'time', 'utc'],
+            errors: {
+                escapeHtml: Engine.boolean(),
+                label: ['path', 'key'],
+                language: [
+                    Engine.string(),
+                    desc.ref
+                ],
+                wrap: {
+                    label: wrap,
+                    array: wrap
+                }
+            },
+            externals: Engine.boolean(),
+            messages: desc.messages,
+            noDefaults: Engine.boolean(),
+            nonEnumerables: Engine.boolean(),
+            presence: ['required', 'optional', 'forbidden'],
+            skipFunctions: Engine.boolean(),
+            stripUnknown: Engine.object({
+                arrays: Engine.boolean(),
+                objects: Engine.boolean()
+            })
+                .or('arrays', 'objects')
+                .allow(true, false),
+            warnings: Engine.boolean()
+        },
+        allow: desc.values,
+        invalid: desc.values,
+        rules: Engine.array().min(1).items({
+            name: Engine.string().required(),
+            args: Engine.object().min(1),
+            keep: Engine.boolean(),
+            message: [
+                Engine.string(),
+                desc.messages
+            ],
+            warn: Engine.boolean()
+        }),
+        //Terms
+        keys: Engine.object().pattern(/.*/, Engine.link('/')),
+        link: desc.ref
+    })
+        .pattern(/^[a-z]\w*$/, Engine.any());
+}
+Lazy.schemas = getSchemas;

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

@@ -0,0 +1,110 @@
+/**
+ * Derived from the upstream lib/state.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, reach } from '../utils/index.js';
+import * as Common from './common.js';
+const valueSymbol = Symbol('value');
+function schemaEntry(schema) {
+    if (Common.isSchema(schema))
+        return { schema };
+    return schema;
+}
+/**
+ * Values changed during the validation (converted or stripped), by path
+ */
+export class Shadow {
+    constructor() {
+        this._values = null;
+    }
+    set(path, value, reason) {
+        //No need to store root value
+        if (!path.length)
+            return;
+        //Cannot store stripped array values (due to shift)
+        if (reason === 'strip' && typeof path[path.length - 1] === 'number')
+            return;
+        this._values = this._values || new Map();
+        let node = this._values;
+        for (let i = 0; i < path.length; ++i) {
+            const segment = path[i];
+            let next = node.get(segment);
+            if (!next) {
+                next = new Map();
+                node.set(segment, next);
+            }
+            node = next;
+        }
+        node[valueSymbol] = value;
+    }
+    get(path) {
+        const node = this.node(path);
+        if (node)
+            return node[valueSymbol];
+    }
+    node(path) {
+        if (!this._values)
+            return;
+        return reach(this._values, path, { iterables: true });
+    }
+    override(path, node) {
+        if (!this._values)
+            return;
+        const parents = path.slice(0, -1);
+        const own = path[path.length - 1];
+        const parent = reach(this._values, parents, { iterables: true });
+        if (node) {
+            //Like upstream: overriding with a node expects the parent node to exist
+            parent.set(own, node);
+            return;
+        }
+        if (parent)
+            parent.delete(own);
+    }
+}
+/**
+ * State of the value being validated
+ */
+export class State {
+    constructor(path, ancestors, state) {
+        this.path = path;
+        this.ancestors = ancestors;
+        this.mainstay = state.mainstay;
+        this.schemas = state.schemas;
+        this.debug = null;
+    }
+    localize(path, ancestors = null, schema = null) {
+        const state = new State(path, ancestors, this);
+        if (schema && state.schemas)
+            state.schemas = [schemaEntry(schema), ...state.schemas];
+        return state;
+    }
+    nest(schema, debug) {
+        const state = new State(this.path, this.ancestors, this);
+        state.schemas = state.schemas && [schemaEntry(schema), ...state.schemas];
+        state.debug = debug;
+        return state;
+    }
+    shadow(value, reason) {
+        this.mainstay.shadow = this.mainstay.shadow || new Shadow();
+        this.mainstay.shadow.set(this.path, value, reason);
+    }
+    snapshot() {
+        if (this.mainstay.shadow)
+            this._snapshot = clone(this.mainstay.shadow.node(this.path));
+        this.mainstay.snapshot();
+    }
+    restore() {
+        if (this.mainstay.shadow) {
+            this.mainstay.shadow.override(this.path, this._snapshot);
+            this._snapshot = undefined;
+        }
+        this.mainstay.restore();
+    }
+    commit() {
+        if (this.mainstay.shadow) {
+            this.mainstay.shadow.override(this.path, this._snapshot);
+            this._snapshot = undefined;
+        }
+        this.mainstay.commit();
+    }
+}

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

@@ -0,0 +1,294 @@
+/**
+ * Derived from the upstream lib/template.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, escapeHtml, isArray } from '../utils/index.js';
+import { assert, definitionException } from './assert.js';
+import { Parser } from '../expression/index.js';
+import * as Common from './common.js';
+import * as Errors from './errors.js';
+import { Lazy } from './lazy.js';
+import * as Ref from './ref.js';
+const opens = new Array(1000).join('\u0000');
+const closes = new Array(1000).join('\u0001');
+const dateFormat = {
+    date: Date.prototype.toDateString,
+    iso: Date.prototype.toISOString,
+    string: Date.prototype.toString,
+    time: Date.prototype.toTimeString,
+    utc: Date.prototype.toUTCString
+};
+const constants = {
+    true: true,
+    false: false,
+    null: null,
+    second: 1000,
+    minute: 60 * 1000,
+    hour: 60 * 60 * 1000,
+    day: 24 * 60 * 60 * 1000
+};
+const functions = {
+    if(condition, then, otherwise) {
+        return condition ? then : otherwise;
+    },
+    length(item) {
+        if (typeof item === 'string')
+            return item.length;
+        if (!item || typeof item !== 'object')
+            return null;
+        if (isArray(item))
+            return item.length;
+        return Object.keys(item).length;
+    },
+    msg(code) {
+        const [value, state, prefs, local, options] = this;
+        const messages = options.messages;
+        if (!messages)
+            return '';
+        const template = Errors.template(value, messages[0], code, state, prefs) || Errors.template(value, messages[1], code, state, prefs);
+        if (!template)
+            return '';
+        return template.render(value, state, prefs, local, options);
+    },
+    number(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string')
+            return parseFloat(value);
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        if (value instanceof Date)
+            return value.getTime();
+        return null;
+    }
+};
+function encode(string) {
+    return string
+        .replace(/\\(\{+)/g, ($0, $1) => opens.slice(0, $1.length))
+        .replace(/\\(\}+)/g, ($0, $1) => closes.slice(0, $1.length));
+}
+function decode(string) {
+    return string
+        .replace(/\u0000/g, '{')
+        .replace(/\u0001/g, '}');
+}
+function split(string) {
+    const parts = [];
+    let current = '';
+    for (let i = 0; i < string.length; ++i) {
+        const char = string[i];
+        if (char === '{') {
+            let next = '';
+            while (i + 1 < string.length && string[i + 1] === '{') {
+                next += '{';
+                ++i;
+            }
+            parts.push(current);
+            current = next;
+        }
+        else {
+            current += char;
+        }
+    }
+    parts.push(current);
+    return parts;
+}
+function wrap(value, ends) {
+    if (!ends)
+        return value;
+    if (ends.length === 1)
+        return `${ends}${value}${ends}`;
+    return `${ends[0]}${value}${ends[1]}`;
+}
+function stringify(value, original, state, prefs, local, options = {}) {
+    const type = typeof value;
+    const wrapPrefs = prefs && prefs.errors && prefs.errors.wrap || {};
+    let skipWrap = false;
+    if (Ref.isRef(value) && value.render) {
+        skipWrap = value.in;
+        value = value.resolve(original, state, prefs, local, { in: value.in, ...options });
+    }
+    if (value === null)
+        return 'null';
+    if (type === 'string')
+        return wrap(value, options.arrayItems && wrapPrefs.string);
+    if (type === 'number' || type === 'function' || type === 'symbol')
+        return value.toString();
+    if (type !== 'object')
+        return JSON.stringify(value);
+    if (value instanceof Date)
+        return Template.date(value, prefs);
+    if (value instanceof Map) {
+        const pairs = [];
+        for (const [key, sym] of value.entries())
+            pairs.push(`${key.toString()} -> ${sym.toString()}`);
+        value = pairs;
+    }
+    if (!isArray(value))
+        return value.toString();
+    const values = [];
+    for (const item of value)
+        values.push(stringify(item, original, state, prefs, local, { arrayItems: true, ...options }));
+    return wrap(values.join(', '), !skipWrap && wrapPrefs.array);
+}
+/**
+ * A message template: text with {references} and {{escaped references}}, which may be expressions
+ */
+export class Template {
+    constructor(source, options) {
+        assert(typeof source === 'string', 'Template source must be a string');
+        assert(!source.includes('\u0000') && !source.includes('\u0001'), 'Template source cannot contain reserved control characters');
+        this.source = source;
+        this.rendered = source;
+        this._template = null;
+        if (options) {
+            const { functions: templateFunctions, ...opts } = options;
+            this._settings = Object.keys(opts).length ? clone(opts) : undefined;
+            this._functions = templateFunctions;
+            if (this._functions) {
+                assert(Object.keys(this._functions).every((key) => typeof key === 'string'), 'Functions keys must be strings');
+                assert(Object.values(this._functions).every((key) => typeof key === 'function'), 'Functions values must be functions');
+            }
+        }
+        else {
+            this._settings = undefined;
+            this._functions = undefined;
+        }
+        this._parse();
+    }
+    _parse() {
+        //'text {raw} {{ref}} \\{{ignore}} {{ignore\\}} {{ignore {{ignore}'
+        if (!this.source.includes('{'))
+            return;
+        //Encode escaped \\{{{{{
+        const encoded = encode(this.source);
+        //Split on first { in each set
+        const parts = split(encoded);
+        //Process parts
+        let refs = false;
+        const processed = [];
+        const head = parts.shift();
+        if (head)
+            processed.push(head);
+        for (const part of parts) {
+            const raw = part[0] !== '{';
+            const ender = raw ? '}' : '}}';
+            const end = part.indexOf(ender);
+            //Ignore non-matching closing, ignore more than two {
+            if (end === -1 || part[1] === '{') {
+                processed.push(`{${decode(part)}`);
+                continue;
+            }
+            let variable = part.slice(raw ? 0 : 1, end);
+            const wrapped = variable[0] === ':';
+            if (wrapped)
+                variable = variable.slice(1);
+            const dynamic = this._ref(decode(variable), { raw, wrapped });
+            processed.push(dynamic);
+            if (typeof dynamic !== 'string')
+                refs = true;
+            const rest = part.slice(end + ender.length);
+            if (rest)
+                processed.push(decode(rest));
+        }
+        if (!refs) {
+            this.rendered = processed.join('');
+            return;
+        }
+        this._template = processed;
+    }
+    static date(date, prefs) {
+        return dateFormat[prefs.dateFormat].call(date);
+    }
+    describe(options = {}) {
+        if (!this._settings && options.compact)
+            return this.source;
+        const desc = { template: this.source };
+        if (this._settings)
+            desc.options = this._settings;
+        if (this._functions)
+            desc.functions = this._functions;
+        return desc;
+    }
+    static build(desc) {
+        return new Template(desc.template, desc.options || desc.functions ? { ...desc.options, functions: desc.functions } : undefined);
+    }
+    isDynamic() {
+        return !!this._template;
+    }
+    static isTemplate(template) {
+        return template ? !!template[Common.symbols.template] : false;
+    }
+    refs() {
+        if (!this._template)
+            return;
+        const refs = [];
+        for (const part of this._template) {
+            if (typeof part !== 'string')
+                refs.push(...part.refs);
+        }
+        return refs;
+    }
+    resolve(value, state, prefs, local) {
+        if (this._template && this._template.length === 1)
+            return this._part(this._template[0], [value, state, prefs, local, {}]);
+        return this.render(value, state, prefs, local);
+    }
+    _part(part, context) {
+        if (part.ref)
+            return part.ref.resolve(...context);
+        return part.expression.evaluate(context);
+    }
+    render(value, state, prefs, local, options = {}) {
+        if (!this.isDynamic())
+            return this.rendered;
+        const parts = [];
+        for (const part of this._template) {
+            if (typeof part === 'string') {
+                parts.push(part);
+            }
+            else {
+                const rendered = this._part(part, [value, state, prefs, local, options]);
+                const string = stringify(rendered, value, state, prefs, local, options);
+                if (string !== undefined) {
+                    const result = part.raw || (options.errors && options.errors.escapeHtml) === false ? string : escapeHtml(string);
+                    parts.push(wrap(result, part.wrapped && prefs.errors.wrap.label));
+                }
+            }
+        }
+        return parts.join('');
+    }
+    _ref(content, { raw, wrapped }) {
+        const refs = [];
+        const reference = (variable) => {
+            const ref = Ref.create(variable, this._settings);
+            refs.push(ref);
+            return (context) => {
+                const resolved = ref.resolve(...context);
+                return resolved !== undefined ? resolved : null;
+            };
+        };
+        let expression;
+        try {
+            const templateFunctions = this._functions ? { ...functions, ...this._functions } : functions;
+            expression = new Parser(content, { reference, functions: templateFunctions, constants });
+        }
+        catch (err) {
+            throw definitionException(`Invalid template variable "${content}" fails due to: ${err.message}`, Template.prototype._ref, err);
+        }
+        if (expression.single) {
+            if (expression.single.type === 'reference') {
+                const ref = refs[0];
+                return { ref, raw, refs, wrapped: wrapped || ref.type === 'local' && ref.key === 'label' };
+            }
+            return stringify(expression.single.value);
+        }
+        return { expression, raw, refs };
+    }
+    toString() {
+        return this.source;
+    }
+}
+Object.defineProperty(Template.prototype, Common.symbols.template, { value: true, writable: true, enumerable: true, configurable: true });
+//Prevents clone() from deep cloning schema objects
+Object.defineProperty(Template.prototype, 'isImmutable', { value: true, writable: true, enumerable: true, configurable: true });
+Lazy.template = Template;