@o/hooks 0.16.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 vxrn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# @takeout/hooks
+
+collection of reusable react hooks for the takeout project.
+
+## hooks
+
+### useClickOutside
+
+detect clicks outside a referenced element (web only)
+
+```ts
+useClickOutside({ ref, active, onClickOutside })
+```
+
+### useDebouncePrepend
+
+debounce list updates when prepending items, immediate updates otherwise
+
+```ts
+const debouncedList = useDebouncePrepend(list, delay)
+```
+
+### useDeepMemoizedObject
+
+deep memoization with optional immutable field tracking
+
+```ts
+const memoized = useDeepMemoizedObject(value, {
+  immutableToNestedChanges: { 'path.to.field': true },
+})
+```
+
+### useDeferredBoolean
+
+defer boolean state updates using react transitions
+
+```ts
+const deferredValue = useDeferredBoolean(value)
+```
+
+### useEffectOnceGlobally
+
+run effect once globally across all component instances, keyed by id
+
+```ts
+useEffectOnceGlobally(key, (value) => {
+  // runs once per unique key
+})
+```
+
+### useIsMounted
+
+returns true after component mounts
+
+```ts
+const isMounted = useIsMounted()
+```
+
+### useLastValue
+
+returns previous value from last render
+
+```ts
+const previousValue = useLastValue(currentValue)
+```
+
+### useLastValueIf
+
+conditionally keep last value based on boolean
+
+```ts
+const value = useLastValueIf(currentValue, shouldKeepLast)
+```
+
+### useMemoizedObjectList
+
+memoize list items by identity key, prevents unnecessary re-renders when zero
+mutates objects
+
+```ts
+const memoizedList = useMemoizedObjectList(list, 'id')
+```
+
+### useMemoStable
+
+useMemo with warnings when dependencies change too often (development only)
+
+```ts
+const value = useMemoStable(() => expensiveComputation(), deps, {
+  name: 'myMemo',
+  maxChanges: 5,
+})
+```
+
+### useThrottle
+
+throttle function calls
+
+```ts
+const throttledFn = useThrottle(fn, delay)
+```
+
+### useWarnIfDepsChange
+
+warn when dependencies change too often (development only)
+
+```ts
+useWarnIfDepsChange(deps, {
+  name: 'myEffect',
+  maxChanges: 5,
+})
+```
+
+### useWarnIfMemoChangesOften
+
+warn when memoized value changes frequently (development only)
+
+```ts
+useWarnIfMemoChangesOften(value, threshold, 'valueName')
+```

package/dist/cjs/index.cjs

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./useClickOutside.cjs"), module.exports);
+__reExport(index_exports, require("./useDebouncePrepend.cjs"), module.exports);
+__reExport(index_exports, require("./useDeepMemoizedObject.cjs"), module.exports);
+__reExport(index_exports, require("./useDeferredBoolean.cjs"), module.exports);
+__reExport(index_exports, require("./useEffectOnceGlobally.cjs"), module.exports);
+__reExport(index_exports, require("./useIsMounted.cjs"), module.exports);
+__reExport(index_exports, require("./useLastValue.cjs"), module.exports);
+__reExport(index_exports, require("./useLastValueIf.cjs"), module.exports);
+__reExport(index_exports, require("./useMemoizedObjectList.cjs"), module.exports);
+__reExport(index_exports, require("./useMemoStable.cjs"), module.exports);
+__reExport(index_exports, require("./useThrottle.cjs"), module.exports);
+__reExport(index_exports, require("./useWarnIfDepsChange.cjs"), module.exports);
+__reExport(index_exports, require("./useWarnIfMemoChangesOften.cjs"), module.exports);

package/dist/cjs/index.native.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./useClickOutside.native.js"), module.exports);
+__reExport(index_exports, require("./useDebouncePrepend.native.js"), module.exports);
+__reExport(index_exports, require("./useDeepMemoizedObject.native.js"), module.exports);
+__reExport(index_exports, require("./useDeferredBoolean.native.js"), module.exports);
+__reExport(index_exports, require("./useEffectOnceGlobally.native.js"), module.exports);
+__reExport(index_exports, require("./useIsMounted.native.js"), module.exports);
+__reExport(index_exports, require("./useLastValue.native.js"), module.exports);
+__reExport(index_exports, require("./useLastValueIf.native.js"), module.exports);
+__reExport(index_exports, require("./useMemoizedObjectList.native.js"), module.exports);
+__reExport(index_exports, require("./useMemoStable.native.js"), module.exports);
+__reExport(index_exports, require("./useThrottle.native.js"), module.exports);
+__reExport(index_exports, require("./useWarnIfDepsChange.native.js"), module.exports);
+__reExport(index_exports, require("./useWarnIfMemoChangesOften.native.js"), module.exports);
+//# sourceMappingURL=index.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","module","exports","__reExport","require"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAP,YAAc,CAAAK,aAAA;AACdG,UAAA,CAAAH,aAAA,EAAcI,OAAA,iCAAAH,MADd,CAAAC,OAAA;AAEAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,oCAAAH,MAFd,CAAAC,OAAA;AAGAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,oCAHd,GAAAH,MAAA,CAAAC,OAAA;AAIAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,oCAAAH,MAJd,CAAAC,OAAA;AAKAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,oCALd,GAAAH,MAAA,CAAAC,OAAA;AAMAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,8BANdH,MAAA,CAAAC,OAAA;AAOAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,8BAAAH,MAPd,CAAAC,OAAA;AAQAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,gCAAAH,MAAA,CARdC,OAAA;AASAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,oCATd,GAAAH,MAAA,CAAAC,OAAA;AAUAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,6BAVd,EAAAH,MAAA,CAAAC,OAAA;AAWAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,6BAAAH,MAAA,CAAAC,OAXd;AAYAC,UAAA,CAAAH,aAAA,EAAcI,OAAA,qCAAAH,MAZd,CAAAC,OAAA","ignoreList":[]}

package/dist/cjs/useClickOutside.cjs

@@ -0,0 +1,52 @@
+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 useClickOutside_exports = {};
+__export(useClickOutside_exports, {
+  useClickOutside: () => useClickOutside
+});
+module.exports = __toCommonJS(useClickOutside_exports);
+var import_helpers = require("@o/helpers");
+var import_react = require("react");
+const useClickOutside = ({
+  ref,
+  active,
+  onClickOutside
+}) => {
+  (0, import_react.useEffect)(() => {
+    if (!import_helpers.IS_WEB) return;
+    if (!active) return;
+    if (!onClickOutside) return;
+    const handleClickOutside = e => {
+      const node = ref.current;
+      if (!node) return;
+      if (!(e.target instanceof HTMLElement)) return;
+      if (!node.contains(e.target)) {
+        onClickOutside();
+      }
+    };
+    document.addEventListener("click", handleClickOutside);
+    return () => {
+      document.removeEventListener("click", handleClickOutside);
+    };
+  }, [ref, active, onClickOutside]);
+};

package/dist/cjs/useClickOutside.native.js

@@ -0,0 +1,63 @@
+"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 useClickOutside_exports = {};
+__export(useClickOutside_exports, {
+  useClickOutside: () => useClickOutside
+});
+module.exports = __toCommonJS(useClickOutside_exports);
+var import_helpers = require("@o/helpers");
+var import_react = require("react");
+function _instanceof(left, right) {
+  "@swc/helpers - instanceof";
+
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else return left instanceof right;
+}
+var useClickOutside = function useClickOutside2(param) {
+  var {
+    ref,
+    active,
+    onClickOutside
+  } = param;
+  (0, import_react.useEffect)(function () {
+    if (!import_helpers.IS_WEB) return;
+    if (!active) return;
+    if (!onClickOutside) return;
+    var handleClickOutside = function handleClickOutside2(e) {
+      var node = ref.current;
+      if (!node) return;
+      if (!_instanceof(e.target, HTMLElement)) return;
+      if (!node.contains(e.target)) {
+        onClickOutside();
+      }
+    };
+    document.addEventListener("click", handleClickOutside);
+    return function () {
+      document.removeEventListener("click", handleClickOutside);
+    };
+  }, [ref, active, onClickOutside]);
+};
+//# sourceMappingURL=useClickOutside.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useClickOutside_exports","__export","useClickOutside","module","exports","import_helpers","require","import_react","_instanceof","left","right","Symbol","hasInstance","useClickOutside2","param","ref","active","onClickOutside","useEffect","IS_WEB","handleClickOutside","handleClickOutside2","e","node","current","target","HTMLElement","contains","document","addEventListener"],"sources":["../../src/useClickOutside.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,uBAAA;AAAAC,QAAA,CAAAD,uBAAA;EAAAE,eAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAuB,CAAAK,uBAAA;AACvB,IAAAK,cAAA,GAA0BC,OAAA;AAQnB,IAAAC,YAAM,GAAAD,OAAmB;AAAA,SAC9BE,YAAAC,IAAA,EAAAC,KAAA;EACA;;EACA,IAAAA,KAAA,mBAAAC,MAAA,oBAAAD,KAAA,CAAAC,MAAA,CAAAC,WAAA;IACF,OAA4B,EAAAF,KAAA,CAAAC,MAAA,CAAAC,WAAA,EAAAH,IAAA;EAC1B,cAAAA,IAAA,YAAUC,KAAM;AACd;AACA,IAAAR,eAAa,YAAAW,iBAAAC,KAAA;EACb;IAAIC,GAAC;IAAAC,MAAA;IAAAC;EAAgB,IAAAH,KAAA;EAErB,IAAAP,YAAM,CAAAW,SAAA,cAAwC;IAC5C,KAAAb,cAAiB,CAAAc,MAAA;IACjB,KAAAH,MAAK,EAAM;IACX,KAAAC,cAAQ;IACR,IAAAG,kBAAmB,GAAE,SAASC,oBAAAC,CAAA;MAC5B,IAAAC,IAAA,GAAAR,GAAA,CAAAS,OAAe;MACjB,KAAAD,IAAA;MACF,KAAAf,WAAA,CAAAc,CAAA,CAAAG,MAAA,EAAAC,WAAA;MAEA,KAAAH,IAAS,CAAAI,QAAA,CAAAL,CAAA,CAAAG,MAAiB;QAC1BR,cAAa;MACX;IACF;IACFW,QAAS,CAAAC,gBAAQ,QAAe,EAAAT,kBAAA;IAClC","ignoreList":[]}

package/dist/cjs/useDebouncePrepend.cjs

@@ -0,0 +1,66 @@
+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 useDebouncePrepend_exports = {};
+__export(useDebouncePrepend_exports, {
+  useDebouncePrepend: () => useDebouncePrepend
+});
+module.exports = __toCommonJS(useDebouncePrepend_exports);
+var import_helpers = require("@o/helpers");
+var import_react = require("react");
+function useDebouncePrepend(list, delay) {
+  const [current, setCurrent] = (0, import_react.useState)(list);
+  const [previous, setPrevious] = (0, import_react.useState)(list);
+  const [pendingUpdate, setPendingUpdate] = (0, import_react.useState)(null);
+  const debouncedUpdate = (0, import_react.useMemo)(() => {
+    return (0, import_helpers.debounce)(newList => {
+      setCurrent(newList);
+      setPendingUpdate(null);
+    }, delay);
+  }, [delay]);
+  const updateState = (0, import_react.useCallback)(newList => {
+    setCurrent(prevCurrent => {
+      const currentList = pendingUpdate || prevCurrent;
+      const isPrepending = newList.length > previous.length && newList[0]?.id !== previous[0]?.id;
+      if (isPrepending) {
+        debouncedUpdate.cancel();
+        setPendingUpdate(newList);
+        debouncedUpdate(newList);
+        return currentList;
+      }
+      debouncedUpdate.cancel();
+      setPendingUpdate(null);
+      return newList;
+    });
+  }, [previous, pendingUpdate, debouncedUpdate]);
+  (0, import_react.useEffect)(() => {
+    if (list === previous) {
+      return;
+    }
+    setPrevious(list);
+    updateState(list);
+    return () => {
+      debouncedUpdate.cancel();
+    };
+  }, [list, previous, updateState, debouncedUpdate]);
+  return current;
+}

package/dist/cjs/useDebouncePrepend.native.js

@@ -0,0 +1,70 @@
+"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 useDebouncePrepend_exports = {};
+__export(useDebouncePrepend_exports, {
+  useDebouncePrepend: () => useDebouncePrepend
+});
+module.exports = __toCommonJS(useDebouncePrepend_exports);
+var import_helpers = require("@o/helpers");
+var import_react = require("react");
+function useDebouncePrepend(list, delay) {
+  var [current, setCurrent] = (0, import_react.useState)(list);
+  var [previous, setPrevious] = (0, import_react.useState)(list);
+  var [pendingUpdate, setPendingUpdate] = (0, import_react.useState)(null);
+  var debouncedUpdate = (0, import_react.useMemo)(function () {
+    return (0, import_helpers.debounce)(function (newList) {
+      setCurrent(newList);
+      setPendingUpdate(null);
+    }, delay);
+  }, [delay]);
+  var updateState = (0, import_react.useCallback)(function (newList) {
+    setCurrent(function (prevCurrent) {
+      var _newList_, _previous_;
+      var currentList = pendingUpdate || prevCurrent;
+      var isPrepending = newList.length > previous.length && ((_newList_ = newList[0]) === null || _newList_ === void 0 ? void 0 : _newList_.id) !== ((_previous_ = previous[0]) === null || _previous_ === void 0 ? void 0 : _previous_.id);
+      if (isPrepending) {
+        debouncedUpdate.cancel();
+        setPendingUpdate(newList);
+        debouncedUpdate(newList);
+        return currentList;
+      }
+      debouncedUpdate.cancel();
+      setPendingUpdate(null);
+      return newList;
+    });
+  }, [previous, pendingUpdate, debouncedUpdate]);
+  (0, import_react.useEffect)(function () {
+    if (list === previous) {
+      return;
+    }
+    setPrevious(list);
+    updateState(list);
+    return function () {
+      debouncedUpdate.cancel();
+    };
+  }, [list, previous, updateState, debouncedUpdate]);
+  return current;
+}
+//# sourceMappingURL=useDebouncePrepend.native.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","useDebouncePrepend_exports","__export","useDebouncePrepend","module","exports","import_helpers","require","import_react","list","delay","current","setCurrent","useState","previous","setPrevious","pendingUpdate","setPendingUpdate","debouncedUpdate","useMemo","debounce","newList","updateState","useCallback","prevCurrent","_newList_","_previous_","currentList","isPrepending","length","id","cancel","useEffect"],"sources":["../../src/useDebouncePrepend.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,0BAAA;AAAAC,QAAA,CAAAD,0BAAA;EAAAE,kBAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAyB,CAAAK,0BAAA;AACzB,IAAAK,cAAA,GAA0DC,OAAA;AAEnD,IAAAC,YAAS,GAAAD,OAAA,QAEd;AAEA,SAAOJ,kBAASA,CAAUM,IAAA,EAAAC,KAAI;EAC9B,KAAAC,OAAO,EAAAC,UAAU,IAAW,IAAAJ,YAAI,CAAAK,QAAA,EAAAJ,IAAS;EACzC,KAAAK,QAAO,EAAAC,WAAe,QAAAP,YAAoB,CAAAK,QAAA,EAAAJ,IAAA;EAE1C,KAAAO,aAAM,EAAAC,gBAAkB,QAAAT,YAAc,CAAAK,QAAA;EACpC,IAAAK,eAAO,OAAAV,YAAS,CAACW,OAAA,cAAe;IAC9B,WAAAb,cAAkB,CAAAc,QAAA,YAAAC,OAAA;MAClBT,UAAA,CAAAS,OAAiB;MACnBJ,gBAAQ;IACV,CAAG,EAACP,KAAM;EAEV,IACEA,KAAC,CACC;EAEE,IAAAY,WAAM,OAAAd,YAAc,CAAAe,WAAiB,YAAAF,OAAA;IAGrCT,UAAM,WAAAY,WACJ,EAAQ;MAEV,IAAAC,SAAI,EAAAC,UAAc;MAEhB,IAAAC,WAAA,GAAAX,aAAuB,IAAAQ,WAAA;MACvB,IAAAI,YAAA,GAAAP,OAAiB,CAAAQ,MAAO,GAAAf,QAAA,CAAAe,MAAA,MAAAJ,SAAA,GAAAJ,OAAA,iBAAAI,SAAA,uBAAAA,SAAA,CAAAK,EAAA,QAAAJ,UAAA,GAAAZ,QAAA,iBAAAY,UAAA,uBAAAA,UAAA,CAAAI,EAAA;MACxB,IAAAF,YAAA;QACAV,eAAO,CAAAa,MAAA;QACTd,gBAAA,CAAAI,OAAA;QAGAH,eAAA,CAAgBG,OAAO;QACvB,OAAAM,WAAiB;MACjB;MACFT,eAAC,CAAAa,MAAA;MACHd,gBAAA;MACC,OAAAI,OAAU;IACb;EAEA,IACEP,QAAI,EACFE,aAAA,EACFE,eAAA,CAGA;EAGA,IAAAV,YAAY,CAAAwB,SAAI;IAEhB,IAAAvB,IAAO,KAAMK,QAAA;MACX;IACF;IACFC,WAAU,CAAAN,IAAA;IAEVa,WAAO,CAAAb,IAAA;IACT","ignoreList":[]}

package/dist/cjs/useDeepMemoizedObject.cjs

@@ -0,0 +1,207 @@
+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 shouldBeImmutable(path, immutableToNestedChanges) {
+  if (!immutableToNestedChanges) return false;
+  const currentPath = path.join(".");
+  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) {
+    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 = false) {
+  if (current === previous) {
+    return {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: false
+    };
+  }
+  if (typeof current !== "object" || current === null) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  if (typeof previous !== "object" || previous === null) {
+    return {
+      value: current,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  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)];
+      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 {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: false
+    };
+  }
+  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];
+    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];
+      }
+    }
+    return {
+      value: previous,
+      hasChanges: false,
+      hasImmutableMutation: true
+    };
+  }
+  if (hasChanges || hasImmutableMutation) {
+    return {
+      value: memoizedObject,
+      hasChanges: true,
+      hasImmutableMutation: false
+    };
+  }
+  return {
+    value: previous,
+    hasChanges: false,
+    hasImmutableMutation: false
+  };
+}
+function deepMemoize(current, previous, path = [], immutableToNestedChanges) {
+  const 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 (typeof result.value === "object" && result.value !== null) {
+      return {
+        ...result.value
+      };
+    }
+  }
+  return result.value;
+}
+function useDeepMemoizedObject(value, options) {
+  const previousValueRef = (0, import_react.useRef)(value);
+  const memoizedValue = deepMemoize(value, previousValueRef.current, [], options?.immutableToNestedChanges);
+  previousValueRef.current = memoizedValue;
+  return memoizedValue;
+}