@isograph/react-disposable-state 0.5.0 → 0.5.1

package/dist/useHasCommittedRef.d.ts

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

package/dist/useHasCommittedRef.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useHasCommittedRef.d.ts","sourceRoot":"","sources":["../src/useHasCommittedRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAqB,MAAM,OAAO,CAAC;AAE5D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,gBAAgB,CAAC,OAAO,CAAC,CAM9D"}
+{"version":3,"file":"useHasCommittedRef.d.ts","names":[],"sources":["../src/useHasCommittedRef.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;iBAAgB,kBAAA,CAAA,GAAsB"}

package/dist/useHasCommittedRef.js

@@ -1,14 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHasCommittedRef = useHasCommittedRef;
-const react_1 = require("react");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/useHasCommittedRef.ts
 /**
- * Returns true if the component has committed, false otherwise.
- */
+* Returns true if the component has committed, false otherwise.
+*/
 function useHasCommittedRef() {
-    const hasCommittedRef = (0, react_1.useRef)(false);
-    (0, react_1.useEffect)(() => {
-        hasCommittedRef.current = true;
-    }, []);
-    return hasCommittedRef;
+	const hasCommittedRef = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		hasCommittedRef.current = true;
+	}, []);
+	return hasCommittedRef;
 }
+
+//#endregion
+exports.useHasCommittedRef = useHasCommittedRef;

package/dist/useHasCommittedRef.mjs

@@ -0,0 +1,17 @@
+import { useEffect, useRef } from "react";
+
+//#region src/useHasCommittedRef.ts
+/**
+* Returns true if the component has committed, false otherwise.
+*/
+function useHasCommittedRef() {
+	const hasCommittedRef = useRef(false);
+	useEffect(() => {
+		hasCommittedRef.current = true;
+	}, []);
+	return hasCommittedRef;
+}
+
+//#endregion
+export { useHasCommittedRef };
+//# sourceMappingURL=useHasCommittedRef.mjs.map

package/dist/useHasCommittedRef.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHasCommittedRef.mjs","names":[],"sources":["../src/useHasCommittedRef.ts"],"sourcesContent":["import { type MutableRefObject, useEffect, useRef } from 'react';\n\n/**\n * Returns true if the component has committed, false otherwise.\n */\nexport function useHasCommittedRef(): MutableRefObject<boolean> {\n  const hasCommittedRef = useRef(false);\n  useEffect(() => {\n    hasCommittedRef.current = true;\n  }, []);\n  return hasCommittedRef;\n}\n"],"mappings":";;;;;;AAKA,SAAgB,qBAAgD;CAC9D,MAAM,kBAAkB,OAAO,MAAM;AACrC,iBAAgB;AACd,kBAAgB,UAAU;IACzB,EAAE,CAAC;AACN,QAAO"}

package/dist/useLazyDisposableState.d.mts

@@ -0,0 +1,20 @@
+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
+ * - Returns { state: T }
+ *
+ * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then
+ * (on commit) sets it in state. The item continues to be returned after
+ * commit and is disposed when the hook unmounts.
+ */
+declare function useLazyDisposableState<T>(parentCache: ParentCache<Exclude<T, UnassignedState>>): {
+  state: T;
+};
+//#endregion
+export { useLazyDisposableState };
+//# sourceMappingURL=useLazyDisposableState.d.mts.map

package/dist/useLazyDisposableState.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyDisposableState.d.mts","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;iBAAgB,uCACD,YAAY,QAAQ,GAAG;SAE7B"}

package/dist/useLazyDisposableState.d.ts

@@ -1,5 +1,8 @@
-import { ParentCache } from './ParentCache';
-import { type UnassignedState } from './useUpdatableDisposableState';
+import { ParentCache } from "./ParentCache.js";
+import { UnassignedState } from "./useUpdatableDisposableState.js";
+
+//#region src/useLazyDisposableState.d.ts
+
 /**
  * useLazyDisposableState<T>
  * - Takes a mutable parent cache and a factory function
@@ -9,7 +12,9 @@ import { type UnassignedState } from './useUpdatableDisposableState';
  * (on commit) sets it in state. The item continues to be returned after
  * commit and is disposed when the hook unmounts.
  */
-export declare function useLazyDisposableState<T>(parentCache: ParentCache<Exclude<T, UnassignedState>>): {
-    state: T;
+declare function useLazyDisposableState<T>(parentCache: ParentCache<Exclude<T, UnassignedState>>): {
+  state: T;
 };
+//#endregion
+export { useLazyDisposableState };
 //# sourceMappingURL=useLazyDisposableState.d.ts.map

package/dist/useLazyDisposableState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyDisposableState.d.ts","sourceRoot":"","sources":["../src/useLazyDisposableState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,GACpD;IACD,KAAK,EAAE,CAAC,CAAC;CACV,CAoCA"}
+{"version":3,"file":"useLazyDisposableState.d.ts","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":[],"mappings":";;;;;;;AAiBA;;;;;;;iBAAgB,uCACD,YAAY,QAAQ,GAAG;SAE7B"}

package/dist/useLazyDisposableState.js

@@ -1,42 +1,35 @@
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLazyDisposableState = useLazyDisposableState;
-const react_1 = require("react");
-const useCachedResponsivePrecommitValue_1 = require("./useCachedResponsivePrecommitValue");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/useLazyDisposableState.ts
 /**
- * useLazyDisposableState<T>
- * - Takes a mutable parent cache and a factory function
- * - Returns { state: T }
- *
- * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then
- * (on commit) sets it in state. The item continues to be returned after
- * commit and is disposed when the hook unmounts.
- */
+* useLazyDisposableState<T>
+* - Takes a mutable parent cache and a factory function
+* - Returns { state: T }
+*
+* This lazily loads the disposable item using useCachedResponsivePrecommitValue, then
+* (on commit) sets it in state. The item continues to be returned after
+* commit and is disposed when the hook unmounts.
+*/
 function useLazyDisposableState(parentCache) {
-    var _a, _b;
-    const itemCleanupPairRef = (0, react_1.useRef)(null);
-    const preCommitItem = (0, useCachedResponsivePrecommitValue_1.useCachedResponsivePrecommitValue)(parentCache, (pair) => {
-        var _a;
-        (_a = itemCleanupPairRef.current) === null || _a === void 0 ? void 0 : _a[1]();
-        itemCleanupPairRef.current = pair;
-    });
-    (0, react_1.useEffect)(() => {
-        return () => {
-            var _a;
-            const cleanupFn = (_a = itemCleanupPairRef.current) === null || _a === void 0 ? void 0 : _a[1];
-            // TODO confirm useEffect is called in order.
-            if (cleanupFn == null) {
-                throw new Error('cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.');
-            }
-            return cleanupFn();
-        };
-    }, []);
-    const returnedItem = (_a = preCommitItem === null || preCommitItem === void 0 ? void 0 : preCommitItem.state) !== null && _a !== void 0 ? _a : (_b = itemCleanupPairRef.current) === null || _b === void 0 ? void 0 : _b[0];
-    if (returnedItem != null) {
-        return { state: returnedItem };
-    }
-    // Safety: This can't happen. For renders before the initial commit, preCommitItem
-    // is non-null. During the initial commit, we assign itemCleanupPairRef.current,
-    // so during subsequent renders, itemCleanupPairRef.current is non-null.
-    throw new Error('returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.');
+	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();
+		};
+	}, []);
+	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.");
 }
+
+//#endregion
+exports.useLazyDisposableState = useLazyDisposableState;

package/dist/useLazyDisposableState.mjs

@@ -0,0 +1,34 @@
+import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
+import { useEffect, useRef } from "react";
+
+//#region src/useLazyDisposableState.ts
+/**
+* useLazyDisposableState<T>
+* - Takes a mutable parent cache and a factory function
+* - Returns { state: T }
+*
+* This lazily loads the disposable item using useCachedResponsivePrecommitValue, then
+* (on commit) sets it in state. The item continues to be returned after
+* commit and is disposed when the hook unmounts.
+*/
+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();
+		};
+	}, []);
+	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.");
+}
+
+//#endregion
+export { useLazyDisposableState };
+//# sourceMappingURL=useLazyDisposableState.mjs.map

package/dist/useLazyDisposableState.mjs.map

@@ -0,0 +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"}

package/dist/useUpdatableDisposableState.d.mts

@@ -0,0 +1,43 @@
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useUpdatableDisposableState.d.ts
+declare const UNASSIGNED_STATE: unique symbol;
+type UnassignedState = typeof UNASSIGNED_STATE;
+type UseUpdatableDisposableStateReturnValue<T> = {
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+};
+/**
+ * useUpdatableDisposableState
+ * - Returns a { state, setItem } object.
+ * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.
+ * - setItem sets the T in state and adds it to a set.
+ * - React's behavior is that when the hook commits, whatever item is currently
+ *   returned from the useState hook is the oldest item which will ever be returned
+ *   from that useState hook. (More newly created ones can later be returned with
+ *   concurrent mode.)
+ * - When this hook commits, all items up to, but not including, the item currently
+ *   returned from the useState hook are disposed and removed from the set.
+ *
+ * Calling setState before the hook commits:
+ * - Calling setState before the hook commits is disallowed because until the hook
+ *   commits, React will not schedule any unmount callbacks, meaning that if this
+ *   hook never commits, any disposable items passed to setState will never be
+ *   disposed.
+ * - We also cannot store them in some cache, because multiple components can share
+ *   the same cache location (for example, if they are loading the same query from
+ *   multiple components), so updating the cache with the disposable item will cause
+ *   both components to show the updated data, which is almost certainly a bug.
+ * - Note that calling setState before commit is probably an anti-pattern! Consider
+ *   not doing it.
+ * - If you must, the workaround is to lazily load the disposable item with
+ *   useDisposableState or useLazyDisposableState, and update the cache location
+ *   instead of calling setState before commit. One can update the cache location
+ *   by calling setState on some parent component that has already mounted, and
+ *   therefore passing in different props.
+ *   - This may only work in concurrent mode, though.
+ */
+declare function useUpdatableDisposableState<T = never>(): UseUpdatableDisposableStateReturnValue<T>;
+//#endregion
+export { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState };
+//# sourceMappingURL=useUpdatableDisposableState.d.mts.map

package/dist/useUpdatableDisposableState.d.mts.map

@@ -0,0 +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"}

package/dist/useUpdatableDisposableState.d.ts

@@ -1,9 +1,11 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
-export declare const UNASSIGNED_STATE: unique symbol;
-export type UnassignedState = typeof UNASSIGNED_STATE;
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useUpdatableDisposableState.d.ts
+declare const UNASSIGNED_STATE: unique symbol;
+type UnassignedState = typeof UNASSIGNED_STATE;
 type UseUpdatableDisposableStateReturnValue<T> = {
-    state: T | UnassignedState;
-    setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
 };
 /**
  * useUpdatableDisposableState
@@ -35,6 +37,7 @@ type UseUpdatableDisposableStateReturnValue<T> = {
  *   therefore passing in different props.
  *   - This may only work in concurrent mode, though.
  */
-export declare function useUpdatableDisposableState<T = never>(): UseUpdatableDisposableStateReturnValue<T>;
-export {};
+declare function useUpdatableDisposableState<T = never>(): UseUpdatableDisposableStateReturnValue<T>;
+//#endregion
+export { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState };
 //# sourceMappingURL=useUpdatableDisposableState.d.ts.map

package/dist/useUpdatableDisposableState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdatableDisposableState.d.ts","sourceRoot":"","sources":["../src/useUpdatableDisposableState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAI7D,eAAO,MAAM,gBAAgB,EAAE,OAAO,MAAiB,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC;AAEtD,KAAK,sCAAsC,CAAC,CAAC,IAAI;IAC/C,KAAK,EAAE,CAAC,GAAG,eAAe,CAAC;IAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,IAAI,CAAC;CACxE,CAAC;AAoBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,2BAA2B,CACzC,CAAC,GAAG,KAAK,KACN,sCAAsC,CAAC,CAAC,CAAC,CA0D7C"}
+{"version":3,"file":"useUpdatableDisposableState.d.ts","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"}

package/dist/useUpdatableDisposableState.js

@@ -1,92 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UNASSIGNED_STATE = void 0;
-exports.useUpdatableDisposableState = useUpdatableDisposableState;
-const react_1 = require("react");
-const useHasCommittedRef_1 = require("./useHasCommittedRef");
-exports.UNASSIGNED_STATE = Symbol();
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_useHasCommittedRef = require('./useHasCommittedRef.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/useUpdatableDisposableState.ts
+const UNASSIGNED_STATE = Symbol();
 /**
- * useUpdatableDisposableState
- * - Returns a { state, setItem } object.
- * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.
- * - setItem sets the T in state and adds it to a set.
- * - React's behavior is that when the hook commits, whatever item is currently
- *   returned from the useState hook is the oldest item which will ever be returned
- *   from that useState hook. (More newly created ones can later be returned with
- *   concurrent mode.)
- * - When this hook commits, all items up to, but not including, the item currently
- *   returned from the useState hook are disposed and removed from the set.
- *
- * Calling setState before the hook commits:
- * - Calling setState before the hook commits is disallowed because until the hook
- *   commits, React will not schedule any unmount callbacks, meaning that if this
- *   hook never commits, any disposable items passed to setState will never be
- *   disposed.
- * - We also cannot store them in some cache, because multiple components can share
- *   the same cache location (for example, if they are loading the same query from
- *   multiple components), so updating the cache with the disposable item will cause
- *   both components to show the updated data, which is almost certainly a bug.
- * - Note that calling setState before commit is probably an anti-pattern! Consider
- *   not doing it.
- * - If you must, the workaround is to lazily load the disposable item with
- *   useDisposableState or useLazyDisposableState, and update the cache location
- *   instead of calling setState before commit. One can update the cache location
- *   by calling setState on some parent component that has already mounted, and
- *   therefore passing in different props.
- *   - This may only work in concurrent mode, though.
- */
+* useUpdatableDisposableState
+* - Returns a { state, setItem } object.
+* - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.
+* - setItem sets the T in state and adds it to a set.
+* - React's behavior is that when the hook commits, whatever item is currently
+*   returned from the useState hook is the oldest item which will ever be returned
+*   from that useState hook. (More newly created ones can later be returned with
+*   concurrent mode.)
+* - When this hook commits, all items up to, but not including, the item currently
+*   returned from the useState hook are disposed and removed from the set.
+*
+* Calling setState before the hook commits:
+* - Calling setState before the hook commits is disallowed because until the hook
+*   commits, React will not schedule any unmount callbacks, meaning that if this
+*   hook never commits, any disposable items passed to setState will never be
+*   disposed.
+* - We also cannot store them in some cache, because multiple components can share
+*   the same cache location (for example, if they are loading the same query from
+*   multiple components), so updating the cache with the disposable item will cause
+*   both components to show the updated data, which is almost certainly a bug.
+* - Note that calling setState before commit is probably an anti-pattern! Consider
+*   not doing it.
+* - If you must, the workaround is to lazily load the disposable item with
+*   useDisposableState or useLazyDisposableState, and update the cache location
+*   instead of calling setState before commit. One can update the cache location
+*   by calling setState on some parent component that has already mounted, and
+*   therefore passing in different props.
+*   - This may only work in concurrent mode, though.
+*/
 function useUpdatableDisposableState() {
-    const hasCommittedRef = (0, useHasCommittedRef_1.useHasCommittedRef)();
-    const undisposedICIs = (0, react_1.useRef)(new Set());
-    const setStateCountRef = (0, react_1.useRef)(0);
-    const [stateICI, setStateICI] = (0, react_1.useState)(exports.UNASSIGNED_STATE);
-    const setStateAfterCommit = (0, react_1.useCallback)((itemCleanupPair) => {
-        if (!hasCommittedRef.current) {
-            throw new Error('Calling setState before the component has committed is unsafe and disallowed.');
-        }
-        const ici = {
-            item: itemCleanupPair[0],
-            cleanup: itemCleanupPair[1],
-            index: setStateCountRef.current,
-        };
-        setStateCountRef.current++;
-        undisposedICIs.current.add(ici);
-        setStateICI(ici);
-    }, [setStateICI]);
-    (0, react_1.useEffect)(function cleanupUnreachableItems() {
-        const indexInState = stateICI !== exports.UNASSIGNED_STATE ? stateICI.index : 0;
-        if (indexInState === 0) {
-            return;
-        }
-        for (const undisposedICI of undisposedICIs.current) {
-            if (undisposedICI.index === indexInState) {
-                break;
-            }
-            undisposedICIs.current.delete(undisposedICI);
-            undisposedICI.cleanup();
-        }
-    });
-    (0, react_1.useEffect)(() => {
-        return function disposeAllRemainingItems() {
-            for (const undisposedICI of undisposedICIs.current) {
-                undisposedICI.cleanup();
-            }
-        };
-    }, []);
-    return {
-        setState: setStateAfterCommit,
-        state: stateICI !== exports.UNASSIGNED_STATE ? stateICI.item : exports.UNASSIGNED_STATE,
-    };
-}
-// @ts-ignore
-function tsTests() {
-    const a = useUpdatableDisposableState();
-    // @ts-expect-error
-    a.setState([exports.UNASSIGNED_STATE, () => { }]);
-    // @ts-expect-error
-    a.setState(['asdf', () => { }]);
-    const b = useUpdatableDisposableState();
-    // @ts-expect-error
-    b.setState([exports.UNASSIGNED_STATE, () => { }]);
-    b.setState(['asdf', () => { }]);
+	const hasCommittedRef = require_useHasCommittedRef.useHasCommittedRef();
+	const undisposedICIs = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const setStateCountRef = (0, react.useRef)(0);
+	const [stateICI, setStateICI] = (0, react.useState)(UNASSIGNED_STATE);
+	const setStateAfterCommit = (0, react.useCallback)((itemCleanupPair) => {
+		if (!hasCommittedRef.current) throw new Error("Calling setState before the component has committed is unsafe and disallowed.");
+		const ici = {
+			item: itemCleanupPair[0],
+			cleanup: itemCleanupPair[1],
+			index: setStateCountRef.current
+		};
+		setStateCountRef.current++;
+		undisposedICIs.current.add(ici);
+		setStateICI(ici);
+	}, [setStateICI]);
+	(0, react.useEffect)(function cleanupUnreachableItems() {
+		const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;
+		if (indexInState === 0) return;
+		for (const undisposedICI of undisposedICIs.current) {
+			if (undisposedICI.index === indexInState) break;
+			undisposedICIs.current.delete(undisposedICI);
+			undisposedICI.cleanup();
+		}
+	});
+	(0, react.useEffect)(() => {
+		return function disposeAllRemainingItems() {
+			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+		};
+	}, []);
+	return {
+		setState: setStateAfterCommit,
+		state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE
+	};
 }
+
+//#endregion
+exports.UNASSIGNED_STATE = UNASSIGNED_STATE;
+exports.useUpdatableDisposableState = useUpdatableDisposableState;

package/dist/useUpdatableDisposableState.mjs

@@ -0,0 +1,74 @@
+import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
+import { useCallback, useEffect, useRef, useState } from "react";
+
+//#region src/useUpdatableDisposableState.ts
+const UNASSIGNED_STATE = Symbol();
+/**
+* useUpdatableDisposableState
+* - Returns a { state, setItem } object.
+* - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.
+* - setItem sets the T in state and adds it to a set.
+* - React's behavior is that when the hook commits, whatever item is currently
+*   returned from the useState hook is the oldest item which will ever be returned
+*   from that useState hook. (More newly created ones can later be returned with
+*   concurrent mode.)
+* - When this hook commits, all items up to, but not including, the item currently
+*   returned from the useState hook are disposed and removed from the set.
+*
+* Calling setState before the hook commits:
+* - Calling setState before the hook commits is disallowed because until the hook
+*   commits, React will not schedule any unmount callbacks, meaning that if this
+*   hook never commits, any disposable items passed to setState will never be
+*   disposed.
+* - We also cannot store them in some cache, because multiple components can share
+*   the same cache location (for example, if they are loading the same query from
+*   multiple components), so updating the cache with the disposable item will cause
+*   both components to show the updated data, which is almost certainly a bug.
+* - Note that calling setState before commit is probably an anti-pattern! Consider
+*   not doing it.
+* - If you must, the workaround is to lazily load the disposable item with
+*   useDisposableState or useLazyDisposableState, and update the cache location
+*   instead of calling setState before commit. One can update the cache location
+*   by calling setState on some parent component that has already mounted, and
+*   therefore passing in different props.
+*   - This may only work in concurrent mode, though.
+*/
+function useUpdatableDisposableState() {
+	const hasCommittedRef = useHasCommittedRef();
+	const undisposedICIs = useRef(/* @__PURE__ */ new Set());
+	const setStateCountRef = useRef(0);
+	const [stateICI, setStateICI] = useState(UNASSIGNED_STATE);
+	const setStateAfterCommit = useCallback((itemCleanupPair) => {
+		if (!hasCommittedRef.current) throw new Error("Calling setState before the component has committed is unsafe and disallowed.");
+		const ici = {
+			item: itemCleanupPair[0],
+			cleanup: itemCleanupPair[1],
+			index: setStateCountRef.current
+		};
+		setStateCountRef.current++;
+		undisposedICIs.current.add(ici);
+		setStateICI(ici);
+	}, [setStateICI]);
+	useEffect(function cleanupUnreachableItems() {
+		const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;
+		if (indexInState === 0) return;
+		for (const undisposedICI of undisposedICIs.current) {
+			if (undisposedICI.index === indexInState) break;
+			undisposedICIs.current.delete(undisposedICI);
+			undisposedICI.cleanup();
+		}
+	});
+	useEffect(() => {
+		return function disposeAllRemainingItems() {
+			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+		};
+	}, []);
+	return {
+		setState: setStateAfterCommit,
+		state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE
+	};
+}
+
+//#endregion
+export { UNASSIGNED_STATE, useUpdatableDisposableState };
+//# sourceMappingURL=useUpdatableDisposableState.mjs.map

package/dist/useUpdatableDisposableState.mjs.map

@@ -0,0 +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"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Primitives for managing disposable state in React",
   "homepage": "https://isograph.dev",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "author": "Isograph Labs",
   "license": "MIT",
   "dependencies": {
-    "@isograph/disposable-types": "0.5.0"
+    "@isograph/disposable-types": "0.5.1"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
@@ -24,9 +24,17 @@
     "directory": "libs/isograph-react-disposable-state"
   },
   "sideEffects": false,
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
-    "compile-libs": "rimraf dist && tsc -p tsconfig.pkg.json",
-    "compile-watch": "tsc -p tsconfig.pkg.json --watch",
+    "compile-libs": "tsdown",
+    "watch-libs": "tsdown --watch",
     "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",