houdini-react 0.0.0-20231008055552

package/build/runtime-cjs/server/utils/projectInfo.js

@@ -0,0 +1,37 @@
+"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 projectInfo_exports = {};
+__export(projectInfo_exports, {
+  projectInfo: () => projectInfo
+});
+module.exports = __toCommonJS(projectInfo_exports);
+const PROJECT_VERSION = "0.3.14";
+const projectInfo = {
+  projectName: "react-streaming",
+  projectVersion: PROJECT_VERSION,
+  npmPackageName: "react-streaming",
+  githubRepository: "https://github.com/brillout/react-streaming",
+  discordInviteToolChannel: "https://discord.com/invite/H23tjRxFvx"
+};
+globalThis.__vite_plugin_ssr__instances = globalThis.__vite_plugin_ssr__instances || [];
+globalThis.__vite_plugin_ssr__instances.push(projectInfo.projectVersion);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  projectInfo
+});

package/build/runtime-cjs/server/utils.d.ts

@@ -0,0 +1,4 @@
+export * from './utils/assert';
+export * from './utils/debug';
+export * from './utils/isPromise';
+export * from './utils/isBrowser';

package/build/runtime-cjs/server/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./utils/assert"), module.exports);
+__reExport(utils_exports, require("./utils/debug"), module.exports);
+__reExport(utils_exports, require("./utils/isPromise"), module.exports);
+__reExport(utils_exports, require("./utils/isBrowser"), module.exports);

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

@@ -0,0 +1,3 @@
+import type { HoudiniClient } from '$houdini/runtime/client';
+declare const _default: () => HoudiniClient;
+export default _default;

package/build/runtime-esm/client.js

@@ -0,0 +1,5 @@
+var client_default = () => {
+};
+export {
+  client_default as default
+};

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

@@ -0,0 +1,3 @@
+import type { ClientPlugin } from 'houdini';
+declare const plugin: () => ClientPlugin;
+export default plugin;

package/build/runtime-esm/clientPlugin.js

@@ -0,0 +1,17 @@
+const plugin = () => () => {
+  return {
+    beforeNetwork(ctx, { next }) {
+      next({
+        ...ctx,
+        cacheParams: {
+          ...ctx.fetchParams,
+          serverSideFallback: false
+        }
+      });
+    }
+  };
+};
+var clientPlugin_default = plugin;
+export {
+  clientPlugin_default as default
+};

package/build/runtime-esm/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export { useQuery } from './useQuery';
+export { useQueryHandle } from './useQueryHandle';
+export { useFragment } from './useFragment';
+export { useFragmentHandle } from './useFragmentHandle';
+export { useMutation } from './useMutation';
+export { useSubscription } from './useSubscription';
+export { type DocumentHandle } from './useDocumentHandle';
+export { type UseQueryConfig } from './useQueryHandle';

package/build/runtime-esm/hooks/index.js

@@ -0,0 +1,16 @@
+import { useQuery } from "./useQuery";
+import { useQueryHandle } from "./useQueryHandle";
+import { useFragment } from "./useFragment";
+import { useFragmentHandle } from "./useFragmentHandle";
+import { useMutation } from "./useMutation";
+import { useSubscription } from "./useSubscription";
+import {} from "./useDocumentHandle";
+import {} from "./useQueryHandle";
+export {
+  useFragment,
+  useFragmentHandle,
+  useMutation,
+  useQuery,
+  useQueryHandle,
+  useSubscription
+};

package/build/runtime-esm/hooks/useDeepCompareEffect.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+type UseEffectParams = Parameters<typeof React.useEffect>;
+type EffectCallback = UseEffectParams[0];
+type DependencyList = UseEffectParams[1];
+type UseEffectReturn = ReturnType<typeof React.useEffect>;
+/**
+ * @param value the value to be memoized (usually a dependency list)
+ * @returns a memoized version of the value as long as it remains deeply equal
+ */
+export declare function useDeepCompareMemoize<T>(value: T): T;
+declare function useDeepCompareEffect(callback: EffectCallback, dependencies: DependencyList): UseEffectReturn;
+export declare function useDeepCompareEffectNoCheck(callback: EffectCallback, dependencies: DependencyList): UseEffectReturn;
+export default useDeepCompareEffect;
+/**
+The MIT License (MIT)
+Copyright (c) 2020 Kent C. Dodds
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/

package/build/runtime-esm/hooks/useDeepCompareEffect.js

@@ -0,0 +1,41 @@
+import { deepEquals } from "$houdini/runtime/lib/deepEquals";
+import * as React from "react";
+function checkDeps(deps) {
+  if (!deps || !deps.length) {
+    throw new Error(
+      "useDeepCompareEffect should not be used with no dependencies. Use React.useEffect instead."
+    );
+  }
+  if (deps.every(isPrimitive)) {
+    throw new Error(
+      "useDeepCompareEffect should not be used with dependencies that are all primitive values. Use React.useEffect instead."
+    );
+  }
+}
+function isPrimitive(val) {
+  return val == null || /^[sbn]/.test(typeof val);
+}
+function useDeepCompareMemoize(value) {
+  const ref = React.useRef(value);
+  const signalRef = React.useRef(0);
+  if (!deepEquals(value, ref.current)) {
+    ref.current = value;
+    signalRef.current += 1;
+  }
+  return React.useMemo(() => ref.current, [signalRef.current]);
+}
+function useDeepCompareEffect(callback, dependencies) {
+  if (process.env.NODE_ENV !== "production") {
+    checkDeps(dependencies);
+  }
+  return React.useEffect(callback, useDeepCompareMemoize(dependencies));
+}
+function useDeepCompareEffectNoCheck(callback, dependencies) {
+  return React.useEffect(callback, useDeepCompareMemoize(dependencies));
+}
+var useDeepCompareEffect_default = useDeepCompareEffect;
+export {
+  useDeepCompareEffect_default as default,
+  useDeepCompareEffectNoCheck,
+  useDeepCompareMemoize
+};

package/build/runtime-esm/hooks/useDocumentHandle.d.ts

@@ -0,0 +1,34 @@
+import type { DocumentStore } from '$houdini/runtime/client';
+import type { GraphQLObject, GraphQLVariables, CursorHandlers, OffsetHandlers, PageInfo, FetchFn, QueryResult, DocumentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
+export declare function useDocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input extends GraphQLVariables>({ artifact, observer, storeValue, }: {
+    artifact: DocumentArtifact;
+    observer: DocumentStore<_Data, _Input>;
+    storeValue: QueryResult<_Data, _Input>;
+}): DocumentHandle<_Artifact, _Data, _Input> & {
+    fetch: FetchFn<_Data, _Input>;
+};
+export type DocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables> = {
+    data: _Data;
+    partial: boolean;
+} & RefetchHandlers<_Artifact, _Data, _Input>;
+type RefetchHandlers<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input> = _Artifact extends {
+    refetch: {
+        paginated: true;
+        method: 'cursor';
+    };
+} ? {
+    loadNext: CursorHandlers<_Data, _Input>['loadNextPage'];
+    loadNextPending: boolean;
+    loadPrevious: CursorHandlers<_Data, _Input>['loadPreviousPage'];
+    loadPreviousPending: boolean;
+    pageInfo: PageInfo;
+} : _Artifact extends {
+    refetch: {
+        paginated: true;
+        method: 'offset';
+    };
+} ? {
+    loadNext: OffsetHandlers<_Data, _Input>['loadNextPage'];
+    loadNextPending: boolean;
+} : {};
+export {};

package/build/runtime-esm/hooks/useDocumentHandle.js

@@ -0,0 +1,101 @@
+import { extractPageInfo } from "$houdini/runtime/lib/pageInfo";
+import { cursorHandlers, offsetHandlers } from "$houdini/runtime/lib/pagination";
+import { ArtifactKind } from "$houdini/runtime/lib/types";
+import React from "react";
+import { useSession } from "../routing/Router";
+function useDocumentHandle({
+  artifact,
+  observer,
+  storeValue
+}) {
+  const [forwardPending, setForwardPending] = React.useState(false);
+  const [backwardPending, setBackwardPending] = React.useState(false);
+  const session = useSession();
+  return React.useMemo(() => {
+    const wrapLoad = (setLoading, fn) => {
+      return async (value) => {
+        setLoading(true);
+        const result = await fn(value);
+        setLoading(false);
+        return result;
+      };
+    };
+    const fetchQuery = (args) => observer.send({
+      ...args,
+      session
+    });
+    if (artifact.kind !== ArtifactKind.Query || !artifact.refetch?.paginated) {
+      return {
+        data: storeValue.data,
+        fetch: fetchQuery,
+        partial: storeValue.partial
+      };
+    }
+    if (artifact.refetch.method === "cursor") {
+      const handlers = cursorHandlers({
+        artifact,
+        getState: () => storeValue.data,
+        getVariables: () => storeValue.variables,
+        fetch: fetchQuery,
+        fetchUpdate: (args, updates) => {
+          return observer.send({
+            ...args,
+            cacheParams: {
+              disableSubscriptions: true,
+              applyUpdates: updates,
+              ...args?.cacheParams
+            },
+            session
+          });
+        },
+        getSession: async () => session
+      });
+      return {
+        data: storeValue.data,
+        fetch: handlers.fetch,
+        partial: storeValue.partial,
+        loadNext: wrapLoad(setForwardPending, handlers.loadNextPage),
+        loadNextPending: forwardPending,
+        loadPrevious: wrapLoad(setBackwardPending, handlers.loadPreviousPage),
+        loadPreviousPending: backwardPending,
+        pageInfo: extractPageInfo(storeValue.data, artifact.refetch.path)
+      };
+    }
+    if (artifact.refetch.method === "offset") {
+      const handlers = offsetHandlers({
+        artifact,
+        getState: () => storeValue.data,
+        getVariables: () => storeValue.variables,
+        storeName: artifact.name,
+        fetch: fetchQuery,
+        fetchUpdate: async (args, updates = ["append"]) => {
+          return observer.send({
+            ...args,
+            cacheParams: {
+              disableSubscriptions: true,
+              applyUpdates: updates,
+              ...args?.cacheParams
+            }
+          });
+        },
+        getSession: async () => session
+      });
+      return {
+        data: storeValue.data,
+        fetch: handlers.fetch,
+        partial: storeValue.partial,
+        loadNext: wrapLoad(setForwardPending, handlers.loadNextPage),
+        loadNextPending: forwardPending
+      };
+    }
+    return {
+      data: storeValue.data,
+      fetch: fetchQuery,
+      refetch: fetchQuery,
+      partial: storeValue.partial
+    };
+  }, [artifact, observer, session, storeValue, true, true]);
+}
+export {
+  useDocumentHandle
+};

package/build/runtime-esm/hooks/useDocumentStore.d.ts

@@ -0,0 +1,12 @@
+import type { DocumentArtifact, GraphQLVariables, QueryResult } from '$houdini/lib/types';
+import type { DocumentStore, ObserveParams } from '$houdini/runtime/client';
+import type { GraphQLObject } from 'houdini';
+export type UseDocumentStoreParams<_Artifact extends DocumentArtifact, _Data extends GraphQLObject, _Input extends GraphQLVariables> = {
+    artifact: _Artifact;
+    observer?: DocumentStore<_Data, _Input>;
+} & Partial<ObserveParams<_Data, DocumentArtifact, _Input>>;
+export declare function useDocumentStore<_Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables, _Artifact extends DocumentArtifact = DocumentArtifact>({ artifact, observer: obs, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data, _Input>): [
+    QueryResult<_Data, _Input>,
+    DocumentStore<_Data, _Input>,
+    (store: DocumentStore<_Data, _Input>) => void
+];

package/build/runtime-esm/hooks/useDocumentStore.js

@@ -0,0 +1,38 @@
+import * as React from "react";
+import { useClient } from "../routing";
+import { useIsMountedRef } from "./useIsMounted";
+function useDocumentStore({
+  artifact,
+  observer: obs,
+  ...observeParams
+}) {
+  const client = useClient();
+  const isMountedRef = useIsMountedRef();
+  let [observer, setObserver] = React.useState(
+    () => obs ?? client.observe({
+      artifact,
+      ...observeParams
+    })
+  );
+  const box = React.useRef(observer.state);
+  const subscribe = React.useCallback(
+    (fn) => {
+      return observer.subscribe((val) => {
+        box.current = val;
+        if (isMountedRef.current) {
+          fn();
+        }
+      });
+    },
+    [observer]
+  );
+  const storeValue = React.useSyncExternalStore(
+    subscribe,
+    () => box.current,
+    () => box.current
+  );
+  return [storeValue, observer, setObserver];
+}
+export {
+  useDocumentStore
+};

package/build/runtime-esm/hooks/useDocumentSubscription.d.ts

@@ -0,0 +1,15 @@
+import type { DocumentArtifact, GraphQLVariables, QueryResult } from '$houdini/lib/types';
+import type { DocumentStore, SendParams } from '$houdini/runtime/client';
+import type { GraphQLObject } from 'houdini';
+import { type UseDocumentStoreParams } from './useDocumentStore';
+export declare function useDocumentSubscription<_Artifact extends DocumentArtifact = DocumentArtifact, _Data extends GraphQLObject = GraphQLObject, _Input extends GraphQLVariables = GraphQLVariables>({ artifact, variables, send, disabled, ...observeParams }: UseDocumentStoreParams<_Artifact, _Data, _Input> & {
+    variables: _Input;
+    disabled?: boolean;
+    send?: Partial<SendParams>;
+}): [
+    QueryResult<_Data, _Input> & {
+        parent?: string | null;
+    },
+    DocumentStore<_Data, _Input>,
+    (store: DocumentStore<_Data, _Input>) => void
+];

package/build/runtime-esm/hooks/useDocumentSubscription.js

@@ -0,0 +1,42 @@
+import { useSession } from "../routing/Router";
+import useDeepCompareEffect from "./useDeepCompareEffect";
+import { useDocumentStore } from "./useDocumentStore";
+function useDocumentSubscription({
+  artifact,
+  variables,
+  send,
+  disabled,
+  ...observeParams
+}) {
+  const [storeValue, observer, setObserver] = useDocumentStore({
+    artifact,
+    ...observeParams
+  });
+  const session = useSession();
+  useDeepCompareEffect(() => {
+    if (!disabled) {
+      observer.send({
+        variables,
+        session,
+        metadata: {},
+        ...send
+      });
+    }
+    return () => {
+      if (!disabled) {
+        observer.cleanup();
+      }
+    };
+  }, [disabled, session, observer, variables ?? {}, send ?? {}]);
+  return [
+    {
+      parent: send?.stuff?.parentID,
+      ...storeValue
+    },
+    observer,
+    setObserver
+  ];
+}
+export {
+  useDocumentSubscription
+};

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

@@ -0,0 +1,16 @@
+import { fragmentKey } from '$houdini/runtime/lib/types';
+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;
+}): _Data | null;
+export declare function fragmentReference<_Data extends GraphQLObject, _Input, _ReferenceType extends {}>(reference: _Data | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+}): {
+    variables: _Input;
+    parent: string;
+    loading: boolean;
+};

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

@@ -0,0 +1,66 @@
+import { deepEquals } from "$houdini/runtime/lib/deepEquals";
+import { fragmentKey } from "$houdini/runtime/lib/types";
+import * as React from "react";
+import { useRouterContext } from "../routing";
+import { useDeepCompareMemoize } from "./useDeepCompareEffect";
+import { useDocumentSubscription } from "./useDocumentSubscription";
+function useFragment(reference, document) {
+  const { cache } = useRouterContext();
+  const { parent, variables, loading } = fragmentReference(
+    reference,
+    document
+  );
+  let cachedValue = reference;
+  if (reference && parent) {
+    cachedValue = cache.read({
+      selection: document.artifact.selection,
+      parent,
+      variables,
+      loading
+    }).data;
+  }
+  const [storeValue] = useDocumentSubscription({
+    artifact: document.artifact,
+    variables,
+    initialValue: cachedValue,
+    disabled: loading,
+    send: {
+      stuff: {
+        parentID: parent
+      },
+      setup: true
+    }
+  });
+  const lastReference = React.useRef(null);
+  return React.useMemo(() => {
+    const parentChange = storeValue.parent !== parent || !deepEquals({ parent, variables }, lastReference.current);
+    if (parentChange) {
+      lastReference.current = { parent, variables: { ...variables } };
+      return cachedValue;
+    }
+    return storeValue.data;
+  }, [
+    useDeepCompareMemoize({
+      parent,
+      variables,
+      cachedValue,
+      storeValue: storeValue.data,
+      storeParent: storeValue.parent
+    })
+  ]);
+}
+function fragmentReference(reference, document) {
+  const { variables, parent } = reference?.[fragmentKey]?.values?.[document.artifact.name] ?? {};
+  if (reference && 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.`
+    );
+  }
+  const loading = Boolean(reference?.[fragmentKey]?.loading);
+  return { variables, parent, loading };
+}
+export {
+  fragmentReference,
+  useFragment
+};

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

@@ -0,0 +1,8 @@
+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 GraphQLVariables = GraphQLVariables>(reference: _Data | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+    refetchArtifact?: QueryArtifact;
+}): DocumentHandle<_PaginationArtifact, _Data, _Input>;

package/build/runtime-esm/hooks/useFragmentHandle.js

@@ -0,0 +1,23 @@
+import { useDocumentHandle } from "./useDocumentHandle";
+import { useDocumentStore } from "./useDocumentStore";
+import { fragmentReference, useFragment } from "./useFragment";
+function useFragmentHandle(reference, document) {
+  const data = useFragment(reference, document);
+  const { variables } = fragmentReference(reference, document);
+  const [handleValue, handleObserver] = useDocumentStore({
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  const handle = useDocumentHandle({
+    observer: handleObserver,
+    storeValue: handleValue,
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  return {
+    ...handle,
+    variables,
+    data
+  };
+}
+export {
+  useFragmentHandle
+};

package/build/runtime-esm/hooks/useIsMounted.d.ts

@@ -0,0 +1,3 @@
+export declare function useIsMountedRef(): {
+    current: boolean;
+};

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

@@ -0,0 +1,14 @@
+import { useRef, useEffect } from "react";
+function useIsMountedRef() {
+  const isMountedRef = useRef(true);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+    };
+  }, []);
+  return isMountedRef;
+}
+export {
+  useIsMountedRef
+};

package/build/runtime-esm/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-esm/hooks/useMutation.js

@@ -0,0 +1,26 @@
+import { useSession } from "../routing/Router";
+import { useDocumentStore } from "./useDocumentStore";
+function useMutation({
+  artifact
+}) {
+  const [storeValue, observer] = useDocumentStore({ artifact });
+  const pending = storeValue.fetching;
+  const session = useSession();
+  const mutate = ({
+    metadata,
+    fetch,
+    variables,
+    ...mutationConfig
+  }) => observer.send({
+    variables,
+    metadata,
+    session,
+    stuff: {
+      ...mutationConfig
+    }
+  });
+  return [pending, mutate];
+}
+export {
+  useMutation
+};

package/build/runtime-esm/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-esm/hooks/useQuery.js

@@ -0,0 +1,8 @@
+import { useQueryHandle } from "./useQueryHandle";
+function useQuery(document, variables = null, config = {}) {
+  const { data } = useQueryHandle(document, variables, config);
+  return data;
+}
+export {
+  useQuery
+};

package/build/runtime-esm/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;
+};