@isograph/react-disposable-state 0.3.0 → 0.3.1

package/.turbo/turbo-compile-typescript.log

@@ -0,0 +1,4 @@
+
+> @isograph/react-disposable-state@0.3.1 compile-typescript /Users/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> rm -rf dist/* && tsc -p tsconfig.pkg.json
+

package/README.md

@@ -84,9 +84,9 @@ A hook that:
 
 ```typescript
 const { state }: { state: T } = useLazyDisposableState<T>(
-  parentCache: ParentCache<T>,
-  factory: Loader<T>,
-  options: ?Options,
+  parentCache,
+  factory,
+  options,
 );
 ```
 
@@ -105,11 +105,9 @@ const {
   state,
   setState,
 }: {
-  state: T | null,
-  setState: (ItemCleanupPair<T>) => void,
-} = useUpdatableDisposableState<T>(
-  options: ?Options,
-);
+  state: T | null;
+  setState: (pair: ItemCleanupPair<T>) => void;
+} = useUpdatableDisposableState<T>(options);
 ```
 
 ### `useDisposableState`
@@ -123,13 +121,9 @@ const {
   state,
   setState,
 }: {
-  state: T,
-  setState: (ItemCleanupPair<T>) => void,
-} = useDisposableState<T>(
-  parentCache: ParentCache<T>,
-  factory: Loader<T>,
-  options: ?Options,
-);
+  state: T;
+  setState: (pair: ItemCleanupPair<T>) => void;
+} = useDisposableState<T>(parentCache, factory, options);
 ```
 
 ## Miscellaneous notes

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';
 /**
  * ParentCache
  * - A ParentCache can be in two states: populated and unpopulated.

package/dist/ParentCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.d.ts","sourceRoot":"","sources":["../src/ParentCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAsC,MAAM,aAAa,CAAC;AAC5E,OAAO,EACL,SAAS,EACT,OAAO,EACP,eAAe,EAChB,MAAM,4BAA4B,CAAC;AAKpC;;;;;;;;;;;;;;;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","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"}

package/dist/useCachedResponsivePrecommitValue.d.ts

@@ -31,7 +31,6 @@ import { ParentCache } from './ParentCache';
  *
  * Passing a different onCommit:
  * - Passing a different onCommit has no effect, except for during commit.
- *
  */
 export declare function useCachedResponsivePrecommitValue<T>(parentCache: ParentCache<T>, onCommit: (pair: ItemCleanupPair<T>) => void): {
     state: T;

package/dist/useCachedResponsivePrecommitValue.d.ts.map

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

package/dist/useCachedResponsivePrecommitValue.js

@@ -33,7 +33,6 @@ const react_1 = require("react");
  *
  * Passing a different onCommit:
  * - Passing a different onCommit has no effect, except for during commit.
- *
  */
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
     // TODO: there should be two APIs. One in which we always re-render if the

package/dist/useDisposableState.d.ts.map

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

package/dist/useLazyDisposableState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyDisposableState.d.ts","sourceRoot":"","sources":["../src/useLazyDisposableState.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAGrE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,GACpD;IACD,KAAK,EAAE,CAAC,CAAC;CACV,CAoCA"}
+{"version":3,"file":"useLazyDisposableState.d.ts","sourceRoot":"","sources":["../src/useLazyDisposableState.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,WAAW,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,GACpD;IACD,KAAK,EAAE,CAAC,CAAC;CACV,CAoCA"}

package/docs/managing-complex-state.md

@@ -13,17 +13,19 @@ Consider using `useUpdatableDisposableState` state to manage an array of disposa
 The behavior of `useUpdatableDisposableState` is to entirely dispose of all previously-held items after a new item is set in state. So, if we had
 
 ```js
-const { state, setState } = useUpdatableDisposableState();
-// assume state === [item1], and the cleanup function will dispose item1
-
-const addItem2ToState = () => {
-  setState([item1, item2], () => {
-    disposeItem1();
-    disposeItem2();
-  });
+const component = () => {
+  const { state, setState } = useUpdatableDisposableState();
+  // assume state === [item1], and the cleanup function will dispose item1
+
+  const addItem2ToState = () => {
+    setState([item1, item2], () => {
+      disposeItem1();
+      disposeItem2();
+    });
+  };
+
+  return makePrettyJSX(state[0]);
 };
-
-return makePrettyJSX(state[0]);
 ```
 
 In the above, `item1` would be disposed after the state was updated to be `[item1, item2]`. Meaning, the hook returns an item that has already been disposed. Clearly, this will not do.
@@ -51,25 +53,27 @@ Given an undisposed active reference `r1`, one can get a new active reference `r
 Let's use reference counted pointers in the example.
 
 ```js
-const { state, setState } = useUpdatableDisposableState();
-// assume state === [item1activeReference], and the cleanup function will dispose that active reference
-
-const addItem2ToState = () => {
-  const [item2, disposeItem2] = createDisposeItem2();
-  const [item2ActiveReference, disposeItem2ActiveReference] =
-    createReferenceCountedPointer([item2, disposeItem2]);
-
-  // get a new active reference to the existing item1
-  const [item1ActiveReference, disposeItem1ActiveReference] = nullthrows(
-    state[0].cloneIfNotDisposed(),
-  );
-  setState([item1ActiveReference, item2ActiveReference], () => {
-    disposeItem1ActiveReference();
-    disposeItem2ActiveReference();
-  });
+const component = () => {
+  const { state, setState } = useUpdatableDisposableState();
+  // assume state === [item1activeReference], and the cleanup function will dispose that active reference
+
+  const addItem2ToState = () => {
+    const [item2, disposeItem2] = createDisposeItem2();
+    const [item2ActiveReference, disposeItem2ActiveReference] =
+      createReferenceCountedPointer([item2, disposeItem2]);
+
+    // get a new active reference to the existing item1
+    const [item1ActiveReference, disposeItem1ActiveReference] = nullthrows(
+      state[0].cloneIfNotDisposed(),
+    );
+    setState([item1ActiveReference, item2ActiveReference], () => {
+      disposeItem1ActiveReference();
+      disposeItem2ActiveReference();
+    });
+  };
+
+  return makePrettyJSX(nullthrows(state[0].getItemIfNotDisposed()));
 };
-
-return makePrettyJSX(nullthrows(state[0].getItemIfNotDisposed()));
 ```
 
 Not the most ergonomic, but it does the job.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Primitives for managing disposable state in React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -8,20 +8,21 @@
   "author": "Isograph Labs",
   "license": "MIT",
   "scripts": {
-    "compile": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
+    "compile-typescript": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
     "compile-watch": "tsc -p tsconfig.pkg.json --watch",
     "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",
     "note": "WE SHOULD ALSO TEST HERE",
-    "prepack": "pnpm run compile",
-    "tsc": "tsc"
+    "prepack": "pnpm run compile-typescript",
+    "tsc": "tsc",
+    "tsc-force": "tsc --build --clean && tsc --build --force"
   },
   "dependencies": {
     "@isograph/disposable-types": "*"
   },
   "peerDependencies": {
-    "react": "18.3.1"
+    "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/react": "18.3.1",

package/src/CacheItem.test.ts

@@ -1,18 +1,18 @@
+import { ItemCleanupPair } from '@isograph/disposable-types';
 import {
-  describe,
+  afterEach,
   assert,
-  test,
-  vi,
   beforeEach,
-  afterEach,
+  describe,
   expect,
+  test,
+  vi,
 } from 'vitest';
 import {
   CacheItem,
   CacheItemState,
   createTemporarilyRetainedCacheItem,
 } from './CacheItem';
-import { ItemCleanupPair } from '@isograph/disposable-types';
 
 function getState<T>(cacheItem: CacheItem<T>): CacheItemState<T> {
   return (cacheItem as any).__state as CacheItemState<T>;

package/src/ParentCache.test.ts

@@ -1,7 +1,7 @@
-import { describe, assert, test, vi, expect } from 'vitest';
-import { ParentCache } from './ParentCache';
 import { ItemCleanupPair } from '@isograph/disposable-types';
+import { assert, describe, expect, test, vi } from 'vitest';
 import { CacheItem } from './CacheItem';
+import { ParentCache } from './ParentCache';
 
 function getValue<T>(cache: ParentCache<T>): CacheItem<T> | null {
   return (cache as any).__cacheItem as CacheItem<T> | null;

package/src/ParentCache.ts

@@ -1,9 +1,9 @@
-import { CacheItem, createTemporarilyRetainedCacheItem } from './CacheItem';
 import {
   CleanupFn,
   Factory,
   ItemCleanupPair,
 } from '@isograph/disposable-types';
+import { CacheItem, createTemporarilyRetainedCacheItem } from './CacheItem';
 
 // TODO convert cache impl to a getter and setter and free functions
 // TODO accept options that get passed to CacheItem

package/src/useCachedResponsivePrecommitValue.test.tsx

@@ -1,10 +1,10 @@
-import { describe, test, vi, expect, assert } from 'vitest';
-import { ParentCache } from './ParentCache';
 import { ItemCleanupPair } from '@isograph/disposable-types';
-import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 import React from 'react';
 import { create } from 'react-test-renderer';
+import { assert, describe, expect, test, vi } from 'vitest';
 import { CacheItem, CacheItemState } from './CacheItem';
+import { ParentCache } from './ParentCache';
+import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 
 function getItem<T>(cache: ParentCache<T>): CacheItem<T> | null {
   return (cache as any).__cacheItem;

package/src/useCachedResponsivePrecommitValue.ts

@@ -35,7 +35,6 @@ import { ParentCache } from './ParentCache';
  *
  * Passing a different onCommit:
  * - Passing a different onCommit has no effect, except for during commit.
- *
  */
 export function useCachedResponsivePrecommitValue<T>(
   parentCache: ParentCache<T>,

package/src/useDisposableState.ts

@@ -1,7 +1,6 @@
 import { ItemCleanupPair } from '@isograph/disposable-types';
 import { useEffect, useRef } from 'react';
 import { ParentCache } from './ParentCache';
-
 import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
 import {
   UNASSIGNED_STATE,

package/src/useLazyDisposableState.test.tsx

@@ -4,6 +4,7 @@ import { create } from 'react-test-renderer';
 import { describe, expect, test, vi } from 'vitest';
 import { ParentCache } from './ParentCache';
 import { useLazyDisposableState } from './useLazyDisposableState';
+
 function createCache<T>(value: T) {
   const disposeItem = vi.fn();
   const factory = vi.fn(() => {

package/src/useLazyDisposableState.ts

@@ -1,12 +1,10 @@
 'use strict';
 
-import { useEffect, useRef } from 'react';
-
 import type { ItemCleanupPair } from '@isograph/isograph-disposable-types';
+import { useEffect, useRef } from 'react';
 import { ParentCache } from './ParentCache';
-
-import { type UnassignedState } from './useUpdatableDisposableState';
 import { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';
+import { type UnassignedState } from './useUpdatableDisposableState';
 
 /**
  * useLazyDisposableState<T>

package/src/useUpdatableDisposableState.test.tsx

@@ -1,9 +1,9 @@
-import { describe, test, vi, expect } from 'vitest';
 import React from 'react';
 import { create } from 'react-test-renderer';
+import { describe, expect, test, vi } from 'vitest';
 import {
-  useUpdatableDisposableState,
   UNASSIGNED_STATE,
+  useUpdatableDisposableState,
 } from './useUpdatableDisposableState';
 
 function Suspender({ promise, isResolvedRef }) {