houdini-react 1.2.0-react.1

package/build/plugin-esm/package.json

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

package/build/runtime/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/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/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/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/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/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/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/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/hooks/useHoudiniClient.d.ts

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

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

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

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

package/build/runtime/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/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/index.d.ts

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

package/build/runtime/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/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-cjs/context.js

@@ -0,0 +1,41 @@
+"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 context_exports = {};
+__export(context_exports, {
+  HoudiniContext: () => HoudiniContext,
+  HoudiniProvider: () => HoudiniProvider
+});
+module.exports = __toCommonJS(context_exports);
+var React = __toESM(require("react"));
+const HoudiniContext = React.createContext(null);
+const HoudiniProvider = ({
+  client,
+  children
+}) => /* @__PURE__ */ React.createElement(HoudiniContext.Provider, { value: client }, children);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HoudiniContext,
+  HoudiniProvider
+});

package/build/runtime-cjs/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-cjs/hooks/index.js

@@ -0,0 +1,45 @@
+"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 hooks_exports = {};
+__export(hooks_exports, {
+  useFragment: () => import_useFragment.useFragment,
+  useFragmentHandle: () => import_useFragmentHandle.useFragmentHandle,
+  useMutation: () => import_useMutation.useMutation,
+  useQuery: () => import_useQuery.useQuery,
+  useQueryHandle: () => import_useQueryHandle.useQueryHandle,
+  useSubscription: () => import_useSubscription.useSubscription
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_useQuery = require("./useQuery");
+var import_useQueryHandle = require("./useQueryHandle");
+var import_useFragment = require("./useFragment");
+var import_useFragmentHandle = require("./useFragmentHandle");
+var import_useMutation = require("./useMutation");
+var import_useSubscription = require("./useSubscription");
+var import_useDocumentHandle = require("./useDocumentHandle");
+var import_useQueryHandle2 = require("./useQueryHandle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFragment,
+  useFragmentHandle,
+  useMutation,
+  useQuery,
+  useQueryHandle,
+  useSubscription
+});

package/build/runtime-cjs/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-cjs/hooks/useDeepCompareEffect.js

@@ -0,0 +1,72 @@
+"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 useDeepCompareEffect_exports = {};
+__export(useDeepCompareEffect_exports, {
+  default: () => useDeepCompareEffect_default,
+  useDeepCompareEffectNoCheck: () => useDeepCompareEffectNoCheck,
+  useDeepCompareMemoize: () => useDeepCompareMemoize
+});
+module.exports = __toCommonJS(useDeepCompareEffect_exports);
+var import_deepEquals = require("$houdini/runtime/lib/deepEquals");
+var React = __toESM(require("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 (!(0, import_deepEquals.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDeepCompareEffectNoCheck,
+  useDeepCompareMemoize
+});

package/build/runtime-cjs/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 {};