@isograph/react-disposable-state 0.5.2 → 0.5.4

package/dist/{useDisposableState.js → useDisposableState.cjs}

@@ -1,22 +1,21 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
-const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.js');
-const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.js');
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.cjs');
+const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.cjs');
 let react = require("react");
-react = require_rolldown_runtime.__toESM(react);
 
 //#region src/useDisposableState.ts
 function useDisposableState(parentCache) {
 	const itemCleanupPairRef = (0, react.useRef)(null);
 	const preCommitItem = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	const { state: stateFromDisposableStateHook, setState } = require_useUpdatableDisposableState.useUpdatableDisposableState();
 	(0, react.useEffect)(function cleanupItemCleanupPairRefAfterSetState() {
-		if (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE) if (itemCleanupPairRef.current != null) {
-			itemCleanupPairRef.current[1]();
-			itemCleanupPairRef.current = null;
-		} else throw new Error("itemCleanupPairRef.current is unexpectedly null. This indicates a bug in react-disposable-state.");
+		if (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE) {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		}
 	}, [stateFromDisposableStateHook]);
 	(0, react.useEffect)(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
 		return () => {
@@ -25,7 +24,7 @@ function useDisposableState(parentCache) {
 				itemCleanupPairRef.current = null;
 			}
 		};
-	}, []);
+	}, [parentCache]);
 	const state = (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (state != null) return {
 		state,

package/dist/{useDisposableState.d.ts → useDisposableState.d.cts}

@@ -1,5 +1,5 @@
-import { ParentCache } from "./ParentCache.js";
-import { UnassignedState } from "./useUpdatableDisposableState.js";
+import { ParentCache } from "./ParentCache.cjs";
+import { UnassignedState } from "./useUpdatableDisposableState.cjs";
 import { ItemCleanupPair } from "@isograph/disposable-types";
 
 //#region src/useDisposableState.d.ts
@@ -10,4 +10,4 @@ type UseUpdatableDisposableStateReturnValue<T> = {
 declare function useDisposableState<T = never>(parentCache: ParentCache<T>): UseUpdatableDisposableStateReturnValue<T>;
 //#endregion
 export { useDisposableState };
-//# sourceMappingURL=useDisposableState.d.ts.map
+//# sourceMappingURL=useDisposableState.d.cts.map

package/dist/useDisposableState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDisposableState.d.cts","names":[],"sources":["../src/useDisposableState.ts"],"mappings":";;;;;KAUK,sCAAA;EACH,KAAA,EAAO,CAAA;EACP,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;AAAA;AAAA,iBAG9B,kBAAA,WAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,IACxB,sCAAA,CAAuC,CAAA"}

package/dist/useDisposableState.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useDisposableState.d.mts","names":[],"sources":["../src/useDisposableState.ts"],"sourcesContent":[],"mappings":";;;;;KAUK;SACI;EADJ,QAAA,EAAA,CAAA,IAAA,EAEc,eAFd,CAE8B,OAF9B,CAEsC,CAFA,EAEG,eAFH,CAAA,CAAA,EAAA,GAAA,IAAA;CAClC;AACkC,iBAG3B,kBAH2B,CAAA,IAAA,KAAA,CAAA,CAAA,WAAA,EAI5B,WAJ4B,CAIhB,CAJgB,CAAA,CAAA,EAKxC,sCALwC,CAKD,CALC,CAAA"}
+{"version":3,"file":"useDisposableState.d.mts","names":[],"sources":["../src/useDisposableState.ts"],"mappings":";;;;;KAUK,sCAAA;EACH,KAAA,EAAO,CAAA;EACP,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;AAAA;AAAA,iBAG9B,kBAAA,WAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,IACxB,sCAAA,CAAuC,CAAA"}

package/dist/useDisposableState.mjs

@@ -6,15 +6,16 @@ import { useEffect, useRef } from "react";
 function useDisposableState(parentCache) {
 	const itemCleanupPairRef = useRef(null);
 	const preCommitItem = useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	const { state: stateFromDisposableStateHook, setState } = useUpdatableDisposableState();
 	useEffect(function cleanupItemCleanupPairRefAfterSetState() {
-		if (stateFromDisposableStateHook !== UNASSIGNED_STATE) if (itemCleanupPairRef.current != null) {
-			itemCleanupPairRef.current[1]();
-			itemCleanupPairRef.current = null;
-		} else throw new Error("itemCleanupPairRef.current is unexpectedly null. This indicates a bug in react-disposable-state.");
+		if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		}
 	}, [stateFromDisposableStateHook]);
 	useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
 		return () => {
@@ -23,7 +24,7 @@ function useDisposableState(parentCache) {
 				itemCleanupPairRef.current = null;
 			}
 		};
-	}, []);
+	}, [parentCache]);
 	const state = (stateFromDisposableStateHook !== UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (state != null) return {
 		state,

package/dist/useDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDisposableState.mjs","names":["state: T | undefined"],"sources":["../src/useDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport {\n  UNASSIGNED_STATE,\n  type UnassignedState,\n  useUpdatableDisposableState,\n} from './useUpdatableDisposableState';\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\nexport function useDisposableState<T = never>(\n  parentCache: ParentCache<T>,\n): UseUpdatableDisposableStateReturnValue<T> {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current?.[1]();\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  const { state: stateFromDisposableStateHook, setState } =\n    useUpdatableDisposableState<T>();\n\n  useEffect(\n    function cleanupItemCleanupPairRefAfterSetState() {\n      if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          itemCleanupPairRef.current = null;\n        } else {\n          throw new Error(\n            'itemCleanupPairRef.current is unexpectedly null. ' +\n              'This indicates a bug in react-disposable-state.',\n          );\n        }\n      }\n    },\n    [stateFromDisposableStateHook],\n  );\n\n  useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {\n    return () => {\n      if (itemCleanupPairRef.current != null) {\n        itemCleanupPairRef.current[1]();\n        itemCleanupPairRef.current = null;\n      }\n    };\n  }, []);\n  const state: T | undefined =\n    (stateFromDisposableStateHook !== UNASSIGNED_STATE\n      ? stateFromDisposableStateHook\n      : null) ??\n    preCommitItem?.state ??\n    itemCleanupPairRef.current?.[0];\n\n  if (state != null) {\n    return {\n      state: state,\n      setState,\n    };\n  }\n\n  // Safety: we can be in one of three states. Pre-commit, in which case\n  // preCommitItem is assigned, post-commit but before setState has been\n  // called, in which case itemCleanupPairRef.current is assigned, or\n  // after setState has been called, in which case\n  // stateFromDisposableStateHook is assigned.\n  //\n  // Therefore, the type of state is T, not T | undefined. But the fact\n  // that we are in one of the three states is not reflected in the types.\n  // So we have to cast to T.\n  //\n  // Note that in the post-commit post-setState state, itemCleanupPairRef\n  // can still be assigned, during the render before the\n  // cleanupItemCleanupPairRefAfterSetState effect is called.\n  throw new Error(\n    'state was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let x: any;\n  const a = useDisposableState(x);\n  // This should be a compiler error, because the generic is inferred to be of\n  // type never. TODO determine why this doesn't break the build!\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  const b = useDisposableState<string | UnassignedState>(x);\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;;AAeA,SAAgB,mBACd,aAC2C;CAC3C,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU,IAAI;AACjC,qBAAmB,UAAU;GAEhC;CAED,MAAM,EAAE,OAAO,8BAA8B,aAC3C,6BAAgC;AAElC,WACE,SAAS,yCAAyC;AAChD,MAAI,iCAAiC,iBACnC,KAAI,mBAAmB,WAAW,MAAM;AACtC,sBAAmB,QAAQ,IAAI;AAC/B,sBAAmB,UAAU;QAE7B,OAAM,IAAI,MACR,mGAED;IAIP,CAAC,6BAA6B,CAC/B;AAED,WAAU,SAAS,+CAA+C;AAChE,eAAa;AACX,OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAC/B,uBAAmB,UAAU;;;IAGhC,EAAE,CAAC;CACN,MAAMA,SACH,iCAAiC,mBAC9B,+BACA,SACJ,eAAe,SACf,mBAAmB,UAAU;AAE/B,KAAI,SAAS,KACX,QAAO;EACE;EACP;EACD;AAgBH,OAAM,IAAI,MACR,+EACD"}
+{"version":3,"file":"useDisposableState.mjs","names":[],"sources":["../src/useDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport {\n  UNASSIGNED_STATE,\n  type UnassignedState,\n  useUpdatableDisposableState,\n} from './useUpdatableDisposableState';\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\nexport function useDisposableState<T = never>(\n  parentCache: ParentCache<T>,\n): UseUpdatableDisposableStateReturnValue<T> {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  const { state: stateFromDisposableStateHook, setState } =\n    useUpdatableDisposableState<T>();\n\n  useEffect(\n    function cleanupItemCleanupPairRefAfterSetState() {\n      if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          itemCleanupPairRef.current = null;\n        }\n      }\n    },\n    [stateFromDisposableStateHook],\n  );\n\n  useEffect(\n    function cleanupItemCleanupPairRefIfSetStateNotCalled() {\n      return () => {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          // Forgotten so that nothing can release this pair a second time\n          // before an effect re-run (StrictMode, Fast Refresh) stores a new one.\n          itemCleanupPairRef.current = null;\n        }\n      };\n    },\n    [parentCache],\n  );\n  const state: T | undefined =\n    (stateFromDisposableStateHook !== UNASSIGNED_STATE\n      ? stateFromDisposableStateHook\n      : null) ??\n    preCommitItem?.state ??\n    itemCleanupPairRef.current?.[0];\n\n  if (state != null) {\n    return {\n      state: state,\n      setState,\n    };\n  }\n  // Safety: we can be in one of three states. Pre-commit, in which case\n  // preCommitItem is assigned, post-commit but before setState has been\n  // called, in which case itemCleanupPairRef.current is assigned, or\n  // after setState has been called, in which case\n  // stateFromDisposableStateHook is assigned.\n  //\n  // Therefore, the type of state is T, not T | undefined. But the fact\n  // that we are in one of the three states is not reflected in the types.\n  // So we have to cast to T.\n  //\n  // Note that in the post-commit post-setState state, itemCleanupPairRef\n  // can still be assigned, during the render before the\n  // cleanupItemCleanupPairRefAfterSetState effect is called.\n  throw new Error(\n    'state was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let x: any;\n  const a = useDisposableState(x);\n  // This should be a compiler error, because the generic is inferred to be of\n  // type never. TODO determine why this doesn't break the build!\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  const b = useDisposableState<string | UnassignedState>(x);\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;;AAeA,SAAgB,mBACd,aAC2C;CAC3C,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU;GAEhC;CAED,MAAM,EAAE,OAAO,8BAA8B,aAC3C,6BAAgC;AAElC,WACE,SAAS,yCAAyC;AAChD,MAAI,iCAAiC,kBACnC;OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAC/B,uBAAmB,UAAU;;;IAInC,CAAC,6BAA6B,CAC/B;AAED,WACE,SAAS,+CAA+C;AACtD,eAAa;AACX,OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAG/B,uBAAmB,UAAU;;;IAInC,CAAC,YAAY,CACd;CACD,MAAM,SACH,iCAAiC,mBAC9B,+BACA,SACJ,eAAe,SACf,mBAAmB,UAAU;AAE/B,KAAI,SAAS,KACX,QAAO;EACE;EACP;EACD;AAeH,OAAM,IAAI,MACR,+EACD"}

package/dist/useEffectsRerunWithoutRender.cjs

@@ -0,0 +1,27 @@
+let react = require("react");
+
+//#region src/useEffectsRerunWithoutRender.ts
+/**
+* Detects that React is running this component's effects again without a
+* render in between. That happens on StrictMode's simulated unmount and
+* remount on the first commit, on Fast Refresh, and when an `Activity`
+* boundary hides and then shows the component. In each case React runs every
+* effect's cleanup and then its mount, so a cleanup that sets a flag is
+* observable from the mounts that follow.
+*
+* Returns a ref whose `current` is `true` from the moment the cleanup ran until
+* the caller resets it. The effect that must tell a re-run apart from a first
+* mount reads it and sets it back to `false`; nothing else clears it.
+*/
+function useEffectsRerunWithoutRenderRef() {
+	const effectsRerunWithoutRenderRef = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		return () => {
+			effectsRerunWithoutRenderRef.current = true;
+		};
+	}, []);
+	return effectsRerunWithoutRenderRef;
+}
+
+//#endregion
+exports.useEffectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef;

package/dist/useEffectsRerunWithoutRender.d.cts

@@ -0,0 +1,19 @@
+import { MutableRefObject } from "react";
+
+//#region src/useEffectsRerunWithoutRender.d.ts
+/**
+ * Detects that React is running this component's effects again without a
+ * render in between. That happens on StrictMode's simulated unmount and
+ * remount on the first commit, on Fast Refresh, and when an `Activity`
+ * boundary hides and then shows the component. In each case React runs every
+ * effect's cleanup and then its mount, so a cleanup that sets a flag is
+ * observable from the mounts that follow.
+ *
+ * Returns a ref whose `current` is `true` from the moment the cleanup ran until
+ * the caller resets it. The effect that must tell a re-run apart from a first
+ * mount reads it and sets it back to `false`; nothing else clears it.
+ */
+declare function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean>;
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.d.cts.map

package/dist/useEffectsRerunWithoutRender.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.d.cts","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"mappings":";;;;;AAcA;;;;;;;;;;iBAAgB,+BAAA,CAAA,GAAmC,gBAAA"}

package/dist/useEffectsRerunWithoutRender.d.mts

@@ -0,0 +1,19 @@
+import { MutableRefObject } from "react";
+
+//#region src/useEffectsRerunWithoutRender.d.ts
+/**
+ * Detects that React is running this component's effects again without a
+ * render in between. That happens on StrictMode's simulated unmount and
+ * remount on the first commit, on Fast Refresh, and when an `Activity`
+ * boundary hides and then shows the component. In each case React runs every
+ * effect's cleanup and then its mount, so a cleanup that sets a flag is
+ * observable from the mounts that follow.
+ *
+ * Returns a ref whose `current` is `true` from the moment the cleanup ran until
+ * the caller resets it. The effect that must tell a re-run apart from a first
+ * mount reads it and sets it back to `false`; nothing else clears it.
+ */
+declare function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean>;
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.d.mts.map

package/dist/useEffectsRerunWithoutRender.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.d.mts","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"mappings":";;;;;AAcA;;;;;;;;;;iBAAgB,+BAAA,CAAA,GAAmC,gBAAA"}

package/dist/useEffectsRerunWithoutRender.mjs

@@ -0,0 +1,28 @@
+import { useEffect, useRef } from "react";
+
+//#region src/useEffectsRerunWithoutRender.ts
+/**
+* Detects that React is running this component's effects again without a
+* render in between. That happens on StrictMode's simulated unmount and
+* remount on the first commit, on Fast Refresh, and when an `Activity`
+* boundary hides and then shows the component. In each case React runs every
+* effect's cleanup and then its mount, so a cleanup that sets a flag is
+* observable from the mounts that follow.
+*
+* Returns a ref whose `current` is `true` from the moment the cleanup ran until
+* the caller resets it. The effect that must tell a re-run apart from a first
+* mount reads it and sets it back to `false`; nothing else clears it.
+*/
+function useEffectsRerunWithoutRenderRef() {
+	const effectsRerunWithoutRenderRef = useRef(false);
+	useEffect(() => {
+		return () => {
+			effectsRerunWithoutRenderRef.current = true;
+		};
+	}, []);
+	return effectsRerunWithoutRenderRef;
+}
+
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.mjs.map

package/dist/useEffectsRerunWithoutRender.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.mjs","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"sourcesContent":["import { type MutableRefObject, useEffect, useRef } from 'react';\n\n/**\n * Detects that React is running this component's effects again without a\n * render in between. That happens on StrictMode's simulated unmount and\n * remount on the first commit, on Fast Refresh, and when an `Activity`\n * boundary hides and then shows the component. In each case React runs every\n * effect's cleanup and then its mount, so a cleanup that sets a flag is\n * observable from the mounts that follow.\n *\n * Returns a ref whose `current` is `true` from the moment the cleanup ran until\n * the caller resets it. The effect that must tell a re-run apart from a first\n * mount reads it and sets it back to `false`; nothing else clears it.\n */\nexport function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean> {\n  const effectsRerunWithoutRenderRef = useRef(false);\n  useEffect(() => {\n    return () => {\n      effectsRerunWithoutRenderRef.current = true;\n    };\n  }, []);\n  return effectsRerunWithoutRenderRef;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,kCAA6D;CAC3E,MAAM,+BAA+B,OAAO,MAAM;AAClD,iBAAgB;AACd,eAAa;AACX,gCAA6B,UAAU;;IAExC,EAAE,CAAC;AACN,QAAO"}

package/dist/{useHasCommittedRef.js → useHasCommittedRef.cjs}

@@ -1,6 +1,4 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
 let react = require("react");
-react = require_rolldown_runtime.__toESM(react);
 
 //#region src/useHasCommittedRef.ts
 /**

package/dist/{useHasCommittedRef.d.ts → useHasCommittedRef.d.cts}

@@ -1,11 +1,10 @@
 import { MutableRefObject } from "react";
 
 //#region src/useHasCommittedRef.d.ts
-
 /**
  * Returns true if the component has committed, false otherwise.
  */
 declare function useHasCommittedRef(): MutableRefObject<boolean>;
 //#endregion
 export { useHasCommittedRef };
-//# sourceMappingURL=useHasCommittedRef.d.ts.map
+//# sourceMappingURL=useHasCommittedRef.d.cts.map

package/dist/useHasCommittedRef.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHasCommittedRef.d.cts","names":[],"sources":["../src/useHasCommittedRef.ts"],"mappings":";;;;;AAKA;iBAAgB,kBAAA,CAAA,GAAsB,gBAAA"}

package/dist/useHasCommittedRef.d.mts

@@ -1,7 +1,6 @@
 import { MutableRefObject } from "react";
 
 //#region src/useHasCommittedRef.d.ts
-
 /**
  * Returns true if the component has committed, false otherwise.
  */

package/dist/useHasCommittedRef.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useHasCommittedRef.d.mts","names":[],"sources":["../src/useHasCommittedRef.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;iBAAgB,kBAAA,CAAA,GAAsB"}
+{"version":3,"file":"useHasCommittedRef.d.mts","names":[],"sources":["../src/useHasCommittedRef.ts"],"mappings":";;;;;AAKA;iBAAgB,kBAAA,CAAA,GAAsB,gBAAA"}

package/dist/{useLazyDisposableState.js → useLazyDisposableState.cjs}

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
-const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.js');
+'use strict';
+
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.cjs');
 let react = require("react");
-react = require_rolldown_runtime.__toESM(react);
 
 //#region src/useLazyDisposableState.ts
 /**
@@ -16,16 +16,16 @@ react = require_rolldown_runtime.__toESM(react);
 function useLazyDisposableState(parentCache) {
 	const itemCleanupPairRef = (0, react.useRef)(null);
 	const preCommitItem = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	(0, react.useEffect)(() => {
 		return () => {
 			const cleanupFn = itemCleanupPairRef.current?.[1];
 			if (cleanupFn == null) throw new Error("cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.");
-			return cleanupFn();
+			cleanupFn();
+			itemCleanupPairRef.current = null;
 		};
-	}, []);
+	}, [parentCache]);
 	const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (returnedItem != null) return { state: returnedItem };
 	throw new Error("returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.");

package/dist/{useLazyDisposableState.d.ts → useLazyDisposableState.d.cts}

@@ -1,8 +1,7 @@
-import { ParentCache } from "./ParentCache.js";
-import { UnassignedState } from "./useUpdatableDisposableState.js";
+import { ParentCache } from "./ParentCache.cjs";
+import { UnassignedState } from "./useUpdatableDisposableState.cjs";
 
 //#region src/useLazyDisposableState.d.ts
-
 /**
  * useLazyDisposableState<T>
  * - Takes a mutable parent cache and a factory function
@@ -17,4 +16,4 @@ declare function useLazyDisposableState<T>(parentCache: ParentCache<Exclude<T, U
 };
 //#endregion
 export { useLazyDisposableState };
-//# sourceMappingURL=useLazyDisposableState.d.ts.map
+//# sourceMappingURL=useLazyDisposableState.d.cts.map

package/dist/useLazyDisposableState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyDisposableState.d.cts","names":[],"sources":["../src/useLazyDisposableState.ts"],"mappings":";;;;;;AAiBA;;;;;;;iBAAgB,sBAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,OAAA,CAAQ,CAAA,EAAG,eAAA;EAEpC,KAAA,EAAO,CAAA;AAAA"}

package/dist/useLazyDisposableState.d.mts

@@ -2,7 +2,6 @@ import { ParentCache } from "./ParentCache.mjs";
 import { UnassignedState } from "./useUpdatableDisposableState.mjs";
 
 //#region src/useLazyDisposableState.d.ts
-
 /**
  * useLazyDisposableState<T>
  * - Takes a mutable parent cache and a factory function

package/dist/useLazyDisposableState.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyDisposableState.d.mts","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;iBAAgB,uCACD,YAAY,QAAQ,GAAG;SAE7B"}
+{"version":3,"file":"useLazyDisposableState.d.mts","names":[],"sources":["../src/useLazyDisposableState.ts"],"mappings":";;;;;;AAiBA;;;;;;;iBAAgB,sBAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,OAAA,CAAQ,CAAA,EAAG,eAAA;EAEpC,KAAA,EAAO,CAAA;AAAA"}

package/dist/useLazyDisposableState.mjs

@@ -14,16 +14,16 @@ import { useEffect, useRef } from "react";
 function useLazyDisposableState(parentCache) {
 	const itemCleanupPairRef = useRef(null);
 	const preCommitItem = useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	useEffect(() => {
 		return () => {
 			const cleanupFn = itemCleanupPairRef.current?.[1];
 			if (cleanupFn == null) throw new Error("cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.");
-			return cleanupFn();
+			cleanupFn();
+			itemCleanupPairRef.current = null;
 		};
-	}, []);
+	}, [parentCache]);
 	const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (returnedItem != null) return { state: returnedItem };
 	throw new Error("returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.");

package/dist/useLazyDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyDisposableState.mjs","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/isograph-disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport { type UnassignedState } from './useUpdatableDisposableState';\n\n/**\n * useLazyDisposableState<T>\n * - Takes a mutable parent cache and a factory function\n * - Returns { state: T }\n *\n * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then\n * (on commit) sets it in state. The item continues to be returned after\n * commit and is disposed when the hook unmounts.\n */\nexport function useLazyDisposableState<T>(\n  parentCache: ParentCache<Exclude<T, UnassignedState>>,\n): {\n  state: T;\n} {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current?.[1]();\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  useEffect(() => {\n    return () => {\n      const cleanupFn = itemCleanupPairRef.current?.[1];\n      // TODO confirm useEffect is called in order.\n      if (cleanupFn == null) {\n        throw new Error(\n          'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',\n        );\n      }\n      return cleanupFn();\n    };\n  }, []);\n\n  const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];\n\n  if (returnedItem != null) {\n    return { state: returnedItem };\n  }\n\n  // Safety: This can't happen. For renders before the initial commit, preCommitItem\n  // is non-null. During the initial commit, we assign itemCleanupPairRef.current,\n  // so during subsequent renders, itemCleanupPairRef.current is non-null.\n  throw new Error(\n    'returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,uBACd,aAGA;CACA,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU,IAAI;AACjC,qBAAmB,UAAU;GAEhC;AAED,iBAAgB;AACd,eAAa;GACX,MAAM,YAAY,mBAAmB,UAAU;AAE/C,OAAI,aAAa,KACf,OAAM,IAAI,MACR,+EACD;AAEH,UAAO,WAAW;;IAEnB,EAAE,CAAC;CAEN,MAAM,eAAe,eAAe,SAAS,mBAAmB,UAAU;AAE1E,KAAI,gBAAgB,KAClB,QAAO,EAAE,OAAO,cAAc;AAMhC,OAAM,IAAI,MACR,sFACD"}
+{"version":3,"file":"useLazyDisposableState.mjs","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport { type UnassignedState } from './useUpdatableDisposableState';\n\n/**\n * useLazyDisposableState<T>\n * - Takes a mutable parent cache and a factory function\n * - Returns { state: T }\n *\n * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then\n * (on commit) sets it in state. The item continues to be returned after\n * commit and is disposed when the hook unmounts.\n */\nexport function useLazyDisposableState<T>(\n  parentCache: ParentCache<Exclude<T, UnassignedState>>,\n): {\n  state: T;\n} {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  useEffect(() => {\n    return () => {\n      const cleanupFn = itemCleanupPairRef.current?.[1];\n      // TODO confirm useEffect is called in order.\n      if (cleanupFn == null) {\n        throw new Error(\n          'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',\n        );\n      }\n      cleanupFn();\n      itemCleanupPairRef.current = null;\n    };\n  }, [parentCache]);\n\n  const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];\n\n  if (returnedItem != null) {\n    return { state: returnedItem };\n  }\n\n  // Safety: This can't happen. For renders before the initial commit, preCommitItem\n  // is non-null. During the initial commit, we assign itemCleanupPairRef.current,\n  // so during subsequent renders, itemCleanupPairRef.current is non-null.\n  throw new Error(\n    'returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,uBACd,aAGA;CACA,MAAM,qBAAqB,OAAkC,KAAK;CAClE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU;GAEhC;AAED,iBAAgB;AACd,eAAa;GACX,MAAM,YAAY,mBAAmB,UAAU;AAE/C,OAAI,aAAa,KACf,OAAM,IAAI,MACR,+EACD;AAEH,cAAW;AACX,sBAAmB,UAAU;;IAE9B,CAAC,YAAY,CAAC;CAEjB,MAAM,eAAe,eAAe,SAAS,mBAAmB,UAAU;AAE1E,KAAI,gBAAgB,KAClB,QAAO,EAAE,OAAO,cAAc;AAMhC,OAAM,IAAI,MACR,sFACD"}

package/dist/useUpdatableDisposableClearableState.cjs

@@ -0,0 +1,36 @@
+const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.cjs');
+let react = require("react");
+
+//#region src/useUpdatableDisposableClearableState.ts
+/**
+* The item that `clearState` puts in the underlying state. It is never returned
+* from this hook; the hook reports UNASSIGNED_STATE while it is current.
+*/
+const CLEARED_STATE = Symbol();
+function noop() {}
+/**
+* useUpdatableDisposableClearableState
+* - useUpdatableDisposableState, plus clearState.
+* - clearState returns the state to UNASSIGNED_STATE. The item that was in state
+*   is disposed on the next commit, exactly as if it had been superseded by
+*   setState.
+* - Like setState, clearState throws if called before the initial commit.
+*
+* This is a wrapper around useUpdatableDisposableState: clearing sets a sentinel
+* item with no cleanup, so the underlying hook's commit-time disposal of
+* superseded items disposes the cleared item, and the sentinel is mapped back to
+* UNASSIGNED_STATE on the way out.
+*/
+function useUpdatableDisposableClearableState() {
+	const { state, setState } = require_useUpdatableDisposableState.useUpdatableDisposableState();
+	return {
+		clearState: (0, react.useCallback)(() => {
+			setState([CLEARED_STATE, noop]);
+		}, [setState]),
+		setState,
+		state: state === CLEARED_STATE ? require_useUpdatableDisposableState.UNASSIGNED_STATE : state
+	};
+}
+
+//#endregion
+exports.useUpdatableDisposableClearableState = useUpdatableDisposableClearableState;

package/dist/useUpdatableDisposableClearableState.d.cts

@@ -0,0 +1,26 @@
+import { UnassignedState } from "./useUpdatableDisposableState.cjs";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useUpdatableDisposableClearableState.d.ts
+type UseUpdatableDisposableClearableStateReturnValue<T> = {
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+  clearState: () => void;
+};
+/**
+ * useUpdatableDisposableClearableState
+ * - useUpdatableDisposableState, plus clearState.
+ * - clearState returns the state to UNASSIGNED_STATE. The item that was in state
+ *   is disposed on the next commit, exactly as if it had been superseded by
+ *   setState.
+ * - Like setState, clearState throws if called before the initial commit.
+ *
+ * This is a wrapper around useUpdatableDisposableState: clearing sets a sentinel
+ * item with no cleanup, so the underlying hook's commit-time disposal of
+ * superseded items disposes the cleared item, and the sentinel is mapped back to
+ * UNASSIGNED_STATE on the way out.
+ */
+declare function useUpdatableDisposableClearableState<T = never>(): UseUpdatableDisposableClearableStateReturnValue<T>;
+//#endregion
+export { useUpdatableDisposableClearableState };
+//# sourceMappingURL=useUpdatableDisposableClearableState.d.cts.map

package/dist/useUpdatableDisposableClearableState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdatableDisposableClearableState.d.cts","names":[],"sources":["../src/useUpdatableDisposableClearableState.ts"],"mappings":";;;;KAQK,+CAAA;EACH,KAAA,EAAO,CAAA,GAAI,eAAA;EACX,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;EAC5C,UAAA;AAAA;;;;;;;;;;;;;;iBAyBc,oCAAA,WAAA,CAAA,GAEX,+CAAA,CAAgD,CAAA"}

package/dist/useUpdatableDisposableClearableState.d.mts

@@ -0,0 +1,26 @@
+import { UnassignedState } from "./useUpdatableDisposableState.mjs";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useUpdatableDisposableClearableState.d.ts
+type UseUpdatableDisposableClearableStateReturnValue<T> = {
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+  clearState: () => void;
+};
+/**
+ * useUpdatableDisposableClearableState
+ * - useUpdatableDisposableState, plus clearState.
+ * - clearState returns the state to UNASSIGNED_STATE. The item that was in state
+ *   is disposed on the next commit, exactly as if it had been superseded by
+ *   setState.
+ * - Like setState, clearState throws if called before the initial commit.
+ *
+ * This is a wrapper around useUpdatableDisposableState: clearing sets a sentinel
+ * item with no cleanup, so the underlying hook's commit-time disposal of
+ * superseded items disposes the cleared item, and the sentinel is mapped back to
+ * UNASSIGNED_STATE on the way out.
+ */
+declare function useUpdatableDisposableClearableState<T = never>(): UseUpdatableDisposableClearableStateReturnValue<T>;
+//#endregion
+export { useUpdatableDisposableClearableState };
+//# sourceMappingURL=useUpdatableDisposableClearableState.d.mts.map

package/dist/useUpdatableDisposableClearableState.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdatableDisposableClearableState.d.mts","names":[],"sources":["../src/useUpdatableDisposableClearableState.ts"],"mappings":";;;;KAQK,+CAAA;EACH,KAAA,EAAO,CAAA,GAAI,eAAA;EACX,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;EAC5C,UAAA;AAAA;;;;;;;;;;;;;;iBAyBc,oCAAA,WAAA,CAAA,GAEX,+CAAA,CAAgD,CAAA"}

package/dist/useUpdatableDisposableClearableState.mjs

@@ -0,0 +1,37 @@
+import { UNASSIGNED_STATE, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
+import { useCallback } from "react";
+
+//#region src/useUpdatableDisposableClearableState.ts
+/**
+* The item that `clearState` puts in the underlying state. It is never returned
+* from this hook; the hook reports UNASSIGNED_STATE while it is current.
+*/
+const CLEARED_STATE = Symbol();
+function noop() {}
+/**
+* useUpdatableDisposableClearableState
+* - useUpdatableDisposableState, plus clearState.
+* - clearState returns the state to UNASSIGNED_STATE. The item that was in state
+*   is disposed on the next commit, exactly as if it had been superseded by
+*   setState.
+* - Like setState, clearState throws if called before the initial commit.
+*
+* This is a wrapper around useUpdatableDisposableState: clearing sets a sentinel
+* item with no cleanup, so the underlying hook's commit-time disposal of
+* superseded items disposes the cleared item, and the sentinel is mapped back to
+* UNASSIGNED_STATE on the way out.
+*/
+function useUpdatableDisposableClearableState() {
+	const { state, setState } = useUpdatableDisposableState();
+	return {
+		clearState: useCallback(() => {
+			setState([CLEARED_STATE, noop]);
+		}, [setState]),
+		setState,
+		state: state === CLEARED_STATE ? UNASSIGNED_STATE : state
+	};
+}
+
+//#endregion
+export { useUpdatableDisposableClearableState };
+//# sourceMappingURL=useUpdatableDisposableClearableState.mjs.map

package/dist/useUpdatableDisposableClearableState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdatableDisposableClearableState.mjs","names":[],"sources":["../src/useUpdatableDisposableClearableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useCallback } from 'react';\nimport {\n  UNASSIGNED_STATE,\n  type UnassignedState,\n  useUpdatableDisposableState,\n} from './useUpdatableDisposableState';\n\ntype UseUpdatableDisposableClearableStateReturnValue<T> = {\n  state: T | UnassignedState;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n  clearState: () => void;\n};\n\n/**\n * The item that `clearState` puts in the underlying state. It is never returned\n * from this hook; the hook reports UNASSIGNED_STATE while it is current.\n */\nconst CLEARED_STATE: unique symbol = Symbol();\ntype ClearedState = typeof CLEARED_STATE;\n\nfunction noop() {}\n\n/**\n * useUpdatableDisposableClearableState\n * - useUpdatableDisposableState, plus clearState.\n * - clearState returns the state to UNASSIGNED_STATE. The item that was in state\n *   is disposed on the next commit, exactly as if it had been superseded by\n *   setState.\n * - Like setState, clearState throws if called before the initial commit.\n *\n * This is a wrapper around useUpdatableDisposableState: clearing sets a sentinel\n * item with no cleanup, so the underlying hook's commit-time disposal of\n * superseded items disposes the cleared item, and the sentinel is mapped back to\n * UNASSIGNED_STATE on the way out.\n */\nexport function useUpdatableDisposableClearableState<\n  T = never,\n>(): UseUpdatableDisposableClearableStateReturnValue<T> {\n  const { state, setState } = useUpdatableDisposableState<T | ClearedState>();\n\n  const clearState = useCallback(() => {\n    setState([CLEARED_STATE, noop]);\n  }, [setState]);\n\n  return {\n    clearState,\n    setState,\n    state: state === CLEARED_STATE ? UNASSIGNED_STATE : state,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  const a = useUpdatableDisposableClearableState();\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  const b = useUpdatableDisposableClearableState<string | UnassignedState>();\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n  // The cleared sentinel is not part of T, so it cannot be set from outside.\n  // @ts-expect-error\n  b.setState([CLEARED_STATE, () => {}]);\n}\n"],"mappings":";;;;;;;;AAkBA,MAAM,gBAA+B,QAAQ;AAG7C,SAAS,OAAO;;;;;;;;;;;;;;AAehB,SAAgB,uCAEwC;CACtD,MAAM,EAAE,OAAO,aAAa,6BAA+C;AAM3E,QAAO;EACL,YALiB,kBAAkB;AACnC,YAAS,CAAC,eAAe,KAAK,CAAC;KAC9B,CAAC,SAAS,CAAC;EAIZ;EACA,OAAO,UAAU,gBAAgB,mBAAmB;EACrD"}

package/dist/{useUpdatableDisposableState.js → useUpdatableDisposableState.cjs}

@@ -1,7 +1,5 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
-const require_useHasCommittedRef = require('./useHasCommittedRef.js');
+const require_useHasCommittedRef = require('./useHasCommittedRef.cjs');
 let react = require("react");
-react = require_rolldown_runtime.__toESM(react);
 
 //#region src/useUpdatableDisposableState.ts
 const UNASSIGNED_STATE = Symbol();
@@ -62,7 +60,11 @@ function useUpdatableDisposableState() {
 	});
 	(0, react.useEffect)(() => {
 		return function disposeAllRemainingItems() {
-			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+			for (const undisposedICI of undisposedICIs.current) {
+				undisposedICIs.current.delete(undisposedICI);
+				undisposedICI.cleanup();
+			}
+			setStateICI(UNASSIGNED_STATE);
 		};
 	}, []);
 	return {

package/dist/{useUpdatableDisposableState.d.ts → useUpdatableDisposableState.d.cts}

@@ -40,4 +40,4 @@ type UseUpdatableDisposableStateReturnValue<T> = {
 declare function useUpdatableDisposableState<T = never>(): UseUpdatableDisposableStateReturnValue<T>;
 //#endregion
 export { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState };
-//# sourceMappingURL=useUpdatableDisposableState.d.ts.map
+//# sourceMappingURL=useUpdatableDisposableState.d.cts.map

package/dist/useUpdatableDisposableState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdatableDisposableState.d.cts","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"mappings":";;;cAIa,gBAAA;AAAA,KACD,eAAA,UAAyB,gBAAA;AAAA,KAEhC,sCAAA;EACH,KAAA,EAAO,CAAA,GAAI,eAAA;EACX,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;AAAA;;AAJ9C;;;;;AAAsD;;;;;;;;;;;;;;;;;;;;;;;AAuDtD;iBAAgB,2BAAA,WAAA,CAAA,GAEX,sCAAA,CAAuC,CAAA"}

package/dist/useUpdatableDisposableState.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdatableDisposableState.d.mts","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"sourcesContent":[],"mappings":";;;cAIa;KACD,eAAA,UAAyB;AADrC,KAGK,sCAHkD,CAAA,CAAA,CAAA,GAAA;EAC3C,KAAA,EAGH,CAHG,GAGC,eAHc;EAEtB,QAAA,EAAA,CAAA,IAAA,EAEc,eAFd,CAE8B,OAF9B,CAEsC,CAFA,EAEG,eAFH,CAAA,CAAA,EAAA,GAAA,IAAA;CAClC;;;;;;;AAoDT;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,0CAEX,uCAAuC"}
+{"version":3,"file":"useUpdatableDisposableState.d.mts","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"mappings":";;;cAIa,gBAAA;AAAA,KACD,eAAA,UAAyB,gBAAA;AAAA,KAEhC,sCAAA;EACH,KAAA,EAAO,CAAA,GAAI,eAAA;EACX,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,OAAA,CAAQ,CAAA,EAAG,eAAA;AAAA;;AAJ9C;;;;;AAAsD;;;;;;;;;;;;;;;;;;;;;;;AAuDtD;iBAAgB,2BAAA,WAAA,CAAA,GAEX,sCAAA,CAAuC,CAAA"}

package/dist/useUpdatableDisposableState.mjs

@@ -60,7 +60,11 @@ function useUpdatableDisposableState() {
 	});
 	useEffect(() => {
 		return function disposeAllRemainingItems() {
-			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+			for (const undisposedICI of undisposedICIs.current) {
+				undisposedICIs.current.delete(undisposedICI);
+				undisposedICI.cleanup();
+			}
+			setStateICI(UNASSIGNED_STATE);
 		};
 	}, []);
 	return {

package/dist/useUpdatableDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdatableDisposableState.mjs","names":["UNASSIGNED_STATE: unique symbol","ici: ICI<T>"],"sources":["../src/useUpdatableDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { useHasCommittedRef } from './useHasCommittedRef';\n\nexport const UNASSIGNED_STATE: unique symbol = Symbol();\nexport type UnassignedState = typeof UNASSIGNED_STATE;\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T | UnassignedState;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\n/**\n * ICI stands for ItemCleanupIndex. Use a short name because it shows up a lot.\n *\n * Like an ItemCleanupPair<T>, but with an additional index and as a struct\n * for readability.\n *\n * Interally, we must keep track of the index of the state change. The disposable\n * items that are set in state are not guaranteed to be distinct according to ===,\n * as in `setState([1, dispose1]); setState([1, dispose2])`. Following this, we\n * would expect dispose1 to be called on commit. If state items were compared for\n * ===, then dispose1 would not be called in such a situation.\n *\n * Note that this comes at a runtime cost, and we may want to expose APIs that do\n * not incur this runtime cost, for example in cases where every disposable item is\n * distinguishable via ===.\n */\ntype ICI<T> = { item: T; cleanup: () => void; index: number };\n\n/**\n * useUpdatableDisposableState\n * - Returns a { state, setItem } object.\n * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.\n * - setItem sets the T in state and adds it to a set.\n * - React's behavior is that when the hook commits, whatever item is currently\n *   returned from the useState hook is the oldest item which will ever be returned\n *   from that useState hook. (More newly created ones can later be returned with\n *   concurrent mode.)\n * - When this hook commits, all items up to, but not including, the item currently\n *   returned from the useState hook are disposed and removed from the set.\n *\n * Calling setState before the hook commits:\n * - Calling setState before the hook commits is disallowed because until the hook\n *   commits, React will not schedule any unmount callbacks, meaning that if this\n *   hook never commits, any disposable items passed to setState will never be\n *   disposed.\n * - We also cannot store them in some cache, because multiple components can share\n *   the same cache location (for example, if they are loading the same query from\n *   multiple components), so updating the cache with the disposable item will cause\n *   both components to show the updated data, which is almost certainly a bug.\n * - Note that calling setState before commit is probably an anti-pattern! Consider\n *   not doing it.\n * - If you must, the workaround is to lazily load the disposable item with\n *   useDisposableState or useLazyDisposableState, and update the cache location\n *   instead of calling setState before commit. One can update the cache location\n *   by calling setState on some parent component that has already mounted, and\n *   therefore passing in different props.\n *   - This may only work in concurrent mode, though.\n */\nexport function useUpdatableDisposableState<\n  T = never,\n>(): UseUpdatableDisposableStateReturnValue<T> {\n  const hasCommittedRef = useHasCommittedRef();\n\n  const undisposedICIs = useRef(new Set<ICI<T>>());\n  const setStateCountRef = useRef(0);\n\n  const [stateICI, setStateICI] = useState<ICI<T> | UnassignedState>(\n    UNASSIGNED_STATE,\n  );\n\n  const setStateAfterCommit = useCallback(\n    (itemCleanupPair: ItemCleanupPair<T>) => {\n      if (!hasCommittedRef.current) {\n        throw new Error(\n          'Calling setState before the component has committed is unsafe and disallowed.',\n        );\n      }\n\n      const ici: ICI<T> = {\n        item: itemCleanupPair[0],\n        cleanup: itemCleanupPair[1],\n        index: setStateCountRef.current,\n      };\n      setStateCountRef.current++;\n      undisposedICIs.current.add(ici);\n      setStateICI(ici);\n    },\n    [setStateICI],\n  );\n\n  useEffect(function cleanupUnreachableItems() {\n    const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;\n\n    if (indexInState === 0) {\n      return;\n    }\n\n    for (const undisposedICI of undisposedICIs.current) {\n      if (undisposedICI.index === indexInState) {\n        break;\n      }\n      undisposedICIs.current.delete(undisposedICI);\n      undisposedICI.cleanup();\n    }\n  });\n\n  useEffect(() => {\n    return function disposeAllRemainingItems() {\n      for (const undisposedICI of undisposedICIs.current) {\n        undisposedICI.cleanup();\n      }\n    };\n  }, []);\n\n  return {\n    setState: setStateAfterCommit,\n    state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  const a = useUpdatableDisposableState();\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  const b = useUpdatableDisposableState<string | UnassignedState>();\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;AAIA,MAAaA,mBAAkC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDvD,SAAgB,8BAE+B;CAC7C,MAAM,kBAAkB,oBAAoB;CAE5C,MAAM,iBAAiB,uBAAO,IAAI,KAAa,CAAC;CAChD,MAAM,mBAAmB,OAAO,EAAE;CAElC,MAAM,CAAC,UAAU,eAAe,SAC9B,iBACD;CAED,MAAM,sBAAsB,aACzB,oBAAwC;AACvC,MAAI,CAAC,gBAAgB,QACnB,OAAM,IAAI,MACR,gFACD;EAGH,MAAMC,MAAc;GAClB,MAAM,gBAAgB;GACtB,SAAS,gBAAgB;GACzB,OAAO,iBAAiB;GACzB;AACD,mBAAiB;AACjB,iBAAe,QAAQ,IAAI,IAAI;AAC/B,cAAY,IAAI;IAElB,CAAC,YAAY,CACd;AAED,WAAU,SAAS,0BAA0B;EAC3C,MAAM,eAAe,aAAa,mBAAmB,SAAS,QAAQ;AAEtE,MAAI,iBAAiB,EACnB;AAGF,OAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,OAAI,cAAc,UAAU,aAC1B;AAEF,kBAAe,QAAQ,OAAO,cAAc;AAC5C,iBAAc,SAAS;;GAEzB;AAEF,iBAAgB;AACd,SAAO,SAAS,2BAA2B;AACzC,QAAK,MAAM,iBAAiB,eAAe,QACzC,eAAc,SAAS;;IAG1B,EAAE,CAAC;AAEN,QAAO;EACL,UAAU;EACV,OAAO,aAAa,mBAAmB,SAAS,OAAO;EACxD"}
+{"version":3,"file":"useUpdatableDisposableState.mjs","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { useHasCommittedRef } from './useHasCommittedRef';\n\nexport const UNASSIGNED_STATE: unique symbol = Symbol();\nexport type UnassignedState = typeof UNASSIGNED_STATE;\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T | UnassignedState;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\n/**\n * ICI stands for ItemCleanupIndex. Use a short name because it shows up a lot.\n *\n * Like an ItemCleanupPair<T>, but with an additional index and as a struct\n * for readability.\n *\n * Interally, we must keep track of the index of the state change. The disposable\n * items that are set in state are not guaranteed to be distinct according to ===,\n * as in `setState([1, dispose1]); setState([1, dispose2])`. Following this, we\n * would expect dispose1 to be called on commit. If state items were compared for\n * ===, then dispose1 would not be called in such a situation.\n *\n * Note that this comes at a runtime cost, and we may want to expose APIs that do\n * not incur this runtime cost, for example in cases where every disposable item is\n * distinguishable via ===.\n */\ntype ICI<T> = { item: T; cleanup: () => void; index: number };\n\n/**\n * useUpdatableDisposableState\n * - Returns a { state, setItem } object.\n * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.\n * - setItem sets the T in state and adds it to a set.\n * - React's behavior is that when the hook commits, whatever item is currently\n *   returned from the useState hook is the oldest item which will ever be returned\n *   from that useState hook. (More newly created ones can later be returned with\n *   concurrent mode.)\n * - When this hook commits, all items up to, but not including, the item currently\n *   returned from the useState hook are disposed and removed from the set.\n *\n * Calling setState before the hook commits:\n * - Calling setState before the hook commits is disallowed because until the hook\n *   commits, React will not schedule any unmount callbacks, meaning that if this\n *   hook never commits, any disposable items passed to setState will never be\n *   disposed.\n * - We also cannot store them in some cache, because multiple components can share\n *   the same cache location (for example, if they are loading the same query from\n *   multiple components), so updating the cache with the disposable item will cause\n *   both components to show the updated data, which is almost certainly a bug.\n * - Note that calling setState before commit is probably an anti-pattern! Consider\n *   not doing it.\n * - If you must, the workaround is to lazily load the disposable item with\n *   useDisposableState or useLazyDisposableState, and update the cache location\n *   instead of calling setState before commit. One can update the cache location\n *   by calling setState on some parent component that has already mounted, and\n *   therefore passing in different props.\n *   - This may only work in concurrent mode, though.\n */\nexport function useUpdatableDisposableState<\n  T = never,\n>(): UseUpdatableDisposableStateReturnValue<T> {\n  const hasCommittedRef = useHasCommittedRef();\n\n  const undisposedICIs = useRef(new Set<ICI<T>>());\n  const setStateCountRef = useRef(0);\n\n  const [stateICI, setStateICI] = useState<ICI<T> | UnassignedState>(\n    UNASSIGNED_STATE,\n  );\n\n  const setStateAfterCommit = useCallback(\n    (itemCleanupPair: ItemCleanupPair<T>) => {\n      if (!hasCommittedRef.current) {\n        throw new Error(\n          'Calling setState before the component has committed is unsafe and disallowed.',\n        );\n      }\n\n      const ici: ICI<T> = {\n        item: itemCleanupPair[0],\n        cleanup: itemCleanupPair[1],\n        index: setStateCountRef.current,\n      };\n      setStateCountRef.current++;\n      undisposedICIs.current.add(ici);\n      setStateICI(ici);\n    },\n    [setStateICI],\n  );\n\n  useEffect(function cleanupUnreachableItems() {\n    const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;\n\n    if (indexInState === 0) {\n      return;\n    }\n\n    for (const undisposedICI of undisposedICIs.current) {\n      if (undisposedICI.index === indexInState) {\n        break;\n      }\n      undisposedICIs.current.delete(undisposedICI);\n      undisposedICI.cleanup();\n    }\n  });\n\n  useEffect(() => {\n    return function disposeAllRemainingItems() {\n      for (const undisposedICI of undisposedICIs.current) {\n        undisposedICIs.current.delete(undisposedICI);\n        undisposedICI.cleanup();\n      }\n      setStateICI(UNASSIGNED_STATE);\n    };\n  }, []);\n\n  return {\n    setState: setStateAfterCommit,\n    state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  const a = useUpdatableDisposableState();\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  const b = useUpdatableDisposableState<string | UnassignedState>();\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;AAIA,MAAa,mBAAkC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDvD,SAAgB,8BAE+B;CAC7C,MAAM,kBAAkB,oBAAoB;CAE5C,MAAM,iBAAiB,uBAAO,IAAI,KAAa,CAAC;CAChD,MAAM,mBAAmB,OAAO,EAAE;CAElC,MAAM,CAAC,UAAU,eAAe,SAC9B,iBACD;CAED,MAAM,sBAAsB,aACzB,oBAAwC;AACvC,MAAI,CAAC,gBAAgB,QACnB,OAAM,IAAI,MACR,gFACD;EAGH,MAAM,MAAc;GAClB,MAAM,gBAAgB;GACtB,SAAS,gBAAgB;GACzB,OAAO,iBAAiB;GACzB;AACD,mBAAiB;AACjB,iBAAe,QAAQ,IAAI,IAAI;AAC/B,cAAY,IAAI;IAElB,CAAC,YAAY,CACd;AAED,WAAU,SAAS,0BAA0B;EAC3C,MAAM,eAAe,aAAa,mBAAmB,SAAS,QAAQ;AAEtE,MAAI,iBAAiB,EACnB;AAGF,OAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,OAAI,cAAc,UAAU,aAC1B;AAEF,kBAAe,QAAQ,OAAO,cAAc;AAC5C,iBAAc,SAAS;;GAEzB;AAEF,iBAAgB;AACd,SAAO,SAAS,2BAA2B;AACzC,QAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,mBAAe,QAAQ,OAAO,cAAc;AAC5C,kBAAc,SAAS;;AAEzB,eAAY,iBAAiB;;IAE9B,EAAE,CAAC;AAEN,QAAO;EACL,UAAU;EACV,OAAO,aAAa,mBAAmB,SAAS,OAAO;EACxD"}