@trpc/client 10.0.0-alpha.21 → 10.0.0-alpha.22

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

@@ -1,92 +0,0 @@
-import { EventEmitter } from 'events';
-import { expectTypeOf } from 'expect-type';
-import { map } from '.';
-import { observable } from '../observable';
-
-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

@@ -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/observable/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/observable/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/observable/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/observable/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
->;