@isograph/react 0.1.0 → 0.2.0

package/src/tests/garbageCollection.test.ts

@@ -0,0 +1,136 @@
+import { describe, test, expect } from 'vitest';
+import {
+  ROOT_ID,
+  createIsographEnvironment,
+} from '../core/IsographEnvironment';
+import {
+  garbageCollectEnvironment,
+  retainQuery,
+} from '../core/garbageCollection';
+import { iso } from './__isograph/iso';
+import { nodeFieldRetainedQuery } from './nodeQuery';
+
+const getDefaultStore = () => ({
+  [ROOT_ID]: {
+    me: { __link: '0' },
+    you: { __link: '1' },
+    node____id___0: {
+      __link: '0',
+    },
+  },
+  0: {
+    __typename: 'Economist',
+    id: '0',
+    name: 'Jeremy Bentham',
+    successor: { __link: '1' },
+  },
+  1: {
+    __typename: 'Economist',
+    id: '1',
+    name: 'John Stuart Mill',
+    predecessor: { __link: '0' },
+    successor: { __link: '2' },
+  },
+  2: {
+    __typename: 'Economist',
+    id: '2',
+    name: 'Henry Sidgwick',
+    predecessor: { __link: '1' },
+  },
+});
+
+export const meNameField = iso(`
+  field Query.meName {
+    me {
+      name
+    }
+  }
+`)(() => {});
+import meNameEntrypoint from './__isograph/Query/meName/entrypoint';
+import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
+iso(`entrypoint Query.meName`);
+const meNameRetainedQuery = {
+  normalizationAst: meNameEntrypoint.normalizationAst,
+  variables: {},
+};
+
+describe('garbage collection', () => {
+  test('Unreferenced records should be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[1]).not.toBe(undefined);
+
+    // TODO enable babel so we don't have to do this
+    retainQuery(environment, meNameRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[1]).toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[0]).not.toBe(undefined);
+
+    // TODO enable babel so we don't have to do this
+    retainQuery(environment, meNameRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work with variables', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[0]).not.toBe(undefined);
+
+    retainQuery(environment, nodeFieldRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work through multiple levels', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    retainQuery(environment, meNameSuccessorRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+    expect(store[1]).not.toBe(undefined);
+    expect(store[2]).not.toBe(undefined);
+  });
+
+  test('ROOT_ID should not be garbage collected, even if there are no retained queries', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+    garbageCollectEnvironment(environment);
+
+    expect(store[ROOT_ID]).not.toBe(undefined);
+    expect(store[0]).toBe(undefined);
+  });
+});

package/src/tests/isograph.config.json

@@ -0,0 +1,7 @@
+{
+  "project_root": ".",
+  "schema": "./schema.graphql",
+  "options": {
+    "on_invalid_id_type": "error"
+  }
+}

package/src/tests/meNameSuccessor.ts

@@ -0,0 +1,20 @@
+import { iso } from './__isograph/iso';
+
+export const meNameField = iso(`
+  field Query.meNameSuccessor {
+    me {
+      name
+      successor {
+        successor {
+          name
+        }
+      }
+    }
+  }
+`)(() => {});
+import meNameSuccessorEntrypoint from './__isograph/Query/meNameSuccessor/entrypoint';
+iso(`entrypoint Query.meNameSuccessor`);
+export const meNameSuccessorRetainedQuery = {
+  normalizationAst: meNameSuccessorEntrypoint.normalizationAst,
+  variables: {},
+};

package/src/tests/nodeQuery.ts

@@ -0,0 +1,17 @@
+import { iso } from './__isograph/iso';
+
+// TODO investigate why this can't be in garbageCollection.test.ts without
+// typescript incorrectly thinking it is referenced in its own initializer
+export const nodeField = iso(`
+  field Query.nodeField($id: ID!) {
+    node(id: $id) {
+      id
+    }
+  }
+`)(() => {});
+import nodeFieldEntrypoint from './__isograph/Query/nodeField/entrypoint';
+iso(`entrypoint Query.nodeField`);
+export const nodeFieldRetainedQuery = {
+  normalizationAst: nodeFieldEntrypoint.normalizationAst,
+  variables: { id: 0 },
+};

package/src/tests/schema.graphql

@@ -0,0 +1,16 @@
+type Query {
+  me: Economist!
+  you: Economist!
+  node(id: ID!): Node
+}
+
+type Economist implements Node {
+  id: ID!
+  name: String!
+  predecessor: Economist
+  successor: Economist
+}
+
+interface Node {
+  id: ID!
+}

package/src/tests/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "@isograph/react": ["../index.ts"],
+    },
+  },
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.pkg.json",
+  "compilerOptions": {
+    "noEmit": true,
+  },
+}

package/tsconfig.pkg.json

@@ -7,5 +7,6 @@
     "jsx": "react",
     "lib": ["es2017", "DOM"]
   },
-  "include": ["./**/*.ts", "./**/*.tsx"]
+  "include": ["./**/*.ts", "./**/*.tsx"],
+  "exclude": ["./src/tests/**/*"]
 }

package/dist/IsographEnvironment.d.ts

@@ -1,56 +0,0 @@
-import { ReactNode } from 'react';
-import * as React from 'react';
-import { ParentCache } from '@isograph/isograph-react-disposable-state';
-export declare const IsographEnvironmentContext: React.Context<IsographEnvironment | null>;
-type ComponentName = string;
-type StringifiedArgs = string;
-type ComponentCache = {
-    [key: DataId]: {
-        [key: ComponentName]: {
-            [key: StringifiedArgs]: React.FC<any>;
-        };
-    };
-};
-export type Subscriptions = Set<() => void>;
-type SuspenseCache = {
-    [index: string]: ParentCache<any>;
-};
-export type IsographEnvironment = {
-    store: IsographStore;
-    networkFunction: IsographNetworkFunction;
-    missingFieldHandler: MissingFieldHandler | null;
-    componentCache: ComponentCache;
-    subscriptions: Subscriptions;
-    suspenseCache: SuspenseCache;
-};
-export type MissingFieldHandler = (storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
-    [index: string]: any;
-} | null, variables: {
-    [index: string]: any;
-} | null) => Link | undefined;
-export type IsographNetworkFunction = (queryText: string, variables: object) => Promise<any>;
-export type Link = {
-    __link: DataId;
-};
-export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
-export type StoreRecord = {
-    [index: DataId | string]: DataTypeValue;
-    id?: DataId;
-};
-export type DataId = string;
-export declare const ROOT_ID: DataId & '__ROOT';
-export type IsographStore = {
-    [index: DataId]: StoreRecord | null;
-    __ROOT: StoreRecord;
-};
-export type IsographEnvironmentProviderProps = {
-    environment: IsographEnvironment;
-    children: ReactNode;
-};
-export declare function IsographEnvironmentProvider({ environment, children, }: IsographEnvironmentProviderProps): React.JSX.Element;
-export declare function useIsographEnvironment(): IsographEnvironment;
-export declare function createIsographEnvironment(store: IsographStore, networkFunction: IsographNetworkFunction, missingFieldHandler?: MissingFieldHandler): IsographEnvironment;
-export declare function createIsographStore(): {
-    __ROOT: {};
-};
-export {};

package/dist/PromiseWrapper.d.ts

@@ -1,13 +0,0 @@
-declare const NOT_SET: Symbol;
-type NotSet = typeof NOT_SET;
-/**
- * Invariant:
- * Before the promise is resolved, value becomes non-null.
- */
-export type PromiseWrapper<T> = {
-    promise: Promise<T>;
-    value: Exclude<T, NotSet> | NotSet;
-};
-export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T>;
-export declare function useReadPromise<T>(p: PromiseWrapper<T>): T;
-export {};

package/dist/PromiseWrapper.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReadPromise = exports.wrapPromise = void 0;
-const NOT_SET = Symbol('NOT_SET');
-function wrapPromise(promise) {
-    // TODO confirm suspense works if the promise is already resolved.
-    const wrapper = { promise, value: NOT_SET };
-    promise.then((v) => {
-        // T is assignable to Exclude<T, Symbol> | Symbol
-        wrapper.value = v;
-    });
-    return wrapper;
-}
-exports.wrapPromise = wrapPromise;
-function useReadPromise(p) {
-    if (p.value !== NOT_SET) {
-        // Safety: p.value is either NOT_SET or an actual value.
-        return p.value;
-    }
-    throw p.promise;
-}
-exports.useReadPromise = useReadPromise;

package/dist/cache.d.ts

@@ -1,26 +0,0 @@
-import { ItemCleanupPair, ParentCache } from '@isograph/react-disposable-state';
-import { PromiseWrapper } from './PromiseWrapper';
-import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from './index';
-import { type IsographEnvironment } from './IsographEnvironment';
-declare global {
-    interface Window {
-        __LOG: boolean;
-    }
-}
-/**
- * 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.
- */
-export declare function stableCopy<T>(value: T): T;
-type IsoResolver = IsographEntrypoint<any, any, any>;
-export declare function getOrCreateCacheForArtifact<T>(environment: IsographEnvironment, artifact: IsographEntrypoint<any, any, T>, variables: object): ParentCache<PromiseWrapper<T>>;
-export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
-export declare function subscribe(environment: IsographEnvironment, callback: () => void): () => void;
-export declare function onNextChange(environment: IsographEnvironment): Promise<void>;
-export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: {
-    [index: string]: string;
-}): string;
-export declare const FIRST_SPLIT_KEY = "____";
-export declare const SECOND_SPLIT_KEY = "___";
-export {};

package/dist/cache.js

@@ -1,274 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.makeNetworkRequest = exports.getOrCreateCacheForArtifact = exports.stableCopy = void 0;
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const PromiseWrapper_1 = require("./PromiseWrapper");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-function getOrCreateCache(environment, index, factory) {
-    if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('getting cache for', {
-            index,
-            cache: Object.keys(environment.suspenseCache),
-            found: !!environment.suspenseCache[index],
-        });
-    }
-    if (environment.suspenseCache[index] == null) {
-        environment.suspenseCache[index] = new react_disposable_state_1.ParentCache(factory);
-    }
-    return environment.suspenseCache[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;
-}
-exports.stableCopy = stableCopy;
-function getOrCreateCacheForArtifact(environment, artifact, variables) {
-    const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-    const factory = () => makeNetworkRequest(environment, artifact, variables);
-    return getOrCreateCache(environment, cacheKey, factory);
-}
-exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
-function makeNetworkRequest(environment, artifact, variables) {
-    if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('make network request', artifact, variables);
-    }
-    const promise = environment
-        .networkFunction(artifact.queryText, variables)
-        .then((networkResponse) => {
-        if (typeof window !== 'undefined' && window.__LOG) {
-            console.log('network response', artifact);
-        }
-        normalizeData(environment, artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
-        return networkResponse.data;
-    });
-    const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
-    const response = [
-        wrapper,
-        () => {
-            // delete from cache
-        },
-    ];
-    return response;
-}
-exports.makeNetworkRequest = makeNetworkRequest;
-function normalizeData(environment, normalizationAst, networkResponse, variables, nestedRefetchQueries) {
-    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);
-    if (typeof window !== 'undefined' && window.__LOG) {
-        console.log('after normalization', { store: environment.store });
-    }
-    callSubscriptions(environment);
-}
-function subscribe(environment, callback) {
-    environment.subscriptions.add(callback);
-    return () => environment.subscriptions.delete(callback);
-}
-exports.subscribe = subscribe;
-function onNextChange(environment) {
-    return new Promise((resolve) => {
-        const unsubscribe = subscribe(environment, () => {
-            unsubscribe();
-            resolve();
-        });
-    });
-}
-exports.onNextChange = onNextChange;
-function callSubscriptions(environment) {
-    environment.subscriptions.forEach((callback) => callback());
-}
-/**
- * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
- */
-function normalizeDataIntoRecord(environment, normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
-    for (const normalizationNode of normalizationAst) {
-        switch (normalizationNode.kind) {
-            case 'Scalar': {
-                normalizeScalarField(normalizationNode, networkResponseParentRecord, targetParentRecord, variables);
-                break;
-            }
-            case 'Linked': {
-                normalizeLinkedField(environment, normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
-                break;
-            }
-        }
-    }
-}
-function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreRecord, variables) {
-    const networkResponseKey = getNetworkResponseKey(astNode);
-    const networkResponseData = networkResponseParentRecord[networkResponseKey];
-    const parentRecordKey = getParentRecordKey(astNode, variables);
-    if (networkResponseData == null ||
-        isScalarOrEmptyArray(networkResponseData)) {
-        targetStoreRecord[parentRecordKey] = 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) {
-    const networkResponseKey = getNetworkResponseKey(astNode);
-    const networkResponseData = networkResponseParentRecord[networkResponseKey];
-    const parentRecordKey = getParentRecordKey(astNode, variables);
-    if (networkResponseData == null) {
-        targetParentRecord[parentRecordKey] = null;
-        return;
-    }
-    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);
-            dataIds.push({ __link: newStoreRecordId });
-        }
-        targetParentRecord[parentRecordKey] = dataIds;
-    }
-    else {
-        const newStoreRecordId = normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
-        targetParentRecord[parentRecordKey] = {
-            __link: newStoreRecordId,
-        };
-    }
-}
-function normalizeNetworkResponseObject(environment, astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
-    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);
-    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) {
-    switch (argumentValue.kind) {
-        case 'Literal': {
-            return argumentValue.value;
-            break;
-        }
-        case 'Variable': {
-            return variables[argumentValue.name];
-            break;
-        }
-        default: {
-            // TODO configure eslint to allow unused vars starting with _
-            // @ts-expect-error
-            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;
-                }
-                default: {
-                    // @ts-expect-error
-                    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/componentCache.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="react" />
-import { ReaderArtifact, RefetchQueryArtifactWrapper } from './index';
-import { IsographEnvironment, DataId } from './IsographEnvironment';
-export declare function getOrCreateCachedComponent(environment: IsographEnvironment, root: DataId, componentName: string, readerArtifact: ReaderArtifact<any, any, any>, variables: {
-    [key: string]: string;
-}, resolverRefetchQueries: RefetchQueryArtifactWrapper[]): import("react").FC<any>;

package/dist/componentCache.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOrCreateCachedComponent = void 0;
-const index_1 = require("./index");
-const cache_1 = require("./cache");
-function getOrCreateCachedComponent(environment, root, componentName, readerArtifact, variables, resolverRefetchQueries) {
-    var _a, _b, _c;
-    const cachedComponentsById = environment.componentCache;
-    const stringifiedArgs = JSON.stringify((0, cache_1.stableCopy)(variables));
-    cachedComponentsById[root] = (_a = cachedComponentsById[root]) !== null && _a !== void 0 ? _a : {};
-    const componentsByName = cachedComponentsById[root];
-    componentsByName[componentName] = (_b = componentsByName[componentName]) !== null && _b !== void 0 ? _b : {};
-    const byArgs = componentsByName[componentName];
-    byArgs[stringifiedArgs] =
-        (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
-            function Component(additionalRuntimeProps) {
-                const data = (0, index_1.readButDoNotEvaluate)(environment, {
-                    kind: 'FragmentReference',
-                    readerArtifact: readerArtifact,
-                    root,
-                    variables,
-                    nestedRefetchQueries: resolverRefetchQueries,
-                });
-                return readerArtifact.resolver(Object.assign({ data }, additionalRuntimeProps));
-            }
-            Component.displayName = `${componentName} (id: ${root}) @component`;
-            return Component;
-        })();
-    return byArgs[stringifiedArgs];
-}
-exports.getOrCreateCachedComponent = getOrCreateCachedComponent;