@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = exports.Shadow = void 0;
+/**
+ * Derived from the upstream lib/state.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const Common = __importStar(require("./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
+ */
+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 (0, index_js_1.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 = (0, index_js_1.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);
+    }
+}
+exports.Shadow = Shadow;
+/**
+ * State of the value being validated
+ */
+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 = (0, index_js_1.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();
+    }
+}
+exports.State = State;

package/dist/cjs/lib/validation/engine/schema/template.d.ts

@@ -0,0 +1,72 @@
+import { type ExpressionFunction, Parser } from '../expression/index.js';
+import type { ErrorPreferences, Preferences, StateLike } from './model.js';
+import * as Ref from './ref.js';
+import type { Messages } from './messages.js';
+/**
+ * Options of a template: reference options, and functions callable from the template expressions
+ */
+export interface TemplateOptions extends Ref.RefOptions {
+    functions?: Record<string, ExpressionFunction>;
+}
+export interface TemplateDescription {
+    template: string;
+    options?: Ref.RefOptions;
+    functions?: Record<string, ExpressionFunction>;
+}
+/**
+ * Options of a template rendering
+ */
+export interface RenderOptions extends Ref.ResolveOptions {
+    errors?: ErrorPreferences;
+    messages?: (Messages | null | undefined)[];
+    arrayItems?: boolean;
+}
+/**
+ * The arguments a template resolves with, also the `this` of its expression functions
+ */
+type RenderContext = [value: unknown, state: StateLike, prefs: Preferences, local: unknown, options: RenderOptions];
+interface RefPart {
+    ref: Ref.Ref;
+    raw: boolean;
+    refs: Ref.Ref[];
+    wrapped: boolean;
+}
+interface ExpressionPart {
+    expression: Parser;
+    raw: boolean;
+    refs: Ref.Ref[];
+    wrapped?: undefined;
+    ref?: undefined;
+}
+type DynamicPart = RefPart | ExpressionPart;
+type TemplatePart = string | DynamicPart;
+/**
+ * A message template: text with {references} and {{escaped references}}, which may be expressions
+ */
+export declare class Template {
+    isImmutable: true;
+    source: string;
+    rendered: string;
+    protected _template: TemplatePart[] | null;
+    protected _settings: Ref.RefOptions | undefined;
+    protected _functions: Record<string, ExpressionFunction> | undefined;
+    constructor(source: string, options?: TemplateOptions);
+    protected _parse(): void;
+    static date(date: Date, prefs: Preferences): string;
+    describe(options?: {
+        compact?: boolean;
+    }): string | TemplateDescription;
+    static build(desc: TemplateDescription): Template;
+    isDynamic(): boolean;
+    static isTemplate(template: unknown): template is Template;
+    refs(): Ref.Ref[] | undefined;
+    resolve(value: unknown, state: StateLike, prefs: Preferences, local: unknown): unknown;
+    protected _part(part: DynamicPart, context: RenderContext): unknown;
+    render(value: unknown, state: StateLike, prefs: Preferences, local: unknown, options?: RenderOptions): string;
+    protected _ref(content: string, { raw, wrapped }: {
+        raw: boolean;
+        wrapped: boolean;
+    }): string | DynamicPart;
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,331 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Template = void 0;
+/**
+ * Derived from the upstream lib/template.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const assert_js_1 = require("./assert.js");
+const index_js_2 = require("../expression/index.js");
+const Common = __importStar(require("./common.js"));
+const Errors = __importStar(require("./errors.js"));
+const lazy_js_1 = require("./lazy.js");
+const Ref = __importStar(require("./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 ((0, index_js_1.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 (!(0, index_js_1.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
+ */
+class Template {
+    constructor(source, options) {
+        (0, assert_js_1.assert)(typeof source === 'string', 'Template source must be a string');
+        (0, assert_js_1.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 ? (0, index_js_1.clone)(opts) : undefined;
+            this._functions = templateFunctions;
+            if (this._functions) {
+                (0, assert_js_1.assert)(Object.keys(this._functions).every((key) => typeof key === 'string'), 'Functions keys must be strings');
+                (0, assert_js_1.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 : (0, index_js_1.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 index_js_2.Parser(content, { reference, functions: templateFunctions, constants });
+        }
+        catch (err) {
+            throw (0, assert_js_1.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;
+    }
+}
+exports.Template = Template;
+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_js_1.Lazy.template = Template;

package/dist/cjs/lib/validation/engine/schema/trace.d.ts

@@ -0,0 +1,121 @@
+import type { MainstayLike, PathKey, SchemaInternals, StateLike } from './model.js';
+import type { ResolvableValue } from './values.js';
+type TraceResult = 'error' | 'pass' | 'full';
+/**
+ * A segment of a sub schema path: an id or key, or a [@term, position] pair
+ */
+type TracePathSegment = string | [string, PathKey];
+type TracePath = TracePathSegment[];
+/**
+ * A debug event of a validation
+ */
+export interface DebugEvent {
+    type: string;
+    path?: unknown[];
+    [name: string]: unknown;
+}
+/**
+ * The state parts the tracer reads
+ */
+export interface TraceState extends StateLike {
+    debug?: unknown;
+    mainstay: MainstayLike & {
+        debug?: DebugEvent[] | null;
+    };
+}
+/**
+ * A resolvable value, as the tracer displays it
+ */
+interface DisplayedResolvable extends ResolvableValue {
+    display?: string;
+}
+/**
+ * A matched value of a values set
+ */
+interface ValuesFilter {
+    value: unknown;
+    ref?: DisplayedResolvable;
+}
+/**
+ * The coverage log of one (sub) schema
+ */
+interface SourceLog {
+    paths: Set<TracePath>;
+    entry: boolean;
+    rule: Record<string, number>;
+    valid: Set<ValuesFilter>;
+    invalid: Set<ValuesFilter>;
+}
+/**
+ * A missing coverage item
+ */
+interface MissingItem {
+    status: string | unknown[];
+    paths?: TracePath[];
+    rule?: string;
+}
+/**
+ * The coverage report of one registered schema
+ */
+export interface CoverageReport {
+    filename: string;
+    line: number;
+    missing: MissingItem[];
+    severity: 'error';
+    message: string;
+}
+interface RegisteredSchema {
+    filename: string;
+    line: number;
+    store: Store;
+}
+/**
+ * The root object parts set by setup()
+ */
+export interface TraceRoot {
+    _tracer?: Tracer | null;
+    trace?: () => Tracer;
+    untrace?: () => void;
+}
+/**
+ * Add trace() and untrace() to the root object
+ * @param root
+ */
+export declare function setup(root: TraceRoot): void;
+/**
+ * Record the location of the caller of schema.tracer()
+ * @param schema
+ */
+export declare function location<T extends SchemaInternals>(schema: T): T;
+/**
+ * Collects the coverage of the traced schemas
+ */
+export declare class Tracer {
+    name: string;
+    protected _schemas: Map<SchemaInternals, RegisteredSchema>;
+    constructor();
+    _register(schema: SchemaInternals): Store;
+    _combine(merged: SchemaInternals, sources: SchemaInternals[]): void;
+    report(file?: string): CoverageReport[] | null;
+}
+/**
+ * The coverage store of a registered schema, recording the validations of its sub schemas
+ */
+export declare class Store {
+    active: boolean;
+    _sources: Map<SchemaInternals, SourceLog>;
+    protected _combos: Map<SchemaInternals, SchemaInternals[]>;
+    constructor(schema: SchemaInternals);
+    debug(state: TraceState, source: string, name: string, result: unknown): void;
+    entry(schema: SchemaInternals, state: TraceState): void;
+    filter(schema: SchemaInternals, state: TraceState, source: 'valid' | 'invalid', value: ValuesFilter): void;
+    log(schema: SchemaInternals, state: TraceState, source: 'rule', name: string, result: TraceResult): void;
+    resolve(state: TraceState, ref: {
+        display?: string;
+    }, to: unknown): void;
+    value(state: TraceState, by: string, from: unknown, to: unknown, name?: string): void;
+    _record(schema: SchemaInternals, each: (log: SourceLog) => void): void;
+    _scan(schema: SchemaInternals, _path?: TracePath): void;
+    _combine(merged: SchemaInternals, sources: SchemaInternals[]): void;
+}
+export {};