@isograph/react-disposable-state 0.5.1 → 0.5.4

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

@@ -1,11 +1,11 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"22.9.0"} (current: {"node":"v22.21.1","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v22.23.2","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.5.1 compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.5.4 compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsdown
 
-ℹ tsdown v0.15.10 powered by rolldown v1.0.0-beta.44
-ℹ Using tsdown config: /home/runner/work/isograph/isograph/tsdown.config.ts
-(node:2983) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts is not specified and it doesn't parse as CommonJS.
+ℹ tsdown v0.20.1 powered by rolldown v1.0.0-rc.1
+ℹ config file: /home/runner/work/isograph/isograph/tsdown.config.ts 
+(node:2709) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=cb34fd7c-d7fd-4eb6-92b4-94989215fe3c 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

@@ -0,0 +1,5 @@
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v22.23.2","pnpm":"10.15.0"})
+
+> @isograph/react-disposable-state@0.5.4 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/{CacheItem.js → CacheItem.cjs}

@@ -94,14 +94,17 @@ var CacheItem = class {
 				this.__state.temporaryRetainCount++;
 				const clearTemporaryRetainByCallack = () => {
 					if (status === "ClearedByCallback") throw new Error("A temporary retain should only be cleared once. This indicates a bug in react-disposable-state.");
-					else if (status === "Uncleared") switch (this.__state.kind) {
-						case "InParentCacheAndNotDisposed":
-							this.__state.temporaryRetainCount--;
-							this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
-							clearTimeout(timeoutId);
-							return;
-						case "NotInParentCacheAndDisposed":
-						case "NotInParentCacheAndNotDisposed": throw new Error("A temporary retain was cleared, for which the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+					else if (status === "Uncleared") {
+						status = "ClearedByCallback";
+						switch (this.__state.kind) {
+							case "InParentCacheAndNotDisposed":
+								this.__state.temporaryRetainCount--;
+								this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
+								clearTimeout(timeoutId);
+								return;
+							case "NotInParentCacheAndDisposed":
+							case "NotInParentCacheAndNotDisposed": throw new Error("A temporary retain was cleared, for which the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+						}
 					}
 				};
 				const clearTemporaryRetainByTimeout = () => {

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

@@ -60,4 +60,4 @@ declare class CacheItem<T> {
 declare function createTemporarilyRetainedCacheItem<T>(factory: Factory<T>, removeFromParentCache: CleanupFn, options: CacheItemOptions | void): [CacheItem<T>, CleanupFn];
 //#endregion
 export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, createTemporarilyRetainedCacheItem };
-//# sourceMappingURL=CacheItem.d.ts.map
+//# sourceMappingURL=CacheItem.d.cts.map

package/dist/CacheItem.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheItem.d.cts","names":[],"sources":["../src/CacheItem.ts"],"mappings":";;;KAQY,2BAAA;EACV,IAAA;AAAA;AAAA,KAEU,8BAAA;EACV,IAAA;EACA,KAAA,EAAO,CAAA;EACP,YAAA;EAGA,oBAAA;AAAA;AAAA,KAEU,2BAAA;EACV,IAAA;EACA,KAAA,EAAO,CAAA;EACP,YAAA;EACA,qBAAA;EAGA,oBAAA;EAGA,oBAAA;AAAA;AAAA,KAGU,cAAA,MACR,2BAAA,CAA4B,CAAA,IAC5B,8BAAA,CAA+B,CAAA,IAC/B,2BAAA;AAAA,KAEQ,gBAAA;EACV,mBAAA;AAAA;;;;;;;;;;;;;AANF;;;;;;;;;;;;cAoCa,SAAA;EAAA,QACH,OAAA;EAAA,QACA,SAAA;cAQN,OAAA,EAAS,OAAA,CAAQ,CAAA,GACjB,qBAAA,EAAuB,SAAA,EACvB,OAAA,EAAS,gBAAA;EAgBX,QAAA,CAAA,GAAY,CAAA;EAiBZ,4BAAA,CACE,wBAAA,EAA0B,SAAA,GACzB,eAAA,CAAgB,CAAA;EA+EnB,eAAA,CAAA,GAAmB,SAAA;EAsEnB,eAAA,CAAA,GAAmB,SAAA;EAAA,QAqEX,2CAAA;EAAA,QAoBA,8CAAA;AAAA;AAAA,iBAYM,kCAAA,GAAA,CACd,OAAA,EAAS,OAAA,CAAQ,CAAA,GACjB,qBAAA,EAAuB,SAAA,EACvB,OAAA,EAAS,gBAAA,WACP,SAAA,CAAU,CAAA,GAAI,SAAA"}

package/dist/CacheItem.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheItem.d.mts","names":[],"sources":["../src/CacheItem.ts"],"sourcesContent":[],"mappings":";;;KAQY,2BAAA;;AAAZ,CAAA;AAGY,KAAA,8BAA8B,CAAA,CAAA,CAAA,GAAA;EAQ9B,IAAA,EAAA,gCAA2B;EAa3B,KAAA,EAnBH,CAmBG;EACoB,YAAA,EAAA,GAAA,GAAA,IAAA;EAA5B,oBAAA,EAAA,MAAA;CAC+B;AAA/B,KAfQ,2BAeR,CAAA,CAAA,CAAA,GAAA;EACA,IAAA,EAAA,6BAAA;EAA2B,KAAA,EAdtB,CAcsB;EAEnB,YAAA,EAAA,GAAA,GAAgB,IAAA;EA+Bf,qBAAS,EAAA,GAAA,GAAA,IAAA;EAUD,oBAAA,EAAA,MAAA;EAAR,oBAAA,EAAA,MAAA;CACc;AACd,KAhDD,cAgDC,CAAA,CAAA,CAAA,GA/CT,2BA+CS,CA/CmB,CA+CnB,CAAA,GA9CT,8BA8CS,CA9CsB,CA8CtB,CAAA,GA7CT,2BA6CS;AAgBC,KA3DF,gBAAA,GA2DE;EAkBgB,mBAAA,EAAA,MAAA;CACT;;;;;AAyPrB;;;;;;;;;;;;;;;;;;;;cAxSa;;;uBAUA,QAAQ,2BACM,oBACd;cAgBC;yDAkBgB,YACzB,gBAAgB;qBA+EA;qBAqEA;;;;iBAqGL,+CACL,QAAQ,2BACM,oBACd,2BACP,UAAU,IAAI"}
+{"version":3,"file":"CacheItem.d.mts","names":[],"sources":["../src/CacheItem.ts"],"mappings":";;;KAQY,2BAAA;EACV,IAAA;AAAA;AAAA,KAEU,8BAAA;EACV,IAAA;EACA,KAAA,EAAO,CAAA;EACP,YAAA;EAGA,oBAAA;AAAA;AAAA,KAEU,2BAAA;EACV,IAAA;EACA,KAAA,EAAO,CAAA;EACP,YAAA;EACA,qBAAA;EAGA,oBAAA;EAGA,oBAAA;AAAA;AAAA,KAGU,cAAA,MACR,2BAAA,CAA4B,CAAA,IAC5B,8BAAA,CAA+B,CAAA,IAC/B,2BAAA;AAAA,KAEQ,gBAAA;EACV,mBAAA;AAAA;;;;;;;;;;;;;AANF;;;;;;;;;;;;cAoCa,SAAA;EAAA,QACH,OAAA;EAAA,QACA,SAAA;cAQN,OAAA,EAAS,OAAA,CAAQ,CAAA,GACjB,qBAAA,EAAuB,SAAA,EACvB,OAAA,EAAS,gBAAA;EAgBX,QAAA,CAAA,GAAY,CAAA;EAiBZ,4BAAA,CACE,wBAAA,EAA0B,SAAA,GACzB,eAAA,CAAgB,CAAA;EA+EnB,eAAA,CAAA,GAAmB,SAAA;EAsEnB,eAAA,CAAA,GAAmB,SAAA;EAAA,QAqEX,2CAAA;EAAA,QAoBA,8CAAA;AAAA;AAAA,iBAYM,kCAAA,GAAA,CACd,OAAA,EAAS,OAAA,CAAQ,CAAA,GACjB,qBAAA,EAAuB,SAAA,EACvB,OAAA,EAAS,gBAAA,WACP,SAAA,CAAU,CAAA,GAAI,SAAA"}

package/dist/CacheItem.mjs

@@ -93,14 +93,17 @@ var CacheItem = class {
 				this.__state.temporaryRetainCount++;
 				const clearTemporaryRetainByCallack = () => {
 					if (status === "ClearedByCallback") throw new Error("A temporary retain should only be cleared once. This indicates a bug in react-disposable-state.");
-					else if (status === "Uncleared") switch (this.__state.kind) {
-						case "InParentCacheAndNotDisposed":
-							this.__state.temporaryRetainCount--;
-							this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
-							clearTimeout(timeoutId);
-							return;
-						case "NotInParentCacheAndDisposed":
-						case "NotInParentCacheAndNotDisposed": throw new Error("A temporary retain was cleared, for which the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+					else if (status === "Uncleared") {
+						status = "ClearedByCallback";
+						switch (this.__state.kind) {
+							case "InParentCacheAndNotDisposed":
+								this.__state.temporaryRetainCount--;
+								this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
+								clearTimeout(timeoutId);
+								return;
+							case "NotInParentCacheAndDisposed":
+							case "NotInParentCacheAndNotDisposed": throw new Error("A temporary retain was cleared, for which the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+						}
 					}
 				};
 				const clearTemporaryRetainByTimeout = () => {

package/dist/CacheItem.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CacheItem.mjs","names":["status: TemporaryRetainStatus","clearTemporaryRetainByCallack: CleanupFn"],"sources":["../src/CacheItem.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\n\nconst DEFAULT_TEMPORARY_RETAIN_TIME = 5000;\n\nexport type NotInParentCacheAndDisposed = {\n  kind: 'NotInParentCacheAndDisposed';\n};\nexport type NotInParentCacheAndNotDisposed<T> = {\n  kind: 'NotInParentCacheAndNotDisposed';\n  value: T;\n  disposeValue: () => void;\n\n  // Invariant: >0\n  permanentRetainCount: number;\n};\nexport type InParentCacheAndNotDisposed<T> = {\n  kind: 'InParentCacheAndNotDisposed';\n  value: T;\n  disposeValue: () => void;\n  removeFromParentCache: () => void;\n\n  // Invariant: >0\n  temporaryRetainCount: number;\n\n  // Invariant: >= 0\n  permanentRetainCount: number;\n};\n\nexport type CacheItemState<T> =\n  | InParentCacheAndNotDisposed<T>\n  | NotInParentCacheAndNotDisposed<T>\n  | NotInParentCacheAndDisposed;\n\nexport type CacheItemOptions = {\n  temporaryRetainTime: number;\n};\n\n// TODO don't export this class, only export type (interface) instead\n// TODO convert cacheitem impl to a getter and setter and free functions\n\n/**\n * CacheItem:\n *\n * Terminology:\n * - TRC = Temporary Retain Count\n * - PRC = Permanent Retain Count\n *\n * A CacheItem<T> can be in three states:\n *   In parent cache? | Item disposed? | TRC | PRC | Name\n *   -----------------+----------------+-----+-----+-------------------------------\n *   In parent cache  | Not disposed   | >0  | >=0 | InParentCacheAndNotDisposed\n *   Removed          | Not disposed   |  0  |  >0 | NotInParentCacheAndNotDisposed\n *   Removed          | Disposed       |  0  |   0 | NotInParentCacheAndNotDisposed\n *\n * A cache item can only move down rows. As in, if its in the parent cache,\n * it can be removed. It can never be replaced in the parent cache. (If a\n * parent cache becomes full again, it will contain a new CacheItem.) The\n * contained item can be disposed, but never un-disposed.\n *\n * So, the valid transitions are:\n * - InParentCacheAndNotDisposed => NotInParentCacheAndNotDisposed\n * - InParentCacheAndNotDisposed => NotInParentCacheAndDisposed\n * - NotInParentCacheAndNotDisposed => NotInParentCacheAndDisposed\n */\nexport class CacheItem<T> {\n  private __state: CacheItemState<T>;\n  private __options: CacheItemOptions | null;\n\n  // Private. Do not call this constructor directly. Use\n  // createTemporarilyRetainedCacheItem instead. This is because this\n  // constructor creates a CacheItem in an invalid state. It must be\n  // temporarily retained to enter a valid state, and JavaScript doesn't\n  // let you return a tuple from a constructor.\n  constructor(\n    factory: Factory<T>,\n    removeFromParentCache: CleanupFn,\n    options: CacheItemOptions | void,\n  ) {\n    this.__options = options ?? null;\n    const [value, disposeValue] = factory();\n    this.__state = {\n      kind: 'InParentCacheAndNotDisposed',\n      value,\n      disposeValue,\n      removeFromParentCache,\n      // NOTE: we are creating the CacheItem in an invalid state. This is okay, because\n      // we are immediately calling .temporaryRetain.\n      temporaryRetainCount: 0,\n      permanentRetainCount: 0,\n    };\n  }\n\n  getValue(): T {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        return this.__state.value;\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        return this.__state.value;\n      }\n      case 'NotInParentCacheAndDisposed': {\n        throw new Error(\n          'Attempted to access disposed value from CacheItem. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  permanentRetainIfNotDisposed(\n    disposeOfTemporaryRetain: CleanupFn,\n  ): ItemCleanupPair<T> | null {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        disposeOfTemporaryRetain();\n        return [\n          this.__state.value,\n          () => {\n            if (cleared) {\n              throw new Error(\n                'A permanent retain should only be cleared once. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n            cleared = true;\n            switch (this.__state.kind) {\n              case 'InParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n                return;\n              }\n              case 'NotInParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitNotInParentCacheAndNotDisposedState(\n                  this.__state,\n                );\n                return;\n              }\n              case 'NotInParentCacheAndDisposed': {\n                throw new Error(\n                  'CacheItem was in a disposed state, but there existed a permanent retain. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          },\n        ];\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        disposeOfTemporaryRetain();\n        return [\n          this.__state.value,\n          () => {\n            if (cleared) {\n              throw new Error(\n                'A permanent retain should only be cleared once. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n            cleared = true;\n            switch (this.__state.kind) {\n              case 'NotInParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitNotInParentCacheAndNotDisposedState(\n                  this.__state,\n                );\n                return;\n              }\n              case 'InParentCacheAndNotDisposed':\n              case 'NotInParentCacheAndDisposed': {\n                throw new Error(\n                  'CacheItem was in an unexpected state. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          },\n        ];\n      }\n      case 'NotInParentCacheAndDisposed': {\n        // The CacheItem is disposed, so disposeOfTemporaryRetain is a no-op\n        return null;\n      }\n    }\n  }\n\n  temporaryRetain(): CleanupFn {\n    type TemporaryRetainStatus =\n      | 'Uncleared'\n      | 'ClearedByCallback'\n      | 'ClearedByTimeout';\n\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let status: TemporaryRetainStatus = 'Uncleared';\n        this.__state.temporaryRetainCount++;\n        const clearTemporaryRetainByCallack: CleanupFn = () => {\n          if (status === 'ClearedByCallback') {\n            throw new Error(\n              'A temporary retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          } else if (status === 'Uncleared') {\n            switch (this.__state.kind) {\n              case 'InParentCacheAndNotDisposed': {\n                this.__state.temporaryRetainCount--;\n                this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n                clearTimeout(timeoutId);\n                return;\n              }\n              case 'NotInParentCacheAndDisposed':\n              case 'NotInParentCacheAndNotDisposed': {\n                throw new Error(\n                  'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          }\n        };\n\n        const clearTemporaryRetainByTimeout = () => {\n          status = 'ClearedByTimeout';\n          switch (this.__state.kind) {\n            case 'InParentCacheAndNotDisposed': {\n              this.__state.temporaryRetainCount--;\n              this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndDisposed':\n            case 'NotInParentCacheAndNotDisposed': {\n              throw new Error(\n                'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n\n        const timeoutId = setTimeout(\n          clearTemporaryRetainByTimeout,\n          this.__options?.temporaryRetainTime ?? DEFAULT_TEMPORARY_RETAIN_TIME,\n        );\n        return clearTemporaryRetainByCallack;\n      }\n      case 'NotInParentCacheAndDisposed':\n      case 'NotInParentCacheAndNotDisposed': {\n        throw new Error(\n          'temporaryRetain was called, for which the CacheItem is in an invalid state. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  permanentRetain(): CleanupFn {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        return () => {\n          if (cleared) {\n            throw new Error(\n              'A permanent retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          }\n          cleared = true;\n          switch (this.__state.kind) {\n            case 'InParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndDisposed': {\n              throw new Error(\n                'CacheItem was in a disposed state, but there existed a permanent retain. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        return () => {\n          if (cleared) {\n            throw new Error(\n              'A permanent retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          }\n          cleared = true;\n          switch (this.__state.kind) {\n            case 'NotInParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'InParentCacheAndNotDisposed':\n            case 'NotInParentCacheAndDisposed': {\n              throw new Error(\n                'CacheItem was in an unexpected state. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n      }\n      case 'NotInParentCacheAndDisposed': {\n        throw new Error(\n          'permanentRetain was called, but the CacheItem is in an invalid state. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  private __maybeExitInParentCacheAndNotDisposedState(\n    state: InParentCacheAndNotDisposed<T>,\n  ) {\n    if (state.temporaryRetainCount === 0 && state.permanentRetainCount === 0) {\n      state.removeFromParentCache();\n      state.disposeValue();\n      this.__state = {\n        kind: 'NotInParentCacheAndDisposed',\n      };\n    } else if (state.temporaryRetainCount === 0) {\n      state.removeFromParentCache();\n      this.__state = {\n        kind: 'NotInParentCacheAndNotDisposed',\n        value: state.value,\n        disposeValue: state.disposeValue,\n        permanentRetainCount: state.permanentRetainCount,\n      };\n    }\n  }\n\n  private __maybeExitNotInParentCacheAndNotDisposedState(\n    state: NotInParentCacheAndNotDisposed<T>,\n  ) {\n    if (state.permanentRetainCount === 0) {\n      state.disposeValue();\n      this.__state = {\n        kind: 'NotInParentCacheAndDisposed',\n      };\n    }\n  }\n}\n\nexport function createTemporarilyRetainedCacheItem<T>(\n  factory: Factory<T>,\n  removeFromParentCache: CleanupFn,\n  options: CacheItemOptions | void,\n): [CacheItem<T>, CleanupFn] {\n  const cacheItem = new CacheItem(factory, removeFromParentCache, options);\n  const disposeTemporaryRetain = cacheItem.temporaryRetain();\n  return [cacheItem, disposeTemporaryRetain];\n}\n"],"mappings":"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"}
+{"version":3,"file":"CacheItem.mjs","names":[],"sources":["../src/CacheItem.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\n\nconst DEFAULT_TEMPORARY_RETAIN_TIME = 5000;\n\nexport type NotInParentCacheAndDisposed = {\n  kind: 'NotInParentCacheAndDisposed';\n};\nexport type NotInParentCacheAndNotDisposed<T> = {\n  kind: 'NotInParentCacheAndNotDisposed';\n  value: T;\n  disposeValue: () => void;\n\n  // Invariant: >0\n  permanentRetainCount: number;\n};\nexport type InParentCacheAndNotDisposed<T> = {\n  kind: 'InParentCacheAndNotDisposed';\n  value: T;\n  disposeValue: () => void;\n  removeFromParentCache: () => void;\n\n  // Invariant: >0\n  temporaryRetainCount: number;\n\n  // Invariant: >= 0\n  permanentRetainCount: number;\n};\n\nexport type CacheItemState<T> =\n  | InParentCacheAndNotDisposed<T>\n  | NotInParentCacheAndNotDisposed<T>\n  | NotInParentCacheAndDisposed;\n\nexport type CacheItemOptions = {\n  temporaryRetainTime: number;\n};\n\n// TODO don't export this class, only export type (interface) instead\n// TODO convert cacheitem impl to a getter and setter and free functions\n\n/**\n * CacheItem:\n *\n * Terminology:\n * - TRC = Temporary Retain Count\n * - PRC = Permanent Retain Count\n *\n * A CacheItem<T> can be in three states:\n *   In parent cache? | Item disposed? | TRC | PRC | Name\n *   -----------------+----------------+-----+-----+-------------------------------\n *   In parent cache  | Not disposed   | >0  | >=0 | InParentCacheAndNotDisposed\n *   Removed          | Not disposed   |  0  |  >0 | NotInParentCacheAndNotDisposed\n *   Removed          | Disposed       |  0  |   0 | NotInParentCacheAndNotDisposed\n *\n * A cache item can only move down rows. As in, if its in the parent cache,\n * it can be removed. It can never be replaced in the parent cache. (If a\n * parent cache becomes full again, it will contain a new CacheItem.) The\n * contained item can be disposed, but never un-disposed.\n *\n * So, the valid transitions are:\n * - InParentCacheAndNotDisposed => NotInParentCacheAndNotDisposed\n * - InParentCacheAndNotDisposed => NotInParentCacheAndDisposed\n * - NotInParentCacheAndNotDisposed => NotInParentCacheAndDisposed\n */\nexport class CacheItem<T> {\n  private __state: CacheItemState<T>;\n  private __options: CacheItemOptions | null;\n\n  // Private. Do not call this constructor directly. Use\n  // createTemporarilyRetainedCacheItem instead. This is because this\n  // constructor creates a CacheItem in an invalid state. It must be\n  // temporarily retained to enter a valid state, and JavaScript doesn't\n  // let you return a tuple from a constructor.\n  constructor(\n    factory: Factory<T>,\n    removeFromParentCache: CleanupFn,\n    options: CacheItemOptions | void,\n  ) {\n    this.__options = options ?? null;\n    const [value, disposeValue] = factory();\n    this.__state = {\n      kind: 'InParentCacheAndNotDisposed',\n      value,\n      disposeValue,\n      removeFromParentCache,\n      // NOTE: we are creating the CacheItem in an invalid state. This is okay, because\n      // we are immediately calling .temporaryRetain.\n      temporaryRetainCount: 0,\n      permanentRetainCount: 0,\n    };\n  }\n\n  getValue(): T {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        return this.__state.value;\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        return this.__state.value;\n      }\n      case 'NotInParentCacheAndDisposed': {\n        throw new Error(\n          'Attempted to access disposed value from CacheItem. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  permanentRetainIfNotDisposed(\n    disposeOfTemporaryRetain: CleanupFn,\n  ): ItemCleanupPair<T> | null {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        disposeOfTemporaryRetain();\n        return [\n          this.__state.value,\n          () => {\n            if (cleared) {\n              throw new Error(\n                'A permanent retain should only be cleared once. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n            cleared = true;\n            switch (this.__state.kind) {\n              case 'InParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n                return;\n              }\n              case 'NotInParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitNotInParentCacheAndNotDisposedState(\n                  this.__state,\n                );\n                return;\n              }\n              case 'NotInParentCacheAndDisposed': {\n                throw new Error(\n                  'CacheItem was in a disposed state, but there existed a permanent retain. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          },\n        ];\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        disposeOfTemporaryRetain();\n        return [\n          this.__state.value,\n          () => {\n            if (cleared) {\n              throw new Error(\n                'A permanent retain should only be cleared once. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n            cleared = true;\n            switch (this.__state.kind) {\n              case 'NotInParentCacheAndNotDisposed': {\n                this.__state.permanentRetainCount--;\n                this.__maybeExitNotInParentCacheAndNotDisposedState(\n                  this.__state,\n                );\n                return;\n              }\n              case 'InParentCacheAndNotDisposed':\n              case 'NotInParentCacheAndDisposed': {\n                throw new Error(\n                  'CacheItem was in an unexpected state. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          },\n        ];\n      }\n      case 'NotInParentCacheAndDisposed': {\n        // The CacheItem is disposed, so disposeOfTemporaryRetain is a no-op\n        return null;\n      }\n    }\n  }\n\n  temporaryRetain(): CleanupFn {\n    type TemporaryRetainStatus =\n      | 'Uncleared'\n      | 'ClearedByCallback'\n      | 'ClearedByTimeout';\n\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let status: TemporaryRetainStatus = 'Uncleared';\n        this.__state.temporaryRetainCount++;\n        const clearTemporaryRetainByCallack: CleanupFn = () => {\n          if (status === 'ClearedByCallback') {\n            throw new Error(\n              'A temporary retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          } else if (status === 'Uncleared') {\n            status = 'ClearedByCallback';\n            switch (this.__state.kind) {\n              case 'InParentCacheAndNotDisposed': {\n                this.__state.temporaryRetainCount--;\n                this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n                clearTimeout(timeoutId);\n                return;\n              }\n              case 'NotInParentCacheAndDisposed':\n              case 'NotInParentCacheAndNotDisposed': {\n                throw new Error(\n                  'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +\n                    'This indicates a bug in react-disposable-state.',\n                );\n              }\n            }\n          }\n        };\n\n        const clearTemporaryRetainByTimeout = () => {\n          status = 'ClearedByTimeout';\n          switch (this.__state.kind) {\n            case 'InParentCacheAndNotDisposed': {\n              this.__state.temporaryRetainCount--;\n              this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndDisposed':\n            case 'NotInParentCacheAndNotDisposed': {\n              throw new Error(\n                'A temporary retain was cleared, for which the CacheItem is in an invalid state. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n\n        const timeoutId = setTimeout(\n          clearTemporaryRetainByTimeout,\n          this.__options?.temporaryRetainTime ?? DEFAULT_TEMPORARY_RETAIN_TIME,\n        );\n        return clearTemporaryRetainByCallack;\n      }\n      case 'NotInParentCacheAndDisposed':\n      case 'NotInParentCacheAndNotDisposed': {\n        throw new Error(\n          'temporaryRetain was called, for which the CacheItem is in an invalid state. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  permanentRetain(): CleanupFn {\n    switch (this.__state.kind) {\n      case 'InParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        return () => {\n          if (cleared) {\n            throw new Error(\n              'A permanent retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          }\n          cleared = true;\n          switch (this.__state.kind) {\n            case 'InParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'NotInParentCacheAndDisposed': {\n              throw new Error(\n                'CacheItem was in a disposed state, but there existed a permanent retain. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n      }\n      case 'NotInParentCacheAndNotDisposed': {\n        let cleared = false;\n        this.__state.permanentRetainCount++;\n        return () => {\n          if (cleared) {\n            throw new Error(\n              'A permanent retain should only be cleared once. ' +\n                'This indicates a bug in react-disposable-state.',\n            );\n          }\n          cleared = true;\n          switch (this.__state.kind) {\n            case 'NotInParentCacheAndNotDisposed': {\n              this.__state.permanentRetainCount--;\n              this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);\n              return;\n            }\n            case 'InParentCacheAndNotDisposed':\n            case 'NotInParentCacheAndDisposed': {\n              throw new Error(\n                'CacheItem was in an unexpected state. ' +\n                  'This indicates a bug in react-disposable-state.',\n              );\n            }\n          }\n        };\n      }\n      case 'NotInParentCacheAndDisposed': {\n        throw new Error(\n          'permanentRetain was called, but the CacheItem is in an invalid state. ' +\n            'This indicates a bug in react-disposable-state.',\n        );\n      }\n    }\n  }\n\n  private __maybeExitInParentCacheAndNotDisposedState(\n    state: InParentCacheAndNotDisposed<T>,\n  ) {\n    if (state.temporaryRetainCount === 0 && state.permanentRetainCount === 0) {\n      state.removeFromParentCache();\n      state.disposeValue();\n      this.__state = {\n        kind: 'NotInParentCacheAndDisposed',\n      };\n    } else if (state.temporaryRetainCount === 0) {\n      state.removeFromParentCache();\n      this.__state = {\n        kind: 'NotInParentCacheAndNotDisposed',\n        value: state.value,\n        disposeValue: state.disposeValue,\n        permanentRetainCount: state.permanentRetainCount,\n      };\n    }\n  }\n\n  private __maybeExitNotInParentCacheAndNotDisposedState(\n    state: NotInParentCacheAndNotDisposed<T>,\n  ) {\n    if (state.permanentRetainCount === 0) {\n      state.disposeValue();\n      this.__state = {\n        kind: 'NotInParentCacheAndDisposed',\n      };\n    }\n  }\n}\n\nexport function createTemporarilyRetainedCacheItem<T>(\n  factory: Factory<T>,\n  removeFromParentCache: CleanupFn,\n  options: CacheItemOptions | void,\n): [CacheItem<T>, CleanupFn] {\n  const cacheItem = new CacheItem(factory, removeFromParentCache, options);\n  const disposeTemporaryRetain = cacheItem.temporaryRetain();\n  return [cacheItem, disposeTemporaryRetain];\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,4 @@
-const require_CacheItem = require('./CacheItem.js');
+const require_CacheItem = require('./CacheItem.cjs');
 
 //#region src/ParentCache.ts
 /**
@@ -18,9 +18,10 @@ const require_CacheItem = require('./CacheItem.js');
 *   be called
 */
 var ParentCache = class {
-	constructor(factory) {
+	constructor(factory, options) {
 		this.__cacheItem = null;
 		this.__factory = factory;
+		this.__options = options;
 	}
 	/**
 	* This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
@@ -41,7 +42,7 @@ var ParentCache = class {
 	__populateAndTemporaryRetain() {
 		const pair = require_CacheItem.createTemporarilyRetainedCacheItem(this.__factory, () => {
 			if (this.__cacheItem === pair[0]) this.empty();
-		});
+		}, this.__options);
 		const [cacheItem, disposeTemporaryRetain] = pair;
 		this.__cacheItem = cacheItem;
 		return [

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

@@ -1,8 +1,7 @@
-import { CacheItem } from "./CacheItem.js";
+import { CacheItem, CacheItemOptions } from "./CacheItem.cjs";
 import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
 
 //#region src/ParentCache.d.ts
-
 /**
  * ParentCache
  * - A ParentCache can be in two states: populated and unpopulated.
@@ -22,7 +21,8 @@ import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types"
 declare class ParentCache<T> {
   private __cacheItem;
   private readonly __factory;
-  constructor(factory: Factory<T>);
+  private readonly __options;
+  constructor(factory: Factory<T>, options?: CacheItemOptions);
   /**
    * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
    * and a previous temporary retain has been disposed. This can occur in scenarios like:
@@ -42,4 +42,4 @@ declare class ParentCache<T> {
 }
 //#endregion
 export { ParentCache };
-//# sourceMappingURL=ParentCache.d.ts.map
+//# sourceMappingURL=ParentCache.d.cts.map

package/dist/ParentCache.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParentCache.d.cts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;EAAA,iBACA,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA,GAAU,gBAAA;EAJ1B;;;;;;;;;;EAmBjB,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EAgCR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}

package/dist/ParentCache.d.mts

@@ -1,8 +1,7 @@
-import { CacheItem } from "./CacheItem.mjs";
+import { CacheItem, CacheItemOptions } from "./CacheItem.mjs";
 import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
 
 //#region src/ParentCache.d.ts
-
 /**
  * ParentCache
  * - A ParentCache can be in two states: populated and unpopulated.
@@ -22,7 +21,8 @@ import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types"
 declare class ParentCache<T> {
   private __cacheItem;
   private readonly __factory;
-  constructor(factory: Factory<T>);
+  private readonly __options;
+  constructor(factory: Factory<T>, options?: CacheItemOptions);
   /**
    * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
    * and a previous temporary retain has been disposed. This can occur in scenarios like:

package/dist/ParentCache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.d.mts","names":[],"sources":["../src/ParentCache.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;cAAa;;;uBAMU,QAAQ;;;;;;;;;;;oCAcK,gBAAgB;sCAMd,UAAU,IAAI,GAAG;;;iBAsCtC,QAAQ"}
+{"version":3,"file":"ParentCache.d.mts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;EAAA,iBACA,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA,GAAU,gBAAA;EAJ1B;;;;;;;;;;EAmBjB,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EAgCR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}

package/dist/ParentCache.mjs

@@ -18,9 +18,10 @@ import { createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
 *   be called
 */
 var ParentCache = class {
-	constructor(factory) {
+	constructor(factory, options) {
 		this.__cacheItem = null;
 		this.__factory = factory;
+		this.__options = options;
 	}
 	/**
 	* This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
@@ -41,7 +42,7 @@ var ParentCache = class {
 	__populateAndTemporaryRetain() {
 		const pair = createTemporarilyRetainedCacheItem(this.__factory, () => {
 			if (this.__cacheItem === pair[0]) this.empty();
-		});
+		}, this.__options);
 		const [cacheItem, disposeTemporaryRetain] = pair;
 		this.__cacheItem = cacheItem;
 		return [

package/dist/ParentCache.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.mjs","names":["pair: ItemCleanupPair<CacheItem<T>>"],"sources":["../src/ParentCache.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\nimport type { CacheItem } from './CacheItem';\nimport { createTemporarilyRetainedCacheItem } from './CacheItem';\n\n// TODO convert cache impl to a getter and setter and free functions\n// TODO accept options that get passed to CacheItem\n\n/**\n * ParentCache\n * - A ParentCache can be in two states: populated and unpopulated.\n * - A ParentCache holds a CacheItem, which can choose to remove itself from\n *   the parent ParentCache.\n * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be\n *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we\n *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()\n *   and this.__value.permanentRetain() are safe to be called.\n *\n * - Though we do not do so, it is always safe to call parentCache.delete().\n *\n * Invariant:\n * - A parent cache at a given \"location\" (conceptually, an ID) should always\n *   be called\n */\nexport class ParentCache<T> {\n  private __cacheItem: CacheItem<T> | null = null;\n  private readonly __factory: Factory<T>;\n\n  // TODO pass an onEmpty function, which can e.g. remove this ParentCache\n  // from some parent object.\n  constructor(factory: Factory<T>) {\n    this.__factory = factory;\n  }\n\n  /**\n   * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated\n   * and a previous temporary retain has been disposed. This can occur in scenarios like:\n   * - temporary retain A is created by component B rendering\n   * - temporary retain A expires, emptying the parent cache\n   * - another component renders, sharing the same parent cache, filling\n   *   by calling getOrPopulateAndTemporaryRetain\n   * - component B commits. We see that temporary retain A has been disposed,\n   *   and re-check the parent cache by calling this method.\n   */\n  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null {\n    return this.__cacheItem != null\n      ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()]\n      : null;\n  }\n\n  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    return this.__cacheItem == null\n      ? this.__populateAndTemporaryRetain()\n      : temporaryRetain(this.__cacheItem);\n  }\n\n  private __populateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    const pair: ItemCleanupPair<CacheItem<T>> =\n      createTemporarilyRetainedCacheItem(this.__factory, () => {\n        // We are doing this check because we don't want to remove the cache item\n        // if it is not the one that was created when the temporary retain was created.\n        //\n        // Consider the following scenario:\n        // - we populate the cache with CacheItem A,\n        // - then manually delete CacheItem A (e.g. to force a refetch)\n        // - then, we re-populate the parent cache with CacheItem B\n        // - then, the temporary retain of CacheItem A is disposed or expires.\n        //\n        // At this point, we don't want to delete CacheItem B from the cache.\n        //\n        // TODO consider what happens if items are === comparable to each other,\n        // e.g. the item is a number!\n        if (this.__cacheItem === pair[0]) {\n          this.empty();\n        }\n      });\n\n    // We deconstruct this here instead of at the definition site because otherwise,\n    // typescript thinks that cacheItem is any, because it's referenced in the closure.\n    const [cacheItem, disposeTemporaryRetain] = pair;\n    this.__cacheItem = cacheItem;\n    return [cacheItem, cacheItem.getValue(), disposeTemporaryRetain];\n  }\n\n  empty() {\n    this.__cacheItem = null;\n  }\n\n  get factory(): Factory<T> {\n    return this.__factory;\n  }\n\n  isEmpty(): boolean {\n    return this.__cacheItem == null;\n  }\n}\n\nfunction temporaryRetain<T>(value: CacheItem<T>): [CacheItem<T>, T, CleanupFn] {\n  return [value, value.getValue(), value.temporaryRetain()];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA2BA,IAAa,cAAb,MAA4B;CAM1B,YAAY,SAAqB;qBALU;AAMzC,OAAK,YAAY;;;;;;;;;;;;CAanB,iCAA4D;AAC1D,SAAO,KAAK,eAAe,OACvB,CAAC,KAAK,YAAY,UAAU,EAAE,KAAK,YAAY,iBAAiB,CAAC,GACjE;;CAGN,kCAAgE;AAC9D,SAAO,KAAK,eAAe,OACvB,KAAK,8BAA8B,GACnC,gBAAgB,KAAK,YAAY;;CAGvC,AAAQ,+BAA6D;EACnE,MAAMA,OACJ,mCAAmC,KAAK,iBAAiB;AAcvD,OAAI,KAAK,gBAAgB,KAAK,GAC5B,MAAK,OAAO;IAEd;EAIJ,MAAM,CAAC,WAAW,0BAA0B;AAC5C,OAAK,cAAc;AACnB,SAAO;GAAC;GAAW,UAAU,UAAU;GAAE;GAAuB;;CAGlE,QAAQ;AACN,OAAK,cAAc;;CAGrB,IAAI,UAAsB;AACxB,SAAO,KAAK;;CAGd,UAAmB;AACjB,SAAO,KAAK,eAAe;;;AAI/B,SAAS,gBAAmB,OAAmD;AAC7E,QAAO;EAAC;EAAO,MAAM,UAAU;EAAE,MAAM,iBAAiB;EAAC"}
+{"version":3,"file":"ParentCache.mjs","names":[],"sources":["../src/ParentCache.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\nimport type { CacheItem, CacheItemOptions } from './CacheItem';\nimport { createTemporarilyRetainedCacheItem } from './CacheItem';\n\n// TODO convert cache impl to a getter and setter and free functions\n\n/**\n * ParentCache\n * - A ParentCache can be in two states: populated and unpopulated.\n * - A ParentCache holds a CacheItem, which can choose to remove itself from\n *   the parent ParentCache.\n * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be\n *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we\n *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()\n *   and this.__value.permanentRetain() are safe to be called.\n *\n * - Though we do not do so, it is always safe to call parentCache.delete().\n *\n * Invariant:\n * - A parent cache at a given \"location\" (conceptually, an ID) should always\n *   be called\n */\nexport class ParentCache<T> {\n  private __cacheItem: CacheItem<T> | null = null;\n  private readonly __factory: Factory<T>;\n  private readonly __options: CacheItemOptions | void;\n\n  // TODO pass an onEmpty function, which can e.g. remove this ParentCache\n  // from some parent object.\n  constructor(factory: Factory<T>, options?: CacheItemOptions) {\n    this.__factory = factory;\n    this.__options = options;\n  }\n\n  /**\n   * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated\n   * and a previous temporary retain has been disposed. This can occur in scenarios like:\n   * - temporary retain A is created by component B rendering\n   * - temporary retain A expires, emptying the parent cache\n   * - another component renders, sharing the same parent cache, filling\n   *   by calling getOrPopulateAndTemporaryRetain\n   * - component B commits. We see that temporary retain A has been disposed,\n   *   and re-check the parent cache by calling this method.\n   */\n  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null {\n    return this.__cacheItem != null\n      ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()]\n      : null;\n  }\n\n  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    return this.__cacheItem == null\n      ? this.__populateAndTemporaryRetain()\n      : temporaryRetain(this.__cacheItem);\n  }\n\n  private __populateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    const pair: ItemCleanupPair<CacheItem<T>> =\n      createTemporarilyRetainedCacheItem(\n        this.__factory,\n        () => {\n          // We are doing this check because we don't want to remove the cache item\n          // if it is not the one that was created when the temporary retain was created.\n          //\n          // Consider the following scenario:\n          // - we populate the cache with CacheItem A,\n          // - then manually delete CacheItem A (e.g. to force a refetch)\n          // - then, we re-populate the parent cache with CacheItem B\n          // - then, the temporary retain of CacheItem A is disposed or expires.\n          //\n          // At this point, we don't want to delete CacheItem B from the cache.\n          //\n          // TODO consider what happens if items are === comparable to each other,\n          // e.g. the item is a number!\n          if (this.__cacheItem === pair[0]) {\n            this.empty();\n          }\n        },\n        this.__options,\n      );\n\n    // We deconstruct this here instead of at the definition site because otherwise,\n    // typescript thinks that cacheItem is any, because it's referenced in the closure.\n    const [cacheItem, disposeTemporaryRetain] = pair;\n    this.__cacheItem = cacheItem;\n    return [cacheItem, cacheItem.getValue(), disposeTemporaryRetain];\n  }\n\n  empty() {\n    this.__cacheItem = null;\n  }\n\n  get factory(): Factory<T> {\n    return this.__factory;\n  }\n\n  isEmpty(): boolean {\n    return this.__cacheItem == null;\n  }\n}\n\nfunction temporaryRetain<T>(value: CacheItem<T>): [CacheItem<T>, T, CleanupFn] {\n  return [value, value.getValue(), value.temporaryRetain()];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,IAAa,cAAb,MAA4B;CAO1B,YAAY,SAAqB,SAA4B;qBANlB;AAOzC,OAAK,YAAY;AACjB,OAAK,YAAY;;;;;;;;;;;;CAanB,iCAA4D;AAC1D,SAAO,KAAK,eAAe,OACvB,CAAC,KAAK,YAAY,UAAU,EAAE,KAAK,YAAY,iBAAiB,CAAC,GACjE;;CAGN,kCAAgE;AAC9D,SAAO,KAAK,eAAe,OACvB,KAAK,8BAA8B,GACnC,gBAAgB,KAAK,YAAY;;CAGvC,AAAQ,+BAA6D;EACnE,MAAM,OACJ,mCACE,KAAK,iBACC;AAcJ,OAAI,KAAK,gBAAgB,KAAK,GAC5B,MAAK,OAAO;KAGhB,KAAK,UACN;EAIH,MAAM,CAAC,WAAW,0BAA0B;AAC5C,OAAK,cAAc;AACnB,SAAO;GAAC;GAAW,UAAU,UAAU;GAAE;GAAuB;;CAGlE,QAAQ;AACN,OAAK,cAAc;;CAGrB,IAAI,UAAsB;AACxB,SAAO,KAAK;;CAGd,UAAmB;AACjB,SAAO,KAAK,eAAe;;;AAI/B,SAAS,gBAAmB,OAAmD;AAC7E,QAAO;EAAC;EAAO,MAAM,UAAU;EAAE,MAAM,iBAAiB;EAAC"}

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

@@ -1,10 +1,12 @@
-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');
+const require_CacheItem = require('./CacheItem.cjs');
+const require_ParentCache = require('./ParentCache.cjs');
+const require_useEffectsRerunWithoutRender = require('./useEffectsRerunWithoutRender.cjs');
+const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.cjs');
+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;
@@ -12,13 +14,15 @@ exports.UNASSIGNED_STATE = require_useUpdatableDisposableState.UNASSIGNED_STATE;
 exports.createTemporarilyRetainedCacheItem = require_CacheItem.createTemporarilyRetainedCacheItem;
 exports.useCachedResponsivePrecommitValue = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue;
 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) {
+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]; }
+    get: function () { return _isograph_disposable_types[k]; }
   });
 });

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

@@ -1,9 +1,11 @@
-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";
+import { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, createTemporarilyRetainedCacheItem } from "./CacheItem.cjs";
+import { ParentCache } from "./ParentCache.cjs";
+import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.cjs";
+import { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState } from "./useUpdatableDisposableState.cjs";
+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, 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

@@ -3,7 +3,9 @@ import { ParentCache } from "./ParentCache.mjs";
 import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
 import { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
 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, 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

@@ -1,11 +1,13 @@
 import { CacheItem, createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
 import { ParentCache } from "./ParentCache.mjs";
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.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";
+import { useUpdatableDisposableClearableState } from "./useUpdatableDisposableClearableState.mjs";
 
 export * from "@isograph/disposable-types"
 
-export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableClearableState, useUpdatableDisposableState };

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

@@ -1,6 +1,7 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+'use strict';
+
+const require_useEffectsRerunWithoutRender = require('./useEffectsRerunWithoutRender.cjs');
 let react = require("react");
-react = require_rolldown_runtime.__toESM(react);
 
 //#region src/useCachedResponsivePrecommitValue.ts
 /**
@@ -38,16 +39,21 @@ react = require_rolldown_runtime.__toESM(react);
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
 	const [, rerender] = (0, react.useState)(null);
 	const lastCommittedParentCache = (0, react.useRef)(null);
+	const effectsRerunWithoutRenderRef = require_useEffectsRerunWithoutRender.useEffectsRerunWithoutRenderRef();
 	(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({});
+		if (!effectsRerunWithoutRenderRef.current) {
+			const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+			if (undisposedPair != null) {
+				onCommit(undisposedPair);
+				return;
+			}
 		}
+		effectsRerunWithoutRenderRef.current = false;
+		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();

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

@@ -1,8 +1,7 @@
-import { ParentCache } from "./ParentCache.js";
+import { ParentCache } from "./ParentCache.cjs";
 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.
@@ -40,4 +39,4 @@ declare function useCachedResponsivePrecommitValue<T>(parentCache: ParentCache<T
 } | null;
 //#endregion
 export { useCachedResponsivePrecommitValue };
-//# sourceMappingURL=useCachedResponsivePrecommitValue.d.ts.map
+//# sourceMappingURL=useCachedResponsivePrecommitValue.d.cts.map

package/dist/useCachedResponsivePrecommitValue.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.cts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}

package/dist/useCachedResponsivePrecommitValue.d.mts

@@ -2,7 +2,6 @@ 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.

package/dist/useCachedResponsivePrecommitValue.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedResponsivePrecommitValue.d.mts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":[],"mappings":";;;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kDACD,YAAY,qBACR,gBAAgB;SACvB"}
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.mts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}

package/dist/useCachedResponsivePrecommitValue.mjs

@@ -1,3 +1,4 @@
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.mjs";
 import { useEffect, useRef, useState } from "react";
 
 //#region src/useCachedResponsivePrecommitValue.ts
@@ -36,16 +37,21 @@ import { useEffect, useRef, useState } from "react";
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
 	const [, rerender] = useState(null);
 	const lastCommittedParentCache = useRef(null);
+	const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();
 	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({});
+		if (!effectsRerunWithoutRenderRef.current) {
+			const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+			if (undisposedPair != null) {
+				onCommit(undisposedPair);
+				return;
+			}
 		}
+		effectsRerunWithoutRenderRef.current = false;
+		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();

package/dist/useCachedResponsivePrecommitValue.mjs.map

@@ -1 +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"}
+{"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';\nimport { useEffectsRerunWithoutRenderRef } from './useEffectsRerunWithoutRender';\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  const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();\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    //\n    // When this effect runs again without a render (StrictMode's simulated\n    // remount, Fast Refresh, Activity), the render's temporary retain was\n    // already converted by the first run and released by the cleanup, so the\n    // item is re-acquired from the parent cache below instead.\n    if (!effectsRerunWithoutRenderRef.current) {\n      const undisposedPair = cacheItem.permanentRetainIfNotDisposed(\n        disposeOfTemporaryRetain,\n      );\n      if (undisposedPair != null) {\n        onCommit(undisposedPair);\n        return;\n      }\n    }\n    effectsRerunWithoutRenderRef.current = false;\n\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  }, [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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,kCACd,aACA,UACqB;CAOrB,MAAM,GAAG,YAAY,SAAoB,KAAK;CAC9C,MAAM,2BAA2B,OAA8B,KAAK;CAEpE,MAAM,+BAA+B,iCAAiC;AAEtE,iBAAgB;AACd,2BAAyB,UAAU;AAsBnC,MAAI,CAAC,6BAA6B,SAAS;GACzC,MAAM,iBAAiB,UAAU,6BAC/B,yBACD;AACD,OAAI,kBAAkB,MAAM;AAC1B,aAAS,eAAe;AACxB;;;AAGJ,+BAA6B,UAAU;EAIvC,MAAM,+BACJ,YAAY,gCAAgC;AAC9C,MAAI,gCAAgC,KAClC,UAAS,6BAA6B;MAGtC,UAAS,YAAY,SAAS,CAAC;AAMjC,WAAS,EAAE,CAAC;IACX,CAAC,YAAY,CAAC;AAEjB,KAAI,yBAAyB,YAAY,YACvC,QAAO;CAKT,MAAM,CAAC,WAAW,MAAM,4BACtB,YAAY,iCAAiC;AAE/C,QAAO,EAAE,OAAO,MAAM"}