@isograph/react 0.0.0-main-945e49cc → 0.0.0-main-1bfd646b

package/dist/IsographEnvironment.d.ts

@@ -1,7 +1,6 @@
-import { ReactNode } from 'react';
-import * as React from 'react';
+/// <reference types="react" />
 import { ParentCache } from '@isograph/isograph-react-disposable-state';
-export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+import { RetainedQuery } from './garbageCollection';
 type ComponentName = string;
 type StringifiedArgs = string;
 type ComponentCache = {
@@ -22,6 +21,9 @@ export type IsographEnvironment = {
     componentCache: ComponentCache;
     subscriptions: Subscriptions;
     suspenseCache: SuspenseCache;
+    retainedQueries: Set<RetainedQuery>;
+    gcBuffer: Array<RetainedQuery>;
+    gcBufferSize: number;
 };
 export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
     [index: string]: any;
@@ -43,12 +45,6 @@ export type IsographStore = {
     [index: DataId]: StoreRecord | null;
     __ROOT: StoreRecord;
 };
-export type IsographEnvironmentProviderProps = {
-    environment: IsographEnvironment;
-    children: ReactNode;
-};
-export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
-export declare function useIsographEnvironment(): IsographEnvironment;
 export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
 export declare function createIsographStore(): {
     __ROOT: {};

package/dist/IsographEnvironment.js

@@ -1,46 +1,8 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIsographStore = exports.createIsographEnvironment = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.ROOT_ID = exports.IsographEnvironmentContext = void 0;
-const react_1 = require("react");
-const React = __importStar(require("react"));
-exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = void 0;
 exports.ROOT_ID = '__ROOT';
-function IsographEnvironmentProvider({ environment, children, }) {
-    return (React.createElement(exports.IsographEnvironmentContext.Provider, { value: environment }, children));
-}
-exports.IsographEnvironmentProvider = IsographEnvironmentProvider;
-function useIsographEnvironment() {
-    const context = (0, react_1.useContext)(exports.IsographEnvironmentContext);
-    if (context == null) {
-        throw new Error('Unexpected null environment context. Make sure to render ' +
-            'this component within an IsographEnvironmentProvider component');
-    }
-    return context;
-}
-exports.useIsographEnvironment = useIsographEnvironment;
+const DEFAULT_GC_BUFFER_SIZE = 10;
 function createIsographEnvironment(store, networkFunction, missingFieldHandler) {
     return {
         store,
@@ -49,6 +11,9 @@ function createIsographEnvironment(store, networkFunction, missingFieldHandler)
         componentCache: {},
         subscriptions: new Set(),
         suspenseCache: {},
+        retainedQueries: new Set(),
+        gcBuffer: [],
+        gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
     };
 }
 exports.createIsographEnvironment = createIsographEnvironment;

package/dist/IsographEnvironmentProvider.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { type IsographEnvironment } from './IsographEnvironment';
+export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
+export type IsographEnvironmentProviderProps = {
+    environment: IsographEnvironment;
+    children: ReactNode;
+};
+export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
+export declare function useIsographEnvironment(): IsographEnvironment;

package/dist/IsographEnvironmentProvider.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.IsographEnvironmentContext = void 0;
+const React = __importStar(require("react"));
+const react_1 = require("react");
+exports.IsographEnvironmentContext = (0, react_1.createContext)(null);
+function IsographEnvironmentProvider({ environment, children, }) {
+    return (React.createElement(exports.IsographEnvironmentContext.Provider, { value: environment }, children));
+}
+exports.IsographEnvironmentProvider = IsographEnvironmentProvider;
+function useIsographEnvironment() {
+    const context = (0, react_1.useContext)(exports.IsographEnvironmentContext);
+    if (context == null) {
+        throw new Error('Unexpected null environment context. Make sure to render ' +
+            'this component within an IsographEnvironmentProvider component');
+    }
+    return context;
+}
+exports.useIsographEnvironment = useIsographEnvironment;

package/dist/cache.js

@@ -4,6 +4,7 @@ exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const PromiseWrapper_1 = require("./PromiseWrapper");
 const IsographEnvironment_1 = require("./IsographEnvironment");
+const garbageCollection_1 = require("./garbageCollection");
 function getOrCreateCache(environment, index, factory) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('getting cache for', {
@@ -49,34 +50,60 @@ function makeNetworkRequest(environment, artifact, variables) {
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('make network request', artifact, variables);
     }
+    let status = {
+        kind: 'UndisposedIncomplete',
+    };
+    // This should be an observable, not a promise
     const promise = environment
         .networkFunction(artifact.queryText, variables)
         .then((networkResponse) => {
         if (typeof window !== 'undefined' && window.__LOG) {
             console.log('network response', artifact, artifact);
         }
-        normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
-        return networkResponse.data;
+        if (status.kind === 'UndisposedIncomplete') {
+            normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
+            const retainedQuery = {
+                normalizationAst: artifact.normalizationAst,
+                variables,
+            };
+            status = {
+                kind: 'UndisposedComplete',
+                retainedQuery,
+            };
+            (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
+        }
+        // TODO return null
+        return networkResponse;
     });
     const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
     const response = [
         wrapper,
         () => {
-            // delete from cache
+            if (status.kind === 'UndisposedComplete') {
+                const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
+                if (didUnretainSomeQuery) {
+                    (0, garbageCollection_1.garbageCollectEnvironment)(environment);
+                }
+            }
+            status = {
+                kind: 'Disposed',
+            };
         },
     ];
     return response;
 }
 exports.makeNetworkRequest = makeNetworkRequest;
 function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {
+    const encounteredIds = new Set();
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('about to normalize', normalizationAst, networkResponse, variables);
     }
-    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, environment.store.__ROOT, IsographEnvironment_1.ROOT_ID, variables, nestedRefetchQueries);
+    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, environment.store.__ROOT, IsographEnvironment_1.ROOT_ID, variables, nestedRefetchQueries, encounteredIds);
     if (typeof window !== 'undefined' && window.__LOG) {
         console.log('after normalization', { store: environment.store });
     }
     callSubscriptions(environment);
+    return encounteredIds;
 }
 function subscribe(environment, callback) {
     environment.subscriptions.add(callback);
@@ -98,7 +125,8 @@ function callSubscriptions(environment) {
 /**
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
  */
-function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    mutableEncounteredIds.add(targetParentRecordId);
     for (const normalizationNode of normalizationAst) {
         switch (normalizationNode.kind) {
             case 'Scalar': {
@@ -106,7 +134,7 @@ function normalizeDataIntoRecord(environment, normalizationAst, networkResponseP
                 break;
             }
             case 'Linked': {
-                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
+                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
                 break;
             }
         }
@@ -127,7 +155,7 @@ function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreR
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
-function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
     const parentRecordKey = getParentRecordKey(astNode, variables);
@@ -143,24 +171,24 @@ function normalizeLinkedField(environment, astNode, networkResponseParentRecord,
         const dataIds = [];
         for (let i = 0; i < networkResponseData.length; i++) {
             const networkResponseObject = networkResponseData[i];
-            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries);
+            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries, mutableEncounteredIds);
             dataIds.push({ __link: newStoreRecordId });
         }
         targetParentRecord[parentRecordKey] = dataIds;
     }
     else {
-        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
+        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries, mutableEncounteredIds);
         targetParentRecord[parentRecordKey] = {
             __link: newStoreRecordId,
         };
     }
 }
-function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
+function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries, mutableEncounteredIds) {
     var _a;
     const newStoreRecordId = getDataIdOfNetworkResponse(targetParentRecordId, networkResponseData, astNode, variables, index);
     const newStoreRecord = (_a = environment.store[newStoreRecordId]) !== null && _a !== void 0 ? _a : {};
     environment.store[newStoreRecordId] = newStoreRecord;
-    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries);
+    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
     return newStoreRecordId;
 }
 function isScalarOrEmptyArray(data) {

package/dist/entrypoint.d.ts

@@ -0,0 +1,32 @@
+import { Arguments } from './index';
+import { ReaderArtifact } from './reader';
+export type IsographEntrypoint<TReadFromStore extends Object, TResolverResult> = {
+    kind: 'Entrypoint';
+    queryText: string;
+    normalizationAst: NormalizationAst;
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverResult>;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+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 declare function assertIsEntrypoint<TReadFromStore extends Object, TResolverResult>(value: IsographEntrypoint<TReadFromStore, TResolverResult> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TResolverResult>;

package/dist/entrypoint.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsEntrypoint = void 0;
+function assertIsEntrypoint(value) {
+    if (typeof value === 'function')
+        throw new Error('Not a string');
+}
+exports.assertIsEntrypoint = assertIsEntrypoint;

package/dist/garbageCollection.d.ts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from './IsographEnvironment';
+import { NormalizationAst } from './index';
+export type RetainedQuery = {
+    normalizationAst: NormalizationAst;
+    variables: {};
+};
+type DidUnretainSomeQuery = boolean;
+export declare function unretainQuery(environment: IsographEnvironment, retainedQuery: RetainedQuery): DidUnretainSomeQuery;
+export declare function retainQuery(environment: IsographEnvironment, queryToRetain: RetainedQuery): void;
+export declare function garbageCollectEnvironment(environment: IsographEnvironment): void;
+export {};

package/dist/garbageCollection.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.garbageCollectEnvironment = exports.retainQuery = exports.unretainQuery = void 0;
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const cache_1 = require("./cache");
+function unretainQuery(environment, retainedQuery) {
+    environment.retainedQueries.delete(retainedQuery);
+    environment.gcBuffer.push(retainedQuery);
+    if (environment.gcBuffer.length > environment.gcBufferSize) {
+        environment.gcBuffer.shift();
+        return true;
+    }
+    return false;
+}
+exports.unretainQuery = unretainQuery;
+function retainQuery(environment, queryToRetain) {
+    environment.retainedQueries.add(queryToRetain);
+    // TODO can we remove this query from the buffer somehow?
+    // We are relying on === equality, but we really should be comparing
+    // id + variables
+}
+exports.retainQuery = retainQuery;
+function garbageCollectEnvironment(environment) {
+    const retainedIds = new Set([IsographEnvironment_1.ROOT_ID]);
+    for (const query of environment.retainedQueries) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const query of environment.gcBuffer) {
+        recordReachableIds(environment.store, query, retainedIds);
+    }
+    for (const dataId in environment.store) {
+        if (!retainedIds.has(dataId)) {
+            delete environment.store[dataId];
+        }
+    }
+}
+exports.garbageCollectEnvironment = garbageCollectEnvironment;
+function recordReachableIds(store, retainedQuery, mutableRetainedIds) {
+    recordReachableIdsFromRecord(store, store[IsographEnvironment_1.ROOT_ID], mutableRetainedIds, retainedQuery.normalizationAst, retainedQuery.variables);
+}
+function getLinkedId(data) {
+    // @ts-expect-error
+    if (data.__link != null) {
+        // @ts-expect-error
+        return data.__link;
+    }
+    else {
+        throw new Error('Record in an invalid state');
+    }
+}
+function recordReachableIdsFromRecord(store, currentRecord, mutableRetainedIds, selections, variables) {
+    for (const selection of selections) {
+        switch (selection.kind) {
+            case 'Linked':
+                const linkKey = (0, cache_1.getParentRecordKey)(selection, variables !== null && variables !== void 0 ? variables : {});
+                const linkedFieldOrFields = currentRecord[linkKey];
+                const ids = [];
+                if (Array.isArray(linkedFieldOrFields)) {
+                    for (const link of linkedFieldOrFields) {
+                        if (link != null) {
+                            const id = getLinkedId(link);
+                            ids.push(id);
+                        }
+                    }
+                }
+                else {
+                    if (linkedFieldOrFields != null) {
+                        const id = getLinkedId(linkedFieldOrFields);
+                        ids.push(id);
+                    }
+                }
+                for (const nextRecordId of ids) {
+                    const nextRecord = store[nextRecordId];
+                    if (nextRecord != null) {
+                        mutableRetainedIds.add(nextRecordId);
+                        recordReachableIdsFromRecord(store, nextRecord, mutableRetainedIds, selection.selections, variables);
+                    }
+                }
+                continue;
+            case 'Scalar':
+                continue;
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,85 +1,16 @@
 import { DataId, IsographEnvironment, Link, StoreRecord } 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';
-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 { ROOT_ID, type DataId, type DataTypeValue, type IsographEnvironment, type IsographNetworkFunction, type IsographStore, type Link, type StoreRecord, createIsographEnvironment, createIsographStore, } from './IsographEnvironment';
+export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './IsographEnvironmentProvider';
 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 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 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;

package/dist/index.js

@@ -1,36 +1,40 @@
 "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;
+exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useResult = exports.useLazyReference = exports.assertIsEntrypoint = exports.EntrypointReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = 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");
+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, "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 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 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; } });
-function assertIsEntrypoint(value) {
-    if (typeof value === 'function')
-        throw new Error('Not a string');
-}
+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, IsographEnvironment_1.useIsographEnvironment)();
-    assertIsEntrypoint(entrypoint);
+    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
@@ -47,7 +51,7 @@ function useLazyReference(entrypoint, variables) {
 }
 exports.useLazyReference = useLazyReference;
 function useResult(fragmentReference) {
-    const environment = (0, IsographEnvironment_1.useIsographEnvironment)();
+    const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     const [, setState] = (0, react_1.useState)();
     (0, react_1.useEffect)(() => {
         return (0, cache_1.subscribe)(environment, () => {

package/dist/reader.d.ts

@@ -0,0 +1,47 @@
+import { Arguments } from './index';
+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 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;
+};

package/dist/reader.js

@@ -0,0 +1,3 @@
+"use strict";
+// TODO this should probably be at least three distinct types, for @component,
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-945e49cc",
+  "version": "0.0.0-main-1bfd646b",
   "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-945e49cc",
-    "@isograph/react-disposable-state": "0.0.0-main-945e49cc",
+    "@isograph/disposable-types": "0.0.0-main-1bfd646b",
+    "@isograph/react-disposable-state": "0.0.0-main-1bfd646b",
     "react": "^18.2.0"
   },
   "devDependencies": {