@isograph/react 0.1.1 → 0.3.0

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, 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>, 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(data, additionalRuntimeProps);
-            }
-            Component.displayName = `${componentName} (id: ${root}) @component`;
-            return Component;
-        })();
-    return byArgs[stringifiedArgs];
-}
-exports.getOrCreateCachedComponent = getOrCreateCachedComponent;

package/dist/useImperativeReference.d.ts

@@ -1,8 +0,0 @@
-import { UnassignedState } from '@isograph/react-disposable-state';
-import { type IsographEntrypoint, type FragmentReference, ExtractReadFromStore, ExtractResolverResult } from './index';
-export declare function useImperativeReference<TEntrypoint extends IsographEntrypoint<any, any>>(entrypoint: TEntrypoint): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>> | UnassignedState;
-    loadQueryReference: (variables: {
-        [index: string]: string;
-    }) => void;
-};

package/dist/useImperativeReference.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useImperativeReference = void 0;
-const react_disposable_state_1 = require("@isograph/react-disposable-state");
-const index_1 = require("./index");
-function useImperativeReference(entrypoint) {
-    const { state, setState } = (0, react_disposable_state_1.useUpdatableDisposableState)();
-    const environment = (0, index_1.useIsographEnvironment)();
-    return {
-        queryReference: state,
-        loadQueryReference: (variables) => {
-            const [_networkRequest, disposeNetworkRequest] = (0, index_1.makeNetworkRequest)(environment, entrypoint, variables);
-            setState([
-                {
-                    kind: 'FragmentReference',
-                    readerArtifact: entrypoint.readerArtifact,
-                    root: index_1.ROOT_ID,
-                    variables,
-                    nestedRefetchQueries: entrypoint.nestedRefetchQueries,
-                },
-                () => {
-                    disposeNetworkRequest();
-                },
-            ]);
-        },
-    };
-}
-exports.useImperativeReference = useImperativeReference;

package/src/EntrypointReader.tsx

@@ -1,20 +0,0 @@
-import * as React from 'react';
-import {
-  ExtractReadFromStore,
-  IsographEntrypoint,
-  type FragmentReference,
-  useResult,
-} from './index';
-
-export function EntrypointReader<
-  TEntrypoint extends IsographEntrypoint<any, React.FC<any>>,
->(props: {
-  queryReference: FragmentReference<
-    ExtractReadFromStore<TEntrypoint>,
-    React.FC<any>
-  >;
-  additionalProps?: any | void;
-}): ReturnType<React.FC<any>> {
-  const Component = useResult(props.queryReference);
-  return <Component {...props.additionalProps} />;
-}

package/src/IsographEnvironment.tsx

@@ -1,120 +0,0 @@
-import { ReactNode, createContext, useContext } from 'react';
-import * as React from 'react';
-import { ParentCache } from '@isograph/isograph-react-disposable-state';
-
-export const IsographEnvironmentContext =
-  createContext<IsographEnvironment | null>(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 =
-  // N.B. undefined is here to support optional id's, but
-  // undefined should not *actually* be present in the store.
-  | undefined
-  // Singular scalar fields:
-  | number
-  | boolean
-  | string
-  | null
-  // Singular linked fields:
-  | Link
-  // Plural scalar and linked fields:
-  | DataTypeValue[];
-
-export type StoreRecord = {
-  [index: DataId | string]: DataTypeValue;
-  // TODO __typename?: T, which is restricted to being a concrete string
-  // TODO this shouldn't always be named id
-  id?: DataId;
-};
-
-export type DataId = string;
-
-export const ROOT_ID: DataId & '__ROOT' = '__ROOT';
-
-export type IsographStore = {
-  [index: DataId]: StoreRecord | null;
-  __ROOT: StoreRecord;
-};
-
-export type IsographEnvironmentProviderProps = {
-  environment: IsographEnvironment;
-  children: ReactNode;
-};
-
-export function IsographEnvironmentProvider({
-  environment,
-  children,
-}: IsographEnvironmentProviderProps) {
-  return (
-    <IsographEnvironmentContext.Provider value={environment}>
-      {children}
-    </IsographEnvironmentContext.Provider>
-  );
-}
-
-export function useIsographEnvironment(): IsographEnvironment {
-  const context = useContext(IsographEnvironmentContext);
-  if (context == null) {
-    throw new Error(
-      'Unexpected null environment context. Make sure to render ' +
-        'this component within an IsographEnvironmentProvider component',
-    );
-  }
-  return context;
-}
-
-export function createIsographEnvironment(
-  store: IsographStore,
-  networkFunction: IsographNetworkFunction,
-  missingFieldHandler?: MissingFieldHandler,
-): IsographEnvironment {
-  return {
-    store,
-    networkFunction,
-    missingFieldHandler: missingFieldHandler ?? null,
-    componentCache: {},
-    subscriptions: new Set(),
-    suspenseCache: {},
-  };
-}
-
-export function createIsographStore() {
-  return {
-    [ROOT_ID]: {},
-  };
-}

package/src/PromiseWrapper.ts

@@ -1,29 +0,0 @@
-const NOT_SET: Symbol = Symbol('NOT_SET');
-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 function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T> {
-  // TODO confirm suspense works if the promise is already resolved.
-  const wrapper: PromiseWrapper<T> = { promise, value: NOT_SET };
-  promise.then((v) => {
-    // T is assignable to Exclude<T, Symbol> | Symbol
-    wrapper.value = v as any;
-  });
-  return wrapper;
-}
-
-export function useReadPromise<T>(p: PromiseWrapper<T>): T {
-  if (p.value !== NOT_SET) {
-    // Safety: p.value is either NOT_SET or an actual value.
-    return p.value as any;
-  }
-  throw p.promise;
-}