@isograph/react 0.4.3 → 0.5.1

package/dist/core/garbageCollection.js

@@ -1,107 +1,90 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unretainQuery = unretainQuery;
-exports.retainQuery = retainQuery;
-exports.garbageCollectEnvironment = garbageCollectEnvironment;
-const cache_1 = require("./cache");
-const IsographEnvironment_1 = require("./IsographEnvironment");
+const require_PromiseWrapper = require('./PromiseWrapper.js');
+const require_IsographEnvironment = require('./IsographEnvironment.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/garbageCollection.ts
+function isRetainedQueryWithNormalizationAst(query) {
+	return query.normalizationAst.result !== require_PromiseWrapper.NOT_SET && query.normalizationAst.result.kind === "Ok";
+}
 function unretainQuery(environment, retainedQuery) {
-    environment.retainedQueries.delete(retainedQuery);
-    environment.gcBuffer.push(retainedQuery);
-    if (environment.gcBuffer.length > environment.gcBufferSize) {
-        environment.gcBuffer.shift();
-        return true;
-    }
-    return false;
+	environment.retainedQueries.delete(retainedQuery);
+	environment.gcBuffer.push(retainedQuery);
+	if (environment.gcBuffer.length > environment.gcBufferSize) {
+		environment.gcBuffer.shift();
+		return true;
+	}
+	return false;
 }
 function retainQuery(environment, queryToRetain) {
-    environment.retainedQueries.add(queryToRetain);
-    // TODO can we remove this query from the buffer somehow?
-    // We are relying on === equality, but we really should be comparing
-    // id + variables
+	environment.retainedQueries.add(queryToRetain);
 }
 function garbageCollectEnvironment(environment) {
-    const retainedIds = {};
-    for (const query of environment.retainedQueries) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const query of environment.gcBuffer) {
-        recordReachableIds(environment.store, query, retainedIds);
-    }
-    for (const typeName in environment.store) {
-        const dataById = environment.store[typeName];
-        if (dataById == null)
-            continue;
-        const retainedTypeIds = retainedIds[typeName];
-        // delete all objects
-        if (retainedTypeIds == undefined || retainedTypeIds.size == 0) {
-            delete environment.store[typeName];
-            continue;
-        }
-        for (const dataId in dataById) {
-            if (!retainedTypeIds.has(dataId)) {
-                delete dataById[dataId];
-            }
-        }
-        if (Object.keys(dataById).length === 0) {
-            delete environment.store[typeName];
-        }
-    }
+	if (environment.store.kind !== "BaseStoreLayer") return;
+	const retainedQueries = [];
+	for (const query of environment.retainedQueries) {
+		if (!isRetainedQueryWithNormalizationAst(query)) return;
+		retainedQueries.push(query);
+	}
+	for (const query of environment.gcBuffer) {
+		if (!isRetainedQueryWithNormalizationAst(query)) return;
+		retainedQueries.push(query);
+	}
+	garbageCollectBaseStoreLayer(retainedQueries, environment.store);
 }
-function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
-    var _a, _b;
-    var _c;
-    const record = (_a = store[retainedQuery.root.__typename]) === null || _a === void 0 ? void 0 : _a[retainedQuery.root.__link];
-    const retainedRecordsIds = ((_b = mutableRetainedIds[_c = retainedQuery.root.__typename]) !== null && _b !== void 0 ? _b : (mutableRetainedIds[_c] = new Set()));
-    retainedRecordsIds.add(retainedQuery.root.__link);
-    if (record) {
-        recordReachableIdsFromRecord(store, record, mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
-    }
+function garbageCollectBaseStoreLayer(retainedQueries, baseStoreLayer) {
+	const retainedIds = {};
+	for (const query of retainedQueries) recordReachableIds(baseStoreLayer.data, query, retainedIds);
+	for (const typeName in baseStoreLayer.data) {
+		const dataById = baseStoreLayer.data[typeName];
+		if (dataById == null) continue;
+		const retainedTypeIds = retainedIds[typeName];
+		if (retainedTypeIds === void 0 || retainedTypeIds.size === 0) {
+			delete baseStoreLayer.data[typeName];
+			continue;
+		}
+		for (const dataId in dataById) if (!retainedTypeIds.has(dataId)) delete dataById[dataId];
+		if (Object.keys(dataById).length === 0) delete baseStoreLayer.data[typeName];
+	}
 }
-function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
-    var _a;
-    for (const selection of selections) {
-        switch (selection.kind) {
-            case 'Linked':
-                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
-                const linkedFieldOrFields = currentRecord[linkKey];
-                const links = [];
-                if (Array.isArray(linkedFieldOrFields)) {
-                    for (const maybeLink of linkedFieldOrFields) {
-                        const link = (0, IsographEnvironment_1.assertLink)(maybeLink);
-                        if (link != null) {
-                            links.push(link);
-                        }
-                    }
-                }
-                else {
-                    const link = (0, IsographEnvironment_1.assertLink)(linkedFieldOrFields);
-                    if (link != null) {
-                        links.push(link);
-                    }
-                }
-                let typeStore = selection.concreteType !== null
-                    ? store[selection.concreteType]
-                    : null;
-                if (typeStore == null && selection.concreteType !== null) {
-                    continue;
-                }
-                for (const nextRecordLink of links) {
-                    let __typename = nextRecordLink.__typename;
-                    const resolvedTypeStore = typeStore !== null && typeStore !== void 0 ? typeStore : store[__typename];
-                    if (resolvedTypeStore == null) {
-                        continue;
-                    }
-                    const nextRecord = resolvedTypeStore[nextRecordLink.__link];
-                    if (nextRecord != null) {
-                        const retainedRecordsIds = ((_a = mutableRetainedIds[__typename]) !== null && _a !== void 0 ? _a : (mutableRetainedIds[__typename] = new Set()));
-                        retainedRecordsIds.add(nextRecordLink.__link);
-                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
-                    }
-                }
-                continue;
-            case 'Scalar':
-                continue;
-        }
-    }
+function recordReachableIds(dataLayer, retainedQuery, mutableRetainedIds) {
+	const record = dataLayer[retainedQuery.root.__typename]?.[retainedQuery.root.__link];
+	(mutableRetainedIds[retainedQuery.root.__typename] ??= /* @__PURE__ */ new Set()).add(retainedQuery.root.__link);
+	if (record != null) recordReachableIdsFromRecord(dataLayer, record, mutableRetainedIds, retainedQuery.normalizationAst.result.value.selections, retainedQuery.variables);
 }
+function recordReachableIdsFromRecord(dataLayer, currentRecord, mutableRetainedIds, selections, variables) {
+	for (const selection of selections) switch (selection.kind) {
+		case "InlineFragment":
+			if (currentRecord[require_cache.TYPENAME_FIELD_NAME] === selection.type) recordReachableIdsFromRecord(dataLayer, currentRecord, mutableRetainedIds, selection.selections, variables);
+			continue;
+		case "Linked":
+			const linkedFieldOrFields = currentRecord[require_cache.getParentRecordKey(selection, variables ?? {})];
+			const links = [];
+			if (Array.isArray(linkedFieldOrFields)) for (const maybeLink of linkedFieldOrFields) {
+				const link = require_IsographEnvironment.assertLink(maybeLink);
+				if (link != null) links.push(link);
+			}
+			else {
+				const link = require_IsographEnvironment.assertLink(linkedFieldOrFields);
+				if (link != null) links.push(link);
+			}
+			let typeStore = selection.concreteType != null ? dataLayer[selection.concreteType] : null;
+			if (typeStore == null && selection.concreteType != null) continue;
+			for (const nextRecordLink of links) {
+				let __typename = nextRecordLink.__typename;
+				const resolvedTypeStore = typeStore ?? dataLayer[__typename];
+				if (resolvedTypeStore == null) continue;
+				const nextRecord = resolvedTypeStore[nextRecordLink.__link];
+				if (nextRecord != null) {
+					(mutableRetainedIds[__typename] ??= /* @__PURE__ */ new Set()).add(nextRecordLink.__link);
+					recordReachableIdsFromRecord(dataLayer, nextRecord, mutableRetainedIds, selection.selections, variables);
+				}
+			}
+			continue;
+		case "Scalar": continue;
+	}
+}
+
+//#endregion
+exports.garbageCollectEnvironment = garbageCollectEnvironment;
+exports.retainQuery = retainQuery;
+exports.unretainQuery = unretainQuery;

package/dist/core/garbageCollection.mjs

@@ -0,0 +1,89 @@
+import { NOT_SET } from "./PromiseWrapper.mjs";
+import { assertLink } from "./IsographEnvironment.mjs";
+import { TYPENAME_FIELD_NAME, getParentRecordKey } from "./cache.mjs";
+
+//#region src/core/garbageCollection.ts
+function isRetainedQueryWithNormalizationAst(query) {
+	return query.normalizationAst.result !== NOT_SET && query.normalizationAst.result.kind === "Ok";
+}
+function unretainQuery(environment, retainedQuery) {
+	environment.retainedQueries.delete(retainedQuery);
+	environment.gcBuffer.push(retainedQuery);
+	if (environment.gcBuffer.length > environment.gcBufferSize) {
+		environment.gcBuffer.shift();
+		return true;
+	}
+	return false;
+}
+function retainQuery(environment, queryToRetain) {
+	environment.retainedQueries.add(queryToRetain);
+}
+function garbageCollectEnvironment(environment) {
+	if (environment.store.kind !== "BaseStoreLayer") return;
+	const retainedQueries = [];
+	for (const query of environment.retainedQueries) {
+		if (!isRetainedQueryWithNormalizationAst(query)) return;
+		retainedQueries.push(query);
+	}
+	for (const query of environment.gcBuffer) {
+		if (!isRetainedQueryWithNormalizationAst(query)) return;
+		retainedQueries.push(query);
+	}
+	garbageCollectBaseStoreLayer(retainedQueries, environment.store);
+}
+function garbageCollectBaseStoreLayer(retainedQueries, baseStoreLayer) {
+	const retainedIds = {};
+	for (const query of retainedQueries) recordReachableIds(baseStoreLayer.data, query, retainedIds);
+	for (const typeName in baseStoreLayer.data) {
+		const dataById = baseStoreLayer.data[typeName];
+		if (dataById == null) continue;
+		const retainedTypeIds = retainedIds[typeName];
+		if (retainedTypeIds === void 0 || retainedTypeIds.size === 0) {
+			delete baseStoreLayer.data[typeName];
+			continue;
+		}
+		for (const dataId in dataById) if (!retainedTypeIds.has(dataId)) delete dataById[dataId];
+		if (Object.keys(dataById).length === 0) delete baseStoreLayer.data[typeName];
+	}
+}
+function recordReachableIds(dataLayer, retainedQuery, mutableRetainedIds) {
+	const record = dataLayer[retainedQuery.root.__typename]?.[retainedQuery.root.__link];
+	(mutableRetainedIds[retainedQuery.root.__typename] ??= /* @__PURE__ */ new Set()).add(retainedQuery.root.__link);
+	if (record != null) recordReachableIdsFromRecord(dataLayer, record, mutableRetainedIds, retainedQuery.normalizationAst.result.value.selections, retainedQuery.variables);
+}
+function recordReachableIdsFromRecord(dataLayer, currentRecord, mutableRetainedIds, selections, variables) {
+	for (const selection of selections) switch (selection.kind) {
+		case "InlineFragment":
+			if (currentRecord[TYPENAME_FIELD_NAME] === selection.type) recordReachableIdsFromRecord(dataLayer, currentRecord, mutableRetainedIds, selection.selections, variables);
+			continue;
+		case "Linked":
+			const linkedFieldOrFields = currentRecord[getParentRecordKey(selection, variables ?? {})];
+			const links = [];
+			if (Array.isArray(linkedFieldOrFields)) for (const maybeLink of linkedFieldOrFields) {
+				const link = assertLink(maybeLink);
+				if (link != null) links.push(link);
+			}
+			else {
+				const link = assertLink(linkedFieldOrFields);
+				if (link != null) links.push(link);
+			}
+			let typeStore = selection.concreteType != null ? dataLayer[selection.concreteType] : null;
+			if (typeStore == null && selection.concreteType != null) continue;
+			for (const nextRecordLink of links) {
+				let __typename = nextRecordLink.__typename;
+				const resolvedTypeStore = typeStore ?? dataLayer[__typename];
+				if (resolvedTypeStore == null) continue;
+				const nextRecord = resolvedTypeStore[nextRecordLink.__link];
+				if (nextRecord != null) {
+					(mutableRetainedIds[__typename] ??= /* @__PURE__ */ new Set()).add(nextRecordLink.__link);
+					recordReachableIdsFromRecord(dataLayer, nextRecord, mutableRetainedIds, selection.selections, variables);
+				}
+			}
+			continue;
+		case "Scalar": continue;
+	}
+}
+
+//#endregion
+export { garbageCollectEnvironment, retainQuery, unretainQuery };
+//# sourceMappingURL=garbageCollection.mjs.map

package/dist/core/garbageCollection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"garbageCollection.mjs","names":["retainedQueries: RetainedQueryWithNormalizationAst[]","retainedIds: RetainedIds","links: StoreLink[]"],"sources":["../../src/core/garbageCollection.ts"],"sourcesContent":["import { getParentRecordKey, TYPENAME_FIELD_NAME } from './cache';\nimport type { NormalizationAstNodes, NormalizationAst } from './entrypoint';\nimport type { Variables } from './FragmentReference';\nimport {\n  assertLink,\n  type DataId,\n  type IsographEnvironment,\n  type StoreRecord,\n  type StoreLayerData,\n  type StoreLink,\n  type TypeName,\n} from './IsographEnvironment';\nimport type { BaseStoreLayer } from './optimisticProxy';\nimport {\n  NOT_SET,\n  type PromiseWrapper,\n  type PromiseWrapperOk,\n} from './PromiseWrapper';\n\nexport type RetainedQuery = {\n  readonly normalizationAst: PromiseWrapper<NormalizationAst>;\n  readonly variables: {};\n  readonly root: StoreLink;\n};\n\nexport interface RetainedQueryWithNormalizationAst extends RetainedQuery {\n  readonly normalizationAst: PromiseWrapperOk<NormalizationAst>;\n}\n\nfunction isRetainedQueryWithNormalizationAst(\n  query: RetainedQuery,\n): query is RetainedQueryWithNormalizationAst {\n  return (\n    query.normalizationAst.result !== NOT_SET &&\n    query.normalizationAst.result.kind === 'Ok'\n  );\n}\n\nexport type DidUnretainSomeQuery = boolean;\nexport function unretainQuery(\n  environment: IsographEnvironment,\n  retainedQuery: RetainedQuery,\n): DidUnretainSomeQuery {\n  environment.retainedQueries.delete(retainedQuery);\n  environment.gcBuffer.push(retainedQuery);\n\n  if (environment.gcBuffer.length > environment.gcBufferSize) {\n    environment.gcBuffer.shift();\n    return true;\n  }\n\n  return false;\n}\n\nexport function retainQuery(\n  environment: IsographEnvironment,\n  queryToRetain: RetainedQuery,\n) {\n  environment.retainedQueries.add(queryToRetain);\n  // TODO can we remove this query from the buffer somehow?\n  // We are relying on === equality, but we really should be comparing\n  // id + variables\n}\n\nexport function garbageCollectEnvironment(environment: IsographEnvironment) {\n  if (environment.store.kind !== 'BaseStoreLayer') {\n    return;\n  }\n\n  const retainedQueries: RetainedQueryWithNormalizationAst[] = [];\n  for (const query of environment.retainedQueries) {\n    if (!isRetainedQueryWithNormalizationAst(query)) {\n      return;\n    }\n    retainedQueries.push(query);\n  }\n\n  for (const query of environment.gcBuffer) {\n    if (!isRetainedQueryWithNormalizationAst(query)) {\n      return;\n    }\n    retainedQueries.push(query);\n  }\n\n  garbageCollectBaseStoreLayer(retainedQueries, environment.store);\n}\n\nexport function garbageCollectBaseStoreLayer(\n  retainedQueries: RetainedQueryWithNormalizationAst[],\n  baseStoreLayer: BaseStoreLayer,\n) {\n  const retainedIds: RetainedIds = {};\n\n  for (const query of retainedQueries) {\n    recordReachableIds(baseStoreLayer.data, query, retainedIds);\n  }\n\n  for (const typeName in baseStoreLayer.data) {\n    const dataById = baseStoreLayer.data[typeName];\n    if (dataById == null) continue;\n    const retainedTypeIds = retainedIds[typeName];\n\n    // delete all objects\n    if (retainedTypeIds === undefined || retainedTypeIds.size === 0) {\n      delete baseStoreLayer.data[typeName];\n      continue;\n    }\n\n    for (const dataId in dataById) {\n      if (!retainedTypeIds.has(dataId)) {\n        delete dataById[dataId];\n      }\n    }\n\n    if (Object.keys(dataById).length === 0) {\n      delete baseStoreLayer.data[typeName];\n    }\n  }\n}\n\ninterface RetainedIds {\n  [typeName: TypeName]: Set<DataId>;\n}\n\nfunction recordReachableIds(\n  dataLayer: StoreLayerData,\n  retainedQuery: RetainedQueryWithNormalizationAst,\n  mutableRetainedIds: RetainedIds,\n) {\n  const record =\n    dataLayer[retainedQuery.root.__typename]?.[retainedQuery.root.__link];\n\n  const retainedRecordsIds = (mutableRetainedIds[\n    retainedQuery.root.__typename\n  ] ??= new Set());\n  retainedRecordsIds.add(retainedQuery.root.__link);\n\n  if (record != null) {\n    recordReachableIdsFromRecord(\n      dataLayer,\n      record,\n      mutableRetainedIds,\n      retainedQuery.normalizationAst.result.value.selections,\n      retainedQuery.variables,\n    );\n  }\n}\n\nfunction recordReachableIdsFromRecord(\n  dataLayer: StoreLayerData,\n  currentRecord: StoreRecord,\n  mutableRetainedIds: RetainedIds,\n  selections: NormalizationAstNodes,\n  variables: Variables | null,\n) {\n  for (const selection of selections) {\n    switch (selection.kind) {\n      case 'InlineFragment':\n        if (currentRecord[TYPENAME_FIELD_NAME] === selection.type) {\n          recordReachableIdsFromRecord(\n            dataLayer,\n            currentRecord,\n            mutableRetainedIds,\n            selection.selections,\n            variables,\n          );\n        }\n        continue;\n      case 'Linked':\n        const linkKey = getParentRecordKey(selection, variables ?? {});\n        const linkedFieldOrFields = currentRecord[linkKey];\n\n        const links: StoreLink[] = [];\n        if (Array.isArray(linkedFieldOrFields)) {\n          for (const maybeLink of linkedFieldOrFields) {\n            const link = assertLink(maybeLink);\n            if (link != null) {\n              links.push(link);\n            }\n          }\n        } else {\n          const link = assertLink(linkedFieldOrFields);\n          if (link != null) {\n            links.push(link);\n          }\n        }\n\n        let typeStore =\n          selection.concreteType != null\n            ? dataLayer[selection.concreteType]\n            : null;\n\n        if (typeStore == null && selection.concreteType != null) {\n          continue;\n        }\n\n        for (const nextRecordLink of links) {\n          let __typename = nextRecordLink.__typename;\n\n          const resolvedTypeStore = typeStore ?? dataLayer[__typename];\n\n          if (resolvedTypeStore == null) {\n            continue;\n          }\n\n          const nextRecord = resolvedTypeStore[nextRecordLink.__link];\n          if (nextRecord != null) {\n            const retainedRecordsIds = (mutableRetainedIds[__typename] ??=\n              new Set());\n            retainedRecordsIds.add(nextRecordLink.__link);\n            recordReachableIdsFromRecord(\n              dataLayer,\n              nextRecord,\n              mutableRetainedIds,\n              selection.selections,\n              variables,\n            );\n          }\n        }\n\n        continue;\n      case 'Scalar':\n        continue;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/core/getOrCreateCacheForArtifact.js

@@ -0,0 +1,37 @@
+const require_util = require('./util.js');
+const require_IsographEnvironment = require('./IsographEnvironment.js');
+const require_makeNetworkRequest = require('./makeNetworkRequest.js');
+const require_cache = require('./cache.js');
+
+//#region src/core/getOrCreateCacheForArtifact.ts
+function getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions) {
+	let cacheKey = "";
+	switch (entrypoint.networkRequestInfo.operation.kind) {
+		case "Operation":
+			cacheKey = entrypoint.networkRequestInfo.operation.text + JSON.stringify(require_util.stableCopy(variables));
+			break;
+		case "PersistedOperation":
+			cacheKey = entrypoint.networkRequestInfo.operation.operationId + JSON.stringify(require_util.stableCopy(variables));
+			break;
+	}
+	const factory = () => {
+		const { fieldName, readerArtifactKind, readerWithRefetchQueries } = require_IsographEnvironment.getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+		const [networkRequest, disposeNetworkRequest] = require_makeNetworkRequest.maybeMakeNetworkRequest(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions ?? null);
+		return [{
+			kind: "FragmentReference",
+			readerWithRefetchQueries,
+			fieldName,
+			readerArtifactKind,
+			root: {
+				__link: require_IsographEnvironment.ROOT_ID,
+				__typename: entrypoint.concreteType
+			},
+			variables,
+			networkRequest
+		}, disposeNetworkRequest];
+	};
+	return require_cache.getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
+}
+
+//#endregion
+exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;

package/dist/core/getOrCreateCacheForArtifact.mjs

@@ -0,0 +1,38 @@
+import { stableCopy } from "./util.mjs";
+import { ROOT_ID, getOrLoadReaderWithRefetchQueries } from "./IsographEnvironment.mjs";
+import { maybeMakeNetworkRequest } from "./makeNetworkRequest.mjs";
+import { getOrCreateItemInSuspenseCache } from "./cache.mjs";
+
+//#region src/core/getOrCreateCacheForArtifact.ts
+function getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions) {
+	let cacheKey = "";
+	switch (entrypoint.networkRequestInfo.operation.kind) {
+		case "Operation":
+			cacheKey = entrypoint.networkRequestInfo.operation.text + JSON.stringify(stableCopy(variables));
+			break;
+		case "PersistedOperation":
+			cacheKey = entrypoint.networkRequestInfo.operation.operationId + JSON.stringify(stableCopy(variables));
+			break;
+	}
+	const factory = () => {
+		const { fieldName, readerArtifactKind, readerWithRefetchQueries } = getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+		const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions ?? null);
+		return [{
+			kind: "FragmentReference",
+			readerWithRefetchQueries,
+			fieldName,
+			readerArtifactKind,
+			root: {
+				__link: ROOT_ID,
+				__typename: entrypoint.concreteType
+			},
+			variables,
+			networkRequest
+		}, disposeNetworkRequest];
+	};
+	return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
+}
+
+//#endregion
+export { getOrCreateCacheForArtifact };
+//# sourceMappingURL=getOrCreateCacheForArtifact.mjs.map

package/dist/core/getOrCreateCacheForArtifact.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOrCreateCacheForArtifact.mjs","names":[],"sources":["../../src/core/getOrCreateCacheForArtifact.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/isograph-disposable-types/dist';\nimport type { ParentCache } from '@isograph/isograph-react-disposable-state/dist';\nimport {\n  type NetworkResponseObject,\n  getOrCreateItemInSuspenseCache,\n} from './cache';\nimport type { FetchOptions } from './check';\nimport type {\n  IsographEntrypoint,\n  NormalizationAst,\n  NormalizationAstLoader,\n} from './entrypoint';\nimport type {\n  ExtractParameters,\n  FragmentReference,\n  UnknownTReadFromStore,\n} from './FragmentReference';\nimport {\n  type IsographEnvironment,\n  getOrLoadReaderWithRefetchQueries,\n  ROOT_ID,\n} from './IsographEnvironment';\nimport { maybeMakeNetworkRequest } from './makeNetworkRequest';\nimport { stableCopy } from './util';\n\nexport function getOrCreateCacheForArtifact<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  environment: IsographEnvironment,\n  entrypoint: IsographEntrypoint<\n    TReadFromStore,\n    TClientFieldValue,\n    TNormalizationAst,\n    TRawResponseType\n  >,\n  variables: ExtractParameters<TReadFromStore>,\n  fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>,\n): ParentCache<FragmentReference<TReadFromStore, TClientFieldValue>> {\n  let cacheKey = '';\n  switch (entrypoint.networkRequestInfo.operation.kind) {\n    case 'Operation':\n      cacheKey =\n        entrypoint.networkRequestInfo.operation.text +\n        JSON.stringify(stableCopy(variables));\n      break;\n    case 'PersistedOperation':\n      cacheKey =\n        entrypoint.networkRequestInfo.operation.operationId +\n        JSON.stringify(stableCopy(variables));\n      break;\n  }\n  const factory = () => {\n    const { fieldName, readerArtifactKind, readerWithRefetchQueries } =\n      getOrLoadReaderWithRefetchQueries(\n        environment,\n        entrypoint.readerWithRefetchQueries,\n      );\n    const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(\n      environment,\n      entrypoint,\n      variables,\n      readerWithRefetchQueries,\n      fetchOptions ?? null,\n    );\n\n    const itemCleanupPair: ItemCleanupPair<\n      FragmentReference<TReadFromStore, TClientFieldValue>\n    > = [\n      {\n        kind: 'FragmentReference',\n        readerWithRefetchQueries,\n        fieldName,\n        readerArtifactKind,\n        root: { __link: ROOT_ID, __typename: entrypoint.concreteType },\n        variables,\n        networkRequest: networkRequest,\n      },\n      disposeNetworkRequest,\n    ];\n    return itemCleanupPair;\n  };\n  return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);\n}\n"],"mappings":";;;;;;AAyBA,SAAgB,4BAMd,aACA,YAMA,WACA,cACmE;CACnE,IAAI,WAAW;AACf,SAAQ,WAAW,mBAAmB,UAAU,MAAhD;EACE,KAAK;AACH,cACE,WAAW,mBAAmB,UAAU,OACxC,KAAK,UAAU,WAAW,UAAU,CAAC;AACvC;EACF,KAAK;AACH,cACE,WAAW,mBAAmB,UAAU,cACxC,KAAK,UAAU,WAAW,UAAU,CAAC;AACvC;;CAEJ,MAAM,gBAAgB;EACpB,MAAM,EAAE,WAAW,oBAAoB,6BACrC,kCACE,aACA,WAAW,yBACZ;EACH,MAAM,CAAC,gBAAgB,yBAAyB,wBAC9C,aACA,YACA,WACA,0BACA,gBAAgB,KACjB;AAgBD,SAZI,CACF;GACE,MAAM;GACN;GACA;GACA;GACA,MAAM;IAAE,QAAQ;IAAS,YAAY,WAAW;IAAc;GAC9D;GACgB;GACjB,EACD,sBACD;;AAGH,QAAO,+BAA+B,aAAa,UAAU,QAAQ"}

package/dist/core/logging.d.mts

@@ -0,0 +1,95 @@
+import { CheckResult } from "./check.mjs";
+import { Arguments } from "./util.mjs";
+import { ReadDataResult } from "./read.mjs";
+import { StoreLayer } from "./optimisticProxy.mjs";
+import { IsographEnvironment, StoreLink, StoreRecord } from "./IsographEnvironment.mjs";
+import { FragmentReference, Variables } from "./FragmentReference.mjs";
+import { EncounteredIds, NetworkResponseObject } from "./cache.mjs";
+import { IsographEntrypoint, NormalizationAstNodes, RefetchQueryNormalizationArtifact } from "./entrypoint.mjs";
+import { CleanupFn } from "@isograph/disposable-types";
+
+//#region src/core/logging.d.ts
+
+/**
+ * Note: these types are unstable. We will add and remove items from this enum
+ * and add and remove fields. Please do not rely on the specifics here (for now).
+ *
+ * Goals include:
+ * - convenient debugging for Isograph developers
+ * - eventual support for the Isograph devtools
+ *
+ * In some cases (e.g. in `AfterNormalization`), we include large objects and thus
+ * prevent them from getting garbage collected (if the log message is printed).
+ * Especially in cases like that, we intend to remove those!
+ */
+type LogMessage = {
+  kind: 'AboutToNormalize';
+  normalizationAst: NormalizationAstNodes;
+  networkResponse: NetworkResponseObject;
+  variables: Variables;
+} | {
+  kind: 'AfterNormalization';
+  store: StoreLayer;
+  encounteredIds: EncounteredIds;
+} | {
+  kind: 'DeepEqualityCheck';
+  fragmentReference: FragmentReference<any, any>;
+  old: object;
+  new: object;
+  deeplyEqual: boolean;
+} | {
+  kind: 'ComponentRerendered';
+  componentName: string;
+  rootLink: StoreLink;
+} | {
+  kind: 'MakeNetworkRequest';
+  artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any, any, any>;
+  variables: Variables;
+  networkRequestId: string;
+} | {
+  kind: 'ReceivedNetworkResponse';
+  networkResponse: any;
+  networkRequestId: string;
+} | {
+  kind: 'ReceivedNetworkError';
+  error: any;
+  networkRequestId: string;
+} | {
+  kind: 'MissingFieldHandlerCalled';
+  root: StoreLink;
+  storeRecord: StoreRecord;
+  fieldName: string;
+  arguments: Arguments | null;
+  variables: Variables;
+} | {
+  kind: 'DoneReading';
+  response: ReadDataResult<any>;
+  fieldName: string;
+  root: StoreLink;
+} | {
+  kind: 'NonEntrypointReceived';
+  entrypoint: any;
+} | {
+  kind: 'EnvironmentCheck';
+  result: CheckResult;
+} | {
+  kind: 'EnvironmentCreated';
+} | {
+  kind: 'StartUpdateError';
+  error: any;
+} | {
+  kind: 'StartUpdateComplete';
+  updatedIds: EncounteredIds;
+} | {
+  kind: 'ErrorEncounteredInWithErrorHandling';
+  error: any;
+};
+type LogFunction = (logMessage: LogMessage) => void;
+type WrappedLogFunction = {
+  log: LogFunction;
+};
+declare function logMessage(environment: IsographEnvironment, getMessage: () => LogMessage): void;
+declare function registerLogger(environment: IsographEnvironment, log: LogFunction): CleanupFn;
+//#endregion
+export { LogFunction, LogMessage, WrappedLogFunction, logMessage, registerLogger };
+//# sourceMappingURL=logging.d.mts.map

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

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

package/dist/core/logging.d.ts

@@ -1,77 +1,95 @@
-import { CleanupFn } from '@isograph/disposable-types';
-import { NetworkResponseObject, type EncounteredIds } from './cache';
-import { CheckResult } from './check';
-import { IsographEntrypoint, RefetchQueryNormalizationArtifact, type NormalizationAstNodes } from './entrypoint';
-import { FragmentReference, Variables } from './FragmentReference';
-import { IsographEnvironment, IsographStore, StoreRecord, type StoreLink } from './IsographEnvironment';
-import { ReadDataResult } from './read';
-import { Arguments } from './util';
-export type LogMessage = {
-    kind: 'AboutToNormalize';
-    normalizationAst: NormalizationAstNodes;
-    networkResponse: NetworkResponseObject;
-    variables: Variables;
+import { CheckResult } from "./check.js";
+import { Arguments } from "./util.js";
+import { ReadDataResult } from "./read.js";
+import { StoreLayer } from "./optimisticProxy.js";
+import { IsographEnvironment, StoreLink, StoreRecord } from "./IsographEnvironment.js";
+import { FragmentReference, Variables } from "./FragmentReference.js";
+import { EncounteredIds, NetworkResponseObject } from "./cache.js";
+import { IsographEntrypoint, NormalizationAstNodes, RefetchQueryNormalizationArtifact } from "./entrypoint.js";
+import { CleanupFn } from "@isograph/disposable-types";
+
+//#region src/core/logging.d.ts
+
+/**
+ * Note: these types are unstable. We will add and remove items from this enum
+ * and add and remove fields. Please do not rely on the specifics here (for now).
+ *
+ * Goals include:
+ * - convenient debugging for Isograph developers
+ * - eventual support for the Isograph devtools
+ *
+ * In some cases (e.g. in `AfterNormalization`), we include large objects and thus
+ * prevent them from getting garbage collected (if the log message is printed).
+ * Especially in cases like that, we intend to remove those!
+ */
+type LogMessage = {
+  kind: 'AboutToNormalize';
+  normalizationAst: NormalizationAstNodes;
+  networkResponse: NetworkResponseObject;
+  variables: Variables;
 } | {
-    kind: 'AfterNormalization';
-    store: IsographStore;
-    encounteredIds: EncounteredIds;
+  kind: 'AfterNormalization';
+  store: StoreLayer;
+  encounteredIds: EncounteredIds;
 } | {
-    kind: 'DeepEqualityCheck';
-    fragmentReference: FragmentReference<any, any>;
-    old: object;
-    new: object;
-    deeplyEqual: boolean;
+  kind: 'DeepEqualityCheck';
+  fragmentReference: FragmentReference<any, any>;
+  old: object;
+  new: object;
+  deeplyEqual: boolean;
 } | {
-    kind: 'ComponentRerendered';
-    componentName: string;
-    rootLink: StoreLink;
+  kind: 'ComponentRerendered';
+  componentName: string;
+  rootLink: StoreLink;
 } | {
-    kind: 'MakeNetworkRequest';
-    artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any, any>;
-    variables: Variables;
-    networkRequestId: string;
+  kind: 'MakeNetworkRequest';
+  artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any, any, any>;
+  variables: Variables;
+  networkRequestId: string;
 } | {
-    kind: 'ReceivedNetworkResponse';
-    networkResponse: any;
-    networkRequestId: string;
+  kind: 'ReceivedNetworkResponse';
+  networkResponse: any;
+  networkRequestId: string;
 } | {
-    kind: 'ReceivedNetworkError';
-    error: any;
-    networkRequestId: string;
+  kind: 'ReceivedNetworkError';
+  error: any;
+  networkRequestId: string;
 } | {
-    kind: 'MissingFieldHandlerCalled';
-    root: StoreLink;
-    storeRecord: StoreRecord;
-    fieldName: string;
-    arguments: Arguments | null;
-    variables: Variables;
+  kind: 'MissingFieldHandlerCalled';
+  root: StoreLink;
+  storeRecord: StoreRecord;
+  fieldName: string;
+  arguments: Arguments | null;
+  variables: Variables;
 } | {
-    kind: 'DoneReading';
-    response: ReadDataResult<any>;
-    fieldName: string;
-    root: StoreLink;
+  kind: 'DoneReading';
+  response: ReadDataResult<any>;
+  fieldName: string;
+  root: StoreLink;
 } | {
-    kind: 'NonEntrypointReceived';
-    entrypoint: any;
+  kind: 'NonEntrypointReceived';
+  entrypoint: any;
 } | {
-    kind: 'EnvironmentCheck';
-    result: CheckResult;
+  kind: 'EnvironmentCheck';
+  result: CheckResult;
 } | {
-    kind: 'EnvironmentCreated';
+  kind: 'EnvironmentCreated';
 } | {
-    kind: 'StartUpdateError';
-    error: any;
+  kind: 'StartUpdateError';
+  error: any;
 } | {
-    kind: 'StartUpdateComplete';
-    updatedIds: EncounteredIds;
+  kind: 'StartUpdateComplete';
+  updatedIds: EncounteredIds;
 } | {
-    kind: 'ErrorEncounteredInWithErrorHandling';
-    error: any;
+  kind: 'ErrorEncounteredInWithErrorHandling';
+  error: any;
 };
-export type LogFunction = (logMessage: LogMessage) => void;
-export type WrappedLogFunction = {
-    log: LogFunction;
+type LogFunction = (logMessage: LogMessage) => void;
+type WrappedLogFunction = {
+  log: LogFunction;
 };
-export declare function logMessage(environment: IsographEnvironment, getMessage: () => LogMessage): void;
-export declare function registerLogger(environment: IsographEnvironment, log: LogFunction): CleanupFn;
+declare function logMessage(environment: IsographEnvironment, getMessage: () => LogMessage): void;
+declare function registerLogger(environment: IsographEnvironment, log: LogFunction): CleanupFn;
+//#endregion
+export { LogFunction, LogMessage, WrappedLogFunction, logMessage, registerLogger };
 //# sourceMappingURL=logging.d.ts.map