@isograph/react 0.0.0-main-ae8aa2fe → 0.0.0-main-d3ef6e33

package/dist/core/FragmentReference.d.ts

@@ -1,6 +1,7 @@
 import { DataId } from './IsographEnvironment';
 import { RefetchQueryNormalizationArtifactWrapper } from '../core/entrypoint';
 import { TopLevelReaderArtifact } from './reader';
+import { PromiseWrapper } from './PromiseWrapper';
 export type VariableValue = string | number | boolean | null | object;
 export type Variables = {
     readonly [index: string]: VariableValue;
@@ -11,4 +12,5 @@ export type FragmentReference<TReadFromStore extends Object, TClientFieldValue>
     readonly root: DataId;
     readonly variables: Variables | null;
     readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
+    readonly networkRequest: PromiseWrapper<void, any>;
 };

package/dist/core/PromiseWrapper.d.ts

@@ -1,13 +1,26 @@
+export type AnyError = any;
 declare const NOT_SET: Symbol;
 type NotSet = typeof NOT_SET;
+type Result<T, E> = {
+    kind: 'Ok';
+    value: T;
+} | {
+    kind: 'Err';
+    error: E;
+};
 /**
  * Invariant:
  * Before the promise is resolved, value becomes non-null.
  */
-export type PromiseWrapper<T> = {
+export type PromiseWrapper<T, E> = {
     readonly promise: Promise<T>;
-    value: Exclude<T, NotSet> | NotSet;
+    result: Result<Exclude<T, NotSet>, E> | NotSet;
 };
-export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T>;
-export declare function useReadPromise<T>(p: PromiseWrapper<T>): T;
+export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T, any>;
+export declare function readPromise<T, E>(p: PromiseWrapper<T, E>): T;
+export type PromiseState<T, E> = {
+    kind: 'Pending';
+    promise: Promise<T>;
+} | Result<T, E>;
+export declare function getPromiseState<T, E>(p: PromiseWrapper<T, E>): PromiseState<T, E>;
 export {};

package/dist/core/PromiseWrapper.js

@@ -1,22 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReadPromise = exports.wrapPromise = void 0;
+exports.getPromiseState = exports.readPromise = exports.wrapPromise = void 0;
 const NOT_SET = Symbol('NOT_SET');
 function wrapPromise(promise) {
     // TODO confirm suspense works if the promise is already resolved.
-    const wrapper = { promise, value: NOT_SET };
-    promise.then((v) => {
-        // T is assignable to Exclude<T, Symbol> | Symbol
-        wrapper.value = v;
+    const wrapper = { promise, result: NOT_SET };
+    promise
+        .then((v) => {
+        // v is assignable to Exclude<T, Symbol> | Symbol
+        wrapper.result = { kind: 'Ok', value: v };
+    })
+        .catch((e) => {
+        // e is assignable to Exclude<T, Symbol> | Symbol
+        wrapper.result = { kind: 'Err', error: e };
     });
     return wrapper;
 }
 exports.wrapPromise = wrapPromise;
-function useReadPromise(p) {
-    if (p.value !== NOT_SET) {
-        // Safety: p.value is either NOT_SET or an actual value.
-        return p.value;
+function readPromise(p) {
+    const { result } = p;
+    if (result !== NOT_SET) {
+        // Safety: p.result is either NOT_SET or an actual value.
+        const resultKind = result;
+        if (resultKind.kind === 'Ok') {
+            return resultKind.value;
+        }
+        else {
+            throw resultKind.error;
+        }
     }
     throw p.promise;
 }
-exports.useReadPromise = useReadPromise;
+exports.readPromise = readPromise;
+function getPromiseState(p) {
+    const { result } = p;
+    if (result !== NOT_SET) {
+        // Safety: p.result is either NOT_SET or an actual value.
+        const resultKind = result;
+        return resultKind;
+    }
+    return {
+        kind: 'Pending',
+        promise: p.promise,
+    };
+}
+exports.getPromiseState = getPromiseState;

package/dist/core/cache.d.ts

@@ -1,5 +1,5 @@
 import { Factory, ParentCache } from '@isograph/react-disposable-state';
-import { PromiseWrapper } from './PromiseWrapper';
+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';
@@ -17,7 +17,7 @@ export declare function getOrCreateCache<T>(environment: IsographEnvironment, in
  * 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<TClientFieldValue>>;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): ParentCache<PromiseWrapper<void, AnyError>>;
 type NetworkResponseScalarValue = string | number | boolean;
 type NetworkResponseValue = NetworkResponseScalarValue | null | NetworkResponseObject | NetworkResponseObject[] | NetworkResponseScalarValue[];
 type NetworkResponseObject = {

package/dist/core/cache.js

@@ -96,15 +96,41 @@ function onNextChange(environment) {
     });
 }
 exports.onNextChange = onNextChange;
+// Calls to readButDoNotEvaluate can suspend (i.e. throw a promise).
+// Maybe in the future, they will be able to throw errors.
+//
+// That's probably okay to ignore. We don't, however, want to prevent
+// updating other subscriptions if one subscription had missing data.
+function withErrorHandling(f) {
+    return (t) => {
+        try {
+            return f(t);
+        }
+        catch (_a) { }
+    };
+}
 function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
-    environment.subscriptions.forEach((subscription) => {
+    environment.subscriptions.forEach(withErrorHandling((subscription) => {
         switch (subscription.kind) {
             case 'FragmentSubscription': {
                 // TODO if there are multiple components subscribed to the same
                 // fragment, we will call readButNotEvaluate multiple times. We
                 // should fix that.
                 if (hasOverlappingIds(recordsEncounteredWhenNormalizing, subscription.encounteredDataAndRecords.encounteredRecords)) {
-                    const newEncounteredDataAndRecords = (0, read_1.readButDoNotEvaluate)(environment, subscription.fragmentReference);
+                    const newEncounteredDataAndRecords = (0, read_1.readButDoNotEvaluate)(environment, subscription.fragmentReference, 
+                    // Is this wrong?
+                    // Reasons to think no:
+                    // - we are only updating the read-out value, and the network
+                    //   options only affect whether we throw.
+                    // - the component will re-render, and re-throw on its own, anyway.
+                    //
+                    // Reasons to think not:
+                    // - it seems more efficient to suspend here and not update state,
+                    //   if we expect that the component will just throw anyway
+                    // - consistency
+                    // - it's also weird, this is called from makeNetworkRequest, where
+                    //   we don't currently pass network request options
+                    {});
                     if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item)) {
                         if (typeof window !== 'undefined' && window.__LOG) {
                             console.log('Deep equality - No', {
@@ -137,7 +163,7 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
                 throw new Error('Unexpected case');
             }
         }
-    });
+    }));
 }
 function hasOverlappingIds(set1, set2) {
     for (const id of set1) {
@@ -309,12 +335,13 @@ function getParentRecordKey(astNode, variables) {
 }
 exports.getParentRecordKey = getParentRecordKey;
 function getStoreKeyChunkForArgumentValue(argumentValue, variables) {
+    var _a;
     switch (argumentValue.kind) {
         case 'Literal': {
             return argumentValue.value;
         }
         case 'Variable': {
-            return variables[argumentValue.name];
+            return (_a = variables[argumentValue.name]) !== null && _a !== void 0 ? _a : 'null';
         }
         case 'String': {
             return argumentValue.value;

package/dist/core/componentCache.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="react" />
 import { IsographEnvironment } from './IsographEnvironment';
 import { FragmentReference } from './FragmentReference';
-export declare function getOrCreateCachedComponent(environment: IsographEnvironment, componentName: string, fragmentReference: FragmentReference<any, any>): React.FC<any>;
+import { NetworkRequestReaderOptions } from './read';
+export declare function getOrCreateCachedComponent(environment: IsographEnvironment, componentName: string, fragmentReference: FragmentReference<any, any>, networkRequestOptions: NetworkRequestReaderOptions): React.FC<any>;

package/dist/core/componentCache.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrCreateCachedComponent = void 0;
 const cache_1 = require("./cache");
 const useReadAndSubscribe_1 = require("../react/useReadAndSubscribe");
-function getOrCreateCachedComponent(environment, componentName, fragmentReference) {
+function getOrCreateCachedComponent(environment, componentName, fragmentReference, networkRequestOptions) {
     var _a, _b, _c;
     // cachedComponentsById is a three layer cache: id, then component name, then
     // stringified args. These three, together, uniquely identify a read at a given
@@ -18,7 +18,7 @@ function getOrCreateCachedComponent(environment, componentName, fragmentReferenc
     byArgs[stringifiedArgs] =
         (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
             function Component(additionalRuntimeProps) {
-                const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(environment, fragmentReference);
+                const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions);
                 if (typeof window !== 'undefined' && window.__LOG) {
                     console.log('Component re-rendered: ' +
                         componentName +

package/dist/core/entrypoint.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { TopLevelReaderArtifact } from './reader';
 import { Arguments } from './util';
 export type IsographEntrypoint<TReadFromStore extends Object, TClientFieldValue> = {
@@ -37,3 +38,4 @@ export type RefetchQueryNormalizationArtifactWrapper = {
 export declare function assertIsEntrypoint<TReadFromStore extends Object, TClientFieldValue>(value: IsographEntrypoint<TReadFromStore, TClientFieldValue> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TClientFieldValue>;
 export type ExtractReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any> ? X : never;
 export type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, infer X> ? X : never;
+export type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;

package/dist/core/makeNetworkRequest.d.ts

@@ -2,5 +2,5 @@ import { ItemCleanupPair } from '@isograph/disposable-types';
 import { IsographEntrypoint, RefetchQueryNormalizationArtifact } from './entrypoint';
 import { Variables } from './FragmentReference';
 import { IsographEnvironment } from './IsographEnvironment';
-import { PromiseWrapper } from './PromiseWrapper';
-export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>, variables: Variables): ItemCleanupPair<PromiseWrapper<T>>;
+import { AnyError, PromiseWrapper } from './PromiseWrapper';
+export declare function makeNetworkRequest(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>, variables: Variables): ItemCleanupPair<PromiseWrapper<void, AnyError>>;

package/dist/core/makeNetworkRequest.js

@@ -19,6 +19,12 @@ function makeNetworkRequest(environment, artifact, variables) {
         if (typeof window !== 'undefined' && window.__LOG) {
             console.log('network response', artifact, networkResponse);
         }
+        if (networkResponse.errors != null) {
+            // @ts-expect-error Why are we getting the wrong constructor here?
+            throw new Error('GraphQL network response had errors', {
+                cause: networkResponse,
+            });
+        }
         if (status.kind === 'UndisposedIncomplete') {
             (0, cache_1.normalizeData)(environment, artifact.normalizationAst, (_a = networkResponse.data) !== null && _a !== void 0 ? _a : {}, variables, artifact.kind === 'Entrypoint' ? artifact.nestedRefetchQueries : []);
             const retainedQuery = {
@@ -31,8 +37,6 @@ function makeNetworkRequest(environment, artifact, variables) {
             };
             (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
         }
-        // TODO return null
-        return networkResponse;
     });
     const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
     const response = [

package/dist/core/read.d.ts

@@ -4,4 +4,8 @@ export type WithEncounteredRecords<T> = {
     readonly encounteredRecords: Set<DataId>;
     readonly item: T;
 };
-export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown>): WithEncounteredRecords<TReadFromStore>;
+export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
+export type NetworkRequestReaderOptions = {
+    suspendIfInFlight?: boolean;
+    throwOnNetworkError?: boolean;
+};

package/dist/core/read.js

@@ -5,14 +5,31 @@ const cache_1 = require("./cache");
 const componentCache_1 = require("./componentCache");
 const IsographEnvironment_1 = require("./IsographEnvironment");
 const makeNetworkRequest_1 = require("./makeNetworkRequest");
-function readButDoNotEvaluate(environment, reference) {
+function readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions) {
     var _a;
     const mutableEncounteredRecords = new Set();
-    const response = readData(environment, reference.readerArtifact.readerAst, reference.root, (_a = reference.variables) !== null && _a !== void 0 ? _a : {}, reference.nestedRefetchQueries, mutableEncounteredRecords);
+    const response = readData(environment, fragmentReference.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, fragmentReference.nestedRefetchQueries, fragmentReference.networkRequest, networkRequestOptions, mutableEncounteredRecords);
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('done reading', { response });
     }
     if (response.kind === 'MissingData') {
+        // There are two cases here that we care about:
+        // 1. the network request is in flight, we haven't suspend on it, and we want
+        //    to throw if it errors out. So, networkRequestOptions.suspendIfInFlight === false
+        //    and networkRequestOptions.throwOnNetworkError === true.
+        // 2. everything else
+        //
+        // In the first case, we cannot simply throw onNextChange, because if the network
+        // response errors out, we will not update the store, so the onNextChange promise
+        // will not resolve.
+        if (!networkRequestOptions.suspendIfInFlight &&
+            networkRequestOptions.throwOnNetworkError) {
+            // TODO assert that the network request state is not Err
+            throw new Promise((resolve, reject) => {
+                (0, cache_1.onNextChange)(environment).then(resolve);
+                fragmentReference.networkRequest.promise.catch(reject);
+            });
+        }
         throw (0, cache_1.onNextChange)(environment);
     }
     else {
@@ -23,7 +40,7 @@ function readButDoNotEvaluate(environment, reference) {
     }
 }
 exports.readButDoNotEvaluate = readButDoNotEvaluate;
-function readData(environment, ast, root, variables, nestedRefetchQueries, mutableEncounteredRecords) {
+function readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
     var _a, _b, _c, _d, _e;
     mutableEncounteredRecords.add(root);
     let storeRecord = environment.store[root];
@@ -79,7 +96,7 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                             results.push(null);
                             continue;
                         }
-                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries, mutableEncounteredRecords);
+                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
                         if (result.kind === 'MissingData') {
                             return {
                                 kind: 'MissingData',
@@ -122,7 +139,7 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                     break;
                 }
                 const targetId = link.__link;
-                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries, mutableEncounteredRecords);
+                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
                 if (data.kind === 'MissingData') {
                     return {
                         kind: 'MissingData',
@@ -138,7 +155,10 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                 // id field).
                 const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, 
                 // Refetch fields just read the id, and don't need refetch query artifacts
-                [], mutableEncounteredRecords);
+                [], 
+                // This is probably indicative of the fact that we are doing redundant checks
+                // on the status of this network request...
+                networkRequest, networkRequestOptions, mutableEncounteredRecords);
                 if (data.kind === 'MissingData') {
                     return {
                         kind: 'MissingData',
@@ -172,7 +192,7 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                 const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
                 const kind = field.readerArtifact.kind;
                 if (kind === 'EagerReaderArtifact') {
-                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, mutableEncounteredRecords);
+                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
                     if (data.kind === 'MissingData') {
                         return {
                             kind: 'MissingData',
@@ -190,15 +210,16 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                         readerArtifact: field.readerArtifact,
                         root,
                         variables: generateChildVariableMap(variables, field.arguments),
+                        networkRequest,
                         nestedRefetchQueries: resolverRefetchQueries,
-                    });
+                    }, networkRequestOptions);
                 }
                 break;
             }
             case 'LoadablySelectedField': {
                 const refetchReaderParams = readData(environment, field.refetchReaderAst, root, variables, 
                 // Refetch fields just read the id, and don't need refetch query artifacts
-                [], mutableEncounteredRecords);
+                [], networkRequest, networkRequestOptions, mutableEncounteredRecords);
                 if (refetchReaderParams.kind === 'MissingData') {
                     return {
                         kind: 'MissingData',
@@ -207,30 +228,37 @@ function readData(environment, ast, root, variables, nestedRefetchQueries, mutab
                     };
                 }
                 else {
-                    target[field.alias] = (args) => [
-                        // Stable id
-                        root + '__' + field.name,
-                        // Fetcher
-                        () => {
-                            // TODO we should use the reader AST for this
-                            const includeReadOutData = (variables, readOutData) => {
-                                variables.id = readOutData.id;
-                                return variables;
-                            };
-                            const localVariables = includeReadOutData(args !== null && args !== void 0 ? args : {}, refetchReaderParams.data);
-                            writeQueryArgsToVariables(localVariables, field.queryArguments, variables);
-                            const [_networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, field.entrypoint, localVariables);
-                            const fragmentReference = {
-                                kind: 'FragmentReference',
-                                readerArtifact: field.entrypoint.readerArtifact,
-                                // TODO localVariables is not guaranteed to have an id field
-                                root: localVariables.id,
-                                variables: localVariables,
-                                nestedRefetchQueries: field.entrypoint.nestedRefetchQueries,
-                            };
-                            return [fragmentReference, disposeNetworkRequest];
-                        },
-                    ];
+                    target[field.alias] = (args) => {
+                        // TODO we should use the reader AST for this
+                        const includeReadOutData = (variables, readOutData) => {
+                            variables.id = readOutData.id;
+                            return variables;
+                        };
+                        const localVariables = includeReadOutData(args !== null && args !== void 0 ? args : {}, refetchReaderParams.data);
+                        writeQueryArgsToVariables(localVariables, field.queryArguments, variables);
+                        return [
+                            // Stable id
+                            root +
+                                '/' +
+                                field.name +
+                                '/' +
+                                stableStringifyArgs(localVariables),
+                            // Fetcher
+                            () => {
+                                const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, field.entrypoint, localVariables);
+                                const fragmentReference = {
+                                    kind: 'FragmentReference',
+                                    readerArtifact: field.entrypoint.readerArtifact,
+                                    // TODO localVariables is not guaranteed to have an id field
+                                    root: localVariables.id,
+                                    variables: localVariables,
+                                    nestedRefetchQueries: field.entrypoint.nestedRefetchQueries,
+                                    networkRequest,
+                                };
+                                return [fragmentReference, disposeNetworkRequest];
+                            },
+                        ];
+                    };
                 }
                 break;
             }
@@ -301,3 +329,17 @@ function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
         }
     }
 }
+// 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
+// in the demo.
+function stableStringifyArgs(args) {
+    const keys = Object.keys(args);
+    keys.sort();
+    let s = '';
+    for (const key of keys) {
+        // @ts-expect-error
+        s += `${key}=${JSON.stringify(args[key])};`;
+    }
+    return s;
+}

package/dist/index.d.ts

@@ -1,16 +1,16 @@
 export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './core/garbageCollection';
-export { type PromiseWrapper } from './core/PromiseWrapper';
+export { type PromiseWrapper, readPromise, getPromiseState, } from './core/PromiseWrapper';
 export { subscribe, normalizeData } from './core/cache';
 export { makeNetworkRequest } from './core/makeNetworkRequest';
 export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, createIsographEnvironment, createIsographStore, defaultMissingFieldHandler, } from './core/IsographEnvironment';
-export { EagerReaderArtifact, ComponentReaderArtifact, RefetchReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderNonLoadableResolverField, ReaderScalarField, TopLevelReaderArtifact, LoadableField, } from './core/reader';
-export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper, } from './core/entrypoint';
+export { type EagerReaderArtifact, type ComponentReaderArtifact, type RefetchReaderArtifact, type ReaderAst, type ReaderAstNode, type ReaderLinkedField, type ReaderNonLoadableResolverField, type ReaderScalarField, type TopLevelReaderArtifact, type LoadableField, } from './core/reader';
+export { type NormalizationAst, type NormalizationAstNode, type NormalizationLinkedField, type NormalizationScalarField, type IsographEntrypoint, assertIsEntrypoint, type RefetchQueryNormalizationArtifact, type RefetchQueryNormalizationArtifactWrapper, type ExtractProps, type ExtractReadFromStore, type ExtractResolverResult, } from './core/entrypoint';
 export { readButDoNotEvaluate } from './core/read';
-export { ExtractSecondParam, Argument, ArgumentName, ArgumentValue, Arguments, } from './core/util';
-export { type FragmentReference } from './core/FragmentReference';
+export { type ExtractSecondParam, type Argument, type ArgumentName, type ArgumentValue, type Arguments, } from './core/util';
+export { type FragmentReference, type Variables, } from './core/FragmentReference';
 export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './react/IsographEnvironmentProvider';
 export { useImperativeReference } from './react/useImperativeReference';
-export { FragmentReferenceReader } from './react/FragmentReferenceReader';
+export { FragmentReader } from './react/FragmentReader';
 export { useResult } from './react/useResult';
 export { useLazyReference } from './react/useLazyReference';
 export { useRerenderOnChange } from './react/useRerenderOnChange';

package/dist/index.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useClientSideDefer = exports.useRerenderOnChange = exports.useLazyReference = exports.useResult = exports.FragmentReferenceReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.readButDoNotEvaluate = exports.assertIsEntrypoint = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.makeNetworkRequest = exports.normalizeData = exports.subscribe = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
+exports.useClientSideDefer = exports.useRerenderOnChange = exports.useLazyReference = exports.useResult = exports.FragmentReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.readButDoNotEvaluate = exports.assertIsEntrypoint = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.makeNetworkRequest = exports.normalizeData = exports.subscribe = exports.getPromiseState = exports.readPromise = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
 var garbageCollection_1 = require("./core/garbageCollection");
 Object.defineProperty(exports, "retainQuery", { enumerable: true, get: function () { return garbageCollection_1.retainQuery; } });
 Object.defineProperty(exports, "unretainQuery", { enumerable: true, get: function () { return garbageCollection_1.unretainQuery; } });
 Object.defineProperty(exports, "garbageCollectEnvironment", { enumerable: true, get: function () { return garbageCollection_1.garbageCollectEnvironment; } });
+var PromiseWrapper_1 = require("./core/PromiseWrapper");
+Object.defineProperty(exports, "readPromise", { enumerable: true, get: function () { return PromiseWrapper_1.readPromise; } });
+Object.defineProperty(exports, "getPromiseState", { enumerable: true, get: function () { return PromiseWrapper_1.getPromiseState; } });
 var cache_1 = require("./core/cache");
 Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_1.subscribe; } });
 Object.defineProperty(exports, "normalizeData", { enumerable: true, get: function () { return cache_1.normalizeData; } });
@@ -24,8 +27,8 @@ Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true
 Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_1.useIsographEnvironment; } });
 var useImperativeReference_1 = require("./react/useImperativeReference");
 Object.defineProperty(exports, "useImperativeReference", { enumerable: true, get: function () { return useImperativeReference_1.useImperativeReference; } });
-var FragmentReferenceReader_1 = require("./react/FragmentReferenceReader");
-Object.defineProperty(exports, "FragmentReferenceReader", { enumerable: true, get: function () { return FragmentReferenceReader_1.FragmentReferenceReader; } });
+var FragmentReader_1 = require("./react/FragmentReader");
+Object.defineProperty(exports, "FragmentReader", { enumerable: true, get: function () { return FragmentReader_1.FragmentReader; } });
 var useResult_1 = require("./react/useResult");
 Object.defineProperty(exports, "useResult", { enumerable: true, get: function () { return useResult_1.useResult; } });
 var useLazyReference_1 = require("./react/useLazyReference");

package/dist/loadable-hooks/useClientSideDefer.js

@@ -4,7 +4,6 @@ exports.useClientSideDefer = void 0;
 const IsographEnvironmentProvider_1 = require("../react/IsographEnvironmentProvider");
 const cache_1 = require("../core/cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-// TODO allow the user to pass props somehow
 function useClientSideDefer(loadableField, args) {
     // @ts-expect-error args is missing iff it has the type void
     const [id, loader] = loadableField(args);

package/dist/react/{FragmentReferenceReader.d.ts → FragmentReader.d.ts}

@@ -1,10 +1,13 @@
 import * as React from 'react';
 import { ExtractReadFromStore, IsographEntrypoint } from '../core/entrypoint';
 import { FragmentReference } from '../core/FragmentReference';
-export declare function FragmentReferenceReader<TProps extends Record<any, any>, TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>>>(props: TProps extends Record<string, never> ? {
+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;
 } : {
     fragmentReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<TProps>>;
     additionalProps: TProps;
+    networkRequestOptions?: NetworkRequestReaderOptions;
 }): React.ReactNode;

package/dist/react/{FragmentReferenceReader.js → FragmentReader.js}

@@ -23,11 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FragmentReferenceReader = void 0;
+exports.FragmentReader = void 0;
 const React = __importStar(require("react"));
 const useResult_1 = require("./useResult");
-function FragmentReferenceReader(props) {
-    const Component = (0, useResult_1.useResult)(props.fragmentReference);
+function FragmentReader(props) {
+    var _a;
+    const Component = (0, useResult_1.useResult)(props.fragmentReference, (_a = props.networkRequestOptions) !== null && _a !== void 0 ? _a : {});
     return React.createElement(Component, Object.assign({}, props.additionalProps));
 }
-exports.FragmentReferenceReader = FragmentReferenceReader;
+exports.FragmentReader = FragmentReader;

package/dist/react/useImperativeReference.d.ts

@@ -3,5 +3,5 @@ import { IsographEntrypoint } from '../core/entrypoint';
 import { FragmentReference, Variables } from '../core/FragmentReference';
 export declare function useImperativeReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>): {
     fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue> | UnassignedState;
-    loadfragmentReference: (variables: Variables) => void;
+    loadFragmentReference: (variables: Variables) => void;
 };

package/dist/react/useImperativeReference.js

@@ -10,8 +10,8 @@ function useImperativeReference(entrypoint) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     return {
         fragmentReference: state,
-        loadfragmentReference: (variables) => {
-            const [_networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
+        loadFragmentReference: (variables) => {
+            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
             setState([
                 {
                     kind: 'FragmentReference',
@@ -19,6 +19,7 @@ function useImperativeReference(entrypoint) {
                     root: IsographEnvironment_1.ROOT_ID,
                     variables,
                     nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+                    networkRequest,
                 },
                 () => {
                     disposeNetworkRequest();

package/dist/react/useLazyReference.js

@@ -8,9 +8,7 @@ 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);
-    // TODO add comment explaining why we never use this value
-    // @ts-ignore(6133)
-    const _data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
+    const networkRequest = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
     return {
         fragmentReference: {
             kind: 'FragmentReference',
@@ -18,6 +16,7 @@ function useLazyReference(entrypoint, variables) {
             root: IsographEnvironment_1.ROOT_ID,
             variables,
             nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+            networkRequest,
         },
     };
 }

package/dist/react/useReadAndSubscribe.d.ts

@@ -1,7 +1,7 @@
 import { FragmentReference } from '../core/FragmentReference';
-import { IsographEnvironment } from '../core/IsographEnvironment';
+import { NetworkRequestReaderOptions } from '../core/read';
 /**
  * Read the data from a fragment reference and subscribe to updates.
  * Does not pass the data to the fragment reference's resolver function.
  */
-export declare function useReadAndSubscribe<TReadFromStore extends Object>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, any>): TReadFromStore;
+export declare function useReadAndSubscribe<TReadFromStore extends Object>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions): TReadFromStore;