@trpc/client 9.17.0 → 10.0.0-alpha.0

package/dist/httpRequest-8c422e7a.cjs.prod.js

@@ -1,132 +0,0 @@
-'use strict';
-
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _createSuper = require('@babel/runtime/helpers/createSuper');
-var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var TRPCClientError = require('./TRPCClientError-e9bf96e9.cjs.prod.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.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
-  };
-}
-
-exports.TRPCAbortError = TRPCAbortError;
-exports.httpRequest = httpRequest;
-exports.transformRPCResponse = transformRPCResponse;

package/src/internals/TRPCAbortError.ts

@@ -1,7 +0,0 @@
-export class TRPCAbortError extends Error {
-  constructor() {
-    super('The operation was aborted.');
-    this.name = 'TRPCAbortError';
-    Object.setPrototypeOf(this, TRPCAbortError.prototype);
-  }
-}

package/src/internals/executeChain.ts

@@ -1,67 +0,0 @@
-import { AnyRouter } from '@trpc/server';
-import { TRPCResult } from '@trpc/server/rpc';
-import { TRPCClientError } from '../TRPCClientError';
-import {
-  Operation,
-  OperationLink,
-  OperationResponse,
-  PrevCallback,
-} from '../links/core';
-import { observableSubject } from './observable';
-
-export function executeChain<
-  TRouter extends AnyRouter,
-  TInput = unknown,
-  TOutput = unknown,
->(opts: {
-  links: OperationLink<TRouter, TInput, TOutput>[];
-  op: Operation<TInput>;
-}) {
-  const $result = observableSubject<
-    null | TRPCResult<TOutput>,
-    TRPCClientError<TRouter>
-  >(null);
-
-  const updateResult = (result: OperationResponse<TRouter, TOutput>) => {
-    if (result instanceof Error) {
-      $result.error(result);
-      if (result.isDone) {
-        $result.done();
-      }
-    } else {
-      $result.next(result);
-    }
-  };
-  function walk({
-    index,
-    op,
-    stack,
-  }: {
-    index: number;
-    op: Operation<TInput>;
-    stack: PrevCallback<TRouter, TOutput>[];
-  }) {
-    const link = opts.links[index];
-    const prev: PrevCallback<TRouter, TOutput> =
-      index === 0 ? (value) => updateResult(value) : stack[index - 1];
-
-    link({
-      op,
-      prev,
-      next: (op, prevOp) => {
-        const prevStack = stack.slice();
-        prevStack[index] = prevOp;
-        walk({ index: index + 1, op, stack: prevStack });
-      },
-      onDestroy: (callback) => {
-        $result.subscribe({
-          onDone() {
-            callback();
-          },
-        });
-      },
-    });
-  }
-  walk({ index: 0, op: opts.op, stack: [] });
-  return $result;
-}

package/src/internals/observable.ts

@@ -1,89 +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 type UnsubscribeFn = () => void;
-
-export function observable<TValue, TError = unknown>(): ObservableLike<
-  TValue,
-  TError
-> {
-  type Listener = {
-    callbacks: ObservableCallbacks<TValue, TError>;
-    unsubscribe: () => void;
-  };
-  const listeners: Listener[] = [];
-
-  let value: TValue | null = null;
-  return {
-    subscribe(callbacks) {
-      const listener: Listener = {
-        callbacks,
-        unsubscribe() {
-          const index = listeners.indexOf(listener);
-          if (index !== -1) {
-            listeners.splice(index, 1);
-            listener.callbacks.onDone?.();
-          }
-        },
-      };
-      listeners.push(listener);
-      return () => {
-        listener.unsubscribe();
-      };
-    },
-    next(newValue) {
-      const oldValue = value;
-      value = newValue;
-      if (oldValue !== newValue) {
-        for (const listener of listeners) {
-          listener.callbacks.onNext?.(newValue);
-        }
-      }
-    },
-    done() {
-      while (listeners.length) {
-        const listener = listeners.pop();
-        listener?.callbacks.onDone?.();
-        listener?.unsubscribe();
-      }
-    },
-    error(error) {
-      for (const listener of listeners) {
-        listener.callbacks.onError?.(error);
-      }
-    },
-  };
-}
-
-export function observableSubject<TValue, TError = unknown>(
-  initialValue: TValue,
-): ObservableSubject<TValue, TError> {
-  const $obs = observable<TValue>();
-  let value = initialValue;
-  $obs.next(initialValue);
-
-  return {
-    ...$obs,
-    next(v) {
-      value = v;
-      $obs.next(v);
-    },
-    get() {
-      return value;
-    },
-  };
-}