@tsed/core 8.44.5 → 8.44.7

package/lib/esm/utils/deepClone.js

@@ -1,11 +1,6 @@
 import { classOf } from "./classOf.js";
 import { isDate } from "./isDate.js";
-import { isFunction } from "./isFunction.js";
-import { isNil } from "./isNil.js";
-import { isPrimitive } from "./isPrimitive.js";
 import { isRegExp } from "./isRegExp.js";
-import { isSymbol } from "./isSymbol.js";
-const isBasicType = (source) => isNil(source) || isPrimitive(source) || isSymbol(source) || isFunction(source);
 /**
  * Creates a deep clone of the provided value, preserving prototype chains and handling circular references.
  *
@@ -16,8 +11,8 @@ const isBasicType = (source) => isNil(source) || isPrimitive(source) || isSymbol
  * @since v7.0.0
  */
 export const deepClone = (source, stack = new WeakMap()) => {
-    // provides an early exit for simple cases
-    if (isBasicType(source)) {
+    // provides an early exit for simple cases. Inline typeof checks: this runs for every cloned value
+    if (source === null || typeof source !== "object" || source instanceof Boolean) {
         return source;
     }
     const stacked = stack.get(source);
@@ -40,7 +35,12 @@ export const deepClone = (source, stack = new WeakMap()) => {
     if (Array.isArray(source)) {
         const clone = [];
         stack.set(source, clone);
-        source.forEach((item, idx) => (clone[idx] = deepClone(item, stack)));
+        // the length is read once and holes are skipped, as forEach does
+        for (let i = 0, length = source.length; i < length; i++) {
+            if (i in source) {
+                clone[i] = deepClone(source[i], stack);
+            }
+        }
         return clone;
     }
     if (source instanceof Map) {
@@ -57,20 +57,25 @@ export const deepClone = (source, stack = new WeakMap()) => {
     }
     const clone = Object.create(Reflect.getPrototypeOf(source));
     stack.set(source, clone);
-    Reflect.ownKeys(source).forEach((key) => {
+    const keys = Reflect.ownKeys(source);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
         // respects property descriptors and the prototype chain more explicitly, which is important for objects with getter/setter.
-        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
         if (descriptor) {
-            if (!isFunction(descriptor.value)) {
-                Object.defineProperty(clone, key, {
-                    ...descriptor,
-                    value: deepClone(descriptor.value, stack)
-                });
+            // the descriptor is a new object: the cloned value can be written into it. Accessors are kept as is
+            if ("value" in descriptor && typeof descriptor.value !== "function") {
+                descriptor.value = deepClone(descriptor.value, stack);
+            }
+            // a plain data property that nothing in the prototype chain intercepts (setter, read-only, __proto__):
+            // an assignment defines the same property, faster than defineProperty
+            if (descriptor.writable && descriptor.enumerable && descriptor.configurable && !(key in clone)) {
+                clone[key] = descriptor.value;
             }
             else {
-                Object.defineProperty(clone, key, descriptor);
+                Reflect.defineProperty(clone, key, descriptor);
             }
         }
-    });
+    }
     return clone;
 };

package/lib/esm/utils/deepMerge.js

@@ -1,7 +1,4 @@
 import { createInstance } from "./createInstance.js";
-import { isFunction } from "./isFunction.js";
-import { isPrimitive } from "./isPrimitive.js";
-import { isSymbol } from "./isSymbol.js";
 import { objectKeys } from "./objectKeys.js";
 /**
  * Creates a merge reducer using a custom comparator function.
@@ -19,18 +16,40 @@ export function mergeReducerBuilder(cb) {
         return collection;
     };
 }
-const defaultReducer = mergeReducerBuilder((a, b) => a === b);
-function getReducer({ reducers, parentKey }) {
+const hasEnumerableOwn = Object.prototype.propertyIsEnumerable;
+/**
+ * Same result as `mergeReducerBuilder((a, b) => a === b)`, but appends in place:
+ * `merge()` gives it its own copy of the source array.
+ */
+function defaultInPlaceReducer(collection, value, options) {
+    const index = collection.indexOf(value);
+    if (index === -1) {
+        collection.push(value);
+    }
+    else {
+        collection[index] = deepMerge(collection[index], value, options);
+    }
+    return collection;
+}
+function getReducer(reducers, parentKey) {
     if (!reducers) {
-        return defaultReducer;
+        return defaultInPlaceReducer;
     }
     if (parentKey && reducers[parentKey]) {
         return reducers[parentKey];
     }
-    return reducers["default"] || defaultReducer;
+    return reducers["default"] || defaultInPlaceReducer;
 }
 function shouldReturnObj(obj, source) {
-    return isPrimitive(obj) || isSymbol(obj) || isFunction(obj) || source === undefined;
+    // inline typeof checks: this runs for every merged value
+    const type = typeof obj;
+    return (type === "string" ||
+        type === "number" ||
+        type === "boolean" ||
+        type === "symbol" ||
+        type === "function" ||
+        obj instanceof Boolean ||
+        source === undefined);
 }
 function shouldReturnSource(obj, source) {
     return obj === undefined || obj === null || (obj === "" && source !== "");
@@ -45,6 +64,13 @@ function shouldReturnSource(obj, source) {
  * @see DeepMergeOptions
  */
 export function deepMerge(source, obj, options = {}) {
+    return merge(source, obj, options, options.parentKey, true);
+}
+/**
+ * The root call works with the caller's options. The nested merges share one copy of its own properties,
+ * the nested key travels as `parentKey`, and each nested reducer receives its own `{...options, parentKey}` copy.
+ */
+function merge(source, obj, options, parentKey, isRoot) {
     if (shouldReturnSource(obj, source)) {
         return source;
     }
@@ -52,20 +78,33 @@ export function deepMerge(source, obj, options = {}) {
         return obj;
     }
     if (Array.isArray(source)) {
-        const reducer = getReducer(options);
-        return [].concat(obj).reduce((out, value) => reducer(out, value, options), [...source]);
+        const reducerOptions = isRoot ? options : { ...options, parentKey };
+        const reducer = getReducer(reducerOptions.reducers, parentKey);
+        return [].concat(obj).reduce((out, value) => reducer(out, value, reducerOptions), [...source]);
     }
-    const newObj = createInstance(source);
-    return [...objectKeys(source), ...objectKeys(obj)].reduce((out, key) => {
-        const src = source && source[key];
-        const value = deepMerge(src, obj && obj[key], {
-            ...options,
-            parentKey: key
-        });
-        if (options.cleanUndefinedProps && value === undefined) {
-            return out;
+    const out = createInstance(source);
+    const sourceKeys = objectKeys(source);
+    const objKeys = objectKeys(obj);
+    const nestedOptions = isRoot ? { ...options } : options;
+    // the keys of obj missing from source, listed before any merge: alter() can add properties to source
+    const newKeys = [];
+    for (let i = 0; i < objKeys.length; i++) {
+        if (!hasEnumerableOwn.call(source, objKeys[i])) {
+            newKeys.push(objKeys[i]);
         }
-        out[key] = options.alter?.(key, value) ?? value;
-        return out;
-    }, newObj);
+    }
+    for (let i = 0; i < sourceKeys.length; i++) {
+        mergeKey(out, source, obj, sourceKeys[i], options, nestedOptions);
+    }
+    for (let i = 0; i < newKeys.length; i++) {
+        mergeKey(out, source, obj, newKeys[i], options, nestedOptions);
+    }
+    return out;
+}
+function mergeKey(out, source, obj, key, options, nestedOptions) {
+    const value = merge(source && source[key], obj && obj[key], nestedOptions, key, false);
+    if (options.cleanUndefinedProps && value === undefined) {
+        return;
+    }
+    out[key] = options.alter?.(key, value) ?? value;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/core",
-  "version": "8.44.5",
+  "version": "8.44.7",
   "description": "Core module for Ts.ED Framework",
   "source": "./src/index.ts",
   "type": "module",
@@ -39,10 +39,10 @@
     "tslib": ">=2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.44.5",
+    "@tsed/barrels": "8.44.7",
     "@tsed/monorepo-utils": "3.3.3",
-    "@tsed/typescript": "8.44.5",
-    "@tsed/vitest": "8.44.5",
+    "@tsed/typescript": "8.44.7",
+    "@tsed/vitest": "8.44.7",
     "temporal-polyfill": "1.0.1",
     "typescript": "6.0.2",
     "vitest": "4.1.4"