@isograph/react 0.4.3 → 0.5.1

package/dist/core/logging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/core/logging.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"logging.d.ts","names":[],"sources":["../../src/core/logging.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;AA8BA;;;;;;;;;;AA6BiB,KA7BL,UAAA,GA6BK;EAgBL,IAAA,EAAA,kBAAA;EACO,gBAAA,EA3CK,qBA2CL;EAEF,eAAA,EA5CM,qBA4CN;EACA,SAAA,EA5CA,SA4CA;CAID,GAAA;EAEJ,IAAA,EAAA,oBAAA;EAQE,KAAA,EAtDD,UAsDC;EAWI,cAAA,EAhEI,cAgEJ;CAAc,GAAA;EAOpB,IAAA,EAAA,mBAAW;EAGX,iBAAA,EAtEa,iBAuElB,CAAA,GAAA,EAAA,GAAA,CAAW;EAGF,GAAA,EAAA,MAAA;EAcA,GAAA,EAAA,MAAA;EACD,WAAA,EAAA,OAAA;CACR,GAAA;EACJ,IAAA,EAAA,qBAAA;EAAS,aAAA,EAAA,MAAA;YAnFI;;;YAKN,oCACA;aACO;;;;;;;;;;;;QAgBL;eACO;;aAEF;aACA;;;YAID;;QAEJ;;;;;;UAQE;;;;;;;;cAWI;;;;;KAON,WAAA,gBAA2B;KAG3B,kBAAA;OACL;;iBAGS,UAAA,cACD,uCACK;iBAYJ,cAAA,cACD,0BACR,cACJ"}

package/dist/core/logging.js

@@ -1,22 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logMessage = logMessage;
-exports.registerLogger = registerLogger;
+
+//#region src/core/logging.ts
 function logMessage(environment, getMessage) {
-    if (environment.loggers.size > 0) {
-        const message = getMessage();
-        for (const logger of environment.loggers) {
-            try {
-                logger.log(message);
-            }
-            catch (_a) { }
-        }
-    }
+	if (environment.loggers.size > 0) {
+		const message = getMessage();
+		for (const logger of environment.loggers) try {
+			logger.log(message);
+		} catch {}
+	}
 }
 function registerLogger(environment, log) {
-    const wrapped = { log };
-    environment.loggers.add(wrapped);
-    return () => {
-        environment.loggers.delete(wrapped);
-    };
+	const wrapped = { log };
+	environment.loggers.add(wrapped);
+	return () => {
+		environment.loggers.delete(wrapped);
+	};
 }
+
+//#endregion
+exports.logMessage = logMessage;
+exports.registerLogger = registerLogger;

package/dist/core/logging.mjs

@@ -0,0 +1,20 @@
+//#region src/core/logging.ts
+function logMessage(environment, getMessage) {
+	if (environment.loggers.size > 0) {
+		const message = getMessage();
+		for (const logger of environment.loggers) try {
+			logger.log(message);
+		} catch {}
+	}
+}
+function registerLogger(environment, log) {
+	const wrapped = { log };
+	environment.loggers.add(wrapped);
+	return () => {
+		environment.loggers.delete(wrapped);
+	};
+}
+
+//#endregion
+export { logMessage, registerLogger };
+//# sourceMappingURL=logging.mjs.map

package/dist/core/logging.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.mjs","names":[],"sources":["../../src/core/logging.ts"],"sourcesContent":["import type { CleanupFn } from '@isograph/disposable-types';\nimport type { NetworkResponseObject, EncounteredIds } from './cache';\nimport type { CheckResult } from './check';\nimport type {\n  IsographEntrypoint,\n  RefetchQueryNormalizationArtifact,\n  NormalizationAstNodes,\n} from './entrypoint';\nimport type { FragmentReference, Variables } from './FragmentReference';\nimport type {\n  IsographEnvironment,\n  StoreRecord,\n  StoreLink,\n} from './IsographEnvironment';\nimport type { ReadDataResult } from './read';\nimport type { Arguments } from './util';\nimport type { StoreLayer } from './optimisticProxy';\n\n/**\n * Note: these types are unstable. We will add and remove items from this enum\n * and add and remove fields. Please do not rely on the specifics here (for now).\n *\n * Goals include:\n * - convenient debugging for Isograph developers\n * - eventual support for the Isograph devtools\n *\n * In some cases (e.g. in `AfterNormalization`), we include large objects and thus\n * prevent them from getting garbage collected (if the log message is printed).\n * Especially in cases like that, we intend to remove those!\n */\nexport type LogMessage =\n  | {\n      kind: 'AboutToNormalize';\n      normalizationAst: NormalizationAstNodes;\n      networkResponse: NetworkResponseObject;\n      variables: Variables;\n    }\n  | {\n      kind: 'AfterNormalization';\n      store: StoreLayer;\n      encounteredIds: EncounteredIds;\n    }\n  | {\n      kind: 'DeepEqualityCheck';\n      fragmentReference: FragmentReference<any, any>;\n      old: object;\n      new: object;\n      deeplyEqual: boolean;\n    }\n  | {\n      kind: 'ComponentRerendered';\n      componentName: string;\n      rootLink: StoreLink;\n    }\n  | {\n      kind: 'MakeNetworkRequest';\n      artifact:\n        | RefetchQueryNormalizationArtifact\n        | IsographEntrypoint<any, any, any, any>;\n      variables: Variables;\n      networkRequestId: string;\n    }\n  | {\n      kind: 'ReceivedNetworkResponse';\n      // TODO should be object\n      networkResponse: any;\n      networkRequestId: string;\n    }\n  | {\n      kind: 'ReceivedNetworkError';\n      error: any;\n      networkRequestId: string;\n    }\n  | {\n      kind: 'MissingFieldHandlerCalled';\n      root: StoreLink;\n      storeRecord: StoreRecord;\n      fieldName: string;\n      arguments: Arguments | null;\n      variables: Variables;\n    }\n  | {\n      kind: 'DoneReading';\n      response: ReadDataResult<any>;\n      fieldName: string;\n      root: StoreLink;\n    }\n  | {\n      kind: 'NonEntrypointReceived';\n      entrypoint: any;\n    }\n  | {\n      kind: 'EnvironmentCheck';\n      result: CheckResult;\n    }\n  | {\n      kind: 'EnvironmentCreated';\n    }\n  | {\n      kind: 'StartUpdateError';\n      error: any;\n    }\n  | {\n      kind: 'StartUpdateComplete';\n      updatedIds: EncounteredIds;\n    }\n  | {\n      kind: 'ErrorEncounteredInWithErrorHandling';\n      error: any;\n    };\n\nexport type LogFunction = (logMessage: LogMessage) => void;\n\n// wrapped so that items in the loggers set are unique.\nexport type WrappedLogFunction = {\n  log: LogFunction;\n};\n\nexport function logMessage(\n  environment: IsographEnvironment,\n  getMessage: () => LogMessage,\n) {\n  if (environment.loggers.size > 0) {\n    const message = getMessage();\n    for (const logger of environment.loggers) {\n      try {\n        logger.log(message);\n      } catch {}\n    }\n  }\n}\n\nexport function registerLogger(\n  environment: IsographEnvironment,\n  log: LogFunction,\n): CleanupFn {\n  const wrapped = { log };\n  environment.loggers.add(wrapped);\n  return () => {\n    environment.loggers.delete(wrapped);\n  };\n}\n"],"mappings":";AAsHA,SAAgB,WACd,aACA,YACA;AACA,KAAI,YAAY,QAAQ,OAAO,GAAG;EAChC,MAAM,UAAU,YAAY;AAC5B,OAAK,MAAM,UAAU,YAAY,QAC/B,KAAI;AACF,UAAO,IAAI,QAAQ;UACb;;;AAKd,SAAgB,eACd,aACA,KACW;CACX,MAAM,UAAU,EAAE,KAAK;AACvB,aAAY,QAAQ,IAAI,QAAQ;AAChC,cAAa;AACX,cAAY,QAAQ,OAAO,QAAQ"}

package/dist/core/makeNetworkRequest.d.mts

@@ -0,0 +1,13 @@
+import { FetchOptions } from "./check.mjs";
+import { AnyError, PromiseWrapper } from "./PromiseWrapper.mjs";
+import { IsographEnvironment } from "./IsographEnvironment.mjs";
+import { ExtractParameters, UnknownTReadFromStore } from "./FragmentReference.mjs";
+import { NetworkResponseObject } from "./cache.mjs";
+import { IsographEntrypoint, NormalizationAst, NormalizationAstLoader, ReaderWithRefetchQueries, RefetchQueryNormalizationArtifact } from "./entrypoint.mjs";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/core/makeNetworkRequest.d.ts
+declare function makeNetworkRequest<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>, variables: ExtractParameters<TReadFromStore>, readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>> | null, fetchOptions: FetchOptions<TClientFieldValue, TRawResponseType> | null): ItemCleanupPair<PromiseWrapper<void, AnyError>>;
+//#endregion
+export { makeNetworkRequest };
+//# sourceMappingURL=makeNetworkRequest.d.mts.map

package/dist/core/makeNetworkRequest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeNetworkRequest.d.mts","names":[],"sources":["../../src/core/makeNetworkRequest.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA8JgB,iBAAA,kBAAkB,CAAA,uBACT,qBADS,EAAA,iBAAA,EAAA,0BAGN,gBAHM,GAGa,sBAHb,EAAA,yBAIP,qBAJO,CAAA,CAAA,WAAA,EAMnB,mBANmB,EAAA,QAAA,EAQ5B,iCAR4B,GAS5B,kBAT4B,CAU1B,cAV0B,EAW1B,iBAX0B,EAY1B,iBAZ0B,EAa1B,gBAb0B,CAAA,EAAA,SAAA,EAerB,iBAfqB,CAeH,cAfG,CAAA,EAAA,wBAAA,EAgBN,cAhBM,CAiB9B,wBAjB8B,CAiBL,cAjBK,EAiBW,iBAjBX,CAAA,CAAA,GAAA,IAAA,EAAA,YAAA,EAmBlB,YAnBkB,CAmBL,iBAnBK,EAmBc,gBAnBd,CAAA,GAAA,IAAA,CAAA,EAoB/B,eApB+B,CAoBf,cApBe,CAAA,IAAA,EAoBM,QApBN,CAAA,CAAA"}

package/dist/core/makeNetworkRequest.d.ts

@@ -1,9 +1,13 @@
-import { ItemCleanupPair } from '@isograph/disposable-types';
-import { FetchOptions } from './check';
-import { IsographEntrypoint, ReaderWithRefetchQueries, RefetchQueryNormalizationArtifact, type NormalizationAst, type NormalizationAstLoader } from './entrypoint';
-import { ExtractParameters, type UnknownTReadFromStore } from './FragmentReference';
-import { IsographEnvironment } from './IsographEnvironment';
-import { AnyError, PromiseWrapper } from './PromiseWrapper';
-export declare function maybeMakeNetworkRequest<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TArtifact extends RefetchQueryNormalizationArtifact | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>, TNormalizationAst extends NormalizationAst | NormalizationAstLoader>(environment: IsographEnvironment, artifact: TArtifact, variables: ExtractParameters<TReadFromStore>, readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>> | null, fetchOptions: FetchOptions<TClientFieldValue> | null): ItemCleanupPair<PromiseWrapper<void, AnyError>>;
-export declare function makeNetworkRequest<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TArtifact extends RefetchQueryNormalizationArtifact | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>, TNormalizationAst extends NormalizationAst | NormalizationAstLoader>(environment: IsographEnvironment, artifact: TArtifact, variables: ExtractParameters<TReadFromStore>, readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>> | null, fetchOptions: FetchOptions<TClientFieldValue> | null): ItemCleanupPair<PromiseWrapper<void, AnyError>>;
+import { FetchOptions } from "./check.js";
+import { AnyError, PromiseWrapper } from "./PromiseWrapper.js";
+import { IsographEnvironment } from "./IsographEnvironment.js";
+import { ExtractParameters, UnknownTReadFromStore } from "./FragmentReference.js";
+import { NetworkResponseObject } from "./cache.js";
+import { IsographEntrypoint, NormalizationAst, NormalizationAstLoader, ReaderWithRefetchQueries, RefetchQueryNormalizationArtifact } from "./entrypoint.js";
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/core/makeNetworkRequest.d.ts
+declare function makeNetworkRequest<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>, variables: ExtractParameters<TReadFromStore>, readerWithRefetchQueries: PromiseWrapper<ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>> | null, fetchOptions: FetchOptions<TClientFieldValue, TRawResponseType> | null): ItemCleanupPair<PromiseWrapper<void, AnyError>>;
+//#endregion
+export { makeNetworkRequest };
 //# sourceMappingURL=makeNetworkRequest.d.ts.map

package/dist/core/makeNetworkRequest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeNetworkRequest.d.ts","sourceRoot":"","sources":["../../src/core/makeNetworkRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAqC,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1E,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,iCAAiC,EACjC,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,iBAAiB,EAEjB,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAO7B,OAAO,EAAE,mBAAmB,EAAsB,MAAM,uBAAuB,CAAC;AAEhF,OAAO,EACL,QAAQ,EACR,cAAc,EAGf,MAAM,kBAAkB,CAAC;AAM1B,wBAAgB,uBAAuB,CACrC,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,SAAS,SACL,iCAAiC,GACjC,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,CAAC,EAC5E,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,EAEnE,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,SAAS,EACnB,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAC5C,wBAAwB,EAAE,cAAc,CACtC,wBAAwB,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAC5D,GAAG,IAAI,EACR,YAAY,EAAE,YAAY,CAAC,iBAAiB,CAAC,GAAG,IAAI,GACnD,eAAe,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CA8CjD;AAeD,wBAAgB,kBAAkB,CAChC,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,SAAS,SACL,iCAAiC,GACjC,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,CAAC,EAC5E,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,EAEnE,WAAW,EAAE,mBAAmB,EAChC,QAAQ,EAAE,SAAS,EACnB,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAC5C,wBAAwB,EAAE,cAAc,CACtC,wBAAwB,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAC5D,GAAG,IAAI,EACR,YAAY,EAAE,YAAY,CAAC,iBAAiB,CAAC,GAAG,IAAI,GACnD,eAAe,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAgHjD"}
+{"version":3,"file":"makeNetworkRequest.d.ts","names":[],"sources":["../../src/core/makeNetworkRequest.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AA8JgB,iBAAA,kBAAkB,CAAA,uBACT,qBADS,EAAA,iBAAA,EAAA,0BAGN,gBAHM,GAGa,sBAHb,EAAA,yBAIP,qBAJO,CAAA,CAAA,WAAA,EAMnB,mBANmB,EAAA,QAAA,EAQ5B,iCAR4B,GAS5B,kBAT4B,CAU1B,cAV0B,EAW1B,iBAX0B,EAY1B,iBAZ0B,EAa1B,gBAb0B,CAAA,EAAA,SAAA,EAerB,iBAfqB,CAeH,cAfG,CAAA,EAAA,wBAAA,EAgBN,cAhBM,CAiB9B,wBAjB8B,CAiBL,cAjBK,EAiBW,iBAjBX,CAAA,CAAA,GAAA,IAAA,EAAA,YAAA,EAmBlB,YAnBkB,CAmBL,iBAnBK,EAmBc,gBAnBd,CAAA,GAAA,IAAA,CAAA,EAoB/B,eApB+B,CAoBf,cApBe,CAAA,IAAA,EAoBM,QApBN,CAAA,CAAA"}

package/dist/core/makeNetworkRequest.js

@@ -1,203 +1,196 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeMakeNetworkRequest = maybeMakeNetworkRequest;
-exports.makeNetworkRequest = makeNetworkRequest;
-const cache_1 = require("./cache");
-const check_1 = require("./check");
-const componentCache_1 = require("./componentCache");
-const garbageCollection_1 = require("./garbageCollection");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-const logging_1 = require("./logging");
-const PromiseWrapper_1 = require("./PromiseWrapper");
-const read_1 = require("./read");
-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_check = require('./check.js');
+const require_read = require('./read.js');
+const require_subscribe = require('./subscribe.js');
+const require_optimisticProxy = require('./optimisticProxy.js');
+const require_cache = require('./cache.js');
+const require_garbageCollection = require('./garbageCollection.js');
+
+//#region src/core/makeNetworkRequest.ts
 let networkRequestId = 0;
 function maybeMakeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
-    var _a;
-    switch ((_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.shouldFetch) !== null && _a !== void 0 ? _a : check_1.DEFAULT_SHOULD_FETCH_VALUE) {
-        case 'Yes': {
-            return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
-        }
-        case 'No': {
-            return [(0, PromiseWrapper_1.wrapResolvedValue)(undefined), () => { }];
-        }
-        case 'IfNecessary': {
-            if (artifact.networkRequestInfo.normalizationAst.kind ===
-                'NormalizationAstLoader') {
-                throw new Error('Using lazy loaded normalizationAst with shouldFetch: "IfNecessary" is not supported as it will lead to slower initial load time.');
-            }
-            const result = (0, check_1.check)(environment, artifact.networkRequestInfo.normalizationAst.selections, variables, {
-                __link: IsographEnvironment_1.ROOT_ID,
-                __typename: artifact.concreteType,
-            });
-            if (result.kind === 'EnoughData') {
-                return [(0, PromiseWrapper_1.wrapResolvedValue)(undefined), () => { }];
-            }
-            else {
-                return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
-            }
-        }
-    }
+	switch (fetchOptions?.shouldFetch ?? require_check.DEFAULT_SHOULD_FETCH_VALUE) {
+		case "Yes": return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+		case "No": return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+		case "IfNecessary":
+			if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with shouldFetch: \"IfNecessary\" is not supported as it will lead to a network waterfall.");
+			if (require_check.check(environment, artifact.networkRequestInfo.normalizationAst.selections, variables, {
+				__link: require_IsographEnvironment.ROOT_ID,
+				__typename: artifact.concreteType
+			}).kind === "EnoughData") return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+			else return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+	}
 }
-function loadNormalizationAst(normalizationAst) {
-    switch (normalizationAst.kind) {
-        case 'NormalizationAst': {
-            return normalizationAst;
-        }
-        case 'NormalizationAstLoader': {
-            return normalizationAst.loader();
-        }
-    }
+function retainQueryWithoutMakingNetworkRequest(environment, artifact, variables) {
+	let status = {
+		kind: "UndisposedComplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables)
+	};
+	return [require_PromiseWrapper.wrapResolvedValue(void 0), () => {
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
 }
 function makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
-    // TODO this should be a DataId and stored in the store
-    const myNetworkRequestId = networkRequestId + '';
-    networkRequestId++;
-    (0, logging_1.logMessage)(environment, () => ({
-        kind: 'MakeNetworkRequest',
-        artifact,
-        variables,
-        networkRequestId: myNetworkRequestId,
-    }));
-    let status = {
-        kind: 'UndisposedIncomplete',
-    };
-    // This should be an observable, not a promise
-    const promise = Promise.all([
-        environment.networkFunction(artifact.networkRequestInfo.operation, variables),
-        loadNormalizationAst(artifact.networkRequestInfo.normalizationAst),
-        readerWithRefetchQueries === null || readerWithRefetchQueries === void 0 ? void 0 : readerWithRefetchQueries.promise,
-    ])
-        .then(([networkResponse, normalizationAst, readerWithRefetchQueries]) => {
-        var _a, _b;
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ReceivedNetworkResponse',
-            networkResponse,
-            networkRequestId: myNetworkRequestId,
-        }));
-        if (networkResponse.errors != null) {
-            try {
-                (_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onError) === null || _a === void 0 ? void 0 : _a.call(fetchOptions);
-            }
-            catch (_c) { }
-            throw new Error('GraphQL network response had errors', {
-                cause: networkResponse,
-            });
-        }
-        const root = { __link: IsographEnvironment_1.ROOT_ID, __typename: artifact.concreteType };
-        if (status.kind === 'UndisposedIncomplete') {
-            (0, cache_1.normalizeData)(environment, normalizationAst.selections, (_b = networkResponse.data) !== null && _b !== void 0 ? _b : {}, variables, root);
-            const retainedQuery = {
-                normalizationAst: normalizationAst.selections,
-                variables,
-                root,
-            };
-            status = {
-                kind: 'UndisposedComplete',
-                retainedQuery,
-            };
-            (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
-        }
-        const onComplete = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onComplete;
-        if (onComplete != null) {
-            let data = readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries);
-            try {
-                // @ts-expect-error this problem will be fixed when we remove RefetchQueryNormalizationArtifact
-                // (or we can fix this by having a single param of type { kind: 'Entrypoint', entrypoint,
-                // fetchOptions: FetchOptions<TReadFromStore> } | { kind: 'RefetchQuery', refetchQuery,
-                // fetchOptions: FetchOptions<void> }).
-                onComplete(data);
-            }
-            catch (_d) { }
-        }
-    })
-        .catch((e) => {
-        var _a;
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ReceivedNetworkError',
-            networkRequestId: myNetworkRequestId,
-            error: e,
-        }));
-        try {
-            (_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onError) === null || _a === void 0 ? void 0 : _a.call(fetchOptions);
-        }
-        catch (_b) { }
-        throw e;
-    });
-    const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
-    const response = [
-        wrapper,
-        () => {
-            if (status.kind === 'UndisposedComplete') {
-                const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
-                if (didUnretainSomeQuery) {
-                    (0, garbageCollection_1.garbageCollectEnvironment)(environment);
-                }
-            }
-            status = {
-                kind: 'Disposed',
-            };
-        },
-    ];
-    return response;
+	const myNetworkRequestId = networkRequestId + "";
+	networkRequestId++;
+	let status = {
+		kind: "UndisposedIncomplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables),
+		optimistic: fetchOptions?.optimisticNetworkResponse != null ? makeOptimisticUpdate(environment, artifact, variables, fetchOptions?.optimisticNetworkResponse) : null
+	};
+	require_logging.logMessage(environment, () => ({
+		kind: "MakeNetworkRequest",
+		artifact,
+		variables,
+		networkRequestId: myNetworkRequestId
+	}));
+	return [require_PromiseWrapper.wrapPromise(Promise.all([
+		environment.networkFunction(artifact.networkRequestInfo.operation, variables),
+		status.retainedQuery.normalizationAst.promise,
+		readerWithRefetchQueries?.promise
+	]).then(([networkResponse, normalizationAst, readerWithRefetchQueries$1]) => {
+		require_logging.logMessage(environment, () => ({
+			kind: "ReceivedNetworkResponse",
+			networkResponse,
+			networkRequestId: myNetworkRequestId
+		}));
+		if (networkResponse.errors != null) {
+			try {
+				fetchOptions?.onError?.();
+			} catch {}
+			throw new Error("Network response had errors", { cause: networkResponse });
+		}
+		const root = {
+			__link: require_IsographEnvironment.ROOT_ID,
+			__typename: artifact.concreteType
+		};
+		if (status.kind === "UndisposedIncomplete") if (status.optimistic != null) status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, (storeLayer) => require_cache.normalizeData(environment, storeLayer, normalizationAst.selections, networkResponse.data ?? {}, variables, root, /* @__PURE__ */ new Map()));
+		else {
+			const encounteredIds = /* @__PURE__ */ new Map();
+			environment.store = require_optimisticProxy.addNetworkResponseStoreLayer(environment.store);
+			require_cache.normalizeData(environment, environment.store, normalizationAst.selections, networkResponse.data ?? {}, variables, root, encounteredIds);
+			require_logging.logMessage(environment, () => ({
+				kind: "AfterNormalization",
+				store: environment.store,
+				encounteredIds
+			}));
+			require_subscribe.callSubscriptions(environment, encounteredIds);
+			status = {
+				kind: "UndisposedComplete",
+				retainedQuery: status.retainedQuery
+			};
+		}
+		const onComplete = fetchOptions?.onComplete;
+		if (onComplete != null) {
+			let data = readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries$1);
+			try {
+				onComplete(data);
+			} catch {}
+		}
+	}).catch((e) => {
+		require_logging.logMessage(environment, () => ({
+			kind: "ReceivedNetworkError",
+			networkRequestId: myNetworkRequestId,
+			error: e
+		}));
+		try {
+			fetchOptions?.onError?.();
+		} catch {}
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		throw e;
+	})), () => {
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
 }
 function readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries) {
-    // An entrypoint, but not a RefetchQueryNormalizationArtifact, has a reader ASTs.
-    // So, we can only pass data to onComplete if makeNetworkRequest was passed an entrypoint.
-    // This is awkward, since we don't express that in the types of the parameters
-    // (i.e. FetchOptions could be passed, along with a RefetchQueryNormalizationArtifact).
-    //
-    // However, this isn't a big deal: RefetchQueryNormalizationArtifact is going away.
-    if (artifact.kind === 'Entrypoint') {
-        // TODO this is a smell!
-        const fakeNetworkRequest = (0, PromiseWrapper_1.wrapResolvedValue)(undefined);
-        // TODO this is a smell — we know the network response is not in flight,
-        // so we don't really care!
-        const fakeNetworkRequestOptions = {
-            suspendIfInFlight: false,
-            throwOnNetworkError: false,
-        };
-        const resolvedReaderWithRefetchQueries = readerWithRefetchQueries;
-        const fragment = {
-            kind: 'FragmentReference',
-            // TODO this smells.
-            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(resolvedReaderWithRefetchQueries),
-            root,
-            variables,
-            networkRequest: fakeNetworkRequest,
-        };
-        const fragmentResult = (0, read_1.readButDoNotEvaluate)(environment, fragment, fakeNetworkRequestOptions).item;
-        const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
-        switch (readerArtifact.kind) {
-            case 'ComponentReaderArtifact': {
-                // @ts-expect-error We should find a way to encode this in the type system:
-                // if we have a ComponentReaderArtifact, we will necessarily have a
-                // TClientFieldValue which is a React.FC<...>
-                return (0, componentCache_1.getOrCreateCachedComponent)(environment, readerArtifact.fieldName, {
-                    kind: 'FragmentReference',
-                    readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
-                        kind: 'ReaderWithRefetchQueries',
-                        readerArtifact: readerArtifact,
-                        nestedRefetchQueries: resolvedReaderWithRefetchQueries.nestedRefetchQueries,
-                    }),
-                    root,
-                    variables,
-                    networkRequest: fakeNetworkRequest,
-                }, fakeNetworkRequestOptions);
-            }
-            case 'EagerReaderArtifact': {
-                return readerArtifact.resolver(Object.assign({ data: fragmentResult, parameters: variables }, (readerArtifact.hasUpdatable
-                    ? {
-                        startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, resolvedReaderWithRefetchQueries.readerArtifact.fieldName, fakeNetworkRequestOptions),
-                    }
-                    : undefined)));
-            }
-            default: {
-                const _ = readerArtifact;
-                _;
-                throw new Error('Expected case');
-            }
-        }
-    }
-    return null;
+	if (artifact.kind === "Entrypoint") {
+		const fakeNetworkRequest = require_PromiseWrapper.wrapResolvedValue(void 0);
+		const fakeNetworkRequestOptions = {
+			suspendIfInFlight: false,
+			throwOnNetworkError: false
+		};
+		const resolvedReaderWithRefetchQueries = readerWithRefetchQueries;
+		const fragment = {
+			kind: "FragmentReference",
+			readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue(resolvedReaderWithRefetchQueries),
+			fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
+			readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,
+			root,
+			variables,
+			networkRequest: fakeNetworkRequest
+		};
+		const fragmentResult = require_read.readButDoNotEvaluate(environment, fragment, fakeNetworkRequestOptions).item;
+		const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
+		switch (readerArtifact.kind) {
+			case "ComponentReaderArtifact": return require_componentCache.getOrCreateCachedComponent(environment, {
+				kind: "FragmentReference",
+				readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue({
+					kind: "ReaderWithRefetchQueries",
+					readerArtifact,
+					nestedRefetchQueries: resolvedReaderWithRefetchQueries.nestedRefetchQueries
+				}),
+				fieldName: readerArtifact.fieldName,
+				readerArtifactKind: readerArtifact.kind,
+				root,
+				variables,
+				networkRequest: fakeNetworkRequest
+			}, fakeNetworkRequestOptions);
+			case "EagerReaderArtifact": return readerArtifact.resolver({
+				data: fragmentResult,
+				parameters: variables,
+				...readerArtifact.hasUpdatable ? { startUpdate: require_startUpdate.getOrCreateCachedStartUpdate(environment, fragment, fakeNetworkRequestOptions) } : void 0
+			});
+		}
+	}
+	return null;
+}
+function fetchNormalizationAstAndRetainArtifact(environment, artifact, variables) {
+	const retainedQuery = {
+		normalizationAst: artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAst" ? require_PromiseWrapper.wrapResolvedValue(artifact.networkRequestInfo.normalizationAst) : require_PromiseWrapper.wrapPromise(artifact.networkRequestInfo.normalizationAst.loader()),
+		variables,
+		root: {
+			__link: require_IsographEnvironment.ROOT_ID,
+			__typename: artifact.concreteType
+		}
+	};
+	require_garbageCollection.retainQuery(environment, retainedQuery);
+	return retainedQuery;
+}
+function makeOptimisticUpdate(environment, artifact, variables, optimisticNetworkResponse) {
+	const root = {
+		__link: require_IsographEnvironment.ROOT_ID,
+		__typename: artifact.concreteType
+	};
+	if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with optimisticNetworkResponse is not supported.");
+	const encounteredIds = /* @__PURE__ */ new Map();
+	const optimistic = environment.store = require_optimisticProxy.addOptimisticNetworkResponseStoreLayer(environment.store);
+	require_cache.normalizeData(environment, environment.store, artifact.networkRequestInfo.normalizationAst.selections, optimisticNetworkResponse, variables, root, encounteredIds);
+	require_logging.logMessage(environment, () => ({
+		kind: "AfterNormalization",
+		store: environment.store,
+		encounteredIds
+	}));
+	require_subscribe.callSubscriptions(environment, encounteredIds);
+	return optimistic;
 }
+function revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, normalizeData$1) {
+	if (status.optimistic != null) require_optimisticProxy.revertOptimisticStoreLayerAndMaybeReplace(environment, status.optimistic, normalizeData$1);
+	return {
+		kind: "UndisposedComplete",
+		retainedQuery: status.retainedQuery
+	};
+}
+function unretainAndGarbageCollect(environment, status) {
+	if (require_garbageCollection.unretainQuery(environment, status.retainedQuery)) require_garbageCollection.garbageCollectEnvironment(environment);
+	return { kind: "Disposed" };
+}
+
+//#endregion
+exports.makeNetworkRequest = makeNetworkRequest;
+exports.maybeMakeNetworkRequest = maybeMakeNetworkRequest;
+exports.retainQueryWithoutMakingNetworkRequest = retainQueryWithoutMakingNetworkRequest;