@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/json-schema/helpers.js

@@ -0,0 +1,366 @@
+/**
+ * Native equivalents of the lodash 4.17.21 collection functions used by the upstream JSON Schema conversion (see
+ * UPSTREAM.md; lodash and the upstream library: MIT, see THIRD_PARTY_NOTICES.md). Each function keeps the lodash
+ * semantics for the values the parsers pass
+ * (plain objects, arrays, strings, null and undefined); merge() follows lodash's merge algorithm.
+ */
+const typedArrayTags = new Set([
+    '[object Float32Array]', '[object Float64Array]', '[object Int8Array]', '[object Int16Array]', '[object Int32Array]',
+    '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Uint16Array]', '[object Uint32Array]'
+]);
+const objectCtorString = Function.prototype.toString.call(Object);
+function tagOf(value) {
+    return Object.prototype.toString.call(value);
+}
+function isObject(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+function isObjectLike(value) {
+    return value !== null && typeof value === 'object';
+}
+function isLength(value) {
+    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+    return value !== null && value !== undefined && typeof value !== 'function' && isLength(value.length);
+}
+function isArguments(value) {
+    return isObjectLike(value) && tagOf(value) === '[object Arguments]';
+}
+function isTypedArray(value) {
+    return isObjectLike(value) && typedArrayTags.has(tagOf(value));
+}
+function isPlainObject(value) {
+    if (!isObjectLike(value) || tagOf(value) !== '[object Object]')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return true;
+    const Ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+    return typeof Ctor === 'function' && Ctor instanceof Ctor && Function.prototype.toString.call(Ctor) === objectCtorString;
+}
+function isIndex(value) {
+    return /^(?:0|[1-9]\d*)$/.test(value) && Number(value) < Number.MAX_SAFE_INTEGER;
+}
+//SameValueZero
+function eq(value, other) {
+    return value === other || (value !== value && other !== other);
+}
+/**
+ * The keys of a collection: indexes of array-likes, own enumerable keys of objects
+ * @param collection
+ */
+function keysOf(collection) {
+    if (isArrayLike(collection)) {
+        const keys = [];
+        for (let i = 0; i < collection.length; ++i)
+            keys.push(String(i));
+        return keys;
+    }
+    return Object.keys(collection);
+}
+/**
+ * The value at a dotted path, or undefined when a segment is missing (a key present as is in the object wins)
+ * @param object
+ * @param path
+ */
+export function get(object, path) {
+    if (object === null || object === undefined)
+        return undefined;
+    if (path in Object(object))
+        return object[path];
+    let value = object;
+    for (const key of path.split('.')) {
+        if (value === null || value === undefined)
+            return undefined;
+        value = value[key];
+    }
+    return value;
+}
+/**
+ * Set the value at a dotted path, creating the missing objects (arrays for index segments)
+ * @param object
+ * @param path
+ * @param value
+ */
+export function set(object, path, value) {
+    if (!isObject(object))
+        return object;
+    const keys = path in object ? [path] : path.split('.');
+    let nested = object;
+    for (let i = 0; i < keys.length && nested !== null && nested !== undefined; ++i) {
+        const key = keys[i];
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype')
+            return object;
+        if (i === keys.length - 1) {
+            assignValue(nested, key, value);
+            break;
+        }
+        const current = nested[key];
+        assignValue(nested, key, isObject(current) ? current : (isIndex(keys[i + 1]) ? [] : {}));
+        nested = nested[key];
+    }
+    return object;
+}
+function assignValue(object, key, value) {
+    //Like lodash (not in strict mode): an assignment to a primitive does nothing
+    if (!isObject(object))
+        return;
+    const current = object[key];
+    if (!(Object.prototype.hasOwnProperty.call(object, key) && eq(current, value)) || (value === undefined && !(key in object)))
+        object[key] = value;
+}
+/**
+ * Whether a value is empty: no length (array-likes), no size (maps, sets) or no own enumerable key (objects)
+ * @param value
+ */
+export function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (isArrayLike(value) && (Array.isArray(value) || typeof value === 'string' || typeof value.splice === 'function' || Buffer.isBuffer(value) || isTypedArray(value) || isArguments(value)))
+        return !value.length;
+    if (value instanceof Map || value instanceof Set)
+        return !value.size;
+    for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            return false;
+    }
+    return true;
+}
+/**
+ * Map a collection (array-likes by index, objects by own enumerable key); nothing for null or undefined
+ * @param collection
+ * @param iteratee
+ */
+export function map(collection, iteratee) {
+    if (collection === null || collection === undefined)
+        return [];
+    if (Array.isArray(collection)) {
+        const result = new Array(collection.length);
+        for (let i = 0; i < collection.length; ++i)
+            result[i] = iteratee(collection[i], i);
+        return result;
+    }
+    const record = Object(collection);
+    return keysOf(record).map((key) => iteratee(record[key], isArrayLike(collection) ? Number(key) : key));
+}
+/**
+ * Iterate a collection (array-likes by index, objects by own enumerable key), until the iteratee returns false
+ * @param collection
+ * @param iteratee
+ */
+export function each(collection, iteratee) {
+    if (collection === null || collection === undefined)
+        return;
+    const record = Object(collection);
+    const arrayLike = isArrayLike(collection);
+    for (const key of keysOf(record)) {
+        if (iteratee(record[key], arrayLike ? Number(key) : key) === false)
+            return;
+    }
+}
+/**
+ * The number of items of a collection (length, size or own enumerable keys)
+ * @param collection
+ */
+export function size(collection) {
+    if (collection === null || collection === undefined)
+        return 0;
+    if (isArrayLike(collection))
+        return collection.length;
+    if (collection instanceof Map || collection instanceof Set)
+        return collection.size;
+    return Object.keys(collection).length;
+}
+/**
+ * The unique values of an array (SameValueZero), in order
+ * @param array
+ */
+export function uniq(array) {
+    return array && array.length ? [...new Set(array)] : [];
+}
+/**
+ * Remove (in place) the items of an array matching a predicate, returning them
+ * @param array
+ * @param predicate
+ */
+export function remove(array, predicate) {
+    const result = [];
+    if (!(array && array.length))
+        return result;
+    const indexes = [];
+    for (let i = 0; i < array.length; ++i) {
+        const value = array[i];
+        if (predicate(value, i, array)) {
+            result.push(value);
+            indexes.push(i);
+        }
+    }
+    for (let i = indexes.length - 1; i >= 0; --i)
+        array.splice(indexes[i], 1);
+    return result;
+}
+/**
+ * The truthy items of an array
+ * @param array
+ */
+export function compact(array) {
+    const result = [];
+    if (!array)
+        return result;
+    for (const value of array) {
+        if (value)
+            result.push(value);
+    }
+    return result;
+}
+/**
+ * Whether an item of an array matches a predicate
+ * @param array
+ * @param predicate
+ */
+export function some(array, predicate) {
+    if (!array)
+        return false;
+    for (const value of array) {
+        if (predicate(value))
+            return true;
+    }
+    return false;
+}
+/**
+ * The properties (own and inherited enumerable) of an object matching a predicate
+ * @param object
+ * @param predicate
+ */
+export function pickBy(object, predicate) {
+    const result = {};
+    if (object === null || object === undefined)
+        return result;
+    const record = object;
+    for (const key in record) {
+        if (key !== '__proto__' && predicate(record[key], key))
+            result[key] = record[key];
+    }
+    return result;
+}
+/**
+ * Deep merge the sources into the object (lodash merge): plain objects and arrays are merged recursively (into the
+ * existing value when it is an object), other values are assigned; undefined does not replace an existing key
+ * @param object
+ * @param sources
+ */
+export function merge(object, ...sources) {
+    for (const source of sources) {
+        if (source)
+            baseMerge(object, source, new Map());
+    }
+    return object;
+}
+function keysIn(source) {
+    const keys = [];
+    if (isArrayLike(source)) {
+        const isBuff = Buffer.isBuffer(source);
+        const isTyped = !isBuff && isTypedArray(source);
+        for (let i = 0; i < source.length; ++i)
+            keys.push(String(i));
+        for (const key in source) {
+            if (isIndex(key) || key === 'length')
+                continue;
+            //Like lodash: the internal properties of buffers and typed arrays are skipped
+            if (isBuff && (key === 'offset' || key === 'parent'))
+                continue;
+            if (isTyped && (key === 'buffer' || key === 'byteLength' || key === 'byteOffset'))
+                continue;
+            keys.push(key);
+        }
+        return keys;
+    }
+    for (const key in source)
+        keys.push(key);
+    return keys;
+}
+function safeGet(object, key) {
+    if (key === 'constructor' && typeof object[key] === 'function')
+        return undefined;
+    if (key === '__proto__')
+        return undefined;
+    return object[key];
+}
+function assignMergeValue(object, key, value) {
+    if ((value !== undefined && !eq(object[key], value)) || (value === undefined && !(key in object))) {
+        if (key === '__proto__') {
+            Object.defineProperty(object, key, { configurable: true, enumerable: true, value, writable: true });
+        }
+        else {
+            object[key] = value;
+        }
+    }
+}
+function baseMerge(object, source, stack) {
+    if (object === source)
+        return;
+    for (const key of keysIn(source)) {
+        const srcValue = source[key];
+        if (isObject(srcValue)) {
+            baseMergeDeep(object, source, key, stack);
+        }
+        else {
+            assignMergeValue(object, key, srcValue);
+        }
+    }
+}
+function baseMergeDeep(object, source, key, stack) {
+    const objValue = safeGet(object, key);
+    const srcValue = safeGet(source, key);
+    const stacked = stack.get(srcValue);
+    if (stacked) {
+        assignMergeValue(object, key, stacked);
+        return;
+    }
+    let isCommon = true;
+    let newValue = srcValue;
+    const isArr = Array.isArray(srcValue);
+    const isBuff = !isArr && Buffer.isBuffer(srcValue);
+    const isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+    if (isArr || isBuff || isTyped) {
+        if (Array.isArray(objValue)) {
+            newValue = objValue;
+        }
+        else if (isObjectLike(objValue) && isArrayLike(objValue)) {
+            newValue = Array.from(objValue);
+        }
+        else if (isBuff) {
+            isCommon = false;
+            //Like lodash (its deep buffer clone is a slice, which shares the memory)
+            newValue = srcValue.subarray();
+        }
+        else if (isTyped) {
+            isCommon = false;
+            const typed = srcValue;
+            const TypedArray = typed.constructor;
+            newValue = new TypedArray(typed.buffer.slice(0), typed.byteOffset, typed.length);
+        }
+        else {
+            newValue = [];
+        }
+    }
+    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+        newValue = objValue;
+        if (isArguments(objValue)) {
+            newValue = Object.assign({}, objValue);
+        }
+        else if (!isObject(objValue) || typeof objValue === 'function') {
+            newValue = typeof srcValue.constructor === 'function' ? Object.create(Object.getPrototypeOf(srcValue)) : {};
+        }
+    }
+    else {
+        isCommon = false;
+    }
+    if (isCommon) {
+        stack.set(srcValue, newValue);
+        baseMerge(newValue, srcValue, stack);
+        stack.delete(srcValue);
+    }
+    assignMergeValue(object, key, newValue);
+}