@isograph/react 0.1.1 → 0.2.0

package/dist/core/cache.js

@@ -0,0 +1,452 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.subscribeToAnyChange = exports.normalizeData = exports.getOrCreateCacheForArtifact = exports.stableCopy = exports.getOrCreateItemInSuspenseCache = void 0;
+const react_disposable_state_1 = require("@isograph/react-disposable-state");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const read_1 = require("./read");
+const areEqualWithDeepComparison_1 = require("./areEqualWithDeepComparison");
+const makeNetworkRequest_1 = require("./makeNetworkRequest");
+const PromiseWrapper_1 = require("./PromiseWrapper");
+const TYPENAME_FIELD_NAME = '__typename';
+function getOrCreateItemInSuspenseCache(environment, index, factory) {
+    // @ts-expect-error
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('getting cache for', {
+            index,
+            cache: Object.keys(environment.fragmentCache),
+            found: !!environment.fragmentCache[index],
+        });
+    }
+    if (environment.fragmentCache[index] == null) {
+        environment.fragmentCache[index] = new react_disposable_state_1.ParentCache(factory);
+    }
+    return environment.fragmentCache[index];
+}
+exports.getOrCreateItemInSuspenseCache = getOrCreateItemInSuspenseCache;
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+function stableCopy(value) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // @ts-ignore
+        return value.map(stableCopy);
+    }
+    const keys = Object.keys(value).sort();
+    const stable = {};
+    for (let i = 0; i < keys.length; i++) {
+        // @ts-ignore
+        stable[keys[i]] = stableCopy(value[keys[i]]);
+    }
+    return stable;
+}
+exports.stableCopy = stableCopy;
+function getOrCreateCacheForArtifact(environment, entrypoint, variables) {
+    const cacheKey = entrypoint.queryText + JSON.stringify(stableCopy(variables));
+    const factory = () => {
+        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
+        const itemCleanupPair = [
+            {
+                kind: 'FragmentReference',
+                readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                    kind: 'ReaderWithRefetchQueries',
+                    readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
+                    nestedRefetchQueries: entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
+                }),
+                root: IsographEnvironment_1.ROOT_ID,
+                variables,
+                networkRequest: networkRequest,
+            },
+            disposeNetworkRequest,
+        ];
+        return itemCleanupPair;
+    };
+    return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
+}
+exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
+function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {
+    const encounteredIds = new Set();
+    // @ts-expect-error
+    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, encounteredIds);
+    // @ts-expect-error
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('after normalization', {
+            store: environment.store,
+            encounteredIds,
+            environment,
+        });
+    }
+    callSubscriptions(environment, encounteredIds);
+    return encounteredIds;
+}
+exports.normalizeData = normalizeData;
+function subscribeToAnyChange(environment, callback) {
+    const subscription = {
+        kind: 'AnyRecords',
+        callback,
+    };
+    environment.subscriptions.add(subscription);
+    return () => environment.subscriptions.delete(subscription);
+}
+exports.subscribeToAnyChange = subscribeToAnyChange;
+// TODO we should re-read and call callback if the value has changed
+function subscribe(environment, encounteredDataAndRecords, fragmentReference, callback) {
+    const fragmentSubscription = {
+        kind: 'FragmentSubscription',
+        callback,
+        encounteredDataAndRecords,
+        fragmentReference,
+    };
+    // @ts-expect-error
+    environment.subscriptions.add(fragmentSubscription);
+    // @ts-expect-error
+    return () => environment.subscriptions.delete(fragmentSubscription);
+}
+exports.subscribe = subscribe;
+function onNextChange(environment) {
+    return new Promise((resolve) => {
+        const unsubscribe = subscribeToAnyChange(environment, () => {
+            unsubscribe();
+            resolve();
+        });
+    });
+}
+exports.onNextChange = onNextChange;
+// Calls to readButDoNotEvaluate can suspend (i.e. throw a promise).
+// Maybe in the future, they will be able to throw errors.
+//
+// That's probably okay to ignore. We don't, however, want to prevent
+// updating other subscriptions if one subscription had missing data.
+function withErrorHandling(f) {
+    return (t) => {
+        try {
+            return f(t);
+        }
+        catch (_a) { }
+    };
+}
+function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
+    environment.subscriptions.forEach(withErrorHandling((subscription) => {
+        switch (subscription.kind) {
+            case 'FragmentSubscription': {
+                // TODO if there are multiple components subscribed to the same
+                // fragment, we will call readButNotEvaluate multiple times. We
+                // should fix that.
+                if (hasOverlappingIds(recordsEncounteredWhenNormalizing, subscription.encounteredDataAndRecords.encounteredRecords)) {
+                    const newEncounteredDataAndRecords = (0, read_1.readButDoNotEvaluate)(environment, subscription.fragmentReference, 
+                    // Is this wrong?
+                    // Reasons to think no:
+                    // - we are only updating the read-out value, and the network
+                    //   options only affect whether we throw.
+                    // - the component will re-render, and re-throw on its own, anyway.
+                    //
+                    // Reasons to think not:
+                    // - it seems more efficient to suspend here and not update state,
+                    //   if we expect that the component will just throw anyway
+                    // - consistency
+                    // - it's also weird, this is called from makeNetworkRequest, where
+                    //   we don't currently pass network request options
+                    {
+                        suspendIfInFlight: false,
+                        throwOnNetworkError: false,
+                    });
+                    if (!(0, areEqualWithDeepComparison_1.areEqualObjectsWithDeepComparison)(subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item)) {
+                        // @ts-expect-error
+                        if (typeof window !== 'undefined' && window.__LOG) {
+                            console.log('Deep equality - No', {
+                                fragmentReference: subscription.fragmentReference,
+                                old: subscription.encounteredDataAndRecords.item,
+                                new: newEncounteredDataAndRecords.item,
+                            });
+                        }
+                        // TODO deep compare values
+                        subscription.callback(newEncounteredDataAndRecords);
+                    }
+                    else {
+                        // @ts-expect-error
+                        if (typeof window !== 'undefined' && window.__LOG) {
+                            console.log('Deep equality - Yes', {
+                                fragmentReference: subscription.fragmentReference,
+                                old: subscription.encounteredDataAndRecords.item,
+                            });
+                        }
+                    }
+                }
+                return;
+            }
+            case 'AnyRecords': {
+                return subscription.callback();
+            }
+            default: {
+                // Ensure we have covered all variants
+                const _ = subscription;
+                _;
+                throw new Error('Unexpected case');
+            }
+        }
+    }));
+}
+function hasOverlappingIds(set1, set2) {
+    for (const id of set1) {
+        if (set2.has(id)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
+ */
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    let recordHasBeenUpdated = false;
+    for (const normalizationNode of normalizationAst) {
+        switch (normalizationNode.kind) {
+            case 'Scalar': {
+                const scalarFieldResultedInChange = normalizeScalarField(normalizationNode, networkResponseParentRecord, targetParentRecord, variables);
+                recordHasBeenUpdated =
+                    recordHasBeenUpdated || scalarFieldResultedInChange;
+                break;
+            }
+            case 'Linked': {
+                const linkedFieldResultedInChange = normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
+                recordHasBeenUpdated =
+                    recordHasBeenUpdated || linkedFieldResultedInChange;
+                break;
+            }
+            case 'InlineFragment': {
+                const inlineFragmentResultedInChange = normalizeInlineFragment(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
+                recordHasBeenUpdated =
+                    recordHasBeenUpdated || inlineFragmentResultedInChange;
+                break;
+            }
+            default: {
+                // Ensure we have covered all variants
+                let _ = normalizationNode;
+                _;
+                throw new Error('Unexpected normalization node kind');
+            }
+        }
+    }
+    if (recordHasBeenUpdated) {
+        mutableEncounteredIds.add(targetParentRecordId);
+    }
+    return recordHasBeenUpdated;
+}
+function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreRecord, variables) {
+    const networkResponseKey = getNetworkResponseKey(astNode);
+    const networkResponseData = networkResponseParentRecord[networkResponseKey];
+    const parentRecordKey = getParentRecordKey(astNode, variables);
+    if (networkResponseData == null ||
+        isScalarOrEmptyArray(networkResponseData)) {
+        const existingValue = targetStoreRecord[parentRecordKey];
+        targetStoreRecord[parentRecordKey] = networkResponseData;
+        return existingValue !== networkResponseData;
+    }
+    else {
+        throw new Error('Unexpected object array when normalizing scalar');
+    }
+}
+/**
+ * Mutate targetParentRecord with a given linked field ast node.
+ */
+function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    const networkResponseKey = getNetworkResponseKey(astNode);
+    const networkResponseData = networkResponseParentRecord[networkResponseKey];
+    const parentRecordKey = getParentRecordKey(astNode, variables);
+    const existingValue = targetParentRecord[parentRecordKey];
+    if (networkResponseData == null) {
+        targetParentRecord[parentRecordKey] = null;
+        return existingValue !== null;
+    }
+    if (isScalarButNotEmptyArray(networkResponseData)) {
+        throw new Error('Unexpected scalar network response when normalizing a linked field');
+    }
+    if (Array.isArray(networkResponseData)) {
+        // TODO check astNode.plural or the like
+        const dataIds = [];
+        for (let i = 0; i < networkResponseData.length; i++) {
+            const networkResponseObject = networkResponseData[i];
+            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries, mutableEncounteredIds);
+            dataIds.push({ __link: newStoreRecordId });
+        }
+        targetParentRecord[parentRecordKey] = dataIds;
+        return !dataIdsAreTheSame(existingValue, dataIds);
+    }
+    else {
+        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries, mutableEncounteredIds);
+        targetParentRecord[parentRecordKey] = {
+            __link: newStoreRecordId,
+        };
+        const link = (0, IsographEnvironment_1.getLink)(existingValue);
+        return (link === null || link === void 0 ? void 0 : link.__link) !== newStoreRecordId;
+    }
+}
+/**
+ * Mutate targetParentRecord with a given linked field ast node.
+ */
+function normalizeInlineFragment(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    const typeToRefineTo = astNode.type;
+    if (networkResponseParentRecord[TYPENAME_FIELD_NAME] === typeToRefineTo) {
+        const hasBeenModified = normalizeDataIntoRecord(environment, astNode.selections, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
+        return hasBeenModified;
+    }
+    return false;
+}
+function dataIdsAreTheSame(existingValue, newDataIds) {
+    if (Array.isArray(existingValue)) {
+        if (newDataIds.length !== existingValue.length) {
+            return false;
+        }
+        for (let i = 0; i < newDataIds.length; i++) {
+            const maybeLink = (0, IsographEnvironment_1.getLink)(existingValue[i]);
+            if (maybeLink !== null) {
+                if (newDataIds[i].__link !== maybeLink.__link) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+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, mutableEncounteredIds);
+    return newStoreRecordId;
+}
+function isScalarOrEmptyArray(data) {
+    // N.B. empty arrays count as empty arrays of scalar fields.
+    if (Array.isArray(data)) {
+        // This is maybe fixed in a new version of Typescript??
+        return data.every((x) => isScalarOrEmptyArray(x));
+    }
+    const isScalarValue = typeof data === 'string' ||
+        typeof data === 'number' ||
+        typeof data === 'boolean';
+    return isScalarValue;
+}
+function isScalarButNotEmptyArray(data) {
+    // N.B. empty arrays count as empty arrays of linked fields.
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return false;
+        }
+        // This is maybe fixed in a new version of Typescript??
+        return data.every((x) => isScalarOrEmptyArray(x));
+    }
+    const isScalarValue = typeof data === 'string' ||
+        typeof data === 'number' ||
+        typeof data === 'boolean';
+    return isScalarValue;
+}
+function getParentRecordKey(astNode, variables) {
+    let parentRecordKey = astNode.fieldName;
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters != null) {
+        for (const fieldParameter of fieldParameters) {
+            parentRecordKey += getStoreKeyChunkForArgument(fieldParameter, variables);
+        }
+    }
+    return parentRecordKey;
+}
+exports.getParentRecordKey = getParentRecordKey;
+function getStoreKeyChunkForArgumentValue(argumentValue, variables) {
+    var _a;
+    switch (argumentValue.kind) {
+        case 'Literal': {
+            return argumentValue.value;
+        }
+        case 'Variable': {
+            return (_a = variables[argumentValue.name]) !== null && _a !== void 0 ? _a : 'null';
+        }
+        case 'String': {
+            return argumentValue.value;
+        }
+        case 'Enum': {
+            return argumentValue.value;
+        }
+        default: {
+            // TODO configure eslint to allow unused vars starting with _
+            // Ensure we have covered all variants
+            const _ = argumentValue;
+            _;
+            throw new Error('Unexpected case');
+        }
+    }
+}
+function getStoreKeyChunkForArgument(argument, variables) {
+    const chunk = getStoreKeyChunkForArgumentValue(argument[1], variables);
+    return `${exports.FIRST_SPLIT_KEY}${argument[0]}${exports.SECOND_SPLIT_KEY}${chunk}`;
+}
+function getNetworkResponseKey(astNode) {
+    let networkResponseKey = astNode.fieldName;
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters != null) {
+        for (const fieldParameter of fieldParameters) {
+            const [argumentName, argumentValue] = fieldParameter;
+            let argumentValueChunk;
+            switch (argumentValue.kind) {
+                case 'Literal': {
+                    argumentValueChunk = 'l_' + argumentValue.value;
+                    break;
+                }
+                case 'Variable': {
+                    argumentValueChunk = 'v_' + argumentValue.name;
+                    break;
+                }
+                case 'String': {
+                    argumentValueChunk = 's_' + argumentValue.value;
+                    break;
+                }
+                case 'Enum': {
+                    argumentValueChunk = 'e_' + argumentValue.value;
+                    break;
+                }
+                default: {
+                    // Ensure we have covered all variants
+                    let _ = argumentValue;
+                    _;
+                    throw new Error('Unexpected case');
+                }
+            }
+            networkResponseKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${argumentValueChunk}`;
+        }
+    }
+    return networkResponseKey;
+}
+// an alias might be pullRequests____first___first____after___cursor
+exports.FIRST_SPLIT_KEY = '____';
+exports.SECOND_SPLIT_KEY = '___';
+// Returns a key to look up an item in the store
+function getDataIdOfNetworkResponse(parentRecordId, dataToNormalize, astNode, variables, index) {
+    // Check whether the dataToNormalize has an id field. If so, that is the key.
+    // If not, we construct an id from the parentRecordId and the field parameters.
+    const dataId = dataToNormalize.id;
+    if (dataId != null) {
+        return dataId;
+    }
+    let storeKey = `${parentRecordId}.${astNode.fieldName}`;
+    if (index != null) {
+        storeKey += `.${index}`;
+    }
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters == null) {
+        return storeKey;
+    }
+    for (const fieldParameter of fieldParameters) {
+        storeKey += getStoreKeyChunkForArgument(fieldParameter, variables);
+    }
+    return storeKey;
+}

package/dist/core/componentCache.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { IsographEnvironment } from './IsographEnvironment';
+import { FragmentReference } from './FragmentReference';
+import { NetworkRequestReaderOptions } from './read';
+export declare function getOrCreateCachedComponent(environment: IsographEnvironment, componentName: string, fragmentReference: FragmentReference<any, any>, networkRequestOptions: NetworkRequestReaderOptions): React.FC<any>;

package/dist/core/componentCache.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateCachedComponent = void 0;
+const cache_1 = require("./cache");
+const useReadAndSubscribe_1 = require("../react/useReadAndSubscribe");
+const PromiseWrapper_1 = require("./PromiseWrapper");
+function getOrCreateCachedComponent(environment, componentName, fragmentReference, networkRequestOptions) {
+    var _a, _b, _c;
+    // cachedComponentsById is a three layer cache: id, then component name, then
+    // stringified args. These three, together, uniquely identify a read at a given
+    // time.
+    const cachedComponentsById = environment.componentCache;
+    cachedComponentsById[fragmentReference.root] =
+        (_a = cachedComponentsById[fragmentReference.root]) !== null && _a !== void 0 ? _a : {};
+    const componentsByName = cachedComponentsById[fragmentReference.root];
+    componentsByName[componentName] = (_b = componentsByName[componentName]) !== null && _b !== void 0 ? _b : {};
+    const byArgs = componentsByName[componentName];
+    const stringifiedArgs = JSON.stringify((0, cache_1.stableCopy)(fragmentReference.variables));
+    byArgs[stringifiedArgs] =
+        (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
+            function Component(additionalRuntimeProps) {
+                const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions);
+                // @ts-expect-error
+                if (typeof window !== 'undefined' && window.__LOG) {
+                    console.log('Component re-rendered: ' +
+                        componentName +
+                        ' ' +
+                        fragmentReference.root);
+                }
+                const readerWithRefetchQueries = (0, PromiseWrapper_1.readPromise)(fragmentReference.readerWithRefetchQueries);
+                return readerWithRefetchQueries.readerArtifact.resolver(data, additionalRuntimeProps);
+            }
+            Component.displayName = `${componentName} (id: ${fragmentReference.root}) @component`;
+            return Component;
+        })();
+    return byArgs[stringifiedArgs];
+}
+exports.getOrCreateCachedComponent = getOrCreateCachedComponent;

package/dist/core/entrypoint.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="react" />
+import { TopLevelReaderArtifact } from './reader';
+import { Arguments } from './util';
+export type ReaderWithRefetchQueries<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'ReaderWithRefetchQueries';
+    readonly readerArtifact: TopLevelReaderArtifact<TReadFromStore, TClientFieldValue, any>;
+    readonly nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[];
+};
+export type IsographEntrypoint<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'Entrypoint';
+    readonly queryText: string;
+    readonly normalizationAst: NormalizationAst;
+    readonly readerWithRefetchQueries: ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>;
+};
+export type IsographEntrypointLoader<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'EntrypointLoader';
+    readonly typeAndField: string;
+    readonly loader: () => Promise<IsographEntrypoint<TReadFromStore, TClientFieldValue>>;
+};
+export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField | NormalizationInlineFragment;
+export type NormalizationAst = ReadonlyArray<NormalizationAstNode>;
+export type NormalizationScalarField = {
+    readonly kind: 'Scalar';
+    readonly fieldName: string;
+    readonly arguments: Arguments | null;
+};
+export type NormalizationLinkedField = {
+    readonly kind: 'Linked';
+    readonly fieldName: string;
+    readonly arguments: Arguments | null;
+    readonly selections: NormalizationAst;
+};
+export type NormalizationInlineFragment = {
+    readonly kind: 'InlineFragment';
+    readonly type: string;
+    readonly selections: NormalizationAst;
+};
+export type RefetchQueryNormalizationArtifact = {
+    readonly kind: 'RefetchQuery';
+    readonly queryText: string;
+    readonly normalizationAst: NormalizationAst;
+};
+export type RefetchQueryNormalizationArtifactWrapper = {
+    readonly artifact: RefetchQueryNormalizationArtifact;
+    readonly allowedVariables: string[];
+};
+export declare function assertIsEntrypoint<TReadFromStore extends Object, TClientFieldValue>(value: IsographEntrypoint<TReadFromStore, TClientFieldValue> | ((_: any) => any) | any): asserts value is IsographEntrypoint<TReadFromStore, TClientFieldValue>;
+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 type ExtractProps<Type> = Type extends React.FC<infer X> ? X : never;

package/dist/core/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/core/garbageCollection.d.ts

@@ -0,0 +1,11 @@
+import { IsographEnvironment } from './IsographEnvironment';
+import { NormalizationAst } from './entrypoint';
+export type RetainedQuery = {
+    readonly normalizationAst: NormalizationAst;
+    readonly 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/core/garbageCollection.js

@@ -0,0 +1,74 @@
+"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 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 maybeLink of linkedFieldOrFields) {
+                        const link = (0, IsographEnvironment_1.assertLink)(maybeLink);
+                        if (link != null) {
+                            ids.push(link.__link);
+                        }
+                    }
+                }
+                else {
+                    const link = (0, IsographEnvironment_1.assertLink)(linkedFieldOrFields);
+                    if (link != null) {
+                        ids.push(link.__link);
+                    }
+                }
+                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/core/makeNetworkRequest.d.ts

@@ -0,0 +1,6 @@
+import { ItemCleanupPair } from '@isograph/disposable-types';
+import { IsographEntrypoint, RefetchQueryNormalizationArtifact } from './entrypoint';
+import { Variables } from './FragmentReference';
+import { IsographEnvironment } from './IsographEnvironment';
+import { AnyError, PromiseWrapper } from './PromiseWrapper';
+export declare function makeNetworkRequest(environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact | IsographEntrypoint<any, any>, variables: Variables): ItemCleanupPair<PromiseWrapper<void, AnyError>>;