@lakutata/core 1.0.60 → 3.0.0-beta.1

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

@@ -0,0 +1,235 @@
+"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.type = type;
+/**
+ * Derived from the upstream lib/extend.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 Common = __importStar(require("./common.js"));
+const Messages = __importStar(require("./messages.js"));
+/**
+ * A new type (a schema with its own prototype), extending the type of a schema
+ * @param from
+ * @param options
+ */
+function type(from, options) {
+    const base = Object.getPrototypeOf(from);
+    const prototype = (0, index_js_1.clone)(base);
+    const schema = from._assign(Object.create(prototype));
+    //Shallow cloned
+    const def = Object.assign({}, options);
+    delete def.base;
+    //Normalized in place below, like upstream
+    const extended = def;
+    prototype._definition = extended;
+    const parent = base._definition || {};
+    extended.messages = Messages.merge(parent.messages, def.messages);
+    extended.properties = Object.assign({}, parent.properties, def.properties);
+    //Type
+    schema.type = def.type;
+    //Flags
+    extended.flags = Object.assign({}, parent.flags, def.flags);
+    //Terms
+    const terms = Object.assign({}, parent.terms);
+    if (def.terms) {
+        //Only apply own terms
+        for (const name in def.terms) {
+            const term = def.terms[name];
+            (0, assert_js_1.assert)(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
+            schema.$_terms[name] = term.init;
+            terms[name] = term;
+        }
+    }
+    extended.terms = terms;
+    //Constructor arguments
+    if (!def.args)
+        extended.args = parent.args;
+    //Prepare
+    extended.prepare = prepare(def.prepare, parent.prepare);
+    //Coerce
+    if (def.coerce) {
+        if (typeof def.coerce === 'function')
+            def.coerce = { method: def.coerce };
+        if (def.coerce.from && !Array.isArray(def.coerce.from))
+            def.coerce = { method: def.coerce.method, from: [].concat(def.coerce.from) };
+    }
+    extended.coerce = coerce(def.coerce, parent.coerce);
+    //Validate
+    extended.validate = validate(def.validate, parent.validate);
+    //Rules
+    const rules = Object.assign({}, parent.rules);
+    if (def.rules) {
+        for (const name in def.rules) {
+            const rule = def.rules[name];
+            (0, assert_js_1.assert)(typeof rule === 'object', 'Invalid rule definition for', def.type, name);
+            let method = rule.method;
+            if (method === undefined) {
+                method = function () {
+                    return this.$_addRule(name);
+                };
+            }
+            if (method) {
+                (0, assert_js_1.assert)(!prototype[name], 'Rule conflict in', def.type, name);
+                prototype[name] = method;
+            }
+            (0, assert_js_1.assert)(!rules[name], 'Rule conflict in', def.type, name);
+            rules[name] = rule;
+            if (rule.alias) {
+                const aliases = [].concat(rule.alias);
+                for (const alias of aliases)
+                    prototype[alias] = rule.method;
+            }
+            if (rule.args) {
+                const argsByName = new Map();
+                rule.argsByName = argsByName;
+                rule.args = rule.args.map((arg) => {
+                    if (typeof arg === 'string')
+                        arg = { name: arg };
+                    (0, assert_js_1.assert)(!argsByName.has(arg.name), 'Duplicated argument name', arg.name);
+                    if (Common.isSchema(arg.assert))
+                        arg.assert = arg.assert.strict().label(arg.name);
+                    argsByName.set(arg.name, arg);
+                    return arg;
+                });
+            }
+        }
+    }
+    extended.rules = rules;
+    //Modifiers
+    const modifiers = Object.assign({}, parent.modifiers);
+    if (def.modifiers) {
+        for (const name in def.modifiers) {
+            (0, assert_js_1.assert)(!prototype[name], 'Rule conflict in', def.type, name);
+            const modifier = def.modifiers[name];
+            (0, assert_js_1.assert)(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);
+            const method = function (arg) {
+                return this.rule({ [name]: arg });
+            };
+            prototype[name] = method;
+            modifiers[name] = modifier;
+        }
+    }
+    extended.modifiers = modifiers;
+    //Overrides
+    if (def.overrides) {
+        prototype._super = base;
+        //Backwards compatibility
+        schema.$_super = {};
+        for (const override in def.overrides) {
+            const overridden = base[override];
+            (0, assert_js_1.assert)(overridden, 'Cannot override missing', override);
+            def.overrides[override][Common.symbols.parent] = overridden;
+            //Backwards compatibility
+            schema.$_super[override] = overridden.bind(schema);
+        }
+        Object.assign(prototype, def.overrides);
+    }
+    //Casts
+    extended.cast = Object.assign({}, parent.cast, def.cast);
+    //Manifest
+    const manifest = Object.assign({}, parent.manifest, def.manifest);
+    manifest.build = build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
+    extended.manifest = manifest;
+    //Rebuild
+    extended.rebuild = rebuild(def.rebuild, parent.rebuild);
+    return schema;
+}
+function build(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (obj, desc) {
+        return parent(child(obj, desc), desc);
+    };
+}
+function coerce(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return {
+        from: child.from && parent.from ? [...new Set([...child.from, ...parent.from])] : null,
+        method(value, helpers) {
+            let coerced;
+            if (!parent.from || parent.from.includes(typeof value)) {
+                coerced = parent.method(value, helpers);
+                if (coerced) {
+                    if (coerced.errors || coerced.value === undefined)
+                        return coerced;
+                    value = coerced.value;
+                }
+            }
+            if (!child.from || child.from.includes(typeof value)) {
+                const own = child.method(value, helpers);
+                if (own)
+                    return own;
+            }
+            return coerced;
+        }
+    };
+}
+function prepare(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (value, helpers) {
+        const prepared = child(value, helpers);
+        if (prepared) {
+            if (prepared.errors || prepared.value === undefined)
+                return prepared;
+            value = prepared.value;
+        }
+        return parent(value, helpers) || prepared;
+    };
+}
+function rebuild(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (schema) {
+        parent(schema);
+        child(schema);
+    };
+}
+function validate(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (value, helpers) {
+        const result = parent(value, helpers);
+        if (result) {
+            if (result.errors && (!Array.isArray(result.errors) || result.errors.length))
+                return result;
+            value = result.value;
+        }
+        return child(value, helpers) || result;
+    };
+}

package/dist/cjs/lib/validation/engine/schema/extensions/bigint.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Derived from the upstream src/index.ts and src/types.ts (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+import type * as Ref from '../ref.js';
+import type { Extension, Root } from '../index.js';
+import type { AnySchema } from '../types/any.js';
+/**
+ * The bigint schema
+ * @typeParam T the validated value type (kept for compatibility with the upstream type, which is generic)
+ */
+export interface BigIntSchema<T = bigint> extends AnySchema {
+    greater(limit: bigint | Ref.Ref): this;
+    less(limit: bigint | Ref.Ref): this;
+    max(limit: bigint | Ref.Ref): this;
+    min(limit: bigint | Ref.Ref): this;
+    multiple(base: bigint | Ref.Ref): this;
+    negative(): this;
+    port(): this;
+    positive(): this;
+    sign(sign: 'positive' | 'negative'): this;
+}
+/**
+ * The bigint extension of the root object
+ * @param _engine the root object (extend() requires the factories of the extensions to take it)
+ */
+export declare const bigintExtension: (_engine: Root) => Extension<BigIntSchema>;
+/**
+ * A root object with the bigint type
+ * @param baseEngine
+ */
+export declare const extendBigInt: <T extends Root>(baseEngine: T) => T & {
+    bigint<U = bigint>(): BigIntSchema<U>;
+};

package/dist/cjs/lib/validation/engine/schema/extensions/bigint.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendBigInt = exports.bigintExtension = void 0;
+const isBigint = (value) => typeof value === 'bigint';
+/**
+ * The bigint extension of the root object
+ * @param _engine the root object (extend() requires the factories of the extensions to take it)
+ */
+const bigintExtension = (_engine) => ({
+    type: 'bigint',
+    messages: {
+        'bigint.base': '{{#label}} must be a bigint',
+        'bigint.greater': '{{#label}} must be greater than {{#limit}}',
+        'bigint.less': '{{#label}} must be less than {{#limit}}',
+        'bigint.max': '{{#label}} must be less than or equal to {{#limit}}',
+        'bigint.min': '{{#label}} must be greater than or equal to {{#limit}}',
+        'bigint.multiple': '{{#label}} must be a multiple of {{#base}}',
+        'bigint.negative': '{{#label}} must be a negative number',
+        'bigint.port': '{{#label}} must be a valid port',
+        'bigint.positive': '{{#label}} must be a positive number'
+    },
+    coerce(value) {
+        if (typeof value === 'string' || (typeof value === 'number' && Number.isInteger(value))) {
+            try {
+                return { value: BigInt(value) };
+            }
+            catch {
+                //Not convertible: validate() reports it
+            }
+        }
+        return { value };
+    },
+    validate(value, helpers) {
+        if (!isBigint(value))
+            return { value, errors: helpers.error('bigint.base') };
+    },
+    rules: {
+        greater: {
+            method(limit) {
+                return this.$_addRule({ name: 'greater', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value > limit ? value : helpers.error('bigint.greater', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        less: {
+            method(limit) {
+                return this.$_addRule({ name: 'less', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value < limit ? value : helpers.error('bigint.less', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        max: {
+            method(limit) {
+                return this.$_addRule({ name: 'max', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value <= limit ? value : helpers.error('bigint.max', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        min: {
+            method(limit) {
+                return this.$_addRule({ name: 'min', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value >= limit ? value : helpers.error('bigint.min', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        multiple: {
+            method(base) {
+                return this.$_addRule({ name: 'multiple', args: { base } });
+            },
+            validate(value, helpers, { base }) {
+                //A multiple of the base: 0 and the negative multiples included, as the numbers (upstream refused the
+                //values lower than the base)
+                return value % base === 0n
+                    ? value
+                    : helpers.error('bigint.multiple', { base: base.toString() });
+            },
+            args: [
+                {
+                    name: 'base',
+                    ref: true,
+                    assert: (base) => isBigint(base) && base > 0n,
+                    message: 'must be a positive bigint'
+                }
+            ],
+            multi: true
+        },
+        negative: {
+            method() {
+                return this.$_addRule({ name: 'negative' });
+            },
+            validate(value, helpers) {
+                return value < 0n ? value : helpers.error('bigint.negative');
+            }
+        },
+        port: {
+            method() {
+                return this.$_addRule({ name: 'port' });
+            },
+            validate(value, helpers) {
+                return value >= 0n && value <= 65535n ? value : helpers.error('bigint.port');
+            }
+        },
+        positive: {
+            method() {
+                return this.$_addRule({ name: 'positive' });
+            },
+            validate(value, helpers) {
+                return value > 0n ? value : helpers.error('bigint.positive');
+            }
+        },
+        sign: {
+            method(sign) {
+                return this.$_addRule({ name: 'sign', args: { sign } });
+            },
+            validate(value, helpers, { sign }) {
+                return (sign === 'negative' && value < 0n) || (sign === 'positive' && value > 0n)
+                    ? value
+                    : helpers.error(`bigint.${sign}`);
+            },
+            args: [
+                {
+                    name: 'sign',
+                    assert: (value) => ['negative', 'positive'].includes(value),
+                    message: 'must be "negative" or "positive"'
+                }
+            ]
+        }
+    }
+});
+exports.bigintExtension = bigintExtension;
+/**
+ * A root object with the bigint type
+ * @param baseEngine
+ */
+const extendBigInt = (baseEngine) => {
+    //The extension is typed with its own schema type, the root accepts the extensions of any schema type
+    return baseEngine.extend(exports.bigintExtension);
+};
+exports.extendBigInt = extendBigInt;

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

@@ -0,0 +1,35 @@
+import type { Base } from './base.js';
+import type { Preferences } from './model.js';
+/**
+ * Returned by a compiled schema when the value must be validated by the interpreter
+ */
+export declare const FALLBACK: unique symbol;
+/**
+ * Returned by a compiled schema when the value is invalid (the interpreter reports an error for it)
+ */
+export declare const INVALID: unique symbol;
+/**
+ * A compiled schema: the validated value, INVALID or FALLBACK
+ */
+export type Compiled = (value: unknown) => unknown;
+/**
+ * Mark the method of a custom rule as pure (deterministic, without side effects, calling only error() of the helpers),
+ * so the fast path can compile the schemas using it (for lakutata's own validators; other custom rules are interpreted)
+ * @param method
+ */
+export declare function pure<T extends Function>(method: T): T;
+/**
+ * The compiled schema for the validation settings (null: validate with the interpreter)
+ * @param schema
+ * @param settings the settings of a validation (defaults merged with the validate() options), which must not change
+ */
+export declare function compiledFor(schema: Base, settings: Preferences): Compiled | null;
+/**
+ * Whether the fast path and the interpreter produced the same value: same primitives (Object.is), and objects with the
+ * same prototype, own keys (in order), property attributes and values, where the input is reused in the same places
+ * @param fast
+ * @param interpreted
+ * @param input the validated value at the same place
+ * @param seen
+ */
+export declare function sameResult(fast: unknown, interpreted: unknown, input: unknown, seen?: Map<object, object>): boolean;