@isograph/react 0.0.0-main-3de26263 → 0.0.0-main-709dc2bb

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

@@ -1,8 +1,12 @@
-import type { EncounteredIds } from './cache';
-import type { FragmentReference, UnknownTReadFromStore } from './FragmentReference';
-import type { IsographEnvironment } from './IsographEnvironment';
-import { type WithEncounteredRecords } from './read';
-import type { ReaderAst } from './reader';
-export declare function subscribe<TReadFromStore extends UnknownTReadFromStore>(environment: IsographEnvironment, encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<TReadFromStore, any>, callback: (newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): () => void;
-export declare function callSubscriptions(environment: IsographEnvironment, recordsEncounteredWhenNormalizing: EncounteredIds): void;
+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

@@ -1 +1 @@
-{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["../../src/core/subscribe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,KAAK,sBAAsB,EAAwB,MAAM,QAAQ,CAAC;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,wBAAgB,SAAS,CAAC,cAAc,SAAS,qBAAqB,EACpE,WAAW,EAAE,mBAAmB,EAChC,yBAAyB,EAAE,sBAAsB,CAAC,cAAc,CAAC,EACjE,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,EACzD,QAAQ,EAAE,CACR,4BAA4B,EAAE,sBAAsB,CAAC,cAAc,CAAC,KACjE,IAAI,EACT,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,GACnC,MAAM,IAAI,CAiBZ;AAuBD,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,mBAAmB,EAChC,iCAAiC,EAAE,cAAc,QA4ClD"}
+{"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

@@ -1,121 +1,79 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribe = subscribe;
-exports.callSubscriptions = callSubscriptions;
-const areEqualWithDeepComparison_1 = require("./areEqualWithDeepComparison");
-const logging_1 = require("./logging");
-const read_1 = require("./read");
+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,
-    };
-    // subscribe is called in an effect. (We should actually subscribe during the
-    // initial render.) Because it's called in an effect, we might have missed some
-    // changes since the initial render! So, at this point, we re-read and call the
-    // subscription (i.e. re-render) if the fragment data has changed.
-    callSubscriptionIfDataChanged(environment, fragmentSubscription);
-    environment.subscriptions.add(fragmentSubscription);
-    return () => environment.subscriptions.delete(fragmentSubscription);
+	const fragmentSubscription = {
+		kind: "FragmentSubscription",
+		callback,
+		encounteredDataAndRecords,
+		fragmentReference,
+		readerAst
+	};
+	callSubscriptionIfDataChanged(environment, fragmentSubscription);
+	environment.subscriptions.add(fragmentSubscription);
+	return () => environment.subscriptions.delete(fragmentSubscription);
 }
-// Calls to readButDoNotEvaluate can suspend (i.e. throw a promise).
-// Maybe in the future, they will be able to throw errors.
-//
-// That's probably okay to ignore. We don't, however, want to prevent
-// updating other subscriptions if one subscription had missing data.
 function logAnyError(environment, context, f) {
-    try {
-        f();
-    }
-    catch (e) {
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ErrorEncounteredInWithErrorHandling',
-            error: e,
-            context,
-        }));
-    }
+	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' }, () => {
-        var _a;
-        switch (subscription.kind) {
-            case 'FragmentSubscription': {
-                // TODO if there are multiple components subscribed to the same
-                // fragment, we will call readButNotEvaluate multiple times. We
-                // should fix that.
-                if (hasOverlappingIds(recordsEncounteredWhenNormalizing, subscription.encounteredDataAndRecords.encounteredRecords)) {
-                    callSubscriptionIfDataChanged(environment, subscription);
-                }
-                return;
-            }
-            case 'AnyRecords': {
-                logAnyError(environment, { situation: 'calling AnyRecords callback' }, () => subscription.callback());
-                return;
-            }
-            case 'AnyChangesToRecord': {
-                if (((_a = recordsEncounteredWhenNormalizing
-                    .get(subscription.recordLink.__typename)) === null || _a === void 0 ? void 0 : _a.has(subscription.recordLink.__link)) != null) {
-                    logAnyError(environment, { situation: 'calling AnyChangesToRecord callback' }, () => subscription.callback());
-                }
-                return;
-            }
-        }
-    }));
+	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 = (0, read_1.readButDoNotEvaluate)(environment, subscription.fragmentReference, 
-    // Is this wrong?
-    // Reasons to think no:
-    // - we are only updating the read-out value, and the network
-    //   options only affect whether we throw.
-    // - the component will re-render, and re-throw on its own, anyway.
-    //
-    // Reasons to think not:
-    // - it seems more efficient to suspend here and not update state,
-    //   if we expect that the component will just throw anyway
-    // - consistency
-    // - it's also weird, this is called from makeNetworkRequest, where
-    //   we don't currently pass network request options
-    {
-        suspendIfInFlight: false,
-        throwOnNetworkError: false,
-    });
-    const mergedItem = (0, areEqualWithDeepComparison_1.mergeObjectsUsingReaderAst)(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item);
-    (0, logging_1.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;
-    }
+	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 === undefined) {
-            continue;
-        }
-        if (isNotDisjointFrom(set1, set2)) {
-            return true;
-        }
-    }
-    return false;
+	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;
 }
-// TODO use a polyfill library
 function isNotDisjointFrom(set1, set2) {
-    for (const id of set1) {
-        if (set2.has(id)) {
-            return true;
-        }
-    }
-    return false;
+	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,30 +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;
 };
-export declare function isArray(value: unknown): value is readonly unknown[];
-/**
- * Creates a copy of the provided value, ensuring any nested objects have their
- * keys sorted such that equivalent values would have identical JSON.stringify
- * results.
- */
-export declare function stableCopy<T>(value: T): T;
+//#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;AAEN,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,OAAO,EAAE,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAezC"}
+{"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,28 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isArray = isArray;
-exports.stableCopy = stableCopy;
+
+//#region src/core/util.ts
 function isArray(value) {
-    return Array.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.
- */
+* 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)) {
-        // @ts-ignore
-        return value.map(stableCopy);
-    }
-    const keys = Object.keys(value).sort();
-    const stable = {};
-    for (let i = 0; i < keys.length; i++) {
-        // @ts-ignore
-        stable[keys[i]] = stableCopy(value[keys[i]]);
-    }
-    return stable;
+	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

@@ -1,7 +1,11 @@
-import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';
-import { type NetworkResponseObject } from './cache';
-import type { IsographEntrypoint, NormalizationAst } from './entrypoint';
-import type { UnknownTReadFromStore, ExtractParameters, FragmentReference } from './FragmentReference';
-import { type IsographEnvironment } from './IsographEnvironment';
-export 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>>;
+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

@@ -1 +1 @@
-{"version":3,"file":"writeData.d.ts","sourceRoot":"","sources":["../../src/core/writeData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAEhF,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACzE,OAAO,KAAK,EACV,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,uBAAuB,CAAC;AAK/B,wBAAgB,SAAS,CACvB,cAAc,SAAS,qBAAqB,EAC5C,gBAAgB,SAAS,qBAAqB,EAC9C,iBAAiB,EAEjB,WAAW,EAAE,mBAAmB,EAChC,UAAU,EAAE,kBAAkB,CAC5B,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,CACjB,EACD,IAAI,EAAE,gBAAgB,EACtB,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,GAC3C,eAAe,CAAC,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC,CA0CvE"}
+{"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"}