@trpc/client 9.16.0 → 10.0.0-alpha.1

package/src/rx/operators/share.test.ts

@@ -0,0 +1,60 @@
+/* eslint-disable no-var */
+import { observable } from '../observable';
+import { share } from './share';
+
+test('share', () => {
+  const obs = share()(
+    observable<number, Error>((observer) => {
+      observer.next(1);
+    }),
+  );
+
+  {
+    const next = jest.fn();
+    const error = jest.fn();
+    const complete = jest.fn();
+    var subscription1 = obs.subscribe({
+      next,
+      error,
+      complete,
+    });
+    expect(next.mock.calls).toHaveLength(1);
+    expect(complete.mock.calls).toHaveLength(0);
+    expect(error.mock.calls).toHaveLength(0);
+    expect(next.mock.calls[0][0]).toBe(1);
+  }
+
+  {
+    // subscribe again - it's shared so should not propagate any results
+    const next = jest.fn();
+    const error = jest.fn();
+    const complete = jest.fn();
+    var subscription2 = obs.subscribe({
+      next,
+      error,
+      complete,
+    });
+    expect(next.mock.calls).toHaveLength(0);
+    expect(complete.mock.calls).toHaveLength(0);
+    expect(error.mock.calls).toHaveLength(0);
+  }
+
+  subscription1.unsubscribe();
+  subscription2.unsubscribe();
+  // now it should be reset so we can do a new subscription
+  {
+    const next = jest.fn();
+    const error = jest.fn();
+    const complete = jest.fn();
+    var subscription3 = obs.subscribe({
+      next,
+      error,
+      complete,
+    });
+    expect(next.mock.calls).toHaveLength(1);
+    expect(complete.mock.calls).toHaveLength(0);
+    expect(error.mock.calls).toHaveLength(0);
+    expect(next.mock.calls[0][0]).toBe(1);
+    subscription3.unsubscribe();
+  }
+});

package/src/rx/operators/share.ts

@@ -0,0 +1,67 @@
+import { MonoTypeOperatorFunction, Observer, Unsubscribable } from '../types';
+
+/* eslint-disable @typescript-eslint/no-empty-interface */
+interface ShareConfig {}
+export function share<TValue, TError>(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _opts?: ShareConfig,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (originalObserver) => {
+    let refCount = 0;
+
+    let subscription: Unsubscribable | null = null;
+    const observers: Partial<Observer<TValue, TError>>[] = [];
+
+    function startIfNeeded() {
+      if (subscription) {
+        return;
+      }
+      subscription = originalObserver.subscribe({
+        next(value) {
+          for (const observer of observers) {
+            observer.next?.(value);
+          }
+        },
+        error(error) {
+          for (const observer of observers) {
+            observer.error?.(error);
+          }
+        },
+        complete() {
+          for (const observer of observers) {
+            observer.complete?.();
+          }
+        },
+      });
+    }
+    function resetIfNeeded() {
+      // "resetOnRefCountZero"
+      if (refCount === 0 && subscription) {
+        const _sub = subscription;
+        subscription = null;
+        _sub.unsubscribe();
+      }
+    }
+
+    return {
+      subscribe(observer) {
+        refCount++;
+
+        observers.push(observer);
+        startIfNeeded();
+        return {
+          unsubscribe() {
+            refCount--;
+            resetIfNeeded();
+
+            const index = observers.findIndex((v) => v === observer);
+
+            if (index > -1) {
+              observers.splice(index, 1);
+            }
+          },
+        };
+      },
+    };
+  };
+}

package/src/rx/operators/tap.ts

@@ -0,0 +1,26 @@
+import { MonoTypeOperatorFunction, Observer } from '../types';
+
+export function tap<TValue, TError>(
+  observer: Partial<Observer<TValue, TError>>,
+): MonoTypeOperatorFunction<TValue, TError> {
+  return (originalObserver) => {
+    return {
+      subscribe(observer2) {
+        return originalObserver.subscribe({
+          next(v) {
+            observer.next?.(v);
+            observer2.next?.(v);
+          },
+          error(v) {
+            observer.error?.(v);
+            observer2.error?.(v);
+          },
+          complete() {
+            observer.complete?.();
+            observer2.complete?.();
+          },
+        });
+      },
+    };
+  };
+}

package/src/rx/types.ts

@@ -0,0 +1,69 @@
+export interface Unsubscribable {
+  unsubscribe(): void;
+}
+export type UnsubscribeFn = () => void;
+export interface Subscribable<TValue, TError> {
+  subscribe(observer: Partial<Observer<TValue, TError>>): Unsubscribable;
+}
+export interface Observable<TValue, TError>
+  extends Subscribable<TValue, TError> {
+  pipe(): Observable<TValue, TError>;
+  pipe<V1, E1>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+  ): Observable<V1, E1>;
+  pipe<V1, E1, V2, E2>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3, V4, E4>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+    op4: OperatorFunction<V3, E3, V4, E4>,
+  ): Observable<V2, E2>;
+  pipe<V1, E1, V2, E2, V3, E3, V4, E4, V5, E5>(
+    op1: OperatorFunction<TValue, TError, V1, E1>,
+    op2: OperatorFunction<V1, E1, V2, E2>,
+    op3: OperatorFunction<V2, E2, V3, E3>,
+    op4: OperatorFunction<V3, E3, V4, E4>,
+    op5: OperatorFunction<V4, E4, V5, E5>,
+  ): Observable<V2, E2>;
+}
+export interface SubscriptionLike extends Unsubscribable {
+  unsubscribe(): void;
+  readonly closed: boolean;
+}
+
+export interface Observer<TValue, TError> {
+  next: (value: TValue) => void;
+  error: (err: TError) => void;
+  complete: () => void;
+}
+
+export type TeardownLogic =
+  // | SubscriptionLike
+  Unsubscribable | UnsubscribeFn | void;
+
+export type UnaryFunction<T, R> = (source: T) => R;
+
+export type OperatorFunction<
+  TValueBefore,
+  TErrorBefore,
+  TValueAfter,
+  TErrorAfter,
+> = UnaryFunction<
+  Subscribable<TValueBefore, TErrorBefore>,
+  Subscribable<TValueAfter, TErrorAfter>
+>;
+
+export type MonoTypeOperatorFunction<TValue, TError> = OperatorFunction<
+  TValue,
+  TError,
+  TValue,
+  TError
+>;

package/src/rx/util/identity.ts

@@ -0,0 +1,3 @@
+export function identity<T>(x: T): T {
+  return x;
+}

package/src/rx/util/observableToPromise.ts

@@ -0,0 +1,49 @@
+import { Observable } from '../types';
+
+export class ObservableAbortError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ObservableAbortError';
+    Object.setPrototypeOf(this, ObservableAbortError.prototype);
+  }
+}
+
+/** @internal */
+export function observableToPromise<TValue>(
+  observable: Observable<TValue, unknown>,
+) {
+  let abort: () => void;
+  const promise = new Promise<TValue>((resolve, reject) => {
+    let isDone = false;
+    function onDone() {
+      if (isDone) {
+        return;
+      }
+      isDone = true;
+      reject(new ObservableAbortError('This operation was cancelled.'));
+      obs$.unsubscribe();
+    }
+    const obs$ = observable.subscribe({
+      next(data) {
+        isDone = true;
+        resolve(data);
+        onDone();
+      },
+      error(data) {
+        isDone = true;
+        reject(data);
+        onDone();
+      },
+      complete() {
+        isDone = true;
+        onDone();
+      },
+    });
+    abort = onDone;
+  });
+  return {
+    promise,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    abort: abort!,
+  };
+}

package/src/rx/util/pipe.ts

@@ -0,0 +1,22 @@
+import { identity } from './identity';
+import { UnaryFunction } from '../types';
+
+/** @internal */
+export function pipeFromArray<T, R>(
+  fns: Array<UnaryFunction<T, R>>,
+): UnaryFunction<T, R> {
+  if (fns.length === 0) {
+    return identity as UnaryFunction<any, any>;
+  }
+
+  if (fns.length === 1) {
+    return fns[0];
+  }
+
+  return function piped(input: T): R {
+    return fns.reduce(
+      (prev: any, fn: UnaryFunction<T, R>) => fn(prev),
+      input as any,
+    );
+  };
+}

package/dist/declarations/src/internals/TRPCAbortError.d.ts

@@ -1,4 +0,0 @@
-export declare class TRPCAbortError extends Error {
-    constructor();
-}
-//# sourceMappingURL=TRPCAbortError.d.ts.map

package/dist/declarations/src/internals/TRPCAbortError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TRPCAbortError.d.ts","sourceRoot":"../../../../src/internals","sources":["TRPCAbortError.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAe,SAAQ,KAAK;;CAMxC"}

package/dist/declarations/src/internals/executeChain.d.ts

@@ -1,8 +0,0 @@
-import { AnyRouter } from '@trpc/server';
-import { TRPCClientError } from '../TRPCClientError';
-import { Operation, OperationLink } from '../links/core';
-export declare function executeChain<TRouter extends AnyRouter, TInput = unknown, TOutput = unknown>(opts: {
-    links: OperationLink<TRouter, TInput, TOutput>[];
-    op: Operation<TInput>;
-}): import("./observable").ObservableSubject<any, TRPCClientError<TRouter>>;
-//# sourceMappingURL=executeChain.d.ts.map

package/dist/declarations/src/internals/executeChain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executeChain.d.ts","sourceRoot":"../../../../src/internals","sources":["executeChain.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EACL,SAAS,EACT,aAAa,EAGd,MAAM,eAAe,CAAC;AAGvB,wBAAgB,YAAY,CAC1B,OAAO,SAAS,SAAS,EACzB,MAAM,GAAG,OAAO,EAChB,OAAO,GAAG,OAAO,EACjB,IAAI,EAAE;IACN,KAAK,EAAE,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACjD,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACvB,2EAgDA"}

package/dist/declarations/src/internals/httpRequest.d.ts

@@ -1,14 +0,0 @@
-import { ProcedureType } from '@trpc/server';
-import { TRPCResponse } from '@trpc/server/rpc';
-import { LinkRuntimeOptions, PromiseAndCancel } from '../links/core';
-export declare function httpRequest<TResponseShape = TRPCResponse>(props: {
-    runtime: LinkRuntimeOptions;
-    type: ProcedureType;
-    path: string;
-    url: string;
-} & ({
-    inputs: unknown[];
-} | {
-    input: unknown;
-})): PromiseAndCancel<TResponseShape>;
-//# sourceMappingURL=httpRequest.d.ts.map

package/dist/declarations/src/internals/httpRequest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpRequest.d.ts","sourceRoot":"../../../../src/internals","sources":["httpRequest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAYrE,wBAAgB,WAAW,CAAC,cAAc,GAAG,YAAY,EACvD,KAAK,EAAE;IACL,OAAO,EAAE,kBAAkB,CAAC;IAC5B,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,CAAC;IAAE,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,GAC/C,gBAAgB,CAAC,cAAc,CAAC,CA+DlC"}

package/dist/declarations/src/internals/observable.d.ts

@@ -1,18 +0,0 @@
-export interface ObservableCallbacks<TValue, TError> {
-    onNext?: (opts: TValue) => void;
-    onError?: (opts: TError) => void;
-    onDone?: () => void;
-}
-export interface ObservableLike<TValue, TError = unknown> {
-    subscribe(callbacks: ObservableCallbacks<TValue, TError>): UnsubscribeFn;
-    next(value: TValue): void;
-    done(): void;
-    error(error: TError): void;
-}
-export interface ObservableSubject<TValue, TError = unknown> extends ObservableLike<TValue, TError> {
-    get(): TValue;
-}
-export declare type UnsubscribeFn = () => void;
-export declare function observable<TValue, TError = unknown>(): ObservableLike<TValue, TError>;
-export declare function observableSubject<TValue, TError = unknown>(initialValue: TValue): ObservableSubject<TValue, TError>;
-//# sourceMappingURL=observable.d.ts.map

package/dist/declarations/src/internals/observable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observable.d.ts","sourceRoot":"../../../../src/internals","sources":["observable.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB,CAAC,MAAM,EAAE,MAAM;IACjD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IACtD,SAAS,CAAC,SAAS,EAAE,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,aAAa,CAAC;IACzE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AACD,MAAM,WAAW,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CACzD,SAAQ,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC;IACtC,GAAG,IAAI,MAAM,CAAC;CACf;AAED,oBAAY,aAAa,GAAG,MAAM,IAAI,CAAC;AAEvC,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,KAAK,cAAc,CACpE,MAAM,EACN,MAAM,CACP,CA+CA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,EACxD,YAAY,EAAE,MAAM,GACnB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAenC"}

package/dist/declarations/src/internals/transformRPCResponse.d.ts

@@ -1,7 +0,0 @@
-import { TRPCResponse } from '@trpc/server/rpc';
-import { LinkRuntimeOptions } from '../links/core';
-export declare function transformRPCResponse({ envelope, runtime, }: {
-    envelope: TRPCResponse;
-    runtime: LinkRuntimeOptions;
-}): any;
-//# sourceMappingURL=transformRPCResponse.d.ts.map

package/dist/declarations/src/internals/transformRPCResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transformRPCResponse.d.ts","sourceRoot":"../../../../src/internals","sources":["transformRPCResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,kBAAkB,CAAC;CAC7B,OAcA"}

package/dist/declarations/src/links/core.d.ts

@@ -1,45 +0,0 @@
-import { AnyRouter, DataTransformer } from '@trpc/server';
-import { TRPCResult } from '@trpc/server/rpc';
-import { TRPCClientError } from '../TRPCClientError';
-export declare type OperationContext = Record<string, unknown>;
-export declare type Operation<TInput = unknown> = {
-    id: number;
-    type: 'query' | 'mutation' | 'subscription';
-    input: TInput;
-    path: string;
-    context: OperationContext;
-};
-export declare type OperationResponse<TRouter extends AnyRouter, TOutput = unknown> = TRPCResult<TOutput> | TRPCClientError<TRouter>;
-export declare type PrevCallback<TRouter extends AnyRouter, TOutput = unknown> = (result: OperationResponse<TRouter, TOutput>) => void;
-export declare type OperationLink<TRouter extends AnyRouter, TInput = unknown, TOutput = unknown> = (opts: {
-    op: Operation;
-    prev: PrevCallback<TRouter, TOutput>;
-    next: (op: Operation<TInput>, callback: PrevCallback<TRouter, TOutput>) => void;
-    onDestroy: (callback: () => void) => void;
-}) => void;
-export declare type TRPCLink<TRouter extends AnyRouter> = (opts: LinkRuntimeOptions) => OperationLink<TRouter>;
-export interface HTTPLinkOptions {
-    url: string;
-}
-/**
- * @deprecated use `HTTPLinkOptions`
- */
-export declare type HttpLinkOptions = HTTPLinkOptions;
-export declare type HTTPHeaders = Record<string, string | string[] | undefined>;
-/**
- * The default `fetch` implementation has an overloaded signature. By convention this library
- * only uses the overload taking a string and options object.
- */
-export declare type TRPCFetch = (url: string, options?: RequestInit) => Promise<Response>;
-export declare type LinkRuntimeOptions = Readonly<{
-    transformer: DataTransformer;
-    headers: () => HTTPHeaders | Promise<HTTPHeaders>;
-    fetch: TRPCFetch;
-    AbortController?: typeof AbortController;
-}>;
-export declare type CancelFn = () => void;
-export declare type PromiseAndCancel<TValue> = {
-    promise: Promise<TValue>;
-    cancel: CancelFn;
-};
-//# sourceMappingURL=core.d.ts.map

package/dist/declarations/src/links/core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"../../../../src/links","sources":["core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,oBAAY,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACvD,oBAAY,SAAS,CAAC,MAAM,GAAG,OAAO,IAAI;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,gBAAgB,CAAC;CAC3B,CAAC;AAEF,oBAAY,iBAAiB,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,GAAG,OAAO,IACtE,UAAU,CAAC,OAAO,CAAC,GACnB,eAAe,CAAC,OAAO,CAAC,CAAC;AAE7B,oBAAY,YAAY,CAAC,OAAO,SAAS,SAAS,EAAE,OAAO,GAAG,OAAO,IAAI,CACvE,MAAM,EAAE,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,KACxC,IAAI,CAAC;AACV,oBAAY,aAAa,CACvB,OAAO,SAAS,SAAS,EACzB,MAAM,GAAG,OAAO,EAChB,OAAO,GAAG,OAAO,IACf,CAAC,IAAI,EAAE;IACT,EAAE,EAAE,SAAS,CAAC;IACd,IAAI,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACrC,IAAI,EAAE,CACJ,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,EACrB,QAAQ,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,KACrC,IAAI,CAAC;IACV,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CAC3C,KAAK,IAAI,CAAC;AAEX,oBAAY,QAAQ,CAAC,OAAO,SAAS,SAAS,IAAI,CAChD,IAAI,EAAE,kBAAkB,KACrB,aAAa,CAAC,OAAO,CAAC,CAAC;AAE5B,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,oBAAY,eAAe,GAAG,eAAe,CAAC;AAE9C,oBAAY,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;AAExE;;;GAGG;AACH,oBAAY,SAAS,GAAG,CACtB,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,WAAW,KAClB,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,oBAAY,kBAAkB,GAAG,QAAQ,CAAC;IACxC,WAAW,EAAE,eAAe,CAAC;IAC7B,OAAO,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAClD,KAAK,EAAE,SAAS,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,eAAe,CAAC;CAC1C,CAAC,CAAC;AAEH,oBAAY,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC,oBAAY,gBAAgB,CAAC,MAAM,IAAI;IACrC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,MAAM,EAAE,QAAQ,CAAC;CAClB,CAAC"}

package/dist/httpRequest-672ff1f0.esm.js

@@ -1,128 +0,0 @@
-import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
-import _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/esm/inherits';
-import _createSuper from '@babel/runtime/helpers/esm/createSuper';
-import _wrapNativeSuper from '@babel/runtime/helpers/esm/wrapNativeSuper';
-import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
-import { T as TRPCClientError } from './TRPCClientError-09b8a26b.esm.js';
-
-var TRPCAbortError = /*#__PURE__*/function (_Error) {
-  _inherits(TRPCAbortError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(TRPCAbortError);
-
-  function TRPCAbortError() {
-    var _this;
-
-    _classCallCheck(this, TRPCAbortError);
-
-    _this = _super.call(this, 'The operation was aborted.');
-    _this.name = 'TRPCAbortError';
-    Object.setPrototypeOf(_assertThisInitialized(_this), TRPCAbortError.prototype);
-    return _this;
-  }
-
-  return TRPCAbortError;
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-
-function transformRPCResponse(_ref) {
-  var envelope = _ref.envelope,
-      runtime = _ref.runtime;
-
-  if ('error' in envelope) {
-    return TRPCClientError.from(_objectSpread(_objectSpread({}, envelope), {}, {
-      error: runtime.transformer.deserialize(envelope.error)
-    }));
-  }
-
-  if (envelope.result.type === 'data') {
-    return _objectSpread(_objectSpread({}, envelope.result), {}, {
-      data: runtime.transformer.deserialize(envelope.result.data)
-    });
-  }
-
-  return envelope.result;
-}
-
-// https://github.com/trpc/trpc/pull/669
-function arrayToDict(array) {
-  var dict = {};
-
-  for (var index = 0; index < array.length; index++) {
-    var element = array[index];
-    dict[index] = element;
-  }
-
-  return dict;
-}
-
-function httpRequest(props) {
-  var type = props.type,
-      rt = props.runtime,
-      path = props.path;
-  var ac = rt.AbortController ? new rt.AbortController() : null;
-  var method = {
-    query: 'GET',
-    mutation: 'POST',
-    subscription: 'PATCH'
-  };
-  var input = 'input' in props ? rt.transformer.serialize(props.input) : arrayToDict(props.inputs.map(function (_input) {
-    return rt.transformer.serialize(_input);
-  }));
-
-  function getUrl() {
-    var url = props.url + '/' + path;
-    var queryParts = [];
-
-    if ('inputs' in props) {
-      queryParts.push('batch=1');
-    }
-
-    if (type === 'query' && input !== undefined) {
-      queryParts.push("input=".concat(encodeURIComponent(JSON.stringify(input))));
-    }
-
-    if (queryParts.length) {
-      url += '?' + queryParts.join('&');
-    }
-
-    return url;
-  }
-
-  function getBody() {
-    if (type === 'query') {
-      return undefined;
-    }
-
-    return input !== undefined ? JSON.stringify(input) : undefined;
-  }
-
-  var promise = new Promise(function (resolve, reject) {
-    var url = getUrl();
-    Promise.resolve(rt.headers()).then(function (headers) {
-      return rt.fetch(url, {
-        method: method[type],
-        signal: ac === null || ac === void 0 ? void 0 : ac.signal,
-        body: getBody(),
-        headers: _objectSpread({
-          'content-type': 'application/json'
-        }, headers)
-      });
-    }).then(function (res) {
-      return res.json();
-    }).then(function (json) {
-      resolve(json);
-    }).catch(reject);
-  });
-
-  var cancel = function cancel() {
-    ac === null || ac === void 0 ? void 0 : ac.abort();
-  };
-
-  return {
-    promise: promise,
-    cancel: cancel
-  };
-}
-
-export { TRPCAbortError as T, httpRequest as h, transformRPCResponse as t };