houdini-react 0.0.0-20231008055552

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 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-cjs/hooks/useDocumentHandle.js

@@ -0,0 +1,131 @@
+"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"));
+var import_Router = require("../routing/Router");
+function useDocumentHandle({
+  artifact,
+  observer,
+  storeValue
+}) {
+  const [forwardPending, setForwardPending] = import_react.default.useState(false);
+  const [backwardPending, setBackwardPending] = import_react.default.useState(false);
+  const session = (0, import_Router.useSession)();
+  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,
+      session
+    });
+    if (artifact.kind !== import_types.ArtifactKind.Query || !artifact.refetch?.paginated) {
+      return {
+        data: storeValue.data,
+        fetch: fetchQuery,
+        partial: storeValue.partial
+      };
+    }
+    if (artifact.refetch.method === "cursor") {
+      const handlers = (0, import_pagination.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: (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 () => 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]);
+}
+// 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,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-cjs/hooks/useDocumentStore.js

@@ -0,0 +1,68 @@
+"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_routing = require("../routing");
+var import_useIsMounted = require("./useIsMounted");
+function useDocumentStore({
+  artifact,
+  observer: obs,
+  ...observeParams
+}) {
+  const client = (0, import_routing.useClient)();
+  const isMountedRef = (0, import_useIsMounted.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];
+}
+// 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,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-cjs/hooks/useDocumentSubscription.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 useDocumentSubscription_exports = {};
+__export(useDocumentSubscription_exports, {
+  useDocumentSubscription: () => useDocumentSubscription
+});
+module.exports = __toCommonJS(useDocumentSubscription_exports);
+var import_Router = require("../routing/Router");
+var import_useDeepCompareEffect = __toESM(require("./useDeepCompareEffect"));
+var import_useDocumentStore = require("./useDocumentStore");
+function useDocumentSubscription({
+  artifact,
+  variables,
+  send,
+  disabled,
+  ...observeParams
+}) {
+  const [storeValue, observer, setObserver] = (0, import_useDocumentStore.useDocumentStore)({
+    artifact,
+    ...observeParams
+  });
+  const session = (0, import_Router.useSession)();
+  (0, import_useDeepCompareEffect.default)(() => {
+    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
+  ];
+}
+// 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,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-cjs/hooks/useFragment.js

@@ -0,0 +1,97 @@
+"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_deepEquals = require("$houdini/runtime/lib/deepEquals");
+var import_types = require("$houdini/runtime/lib/types");
+var React = __toESM(require("react"));
+var import_routing = require("../routing");
+var import_useDeepCompareEffect = require("./useDeepCompareEffect");
+var import_useDocumentSubscription = require("./useDocumentSubscription");
+function useFragment(reference, document) {
+  const { cache } = (0, import_routing.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] = (0, import_useDocumentSubscription.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 || !(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]?.values?.[document.artifact.name] ?? {};
+  if (reference && import_types.fragmentKey in reference && (!variables || !parent)) {
+    console.warn(
+      `\u26A0\uFE0F Parent does not contain the information for this fragment. Something is wrong.
+Please ensure that you have passed a record that has ${document.artifact.name} mixed into it.`
+    );
+  }
+  const loading = Boolean(reference?.[import_types.fragmentKey]?.loading);
+  return { variables, parent, loading };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fragmentReference,
+  useFragment
+});

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

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