@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/cjs/lib/validation/engine/utils/applyToDefaults.d.ts

@@ -0,0 +1,17 @@
+export interface ApplyToDefaultsOptions {
+    /**
+     * Override the default value with null source values, defaults to false
+     */
+    readonly nullOverride?: boolean;
+    /**
+     * Keys (paths) whose values are copied by reference
+     */
+    readonly shallow?: string[] | string[][];
+}
+/**
+ * Apply source to a copy of the defaults
+ * @param defaults
+ * @param source true to return a copy of the defaults, a falsy value to return null
+ * @param options
+ */
+export declare function applyToDefaults<T extends object>(defaults: T, source: Partial<T> | object | boolean | null | undefined, options?: ApplyToDefaultsOptions): T | null;

package/dist/cjs/lib/validation/engine/utils/applyToDefaults.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyToDefaults = applyToDefaults;
+/**
+ * Derived from the upstream lib/applyToDefaults.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const assert_js_1 = require("./assert.js");
+const clone_js_1 = require("./clone.js");
+const merge_js_1 = require("./merge.js");
+const reach_js_1 = require("./reach.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Apply source to a copy of the defaults
+ * @param defaults
+ * @param source true to return a copy of the defaults, a falsy value to return null
+ * @param options
+ */
+function applyToDefaults(defaults, source, options = {}) {
+    (0, assert_js_1.assert)(defaults && typeof defaults === 'object', 'Invalid defaults value: must be an object');
+    (0, assert_js_1.assert)(!source || source === true || typeof source === 'object', 'Invalid source value: must be true, falsy or an object');
+    (0, assert_js_1.assert)(typeof options === 'object', 'Invalid options: must be an object');
+    //If no source, return null
+    if (!source)
+        return null;
+    if (options.shallow)
+        return applyToDefaultsWithShallow(defaults, source, options);
+    const copy = (0, clone_js_1.clone)(defaults);
+    //If source is set to true, use defaults
+    if (source === true)
+        return copy;
+    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
+    return (0, merge_js_1.merge)(copy, source, { nullOverride, mergeArrays: false });
+}
+/**
+ * Apply source to defaults, copying the values at the shallow paths by reference
+ * @param defaults
+ * @param source
+ * @param options
+ */
+function applyToDefaultsWithShallow(defaults, source, options) {
+    const shallowKeys = options.shallow;
+    (0, assert_js_1.assert)((0, utils_js_1.isArray)(shallowKeys), 'Invalid keys');
+    const seen = new Map();
+    const mergePaths = source === true ? null : new Set();
+    for (const shallowKey of shallowKeys) {
+        //Pre-split optimization
+        const key = (0, utils_js_1.isArray)(shallowKey) ? shallowKey : shallowKey.split('.');
+        const ref = (0, reach_js_1.reach)(defaults, key);
+        if (ref && typeof ref === 'object') {
+            seen.set(ref, mergePaths && (0, reach_js_1.reach)(source, key) || ref);
+        }
+        else if (mergePaths) {
+            mergePaths.add(key);
+        }
+    }
+    const copy = (0, clone_js_1.clone)(defaults, {}, seen);
+    if (!mergePaths)
+        return copy;
+    for (const key of mergePaths)
+        reachCopy(copy, source, key);
+    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
+    return (0, merge_js_1.merge)(copy, source, { nullOverride, mergeArrays: false });
+}
+/**
+ * Copy the value at path from src into dst
+ * @param dst
+ * @param src
+ * @param path
+ */
+function reachCopy(dst, src, path) {
+    let current = src;
+    for (const segment of path) {
+        if (!(segment in current))
+            return;
+        const val = current[segment];
+        if (typeof val !== 'object' || val === null)
+            return;
+        current = val;
+    }
+    const value = current;
+    let ref = dst;
+    for (let i = 0; i < path.length - 1; ++i) {
+        const segment = path[i];
+        if (typeof ref[segment] !== 'object')
+            ref[segment] = {};
+        ref = ref[segment];
+    }
+    ref[path[path.length - 1]] = value;
+}

package/dist/cjs/lib/validation/engine/utils/assert.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Throw an AssertError (or the given error) when the condition is falsy
+ * @param condition
+ * @param args message parts (strings, errors or values to stringify), or a single error to throw
+ */
+export declare function assert(condition: unknown, ...args: unknown[]): asserts condition;

package/dist/cjs/lib/validation/engine/utils/assert.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+/**
+ * Derived from the upstream lib/assert.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const assertError_js_1 = require("./assertError.js");
+const stringify_js_1 = require("./stringify.js");
+/**
+ * Throw an AssertError (or the given error) when the condition is falsy
+ * @param condition
+ * @param args message parts (strings, errors or values to stringify), or a single error to throw
+ */
+function assert(condition, ...args) {
+    if (condition)
+        return;
+    if (args.length === 1 && args[0] instanceof Error)
+        throw args[0];
+    const msgs = args
+        .filter((arg) => arg !== '')
+        .map((arg) => typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : (0, stringify_js_1.stringify)(arg));
+    throw new assertError_js_1.AssertError(msgs.join(' '), assert);
+}

package/dist/cjs/lib/validation/engine/utils/assertError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Derived from the upstream lib/assertError.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Error thrown by assert()
+ */
+export declare class AssertError extends Error {
+    name: "AssertError";
+    constructor(message?: string, ctor?: Function);
+}

package/dist/cjs/lib/validation/engine/utils/assertError.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Derived from the upstream lib/assertError.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertError = void 0;
+/**
+ * Error thrown by assert()
+ */
+class AssertError extends Error {
+    constructor(message, ctor) {
+        super(message || 'Unknown error');
+        this.name = 'AssertError';
+        if (typeof Error.captureStackTrace === 'function')
+            Error.captureStackTrace(this, ctor);
+    }
+}
+exports.AssertError = AssertError;

package/dist/cjs/lib/validation/engine/utils/clone.d.ts

@@ -0,0 +1,25 @@
+export interface CloneOptions {
+    /**
+     * Clone the object's prototype, defaults to true
+     */
+    readonly prototype?: boolean;
+    /**
+     * Include symbol properties, defaults to true
+     */
+    readonly symbols?: boolean;
+    /**
+     * Shallow clone the specified keys (paths), or the whole object when true
+     */
+    readonly shallow?: string[] | string[][] | boolean;
+}
+/**
+ * Map of already cloned objects to their clones
+ */
+export type CloneSeen = Map<unknown, unknown>;
+/**
+ * Deep clone an object or array
+ * @param obj
+ * @param options
+ * @param _seen already cloned objects, internal
+ */
+export declare function clone<T>(obj: T, options?: CloneOptions, _seen?: CloneSeen | null): T;

package/dist/cjs/lib/validation/engine/utils/clone.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = clone;
+/**
+ * Derived from the upstream lib/clone.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const reach_js_1 = require("./reach.js");
+const types_js_1 = require("./types.js");
+const utils_js_1 = require("./utils.js");
+const needsProtoHack = new Set([types_js_1.Types.set, types_js_1.Types.map, types_js_1.Types.weakSet, types_js_1.Types.weakMap]);
+/**
+ * Deep clone an object or array
+ * @param obj
+ * @param options
+ * @param _seen already cloned objects, internal
+ */
+function clone(obj, options = {}, _seen = null) {
+    return cloneValue(obj, options, _seen);
+}
+/**
+ * Clone implementation
+ * @param obj
+ * @param options
+ * @param _seen
+ */
+function cloneValue(obj, options, _seen) {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    let cloner = cloneValue;
+    let seen = _seen;
+    if (options.shallow) {
+        if (options.shallow !== true)
+            return cloneWithShallow(obj, options);
+        cloner = (value) => value;
+    }
+    else if (seen) {
+        const lookup = seen.get(obj);
+        if (lookup)
+            return lookup;
+    }
+    else {
+        seen = new Map();
+    }
+    //Built-in object types
+    const baseProto = (0, types_js_1.getInternalProto)(obj);
+    switch (baseProto) {
+        case types_js_1.Types.buffer:
+            return Buffer.from(obj);
+        case types_js_1.Types.date:
+            return new Date(obj.getTime());
+        case types_js_1.Types.regex:
+            return new RegExp(obj);
+        case types_js_1.Types.url:
+            return new URL(obj);
+    }
+    //Generic objects
+    const newObj = base(obj, baseProto, options);
+    if (newObj === obj)
+        return obj;
+    //Set seen, since obj could recurse
+    if (seen)
+        seen.set(obj, newObj);
+    if (baseProto === types_js_1.Types.set) {
+        for (const value of obj)
+            newObj.add(cloner(value, options, seen));
+    }
+    else if (baseProto === types_js_1.Types.map) {
+        for (const [key, value] of obj)
+            newObj.set(key, cloner(value, options, seen));
+    }
+    const source = obj;
+    const target = newObj;
+    for (const key of (0, utils_js_1.keys)(obj, options)) {
+        if (key === '__proto__')
+            continue;
+        if (baseProto === types_js_1.Types.array && key === 'length') {
+            newObj.length = obj.length;
+            continue;
+        }
+        //Already a part of the base object (see base())
+        if (baseProto === types_js_1.Types.error && key === 'stack')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (descriptor) {
+            if (descriptor.get || descriptor.set) {
+                Object.defineProperty(newObj, key, descriptor);
+            }
+            else if (descriptor.enumerable) {
+                target[key] = cloner(source[key], options, seen);
+            }
+            else {
+                Object.defineProperty(newObj, key, { enumerable: false, writable: true, configurable: true, value: cloner(source[key], options, seen) });
+            }
+        }
+        else {
+            Object.defineProperty(newObj, key, {
+                enumerable: true,
+                writable: true,
+                configurable: true,
+                value: cloner(source[key], options, seen)
+            });
+        }
+    }
+    return newObj;
+}
+/**
+ * Clone keeping the objects at the given paths shallow
+ * @param source
+ * @param options
+ */
+function cloneWithShallow(source, options) {
+    const shallowKeys = options.shallow;
+    const settings = { ...options, shallow: false };
+    const seen = new Map();
+    for (const key of shallowKeys) {
+        const ref = (0, reach_js_1.reach)(source, key);
+        if (typeof ref === 'object' || typeof ref === 'function')
+            seen.set(ref, ref);
+    }
+    return cloneValue(source, settings, seen);
+}
+/**
+ * Create the base (empty) object of a clone
+ * @param obj
+ * @param baseProto
+ * @param options
+ */
+function base(obj, baseProto, options) {
+    //Defaults to true
+    if (options.prototype === false) {
+        if (needsProtoHack.has(baseProto))
+            return new baseProto.constructor();
+        return baseProto === types_js_1.Types.array ? [] : {};
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto && proto.isImmutable)
+        return obj;
+    if (baseProto === types_js_1.Types.array) {
+        const newObj = [];
+        if (proto !== baseProto)
+            Object.setPrototypeOf(newObj, proto);
+        return newObj;
+    }
+    //Don't match Util.inherit() subclassed errors
+    if (baseProto === types_js_1.Types.error && proto && (proto === baseProto || Object.prototype.isPrototypeOf.call(Error, proto.constructor))) {
+        //Needed to copy internal stack state
+        const err = structuredClone(obj);
+        //Fix prototype
+        if (Object.getPrototypeOf(err) !== proto)
+            Object.setPrototypeOf(err, proto);
+        return err;
+    }
+    if (needsProtoHack.has(baseProto)) {
+        const newObj = new proto.constructor();
+        if (proto !== baseProto)
+            Object.setPrototypeOf(newObj, proto);
+        return newObj;
+    }
+    return Object.create(proto);
+}

package/dist/cjs/lib/validation/engine/utils/deepEqual.d.ts

@@ -0,0 +1,29 @@
+export interface DeepEqualOptions {
+    /**
+     * Compare functions by their source code, defaults to false
+     */
+    readonly deepFunction?: boolean;
+    /**
+     * Allow a partial match, defaults to false
+     */
+    readonly part?: boolean;
+    /**
+     * Compare the objects' prototypes, defaults to true
+     */
+    readonly prototype?: boolean;
+    /**
+     * Property keys to skip
+     */
+    readonly skip?: (string | symbol)[];
+    /**
+     * Compare symbol properties, defaults to true
+     */
+    readonly symbols?: boolean;
+}
+/**
+ * Perform a deep comparison of the two values including support for circular dependencies, prototype, and enumerable properties
+ * @param obj
+ * @param ref
+ * @param options
+ */
+export declare function deepEqual(obj: unknown, ref: unknown, options?: DeepEqualOptions): boolean;

package/dist/cjs/lib/validation/engine/utils/deepEqual.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEqual = deepEqual;
+/**
+ * Derived from the upstream lib/deepEqual.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const types_js_1 = require("./types.js");
+/**
+ * Marker of objects of mismatched types
+ */
+const mismatched = Symbol('mismatched');
+/**
+ * A pair of objects being compared, used to stop on circular references
+ */
+class SeenEntry {
+    constructor(obj, ref) {
+        this.obj = obj;
+        this.ref = ref;
+    }
+    isSame(obj, ref) {
+        return this.obj === obj && this.ref === ref;
+    }
+}
+/**
+ * Perform a deep comparison of the two values including support for circular dependencies, prototype, and enumerable properties
+ * @param obj
+ * @param ref
+ * @param options
+ */
+function deepEqual(obj, ref, options) {
+    return !!isDeepEqual(obj, ref, { prototype: true, ...options }, []);
+}
+/**
+ * Compare two values
+ * @param obj
+ * @param ref
+ * @param options
+ * @param seen
+ */
+function isDeepEqual(obj, ref, options, seen) {
+    //Copied from Deep-eql, copyright(c) 2013 Jake Luer, jake@alogicalparadox.com, MIT Licensed, https://github.com/chaijs/deep-eql
+    if (obj === ref)
+        return obj !== 0 || 1 / obj === 1 / ref;
+    const type = typeof obj;
+    if (type !== typeof ref)
+        return false;
+    if (obj === null || ref === null)
+        return false;
+    if (type === 'function') {
+        if (!options.deepFunction || toStringOf(obj) !== toStringOf(ref))
+            return false;
+        //Continue as object
+    }
+    else if (type !== 'object') {
+        //NaN
+        return obj !== obj && ref !== ref;
+    }
+    const objObject = obj;
+    const refObject = ref;
+    const instanceType = getSharedType(objObject, refObject, !!options.prototype);
+    switch (instanceType) {
+        case types_js_1.Types.buffer:
+            return Buffer.prototype.equals.call(obj, ref);
+        case types_js_1.Types.promise:
+            return obj === ref;
+        case types_js_1.Types.regex:
+        case types_js_1.Types.url:
+            return toStringOf(obj) === toStringOf(ref);
+        case mismatched:
+            return false;
+    }
+    //If previous comparison failed, it would have stopped execution
+    for (let i = seen.length - 1; i >= 0; --i) {
+        if (seen[i].isSame(objObject, refObject))
+            return true;
+    }
+    seen.push(new SeenEntry(objObject, refObject));
+    try {
+        return !!isDeepEqualObj(instanceType, objObject, refObject, options, seen);
+    }
+    finally {
+        seen.pop();
+    }
+}
+/**
+ * Call the value's own toString() (like upstream, rather than String() which prefers Symbol.toPrimitive)
+ * @param value
+ */
+function toStringOf(value) {
+    return value.toString();
+}
+/**
+ * Get the type shared by both objects, or the mismatched marker
+ * @param obj
+ * @param ref
+ * @param checkPrototype
+ */
+function getSharedType(obj, ref, checkPrototype) {
+    if (checkPrototype) {
+        if (Object.getPrototypeOf(obj) !== Object.getPrototypeOf(ref))
+            return mismatched;
+        return (0, types_js_1.getInternalProto)(obj);
+    }
+    const type = (0, types_js_1.getInternalProto)(obj);
+    if (type !== (0, types_js_1.getInternalProto)(ref))
+        return mismatched;
+    return type;
+}
+/**
+ * Get the primitive value of an object, or the error thrown while getting it
+ * @param obj
+ */
+function valueOf(obj) {
+    const objValueOf = obj.valueOf;
+    if (objValueOf === undefined)
+        return obj;
+    try {
+        return objValueOf.call(obj);
+    }
+    catch (err) {
+        return err;
+    }
+}
+/**
+ * Whether the object has an own enumerable property
+ * @param obj
+ * @param key
+ */
+function hasOwnEnumerableProperty(obj, key) {
+    return Object.prototype.propertyIsEnumerable.call(obj, key);
+}
+/**
+ * Whether every entry of obj is also in ref (by identity)
+ * @param obj
+ * @param ref
+ */
+function isSetSimpleEqual(obj, ref) {
+    for (const entry of Set.prototype.values.call(obj)) {
+        if (!Set.prototype.has.call(ref, entry))
+            return false;
+    }
+    return true;
+}
+/**
+ * Compare two objects of the same type
+ * @param instanceType
+ * @param obj
+ * @param ref
+ * @param options
+ * @param seen
+ */
+function isDeepEqualObj(instanceType, obj, ref, options, seen) {
+    const objRecord = obj;
+    const refRecord = ref;
+    if (instanceType === types_js_1.Types.array) {
+        const objArray = obj;
+        const refArray = ref;
+        if (options.part) {
+            //Check if any index match any other index
+            for (const objValue of objArray) {
+                for (const refValue of refArray) {
+                    if (isDeepEqual(objValue, refValue, options, seen))
+                        return true;
+                }
+            }
+        }
+        else {
+            if (objArray.length !== refArray.length)
+                return false;
+            for (let i = 0; i < objArray.length; ++i) {
+                if (!isDeepEqual(objArray[i], refArray[i], options, seen))
+                    return false;
+            }
+            return true;
+        }
+    }
+    else if (instanceType === types_js_1.Types.set) {
+        const objSet = obj;
+        const refSet = ref;
+        if (objSet.size !== refSet.size)
+            return false;
+        if (!isSetSimpleEqual(objSet, refSet)) {
+            //Check for deep equality
+            const ref2 = new Set(Set.prototype.values.call(refSet));
+            for (const objEntry of Set.prototype.values.call(objSet)) {
+                if (ref2.delete(objEntry))
+                    continue;
+                let found = false;
+                for (const refEntry of ref2) {
+                    if (isDeepEqual(objEntry, refEntry, options, seen)) {
+                        ref2.delete(refEntry);
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    return false;
+            }
+        }
+    }
+    else if (instanceType === types_js_1.Types.map) {
+        const objMap = obj;
+        const refMap = ref;
+        if (objMap.size !== refMap.size)
+            return false;
+        for (const [key, value] of Map.prototype.entries.call(objMap)) {
+            if (value === undefined && !Map.prototype.has.call(refMap, key))
+                return false;
+            if (!isDeepEqual(value, Map.prototype.get.call(refMap, key), options, seen))
+                return false;
+        }
+    }
+    else if (instanceType === types_js_1.Types.error) {
+        //Always check name and message
+        if (obj.name !== ref.name || obj.message !== ref.message)
+            return false;
+    }
+    //Check .valueOf()
+    const valueOfObj = valueOf(obj);
+    const valueOfRef = valueOf(ref);
+    if ((obj !== valueOfObj || ref !== valueOfRef) && !isDeepEqual(valueOfObj, valueOfRef, options, seen))
+        return false;
+    //Check properties
+    const objKeys = Object.keys(obj);
+    if (!options.part && objKeys.length !== Object.keys(ref).length && !options.skip)
+        return false;
+    let skipped = 0;
+    for (const key of objKeys) {
+        if (options.skip && options.skip.includes(key)) {
+            if (refRecord[key] === undefined)
+                ++skipped;
+            continue;
+        }
+        if (!hasOwnEnumerableProperty(ref, key))
+            return false;
+        if (!isDeepEqual(objRecord[key], refRecord[key], options, seen))
+            return false;
+    }
+    if (!options.part && objKeys.length - skipped !== Object.keys(ref).length)
+        return false;
+    //Check symbols (defaults to true)
+    if (options.symbols !== false) {
+        const objSymbols = Object.getOwnPropertySymbols(obj);
+        const refSymbols = new Set(Object.getOwnPropertySymbols(ref));
+        for (const key of objSymbols) {
+            if (!options.skip?.includes(key)) {
+                if (hasOwnEnumerableProperty(obj, key)) {
+                    if (!hasOwnEnumerableProperty(ref, key))
+                        return false;
+                    if (!isDeepEqual(objRecord[key], refRecord[key], options, seen))
+                        return false;
+                }
+                else if (hasOwnEnumerableProperty(ref, key)) {
+                    return false;
+                }
+            }
+            refSymbols.delete(key);
+        }
+        for (const key of refSymbols) {
+            if (hasOwnEnumerableProperty(ref, key))
+                return false;
+        }
+    }
+    return true;
+}

package/dist/cjs/lib/validation/engine/utils/escapeHtml.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Derived from the upstream lib/escapeHtml.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Escape a string for HTML
+ * @param input
+ */
+export declare function escapeHtml(input: string): string;