@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.1

package/lib/utils/cloneDeep.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneDeep = cloneDeep;
+const node_util_1 = require("node:util");
+const { isTypedArray, isMap, isSet, isProxy } = node_util_1.types;
+const toString = Object.prototype.toString;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+const getPrototypeOf = Object.getPrototypeOf;
+const getOwnPropertySymbols = Object.getOwnPropertySymbols;
+const objectKeys = Object.keys;
+const objectProto = Object.prototype;
+const symToStringTag = Symbol.toStringTag;
+const symbolValueOf = Symbol.prototype.valueOf;
+const ARGS_TAG = '[object Arguments]';
+const ARRAY_BUFFER_TAG = '[object ArrayBuffer]';
+const BOOL_TAG = '[object Boolean]';
+const DATA_VIEW_TAG = '[object DataView]';
+const DATE_TAG = '[object Date]';
+const FUNC_TAG = '[object Function]';
+const GEN_TAG = '[object GeneratorFunction]';
+const MAP_TAG = '[object Map]';
+const NUMBER_TAG = '[object Number]';
+const OBJECT_TAG = '[object Object]';
+const REGEXP_TAG = '[object RegExp]';
+const SET_TAG = '[object Set]';
+const STRING_TAG = '[object String]';
+const SYMBOL_TAG = '[object Symbol]';
+const TYPED_ARRAY_TAGS = [
+    '[object Float32Array]',
+    '[object Float64Array]',
+    '[object Int8Array]',
+    '[object Int16Array]',
+    '[object Int32Array]',
+    '[object Uint8Array]',
+    '[object Uint8ClampedArray]',
+    '[object Uint16Array]',
+    '[object Uint32Array]',
+];
+// The tags lodash clones by type. Values with other tags (Error, WeakMap,
+// Promise, a custom `Symbol.toStringTag` and so on) aren't cloned.
+const CLONEABLE_TAGS = new Set([
+    ARGS_TAG,
+    '[object Array]',
+    ARRAY_BUFFER_TAG,
+    DATA_VIEW_TAG,
+    BOOL_TAG,
+    DATE_TAG,
+    MAP_TAG,
+    NUMBER_TAG,
+    OBJECT_TAG,
+    REGEXP_TAG,
+    SET_TAG,
+    STRING_TAG,
+    SYMBOL_TAG,
+    ...TYPED_ARRAY_TAGS,
+]);
+const RE_FLAGS = /\w*$/;
+const RE_IS_UINT = /^(?:0|[1-9]\d*)$/;
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+function cloneDeep(value) {
+    if (!isObject(value)) {
+        return value;
+    }
+    return baseClone(value, false, new Map());
+}
+// `isNested` is true when the value is inside another value.
+function baseClone(value, isNested, seen) {
+    if (!isObject(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return cloneArray(value, seen);
+    }
+    if (Buffer.isBuffer(value)) {
+        // Buffers are cloned before the lookup of values already seen, so a
+        // buffer found twice gives two copies, as in lodash.
+        const result = Buffer.allocUnsafe(value.length);
+        value.copy(result);
+        return result;
+    }
+    if (getPrototypeOf(value) === objectProto && !hasOwnProperty.call(value, symToStringTag)) {
+        return clonePlainObject(value, seen);
+    }
+    return cloneOther(value, isNested, seen);
+}
+function cloneArray(array, seen) {
+    const length = array.length;
+    const Ctor = array.constructor;
+    const result = new Ctor(length);
+    // The properties `RegExp#exec` adds to its result.
+    if (length && typeof array[0] === 'string' && hasOwnProperty.call(array, 'index')) {
+        result.index = array.index;
+        result.input = array.input;
+    }
+    const cloned = seen.get(array);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    seen.set(array, result);
+    if (Ctor === Array) {
+        // A new Array has no elements yet, so every assignment happens.
+        for (let i = 0; i < length; ++i) {
+            result[i] = baseClone(array[i], true, seen);
+        }
+    }
+    else {
+        for (let i = 0; i < length; ++i) {
+            assignValue(result, i, baseClone(array[i], true, seen));
+        }
+    }
+    return result;
+}
+// An object whose prototype is Object.prototype. This is the same as the
+// general path for such objects, without the checks that can't apply.
+function clonePlainObject(obj, seen) {
+    const cloned = seen.get(obj);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    const result = {};
+    seen.set(obj, result);
+    const keys = objectKeys(obj);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        // lodash skips the `constructor` key of prototype objects.
+        if (key === 'constructor' && !isArrayLike(obj) && isPrototype(obj)) {
+            continue;
+        }
+        const value = baseClone(obj[key], true, seen);
+        if (key === '__proto__') {
+            defineOwn(result, key, value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    copySymbols(obj, result, seen);
+    return result;
+}
+function cloneOther(value, isNested, seen) {
+    const tag = getTag(value);
+    const isFunc = tag === FUNC_TAG || tag === GEN_TAG;
+    let result;
+    if (tag === OBJECT_TAG || tag === ARGS_TAG || (isFunc && !isNested)) {
+        result = isFunc ? {} : initCloneObject(value);
+    }
+    else if (!CLONEABLE_TAGS.has(tag)) {
+        return isNested ? value : {};
+    }
+    else {
+        result = initCloneByTag(value, tag);
+    }
+    const cloned = seen.get(value);
+    if (cloned !== undefined) {
+        return cloned;
+    }
+    seen.set(value, result);
+    if (isSet(value)) {
+        value.forEach((item) => {
+            result.add(baseClone(item, true, seen));
+        });
+        return result;
+    }
+    if (isMap(value)) {
+        value.forEach((item, key) => {
+            result.set(key, baseClone(item, true, seen));
+        });
+        return result;
+    }
+    const keys = getKeys(value);
+    for (let i = 0, l = keys.length; i < l; ++i) {
+        const key = keys[i];
+        assignValue(result, key, baseClone(value[key], true, seen));
+    }
+    copySymbols(value, result, seen);
+    return result;
+}
+function copySymbols(source, result, seen) {
+    const symbols = getOwnPropertySymbols(source);
+    for (let i = 0, l = symbols.length; i < l; ++i) {
+        const symbol = symbols[i];
+        if (propertyIsEnumerable.call(source, symbol)) {
+            assignValue(result, symbol, baseClone(source[symbol], true, seen));
+        }
+    }
+}
+function initCloneObject(value) {
+    if (typeof value.constructor === 'function' && !isPrototype(value)) {
+        const proto = getPrototypeOf(value);
+        return isObject(proto) ? Object.create(proto) : {};
+    }
+    return {};
+}
+// `value` is an object with one of the tags in CLONEABLE_TAGS, other than
+// the object, arguments and array tags.
+function initCloneByTag(value, tag) {
+    const Ctor = value.constructor;
+    switch (tag) {
+        case ARRAY_BUFFER_TAG:
+            return cloneArrayBuffer(value);
+        case BOOL_TAG:
+        case DATE_TAG:
+            return new Ctor(+value);
+        case DATA_VIEW_TAG: {
+            const dataView = value;
+            return new Ctor(cloneArrayBuffer(dataView.buffer), dataView.byteOffset, dataView.byteLength);
+        }
+        case MAP_TAG:
+        case SET_TAG:
+            return new Ctor();
+        case NUMBER_TAG:
+        case STRING_TAG:
+            return new Ctor(value);
+        case REGEXP_TAG: {
+            const regExp = value;
+            const result = new Ctor(regExp.source, RE_FLAGS.exec(regExp));
+            result.lastIndex = regExp.lastIndex;
+            return result;
+        }
+        case SYMBOL_TAG:
+            return Object(symbolValueOf.call(value));
+        default: {
+            // A typed array.
+            const typedArray = value;
+            return new Ctor(cloneArrayBuffer(typedArray.buffer), typedArray.byteOffset, typedArray.length);
+        }
+    }
+}
+function cloneArrayBuffer(arrayBuffer) {
+    const result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+    return result;
+}
+// lodash's `keys`: the own enumerable string keys, except the indexes and
+// `length` of arguments objects and typed arrays (which are listed by index
+// instead) and the `constructor` key of prototype objects.
+function getKeys(value) {
+    if (isArrayLike(value)) {
+        return arrayLikeKeys(value);
+    }
+    const keys = objectKeys(value);
+    return isPrototype(value) ? keys.filter((key) => key !== 'constructor') : keys;
+}
+function arrayLikeKeys(value) {
+    const isArgs = getTag(value) === ARGS_TAG;
+    const isTyped = !isArgs && isTypedArray(value);
+    const skipIndexes = isArgs || isTyped;
+    const length = skipIndexes ? value.length : 0;
+    const result = [];
+    for (let i = 0; i < length; ++i) {
+        result.push(String(i));
+    }
+    for (const key in value) {
+        if (hasOwnProperty.call(value, key) &&
+            !(skipIndexes &&
+                (key === 'length' ||
+                    (isTyped && (key === 'buffer' || key === 'byteLength' || key === 'byteOffset')) ||
+                    isIndex(key, length)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+// lodash's `getTag`, which reads the built-in tag of an object whose
+// `Symbol.toStringTag` property can be written over, the way lodash does it:
+// lodash writes `undefined` over the tag, reads the tag and puts it back.
+// Writing over a read-only tag, like the ones of Map, Set and the typed
+// arrays, throws. That is checked first, because a throw is slow.
+function getTag(value) {
+    if (!(symToStringTag in value)) {
+        return toString.call(value);
+    }
+    if (isProxy(value)) {
+        return getTagByWriting(value);
+    }
+    return canWriteTag(value) ? getTagByWriting(value) : toString.call(value);
+}
+// Whether `value[Symbol.toStringTag] = undefined` would succeed: the first
+// object up the prototype chain that has the property decides, as in the
+// [[Set]] of ordinary objects.
+function canWriteTag(value) {
+    let obj = value;
+    while (obj !== null) {
+        if (isProxy(obj)) {
+            // A proxy decides for itself. Try it, as lodash does.
+            return true;
+        }
+        const desc = Object.getOwnPropertyDescriptor(obj, symToStringTag);
+        if (desc !== undefined) {
+            if ('value' in desc) {
+                return desc.writable && (obj === value || Object.isExtensible(value));
+            }
+            return desc.set !== undefined;
+        }
+        obj = getPrototypeOf(obj);
+    }
+    return true;
+}
+function getTagByWriting(value) {
+    const obj = value;
+    const isOwn = hasOwnProperty.call(obj, symToStringTag);
+    const tag = obj[symToStringTag];
+    let unmasked = false;
+    try {
+        obj[symToStringTag] = undefined;
+        unmasked = true;
+    }
+    catch (err) {
+        // The tag can't be written over, so it's used as is.
+    }
+    const result = toString.call(obj);
+    if (unmasked) {
+        if (isOwn) {
+            obj[symToStringTag] = tag;
+        }
+        else {
+            delete obj[symToStringTag];
+        }
+    }
+    return result;
+}
+// Assigns unless the property already has the same value, as lodash does.
+function assignValue(object, key, value) {
+    const objValue = object[key];
+    if (!(hasOwnProperty.call(object, key) && sameValueZero(objValue, value)) ||
+        (value === undefined && !(key in object))) {
+        if (key === '__proto__') {
+            defineOwn(object, key, value);
+        }
+        else {
+            object[key] = value;
+        }
+    }
+}
+function defineOwn(object, key, value) {
+    Object.defineProperty(object, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+function isObject(value) {
+    const type = typeof value;
+    return value !== null && (type === 'object' || type === 'function');
+}
+function isPrototype(value) {
+    const Ctor = value.constructor;
+    const proto = (typeof Ctor === 'function' && Ctor.prototype) || objectProto;
+    return value === proto;
+}
+function isArrayLike(value) {
+    return typeof value !== 'function' && isLength(value.length);
+}
+function isLength(value) {
+    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
+}
+function isIndex(key, length) {
+    // `key < length` compares the key as a number.
+    return length > 0 && RE_IS_UINT.test(key) && key < length;
+}
+function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
+}

package/lib/utils/createModifier.js

@@ -1,42 +1,37 @@
-'use strict';
-
-const { asArray, isString, isFunction, isPlainObject } = require('./objectUtils');
-
-function createModifier({ modelClass, modifier, modifiers }) {
-  const modelModifiers = modelClass ? modelClass.getModifiers() : {};
-
-  const modifierFunctions = asArray(modifier).map((modifier) => {
-    let modify = null;
-
-    if (isString(modifier)) {
-      modify = (modifiers && modifiers[modifier]) || modelModifiers[modifier];
-
-      // Modifiers can be pointers to other modifiers. Call this function recursively.
-      if (modify && !isFunction(modify)) {
-        return createModifier({ modelClass, modifier: modify, modifiers });
-      }
-    } else if (isFunction(modifier)) {
-      modify = modifier;
-    } else if (isPlainObject(modifier)) {
-      modify = (builder) => builder.where(modifier);
-    } else if (Array.isArray(modifier)) {
-      return createModifier({ modelClass, modifier, modifiers });
-    }
-
-    if (!modify) {
-      modify = (builder) => modelClass.modifierNotFound(builder, modifier);
-    }
-
-    return modify;
-  });
-
-  return (builder, ...args) => {
-    for (const modifier of modifierFunctions) {
-      modifier.call(builder, builder, ...args);
-    }
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModifier = createModifier;
+const objectUtils_1 = require("./objectUtils");
+function createModifier({ modelClass, modifier, modifiers, }) {
+    const modelModifiers = modelClass ? modelClass.getModifiers() : {};
+    const modifierFunctions = (0, objectUtils_1.asArray)(modifier).map((modifier) => {
+        let modify = null;
+        if ((0, objectUtils_1.isString)(modifier)) {
+            modify = (modifiers && modifiers[modifier]) || modelModifiers[modifier];
+            // Modifiers can be pointers to other modifiers. Call this function recursively.
+            if (modify && !(0, objectUtils_1.isFunction)(modify)) {
+                return createModifier({ modelClass, modifier: modify, modifiers });
+            }
+        }
+        else if ((0, objectUtils_1.isFunction)(modifier)) {
+            modify = modifier;
+        }
+        else if ((0, objectUtils_1.isPlainObject)(modifier)) {
+            modify = (builder) => builder.where(modifier);
+        }
+        else if (Array.isArray(modifier)) {
+            return createModifier({ modelClass, modifier, modifiers });
+        }
+        if (!modify) {
+            // Without a model class this throws when the modifier is called, as it did
+            // in the JavaScript code.
+            modify = (builder) => modelClass.modifierNotFound(builder, modifier);
+        }
+        return modify;
+    });
+    return (builder, ...args) => {
+        for (const modifier of modifierFunctions) {
+            modifier.call(builder, builder, ...args);
+        }
+    };
 }
-
-module.exports = {
-  createModifier,
-};

package/lib/utils/deprecate.js

@@ -1,15 +1,11 @@
-'use strict';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecate = deprecate;
 const LOGGED_DEPRECATIONS = new Set();
-
 function deprecate(message) {
-  // Only log deprecation messages once.
-  if (!LOGGED_DEPRECATIONS.has(message)) {
-    LOGGED_DEPRECATIONS.add(message);
-    console.warn(message);
-  }
+    // Only log deprecation messages once.
+    if (!LOGGED_DEPRECATIONS.has(message)) {
+        LOGGED_DEPRECATIONS.add(message);
+        console.warn(message);
+    }
 }
-
-module.exports = {
-  deprecate,
-};