@isograph/react 0.5.0 → 0.5.1

package/dist/core/read.js

@@ -1,676 +1,461 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readButDoNotEvaluate = readButDoNotEvaluate;
-exports.readLoadablySelectedFieldData = readLoadablySelectedFieldData;
-exports.readResolverFieldData = readResolverFieldData;
-exports.readScalarFieldData = readScalarFieldData;
-exports.readLinkedFieldData = readLinkedFieldData;
-exports.readClientPointerData = readClientPointerData;
-exports.getNetworkRequestOptionsWithDefaults = getNetworkRequestOptionsWithDefaults;
-exports.readImperativelyLoadedField = readImperativelyLoadedField;
-const cache_1 = require("./cache");
-const componentCache_1 = require("./componentCache");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-const logging_1 = require("./logging");
-const makeNetworkRequest_1 = require("./makeNetworkRequest");
-const optimisticProxy_1 = require("./optimisticProxy");
-const PromiseWrapper_1 = require("./PromiseWrapper");
-const startUpdate_1 = require("./startUpdate");
+const require_PromiseWrapper = require('./PromiseWrapper.js');
+const require_IsographEnvironment = require('./IsographEnvironment.js');
+const require_logging = require('./logging.js');
+const require_startUpdate = require('./startUpdate.js');
+const require_componentCache = require('./componentCache.js');
+const require_makeNetworkRequest = require('./makeNetworkRequest.js');
+const require_optimisticProxy = require('./optimisticProxy.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/read.ts
 function readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions) {
-    var _a;
-    const mutableEncounteredRecords = new Map();
-    // TODO consider moving this to the outside
-    const readerWithRefetchQueries = (0, PromiseWrapper_1.readPromise)(fragmentReference.readerWithRefetchQueries);
-    const response = readData(environment, readerWithRefetchQueries.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, readerWithRefetchQueries.nestedRefetchQueries, fragmentReference.networkRequest, networkRequestOptions, mutableEncounteredRecords);
-    (0, logging_1.logMessage)(environment, () => ({
-        kind: 'DoneReading',
-        response,
-        fieldName: readerWithRefetchQueries.readerArtifact.fieldName,
-        root: fragmentReference.root,
-    }));
-    if (response.kind === 'MissingData') {
-        // There are two cases here that we care about:
-        // 1. the network request is in flight, we haven't suspended 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) {
-            // What are we doing here? If the network response has errored out, we can do
-            // two things: throw a rejected promise, or throw an error. Both work identically
-            // in the browser. However, during initial SSR on NextJS, throwing a rejected
-            // promise results in an infinite loop (including re-issuing the query until the
-            // process OOM's or something.) Hence, we throw an error.
-            const result = fragmentReference.networkRequest.result;
-            if (result !== PromiseWrapper_1.NOT_SET && result.kind === 'Err') {
-                throw new Error('NetworkError', { cause: result.error });
-            }
-            throw new Promise((resolve, reject) => {
-                (0, cache_1.onNextChangeToRecord)(environment, response.recordLink).then(resolve);
-                fragmentReference.networkRequest.promise.catch(reject);
-            });
-        }
-        throw (0, cache_1.onNextChangeToRecord)(environment, response.recordLink);
-    }
-    else {
-        return {
-            encounteredRecords: mutableEncounteredRecords,
-            item: response.data,
-        };
-    }
+	const mutableEncounteredRecords = /* @__PURE__ */ new Map();
+	const readerWithRefetchQueries = require_PromiseWrapper.readPromise(fragmentReference.readerWithRefetchQueries);
+	const response = readData(environment, readerWithRefetchQueries.readerArtifact.readerAst, fragmentReference.root, fragmentReference.variables ?? {}, readerWithRefetchQueries.nestedRefetchQueries, fragmentReference.networkRequest, networkRequestOptions, mutableEncounteredRecords);
+	require_logging.logMessage(environment, () => ({
+		kind: "DoneReading",
+		response,
+		fieldName: readerWithRefetchQueries.readerArtifact.fieldName,
+		root: fragmentReference.root
+	}));
+	if (response.kind === "MissingData") {
+		if (!networkRequestOptions.suspendIfInFlight && networkRequestOptions.throwOnNetworkError) {
+			const result = fragmentReference.networkRequest.result;
+			if (result !== require_PromiseWrapper.NOT_SET && result.kind === "Err") throw new Error("NetworkError", { cause: result.error });
+			throw new Promise((resolve, reject) => {
+				require_cache.onNextChangeToRecord(environment, response.recordLink).then(resolve);
+				fragmentReference.networkRequest.promise.catch(reject);
+			});
+		}
+		throw require_cache.onNextChangeToRecord(environment, response.recordLink);
+	} else return {
+		encounteredRecords: mutableEncounteredRecords,
+		item: response.data
+	};
 }
 function readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
-    var _a, _b;
-    const encounteredIds = (0, cache_1.insertEmptySetIfMissing)(mutableEncounteredRecords, root.__typename);
-    encounteredIds.add(root.__link);
-    let storeRecord = (0, optimisticProxy_1.getStoreRecordProxy)(environment.store, root);
-    if (storeRecord === undefined) {
-        return {
-            kind: 'MissingData',
-            reason: 'No record for root ' + root.__link,
-            recordLink: root,
-        };
-    }
-    if (storeRecord === null) {
-        return {
-            kind: 'Success',
-            data: null,
-        };
-    }
-    let target = {};
-    for (const field of ast) {
-        switch (field.kind) {
-            case 'Scalar': {
-                const data = readScalarFieldData(field, storeRecord, root, variables);
-                if (data.kind === 'MissingData') {
-                    return data;
-                }
-                target[(_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName] = data.data;
-                break;
-            }
-            case 'Link': {
-                target[field.alias] = root;
-                break;
-            }
-            case 'Linked': {
-                const data = readLinkedFieldData(environment, field, storeRecord, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, (ast, root) => readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords));
-                if (data.kind === 'MissingData') {
-                    return data;
-                }
-                target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = data.data;
-                break;
-            }
-            case 'ImperativelyLoadedField': {
-                const data = readImperativelyLoadedField(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                if (data.kind === 'MissingData') {
-                    return data;
-                }
-                target[field.alias] = data.data;
-                break;
-            }
-            case 'Resolver': {
-                const data = readResolverFieldData(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                if (data.kind === 'MissingData') {
-                    return data;
-                }
-                target[field.alias] = data.data;
-                break;
-            }
-            case 'LoadablySelectedField': {
-                const data = readLoadablySelectedFieldData(environment, field, root, variables, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-                if (data.kind === 'MissingData') {
-                    return data;
-                }
-                target[field.alias] = data.data;
-                break;
-            }
-            default: {
-                // Ensure we have covered all variants
-                let _ = field;
-                _;
-                throw new Error('Unexpected case.');
-            }
-        }
-    }
-    return {
-        kind: 'Success',
-        data: target,
-    };
+	require_cache.insertEmptySetIfMissing(mutableEncounteredRecords, root.__typename).add(root.__link);
+	let storeRecord = require_optimisticProxy.getStoreRecordProxy(environment.store, root);
+	if (storeRecord === void 0) return {
+		kind: "MissingData",
+		reason: "No record for root " + root.__link,
+		recordLink: root
+	};
+	if (storeRecord == null) return {
+		kind: "Success",
+		data: null
+	};
+	let target = {};
+	for (const field of ast) switch (field.kind) {
+		case "Scalar": {
+			const data = readScalarFieldData(field, storeRecord, root, variables);
+			if (data.kind === "MissingData") return data;
+			target[field.alias ?? field.fieldName] = data.data;
+			break;
+		}
+		case "Link":
+			target[field.alias] = root;
+			break;
+		case "Linked": {
+			const data = readLinkedFieldData(environment, field, storeRecord, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, (ast$1, root$1) => readData(environment, ast$1, root$1, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords));
+			if (data.kind === "MissingData") return data;
+			target[field.alias ?? field.fieldName] = data.data;
+			break;
+		}
+		case "ImperativelyLoadedField": {
+			const data = readImperativelyLoadedField(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+			if (data.kind === "MissingData") return data;
+			target[field.alias] = data.data;
+			break;
+		}
+		case "Resolver": {
+			const data = readResolverFieldData(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+			if (data.kind === "MissingData") return data;
+			target[field.alias] = data.data;
+			break;
+		}
+		case "LoadablySelectedField": {
+			const data = readLoadablySelectedFieldData(environment, field, root, variables, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+			if (data.kind === "MissingData") return data;
+			target[field.alias] = data.data;
+			break;
+		}
+	}
+	return {
+		kind: "Success",
+		data: target
+	};
 }
 function readLoadablySelectedFieldData(environment, field, root, variables, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
-    const refetchReaderParams = readData(environment, field.refetchReaderAst, root, variables, 
-    // Refetch fields just read the id, and don't need refetch query artifacts
-    [], networkRequest, networkRequestOptions, mutableEncounteredRecords);
-    if (refetchReaderParams.kind === 'MissingData') {
-        return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
-            nestedReason: refetchReaderParams,
-            recordLink: refetchReaderParams.recordLink,
-        };
-    }
-    return {
-        kind: 'Success',
-        data: (args, 
-        // TODO get the associated type for FetchOptions from the loadably selected field
-        fetchOptions) => {
-            // 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.__typename +
-                    ':' +
-                    root.__link +
-                    '/' +
-                    field.name +
-                    '/' +
-                    stableStringifyArgs(localVariables),
-                // Fetcher
-                () => {
-                    const fragmentReferenceAndDisposeFromEntrypoint = (entrypoint) => {
-                        const { fieldName, readerArtifactKind, readerWithRefetchQueries } = (0, IsographEnvironment_1.getOrLoadReaderWithRefetchQueries)(environment, entrypoint.readerWithRefetchQueries);
-                        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, localVariables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
-                        const fragmentReference = {
-                            kind: 'FragmentReference',
-                            readerWithRefetchQueries,
-                            fieldName,
-                            readerArtifactKind,
-                            // TODO localVariables is not guaranteed to have an id field
-                            root,
-                            variables: localVariables,
-                            networkRequest,
-                        };
-                        return [fragmentReference, disposeNetworkRequest];
-                    };
-                    if (field.entrypoint.kind === 'Entrypoint') {
-                        return fragmentReferenceAndDisposeFromEntrypoint(field.entrypoint);
-                    }
-                    else {
-                        const isographArtifactPromiseWrapper = (0, IsographEnvironment_1.getOrLoadIsographArtifact)(environment, field.entrypoint.typeAndField, field.entrypoint.loader);
-                        const state = (0, PromiseWrapper_1.getPromiseState)(isographArtifactPromiseWrapper);
-                        if (state.kind === 'Ok') {
-                            return fragmentReferenceAndDisposeFromEntrypoint(state.value);
-                        }
-                        else {
-                            // Promise is pending or thrown
-                            let entrypointLoaderState = { kind: 'EntrypointNotLoaded' };
-                            const readerWithRefetchQueries = (0, PromiseWrapper_1.wrapPromise)(isographArtifactPromiseWrapper.promise.then((entrypoint) => (0, IsographEnvironment_1.getOrLoadReaderWithRefetchQueries)(environment, entrypoint.readerWithRefetchQueries).readerWithRefetchQueries.promise));
-                            const networkRequest = (0, PromiseWrapper_1.wrapPromise)(isographArtifactPromiseWrapper.promise.then((entrypoint) => {
-                                if (entrypointLoaderState.kind === 'EntrypointNotLoaded') {
-                                    const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, localVariables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
-                                    entrypointLoaderState = {
-                                        kind: 'NetworkRequestStarted',
-                                        disposeNetworkRequest,
-                                    };
-                                    return networkRequest.promise;
-                                }
-                            }));
-                            const fragmentReference = {
-                                kind: 'FragmentReference',
-                                readerWithRefetchQueries,
-                                fieldName: field.name,
-                                readerArtifactKind: field.entrypoint.readerArtifactKind,
-                                // TODO localVariables is not guaranteed to have an id field
-                                root,
-                                variables: localVariables,
-                                networkRequest,
-                            };
-                            return [
-                                fragmentReference,
-                                () => {
-                                    if (entrypointLoaderState.kind === 'NetworkRequestStarted') {
-                                        entrypointLoaderState.disposeNetworkRequest();
-                                    }
-                                    entrypointLoaderState = { kind: 'Disposed' };
-                                },
-                            ];
-                        }
-                    }
-                },
-            ];
-        },
-    };
+	const refetchReaderParams = readData(environment, field.refetchReaderAst, root, variables, [], networkRequest, networkRequestOptions, mutableEncounteredRecords);
+	if (refetchReaderParams.kind === "MissingData") return {
+		kind: "MissingData",
+		reason: "Missing data for " + field.alias + " on root " + root.__link,
+		nestedReason: refetchReaderParams,
+		recordLink: refetchReaderParams.recordLink
+	};
+	return {
+		kind: "Success",
+		data: (args, fetchOptions) => {
+			const includeReadOutData = (variables$1, readOutData) => {
+				variables$1.id = readOutData.id;
+				return variables$1;
+			};
+			const localVariables = includeReadOutData(args ?? {}, refetchReaderParams.data);
+			writeQueryArgsToVariables(localVariables, field.queryArguments, variables);
+			return [root.__typename + ":" + root.__link + "/" + field.name + "/" + stableStringifyArgs(localVariables), () => {
+				const fragmentReferenceAndDisposeFromEntrypoint = (entrypoint) => {
+					const { fieldName, readerArtifactKind, readerWithRefetchQueries } = require_IsographEnvironment.getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+					const [networkRequest$1, disposeNetworkRequest] = require_makeNetworkRequest.maybeMakeNetworkRequest(environment, entrypoint, localVariables, readerWithRefetchQueries, fetchOptions ?? null);
+					return [{
+						kind: "FragmentReference",
+						readerWithRefetchQueries,
+						fieldName,
+						readerArtifactKind,
+						root,
+						variables: localVariables,
+						networkRequest: networkRequest$1
+					}, disposeNetworkRequest];
+				};
+				if (field.entrypoint.kind === "Entrypoint") return fragmentReferenceAndDisposeFromEntrypoint(field.entrypoint);
+				else {
+					const isographArtifactPromiseWrapper = require_IsographEnvironment.getOrLoadIsographArtifact(environment, field.entrypoint.typeAndField, field.entrypoint.loader);
+					const state = require_PromiseWrapper.getPromiseState(isographArtifactPromiseWrapper);
+					if (state.kind === "Ok") return fragmentReferenceAndDisposeFromEntrypoint(state.value);
+					else {
+						let entrypointLoaderState = { kind: "EntrypointNotLoaded" };
+						const readerWithRefetchQueries = require_PromiseWrapper.wrapPromise(isographArtifactPromiseWrapper.promise.then((entrypoint) => require_IsographEnvironment.getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries).readerWithRefetchQueries.promise));
+						const networkRequest$1 = require_PromiseWrapper.wrapPromise(isographArtifactPromiseWrapper.promise.then((entrypoint) => {
+							if (entrypointLoaderState.kind === "EntrypointNotLoaded") {
+								const [networkRequest$2, disposeNetworkRequest] = require_makeNetworkRequest.maybeMakeNetworkRequest(environment, entrypoint, localVariables, readerWithRefetchQueries, fetchOptions ?? null);
+								entrypointLoaderState = {
+									kind: "NetworkRequestStarted",
+									disposeNetworkRequest
+								};
+								return networkRequest$2.promise;
+							}
+						}));
+						return [{
+							kind: "FragmentReference",
+							readerWithRefetchQueries,
+							fieldName: field.name,
+							readerArtifactKind: field.entrypoint.readerArtifactKind,
+							root,
+							variables: localVariables,
+							networkRequest: networkRequest$1
+						}, () => {
+							if (entrypointLoaderState.kind === "NetworkRequestStarted") entrypointLoaderState.disposeNetworkRequest();
+							entrypointLoaderState = { kind: "Disposed" };
+						}];
+					}
+				}
+			}];
+		}
+	};
 }
 function filterVariables(variables, allowedVariables) {
-    const result = {};
-    for (const key of allowedVariables) {
-        // @ts-expect-error
-        result[key] = variables[key];
-    }
-    return result;
+	const result = {};
+	for (const key of allowedVariables) result[key] = variables[key];
+	return result;
 }
 function generateChildVariableMap(variables, fieldArguments) {
-    if (fieldArguments == null) {
-        return {};
-    }
-    const childVars = {};
-    for (const [name, value] of fieldArguments) {
-        if (value.kind === 'Object') {
-            childVars[name] = generateChildVariableMap(variables, value.value);
-        }
-        else if (value.kind === 'Variable') {
-            const variable = variables[value.name];
-            // Variable could be null if it was not provided but has a default case,
-            // so we allow the loop to continue rather than throwing an error.
-            if (variable != null) {
-                childVars[name] = variable;
-            }
-        }
-        else {
-            childVars[name] = value.value;
-        }
-    }
-    return childVars;
+	if (fieldArguments == null) return {};
+	const childVars = {};
+	for (const [name, value] of fieldArguments) if (value.kind === "Object") childVars[name] = generateChildVariableMap(variables, value.value);
+	else if (value.kind === "Variable") {
+		const variable = variables[value.name];
+		if (variable != null) childVars[name] = variable;
+	} else childVars[name] = value.value;
+	return childVars;
 }
 function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
-    if (queryArgs == null) {
-        return;
-    }
-    for (const [name, argType] of queryArgs) {
-        switch (argType.kind) {
-            case 'Object': {
-                writeQueryArgsToVariables((targetVariables[name] = {}), argType.value, variables);
-                break;
-            }
-            case 'Variable': {
-                targetVariables[name] = variables[argType.name];
-                break;
-            }
-            case 'Enum': {
-                targetVariables[name] = argType.value;
-                break;
-            }
-            case 'Literal': {
-                targetVariables[name] = argType.value;
-                break;
-            }
-            case 'String': {
-                targetVariables[name] = argType.value;
-                break;
-            }
-            default: {
-                const _ = argType;
-                _;
-                throw new Error('Unexpected case');
-            }
-        }
-    }
+	if (queryArgs == null) return;
+	for (const [name, argType] of queryArgs) switch (argType.kind) {
+		case "Object":
+			writeQueryArgsToVariables(targetVariables[name] = {}, argType.value, variables);
+			break;
+		case "Variable":
+			targetVariables[name] = variables[argType.name];
+			break;
+		case "Enum":
+			targetVariables[name] = argType.value;
+			break;
+		case "Literal":
+			targetVariables[name] = argType.value;
+			break;
+		case "String":
+			targetVariables[name] = argType.value;
+			break;
+	}
 }
 function readResolverFieldData(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
-    const usedRefetchQueries = field.usedRefetchQueries;
-    const resolverRefetchQueries = usedRefetchQueries.map((index) => {
-        const resolverRefetchQuery = nestedRefetchQueries[index];
-        if (resolverRefetchQuery == null) {
-            throw new Error('resolverRefetchQuery is null in Resolver. This is indicative of a bug in Isograph.');
-        }
-        return resolverRefetchQuery;
-    });
-    const readerWithRefetchQueries = {
-        kind: 'ReaderWithRefetchQueries',
-        readerArtifact: field.readerArtifact,
-        nestedRefetchQueries: resolverRefetchQueries,
-    };
-    const fragment = {
-        kind: 'FragmentReference',
-        readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(readerWithRefetchQueries),
-        fieldName: field.readerArtifact.fieldName,
-        readerArtifactKind: field.readerArtifact.kind,
-        root,
-        variables: generateChildVariableMap(variables, field.arguments),
-        networkRequest,
-    };
-    switch (field.readerArtifact.kind) {
-        case 'EagerReaderArtifact': {
-            const data = readData(environment, field.readerArtifact.readerAst, root, generateChildVariableMap(variables, field.arguments), resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
-            if (data.kind === 'MissingData') {
-                return {
-                    kind: 'MissingData',
-                    reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
-                    nestedReason: data,
-                    recordLink: data.recordLink,
-                };
-            }
-            const firstParameter = {
-                data: data.data,
-                parameters: variables,
-                startUpdate: field.readerArtifact.hasUpdatable
-                    ? (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, networkRequestOptions)
-                    : undefined,
-            };
-            return {
-                kind: 'Success',
-                data: field.readerArtifact.resolver(firstParameter),
-            };
-        }
-        case 'ComponentReaderArtifact': {
-            return {
-                kind: 'Success',
-                data: (0, componentCache_1.getOrCreateCachedComponent)(environment, fragment, networkRequestOptions),
-            };
-        }
-        default: {
-            let _ = field.readerArtifact;
-            _;
-            throw new Error('Unexpected kind');
-        }
-    }
+	const resolverRefetchQueries = field.usedRefetchQueries.map((index) => {
+		const resolverRefetchQuery = nestedRefetchQueries[index];
+		if (resolverRefetchQuery == null) throw new Error("resolverRefetchQuery is null in Resolver. This is indicative of a bug in Isograph.");
+		return resolverRefetchQuery;
+	});
+	const fragment = {
+		kind: "FragmentReference",
+		readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue({
+			kind: "ReaderWithRefetchQueries",
+			readerArtifact: field.readerArtifact,
+			nestedRefetchQueries: resolverRefetchQueries
+		}),
+		fieldName: field.readerArtifact.fieldName,
+		readerArtifactKind: field.readerArtifact.kind,
+		root,
+		variables: generateChildVariableMap(variables, field.arguments),
+		networkRequest
+	};
+	switch (field.readerArtifact.kind) {
+		case "EagerReaderArtifact": {
+			const data = readData(environment, field.readerArtifact.readerAst, root, generateChildVariableMap(variables, field.arguments), resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+			if (data.kind === "MissingData") return {
+				kind: "MissingData",
+				reason: "Missing data for " + field.alias + " on root " + root.__link,
+				nestedReason: data,
+				recordLink: data.recordLink
+			};
+			const firstParameter = {
+				data: data.data,
+				parameters: variables,
+				startUpdate: field.readerArtifact.hasUpdatable ? require_startUpdate.getOrCreateCachedStartUpdate(environment, fragment, networkRequestOptions) : void 0
+			};
+			return {
+				kind: "Success",
+				data: field.readerArtifact.resolver(firstParameter)
+			};
+		}
+		case "ComponentReaderArtifact": return {
+			kind: "Success",
+			data: require_componentCache.getOrCreateCachedComponent(environment, fragment, networkRequestOptions)
+		};
+	}
 }
 function readScalarFieldData(field, storeRecord, root, variables) {
-    const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-    const value = storeRecord[storeRecordName];
-    // TODO consider making scalars into discriminated unions. This probably has
-    // to happen for when we handle errors.
-    if (value === undefined) {
-        return {
-            kind: 'MissingData',
-            reason: 'No value for ' + storeRecordName + ' on root ' + root.__link,
-            recordLink: root,
-        };
-    }
-    return { kind: 'Success', data: value };
+	const storeRecordName = require_cache.getParentRecordKey(field, variables);
+	const value = storeRecord[storeRecordName];
+	if (value === void 0) return {
+		kind: "MissingData",
+		reason: "No value for " + storeRecordName + " on root " + root.__link,
+		recordLink: root
+	};
+	return {
+		kind: "Success",
+		data: value
+	};
 }
-function readLinkedFieldData(environment, field, storeRecord, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, readData) {
-    const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-    let value = storeRecord[storeRecordName];
-    if (field.condition) {
-        const data = readData(field.condition.readerAst, root);
-        if (data.kind === 'MissingData') {
-            return {
-                kind: 'MissingData',
-                reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
-                nestedReason: data,
-                recordLink: data.recordLink,
-            };
-        }
-        const readerWithRefetchQueries = {
-            kind: 'ReaderWithRefetchQueries',
-            readerArtifact: field.condition,
-            // TODO this is wrong
-            // should map field.condition.usedRefetchQueries
-            // but it doesn't exist
-            nestedRefetchQueries: [],
-        };
-        const fragment = {
-            kind: 'FragmentReference',
-            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(readerWithRefetchQueries),
-            root,
-            fieldName: field.condition.fieldName,
-            readerArtifactKind: field.condition.kind,
-            variables: generateChildVariableMap(variables, 
-            // TODO this is wrong
-            // should use field.arguments
-            // but it doesn't exist
-            []),
-            networkRequest,
-        };
-        const condition = field.condition.resolver(Object.assign({ data: data.data, parameters: {} }, (field.condition.hasUpdatable
-            ? {
-                startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, networkRequestOptions),
-            }
-            : undefined)));
-        value = condition;
-    }
-    if (Array.isArray(value)) {
-        const results = [];
-        for (const item of value) {
-            const link = (0, IsographEnvironment_1.assertLink)(item);
-            if (link === undefined) {
-                return {
-                    kind: 'MissingData',
-                    reason: 'No link for ' +
-                        storeRecordName +
-                        ' on root ' +
-                        root.__link +
-                        '. Link is ' +
-                        JSON.stringify(item),
-                    recordLink: root,
-                };
-            }
-            else if (link === null) {
-                results.push(null);
-                continue;
-            }
-            if (isClientPointer(field)) {
-                const result = readClientPointerData(environment, field, link, variables, nestedRefetchQueries, readData);
-                if (result.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' +
-                            storeRecordName +
-                            ' on root ' +
-                            root.__link +
-                            '. Link is ' +
-                            JSON.stringify(item),
-                        nestedReason: result,
-                        recordLink: result.recordLink,
-                    };
-                }
-                results.push(result.data);
-                continue;
-            }
-            const result = readData(field.selections, link);
-            if (result.kind === 'MissingData') {
-                return {
-                    kind: 'MissingData',
-                    reason: 'Missing data for ' +
-                        storeRecordName +
-                        ' on root ' +
-                        root.__link +
-                        '. Link is ' +
-                        JSON.stringify(item),
-                    nestedReason: result,
-                    recordLink: result.recordLink,
-                };
-            }
-            results.push(result.data);
-        }
-        return {
-            kind: 'Success',
-            data: results,
-        };
-    }
-    let link = (0, IsographEnvironment_1.assertLink)(value);
-    if (link === undefined) {
-        // TODO make this configurable, and also generated and derived from the schema
-        const missingFieldHandler = environment.missingFieldHandler;
-        const altLink = missingFieldHandler === null || missingFieldHandler === void 0 ? void 0 : missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'MissingFieldHandlerCalled',
-            root,
-            storeRecord,
-            fieldName: field.fieldName,
-            arguments: field.arguments,
-            variables,
-        }));
-        if (altLink === undefined) {
-            return {
-                kind: 'MissingData',
-                reason: 'No link for ' +
-                    storeRecordName +
-                    ' on root ' +
-                    root.__link +
-                    '. Link is ' +
-                    JSON.stringify(value),
-                recordLink: root,
-            };
-        }
-        else {
-            link = altLink;
-        }
-    }
-    else if (link === null) {
-        return {
-            kind: 'Success',
-            data: null,
-        };
-    }
-    if (isClientPointer(field)) {
-        const data = readClientPointerData(environment, field, link, variables, nestedRefetchQueries, readData);
-        if (data.kind === 'MissingData') {
-            return {
-                kind: 'MissingData',
-                reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
-                nestedReason: data,
-                recordLink: data.recordLink,
-            };
-        }
-        return data;
-    }
-    const data = readData(field.selections, link);
-    if (data.kind === 'MissingData') {
-        return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + storeRecordName + ' on root ' + root.__link,
-            nestedReason: data,
-            recordLink: data.recordLink,
-        };
-    }
-    return data;
+function readLinkedFieldData(environment, field, storeRecord, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, readData$1) {
+	const storeRecordName = require_cache.getParentRecordKey(field, variables);
+	let value = storeRecord[storeRecordName];
+	if (field.condition != null) {
+		const data$1 = readData$1(field.condition.readerAst, root);
+		if (data$1.kind === "MissingData") return {
+			kind: "MissingData",
+			reason: "Missing data for " + storeRecordName + " on root " + root.__link,
+			nestedReason: data$1,
+			recordLink: data$1.recordLink
+		};
+		const fragment = {
+			kind: "FragmentReference",
+			readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue({
+				kind: "ReaderWithRefetchQueries",
+				readerArtifact: field.condition,
+				nestedRefetchQueries: []
+			}),
+			root,
+			fieldName: field.condition.fieldName,
+			readerArtifactKind: field.condition.kind,
+			variables: generateChildVariableMap(variables, []),
+			networkRequest
+		};
+		value = field.condition.resolver({
+			data: data$1.data,
+			parameters: {},
+			...field.condition.hasUpdatable ? { startUpdate: require_startUpdate.getOrCreateCachedStartUpdate(environment, fragment, networkRequestOptions) } : void 0
+		});
+	}
+	if (Array.isArray(value)) {
+		const results = [];
+		for (const item of value) {
+			const link$1 = require_IsographEnvironment.assertLink(item);
+			if (link$1 === void 0) return {
+				kind: "MissingData",
+				reason: "No link for " + storeRecordName + " on root " + root.__link + ". Link is " + JSON.stringify(item),
+				recordLink: root
+			};
+			else if (link$1 == null) {
+				results.push(null);
+				continue;
+			}
+			if (isClientPointer(field)) {
+				const result$1 = readClientPointerData(environment, field, link$1, variables, nestedRefetchQueries, readData$1);
+				if (result$1.kind === "MissingData") return {
+					kind: "MissingData",
+					reason: "Missing data for " + storeRecordName + " on root " + root.__link + ". Link is " + JSON.stringify(item),
+					nestedReason: result$1,
+					recordLink: result$1.recordLink
+				};
+				results.push(result$1.data);
+				continue;
+			}
+			const result = readData$1(field.selections, link$1);
+			if (result.kind === "MissingData") return {
+				kind: "MissingData",
+				reason: "Missing data for " + storeRecordName + " on root " + root.__link + ". Link is " + JSON.stringify(item),
+				nestedReason: result,
+				recordLink: result.recordLink
+			};
+			results.push(result.data);
+		}
+		return {
+			kind: "Success",
+			data: results
+		};
+	}
+	let link = require_IsographEnvironment.assertLink(value);
+	if (link === void 0) {
+		const missingFieldHandler = environment.missingFieldHandler;
+		const altLink = missingFieldHandler?.(storeRecord, root, field.fieldName, field.arguments, variables);
+		require_logging.logMessage(environment, () => ({
+			kind: "MissingFieldHandlerCalled",
+			root,
+			storeRecord,
+			fieldName: field.fieldName,
+			arguments: field.arguments,
+			variables
+		}));
+		if (altLink === void 0) return {
+			kind: "MissingData",
+			reason: "No link for " + storeRecordName + " on root " + root.__link + ". Link is " + JSON.stringify(value),
+			recordLink: root
+		};
+		else link = altLink;
+	} else if (link == null) return {
+		kind: "Success",
+		data: null
+	};
+	if (isClientPointer(field)) {
+		const data$1 = readClientPointerData(environment, field, link, variables, nestedRefetchQueries, readData$1);
+		if (data$1.kind === "MissingData") return {
+			kind: "MissingData",
+			reason: "Missing data for " + storeRecordName + " on root " + root.__link,
+			nestedReason: data$1,
+			recordLink: data$1.recordLink
+		};
+		return data$1;
+	}
+	const data = readData$1(field.selections, link);
+	if (data.kind === "MissingData") return {
+		kind: "MissingData",
+		reason: "Missing data for " + storeRecordName + " on root " + root.__link,
+		nestedReason: data,
+		recordLink: data.recordLink
+	};
+	return data;
 }
 function isClientPointer(field) {
-    return field.refetchQueryIndex !== null;
+	return field.refetchQueryIndex != null;
 }
-function readClientPointerData(environment, field, root, variables, nestedRefetchQueries, readData) {
-    const refetchReaderParams = readData([
-        {
-            kind: 'Scalar',
-            fieldName: 'id',
-            alias: null,
-            arguments: null,
-            isUpdatable: false,
-        },
-    ], root);
-    if (refetchReaderParams.kind === 'MissingData') {
-        return {
-            kind: 'MissingData',
-            reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
-            nestedReason: refetchReaderParams,
-            recordLink: refetchReaderParams.recordLink,
-        };
-    }
-    const refetchQuery = nestedRefetchQueries[field.refetchQueryIndex];
-    if (refetchQuery == null) {
-        throw new Error('refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.');
-    }
-    const refetchQueryArtifact = refetchQuery.artifact;
-    const allowedVariables = refetchQuery.allowedVariables;
-    return {
-        kind: 'Success',
-        data: (args, 
-        // TODO get the associated type for FetchOptions from the loadably selected field
-        fetchOptions) => {
-            const includeReadOutData = (variables, readOutData) => {
-                variables.id = readOutData.id;
-                return variables;
-            };
-            const localVariables = includeReadOutData(args !== null && args !== void 0 ? args : {}, refetchReaderParams.data);
-            writeQueryArgsToVariables(localVariables, field.arguments, variables);
-            return [
-                // Stable id
-                root.__typename +
-                    ':' +
-                    root.__link +
-                    '/' +
-                    field.fieldName +
-                    '/' +
-                    stableStringifyArgs(localVariables),
-                // Fetcher
-                () => {
-                    const variables = includeReadOutData(filterVariables(Object.assign(Object.assign({}, args), localVariables), allowedVariables), refetchReaderParams.data);
-                    const readerWithRefetchQueries = (0, PromiseWrapper_1.wrapResolvedValue)({
-                        kind: 'ReaderWithRefetchQueries',
-                        readerArtifact: {
-                            kind: 'EagerReaderArtifact',
-                            fieldName: field.fieldName,
-                            readerAst: field.selections,
-                            resolver: ({ data }) => data,
-                            hasUpdatable: false,
-                        },
-                        nestedRefetchQueries,
-                    });
-                    const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, refetchQueryArtifact, variables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
-                    const fragmentReference = {
-                        kind: 'FragmentReference',
-                        fieldName: field.fieldName,
-                        readerArtifactKind: 'EagerReaderArtifact',
-                        readerWithRefetchQueries: readerWithRefetchQueries,
-                        root,
-                        variables,
-                        networkRequest,
-                    };
-                    return [fragmentReference, disposeNetworkRequest];
-                },
-            ];
-        },
-    };
+function readClientPointerData(environment, field, root, variables, nestedRefetchQueries, readData$1) {
+	const refetchReaderParams = readData$1([{
+		kind: "Scalar",
+		fieldName: "id",
+		alias: null,
+		arguments: null,
+		isUpdatable: false
+	}], root);
+	if (refetchReaderParams.kind === "MissingData") return {
+		kind: "MissingData",
+		reason: "Missing data for " + field.alias + " on root " + root.__link,
+		nestedReason: refetchReaderParams,
+		recordLink: refetchReaderParams.recordLink
+	};
+	const refetchQuery = nestedRefetchQueries[field.refetchQueryIndex];
+	if (refetchQuery == null) throw new Error("refetchQuery is null in RefetchField. This is indicative of a bug in Isograph.");
+	const refetchQueryArtifact = refetchQuery.artifact;
+	const allowedVariables = refetchQuery.allowedVariables;
+	return {
+		kind: "Success",
+		data: (args, fetchOptions) => {
+			const includeReadOutData = (variables$1, readOutData) => {
+				variables$1.id = readOutData.id;
+				return variables$1;
+			};
+			const localVariables = includeReadOutData(args ?? {}, refetchReaderParams.data);
+			writeQueryArgsToVariables(localVariables, field.arguments, variables);
+			return [root.__typename + ":" + root.__link + "/" + field.fieldName + "/" + stableStringifyArgs(localVariables), () => {
+				const variables$1 = includeReadOutData(filterVariables({
+					...args,
+					...localVariables
+				}, allowedVariables), refetchReaderParams.data);
+				const readerWithRefetchQueries = require_PromiseWrapper.wrapResolvedValue({
+					kind: "ReaderWithRefetchQueries",
+					readerArtifact: {
+						kind: "EagerReaderArtifact",
+						fieldName: field.fieldName,
+						readerAst: field.selections,
+						resolver: ({ data }) => data,
+						hasUpdatable: false
+					},
+					nestedRefetchQueries
+				});
+				const [networkRequest, disposeNetworkRequest] = require_makeNetworkRequest.maybeMakeNetworkRequest(environment, refetchQueryArtifact, variables$1, readerWithRefetchQueries, fetchOptions ?? null);
+				return [{
+					kind: "FragmentReference",
+					fieldName: field.fieldName,
+					readerArtifactKind: "EagerReaderArtifact",
+					readerWithRefetchQueries,
+					root,
+					variables: variables$1,
+					networkRequest
+				}, disposeNetworkRequest];
+			}];
+		}
+	};
 }
 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,
-    };
+	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
-// 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;
+	const keys = Object.keys(args);
+	keys.sort();
+	let s = "";
+	for (const key of keys) s += `${key}=${JSON.stringify(args[key])};`;
+	return s;
 }
 function readImperativelyLoadedField(environment, field, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
-    // First, we read the data using the refetch reader AST (i.e. read out the
-    // id field).
-    const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, 
-    // Refetch fields just read the id, and don't need refetch query artifacts
-    [], 
-    // 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',
-            reason: 'Missing data for ' + field.alias + ' on root ' + root.__link,
-            nestedReason: data,
-            recordLink: data.recordLink,
-        };
-    }
-    else {
-        const { refetchQueryIndex } = field;
-        const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-        if (refetchQuery == null) {
-            throw new Error('Refetch query not found. This is indicative of a bug in Isograph.');
-        }
-        const refetchQueryArtifact = refetchQuery.artifact;
-        const allowedVariables = refetchQuery.allowedVariables;
-        // Second, we allow the user to call the resolver, which will ultimately
-        // use the resolver reader AST to get the resolver parameters.
-        return {
-            kind: 'Success',
-            data: (args) => [
-                // Stable id
-                root.__typename + ':' + root.__link + '__' + field.name,
-                // Fetcher
-                field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(Object.assign(Object.assign({}, args), variables), allowedVariables), root, 
-                // TODO these params should be removed
-                null, []),
-            ],
-        };
-    }
+	const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, [], networkRequest, networkRequestOptions, mutableEncounteredRecords);
+	if (data.kind === "MissingData") return {
+		kind: "MissingData",
+		reason: "Missing data for " + field.alias + " on root " + root.__link,
+		nestedReason: data,
+		recordLink: data.recordLink
+	};
+	else {
+		const { refetchQueryIndex } = field;
+		const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+		if (refetchQuery == null) throw new Error("Refetch query not found. This is indicative of a bug in Isograph.");
+		const refetchQueryArtifact = refetchQuery.artifact;
+		const allowedVariables = refetchQuery.allowedVariables;
+		return {
+			kind: "Success",
+			data: (args) => [root.__typename + ":" + root.__link + "__" + field.name, field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables({
+				...args,
+				...variables
+			}, allowedVariables), root, null, [])]
+		};
+	}
 }
+
+//#endregion
+exports.getNetworkRequestOptionsWithDefaults = getNetworkRequestOptionsWithDefaults;
+exports.readButDoNotEvaluate = readButDoNotEvaluate;
+exports.readImperativelyLoadedField = readImperativelyLoadedField;
+exports.readLinkedFieldData = readLinkedFieldData;
+exports.readLoadablySelectedFieldData = readLoadablySelectedFieldData;
+exports.readResolverFieldData = readResolverFieldData;
+exports.readScalarFieldData = readScalarFieldData;