@isograph/react-disposable-state 0.4.3 → 0.5.1

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

@@ -1,5 +1,12 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"22.9.0"} (current: {"node":"v22.20.0","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"22.9.0"} (current: {"node":"v22.21.1","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.4.3 compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
-> rimraf dist && tsc -p tsconfig.pkg.json
+> @isograph/react-disposable-state@0.5.1 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.
+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)
+ℹ Build start

package/dist/CacheItem.d.mts

@@ -0,0 +1,63 @@
+import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/CacheItem.d.ts
+type NotInParentCacheAndDisposed = {
+  kind: 'NotInParentCacheAndDisposed';
+};
+type NotInParentCacheAndNotDisposed<T> = {
+  kind: 'NotInParentCacheAndNotDisposed';
+  value: T;
+  disposeValue: () => void;
+  permanentRetainCount: number;
+};
+type InParentCacheAndNotDisposed<T> = {
+  kind: 'InParentCacheAndNotDisposed';
+  value: T;
+  disposeValue: () => void;
+  removeFromParentCache: () => void;
+  temporaryRetainCount: number;
+  permanentRetainCount: number;
+};
+type CacheItemState<T> = InParentCacheAndNotDisposed<T> | NotInParentCacheAndNotDisposed<T> | NotInParentCacheAndDisposed;
+type CacheItemOptions = {
+  temporaryRetainTime: number;
+};
+/**
+ * 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
+ */
+declare class CacheItem<T> {
+  private __state;
+  private __options;
+  constructor(factory: Factory<T>, removeFromParentCache: CleanupFn, options: CacheItemOptions | void);
+  getValue(): T;
+  permanentRetainIfNotDisposed(disposeOfTemporaryRetain: CleanupFn): ItemCleanupPair<T> | null;
+  temporaryRetain(): CleanupFn;
+  permanentRetain(): CleanupFn;
+  private __maybeExitInParentCacheAndNotDisposedState;
+  private __maybeExitNotInParentCacheAndNotDisposedState;
+}
+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.mts.map

package/dist/CacheItem.d.mts.map

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

package/dist/CacheItem.d.ts

@@ -1,24 +1,26 @@
-import { CleanupFn, Factory, ItemCleanupPair } from '@isograph/disposable-types';
-export type NotInParentCacheAndDisposed = {
-    kind: 'NotInParentCacheAndDisposed';
+import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/CacheItem.d.ts
+type NotInParentCacheAndDisposed = {
+  kind: 'NotInParentCacheAndDisposed';
 };
-export type NotInParentCacheAndNotDisposed<T> = {
-    kind: 'NotInParentCacheAndNotDisposed';
-    value: T;
-    disposeValue: () => void;
-    permanentRetainCount: number;
+type NotInParentCacheAndNotDisposed<T> = {
+  kind: 'NotInParentCacheAndNotDisposed';
+  value: T;
+  disposeValue: () => void;
+  permanentRetainCount: number;
 };
-export type InParentCacheAndNotDisposed<T> = {
-    kind: 'InParentCacheAndNotDisposed';
-    value: T;
-    disposeValue: () => void;
-    removeFromParentCache: () => void;
-    temporaryRetainCount: number;
-    permanentRetainCount: number;
+type InParentCacheAndNotDisposed<T> = {
+  kind: 'InParentCacheAndNotDisposed';
+  value: T;
+  disposeValue: () => void;
+  removeFromParentCache: () => void;
+  temporaryRetainCount: number;
+  permanentRetainCount: number;
 };
-export type CacheItemState<T> = InParentCacheAndNotDisposed<T> | NotInParentCacheAndNotDisposed<T> | NotInParentCacheAndDisposed;
-export type CacheItemOptions = {
-    temporaryRetainTime: number;
+type CacheItemState<T> = InParentCacheAndNotDisposed<T> | NotInParentCacheAndNotDisposed<T> | NotInParentCacheAndDisposed;
+type CacheItemOptions = {
+  temporaryRetainTime: number;
 };
 /**
  * CacheItem:
@@ -44,16 +46,18 @@ export type CacheItemOptions = {
  * - InParentCacheAndNotDisposed => NotInParentCacheAndDisposed
  * - NotInParentCacheAndNotDisposed => NotInParentCacheAndDisposed
  */
-export declare class CacheItem<T> {
-    private __state;
-    private __options;
-    constructor(factory: Factory<T>, removeFromParentCache: CleanupFn, options: CacheItemOptions | void);
-    getValue(): T;
-    permanentRetainIfNotDisposed(disposeOfTemporaryRetain: CleanupFn): ItemCleanupPair<T> | null;
-    temporaryRetain(): CleanupFn;
-    permanentRetain(): CleanupFn;
-    private __maybeExitInParentCacheAndNotDisposedState;
-    private __maybeExitNotInParentCacheAndNotDisposedState;
+declare class CacheItem<T> {
+  private __state;
+  private __options;
+  constructor(factory: Factory<T>, removeFromParentCache: CleanupFn, options: CacheItemOptions | void);
+  getValue(): T;
+  permanentRetainIfNotDisposed(disposeOfTemporaryRetain: CleanupFn): ItemCleanupPair<T> | null;
+  temporaryRetain(): CleanupFn;
+  permanentRetain(): CleanupFn;
+  private __maybeExitInParentCacheAndNotDisposedState;
+  private __maybeExitNotInParentCacheAndNotDisposedState;
 }
-export declare function createTemporarilyRetainedCacheItem<T>(factory: Factory<T>, removeFromParentCache: CleanupFn, options: CacheItemOptions | void): [CacheItem<T>, CleanupFn];
+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

package/dist/CacheItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CacheItem.d.ts","sourceRoot":"","sources":["../src/CacheItem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAIpC,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,6BAA6B,CAAC;CACrC,CAAC;AACF,MAAM,MAAM,8BAA8B,CAAC,CAAC,IAAI;IAC9C,IAAI,EAAE,gCAAgC,CAAC;IACvC,KAAK,EAAE,CAAC,CAAC;IACT,YAAY,EAAE,MAAM,IAAI,CAAC;IAGzB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AACF,MAAM,MAAM,2BAA2B,CAAC,CAAC,IAAI;IAC3C,IAAI,EAAE,6BAA6B,CAAC;IACpC,KAAK,EAAE,CAAC,CAAC;IACT,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAGlC,oBAAoB,EAAE,MAAM,CAAC;IAG7B,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,IACxB,2BAA2B,CAAC,CAAC,CAAC,GAC9B,8BAA8B,CAAC,CAAC,CAAC,GACjC,2BAA2B,CAAC;AAEhC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAKF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,SAAS,CAA0B;gBAQzC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,qBAAqB,EAAE,SAAS,EAChC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAgBlC,QAAQ,IAAI,CAAC;IAiBb,4BAA4B,CAC1B,wBAAwB,EAAE,SAAS,GAClC,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IA8E5B,eAAe,IAAI,SAAS;IAkE5B,eAAe,IAAI,SAAS;IAoE5B,OAAO,CAAC,2CAA2C;IAoBnD,OAAO,CAAC,8CAA8C;CAUvD;AAED,wBAAgB,kCAAkC,CAAC,CAAC,EAClD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,qBAAqB,EAAE,SAAS,EAChC,OAAO,EAAE,gBAAgB,GAAG,IAAI,GAC/B,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAI3B"}
+{"version":3,"file":"CacheItem.d.ts","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"}

package/dist/CacheItem.js

@@ -1,269 +1,194 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CacheItem = void 0;
-exports.createTemporarilyRetainedCacheItem = createTemporarilyRetainedCacheItem;
-const DEFAULT_TEMPORARY_RETAIN_TIME = 5000;
-// TODO don't export this class, only export type (interface) instead
-// TODO convert cacheitem impl to a getter and setter and free functions
+
+//#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
- */
-class CacheItem {
-    // Private. Do not call this constructor directly. Use
-    // createTemporarilyRetainedCacheItem instead. This is because this
-    // constructor creates a CacheItem in an invalid state. It must be
-    // temporarily retained to enter a valid state, and JavaScript doesn't
-    // let you return a tuple from a constructor.
-    constructor(factory, removeFromParentCache, options) {
-        this.__options = options !== null && options !== void 0 ? options : null;
-        const [value, disposeValue] = factory();
-        this.__state = {
-            kind: 'InParentCacheAndNotDisposed',
-            value,
-            disposeValue,
-            removeFromParentCache,
-            // NOTE: we are creating the CacheItem in an invalid state. This is okay, because
-            // we are immediately calling .temporaryRetain.
-            temporaryRetainCount: 0,
-            permanentRetainCount: 0,
-        };
-    }
-    getValue() {
-        switch (this.__state.kind) {
-            case 'InParentCacheAndNotDisposed': {
-                return this.__state.value;
-            }
-            case 'NotInParentCacheAndNotDisposed': {
-                return this.__state.value;
-            }
-            default: {
-                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;
-                            }
-                            default: {
-                                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;
-                            }
-                            default: {
-                                throw new Error('CacheItem was in an unexpected state. ' +
-                                    'This indicates a bug in react-disposable-state.');
-                            }
-                        }
-                    },
-                ];
-            }
-            default: {
-                // The CacheItem is disposed, so disposeOfTemporaryRetain is a no-op
-                return null;
-            }
-        }
-    }
-    temporaryRetain() {
-        var _a, _b;
-        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;
-                            }
-                            default: {
-                                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;
-                        }
-                        default: {
-                            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, (_b = (_a = this.__options) === null || _a === void 0 ? void 0 : _a.temporaryRetainTime) !== null && _b !== void 0 ? _b : DEFAULT_TEMPORARY_RETAIN_TIME);
-                return clearTemporaryRetainByCallack;
-            }
-            default: {
-                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;
-                        }
-                        default: {
-                            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;
-                        }
-                        default: {
-                            throw new Error('CacheItem was in an unexpected state. ' +
-                                'This indicates a bug in react-disposable-state.');
-                        }
-                    }
-                };
-            }
-            default: {
-                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',
-            };
-        }
-    }
-}
-exports.CacheItem = CacheItem;
+* 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);
-    const disposeTemporaryRetain = cacheItem.temporaryRetain();
-    return [cacheItem, disposeTemporaryRetain];
+	const cacheItem = new CacheItem(factory, removeFromParentCache, options);
+	return [cacheItem, cacheItem.temporaryRetain()];
 }
+
+//#endregion
+exports.CacheItem = CacheItem;
+exports.createTemporarilyRetainedCacheItem = createTemporarilyRetainedCacheItem;