@isograph/react-disposable-state 0.5.0 → 0.5.1

package/dist/CacheItem.mjs

@@ -0,0 +1,193 @@
+//#region src/CacheItem.ts
+const DEFAULT_TEMPORARY_RETAIN_TIME = 5e3;
+/**
+* CacheItem:
+*
+* Terminology:
+* - TRC = Temporary Retain Count
+* - PRC = Permanent Retain Count
+*
+* A CacheItem<T> can be in three states:
+*   In parent cache? | Item disposed? | TRC | PRC | Name
+*   -----------------+----------------+-----+-----+-------------------------------
+*   In parent cache  | Not disposed   | >0  | >=0 | InParentCacheAndNotDisposed
+*   Removed          | Not disposed   |  0  |  >0 | NotInParentCacheAndNotDisposed
+*   Removed          | Disposed       |  0  |   0 | NotInParentCacheAndNotDisposed
+*
+* A cache item can only move down rows. As in, if its in the parent cache,
+* it can be removed. It can never be replaced in the parent cache. (If a
+* parent cache becomes full again, it will contain a new CacheItem.) The
+* contained item can be disposed, but never un-disposed.
+*
+* So, the valid transitions are:
+* - InParentCacheAndNotDisposed => NotInParentCacheAndNotDisposed
+* - InParentCacheAndNotDisposed => NotInParentCacheAndDisposed
+* - NotInParentCacheAndNotDisposed => NotInParentCacheAndDisposed
+*/
+var CacheItem = class {
+	constructor(factory, removeFromParentCache, options) {
+		this.__options = options ?? null;
+		const [value, disposeValue] = factory();
+		this.__state = {
+			kind: "InParentCacheAndNotDisposed",
+			value,
+			disposeValue,
+			removeFromParentCache,
+			temporaryRetainCount: 0,
+			permanentRetainCount: 0
+		};
+	}
+	getValue() {
+		switch (this.__state.kind) {
+			case "InParentCacheAndNotDisposed": return this.__state.value;
+			case "NotInParentCacheAndNotDisposed": return this.__state.value;
+			case "NotInParentCacheAndDisposed": throw new Error("Attempted to access disposed value from CacheItem. This indicates a bug in react-disposable-state.");
+		}
+	}
+	permanentRetainIfNotDisposed(disposeOfTemporaryRetain) {
+		switch (this.__state.kind) {
+			case "InParentCacheAndNotDisposed": {
+				let cleared = false;
+				this.__state.permanentRetainCount++;
+				disposeOfTemporaryRetain();
+				return [this.__state.value, () => {
+					if (cleared) throw new Error("A permanent retain should only be cleared once. This indicates a bug in react-disposable-state.");
+					cleared = true;
+					switch (this.__state.kind) {
+						case "InParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "NotInParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "NotInParentCacheAndDisposed": throw new Error("CacheItem was in a disposed state, but there existed a permanent retain. This indicates a bug in react-disposable-state.");
+					}
+				}];
+			}
+			case "NotInParentCacheAndNotDisposed": {
+				let cleared = false;
+				this.__state.permanentRetainCount++;
+				disposeOfTemporaryRetain();
+				return [this.__state.value, () => {
+					if (cleared) throw new Error("A permanent retain should only be cleared once. This indicates a bug in react-disposable-state.");
+					cleared = true;
+					switch (this.__state.kind) {
+						case "NotInParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "InParentCacheAndNotDisposed":
+						case "NotInParentCacheAndDisposed": throw new Error("CacheItem was in an unexpected state. This indicates a bug in react-disposable-state.");
+					}
+				}];
+			}
+			case "NotInParentCacheAndDisposed": return null;
+		}
+	}
+	temporaryRetain() {
+		switch (this.__state.kind) {
+			case "InParentCacheAndNotDisposed": {
+				let status = "Uncleared";
+				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.");
+					}
+				};
+				const clearTemporaryRetainByTimeout = () => {
+					status = "ClearedByTimeout";
+					switch (this.__state.kind) {
+						case "InParentCacheAndNotDisposed":
+							this.__state.temporaryRetainCount--;
+							this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
+							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 timeoutId = setTimeout(clearTemporaryRetainByTimeout, this.__options?.temporaryRetainTime ?? DEFAULT_TEMPORARY_RETAIN_TIME);
+				return clearTemporaryRetainByCallack;
+			}
+			case "NotInParentCacheAndDisposed":
+			case "NotInParentCacheAndNotDisposed": throw new Error("temporaryRetain was called, for which the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+		}
+	}
+	permanentRetain() {
+		switch (this.__state.kind) {
+			case "InParentCacheAndNotDisposed": {
+				let cleared = false;
+				this.__state.permanentRetainCount++;
+				return () => {
+					if (cleared) throw new Error("A permanent retain should only be cleared once. This indicates a bug in react-disposable-state.");
+					cleared = true;
+					switch (this.__state.kind) {
+						case "InParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "NotInParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "NotInParentCacheAndDisposed": throw new Error("CacheItem was in a disposed state, but there existed a permanent retain. This indicates a bug in react-disposable-state.");
+					}
+				};
+			}
+			case "NotInParentCacheAndNotDisposed": {
+				let cleared = false;
+				this.__state.permanentRetainCount++;
+				return () => {
+					if (cleared) throw new Error("A permanent retain should only be cleared once. This indicates a bug in react-disposable-state.");
+					cleared = true;
+					switch (this.__state.kind) {
+						case "NotInParentCacheAndNotDisposed":
+							this.__state.permanentRetainCount--;
+							this.__maybeExitNotInParentCacheAndNotDisposedState(this.__state);
+							return;
+						case "InParentCacheAndNotDisposed":
+						case "NotInParentCacheAndDisposed": throw new Error("CacheItem was in an unexpected state. This indicates a bug in react-disposable-state.");
+					}
+				};
+			}
+			case "NotInParentCacheAndDisposed": throw new Error("permanentRetain was called, but the CacheItem is in an invalid state. This indicates a bug in react-disposable-state.");
+		}
+	}
+	__maybeExitInParentCacheAndNotDisposedState(state) {
+		if (state.temporaryRetainCount === 0 && state.permanentRetainCount === 0) {
+			state.removeFromParentCache();
+			state.disposeValue();
+			this.__state = { kind: "NotInParentCacheAndDisposed" };
+		} else if (state.temporaryRetainCount === 0) {
+			state.removeFromParentCache();
+			this.__state = {
+				kind: "NotInParentCacheAndNotDisposed",
+				value: state.value,
+				disposeValue: state.disposeValue,
+				permanentRetainCount: state.permanentRetainCount
+			};
+		}
+	}
+	__maybeExitNotInParentCacheAndNotDisposedState(state) {
+		if (state.permanentRetainCount === 0) {
+			state.disposeValue();
+			this.__state = { kind: "NotInParentCacheAndDisposed" };
+		}
+	}
+};
+function createTemporarilyRetainedCacheItem(factory, removeFromParentCache, options) {
+	const cacheItem = new CacheItem(factory, removeFromParentCache, options);
+	return [cacheItem, cacheItem.temporaryRetain()];
+}
+
+//#endregion
+export { CacheItem, createTemporarilyRetainedCacheItem };
+//# sourceMappingURL=CacheItem.mjs.map

package/dist/CacheItem.mjs.map

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

package/dist/ParentCache.d.mts

@@ -0,0 +1,45 @@
+import { CacheItem } 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.
+ * - A ParentCache holds a CacheItem, which can choose to remove itself from
+ *   the parent ParentCache.
+ * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be
+ *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we
+ *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()
+ *   and this.__value.permanentRetain() are safe to be called.
+ *
+ * - Though we do not do so, it is always safe to call parentCache.delete().
+ *
+ * Invariant:
+ * - A parent cache at a given "location" (conceptually, an ID) should always
+ *   be called
+ */
+declare class ParentCache<T> {
+  private __cacheItem;
+  private readonly __factory;
+  constructor(factory: Factory<T>);
+  /**
+   * 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:
+   * - temporary retain A is created by component B rendering
+   * - temporary retain A expires, emptying the parent cache
+   * - another component renders, sharing the same parent cache, filling
+   *   by calling getOrPopulateAndTemporaryRetain
+   * - component B commits. We see that temporary retain A has been disposed,
+   *   and re-check the parent cache by calling this method.
+   */
+  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null;
+  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn];
+  private __populateAndTemporaryRetain;
+  empty(): void;
+  get factory(): Factory<T>;
+  isEmpty(): boolean;
+}
+//#endregion
+export { ParentCache };
+//# sourceMappingURL=ParentCache.d.mts.map

package/dist/ParentCache.d.mts.map

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

package/dist/ParentCache.d.ts

@@ -1,5 +1,8 @@
-import { CleanupFn, Factory, ItemCleanupPair } from '@isograph/disposable-types';
-import { CacheItem } from './CacheItem';
+import { CacheItem } from "./CacheItem.js";
+import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/ParentCache.d.ts
+
 /**
  * ParentCache
  * - A ParentCache can be in two states: populated and unpopulated.
@@ -16,25 +19,27 @@ import { CacheItem } from './CacheItem';
  * - A parent cache at a given "location" (conceptually, an ID) should always
  *   be called
  */
-export declare class ParentCache<T> {
-    private __cacheItem;
-    private readonly __factory;
-    constructor(factory: Factory<T>);
-    /**
-     * 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:
-     * - temporary retain A is created by component B rendering
-     * - temporary retain A expires, emptying the parent cache
-     * - another component renders, sharing the same parent cache, filling
-     *   by calling getOrPopulateAndTemporaryRetain
-     * - component B commits. We see that temporary retain A has been disposed,
-     *   and re-check the parent cache by calling this method.
-     */
-    getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null;
-    getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn];
-    private __populateAndTemporaryRetain;
-    empty(): void;
-    get factory(): Factory<T>;
-    isEmpty(): boolean;
+declare class ParentCache<T> {
+  private __cacheItem;
+  private readonly __factory;
+  constructor(factory: Factory<T>);
+  /**
+   * 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:
+   * - temporary retain A is created by component B rendering
+   * - temporary retain A expires, emptying the parent cache
+   * - another component renders, sharing the same parent cache, filling
+   *   by calling getOrPopulateAndTemporaryRetain
+   * - component B commits. We see that temporary retain A has been disposed,
+   *   and re-check the parent cache by calling this method.
+   */
+  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null;
+  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn];
+  private __populateAndTemporaryRetain;
+  empty(): void;
+  get factory(): Factory<T>;
+  isEmpty(): boolean;
 }
+//#endregion
+export { ParentCache };
 //# sourceMappingURL=ParentCache.d.ts.map

package/dist/ParentCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.d.ts","sourceRoot":"","sources":["../src/ParentCache.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,SAAS,EAAsC,MAAM,aAAa,CAAC;AAK5E;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;gBAI3B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IAI/B;;;;;;;;;OASG;IACH,8BAA8B,IAAI,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IAM3D,+BAA+B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC;IAM/D,OAAO,CAAC,4BAA4B;IA4BpC,KAAK;IAIL,IAAI,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC,CAExB;IAED,OAAO,IAAI,OAAO;CAGnB"}
+{"version":3,"file":"ParentCache.d.ts","names":[],"sources":["../src/ParentCache.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;cAAa;;;uBAMU,QAAQ;;;;;;;;;;;oCAcK,gBAAgB;sCAMd,UAAU,IAAI,GAAG;;;iBAsCtC,QAAQ"}

package/dist/ParentCache.js

@@ -1,88 +1,72 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParentCache = void 0;
-const CacheItem_1 = require("./CacheItem");
-// TODO convert cache impl to a getter and setter and free functions
-// TODO accept options that get passed to CacheItem
+const require_CacheItem = require('./CacheItem.js');
+
+//#region src/ParentCache.ts
 /**
- * ParentCache
- * - A ParentCache can be in two states: populated and unpopulated.
- * - A ParentCache holds a CacheItem, which can choose to remove itself from
- *   the parent ParentCache.
- * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be
- *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we
- *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()
- *   and this.__value.permanentRetain() are safe to be called.
- *
- * - Though we do not do so, it is always safe to call parentCache.delete().
- *
- * Invariant:
- * - A parent cache at a given "location" (conceptually, an ID) should always
- *   be called
- */
-class ParentCache {
-    // TODO pass an onEmpty function, which can e.g. remove this ParentCache
-    // from some parent object.
-    constructor(factory) {
-        this.__cacheItem = null;
-        this.__factory = factory;
-    }
-    /**
-     * 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:
-     * - temporary retain A is created by component B rendering
-     * - temporary retain A expires, emptying the parent cache
-     * - another component renders, sharing the same parent cache, filling
-     *   by calling getOrPopulateAndTemporaryRetain
-     * - component B commits. We see that temporary retain A has been disposed,
-     *   and re-check the parent cache by calling this method.
-     */
-    getAndPermanentRetainIfPresent() {
-        return this.__cacheItem != null
-            ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()]
-            : null;
-    }
-    getOrPopulateAndTemporaryRetain() {
-        return this.__cacheItem === null
-            ? this.__populateAndTemporaryRetain()
-            : temporaryRetain(this.__cacheItem);
-    }
-    __populateAndTemporaryRetain() {
-        const pair = (0, CacheItem_1.createTemporarilyRetainedCacheItem)(this.__factory, () => {
-            // We are doing this check because we don't want to remove the cache item
-            // if it is not the one that was created when the temporary retain was created.
-            //
-            // Consider the following scenario:
-            // - we populate the cache with CacheItem A,
-            // - then manually delete CacheItem A (e.g. to force a refetch)
-            // - then, we re-populate the parent cache with CacheItem B
-            // - then, the temporary retain of CacheItem A is disposed or expires.
-            //
-            // At this point, we don't want to delete CacheItem B from the cache.
-            //
-            // TODO consider what happens if items are === comparable to each other,
-            // e.g. the item is a number!
-            if (this.__cacheItem === pair[0]) {
-                this.empty();
-            }
-        });
-        // We deconstruct this here instead of at the definition site because otherwise,
-        // typescript thinks that cacheItem is any, because it's referenced in the closure.
-        const [cacheItem, disposeTemporaryRetain] = pair;
-        this.__cacheItem = cacheItem;
-        return [cacheItem, cacheItem.getValue(), disposeTemporaryRetain];
-    }
-    empty() {
-        this.__cacheItem = null;
-    }
-    get factory() {
-        return this.__factory;
-    }
-    isEmpty() {
-        return this.__cacheItem === null;
-    }
-}
-exports.ParentCache = ParentCache;
+* ParentCache
+* - A ParentCache can be in two states: populated and unpopulated.
+* - A ParentCache holds a CacheItem, which can choose to remove itself from
+*   the parent ParentCache.
+* - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be
+*   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we
+*   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()
+*   and this.__value.permanentRetain() are safe to be called.
+*
+* - Though we do not do so, it is always safe to call parentCache.delete().
+*
+* Invariant:
+* - A parent cache at a given "location" (conceptually, an ID) should always
+*   be called
+*/
+var ParentCache = class {
+	constructor(factory) {
+		this.__cacheItem = null;
+		this.__factory = factory;
+	}
+	/**
+	* 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:
+	* - temporary retain A is created by component B rendering
+	* - temporary retain A expires, emptying the parent cache
+	* - another component renders, sharing the same parent cache, filling
+	*   by calling getOrPopulateAndTemporaryRetain
+	* - component B commits. We see that temporary retain A has been disposed,
+	*   and re-check the parent cache by calling this method.
+	*/
+	getAndPermanentRetainIfPresent() {
+		return this.__cacheItem != null ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()] : null;
+	}
+	getOrPopulateAndTemporaryRetain() {
+		return this.__cacheItem == null ? this.__populateAndTemporaryRetain() : temporaryRetain(this.__cacheItem);
+	}
+	__populateAndTemporaryRetain() {
+		const pair = require_CacheItem.createTemporarilyRetainedCacheItem(this.__factory, () => {
+			if (this.__cacheItem === pair[0]) this.empty();
+		});
+		const [cacheItem, disposeTemporaryRetain] = pair;
+		this.__cacheItem = cacheItem;
+		return [
+			cacheItem,
+			cacheItem.getValue(),
+			disposeTemporaryRetain
+		];
+	}
+	empty() {
+		this.__cacheItem = null;
+	}
+	get factory() {
+		return this.__factory;
+	}
+	isEmpty() {
+		return this.__cacheItem == null;
+	}
+};
 function temporaryRetain(value) {
-    return [value, value.getValue(), value.temporaryRetain()];
+	return [
+		value,
+		value.getValue(),
+		value.temporaryRetain()
+	];
 }
+
+//#endregion
+exports.ParentCache = ParentCache;

package/dist/ParentCache.mjs

@@ -0,0 +1,73 @@
+import { createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
+
+//#region src/ParentCache.ts
+/**
+* ParentCache
+* - A ParentCache can be in two states: populated and unpopulated.
+* - A ParentCache holds a CacheItem, which can choose to remove itself from
+*   the parent ParentCache.
+* - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be
+*   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we
+*   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()
+*   and this.__value.permanentRetain() are safe to be called.
+*
+* - Though we do not do so, it is always safe to call parentCache.delete().
+*
+* Invariant:
+* - A parent cache at a given "location" (conceptually, an ID) should always
+*   be called
+*/
+var ParentCache = class {
+	constructor(factory) {
+		this.__cacheItem = null;
+		this.__factory = factory;
+	}
+	/**
+	* 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:
+	* - temporary retain A is created by component B rendering
+	* - temporary retain A expires, emptying the parent cache
+	* - another component renders, sharing the same parent cache, filling
+	*   by calling getOrPopulateAndTemporaryRetain
+	* - component B commits. We see that temporary retain A has been disposed,
+	*   and re-check the parent cache by calling this method.
+	*/
+	getAndPermanentRetainIfPresent() {
+		return this.__cacheItem != null ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()] : null;
+	}
+	getOrPopulateAndTemporaryRetain() {
+		return this.__cacheItem == null ? this.__populateAndTemporaryRetain() : temporaryRetain(this.__cacheItem);
+	}
+	__populateAndTemporaryRetain() {
+		const pair = createTemporarilyRetainedCacheItem(this.__factory, () => {
+			if (this.__cacheItem === pair[0]) this.empty();
+		});
+		const [cacheItem, disposeTemporaryRetain] = pair;
+		this.__cacheItem = cacheItem;
+		return [
+			cacheItem,
+			cacheItem.getValue(),
+			disposeTemporaryRetain
+		];
+	}
+	empty() {
+		this.__cacheItem = null;
+	}
+	get factory() {
+		return this.__factory;
+	}
+	isEmpty() {
+		return this.__cacheItem == null;
+	}
+};
+function temporaryRetain(value) {
+	return [
+		value,
+		value.getValue(),
+		value.temporaryRetain()
+	];
+}
+
+//#endregion
+export { ParentCache };
+//# sourceMappingURL=ParentCache.mjs.map

package/dist/ParentCache.mjs.map

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

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,25 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/index.d.mts

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