@isograph/react 0.4.3 → 0.5.1

package/dist/react/LoadableFieldRenderer.js

@@ -1,37 +1,15 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadableFieldRenderer = LoadableFieldRenderer;
-const React = __importStar(require("react"));
-const useClientSideDefer_1 = require("../loadable-hooks/useClientSideDefer");
-const useResult_1 = require("./useResult");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+const require_useResult = require('./useResult.js');
+const require_useClientSideDefer = require('../loadable-hooks/useClientSideDefer.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/react/LoadableFieldRenderer.tsx
 function LoadableFieldRenderer(props) {
-    const { fragmentReference } = (0, useClientSideDefer_1.useClientSideDefer)(props.loadableField, props.args, props.fetchOptions);
-    const Component = (0, useResult_1.useResult)(fragmentReference, props.networkRequestOptions);
-    // TODO we probably can figure out a way to convince TypeScript of
-    // the validity of this.
-    // @ts-expect-error
-    return React.createElement(Component, Object.assign({}, props.additionalProps));
+	const { fragmentReference } = require_useClientSideDefer.useClientSideDefer(props.loadableField, props.args, props.fetchOptions);
+	const Component = require_useResult.useResult(fragmentReference, props.networkRequestOptions);
+	return /* @__PURE__ */ react.createElement(Component, props.additionalProps);
 }
+
+//#endregion
+exports.LoadableFieldRenderer = LoadableFieldRenderer;

package/dist/react/LoadableFieldRenderer.mjs

@@ -0,0 +1,14 @@
+import { useResult } from "./useResult.mjs";
+import { useClientSideDefer } from "../loadable-hooks/useClientSideDefer.mjs";
+import * as React$1 from "react";
+
+//#region src/react/LoadableFieldRenderer.tsx
+function LoadableFieldRenderer(props) {
+	const { fragmentReference } = useClientSideDefer(props.loadableField, props.args, props.fetchOptions);
+	const Component = useResult(fragmentReference, props.networkRequestOptions);
+	return /* @__PURE__ */ React$1.createElement(Component, props.additionalProps);
+}
+
+//#endregion
+export { LoadableFieldRenderer };
+//# sourceMappingURL=LoadableFieldRenderer.mjs.map

package/dist/react/LoadableFieldRenderer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoadableFieldRenderer.mjs","names":[],"sources":["../../src/react/LoadableFieldRenderer.tsx"],"sourcesContent":["import * as React from 'react';\nimport { type FetchOptions } from '../core/check';\nimport type { ExtractParameters } from '../core/FragmentReference';\nimport { type UnknownTReadFromStore } from '../core/FragmentReference';\nimport { type NetworkRequestReaderOptions } from '../core/read';\nimport { type LoadableField } from '../core/reader';\nimport { useClientSideDefer } from '../loadable-hooks/useClientSideDefer';\nimport { useResult } from './useResult';\n\ntype ArgsWithoutProvidedArgs<\n  TReadFromStore extends UnknownTReadFromStore,\n  TProvidedArgs extends object,\n> = Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>;\n\ntype MaybeRequiredArgs<\n  TReadFromStore extends UnknownTReadFromStore,\n  TProvidedArgs extends object,\n> =\n  {} extends ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>\n    ? {\n        args?: ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>;\n      }\n    : {\n        args: ArgsWithoutProvidedArgs<TReadFromStore, TProvidedArgs>;\n      };\n\nexport function LoadableFieldRenderer<\n  TReadFromStore extends UnknownTReadFromStore,\n  TProvidedArgs extends object,\n  TChildrenResult,\n  TProps,\n>(\n  props: {\n    loadableField: LoadableField<\n      TReadFromStore,\n      React.FC<TProps>,\n      Omit<ExtractParameters<TReadFromStore>, keyof TProvidedArgs>\n    >;\n    fetchOptions?: FetchOptions<React.FC<TProps>, never>;\n    networkRequestOptions?: Partial<NetworkRequestReaderOptions>;\n    additionalProps: Omit<TProps, keyof JSX.IntrinsicAttributes>;\n  } & MaybeRequiredArgs<TReadFromStore, TProvidedArgs>,\n): TChildrenResult {\n  const { fragmentReference } = useClientSideDefer(\n    props.loadableField,\n    // @ts-expect-error\n    props.args,\n    props.fetchOptions,\n  );\n\n  const Component = useResult(fragmentReference, props.networkRequestOptions);\n\n  // TODO we probably can figure out a way to convince TypeScript of\n  // the validity of this.\n  // @ts-expect-error\n  return <Component {...props.additionalProps} />;\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let neverArgs!: LoadableField<\n    {\n      parameters: Record<string, never>;\n      data: {};\n    },\n    () => React.ReactNode\n  >;\n\n  let optionalArgs!: LoadableField<\n    {\n      parameters: {\n        foo?: string;\n      };\n      data: {};\n    },\n    () => React.ReactNode\n  >;\n\n  let requiredArgs!: LoadableField<\n    {\n      parameters: {\n        foo: string;\n      };\n      data: {};\n    },\n    () => React.ReactNode\n  >;\n\n  <LoadableFieldRenderer loadableField={neverArgs} additionalProps={{}} />;\n  <LoadableFieldRenderer\n    loadableField={neverArgs}\n    additionalProps={{}}\n    args={{}}\n  />;\n  <LoadableFieldRenderer\n    loadableField={neverArgs}\n    additionalProps={{}}\n    args={{\n      // @ts-expect-error\n      foo: 'bar',\n    }}\n  />;\n\n  <LoadableFieldRenderer loadableField={optionalArgs} additionalProps={{}} />;\n  <LoadableFieldRenderer\n    loadableField={optionalArgs}\n    additionalProps={{}}\n    args={{}}\n  />;\n  <LoadableFieldRenderer\n    loadableField={optionalArgs}\n    additionalProps={{}}\n    args={{\n      foo: 'bar',\n    }}\n  />;\n  <LoadableFieldRenderer\n    loadableField={optionalArgs}\n    additionalProps={{}}\n    args={{\n      // @ts-expect-error\n      foo: 12,\n    }}\n  />;\n\n  // @ts-expect-error\n  <LoadableFieldRenderer loadableField={requiredArgs} additionalProps={{}} />;\n  <LoadableFieldRenderer\n    loadableField={requiredArgs}\n    additionalProps={{}}\n    // @ts-expect-error\n    args={{}}\n  />;\n  <LoadableFieldRenderer\n    loadableField={requiredArgs}\n    additionalProps={{}}\n    args={{\n      foo: 'bar',\n    }}\n  />;\n  <LoadableFieldRenderer\n    loadableField={requiredArgs}\n    additionalProps={{}}\n    args={{\n      // @ts-expect-error\n      foo: 12,\n    }}\n  />;\n}\n"],"mappings":";;;;;AA0BA,SAAgB,sBAMd,OAUiB;CACjB,MAAM,EAAE,sBAAsB,mBAC5B,MAAM,eAEN,MAAM,MACN,MAAM,aACP;CAED,MAAM,YAAY,UAAU,mBAAmB,MAAM,sBAAsB;AAK3E,QAAO,sCAAC,WAAc,MAAM,gBAAmB"}

package/dist/react/RenderAfterCommit__DO_NOT_USE.d.mts

@@ -0,0 +1,18 @@
+import * as react0 from "react";
+
+//#region src/react/RenderAfterCommit__DO_NOT_USE.d.ts
+
+/**
+ * This is a function that will render a component only after it commits.
+ * It should not be used in production. It's useful as a way to debug issues
+ * with NextJS, where an indefinite suspense causes the server to hang
+ * forever and never complete the original request.
+ */
+declare function RenderAfterCommit__DO_NOT_USE({
+  children
+}: {
+  children: React.ReactNode;
+}): react0.ReactNode;
+//#endregion
+export { RenderAfterCommit__DO_NOT_USE };
+//# sourceMappingURL=RenderAfterCommit__DO_NOT_USE.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RenderAfterCommit__DO_NOT_USE.d.mts","names":[],"sources":["../../src/react/RenderAfterCommit__DO_NOT_USE.tsx"],"sourcesContent":[],"mappings":";;;;;;;AAQA;;;AAG2B,iBAHX,6BAAA,CAIf;EAAA;CAAA,EAAA;EAAA,QAAA,EADW,KAAA,CAAM,SACjB;IAD0B,MAAA,CAC1B"}

package/dist/react/RenderAfterCommit__DO_NOT_USE.d.ts

@@ -1,10 +1,18 @@
+import * as react0 from "react";
+
+//#region src/react/RenderAfterCommit__DO_NOT_USE.d.ts
+
 /**
  * This is a function that will render a component only after it commits.
  * It should not be used in production. It's useful as a way to debug issues
  * with NextJS, where an indefinite suspense causes the server to hang
  * forever and never complete the original request.
  */
-export declare function RenderAfterCommit__DO_NOT_USE({ children, }: {
-    children: React.ReactNode;
-}): import("react").ReactNode;
+declare function RenderAfterCommit__DO_NOT_USE({
+  children
+}: {
+  children: React.ReactNode;
+}): react0.ReactNode;
+//#endregion
+export { RenderAfterCommit__DO_NOT_USE };
 //# sourceMappingURL=RenderAfterCommit__DO_NOT_USE.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RenderAfterCommit__DO_NOT_USE.d.ts","sourceRoot":"","sources":["../../src/react/RenderAfterCommit__DO_NOT_USE.tsx"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,6BAIA"}
+{"version":3,"file":"RenderAfterCommit__DO_NOT_USE.d.ts","names":[],"sources":["../../src/react/RenderAfterCommit__DO_NOT_USE.tsx"],"sourcesContent":[],"mappings":";;;;;;;AAQA;;;AAG2B,iBAHX,6BAAA,CAIf;EAAA;CAAA,EAAA;EAAA,QAAA,EADW,KAAA,CAAM,SACjB;IAD0B,MAAA,CAC1B"}

package/dist/react/RenderAfterCommit__DO_NOT_USE.js

@@ -1,15 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RenderAfterCommit__DO_NOT_USE = RenderAfterCommit__DO_NOT_USE;
-const react_1 = require("react");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.js');
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react);
+
+//#region src/react/RenderAfterCommit__DO_NOT_USE.tsx
 /**
- * This is a function that will render a component only after it commits.
- * It should not be used in production. It's useful as a way to debug issues
- * with NextJS, where an indefinite suspense causes the server to hang
- * forever and never complete the original request.
- */
-function RenderAfterCommit__DO_NOT_USE({ children, }) {
-    const [show, setShow] = (0, react_1.useState)(false);
-    (0, react_1.useEffect)(() => setShow(true), []);
-    return show ? children : null;
+* This is a function that will render a component only after it commits.
+* It should not be used in production. It's useful as a way to debug issues
+* with NextJS, where an indefinite suspense causes the server to hang
+* forever and never complete the original request.
+*/
+function RenderAfterCommit__DO_NOT_USE({ children }) {
+	const [show, setShow] = (0, react.useState)(false);
+	(0, react.useEffect)(() => setShow(true), []);
+	return show ? children : null;
 }
+
+//#endregion
+exports.RenderAfterCommit__DO_NOT_USE = RenderAfterCommit__DO_NOT_USE;

package/dist/react/RenderAfterCommit__DO_NOT_USE.mjs

@@ -0,0 +1,18 @@
+import { useEffect, useState } from "react";
+
+//#region src/react/RenderAfterCommit__DO_NOT_USE.tsx
+/**
+* This is a function that will render a component only after it commits.
+* It should not be used in production. It's useful as a way to debug issues
+* with NextJS, where an indefinite suspense causes the server to hang
+* forever and never complete the original request.
+*/
+function RenderAfterCommit__DO_NOT_USE({ children }) {
+	const [show, setShow] = useState(false);
+	useEffect(() => setShow(true), []);
+	return show ? children : null;
+}
+
+//#endregion
+export { RenderAfterCommit__DO_NOT_USE };
+//# sourceMappingURL=RenderAfterCommit__DO_NOT_USE.mjs.map

package/dist/react/RenderAfterCommit__DO_NOT_USE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderAfterCommit__DO_NOT_USE.mjs","names":[],"sources":["../../src/react/RenderAfterCommit__DO_NOT_USE.tsx"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * This is a function that will render a component only after it commits.\n * It should not be used in production. It's useful as a way to debug issues\n * with NextJS, where an indefinite suspense causes the server to hang\n * forever and never complete the original request.\n */\nexport function RenderAfterCommit__DO_NOT_USE({\n  children,\n}: {\n  children: React.ReactNode;\n}) {\n  const [show, setShow] = useState(false);\n  useEffect(() => setShow(true), []);\n  return show ? children : null;\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,8BAA8B,EAC5C,YAGC;CACD,MAAM,CAAC,MAAM,WAAW,SAAS,MAAM;AACvC,iBAAgB,QAAQ,KAAK,EAAE,EAAE,CAAC;AAClC,QAAO,OAAO,WAAW"}

package/dist/react/createIsographEnvironment.d.mts

@@ -0,0 +1,9 @@
+import { LogFunction } from "../core/logging.mjs";
+import { BaseStoreLayerData, IsographEnvironment, IsographNetworkFunction, MissingFieldHandler } from "../core/IsographEnvironment.mjs";
+import "../index.mjs";
+
+//#region src/react/createIsographEnvironment.d.ts
+declare function createIsographEnvironment(baseStoreLayerData: BaseStoreLayerData, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler | null, logFunction?: LogFunction | null): IsographEnvironment;
+//#endregion
+export { createIsographEnvironment };
+//# sourceMappingURL=createIsographEnvironment.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createIsographEnvironment.d.mts","names":[],"sources":["../../src/react/createIsographEnvironment.ts"],"sourcesContent":[],"mappings":";;;;;iBASgB,yBAAA,qBACM,qCACH,+CACK,0CACR,qBAAW"}

package/dist/react/createIsographEnvironment.d.ts

@@ -0,0 +1,8 @@
+import { LogFunction } from "../core/logging.js";
+import { BaseStoreLayerData, IsographEnvironment, IsographNetworkFunction, MissingFieldHandler } from "../core/IsographEnvironment.js";
+
+//#region src/react/createIsographEnvironment.d.ts
+declare function createIsographEnvironment(baseStoreLayerData: BaseStoreLayerData, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler | null, logFunction?: LogFunction | null): IsographEnvironment;
+//#endregion
+export { createIsographEnvironment };
+//# sourceMappingURL=createIsographEnvironment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createIsographEnvironment.d.ts","names":[],"sources":["../../src/react/createIsographEnvironment.ts"],"sourcesContent":[],"mappings":";;;;iBASgB,yBAAA,qBACM,qCACH,+CACK,0CACR,qBAAW"}

package/dist/react/createIsographEnvironment.js

@@ -0,0 +1,10 @@
+const require_IsographEnvironment = require('../core/IsographEnvironment.js');
+const require_useReadAndSubscribe = require('./useReadAndSubscribe.js');
+
+//#region src/react/createIsographEnvironment.ts
+function createIsographEnvironment(baseStoreLayerData, networkFunction, missingFieldHandler, logFunction) {
+	return require_IsographEnvironment.createIsographEnvironmentCore(baseStoreLayerData, networkFunction, require_useReadAndSubscribe.componentFunction, missingFieldHandler, logFunction);
+}
+
+//#endregion
+exports.createIsographEnvironment = createIsographEnvironment;

package/dist/react/createIsographEnvironment.mjs

@@ -0,0 +1,11 @@
+import { createIsographEnvironmentCore } from "../core/IsographEnvironment.mjs";
+import { componentFunction } from "./useReadAndSubscribe.mjs";
+
+//#region src/react/createIsographEnvironment.ts
+function createIsographEnvironment(baseStoreLayerData, networkFunction, missingFieldHandler, logFunction) {
+	return createIsographEnvironmentCore(baseStoreLayerData, networkFunction, componentFunction, missingFieldHandler, logFunction);
+}
+
+//#endregion
+export { createIsographEnvironment };
+//# sourceMappingURL=createIsographEnvironment.mjs.map

package/dist/react/createIsographEnvironment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createIsographEnvironment.mjs","names":[],"sources":["../../src/react/createIsographEnvironment.ts"],"sourcesContent":["import {\n  createIsographEnvironmentCore,\n  type BaseStoreLayerData,\n  type IsographNetworkFunction,\n  type MissingFieldHandler,\n} from '../core/IsographEnvironment';\nimport type { LogFunction } from '../core/logging';\nimport { componentFunction } from './useReadAndSubscribe';\n\nexport function createIsographEnvironment(\n  baseStoreLayerData: BaseStoreLayerData,\n  networkFunction: IsographNetworkFunction,\n  missingFieldHandler?: MissingFieldHandler | null,\n  logFunction?: LogFunction | null,\n) {\n  return createIsographEnvironmentCore(\n    baseStoreLayerData,\n    networkFunction,\n    componentFunction,\n    missingFieldHandler,\n    logFunction,\n  );\n}\n"],"mappings":";;;;AASA,SAAgB,0BACd,oBACA,iBACA,qBACA,aACA;AACA,QAAO,8BACL,oBACA,iBACA,mBACA,qBACA,YACD"}

package/dist/react/maybeUnwrapNetworkRequest.js

@@ -0,0 +1,11 @@
+const require_PromiseWrapper = require('../core/PromiseWrapper.js');
+
+//#region src/react/maybeUnwrapNetworkRequest.ts
+function maybeUnwrapNetworkRequest(networkRequest, networkRequestOptions) {
+	const state = require_PromiseWrapper.getPromiseState(networkRequest);
+	if (state.kind === "Err" && networkRequestOptions.throwOnNetworkError) throw state.error;
+	else if (state.kind === "Pending" && networkRequestOptions.suspendIfInFlight) throw state.promise;
+}
+
+//#endregion
+exports.maybeUnwrapNetworkRequest = maybeUnwrapNetworkRequest;

package/dist/react/maybeUnwrapNetworkRequest.mjs

@@ -0,0 +1,12 @@
+import { getPromiseState } from "../core/PromiseWrapper.mjs";
+
+//#region src/react/maybeUnwrapNetworkRequest.ts
+function maybeUnwrapNetworkRequest(networkRequest, networkRequestOptions) {
+	const state = getPromiseState(networkRequest);
+	if (state.kind === "Err" && networkRequestOptions.throwOnNetworkError) throw state.error;
+	else if (state.kind === "Pending" && networkRequestOptions.suspendIfInFlight) throw state.promise;
+}
+
+//#endregion
+export { maybeUnwrapNetworkRequest };
+//# sourceMappingURL=maybeUnwrapNetworkRequest.mjs.map

package/dist/react/maybeUnwrapNetworkRequest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybeUnwrapNetworkRequest.mjs","names":[],"sources":["../../src/react/maybeUnwrapNetworkRequest.ts"],"sourcesContent":["import { type PromiseWrapper, getPromiseState } from '../core/PromiseWrapper';\nimport type { NetworkRequestReaderOptions } from '../core/read';\n\nexport function maybeUnwrapNetworkRequest(\n  networkRequest: PromiseWrapper<void, any>,\n  networkRequestOptions: NetworkRequestReaderOptions,\n) {\n  const state = getPromiseState(networkRequest);\n  if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {\n    throw state.error;\n  } else if (\n    state.kind === 'Pending' &&\n    networkRequestOptions.suspendIfInFlight\n  ) {\n    throw state.promise;\n  }\n}\n"],"mappings":";;;AAGA,SAAgB,0BACd,gBACA,uBACA;CACA,MAAM,QAAQ,gBAAgB,eAAe;AAC7C,KAAI,MAAM,SAAS,SAAS,sBAAsB,oBAChD,OAAM,MAAM;UAEZ,MAAM,SAAS,aACf,sBAAsB,kBAEtB,OAAM,MAAM"}

package/dist/react/useImperativeReference.d.mts

@@ -0,0 +1,15 @@
+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/useImperativeReference.d.ts
+
+type UseImperativeReferenceResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType> = {
+  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue> | null;
+  loadFragmentReference: (variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: NormalizationAstLoader extends TNormalizationAst ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]) => void;
+};
+declare function useImperativeReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>): UseImperativeReferenceResult<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>;
+//#endregion
+export { UseImperativeReferenceResult, useImperativeReference };
+//# sourceMappingURL=useImperativeReference.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeReference.d.mts","names":[],"sources":["../../src/react/useImperativeReference.ts"],"sourcesContent":[],"mappings":";;;;;;;AAyByB,KADb,4BACa,CAAA,uBAAA,qBAAA,EAAA,iBAAA,EAAA,0BAEG,gBAFH,GAEsB,sBAFtB,EAAA,gBAAA,CAAA,GAAA;EAEG,iBAAA,EAGP,iBAHO,CAIxB,cAJwB,EAKxB,iBALwB,CAAA,GAAA,IAAA;EAAmB,qBAAA,EAAA,CAAA,SAAA,EAQhC,iBARgC,CAQd,cARc,CAAA,EAAA,GAAA,CAAA,YAAA,CAAA,EASxB,sBATwB,SASO,iBATP,GAAA,CAAA,YAAA,EAUxB,oBAVwB,CAUH,iBAVG,CAAA,CAAA,GAAA,CAAA,YAAA,GAWvB,YAXuB,CAWV,iBAXU,EAWS,gBAXT,CAAA,CAAA,EAAA,GAAA,IAAA;CAI3C;AACA,iBAUY,sBAVZ,CAAA,uBAWqB,qBAXrB,EAAA,iBAAA,EAAA,0BAawB,gBAbxB,GAa2C,sBAb3C,EAAA,yBAcuB,qBAdvB,CAAA,CAAA,UAAA,EAgBU,kBAhBV,CAiBA,cAjBA,EAkBA,iBAlBA,EAmBA,iBAnBA,EAoBA,gBApBA,CAAA,CAAA,EAsBD,4BAtBC,CAuBF,cAvBE,EAwBF,iBAxBE,EAyBF,iBAzBE,EA0BF,gBA1BE,CAAA"}

package/dist/react/useImperativeReference.d.ts

@@ -1,9 +1,15 @@
-import { FetchOptions, type RequiredFetchOptions } from '../core/check';
-import { IsographEntrypoint, type NormalizationAst, type NormalizationAstLoader } from '../core/entrypoint';
-import { ExtractParameters, FragmentReference, type UnknownTReadFromStore } from '../core/FragmentReference';
-export type UseImperativeReferenceResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader> = {
-    fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue> | null;
-    loadFragmentReference: (variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: NormalizationAstLoader extends TNormalizationAst ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue>]) => void;
+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/useImperativeReference.d.ts
+
+type UseImperativeReferenceResult<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType> = {
+  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue> | null;
+  loadFragmentReference: (variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: NormalizationAstLoader extends TNormalizationAst ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue, TRawResponseType>]) => void;
 };
-export declare function useImperativeReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>): UseImperativeReferenceResult<TReadFromStore, TClientFieldValue, TNormalizationAst>;
+declare function useImperativeReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader, TRawResponseType extends NetworkResponseObject>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>): UseImperativeReferenceResult<TReadFromStore, TClientFieldValue, TNormalizationAst, TRawResponseType>;
+//#endregion
+export { UseImperativeReferenceResult, useImperativeReference };
 //# sourceMappingURL=useImperativeReference.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useImperativeReference.d.ts","sourceRoot":"","sources":["../../src/react/useImperativeReference.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAMnC,MAAM,MAAM,4BAA4B,CACtC,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,IACjE;IACF,iBAAiB,EAAE,iBAAiB,CAClC,cAAc,EACd,iBAAiB,CAClB,GAAG,IAAI,CAAC;IACT,qBAAqB,EAAE,CACrB,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAC5C,GAAG,CAAC,YAAY,CAAC,EAAE,sBAAsB,SAAS,iBAAiB,GAC/D,CAAC,YAAY,EAAE,oBAAoB,CAAC,iBAAiB,CAAC,CAAC,GACvD,CAAC,YAAY,CAAC,EAAE,YAAY,CAAC,iBAAiB,CAAC,CAAC,KACjD,IAAI,CAAC;CACX,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,EAEnE,UAAU,EAAE,kBAAkB,CAC5B,cAAc,EACd,iBAAiB,EACjB,iBAAiB,CAClB,GACA,4BAA4B,CAC7B,cAAc,EACd,iBAAiB,EACjB,iBAAiB,CAClB,CAsCA"}
+{"version":3,"file":"useImperativeReference.d.ts","names":[],"sources":["../../src/react/useImperativeReference.ts"],"sourcesContent":[],"mappings":";;;;;;;AAyByB,KADb,4BACa,CAAA,uBAAA,qBAAA,EAAA,iBAAA,EAAA,0BAEG,gBAFH,GAEsB,sBAFtB,EAAA,gBAAA,CAAA,GAAA;EAEG,iBAAA,EAGP,iBAHO,CAIxB,cAJwB,EAKxB,iBALwB,CAAA,GAAA,IAAA;EAAmB,qBAAA,EAAA,CAAA,SAAA,EAQhC,iBARgC,CAQd,cARc,CAAA,EAAA,GAAA,CAAA,YAAA,CAAA,EASxB,sBATwB,SASO,iBATP,GAAA,CAAA,YAAA,EAUxB,oBAVwB,CAUH,iBAVG,CAAA,CAAA,GAAA,CAAA,YAAA,GAWvB,YAXuB,CAWV,iBAXU,EAWS,gBAXT,CAAA,CAAA,EAAA,GAAA,IAAA;CAI3C;AACA,iBAUY,sBAVZ,CAAA,uBAWqB,qBAXrB,EAAA,iBAAA,EAAA,0BAawB,gBAbxB,GAa2C,sBAb3C,EAAA,yBAcuB,qBAdvB,CAAA,CAAA,UAAA,EAgBU,kBAhBV,CAiBA,cAjBA,EAkBA,iBAlBA,EAmBA,iBAnBA,EAoBA,gBApBA,CAAA,CAAA,EAsBD,4BAtBC,CAuBF,cAvBE,EAwBF,iBAxBE,EAyBF,iBAzBE,EA0BF,gBA1BE,CAAA"}

package/dist/react/useImperativeReference.js

@@ -1,34 +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 PromiseWrapper_1 = require("../core/PromiseWrapper");
-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 readerWithRefetchQueries = entrypoint.readerWithRefetchQueries.kind ===
-                'ReaderWithRefetchQueriesLoader'
-                ? (0, PromiseWrapper_1.wrapPromise)(entrypoint.readerWithRefetchQueries.loader())
-                : (0, PromiseWrapper_1.wrapResolvedValue)(entrypoint.readerWithRefetchQueries);
-            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, readerWithRefetchQueries, fetchOptions !== null && fetchOptions !== void 0 ? fetchOptions : null);
-            setState([
-                {
-                    kind: 'FragmentReference',
-                    readerWithRefetchQueries,
-                    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,7 +1,13 @@
-import { FetchOptions, type RequiredFetchOptions } from '../core/check';
-import { IsographEntrypoint, type NormalizationAst, type NormalizationAstLoader } from '../core/entrypoint';
-import { ExtractParameters, FragmentReference, type UnknownTReadFromStore } from '../core/FragmentReference';
-export declare function useLazyReference<TReadFromStore extends UnknownTReadFromStore, TClientFieldValue, TNormalizationAst extends NormalizationAst | NormalizationAstLoader>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue, TNormalizationAst>, variables: ExtractParameters<TReadFromStore>, ...[fetchOptions]: TNormalizationAst extends NormalizationAstLoader ? [fetchOptions: RequiredFetchOptions<TClientFieldValue>] : [fetchOptions?: FetchOptions<TClientFieldValue>]): 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":"AAEA,OAAO,EAAE,YAAY,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAInC,wBAAgB,gBAAgB,CAC9B,cAAc,SAAS,qBAAqB,EAC5C,iBAAiB,EACjB,iBAAiB,SAAS,gBAAgB,GAAG,sBAAsB,EAEnE,UAAU,EAAE,kBAAkB,CAC5B,cAAc,EACd,iBAAiB,EACjB,iBAAiB,CAClB,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,CAAC,CAAC,GACnD,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 cache_1 = require("../core/cache");
-const logging_1 = require("../core/logging");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+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, cache_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"}