@revolugo/common 6.10.7-beta.0 → 6.10.7-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "6.10.7-beta.0",
+  "version": "6.10.7-beta.2",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",

package/src/utils/index.ts

@@ -13,6 +13,7 @@ export * from './is-empty.ts'
 export * from './is-equal.ts'
 export * from './lang-default-fallbacks.ts'
 export * from './math.ts'
+export * from './merge.ts'
 export * from './numbers.ts'
 export * from './object-tools.ts'
 export * from './poller.ts'

package/src/utils/merge.ts

@@ -0,0 +1,140 @@
+/**
+ * Checks if a value is a plain object (created via {} or new Object).
+ * Lodash treats only plain objects as recursively mergable.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+/**
+ * Deep clones an object, handling arrays and plain objects
+ */
+function cloneDeep<T>(value: T, seen = new WeakSet()): T {
+  if (value === null || value === undefined || typeof value !== 'object') {
+    return value
+  }
+
+  // Handle circular references
+  if (seen.has(value as object)) {
+    return value
+  }
+  seen.add(value as object)
+
+  if (Array.isArray(value)) {
+    return value.map(item => cloneDeep(item, seen)) as T
+  }
+
+  if (isPlainObject(value)) {
+    const cloned: Record<string, unknown> = {}
+    for (const key in value) {
+      if (Object.hasOwn(value, key)) {
+        cloned[key] = cloneDeep(value[key], seen)
+      }
+    }
+    return cloned as T
+  }
+
+  // For other object types (Date, RegExp, etc.), return as-is
+  return value
+}
+
+/**
+ * Recursively merges source into target, following lodash.merge semantics.
+ */
+function mergeObject(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  seen = new WeakSet<object>(),
+): void {
+  if (!isPlainObject(source) || !isPlainObject(target)) {
+    return
+  }
+
+  // Circular reference guard
+  if (source === target || seen.has(source)) {
+    return
+  }
+  seen.add(source)
+
+  // Lodash merges own + inherited enumerable string-keyed props
+  for (const key in source) {
+    if (Object.hasOwn(source, key)) {
+      const srcVal = source[key]
+      const tgtVal = target[key]
+
+      if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+        mergeObject(tgtVal as Record<string, unknown>, srcVal, seen)
+      } else if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        target[key] = mergeArrays(tgtVal, srcVal, seen)
+      } else {
+        // Override with source value - this is the key fix
+        target[key] = cloneDeep(srcVal, seen)
+      }
+    }
+  }
+}
+
+/**
+ * Merges two arrays by index, lodash style.
+ * - Recursively merges plain objects/arrays
+ * - Overwrites with source otherwise
+ */
+function mergeArrays(
+  target: unknown[],
+  source: unknown[],
+  seen: WeakSet<object>,
+): unknown[] {
+  const result = target.slice()
+
+  for (let i = 0; i < source.length; i++) {
+    const srcVal = source[i]
+    const tgtVal = result[i]
+
+    if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+      const merged: Record<string, unknown> = { ...tgtVal }
+      mergeObject(merged, srcVal, seen)
+      result[i] = merged
+    } else if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+      result[i] = mergeArrays(tgtVal, srcVal, seen)
+    } else {
+      result[i] = cloneDeep(srcVal, seen)
+    }
+  }
+
+  return result
+}
+
+/**
+ * A drop-in replacement for lodash-es merge.
+ *
+ * - Recursively merges own and inherited enumerable string-keyed properties.
+ * - Arrays and plain objects are merged by index/key.
+ * - Non-plain objects (Date, RegExp, Map, Set, custom classes, etc.)
+ *   are assigned by reference (not cloned).
+ * - `undefined` does not overwrite an existing value.
+ * - Symbols and non-enumerables are ignored.
+ * - Prototype pollution is *not* prevented (matches lodash behavior).
+ */
+export function merge<T extends Record<string, unknown>>(
+  object: T,
+  ...sources: unknown[]
+): T {
+  if (!isPlainObject(object)) {
+    throw new TypeError('Target must be a plain object')
+  }
+
+  const seen = new WeakSet<object>()
+
+  for (const src of sources) {
+    if (src !== null && src !== undefined) {
+      mergeObject(object, src as Record<string, unknown>, seen)
+    }
+  }
+
+  return object
+}

package/src/utils/object-tools.ts

@@ -1,47 +1,5 @@
 import { isNil } from './value-tools.ts'
 
-// Utility type to merge T and S, allowing S to add/override properties in T
-type Merge<T, S> = {
-  [K in keyof T | keyof S]: K extends keyof S
-    ? S[K] extends object
-      ? K extends keyof T
-        ? T[K] extends object
-          ? Merge<T[K], S[K]>
-          : S[K]
-        : S[K]
-      : S[K]
-    : K extends keyof T
-      ? T[K]
-      : never
-}
-
-export function customMerge<T extends object, S extends object>(
-  target: T,
-  source: S,
-): Merge<T, S> {
-  for (const key of Object.keys(source)) {
-    const sourceValue = source[key as keyof S]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const targetValue = (target as any)[key]
-
-    if (sourceValue !== undefined && sourceValue !== null) {
-      if (
-        targetValue &&
-        typeof targetValue === 'object' &&
-        !Array.isArray(targetValue) &&
-        typeof sourceValue === 'object' &&
-        !Array.isArray(sourceValue)
-      ) {
-        customMerge(targetValue as object, sourceValue as object)
-      } else {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ;(target as any)[key] = sourceValue
-      }
-    }
-  }
-  return target as Merge<T, S>
-}
-
 export function pick<T extends object, K extends keyof T>(
   obj: T,
   keys: readonly K[],