gomtm 0.0.1 → 0.0.3

package/dist/esm/clientlib.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare function mergeRefs<T = any>(refs: Array<React.MutableRefObject<T> | React.LegacyRef<T>>): React.RefCallback<T>;
+export declare function getCookie(name: string): string | undefined;
+export declare function deleteCookie(name: string): void;
+export declare function deleteAllCookies(): void;
+export declare function setCookie(name: string, value: any): void;

package/dist/esm/clientlib.js

@@ -0,0 +1,44 @@
+"use client";
+function mergeRefs(refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ;
+        ref.current = value;
+      }
+    });
+  };
+}
+function getCookie(name) {
+  const cookieArr = document.cookie.split(";");
+  for (let i = 0; i < cookieArr.length; i++) {
+    const cookiePair = cookieArr[i].split("=");
+    if (name == cookiePair[0].trim()) {
+      return decodeURIComponent(cookiePair[1]);
+    }
+  }
+}
+function deleteCookie(name) {
+  document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+}
+function deleteAllCookies() {
+  const cookies = document.cookie.split(";");
+  for (let i = 0; i < cookies.length; i++) {
+    const cookie = cookies[i];
+    const eqPos = cookie.indexOf("=");
+    const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
+    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT";
+  }
+}
+function setCookie(name, value) {
+  document.cookie = `${name}=${value}`;
+}
+export {
+  deleteAllCookies,
+  deleteCookie,
+  getCookie,
+  mergeRefs,
+  setCookie
+};

package/dist/esm/connectquery/call-unary-method.d.ts

@@ -0,0 +1,8 @@
+import { PlainMessage, type Message, type PartialMessage } from "@bufbuild/protobuf";
+import type { CallOptions, Transport } from "@connectrpc/connect";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import { MtUnaryCallError } from "./utils";
+export declare function callUnaryMethod<I extends Message<I>, O extends Message<O>>(methodType: MethodUnaryDescriptor<I, O>, input: PartialMessage<I> | undefined, { callOptions, transport, }: {
+    transport: Transport;
+    callOptions?: CallOptions | undefined;
+}): Promise<PlainMessage<O> & MtUnaryCallError>;

package/dist/esm/connectquery/call-unary-method.js

@@ -0,0 +1,47 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { toPlainMessage } from "@bufbuild/protobuf";
+function callUnaryMethod(_0, _1, _2) {
+  return __async(this, arguments, function* (methodType, input, {
+    callOptions,
+    transport
+  }) {
+    try {
+      const result = yield transport.unary(
+        { typeName: methodType.service.typeName, methods: {} },
+        methodType,
+        callOptions == null ? void 0 : callOptions.signal,
+        callOptions == null ? void 0 : callOptions.timeoutMs,
+        callOptions == null ? void 0 : callOptions.headers,
+        input != null ? input : {}
+      );
+      return toPlainMessage(result.message);
+    } catch (e) {
+      return {
+        error_message: e == null ? void 0 : e.toString(),
+        error_code: "unary_call_error"
+      };
+    }
+  });
+}
+export {
+  callUnaryMethod
+};

package/dist/esm/connectquery/connect-query-key.d.ts

@@ -0,0 +1,16 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import type { DisableQuery } from "./utils";
+export type ConnectQueryKey<I extends Message<I>> = [
+    serviceTypeName: string,
+    methodName: string,
+    input: PartialMessage<I>
+];
+export declare function createConnectQueryKey<I extends Message<I>, O extends Message<O>>(methodDescriptor: Pick<MethodUnaryDescriptor<I, O>, "I" | "name" | "service">, input?: DisableQuery | PartialMessage<I> | undefined): ConnectQueryKey<I>;
+export type ConnectInfiniteQueryKey<I extends Message<I>> = [
+    serviceTypeName: string,
+    methodName: string,
+    input: PartialMessage<I>,
+    "infinite"
+];
+export declare function createConnectInfiniteQueryKey<I extends Message<I>, O extends Message<O>>(methodDescriptor: Pick<MethodUnaryDescriptor<I, O>, "I" | "name" | "service">, input?: DisableQuery | PartialMessage<I> | undefined): ConnectInfiniteQueryKey<I>;

package/dist/esm/connectquery/connect-query-key.js

@@ -0,0 +1,15 @@
+import { disableQuery } from "./utils";
+function createConnectQueryKey(methodDescriptor, input) {
+  return [
+    methodDescriptor.service.typeName,
+    methodDescriptor.name,
+    input === disableQuery || !input ? {} : input
+  ];
+}
+function createConnectInfiniteQueryKey(methodDescriptor, input) {
+  return [...createConnectQueryKey(methodDescriptor, input), "infinite"];
+}
+export {
+  createConnectInfiniteQueryKey,
+  createConnectQueryKey
+};

package/dist/esm/connectquery/create-use-infinite-query-options.d.ts

@@ -0,0 +1,21 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { CallOptions, ConnectError, Transport } from "@connectrpc/connect";
+import type { GetNextPageParamFunction, InfiniteData, QueryFunction, UseInfiniteQueryOptions, UseSuspenseInfiniteQueryOptions } from "@tanstack/react-query";
+import { type ConnectInfiniteQueryKey } from "./connect-query-key";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import { MtUnaryCallError, type DisableQuery } from "./utils";
+export interface ConnectInfiniteQueryOptions<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>> {
+    pageParamKey: ParamKey;
+    transport: Transport;
+    callOptions?: Omit<CallOptions, "signal"> | undefined;
+    getNextPageParam: GetNextPageParamFunction<PartialMessage<I>[ParamKey], O | MtUnaryCallError>;
+}
+export type CreateInfiniteQueryOptions<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>> = ConnectInfiniteQueryOptions<I, O, ParamKey> & Omit<UseInfiniteQueryOptions<O, ConnectError, InfiniteData<O>, O, ConnectInfiniteQueryKey<I>, PartialMessage<I>[ParamKey]>, "getNextPageParam" | "initialPageParam" | "queryFn" | "queryKey">;
+export type CreateSuspenseInfiniteQueryOptions<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>> = ConnectInfiniteQueryOptions<I, O, ParamKey> & Omit<UseSuspenseInfiniteQueryOptions<O, ConnectError, InfiniteData<O>, O, ConnectInfiniteQueryKey<I>, PartialMessage<I>[ParamKey]>, "getNextPageParam" | "initialPageParam" | "queryFn" | "queryKey">;
+export declare function createUseInfiniteQueryOptions<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>>(methodSig: MethodUnaryDescriptor<I, O>, input: DisableQuery | (PartialMessage<I> & Required<Pick<PartialMessage<I>, ParamKey>>), { transport, getNextPageParam, pageParamKey, callOptions, }: ConnectInfiniteQueryOptions<I, O, ParamKey>): {
+    getNextPageParam: ConnectInfiniteQueryOptions<I, O, ParamKey>["getNextPageParam"];
+    queryKey: ConnectInfiniteQueryKey<I>;
+    queryFn: QueryFunction<O | MtUnaryCallError, ConnectInfiniteQueryKey<I>, PartialMessage<I>[ParamKey]>;
+    initialPageParam: PartialMessage<I>[ParamKey];
+    enabled: boolean;
+};

package/dist/esm/connectquery/create-use-infinite-query-options.js

@@ -0,0 +1,92 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { callUnaryMethod } from "./call-unary-method";
+import {
+  createConnectInfiniteQueryKey
+} from "./connect-query-key";
+import { assert, disableQuery } from "./utils";
+function createUnaryInfiniteQueryFn(methodType, input, {
+  callOptions,
+  transport,
+  pageParamKey
+}) {
+  return (context) => __async(this, null, function* () {
+    var _a;
+    assert(input !== disableQuery, "Disabled query cannot be fetched");
+    assert("pageParam" in context, "pageParam must be part of context");
+    const inputCombinedWithPageParam = __spreadProps(__spreadValues({}, input), {
+      [pageParamKey]: context.pageParam
+    });
+    console.log("callUnaryMothod", inputCombinedWithPageParam);
+    return callUnaryMethod(methodType, inputCombinedWithPageParam, {
+      callOptions: __spreadProps(__spreadValues({}, callOptions), {
+        signal: (_a = callOptions == null ? void 0 : callOptions.signal) != null ? _a : context.signal
+      }),
+      transport
+    });
+  });
+}
+function createUseInfiniteQueryOptions(methodSig, input, {
+  transport,
+  getNextPageParam,
+  pageParamKey,
+  callOptions
+}) {
+  const queryKey = createConnectInfiniteQueryKey(
+    methodSig,
+    input === disableQuery ? void 0 : __spreadProps(__spreadValues({}, input), {
+      [pageParamKey]: void 0
+    })
+  );
+  return {
+    getNextPageParam,
+    initialPageParam: input === disableQuery ? void 0 : input[pageParamKey],
+    queryKey,
+    queryFn: createUnaryInfiniteQueryFn(methodSig, input, {
+      transport,
+      callOptions,
+      pageParamKey
+    }),
+    enabled: input !== disableQuery
+  };
+}
+export {
+  createUseInfiniteQueryOptions
+};

package/dist/esm/connectquery/create-use-query-options.d.ts

@@ -0,0 +1,19 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { CallOptions, ConnectError, Transport } from "@connectrpc/connect";
+import type { QueryFunction, UseQueryOptions, UseSuspenseQueryOptions } from "@tanstack/react-query";
+import type { ConnectQueryKey } from "./connect-query-key";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import { MtUnaryCallError, type DisableQuery } from "./utils";
+export interface ConnectQueryOptions {
+    transport: Transport;
+    callOptions?: Omit<CallOptions, "signal"> | undefined;
+}
+export type CreateQueryOptions<I extends Message<I>, O extends Message<O>, SelectOutData = 0 | MtUnaryCallError> = ConnectQueryOptions & Omit<UseQueryOptions<O | MtUnaryCallError, ConnectError, SelectOutData, ConnectQueryKey<I>>, "queryFn" | "queryKey">;
+export type CreateSuspenseQueryOptions<I extends Message<I>, O extends Message<O>, SelectOutData = 0> = ConnectQueryOptions & Omit<UseSuspenseQueryOptions<O | MtUnaryCallError, ConnectError, SelectOutData, ConnectQueryKey<I>>, "queryFn" | "queryKey">;
+export declare function createUseQueryOptions<I extends Message<I>, O extends Message<O>>(methodSig: MethodUnaryDescriptor<I, O>, input: DisableQuery | PartialMessage<I> | undefined, { transport, callOptions, }: ConnectQueryOptions & {
+    transport: Transport;
+}): {
+    queryKey: ConnectQueryKey<I>;
+    queryFn: QueryFunction<O | MtUnaryCallError, ConnectQueryKey<I>>;
+    enabled: boolean;
+};

package/dist/esm/connectquery/create-use-query-options.js

@@ -0,0 +1,74 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { callUnaryMethod } from "./call-unary-method";
+import { createConnectQueryKey } from "./connect-query-key";
+import { assert, disableQuery } from "./utils";
+function createUnaryQueryFn(methodType, input, {
+  callOptions,
+  transport
+}) {
+  return (context) => __async(this, null, function* () {
+    var _a;
+    assert(input !== disableQuery, "Disabled query cannot be fetched");
+    return callUnaryMethod(methodType, input, {
+      callOptions: __spreadProps(__spreadValues({}, callOptions), {
+        signal: (_a = callOptions == null ? void 0 : callOptions.signal) != null ? _a : context.signal
+      }),
+      transport
+    });
+  });
+}
+function createUseQueryOptions(methodSig, input, {
+  transport,
+  callOptions
+}) {
+  const queryKey = createConnectQueryKey(methodSig, input);
+  return {
+    queryKey,
+    queryFn: createUnaryQueryFn(methodSig, input, {
+      transport,
+      callOptions
+    }),
+    enabled: input !== disableQuery
+  };
+}
+export {
+  createUseQueryOptions
+};

package/dist/esm/connectquery/default-options.d.ts

@@ -0,0 +1,6 @@
+import stableHash from "stable-hash";
+export declare const defaultOptions: {
+    queries: {
+        queryKeyHashFn: typeof stableHash;
+    };
+};

package/dist/esm/connectquery/default-options.js

@@ -0,0 +1,9 @@
+import stableHash from "stable-hash";
+const defaultOptions = {
+  queries: {
+    queryKeyHashFn: stableHash
+  }
+};
+export {
+  defaultOptions
+};

package/dist/esm/connectquery/index.d.ts

@@ -0,0 +1,16 @@
+export { callUnaryMethod } from "./call-unary-method";
+export { createConnectInfiniteQueryKey, createConnectQueryKey } from "./connect-query-key";
+export type { ConnectInfiniteQueryKey, ConnectQueryKey } from "./connect-query-key";
+export { createUseInfiniteQueryOptions as createInfiniteQueryOptions } from "./create-use-infinite-query-options";
+export type { CreateInfiniteQueryOptions as UseInfiniteQueryOptions } from "./create-use-infinite-query-options";
+export { createUseQueryOptions as createQueryOptions } from "./create-use-query-options";
+export type { CreateQueryOptions as UseQueryOptions } from "./create-use-query-options";
+export { defaultOptions } from "./default-options";
+export type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+export { useInfiniteQuery, useSuspenseInfiniteQuery } from "./use-infinite-query";
+export { useMutation } from "./use-mutation";
+export type { UseMutationOptions } from "./use-mutation";
+export { useQuery, useSuspenseQuery } from "./use-query";
+export { TransportProvider, useTransport } from "./use-transport";
+export { createProtobufSafeUpdater, disableQuery } from "./utils";
+export type { ConnectUpdater, DisableQuery } from "./utils";

package/dist/esm/connectquery/index.js

@@ -0,0 +1,33 @@
+import { callUnaryMethod } from "./call-unary-method";
+import {
+  createConnectInfiniteQueryKey,
+  createConnectQueryKey
+} from "./connect-query-key";
+import { createUseInfiniteQueryOptions } from "./create-use-infinite-query-options";
+import { createUseQueryOptions } from "./create-use-query-options";
+import { defaultOptions } from "./default-options";
+import {
+  useInfiniteQuery,
+  useSuspenseInfiniteQuery
+} from "./use-infinite-query";
+import { useMutation } from "./use-mutation";
+import { useQuery, useSuspenseQuery } from "./use-query";
+import { TransportProvider, useTransport } from "./use-transport";
+import { createProtobufSafeUpdater, disableQuery } from "./utils";
+export {
+  TransportProvider,
+  callUnaryMethod,
+  createConnectInfiniteQueryKey,
+  createConnectQueryKey,
+  createUseInfiniteQueryOptions as createInfiniteQueryOptions,
+  createProtobufSafeUpdater,
+  createUseQueryOptions as createQueryOptions,
+  defaultOptions,
+  disableQuery,
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+  useSuspenseInfiniteQuery,
+  useSuspenseQuery,
+  useTransport
+};

package/dist/esm/connectquery/method-unary-descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { Message, MethodInfoUnary, ServiceType } from "@bufbuild/protobuf";
+export type MethodUnaryDescriptor<I extends Message<I>, O extends Message<O>> = MethodInfoUnary<I, O> & {
+    readonly service: Omit<ServiceType, "methods">;
+};

package/dist/esm/connectquery/use-infinite-query.d.ts

@@ -0,0 +1,12 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { ConnectError, Transport } from "@connectrpc/connect";
+import type { InfiniteData, UseInfiniteQueryResult, UseSuspenseInfiniteQueryResult } from "@tanstack/react-query";
+import type { CreateInfiniteQueryOptions, CreateSuspenseInfiniteQueryOptions } from "./create-use-infinite-query-options";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import type { DisableQuery, MtUnaryCallError } from "./utils";
+export declare function useInfiniteQuery<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>>(methodSig: MethodUnaryDescriptor<I, O>, input: DisableQuery | (PartialMessage<I> & Required<Pick<PartialMessage<I>, ParamKey>>), { transport, callOptions, pageParamKey, getNextPageParam, ...options }: Omit<CreateInfiniteQueryOptions<I, O, ParamKey>, "transport"> & {
+    transport?: Transport;
+}): UseInfiniteQueryResult<InfiniteData<O | MtUnaryCallError>, ConnectError>;
+export declare function useSuspenseInfiniteQuery<I extends Message<I>, O extends Message<O>, ParamKey extends keyof PartialMessage<I>>(methodSig: MethodUnaryDescriptor<I, O>, input: PartialMessage<I> & Required<Pick<PartialMessage<I>, ParamKey>>, { transport, callOptions, pageParamKey, getNextPageParam, ...options }: Omit<CreateSuspenseInfiniteQueryOptions<I, O, ParamKey>, "transport" | "refetchInterval"> & {
+    transport?: Transport;
+}): UseSuspenseInfiniteQueryResult<InfiniteData<O & MtUnaryCallError>, ConnectError>;

package/dist/esm/connectquery/use-infinite-query.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import {
+  useInfiniteQuery as tsUseInfiniteQuery,
+  useSuspenseInfiniteQuery as tsUseSuspenseInfiniteQuery
+} from "@tanstack/react-query";
+import { createUseInfiniteQueryOptions } from "./create-use-infinite-query-options";
+import { useTransport } from "./use-transport";
+function useInfiniteQuery(methodSig, input, _a) {
+  var _b = _a, {
+    transport,
+    callOptions,
+    pageParamKey,
+    getNextPageParam
+  } = _b, options = __objRest(_b, [
+    "transport",
+    "callOptions",
+    "pageParamKey",
+    "getNextPageParam"
+  ]);
+  var _a2;
+  const transportFromCtx = useTransport();
+  const baseOptions = createUseInfiniteQueryOptions(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    getNextPageParam,
+    pageParamKey,
+    callOptions
+  });
+  const enabled = baseOptions.enabled && ((_a2 = options.enabled) != null ? _a2 : true);
+  return tsUseInfiniteQuery(__spreadProps(__spreadValues(__spreadValues({}, options), baseOptions), {
+    enabled
+  }));
+}
+function useSuspenseInfiniteQuery(methodSig, input, _c) {
+  var _d = _c, {
+    transport,
+    callOptions,
+    pageParamKey,
+    getNextPageParam
+  } = _d, options = __objRest(_d, [
+    "transport",
+    "callOptions",
+    "pageParamKey",
+    "getNextPageParam"
+  ]);
+  const transportFromCtx = useTransport();
+  const baseOptions = createUseInfiniteQueryOptions(methodSig, input, {
+    transport: transport != null ? transport : transportFromCtx,
+    getNextPageParam,
+    pageParamKey,
+    callOptions
+  });
+  return tsUseSuspenseInfiniteQuery(__spreadValues(__spreadValues({}, options), baseOptions));
+}
+export {
+  useInfiniteQuery,
+  useSuspenseInfiniteQuery
+};

package/dist/esm/connectquery/use-mutation.d.ts

@@ -0,0 +1,10 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { CallOptions, ConnectError, Transport } from "@connectrpc/connect";
+import type { UseMutationOptions as TSUseMutationOptions, UseMutationResult } from "@tanstack/react-query";
+import type { ConnectQueryKey } from "./connect-query-key";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+export type UseMutationOptions<I extends Message<I>, O extends Message<O>> = Omit<TSUseMutationOptions<O, ConnectError, PartialMessage<I>, ConnectQueryKey<I>>, "mutationFn"> & {
+    transport?: Transport;
+    callOptions?: CallOptions;
+};
+export declare function useMutation<I extends Message<I>, O extends Message<O>>(methodSig: MethodUnaryDescriptor<I, O>, { transport, callOptions, ...queryOptions }?: UseMutationOptions<I, O>): UseMutationResult<O, ConnectError, PartialMessage<I>>;

package/dist/esm/connectquery/use-mutation.js

@@ -0,0 +1,79 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { useMutation as tsUseMutation } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { useTransport } from "./use-transport";
+function useMutation(methodSig, _a = {}) {
+  var _b = _a, { transport, callOptions } = _b, queryOptions = __objRest(_b, ["transport", "callOptions"]);
+  const transportFromCtx = useTransport();
+  const transportToUse = transport != null ? transport : transportFromCtx;
+  const mutationFn = useCallback(
+    (input) => __async(this, null, function* () {
+      const result = yield transportToUse.unary(
+        { typeName: methodSig.service.typeName, methods: {} },
+        methodSig,
+        callOptions == null ? void 0 : callOptions.signal,
+        callOptions == null ? void 0 : callOptions.timeoutMs,
+        callOptions == null ? void 0 : callOptions.headers,
+        input
+      );
+      return result.message;
+    }),
+    [transportToUse, callOptions, methodSig]
+  );
+  return tsUseMutation(__spreadProps(__spreadValues({}, queryOptions), {
+    mutationFn
+  }));
+}
+export {
+  useMutation
+};

package/dist/esm/connectquery/use-query.d.ts

@@ -0,0 +1,12 @@
+import type { Message, PartialMessage } from "@bufbuild/protobuf";
+import type { ConnectError, Transport } from "@connectrpc/connect";
+import type { UseQueryResult, UseSuspenseQueryResult } from "@tanstack/react-query";
+import type { CreateQueryOptions, CreateSuspenseQueryOptions } from "./create-use-query-options";
+import type { MethodUnaryDescriptor } from "./method-unary-descriptor";
+import type { DisableQuery, MtUnaryCallError } from "./utils";
+export declare function useQuery<I extends Message<I>, O extends Message<O>, SelectOutData = O>(methodSig: MethodUnaryDescriptor<I, O>, input?: DisableQuery | PartialMessage<I>, { transport, callOptions, ...queryOptions }?: Omit<CreateQueryOptions<I, O, SelectOutData>, "transport"> & {
+    transport?: Transport;
+}): UseQueryResult<SelectOutData | MtUnaryCallError, ConnectError>;
+export declare function useSuspenseQuery<I extends Message<I>, O extends Message<O>, SelectOutData = O & MtUnaryCallError>(methodSig: MethodUnaryDescriptor<I, O>, input?: PartialMessage<I>, { transport, callOptions, ...queryOptions }?: Omit<CreateSuspenseQueryOptions<I, O, SelectOutData>, "transport"> & {
+    transport?: Transport;
+}): UseSuspenseQueryResult<SelectOutData, ConnectError>;