@isograph/react 0.0.0-main-0e7d8883 → 0.0.0-main-4b202045

package/dist/EntrypointReader.d.ts

@@ -1,6 +1,10 @@
 import * as React from 'react';
-import { ExtractReadFromStore, IsographEntrypoint, type FragmentReference } from './index';
-export declare function EntrypointReader<TProps extends Record<any, any>, TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>>>(props: {
+import { ExtractReadFromStore, IsographEntrypoint } from './entrypoint';
+import { FragmentReference } from './FragmentReference';
+export declare function EntrypointReader<TProps extends Record<any, any>, TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>>>(props: TProps extends Record<string, never> ? {
+    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<TProps>>;
+    additionalProps?: TProps;
+} : {
     queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<TProps>>;
     additionalProps: TProps;
 }): React.ReactNode;

package/dist/EntrypointReader.js

@@ -25,9 +25,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EntrypointReader = void 0;
 const React = __importStar(require("react"));
-const index_1 = require("./index");
+const useResult_1 = require("./useResult");
 function EntrypointReader(props) {
-    const Component = (0, index_1.useResult)(props.queryReference);
+    const Component = (0, useResult_1.useResult)(props.queryReference);
     return React.createElement(Component, Object.assign({}, props.additionalProps));
 }
 exports.EntrypointReader = EntrypointReader;

package/dist/IsographEnvironment.d.ts

@@ -54,4 +54,5 @@ export declare function defaultMissingFieldHandler(_storeRecord: StoreRecord, _r
 } | null, variables: {
     [index: string]: any;
 } | null): Link | undefined;
+export declare function assertLink(link: DataTypeValue): Link | null;
 export {};

package/dist/IsographEnvironment.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
+exports.assertLink = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
 exports.ROOT_ID = '__ROOT';
 const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
@@ -34,3 +34,16 @@ function defaultMissingFieldHandler(_storeRecord, _root, fieldName, arguments_,
     }
 }
 exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
+function assertLink(link) {
+    if (Array.isArray(link)) {
+        throw new Error('Unexpected array');
+    }
+    if (link == null) {
+        return null;
+    }
+    if (typeof link === 'object') {
+        return link;
+    }
+    throw new Error('Invalid link');
+}
+exports.assertLink = assertLink;

package/dist/cache.d.ts

@@ -1,7 +1,8 @@
 import { ItemCleanupPair, ParentCache } from '@isograph/react-disposable-state';
 import { PromiseWrapper } from './PromiseWrapper';
-import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from './index';
 import { type IsographEnvironment } from './IsographEnvironment';
+import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField } from './entrypoint';
+import { ReaderLinkedField, ReaderScalarField } from './reader';
 declare global {
     interface Window {
         __LOG: boolean;

package/dist/componentCache.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
-import { ReaderArtifact, RefetchQueryArtifactWrapper } from './index';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
 import { IsographEnvironment, DataId } from './IsographEnvironment';
+import { ReaderArtifact } from './reader';
 export declare function getOrCreateCachedComponent(environment: IsographEnvironment, root: DataId, componentName: string, readerArtifact: ReaderArtifact<any, any>, variables: {
     [key: string]: string;
 }, resolverRefetchQueries: RefetchQueryArtifactWrapper[]): import("react").FC<any>;

package/dist/componentCache.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrCreateCachedComponent = void 0;
-const index_1 = require("./index");
 const cache_1 = require("./cache");
+const read_1 = require("./read");
 function getOrCreateCachedComponent(environment, root, componentName, readerArtifact, variables, resolverRefetchQueries) {
     var _a, _b, _c;
     const cachedComponentsById = environment.componentCache;
@@ -14,7 +14,7 @@ function getOrCreateCachedComponent(environment, root, componentName, readerArti
     byArgs[stringifiedArgs] =
         (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
             function Component(additionalRuntimeProps) {
-                const data = (0, index_1.readButDoNotEvaluate)(environment, {
+                const data = (0, read_1.readButDoNotEvaluate)(environment, {
                     kind: 'FragmentReference',
                     readerArtifact: readerArtifact,
                     root,

package/dist/entrypoint.d.ts

@@ -1,5 +1,5 @@
-import { Arguments } from './index';
 import { ReaderArtifact } from './reader';
+import { Arguments } from './util';
 export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
     kind: 'Entrypoint';
     queryText: string;
@@ -30,3 +30,5 @@ export type RefetchQueryArtifactWrapper = {
     allowedVariables: string[];
 };
 export declare function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(value: IsographEntrypoint<TReadFromStore, TResolverResult> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult>;
+export type ExtractReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any> ? X : never;
+export type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, infer X> ? X : never;

package/dist/garbageCollection.d.ts

@@ -1,5 +1,5 @@
 import { IsographEnvironment } from './IsographEnvironment';
-import { NormalizationAst } from './index';
+import { NormalizationAst } from './entrypoint';
 export type RetainedQuery = {
     normalizationAst: NormalizationAst;
     variables: {};

package/dist/garbageCollection.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.garbageCollectEnvironment = exports.retainQuery = exports.unretainQuery = void 0;
 const IsographEnvironment_1 = require("./IsographEnvironment");
-const index_1 = require("./index");
 const cache_1 = require("./cache");
 function unretainQuery(environment, retainedQuery) {
     environment.retainedQueries.delete(retainedQuery);
@@ -48,14 +47,14 @@ function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds,
                 const ids = [];
                 if (Array.isArray(linkedFieldOrFields)) {
                     for (const maybeLink of linkedFieldOrFields) {
-                        const link = (0, index_1.assertLink)(maybeLink);
+                        const link = (0, IsographEnvironment_1.assertLink)(maybeLink);
                         if (link != null) {
                             ids.push(link.__link);
                         }
                     }
                 }
                 else {
-                    const link = (0, index_1.assertLink)(linkedFieldOrFields);
+                    const link = (0, IsographEnvironment_1.assertLink)(linkedFieldOrFields);
                     if (link != null) {
                         ids.push(link.__link);
                     }

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import { DataTypeValue, Link } from './IsographEnvironment';
-import { IsographEntrypoint } from './entrypoint';
-import { FragmentReference, Variable } from './FragmentReference';
 export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
@@ -13,22 +10,5 @@ export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, Norma
 export { read, readButDoNotEvaluate } from './read';
 export { useResult } from './useResult';
 export { type FragmentReference } from './FragmentReference';
-export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
-export type Arguments = Argument[];
-export type Argument = [ArgumentName, ArgumentValue];
-export type ArgumentName = string;
-export type ArgumentValue = {
-    kind: 'Variable';
-    name: string;
-} | {
-    kind: 'Literal';
-    value: any;
-};
-export type ExtractReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any> ? X : never;
-export type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, infer X> ? X : never;
-export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
-    [key: string]: Variable;
-}): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
-};
-export declare function assertLink(link: DataTypeValue): Link | null;
+export { useLazyReference } from './useLazyReference';
+export { ExtractSecondParam, Argument, ArgumentName, ArgumentValue, Arguments, } from './util';

package/dist/index.js

@@ -1,69 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertLink = exports.useLazyReference = exports.useResult = exports.readButDoNotEvaluate = exports.read = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.subscribe = exports.makeNetworkRequest = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
-const cache_1 = require("./cache");
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
-const entrypoint_1 = require("./entrypoint");
+exports.useLazyReference = exports.useResult = exports.readButDoNotEvaluate = exports.read = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.subscribe = exports.makeNetworkRequest = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
 var garbageCollection_1 = require("./garbageCollection");
 Object.defineProperty(exports, "retainQuery", { enumerable: true, get: function () { return garbageCollection_1.retainQuery; } });
 Object.defineProperty(exports, "unretainQuery", { enumerable: true, get: function () { return garbageCollection_1.unretainQuery; } });
 Object.defineProperty(exports, "garbageCollectEnvironment", { enumerable: true, get: function () { return garbageCollection_1.garbageCollectEnvironment; } });
-var cache_2 = require("./cache");
-Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
-Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
-var IsographEnvironment_2 = require("./IsographEnvironment");
-Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_2.ROOT_ID; } });
-Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographEnvironment; } });
-Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographStore; } });
-Object.defineProperty(exports, "defaultMissingFieldHandler", { enumerable: true, get: function () { return IsographEnvironment_2.defaultMissingFieldHandler; } });
-var IsographEnvironmentProvider_2 = require("./IsographEnvironmentProvider");
-Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.IsographEnvironmentProvider; } });
-Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_2.useIsographEnvironment; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_1.makeNetworkRequest; } });
+Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_1.subscribe; } });
+var IsographEnvironment_1 = require("./IsographEnvironment");
+Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_1.ROOT_ID; } });
+Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_1.createIsographEnvironment; } });
+Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_1.createIsographStore; } });
+Object.defineProperty(exports, "defaultMissingFieldHandler", { enumerable: true, get: function () { return IsographEnvironment_1.defaultMissingFieldHandler; } });
+var IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironmentProvider_1.IsographEnvironmentProvider; } });
+Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_1.useIsographEnvironment; } });
 var useImperativeReference_1 = require("./useImperativeReference");
 Object.defineProperty(exports, "useImperativeReference", { enumerable: true, get: function () { return useImperativeReference_1.useImperativeReference; } });
 var EntrypointReader_1 = require("./EntrypointReader");
 Object.defineProperty(exports, "EntrypointReader", { enumerable: true, get: function () { return EntrypointReader_1.EntrypointReader; } });
-var entrypoint_2 = require("./entrypoint");
-Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_2.assertIsEntrypoint; } });
+var entrypoint_1 = require("./entrypoint");
+Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_1.assertIsEntrypoint; } });
 var read_1 = require("./read");
 Object.defineProperty(exports, "read", { enumerable: true, get: function () { return read_1.read; } });
 Object.defineProperty(exports, "readButDoNotEvaluate", { enumerable: true, get: function () { return read_1.readButDoNotEvaluate; } });
 var useResult_1 = require("./useResult");
 Object.defineProperty(exports, "useResult", { enumerable: true, get: function () { return useResult_1.useResult; } });
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
-function useLazyReference(entrypoint, variables) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
-    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
-    // TODO add comment explaining why we never use this value
-    // @ts-ignore
-    const data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
-    return {
-        queryReference: {
-            kind: 'FragmentReference',
-            readerArtifact: entrypoint.readerArtifact,
-            root: IsographEnvironment_1.ROOT_ID,
-            variables,
-            nestedRefetchQueries: entrypoint.nestedRefetchQueries,
-        },
-    };
-}
-exports.useLazyReference = useLazyReference;
-function assertLink(link) {
-    if (Array.isArray(link)) {
-        throw new Error('Unexpected array');
-    }
-    if (link == null) {
-        return null;
-    }
-    if (typeof link === 'object') {
-        return link;
-    }
-    throw new Error('Invalid link');
-}
-exports.assertLink = assertLink;
+var useLazyReference_1 = require("./useLazyReference");
+Object.defineProperty(exports, "useLazyReference", { enumerable: true, get: function () { return useLazyReference_1.useLazyReference; } });

package/dist/read.d.ts

@@ -1,4 +1,4 @@
-import { FragmentReference } from './index';
+import { FragmentReference } from './FragmentReference';
 import { IsographEnvironment } from './IsographEnvironment';
 export declare function read<TReadFromStore extends Object, TResolverResult>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;
 export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, reference: FragmentReference<TReadFromStore, unknown>): TReadFromStore;

package/dist/read.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readButDoNotEvaluate = exports.read = void 0;
 const cache_1 = require("./cache");
 const componentCache_1 = require("./componentCache");
-const index_1 = require("./index");
 const IsographEnvironment_1 = require("./IsographEnvironment");
 function read(environment, fragmentReference) {
     var _a, _b;
@@ -72,7 +71,7 @@ function readData(environment, ast, root, variables, nestedRefetchQueries) {
                 if (Array.isArray(value)) {
                     const results = [];
                     for (const item of value) {
-                        const link = (0, index_1.assertLink)(item);
+                        const link = (0, IsographEnvironment_1.assertLink)(item);
                         if (link === undefined) {
                             return {
                                 kind: 'MissingData',
@@ -106,7 +105,7 @@ function readData(environment, ast, root, variables, nestedRefetchQueries) {
                     target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = results;
                     break;
                 }
-                let link = (0, index_1.assertLink)(value);
+                let link = (0, IsographEnvironment_1.assertLink)(value);
                 if (link === undefined) {
                     // TODO make this configurable, and also generated and derived from the schema
                     const missingFieldHandler = (_c = environment.missingFieldHandler) !== null && _c !== void 0 ? _c : IsographEnvironment_1.defaultMissingFieldHandler;

package/dist/reader.d.ts

@@ -1,4 +1,4 @@
-import { Arguments } from './index';
+import { Arguments } from './util';
 export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
     kind: 'ReaderArtifact';
     readerAst: ReaderAst<TReadFromStore>;

package/dist/useImperativeReference.d.ts

@@ -1,5 +1,6 @@
 import { UnassignedState } from '@isograph/react-disposable-state';
-import { type IsographEntrypoint, type FragmentReference, ExtractReadFromStore, ExtractResolverResult } from './index';
+import { ExtractReadFromStore, ExtractResolverResult, IsographEntrypoint } from './entrypoint';
+import { FragmentReference } from './FragmentReference';
 export declare function useImperativeReference<TEntrypoint extends IsographEntrypoint<any, any>>(entrypoint: TEntrypoint): {
     queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>> | UnassignedState;
     loadQueryReference: (variables: {

package/dist/useImperativeReference.js

@@ -2,19 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useImperativeReference = void 0;
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const index_1 = require("./index");
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const cache_1 = require("./cache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
 function useImperativeReference(entrypoint) {
     const { state, setState } = (0, react_disposable_state_1.useUpdatableDisposableState)();
-    const environment = (0, index_1.useIsographEnvironment)();
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     return {
         queryReference: state,
         loadQueryReference: (variables) => {
-            const [_networkRequest, disposeNetworkRequest] = (0, index_1.makeNetworkRequest)(environment, entrypoint, variables);
+            const [_networkRequest, disposeNetworkRequest] = (0, cache_1.makeNetworkRequest)(environment, entrypoint, variables);
             setState([
                 {
                     kind: 'FragmentReference',
                     readerArtifact: entrypoint.readerArtifact,
-                    root: index_1.ROOT_ID,
+                    root: IsographEnvironment_1.ROOT_ID,
                     variables,
                     nestedRefetchQueries: entrypoint.nestedRefetchQueries,
                 },

package/dist/useLazyReference.d.ts

@@ -0,0 +1,7 @@
+import { FragmentReference, Variable } from './FragmentReference';
+import { ExtractReadFromStore, ExtractResolverResult } from './entrypoint';
+export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
+    [key: string]: Variable;
+}): {
+    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
+};

package/dist/useLazyReference.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLazyReference = void 0;
+const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const entrypoint_1 = require("./entrypoint");
+const cache_1 = require("./cache");
+const isograph_react_disposable_state_1 = require("@isograph/isograph-react-disposable-state");
+// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
+// if we do not explicitly pass a type, the read out type will be any.
+// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
+// any actual Entrypoint we pass will not be valid.
+function useLazyReference(entrypoint, variables) {
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
+    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
+    // TODO add comment explaining why we never use this value
+    // @ts-ignore
+    const data = (0, isograph_react_disposable_state_1.useLazyDisposableState)(cache).state;
+    return {
+        queryReference: {
+            kind: 'FragmentReference',
+            readerArtifact: entrypoint.readerArtifact,
+            root: IsographEnvironment_1.ROOT_ID,
+            variables,
+            nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+        },
+    };
+}
+exports.useLazyReference = useLazyReference;

package/dist/useResult.d.ts

@@ -1,2 +1,2 @@
-import { FragmentReference } from './index';
+import { FragmentReference } from './FragmentReference';
 export declare function useResult<TReadFromStore extends Object, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;

package/dist/util.d.ts

@@ -0,0 +1,11 @@
+export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
+export type Arguments = Argument[];
+export type Argument = [ArgumentName, ArgumentValue];
+export type ArgumentName = string;
+export type ArgumentValue = {
+    kind: 'Variable';
+    name: string;
+} | {
+    kind: 'Literal';
+    value: any;
+};

package/dist/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-0e7d8883",
+  "version": "0.0.0-main-4b202045",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-0e7d8883",
-    "@isograph/react-disposable-state": "0.0.0-main-0e7d8883",
+    "@isograph/disposable-types": "0.0.0-main-4b202045",
+    "@isograph/react-disposable-state": "0.0.0-main-4b202045",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/EntrypointReader.tsx

@@ -1,23 +1,28 @@
 import * as React from 'react';
-import {
-  ExtractReadFromStore,
-  IsographEntrypoint,
-  type FragmentReference,
-  useResult,
-} from './index';
+import { ExtractReadFromStore, IsographEntrypoint } from './entrypoint';
+import { FragmentReference } from './FragmentReference';
+import { useResult } from './useResult';
 
 export function EntrypointReader<
   TProps extends Record<any, any>,
   TEntrypoint extends IsographEntrypoint<any, React.FC<TProps>>,
->(props: {
-  queryReference: FragmentReference<
-    ExtractReadFromStore<TEntrypoint>,
-    React.FC<TProps>
-  >;
-  // TODO make additionalProps optional if TProps extends Record<string, never>
-  // perhaps with a type overload
-  additionalProps: TProps;
-}): React.ReactNode {
+>(
+  props: TProps extends Record<string, never>
+    ? {
+        queryReference: FragmentReference<
+          ExtractReadFromStore<TEntrypoint>,
+          React.FC<TProps>
+        >;
+        additionalProps?: TProps;
+      }
+    : {
+        queryReference: FragmentReference<
+          ExtractReadFromStore<TEntrypoint>,
+          React.FC<TProps>
+        >;
+        additionalProps: TProps;
+      },
+): React.ReactNode {
   const Component = useResult(props.queryReference);
   return <Component {...props.additionalProps} />;
 }

package/src/IsographEnvironment.tsx

@@ -113,3 +113,16 @@ export function defaultMissingFieldHandler(
     }
   }
 }
+
+export function assertLink(link: DataTypeValue): Link | null {
+  if (Array.isArray(link)) {
+    throw new Error('Unexpected array');
+  }
+  if (link == null) {
+    return null;
+  }
+  if (typeof link === 'object') {
+    return link;
+  }
+  throw new Error('Invalid link');
+}

package/src/cache.tsx

@@ -4,17 +4,6 @@ import {
   ParentCache,
 } from '@isograph/react-disposable-state';
 import { PromiseWrapper, wrapPromise } from './PromiseWrapper';
-import {
-  Argument,
-  ArgumentValue,
-  IsographEntrypoint,
-  NormalizationAst,
-  NormalizationLinkedField,
-  NormalizationScalarField,
-  ReaderLinkedField,
-  ReaderScalarField,
-  RefetchQueryArtifactWrapper,
-} from './index';
 import {
   DataId,
   ROOT_ID,
@@ -28,6 +17,15 @@ import {
   retainQuery,
   unretainQuery,
 } from './garbageCollection';
+import {
+  IsographEntrypoint,
+  NormalizationAst,
+  NormalizationLinkedField,
+  NormalizationScalarField,
+  RefetchQueryArtifactWrapper,
+} from './entrypoint';
+import { ReaderLinkedField, ReaderScalarField } from './reader';
+import { Argument, ArgumentValue } from './util';
 
 declare global {
   interface Window {

package/src/componentCache.ts

@@ -1,10 +1,8 @@
-import {
-  ReaderArtifact,
-  RefetchQueryArtifactWrapper,
-  readButDoNotEvaluate,
-} from './index';
 import { stableCopy } from './cache';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
 import { IsographEnvironment, DataId } from './IsographEnvironment';
+import { readButDoNotEvaluate } from './read';
+import { ReaderArtifact } from './reader';
 
 export function getOrCreateCachedComponent(
   environment: IsographEnvironment,

package/src/entrypoint.ts

@@ -1,5 +1,5 @@
-import { Arguments } from './index';
 import { ReaderArtifact } from './reader';
+import { Arguments } from './util';
 
 // This type should be treated as an opaque type.
 export type IsographEntrypoint<
@@ -57,3 +57,8 @@ export function assertIsEntrypoint<
 ): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult> {
   if (typeof value === 'function') throw new Error('Not a string');
 }
+
+export type ExtractReadFromStore<Type> =
+  Type extends IsographEntrypoint<infer X, any> ? X : never;
+export type ExtractResolverResult<Type> =
+  Type extends IsographEntrypoint<any, infer X> ? X : never;

package/src/garbageCollection.ts

@@ -4,9 +4,10 @@ import {
   IsographStore,
   ROOT_ID,
   StoreRecord,
+  assertLink,
 } from './IsographEnvironment';
-import { NormalizationAst, assertLink } from './index';
 import { getParentRecordKey } from './cache';
+import { NormalizationAst } from './entrypoint';
 
 export type RetainedQuery = {
   normalizationAst: NormalizationAst;

package/src/index.tsx

@@ -1,11 +1,3 @@
-import { getOrCreateCacheForArtifact } from './cache';
-import { useLazyDisposableState } from '@isograph/react-disposable-state';
-import { type PromiseWrapper } from './PromiseWrapper';
-import { DataTypeValue, Link, ROOT_ID } from './IsographEnvironment';
-import { useIsographEnvironment } from './IsographEnvironmentProvider';
-import { IsographEntrypoint, assertIsEntrypoint } from './entrypoint';
-import { FragmentReference, Variable } from './FragmentReference';
-
 export {
   retainQuery,
   unretainQuery,
@@ -58,83 +50,11 @@ export {
 export { read, readButDoNotEvaluate } from './read';
 export { useResult } from './useResult';
 export { type FragmentReference } from './FragmentReference';
-
-export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> =
-  T extends (arg1: any, arg2: infer P) => any ? P : never;
-
-export type Arguments = Argument[];
-export type Argument = [ArgumentName, ArgumentValue];
-export type ArgumentName = string;
-export type ArgumentValue =
-  | {
-      kind: 'Variable';
-      name: string;
-    }
-  | {
-      kind: 'Literal';
-      value: any;
-    };
-
-export type ExtractReadFromStore<Type> =
-  Type extends IsographEntrypoint<infer X, any> ? X : never;
-export type ExtractResolverResult<Type> =
-  Type extends IsographEntrypoint<any, infer X> ? X : never;
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
-export function useLazyReference<TEntrypoint>(
-  entrypoint:
-    | TEntrypoint
-    // Temporarily, we need to allow useLazyReference to take the result of calling
-    // iso(`...`). At runtime, we confirm that the passed-in `iso` literal is actually
-    // an entrypoint.
-    | ((_: any) => any),
-  variables: { [key: string]: Variable },
-): {
-  queryReference: FragmentReference<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >;
-} {
-  const environment = useIsographEnvironment();
-  assertIsEntrypoint<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >(entrypoint);
-  const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
-    environment,
-    entrypoint,
-    variables,
-  );
-
-  // TODO add comment explaining why we never use this value
-  // @ts-ignore
-  const data =
-    useLazyDisposableState<PromiseWrapper<ExtractResolverResult<TEntrypoint>>>(
-      cache,
-    ).state;
-
-  return {
-    queryReference: {
-      kind: 'FragmentReference',
-      readerArtifact: entrypoint.readerArtifact,
-      root: ROOT_ID,
-      variables,
-      nestedRefetchQueries: entrypoint.nestedRefetchQueries,
-    },
-  };
-}
-
-export function assertLink(link: DataTypeValue): Link | null {
-  if (Array.isArray(link)) {
-    throw new Error('Unexpected array');
-  }
-  if (link == null) {
-    return null;
-  }
-  if (typeof link === 'object') {
-    return link;
-  }
-  throw new Error('Invalid link');
-}
+export { useLazyReference } from './useLazyReference';
+export {
+  ExtractSecondParam,
+  Argument,
+  ArgumentName,
+  ArgumentValue,
+  Arguments,
+} from './util';

package/src/read.ts

@@ -1,12 +1,14 @@
 import { getParentRecordKey, onNextChange } from './cache';
 import { getOrCreateCachedComponent } from './componentCache';
 import { RefetchQueryArtifactWrapper } from './entrypoint';
-import { assertLink, FragmentReference, ReaderAst } from './index';
+import { FragmentReference } from './FragmentReference';
 import {
+  assertLink,
   DataId,
   defaultMissingFieldHandler,
   IsographEnvironment,
 } from './IsographEnvironment';
+import { ReaderAst } from './reader';
 
 export function read<TReadFromStore extends Object, TResolverResult>(
   environment: IsographEnvironment,

package/src/reader.ts

@@ -1,6 +1,6 @@
 // TODO this should probably be at least three distinct types, for @component,
 
-import { Arguments } from './index';
+import { Arguments } from './util';
 
 // non-@component and refetch resolvers
 export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {

package/src/useImperativeReference.ts

@@ -3,14 +3,14 @@ import {
   useUpdatableDisposableState,
 } from '@isograph/react-disposable-state';
 import {
-  type IsographEntrypoint,
-  type FragmentReference,
   ExtractReadFromStore,
   ExtractResolverResult,
-  ROOT_ID,
-  useIsographEnvironment,
-  makeNetworkRequest,
-} from './index';
+  IsographEntrypoint,
+} from './entrypoint';
+import { FragmentReference } from './FragmentReference';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { makeNetworkRequest } from './cache';
+import { ROOT_ID } from './IsographEnvironment';
 
 export function useImperativeReference<
   TEntrypoint extends IsographEntrypoint<any, any>,

package/src/useLazyReference.ts

@@ -0,0 +1,58 @@
+import { FragmentReference, Variable } from './FragmentReference';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import { ROOT_ID } from './IsographEnvironment';
+import {
+  ExtractReadFromStore,
+  ExtractResolverResult,
+  assertIsEntrypoint,
+} from './entrypoint';
+import { getOrCreateCacheForArtifact } from './cache';
+import { useLazyDisposableState } from '@isograph/isograph-react-disposable-state';
+import { type PromiseWrapper } from './PromiseWrapper';
+
+// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
+// if we do not explicitly pass a type, the read out type will be any.
+// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
+// any actual Entrypoint we pass will not be valid.
+export function useLazyReference<TEntrypoint>(
+  entrypoint:
+    | TEntrypoint
+    // Temporarily, we need to allow useLazyReference to take the result of calling
+    // iso(`...`). At runtime, we confirm that the passed-in `iso` literal is actually
+    // an entrypoint.
+    | ((_: any) => any),
+  variables: { [key: string]: Variable },
+): {
+  queryReference: FragmentReference<
+    ExtractReadFromStore<TEntrypoint>,
+    ExtractResolverResult<TEntrypoint>
+  >;
+} {
+  const environment = useIsographEnvironment();
+  assertIsEntrypoint<
+    ExtractReadFromStore<TEntrypoint>,
+    ExtractResolverResult<TEntrypoint>
+  >(entrypoint);
+  const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
+    environment,
+    entrypoint,
+    variables,
+  );
+
+  // TODO add comment explaining why we never use this value
+  // @ts-ignore
+  const data =
+    useLazyDisposableState<PromiseWrapper<ExtractResolverResult<TEntrypoint>>>(
+      cache,
+    ).state;
+
+  return {
+    queryReference: {
+      kind: 'FragmentReference',
+      readerArtifact: entrypoint.readerArtifact,
+      root: ROOT_ID,
+      variables,
+      nestedRefetchQueries: entrypoint.nestedRefetchQueries,
+    },
+  };
+}

package/src/useResult.ts

@@ -1,8 +1,8 @@
 import { useEffect, useState } from 'react';
-import { FragmentReference } from './index';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 import { subscribe } from './cache';
 import { read } from './read';
+import { FragmentReference } from './FragmentReference';
 
 export function useResult<TReadFromStore extends Object, TResolverResult>(
   fragmentReference: FragmentReference<TReadFromStore, TResolverResult>,

package/src/util.ts

@@ -0,0 +1,15 @@
+export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> =
+  T extends (arg1: any, arg2: infer P) => any ? P : never;
+
+export type Arguments = Argument[];
+export type Argument = [ArgumentName, ArgumentValue];
+export type ArgumentName = string;
+export type ArgumentValue =
+  | {
+      kind: 'Variable';
+      name: string;
+    }
+  | {
+      kind: 'Literal';
+      value: any;
+    };