@idealyst/components 1.1.6 → 1.1.7

package/src/utils/deepMerge.ts

@@ -14,9 +14,31 @@ function isPlainObject(value: unknown): value is Record<string, any> {
  * Deep merge two objects together, with the second object taking priority.
  * Arrays and non-plain objects are replaced rather than merged.
  *
+ * Special handling:
+ * - Setting a value to `undefined` removes that key from the result
+ * - Nested objects (like `_web`, `variants`) are recursively merged
+ *
  * @param target - The base object
  * @param source - The object to merge in (takes priority)
  * @returns A new merged object
+ *
+ * @example
+ * ```typescript
+ * // Basic merge
+ * deepMerge({ a: 1, b: 2 }, { b: 3, c: 4 })
+ * // => { a: 1, b: 3, c: 4 }
+ *
+ * // Nested _web merge
+ * deepMerge(
+ *   { padding: 10, _web: { cursor: 'pointer', display: 'flex' } },
+ *   { _web: { cursor: 'default' } }
+ * )
+ * // => { padding: 10, _web: { cursor: 'default', display: 'flex' } }
+ *
+ * // Remove property with undefined
+ * deepMerge({ a: 1, b: 2 }, { b: undefined })
+ * // => { a: 1 }
+ * ```
  */
 export function deepMerge<T extends Record<string, any>, S extends Record<string, any>>(
   target: T,
@@ -29,11 +51,15 @@ export function deepMerge<T extends Record<string, any>, S extends Record<string
       const sourceValue = source[key]
       const targetValue = result[key]
 
+      // If source value is undefined, remove the key entirely
+      if (sourceValue === undefined) {
+        delete result[key]
+      }
       // If both values are plain objects, merge them recursively
-      if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
         result[key] = deepMerge(targetValue, sourceValue)
       } else {
-        // Otherwise, source value takes priority (including arrays, primitives, null, undefined)
+        // Otherwise, source value takes priority (including arrays, primitives, null)
         result[key] = sourceValue
       }
     }
@@ -41,3 +67,29 @@ export function deepMerge<T extends Record<string, any>, S extends Record<string
 
   return result as T & S
 }
+
+/**
+ * Deep merge multiple objects together, with later objects taking priority.
+ * This is useful for merging multiple extensions in order.
+ *
+ * @param objects - Objects to merge (later ones have higher precedence)
+ * @returns A new merged object
+ *
+ * @example
+ * ```typescript
+ * deepMergeAll(
+ *   { a: 1, b: 2 },           // base
+ *   { b: 3, c: 4 },           // first extension
+ *   { c: 5, d: 6 }            // second extension (highest precedence)
+ * )
+ * // => { a: 1, b: 3, c: 5, d: 6 }
+ * ```
+ */
+export function deepMergeAll<T extends Record<string, any>>(
+  ...objects: (T | undefined | null)[]
+): T {
+  return objects.reduce<T>((acc, obj) => {
+    if (obj == null) return acc
+    return deepMerge(acc, obj) as T
+  }, {} as T)
+}