@sladg/apex-state 3.7.1 → 3.7.3

package/dist/index.d.ts

@@ -602,10 +602,16 @@ type ComputationPair<DATA extends object, Depth extends number = DefaultDepth> =
 type DeepRequired<T> = {
     [K in keyof T]-?: NonNullable<T[K]> extends object ? DeepRequired<NonNullable<T[K]>> : NonNullable<T[K]>;
 };
-/** Recursively makes all properties optional (allows undefined values) */
-type DeepPartial<T> = {
-    [K in keyof T]?: NonNullable<T[K]> extends object ? DeepPartial<NonNullable<T[K]>> | undefined : T[K] | undefined;
-};
+/**
+ * Recursively makes all properties optional (allows undefined values).
+ *
+ * Written as a conditional type so TypeScript distributes it over union members
+ * automatically — null/undefined fall through to `: T` and are preserved as-is.
+ * Array check comes before object so arrays are not mapped over their keys.
+ */
+type DeepPartial<T> = T extends (infer U)[] ? DeepPartial<U>[] : T extends readonly (infer U)[] ? readonly DeepPartial<U>[] : T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
 
 interface BaseConcernProps<STATE, PATH extends string> {
     state: STATE;

package/dist/index.js

@@ -2433,20 +2433,22 @@ var deepClone = (value) => {
 var deepMerge = (target, source) => {
   if (!source) return target;
   const result = { ...target };
-  for (const key in source) {
-    if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
-    const sourceValue = source[key];
-    const targetValue = target[key];
+  const src = source;
+  for (const key in src) {
+    if (!Object.prototype.hasOwnProperty.call(src, key)) continue;
+    const k = key;
+    const sourceValue = src[k];
+    const targetValue = target[k];
     if (is.undefined(sourceValue)) {
       continue;
     }
     if (is.object(sourceValue) && is.object(targetValue)) {
-      result[key] = deepMerge(
+      result[k] = deepMerge(
         targetValue,
         sourceValue
       );
     } else {
-      result[key] = sourceValue;
+      result[k] = sourceValue;
     }
   }
   return result;