@o/hooks 0.16.19-canary.1790165522484

package/dist/cjs/useDeepMemoizedObject.native.js

@@ -0,0 +1,258 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var useDeepMemoizedObject_exports = {};
+__export(useDeepMemoizedObject_exports, {
+  deepMemoize: () => deepMemoize,
+  shouldBeImmutable: () => shouldBeImmutable,
+  useDeepMemoizedObject: () => useDeepMemoizedObject
+});
+module.exports = __toCommonJS(useDeepMemoizedObject_exports);
+var import_react = require("react");
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+
+  return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function shouldBeImmutable(path, immutableToNestedChanges) {
+  if (!immutableToNestedChanges) return false;
+  var currentPath = path.join(".");
+  for (var pattern in immutableToNestedChanges) {
+    if (immutableToNestedChanges[pattern] && currentPath === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function deepMutateInPlace(target, source) {
+  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] : 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: true,
+      hasImmutableMutation: false
+    };
+  }
+  if ((typeof previous === "undefined" ? "undefined" : _type_of(previous)) !== "object" || previous === null) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  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
+      };
+    }
+    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: 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 keysMatch = currentKeys.every(function (key2) {
+    return key2 in previous;
+  });
+  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 = 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 = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  if (shouldMutateInPlace && (hasChanges1 || hasImmutableMutation1)) {
+    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 = true) {
+          var key1 = _step1.value;
+          ;
+          previous[key1] = memoizedObject[key1];
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+    return {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: true
+    };
+  }
+  if (hasChanges1 || hasImmutableMutation1) {
+    return {
+      value: memoizedObject,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  return {
+    value: previous,
+    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;
+  var result = deepMemoizeWithTracking(current, previous, path, immutableToNestedChanges, false);
+  if (path.length === 0 && result.hasImmutableMutation && !result.hasChanges) {
+    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);
+  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

package/dist/cjs/useDeepMemoizedObject.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useDeepMemoizedObject_exports","__export","deepMemoize","shouldBeImmutable","useDeepMemoizedObject","module","exports","import_react","require","_type_of","obj","Symbol","constructor","path","immutableToNestedChanges","currentPath","join","pattern","deepMutateInPlace","target","source","Array","isArray","length","push","key","targetValue","sourceValue","deepMemoizeWithTracking","current","previous","parentIsImmutable","arguments","hasChanges","hasImmutableMutation","isCurrentImmutable","shouldMutateInPlace","memoizedArray","i","itemPath","String","result","currentKeys","Object","keys","previousKeys","keysMatch","every","key2","hasChanges1","hasImmutableMutation1","memoizedObject","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_iterator","iterator","_step","next","done","propPath","currentValue","previousValue","result1","err"],"sources":["../../src/useDeepMemoizedObject.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/cjs/useDeepMemoizedObject.test.cjs

@@ -0,0 +1,321 @@
+var import_vitest = require("vitest");
+var import_useDeepMemoizedObject = require("./useDeepMemoizedObject.cjs");
+function testMemoization(initialValue, options) {
+  let previousValue = initialValue;
+  return {
+    get current() {
+      return previousValue;
+    },
+    update(value) {
+      previousValue = (0, import_useDeepMemoizedObject.deepMemoize)(value, previousValue, [], options?.immutableToNestedChanges);
+    }
+  };
+}
+(0, import_vitest.describe)("useDeepMemoizedObject", () => {
+  (0, import_vitest.it)("should preserve identity for unchanged primitives", () => {
+    const hook = testMemoization(42);
+    const firstResult = hook.current;
+    hook.update(42);
+    (0, import_vitest.expect)(hook.current).toBe(firstResult);
+  });
+  (0, import_vitest.it)("should preserve identity for unchanged objects", () => {
+    const obj = {
+      a: 1,
+      b: 2
+    };
+    const hook = testMemoization(obj);
+    const firstResult = hook.current;
+    hook.update({
+      a: 1,
+      b: 2
+    });
+    (0, import_vitest.expect)(hook.current).toBe(firstResult);
+  });
+  (0, import_vitest.it)("should preserve identity for unchanged arrays", () => {
+    const arr = [1, 2, 3];
+    const hook = testMemoization(arr);
+    const firstResult = hook.current;
+    hook.update([1, 2, 3]);
+    (0, import_vitest.expect)(hook.current).toBe(firstResult);
+  });
+  (0, import_vitest.it)("should handle nested object changes correctly", () => {
+    const initial = {
+      server: {
+        id: 1,
+        channels: [{
+          id: 1,
+          name: "general"
+        }, {
+          id: 2,
+          name: "random"
+        }, {
+          id: 3,
+          name: "tech"
+        }]
+      }
+    };
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    const updated = {
+      server: {
+        id: 1,
+        channels: [{
+          id: 1,
+          name: "general-updated"
+        }, {
+          id: 2,
+          name: "random"
+        }, {
+          id: 3,
+          name: "tech"
+        }]
+      }
+    };
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult.server).not.toBe(firstResult.server);
+    (0, import_vitest.expect)(secondResult.server.channels).not.toBe(firstResult.server.channels);
+    (0, import_vitest.expect)(secondResult.server.channels[0]).not.toBe(firstResult.server.channels[0]);
+    (0, import_vitest.expect)(secondResult.server.channels[1]).toBe(firstResult.server.channels[1]);
+    (0, import_vitest.expect)(secondResult.server.channels[2]).toBe(firstResult.server.channels[2]);
+  });
+  (0, import_vitest.it)("should handle deep nested changes in arrays", () => {
+    const initial = {
+      server: {
+        channels: [{
+          id: 1,
+          messages: [{
+            id: 1,
+            text: "hi"
+          }, {
+            id: 2,
+            text: "hello"
+          }, {
+            id: 3,
+            text: "world",
+            reactions: [{
+              emoji: "\u{1F44D}",
+              count: 1
+            }, {
+              emoji: "\u2764\uFE0F",
+              count: 2
+            }, {
+              emoji: "\u{1F602}",
+              count: 3,
+              updatedAt: "2024-01-01"
+            }, {
+              emoji: "\u{1F389}",
+              count: 4
+            }]
+          }]
+        }]
+      }
+    };
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    const updated = JSON.parse(JSON.stringify(initial));
+    updated.server.channels[0].messages[2].reactions[2].updatedAt = "2024-01-02";
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult.server).not.toBe(firstResult.server);
+    (0, import_vitest.expect)(secondResult.server.channels).not.toBe(firstResult.server.channels);
+    (0, import_vitest.expect)(secondResult.server.channels[0]).not.toBe(firstResult.server.channels[0]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages).not.toBe(firstResult.server.channels[0].messages);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[0]).toBe(firstResult.server.channels[0].messages[0]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[1]).toBe(firstResult.server.channels[0].messages[1]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2]).not.toBe(firstResult.server.channels[0].messages[2]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2].reactions).not.toBe(firstResult.server.channels[0].messages[2].reactions);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2].reactions[0]).toBe(firstResult.server.channels[0].messages[2].reactions[0]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2].reactions[1]).toBe(firstResult.server.channels[0].messages[2].reactions[1]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2].reactions[2]).not.toBe(firstResult.server.channels[0].messages[2].reactions[2]);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[2].reactions[3]).toBe(firstResult.server.channels[0].messages[2].reactions[3]);
+  });
+  (0, import_vitest.it)("should respect immutableToNestedChanges option", () => {
+    const initial = {
+      server: {
+        id: 1,
+        channels: [{
+          id: 1,
+          messages: [{
+            id: 1,
+            text: "hi"
+          }, {
+            id: 2,
+            text: "hello"
+          }, {
+            id: 3,
+            text: "world"
+          }, {
+            id: 4,
+            text: "foo"
+          }, {
+            id: 5,
+            text: "bar"
+          }, {
+            id: 6,
+            text: "baz",
+            reactions: [{
+              emoji: "\u{1F44D}",
+              count: 1
+            }, {
+              emoji: "\u2764\uFE0F",
+              count: 2
+            }, {
+              emoji: "\u{1F602}",
+              count: 3,
+              updatedAt: "2024-01-01"
+            }]
+          }]
+        }]
+      }
+    };
+    const hook = testMemoization(initial, {
+      immutableToNestedChanges: {
+        server: true,
+        "server.channels.0": true
+      }
+    });
+    const firstResult = hook.current;
+    const originalChannels = firstResult.server.channels;
+    const originalChannel0 = firstResult.server.channels[0];
+    const originalMessages = firstResult.server.channels[0].messages;
+    const originalMessage5 = firstResult.server.channels[0].messages[5];
+    const originalReactions = firstResult.server.channels[0].messages[5].reactions;
+    const updated = JSON.parse(JSON.stringify(initial));
+    updated.server.channels[0].messages[5].reactions[2].updatedAt = "2024-01-02";
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult.server).toBe(firstResult.server);
+    (0, import_vitest.expect)(secondResult.server.channels).not.toBe(originalChannels);
+    (0, import_vitest.expect)(secondResult.server.channels[0]).toBe(originalChannel0);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages).not.toBe(originalMessages);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[5]).not.toBe(originalMessage5);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[5].reactions).not.toBe(originalReactions);
+    (0, import_vitest.expect)(secondResult.server.channels[0].messages[5].reactions[2].updatedAt).toBe("2024-01-02");
+  });
+  (0, import_vitest.it)("should handle adding new properties to objects", () => {
+    const initial = {
+      a: 1,
+      b: 2
+    };
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    const updated = {
+      a: 1,
+      b: 2,
+      c: 3
+    };
+    hook.update(updated);
+    (0, import_vitest.expect)(hook.current).not.toBe(firstResult);
+    (0, import_vitest.expect)(hook.current).toEqual(updated);
+  });
+  (0, import_vitest.it)("should handle array length changes", () => {
+    const initial = [1, 2, 3];
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    hook.update([1, 2, 3, 4]);
+    (0, import_vitest.expect)(hook.current).not.toBe(firstResult);
+    (0, import_vitest.expect)(hook.current).toEqual([1, 2, 3, 4]);
+  });
+  (0, import_vitest.it)("should handle null and undefined values", () => {
+    const nullHook = testMemoization(null);
+    (0, import_vitest.expect)(nullHook.current).toBe(null);
+    nullHook.update(void 0);
+    (0, import_vitest.expect)(nullHook.current).toBe(void 0);
+    nullHook.update({
+      a: null,
+      b: void 0
+    });
+    const objResult = nullHook.current;
+    (0, import_vitest.expect)(objResult.a).toBe(null);
+    (0, import_vitest.expect)(objResult.b).toBe(void 0);
+  });
+  (0, import_vitest.it)("should preserve array items when only one changes", () => {
+    const initial = [{
+      id: 1,
+      name: "Alice"
+    }, {
+      id: 2,
+      name: "Bob"
+    }, {
+      id: 3,
+      name: "Charlie"
+    }];
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    const updated = [{
+      id: 1,
+      name: "Alice"
+    }, {
+      id: 2,
+      name: "Bobby"
+    }, {
+      id: 3,
+      name: "Charlie"
+    }];
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult[0]).toBe(firstResult[0]);
+    (0, import_vitest.expect)(secondResult[1]).not.toBe(firstResult[1]);
+    (0, import_vitest.expect)(secondResult[2]).toBe(firstResult[2]);
+  });
+  (0, import_vitest.it)("should handle complex immutableToNestedChanges patterns", () => {
+    const initial = {
+      app: {
+        settings: {
+          theme: "dark",
+          language: "en",
+          nested: {
+            deep: {
+              value: 1
+            }
+          }
+        }
+      }
+    };
+    const hook = testMemoization(initial, {
+      immutableToNestedChanges: {
+        "app.settings": true
+      }
+    });
+    const firstResult = hook.current;
+    const originalSettings = firstResult.app.settings;
+    const originalNested = firstResult.app.settings.nested;
+    const originalDeep = firstResult.app.settings.nested.deep;
+    const updated = JSON.parse(JSON.stringify(initial));
+    updated.app.settings.nested.deep.value = 2;
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult.app).not.toBe(firstResult.app);
+    (0, import_vitest.expect)(secondResult.app.settings).toBe(originalSettings);
+    (0, import_vitest.expect)(secondResult.app.settings.nested).toBe(originalNested);
+    (0, import_vitest.expect)(secondResult.app.settings.nested.deep).toBe(originalDeep);
+    (0, import_vitest.expect)(secondResult.app.settings.nested.deep.value).toBe(2);
+  });
+  (0, import_vitest.it)("should handle mixed arrays with objects and primitives", () => {
+    const initial = [1, "string", {
+      id: 1,
+      name: "object"
+    }, [1, 2, 3], null, void 0];
+    const hook = testMemoization(initial);
+    const firstResult = hook.current;
+    const updated = [1, "string", {
+      id: 1,
+      name: "updated"
+    }, [1, 2, 3], null, void 0];
+    hook.update(updated);
+    const secondResult = hook.current;
+    (0, import_vitest.expect)(secondResult).not.toBe(firstResult);
+    (0, import_vitest.expect)(secondResult[0]).toBe(1);
+    (0, import_vitest.expect)(secondResult[1]).toBe("string");
+    (0, import_vitest.expect)(secondResult[2]).not.toBe(firstResult[2]);
+    (0, import_vitest.expect)(secondResult[3]).toBe(firstResult[3]);
+    (0, import_vitest.expect)(secondResult[4]).toBe(null);
+    (0, import_vitest.expect)(secondResult[5]).toBe(void 0);
+  });
+});