@trpc/server 10.0.0-proxy-beta.0 → 10.0.0-proxy-beta.1

package/src/internals/invert.ts

@@ -1,14 +1,14 @@
-type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
-  [K in keyof T]: V extends T[K] ? K : never;
-}[keyof T];
+type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof TType]: TValue extends TType[K] ? K : never;
+}[keyof TType];
 
-type Invert<T extends Record<PropertyKey, PropertyKey>> = {
-  [V in T[keyof T]]: KeyFromValue<V, T>;
+type Invert<TType extends Record<PropertyKey, PropertyKey>> = {
+  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
 };
 
-export function invert<T extends Record<PropertyKey, PropertyKey>>(
-  obj: T,
-): Invert<T> {
+export function invert<TRecord extends Record<PropertyKey, PropertyKey>>(
+  obj: TRecord,
+): Invert<TRecord> {
   const newObj = Object.create(null) as any;
   for (const key in obj) {
     const v = obj[key];

package/src/observable/internals/identity.ts

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

package/src/observable/internals/pipe.ts

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

package/src/observable/types.ts

@@ -8,31 +8,42 @@ export interface Subscribable<TValue, TError> {
 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>;
+  pipe<TValue1, TError1>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+  ): Observable<TValue1, TError1>;
+  pipe<TValue1, TError1, TValue2, TError2>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+  ): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+  ): Observable<TValue2, TError2>;
+  pipe<TValue1, TError1, TValue2, TError2, TValue3, TError3, TValue4, TError4>(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
+  ): Observable<TValue2, TError2>;
+  pipe<
+    TValue1,
+    TError1,
+    TValue2,
+    TError2,
+    TValue3,
+    TError3,
+    TValue4,
+    TError4,
+    TValue5,
+    TError5,
+  >(
+    op1: OperatorFunction<TValue, TError, TValue1, TError1>,
+    op2: OperatorFunction<TValue1, TError1, TValue2, TError2>,
+    op3: OperatorFunction<TValue2, TError2, TValue3, TError3>,
+    op4: OperatorFunction<TValue3, TError3, TValue4, TError4>,
+    op5: OperatorFunction<TValue4, TError4, TValue5, TError5>,
+  ): Observable<TValue2, TError2>;
 }
 export interface SubscriptionLike extends Unsubscribable {
   unsubscribe(): void;
@@ -49,7 +60,7 @@ export type TeardownLogic =
   // | SubscriptionLike
   Unsubscribable | UnsubscribeFn | void;
 
-export type UnaryFunction<T, R> = (source: T) => R;
+export type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
 
 export type OperatorFunction<
   TValueBefore,

package/src/rpc/codes.ts

@@ -1,4 +1,4 @@
-import { invert } from './internals/invert';
+import { invert } from '../internals/invert';
 
 // reference: https://www.jsonrpc.org/specification
 
@@ -35,7 +35,7 @@ export const TRPC_ERROR_CODES_BY_KEY = {
 } as const;
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
-type ValueOf<T> = T[keyof T];
+type ValueOf<TObj> = TObj[keyof TObj];
 
 export type TRPC_ERROR_CODE_NUMBER = ValueOf<typeof TRPC_ERROR_CODES_BY_KEY>;
 export type TRPC_ERROR_CODE_KEY = keyof typeof TRPC_ERROR_CODES_BY_KEY;

package/src/types.ts

@@ -3,43 +3,45 @@
 /**
  * @internal
  */
-export type identity<T> = T;
+export type identity<TType> = TType;
 
 /**
  * @internal
  */
-export type FlatOverwrite<T, K> = identity<{
-  [TKey in keyof K | keyof T]: TKey extends keyof K
-    ? K[TKey]
-    : TKey extends keyof T
-    ? T[TKey]
+export type FlatOverwrite<TType, TWith> = identity<{
+  [TKey in keyof TWith | keyof TType]: TKey extends keyof TWith
+    ? TWith[TKey]
+    : TKey extends keyof TType
+    ? TType[TKey]
     : never;
 }>;
 
 /**
  * @public
  */
-export type Maybe<T> = T | undefined | null;
+export type Maybe<TType> = TType | undefined | null;
 
 /**
  * @internal
  */
-export type ThenArg<T> = T extends PromiseLike<infer U> ? ThenArg<U> : T;
+export type ThenArg<TType> = TType extends PromiseLike<infer U>
+  ? ThenArg<U>
+  : TType;
 
 /**
  * @internal
  */
-export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] };
+export type Simplify<TType> = { [KeyType in keyof TType]: TType[KeyType] };
 
 /**
  * @public
  */
-export type Dict<T> = Record<string, T | undefined>;
+export type Dict<TType> = Record<string, TType | undefined>;
 
 /**
  * @public
  */
-export type MaybePromise<T> = T | Promise<T>;
+export type MaybePromise<TType> = TType | Promise<TType>;
 
 /**
  * @internal
@@ -47,7 +49,9 @@ export type MaybePromise<T> = T | Promise<T>;
  * Creates a "lower-priority" type inference.
  * https://github.com/microsoft/TypeScript/issues/14829#issuecomment-322267089
  */
-export type InferLast<T> = T & { [K in keyof T]: T[K] };
+export type InferLast<TType> = TType & {
+  [KeyType in keyof TType]: TType[KeyType];
+};
 
 /**
  * @public
@@ -55,11 +59,14 @@ export type InferLast<T> = T & { [K in keyof T]: T[K] };
 export type inferAsyncReturnType<TFunction extends (...args: any) => any> =
   ThenArg<ReturnType<TFunction>>;
 
-type FilterKeys<T extends object, K> = {
-  [TKey in keyof T]: T[TKey] extends K ? TKey : never;
-}[keyof T];
+type FilterKeys<TObj extends object, TFilter> = {
+  [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
 
 /**
  * @internal
  */
-export type Filter<T extends object, K> = Pick<T, FilterKeys<T, K>>;
+export type Filter<TObj extends object, TFilter> = Pick<
+  TObj,
+  FilterKeys<TObj, TFilter>
+>;

package/dist/rpc/internals/invert.d.ts

@@ -1,18 +0,0 @@
-/**
- * @internal
- */
-declare type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
-    [K in keyof T]: V extends T[K] ? K : never;
-}[keyof T];
-/**
- * @internal
- */
-declare type Invert<T extends Record<PropertyKey, PropertyKey>> = {
-    [V in T[keyof T]]: KeyFromValue<V, T>;
-};
-/**
- * @internal
- */
-export declare function invert<T extends Record<PropertyKey, PropertyKey>>(obj: T): Invert<T>;
-export {};
-//# sourceMappingURL=invert.d.ts.map

package/dist/rpc/internals/invert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../../packages/server/src/rpc/internals/invert.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,aAAK,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI;KAChE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAC3C,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX;;GAEG;AACH,aAAK,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,IAAI;KACvD,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;CACtC,CAAC;AAEF;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,EAC/D,GAAG,EAAE,CAAC,GACL,MAAM,CAAC,CAAC,CAAC,CAOX"}

package/src/rpc/internals/invert.ts

@@ -1,27 +0,0 @@
-/**
- * @internal
- */
-type KeyFromValue<V, T extends Record<PropertyKey, PropertyKey>> = {
-  [K in keyof T]: V extends T[K] ? K : never;
-}[keyof T];
-
-/**
- * @internal
- */
-type Invert<T extends Record<PropertyKey, PropertyKey>> = {
-  [V in T[keyof T]]: KeyFromValue<V, T>;
-};
-
-/**
- * @internal
- */
-export function invert<T extends Record<PropertyKey, PropertyKey>>(
-  obj: T,
-): Invert<T> {
-  const newObj = Object.create(null) as any;
-  for (const key in obj) {
-    const v = obj[key];
-    newObj[v] = key;
-  }
-  return newObj;
-}