@trpc/client 10.0.0-alpha.11 → 10.0.0-alpha.12

package/src/observable/operators/map.test.ts

@@ -0,0 +1,92 @@
+import { expectTypeOf } from 'expect-type';
+import { observable } from '../observable';
+import { map } from '.';
+import { EventEmitter } from 'events';
+
+interface SubscriptionEvents<TOutput> {
+  data: (data: TOutput) => void;
+}
+
+declare interface CustomEventEmitter<TOutput> {
+  on<U extends keyof SubscriptionEvents<TOutput>>(
+    event: U,
+    listener: SubscriptionEvents<TOutput>[U],
+  ): this;
+
+  once<U extends keyof SubscriptionEvents<TOutput>>(
+    event: U,
+    listener: SubscriptionEvents<TOutput>[U],
+  ): this;
+
+  emit<U extends keyof SubscriptionEvents<TOutput>>(
+    event: U,
+    ...args: Parameters<SubscriptionEvents<TOutput>[U]>
+  ): boolean;
+}
+class CustomEventEmitter<TOutput>
+  extends EventEmitter
+  implements CustomEventEmitter<TOutput> {}
+test('map', () => {
+  type EventShape = { num: number };
+  const ee = new CustomEventEmitter<EventShape>();
+  const eventObservable = observable<EventShape, unknown>((observer) => {
+    const callback = (data: EventShape) => {
+      observer.next(data);
+    };
+    ee.on('data', callback);
+
+    return () => {
+      ee.off('data', callback);
+    };
+  });
+  const pipeCalls = jest.fn();
+  const piped = eventObservable.pipe(
+    map((...args) => {
+      pipeCalls(...args);
+      const [value] = args;
+      return value.num;
+    }),
+  );
+
+  const next = jest.fn();
+  const subscription = piped.subscribe({
+    next(value) {
+      expectTypeOf<number>(value);
+      next(value);
+    },
+  });
+  expect(next).not.toHaveBeenCalled();
+  ee.emit('data', { num: 1 });
+  ee.emit('data', { num: 2 });
+  expect(next).toHaveBeenCalledTimes(2);
+  expect(next.mock.calls).toMatchInlineSnapshot(`
+    Array [
+      Array [
+        1,
+      ],
+      Array [
+        2,
+      ],
+    ]
+  `);
+  expect(pipeCalls.mock.calls).toMatchInlineSnapshot(`
+    Array [
+      Array [
+        Object {
+          "num": 1,
+        },
+        0,
+      ],
+      Array [
+        Object {
+          "num": 2,
+        },
+        1,
+      ],
+    ]
+  `);
+
+  expect(ee.listeners('data')).toHaveLength(1);
+  subscription.unsubscribe();
+  expect(ee.listeners('data')).toHaveLength(0);
+});

package/src/observable/operators/map.ts

@@ -0,0 +1,25 @@
+import { OperatorFunction } from '../types';
+
+export function map<TValueBefore, TError, TValueAfter>(
+  project: (value: TValueBefore, index: number) => TValueAfter,
+): OperatorFunction<TValueBefore, TError, TValueAfter, TError> {
+  return (originalObserver) => {
+    return {
+      subscribe(observer) {
+        let index = 0;
+        const subscription = originalObserver.subscribe({
+          next(value) {
+            observer.next?.(project(value, index++));
+          },
+          error(error) {
+            observer.error?.(error);
+          },
+          complete() {
+            observer.complete?.();
+          },
+        });
+        return subscription;
+      },
+    };
+  };
+}

package/src/observable/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/observable/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/observable/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/observable/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/observable/util/identity.ts

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

package/src/observable/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/observable/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/rx.d.ts

@@ -1,12 +0,0 @@
-import { MonoTypeOperatorFunction, Observable } from 'rxjs';
-export declare type inferObservableValue<TObservable extends Observable<any>> = TObservable extends Observable<infer TValue> ? TValue : never;
-export declare class ObservableAbortError extends Error {
-    constructor(message: string);
-}
-/** @internal */
-export declare function observableToPromise<TValue>(observable: Observable<TValue>): {
-    promise: Promise<TValue>;
-    abort: () => void;
-};
-export declare function share<T>(): MonoTypeOperatorFunction<T>;
-//# sourceMappingURL=rx.d.ts.map

package/dist/rx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rx.d.ts","sourceRoot":"","sources":["../src/rx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,UAAU,EAGX,MAAM,MAAM,CAAC;AAEd,oBAAY,oBAAoB,CAAC,WAAW,SAAS,UAAU,CAAC,GAAG,CAAC,IAClE,WAAW,SAAS,UAAU,CAAC,MAAM,MAAM,CAAC,GAAG,MAAM,GAAG,KAAK,CAAC;AAEhE,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAK5B;AAED,gBAAgB;AAChB,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC;;iBACvD,IAAI;EAkCtB;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAK,wBAAwB,CAAC,CAAC,CAAC,CAyBtD"}

package/dist/rx.js

@@ -1,130 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _assertThisInitialized = require('@babel/runtime/helpers/assertThisInitialized');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
-var _wrapNativeSuper = require('@babel/runtime/helpers/wrapNativeSuper');
-var rxjs = require('rxjs');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _assertThisInitialized__default = /*#__PURE__*/_interopDefaultLegacy(_assertThisInitialized);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
-var _wrapNativeSuper__default = /*#__PURE__*/_interopDefaultLegacy(_wrapNativeSuper);
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf__default["default"](Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf__default["default"](this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn__default["default"](this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-var ObservableAbortError = /*#__PURE__*/function (_Error) {
-  _inherits__default["default"](ObservableAbortError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(ObservableAbortError);
-
-  function ObservableAbortError(message) {
-    var _this;
-
-    _classCallCheck__default["default"](this, ObservableAbortError);
-
-    _this = _super.call(this, message);
-    _this.name = 'ObservableAbortError';
-    Object.setPrototypeOf(_assertThisInitialized__default["default"](_this), ObservableAbortError.prototype);
-    return _this;
-  }
-
-  return _createClass__default["default"](ObservableAbortError);
-}( /*#__PURE__*/_wrapNativeSuper__default["default"](Error));
-/** @internal */
-
-function observableToPromise(observable) {
-  var abort;
-  var promise = new Promise(function (resolve, reject) {
-    var isDone = false;
-
-    function onDone() {
-      if (isDone) {
-        return;
-      }
-
-      isDone = true;
-      reject(new ObservableAbortError('This operation was cancelled.'));
-      subscription.unsubscribe();
-    }
-
-    var subscription = observable.subscribe({
-      next: function next(data) {
-        isDone = true;
-        resolve(data);
-        onDone();
-      },
-      error: function error(data) {
-        isDone = true;
-        reject(data);
-        onDone();
-      },
-      complete: function complete() {
-        isDone = true;
-        onDone();
-      }
-    });
-    abort = onDone;
-  });
-  return {
-    promise: promise,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    abort: abort
-  };
-}
-function share() {
-  var subscribers = new Set();
-  var connection = null;
-  return function (source) {
-    return new rxjs.Observable(function (subscriber) {
-      subscribers.add(subscriber);
-      subscriber.add(function () {
-        subscribers.delete(subscriber);
-
-        if (subscribers.size === 0) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          connection.unsubscribe();
-          connection = null;
-        }
-      });
-
-      if (!connection) {
-        connection = source.subscribe({
-          next: function next(value) {
-            return subscribers.forEach(function (s) {
-              return s.next(value);
-            });
-          },
-          error: function error(_error) {
-            return subscribers.forEach(function (s) {
-              return s.error(_error);
-            });
-          },
-          complete: function complete() {
-            return subscribers.forEach(function (s) {
-              return s.complete();
-            });
-          }
-        });
-        connection.add(function () {
-          return subscribers.clear();
-        });
-      }
-    });
-  };
-}
-
-exports.ObservableAbortError = ObservableAbortError;
-exports.observableToPromise = observableToPromise;
-exports.share = share;

package/dist/rx.mjs

@@ -1,114 +0,0 @@
-import _createClass from '@babel/runtime/helpers/createClass';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _assertThisInitialized from '@babel/runtime/helpers/assertThisInitialized';
-import _inherits from '@babel/runtime/helpers/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
-import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
-import { Observable } from 'rxjs';
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-var ObservableAbortError = /*#__PURE__*/function (_Error) {
-  _inherits(ObservableAbortError, _Error);
-
-  var _super = /*#__PURE__*/_createSuper(ObservableAbortError);
-
-  function ObservableAbortError(message) {
-    var _this;
-
-    _classCallCheck(this, ObservableAbortError);
-
-    _this = _super.call(this, message);
-    _this.name = 'ObservableAbortError';
-    Object.setPrototypeOf(_assertThisInitialized(_this), ObservableAbortError.prototype);
-    return _this;
-  }
-
-  return _createClass(ObservableAbortError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
-/** @internal */
-
-function observableToPromise(observable) {
-  var abort;
-  var promise = new Promise(function (resolve, reject) {
-    var isDone = false;
-
-    function onDone() {
-      if (isDone) {
-        return;
-      }
-
-      isDone = true;
-      reject(new ObservableAbortError('This operation was cancelled.'));
-      subscription.unsubscribe();
-    }
-
-    var subscription = observable.subscribe({
-      next: function next(data) {
-        isDone = true;
-        resolve(data);
-        onDone();
-      },
-      error: function error(data) {
-        isDone = true;
-        reject(data);
-        onDone();
-      },
-      complete: function complete() {
-        isDone = true;
-        onDone();
-      }
-    });
-    abort = onDone;
-  });
-  return {
-    promise: promise,
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    abort: abort
-  };
-}
-function share() {
-  var subscribers = new Set();
-  var connection = null;
-  return function (source) {
-    return new Observable(function (subscriber) {
-      subscribers.add(subscriber);
-      subscriber.add(function () {
-        subscribers.delete(subscriber);
-
-        if (subscribers.size === 0) {
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          connection.unsubscribe();
-          connection = null;
-        }
-      });
-
-      if (!connection) {
-        connection = source.subscribe({
-          next: function next(value) {
-            return subscribers.forEach(function (s) {
-              return s.next(value);
-            });
-          },
-          error: function error(_error) {
-            return subscribers.forEach(function (s) {
-              return s.error(_error);
-            });
-          },
-          complete: function complete() {
-            return subscribers.forEach(function (s) {
-              return s.complete();
-            });
-          }
-        });
-        connection.add(function () {
-          return subscribers.clear();
-        });
-      }
-    });
-  };
-}
-
-export { ObservableAbortError, observableToPromise, share };