@trpc/client 10.0.0-alpha.1 → 10.0.0-alpha.10

package/src/rx/observable.test.ts

@@ -1,83 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { observable } from './observable';
-import { tap } from './operators';
-import { share } from './operators/share';
-
-test('vanilla observable', () => {
-  const obs = observable<number, Error>((observer) => {
-    observer.next(1);
-    observer.complete();
-  });
-
-  const next = jest.fn();
-  const error = jest.fn();
-  const complete = jest.fn();
-  obs.subscribe({
-    next,
-    error,
-    complete,
-  });
-  expect(next.mock.calls).toHaveLength(1);
-  expect(complete.mock.calls).toHaveLength(1);
-  expect(error.mock.calls).toHaveLength(0);
-  expect(next.mock.calls[0][0]).toBe(1);
-});
-
-test('pipe - combine operators', () => {
-  const taps = {
-    next: jest.fn(),
-    complete: jest.fn(),
-    error: jest.fn(),
-  };
-  const obs = observable<number, Error>((observer) => {
-    observer.next(1);
-  }).pipe(
-    // operators:
-    share(),
-    tap(taps),
-  );
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    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);
-  }
-
-  {
-    const next = jest.fn();
-    const error = jest.fn();
-    const complete = jest.fn();
-    obs.subscribe({
-      next,
-      error,
-      complete,
-    });
-    expect(next.mock.calls).toHaveLength(0);
-    expect(complete.mock.calls).toHaveLength(0);
-    expect(error.mock.calls).toHaveLength(0);
-  }
-
-  expect({
-    next: taps.next.mock.calls,
-    error: taps.error.mock.calls,
-    complete: taps.complete.mock.calls,
-  }).toMatchInlineSnapshot(`
-    Object {
-      "complete": Array [],
-      "error": Array [],
-      "next": Array [
-        Array [
-          1,
-        ],
-      ],
-    }
-  `);
-});

package/src/rx/observable.ts

@@ -1,70 +0,0 @@
-import { pipeFromArray } from './util/pipe';
-import { Observable, Observer, OperatorFunction, TeardownLogic } from './types';
-
-export type inferObservableValue<TObservable extends Observable<any, any>> =
-  TObservable extends Observable<infer TValue, any> ? TValue : never;
-
-export function observable<TValue, TError = unknown>(
-  subscribe: (observer: Observer<TValue, TError>) => TeardownLogic,
-): Observable<TValue, TError> {
-  const self: Observable<TValue, TError> = {
-    subscribe(observer) {
-      let teardownRef: TeardownLogic | null = null;
-      let isDone = false;
-      let unsubscribed = false;
-      let teardownImmediately = false;
-      function unsubscribe() {
-        if (teardownRef === null) {
-          teardownImmediately = true;
-          return;
-        }
-        if (unsubscribed) {
-          return;
-        }
-        unsubscribed = true;
-
-        if (typeof teardownRef === 'function') {
-          teardownRef();
-        } else if (teardownRef) {
-          teardownRef.unsubscribe();
-        }
-      }
-      teardownRef = subscribe({
-        next(value) {
-          if (isDone) {
-            return;
-          }
-          observer.next?.(value);
-        },
-        error(err) {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.error?.(err);
-          unsubscribe();
-        },
-        complete() {
-          if (isDone) {
-            return;
-          }
-          isDone = true;
-          observer.complete?.();
-          unsubscribe();
-        },
-      });
-      if (teardownImmediately) {
-        unsubscribe();
-      }
-      return {
-        unsubscribe,
-      };
-    },
-    pipe(
-      ...operations: OperatorFunction<any, any, any, any>[]
-    ): Observable<any, any> {
-      return pipeFromArray(operations)(self) as any;
-    },
-  };
-  return self;
-}

package/src/rx/operators/index.ts

@@ -1,3 +0,0 @@
-export * from './share';
-export * from './map';
-export * from './tap';

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

@@ -1,92 +0,0 @@
-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/rx/operators/map.ts

@@ -1,25 +0,0 @@
-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/rx/operators/share.test.ts

@@ -1,60 +0,0 @@
-/* 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

@@ -1,67 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

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

package/src/rx/util/pipe.ts

@@ -1,22 +0,0 @@
-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,
-    );
-  };
-}