@isograph/react 0.0.0-main-edade9ce → 0.0.0-main-d6741831

package/dist/core/IsographEnvironment.d.ts

@@ -25,8 +25,8 @@ type AnyRecordSubscription = {
 };
 type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
-type SuspenseCache = {
-    [index: string]: ParentCache<any>;
+type CacheMap<T> = {
+    [index: string]: ParentCache<T>;
 };
 export type IsographEnvironment = {
     readonly store: IsographStore;
@@ -34,7 +34,7 @@ export type IsographEnvironment = {
     readonly missingFieldHandler: MissingFieldHandler | null;
     readonly componentCache: ComponentCache;
     readonly subscriptions: Subscriptions;
-    readonly suspenseCache: SuspenseCache;
+    readonly fragmentCache: CacheMap<FragmentReference<any, any>>;
     readonly retainedQueries: Set<RetainedQuery>;
     readonly gcBuffer: Array<RetainedQuery>;
     readonly gcBufferSize: number;

package/dist/core/IsographEnvironment.js

@@ -10,7 +10,7 @@ function createIsographEnvironment(store, networkFunction, missingFieldHandler)
         missingFieldHandler: missingFieldHandler !== null && missingFieldHandler !== void 0 ? missingFieldHandler : null,
         componentCache: {},
         subscriptions: new Set(),
-        suspenseCache: {},
+        fragmentCache: {},
         retainedQueries: new Set(),
         gcBuffer: [],
         gcBufferSize: DEFAULT_GC_BUFFER_SIZE,

package/dist/core/cache.d.ts

@@ -1,5 +1,4 @@
 import { Factory, ParentCache } from '@isograph/react-disposable-state';
-import { AnyError, PromiseWrapper } from './PromiseWrapper';
 import { DataId, type IsographEnvironment } from './IsographEnvironment';
 import { IsographEntrypoint, NormalizationAst, NormalizationLinkedField, NormalizationScalarField, RefetchQueryNormalizationArtifactWrapper } from '../core/entrypoint';
 import { ReaderLinkedField, ReaderScalarField } from './reader';
@@ -10,14 +9,14 @@ declare global {
         __LOG: boolean;
     }
 }
-export declare function getOrCreateCache<T>(environment: IsographEnvironment, index: string, factory: Factory<T>): ParentCache<T>;
+export declare function getOrCreateItemInSuspenseCache<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, index: string, factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
 /**
  * Creates a copy of the provided value, ensuring any nested objects have their
  * keys sorted such that equivalent values would have identical JSON.stringify
  * results.
  */
 export declare function stableCopy<T>(value: T): T;
-export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<PromiseWrapper<void, AnyError>>;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>>;
 type NetworkResponseScalarValue = string | number | boolean;
 type NetworkResponseValue = NetworkResponseScalarValue | null | NetworkResponseObject | NetworkResponseObject[] | NetworkResponseScalarValue[];
 type NetworkResponseObject = {

package/dist/core/cache.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.subscribeToAnyChange = exports.normalizeData = exports.getOrCreateCacheForArtifact = exports.stableCopy = exports.getOrCreateCache = void 0;
+exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.subscribeToAnyChange = exports.normalizeData = exports.getOrCreateCacheForArtifact = exports.stableCopy = exports.getOrCreateItemInSuspenseCache = void 0;
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const IsographEnvironment_1 = require("./IsographEnvironment");
 const read_1 = require("./read");
 const areEqualWithDeepComparison_1 = require("./areEqualWithDeepComparison");
 const makeNetworkRequest_1 = require("./makeNetworkRequest");
 const TYPENAME_FIELD_NAME = '__typename';
-function getOrCreateCache(environment, index, factory) {
+function getOrCreateItemInSuspenseCache(environment, index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('getting cache for', {
             index,
-            cache: Object.keys(environment.suspenseCache),
-            found: !!environment.suspenseCache[index],
+            cache: Object.keys(environment.fragmentCache),
+            found: !!environment.fragmentCache[index],
         });
     }
-    if (environment.suspenseCache[index] == null) {
-        environment.suspenseCache[index] = new react_disposable_state_1.ParentCache(factory);
+    if (environment.fragmentCache[index] == null) {
+        environment.fragmentCache[index] = new react_disposable_state_1.ParentCache(factory);
     }
-    return environment.suspenseCache[index];
+    return environment.fragmentCache[index];
 }
-exports.getOrCreateCache = getOrCreateCache;
+exports.getOrCreateItemInSuspenseCache = getOrCreateItemInSuspenseCache;
 /**
  * Creates a copy of the provided value, ensuring any nested objects have their
  * keys sorted such that equivalent values would have identical JSON.stringify
@@ -43,10 +43,24 @@ function stableCopy(value) {
     return stable;
 }
 exports.stableCopy = stableCopy;
-function getOrCreateCacheForArtifact(environment, artifact, variables) {
-    const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-    const factory = () => (0, makeNetworkRequest_1.makeNetworkRequest)(environment, artifact, variables);
-    return getOrCreateCache(environment, cacheKey, factory);
+function getOrCreateCacheForArtifact(environment, entrypoint, variables) {
+    const cacheKey = entrypoint.queryText + JSON.stringify(stableCopy(variables));
+    const factory = () => {
+        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
+        const itemCleanupPair = [
+            {
+                kind: 'FragmentReference',
+                readerArtifact: entrypoint.readerArtifact,
+                root: IsographEnvironment_1.ROOT_ID,
+                variables,
+                nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+                networkRequest: networkRequest,
+            },
+            disposeNetworkRequest,
+        ];
+        return itemCleanupPair;
+    };
+    return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
 }
 exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
 function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {

package/dist/loadable-hooks/useClientSideDefer.d.ts

@@ -1,4 +1,4 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { LoadableField } from '../core/reader';
-export declare function useClientSideDefer<TResult>(loadableField: LoadableField<void, TResult>): FragmentReference<any, TResult>;
-export declare function useClientSideDefer<TArgs, TResult>(loadableField: LoadableField<TArgs, TResult>, args: TArgs): FragmentReference<any, TResult>;
+export declare function useClientSideDefer<TResult>(loadableField: LoadableField<void, TResult>): FragmentReference<Record<string, never>, TResult>;
+export declare function useClientSideDefer<TArgs extends Object, TResult>(loadableField: LoadableField<TArgs, TResult>, args: TArgs): FragmentReference<TArgs, TResult>;

package/dist/loadable-hooks/useClientSideDefer.js

@@ -8,7 +8,7 @@ function useClientSideDefer(loadableField, args) {
     // @ts-expect-error args is missing iff it has the type void
     const [id, loader] = loadableField(args);
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const cache = (0, cache_1.getOrCreateCache)(environment, id, loader);
+    const cache = (0, cache_1.getOrCreateItemInSuspenseCache)(environment, id, loader);
     const fragmentReference = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
     return fragmentReference;
 }

package/dist/react/useLazyReference.js

@@ -2,22 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLazyReference = void 0;
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-const IsographEnvironment_1 = require("../core/IsographEnvironment");
 const cache_1 = require("../core/cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 function useLazyReference(entrypoint, variables) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
-    const networkRequest = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
     return {
-        fragmentReference: {
-            kind: 'FragmentReference',
-            readerArtifact: entrypoint.readerArtifact,
-            root: IsographEnvironment_1.ROOT_ID,
-            variables,
-            nestedRefetchQueries: entrypoint.nestedRefetchQueries,
-            networkRequest,
-        },
+        fragmentReference: (0, react_disposable_state_1.useLazyDisposableState)(cache).state,
     };
 }
 exports.useLazyReference = useLazyReference;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-edade9ce",
+  "version": "0.0.0-main-d6741831",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-edade9ce",
-    "@isograph/react-disposable-state": "0.0.0-main-edade9ce",
-    "@isograph/reference-counted-pointer": "0.0.0-main-edade9ce",
+    "@isograph/disposable-types": "0.0.0-main-d6741831",
+    "@isograph/react-disposable-state": "0.0.0-main-d6741831",
+    "@isograph/reference-counted-pointer": "0.0.0-main-d6741831",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/core/IsographEnvironment.ts

@@ -27,7 +27,7 @@ type AnyRecordSubscription = {
 
 type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
-type SuspenseCache = { [index: string]: ParentCache<any> };
+type CacheMap<T> = { [index: string]: ParentCache<T> };
 
 export type IsographEnvironment = {
   readonly store: IsographStore;
@@ -35,7 +35,9 @@ export type IsographEnvironment = {
   readonly missingFieldHandler: MissingFieldHandler | null;
   readonly componentCache: ComponentCache;
   readonly subscriptions: Subscriptions;
-  readonly suspenseCache: SuspenseCache;
+  // N.B. this must be <any, any>, but all *usages* of this should go through
+  // a function that adds type parameters.
+  readonly fragmentCache: CacheMap<FragmentReference<any, any>>;
   readonly retainedQueries: Set<RetainedQuery>;
   readonly gcBuffer: Array<RetainedQuery>;
   readonly gcBufferSize: number;
@@ -100,7 +102,7 @@ export function createIsographEnvironment(
     missingFieldHandler: missingFieldHandler ?? null,
     componentCache: {},
     subscriptions: new Set(),
-    suspenseCache: {},
+    fragmentCache: {},
     retainedQueries: new Set(),
     gcBuffer: [],
     gcBufferSize: DEFAULT_GC_BUFFER_SIZE,

package/src/core/cache.ts

@@ -1,5 +1,8 @@
-import { Factory, ParentCache } from '@isograph/react-disposable-state';
-import { AnyError, PromiseWrapper } from './PromiseWrapper';
+import {
+  Factory,
+  ItemCleanupPair,
+  ParentCache,
+} from '@isograph/react-disposable-state';
 import {
   DataId,
   ROOT_ID,
@@ -33,23 +36,26 @@ declare global {
   }
 }
 
-export function getOrCreateCache<T>(
+export function getOrCreateItemInSuspenseCache<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+>(
   environment: IsographEnvironment,
   index: string,
-  factory: Factory<T>,
-): ParentCache<T> {
+  factory: Factory<FragmentReference<TReadFromStore, TClientFieldValue>>,
+): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {
   if (typeof window !== 'undefined' && window.__LOG) {
     console.log('getting cache for', {
       index,
-      cache: Object.keys(environment.suspenseCache),
-      found: !!environment.suspenseCache[index],
+      cache: Object.keys(environment.fragmentCache),
+      found: !!environment.fragmentCache[index],
     });
   }
-  if (environment.suspenseCache[index] == null) {
-    environment.suspenseCache[index] = new ParentCache(factory);
+  if (environment.fragmentCache[index] == null) {
+    environment.fragmentCache[index] = new ParentCache(factory);
   }
 
-  return environment.suspenseCache[index];
+  return environment.fragmentCache[index];
 }
 
 /**
@@ -79,12 +85,32 @@ export function getOrCreateCacheForArtifact<
   TClientFieldValue,
 >(
   environment: IsographEnvironment,
-  artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
+  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
   variables: Variables,
-): ParentCache<PromiseWrapper<void, AnyError>> {
-  const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-  const factory = () => makeNetworkRequest(environment, artifact, variables);
-  return getOrCreateCache(environment, cacheKey, factory);
+): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {
+  const cacheKey = entrypoint.queryText + JSON.stringify(stableCopy(variables));
+  const factory = () => {
+    const [networkRequest, disposeNetworkRequest] = makeNetworkRequest(
+      environment,
+      entrypoint,
+      variables,
+    );
+    const itemCleanupPair: ItemCleanupPair<
+      FragmentReference<TReadFromStore, TClientFieldValue>
+    > = [
+      {
+        kind: 'FragmentReference',
+        readerArtifact: entrypoint.readerArtifact,
+        root: ROOT_ID,
+        variables,
+        nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+        networkRequest: networkRequest,
+      },
+      disposeNetworkRequest,
+    ];
+    return itemCleanupPair;
+  };
+  return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
 }
 
 type NetworkResponseScalarValue = string | number | boolean;

package/src/loadable-hooks/useClientSideDefer.ts

@@ -1,27 +1,26 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
-import { getOrCreateCache } from '../core/cache';
+import { getOrCreateItemInSuspenseCache } from '../core/cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
 import { LoadableField } from '../core/reader';
 
 export function useClientSideDefer<TResult>(
   loadableField: LoadableField<void, TResult>,
-): FragmentReference<any, TResult>;
+): FragmentReference<Record<string, never>, TResult>;
 
-export function useClientSideDefer<TArgs, TResult>(
+export function useClientSideDefer<TArgs extends Object, TResult>(
   loadableField: LoadableField<TArgs, TResult>,
   args: TArgs,
-): FragmentReference<any, TResult>;
+): FragmentReference<TArgs, TResult>;
 
-export function useClientSideDefer<TArgs, TResult>(
+export function useClientSideDefer<TArgs extends Object, TResult>(
   loadableField: LoadableField<TArgs, TResult>,
   args?: TArgs,
-  // TODO this should return { fragmentReference, networkRequestReference }
-): FragmentReference<any, TResult> {
+): FragmentReference<TArgs, TResult> {
   // @ts-expect-error args is missing iff it has the type void
   const [id, loader] = loadableField(args);
   const environment = useIsographEnvironment();
-  const cache = getOrCreateCache(environment, id, loader);
+  const cache = getOrCreateItemInSuspenseCache(environment, id, loader);
 
   const fragmentReference = useLazyDisposableState(cache).state;
 

package/src/react/useLazyReference.ts

@@ -1,6 +1,5 @@
 import { FragmentReference, Variables } from '../core/FragmentReference';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
-import { ROOT_ID } from '../core/IsographEnvironment';
 import { IsographEntrypoint } from '../core/entrypoint';
 import { getOrCreateCacheForArtifact } from '../core/cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
@@ -17,16 +16,7 @@ export function useLazyReference<
   const environment = useIsographEnvironment();
   const cache = getOrCreateCacheForArtifact(environment, entrypoint, variables);
 
-  const networkRequest = useLazyDisposableState(cache).state;
-
   return {
-    fragmentReference: {
-      kind: 'FragmentReference',
-      readerArtifact: entrypoint.readerArtifact,
-      root: ROOT_ID,
-      variables,
-      nestedRefetchQueries: entrypoint.nestedRefetchQueries,
-      networkRequest,
-    },
+    fragmentReference: useLazyDisposableState(cache).state,
   };
 }