houdini 1.0.0-next.0 → 1.0.0-next.2

package/build/runtime-cjs/imports/config.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var config_default = {};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/build/runtime-cjs/index.d.ts

@@ -1,6 +1,7 @@
-import { Cache as InternalCache } from './cache/cache';
+import type { Cache as InternalCache } from './cache/cache';
 import type { CacheTypeDef } from './generated';
 import { Cache } from './public';
+export * from './client';
 export * from './lib';
 export declare function graphql(str: string | TemplateStringsArray): any;
 export declare const cache: Cache<CacheTypeDef>;

package/build/runtime-cjs/index.js

@@ -32,6 +32,7 @@ __export(runtime_exports, {
 module.exports = __toCommonJS(runtime_exports);
 var import_cache = __toESM(require("./cache"), 1);
 var import_public = require("./public");
+__reExport(runtime_exports, require("./client"), module.exports);
 __reExport(runtime_exports, require("./lib"), module.exports);
 function graphql(str) {
   if (globalThis?.process?.env?.HOUDINI_PLUGIN) {

package/build/runtime-cjs/lib/config.d.ts

@@ -1,11 +1,11 @@
-import { GraphQLSchema } from 'graphql';
-import { CachePolicy } from './types';
+import type { GraphQLSchema } from 'graphql';
+import type { CachePolicy } from './types';
 export declare function getMockConfig(): ConfigFile | null;
 export declare function setMockConfig(config: ConfigFile | null): void;
 export declare function defaultConfigValues(file: ConfigFile): ConfigFile;
 export declare function keyFieldsForType(configFile: ConfigFile, type: string): string[];
 export declare function computeID(configFile: ConfigFile, type: string, data: any): string;
-export declare function getCurrentConfig(): Promise<ConfigFile>;
+export declare function getCurrentConfig(): ConfigFile;
 export type ConfigFile = {
     /**
      * A glob pointing to all files that houdini should consider. Note, this must include .js files
@@ -140,4 +140,6 @@ export type ScalarSpec = {
 };
 export interface HoudiniPluginConfig {
 }
+export interface HoudiniClientPluginConfig {
+}
 export {};

package/build/runtime-cjs/lib/config.js

@@ -32,12 +32,13 @@ __export(config_exports, {
   setMockConfig: () => setMockConfig
 });
 module.exports = __toCommonJS(config_exports);
+var import_config = __toESM(require("../imports/config"), 1);
 let mockConfig = null;
 function getMockConfig() {
   return mockConfig;
 }
-function setMockConfig(config) {
-  mockConfig = config;
+function setMockConfig(config2) {
+  mockConfig = config2;
 }
 function defaultConfigValues(file) {
   return {
@@ -66,12 +67,12 @@ function computeID(configFile, type, data) {
   }
   return id.slice(0, -2);
 }
-async function getCurrentConfig() {
+function getCurrentConfig() {
   const mockConfig2 = getMockConfig();
   if (mockConfig2) {
     return mockConfig2;
   }
-  return defaultConfigValues((await import("HOUDINI_CONFIG_PATH")).default);
+  return defaultConfigValues(import_config.default);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/build/runtime-cjs/lib/index.d.ts

@@ -1,8 +1,7 @@
 export * from './config';
 export * from './constants';
 export * from './deepEquals';
-export * from './errors';
 export * from './log';
-export * from './network';
 export * from './scalars';
 export * from './types';
+export * from './store';

package/build/runtime-cjs/lib/index.js

@@ -18,8 +18,7 @@ module.exports = __toCommonJS(lib_exports);
 __reExport(lib_exports, require("./config"), module.exports);
 __reExport(lib_exports, require("./constants"), module.exports);
 __reExport(lib_exports, require("./deepEquals"), module.exports);
-__reExport(lib_exports, require("./errors"), module.exports);
 __reExport(lib_exports, require("./log"), module.exports);
-__reExport(lib_exports, require("./network"), module.exports);
 __reExport(lib_exports, require("./scalars"), module.exports);
 __reExport(lib_exports, require("./types"), module.exports);
+__reExport(lib_exports, require("./store"), module.exports);

package/build/runtime-cjs/lib/scalars.d.ts

@@ -1,14 +1,15 @@
-import { ConfigFile } from './config';
-import { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
+import type { ConfigFile } from './config';
+import type { MutationArtifact, QueryArtifact, SubscriptionArtifact, SubscriptionSelection } from './types';
 export declare function marshalSelection({ selection, data, }: {
     selection: SubscriptionSelection;
     data: any;
 }): Promise<{} | null | undefined>;
-export declare function marshalInputs<T>({ artifact, input, rootType, }: {
+export declare function marshalInputs<T>({ artifact, input, config, rootType, }: {
     artifact: QueryArtifact | MutationArtifact | SubscriptionArtifact;
     input: unknown;
     rootType?: string;
-}): Promise<{} | null | undefined>;
+    config: ConfigFile;
+}): {} | null | undefined;
 export declare function unmarshalSelection(config: ConfigFile, selection: SubscriptionSelection, data: any): {} | null | undefined;
 export declare function isScalar(config: ConfigFile, type: string): boolean;
 export declare function parseScalar(config: ConfigFile, type: string, value: string): string | number | boolean;

package/build/runtime-cjs/lib/scalars.js

@@ -31,7 +31,7 @@ async function marshalSelection({
   selection,
   data
 }) {
-  const config = await (0, import_config.getCurrentConfig)();
+  const config = (0, import_config.getCurrentConfig)();
   if (data === null || typeof data === "undefined") {
     return data;
   }
@@ -66,12 +66,12 @@ async function marshalSelection({
     )
   );
 }
-async function marshalInputs({
+function marshalInputs({
   artifact,
   input,
+  config,
   rootType = "@root"
 }) {
-  const config = await (0, import_config.getCurrentConfig)();
   if (input === null || typeof input === "undefined") {
     return input;
   }
@@ -80,30 +80,26 @@ async function marshalInputs({
   }
   const fields = rootType === "@root" ? artifact.input.fields : artifact.input.types[rootType];
   if (Array.isArray(input)) {
-    return await Promise.all(
-      input.map(async (val) => await marshalInputs({ artifact, input: val, rootType }))
-    );
+    return input.map((val) => marshalInputs({ artifact, input: val, rootType, config }));
   }
   return Object.fromEntries(
-    await Promise.all(
-      Object.entries(input).map(async ([fieldName, value]) => {
-        const type = fields?.[fieldName];
-        if (!type) {
-          return [fieldName, value];
-        }
-        const marshalFn = config.scalars?.[type]?.marshal;
-        if (marshalFn) {
-          if (Array.isArray(value)) {
-            return [fieldName, value.map(marshalFn)];
-          }
-          return [fieldName, marshalFn(value)];
-        }
-        if (isScalar(config, type) || !artifact.input.types[type]) {
-          return [fieldName, value];
+    Object.entries(input).map(([fieldName, value]) => {
+      const type = fields?.[fieldName];
+      if (!type) {
+        return [fieldName, value];
+      }
+      const marshalFn = config.scalars?.[type]?.marshal;
+      if (marshalFn) {
+        if (Array.isArray(value)) {
+          return [fieldName, value.map(marshalFn)];
         }
-        return [fieldName, await marshalInputs({ artifact, input: value, rootType: type })];
-      })
-    )
+        return [fieldName, marshalFn(value)];
+      }
+      if (isScalar(config, type) || !artifact.input.types[type]) {
+        return [fieldName, value];
+      }
+      return [fieldName, marshalInputs({ artifact, input: value, rootType: type, config })];
+    })
   );
 }
 function unmarshalSelection(config, selection, data) {

package/build/runtime-cjs/lib/selection.d.ts

@@ -1,2 +1,2 @@
-import { SubscriptionSelection } from './types';
+import type { SubscriptionSelection } from './types';
 export declare function getFieldsForType(selection: SubscriptionSelection, __typename: string | undefined | null): Required<SubscriptionSelection>['fields'];

package/build/runtime-cjs/lib/store.d.ts

@@ -0,0 +1,19 @@
+export declare class Writable<T> {
+    #private;
+    state: T;
+    constructor(value: T, start?: StartStopNotifier<T>);
+    set(new_value: T): void;
+    update(fn: Updater<T>): void;
+    subscribe(run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+/** Start and stop notification callbacks. */
+type StartStopNotifier<T> = (set: Subscriber<T>) => Unsubscriber | void;
+/** Callback to inform of a value updates. */
+export type Subscriber<T> = (value: T) => void;
+/** Unsubscribes from value updates. */
+export type Unsubscriber = () => void;
+/** Callback to update a value. */
+type Updater<T> = (value: T) => T;
+/** Cleanup logic callback. */
+type Invalidator<T> = (value?: T) => void;
+export {};

package/build/runtime-cjs/lib/store.js

@@ -0,0 +1,81 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_exports = {};
+__export(store_exports, {
+  Writable: () => Writable
+});
+module.exports = __toCommonJS(store_exports);
+const subscriber_queue = [];
+const noop = () => {
+};
+class Writable {
+  state;
+  #subscribers;
+  #stop;
+  #start;
+  constructor(value, start = noop) {
+    this.state = value;
+    this.#subscribers = /* @__PURE__ */ new Set();
+    this.#stop = null;
+    this.#start = start;
+  }
+  set(new_value) {
+    if (safe_not_equal(this.state, new_value)) {
+      this.state = new_value;
+      if (this.#stop) {
+        const run_queue = !subscriber_queue.length;
+        for (const subscriber of this.#subscribers) {
+          subscriber[1]();
+          subscriber_queue.push(subscriber, this.state);
+        }
+        if (run_queue) {
+          for (let i = 0; i < subscriber_queue.length; i += 2) {
+            subscriber_queue[i][0](subscriber_queue[i + 1]);
+          }
+          subscriber_queue.length = 0;
+        }
+      }
+    }
+  }
+  update(fn) {
+    this.set(fn(this.state));
+  }
+  subscribe(run, invalidate = noop) {
+    const subscriber = [run, invalidate];
+    this.#subscribers.add(subscriber);
+    if (this.#subscribers.size === 1) {
+      this.#stop = this.#start(this.set) || noop;
+    }
+    run(this.state);
+    return () => {
+      this.#subscribers.delete(subscriber);
+      if (this.#subscribers.size === 0) {
+        this.#stop?.();
+        this.#stop = null;
+      }
+    };
+  }
+}
+function safe_not_equal(a, b) {
+  return a != a ? b == b : a !== b || a && typeof a === "object" || typeof a === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Writable
+});

package/build/runtime-cjs/lib/types.d.ts

@@ -4,6 +4,22 @@ export declare enum CachePolicy {
     NetworkOnly = "NetworkOnly",
     CacheAndNetwork = "CacheAndNetwork"
 }
+declare global {
+    namespace App {
+        interface Session {
+        }
+        interface Metadata {
+        }
+        interface Stuff {
+            inputs: {
+                init: boolean;
+                marshaled: Record<string, any>;
+                changed: boolean;
+            };
+            optimisticResponse?: GraphQLObject;
+        }
+    }
+}
 export type Fragment<_Result> = {
     readonly shape?: _Result;
 };
@@ -65,6 +81,7 @@ export type BaseCompiledDocument = {
         paginated: boolean;
         direction?: 'forward' | 'backwards';
     };
+    pluginsData?: Record<string, any>;
 };
 export type HoudiniFetchContext = {
     variables: () => {};
@@ -150,7 +167,7 @@ export type FetchQueryResult<_Data> = {
     source: DataSource | null;
     partial: boolean;
 };
-export type QueryResult<_Data, _Input, _Extra = {}> = {
+export type QueryResult<_Data = GraphQLObject, _Input = Record<string, any>> = {
     data: _Data | null;
     errors: {
         message: string;
@@ -158,16 +175,12 @@ export type QueryResult<_Data, _Input, _Extra = {}> = {
     fetching: boolean;
     partial: boolean;
     source: DataSource | null;
-    variables: _Input;
-} & _Extra;
-export type RequestPayload<_Data = any> = {
-    data: _Data | null;
+    variables: _Input | null;
+};
+export type RequestPayload<GraphQLObject = any> = {
+    data: GraphQLObject | null;
     errors: {
         message: string;
     }[] | null;
 };
-export type RequestPayloadMagic<_Data = any> = {
-    ssr: boolean;
-    body: RequestPayload<_Data>;
-};
 export {};

package/build/runtime-cjs/public/cache.d.ts

@@ -1,5 +1,5 @@
-import { Cache as _Cache } from '../cache/cache';
-import { SchemaManager, TypeInfo } from '../cache/schema';
+import type { Cache as _Cache } from '../cache/cache';
+import type { SchemaManager, TypeInfo } from '../cache/schema';
 import { ListCollection } from './list';
 import { Record } from './record';
 import type { CacheTypeDef, IDFields, TypeNames, ValidLists } from './types';

package/build/runtime-cjs/public/list.d.ts

@@ -1,5 +1,5 @@
-import { Cache } from './cache';
-import { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
+import type { Cache } from './cache';
+import type { CacheTypeDef, ListType, ValidLists, ListFilters } from './types';
 export declare class ListCollection<Def extends CacheTypeDef, ListName extends ValidLists<Def>> {
     #private;
     constructor({ parentID, allLists, when, cache, name, }: {

package/build/runtime-cjs/public/list.js

@@ -21,7 +21,7 @@ __export(list_exports, {
   ListCollection: () => ListCollection
 });
 module.exports = __toCommonJS(list_exports);
-var import_lib = require("../lib");
+var import_config = require("../lib/config");
 var import_cache = require("./cache");
 var import_record = require("./record");
 class ListCollection {
@@ -130,7 +130,7 @@ class ListCollection {
       if (!(record instanceof import_record.Record)) {
         throw new Error("You must provide a Record to a list operation");
       }
-      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, record.type);
+      const keys = (0, import_config.keyFieldsForType)(this.#cache.config, record.type);
       selection.abstractFields.fields[record.type] = keys.reduce(
         (acc, key) => {
           const keyInfo = (0, import_cache._typeInfo)(this.#cache, record.type, key);

package/build/runtime-cjs/public/record.d.ts

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 import type { ArgType, CacheTypeDef, FieldType, TypeFieldNames, ValidTypes } from './types';
 export declare class Record<Def extends CacheTypeDef, Type extends ValidTypes<Def>> {
     #private;

package/build/runtime-cjs/public/record.js

@@ -25,7 +25,7 @@ __export(record_exports, {
 });
 module.exports = __toCommonJS(record_exports);
 var import_cache = require("../cache/cache");
-var import_lib = require("../lib");
+var import_config = require("../lib/config");
 var import_cache2 = require("./cache");
 class Record {
   #id;
@@ -43,7 +43,7 @@ class Record {
     this.type = type;
     this.idFields = idFields;
     if (id !== import_cache.rootID) {
-      for (const key of (0, import_lib.keyFieldsForType)(this.#cache.config, type)) {
+      for (const key of (0, import_config.keyFieldsForType)(this.#cache.config, type)) {
         if (!(key in idFields)) {
           throw new Error("Missing key in idFields: " + key);
         }
@@ -60,7 +60,7 @@ class Record {
     const typeInfo = (0, import_cache2._typeInfo)(this.#cache, this.type, field);
     let newValue;
     if (typeInfo.link) {
-      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, typeInfo.type);
+      const keys = (0, import_config.keyFieldsForType)(this.#cache.config, typeInfo.type);
       typeInfo.selection = {
         fields: keys.reduce(
           (acc, key2) => {
@@ -123,7 +123,7 @@ class Record {
     const key = computeKey({ field, args });
     const typeInfo = (0, import_cache2._typeInfo)(this.#cache, this.type, field);
     if (typeInfo.link) {
-      const keys = (0, import_lib.keyFieldsForType)(this.#cache.config, typeInfo.type);
+      const keys = (0, import_config.keyFieldsForType)(this.#cache.config, typeInfo.type);
       typeInfo.selection = {
         fields: keys.reduce(
           (acc, key2) => {

package/build/runtime-cjs/public/tests/test.d.ts

@@ -1,5 +1,5 @@
 import { Cache } from '../cache';
-import { Record } from '../record';
+import type { Record } from '../record';
 type CacheTypeDef = {
     types: {
         __ROOT__: {

package/build/runtime-esm/cache/cache.d.ts

@@ -1,10 +1,12 @@
-import { ConfigFile } from '../lib/config';
-import { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
+import type { ConfigFile } from '../lib/config';
+import type { GraphQLObject, GraphQLValue, SubscriptionSelection, SubscriptionSpec } from '../lib/types';
 import { GarbageCollector } from './gc';
-import { ListCollection, ListManager } from './lists';
+import type { ListCollection } from './lists';
+import { ListManager } from './lists';
 import { SchemaManager } from './schema';
-import { InMemoryStorage, Layer, LayerID } from './storage';
-import { InMemorySubscriptions } from './subscription';
+import type { Layer, LayerID } from './storage';
+import { InMemoryStorage } from './storage';
+import { type FieldSelection, InMemorySubscriptions } from './subscription';
 export declare class Cache {
     _internal_unstable: CacheInternal;
     constructor(config?: ConfigFile);
@@ -59,10 +61,10 @@ declare class CacheInternal {
         parent?: string;
         root?: string;
         layer: Layer;
-        toNotify?: SubscriptionSpec[];
+        toNotify?: FieldSelection[];
         applyUpdates?: boolean;
         forceNotify?: boolean;
-    }): SubscriptionSpec[];
+    }): FieldSelection[];
     getSelection({ selection, parent, variables, stepsFromConnection, }: {
         selection: SubscriptionSelection;
         parent?: string;
@@ -94,7 +96,7 @@ declare class CacheInternal {
         linkedType: string;
         abstract: boolean;
         variables: {};
-        specs: SubscriptionSpec[];
+        specs: FieldSelection[];
         applyUpdates: boolean;
         fields: SubscriptionSelection;
         layer: Layer;

package/build/runtime-esm/cache/cache.js

@@ -28,7 +28,7 @@ class Cache {
     ...args
   }) {
     const layer = layerID ? this._internal_unstable.storage.getLayer(layerID) : this._internal_unstable.storage.topLayer;
-    const subscribers = this._internal_unstable.writeSelection({ ...args, layer });
+    const subscribers = this._internal_unstable.writeSelection({ ...args, layer }).map((sub) => sub[0]);
     const notified = [];
     for (const spec of subscribers.concat(notifySubscribers)) {
       if (!notified.includes(spec.set)) {
@@ -166,6 +166,7 @@ class CacheInternal {
         link: !!fieldSelection
       });
       const currentSubscribers = this.subscriptions.get(parent, key);
+      const specs = currentSubscribers.map((sub) => sub[0]);
       const { value: previousValue, displayLayers } = this.storage.get(parent, key);
       const displayLayer = layer.isDisplayLayer(displayLayers);
       if (displayLayer) {
@@ -191,7 +192,7 @@ class CacheInternal {
         }
         const previousLinks = flattenList([previousValue]);
         for (const link of previousLinks) {
-          this.subscriptions.remove(link, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(link, fieldSelection, specs, variables);
         }
         layer.writeLink(parent, key, null);
         toNotify.push(...currentSubscribers);
@@ -215,16 +216,10 @@ class CacheInternal {
         layer.writeLink(parent, key, linkedID);
         if (linkedID && displayLayer && (linkChange || forceNotify)) {
           if (previousValue && typeof previousValue === "string") {
-            this.subscriptions.remove(
-              previousValue,
-              fieldSelection,
-              currentSubscribers,
-              variables
-            );
+            this.subscriptions.remove(previousValue, fieldSelection, specs, variables);
           }
           this.subscriptions.addMany({
             parent: linkedID,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType
@@ -319,7 +314,7 @@ class CacheInternal {
           if (linkedIDs.includes(lostID) || !lostID) {
             continue;
           }
-          this.subscriptions.remove(lostID, fieldSelection, currentSubscribers, variables);
+          this.subscriptions.remove(lostID, fieldSelection, specs, variables);
         }
         if (contentChanged || oldIDs.length === 0 && newIDs.length === 0) {
           layer.writeLink(parent, key, linkedIDs);
@@ -330,7 +325,6 @@ class CacheInternal {
           }
           this.subscriptions.addMany({
             parent: id,
-            selection: fieldSelection,
             subscribers: currentSubscribers,
             variables,
             parentType: linkedType

package/build/runtime-esm/cache/gc.d.ts

@@ -1,4 +1,4 @@
-import { Cache } from './cache';
+import type { Cache } from './cache';
 export declare class GarbageCollector {
     cache: Cache;
     private lifetimes;

package/build/runtime-esm/cache/lists.d.ts

@@ -1,5 +1,5 @@
-import { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
-import { Cache } from './cache';
+import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
+import type { Cache } from './cache';
 export declare class ListManager {
     rootID: string;
     cache: Cache;

package/build/runtime-esm/cache/lists.js

@@ -257,11 +257,11 @@ class List {
     this.cache._internal_unstable.subscriptions.remove(
       targetID,
       this.connection ? this.selection.fields.edges.selection : this.selection,
-      subscribers,
+      subscribers.map((sub) => sub[0]),
       variables
     );
     this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID);
-    for (const spec of subscribers) {
+    for (const [spec] of subscribers) {
       spec.set(
         this.cache._internal_unstable.getSelection({
           parent: spec.parentID || this.manager.rootID,

package/build/runtime-esm/cache/schema.d.ts

@@ -1,5 +1,5 @@
-import { ConfigFile } from '../lib';
-import { Cache } from './cache';
+import type { ConfigFile } from '../lib/config';
+import type { Cache } from './cache';
 export type TypeInfo = {
     type: string;
     nullable: boolean;

package/build/runtime-esm/cache/stuff.d.ts

@@ -1,5 +1,5 @@
-import { GraphQLValue } from '../lib/types';
-import { LinkedList } from './cache';
+import type { GraphQLValue } from '../lib/types';
+import type { LinkedList } from './cache';
 export declare function flattenList<T>(source: LinkedList<T>): T[];
 export declare function evaluateKey(key: string, variables?: {
     [key: string]: GraphQLValue;