houdini-react 1.2.0-react.1 → 1.2.6

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

@@ -1,7 +1,6 @@
-import type { GraphQLObject, FragmentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
-import { fragmentKey } from '$houdini/runtime/lib/types';
+import type { GraphQLObject, FragmentArtifact, QueryArtifact, fragmentKey, GraphQLVariables } from '$houdini/runtime/lib/types';
 import { type DocumentHandle } from './useDocumentHandle';
-export declare function useFragmentHandle<_Artifact extends FragmentArtifact, _Data extends GraphQLObject, _ReferenceType extends {}, _PaginationArtifact extends QueryArtifact, _Input extends {} = {}>(reference: _Data | {
+export declare function useFragmentHandle<_Artifact extends FragmentArtifact, _Data extends GraphQLObject, _ReferenceType extends {}, _PaginationArtifact extends QueryArtifact, _Input extends GraphQLVariables = GraphQLVariables>(reference: _Data | {
     [fragmentKey]: _ReferenceType;
 } | null, document: {
     artifact: FragmentArtifact;

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

@@ -1,10 +1,10 @@
-import type { MutationArtifact, GraphQLObject, QueryResult } from '$houdini/runtime/lib/types';
+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 {}, _Optimistic extends GraphQLObject>({ artifact, }: {
+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/useQuery.d.ts

@@ -1,5 +1,5 @@
-import { type QueryArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-import { UseQueryConfig } from './useQueryHandle';
-export declare function useQuery<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>(document: {
+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/useQueryHandle.d.ts

@@ -1,6 +1,6 @@
-import { type QueryArtifact, GraphQLObject, CachePolicies } from '$houdini/runtime/lib/types';
-import { DocumentHandle } from './useDocumentHandle';
-export declare function useQueryHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends {} = []>({ artifact }: {
+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 = {

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

@@ -27,16 +27,16 @@ __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_cache = require("../lib/cache");
+var import_routing = require("../routing");
 var import_useDocumentHandle = require("./useDocumentHandle");
-var import_useHoudiniClient = require("./useHoudiniClient");
 var import_useIsMounted = require("./useIsMounted");
-const promiseCache = (0, import_cache.createCache)();
+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_useHoudiniClient.useHoudiniClient)();
+  const client = (0, import_routing.useClient)();
   const isMountedRef = (0, import_useIsMounted.useIsMountedRef)();
   let [observer] = import_react.default.useState(
     client.observe({

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

@@ -1,4 +1,4 @@
-import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-export declare function useSubscription<_Result extends GraphQLObject, _Input extends {}>(document: {
+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/useSubscriptionHandle.d.ts

@@ -1,5 +1,5 @@
-import { SubscriptionArtifact, GraphQLObject } from '$houdini/runtime/lib/types';
-export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends {} | null> = {
+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;
@@ -11,7 +11,7 @@ export type SubscriptionHandle<_Result extends GraphQLObject, _Input extends {}
     unlisten: () => void;
     fetching: boolean;
 };
-export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends {}>({ artifact }: {
+export declare function useSubscriptionHandle<_Result extends GraphQLObject, _Input extends GraphQLVariables>({ artifact }: {
     artifact: SubscriptionArtifact;
 }, variables: _Input): {
     data: import("houdini").GraphQLObject | null;

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

@@ -1,2 +1,30 @@
+import type { Cache } from '$houdini/runtime/cache/cache';
+import { DocumentStore } from '$houdini/runtime/client';
+import { LRUCache } from '$houdini/runtime/lib/lru';
+import { GraphQLObject, GraphQLVariables, QueryArtifact } from '$houdini/runtime/lib/types';
+import React from 'react';
+import { PendingCache } from './routing/components/Router';
+import { SuspenseCache } from './routing/lib/cache';
 export * from './hooks';
-export { HoudiniProvider } from './context';
+export * from './routing';
+export declare function Router({ cache, intialURL, artifact_cache, component_cache, data_cache, pending_cache, last_variables, loaded_queries, loaded_artifacts, }: {
+    intialURL: string;
+    cache: Cache;
+    loaded_queries?: Record<string, {
+        data: GraphQLObject;
+        variables: GraphQLVariables;
+    }>;
+    loaded_artifacts?: Record<string, QueryArtifact>;
+} & RouterCache): JSX.Element;
+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, }?: {
+    pending_queries?: string[];
+    artifacts?: Record<string, QueryArtifact>;
+    components?: Record<string, (props: any) => React.ReactElement>;
+}): RouterCache;

package/build/runtime-cjs/index.js

@@ -1,7 +1,9 @@
 "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)
@@ -16,15 +18,97 @@ var __copyProps = (to, from, except, desc) => {
   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, {
-  HoudiniProvider: () => import_context.HoudiniProvider
+  Router: () => Router,
+  router_cache: () => router_cache
 });
 module.exports = __toCommonJS(runtime_exports);
+var import_react = __toESM(require("react"));
+var import_client2 = __toESM(require("./client"));
+var import_manifest = __toESM(require("./manifest"));
+var import_routing = require("./routing");
+var import_cache = require("./routing/lib/cache");
 __reExport(runtime_exports, require("./hooks"), module.exports);
-var import_context = require("./context");
+__reExport(runtime_exports, require("./routing"), module.exports);
+function Router({
+  cache,
+  intialURL,
+  artifact_cache,
+  component_cache,
+  data_cache,
+  pending_cache,
+  last_variables,
+  loaded_queries,
+  loaded_artifacts
+}) {
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_routing.RouterContextProvider,
+    {
+      client: import_client2.default,
+      cache,
+      artifact_cache,
+      component_cache,
+      data_cache,
+      pending_cache,
+      last_variables
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      import_routing.Router,
+      {
+        intialURL,
+        manifest: import_manifest.default,
+        loaded_queries,
+        loaded_artifacts
+      }
+    )
+  );
+}
+function router_cache({
+  pending_queries = [],
+  artifacts = {},
+  components = {}
+} = {}) {
+  const result = {
+    artifact_cache: (0, import_cache.suspense_cache)(),
+    component_cache: (0, import_cache.suspense_cache)(),
+    data_cache: (0, import_cache.suspense_cache)(),
+    pending_cache: (0, import_cache.suspense_cache)(),
+    last_variables: (0, import_cache.suspense_cache)()
+  };
+  for (const query of pending_queries) {
+    result.pending_cache.set(query, signal_promise());
+  }
+  for (const [name, artifact] of Object.entries(artifacts)) {
+    result.artifact_cache.set(name, artifact);
+  }
+  for (const [name, component] of Object.entries(components)) {
+    result.component_cache.set(name, component);
+  }
+  return result;
+}
+function signal_promise() {
+  let resolve = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    ...promise,
+    resolve,
+    reject
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  HoudiniProvider
+  Router,
+  router_cache
 });

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

@@ -0,0 +1,3 @@
+import type { RouterManifest } from './routing';
+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/routing/components/Link.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export declare function Link({ href, children, style, ...props }: {
+    href: string;
+    children: React.ReactNode;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>): JSX.Element;

package/build/runtime-cjs/{hooks/useHoudiniClient.js → routing/components/Link.js}

@@ -22,21 +22,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var useHoudiniClient_exports = {};
-__export(useHoudiniClient_exports, {
-  useHoudiniClient: () => useHoudiniClient
+var Link_exports = {};
+__export(Link_exports, {
+  Link: () => Link
 });
-module.exports = __toCommonJS(useHoudiniClient_exports);
-var React = __toESM(require("react"));
-var import_context = require("../context");
-function useHoudiniClient() {
-  const client = React.useContext(import_context.HoudiniContext);
-  if (!client) {
-    throw new Error("Could not find client");
-  }
-  return client;
+module.exports = __toCommonJS(Link_exports);
+var import_react = __toESM(require("react"));
+var import_Router = require("./Router");
+function Link({
+  href,
+  children,
+  style,
+  ...props
+}) {
+  const { goto } = (0, import_Router.useNavigationContext)();
+  const [pending, startTransition] = (0, import_react.useTransition)();
+  const click = (e) => {
+    e.preventDefault();
+    startTransition(() => {
+      goto(href);
+    });
+  };
+  return /* @__PURE__ */ import_react.default.createElement("a", { href, onClick: click, style, ...props }, children);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  useHoudiniClient
+  Link
 });

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

@@ -0,0 +1,52 @@
+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 React from 'react';
+import { SuspenseCache } from '../lib/cache';
+import type { NavigationContext, RouterManifest } from '../lib/types';
+/**
+ * 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, intialURL, loaded_queries, loaded_artifacts, }: {
+    manifest: RouterManifest;
+    intialURL?: string;
+    loaded_queries?: Record<string, {
+        data: GraphQLObject;
+        variables: GraphQLVariables;
+    }>;
+    loaded_artifacts?: Record<string, QueryArtifact>;
+}): JSX.Element;
+export declare function useNavigationContext(): NavigationContext;
+export declare function RouterContextProvider({ children, client, cache, artifact_cache, component_cache, data_cache, pending_cache, last_variables, }: {
+    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>;
+}): 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>;
+};
+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 useCurrentVariables(): GraphQLVariables;
+export declare function useQueryResult<_Data extends GraphQLObject, _Input extends GraphQLVariables>(name: string): [_Data | null, DocumentStore<_Data, _Input>];
+export {};

package/build/runtime-cjs/routing/components/Router.js

@@ -0,0 +1,267 @@
+"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 Router_exports = {};
+__export(Router_exports, {
+  Router: () => Router,
+  RouterContextProvider: () => RouterContextProvider,
+  useCache: () => useCache,
+  useClient: () => useClient,
+  useCurrentVariables: () => useCurrentVariables,
+  useNavigationContext: () => useNavigationContext,
+  useQueryResult: () => useQueryResult,
+  useRouterContext: () => useRouterContext
+});
+module.exports = __toCommonJS(Router_exports);
+var import_deepEquals = require("$houdini/runtime/lib/deepEquals");
+var import_react = __toESM(require("react"));
+var import_react_streaming = require("react-streaming");
+var import_useDocumentStore = require("../../hooks/useDocumentStore");
+var import_match = require("../lib/match");
+const NavContext = import_react.default.createContext({
+  currentRoute: "/",
+  goto: () => {
+    throw new Error("NOT FOUND");
+  }
+});
+function Router({
+  manifest,
+  intialURL,
+  loaded_queries,
+  loaded_artifacts
+}) {
+  const [current, setCurrent] = import_react.default.useState(() => {
+    return intialURL || window.location.pathname;
+  });
+  const [page, variables] = (0, import_match.find_match)(manifest, current);
+  useLoadPage({ page, variables, loaded_queries, loaded_artifacts });
+  const { component_cache } = useRouterContext();
+  const PageComponent = component_cache.get(page.id);
+  import_react.default.useEffect(() => {
+    if (window.location.pathname !== current) {
+      window.history.pushState({}, "", current);
+    }
+  }, [current]);
+  import_react.default.useEffect(() => {
+    const onChange = (evt) => {
+      setCurrent(window.location.pathname);
+    };
+    window.addEventListener("popstate", onChange);
+    return () => {
+      window.removeEventListener("popstate", onChange);
+    };
+  }, []);
+  return /* @__PURE__ */ import_react.default.createElement(
+    NavContext.Provider,
+    {
+      value: {
+        currentRoute: current,
+        goto: setCurrent
+      }
+    },
+    /* @__PURE__ */ import_react.default.createElement(VariableContext.Provider, { value: variables }, /* @__PURE__ */ import_react.default.createElement(PageComponent, { url: current }))
+  );
+}
+function useLoadPage({
+  page,
+  variables,
+  loaded_queries,
+  loaded_artifacts
+}) {
+  const {
+    client,
+    cache,
+    data_cache,
+    component_cache,
+    artifact_cache,
+    pending_cache,
+    last_variables
+  } = useRouterContext();
+  const stream = (0, import_react_streaming.useStream)();
+  function load_query({ id, artifact }) {
+    last_variables.set(page.id, variables);
+    if (pending_cache.has(id)) {
+      return pending_cache.get(id);
+    }
+    const observer = client.observe({ artifact, cache });
+    let resolve = () => {
+    };
+    let reject = () => {
+    };
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+      observer.send({
+        variables,
+        cacheParams: { disableSubscriptions: true }
+      }).then(() => {
+        data_cache.set(id, observer);
+        if (loaded_queries) {
+          loaded_queries[artifact.name] = {
+            data: observer.state.data,
+            variables
+          };
+        }
+        stream?.injectToStream(`
+						<script>
+							window.__houdini__cache__?.hydrate(${cache.serialize()}, window.__houdini__hydration__layer)
+
+							if (window.__houdini__nav_caches__?.pending_cache.has("${artifact.name}")) {
+								// before we resolve the pending signals,
+								// fill the data cache with values we got on the server
+								const new_store = window.__houdini__client__.observe({
+									artifact: window.__houdini__nav_caches__.artifact_cache.get("${artifact.name}"),
+									cache: window.__houdini__cache__,
+									initialValue: ${JSON.stringify(observer.state.data)}
+								})
+
+								window.__houdini__nav_caches__.data_cache.set("${artifact.name}", new_store)
+
+								// we're pushing this store onto the client, it should be initialized
+								new_store.send({
+									setup: true,
+									variables: ${JSON.stringify(variables)}
+								})
+
+								// notify anyone waiting on the pending cache
+								window.__houdini__nav_caches__.pending_cache.get("${artifact.name}").resolve()
+								window.__houdini__nav_caches__.pending_cache.delete("${artifact.name}")
+							}
+						<\/script>
+					`);
+        resolve();
+      }).catch(reject).finally(() => {
+        pending_cache.delete(id);
+      });
+    });
+    pending_cache.set(id, { ...promise, resolve, reject });
+    return pending_cache.get(id);
+  }
+  if (last_variables.has(page.id) && !(0, import_deepEquals.deepEquals)(last_variables.get(page.id), variables)) {
+    data_cache.clear();
+  }
+  const missing_artifacts = [];
+  const found_artifacts = {};
+  for (const key of Object.keys(page.documents)) {
+    if (artifact_cache.has(key)) {
+      found_artifacts[key] = artifact_cache.get(key);
+    } else {
+      missing_artifacts.push(key);
+    }
+  }
+  for (const artifact_id of missing_artifacts) {
+    page.documents[artifact_id].artifact().then((mod) => {
+      const artifact = mod.default;
+      artifact_cache.set(artifact_id, artifact);
+      if (loaded_artifacts) {
+        loaded_artifacts[artifact.name] = artifact;
+      }
+      stream?.injectToStream(`
+					<script type="module" src="@@houdini/artifact/${artifact.name}.js" async=""><\/script>
+				`);
+      load_query({ id: artifact.name, artifact });
+    }).catch((err) => {
+      console.log(err);
+    });
+  }
+  for (const artifact of Object.values(found_artifacts)) {
+    if (!data_cache.has(artifact.name)) {
+      load_query({ id: artifact.name, artifact });
+    }
+  }
+  if (!component_cache.has(page.id)) {
+    throw new Promise((resolve, reject) => {
+      page.component().then((mod) => {
+        component_cache.set(page.id, mod.default);
+        resolve();
+      }).catch(reject);
+    });
+  }
+}
+function useNavigationContext() {
+  return import_react.default.useContext(NavContext);
+}
+function RouterContextProvider({
+  children,
+  client,
+  cache,
+  artifact_cache,
+  component_cache,
+  data_cache,
+  pending_cache,
+  last_variables
+}) {
+  return /* @__PURE__ */ import_react.default.createElement(
+    Context.Provider,
+    {
+      value: {
+        client,
+        cache,
+        artifact_cache,
+        component_cache,
+        data_cache,
+        pending_cache,
+        last_variables
+      }
+    },
+    children
+  );
+}
+const Context = import_react.default.createContext(null);
+const useRouterContext = () => {
+  const ctx = import_react.default.useContext(Context);
+  if (!ctx) {
+    throw new Error("Could not find router context");
+  }
+  return ctx;
+};
+function useClient() {
+  return useRouterContext().client;
+}
+function useCache() {
+  return useRouterContext().cache;
+}
+function useCurrentVariables() {
+  return import_react.default.useContext(VariableContext);
+}
+const VariableContext = import_react.default.createContext(null);
+function useQueryResult(name) {
+  const store_ref = useRouterContext().data_cache.get(name);
+  const [{ data }, observer] = (0, import_useDocumentStore.useDocumentStore)({
+    artifact: store_ref.artifact,
+    observer: store_ref
+  });
+  return [data, observer];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router,
+  RouterContextProvider,
+  useCache,
+  useClient,
+  useCurrentVariables,
+  useNavigationContext,
+  useQueryResult,
+  useRouterContext
+});

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

@@ -0,0 +1,2 @@
+export { Link } from './Link';
+export { Router, RouterContextProvider, useClient } from './Router';