@isograph/react 0.0.0-main-6c4d9bd8 → 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) {
@@ -132,7 +146,10 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
                     // - consistency
                     // - it's also weird, this is called from makeNetworkRequest, where
                     //   we don't currently pass network request options
-                    {});
+                    {
+                        suspendIfInFlight: false,
+                        throwOnNetworkError: false,
+                    });
                     if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item)) {
                         if (typeof window !== 'undefined' && window.__LOG) {
                             console.log('Deep equality - No', {

package/dist/core/read.d.ts

@@ -6,6 +6,7 @@ export type WithEncounteredRecords<T> = {
 };
 export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
 export type NetworkRequestReaderOptions = {
-    suspendIfInFlight?: boolean;
-    throwOnNetworkError?: boolean;
+    suspendIfInFlight: boolean;
+    throwOnNetworkError: boolean;
 };
+export declare function getNetworkRequestOptionsWithDefaults(networkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): NetworkRequestReaderOptions;

package/dist/core/read.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readButDoNotEvaluate = void 0;
+exports.getNetworkRequestOptionsWithDefaults = exports.readButDoNotEvaluate = void 0;
 const cache_1 = require("./cache");
 const componentCache_1 = require("./componentCache");
 const IsographEnvironment_1 = require("./IsographEnvironment");
@@ -329,6 +329,14 @@ function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
         }
     }
 }
+function getNetworkRequestOptionsWithDefaults(networkRequestOptions) {
+    var _a, _b;
+    return {
+        suspendIfInFlight: (_a = networkRequestOptions === null || networkRequestOptions === void 0 ? void 0 : networkRequestOptions.suspendIfInFlight) !== null && _a !== void 0 ? _a : false,
+        throwOnNetworkError: (_b = networkRequestOptions === null || networkRequestOptions === void 0 ? void 0 : networkRequestOptions.throwOnNetworkError) !== null && _b !== void 0 ? _b : true,
+    };
+}
+exports.getNetworkRequestOptionsWithDefaults = getNetworkRequestOptionsWithDefaults;
 // TODO use a description of the params for this?
 // TODO call stableStringifyArgs on the variable values, as well.
 // This doesn't matter for now, since we are just using primitive values

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/FragmentReader.d.ts

@@ -5,9 +5,9 @@ import { NetworkRequestReaderOptions } from '../core/read';
 export declare function FragmentReader<TProps extends Record<any, any>, TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>>>(props: TProps extends Record<string, never> ? {
     fragmentReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<{}>>;
     additionalProps?: TProps;
-    networkRequestOptions?: NetworkRequestReaderOptions;
+    networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
 } : {
     fragmentReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<TProps>>;
     additionalProps: TProps;
-    networkRequestOptions?: NetworkRequestReaderOptions;
+    networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
 }): React.ReactNode;

package/dist/react/FragmentReader.js

@@ -27,8 +27,7 @@ exports.FragmentReader = void 0;
 const React = __importStar(require("react"));
 const useResult_1 = require("./useResult");
 function FragmentReader(props) {
-    var _a;
-    const Component = (0, useResult_1.useResult)(props.fragmentReference, (_a = props.networkRequestOptions) !== null && _a !== void 0 ? _a : {});
+    const Component = (0, useResult_1.useResult)(props.fragmentReference, props.networkRequestOptions);
     return React.createElement(Component, Object.assign({}, props.additionalProps));
 }
 exports.FragmentReader = FragmentReader;

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/dist/react/useResult.d.ts

@@ -1,5 +1,5 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { NetworkRequestReaderOptions } from '../core/read';
 import { PromiseWrapper } from '../core/PromiseWrapper';
-export declare function useResult<TReadFromStore extends Object, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, networkRequestOptions: NetworkRequestReaderOptions): TClientFieldValue;
+export declare function useResult<TReadFromStore extends Object, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
 export declare function maybeUnwrapNetworkRequest(networkRequest: PromiseWrapper<void, any>, networkRequestOptions: NetworkRequestReaderOptions): void;

package/dist/react/useResult.js

@@ -4,9 +4,11 @@ exports.maybeUnwrapNetworkRequest = exports.useResult = void 0;
 const IsographEnvironmentProvider_1 = require("../react/IsographEnvironmentProvider");
 const componentCache_1 = require("../core/componentCache");
 const useReadAndSubscribe_1 = require("./useReadAndSubscribe");
+const read_1 = require("../core/read");
 const PromiseWrapper_1 = require("../core/PromiseWrapper");
-function useResult(fragmentReference, networkRequestOptions) {
+function useResult(fragmentReference, partialNetworkRequestOptions) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    const networkRequestOptions = (0, read_1.getNetworkRequestOptionsWithDefaults)(partialNetworkRequestOptions);
     maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
     switch (fragmentReference.readerArtifact.kind) {
         case 'ComponentReaderArtifact': {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-6c4d9bd8",
+  "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-6c4d9bd8",
-    "@isograph/react-disposable-state": "0.0.0-main-6c4d9bd8",
-    "@isograph/reference-counted-pointer": "0.0.0-main-6c4d9bd8",
+    "@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;
@@ -226,7 +252,10 @@ function callSubscriptions(
               // - consistency
               // - it's also weird, this is called from makeNetworkRequest, where
               //   we don't currently pass network request options
-              {},
+              {
+                suspendIfInFlight: false,
+                throwOnNetworkError: false,
+              },
             );
 
             if (

package/src/core/read.ts

@@ -468,10 +468,19 @@ function writeQueryArgsToVariables(
 }
 
 export type NetworkRequestReaderOptions = {
-  suspendIfInFlight?: boolean;
-  throwOnNetworkError?: boolean;
+  suspendIfInFlight: boolean;
+  throwOnNetworkError: boolean;
 };
 
+export function getNetworkRequestOptionsWithDefaults(
+  networkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,
+): NetworkRequestReaderOptions {
+  return {
+    suspendIfInFlight: networkRequestOptions?.suspendIfInFlight ?? false,
+    throwOnNetworkError: networkRequestOptions?.throwOnNetworkError ?? true,
+  };
+}
+
 // TODO use a description of the params for this?
 // TODO call stableStringifyArgs on the variable values, as well.
 // This doesn't matter for now, since we are just using primitive values

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/FragmentReader.tsx

@@ -15,7 +15,7 @@ export function FragmentReader<
           React.FC<{}>
         >;
         additionalProps?: TProps;
-        networkRequestOptions?: NetworkRequestReaderOptions;
+        networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
       }
     : {
         fragmentReference: FragmentReference<
@@ -23,12 +23,12 @@ export function FragmentReader<
           React.FC<TProps>
         >;
         additionalProps: TProps;
-        networkRequestOptions?: NetworkRequestReaderOptions;
+        networkRequestOptions?: Partial<NetworkRequestReaderOptions>;
       },
 ): React.ReactNode {
   const Component = useResult(
     props.fragmentReference,
-    props.networkRequestOptions ?? {},
+    props.networkRequestOptions,
   );
   return <Component {...props.additionalProps} />;
 }

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,
   };
 }

package/src/react/useResult.ts

@@ -2,14 +2,20 @@ import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
 import { FragmentReference } from '../core/FragmentReference';
 import { getOrCreateCachedComponent } from '../core/componentCache';
 import { useReadAndSubscribe } from './useReadAndSubscribe';
-import { NetworkRequestReaderOptions } from '../core/read';
+import {
+  getNetworkRequestOptionsWithDefaults,
+  NetworkRequestReaderOptions,
+} from '../core/read';
 import { getPromiseState, PromiseWrapper } from '../core/PromiseWrapper';
 
 export function useResult<TReadFromStore extends Object, TClientFieldValue>(
   fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,
-  networkRequestOptions: NetworkRequestReaderOptions,
+  partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,
 ): TClientFieldValue {
   const environment = useIsographEnvironment();
+  const networkRequestOptions = getNetworkRequestOptionsWithDefaults(
+    partialNetworkRequestOptions,
+  );
 
   maybeUnwrapNetworkRequest(
     fragmentReference.networkRequest,