houdini-react 1.2.0-react.1

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

@@ -0,0 +1,127 @@
+"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 useDocumentHandle_exports = {};
+__export(useDocumentHandle_exports, {
+  useDocumentHandle: () => useDocumentHandle
+});
+module.exports = __toCommonJS(useDocumentHandle_exports);
+var import_pageInfo = require("$houdini/runtime/lib/pageInfo");
+var import_pagination = require("$houdini/runtime/lib/pagination");
+var import_types = require("$houdini/runtime/lib/types");
+var import_react = __toESM(require("react"));
+function useDocumentHandle({
+  artifact,
+  observer,
+  storeValue
+}) {
+  const [forwardPending, setForwardPending] = import_react.default.useState(false);
+  const [backwardPending, setBackwardPending] = import_react.default.useState(false);
+  return import_react.default.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);
+    if (artifact.kind !== import_types.ArtifactKind.Query || !artifact.refetch?.paginated) {
+      return {
+        data: storeValue.data,
+        fetch: fetchQuery,
+        partial: storeValue.partial
+      };
+    }
+    const getSession = async () => ({});
+    if (artifact.refetch.method === "cursor") {
+      const handlers = (0, import_pagination.cursorHandlers)({
+        artifact,
+        getState: () => storeValue.data,
+        getVariables: () => storeValue.variables,
+        storeName: artifact.name,
+        fetch: fetchQuery,
+        fetchUpdate: (args, updates) => {
+          return observer.send({
+            ...args,
+            cacheParams: {
+              disableSubscriptions: true,
+              applyUpdates: updates,
+              ...args?.cacheParams
+            }
+          });
+        },
+        getSession
+      });
+      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: (0, import_pageInfo.extractPageInfo)(storeValue.data, artifact.refetch.path)
+      };
+    }
+    if (artifact.refetch.method === "offset") {
+      const handlers = (0, import_pagination.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 () => ({})
+      });
+      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, storeValue, true, true]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDocumentHandle
+});

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

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

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

@@ -0,0 +1,63 @@
+"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 useDocumentStore_exports = {};
+__export(useDocumentStore_exports, {
+  useDocumentStore: () => useDocumentStore
+});
+module.exports = __toCommonJS(useDocumentStore_exports);
+var React = __toESM(require("react"));
+var import_useHoudiniClient = require("./useHoudiniClient");
+var import_useIsMounted = require("./useIsMounted");
+function useDocumentStore({
+  artifact,
+  ...observeParams
+}) {
+  const client = (0, import_useHoudiniClient.useHoudiniClient)();
+  const isMountedRef = (0, import_useIsMounted.useIsMountedRef)();
+  let [observer, setObserver] = React.useState(
+    () => 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);
+  return [storeValue, observer, setObserver];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDocumentStore
+});

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

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

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

@@ -0,0 +1,65 @@
+"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 useDocumentSubscription_exports = {};
+__export(useDocumentSubscription_exports, {
+  useDocumentSubscription: () => useDocumentSubscription
+});
+module.exports = __toCommonJS(useDocumentSubscription_exports);
+var import_useDeepCompareEffect = __toESM(require("./useDeepCompareEffect"));
+var import_useDocumentStore = require("./useDocumentStore");
+function useDocumentSubscription({
+  artifact,
+  variables,
+  send,
+  ...observeParams
+}) {
+  const [storeValue, observer, setObserver] = (0, import_useDocumentStore.useDocumentStore)({
+    artifact,
+    ...observeParams
+  });
+  (0, import_useDeepCompareEffect.default)(() => {
+    observer.send({
+      variables,
+      session: {},
+      metadata: {},
+      ...send
+    });
+    return () => {
+      observer.cleanup();
+    };
+  }, [observer, variables ?? {}, send ?? {}]);
+  return [
+    {
+      parent: send?.stuff?.parentID,
+      ...storeValue
+    },
+    observer,
+    setObserver
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDocumentSubscription
+});

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

@@ -0,0 +1,15 @@
+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 | {
+    [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;
+};

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

@@ -0,0 +1,93 @@
+"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 useFragment_exports = {};
+__export(useFragment_exports, {
+  fragmentReference: () => fragmentReference,
+  useFragment: () => useFragment
+});
+module.exports = __toCommonJS(useFragment_exports);
+var import_cache = __toESM(require("$houdini/runtime/cache"));
+var import_deepEquals = require("$houdini/runtime/lib/deepEquals");
+var import_types = require("$houdini/runtime/lib/types");
+var React = __toESM(require("react"));
+var import_useDeepCompareEffect = require("./useDeepCompareEffect");
+var import_useDocumentSubscription = require("./useDocumentSubscription");
+function useFragment(reference, document) {
+  const { parent, variables } = fragmentReference(
+    reference,
+    document
+  );
+  let cachedValue = reference;
+  if (reference && parent) {
+    cachedValue = import_cache.default.read({
+      selection: document.artifact.selection,
+      parent,
+      variables
+    }).data;
+  }
+  const observeParams = {
+    artifact: document.artifact,
+    variables,
+    initialValue: cachedValue,
+    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);
+    if (parentChange) {
+      lastReference.current = { parent, variables: { ...variables } };
+      return cachedValue;
+    }
+    return storeValue.data;
+  }, [
+    (0, import_useDeepCompareEffect.useDeepCompareMemoize)({
+      parent,
+      variables,
+      cachedValue,
+      storeValue: storeValue.data,
+      storeParent: storeValue.parent
+    })
+  ]);
+}
+function fragmentReference(reference, document) {
+  const { variables, parent } = reference?.[import_types.fragmentKey]?.[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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fragmentReference,
+  useFragment
+});

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

@@ -0,0 +1,9 @@
+import type { GraphQLObject, FragmentArtifact, QueryArtifact } from '$houdini/runtime/lib/types';
+import { fragmentKey } 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 | {
+    [fragmentKey]: _ReferenceType;
+} | null, document: {
+    artifact: FragmentArtifact;
+    refetchArtifact?: QueryArtifact;
+}): DocumentHandle<_PaginationArtifact, _Data, _Input>;

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

@@ -0,0 +1,47 @@
+"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 useFragmentHandle_exports = {};
+__export(useFragmentHandle_exports, {
+  useFragmentHandle: () => useFragmentHandle
+});
+module.exports = __toCommonJS(useFragmentHandle_exports);
+var import_useDocumentHandle = require("./useDocumentHandle");
+var import_useDocumentStore = require("./useDocumentStore");
+var import_useFragment = require("./useFragment");
+function useFragmentHandle(reference, document) {
+  const data = (0, import_useFragment.useFragment)(reference, document);
+  const { variables } = (0, import_useFragment.fragmentReference)(reference, document);
+  const [handleValue, handleObserver] = (0, import_useDocumentStore.useDocumentStore)({
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  const handle = (0, import_useDocumentHandle.useDocumentHandle)({
+    observer: handleObserver,
+    storeValue: handleValue,
+    artifact: document.refetchArtifact ?? document.artifact
+  });
+  return {
+    ...handle,
+    variables,
+    data
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFragmentHandle
+});

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

@@ -0,0 +1,2 @@
+import type { HoudiniClient } from '$houdini/runtime/client';
+export declare function useHoudiniClient(): HoudiniClient;

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

@@ -0,0 +1,42 @@
+"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 useHoudiniClient_exports = {};
+__export(useHoudiniClient_exports, {
+  useHoudiniClient: () => useHoudiniClient
+});
+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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHoudiniClient
+});

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

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

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 } 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, }: {
+    artifact: MutationArtifact;
+}): [boolean, MutationHandler<_Result, _Input, _Optimistic>];

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

@@ -0,0 +1,48 @@
+"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_useDocumentStore = require("./useDocumentStore");
+function useMutation({
+  artifact
+}) {
+  const [storeValue, observer] = (0, import_useDocumentStore.useDocumentStore)({ artifact });
+  const pending = storeValue.fetching;
+  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 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: {
+    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 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 }: {
+    artifact: QueryArtifact;
+}, variables?: any, config?: UseQueryConfig): DocumentHandle<_Artifact, _Data, _Input>;
+export type UseQueryConfig = {
+    policy?: CachePolicies;
+    metadata?: App.Metadata;
+    fetchKey?: any;
+};