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

package/dist/react/useImperativeReference.js

@@ -1,32 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useImperativeReference = useImperativeReference;
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const IsographEnvironment_1 = require("../core/IsographEnvironment");
-const makeNetworkRequest_1 = require("../core/makeNetworkRequest");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_IsographEnvironment = require('../core/IsographEnvironment.js');
+const require_makeNetworkRequest = require('../core/makeNetworkRequest.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+let __isograph_react_disposable_state = require("@isograph/react-disposable-state");
+__isograph_react_disposable_state = require_rolldown_runtime.__toESM(__isograph_react_disposable_state);
+
+//#region src/react/useImperativeReference.ts
 function useImperativeReference(entrypoint) {
-    const { state, setState } = (0, react_disposable_state_1.useUpdatableDisposableState)();
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    return {
-        fragmentReference: state !== react_disposable_state_1.UNASSIGNED_STATE ? state : null,
-        loadFragmentReference: (variables, fetchOptions) => {
-            const { fieldName, readerArtifactKind, readerWithRefetchQueries } = (0, IsographEnvironment_1.getOrLoadReaderWithRefetchQueries)(environment, entrypoint.readerWithRefetchQueries);
-            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
-            setState([
-                {
-                    kind: 'FragmentReference',
-                    readerWithRefetchQueries,
-                    fieldName,
-                    readerArtifactKind,
-                    root: { __link: IsographEnvironment_1.ROOT_ID, __typename: entrypoint.concreteType },
-                    variables,
-                    networkRequest,
-                },
-                () => {
-                    disposeNetworkRequest();
-                },
-            ]);
-        },
-    };
+	const { state, setState } = (0, __isograph_react_disposable_state.useUpdatableDisposableState)();
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	return {
+		fragmentReference: state !== __isograph_react_disposable_state.UNASSIGNED_STATE ? state : null,
+		loadFragmentReference: (variables, fetchOptions) => {
+			const { fieldName, readerArtifactKind, readerWithRefetchQueries } = require_IsographEnvironment.getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+			const [networkRequest, disposeNetworkRequest] = require_makeNetworkRequest.maybeMakeNetworkRequest(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions ?? null);
+			setState([{
+				kind: "FragmentReference",
+				readerWithRefetchQueries,
+				fieldName,
+				readerArtifactKind,
+				root: {
+					__link: require_IsographEnvironment.ROOT_ID,
+					__typename: entrypoint.concreteType
+				},
+				variables,
+				networkRequest
+			}, () => {
+				disposeNetworkRequest();
+			}]);
+		}
+	};
 }
+
+//#endregion
+exports.useImperativeReference = useImperativeReference;

package/dist/react/useImperativeReference.mjs

@@ -0,0 +1,35 @@
+import { ROOT_ID, getOrLoadReaderWithRefetchQueries } from "../core/IsographEnvironment.mjs";
+import { maybeMakeNetworkRequest } from "../core/makeNetworkRequest.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { UNASSIGNED_STATE, useUpdatableDisposableState } from "@isograph/react-disposable-state";
+
+//#region src/react/useImperativeReference.ts
+function useImperativeReference(entrypoint) {
+	const { state, setState } = useUpdatableDisposableState();
+	const environment = useIsographEnvironment();
+	return {
+		fragmentReference: state !== UNASSIGNED_STATE ? state : null,
+		loadFragmentReference: (variables, fetchOptions) => {
+			const { fieldName, readerArtifactKind, readerWithRefetchQueries } = getOrLoadReaderWithRefetchQueries(environment, entrypoint.readerWithRefetchQueries);
+			const [networkRequest, disposeNetworkRequest] = maybeMakeNetworkRequest(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions ?? null);
+			setState([{
+				kind: "FragmentReference",
+				readerWithRefetchQueries,
+				fieldName,
+				readerArtifactKind,
+				root: {
+					__link: ROOT_ID,
+					__typename: entrypoint.concreteType
+				},
+				variables,
+				networkRequest
+			}, () => {
+				disposeNetworkRequest();
+			}]);
+		}
+	};
+}
+
+//#endregion
+export { useImperativeReference };
+//# sourceMappingURL=useImperativeReference.mjs.map

package/dist/react/useImperativeReference.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeReference.mjs","names":[],"sources":["../../src/react/useImperativeReference.ts"],"sourcesContent":["import {\n  UNASSIGNED_STATE,\n  useUpdatableDisposableState,\n} from '@isograph/react-disposable-state';\nimport type { NetworkResponseObject } from '../core/cache';\nimport type { FetchOptions } from '../core/check';\nimport { type RequiredFetchOptions } from '../core/check';\nimport type { IsographEntrypoint } from '../core/entrypoint';\nimport {\n  type NormalizationAst,\n  type NormalizationAstLoader,\n} from '../core/entrypoint';\nimport type {\n  ExtractParameters,\n  FragmentReference,\n} from '../core/FragmentReference';\nimport { type UnknownTReadFromStore } from '../core/FragmentReference';\nimport {\n  getOrLoadReaderWithRefetchQueries,\n  ROOT_ID,\n} from '../core/IsographEnvironment';\nimport { maybeMakeNetworkRequest } from '../core/makeNetworkRequest';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\n\nexport type UseImperativeReferenceResult<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType,\n> = {\n  fragmentReference: FragmentReference<\n    TReadFromStore,\n    TClientFieldValue\n  > | null;\n  loadFragmentReference: (\n    variables: ExtractParameters<TReadFromStore>,\n    ...[fetchOptions]: NormalizationAstLoader extends TNormalizationAst\n      ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>]\n      : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]\n  ) => void;\n};\n\nexport function useImperativeReference<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  entrypoint: IsographEntrypoint<\n    TReadFromStore,\n    TClientFieldValue,\n    TNormalizationAst,\n    TRawResponseType\n  >,\n): UseImperativeReferenceResult<\n  TReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst,\n  TRawResponseType\n> {\n  const { state, setState } =\n    useUpdatableDisposableState<\n      FragmentReference<TReadFromStore, TClientFieldValue>\n    >();\n  const environment = useIsographEnvironment();\n  return {\n    fragmentReference: state !== UNASSIGNED_STATE ? state : null,\n    loadFragmentReference: (\n      variables: ExtractParameters<TReadFromStore>,\n      fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>,\n    ) => {\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      setState([\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  };\n}\n"],"mappings":";;;;;;AA0CA,SAAgB,uBAMd,YAWA;CACA,MAAM,EAAE,OAAO,aACb,6BAEG;CACL,MAAM,cAAc,wBAAwB;AAC5C,QAAO;EACL,mBAAmB,UAAU,mBAAmB,QAAQ;EACxD,wBACE,WACA,iBACG;GACH,MAAM,EAAE,WAAW,oBAAoB,6BACrC,kCACE,aACA,WAAW,yBACZ;GACH,MAAM,CAAC,gBAAgB,yBAAyB,wBAC9C,aACA,YACA,WACA,0BACA,gBAAgB,KACjB;AACD,YAAS,CACP;IACE,MAAM;IACN;IACA;IACA;IACA,MAAM;KAAE,QAAQ;KAAS,YAAY,WAAW;KAAc;IAC9D;IACA;IACD,QACK;AACJ,2BAAuB;KAE1B,CAAC;;EAEL"}

package/dist/react/useLazyReference.d.mts

@@ -0,0 +1,13 @@
+import { FetchOptions, RequiredFetchOptions } from "../core/check.mjs";
+import { ExtractParameters, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.mjs";
+import { NetworkResponseObject } from "../core/cache.mjs";
+import { IsographEntrypoint, NormalizationAst, NormalizationAstLoader } from "../core/entrypoint.mjs";
+
+//#region src/react/useLazyReference.d.ts
+
+declare function useLazyReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>, variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]): NormalizationAst | NormalizationAstLoader extends TNormalizationAst ? unknown : {
+  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;
+};
+//#endregion
+export { useLazyReference };
+//# sourceMappingURL=useLazyReference.d.mts.map

package/dist/react/useLazyReference.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyReference.d.mts","names":[],"sources":["../../src/react/useLazyReference.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmByB,iBADT,gBACS,CAAA,uBAAA,qBAAA,EAAA,iBAAA,EAAA,0BAEG,gBAFH,GAEsB,sBAFtB,EAAA,yBAGE,qBAHF,CAAA,CAAA,UAAA,EAKX,kBALW,CAMrB,cANqB,EAOrB,iBAPqB,EAQrB,iBARqB,EASrB,gBATqB,CAAA,EAAA,SAAA,EAWZ,iBAXY,CAWM,cAXN,CAAA,EAAA,GAAA,CAAA,YAAA,CAAA,EAYJ,iBAZI,SAYsB,sBAZtB,GAAA,CAAA,YAAA,EAaJ,oBAbI,CAaiB,iBAbjB,CAAA,CAAA,GAAA,CAAA,YAAA,GAcH,YAdG,CAcU,iBAdV,EAc6B,gBAd7B,CAAA,CAAA,CAAA,EAetB,gBAfsB,GAeH,sBAfG,SAe4B,iBAf5B,GAAA,OAAA,GAAA;EAEG,iBAAA,EAgBH,iBAhBG,CAgBe,cAhBf,EAgB+B,iBAhB/B,CAAA;CAAmB"}

package/dist/react/useLazyReference.d.ts

@@ -1,11 +1,13 @@
-import { type NetworkResponseObject } from '../core/cache';
-import type { FetchOptions } from '../core/check';
-import { type RequiredFetchOptions } from '../core/check';
-import type { IsographEntrypoint } from '../core/entrypoint';
-import { type NormalizationAst, type NormalizationAstLoader } from '../core/entrypoint';
-import type { ExtractParameters, FragmentReference } from '../core/FragmentReference';
-import { type UnknownTReadFromStore } from '../core/FragmentReference';
-export declare function useLazyReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>, variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]): NormalizationAst | NormalizationAstLoader extends TNormalizationAst ? unknown : {
-    fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;
+import { FetchOptions, RequiredFetchOptions } from "../core/check.js";
+import { ExtractParameters, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.js";
+import { NetworkResponseObject } from "../core/cache.js";
+import { IsographEntrypoint, NormalizationAst, NormalizationAstLoader } from "../core/entrypoint.js";
+
+//#region src/react/useLazyReference.d.ts
+
+declare function useLazyReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>, variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]): NormalizationAst | NormalizationAstLoader extends TNormalizationAst ? unknown : {
+  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 };
+//#endregion
+export { useLazyReference };
 //# sourceMappingURL=useLazyReference.d.ts.map

package/dist/react/useLazyReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyReference.d.ts","sourceRoot":"","sources":["../../src/react/useLazyReference.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAKvE,wBAAgB,gBAAgB,CAC9B,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,EACnE,gBAAgB,SAAS,qBAAqB,EAE9C,UAAU,EAAE,kBAAkB,CAC5B,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,CACjB,EACD,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAC5C,GAAG,CAAC,YAAY,CAAC,EAAE,iBAAiB,SAAS,sBAAsB,GAC/D,CAAC,YAAY,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,CAAC,GACvD,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,CAAC,GACrE,gBAAgB,GAAG,sBAAsB,SAAS,iBAAiB,GAClE,OAAO,GACP;IACE,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;CACzE,CAqBJ"}
+{"version":3,"file":"useLazyReference.d.ts","names":[],"sources":["../../src/react/useLazyReference.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmByB,iBADT,gBACS,CAAA,uBAAA,qBAAA,EAAA,iBAAA,EAAA,0BAEG,gBAFH,GAEsB,sBAFtB,EAAA,yBAGE,qBAHF,CAAA,CAAA,UAAA,EAKX,kBALW,CAMrB,cANqB,EAOrB,iBAPqB,EAQrB,iBARqB,EASrB,gBATqB,CAAA,EAAA,SAAA,EAWZ,iBAXY,CAWM,cAXN,CAAA,EAAA,GAAA,CAAA,YAAA,CAAA,EAYJ,iBAZI,SAYsB,sBAZtB,GAAA,CAAA,YAAA,EAaJ,oBAbI,CAaiB,iBAbjB,CAAA,CAAA,GAAA,CAAA,YAAA,GAcH,YAdG,CAcU,iBAdV,EAc6B,gBAd7B,CAAA,CAAA,CAAA,EAetB,gBAfsB,GAeH,sBAfG,SAe4B,iBAf5B,GAAA,OAAA,GAAA;EAEG,iBAAA,EAgBH,iBAhBG,CAgBe,cAhBf,EAgB+B,iBAhB/B,CAAA;CAAmB"}

package/dist/react/useLazyReference.js

@@ -1,42 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLazyReference = useLazyReference;
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const logging_1 = require("../core/logging");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-const getOrCreateCacheForArtifact_1 = require("../core/getOrCreateCacheForArtifact");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_logging = require('../core/logging.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+const require_getOrCreateCacheForArtifact = require('../core/getOrCreateCacheForArtifact.js');
+let __isograph_react_disposable_state = require("@isograph/react-disposable-state");
+__isograph_react_disposable_state = require_rolldown_runtime.__toESM(__isograph_react_disposable_state);
+
+//#region src/react/useLazyReference.ts
 function useLazyReference(entrypoint, variables, ...[fetchOptions]) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    if ((entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.kind) !== 'Entrypoint') {
-        // TODO have a separate error logger
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'NonEntrypointReceived',
-            entrypoint,
-        }));
-    }
-    const cache = (0, getOrCreateCacheForArtifact_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables, fetchOptions);
-    return {
-        fragmentReference: (0, react_disposable_state_1.useLazyDisposableState)(cache).state,
-    };
-}
-// @ts-ignore
-function tsTests() {
-    let withAst;
-    let withAstLoader;
-    let withAstOrLoader;
-    useLazyReference(withAst, {});
-    useLazyReference(withAst, {}, { shouldFetch: 'Yes' });
-    useLazyReference(withAst, {}, { shouldFetch: 'IfNecessary' });
-    // @ts-expect-error if there's no ast, require `shouldFetch` to be specified
-    useLazyReference(withAstLoader, {});
-    useLazyReference(withAstLoader, {}, { shouldFetch: 'Yes' });
-    // @ts-expect-error if there's no ast, `shouldFetch` can't be `IfNecessary`
-    useLazyReference(withAstLoader, {}, { shouldFetch: 'IfNecessary' });
-    // if the type is unknown there can be no ast so we should use the same rules
-    // but because of TS bugs with inference we just return unknown
-    // @ts-expect-error this returns unknown which doesn't satisfy the constraint
-    useLazyReference(withAstOrLoader, {});
-    // @ts-expect-error this returns unknown which doesn't satisfy the constraint
-    useLazyReference(withAstOrLoader, {}, { shouldFetch: 'Yes' });
-    useLazyReference(withAstOrLoader, {}, { shouldFetch: 'IfNecessary' });
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	if (entrypoint?.kind !== "Entrypoint") require_logging.logMessage(environment, () => ({
+		kind: "NonEntrypointReceived",
+		entrypoint
+	}));
+	return { fragmentReference: (0, __isograph_react_disposable_state.useLazyDisposableState)(require_getOrCreateCacheForArtifact.getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions)).state };
 }
+
+//#endregion
+exports.useLazyReference = useLazyReference;

package/dist/react/useLazyReference.mjs

@@ -0,0 +1,18 @@
+import { logMessage } from "../core/logging.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { getOrCreateCacheForArtifact } from "../core/getOrCreateCacheForArtifact.mjs";
+import { useLazyDisposableState } from "@isograph/react-disposable-state";
+
+//#region src/react/useLazyReference.ts
+function useLazyReference(entrypoint, variables, ...[fetchOptions]) {
+	const environment = useIsographEnvironment();
+	if (entrypoint?.kind !== "Entrypoint") logMessage(environment, () => ({
+		kind: "NonEntrypointReceived",
+		entrypoint
+	}));
+	return { fragmentReference: useLazyDisposableState(getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions)).state };
+}
+
+//#endregion
+export { useLazyReference };
+//# sourceMappingURL=useLazyReference.mjs.map

package/dist/react/useLazyReference.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyReference.mjs","names":[],"sources":["../../src/react/useLazyReference.ts"],"sourcesContent":["import { useLazyDisposableState } from '@isograph/react-disposable-state';\nimport { type NetworkResponseObject } from '../core/cache';\nimport type { FetchOptions } from '../core/check';\nimport { type RequiredFetchOptions } from '../core/check';\nimport type { IsographEntrypoint } from '../core/entrypoint';\nimport {\n  type NormalizationAst,\n  type NormalizationAstLoader,\n} from '../core/entrypoint';\nimport type {\n  ExtractParameters,\n  FragmentReference,\n} from '../core/FragmentReference';\nimport { type UnknownTReadFromStore } from '../core/FragmentReference';\nimport { logMessage } from '../core/logging';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\nimport { getOrCreateCacheForArtifact } from '../core/getOrCreateCacheForArtifact';\n\nexport function useLazyReference<\n  TReadFromStore extends UnknownTReadFromStore,\n  TClientFieldValue,\n  TNormalizationAst extends NormalizationAst | NormalizationAstLoader,\n  TRawResponseType extends NetworkResponseObject,\n>(\n  entrypoint: IsographEntrypoint<\n    TReadFromStore,\n    TClientFieldValue,\n    TNormalizationAst,\n    TRawResponseType\n  >,\n  variables: ExtractParameters<TReadFromStore>,\n  ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader\n    ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>]\n    : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]\n): NormalizationAst | NormalizationAstLoader extends TNormalizationAst\n  ? unknown\n  : {\n      fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;\n    } {\n  const environment = useIsographEnvironment();\n\n  if (entrypoint?.kind !== 'Entrypoint') {\n    // TODO have a separate error logger\n    logMessage(environment, () => ({\n      kind: 'NonEntrypointReceived',\n      entrypoint,\n    }));\n  }\n\n  const cache = getOrCreateCacheForArtifact(\n    environment,\n    entrypoint,\n    variables,\n    fetchOptions,\n  );\n\n  return {\n    fragmentReference: useLazyDisposableState(cache).state,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let withAst!: IsographEntrypoint<any, unknown, NormalizationAst, any>;\n  let withAstLoader!: IsographEntrypoint<\n    any,\n    unknown,\n    NormalizationAstLoader,\n    {}\n  >;\n  let withAstOrLoader!: IsographEntrypoint<\n    any,\n    unknown,\n    NormalizationAst | NormalizationAstLoader,\n    {}\n  >;\n\n  useLazyReference(withAst, {}) satisfies {};\n  useLazyReference(withAst, {}, { shouldFetch: 'Yes' }) satisfies {};\n  useLazyReference(withAst, {}, { shouldFetch: 'IfNecessary' }) satisfies {};\n\n  // @ts-expect-error if there's no ast, require `shouldFetch` to be specified\n  useLazyReference(withAstLoader, {});\n  useLazyReference(withAstLoader, {}, { shouldFetch: 'Yes' }) satisfies {};\n  // @ts-expect-error if there's no ast, `shouldFetch` can't be `IfNecessary`\n  useLazyReference(withAstLoader, {}, { shouldFetch: 'IfNecessary' });\n\n  // if the type is unknown there can be no ast so we should use the same rules\n  // but because of TS bugs with inference we just return unknown\n  // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  useLazyReference(withAstOrLoader, {}) satisfies {};\n  // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  useLazyReference(withAstOrLoader, {}, { shouldFetch: 'Yes' }) satisfies {};\n  useLazyReference(\n    withAstOrLoader,\n    {},\n    { shouldFetch: 'IfNecessary' },\n    // @ts-expect-error this returns unknown which doesn't satisfy the constraint\n  ) satisfies {};\n}\n"],"mappings":";;;;;;AAkBA,SAAgB,iBAMd,YAMA,WACA,GAAG,CAAC,eAOA;CACJ,MAAM,cAAc,wBAAwB;AAE5C,KAAI,YAAY,SAAS,aAEvB,YAAW,oBAAoB;EAC7B,MAAM;EACN;EACD,EAAE;AAUL,QAAO,EACL,mBAAmB,uBARP,4BACZ,aACA,YACA,WACA,aACD,CAGiD,CAAC,OAClD"}

package/dist/react/useReadAndSubscribe.d.mts

@@ -0,0 +1,20 @@
+import { ReaderAst } from "../core/reader.mjs";
+import { NetworkRequestReaderOptions, WithEncounteredRecords } from "../core/read.mjs";
+import "../core/IsographEnvironment.mjs";
+import { ExtractData, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.mjs";
+
+//#region src/react/useReadAndSubscribe.d.ts
+
+/**
+ * Read the data from a fragment reference and subscribe to updates.
+ */
+declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
+declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
+  records: WithEncounteredRecords<TReadFromStore>;
+  callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
+  fragmentReference: FragmentReference<TReadFromStore, any>;
+  readerAst: ReaderAst<TReadFromStore>;
+}>): void;
+//#endregion
+export { useReadAndSubscribe, useSubscribeToMultiple };
+//# sourceMappingURL=useReadAndSubscribe.d.mts.map

package/dist/react/useReadAndSubscribe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadAndSubscribe.d.mts","names":[],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAwBA;AACyB,iBADT,mBACS,CAAA,uBAAA,qBAAA,CAAA,CAAA,iBAAA,EAEJ,iBAFI,CAEc,cAFd,EAAA,GAAA,CAAA,EAAA,qBAAA,EAGA,2BAHA,EAAA,SAAA,EAIZ,SAJY,CAIF,cAJE,CAAA,CAAA,EAKtB,WALsB,CAKV,cALU,CAAA;AAEc,iBAiBvB,sBAjBuB,CAAA,uBAkBd,qBAlBc,CAAA,CAAA,KAAA,EAoB9B,aApB8B,CAAA;EAAlB,OAAA,EAqBR,sBArBQ,CAqBe,cArBf,CAAA;EACI,QAAA,EAAA,CAAA,cAAA,EAqBM,sBArBN,CAqB6B,cArB7B,CAAA,EAAA,GAAA,IAAA;EACF,iBAAA,EAqBA,iBArBA,CAqBkB,cArBlB,EAAA,GAAA,CAAA;EAAV,SAAA,EAsBE,SAtBF,CAsBY,cAtBZ,CAAA;CACE,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useReadAndSubscribe.d.ts

@@ -1,16 +1,19 @@
-import { type ExtractData, type FragmentReference, type UnknownTReadFromStore } from '../core/FragmentReference';
-import type { IsographComponentFunction } from '../core/IsographEnvironment';
-import { type NetworkRequestReaderOptions, type WithEncounteredRecords } from '../core/read';
-import type { ReaderAst } from '../core/reader';
+import { ReaderAst } from "../core/reader.js";
+import { NetworkRequestReaderOptions, WithEncounteredRecords } from "../core/read.js";
+import { ExtractData, FragmentReference, UnknownTReadFromStore } from "../core/FragmentReference.js";
+
+//#region src/react/useReadAndSubscribe.d.ts
+
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-export declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
-export declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
-    records: WithEncounteredRecords<TReadFromStore>;
-    callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
-    fragmentReference: FragmentReference<TReadFromStore, any>;
-    readerAst: ReaderAst<TReadFromStore>;
+declare function useReadAndSubscribe<TReadFromStore extends UnknownTReadFromStore>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
+declare function useSubscribeToMultiple<TReadFromStore extends UnknownTReadFromStore>(items: ReadonlyArray<{
+  records: WithEncounteredRecords<TReadFromStore>;
+  callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
+  fragmentReference: FragmentReference<TReadFromStore, any>;
+  readerAst: ReaderAst<TReadFromStore>;
 }>): void;
-export declare const componentFunction: IsographComponentFunction;
+//#endregion
+export { useReadAndSubscribe, useSubscribeToMultiple };
 //# sourceMappingURL=useReadAndSubscribe.d.ts.map

package/dist/react/useReadAndSubscribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useReadAndSubscribe.d.ts","sourceRoot":"","sources":["../../src/react/useReadAndSubscribe.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAEtB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAG7E,OAAO,EACL,KAAK,2BAA2B,EAEhC,KAAK,sBAAsB,EAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,SAAS,qBAAqB,EAE5C,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,EACzD,qBAAqB,EAAE,2BAA2B,EAClD,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,GACnC,WAAW,CAAC,cAAc,CAAC,CAY7B;AAED,wBAAgB,sBAAsB,CACpC,cAAc,SAAS,qBAAqB,EAE5C,KAAK,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,sBAAsB,CAAC,cAAc,CAAC,KAAK,IAAI,CAAC;IAC3E,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;IAC1D,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;CACtC,CAAC,QAiCH;AAED,eAAO,MAAM,iBAAiB,EAAE,yBA0C/B,CAAC"}
+{"version":3,"file":"useReadAndSubscribe.d.ts","names":[],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":[],"mappings":";;;;;;;AAwBA;;AAGuC,iBAHvB,mBAGuB,CAAA,uBAFd,qBAEc,CAAA,CAAA,iBAAA,EAAlB,iBAAkB,CAAA,cAAA,EAAA,GAAA,CAAA,EAAA,qBAAA,EACd,2BADc,EAAA,SAAA,EAE1B,SAF0B,CAEhB,cAFgB,CAAA,CAAA,EAGpC,WAHoC,CAGxB,cAHwB,CAAA;AAAlB,iBAiBL,sBAjBK,CAAA,uBAkBI,qBAlBJ,CAAA,CAAA,KAAA,EAoBZ,aApBY,CAAA;EACI,OAAA,EAoBZ,sBApBY,CAoBW,cApBX,CAAA;EACF,QAAA,EAAA,CAAA,cAAA,EAoBQ,sBApBR,CAoB+B,cApB/B,CAAA,EAAA,GAAA,IAAA;EAAV,iBAAA,EAqBU,iBArBV,CAqB4B,cArB5B,EAAA,GAAA,CAAA;EACE,SAAA,EAqBA,SArBA,CAqBU,cArBV,CAAA;CAAZ,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useReadAndSubscribe.js

@@ -1,71 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.componentFunction = void 0;
-exports.useReadAndSubscribe = useReadAndSubscribe;
-exports.useSubscribeToMultiple = useSubscribeToMultiple;
-const react_1 = require("react");
-const FragmentReference_1 = require("../core/FragmentReference");
-const logging_1 = require("../core/logging");
-const PromiseWrapper_1 = require("../core/PromiseWrapper");
-const read_1 = require("../core/read");
-const subscribe_1 = require("../core/subscribe");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-const maybeUnwrapNetworkRequest_1 = require("./maybeUnwrapNetworkRequest");
-const useRerenderOnChange_1 = require("./useRerenderOnChange");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_PromiseWrapper = require('../core/PromiseWrapper.js');
+const require_logging = require('../core/logging.js');
+const require_FragmentReference = require('../core/FragmentReference.js');
+const require_read = require('../core/read.js');
+const require_subscribe = require('../core/subscribe.js');
+const require_IsographEnvironmentProvider = require('./IsographEnvironmentProvider.js');
+const require_maybeUnwrapNetworkRequest = require('./maybeUnwrapNetworkRequest.js');
+const require_useRerenderOnChange = require('./useRerenderOnChange.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/react/useReadAndSubscribe.ts
 /**
- * Read the data from a fragment reference and subscribe to updates.
- */
+* Read the data from a fragment reference and subscribe to updates.
+*/
 function useReadAndSubscribe(fragmentReference, networkRequestOptions, readerAst) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const [readOutDataAndRecords, setReadOutDataAndRecords] = (0, react_1.useState)(() => (0, read_1.readButDoNotEvaluate)(environment, fragmentReference, networkRequestOptions));
-    (0, useRerenderOnChange_1.useRerenderOnChange)(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
-    return readOutDataAndRecords.item;
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	const [readOutDataAndRecords, setReadOutDataAndRecords] = (0, react.useState)(() => require_read.readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions));
+	require_useRerenderOnChange.useRerenderOnChange(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
+	return readOutDataAndRecords.item;
 }
 function useSubscribeToMultiple(items) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, react_1.useEffect)(() => {
-        const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
-            return (0, subscribe_1.subscribe)(environment, records, fragmentReference, callback, readerAst);
-        });
-        return () => {
-            cleanupFns.forEach((loader) => {
-                loader();
-            });
-        };
-    }, 
-    // By analogy to useReadAndSubscribe, we can have an empty dependency array?
-    // Maybe callback has to be depended on. I don't know!
-    // TODO find out
-    [
-        items
-            .map(({ fragmentReference }) => {
-            (0, FragmentReference_1.stableIdForFragmentReference)(fragmentReference);
-        })
-            .join('.'),
-    ]);
+	const environment = require_IsographEnvironmentProvider.useIsographEnvironment();
+	(0, react.useEffect)(() => {
+		const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
+			return require_subscribe.subscribe(environment, records, fragmentReference, callback, readerAst);
+		});
+		return () => {
+			cleanupFns.forEach((loader) => {
+				loader();
+			});
+		};
+	}, [items.map(({ fragmentReference }) => {
+		require_FragmentReference.stableIdForFragmentReference(fragmentReference);
+	}).join(".")]);
 }
 const componentFunction = (environment, fragmentReference, networkRequestOptions, startUpdate) => {
-    function Component(additionalRuntimeProps) {
-        (0, maybeUnwrapNetworkRequest_1.maybeUnwrapNetworkRequest)(fragmentReference.networkRequest, networkRequestOptions);
-        const readerWithRefetchQueries = (0, PromiseWrapper_1.readPromise)(fragmentReference.readerWithRefetchQueries);
-        const data = useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ComponentRerendered',
-            componentName: fragmentReference.fieldName,
-            rootLink: fragmentReference.root,
-        }));
-        return readerWithRefetchQueries.readerArtifact.resolver(
-        // @ts-expect-error
-        {
-            data,
-            parameters: fragmentReference.variables,
-            startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable
-                ? startUpdate
-                : undefined,
-        }, additionalRuntimeProps);
-    }
-    const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
-    Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
-    return Component;
+	function Component(additionalRuntimeProps) {
+		require_maybeUnwrapNetworkRequest.maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+		const readerWithRefetchQueries = require_PromiseWrapper.readPromise(fragmentReference.readerWithRefetchQueries);
+		const data = useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
+		require_logging.logMessage(environment, () => ({
+			kind: "ComponentRerendered",
+			componentName: fragmentReference.fieldName,
+			rootLink: fragmentReference.root
+		}));
+		return readerWithRefetchQueries.readerArtifact.resolver({
+			data,
+			parameters: fragmentReference.variables,
+			startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable ? startUpdate : void 0
+		}, additionalRuntimeProps);
+	}
+	const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
+	Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
+	return Component;
 };
+
+//#endregion
 exports.componentFunction = componentFunction;
+exports.useReadAndSubscribe = useReadAndSubscribe;
+exports.useSubscribeToMultiple = useSubscribeToMultiple;

package/dist/react/useReadAndSubscribe.mjs

@@ -0,0 +1,59 @@
+import { readPromise } from "../core/PromiseWrapper.mjs";
+import { logMessage } from "../core/logging.mjs";
+import { stableIdForFragmentReference } from "../core/FragmentReference.mjs";
+import { readButDoNotEvaluate } from "../core/read.mjs";
+import { subscribe } from "../core/subscribe.mjs";
+import { useIsographEnvironment } from "./IsographEnvironmentProvider.mjs";
+import { maybeUnwrapNetworkRequest } from "./maybeUnwrapNetworkRequest.mjs";
+import { useRerenderOnChange } from "./useRerenderOnChange.mjs";
+import { useEffect, useState } from "react";
+
+//#region src/react/useReadAndSubscribe.ts
+/**
+* Read the data from a fragment reference and subscribe to updates.
+*/
+function useReadAndSubscribe(fragmentReference, networkRequestOptions, readerAst) {
+	const environment = useIsographEnvironment();
+	const [readOutDataAndRecords, setReadOutDataAndRecords] = useState(() => readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions));
+	useRerenderOnChange(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
+	return readOutDataAndRecords.item;
+}
+function useSubscribeToMultiple(items) {
+	const environment = useIsographEnvironment();
+	useEffect(() => {
+		const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
+			return subscribe(environment, records, fragmentReference, callback, readerAst);
+		});
+		return () => {
+			cleanupFns.forEach((loader) => {
+				loader();
+			});
+		};
+	}, [items.map(({ fragmentReference }) => {
+		stableIdForFragmentReference(fragmentReference);
+	}).join(".")]);
+}
+const componentFunction = (environment, fragmentReference, networkRequestOptions, startUpdate) => {
+	function Component(additionalRuntimeProps) {
+		maybeUnwrapNetworkRequest(fragmentReference.networkRequest, networkRequestOptions);
+		const readerWithRefetchQueries = readPromise(fragmentReference.readerWithRefetchQueries);
+		const data = useReadAndSubscribe(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
+		logMessage(environment, () => ({
+			kind: "ComponentRerendered",
+			componentName: fragmentReference.fieldName,
+			rootLink: fragmentReference.root
+		}));
+		return readerWithRefetchQueries.readerArtifact.resolver({
+			data,
+			parameters: fragmentReference.variables,
+			startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable ? startUpdate : void 0
+		}, additionalRuntimeProps);
+	}
+	const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;
+	Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;
+	return Component;
+};
+
+//#endregion
+export { componentFunction, useReadAndSubscribe, useSubscribeToMultiple };
+//# sourceMappingURL=useReadAndSubscribe.mjs.map

package/dist/react/useReadAndSubscribe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadAndSubscribe.mjs","names":["componentFunction: IsographComponentFunction"],"sources":["../../src/react/useReadAndSubscribe.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport {\n  type ExtractData,\n  type FragmentReference,\n  stableIdForFragmentReference,\n  type UnknownTReadFromStore,\n} from '../core/FragmentReference';\nimport type { IsographComponentFunction } from '../core/IsographEnvironment';\nimport { logMessage } from '../core/logging';\nimport { readPromise } from '../core/PromiseWrapper';\nimport {\n  type NetworkRequestReaderOptions,\n  readButDoNotEvaluate,\n  type WithEncounteredRecords,\n} from '../core/read';\nimport type { ReaderAst } from '../core/reader';\nimport { subscribe } from '../core/subscribe';\nimport { useIsographEnvironment } from './IsographEnvironmentProvider';\nimport { maybeUnwrapNetworkRequest } from './maybeUnwrapNetworkRequest';\nimport { useRerenderOnChange } from './useRerenderOnChange';\n\n/**\n * Read the data from a fragment reference and subscribe to updates.\n */\nexport function useReadAndSubscribe<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  fragmentReference: FragmentReference<TReadFromStore, any>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n  readerAst: ReaderAst<TReadFromStore>,\n): ExtractData<TReadFromStore> {\n  const environment = useIsographEnvironment();\n  const [readOutDataAndRecords, setReadOutDataAndRecords] = useState(() =>\n    readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions),\n  );\n  useRerenderOnChange(\n    readOutDataAndRecords,\n    fragmentReference,\n    setReadOutDataAndRecords,\n    readerAst,\n  );\n  return readOutDataAndRecords.item;\n}\n\nexport function useSubscribeToMultiple<\n  TReadFromStore extends UnknownTReadFromStore,\n>(\n  items: ReadonlyArray<{\n    records: WithEncounteredRecords<TReadFromStore>;\n    callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;\n    fragmentReference: FragmentReference<TReadFromStore, any>;\n    readerAst: ReaderAst<TReadFromStore>;\n  }>,\n) {\n  const environment = useIsographEnvironment();\n  useEffect(\n    () => {\n      const cleanupFns = items.map(\n        ({ records, callback, fragmentReference, readerAst }) => {\n          return subscribe(\n            environment,\n            records,\n            fragmentReference,\n            callback,\n            readerAst,\n          );\n        },\n      );\n      return () => {\n        cleanupFns.forEach((loader) => {\n          loader();\n        });\n      };\n    },\n    // By analogy to useReadAndSubscribe, we can have an empty dependency array?\n    // Maybe callback has to be depended on. I don't know!\n    // TODO find out\n    [\n      items\n        .map(({ fragmentReference }) => {\n          stableIdForFragmentReference(fragmentReference);\n        })\n        .join('.'),\n    ],\n  );\n}\n\nexport const componentFunction: IsographComponentFunction = (\n  environment,\n  fragmentReference,\n  networkRequestOptions,\n  startUpdate,\n) => {\n  function Component(additionalRuntimeProps: { [key: string]: any }) {\n    maybeUnwrapNetworkRequest(\n      fragmentReference.networkRequest,\n      networkRequestOptions,\n    );\n    const readerWithRefetchQueries = readPromise(\n      fragmentReference.readerWithRefetchQueries,\n    );\n\n    const data = useReadAndSubscribe(\n      fragmentReference,\n      networkRequestOptions,\n      readerWithRefetchQueries.readerArtifact.readerAst,\n    );\n\n    logMessage(environment, () => ({\n      kind: 'ComponentRerendered',\n      componentName: fragmentReference.fieldName,\n      rootLink: fragmentReference.root,\n    }));\n\n    return readerWithRefetchQueries.readerArtifact.resolver(\n      // @ts-expect-error\n      {\n        data,\n        parameters: fragmentReference.variables,\n        startUpdate: readerWithRefetchQueries.readerArtifact.hasUpdatable\n          ? startUpdate\n          : undefined,\n      },\n      additionalRuntimeProps,\n    );\n  }\n  const idString = `(type: ${fragmentReference.root.__typename}, id: ${fragmentReference.root.__link})`;\n  Component.displayName = `${fragmentReference.fieldName} ${idString} @component`;\n  return Component;\n};\n"],"mappings":";;;;;;;;;;;;;;AAwBA,SAAgB,oBAGd,mBACA,uBACA,WAC6B;CAC7B,MAAM,cAAc,wBAAwB;CAC5C,MAAM,CAAC,uBAAuB,4BAA4B,eACxD,qBAAqB,aAAa,mBAAmB,sBAAsB,CAC5E;AACD,qBACE,uBACA,mBACA,0BACA,UACD;AACD,QAAO,sBAAsB;;AAG/B,SAAgB,uBAGd,OAMA;CACA,MAAM,cAAc,wBAAwB;AAC5C,iBACQ;EACJ,MAAM,aAAa,MAAM,KACtB,EAAE,SAAS,UAAU,mBAAmB,gBAAgB;AACvD,UAAO,UACL,aACA,SACA,mBACA,UACA,UACD;IAEJ;AACD,eAAa;AACX,cAAW,SAAS,WAAW;AAC7B,YAAQ;KACR;;IAMN,CACE,MACG,KAAK,EAAE,wBAAwB;AAC9B,+BAA6B,kBAAkB;GAC/C,CACD,KAAK,IAAI,CACb,CACF;;AAGH,MAAaA,qBACX,aACA,mBACA,uBACA,gBACG;CACH,SAAS,UAAU,wBAAgD;AACjE,4BACE,kBAAkB,gBAClB,sBACD;EACD,MAAM,2BAA2B,YAC/B,kBAAkB,yBACnB;EAED,MAAM,OAAO,oBACX,mBACA,uBACA,yBAAyB,eAAe,UACzC;AAED,aAAW,oBAAoB;GAC7B,MAAM;GACN,eAAe,kBAAkB;GACjC,UAAU,kBAAkB;GAC7B,EAAE;AAEH,SAAO,yBAAyB,eAAe,SAE7C;GACE;GACA,YAAY,kBAAkB;GAC9B,aAAa,yBAAyB,eAAe,eACjD,cACA;GACL,EACD,uBACD;;CAEH,MAAM,WAAW,UAAU,kBAAkB,KAAK,WAAW,QAAQ,kBAAkB,KAAK,OAAO;AACnG,WAAU,cAAc,GAAG,kBAAkB,UAAU,GAAG,SAAS;AACnE,QAAO"}

package/dist/react/useRerenderOnChange.d.mts

@@ -0,0 +1,12 @@
+import { ReaderAst } from "../core/reader.mjs";
+import { WithEncounteredRecords } from "../core/read.mjs";
+import { FragmentReference } from "../core/FragmentReference.mjs";
+
+//#region src/react/useRerenderOnChange.d.ts
+declare function useRerenderOnChange<TReadFromStore extends {
+  parameters: object;
+  data: object;
+}>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+//#endregion
+export { useRerenderOnChange };
+//# sourceMappingURL=useRerenderOnChange.d.mts.map

package/dist/react/useRerenderOnChange.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRerenderOnChange.d.mts","names":[],"sources":["../../src/react/useRerenderOnChange.ts"],"sourcesContent":[],"mappings":";;;;;iBASgB;;EAAA,IAAA,EAAA,MAAA;CAGoC,CAAA,CAAA,yBAAA,EAAvB,sBAAuB,CAAA,cAAA,CAAA,EAAA,iBAAA,EAC/B,iBAD+B,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA,4BAAA,EAAA,CAAA,IAAA,EAG1C,sBAH0C,CAGnB,cAHmB,CAAA,EAAA,GAAA,IAAA,EAAA,SAAA,EAKvC,SALuC,CAK7B,cAL6B,CAAA,CAAA,EAAA,IAAA"}

package/dist/react/useRerenderOnChange.d.ts

@@ -1,8 +1,12 @@
-import type { FragmentReference } from '../core/FragmentReference';
-import type { WithEncounteredRecords } from '../core/read';
-import type { ReaderAst } from '../core/reader';
-export declare function useRerenderOnChange<TReadFromStore extends {
-    parameters: object;
-    data: object;
+import { ReaderAst } from "../core/reader.js";
+import { WithEncounteredRecords } from "../core/read.js";
+import { FragmentReference } from "../core/FragmentReference.js";
+
+//#region src/react/useRerenderOnChange.d.ts
+declare function useRerenderOnChange<TReadFromStore extends {
+  parameters: object;
+  data: object;
 }>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+//#endregion
+export { useRerenderOnChange };
 //# sourceMappingURL=useRerenderOnChange.d.ts.map

package/dist/react/useRerenderOnChange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRerenderOnChange.d.ts","sourceRoot":"","sources":["../../src/react/useRerenderOnChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD,wBAAgB,mBAAmB,CACjC,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAE3D,yBAAyB,EAAE,sBAAsB,CAAC,cAAc,CAAC,EACjE,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC9C,4BAA4B,EAAE,CAC5B,IAAI,EAAE,sBAAsB,CAAC,cAAc,CAAC,KACzC,IAAI,EACT,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,QAoBrC"}
+{"version":3,"file":"useRerenderOnChange.d.ts","names":[],"sources":["../../src/react/useRerenderOnChange.ts"],"sourcesContent":[],"mappings":";;;;;iBASgB;;EAAA,IAAA,EAAA,MAAA;CAGoC,CAAA,CAAA,yBAAA,EAAvB,sBAAuB,CAAA,cAAA,CAAA,EAAA,iBAAA,EAC/B,iBAD+B,CAAA,GAAA,EAAA,GAAA,CAAA,EAAA,4BAAA,EAAA,CAAA,IAAA,EAG1C,sBAH0C,CAGnB,cAHmB,CAAA,EAAA,GAAA,IAAA,EAAA,SAAA,EAKvC,SALuC,CAK7B,cAL6B,CAAA,CAAA,EAAA,IAAA"}