@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,86 @@
+/**
+ * Derived from the upstream lib/applyToDefaults.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from './assert.js';
+import { clone } from './clone.js';
+import { merge } from './merge.js';
+import { reach } from './reach.js';
+import { isArray } from './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
+ */
+export function applyToDefaults(defaults, source, options = {}) {
+    assert(defaults && typeof defaults === 'object', 'Invalid defaults value: must be an object');
+    assert(!source || source === true || typeof source === 'object', 'Invalid source value: must be true, falsy or an object');
+    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 = clone(defaults);
+    //If source is set to true, use defaults
+    if (source === true)
+        return copy;
+    const nullOverride = options.nullOverride !== undefined ? options.nullOverride : false;
+    return 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;
+    assert(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 = isArray(shallowKey) ? shallowKey : shallowKey.split('.');
+        const ref = reach(defaults, key);
+        if (ref && typeof ref === 'object') {
+            seen.set(ref, mergePaths && reach(source, key) || ref);
+        }
+        else if (mergePaths) {
+            mergePaths.add(key);
+        }
+    }
+    const copy = 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 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/esm/lib/validation/engine/utils/assert.js

@@ -0,0 +1,20 @@
+/**
+ * Derived from the upstream lib/assert.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { AssertError } from './assertError.js';
+import { stringify } from './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
+ */
+export 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 : stringify(arg));
+    throw new AssertError(msgs.join(' '), assert);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Derived from the upstream lib/assertError.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Error thrown by assert()
+ */
+export class AssertError extends Error {
+    constructor(message, ctor) {
+        super(message || 'Unknown error');
+        this.name = 'AssertError';
+        if (typeof Error.captureStackTrace === 'function')
+            Error.captureStackTrace(this, ctor);
+    }
+}

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

@@ -0,0 +1,157 @@
+/**
+ * Derived from the upstream lib/clone.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { reach } from './reach.js';
+import { getInternalProto, Types } from './types.js';
+import { keys } from './utils.js';
+const needsProtoHack = new Set([Types.set, Types.map, Types.weakSet, Types.weakMap]);
+/**
+ * Deep clone an object or array
+ * @param obj
+ * @param options
+ * @param _seen already cloned objects, internal
+ */
+export 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 = getInternalProto(obj);
+    switch (baseProto) {
+        case Types.buffer:
+            return Buffer.from(obj);
+        case Types.date:
+            return new Date(obj.getTime());
+        case Types.regex:
+            return new RegExp(obj);
+        case 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.set) {
+        for (const value of obj)
+            newObj.add(cloner(value, options, seen));
+    }
+    else if (baseProto === 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 keys(obj, options)) {
+        if (key === '__proto__')
+            continue;
+        if (baseProto === Types.array && key === 'length') {
+            newObj.length = obj.length;
+            continue;
+        }
+        //Already a part of the base object (see base())
+        if (baseProto === 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 = 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.array ? [] : {};
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto && proto.isImmutable)
+        return obj;
+    if (baseProto === Types.array) {
+        const newObj = [];
+        if (proto !== baseProto)
+            Object.setPrototypeOf(newObj, proto);
+        return newObj;
+    }
+    //Don't match Util.inherit() subclassed errors
+    if (baseProto === 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/esm/lib/validation/engine/utils/deepEqual.js

@@ -0,0 +1,262 @@
+/**
+ * Derived from the upstream lib/deepEqual.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { getInternalProto, Types } from './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
+ */
+export 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.buffer:
+            return Buffer.prototype.equals.call(obj, ref);
+        case Types.promise:
+            return obj === ref;
+        case Types.regex:
+        case 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 getInternalProto(obj);
+    }
+    const type = getInternalProto(obj);
+    if (type !== 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.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.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.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.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/esm/lib/validation/engine/utils/escapeHtml.js

@@ -0,0 +1,59 @@
+/**
+ * Derived from the upstream lib/escapeHtml.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const namedHtml = new Map([
+    [38, '&'],
+    [60, '<'],
+    [62, '>'],
+    [34, '"'],
+    [160, ' '],
+    [162, '¢'],
+    [163, '£'],
+    [164, '¤'],
+    [169, '©'],
+    [174, '®']
+]);
+const safeCharCodes = (() => {
+    const safe = new Set();
+    for (let i = 32; i < 123; ++i) {
+        if ((i >= 97) || // a-z
+            (i >= 65 && i <= 90) || // A-Z
+            (i >= 48 && i <= 57) || // 0-9
+            i === 32 || // space
+            i === 46 || // .
+            i === 44 || // ,
+            i === 45 || // -
+            i === 58 || // :
+            i === 95) { // _
+            safe.add(i);
+        }
+    }
+    return safe;
+})();
+/**
+ * Escape a character for HTML
+ * @param charCode
+ */
+function escapeHtmlChar(charCode) {
+    const namedEscape = namedHtml.get(charCode);
+    if (namedEscape)
+        return namedEscape;
+    if (charCode >= 256)
+        return '&#' + charCode + ';';
+    const hexValue = charCode.toString(16).padStart(2, '0');
+    return `&#x${hexValue};`;
+}
+/**
+ * Escape a string for HTML
+ * @param input
+ */
+export function escapeHtml(input) {
+    if (!input)
+        return '';
+    let escaped = '';
+    for (let i = 0; i < input.length; ++i) {
+        const charCode = input.charCodeAt(i);
+        escaped += safeCharCodes.has(charCode) ? input[i] : escapeHtmlChar(charCode);
+    }
+    return escaped;
+}

package/dist/esm/lib/validation/engine/utils/escapeRegex.js

@@ -0,0 +1,10 @@
+/**
+ * Derived from the upstream lib/escapeRegex.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Escape a string for use in a regular expression: ^$.*+-?=!:|\/()[]{},
+ * @param string
+ */
+export function escapeRegex(string) {
+    return string.replace(/[\^\$\.\*\+\-\?\=\!\:\|\\\/\(\)\[\]\{\}\,]/g, '\\$&');
+}

package/dist/esm/lib/validation/engine/utils/ignore.js

@@ -0,0 +1,9 @@
+/**
+ * Derived from the upstream lib/ignore.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * A no-op function
+ * @param _args
+ */
+export function ignore(..._args) {
+}

package/dist/esm/lib/validation/engine/utils/index.js

@@ -0,0 +1,16 @@
+/**
+ * Subset of the upstream used by the validation engine (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+export { applyToDefaults } from './applyToDefaults.js';
+export { assert } from './assert.js';
+export { AssertError } from './assertError.js';
+export { clone } from './clone.js';
+export { deepEqual } from './deepEqual.js';
+export { escapeHtml } from './escapeHtml.js';
+export { escapeRegex } from './escapeRegex.js';
+export { ignore } from './ignore.js';
+export { merge } from './merge.js';
+export { reach } from './reach.js';
+export { stringify } from './stringify.js';
+export { getInternalProto, Types } from './types.js';
+export { isArray, keys } from './utils.js';