houdini-react 1.2.0-react.1 → 1.2.7

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

@@ -1,6 +1,6 @@
 import { fragmentKey } from '$houdini/runtime/lib/types';
-import type { GraphQLObject, FragmentArtifact } from '$houdini/runtime/lib/types';
-export declare function useFragment<_Data extends GraphQLObject, _ReferenceType extends {}, _Input extends {} = {}>(reference: _Data | {
+import type { GraphQLObject, GraphQLVariables, FragmentArtifact } from '$houdini/runtime/lib/types';
+export declare function useFragment<_Data extends GraphQLObject, _ReferenceType extends {}, _Input extends GraphQLVariables = GraphQLVariables>(reference: _Data | {
     [fragmentKey]: _ReferenceType;
 } | null, document: {
     artifact: FragmentArtifact;
@@ -12,4 +12,5 @@ export declare function fragmentReference<_Data extends GraphQLObject, _Input, _
 }): {
     variables: _Input;
     parent: string;
+    loading: boolean;
 };

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

@@ -35,7 +35,7 @@ var React = __toESM(require("react"));
 var import_useDeepCompareEffect = require("./useDeepCompareEffect");
 var import_useDocumentSubscription = require("./useDocumentSubscription");
 function useFragment(reference, document) {
-  const { parent, variables } = fragmentReference(
+  const { parent, variables, loading } = fragmentReference(
     reference,
     document
   );
@@ -44,20 +44,21 @@ function useFragment(reference, document) {
     cachedValue = import_cache.default.read({
       selection: document.artifact.selection,
       parent,
-      variables
+      variables,
+      loading
     }).data;
   }
-  const observeParams = {
+  const [storeValue] = (0, import_useDocumentSubscription.useDocumentSubscription)({
     artifact: document.artifact,
     variables,
     initialValue: cachedValue,
+    disabled: loading,
     send: {
       stuff: {
         parentID: parent
       }
     }
-  };
-  const [storeValue] = (0, import_useDocumentSubscription.useDocumentSubscription)(observeParams);
+  });
   const lastReference = React.useRef(null);
   return React.useMemo(() => {
     const parentChange = storeValue.parent !== parent || !(0, import_deepEquals.deepEquals)({ parent, variables }, lastReference.current);
@@ -77,14 +78,15 @@ function useFragment(reference, document) {
   ]);
 }
 function fragmentReference(reference, document) {
-  const { variables, parent } = reference?.[import_types.fragmentKey]?.[document.artifact.name] ?? {};
+  const { variables, parent } = reference?.[import_types.fragmentKey]?.values?.[document.artifact.name] ?? {};
   if (reference && import_types.fragmentKey in reference && (!variables || !parent)) {
     console.warn(
       `\u26A0\uFE0F Parent does not contain the information for this fragment. Something is wrong.
 Please ensure that you have passed a record that has ${document.artifact.name} mixed into it.`
     );
   }
-  return { variables, parent };
+  const loading = Boolean(reference?.[import_types.fragmentKey]?.loading);
+  return { variables, parent, loading };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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/useMutation.js

@@ -21,12 +21,14 @@ __export(useMutation_exports, {
   useMutation: () => useMutation
 });
 module.exports = __toCommonJS(useMutation_exports);
+var import_Router = require("../routing/components/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,
@@ -35,7 +37,7 @@ function useMutation({
   }) => observer.send({
     variables,
     metadata,
-    session: {},
+    session,
     stuff: {
       ...mutationConfig
     }

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,31 @@
+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, session, }: {
+    intialURL: string;
+    cache: Cache;
+    loaded_queries?: Record<string, {
+        data: GraphQLObject;
+        variables: GraphQLVariables;
+    }>;
+    loaded_artifacts?: Record<string, QueryArtifact>;
+    session?: App.Session;
+} & 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,99 @@ 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,
+  session
+}) {
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_routing.RouterContextProvider,
+    {
+      client: import_client2.default,
+      cache,
+      artifact_cache,
+      component_cache,
+      data_cache,
+      pending_cache,
+      last_variables,
+      session
+    },
+    /* @__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,56 @@
+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, 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 {};