@isograph/react 0.0.0-main-55364d41 → 0.0.0-main-2c275831

package/dist/PromiseWrapper.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useReadPromise = exports.wrapPromise = void 0;
-const NOT_SET = Symbol("NOT_SET");
+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 };

package/dist/cache.d.ts

@@ -1,6 +1,6 @@
-import { ItemCleanupPair, ParentCache } from "@isograph/react-disposable-state";
-import { PromiseWrapper } from "./PromiseWrapper";
-import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from "./index";
+import { ItemCleanupPair, ParentCache } from '@isograph/react-disposable-state';
+import { PromiseWrapper } from './PromiseWrapper';
+import { IsographEntrypoint, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from './index';
 declare global {
     interface Window {
         __LOG: boolean;
@@ -26,7 +26,7 @@ export type StoreRecord = {
     id?: DataId;
 };
 export type DataId = string;
-export declare const ROOT_ID: DataId & "__ROOT";
+export declare const ROOT_ID: DataId & '__ROOT';
 export declare function getStore(): {
     [index: string]: StoreRecord | null;
     __ROOT: StoreRecord;

package/dist/cache.js

@@ -5,8 +5,8 @@ const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const PromiseWrapper_1 = require("./PromiseWrapper");
 const cache = {};
 function getOrCreateCache(index, factory) {
-    if (typeof window !== "undefined" && window.__LOG) {
-        console.log("getting cache for", {
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('getting cache for', {
             index,
             cache: Object.keys(cache),
             found: !!cache[index],
@@ -23,7 +23,7 @@ function getOrCreateCache(index, factory) {
  * results.
  */
 function stableCopy(value) {
-    if (!value || typeof value !== "object") {
+    if (!value || typeof value !== 'object') {
         return value;
     }
     if (Array.isArray(value)) {
@@ -52,15 +52,15 @@ function setNetwork(newNetwork) {
 }
 exports.setNetwork = setNetwork;
 function makeNetworkRequest(artifact, variables) {
-    if (typeof window !== "undefined" && window.__LOG) {
-        console.log("make network request", artifact, variables);
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('make network request', artifact, variables);
     }
     if (network == null) {
-        throw new Error("Network must be set before makeNetworkRequest is called");
+        throw new Error('Network must be set before makeNetworkRequest is called');
     }
     const promise = network(artifact.queryText, variables).then((networkResponse) => {
-        if (typeof window !== "undefined" && window.__LOG) {
-            console.log("network response", artifact);
+        if (typeof window !== 'undefined' && window.__LOG) {
+            console.log('network response', artifact);
         }
         normalizeData(artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
         return networkResponse.data;
@@ -75,7 +75,7 @@ function makeNetworkRequest(artifact, variables) {
     return response;
 }
 exports.makeNetworkRequest = makeNetworkRequest;
-exports.ROOT_ID = "__ROOT";
+exports.ROOT_ID = '__ROOT';
 let store = {
     __ROOT: {},
 };
@@ -90,12 +90,12 @@ function clearStore() {
 }
 exports.clearStore = clearStore;
 function normalizeData(normalizationAst, networkResponse, variables, nestedRefetchQueries) {
-    if (typeof window !== "undefined" && window.__LOG) {
-        console.log("about to normalize", normalizationAst, networkResponse, variables);
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('about to normalize', normalizationAst, networkResponse, variables);
     }
     normalizeDataIntoRecord(normalizationAst, networkResponse, store.__ROOT, exports.ROOT_ID, variables, nestedRefetchQueries);
-    if (typeof window !== "undefined" && window.__LOG) {
-        console.log("after normalization", { store });
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('after normalization', { store });
     }
     callSubscriptions();
 }
@@ -123,11 +123,11 @@ function callSubscriptions() {
 function normalizeDataIntoRecord(normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
     for (const normalizationNode of normalizationAst) {
         switch (normalizationNode.kind) {
-            case "Scalar": {
+            case 'Scalar': {
                 normalizeScalarField(normalizationNode, networkResponseParentRecord, targetParentRecord, variables);
                 break;
             }
-            case "Linked": {
+            case 'Linked': {
                 normalizeLinkedField(normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
                 break;
             }
@@ -138,12 +138,11 @@ function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreR
     const networkResponseKey = getNetworkResponseKey(astNode);
     const networkResponseData = networkResponseParentRecord[networkResponseKey];
     const parentRecordKey = getParentRecordKey(astNode, variables);
-    if (networkResponseData == null ||
-        isScalarOrEmptyArray(networkResponseData)) {
+    if (networkResponseData == null || isScalarOrEmptyArray(networkResponseData)) {
         targetStoreRecord[parentRecordKey] = networkResponseData;
     }
     else {
-        throw new Error("Unexpected object array when normalizing scalar");
+        throw new Error('Unexpected object array when normalizing scalar');
     }
 }
 /**
@@ -158,7 +157,7 @@ function normalizeLinkedField(astNode, networkResponseParentRecord, targetParent
         return;
     }
     if (isScalarButNotEmptyArray(networkResponseData)) {
-        throw new Error("Unexpected scalar network response when normalizing a linked field");
+        throw new Error('Unexpected scalar network response when normalizing a linked field');
     }
     if (Array.isArray(networkResponseData)) {
         // TODO check astNode.plural or the like
@@ -191,9 +190,7 @@ function isScalarOrEmptyArray(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";
+    const isScalarValue = typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean';
     return isScalarValue;
 }
 function isScalarButNotEmptyArray(data) {
@@ -205,9 +202,7 @@ function isScalarButNotEmptyArray(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";
+    const isScalarValue = typeof data === 'string' || typeof data === 'number' || typeof data === 'boolean';
     return isScalarValue;
 }
 function getParentRecordKey(astNode, variables) {
@@ -215,28 +210,62 @@ function getParentRecordKey(astNode, variables) {
     const fieldParameters = astNode.arguments;
     if (fieldParameters != null) {
         for (const fieldParameter of fieldParameters) {
-            const { argumentName, variableName } = fieldParameter;
-            const valueToUse = variables[variableName];
-            parentRecordKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${valueToUse}`;
+            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 _
+            let _ = 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, variableName } = fieldParameter;
-            networkResponseKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${variableName}`;
+            const [argumentName, argumentValue] = fieldParameter;
+            let argumentValueChunk;
+            switch (argumentValue.kind) {
+                case 'Literal': {
+                    argumentValueChunk = 'l_' + argumentValue.value;
+                    break;
+                }
+                case 'Variable': {
+                    argumentValueChunk = 'v_' + argumentValue.name;
+                    break;
+                }
+                default: {
+                    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 = "___";
+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.
@@ -254,9 +283,7 @@ function getDataIdOfNetworkResponse(parentRecordId, dataToNormalize, astNode, va
         return storeKey;
     }
     for (const fieldParameter of fieldParameters) {
-        const { argumentName, variableName } = fieldParameter;
-        const valueToUse = variables[variableName];
-        storeKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${valueToUse}`;
+        storeKey += getStoreKeyChunkForArgument(fieldParameter, variables);
     }
     return storeKey;
 }

package/dist/componentCache.d.ts

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

package/dist/componentCache.js

@@ -15,7 +15,7 @@ function getOrCreateCachedComponent(root, componentName, readerArtifact, variabl
         (_c = byArgs[stringifiedArgs]) !== null && _c !== void 0 ? _c : (() => {
             function Component(additionalRuntimeProps) {
                 const data = (0, index_1.readButDoNotEvaluate)({
-                    kind: "FragmentReference",
+                    kind: 'FragmentReference',
                     readerArtifact: readerArtifact,
                     root,
                     variables,

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { DataId, StoreRecord, Link } from "./cache";
-export { setNetwork, makeNetworkRequest, subscribe, DataId, Link, StoreRecord, clearStore, } from "./cache";
+import { DataId, StoreRecord, Link } from './cache';
+export { setNetwork, makeNetworkRequest, subscribe, DataId, Link, StoreRecord, clearStore, } from './cache';
 export type IsographEntrypoint<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
-    kind: "Entrypoint";
+    kind: 'Entrypoint';
     queryText: string;
     normalizationAst: NormalizationAst;
     readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
     nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
 export type ReaderArtifact<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
-    kind: "ReaderArtifact";
+    kind: 'ReaderArtifact';
     readerAst: ReaderAst<TReadFromStore>;
     resolver: (data: TResolverProps) => TResolverResult;
     variant: ReaderResolverVariant;
@@ -16,39 +16,39 @@ export type ReaderArtifact<TReadFromStore extends Object, TResolverProps, TResol
 export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
 export type ReaderAst<TReadFromStore> = ReaderAstNode[];
 export type ReaderScalarField = {
-    kind: "Scalar";
+    kind: 'Scalar';
     fieldName: string;
     alias: string | null;
     arguments: Arguments | null;
 };
 export type ReaderLinkedField = {
-    kind: "Linked";
+    kind: 'Linked';
     fieldName: string;
     alias: string | null;
     selections: ReaderAst<unknown>;
     arguments: Arguments | null;
 };
 export type ReaderResolverVariant = {
-    kind: "Eager";
+    kind: 'Eager';
 } | {
-    kind: "Component";
+    kind: 'Component';
     componentName: string;
 };
 export type ReaderResolverField = {
-    kind: "Resolver";
+    kind: 'Resolver';
     alias: string;
     readerArtifact: ReaderArtifact<any, any, any>;
     arguments: Arguments | null;
     usedRefetchQueries: number[];
 };
 export type ReaderRefetchField = {
-    kind: "RefetchField";
+    kind: 'RefetchField';
     alias: string;
     readerArtifact: ReaderArtifact<any, any, any>;
     refetchQuery: number;
 };
 export type ReaderMutationField = {
-    kind: "MutationField";
+    kind: 'MutationField';
     alias: string;
     readerArtifact: ReaderArtifact<any, any, any>;
     refetchQuery: number;
@@ -57,18 +57,18 @@ export type ReaderMutationField = {
 export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
 export type NormalizationAst = NormalizationAstNode[];
 export type NormalizationScalarField = {
-    kind: "Scalar";
+    kind: 'Scalar';
     fieldName: string;
     arguments: Arguments | null;
 };
 export type NormalizationLinkedField = {
-    kind: "Linked";
+    kind: 'Linked';
     fieldName: string;
     arguments: Arguments | null;
     selections: NormalizationAst;
 };
 export type RefetchQueryArtifact = {
-    kind: "RefetchQuery";
+    kind: 'RefetchQuery';
     queryText: string;
     normalizationAst: NormalizationAst;
 };
@@ -77,12 +77,17 @@ export type RefetchQueryArtifactWrapper = {
     allowedVariables: string[];
 };
 export type Arguments = Argument[];
-export type Argument = {
-    argumentName: string;
-    variableName: string;
+export type Argument = [ArgumentName, ArgumentValue];
+export type ArgumentName = string;
+export type ArgumentValue = {
+    kind: 'Variable';
+    name: string;
+} | {
+    kind: 'Literal';
+    value: any;
 };
 export type FragmentReference<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
-    kind: "FragmentReference";
+    kind: 'FragmentReference';
     readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
     root: DataId;
     variables: {
@@ -90,9 +95,12 @@ export type FragmentReference<TReadFromStore extends Object, TResolverProps, TRe
     } | null;
     nestedRefetchQueries: RefetchQueryArtifactWrapper[];
 };
-export declare function iso<TResolverParameter, TResolverReturn = TResolverParameter>(_queryText: TemplateStringsArray): (x: (param: TResolverParameter) => TResolverReturn) => (param: TResolverParameter) => TResolverReturn;
-export declare function useLazyReference<TReadFromStore extends Object, TResolverProps, TResolverResult>(entrypoint: IsographEntrypoint<TReadFromStore, TResolverProps, TResolverResult> | typeof iso, variables: object): {
-    queryReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>;
+export declare function iso<TResolverParameter>(_queryText: TemplateStringsArray): <TResolverReturn>(x: (param: TResolverParameter) => TResolverReturn) => (param: TResolverParameter) => TResolverReturn;
+type ExtractTReadFromStore<Type> = Type extends IsographEntrypoint<infer X, any, any> ? X : never;
+type ExtractResolverProps<Type> = Type extends IsographEntrypoint<any, infer X, any> ? X : never;
+type ExtractResolverResult<Type> = Type extends IsographEntrypoint<any, any, infer X> ? X : never;
+export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: object): {
+    queryReference: FragmentReference<ExtractTReadFromStore<TEntrypoint>, ExtractResolverProps<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
 };
 export declare function read<TReadFromStore extends Object, TResolverProps, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>): TResolverResult;
 export declare function readButDoNotEvaluate<TReadFromStore extends Object>(reference: FragmentReference<TReadFromStore, unknown, unknown>): TReadFromStore;