@isograph/react 0.0.0-main-90264a00 → 0.0.0-main-2fbc0faf

package/dist/EntrypointReader.d.ts

@@ -1,5 +1,6 @@
 import * as React from 'react';
-import { ExtractReadFromStore, IsographEntrypoint, type FragmentReference } from './index';
+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: {
     queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, React.FC<TProps>>;
     additionalProps: TProps;

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/FragmentReference.d.ts

@@ -0,0 +1,13 @@
+import { DataId } from './IsographEnvironment';
+import { RefetchQueryArtifactWrapper } from './entrypoint';
+import { ReaderArtifact } from './reader';
+export type Variable = any;
+export type FragmentReference<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'FragmentReference';
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+    root: DataId;
+    variables: {
+        [index: string]: Variable;
+    } | null;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};

package/dist/FragmentReference.js

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

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 { DataId, DataTypeValue, IsographEnvironment, Link } from './IsographEnvironment';
-import { ReaderArtifact } from './reader';
-import { IsographEntrypoint, RefetchQueryArtifactWrapper } from './entrypoint';
 export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './garbageCollection';
 export { type PromiseWrapper } from './PromiseWrapper';
 export { makeNetworkRequest, subscribe } from './cache';
@@ -10,38 +7,8 @@ export { useImperativeReference } from './useImperativeReference';
 export { EntrypointReader } from './EntrypointReader';
 export { type ReaderArtifact, ReaderAst, ReaderAstNode, ReaderLinkedField, ReaderMutationField, ReaderRefetchField, ReaderResolverField, ReaderResolverVariant, ReaderScalarField, } from './reader';
 export { NormalizationAst, NormalizationAstNode, NormalizationLinkedField, NormalizationScalarField, IsographEntrypoint, assertIsEntrypoint, RefetchQueryArtifact, RefetchQueryArtifactWrapper, } from './entrypoint';
-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;
-};
-type Variable = any;
-export type FragmentReference<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'FragmentReference';
-    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-    root: DataId;
-    variables: {
-        [index: string]: Variable;
-    } | null;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-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 useResult<TReadFromStore extends Object, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverResult>): TResolverResult;
-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;
-export declare function assertLink(link: DataTypeValue): Link | null;
-export type IsographComponentProps<TDataType, TOtherProps = Object> = {
-    data: TDataType;
-} & TOtherProps;
+export { read, readButDoNotEvaluate } from './read';
+export { useResult } from './useResult';
+export { type FragmentReference } from './FragmentReference';
+export { useLazyReference } from './useLazyReference';
+export { ExtractSecondParam, Argument, ArgumentName, ArgumentValue, Arguments, } from './util';

package/dist/index.js

@@ -1,304 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertLink = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = 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 componentCache_1 = require("./componentCache");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-const react_1 = require("react");
-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; } });
-// 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 useResult(fragmentReference) {
-    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const [, setState] = (0, react_1.useState)();
-    (0, react_1.useEffect)(() => {
-        return (0, cache_1.subscribe)(environment, () => {
-            return setState({});
-        });
-    }, []);
-    return read(environment, fragmentReference);
-}
-exports.useResult = useResult;
-function read(environment, fragmentReference) {
-    var _a, _b;
-    const variant = fragmentReference.readerArtifact.variant;
-    if (variant.kind === 'Eager') {
-        const data = readData(environment, fragmentReference.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, fragmentReference.nestedRefetchQueries);
-        if (data.kind === 'MissingData') {
-            throw (0, cache_1.onNextChange)(environment);
-        }
-        else {
-            // @ts-expect-error This not properly typed yet
-            return fragmentReference.readerArtifact.resolver(data.data);
-        }
-    }
-    else if (variant.kind === 'Component') {
-        // @ts-ignore
-        return (0, componentCache_1.getOrCreateCachedComponent)(environment, fragmentReference.root, variant.componentName, fragmentReference.readerArtifact, (_b = fragmentReference.variables) !== null && _b !== void 0 ? _b : {}, fragmentReference.nestedRefetchQueries);
-    }
-    // Why can't Typescript realize that this is unreachable??
-    throw new Error('This is unreachable');
-}
-exports.read = read;
-function readButDoNotEvaluate(environment, reference) {
-    var _a;
-    const response = readData(environment, reference.readerArtifact.readerAst, reference.root, (_a = reference.variables) !== null && _a !== void 0 ? _a : {}, reference.nestedRefetchQueries);
-    if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('done reading', { response });
-    }
-    if (response.kind === 'MissingData') {
-        throw (0, cache_1.onNextChange)(environment);
-    }
-    else {
-        return response.data;
-    }
-}
-exports.readButDoNotEvaluate = readButDoNotEvaluate;
-function readData(environment, ast, root, variables, nestedRefetchQueries) {
-    var _a, _b, _c, _d, _e;
-    let storeRecord = environment.store[root];
-    if (storeRecord === undefined) {
-        return { kind: 'MissingData', reason: 'No record for root ' + root };
-    }
-    if (storeRecord === null) {
-        return { kind: 'Success', data: null };
-    }
-    let target = {};
-    for (const field of ast) {
-        switch (field.kind) {
-            case 'Scalar': {
-                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-                const value = storeRecord[storeRecordName];
-                // TODO consider making scalars into discriminated unions. This probably has
-                // to happen for when we handle errors.
-                if (value === undefined) {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'No value for ' + storeRecordName + ' on root ' + root,
-                    };
-                }
-                target[(_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName] = value;
-                break;
-            }
-            case 'Linked': {
-                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
-                const value = storeRecord[storeRecordName];
-                if (Array.isArray(value)) {
-                    const results = [];
-                    for (const item of value) {
-                        const link = assertLink(item);
-                        if (link === undefined) {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'No link for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                            };
-                        }
-                        else if (link === null) {
-                            results.push(null);
-                            continue;
-                        }
-                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries);
-                        if (result.kind === 'MissingData') {
-                            return {
-                                kind: 'MissingData',
-                                reason: 'Missing data for ' +
-                                    storeRecordName +
-                                    ' on root ' +
-                                    root +
-                                    '. Link is ' +
-                                    JSON.stringify(item),
-                                nestedReason: result,
-                            };
-                        }
-                        results.push(result.data);
-                    }
-                    target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = results;
-                    break;
-                }
-                let link = 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;
-                    const altLink = missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
-                    if (altLink === undefined) {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'No link for ' +
-                                storeRecordName +
-                                ' on root ' +
-                                root +
-                                '. Link is ' +
-                                JSON.stringify(value),
-                        };
-                    }
-                    else {
-                        link = altLink;
-                    }
-                }
-                else if (link === null) {
-                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
-                    break;
-                }
-                const targetId = link.__link;
-                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries);
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + storeRecordName + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
-                break;
-            }
-            case 'RefetchField': {
-                const data = readData(environment, field.readerArtifact.readerAst, root, variables, 
-                // Refetch fields just read the id, and don't need refetch query artifacts
-                []);
-                if (typeof window !== 'undefined' && window.__LOG) {
-                    console.log('refetch field data', data, field);
-                }
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                else {
-                    const refetchQueryIndex = field.refetchQuery;
-                    if (refetchQueryIndex == null) {
-                        throw new Error('refetchQuery is null in RefetchField');
-                    }
-                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-                    const refetchQueryArtifact = refetchQuery.artifact;
-                    const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(environment, 
-                    // resolvers for refetch fields take 3 args, and this is not reflected in types
-                    refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
-                }
-                break;
-            }
-            case 'MutationField': {
-                const data = readData(environment, field.readerArtifact.readerAst, root, variables, 
-                // Refetch fields just read the id, and don't need refetch query artifacts
-                []);
-                if (typeof window !== 'undefined' && window.__LOG) {
-                    console.log('refetch field data', data, field);
-                }
-                if (data.kind === 'MissingData') {
-                    return {
-                        kind: 'MissingData',
-                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                        nestedReason: data,
-                    };
-                }
-                else {
-                    const refetchQueryIndex = field.refetchQuery;
-                    if (refetchQueryIndex == null) {
-                        throw new Error('refetchQuery is null in MutationField');
-                    }
-                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
-                    const refetchQueryArtifact = refetchQuery.artifact;
-                    const allowedVariables = refetchQuery.allowedVariables;
-                    target[field.alias] = field.readerArtifact.resolver(environment, refetchQueryArtifact, 
-                    // @ts-expect-error
-                    data.data, filterVariables(variables, allowedVariables));
-                }
-                break;
-            }
-            case 'Resolver': {
-                const usedRefetchQueries = field.usedRefetchQueries;
-                const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
-                const variant = field.readerArtifact.variant;
-                if (variant.kind === 'Eager') {
-                    const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
-                    if (data.kind === 'MissingData') {
-                        return {
-                            kind: 'MissingData',
-                            reason: 'Missing data for ' + field.alias + ' on root ' + root,
-                            nestedReason: data,
-                        };
-                    }
-                    else {
-                        // @ts-expect-error
-                        target[field.alias] = field.readerArtifact.resolver(data.data);
-                    }
-                }
-                else if (variant.kind === 'Component') {
-                    target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, root, variant.componentName, field.readerArtifact, variables, resolverRefetchQueries);
-                }
-                break;
-            }
-        }
-    }
-    return { kind: 'Success', data: target };
-}
-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;
-function filterVariables(variables, allowedVariables) {
-    const result = {};
-    for (const key of allowedVariables) {
-        result[key] = variables[key];
-    }
-    return result;
-}
+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; } });
+var useLazyReference_1 = require("./useLazyReference");
+Object.defineProperty(exports, "useLazyReference", { enumerable: true, get: function () { return useLazyReference_1.useLazyReference; } });

package/dist/read.d.ts

@@ -0,0 +1,4 @@
+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;