@isograph/react 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -1,120 +1,21 @@
-import { DataId, IsographEnvironment, Link, StoreRecord } from './IsographEnvironment';
-export { type PromiseWrapper } from './PromiseWrapper';
-export { makeNetworkRequest, subscribe } from './cache';
-export { IsographEnvironmentContext, ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, IsographEnvironmentProvider, type IsographEnvironmentProviderProps, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, useIsographEnvironment, createIsographEnvironment, createIsographStore, } from './IsographEnvironment';
-export { useImperativeReference } from './useImperativeReference';
-export { EntrypointReader } from './EntrypointReader';
-export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'Entrypoint';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
-    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
-};
-export type ReaderArtifact<TReadFromStore extends Object, TResolverResult> = {
-    kind: 'ReaderArtifact';
-    readerAst: ReaderAst<TReadFromStore>;
-    resolver: (data: TReadFromStore, runtimeProps: any) => TResolverResult;
-    variant: ReaderResolverVariant;
-};
-export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
-export type ReaderAst<TReadFromStore> = ReaderAstNode[];
-export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
-export type ReaderScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    alias: string | null;
-    arguments: Arguments | null;
-};
-export type ReaderLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    alias: string | null;
-    selections: ReaderAst<unknown>;
-    arguments: Arguments | null;
-};
-export type ReaderResolverVariant = {
-    kind: 'Eager';
-} | {
-    kind: 'Component';
-    componentName: string;
-};
-export type ReaderResolverField = {
-    kind: 'Resolver';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    arguments: Arguments | null;
-    usedRefetchQueries: number[];
-};
-export type ReaderRefetchField = {
-    kind: 'RefetchField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type ReaderMutationField = {
-    kind: 'MutationField';
-    alias: string;
-    readerArtifact: ReaderArtifact<any, any>;
-    refetchQuery: number;
-};
-export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
-export type NormalizationAst = NormalizationAstNode[];
-export type NormalizationScalarField = {
-    kind: 'Scalar';
-    fieldName: string;
-    arguments: Arguments | null;
-};
-export type NormalizationLinkedField = {
-    kind: 'Linked';
-    fieldName: string;
-    arguments: Arguments | null;
-    selections: NormalizationAst;
-};
-export type RefetchQueryArtifact = {
-    kind: 'RefetchQuery';
-    queryText: string;
-    normalizationAst: NormalizationAst;
-};
-export type RefetchQueryArtifactWrapper = {
-    artifact: RefetchQueryArtifact;
-    allowedVariables: string[];
-};
-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 defaultMissingFieldHandler(_storeRecord: StoreRecord, _root: DataId, fieldName: string, arguments_: {
-    [index: string]: any;
-} | null, variables: {
-    [index: string]: any;
-} | null): Link | undefined;
-export type IsographComponentProps<TDataType, TOtherProps = Object> = {
-    data: TDataType;
-} & TOtherProps;
+export { retainQuery, unretainQuery, type RetainedQuery, garbageCollectEnvironment, } from './core/garbageCollection';
+export { type PromiseWrapper, readPromise, getPromiseState, wrapResolvedValue, wrapPromise, } from './core/PromiseWrapper';
+export { subscribe, normalizeData } from './core/cache';
+export { makeNetworkRequest } from './core/makeNetworkRequest';
+export { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, createIsographEnvironment, createIsographStore, defaultMissingFieldHandler, } from './core/IsographEnvironment';
+export { type EagerReaderArtifact, type ComponentReaderArtifact, type RefetchReaderArtifact, type ReaderAst, type ReaderAstNode, type ReaderLinkedField, type ReaderNonLoadableResolverField, type ReaderScalarField, type TopLevelReaderArtifact, type LoadableField, } from './core/reader';
+export { type NormalizationAst, type NormalizationAstNode, type NormalizationLinkedField, type NormalizationScalarField, type IsographEntrypoint, assertIsEntrypoint, type RefetchQueryNormalizationArtifact, type RefetchQueryNormalizationArtifactWrapper, type ExtractProps, type ExtractReadFromStore, type ExtractResolverResult, } from './core/entrypoint';
+export { readButDoNotEvaluate } from './core/read';
+export { type ExtractSecondParam, type Argument, type ArgumentName, type ArgumentValue, type Arguments, } from './core/util';
+export { type FragmentReference, type Variables, stableIdForFragmentReference, } from './core/FragmentReference';
+export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './react/IsographEnvironmentProvider';
+export { useImperativeReference } from './react/useImperativeReference';
+export { FragmentReader } from './react/FragmentReader';
+export { useResult } from './react/useResult';
+export { useReadAndSubscribe, useSubscribeToMultiple, } from './react/useReadAndSubscribe';
+export { useLazyReference } from './react/useLazyReference';
+export { useRerenderOnChange } from './react/useRerenderOnChange';
+export { useClientSideDefer } from './loadable-hooks/useClientSideDefer';
+export { useImperativeExposedMutationField } from './loadable-hooks/useImperativeExposedMutationField';
+export { useSkipLimitPagination } from './loadable-hooks/useSkipLimitPagination';
+export { useImperativeLoadableField } from './loadable-hooks/useImperativeLoadableField';

package/dist/index.js

@@ -1,309 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.EntrypointReader = exports.useImperativeReference = exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = exports.subscribe = exports.makeNetworkRequest = 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");
-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, "IsographEnvironmentContext", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentContext; } });
-Object.defineProperty(exports, "ROOT_ID", { enumerable: true, get: function () { return IsographEnvironment_2.ROOT_ID; } });
-Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironment_2.IsographEnvironmentProvider; } });
-Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.useIsographEnvironment; } });
-Object.defineProperty(exports, "createIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographEnvironment; } });
-Object.defineProperty(exports, "createIsographStore", { enumerable: true, get: function () { return IsographEnvironment_2.createIsographStore; } });
-var useImperativeReference_1 = require("./useImperativeReference");
+exports.useImperativeLoadableField = exports.useSkipLimitPagination = exports.useImperativeExposedMutationField = exports.useClientSideDefer = exports.useRerenderOnChange = exports.useLazyReference = exports.useSubscribeToMultiple = exports.useReadAndSubscribe = exports.useResult = exports.FragmentReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.stableIdForFragmentReference = exports.readButDoNotEvaluate = exports.assertIsEntrypoint = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.makeNetworkRequest = exports.normalizeData = exports.subscribe = exports.wrapPromise = exports.wrapResolvedValue = exports.getPromiseState = exports.readPromise = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
+var garbageCollection_1 = require("./core/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 PromiseWrapper_1 = require("./core/PromiseWrapper");
+Object.defineProperty(exports, "readPromise", { enumerable: true, get: function () { return PromiseWrapper_1.readPromise; } });
+Object.defineProperty(exports, "getPromiseState", { enumerable: true, get: function () { return PromiseWrapper_1.getPromiseState; } });
+Object.defineProperty(exports, "wrapResolvedValue", { enumerable: true, get: function () { return PromiseWrapper_1.wrapResolvedValue; } });
+Object.defineProperty(exports, "wrapPromise", { enumerable: true, get: function () { return PromiseWrapper_1.wrapPromise; } });
+var cache_1 = require("./core/cache");
+Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_1.subscribe; } });
+Object.defineProperty(exports, "normalizeData", { enumerable: true, get: function () { return cache_1.normalizeData; } });
+var makeNetworkRequest_1 = require("./core/makeNetworkRequest");
+Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return makeNetworkRequest_1.makeNetworkRequest; } });
+var IsographEnvironment_1 = require("./core/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 entrypoint_1 = require("./core/entrypoint");
+Object.defineProperty(exports, "assertIsEntrypoint", { enumerable: true, get: function () { return entrypoint_1.assertIsEntrypoint; } });
+var read_1 = require("./core/read");
+Object.defineProperty(exports, "readButDoNotEvaluate", { enumerable: true, get: function () { return read_1.readButDoNotEvaluate; } });
+var FragmentReference_1 = require("./core/FragmentReference");
+Object.defineProperty(exports, "stableIdForFragmentReference", { enumerable: true, get: function () { return FragmentReference_1.stableIdForFragmentReference; } });
+var IsographEnvironmentProvider_1 = require("./react/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("./react/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; } });
-function assertIsEntrypoint(value) {
-    if (typeof value === 'function')
-        throw new Error('Not a string');
-}
-// 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, IsographEnvironment_1.useIsographEnvironment)();
-    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, IsographEnvironment_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 : 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 defaultMissingFieldHandler(_storeRecord, _root, fieldName, arguments_, variables) {
-    if (fieldName === 'node' || fieldName === 'user') {
-        const variable = arguments_ === null || arguments_ === void 0 ? void 0 : arguments_['id'];
-        const value = variables === null || variables === void 0 ? void 0 : variables[variable];
-        // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
-        if (value != null) {
-            return { __link: value };
-        }
-    }
-}
-exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
-function assertLink(link) {
-    if (Array.isArray(link)) {
-        throw new Error('Unexpected array');
-    }
-    if (typeof link === 'object') {
-        return link;
-    }
-    if (link === undefined) {
-        return undefined;
-    }
-    throw new Error('Invalid link');
-}
-function filterVariables(variables, allowedVariables) {
-    const result = {};
-    for (const key of allowedVariables) {
-        result[key] = variables[key];
-    }
-    return result;
-}
+var FragmentReader_1 = require("./react/FragmentReader");
+Object.defineProperty(exports, "FragmentReader", { enumerable: true, get: function () { return FragmentReader_1.FragmentReader; } });
+var useResult_1 = require("./react/useResult");
+Object.defineProperty(exports, "useResult", { enumerable: true, get: function () { return useResult_1.useResult; } });
+var useReadAndSubscribe_1 = require("./react/useReadAndSubscribe");
+Object.defineProperty(exports, "useReadAndSubscribe", { enumerable: true, get: function () { return useReadAndSubscribe_1.useReadAndSubscribe; } });
+Object.defineProperty(exports, "useSubscribeToMultiple", { enumerable: true, get: function () { return useReadAndSubscribe_1.useSubscribeToMultiple; } });
+var useLazyReference_1 = require("./react/useLazyReference");
+Object.defineProperty(exports, "useLazyReference", { enumerable: true, get: function () { return useLazyReference_1.useLazyReference; } });
+var useRerenderOnChange_1 = require("./react/useRerenderOnChange");
+Object.defineProperty(exports, "useRerenderOnChange", { enumerable: true, get: function () { return useRerenderOnChange_1.useRerenderOnChange; } });
+var useClientSideDefer_1 = require("./loadable-hooks/useClientSideDefer");
+Object.defineProperty(exports, "useClientSideDefer", { enumerable: true, get: function () { return useClientSideDefer_1.useClientSideDefer; } });
+var useImperativeExposedMutationField_1 = require("./loadable-hooks/useImperativeExposedMutationField");
+Object.defineProperty(exports, "useImperativeExposedMutationField", { enumerable: true, get: function () { return useImperativeExposedMutationField_1.useImperativeExposedMutationField; } });
+var useSkipLimitPagination_1 = require("./loadable-hooks/useSkipLimitPagination");
+Object.defineProperty(exports, "useSkipLimitPagination", { enumerable: true, get: function () { return useSkipLimitPagination_1.useSkipLimitPagination; } });
+var useImperativeLoadableField_1 = require("./loadable-hooks/useImperativeLoadableField");
+Object.defineProperty(exports, "useImperativeLoadableField", { enumerable: true, get: function () { return useImperativeLoadableField_1.useImperativeLoadableField; } });

package/dist/loadable-hooks/useClientSideDefer.d.ts

@@ -0,0 +1,4 @@
+import { FragmentReference } from '../core/FragmentReference';
+import { LoadableField } from '../core/reader';
+export declare function useClientSideDefer<TResult>(loadableField: LoadableField<void, TResult>): FragmentReference<Record<string, never>, TResult>;
+export declare function useClientSideDefer<TArgs extends Object, TResult>(loadableField: LoadableField<TArgs, TResult>, args: TArgs): FragmentReference<TArgs, TResult>;

package/dist/loadable-hooks/useClientSideDefer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useClientSideDefer = void 0;
+const IsographEnvironmentProvider_1 = require("../react/IsographEnvironmentProvider");
+const cache_1 = require("../core/cache");
+const react_disposable_state_1 = require("@isograph/react-disposable-state");
+function useClientSideDefer(loadableField, args) {
+    // @ts-expect-error args is missing iff it has the type void
+    const [id, loader] = loadableField(args);
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
+    const cache = (0, cache_1.getOrCreateItemInSuspenseCache)(environment, id, loader);
+    const fragmentReference = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
+    return fragmentReference;
+}
+exports.useClientSideDefer = useClientSideDefer;

package/dist/loadable-hooks/useImperativeExposedMutationField.d.ts

@@ -0,0 +1,5 @@
+type UseImperativeLoadableFieldReturn<TArgs> = {
+    loadField: (args: TArgs) => void;
+};
+export declare function useImperativeExposedMutationField<TArgs>(exposedField: (args: TArgs) => [string, () => void]): UseImperativeLoadableFieldReturn<TArgs>;
+export {};

package/dist/loadable-hooks/useImperativeExposedMutationField.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useImperativeExposedMutationField = void 0;
+// Note: this function doesn't seem to work if there are additional arguments,
+// e.g. with set_pet_tagline. Why? This seems to straightforwardly call
+// exposedField(args)[1](); Odd.
+function useImperativeExposedMutationField(exposedField) {
+    return {
+        loadField: (args) => {
+            const [_id, loader] = exposedField(args);
+            loader();
+        },
+    };
+}
+exports.useImperativeExposedMutationField = useImperativeExposedMutationField;

package/dist/loadable-hooks/useImperativeLoadableField.d.ts

@@ -0,0 +1,9 @@
+import { FragmentReference } from '../core/FragmentReference';
+import { UnassignedState } from '@isograph/react-disposable-state';
+import { LoadableField } from '../core/reader';
+type UseImperativeLoadableFieldReturn<TArgs, TResult> = {
+    fragmentReference: FragmentReference<any, TResult> | UnassignedState;
+    loadField: (args: TArgs) => void;
+};
+export declare function useImperativeLoadableField<TArgs, TResult>(loadableField: LoadableField<TArgs, TResult>): UseImperativeLoadableFieldReturn<TArgs, TResult>;
+export {};

package/dist/loadable-hooks/useImperativeLoadableField.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useImperativeLoadableField = void 0;
+const react_disposable_state_1 = require("@isograph/react-disposable-state");
+function useImperativeLoadableField(loadableField) {
+    const { state, setState } = (0, react_disposable_state_1.useUpdatableDisposableState)();
+    return {
+        loadField: (args) => {
+            const [_id, loader] = loadableField(args);
+            setState(loader());
+        },
+        fragmentReference: state,
+    };
+}
+exports.useImperativeLoadableField = useImperativeLoadableField;

package/dist/loadable-hooks/useSkipLimitPagination.d.ts

@@ -0,0 +1,33 @@
+import { LoadableField } from '../core/reader';
+import { FragmentReference } from '../core/FragmentReference';
+type SkipOrLimit = 'skip' | 'limit';
+type OmitSkipLimit<TArgs> = keyof Omit<TArgs, SkipOrLimit> extends never ? void | Record<string, never> : Omit<TArgs, SkipOrLimit>;
+type UseSkipLimitReturnValue<TArgs, TItem> = {
+    readonly kind: 'Complete';
+    readonly fetchMore: (args: OmitSkipLimit<TArgs>, count: number) => void;
+    readonly results: ReadonlyArray<TItem>;
+} | {
+    readonly kind: 'Pending';
+    readonly results: ReadonlyArray<TItem>;
+    readonly pendingFragment: FragmentReference<any, ReadonlyArray<TItem>>;
+};
+/**
+ * accepts a loadableField that accepts skip and limit arguments
+ * and returns:
+ * - a fetchMore function that, when called, triggers a network
+ *   request for additional data, and
+ * - the data received so far.
+ *
+ * This hook will suspend if any network request is in flight.
+ *
+ * Calling fetchMore before the hook mounts is a no-op.
+ *
+ * NOTE: this hook does not subscribe to changes. This is a known
+ * issue. If you are running into this issue, reach out on GitHub/
+ * Twitter, and we'll fix the issue.
+ */
+export declare function useSkipLimitPagination<TArgs extends {
+    skip: number | void | null;
+    limit: number | void | null;
+}, TItem>(loadableField: LoadableField<TArgs, Array<TItem>>): UseSkipLimitReturnValue<TArgs, TItem>;
+export {};