@isograph/react 0.2.0 → 0.3.0

package/dist/core/cache.js

@@ -1,28 +1,37 @@
 "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;
+exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.TYPENAME_FIELD_NAME = void 0;
+exports.getOrCreateItemInSuspenseCache = getOrCreateItemInSuspenseCache;
+exports.stableCopy = stableCopy;
+exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
+exports.normalizeData = normalizeData;
+exports.subscribeToAnyChange = subscribeToAnyChange;
+exports.subscribeToAnyChangesToRecord = subscribeToAnyChangesToRecord;
+exports.subscribe = subscribe;
+exports.onNextChangeToRecord = onNextChangeToRecord;
+exports.insertIfNotExists = insertIfNotExists;
+exports.getParentRecordKey = getParentRecordKey;
 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';
+const logging_1 = require("./logging");
+exports.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],
-        });
-    }
+    // TODO this is probably a useless message, we should remove it
+    (0, logging_1.logMessage)(environment, {
+        kind: 'GettingSuspenseCacheItem',
+        index,
+        availableCacheItems: 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
@@ -44,11 +53,11 @@ function stableCopy(value) {
     }
     return stable;
 }
-exports.stableCopy = stableCopy;
-function getOrCreateCacheForArtifact(environment, entrypoint, variables) {
-    const cacheKey = entrypoint.queryText + JSON.stringify(stableCopy(variables));
+function getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions) {
+    const cacheKey = entrypoint.networkRequestInfo.queryText +
+        JSON.stringify(stableCopy(variables));
     const factory = () => {
-        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
+        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, fetchOptions);
         const itemCleanupPair = [
             {
                 kind: 'FragmentReference',
@@ -57,7 +66,7 @@ function getOrCreateCacheForArtifact(environment, entrypoint, variables) {
                     readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
                     nestedRefetchQueries: entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
                 }),
-                root: IsographEnvironment_1.ROOT_ID,
+                root: { __link: IsographEnvironment_1.ROOT_ID, __typename: entrypoint.concreteType },
                 variables,
                 networkRequest: networkRequest,
             },
@@ -67,26 +76,27 @@ function getOrCreateCacheForArtifact(environment, entrypoint, variables) {
     };
     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,
-        });
-    }
+function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries, root) {
+    var _a, _b;
+    var _c, _d, _e;
+    const encounteredIds = new Map();
+    (0, logging_1.logMessage)(environment, {
+        kind: 'AboutToNormalize',
+        normalizationAst,
+        networkResponse,
+        variables,
+    });
+    const recordsById = ((_a = (_c = environment.store)[_d = root.__typename]) !== null && _a !== void 0 ? _a : (_c[_d] = {}));
+    const newStoreRecord = ((_b = recordsById[_e = root.__link]) !== null && _b !== void 0 ? _b : (recordsById[_e] = {}));
+    normalizeDataIntoRecord(environment, normalizationAst, networkResponse, newStoreRecord, root, variables, nestedRefetchQueries, encounteredIds);
+    (0, logging_1.logMessage)(environment, {
+        kind: 'AfterNormalization',
+        store: environment.store,
+        encounteredIds,
+    });
     callSubscriptions(environment, encounteredIds);
     return encounteredIds;
 }
-exports.normalizeData = normalizeData;
 function subscribeToAnyChange(environment, callback) {
     const subscription = {
         kind: 'AnyRecords',
@@ -95,30 +105,35 @@ function subscribeToAnyChange(environment, callback) {
     environment.subscriptions.add(subscription);
     return () => environment.subscriptions.delete(subscription);
 }
-exports.subscribeToAnyChange = subscribeToAnyChange;
+function subscribeToAnyChangesToRecord(environment, recordLink, callback) {
+    const subscription = {
+        kind: 'AnyChangesToRecord',
+        recordLink,
+        callback,
+    };
+    environment.subscriptions.add(subscription);
+    return () => environment.subscriptions.delete(subscription);
+}
 // TODO we should re-read and call callback if the value has changed
-function subscribe(environment, encounteredDataAndRecords, fragmentReference, callback) {
+function subscribe(environment, encounteredDataAndRecords, fragmentReference, callback, readerAst) {
     const fragmentSubscription = {
         kind: 'FragmentSubscription',
         callback,
         encounteredDataAndRecords,
         fragmentReference,
+        readerAst,
     };
-    // @ts-expect-error
     environment.subscriptions.add(fragmentSubscription);
-    // @ts-expect-error
     return () => environment.subscriptions.delete(fragmentSubscription);
 }
-exports.subscribe = subscribe;
-function onNextChange(environment) {
+function onNextChangeToRecord(environment, recordLink) {
     return new Promise((resolve) => {
-        const unsubscribe = subscribeToAnyChange(environment, () => {
+        const unsubscribe = subscribeToAnyChangesToRecord(environment, recordLink, () => {
             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.
 //
@@ -134,6 +149,7 @@ function withErrorHandling(f) {
 }
 function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
     environment.subscriptions.forEach(withErrorHandling((subscription) => {
+        var _a;
         switch (subscription.kind) {
             case 'FragmentSubscription': {
                 // TODO if there are multiple components subscribed to the same
@@ -157,32 +173,30 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
                         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
+                    const mergedItem = (0, areEqualWithDeepComparison_1.mergeObjectsUsingReaderAst)(subscription.readerAst, subscription.encounteredDataAndRecords.item, newEncounteredDataAndRecords.item);
+                    (0, logging_1.logMessage)(environment, {
+                        kind: 'DeepEqualityCheck',
+                        fragmentReference: subscription.fragmentReference,
+                        old: subscription.encounteredDataAndRecords.item,
+                        new: newEncounteredDataAndRecords.item,
+                        deeplyEqual: mergedItem === subscription.encounteredDataAndRecords.item,
+                    });
+                    if (mergedItem !== subscription.encounteredDataAndRecords.item) {
                         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();
+                subscription.callback();
+                return;
+            }
+            case 'AnyChangesToRecord': {
+                if ((_a = recordsEncounteredWhenNormalizing
+                    .get(subscription.recordLink.__typename)) === null || _a === void 0 ? void 0 : _a.has(subscription.recordLink.__link)) {
+                    subscription.callback();
+                }
+                return;
             }
             default: {
                 // Ensure we have covered all variants
@@ -193,7 +207,20 @@ function callSubscriptions(environment, recordsEncounteredWhenNormalizing) {
         }
     }));
 }
-function hasOverlappingIds(set1, set2) {
+function hasOverlappingIds(ids1, ids2) {
+    for (const [typeName, set1] of ids1.entries()) {
+        const set2 = ids2.get(typeName);
+        if (set2 === undefined) {
+            continue;
+        }
+        if (isNotDisjointFrom(set1, set2)) {
+            return true;
+        }
+    }
+    return false;
+}
+// TODO use a polyfill library
+function isNotDisjointFrom(set1, set2) {
     for (const id of set1) {
         if (set2.has(id)) {
             return true;
@@ -204,7 +231,7 @@ function hasOverlappingIds(set1, set2) {
 /**
  * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
  */
-function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds) {
     let recordHasBeenUpdated = false;
     for (const normalizationNode of normalizationAst) {
         switch (normalizationNode.kind) {
@@ -215,13 +242,13 @@ function normalizeDataIntoRecord(environment, normalizationAst, networkResponseP
                 break;
             }
             case 'Linked': {
-                const linkedFieldResultedInChange = normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
+                const linkedFieldResultedInChange = normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds);
                 recordHasBeenUpdated =
                     recordHasBeenUpdated || linkedFieldResultedInChange;
                 break;
             }
             case 'InlineFragment': {
-                const inlineFragmentResultedInChange = normalizeInlineFragment(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds);
+                const inlineFragmentResultedInChange = normalizeInlineFragment(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds);
                 recordHasBeenUpdated =
                     recordHasBeenUpdated || inlineFragmentResultedInChange;
                 break;
@@ -235,10 +262,19 @@ function normalizeDataIntoRecord(environment, normalizationAst, networkResponseP
         }
     }
     if (recordHasBeenUpdated) {
-        mutableEncounteredIds.add(targetParentRecordId);
+        let encounteredRecordsIds = insertIfNotExists(mutableEncounteredIds, targetParentRecordLink.__typename);
+        encounteredRecordsIds.add(targetParentRecordLink.__link);
     }
     return recordHasBeenUpdated;
 }
+function insertIfNotExists(map, key) {
+    let result = map.get(key);
+    if (result === undefined) {
+        result = new Set();
+        map.set(key, result);
+    }
+    return result;
+}
 function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreRecord, variables) {
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
@@ -256,7 +292,8 @@ function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreR
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
-function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+function normalizeLinkedField(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    var _a, _b;
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
     const parentRecordKey = getParentRecordKey(astNode, variables);
@@ -265,7 +302,8 @@ function normalizeLinkedField(environment, astNode, networkResponseParentRecord,
         targetParentRecord[parentRecordKey] = null;
         return existingValue !== null;
     }
-    if (isScalarButNotEmptyArray(networkResponseData)) {
+    if (isScalarOrEmptyArray(networkResponseData) &&
+        !isNullOrEmptyArray(networkResponseData)) {
         throw new Error('Unexpected scalar network response when normalizing a linked field');
     }
     if (Array.isArray(networkResponseData)) {
@@ -273,43 +311,61 @@ 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, mutableEncounteredIds);
-            dataIds.push({ __link: newStoreRecordId });
+            if (networkResponseObject == null) {
+                dataIds.push(null);
+                continue;
+            }
+            const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseObject, targetParentRecordLink, variables, i, nestedRefetchQueries, mutableEncounteredIds);
+            const __typename = (_a = astNode.concreteType) !== null && _a !== void 0 ? _a : networkResponseObject[exports.TYPENAME_FIELD_NAME];
+            if (__typename == null) {
+                throw new Error('Unexpected missing __typename in network response when normalizing a linked field. ' +
+                    'This is indicative of a bug in Isograph.');
+            }
+            dataIds.push({
+                __link: newStoreRecordId,
+                __typename,
+            });
         }
         targetParentRecord[parentRecordKey] = dataIds;
         return !dataIdsAreTheSame(existingValue, dataIds);
     }
     else {
-        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries, mutableEncounteredIds);
+        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordLink, variables, null, nestedRefetchQueries, mutableEncounteredIds);
+        let __typename = (_b = astNode.concreteType) !== null && _b !== void 0 ? _b : networkResponseData[exports.TYPENAME_FIELD_NAME];
+        if (__typename == null) {
+            throw new Error('Unexpected missing __typename in network response when normalizing a linked field. ' +
+                'This is indicative of a bug in Isograph.');
+        }
         targetParentRecord[parentRecordKey] = {
             __link: newStoreRecordId,
+            __typename,
         };
         const link = (0, IsographEnvironment_1.getLink)(existingValue);
-        return (link === null || link === void 0 ? void 0 : link.__link) !== newStoreRecordId;
+        return (link === null || link === void 0 ? void 0 : link.__link) !== newStoreRecordId || link.__typename !== __typename;
     }
 }
 /**
  * Mutate targetParentRecord with a given linked field ast node.
  */
-function normalizeInlineFragment(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries, mutableEncounteredIds) {
+function normalizeInlineFragment(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, 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);
+    if (networkResponseParentRecord[exports.TYPENAME_FIELD_NAME] === typeToRefineTo) {
+        const hasBeenModified = normalizeDataIntoRecord(environment, astNode.selections, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds);
         return hasBeenModified;
     }
     return false;
 }
 function dataIdsAreTheSame(existingValue, newDataIds) {
+    var _a, _b;
     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;
-                }
+            if (((_a = newDataIds[i]) === null || _a === void 0 ? void 0 : _a.__link) !== (maybeLink === null || maybeLink === void 0 ? void 0 : maybeLink.__link) ||
+                ((_b = newDataIds[i]) === null || _b === void 0 ? void 0 : _b.__typename) !== (maybeLink === null || maybeLink === void 0 ? void 0 : maybeLink.__typename)) {
+                return false;
             }
         }
         return true;
@@ -318,12 +374,18 @@ function dataIdsAreTheSame(existingValue, newDataIds) {
         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);
+function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordLink, variables, index, nestedRefetchQueries, mutableEncounteredIds) {
+    var _a, _b, _c;
+    var _d;
+    const newStoreRecordId = getDataIdOfNetworkResponse(targetParentRecordLink, networkResponseData, astNode, variables, index);
+    const __typename = (_a = astNode.concreteType) !== null && _a !== void 0 ? _a : networkResponseData[exports.TYPENAME_FIELD_NAME];
+    if (__typename == null) {
+        throw new Error('Unexpected missing __typename in network response object. ' +
+            'This is indicative of a bug in Isograph.');
+    }
+    const recordsById = ((_b = (_d = environment.store)[__typename]) !== null && _b !== void 0 ? _b : (_d[__typename] = {}));
+    const newStoreRecord = ((_c = recordsById[newStoreRecordId]) !== null && _c !== void 0 ? _c : (recordsById[newStoreRecordId] = {}));
+    normalizeDataIntoRecord(environment, astNode.selections, networkResponseData, newStoreRecord, { __link: newStoreRecordId, __typename: __typename }, variables, nestedRefetchQueries, mutableEncounteredIds);
     return newStoreRecordId;
 }
 function isScalarOrEmptyArray(data) {
@@ -332,24 +394,20 @@ function isScalarOrEmptyArray(data) {
         // This is maybe fixed in a new version of Typescript??
         return data.every((x) => isScalarOrEmptyArray(x));
     }
-    const isScalarValue = typeof data === 'string' ||
+    const isScalarValue = data === null ||
+        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.
+function isNullOrEmptyArray(data) {
     if (Array.isArray(data)) {
         if (data.length === 0) {
-            return false;
+            return true;
         }
-        // This is maybe fixed in a new version of Typescript??
-        return data.every((x) => isScalarOrEmptyArray(x));
+        return data.every((x) => isNullOrEmptyArray(x));
     }
-    const isScalarValue = typeof data === 'string' ||
-        typeof data === 'number' ||
-        typeof data === 'boolean';
-    return isScalarValue;
+    return data === null;
 }
 function getParentRecordKey(astNode, variables) {
     let parentRecordKey = astNode.fieldName;
@@ -361,7 +419,6 @@ function getParentRecordKey(astNode, variables) {
     }
     return parentRecordKey;
 }
-exports.getParentRecordKey = getParentRecordKey;
 function getStoreKeyChunkForArgumentValue(argumentValue, variables) {
     var _a;
     switch (argumentValue.kind) {
@@ -430,14 +487,19 @@ function getNetworkResponseKey(astNode) {
 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) {
+function getDataIdOfNetworkResponse(parentRecordLink, dataToNormalize, astNode, variables, index) {
+    // If we are dealing with nested Query, use __ROOT as id
+    // TODO do not hard code this value here
+    if (astNode.concreteType === 'Query') {
+        return IsographEnvironment_1.ROOT_ID;
+    }
     // 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}`;
+    let storeKey = `${parentRecordLink.__typename}:${parentRecordLink.__link}.${astNode.fieldName}`;
     if (index != null) {
         storeKey += `.${index}`;
     }

package/dist/core/check.d.ts

@@ -0,0 +1,18 @@
+import { NormalizationAst } from './entrypoint';
+import { Variables } from './FragmentReference';
+import { IsographEnvironment, Link } from './IsographEnvironment';
+export type ShouldFetch = 'Yes' | 'No' | 'IfNecessary';
+export declare const DEFAULT_SHOULD_FETCH_VALUE: ShouldFetch;
+export type FetchOptions = {
+    shouldFetch?: ShouldFetch;
+    onComplete?: () => void;
+    onError?: () => void;
+};
+export type CheckResult = {
+    kind: 'EnoughData';
+} | {
+    kind: 'MissingData';
+    record: Link;
+};
+export declare function check(environment: IsographEnvironment, normalizationAst: NormalizationAst, variables: Variables, root: Link): CheckResult;
+//# sourceMappingURL=check.d.ts.map

package/dist/core/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/core/check.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAEL,mBAAmB,EACnB,IAAI,EAEL,MAAM,uBAAuB,CAAC;AAG/B,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,IAAI,GAAG,aAAa,CAAC;AAEvD,eAAO,MAAM,0BAA0B,EAAE,WAA2B,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GACnB;IACE,IAAI,EAAE,YAAY,CAAC;CACpB,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,IAAI,CAAC;CACd,CAAC;AAEN,wBAAgB,KAAK,CACnB,WAAW,EAAE,mBAAmB,EAChC,gBAAgB,EAAE,gBAAgB,EAClC,SAAS,EAAE,SAAS,EACpB,IAAI,EAAE,IAAI,GACT,WAAW,CAgBb"}

package/dist/core/check.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SHOULD_FETCH_VALUE = void 0;
+exports.check = check;
+const cache_1 = require("./cache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const logging_1 = require("./logging");
+exports.DEFAULT_SHOULD_FETCH_VALUE = 'IfNecessary';
+function check(environment, normalizationAst, variables, root) {
+    var _a, _b;
+    var _c, _d, _e;
+    const recordsById = ((_a = (_c = environment.store)[_d = root.__typename]) !== null && _a !== void 0 ? _a : (_c[_d] = {}));
+    const newStoreRecord = ((_b = recordsById[_e = root.__link]) !== null && _b !== void 0 ? _b : (recordsById[_e] = {}));
+    const checkResult = checkFromRecord(environment, normalizationAst, variables, newStoreRecord, root);
+    (0, logging_1.logMessage)(environment, {
+        kind: 'EnvironmentCheck',
+        result: checkResult,
+    });
+    return checkResult;
+}
+function checkFromRecord(environment, normalizationAst, variables, record, recordLink) {
+    var _a, _b;
+    normalizationAstLoop: for (const normalizationAstNode of normalizationAst) {
+        switch (normalizationAstNode.kind) {
+            case 'Scalar': {
+                const parentRecordKey = (0, cache_1.getParentRecordKey)(normalizationAstNode, variables);
+                const scalarValue = record[parentRecordKey];
+                // null means the value is known to be missing, so it must
+                // be exactly undefined
+                if (scalarValue === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        record: recordLink,
+                    };
+                }
+                continue normalizationAstLoop;
+            }
+            case 'Linked': {
+                const parentRecordKey = (0, cache_1.getParentRecordKey)(normalizationAstNode, variables);
+                const linkedValue = record[parentRecordKey];
+                if (linkedValue === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        record: recordLink,
+                    };
+                }
+                else if (linkedValue === null) {
+                    continue;
+                }
+                else if (Array.isArray(linkedValue)) {
+                    arrayItemsLoop: for (const item of linkedValue) {
+                        const link = (0, IsographEnvironment_1.getLink)(item);
+                        if (link === null) {
+                            throw new Error('Unexpected non-link in the Isograph store. ' +
+                                'This is indicative of a bug in Isograph.');
+                        }
+                        const linkedRecord = (_a = environment.store[link.__typename]) === null || _a === void 0 ? void 0 : _a[link.__link];
+                        if (linkedRecord === undefined) {
+                            return {
+                                kind: 'MissingData',
+                                record: link,
+                            };
+                        }
+                        else if (linkedRecord === null) {
+                            continue arrayItemsLoop;
+                        }
+                        else {
+                            // TODO in __DEV__ assert linkedRecord is an object
+                            const result = checkFromRecord(environment, normalizationAstNode.selections, variables, linkedRecord, link);
+                            if (result.kind === 'MissingData') {
+                                return result;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const link = (0, IsographEnvironment_1.getLink)(linkedValue);
+                    if (link === null) {
+                        throw new Error('Unexpected non-link in the Isograph store. ' +
+                            'This is indicative of a bug in Isograph.');
+                    }
+                    const linkedRecord = (_b = environment.store[link.__typename]) === null || _b === void 0 ? void 0 : _b[link.__link];
+                    if (linkedRecord === undefined) {
+                        return {
+                            kind: 'MissingData',
+                            record: link,
+                        };
+                    }
+                    else if (linkedRecord === null) {
+                        continue normalizationAstLoop;
+                    }
+                    else {
+                        // TODO in __DEV__ assert linkedRecord is an object
+                        const result = checkFromRecord(environment, normalizationAstNode.selections, variables, linkedRecord, link);
+                        if (result.kind === 'MissingData') {
+                            return result;
+                        }
+                    }
+                }
+                continue normalizationAstLoop;
+            }
+            case 'InlineFragment': {
+                const existingRecordTypename = record['__typename'];
+                if (existingRecordTypename == null ||
+                    existingRecordTypename !== normalizationAstNode.type) {
+                    return {
+                        kind: 'MissingData',
+                        record: recordLink,
+                    };
+                }
+                const result = checkFromRecord(environment, normalizationAstNode.selections, variables, record, recordLink);
+                if (result.kind === 'MissingData') {
+                    return result;
+                }
+                continue normalizationAstLoop;
+            }
+            default: {
+                let _ = normalizationAstNode;
+                _;
+                throw new Error('Unexpected case. This is indicative of a bug in Isograph.');
+            }
+        }
+    }
+    return {
+        kind: 'EnoughData',
+    };
+}

package/dist/core/componentCache.d.ts

@@ -1,5 +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>;
+//# sourceMappingURL=componentCache.d.ts.map

package/dist/core/componentCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentCache.d.ts","sourceRoot":"","sources":["../../src/core/componentCache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,2BAA2B,EAAE,MAAM,QAAQ,CAAC;AAIrD,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,mBAAmB,EAChC,aAAa,EAAE,MAAM,EACrB,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC9C,qBAAqB,EAAE,2BAA2B,GACjD,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAgDf"}