houdini-react 1.2.0-react.1

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

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

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useSubscription_exports = {};
+__export(useSubscription_exports, {
+  useSubscription: () => useSubscription
+});
+module.exports = __toCommonJS(useSubscription_exports);
+var import_useSubscriptionHandle = require("./useSubscriptionHandle");
+function useSubscription(document, variables) {
+  const { data } = (0, import_useSubscriptionHandle.useSubscriptionHandle)(document, variables);
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSubscription
+});

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

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

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

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useSubscriptionHandle_exports = {};
+__export(useSubscriptionHandle_exports, {
+  useSubscriptionHandle: () => useSubscriptionHandle
+});
+module.exports = __toCommonJS(useSubscriptionHandle_exports);
+var import_useDocumentSubscription = require("./useDocumentSubscription");
+function useSubscriptionHandle({ artifact }, variables) {
+  const [storeValue, observer] = (0, import_useDocumentSubscription.useDocumentSubscription)({
+    artifact,
+    variables
+  });
+  return {
+    data: storeValue.data,
+    errors: storeValue.errors,
+    fetching: storeValue.fetching,
+    variables,
+    unlisten: observer.cleanup,
+    listen: observer.send
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSubscriptionHandle
+});

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

@@ -0,0 +1,2 @@
+export * from './hooks';
+export { HoudiniProvider } from './context';

package/build/runtime-cjs/index.js

@@ -0,0 +1,30 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runtime_exports = {};
+__export(runtime_exports, {
+  HoudiniProvider: () => import_context.HoudiniProvider
+});
+module.exports = __toCommonJS(runtime_exports);
+__reExport(runtime_exports, require("./hooks"), module.exports);
+var import_context = require("./context");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HoudiniProvider
+});

package/build/runtime-cjs/lib/cache.d.ts

@@ -0,0 +1,62 @@
+/**
+ * This file is a copy and paste of a very simple and effective LRU cache
+ * using javascript maps. It was copied under the MIT license found at the
+ * bottom of the page.
+ */
+export interface Cache<T> {
+    get(key: string): T | null;
+    set(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}
+/**
+ * JS maps (both plain objects and Map) maintain key insertion
+ * order, which means there is an easy way to simulate LRU behavior
+ * that should also perform quite well:
+ *
+ * To insert a new value, first delete the key from the inner _map,
+ * then _map.set(k, v). By deleting and reinserting, you ensure that the
+ * map sees the key as the last inserted key.
+ *
+ * Get does the same: if the key is present, delete and reinsert it.
+ */
+declare class LRUCache<T> implements Cache<T> {
+    _capacity: number;
+    _map: Map<string, T>;
+    constructor(capacity?: number);
+    set(key: string, value: T): void;
+    get(key: string): T | null;
+    has(key: string): boolean;
+    delete(key: string): void;
+    size(): number;
+    capacity(): number;
+    clear(): void;
+}
+export declare function createCache<T>(capacity?: number): LRUCache<T>;
+export {};
+/**
+MIT License
+
+Copyright (c) Meta Platforms, Inc. and affiliates.
+
+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-cjs/lib/cache.js

@@ -0,0 +1,71 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  createCache: () => createCache
+});
+module.exports = __toCommonJS(cache_exports);
+class LRUCache {
+  _capacity;
+  _map;
+  constructor(capacity = 1e3) {
+    this._capacity = capacity;
+    this._map = /* @__PURE__ */ new Map();
+  }
+  set(key, value) {
+    this._map.delete(key);
+    this._map.set(key, value);
+    if (this._map.size > this._capacity) {
+      const firstKey = this._map.keys().next();
+      if (!firstKey.done) {
+        this._map.delete(firstKey.value);
+      }
+    }
+  }
+  get(key) {
+    const value = this._map.get(key);
+    if (value != null) {
+      this._map.delete(key);
+      this._map.set(key, value);
+    }
+    return value ?? null;
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  delete(key) {
+    this._map.delete(key);
+  }
+  size() {
+    return this._map.size;
+  }
+  capacity() {
+    return this._capacity - this._map.size;
+  }
+  clear() {
+    this._map.clear();
+  }
+}
+function createCache(capacity = 1e3) {
+  return new LRUCache(capacity);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache
+});

package/build/runtime-cjs/package.json

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

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

@@ -0,0 +1,7 @@
+import { HoudiniClient } from '$houdini/runtime';
+import * as React from 'react';
+export declare const HoudiniContext: React.Context<HoudiniClient | null>;
+export declare const HoudiniProvider: ({ client, children, }: {
+    client: HoudiniClient;
+    children: React.ReactNode;
+}) => JSX.Element;

package/build/runtime-esm/context.js

@@ -0,0 +1,10 @@
+import * as React from "react";
+const HoudiniContext = React.createContext(null);
+const HoudiniProvider = ({
+  client,
+  children
+}) => /* @__PURE__ */ React.createElement(HoudiniContext.Provider, { value: client }, children);
+export {
+  HoudiniContext,
+  HoudiniProvider
+};

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 { DocumentStore } from '$houdini/runtime/client';
+import { type QueryArtifact, GraphQLObject, CursorHandlers, OffsetHandlers, PageInfo, FetchFn, QueryResult, DocumentArtifact } from '$houdini/runtime/lib/types';
+export declare function useDocumentHandle<_Artifact extends QueryArtifact, _Data extends GraphQLObject, _Input extends Record<string, any>>({ 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 {} = []> = {
+    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,99 @@
+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";
+function useDocumentHandle({
+  artifact,
+  observer,
+  storeValue
+}) {
+  const [forwardPending, setForwardPending] = React.useState(false);
+  const [backwardPending, setBackwardPending] = React.useState(false);
+  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);
+    if (artifact.kind !== ArtifactKind.Query || !artifact.refetch?.paginated) {
+      return {
+        data: storeValue.data,
+        fetch: fetchQuery,
+        partial: storeValue.partial
+      };
+    }
+    const getSession = async () => ({});
+    if (artifact.refetch.method === "cursor") {
+      const handlers = 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: 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 () => ({})
+      });
+      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]);
+}
+export {
+  useDocumentHandle
+};

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