@isograph/react 0.1.1 → 0.3.0

package/dist/core/cache.js

@@ -0,0 +1,514 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 logging_1 = require("./logging");
+exports.TYPENAME_FIELD_NAME = '__typename';
+function getOrCreateItemInSuspenseCache(environment, index, factory) {
+    // 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];
+}
+/**
+ * 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;
+}
+function getOrCreateCacheForArtifact(environment, entrypoint, variables, fetchOptions) {
+    const cacheKey = entrypoint.networkRequestInfo.queryText +
+        JSON.stringify(stableCopy(variables));
+    const factory = () => {
+        const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, fetchOptions);
+        const itemCleanupPair = [
+            {
+                kind: 'FragmentReference',
+                readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                    kind: 'ReaderWithRefetchQueries',
+                    readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
+                    nestedRefetchQueries: entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
+                }),
+                root: { __link: IsographEnvironment_1.ROOT_ID, __typename: entrypoint.concreteType },
+                variables,
+                networkRequest: networkRequest,
+            },
+            disposeNetworkRequest,
+        ];
+        return itemCleanupPair;
+    };
+    return getOrCreateItemInSuspenseCache(environment, cacheKey, factory);
+}
+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;
+}
+function subscribeToAnyChange(environment, callback) {
+    const subscription = {
+        kind: 'AnyRecords',
+        callback,
+    };
+    environment.subscriptions.add(subscription);
+    return () => environment.subscriptions.delete(subscription);
+}
+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, readerAst) {
+    const fragmentSubscription = {
+        kind: 'FragmentSubscription',
+        callback,
+        encounteredDataAndRecords,
+        fragmentReference,
+        readerAst,
+    };
+    environment.subscriptions.add(fragmentSubscription);
+    return () => environment.subscriptions.delete(fragmentSubscription);
+}
+function onNextChangeToRecord(environment, recordLink) {
+    return new Promise((resolve) => {
+        const unsubscribe = subscribeToAnyChangesToRecord(environment, recordLink, () => {
+            unsubscribe();
+            resolve();
+        });
+    });
+}
+// 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) => {
+        var _a;
+        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,
+                    });
+                    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);
+                    }
+                }
+                return;
+            }
+            case 'AnyRecords': {
+                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
+                const _ = subscription;
+                _;
+                throw new Error('Unexpected case');
+            }
+        }
+    }));
+}
+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;
+        }
+    }
+    return false;
+}
+/**
+ * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
+ */
+function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, 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, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds);
+                recordHasBeenUpdated =
+                    recordHasBeenUpdated || linkedFieldResultedInChange;
+                break;
+            }
+            case 'InlineFragment': {
+                const inlineFragmentResultedInChange = normalizeInlineFragment(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, 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) {
+        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];
+    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, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    var _a, _b;
+    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 (isScalarOrEmptyArray(networkResponseData) &&
+        !isNullOrEmptyArray(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];
+            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, 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 || link.__typename !== __typename;
+    }
+}
+/**
+ * Mutate targetParentRecord with a given linked field ast node.
+ */
+function normalizeInlineFragment(environment, astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordLink, variables, nestedRefetchQueries, mutableEncounteredIds) {
+    const typeToRefineTo = astNode.type;
+    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 (((_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;
+    }
+    else {
+        return false;
+    }
+}
+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) {
+    // 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 = data === null ||
+        typeof data === 'string' ||
+        typeof data === 'number' ||
+        typeof data === 'boolean';
+    return isScalarValue;
+}
+function isNullOrEmptyArray(data) {
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return true;
+        }
+        return data.every((x) => isNullOrEmptyArray(x));
+    }
+    return data === null;
+}
+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;
+}
+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(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 = `${parentRecordLink.__typename}:${parentRecordLink.__link}.${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/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

@@ -0,0 +1,5 @@
+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"}