houdini-react 0.0.0-20231008055552

package/build/runtime-cjs/hooks/useIsMounted.js

@@ -0,0 +1,38 @@
+"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 useIsMounted_exports = {};
+__export(useIsMounted_exports, {
+  useIsMountedRef: () => useIsMountedRef
+});
+module.exports = __toCommonJS(useIsMounted_exports);
+var import_react = require("react");
+function useIsMountedRef() {
+  const isMountedRef = (0, import_react.useRef)(true);
+  (0, import_react.useEffect)(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return isMountedRef;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIsMountedRef
+});

package/build/runtime-cjs/hooks/useMutation.d.ts

@@ -0,0 +1,10 @@
+import type { MutationArtifact, GraphQLObject, QueryResult, GraphQLVariables } from '$houdini/runtime/lib/types';
+export type MutationHandler<_Result, _Input, _Optimistic extends GraphQLObject> = (args: {
+    variables: _Input;
+    metadata?: App.Metadata;
+    fetch?: typeof globalThis.fetch;
+    optimisticResponse?: _Optimistic;
+}) => Promise<QueryResult<_Result, _Input>>;
+export declare function useMutation<_Result extends GraphQLObject, _Input extends GraphQLVariables, _Optimistic extends GraphQLObject>({ artifact, }: {
+    artifact: MutationArtifact;
+}): [boolean, MutationHandler<_Result, _Input, _Optimistic>];

package/build/runtime-cjs/hooks/useMutation.js

@@ -0,0 +1,50 @@
+"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 useMutation_exports = {};
+__export(useMutation_exports, {
+  useMutation: () => useMutation
+});
+module.exports = __toCommonJS(useMutation_exports);
+var import_Router = require("../routing/Router");
+var import_useDocumentStore = require("./useDocumentStore");
+function useMutation({
+  artifact
+}) {
+  const [storeValue, observer] = (0, import_useDocumentStore.useDocumentStore)({ artifact });
+  const pending = storeValue.fetching;
+  const session = (0, import_Router.useSession)();
+  const mutate = ({
+    metadata,
+    fetch,
+    variables,
+    ...mutationConfig
+  }) => observer.send({
+    variables,
+    metadata,
+    session,
+    stuff: {
+      ...mutationConfig
+    }
+  });
+  return [pending, mutate];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMutation
+});

package/build/runtime-cjs/hooks/useQuery.d.ts

@@ -0,0 +1,5 @@
+import type { GraphQLVariables, GraphQLObject, QueryArtifact } from '$houdini/runtime/lib/types';
+import type { UseQueryConfig } from './useQueryHandle';
+export declare function useQuery<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>(document: {
+    artifact: QueryArtifact;
+}, variables?: any, config?: UseQueryConfig): _Data;

package/build/runtime-cjs/hooks/useQuery.js

@@ -0,0 +1,32 @@
+"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 useQuery_exports = {};
+__export(useQuery_exports, {
+  useQuery: () => useQuery
+});
+module.exports = __toCommonJS(useQuery_exports);
+var import_useQueryHandle = require("./useQueryHandle");
+function useQuery(document, variables = null, config = {}) {
+  const { data } = (0, import_useQueryHandle.useQueryHandle)(document, variables, config);
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useQuery
+});

package/build/runtime-cjs/hooks/useQueryHandle.d.ts

@@ -0,0 +1,10 @@
+import type { GraphQLObject, CachePolicies, QueryArtifact, GraphQLVariables } from '$houdini/runtime/lib/types';
+import type { DocumentHandle } from './useDocumentHandle';
+export declare function useQueryHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>({ artifact }: {
+    artifact: QueryArtifact;
+}, variables?: any, config?: UseQueryConfig): DocumentHandle<_Artifact, _Data, _Input>;
+export type UseQueryConfig = {
+    policy?: CachePolicies;
+    metadata?: App.Metadata;
+    fetchKey?: any;
+};

package/build/runtime-cjs/hooks/useQueryHandle.js

@@ -0,0 +1,125 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useQueryHandle_exports = {};
+__export(useQueryHandle_exports, {
+  useQueryHandle: () => useQueryHandle
+});
+module.exports = __toCommonJS(useQueryHandle_exports);
+var import_lru = require("$houdini/runtime/lib/lru");
+var import_react = __toESM(require("react"));
+var import_routing = require("../routing");
+var import_useDocumentHandle = require("./useDocumentHandle");
+var import_useIsMounted = require("./useIsMounted");
+const promiseCache = (0, import_lru.createLRUCache)();
+function useQueryHandle({ artifact }, variables = null, config = {}) {
+  const identifier = queryIdentifier({ artifact, variables, config });
+  const suspenseValue = promiseCache.get(identifier);
+  const client = (0, import_routing.useClient)();
+  const isMountedRef = (0, import_useIsMounted.useIsMountedRef)();
+  let [observer] = import_react.default.useState(
+    client.observe({
+      artifact,
+      initialValue: suspenseValue?.resolved?.data ?? {}
+    })
+  );
+  const suspenseTracker = import_react.default.useRef(false);
+  const box = import_react.default.useRef(observer.state);
+  const subscribe = import_react.default.useCallback(
+    (fn) => {
+      return observer.subscribe((val) => {
+        box.current = val;
+        if (isMountedRef.current && !suspenseTracker.current) {
+          fn();
+        }
+      });
+    },
+    [observer]
+  );
+  const storeValue = import_react.default.useSyncExternalStore(subscribe, () => box.current);
+  const handle = (0, import_useDocumentHandle.useDocumentHandle)({
+    artifact,
+    observer,
+    storeValue
+  });
+  import_react.default.useEffect(() => {
+    return () => {
+      promiseCache.delete(identifier);
+    };
+  }, [identifier]);
+  import_react.default.useEffect(() => {
+    return () => {
+      observer.cleanup();
+    };
+  }, [observer]);
+  let result = storeValue.data;
+  if (!suspenseValue) {
+    let resolve = () => {
+    };
+    const loadPromise = new Promise((r) => resolve = r);
+    const suspenseUnit = {
+      then: loadPromise.then.bind(loadPromise),
+      resolve,
+      variables
+    };
+    promiseCache.set(identifier, suspenseUnit);
+    handle.fetch({
+      variables,
+      stuff: {
+        silenceLoading: true
+      }
+    }).then((value) => {
+      suspenseUnit.resolved = {
+        ...handle,
+        data: value.data,
+        partia: value.partial,
+        artifact
+      };
+      suspenseUnit.resolve();
+    });
+    suspenseTracker.current = true;
+    throw suspenseUnit;
+  }
+  if (!result && suspenseValue && !suspenseValue.resolved) {
+    suspenseTracker.current = true;
+    throw suspenseValue;
+  }
+  if (!result && suspenseValue?.resolved) {
+    return suspenseValue.resolved;
+  }
+  return {
+    ...handle,
+    variables: storeValue.variables,
+    data: result
+  };
+}
+function queryIdentifier(args) {
+  args.fetchKey ??= 0;
+  const { artifact, variables, fetchKey } = args;
+  return [artifact.name, JSON.stringify(variables), fetchKey].join("@@");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useQueryHandle
+});

package/build/runtime-cjs/hooks/useSubscription.d.ts

@@ -0,0 +1,4 @@
+import type { SubscriptionArtifact, GraphQLObject, GraphQLVariables } from '$houdini/runtime/lib/types';
+export declare function useSubscription<_Result extends GraphQLObject, _Input extends GraphQLVariables>(document: {
+    artifact: SubscriptionArtifact;
+}, variables: _Input): import("houdini").GraphQLObject | null;

package/build/runtime-cjs/hooks/useSubscription.js

@@ -0,0 +1,32 @@
+"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 useSubscription_exports = {};
+__export(useSubscription_exports, {
+  useSubscription: () => useSubscription
+});
+module.exports = __toCommonJS(useSubscription_exports);
+var import_useSubscriptionHandle = require("./useSubscriptionHandle");
+function useSubscription(document, variables) {
+  const { data } = (0, import_useSubscriptionHandle.useSubscriptionHandle)(document, variables);
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSubscription
+});

package/build/runtime-cjs/hooks/useSubscriptionHandle.d.ts

@@ -0,0 +1,25 @@
+import type { SubscriptionArtifact, GraphQLObject, GraphQLVariables } from '$houdini/runtime/lib/types';
+export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends GraphQLVariables> = {
+    data: _Result | null;
+    errors: {
+        message: string;
+    }[] | null;
+    variables: _Input;
+    listen: (args: {
+        variables?: _Input;
+    }) => void;
+    unlisten: () => void;
+    fetching: boolean;
+};
+export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends GraphQLVariables>({ artifact }: {
+    artifact: SubscriptionArtifact;
+}, variables: _Input): {
+    data: import("houdini").GraphQLObject | null;
+    errors: {
+        message: string;
+    }[] | null;
+    fetching: boolean;
+    variables: _Input;
+    unlisten: () => Promise<void>;
+    listen: ({ metadata, session, fetch, variables, policy, stuff, cacheParams, setup, silenceEcho, }?: import("$houdini/lib").SendParams) => Promise<import("$houdini/runtime/lib/types").QueryResult<import("houdini").GraphQLObject, _Input>>;
+};

package/build/runtime-cjs/hooks/useSubscriptionHandle.js

@@ -0,0 +1,42 @@
+"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 useSubscriptionHandle_exports = {};
+__export(useSubscriptionHandle_exports, {
+  useSubscriptionHandle: () => useSubscriptionHandle
+});
+module.exports = __toCommonJS(useSubscriptionHandle_exports);
+var import_useDocumentSubscription = require("./useDocumentSubscription");
+function useSubscriptionHandle({ artifact }, variables) {
+  const [storeValue, observer] = (0, import_useDocumentSubscription.useDocumentSubscription)({
+    artifact,
+    variables
+  });
+  return {
+    data: storeValue.data,
+    errors: storeValue.errors,
+    fetching: storeValue.fetching,
+    variables,
+    unlisten: observer.cleanup,
+    listen: observer.send
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSubscriptionHandle
+});

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

@@ -0,0 +1,11 @@
+import type { Cache } from '$houdini/runtime/cache/cache';
+import { RouterCache } from './routing';
+export * from './hooks';
+export { router_cache } from './routing';
+export declare function Router({ cache, initialURL, artifact_cache, component_cache, data_cache, pending_cache, last_variables, session, assetPrefix, injectToStream, }: {
+    initialURL: string;
+    cache: Cache;
+    session?: App.Session;
+    assetPrefix: string;
+    injectToStream?: (chunk: string) => void;
+} & RouterCache): JSX.Element;

package/build/runtime-cjs/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  Router: () => Router,
+  router_cache: () => import_routing2.router_cache
+});
+module.exports = __toCommonJS(runtime_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = __toESM(require("./client"));
+var import_manifest = __toESM(require("./manifest"));
+var import_routing = require("./routing");
+__reExport(runtime_exports, require("./hooks"), module.exports);
+var import_routing2 = require("./routing");
+function Router({
+  cache,
+  initialURL,
+  artifact_cache,
+  component_cache,
+  data_cache,
+  pending_cache,
+  last_variables,
+  session,
+  assetPrefix,
+  injectToStream
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_routing.RouterContextProvider,
+    {
+      client: (0, import_client.default)(),
+      cache,
+      artifact_cache,
+      component_cache,
+      data_cache,
+      pending_cache,
+      last_variables,
+      session,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_routing.Router,
+        {
+          initialURL,
+          manifest: import_manifest.default,
+          assetPrefix,
+          injectToStream
+        }
+      )
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router,
+  router_cache
+});

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

@@ -0,0 +1,3 @@
+import type { RouterManifest } from '$houdini/runtime/lib/types';
+declare const manifest: RouterManifest;
+export default manifest;

package/build/runtime-cjs/manifest.js

@@ -0,0 +1,27 @@
+"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 manifest_exports = {};
+__export(manifest_exports, {
+  default: () => manifest_default
+});
+module.exports = __toCommonJS(manifest_exports);
+const manifest = {};
+var manifest_default = manifest;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/build/runtime-cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/build/runtime-cjs/routing/Router.d.ts

@@ -0,0 +1,67 @@
+import type { Cache } from '$houdini/runtime/cache/cache';
+import { DocumentStore, HoudiniClient } from '$houdini/runtime/client';
+import { LRUCache } from '$houdini/runtime/lib/lru';
+import { GraphQLObject, GraphQLVariables } from '$houdini/runtime/lib/types';
+import { QueryArtifact } from '$houdini/runtime/lib/types';
+import type { RouterManifest } from '$houdini/runtime/router/types';
+import React from 'react';
+import { SuspenseCache } from './cache';
+type ComponentType = any;
+/**
+ * Router is the top level entry point for the filesystem-based router.
+ * It is responsible for loading various page sources (including API fetches) and
+ * then rendering when appropriate.
+ */
+export declare function Router({ manifest, initialURL, assetPrefix, injectToStream, }: {
+    manifest: RouterManifest<ComponentType>;
+    initialURL?: string;
+    assetPrefix: string;
+    injectToStream?: undefined | ((chunk: string) => void);
+}): JSX.Element;
+export declare function RouterContextProvider({ children, client, cache, artifact_cache, component_cache, data_cache, pending_cache, last_variables, session: ssrSession, }: {
+    children: React.ReactElement;
+    client: HoudiniClient;
+    cache: Cache;
+    artifact_cache: SuspenseCache<QueryArtifact>;
+    component_cache: SuspenseCache<(props: any) => React.ReactElement>;
+    data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>;
+    pending_cache: PendingCache;
+    last_variables: LRUCache<GraphQLVariables>;
+    session?: App.Session;
+}): JSX.Element;
+type RouterContext = {
+    client: HoudiniClient;
+    cache: Cache;
+    artifact_cache: SuspenseCache<QueryArtifact>;
+    component_cache: SuspenseCache<(props: any) => React.ReactElement>;
+    data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>;
+    pending_cache: PendingCache;
+    last_variables: LRUCache<GraphQLVariables>;
+    session: App.Session;
+};
+export type PendingCache = SuspenseCache<Promise<void> & {
+    resolve: () => void;
+    reject: () => void;
+}>;
+export declare const useRouterContext: () => RouterContext;
+export declare function useClient(): HoudiniClient;
+export declare function useCache(): Cache;
+export declare function updateLocalSession(session: App.Session): void;
+export declare function useSession(): App.Session;
+export declare function useCurrentVariables(): GraphQLVariables;
+export declare function useQueryResult<_Data extends GraphQLObject, _Input extends GraphQLVariables>(name: string): [_Data | null, DocumentStore<_Data, _Input>];
+export type RouterCache = {
+    artifact_cache: SuspenseCache<QueryArtifact>;
+    component_cache: SuspenseCache<(props: any) => React.ReactElement>;
+    data_cache: SuspenseCache<DocumentStore<GraphQLObject, GraphQLVariables>>;
+    last_variables: LRUCache<GraphQLVariables>;
+    pending_cache: PendingCache;
+};
+export declare function router_cache({ pending_queries, artifacts, components, initialData, initialArtifacts, }?: {
+    pending_queries?: string[];
+    artifacts?: Record<string, QueryArtifact>;
+    components?: Record<string, (props: any) => React.ReactElement>;
+    initialData?: Record<string, DocumentStore<GraphQLObject, GraphQLVariables>>;
+    initialArtifacts?: Record<string, QueryArtifact>;
+}): RouterCache;
+export {};