@isograph/react-disposable-state 0.0.0-main-55364d41 → 0.0.0-main-2c275831

package/dist/CacheItem.d.ts

@@ -1,15 +1,15 @@
-import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
+import { CleanupFn, Factory, ItemCleanupPair } from '@isograph/disposable-types';
 export type NotInParentCacheAndDisposed = {
-    kind: "NotInParentCacheAndDisposed";
+    kind: 'NotInParentCacheAndDisposed';
 };
 export type NotInParentCacheAndNotDisposed<T> = {
-    kind: "NotInParentCacheAndNotDisposed";
+    kind: 'NotInParentCacheAndNotDisposed';
     value: T;
     disposeValue: () => void;
     permanentRetainCount: number;
 };
 export type InParentCacheAndNotDisposed<T> = {
-    kind: "InParentCacheAndNotDisposed";
+    kind: 'InParentCacheAndNotDisposed';
     value: T;
     disposeValue: () => void;
     removeFromParentCache: () => void;

package/dist/CacheItem.js

@@ -34,7 +34,7 @@ class CacheItem {
         this.__options = options !== null && options !== void 0 ? options : null;
         const [value, disposeValue] = factory();
         this.__state = {
-            kind: "InParentCacheAndNotDisposed",
+            kind: 'InParentCacheAndNotDisposed',
             value,
             disposeValue,
             removeFromParentCache,
@@ -46,21 +46,21 @@ class CacheItem {
     }
     getValue() {
         switch (this.__state.kind) {
-            case "InParentCacheAndNotDisposed": {
+            case 'InParentCacheAndNotDisposed': {
                 return this.__state.value;
             }
-            case "NotInParentCacheAndNotDisposed": {
+            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.");
+                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": {
+            case 'InParentCacheAndNotDisposed': {
                 let cleared = false;
                 this.__state.permanentRetainCount++;
                 disposeOfTemporaryRetain();
@@ -68,30 +68,30 @@ class CacheItem {
                     this.__state.value,
                     () => {
                         if (cleared) {
-                            throw new Error("A permanent retain should only be cleared once. " +
-                                "This indicates a bug in react-disposable-state.");
+                            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": {
+                            case 'InParentCacheAndNotDisposed': {
                                 this.__state.permanentRetainCount--;
                                 this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
                                 return;
                             }
-                            case "NotInParentCacheAndNotDisposed": {
+                            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.");
+                                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": {
+            case 'NotInParentCacheAndNotDisposed': {
                 let cleared = false;
                 this.__state.permanentRetainCount++;
                 disposeOfTemporaryRetain();
@@ -99,19 +99,19 @@ class CacheItem {
                     this.__state.value,
                     () => {
                         if (cleared) {
-                            throw new Error("A permanent retain should only be cleared once. " +
-                                "This indicates a bug in react-disposable-state.");
+                            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": {
+                            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.");
+                                throw new Error('CacheItem was in an unexpected state. ' +
+                                    'This indicates a bug in react-disposable-state.');
                             }
                         }
                     },
@@ -126,40 +126,40 @@ class CacheItem {
     temporaryRetain() {
         var _a, _b;
         switch (this.__state.kind) {
-            case "InParentCacheAndNotDisposed": {
-                let status = "Uncleared";
+            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.");
+                    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") {
+                    else if (status === 'Uncleared') {
                         switch (this.__state.kind) {
-                            case "InParentCacheAndNotDisposed": {
+                            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.");
+                                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";
+                    status = 'ClearedByTimeout';
                     switch (this.__state.kind) {
-                        case "InParentCacheAndNotDisposed": {
+                        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.");
+                            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.');
                         }
                     }
                 };
@@ -167,65 +167,65 @@ class CacheItem {
                 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.");
+                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": {
+            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.");
+                        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": {
+                        case 'InParentCacheAndNotDisposed': {
                             this.__state.permanentRetainCount--;
                             this.__maybeExitInParentCacheAndNotDisposedState(this.__state);
                             return;
                         }
-                        case "NotInParentCacheAndNotDisposed": {
+                        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.");
+                            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": {
+            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.");
+                        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": {
+                        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.");
+                            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.");
+                throw new Error('permanentRetain was called, but the CacheItem is in an invalid state. ' +
+                    'This indicates a bug in react-disposable-state.');
             }
         }
     }
@@ -234,13 +234,13 @@ class CacheItem {
             state.removeFromParentCache();
             state.disposeValue();
             this.__state = {
-                kind: "NotInParentCacheAndDisposed",
+                kind: 'NotInParentCacheAndDisposed',
             };
         }
         else if (state.temporaryRetainCount === 0) {
             state.removeFromParentCache();
             this.__state = {
-                kind: "NotInParentCacheAndNotDisposed",
+                kind: 'NotInParentCacheAndNotDisposed',
                 value: state.value,
                 disposeValue: state.disposeValue,
                 permanentRetainCount: state.permanentRetainCount,
@@ -251,7 +251,7 @@ class CacheItem {
         if (state.permanentRetainCount === 0) {
             state.disposeValue();
             this.__state = {
-                kind: "NotInParentCacheAndDisposed",
+                kind: 'NotInParentCacheAndDisposed',
             };
         }
     }

package/dist/ParentCache.d.ts

@@ -1,5 +1,5 @@
-import { CacheItem } from "./CacheItem";
-import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
+import { CacheItem } from './CacheItem';
+import { CleanupFn, Factory, ItemCleanupPair } from '@isograph/disposable-types';
 /**
  * ParentCache
  * - A ParentCache can be in two states: populated and unpopulated.

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export * from "@isograph/disposable-types";
-export * from "./CacheItem";
-export * from "./ParentCache";
-export * from "./useCachedPrecommitValue";
-export * from "./useDisposableState";
-export * from "./useHasCommittedRef";
-export * from "./useLazyDisposableState";
-export * from "./useUpdatableDisposableState";
+export * from '@isograph/disposable-types';
+export * from './CacheItem';
+export * from './ParentCache';
+export * from './useCachedPrecommitValue';
+export * from './useDisposableState';
+export * from './useHasCommittedRef';
+export * from './useLazyDisposableState';
+export * from './useUpdatableDisposableState';

package/dist/useCachedPrecommitValue.d.ts

@@ -1,5 +1,5 @@
-import { ParentCache } from "./ParentCache";
-import { ItemCleanupPair } from "@isograph/isograph-disposable-types/dist";
+import { ParentCache } from './ParentCache';
+import { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
 /**
  * usePrecommitValue<T>
  * - Takes a mutable parent cache, a factory function, and an onCommit callback.

package/dist/useCachedPrecommitValue.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCachedPrecommitValue = void 0;
 const react_1 = require("react");

package/dist/useDisposableState.d.ts

@@ -1,6 +1,6 @@
-import { ParentCache } from "./ParentCache";
-import { ItemCleanupPair } from "@isograph/disposable-types";
-import { UnassignedState } from "./useUpdatableDisposableState";
+import { ParentCache } from './ParentCache';
+import { ItemCleanupPair } from '@isograph/disposable-types';
+import { UnassignedState } from './useUpdatableDisposableState';
 type UseUpdatableDisposableStateReturnValue<T> = {
     state: T;
     setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;

package/dist/useDisposableState.js

@@ -18,8 +18,8 @@ function useDisposableState(parentCache) {
                 itemCleanupPairRef.current = null;
             }
             else {
-                throw new Error("itemCleanupPairRef.current is unexpectedly null. " +
-                    "This indicates a bug in react-disposable-state.");
+                throw new Error('itemCleanupPairRef.current is unexpectedly null. ' +
+                    'This indicates a bug in react-disposable-state.');
             }
         }
     }, [stateFromDisposableStateHook]);
@@ -44,9 +44,7 @@ function useDisposableState(parentCache) {
     // Note that in the post-commit post-setState state, itemCleanupPairRef
     // can still be assigned, during the render before the
     // cleanupItemCleanupPairRefAfterSetState effect is called.
-    const state = (_c = (_a = (stateFromDisposableStateHook != useUpdatableDisposableState_1.UNASSIGNED_STATE
-        ? stateFromDisposableStateHook
-        : null)) !== null && _a !== void 0 ? _a : (_b = itemCleanupPairRef.current) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : preCommitItem === null || preCommitItem === void 0 ? void 0 : preCommitItem.state;
+    const state = (_c = (_a = (stateFromDisposableStateHook != useUpdatableDisposableState_1.UNASSIGNED_STATE ? stateFromDisposableStateHook : null)) !== null && _a !== void 0 ? _a : (_b = itemCleanupPairRef.current) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : preCommitItem === null || preCommitItem === void 0 ? void 0 : preCommitItem.state;
     return {
         state: state,
         setState,
@@ -58,11 +56,11 @@ function tsTests() {
     let x;
     const a = useDisposableState(x);
     // @ts-expect-error
-    a.setState(["asdf", () => { }]);
+    a.setState(['asdf', () => { }]);
     // @ts-expect-error
     a.setState([useUpdatableDisposableState_1.UNASSIGNED_STATE, () => { }]);
     const b = useDisposableState(x);
     // @ts-expect-error
     b.setState([useUpdatableDisposableState_1.UNASSIGNED_STATE, () => { }]);
-    b.setState(["asdf", () => { }]);
+    b.setState(['asdf', () => { }]);
 }

package/dist/useHasCommittedRef.d.ts

@@ -1,4 +1,4 @@
-import { MutableRefObject } from "react";
+import { MutableRefObject } from 'react';
 /**
  * Returns true if the component has committed, false otherwise.
  */

package/dist/useLazyDisposableState.d.ts

@@ -1,4 +1,4 @@
-import { ParentCache } from "./ParentCache";
+import { ParentCache } from './ParentCache';
 /**
  * useLazyDisposableState<T>
  * - Takes a mutable parent cache and a factory function

package/dist/useLazyDisposableState.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLazyDisposableState = void 0;
 const react_1 = require("react");
@@ -23,7 +23,7 @@ function useLazyDisposableState(parentCache) {
         const cleanupFn = (_a = itemCleanupPairRef.current) === null || _a === void 0 ? void 0 : _a[1];
         // TODO confirm useEffect is called in order.
         if (cleanupFn == null) {
-            throw new Error("cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.");
+            throw new Error('cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.');
         }
         return cleanupFn;
     }, []);
@@ -34,6 +34,6 @@ function useLazyDisposableState(parentCache) {
     // Safety: This can't happen. For renders before the initial commit, preCommitItem
     // is non-null. During the initial commit, we assign itemCleanupPairRef.current,
     // so during subsequent renders, itemCleanupPairRef.current is non-null.
-    throw new Error("returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.");
+    throw new Error('returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.');
 }
 exports.useLazyDisposableState = useLazyDisposableState;

package/dist/useUpdatableDisposableState.d.ts

@@ -1,4 +1,4 @@
-import { ItemCleanupPair } from "@isograph/disposable-types";
+import { ItemCleanupPair } from '@isograph/disposable-types';
 export declare const UNASSIGNED_STATE: unique symbol;
 export type UnassignedState = typeof UNASSIGNED_STATE;
 type UseUpdatableDisposableStateReturnValue<T> = {

package/dist/useUpdatableDisposableState.js

@@ -41,7 +41,7 @@ function useUpdatableDisposableState() {
     const [stateICI, setStateICI] = (0, react_1.useState)(exports.UNASSIGNED_STATE);
     const setStateAfterCommit = (0, react_1.useCallback)((itemCleanupPair) => {
         if (!hasCommittedRef.current) {
-            throw new Error("Calling setState before the component has committed is unsafe and disallowed.");
+            throw new Error('Calling setState before the component has committed is unsafe and disallowed.');
         }
         const ici = {
             item: itemCleanupPair[0],
@@ -84,9 +84,9 @@ function tsTests() {
     // @ts-expect-error
     a.setState([exports.UNASSIGNED_STATE, () => { }]);
     // @ts-expect-error
-    a.setState(["asdf", () => { }]);
+    a.setState(['asdf', () => { }]);
     const b = useUpdatableDisposableState();
     // @ts-expect-error
     b.setState([exports.UNASSIGNED_STATE, () => { }]);
-    b.setState(["asdf", () => { }]);
+    b.setState(['asdf', () => { }]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.0.0-main-55364d41",
+  "version": "0.0.0-main-2c275831",
   "description": "Primitives for managing disposable state in React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "prepack": "yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-55364d41",
+    "@isograph/disposable-types": "0.0.0-main-2c275831",
     "react": "^18.2.0"
   },
   "devDependencies": {