@orpc/svelte-query/dist/index.mjs

<div align="center"> <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" /> </div>

import { generateOperationKey } from '@orpc/tanstack-query';
export { generateOperationKey as buildKey } from '@orpc/tanstack-query';
import { isAsyncIteratorObject } from '@orpc/shared';
import { skipToken, experimental_streamedQuery } from '@tanstack/svelte-query';

function createGeneralUtils(path) {
  return {
    key(options) {
      return generateOperationKey(path, options);
    }
  };
}

function createProcedureUtils(client, options) {
  return {
    call: client,
    queryOptions(...[optionsIn = {}]) {
      return {
        queryKey: generateOperationKey(options.path, { type: "query", input: optionsIn.input }),
        queryFn: ({ signal }) => {
          if (optionsIn.input === skipToken) {
            throw new Error("queryFn should not be called with skipToken used as input");
          }
          return client(optionsIn.input, { signal, context: optionsIn.context });
        },
        enabled: optionsIn.input !== skipToken,
        ...optionsIn
      };
    },
    experimental_streamedOptions(...[optionsIn = {}]) {
      return {
        enabled: optionsIn.input !== skipToken,
        queryKey: generateOperationKey(options.path, { type: "streamed", input: optionsIn.input, fnOptions: optionsIn.queryFnOptions }),
        queryFn: experimental_streamedQuery({
          queryFn: async ({ signal }) => {
            if (optionsIn.input === skipToken) {
              throw new Error("queryFn should not be called with skipToken used as input");
            }
            const output = await client(optionsIn.input, { signal, context: optionsIn.context });
            if (!isAsyncIteratorObject(output)) {
              throw new Error("streamedQuery requires an event iterator output");
            }
            return output;
          },
          ...optionsIn.queryFnOptions
        }),
        ...optionsIn
      };
    },
    infiniteOptions(optionsIn) {
      return {
        queryKey: generateOperationKey(options.path, {
          type: "infinite",
          input: optionsIn.input === skipToken ? skipToken : optionsIn.input(optionsIn.initialPageParam)
        }),
        queryFn: ({ pageParam, signal }) => {
          if (optionsIn.input === skipToken) {
            throw new Error("queryFn should not be called with skipToken used as input");
          }
          return client(optionsIn.input(pageParam), { signal, context: optionsIn.context });
        },
        enabled: optionsIn.input !== skipToken,
        ...optionsIn
      };
    },
    mutationOptions(...[optionsIn = {}]) {
      return {
        mutationKey: generateOperationKey(options.path, { type: "mutation" }),
        mutationFn: (input) => client(input, { context: optionsIn.context }),
        ...optionsIn
      };
    }
  };
}

function createRouterUtils(client, options = {}) {
  const path = options.path ?? [];
  const generalUtils = createGeneralUtils(path);
  const procedureUtils = createProcedureUtils(client, { path });
  const recursive = new Proxy({
    ...generalUtils,
    ...procedureUtils
  }, {
    get(target, prop) {
      const value = Reflect.get(target, prop);
      if (typeof prop !== "string") {
        return value;
      }
      const nextUtils = createRouterUtils(client[prop], { ...options, path: [...path, prop] });
      if (typeof value !== "function") {
        return nextUtils;
      }
      return new Proxy(value, {
        get(_, prop2) {
          return Reflect.get(nextUtils, prop2);
        }
      });
    }
  });
  return recursive;
}

export { createGeneralUtils, createRouterUtils as createORPCSvelteQueryUtils, createProcedureUtils, createRouterUtils };