@isograph/react 0.4.3 → 0.5.1

package/dist/core/startUpdate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"startUpdate.mjs","names":["mutableUpdatedIds: EncounteredIds","startUpdate: StartUpdateStoreLayer['startUpdate']","value:\n    | { kind: 'Set'; value: T; validatedAt: number }\n    | {\n        kind: 'NotSet';\n      }","target: { [index: string]: any }","storeRecord","ast","root"],"sources":["../../src/core/startUpdate.ts"],"sourcesContent":["import {\n  getParentRecordKey,\n  insertEmptySetIfMissing,\n  type EncounteredIds,\n} from './cache';\nimport type { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';\nimport {\n  stableIdForFragmentReference,\n  type ExtractParameters,\n  type ExtractStartUpdate,\n  type ExtractUpdatableData,\n  type FragmentReference,\n  type UnknownTReadFromStore,\n} from './FragmentReference';\nimport {\n  assertLink,\n  type IsographEnvironment,\n  type StoreLink,\n} from './IsographEnvironment';\nimport { logMessage } from './logging';\nimport {\n  addStartUpdateStoreLayer,\n  getMutableStoreRecordProxy,\n  getOrInsertRecord,\n  type StartUpdateStoreLayer,\n  type StoreLayer,\n} from './optimisticProxy';\nimport { readPromise, type PromiseWrapper } from './PromiseWrapper';\nimport {\n  readImperativelyLoadedField,\n  readLinkedFieldData,\n  readLoadablySelectedFieldData,\n  readResolverFieldData,\n  readScalarFieldData,\n  type NetworkRequestReaderOptions,\n  type ReadDataResultSuccess,\n} from './read';\nimport type { ReaderAst } from './reader';\nimport { callSubscriptions } from './subscribe';\n\nexport function getOrCreateCachedStartUpdate<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  environment: IsographEnvironment,\n  fragmentReference: FragmentReference<TReadFromStore, unknown>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n): ExtractStartUpdate<TReadFromStore> {\n  return (environment.eagerReaderCache[\n    stableIdForFragmentReference(fragmentReference)\n  ] ??= createStartUpdate(\n    environment,\n    fragmentReference,\n    networkRequestOptions,\n  ));\n}\n\nexport function createStartUpdate<TReadFromStore extends UnknownTReadFromStore>(\n  environment: IsographEnvironment,\n  fragmentReference: FragmentReference<TReadFromStore, unknown>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n): ExtractStartUpdate<TReadFromStore> {\n  return (updater) => {\n    let mutableUpdatedIds: EncounteredIds = new Map();\n\n    const startUpdate: StartUpdateStoreLayer['startUpdate'] = (storeLayer) => {\n      mutableUpdatedIds.clear();\n      let updatableData = createUpdatableProxy(\n        environment,\n        storeLayer,\n        fragmentReference,\n        networkRequestOptions,\n        mutableUpdatedIds,\n      );\n\n      try {\n        updater({ updatableData });\n      } catch (e) {\n        logMessage(environment, () => ({\n          kind: 'StartUpdateError',\n          error: e,\n        }));\n        throw e;\n      }\n    };\n\n    environment.store = addStartUpdateStoreLayer(\n      environment.store,\n      startUpdate,\n    );\n\n    logMessage(environment, () => ({\n      kind: 'StartUpdateComplete',\n      updatedIds: mutableUpdatedIds,\n    }));\n\n    callSubscriptions(environment, mutableUpdatedIds);\n  };\n}\n\nexport function createUpdatableProxy<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  environment: IsographEnvironment,\n  storeLayer: StoreLayer,\n  fragmentReference: FragmentReference<TReadFromStore, unknown>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n  mutableUpdatedIds: EncounteredIds,\n): ExtractUpdatableData<TReadFromStore> {\n  const readerWithRefetchQueries = readPromise(\n    fragmentReference.readerWithRefetchQueries,\n  );\n\n  return readUpdatableData(\n    environment,\n    storeLayer,\n    readerWithRefetchQueries.readerArtifact.readerAst,\n    fragmentReference.root,\n    fragmentReference.variables ?? {},\n    readerWithRefetchQueries.nestedRefetchQueries,\n    fragmentReference.networkRequest,\n    networkRequestOptions,\n    {\n      lastInvalidated: 0,\n    },\n    mutableUpdatedIds,\n  ).data;\n}\n\ntype MutableInvalidationState = {\n  lastInvalidated: number;\n};\n\nfunction defineCachedProperty<T>(\n  target: T,\n  property: PropertyKey,\n  mutableState: MutableInvalidationState,\n  get: () => any,\n  set?: (v: any) => void,\n) {\n  let value:\n    | { kind: 'Set'; value: T; validatedAt: number }\n    | {\n        kind: 'NotSet';\n      } = {\n    kind: 'NotSet',\n  };\n\n  Object.defineProperty(target, property, {\n    configurable: false,\n    enumerable: true,\n    get: () => {\n      if (\n        value.kind === 'NotSet' ||\n        value.validatedAt < mutableState.lastInvalidated\n      ) {\n        value = {\n          kind: 'Set',\n          value: get(),\n          validatedAt: mutableState.lastInvalidated,\n        };\n      }\n      return value.value;\n    },\n    ...(set != null && {\n      set: (newValue) => {\n        set(newValue);\n        mutableState.lastInvalidated++;\n      },\n    }),\n  });\n}\n\nfunction readUpdatableData<TReadFromStore extends UnknownTReadFromStore>(\n  environment: IsographEnvironment,\n  storeLayer: StoreLayer,\n  ast: ReaderAst<TReadFromStore>,\n  root: StoreLink,\n  variables: ExtractParameters<TReadFromStore>,\n  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],\n  networkRequest: PromiseWrapper<void, any>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n  mutableState: MutableInvalidationState,\n  mutableUpdatedIds: EncounteredIds,\n): ReadDataResultSuccess<ExtractUpdatableData<TReadFromStore>> {\n  const storeRecord = getMutableStoreRecordProxy(storeLayer, root);\n  let target: { [index: string]: any } = {};\n\n  for (const field of ast) {\n    switch (field.kind) {\n      case 'Scalar': {\n        const storeRecordName = getParentRecordKey(field, variables);\n\n        defineCachedProperty(\n          target,\n          field.alias ?? field.fieldName,\n          mutableState,\n          () => {\n            const data = readScalarFieldData(\n              field,\n              storeRecord,\n              root,\n              variables,\n            );\n            if (data.kind === 'MissingData') {\n              throw new Error(data.reason);\n            }\n            return data.data;\n          },\n          field.isUpdatable\n            ? (newValue) => {\n                const storeRecord = getOrInsertRecord(storeLayer.data, root);\n                storeRecord[storeRecordName] = newValue;\n                const updatedIds = insertEmptySetIfMissing(\n                  mutableUpdatedIds,\n                  root.__typename,\n                );\n                updatedIds.add(root.__link);\n              }\n            : undefined,\n        );\n        break;\n      }\n      case 'Linked': {\n        const storeRecordName = getParentRecordKey(field, variables);\n        defineCachedProperty(\n          target,\n          field.alias ?? field.fieldName,\n          mutableState,\n          () => {\n            const data = readLinkedFieldData(\n              environment,\n              field,\n              storeRecord,\n              root,\n              variables,\n              nestedRefetchQueries,\n              networkRequest,\n              networkRequestOptions,\n              (ast, root) =>\n                readUpdatableData(\n                  environment,\n                  storeLayer,\n                  ast,\n                  root,\n                  variables,\n                  nestedRefetchQueries,\n                  networkRequest,\n                  networkRequestOptions,\n                  mutableState,\n                  mutableUpdatedIds,\n                ),\n            );\n            if (data.kind === 'MissingData') {\n              throw new Error(data.reason);\n            }\n            return data.data;\n          },\n          'isUpdatable' in field && field.isUpdatable\n            ? (newValue) => {\n                const storeRecord = getOrInsertRecord(storeLayer.data, root);\n                if (Array.isArray(newValue)) {\n                  storeRecord[storeRecordName] = newValue.map((node) =>\n                    assertLink(node?.__link),\n                  );\n                } else {\n                  storeRecord[storeRecordName] = assertLink(newValue?.__link);\n                }\n                const updatedIds = insertEmptySetIfMissing(\n                  mutableUpdatedIds,\n                  root.__typename,\n                );\n                updatedIds.add(root.__link);\n              }\n            : undefined,\n        );\n        break;\n      }\n      case 'ImperativelyLoadedField': {\n        defineCachedProperty(target, field.alias, mutableState, () => {\n          const data = readImperativelyLoadedField(\n            environment,\n            field,\n            root,\n            variables,\n            nestedRefetchQueries,\n            networkRequest,\n            networkRequestOptions,\n            new Map(),\n          );\n          if (data.kind === 'MissingData') {\n            throw new Error(data.reason);\n          }\n          return data.data;\n        });\n        break;\n      }\n      case 'Resolver': {\n        defineCachedProperty(target, field.alias, mutableState, () => {\n          const data = readResolverFieldData(\n            environment,\n            field,\n            root,\n            variables,\n            nestedRefetchQueries,\n            networkRequest,\n            networkRequestOptions,\n            new Map(),\n          );\n          if (data.kind === 'MissingData') {\n            throw new Error(data.reason);\n          }\n          return data.data;\n        });\n        break;\n      }\n      case 'LoadablySelectedField': {\n        defineCachedProperty(target, field.alias, mutableState, () => {\n          const data = readLoadablySelectedFieldData(\n            environment,\n            field,\n            root,\n            variables,\n            networkRequest,\n            networkRequestOptions,\n            new Map(),\n          );\n          if (data.kind === 'MissingData') {\n            throw new Error(data.reason);\n          }\n          return data.data;\n        });\n        break;\n      }\n      case 'Link': {\n        target[field.alias] = root;\n        break;\n      }\n    }\n  }\n\n  return {\n    kind: 'Success',\n    data: target as any,\n  };\n}\n"],"mappings":"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"}

package/dist/core/subscribe.d.mts

@@ -0,0 +1,12 @@
+import { ReaderAst } from "./reader.mjs";
+import { WithEncounteredRecords } from "./read.mjs";
+import { IsographEnvironment } from "./IsographEnvironment.mjs";
+import { FragmentReference, UnknownTReadFromStore } from "./FragmentReference.mjs";
+import { EncounteredIds } from "./cache.mjs";
+
+//#region src/core/subscribe.d.ts
+declare function subscribe<TReadFromStore extends UnknownTReadFromStore>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): () => void;
+declare function callSubscriptions(environment: IsographEnvironment, recordsEncounteredWhenNormalizing: EncounteredIds): void;
+//#endregion
+export { callSubscriptions, subscribe };
+//# sourceMappingURL=subscribe.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.mts","names":[],"sources":["../../src/core/subscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAcgB,iCAAiC,oCAClC,gDACc,uBAAuB,oCAC/B,kBAAkB,+DAEL,uBAAuB,qCAE5C,UAAU;iBAyCP,iBAAA,cACD,wDACsB"}

package/dist/core/subscribe.d.ts

@@ -0,0 +1,12 @@
+import { ReaderAst } from "./reader.js";
+import { WithEncounteredRecords } from "./read.js";
+import { IsographEnvironment } from "./IsographEnvironment.js";
+import { FragmentReference, UnknownTReadFromStore } from "./FragmentReference.js";
+import { EncounteredIds } from "./cache.js";
+
+//#region src/core/subscribe.d.ts
+declare function subscribe<TReadFromStore extends UnknownTReadFromStore>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): () => void;
+declare function callSubscriptions(environment: IsographEnvironment, recordsEncounteredWhenNormalizing: EncounteredIds): void;
+//#endregion
+export { callSubscriptions, subscribe };
+//# sourceMappingURL=subscribe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.ts","names":[],"sources":["../../src/core/subscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAcgB,iCAAiC,oCAClC,gDACc,uBAAuB,oCAC/B,kBAAkB,+DAEL,uBAAuB,qCAE5C,UAAU;iBAyCP,iBAAA,cACD,wDACsB"}

package/dist/core/subscribe.js

@@ -0,0 +1,79 @@
+const require_logging = require('./logging.js');
+const require_areEqualWithDeepComparison = require('./areEqualWithDeepComparison.js');
+const require_read = require('./read.js');
+
+//#region src/core/subscribe.ts
+function subscribe(environment, encounteredDataAndRecords, fragmentReference, callback, readerAst) {
+	const fragmentSubscription = {
+		kind: "FragmentSubscription",
+		callback,
+		encounteredDataAndRecords,
+		fragmentReference,
+		readerAst
+	};
+	callSubscriptionIfDataChanged(environment, fragmentSubscription);
+	environment.subscriptions.add(fragmentSubscription);
+	return () => environment.subscriptions.delete(fragmentSubscription);
+}
+function logAnyError(environment, context, f) {
+	try {
+		f();
+	} catch (e) {
+		require_logging.logMessage(environment, () => ({
+			kind: "ErrorEncounteredInWithErrorHandling",
+			error: e,
+			context
+		}));
+	}
+}
+function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
+	environment.subscriptions.forEach((subscription) => logAnyError(environment, { situation: "calling subscriptions" }, () => {
+		switch (subscription.kind) {
+			case "FragmentSubscription":
+				if (hasOverlappingIds(recordsEncounteredWhenNormalizing, subscription.encounteredDataAndRecords.encounteredRecords)) callSubscriptionIfDataChanged(environment, subscription);
+				return;
+			case "AnyRecords":
+				logAnyError(environment, { situation: "calling AnyRecords callback" }, () => subscription.callback());
+				return;
+			case "AnyChangesToRecord":
+				if (recordsEncounteredWhenNormalizing.get(subscription.recordLink.__typename)?.has(subscription.recordLink.__link) != null) logAnyError(environment, { situation: "calling AnyChangesToRecord callback" }, () => subscription.callback());
+				return;
+		}
+	}));
+}
+function callSubscriptionIfDataChanged(environment, subscription) {
+	const newEncounteredDataAndRecords = require_read.readButDoNotEvaluate(environment, subscription.fragmentReference, {
+		suspendIfInFlight: false,
+		throwOnNetworkError: false
+	});
+	const mergedItem = require_areEqualWithDeepComparison.mergeObjectsUsingReaderAst(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item);
+	require_logging.logMessage(environment, () => ({
+		kind: "DeepEqualityCheck",
+		fragmentReference: subscription.fragmentReference,
+		old: subscription.encounteredDataAndRecords.item,
+		new: newEncounteredDataAndRecords.item,
+		deeplyEqual: mergedItem === subscription.encounteredDataAndRecords.item
+	}));
+	if (mergedItem !== subscription.encounteredDataAndRecords.item) {
+		logAnyError(environment, { situation: "calling FragmentSubscription callback" }, () => {
+			subscription.callback(newEncounteredDataAndRecords);
+		});
+		subscription.encounteredDataAndRecords = newEncounteredDataAndRecords;
+	}
+}
+function hasOverlappingIds(ids1, ids2) {
+	for (const [typeName, set1] of ids1.entries()) {
+		const set2 = ids2.get(typeName);
+		if (set2 === void 0) continue;
+		if (isNotDisjointFrom(set1, set2)) return true;
+	}
+	return false;
+}
+function isNotDisjointFrom(set1, set2) {
+	for (const id of set1) if (set2.has(id)) return true;
+	return false;
+}
+
+//#endregion
+exports.callSubscriptions = callSubscriptions;
+exports.subscribe = subscribe;

package/dist/core/subscribe.mjs

@@ -0,0 +1,79 @@
+import { logMessage } from "./logging.mjs";
+import { mergeObjectsUsingReaderAst } from "./areEqualWithDeepComparison.mjs";
+import { readButDoNotEvaluate } from "./read.mjs";
+
+//#region src/core/subscribe.ts
+function subscribe(environment, encounteredDataAndRecords, fragmentReference, callback, readerAst) {
+	const fragmentSubscription = {
+		kind: "FragmentSubscription",
+		callback,
+		encounteredDataAndRecords,
+		fragmentReference,
+		readerAst
+	};
+	callSubscriptionIfDataChanged(environment, fragmentSubscription);
+	environment.subscriptions.add(fragmentSubscription);
+	return () => environment.subscriptions.delete(fragmentSubscription);
+}
+function logAnyError(environment, context, f) {
+	try {
+		f();
+	} catch (e) {
+		logMessage(environment, () => ({
+			kind: "ErrorEncounteredInWithErrorHandling",
+			error: e,
+			context
+		}));
+	}
+}
+function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
+	environment.subscriptions.forEach((subscription) => logAnyError(environment, { situation: "calling subscriptions" }, () => {
+		switch (subscription.kind) {
+			case "FragmentSubscription":
+				if (hasOverlappingIds(recordsEncounteredWhenNormalizing, subscription.encounteredDataAndRecords.encounteredRecords)) callSubscriptionIfDataChanged(environment, subscription);
+				return;
+			case "AnyRecords":
+				logAnyError(environment, { situation: "calling AnyRecords callback" }, () => subscription.callback());
+				return;
+			case "AnyChangesToRecord":
+				if (recordsEncounteredWhenNormalizing.get(subscription.recordLink.__typename)?.has(subscription.recordLink.__link) != null) logAnyError(environment, { situation: "calling AnyChangesToRecord callback" }, () => subscription.callback());
+				return;
+		}
+	}));
+}
+function callSubscriptionIfDataChanged(environment, subscription) {
+	const newEncounteredDataAndRecords = readButDoNotEvaluate(environment, subscription.fragmentReference, {
+		suspendIfInFlight: false,
+		throwOnNetworkError: false
+	});
+	const mergedItem = mergeObjectsUsingReaderAst(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item);
+	logMessage(environment, () => ({
+		kind: "DeepEqualityCheck",
+		fragmentReference: subscription.fragmentReference,
+		old: subscription.encounteredDataAndRecords.item,
+		new: newEncounteredDataAndRecords.item,
+		deeplyEqual: mergedItem === subscription.encounteredDataAndRecords.item
+	}));
+	if (mergedItem !== subscription.encounteredDataAndRecords.item) {
+		logAnyError(environment, { situation: "calling FragmentSubscription callback" }, () => {
+			subscription.callback(newEncounteredDataAndRecords);
+		});
+		subscription.encounteredDataAndRecords = newEncounteredDataAndRecords;
+	}
+}
+function hasOverlappingIds(ids1, ids2) {
+	for (const [typeName, set1] of ids1.entries()) {
+		const set2 = ids2.get(typeName);
+		if (set2 === void 0) continue;
+		if (isNotDisjointFrom(set1, set2)) return true;
+	}
+	return false;
+}
+function isNotDisjointFrom(set1, set2) {
+	for (const id of set1) if (set2.has(id)) return true;
+	return false;
+}
+
+//#endregion
+export { callSubscriptions, subscribe };
+//# sourceMappingURL=subscribe.mjs.map

package/dist/core/subscribe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.mjs","names":["fragmentSubscription: FragmentSubscription<TReadFromStore>"],"sources":["../../src/core/subscribe.ts"],"sourcesContent":["import { mergeObjectsUsingReaderAst } from './areEqualWithDeepComparison';\nimport type { EncounteredIds } from './cache';\nimport type {\n  FragmentReference,\n  UnknownTReadFromStore,\n} from './FragmentReference';\nimport type {\n  FragmentSubscription,\n  IsographEnvironment,\n} from './IsographEnvironment';\nimport { logMessage } from './logging';\nimport { type WithEncounteredRecords, readButDoNotEvaluate } from './read';\nimport type { ReaderAst } from './reader';\n\nexport function subscribe<TReadFromStore extends UnknownTReadFromStore>(\n  environment: IsographEnvironment,\n  encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,\n  fragmentReference: FragmentReference<TReadFromStore, any>,\n  callback: (\n    newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,\n  ) => void,\n  readerAst: ReaderAst<TReadFromStore>,\n): () => void {\n  const fragmentSubscription: FragmentSubscription<TReadFromStore> = {\n    kind: 'FragmentSubscription',\n    callback,\n    encounteredDataAndRecords,\n    fragmentReference,\n    readerAst,\n  };\n\n  // subscribe is called in an effect. (We should actually subscribe during the\n  // initial render.) Because it's called in an effect, we might have missed some\n  // changes since the initial render! So, at this point, we re-read and call the\n  // subscription (i.e. re-render) if the fragment data has changed.\n  callSubscriptionIfDataChanged(environment, fragmentSubscription);\n\n  environment.subscriptions.add(fragmentSubscription);\n  return () => environment.subscriptions.delete(fragmentSubscription);\n}\n\n// Calls to readButDoNotEvaluate can suspend (i.e. throw a promise).\n// Maybe in the future, they will be able to throw errors.\n//\n// That's probably okay to ignore. We don't, however, want to prevent\n// updating other subscriptions if one subscription had missing data.\nfunction logAnyError(\n  environment: IsographEnvironment,\n  context: any,\n  f: () => void,\n) {\n  try {\n    f();\n  } catch (e) {\n    logMessage(environment, () => ({\n      kind: 'ErrorEncounteredInWithErrorHandling',\n      error: e,\n      context,\n    }));\n  }\n}\n\nexport function callSubscriptions(\n  environment: IsographEnvironment,\n  recordsEncounteredWhenNormalizing: EncounteredIds,\n) {\n  environment.subscriptions.forEach((subscription) =>\n    logAnyError(environment, { situation: 'calling subscriptions' }, () => {\n      switch (subscription.kind) {\n        case 'FragmentSubscription': {\n          // TODO if there are multiple components subscribed to the same\n          // fragment, we will call readButNotEvaluate multiple times. We\n          // should fix that.\n          if (\n            hasOverlappingIds(\n              recordsEncounteredWhenNormalizing,\n              subscription.encounteredDataAndRecords.encounteredRecords,\n            )\n          ) {\n            callSubscriptionIfDataChanged(environment, subscription);\n          }\n          return;\n        }\n        case 'AnyRecords': {\n          logAnyError(\n            environment,\n            { situation: 'calling AnyRecords callback' },\n            () => subscription.callback(),\n          );\n          return;\n        }\n        case 'AnyChangesToRecord': {\n          if (\n            recordsEncounteredWhenNormalizing\n              .get(subscription.recordLink.__typename)\n              ?.has(subscription.recordLink.__link) != null\n          ) {\n            logAnyError(\n              environment,\n              { situation: 'calling AnyChangesToRecord callback' },\n              () => subscription.callback(),\n            );\n          }\n          return;\n        }\n      }\n    }),\n  );\n}\n\nfunction callSubscriptionIfDataChanged<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  environment: IsographEnvironment,\n  subscription: FragmentSubscription<TReadFromStore>,\n) {\n  const newEncounteredDataAndRecords = readButDoNotEvaluate(\n    environment,\n    subscription.fragmentReference,\n    // Is this wrong?\n    // Reasons to think no:\n    // - we are only updating the read-out value, and the network\n    //   options only affect whether we throw.\n    // - the component will re-render, and re-throw on its own, anyway.\n    //\n    // Reasons to think not:\n    // - it seems more efficient to suspend here and not update state,\n    //   if we expect that the component will just throw anyway\n    // - consistency\n    // - it's also weird, this is called from makeNetworkRequest, where\n    //   we don't currently pass network request options\n    {\n      suspendIfInFlight: false,\n      throwOnNetworkError: false,\n    },\n  );\n\n  const mergedItem = mergeObjectsUsingReaderAst(\n    subscription.readerAst,\n    subscription.encounteredDataAndRecords.item,\n    newEncounteredDataAndRecords.item,\n  );\n\n  logMessage(environment, () => ({\n    kind: 'DeepEqualityCheck',\n    fragmentReference: subscription.fragmentReference,\n    old: subscription.encounteredDataAndRecords.item,\n    new: newEncounteredDataAndRecords.item,\n    deeplyEqual: mergedItem === subscription.encounteredDataAndRecords.item,\n  }));\n\n  if (mergedItem !== subscription.encounteredDataAndRecords.item) {\n    logAnyError(\n      environment,\n      { situation: 'calling FragmentSubscription callback' },\n      () => {\n        subscription.callback(newEncounteredDataAndRecords);\n      },\n    );\n    subscription.encounteredDataAndRecords = newEncounteredDataAndRecords;\n  }\n}\n\nfunction hasOverlappingIds(\n  ids1: EncounteredIds,\n  ids2: EncounteredIds,\n): boolean {\n  for (const [typeName, set1] of ids1.entries()) {\n    const set2 = ids2.get(typeName);\n    if (set2 === undefined) {\n      continue;\n    }\n\n    if (isNotDisjointFrom(set1, set2)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n// TODO use a polyfill library\nfunction isNotDisjointFrom<T>(set1: Set<T>, set2: Set<T>): boolean {\n  for (const id of set1) {\n    if (set2.has(id)) {\n      return true;\n    }\n  }\n  return false;\n}\n"],"mappings":";;;;;AAcA,SAAgB,UACd,aACA,2BACA,mBACA,UAGA,WACY;CACZ,MAAMA,uBAA6D;EACjE,MAAM;EACN;EACA;EACA;EACA;EACD;AAMD,+BAA8B,aAAa,qBAAqB;AAEhE,aAAY,cAAc,IAAI,qBAAqB;AACnD,cAAa,YAAY,cAAc,OAAO,qBAAqB;;AAQrE,SAAS,YACP,aACA,SACA,GACA;AACA,KAAI;AACF,KAAG;UACI,GAAG;AACV,aAAW,oBAAoB;GAC7B,MAAM;GACN,OAAO;GACP;GACD,EAAE;;;AAIP,SAAgB,kBACd,aACA,mCACA;AACA,aAAY,cAAc,SAAS,iBACjC,YAAY,aAAa,EAAE,WAAW,yBAAyB,QAAQ;AACrE,UAAQ,aAAa,MAArB;GACE,KAAK;AAIH,QACE,kBACE,mCACA,aAAa,0BAA0B,mBACxC,CAED,+BAA8B,aAAa,aAAa;AAE1D;GAEF,KAAK;AACH,gBACE,aACA,EAAE,WAAW,+BAA+B,QACtC,aAAa,UAAU,CAC9B;AACD;GAEF,KAAK;AACH,QACE,kCACG,IAAI,aAAa,WAAW,WAAW,EACtC,IAAI,aAAa,WAAW,OAAO,IAAI,KAE3C,aACE,aACA,EAAE,WAAW,uCAAuC,QAC9C,aAAa,UAAU,CAC9B;AAEH;;GAGJ,CACH;;AAGH,SAAS,8BAGP,aACA,cACA;CACA,MAAM,+BAA+B,qBACnC,aACA,aAAa,mBAab;EACE,mBAAmB;EACnB,qBAAqB;EACtB,CACF;CAED,MAAM,aAAa,2BACjB,aAAa,WACb,aAAa,0BAA0B,MACvC,6BAA6B,KAC9B;AAED,YAAW,oBAAoB;EAC7B,MAAM;EACN,mBAAmB,aAAa;EAChC,KAAK,aAAa,0BAA0B;EAC5C,KAAK,6BAA6B;EAClC,aAAa,eAAe,aAAa,0BAA0B;EACpE,EAAE;AAEH,KAAI,eAAe,aAAa,0BAA0B,MAAM;AAC9D,cACE,aACA,EAAE,WAAW,yCAAyC,QAChD;AACJ,gBAAa,SAAS,6BAA6B;IAEtD;AACD,eAAa,4BAA4B;;;AAI7C,SAAS,kBACP,MACA,MACS;AACT,MAAK,MAAM,CAAC,UAAU,SAAS,KAAK,SAAS,EAAE;EAC7C,MAAM,OAAO,KAAK,IAAI,SAAS;AAC/B,MAAI,SAAS,OACX;AAGF,MAAI,kBAAkB,MAAM,KAAK,CAC/B,QAAO;;AAGX,QAAO;;AAIT,SAAS,kBAAqB,MAAc,MAAuB;AACjE,MAAK,MAAM,MAAM,KACf,KAAI,KAAK,IAAI,GAAG,CACd,QAAO;AAGX,QAAO"}

package/dist/core/util.d.mts

@@ -0,0 +1,27 @@
+import React from "react";
+
+//#region src/core/util.d.ts
+type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends ((arg1: any, arg2: infer P) => any) ? P : never;
+type CombineWithIntrinsicAttributes<T> = T extends Record<PropertyKey, never> ? React.JSX.IntrinsicAttributes : T & React.JSX.IntrinsicAttributes;
+type Arguments = Argument[];
+type Argument = [ArgumentName, ArgumentValue];
+type ArgumentName = string;
+type ArgumentValue = {
+  readonly kind: 'Variable';
+  readonly name: string;
+} | {
+  readonly kind: 'Literal';
+  readonly value: any;
+} | {
+  readonly kind: 'String';
+  readonly value: string;
+} | {
+  readonly kind: 'Enum';
+  readonly value: string;
+} | {
+  readonly kind: 'Object';
+  readonly value: Arguments;
+};
+//#endregion
+export { Argument, ArgumentName, ArgumentValue, Arguments, CombineWithIntrinsicAttributes, ExtractSecondParam };
+//# sourceMappingURL=util.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.mts","names":[],"sources":["../../src/core/util.ts"],"sourcesContent":[],"mappings":";;;KAEY,8DACV,gDAA8C;KACpC,oCACV,UAAU,OAAO,sBACb,KAAA,CAAM,GAAA,CAAI,sBACV,IAAI,KAAA,CAAM,GAAA,CAAI;AALR,KAOA,SAAA,GAAY,QAPM,EAAA;AAElB,KAMA,QAAA,GANA,CAMY,YANZ,EAM0B,aANI,CAAA;AACxC,KAMU,YAAA,GANV,MAAA;AAAiB,KAOP,aAAA,GAPO;EAAP,SAAA,IAAA,EAAA,UAAA;EACN,SAAU,IAAA,EAAA,MAAA;CACV,GAAA;EAAI,SAAU,IAAA,EAAA,SAAA;EAAmB,SAAA,KAAA,EAAA,GAAA;AAEvC,CAAA,GAAY;EACA,SAAA,IAAQ,EAAA,QAAA;EACR,SAAA,KAAA,EAAY,MAAA;AACxB,CAAA,GAAY;;;;;kBAmBU"}

package/dist/core/util.d.ts

@@ -1,23 +1,27 @@
-import type React from 'react';
-export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
-export type CombineWithIntrinsicAttributes<T> = T extends Record<PropertyKey, never> ? React.JSX.IntrinsicAttributes : T & React.JSX.IntrinsicAttributes;
-export type Arguments = Argument[];
-export type Argument = [ArgumentName, ArgumentValue];
-export type ArgumentName = string;
-export type ArgumentValue = {
-    readonly kind: 'Variable';
-    readonly name: string;
+import React from "react";
+
+//#region src/core/util.d.ts
+type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends ((arg1: any, arg2: infer P) => any) ? P : never;
+type CombineWithIntrinsicAttributes<T> = T extends Record<PropertyKey, never> ? React.JSX.IntrinsicAttributes : T & React.JSX.IntrinsicAttributes;
+type Arguments = Argument[];
+type Argument = [ArgumentName, ArgumentValue];
+type ArgumentName = string;
+type ArgumentValue = {
+  readonly kind: 'Variable';
+  readonly name: string;
 } | {
-    readonly kind: 'Literal';
-    readonly value: any;
+  readonly kind: 'Literal';
+  readonly value: any;
 } | {
-    readonly kind: 'String';
-    readonly value: string;
+  readonly kind: 'String';
+  readonly value: string;
 } | {
-    readonly kind: 'Enum';
-    readonly value: string;
+  readonly kind: 'Enum';
+  readonly value: string;
 } | {
-    readonly kind: 'Object';
-    readonly value: Arguments;
+  readonly kind: 'Object';
+  readonly value: Arguments;
 };
+//#endregion
+export { Argument, ArgumentName, ArgumentValue, Arguments, CombineWithIntrinsicAttributes, ExtractSecondParam };
 //# sourceMappingURL=util.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/core/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,KAAK,GAAG,IACpE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,KAAK,CAAC;AAC1D,MAAM,MAAM,8BAA8B,CAAC,CAAC,IAC1C,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,GAChC,KAAK,CAAC,GAAG,CAAC,mBAAmB,GAC7B,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,mBAAmB,CAAC;AAExC,MAAM,MAAM,SAAS,GAAG,QAAQ,EAAE,CAAC;AACnC,MAAM,MAAM,QAAQ,GAAG,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;AACrD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAClC,MAAM,MAAM,aAAa,GACrB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;CACrB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;CAC3B,CAAC"}
+{"version":3,"file":"util.d.ts","names":[],"sources":["../../src/core/util.ts"],"sourcesContent":[],"mappings":";;;KAEY,8DACV,gDAA8C;KACpC,oCACV,UAAU,OAAO,sBACb,KAAA,CAAM,GAAA,CAAI,sBACV,IAAI,KAAA,CAAM,GAAA,CAAI;AALR,KAOA,SAAA,GAAY,QAPM,EAAA;AAElB,KAMA,QAAA,GANA,CAMY,YANZ,EAM0B,aANI,CAAA;AACxC,KAMU,YAAA,GANV,MAAA;AAAiB,KAOP,aAAA,GAPO;EAAP,SAAA,IAAA,EAAA,UAAA;EACN,SAAU,IAAA,EAAA,MAAA;CACV,GAAA;EAAI,SAAU,IAAA,EAAA,SAAA;EAAmB,SAAA,KAAA,EAAA,GAAA;AAEvC,CAAA,GAAY;EACA,SAAA,IAAQ,EAAA,QAAA;EACR,SAAA,KAAA,EAAY,MAAA;AACxB,CAAA,GAAY;;;;;kBAmBU"}

package/dist/core/util.js

@@ -1,2 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+//#region src/core/util.ts
+function isArray(value) {
+	return Array.isArray(value);
+}
+/**
+* Creates a copy of the provided value, ensuring any nested objects have their
+* keys sorted such that equivalent values would have identical JSON.stringify
+* results.
+*/
+function stableCopy(value) {
+	if (value == null || typeof value !== "object") return value;
+	if (isArray(value)) return value.map(stableCopy);
+	const keys = Object.keys(value).sort();
+	const stable = {};
+	for (let i = 0; i < keys.length; i++) stable[keys[i]] = stableCopy(value[keys[i]]);
+	return stable;
+}
+
+//#endregion
+exports.isArray = isArray;
+exports.stableCopy = stableCopy;

package/dist/core/util.mjs

@@ -0,0 +1,21 @@
+//#region src/core/util.ts
+function isArray(value) {
+	return Array.isArray(value);
+}
+/**
+* Creates a copy of the provided value, ensuring any nested objects have their
+* keys sorted such that equivalent values would have identical JSON.stringify
+* results.
+*/
+function stableCopy(value) {
+	if (value == null || typeof value !== "object") return value;
+	if (isArray(value)) return value.map(stableCopy);
+	const keys = Object.keys(value).sort();
+	const stable = {};
+	for (let i = 0; i < keys.length; i++) stable[keys[i]] = stableCopy(value[keys[i]]);
+	return stable;
+}
+
+//#endregion
+export { isArray, stableCopy };
+//# sourceMappingURL=util.mjs.map

package/dist/core/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","names":["stable: { [index: string]: any }"],"sources":["../../src/core/util.ts"],"sourcesContent":["import type React from 'react';\n\nexport type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> =\n  T extends (arg1: any, arg2: infer P) => any ? P : never;\nexport type CombineWithIntrinsicAttributes<T> =\n  T extends Record<PropertyKey, never>\n    ? React.JSX.IntrinsicAttributes\n    : T & React.JSX.IntrinsicAttributes;\n\nexport type Arguments = Argument[];\nexport type Argument = [ArgumentName, ArgumentValue];\nexport type ArgumentName = string;\nexport type ArgumentValue =\n  | {\n      readonly kind: 'Variable';\n      readonly name: string;\n    }\n  | {\n      readonly kind: 'Literal';\n      readonly value: any;\n    }\n  | {\n      readonly kind: 'String';\n      readonly value: string;\n    }\n  | {\n      readonly kind: 'Enum';\n      readonly value: string;\n    }\n  | {\n      readonly kind: 'Object';\n      readonly value: Arguments;\n    };\n\nexport function isArray(value: unknown): value is readonly unknown[] {\n  return Array.isArray(value);\n}\n\n/**\n * Creates a copy of the provided value, ensuring any nested objects have their\n * keys sorted such that equivalent values would have identical JSON.stringify\n * results.\n */\nexport function stableCopy<T>(value: T): T {\n  if (value == null || typeof value !== 'object') {\n    return value;\n  }\n  if (isArray(value)) {\n    // @ts-ignore\n    return value.map(stableCopy);\n  }\n  const keys = Object.keys(value).sort();\n  const stable: { [index: string]: any } = {};\n  for (let i = 0; i < keys.length; i++) {\n    // @ts-ignore\n    stable[keys[i]] = stableCopy(value[keys[i]]);\n  }\n  return stable as any;\n}\n"],"mappings":";AAkCA,SAAgB,QAAQ,OAA6C;AACnE,QAAO,MAAM,QAAQ,MAAM;;;;;;;AAQ7B,SAAgB,WAAc,OAAa;AACzC,KAAI,SAAS,QAAQ,OAAO,UAAU,SACpC,QAAO;AAET,KAAI,QAAQ,MAAM,CAEhB,QAAO,MAAM,IAAI,WAAW;CAE9B,MAAM,OAAO,OAAO,KAAK,MAAM,CAAC,MAAM;CACtC,MAAMA,SAAmC,EAAE;AAC3C,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,IAE/B,QAAO,KAAK,MAAM,WAAW,MAAM,KAAK,IAAI;AAE9C,QAAO"}

package/dist/core/writeData.d.mts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from "./IsographEnvironment.mjs";
+import { ExtractParameters, FragmentReference, UnknownTReadFromStore } from "./FragmentReference.mjs";
+import { NetworkResponseObject } from "./cache.mjs";
+import { IsographEntrypoint, NormalizationAst } from "./entrypoint.mjs";
+import { ItemCleanupPair } from "@isograph/isograph-disposable-types/dist";
+
+//#region src/core/writeData.d.ts
+declare function writeData<TReadFromStore extends UnknownTReadFromStore, TRawResponseType extends NetworkResponseObject, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, NormalizationAst, TRawResponseType>, data: TRawResponseType, variables: ExtractParameters<TReadFromStore>): ItemCleanupPair<FragmentReference<TReadFromStore, TClientFieldValue>>;
+//#endregion
+export { writeData };
+//# sourceMappingURL=writeData.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeData.d.mts","names":[],"sources":["../../src/core/writeData.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAsBgB,iCACS,gDACE,uDAGZ,iCACD,mBACV,gBACA,mBACA,kBACA,yBAEI,6BACK,kBAAkB,kBAC5B,gBAAgB,kBAAkB,gBAAgB"}

package/dist/core/writeData.d.ts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from "./IsographEnvironment.js";
+import { ExtractParameters, FragmentReference, UnknownTReadFromStore } from "./FragmentReference.js";
+import { NetworkResponseObject } from "./cache.js";
+import { IsographEntrypoint, NormalizationAst } from "./entrypoint.js";
+import { ItemCleanupPair } from "@isograph/isograph-disposable-types/dist";
+
+//#region src/core/writeData.d.ts
+declare function writeData<TReadFromStore extends UnknownTReadFromStore, TRawResponseType extends NetworkResponseObject, TClientFieldValue>(environment: IsographEnvironment, entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, NormalizationAst, TRawResponseType>, data: TRawResponseType, variables: ExtractParameters<TReadFromStore>): ItemCleanupPair<FragmentReference<TReadFromStore, TClientFieldValue>>;
+//#endregion
+export { writeData };
+//# sourceMappingURL=writeData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writeData.d.ts","names":[],"sources":["../../src/core/writeData.ts"],"sourcesContent":[],"mappings":";;;;;;;iBAsBgB,iCACS,gDACE,uDAGZ,iCACD,mBACV,gBACA,mBACA,kBACA,yBAEI,6BACK,kBAAkB,kBAC5B,gBAAgB,kBAAkB,gBAAgB"}

package/dist/core/writeData.js

@@ -0,0 +1,41 @@
+const require_IsographEnvironment = require('./IsographEnvironment.js');
+const require_logging = require('./logging.js');
+const require_makeNetworkRequest = require('./makeNetworkRequest.js');
+const require_subscribe = require('./subscribe.js');
+const require_optimisticProxy = require('./optimisticProxy.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/writeData.ts
+function writeData(environment, entrypoint, data, variables) {
+	const encounteredIds = /* @__PURE__ */ new Map();
+	environment.store = require_optimisticProxy.addNetworkResponseStoreLayer(environment.store);
+	require_cache.normalizeData(environment, environment.store, entrypoint.networkRequestInfo.normalizationAst.selections, data, variables, {
+		__link: require_IsographEnvironment.ROOT_ID,
+		__typename: entrypoint.concreteType
+	}, encounteredIds);
+	require_logging.logMessage(environment, () => ({
+		kind: "AfterNormalization",
+		store: environment.store,
+		encounteredIds
+	}));
+	require_subscribe.callSubscriptions(environment, encounteredIds);
+	const { fieldName, readerArtifactKind, readerWithRefetchQueries } = require_IsographEnvironment.getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+	const [networkRequest, disposeNetworkRequest] = require_makeNetworkRequest.retainQueryWithoutMakingNetworkRequest(environment, entrypoint, variables);
+	return [{
+		kind: "FragmentReference",
+		readerWithRefetchQueries,
+		fieldName,
+		readerArtifactKind,
+		root: {
+			__link: require_IsographEnvironment.ROOT_ID,
+			__typename: entrypoint.concreteType
+		},
+		variables,
+		networkRequest
+	}, () => {
+		disposeNetworkRequest();
+	}];
+}
+
+//#endregion
+exports.writeData = writeData;

package/dist/core/writeData.mjs

@@ -0,0 +1,42 @@
+import { ROOT_ID, getOrLoadReaderWithRefetchQueries } from "./IsographEnvironment.mjs";
+import { logMessage } from "./logging.mjs";
+import { retainQueryWithoutMakingNetworkRequest } from "./makeNetworkRequest.mjs";
+import { callSubscriptions } from "./subscribe.mjs";
+import { addNetworkResponseStoreLayer } from "./optimisticProxy.mjs";
+import { normalizeData } from "./cache.mjs";
+
+//#region src/core/writeData.ts
+function writeData(environment, entrypoint, data, variables) {
+	const encounteredIds = /* @__PURE__ */ new Map();
+	environment.store = addNetworkResponseStoreLayer(environment.store);
+	normalizeData(environment, environment.store, entrypoint.networkRequestInfo.normalizationAst.selections, data, variables, {
+		__link: ROOT_ID,
+		__typename: entrypoint.concreteType
+	}, encounteredIds);
+	logMessage(environment, () => ({
+		kind: "AfterNormalization",
+		store: environment.store,
+		encounteredIds
+	}));
+	callSubscriptions(environment, encounteredIds);
+	const { fieldName, readerArtifactKind, readerWithRefetchQueries } = getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+	const [networkRequest, disposeNetworkRequest] = retainQueryWithoutMakingNetworkRequest(environment, entrypoint, variables);
+	return [{
+		kind: "FragmentReference",
+		readerWithRefetchQueries,
+		fieldName,
+		readerArtifactKind,
+		root: {
+			__link: ROOT_ID,
+			__typename: entrypoint.concreteType
+		},
+		variables,
+		networkRequest
+	}, () => {
+		disposeNetworkRequest();
+	}];
+}
+
+//#endregion
+export { writeData };
+//# sourceMappingURL=writeData.mjs.map

package/dist/core/writeData.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeData.mjs","names":["encounteredIds: EncounteredIds"],"sources":["../../src/core/writeData.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';\nimport { callSubscriptions } from './subscribe';\nimport {\n  type NetworkResponseObject,\n  type EncounteredIds,\n  normalizeData,\n} from './cache';\nimport type { IsographEntrypoint, NormalizationAst } from './entrypoint';\nimport type {\n  UnknownTReadFromStore,\n  ExtractParameters,\n  FragmentReference,\n} from './FragmentReference';\nimport {\n  type IsographEnvironment,\n  ROOT_ID,\n  getOrLoadReaderWithRefetchQueries,\n} from './IsographEnvironment';\nimport { logMessage } from './logging';\nimport { retainQueryWithoutMakingNetworkRequest } from './makeNetworkRequest';\nimport { addNetworkResponseStoreLayer } from './optimisticProxy';\n\nexport function writeData<\n  TReadFromStore extends UnknownTReadFromStore,\n  TRawResponseType extends NetworkResponseObject,\n  TClientFieldValue,\n>(\n  environment: IsographEnvironment,\n  entrypoint: IsographEntrypoint<\n    TReadFromStore,\n    TClientFieldValue,\n    NormalizationAst,\n    TRawResponseType\n  >,\n  data: TRawResponseType,\n  variables: ExtractParameters<TReadFromStore>,\n): ItemCleanupPair<FragmentReference<TReadFromStore, TClientFieldValue>> {\n  const encounteredIds: EncounteredIds = new Map();\n  environment.store = addNetworkResponseStoreLayer(environment.store);\n  normalizeData(\n    environment,\n    environment.store,\n    entrypoint.networkRequestInfo.normalizationAst.selections,\n    data,\n    variables,\n    { __link: ROOT_ID, __typename: entrypoint.concreteType },\n    encounteredIds,\n  );\n  logMessage(environment, () => ({\n    kind: 'AfterNormalization',\n    store: environment.store,\n    encounteredIds,\n  }));\n\n  callSubscriptions(environment, encounteredIds);\n\n  const { fieldName, readerArtifactKind, readerWithRefetchQueries } =\n    getOrLoadReaderWithRefetchQueries(\n      environment,\n      entrypoint.readerWithRefetchQueries,\n    );\n  const [networkRequest, disposeNetworkRequest] =\n    retainQueryWithoutMakingNetworkRequest(environment, entrypoint, variables);\n\n  return [\n    {\n      kind: 'FragmentReference',\n      readerWithRefetchQueries,\n      fieldName,\n      readerArtifactKind,\n      root: { __link: ROOT_ID, __typename: entrypoint.concreteType },\n      variables,\n      networkRequest,\n    },\n    () => {\n      disposeNetworkRequest();\n    },\n  ];\n}\n"],"mappings":";;;;;;;;AAsBA,SAAgB,UAKd,aACA,YAMA,MACA,WACuE;CACvE,MAAMA,iCAAiC,IAAI,KAAK;AAChD,aAAY,QAAQ,6BAA6B,YAAY,MAAM;AACnE,eACE,aACA,YAAY,OACZ,WAAW,mBAAmB,iBAAiB,YAC/C,MACA,WACA;EAAE,QAAQ;EAAS,YAAY,WAAW;EAAc,EACxD,eACD;AACD,YAAW,oBAAoB;EAC7B,MAAM;EACN,OAAO,YAAY;EACnB;EACD,EAAE;AAEH,mBAAkB,aAAa,eAAe;CAE9C,MAAM,EAAE,WAAW,oBAAoB,6BACrC,kCACE,aACA,WAAW,yBACZ;CACH,MAAM,CAAC,gBAAgB,yBACrB,uCAAuC,aAAa,YAAY,UAAU;AAE5E,QAAO,CACL;EACE,MAAM;EACN;EACA;EACA;EACA,MAAM;GAAE,QAAQ;GAAS,YAAY,WAAW;GAAc;EAC9D;EACA;EACD,QACK;AACJ,yBAAuB;GAE1B"}

package/dist/index.d.mts

@@ -0,0 +1,32 @@
+import { CheckResult, FetchOptions, RequiredFetchOptions, RequiredShouldFetch, ShouldFetch, check } from "./core/check.mjs";
+import { AnyError, NOT_SET, NotSet, PromiseState, PromiseWrapper, Result, getPromiseState, readPromise, wrapPromise, wrapResolvedValue } from "./core/PromiseWrapper.mjs";
+import { Argument, ArgumentName, ArgumentValue, Arguments, CombineWithIntrinsicAttributes, ExtractSecondParam } from "./core/util.mjs";
+import { ComponentReaderArtifact, EagerReaderArtifact, LoadableField, LoadablySelectedField, ReaderAst, ReaderAstNode, ReaderImperativelyLoadedField, ReaderLinkField, ReaderLinkedField, ReaderNonLoadableResolverField, ReaderScalarField, RefetchReaderArtifact, ResolverFirstParameter, StableId, StartUpdate, TopLevelReaderArtifact } from "./core/reader.mjs";
+import { NetworkRequestReaderOptions, ReadDataResult, WithEncounteredRecords, readButDoNotEvaluate } from "./core/read.mjs";
+import { LogFunction, LogMessage, WrappedLogFunction, logMessage, registerLogger } from "./core/logging.mjs";
+import { AnyChangesToRecordSubscription, AnyRecordSubscription, BaseStoreLayerData, CacheMap, ComponentOrFieldName, DataId, DataTypeValue, FieldCache, FragmentSubscription, IsographEnvironment, IsographNetworkFunction, Link, MissingFieldHandler, ROOT_ID, StoreLink, StoreRecord, StringifiedArgs, Subscription, Subscriptions, TypeName, createIsographStore } from "./core/IsographEnvironment.mjs";
+import { ExtractData, ExtractParameters, ExtractStartUpdate, FragmentReference, StableIdForFragmentReference, UnknownTReadFromStore, VariableValue, Variables, stableIdForFragmentReference } from "./core/FragmentReference.mjs";
+import { EncounteredIds, NetworkResponseObject, NetworkResponseScalarValue, NetworkResponseValue, normalizeData } from "./core/cache.mjs";
+import { ExtractClientFieldValue, ExtractProps, ExtractReadFromStore, ExtractResolverResult, FragmentReferenceOfEntrypoint, IsographEntrypoint, IsographEntrypointLoader, IsographOperation, IsographPersistedOperation, IsographPersistedOperationExtraInfo, NetworkRequestInfo, NormalizationAst, NormalizationAstLoader, NormalizationAstNode, NormalizationAstNodes, NormalizationInlineFragment, NormalizationLinkedField, NormalizationScalarField, ReaderWithRefetchQueries, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper, assertIsEntrypoint } from "./core/entrypoint.mjs";
+import { DidUnretainSomeQuery, RetainedQuery, garbageCollectEnvironment, retainQuery, unretainQuery } from "./core/garbageCollection.mjs";
+import { callSubscriptions, subscribe } from "./core/subscribe.mjs";
+import { writeData } from "./core/writeData.mjs";
+import { makeNetworkRequest } from "./core/makeNetworkRequest.mjs";
+import { IsographEnvironmentProvider, IsographEnvironmentProviderProps, useIsographEnvironment } from "./react/IsographEnvironmentProvider.mjs";
+import { UseImperativeReferenceResult, useImperativeReference } from "./react/useImperativeReference.mjs";
+import { FragmentRenderer, IsExactlyIntrinsicAttributes } from "./react/FragmentRenderer.mjs";
+import { FragmentReader } from "./react/FragmentReader.mjs";
+import { LoadableFieldReader } from "./react/LoadableFieldReader.mjs";
+import { LoadableFieldRenderer } from "./react/LoadableFieldRenderer.mjs";
+import { useResult } from "./react/useResult.mjs";
+import { useReadAndSubscribe, useSubscribeToMultiple } from "./react/useReadAndSubscribe.mjs";
+import { useLazyReference } from "./react/useLazyReference.mjs";
+import { useRerenderOnChange } from "./react/useRerenderOnChange.mjs";
+import { RenderAfterCommit__DO_NOT_USE } from "./react/RenderAfterCommit__DO_NOT_USE.mjs";
+import { createIsographEnvironment } from "./react/createIsographEnvironment.mjs";
+import { useClientSideDefer } from "./loadable-hooks/useClientSideDefer.mjs";
+import { UseImperativeLoadableFieldReturn, useImperativeExposedMutationField } from "./loadable-hooks/useImperativeExposedMutationField.mjs";
+import { UseSkipLimitPaginationArgs, UseSkipLimitReturnValue, useSkipLimitPagination } from "./loadable-hooks/useSkipLimitPagination.mjs";
+import { Connection, PageInfo, UseConnectionSpecPaginationArgs, UsePaginationReturnValue, useConnectionSpecPagination } from "./loadable-hooks/useConnectionSpecPagination.mjs";
+import { UseImperativeLoadableFieldReturn as UseImperativeLoadableFieldReturn$1, useImperativeLoadableField } from "./loadable-hooks/useImperativeLoadableField.mjs";
+export { type AnyChangesToRecordSubscription, type AnyError, type AnyRecordSubscription, type Argument, type ArgumentName, type ArgumentValue, type Arguments, type CacheMap, type CheckResult, type CombineWithIntrinsicAttributes, type ComponentOrFieldName, type ComponentReaderArtifact, type Connection, type DataId, type DataTypeValue, type DidUnretainSomeQuery, type EagerReaderArtifact, type EncounteredIds, type ExtractClientFieldValue, type ExtractData, type ExtractParameters, type ExtractProps, type ExtractReadFromStore, type ExtractResolverResult, type ExtractSecondParam, type ExtractStartUpdate, type FetchOptions, type FieldCache, FragmentReader, type FragmentReference, type FragmentReferenceOfEntrypoint, FragmentRenderer, type FragmentSubscription, type IsExactlyIntrinsicAttributes, type IsographEntrypoint, type IsographEntrypointLoader, type IsographEnvironment, IsographEnvironmentProvider, type IsographEnvironmentProviderProps, type IsographNetworkFunction, type IsographOperation, type IsographPersistedOperation, type IsographPersistedOperationExtraInfo, type BaseStoreLayerData as IsographStore, type Link, type LoadableField, LoadableFieldReader, LoadableFieldRenderer, type LogFunction, type LogMessage, type MissingFieldHandler, NOT_SET, type NetworkRequestInfo, type NetworkRequestReaderOptions, type NetworkResponseObject, type NetworkResponseScalarValue, type NetworkResponseValue, type NormalizationAst, type NormalizationAstLoader, type NormalizationAstNode, type NormalizationAstNodes, type NormalizationInlineFragment, type NormalizationLinkedField, type NormalizationScalarField, type NotSet, type PageInfo, type PromiseState, type PromiseWrapper, ROOT_ID, type ReadDataResult, type ReaderAst, type ReaderAstNode, type ReaderImperativelyLoadedField, type ReaderLinkField, type ReaderLinkedField, type LoadablySelectedField as ReaderLoadableField, type ReaderNonLoadableResolverField, type ReaderScalarField, type ReaderWithRefetchQueries, type RefetchQueryNormalizationArtifact, type RefetchQueryNormalizationArtifactWrapper, type RefetchReaderArtifact, RenderAfterCommit__DO_NOT_USE, type RequiredFetchOptions, type RequiredShouldFetch, type ResolverFirstParameter, type Result, type RetainedQuery, type ShouldFetch, type StableId, type StableIdForFragmentReference, type StartUpdate, type StoreLink, type StoreRecord, type StringifiedArgs, type Subscription, type Subscriptions, type TopLevelReaderArtifact, type TypeName, type UnknownTReadFromStore, type UseConnectionSpecPaginationArgs, type UseImperativeLoadableFieldReturn as UseImperativeExposedMutationFieldReturn, type UseImperativeLoadableFieldReturn$1 as UseImperativeLoadableFieldReturn, type UseImperativeReferenceResult, type UsePaginationReturnValue, type UseSkipLimitPaginationArgs, type UseSkipLimitReturnValue, type VariableValue, type Variables, type WithEncounteredRecords, type WrappedLogFunction, assertIsEntrypoint, callSubscriptions, check, createIsographEnvironment, createIsographStore, garbageCollectEnvironment, getPromiseState, logMessage, makeNetworkRequest, normalizeData, readButDoNotEvaluate, readPromise, registerLogger, retainQuery, stableIdForFragmentReference, subscribe, unretainQuery, useClientSideDefer, useConnectionSpecPagination, useImperativeExposedMutationField, useImperativeLoadableField, useImperativeReference, useIsographEnvironment, useLazyReference, useReadAndSubscribe, useRerenderOnChange, useResult, useSkipLimitPagination, useSubscribeToMultiple, wrapPromise, wrapResolvedValue, writeData };