@take-out/hooks 0.4.3 → 0.4.5

package/dist/cjs/useDeepMemoizedObject.cjs

@@ -3,20 +3,22 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var useDeepMemoizedObject_exports = {};
 __export(useDeepMemoizedObject_exports, {
@@ -27,122 +29,179 @@ __export(useDeepMemoizedObject_exports, {
 module.exports = __toCommonJS(useDeepMemoizedObject_exports);
 var import_react = require("react");
 function shouldBeImmutable(path, immutableToNestedChanges) {
-  if (!immutableToNestedChanges) return !1;
+  if (!immutableToNestedChanges) return false;
   const currentPath = path.join(".");
-  for (const pattern in immutableToNestedChanges) if (immutableToNestedChanges[pattern] && currentPath === pattern) return !0;
-  return !1;
+  for (const pattern in immutableToNestedChanges) {
+    if (immutableToNestedChanges[pattern] && currentPath === pattern) {
+      return true;
+    }
+  }
+  return false;
 }
 function deepMutateInPlace(target, source) {
-  if (!(typeof target != "object" || target === null || typeof source != "object" || source === null)) {
-    if (Array.isArray(target) && Array.isArray(source)) {
-      target.length = 0, target.push(...source);
-      return;
-    }
-    for (const key in source) {
-      const targetValue = target[key],
-        sourceValue = source[key];
-      typeof sourceValue == "object" && sourceValue !== null && typeof targetValue == "object" && targetValue !== null ? deepMutateInPlace(targetValue, sourceValue) : target[key] = sourceValue;
+  if (typeof target !== "object" || target === null || typeof source !== "object" || source === null) {
+    return;
+  }
+  if (Array.isArray(target) && Array.isArray(source)) {
+    ;
+    target.length = 0;
+    target.push(...source);
+    return;
+  }
+  for (const key in source) {
+    const targetValue = target[key];
+    const sourceValue = source[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && typeof targetValue === "object" && targetValue !== null) {
+      deepMutateInPlace(targetValue, sourceValue);
+    } else {
+      ;
+      target[key] = sourceValue;
     }
   }
 }
-function deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, parentIsImmutable = !1) {
-  if (current === previous) return {
-    value: previous,
-    hasChanges: !1,
-    hasImmutableMutation: !1
-  };
-  if (typeof current != "object" || current === null) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  if (typeof previous != "object" || previous === null) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  const shouldMutateInPlace = shouldBeImmutable(path, immutableToNestedChanges) || parentIsImmutable;
-  if (Array.isArray(current)) {
-    if (!Array.isArray(previous)) return {
+function deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, parentIsImmutable = false) {
+  if (current === previous) {
+    return {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: false
+    };
+  }
+  if (typeof current !== "object" || current === null) {
+    return {
       value: current,
-      hasChanges: !0,
-      hasImmutableMutation: !1
+      hasChanges: true,
+      hasImmutableMutation: false
     };
-    if (current.length !== previous.length) return {
+  }
+  if (typeof previous !== "object" || previous === null) {
+    return {
       value: current,
-      hasChanges: !0,
-      hasImmutableMutation: !1
+      hasChanges: true,
+      hasImmutableMutation: false
     };
-    let hasChanges2 = !1,
-      hasImmutableMutation2 = !1;
+  }
+  const isCurrentImmutable = shouldBeImmutable(path, immutableToNestedChanges);
+  const shouldMutateInPlace = isCurrentImmutable || parentIsImmutable;
+  if (Array.isArray(current)) {
+    if (!Array.isArray(previous)) {
+      return {
+        value: current,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
+    }
+    if (current.length !== previous.length) {
+      return {
+        value: current,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
+    }
+    let hasChanges2 = false;
+    let hasImmutableMutation2 = false;
     const memoizedArray = [];
     for (let i = 0; i < current.length; i++) {
-      const itemPath = [...path, String(i)],
-        result = deepMemoizeWithTracking(current[i], previous[i], itemPath, immutableToNestedChanges, !1);
-      memoizedArray[i] = result.value, result.hasChanges && (hasChanges2 = !0), result.hasImmutableMutation && (hasImmutableMutation2 = !0);
+      const itemPath = [...path, String(i)];
+      const result = deepMemoizeWithTracking(current[i], previous[i], itemPath, immutableToNestedChanges, false);
+      memoizedArray[i] = result.value;
+      if (result.hasChanges) {
+        hasChanges2 = true;
+      }
+      if (result.hasImmutableMutation) {
+        hasImmutableMutation2 = true;
+      }
+    }
+    if (hasChanges2 || hasImmutableMutation2) {
+      return {
+        value: memoizedArray,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
     }
-    return hasChanges2 || hasImmutableMutation2 ? {
-      value: memoizedArray,
-      hasChanges: !0,
-      hasImmutableMutation: !1
-    } : {
+    return {
       value: previous,
-      hasChanges: !1,
-      hasImmutableMutation: !1
+      hasChanges: false,
+      hasImmutableMutation: false
     };
   }
-  const currentKeys = Object.keys(current),
-    previousKeys = Object.keys(previous);
-  if (currentKeys.length !== previousKeys.length) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  if (!currentKeys.every(key => key in previous)) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  let hasChanges = !1,
-    hasImmutableMutation = !1;
+  const currentKeys = Object.keys(current);
+  const previousKeys = Object.keys(previous);
+  if (currentKeys.length !== previousKeys.length) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  const keysMatch = currentKeys.every(key => key in previous);
+  if (!keysMatch) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  let hasChanges = false;
+  let hasImmutableMutation = false;
   const memoizedObject = {};
   for (const key of currentKeys) {
-    const propPath = [...path, key],
-      currentValue = current[key],
-      previousValue = previous[key],
-      result = deepMemoizeWithTracking(currentValue, previousValue, propPath, immutableToNestedChanges, shouldMutateInPlace);
-    memoizedObject[key] = result.value, result.hasChanges && (hasChanges = !0), result.hasImmutableMutation && (hasImmutableMutation = !0);
+    const propPath = [...path, key];
+    const currentValue = current[key];
+    const previousValue = previous[key];
+    const result = deepMemoizeWithTracking(currentValue, previousValue, propPath, immutableToNestedChanges, shouldMutateInPlace);
+    memoizedObject[key] = result.value;
+    if (result.hasChanges) {
+      hasChanges = true;
+    }
+    if (result.hasImmutableMutation) {
+      hasImmutableMutation = true;
+    }
   }
   if (shouldMutateInPlace && (hasChanges || hasImmutableMutation)) {
-    if (parentIsImmutable) deepMutateInPlace(previous, current);else for (const key of currentKeys) previous[key] = memoizedObject[key];
+    if (parentIsImmutable) {
+      deepMutateInPlace(previous, current);
+    } else {
+      for (const key of currentKeys) {
+        ;
+        previous[key] = memoizedObject[key];
+      }
+    }
     return {
       value: previous,
-      hasChanges: !1,
-      hasImmutableMutation: !0
+      hasChanges: false,
+      hasImmutableMutation: true
     };
   }
-  return hasChanges || hasImmutableMutation ? {
-    value: memoizedObject,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  } : {
+  if (hasChanges || hasImmutableMutation) {
+    return {
+      value: memoizedObject,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  return {
     value: previous,
-    hasChanges: !1,
-    hasImmutableMutation: !1
+    hasChanges: false,
+    hasImmutableMutation: false
   };
 }
 function deepMemoize(current, previous, path = [], immutableToNestedChanges) {
-  const result = deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, !1);
+  const result = deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, false);
   if (path.length === 0 && result.hasImmutableMutation && !result.hasChanges) {
-    if (Array.isArray(result.value)) return [...result.value];
-    if (typeof result.value == "object" && result.value !== null) return {
-      ...result.value
-    };
+    if (Array.isArray(result.value)) {
+      return [...result.value];
+    } else if (typeof result.value === "object" && result.value !== null) {
+      return {
+        ...result.value
+      };
+    }
   }
   return result.value;
 }
 function useDeepMemoizedObject(value, options) {
-  const previousValueRef = (0, import_react.useRef)(value),
-    memoizedValue = deepMemoize(value, previousValueRef.current, [], options?.immutableToNestedChanges);
-  return previousValueRef.current = memoizedValue, memoizedValue;
+  const previousValueRef = (0, import_react.useRef)(value);
+  const memoizedValue = deepMemoize(value, previousValueRef.current, [], options?.immutableToNestedChanges);
+  previousValueRef.current = memoizedValue;
+  return memoizedValue;
 }

package/dist/cjs/useDeepMemoizedObject.native.js

@@ -5,20 +5,22 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: !0
+  value: true
 }), mod);
 var useDeepMemoizedObject_exports = {};
 __export(useDeepMemoizedObject_exports, {
@@ -31,162 +33,226 @@ var import_react = require("react");
 function _type_of(obj) {
   "@swc/helpers - typeof";
 
-  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
 function shouldBeImmutable(path, immutableToNestedChanges) {
-  if (!immutableToNestedChanges) return !1;
+  if (!immutableToNestedChanges) return false;
   var currentPath = path.join(".");
-  for (var pattern in immutableToNestedChanges) if (immutableToNestedChanges[pattern] && currentPath === pattern) return !0;
-  return !1;
+  for (var pattern in immutableToNestedChanges) {
+    if (immutableToNestedChanges[pattern] && currentPath === pattern) {
+      return true;
+    }
+  }
+  return false;
 }
 function deepMutateInPlace(target, source) {
-  if (!((typeof target > "u" ? "undefined" : _type_of(target)) !== "object" || target === null || (typeof source > "u" ? "undefined" : _type_of(source)) !== "object" || source === null)) {
-    if (Array.isArray(target) && Array.isArray(source)) {
-      target.length = 0, target.push(...source);
-      return;
-    }
-    for (var key in source) {
-      var targetValue = target[key],
-        sourceValue = source[key];
-      (typeof sourceValue > "u" ? "undefined" : _type_of(sourceValue)) === "object" && sourceValue !== null && (typeof targetValue > "u" ? "undefined" : _type_of(targetValue)) === "object" && targetValue !== null ? deepMutateInPlace(targetValue, sourceValue) : target[key] = sourceValue;
+  if ((typeof target === "undefined" ? "undefined" : _type_of(target)) !== "object" || target === null || (typeof source === "undefined" ? "undefined" : _type_of(source)) !== "object" || source === null) {
+    return;
+  }
+  if (Array.isArray(target) && Array.isArray(source)) {
+    ;
+    target.length = 0;
+    target.push(...source);
+    return;
+  }
+  for (var key in source) {
+    var targetValue = target[key];
+    var sourceValue = source[key];
+    if ((typeof sourceValue === "undefined" ? "undefined" : _type_of(sourceValue)) === "object" && sourceValue !== null && (typeof targetValue === "undefined" ? "undefined" : _type_of(targetValue)) === "object" && targetValue !== null) {
+      deepMutateInPlace(targetValue, sourceValue);
+    } else {
+      ;
+      target[key] = sourceValue;
     }
   }
 }
 function deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges) {
-  var parentIsImmutable = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : !1;
-  if (current === previous) return {
-    value: previous,
-    hasChanges: !1,
-    hasImmutableMutation: !1
-  };
-  if ((typeof current > "u" ? "undefined" : _type_of(current)) !== "object" || current === null) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  if ((typeof previous > "u" ? "undefined" : _type_of(previous)) !== "object" || previous === null) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  var isCurrentImmutable = shouldBeImmutable(path, immutableToNestedChanges),
-    shouldMutateInPlace = isCurrentImmutable || parentIsImmutable;
-  if (Array.isArray(current)) {
-    if (!Array.isArray(previous)) return {
+  var parentIsImmutable = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
+  if (current === previous) {
+    return {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: false
+    };
+  }
+  if ((typeof current === "undefined" ? "undefined" : _type_of(current)) !== "object" || current === null) {
+    return {
       value: current,
-      hasChanges: !0,
-      hasImmutableMutation: !1
+      hasChanges: true,
+      hasImmutableMutation: false
     };
-    if (current.length !== previous.length) return {
+  }
+  if ((typeof previous === "undefined" ? "undefined" : _type_of(previous)) !== "object" || previous === null) {
+    return {
       value: current,
-      hasChanges: !0,
-      hasImmutableMutation: !1
+      hasChanges: true,
+      hasImmutableMutation: false
     };
-    for (var hasChanges = !1, hasImmutableMutation = !1, memoizedArray = [], i = 0; i < current.length; i++) {
-      var itemPath = [...path, String(i)],
-        result = deepMemoizeWithTracking(current[i], previous[i], itemPath, immutableToNestedChanges, !1);
-      memoizedArray[i] = result.value, result.hasChanges && (hasChanges = !0), result.hasImmutableMutation && (hasImmutableMutation = !0);
+  }
+  var isCurrentImmutable = shouldBeImmutable(path, immutableToNestedChanges);
+  var shouldMutateInPlace = isCurrentImmutable || parentIsImmutable;
+  if (Array.isArray(current)) {
+    if (!Array.isArray(previous)) {
+      return {
+        value: current,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
+    }
+    if (current.length !== previous.length) {
+      return {
+        value: current,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
     }
-    return hasChanges || hasImmutableMutation ? {
-      value: memoizedArray,
-      hasChanges: !0,
-      hasImmutableMutation: !1
-    } : {
+    var hasChanges = false;
+    var hasImmutableMutation = false;
+    var memoizedArray = [];
+    for (var i = 0; i < current.length; i++) {
+      var itemPath = [...path, String(i)];
+      var result = deepMemoizeWithTracking(current[i], previous[i], itemPath, immutableToNestedChanges, false);
+      memoizedArray[i] = result.value;
+      if (result.hasChanges) {
+        hasChanges = true;
+      }
+      if (result.hasImmutableMutation) {
+        hasImmutableMutation = true;
+      }
+    }
+    if (hasChanges || hasImmutableMutation) {
+      return {
+        value: memoizedArray,
+        hasChanges: true,
+        hasImmutableMutation: false
+      };
+    }
+    return {
       value: previous,
-      hasChanges: !1,
-      hasImmutableMutation: !1
+      hasChanges: false,
+      hasImmutableMutation: false
+    };
+  }
+  var currentKeys = Object.keys(current);
+  var previousKeys = Object.keys(previous);
+  if (currentKeys.length !== previousKeys.length) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
     };
   }
-  var currentKeys = Object.keys(current),
-    previousKeys = Object.keys(previous);
-  if (currentKeys.length !== previousKeys.length) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
   var keysMatch = currentKeys.every(function (key2) {
     return key2 in previous;
   });
-  if (!keysMatch) return {
-    value: current,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  };
-  var hasChanges1 = !1,
-    hasImmutableMutation1 = !1,
-    memoizedObject = {},
-    _iteratorNormalCompletion = !0,
-    _didIteratorError = !1,
+  if (!keysMatch) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  var hasChanges1 = false;
+  var hasImmutableMutation1 = false;
+  var memoizedObject = {};
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
     _iteratorError = void 0;
   try {
-    for (var _iterator = currentKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-      var key = _step.value,
-        propPath = [...path, key],
-        currentValue = current[key],
-        previousValue = previous[key],
-        result1 = deepMemoizeWithTracking(currentValue, previousValue, propPath, immutableToNestedChanges, shouldMutateInPlace);
-      memoizedObject[key] = result1.value, result1.hasChanges && (hasChanges1 = !0), result1.hasImmutableMutation && (hasImmutableMutation1 = !0);
+    for (var _iterator = currentKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var key = _step.value;
+      var propPath = [...path, key];
+      var currentValue = current[key];
+      var previousValue = previous[key];
+      var result1 = deepMemoizeWithTracking(currentValue, previousValue, propPath, immutableToNestedChanges, shouldMutateInPlace);
+      memoizedObject[key] = result1.value;
+      if (result1.hasChanges) {
+        hasChanges1 = true;
+      }
+      if (result1.hasImmutableMutation) {
+        hasImmutableMutation1 = true;
+      }
     }
   } catch (err) {
-    _didIteratorError = !0, _iteratorError = err;
+    _didIteratorError = true;
+    _iteratorError = err;
   } finally {
     try {
-      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
     } finally {
-      if (_didIteratorError) throw _iteratorError;
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
     }
   }
   if (shouldMutateInPlace && (hasChanges1 || hasImmutableMutation1)) {
-    if (parentIsImmutable) deepMutateInPlace(previous, current);else {
-      var _iteratorNormalCompletion1 = !0,
-        _didIteratorError1 = !1,
+    if (parentIsImmutable) {
+      deepMutateInPlace(previous, current);
+    } else {
+      var _iteratorNormalCompletion1 = true,
+        _didIteratorError1 = false,
         _iteratorError1 = void 0;
       try {
-        for (var _iterator1 = currentKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+        for (var _iterator1 = currentKeys[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
           var key1 = _step1.value;
+          ;
           previous[key1] = memoizedObject[key1];
         }
       } catch (err) {
-        _didIteratorError1 = !0, _iteratorError1 = err;
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
       } finally {
         try {
-          !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
         } finally {
-          if (_didIteratorError1) throw _iteratorError1;
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
         }
       }
     }
     return {
       value: previous,
-      hasChanges: !1,
-      hasImmutableMutation: !0
+      hasChanges: false,
+      hasImmutableMutation: true
+    };
+  }
+  if (hasChanges1 || hasImmutableMutation1) {
+    return {
+      value: memoizedObject,
+      hasChanges: true,
+      hasImmutableMutation: false
     };
   }
-  return hasChanges1 || hasImmutableMutation1 ? {
-    value: memoizedObject,
-    hasChanges: !0,
-    hasImmutableMutation: !1
-  } : {
+  return {
     value: previous,
-    hasChanges: !1,
-    hasImmutableMutation: !1
+    hasChanges: false,
+    hasImmutableMutation: false
   };
 }
 function deepMemoize(current, previous) {
   var path = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : [],
-    immutableToNestedChanges = arguments.length > 3 ? arguments[3] : void 0,
-    result = deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, !1);
+    immutableToNestedChanges = arguments.length > 3 ? arguments[3] : void 0;
+  var result = deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, false);
   if (path.length === 0 && result.hasImmutableMutation && !result.hasChanges) {
-    if (Array.isArray(result.value)) return [...result.value];
-    if (_type_of(result.value) === "object" && result.value !== null) return {
-      ...result.value
-    };
+    if (Array.isArray(result.value)) {
+      return [...result.value];
+    } else if (_type_of(result.value) === "object" && result.value !== null) {
+      return {
+        ...result.value
+      };
+    }
   }
   return result.value;
 }
 function useDeepMemoizedObject(value, options) {
-  var previousValueRef = (0, import_react.useRef)(value),
-    memoizedValue = deepMemoize(value, previousValueRef.current, [], options?.immutableToNestedChanges);
-  return previousValueRef.current = memoizedValue, memoizedValue;
+  var previousValueRef = (0, import_react.useRef)(value);
+  var memoizedValue = deepMemoize(value, previousValueRef.current, [], options === null || options === void 0 ? void 0 : options.immutableToNestedChanges);
+  previousValueRef.current = memoizedValue;
+  return memoizedValue;
 }
 //# sourceMappingURL=useDeepMemoizedObject.native.js.map