@isograph/react-disposable-state 0.0.0-main-1ba744d7 → 0.0.0-main-082842ca

package/.turbo/turbo-compile-libs.log

@@ -1,11 +1,11 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.21.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-1ba744d7 compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-082842ca compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsdown
 
 ℹ tsdown v0.20.1 powered by rolldown v1.0.0-rc.1
 ℹ config file: /home/runner/work/isograph/isograph/tsdown.config.ts 
-(node:2646) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=c042b2e9-7e41-49bd-a93d-2e3cc4113e4d is not specified and it doesn't parse as CommonJS.
+(node:2571) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=d49a3978-e0e9-45c9-8009-cf6a5d84baaf is not specified and it doesn't parse as CommonJS.
 Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
 To eliminate this warning, add "type": "module" to /home/runner/work/isograph/isograph/package.json.
 (Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-tsc.log

@@ -1,5 +1,5 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.21.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-1ba744d7 tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-082842ca tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsc
 

package/README.md

@@ -110,6 +110,25 @@ const {
 } = useUpdatableDisposableState<T>(options);
 ```
 
+### `useUpdatableDisposableClearableState`
+
+`useUpdatableDisposableState` with a third member, `clearState`:
+
+- `clearState` returns the state to `UNASSIGNED_STATE`. The item that was in state is disposed on the next commit, exactly as if `setState` had superseded it.
+- `clearState` throws if called before the initial commit, as `setState` does.
+
+```typescript
+const {
+  state,
+  setState,
+  clearState,
+}: {
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<T>) => void;
+  clearState: () => void;
+} = useUpdatableDisposableClearableState<T>();
+```
+
 ### `useDisposableState`
 
 > This could properly be called `useLazyUpdatableDisposableState`, but that's quite long!

package/dist/index.cjs

@@ -6,6 +6,7 @@ const require_useHasCommittedRef = require('./useHasCommittedRef.cjs');
 const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.cjs');
 const require_useDisposableState = require('./useDisposableState.cjs');
 const require_useLazyDisposableState = require('./useLazyDisposableState.cjs');
+const require_useUpdatableDisposableClearableState = require('./useUpdatableDisposableClearableState.cjs');
 
 exports.CacheItem = require_CacheItem.CacheItem;
 exports.ParentCache = require_ParentCache.ParentCache;
@@ -16,6 +17,7 @@ exports.useDisposableState = require_useDisposableState.useDisposableState;
 exports.useEffectsRerunWithoutRenderRef = require_useEffectsRerunWithoutRender.useEffectsRerunWithoutRenderRef;
 exports.useHasCommittedRef = require_useHasCommittedRef.useHasCommittedRef;
 exports.useLazyDisposableState = require_useLazyDisposableState.useLazyDisposableState;
+exports.useUpdatableDisposableClearableState = require_useUpdatableDisposableClearableState.useUpdatableDisposableClearableState;
 exports.useUpdatableDisposableState = require_useUpdatableDisposableState.useUpdatableDisposableState;
 var _isograph_disposable_types = require("@isograph/disposable-types");
 Object.keys(_isograph_disposable_types).forEach(function (k) {

package/dist/index.d.cts

@@ -6,5 +6,6 @@ import { useDisposableState } from "./useDisposableState.cjs";
 import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.cjs";
 import { useHasCommittedRef } from "./useHasCommittedRef.cjs";
 import { useLazyDisposableState } from "./useLazyDisposableState.cjs";
+import { useUpdatableDisposableClearableState } from "./useUpdatableDisposableClearableState.cjs";
 export * from "@isograph/disposable-types";
-export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableClearableState, useUpdatableDisposableState };

package/dist/index.d.mts

@@ -6,5 +6,6 @@ import { useDisposableState } from "./useDisposableState.mjs";
 import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.mjs";
 import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
 import { useLazyDisposableState } from "./useLazyDisposableState.mjs";
+import { useUpdatableDisposableClearableState } from "./useUpdatableDisposableClearableState.mjs";
 export * from "@isograph/disposable-types";
-export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableClearableState, useUpdatableDisposableState };

package/dist/index.mjs

@@ -6,7 +6,8 @@ import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
 import { UNASSIGNED_STATE, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
 import { useDisposableState } from "./useDisposableState.mjs";
 import { useLazyDisposableState } from "./useLazyDisposableState.mjs";
+import { useUpdatableDisposableClearableState } from "./useUpdatableDisposableClearableState.mjs";
 
 export * from "@isograph/disposable-types"
 
-export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableClearableState, useUpdatableDisposableState };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.0.0-main-1ba744d7",
+  "version": "0.0.0-main-082842ca",
   "description": "Primitives for managing disposable state in React",
   "homepage": "https://isograph.dev",
   "main": "./dist/index.cjs",
@@ -8,7 +8,7 @@
   "author": "Isograph Labs",
   "license": "MIT",
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-1ba744d7"
+    "@isograph/disposable-types": "0.0.0-main-082842ca"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/index.ts

@@ -7,4 +7,5 @@ export * from './useDisposableState';
 export * from './useEffectsRerunWithoutRender';
 export * from './useHasCommittedRef';
 export * from './useLazyDisposableState';
+export * from './useUpdatableDisposableClearableState';
 export * from './useUpdatableDisposableState';

package/src/useUpdatableDisposableClearableState.ts

@@ -0,0 +1,67 @@
+import type { ItemCleanupPair } from '@isograph/disposable-types';
+import { useCallback } from 'react';
+import {
+  UNASSIGNED_STATE,
+  type UnassignedState,
+  useUpdatableDisposableState,
+} from './useUpdatableDisposableState';
+
+type UseUpdatableDisposableClearableStateReturnValue<T> = {
+  state: T | UnassignedState;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+  clearState: () => void;
+};
+
+/**
+ * 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: unique symbol = Symbol();
+type ClearedState = typeof CLEARED_STATE;
+
+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.
+ */
+export function useUpdatableDisposableClearableState<
+  T = never,
+>(): UseUpdatableDisposableClearableStateReturnValue<T> {
+  const { state, setState } = useUpdatableDisposableState<T | ClearedState>();
+
+  const clearState = useCallback(() => {
+    setState([CLEARED_STATE, noop]);
+  }, [setState]);
+
+  return {
+    clearState,
+    setState,
+    state: state === CLEARED_STATE ? UNASSIGNED_STATE : state,
+  };
+}
+
+// @ts-ignore
+function tsTests() {
+  const a = useUpdatableDisposableClearableState();
+  // @ts-expect-error
+  a.setState([UNASSIGNED_STATE, () => {}]);
+  // @ts-expect-error
+  a.setState(['asdf', () => {}]);
+  const b = useUpdatableDisposableClearableState<string | UnassignedState>();
+  // @ts-expect-error
+  b.setState([UNASSIGNED_STATE, () => {}]);
+  b.setState(['asdf', () => {}]);
+  // The cleared sentinel is not part of T, so it cannot be set from outside.
+  // @ts-expect-error
+  b.setState([CLEARED_STATE, () => {}]);
+}