@isograph/react-disposable-state 0.4.3 → 0.5.1

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export * from '@isograph/disposable-types';
-export * from './CacheItem';
-export * from './ParentCache';
-export * from './useCachedResponsivePrecommitValue';
-export * from './useDisposableState';
-export * from './useHasCommittedRef';
-export * from './useLazyDisposableState';
-export * from './useUpdatableDisposableState';
-//# sourceMappingURL=index.d.ts.map
+import { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, createTemporarilyRetainedCacheItem } from "./CacheItem.js";
+import { ParentCache } from "./ParentCache.js";
+import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.js";
+import { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState } from "./useUpdatableDisposableState.js";
+import { useDisposableState } from "./useDisposableState.js";
+import { useHasCommittedRef } from "./useHasCommittedRef.js";
+import { useLazyDisposableState } from "./useLazyDisposableState.js";
+export * from "@isograph/disposable-types";
+export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };

package/dist/index.js

@@ -1,24 +1,24 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@isograph/disposable-types"), exports);
-__exportStar(require("./CacheItem"), exports);
-__exportStar(require("./ParentCache"), exports);
-__exportStar(require("./useCachedResponsivePrecommitValue"), exports);
-__exportStar(require("./useDisposableState"), exports);
-__exportStar(require("./useHasCommittedRef"), exports);
-__exportStar(require("./useLazyDisposableState"), exports);
-__exportStar(require("./useUpdatableDisposableState"), exports);
+const require_CacheItem = require('./CacheItem.js');
+const require_ParentCache = require('./ParentCache.js');
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.js');
+const require_useHasCommittedRef = require('./useHasCommittedRef.js');
+const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.js');
+const require_useDisposableState = require('./useDisposableState.js');
+const require_useLazyDisposableState = require('./useLazyDisposableState.js');
+
+exports.CacheItem = require_CacheItem.CacheItem;
+exports.ParentCache = require_ParentCache.ParentCache;
+exports.UNASSIGNED_STATE = require_useUpdatableDisposableState.UNASSIGNED_STATE;
+exports.createTemporarilyRetainedCacheItem = require_CacheItem.createTemporarilyRetainedCacheItem;
+exports.useCachedResponsivePrecommitValue = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue;
+exports.useDisposableState = require_useDisposableState.useDisposableState;
+exports.useHasCommittedRef = require_useHasCommittedRef.useHasCommittedRef;
+exports.useLazyDisposableState = require_useLazyDisposableState.useLazyDisposableState;
+exports.useUpdatableDisposableState = require_useUpdatableDisposableState.useUpdatableDisposableState;
+var __isograph_disposable_types = require("@isograph/disposable-types");
+Object.keys(__isograph_disposable_types).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __isograph_disposable_types[k]; }
+  });
+});

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { CacheItem, createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
+import { ParentCache } from "./ParentCache.mjs";
+import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
+import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
+import { UNASSIGNED_STATE, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
+import { useDisposableState } from "./useDisposableState.mjs";
+import { useLazyDisposableState } from "./useLazyDisposableState.mjs";
+
+export * from "@isograph/disposable-types"
+
+export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };

package/dist/useCachedResponsivePrecommitValue.d.mts

@@ -0,0 +1,43 @@
+import { ParentCache } from "./ParentCache.mjs";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useCachedResponsivePrecommitValue.d.ts
+
+/**
+ * useCachedResponsivePrecommitValue<T>
+ * - Takes a mutable parent cache, a factory function, and an onCommit callback.
+ * - Returns T before commit after every parent cache change, and null afterward.
+ * - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.
+ * - The T from the render phase is only temporarily retained. It may have been
+ *   disposed by the time of the commit. If so, this hook checks the parent cache
+ *   for another T or creates one, and passes this T to onCommit.
+ * - If the T returned during the last render is not the same as the one that
+ *   is passed to onCommit, during the commit phase, it will schedule another render.
+ *
+ * Invariant: the returned T has not been disposed during the tick of the render.
+ * The T passed to the onCommit callback has not been disposed when the onCommit
+ * callback is called.
+ *
+ * Passing a different parentCache:
+ * - Pre-commit, passing a different parentCache has the effect of "resetting" this
+ *   hook's state to the new cache's state. For example, if you have a cache associated
+ *   with a set of variables (e.g. {name: "Matthew"}), and pass in another cache
+ *   (e.g. associated with {name: "James"}), which is empty, the hook will fill that
+ *   new cache with the factory function.
+ * - Post-commit, passing a different parentCache will reset hook to the pre-commit
+ *   state. The cache will return T before commit, then fill the new cache with the
+ *   factory function and return null afterwards.
+ *
+ * Passing a different factory:
+ * - Passing a different factory has no effect, except when factory is called,
+ *   which is when the parent cache is being filled, or during commit.
+ *
+ * Passing a different onCommit:
+ * - Passing a different onCommit has no effect, except for during commit.
+ */
+declare function useCachedResponsivePrecommitValue<T>(parentCache: ParentCache<T>, onCommit: (pair: ItemCleanupPair<T>) => void): {
+  state: T;
+} | null;
+//#endregion
+export { useCachedResponsivePrecommitValue };
+//# sourceMappingURL=useCachedResponsivePrecommitValue.d.mts.map

package/dist/useCachedResponsivePrecommitValue.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.mts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kDACD,YAAY,qBACR,gBAAgB;SACvB"}

package/dist/useCachedResponsivePrecommitValue.d.ts

@@ -1,5 +1,8 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
-import { ParentCache } from './ParentCache';
+import { ParentCache } from "./ParentCache.js";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useCachedResponsivePrecommitValue.d.ts
+
 /**
  * useCachedResponsivePrecommitValue<T>
  * - Takes a mutable parent cache, a factory function, and an onCommit callback.
@@ -32,7 +35,9 @@ import { ParentCache } from './ParentCache';
  * Passing a different onCommit:
  * - Passing a different onCommit has no effect, except for during commit.
  */
-export declare function useCachedResponsivePrecommitValue<T>(parentCache: ParentCache<T>, onCommit: (pair: ItemCleanupPair<T>) => void): {
-    state: T;
+declare function useCachedResponsivePrecommitValue<T>(parentCache: ParentCache<T>, onCommit: (pair: ItemCleanupPair<T>) => void): {
+  state: T;
 } | null;
+//#endregion
+export { useCachedResponsivePrecommitValue };
 //# sourceMappingURL=useCachedResponsivePrecommitValue.d.ts.map

package/dist/useCachedResponsivePrecommitValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedResponsivePrecommitValue.d.ts","sourceRoot":"","sources":["../src/useCachedResponsivePrecommitValue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iCAAiC,CAAC,CAAC,EACjD,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,GAC3C;IAAE,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,IAAI,CA8DrB"}
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.ts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kDACD,YAAY,qBACR,gBAAgB;SACvB"}

package/dist/useCachedResponsivePrecommitValue.js

@@ -1,93 +1,58 @@
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCachedResponsivePrecommitValue = useCachedResponsivePrecommitValue;
-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/useCachedResponsivePrecommitValue.ts
 /**
- * useCachedResponsivePrecommitValue<T>
- * - Takes a mutable parent cache, a factory function, and an onCommit callback.
- * - Returns T before commit after every parent cache change, and null afterward.
- * - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.
- * - The T from the render phase is only temporarily retained. It may have been
- *   disposed by the time of the commit. If so, this hook checks the parent cache
- *   for another T or creates one, and passes this T to onCommit.
- * - If the T returned during the last render is not the same as the one that
- *   is passed to onCommit, during the commit phase, it will schedule another render.
- *
- * Invariant: the returned T has not been disposed during the tick of the render.
- * The T passed to the onCommit callback has not been disposed when the onCommit
- * callback is called.
- *
- * Passing a different parentCache:
- * - Pre-commit, passing a different parentCache has the effect of "resetting" this
- *   hook's state to the new cache's state. For example, if you have a cache associated
- *   with a set of variables (e.g. {name: "Matthew"}), and pass in another cache
- *   (e.g. associated with {name: "James"}), which is empty, the hook will fill that
- *   new cache with the factory function.
- * - Post-commit, passing a different parentCache will reset hook to the pre-commit
- *   state. The cache will return T before commit, then fill the new cache with the
- *   factory function and return null afterwards.
- *
- * Passing a different factory:
- * - Passing a different factory has no effect, except when factory is called,
- *   which is when the parent cache is being filled, or during commit.
- *
- * Passing a different onCommit:
- * - Passing a different onCommit has no effect, except for during commit.
- */
+* useCachedResponsivePrecommitValue<T>
+* - Takes a mutable parent cache, a factory function, and an onCommit callback.
+* - Returns T before commit after every parent cache change, and null afterward.
+* - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.
+* - The T from the render phase is only temporarily retained. It may have been
+*   disposed by the time of the commit. If so, this hook checks the parent cache
+*   for another T or creates one, and passes this T to onCommit.
+* - If the T returned during the last render is not the same as the one that
+*   is passed to onCommit, during the commit phase, it will schedule another render.
+*
+* Invariant: the returned T has not been disposed during the tick of the render.
+* The T passed to the onCommit callback has not been disposed when the onCommit
+* callback is called.
+*
+* Passing a different parentCache:
+* - Pre-commit, passing a different parentCache has the effect of "resetting" this
+*   hook's state to the new cache's state. For example, if you have a cache associated
+*   with a set of variables (e.g. {name: "Matthew"}), and pass in another cache
+*   (e.g. associated with {name: "James"}), which is empty, the hook will fill that
+*   new cache with the factory function.
+* - Post-commit, passing a different parentCache will reset hook to the pre-commit
+*   state. The cache will return T before commit, then fill the new cache with the
+*   factory function and return null afterwards.
+*
+* Passing a different factory:
+* - Passing a different factory has no effect, except when factory is called,
+*   which is when the parent cache is being filled, or during commit.
+*
+* Passing a different onCommit:
+* - Passing a different onCommit has no effect, except for during commit.
+*/
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
-    // TODO: there should be two APIs. One in which we always re-render if the
-    // committed item was not returned during the last render, and one in which
-    // we do not. The latter is useful for cases where every disposable item
-    // behaves identically, but must be loaded.
-    //
-    // This hook is the former, i.e. re-renders if the committed item has changed.
-    const [, rerender] = (0, react_1.useState)(null);
-    const lastCommittedParentCache = (0, react_1.useRef)(null);
-    (0, react_1.useEffect)(() => {
-        lastCommittedParentCache.current = parentCache;
-        // On commit, cacheItem may be disposed, because during the render phase,
-        // we only temporarily retained the item, and the temporary retain could have
-        // expired by the time of the commit.
-        //
-        // So, we can be in one of two states:
-        // - the item is not disposed. In that case, permanently retain and use that item.
-        // - the item is disposed. In that case, we can be in two states:
-        //   - the parent cache is not empty (due to another component rendering, or
-        //     another render of the same component.) In that case, permanently retain and
-        //     use the item from the parent cache. (Note: any item present in the parent
-        //     cache is not disposed.)
-        //   - the parent cache is empty. In that case, call factory, getting a new item
-        //     and a cleanup function.
-        //
-        // After the above, we have a non-disposed item and a cleanup function, which we
-        // can pass to onCommit.
-        const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
-        if (undisposedPair !== null) {
-            onCommit(undisposedPair);
-        }
-        else {
-            // The cache item we created during render has been disposed. Check if the parent
-            // cache is populated.
-            const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
-            if (existingCacheItemCleanupPair !== null) {
-                onCommit(existingCacheItemCleanupPair);
-            }
-            else {
-                // We did not find an item in the parent cache, create a new one.
-                onCommit(parentCache.factory());
-            }
-            // TODO: Consider whether we always want to rerender if the committed item
-            // was not returned during the last render, or whether some callers will
-            // prefer opting out of this behavior (e.g. if every disposable item behaves
-            // identically, but must be loaded.)
-            rerender({});
-        }
-    }, [parentCache]);
-    if (lastCommittedParentCache.current === parentCache) {
-        return null;
-    }
-    // Safety: item is only safe to use (i.e. guaranteed not to have been disposed)
-    // during this tick.
-    const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();
-    return { state: item };
+	const [, rerender] = (0, react.useState)(null);
+	const lastCommittedParentCache = (0, react.useRef)(null);
+	(0, react.useEffect)(() => {
+		lastCommittedParentCache.current = parentCache;
+		const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+		if (undisposedPair != null) onCommit(undisposedPair);
+		else {
+			const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
+			if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
+			else onCommit(parentCache.factory());
+			rerender({});
+		}
+	}, [parentCache]);
+	if (lastCommittedParentCache.current === parentCache) return null;
+	const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();
+	return { state: item };
 }
+
+//#endregion
+exports.useCachedResponsivePrecommitValue = useCachedResponsivePrecommitValue;

package/dist/useCachedResponsivePrecommitValue.mjs

@@ -0,0 +1,57 @@
+import { useEffect, useRef, useState } from "react";
+
+//#region src/useCachedResponsivePrecommitValue.ts
+/**
+* useCachedResponsivePrecommitValue<T>
+* - Takes a mutable parent cache, a factory function, and an onCommit callback.
+* - Returns T before commit after every parent cache change, and null afterward.
+* - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.
+* - The T from the render phase is only temporarily retained. It may have been
+*   disposed by the time of the commit. If so, this hook checks the parent cache
+*   for another T or creates one, and passes this T to onCommit.
+* - If the T returned during the last render is not the same as the one that
+*   is passed to onCommit, during the commit phase, it will schedule another render.
+*
+* Invariant: the returned T has not been disposed during the tick of the render.
+* The T passed to the onCommit callback has not been disposed when the onCommit
+* callback is called.
+*
+* Passing a different parentCache:
+* - Pre-commit, passing a different parentCache has the effect of "resetting" this
+*   hook's state to the new cache's state. For example, if you have a cache associated
+*   with a set of variables (e.g. {name: "Matthew"}), and pass in another cache
+*   (e.g. associated with {name: "James"}), which is empty, the hook will fill that
+*   new cache with the factory function.
+* - Post-commit, passing a different parentCache will reset hook to the pre-commit
+*   state. The cache will return T before commit, then fill the new cache with the
+*   factory function and return null afterwards.
+*
+* Passing a different factory:
+* - Passing a different factory has no effect, except when factory is called,
+*   which is when the parent cache is being filled, or during commit.
+*
+* Passing a different onCommit:
+* - Passing a different onCommit has no effect, except for during commit.
+*/
+function useCachedResponsivePrecommitValue(parentCache, onCommit) {
+	const [, rerender] = useState(null);
+	const lastCommittedParentCache = useRef(null);
+	useEffect(() => {
+		lastCommittedParentCache.current = parentCache;
+		const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+		if (undisposedPair != null) onCommit(undisposedPair);
+		else {
+			const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
+			if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
+			else onCommit(parentCache.factory());
+			rerender({});
+		}
+	}, [parentCache]);
+	if (lastCommittedParentCache.current === parentCache) return null;
+	const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();
+	return { state: item };
+}
+
+//#endregion
+export { useCachedResponsivePrecommitValue };
+//# sourceMappingURL=useCachedResponsivePrecommitValue.mjs.map

package/dist/useCachedResponsivePrecommitValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCachedResponsivePrecommitValue.mjs","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef, useState } from 'react';\nimport type { ParentCache } from './ParentCache';\n\n/**\n * useCachedResponsivePrecommitValue<T>\n * - Takes a mutable parent cache, a factory function, and an onCommit callback.\n * - Returns T before commit after every parent cache change, and null afterward.\n * - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.\n * - The T from the render phase is only temporarily retained. It may have been\n *   disposed by the time of the commit. If so, this hook checks the parent cache\n *   for another T or creates one, and passes this T to onCommit.\n * - If the T returned during the last render is not the same as the one that\n *   is passed to onCommit, during the commit phase, it will schedule another render.\n *\n * Invariant: the returned T has not been disposed during the tick of the render.\n * The T passed to the onCommit callback has not been disposed when the onCommit\n * callback is called.\n *\n * Passing a different parentCache:\n * - Pre-commit, passing a different parentCache has the effect of \"resetting\" this\n *   hook's state to the new cache's state. For example, if you have a cache associated\n *   with a set of variables (e.g. {name: \"Matthew\"}), and pass in another cache\n *   (e.g. associated with {name: \"James\"}), which is empty, the hook will fill that\n *   new cache with the factory function.\n * - Post-commit, passing a different parentCache will reset hook to the pre-commit\n *   state. The cache will return T before commit, then fill the new cache with the\n *   factory function and return null afterwards.\n *\n * Passing a different factory:\n * - Passing a different factory has no effect, except when factory is called,\n *   which is when the parent cache is being filled, or during commit.\n *\n * Passing a different onCommit:\n * - Passing a different onCommit has no effect, except for during commit.\n */\nexport function useCachedResponsivePrecommitValue<T>(\n  parentCache: ParentCache<T>,\n  onCommit: (pair: ItemCleanupPair<T>) => void,\n): { state: T } | null {\n  // TODO: there should be two APIs. One in which we always re-render if the\n  // committed item was not returned during the last render, and one in which\n  // we do not. The latter is useful for cases where every disposable item\n  // behaves identically, but must be loaded.\n  //\n  // This hook is the former, i.e. re-renders if the committed item has changed.\n  const [, rerender] = useState<{} | null>(null);\n  const lastCommittedParentCache = useRef<ParentCache<T> | null>(null);\n\n  useEffect(() => {\n    lastCommittedParentCache.current = parentCache;\n    // On commit, cacheItem may be disposed, because during the render phase,\n    // we only temporarily retained the item, and the temporary retain could have\n    // expired by the time of the commit.\n    //\n    // So, we can be in one of two states:\n    // - the item is not disposed. In that case, permanently retain and use that item.\n    // - the item is disposed. In that case, we can be in two states:\n    //   - the parent cache is not empty (due to another component rendering, or\n    //     another render of the same component.) In that case, permanently retain and\n    //     use the item from the parent cache. (Note: any item present in the parent\n    //     cache is not disposed.)\n    //   - the parent cache is empty. In that case, call factory, getting a new item\n    //     and a cleanup function.\n    //\n    // After the above, we have a non-disposed item and a cleanup function, which we\n    // can pass to onCommit.\n    const undisposedPair = cacheItem.permanentRetainIfNotDisposed(\n      disposeOfTemporaryRetain,\n    );\n    if (undisposedPair != null) {\n      onCommit(undisposedPair);\n    } else {\n      // The cache item we created during render has been disposed. Check if the parent\n      // cache is populated.\n      const existingCacheItemCleanupPair =\n        parentCache.getAndPermanentRetainIfPresent();\n      if (existingCacheItemCleanupPair != null) {\n        onCommit(existingCacheItemCleanupPair);\n      } else {\n        // We did not find an item in the parent cache, create a new one.\n        onCommit(parentCache.factory());\n      }\n      // TODO: Consider whether we always want to rerender if the committed item\n      // was not returned during the last render, or whether some callers will\n      // prefer opting out of this behavior (e.g. if every disposable item behaves\n      // identically, but must be loaded.)\n      rerender({});\n    }\n  }, [parentCache]);\n\n  if (lastCommittedParentCache.current === parentCache) {\n    return null;\n  }\n\n  // Safety: item is only safe to use (i.e. guaranteed not to have been disposed)\n  // during this tick.\n  const [cacheItem, item, disposeOfTemporaryRetain] =\n    parentCache.getOrPopulateAndTemporaryRetain();\n\n  return { state: item };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,kCACd,aACA,UACqB;CAOrB,MAAM,GAAG,YAAY,SAAoB,KAAK;CAC9C,MAAM,2BAA2B,OAA8B,KAAK;AAEpE,iBAAgB;AACd,2BAAyB,UAAU;EAiBnC,MAAM,iBAAiB,UAAU,6BAC/B,yBACD;AACD,MAAI,kBAAkB,KACpB,UAAS,eAAe;OACnB;GAGL,MAAM,+BACJ,YAAY,gCAAgC;AAC9C,OAAI,gCAAgC,KAClC,UAAS,6BAA6B;OAGtC,UAAS,YAAY,SAAS,CAAC;AAMjC,YAAS,EAAE,CAAC;;IAEb,CAAC,YAAY,CAAC;AAEjB,KAAI,yBAAyB,YAAY,YACvC,QAAO;CAKT,MAAM,CAAC,WAAW,MAAM,4BACtB,YAAY,iCAAiC;AAE/C,QAAO,EAAE,OAAO,MAAM"}

package/dist/useDisposableState.d.mts

@@ -0,0 +1,13 @@
+import { ParentCache } from "./ParentCache.mjs";
+import { UnassignedState } from "./useUpdatableDisposableState.mjs";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/useDisposableState.d.ts
+type UseUpdatableDisposableStateReturnValue<T> = {
+  state: T;
+  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;
+};
+declare function useDisposableState<T = never>(parentCache: ParentCache<T>): UseUpdatableDisposableStateReturnValue<T>;
+//#endregion
+export { useDisposableState };
+//# sourceMappingURL=useDisposableState.d.mts.map

package/dist/useDisposableState.d.mts.map

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

package/dist/useDisposableState.d.ts

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

package/dist/useDisposableState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDisposableState.d.ts","sourceRoot":"","sources":["../src/useDisposableState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAEL,eAAe,EAEhB,MAAM,+BAA+B,CAAC;AAEvC,KAAK,sCAAsC,CAAC,CAAC,IAAI;IAC/C,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,CAAC,IAAI,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,KAAK,IAAI,CAAC;CACxE,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,KAAK,EAC1C,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAC1B,sCAAsC,CAAC,CAAC,CAAC,CAgE3C"}
+{"version":3,"file":"useDisposableState.d.ts","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"}

package/dist/useDisposableState.js

@@ -1,71 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useDisposableState = useDisposableState;
-const react_1 = require("react");
-const useCachedResponsivePrecommitValue_1 = require("./useCachedResponsivePrecommitValue");
-const useUpdatableDisposableState_1 = require("./useUpdatableDisposableState");
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.js');
+const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/useDisposableState.ts
 function useDisposableState(parentCache) {
-    var _a, _b, _c;
-    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;
-    });
-    const { state: stateFromDisposableStateHook, setState } = (0, useUpdatableDisposableState_1.useUpdatableDisposableState)();
-    (0, react_1.useEffect)(function cleanupItemCleanupPairRefAfterSetState() {
-        if (stateFromDisposableStateHook !== useUpdatableDisposableState_1.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.');
-            }
-        }
-    }, [stateFromDisposableStateHook]);
-    (0, react_1.useEffect)(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
-        return () => {
-            if (itemCleanupPairRef.current !== null) {
-                itemCleanupPairRef.current[1]();
-                itemCleanupPairRef.current = null;
-            }
-        };
-    }, []);
-    // Safety: we can be in one of three states. Pre-commit, in which case
-    // preCommitItem is assigned, post-commit but before setState has been
-    // called, in which case itemCleanupPairRef.current is assigned, or
-    // after setState has been called, in which case
-    // stateFromDisposableStateHook is assigned.
-    //
-    // Therefore, the type of state is T, not T | undefined. But the fact
-    // that we are in one of the three states is not reflected in the types.
-    // So we have to cast to T.
-    //
-    // Note that in the post-commit post-setState state, itemCleanupPairRef
-    // can still be assigned, during the render before the
-    // cleanupItemCleanupPairRefAfterSetState effect is called.
-    const state = (_b = (_a = (stateFromDisposableStateHook != useUpdatableDisposableState_1.UNASSIGNED_STATE
-        ? stateFromDisposableStateHook
-        : null)) !== null && _a !== void 0 ? _a : preCommitItem === null || preCommitItem === void 0 ? void 0 : preCommitItem.state) !== null && _b !== void 0 ? _b : (_c = itemCleanupPairRef.current) === null || _c === void 0 ? void 0 : _c[0];
-    return {
-        state: state,
-        setState,
-    };
-}
-// @ts-ignore
-function tsTests() {
-    let x;
-    const a = useDisposableState(x);
-    // This should be a compiler error, because the generic is inferred to be of
-    // type never. TODO determine why this doesn't break the build!
-    // @ts-expect-error
-    a.setState(['asdf', () => { }]);
-    // @ts-expect-error
-    a.setState([useUpdatableDisposableState_1.UNASSIGNED_STATE, () => { }]);
-    const b = useDisposableState(x);
-    // @ts-expect-error
-    b.setState([useUpdatableDisposableState_1.UNASSIGNED_STATE, () => { }]);
-    b.setState(['asdf', () => { }]);
+	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.");
+	}, [stateFromDisposableStateHook]);
+	(0, react.useEffect)(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
+		return () => {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		};
+	}, []);
+	const state = (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
+	if (state != null) return {
+		state,
+		setState
+	};
+	throw new Error("state was unexpectedly null. This indicates a bug in react-disposable-state.");
 }
+
+//#endregion
+exports.useDisposableState = useDisposableState;

package/dist/useDisposableState.mjs

@@ -0,0 +1,37 @@
+import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
+import { UNASSIGNED_STATE, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
+import { useEffect, useRef } from "react";
+
+//#region src/useDisposableState.ts
+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.");
+	}, [stateFromDisposableStateHook]);
+	useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
+		return () => {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		};
+	}, []);
+	const state = (stateFromDisposableStateHook !== UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
+	if (state != null) return {
+		state,
+		setState
+	};
+	throw new Error("state was unexpectedly null. This indicates a bug in react-disposable-state.");
+}
+
+//#endregion
+export { useDisposableState };
+//# sourceMappingURL=useDisposableState.mjs.map

package/dist/useDisposableState.mjs.map

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

package/dist/useHasCommittedRef.d.mts

@@ -0,0 +1,11 @@
+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.mts.map

package/dist/useHasCommittedRef.d.mts.map

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