@trpc/server 11.0.0-alpha-tmp-export-from-main-nuke-core.215 → 11.0.0-alpha-tmp-export-from-main.211

package/src/unstable-core-do-not-import/observable/operators.ts

@@ -1,119 +0,0 @@
-import type {
-  MonoTypeOperatorFunction,
-  Observer,
-  OperatorFunction,
-  Unsubscribable,
-} 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;
-      },
-    };
-  };
-}
-
-interface ShareConfig {}
-export function share<TValue, TError>(
-  _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);
-            }
-          },
-        };
-      },
-    };
-  };
-}
-
-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/unstable-core-do-not-import/observable/types.ts

@@ -1,76 +0,0 @@
-export interface Unsubscribable {
-  unsubscribe(): void;
-}
-export type UnsubscribeFn = () => void;
-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<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 Observer<TValue, TError> {
-  next: (value: TValue) => void;
-  error: (err: TError) => void;
-  complete: () => void;
-}
-
-export type TeardownLogic =
-  // | SubscriptionLike
-  Unsubscribable | UnsubscribeFn | void;
-
-export type UnaryFunction<TSource, TReturn> = (source: TSource) => TReturn;
-
-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/unstable-core-do-not-import/parser.ts

@@ -1,94 +0,0 @@
-// zod / @decs/typeschema
-export type ParserZodEsque<TInput, TParsedInput> = {
-  _input: TInput;
-  _output: TParsedInput;
-};
-
-export type ParserMyZodEsque<TInput> = {
-  parse: (input: any) => TInput;
-};
-
-export type ParserSuperstructEsque<TInput> = {
-  create: (input: unknown) => TInput;
-};
-
-export type ParserCustomValidatorEsque<TInput> = (
-  input: unknown,
-) => Promise<TInput> | TInput;
-
-export type ParserYupEsque<TInput> = {
-  validateSync: (input: unknown) => TInput;
-};
-
-export type ParserScaleEsque<TInput> = {
-  assert(value: unknown): asserts value is TInput;
-};
-
-export type ParserWithoutInput<TInput> =
-  | ParserCustomValidatorEsque<TInput>
-  | ParserMyZodEsque<TInput>
-  | ParserScaleEsque<TInput>
-  | ParserSuperstructEsque<TInput>
-  | ParserYupEsque<TInput>;
-
-export type ParserWithInputOutput<TInput, TParsedInput> = ParserZodEsque<
-  TInput,
-  TParsedInput
->;
-
-export type Parser = ParserWithInputOutput<any, any> | ParserWithoutInput<any>;
-
-export type inferParser<TParser extends Parser> =
-  TParser extends ParserWithInputOutput<infer $TIn, infer $TOut>
-    ? {
-        in: $TIn;
-        out: $TOut;
-      }
-    : TParser extends ParserWithoutInput<infer $InOut>
-    ? {
-        in: $InOut;
-        out: $InOut;
-      }
-    : never;
-
-export type ParseFn<TType> = (value: unknown) => Promise<TType> | TType;
-
-export function getParseFn<TType>(procedureParser: Parser): ParseFn<TType> {
-  const parser = procedureParser as any;
-
-  if (typeof parser === 'function') {
-    // ParserCustomValidatorEsque
-    return parser;
-  }
-
-  if (typeof parser.parseAsync === 'function') {
-    // ParserZodEsque
-    return parser.parseAsync.bind(parser);
-  }
-
-  if (typeof parser.parse === 'function') {
-    // ParserZodEsque
-    // ParserValibotEsque (<= v0.12.X)
-    return parser.parse.bind(parser);
-  }
-
-  if (typeof parser.validateSync === 'function') {
-    // ParserYupEsque
-    return parser.validateSync.bind(parser);
-  }
-
-  if (typeof parser.create === 'function') {
-    // ParserSuperstructEsque
-    return parser.create.bind(parser);
-  }
-
-  if (typeof parser.assert === 'function') {
-    // ParserScaleEsque
-    return (value) => {
-      parser.assert(value);
-      return value as TType;
-    };
-  }
-
-  throw new Error('Could not find a validator fn');
-}

package/src/unstable-core-do-not-import/procedure.ts

@@ -1,108 +0,0 @@
-import type { inferObservableValue } from './observable';
-import type { ProcedureCallOptions } from './procedureBuilder';
-import type { Serialize } from './serialize';
-import type { DefaultDataTransformer } from './transformer';
-import type { inferConfig, TRPCInferrable } from './TRPCInferrable';
-
-export const procedureTypes = ['query', 'mutation', 'subscription'] as const;
-/**
- * @public
- */
-export type ProcedureType = (typeof procedureTypes)[number];
-
-type ClientContext = Record<string, unknown>;
-
-/**
- * @internal
- */
-export interface ProcedureOptions {
-  /**
-   * Client-side context
-   */
-  context?: ClientContext;
-  signal?: AbortSignal;
-}
-
-/**
- * @internal
- */
-export type ProcedureArgs<TParams extends AnyProcedure['_def']> =
-  void extends TParams['_input_in']
-    ? [input?: undefined | void, opts?: ProcedureOptions]
-    : undefined extends TParams['_input_in']
-    ? [input?: TParams['_input_in'] | void, opts?: ProcedureOptions]
-    : [input: TParams['_input_in'], opts?: ProcedureOptions];
-
-interface BuiltProcedureDef {
-  input: unknown;
-  output: unknown;
-}
-/**
- *
- * @internal
- */
-export interface Procedure<
-  TType extends ProcedureType,
-  TDef extends BuiltProcedureDef,
-> {
-  _def: {
-    _input_in: TDef['input'];
-    _output_out: TDef['output'];
-    procedure: true;
-    type: TType;
-    /**
-     * @internal
-     * Meta is not inferrable on individual procedures, only on the router
-     */
-    meta: unknown;
-  };
-  /**
-   * @internal
-   */
-  (opts: ProcedureCallOptions): Promise<unknown>;
-}
-
-export interface QueryProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'query', TDef> {}
-
-export interface MutationProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'mutation', TDef> {}
-
-export interface SubscriptionProcedure<TDef extends BuiltProcedureDef>
-  extends Procedure<'subscription', TDef> {}
-
-export type AnyQueryProcedure = QueryProcedure<any>;
-export type AnyMutationProcedure = MutationProcedure<any>;
-export type AnySubscriptionProcedure = SubscriptionProcedure<any>;
-export type AnyProcedure = Procedure<ProcedureType, any>;
-
-/**
- * @internal
- */
-export type inferTransformedProcedureOutput<
-  TInferrable extends TRPCInferrable,
-  TProcedure extends AnyProcedure,
-> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
-  ? Serialize<TProcedure['_def']['_output_out']>
-  : TProcedure['_def']['_output_out'];
-
-/** @internal */
-export type inferTransformedSubscriptionOutput<
-  TInferrable extends TRPCInferrable,
-  TProcedure extends AnyProcedure,
-> = inferConfig<TInferrable>['transformer'] extends DefaultDataTransformer
-  ? Serialize<inferObservableValue<TProcedure['_def']['_output_out']>>
-  : inferObservableValue<TProcedure['_def']['_output_out']>;
-
-export type inferHandlerInput<TProcedure extends AnyProcedure> = ProcedureArgs<
-  inferProcedureParams<TProcedure>
->;
-
-export type inferProcedureInput<TProcedure extends AnyProcedure> =
-  inferProcedureParams<TProcedure>['_input_in'];
-
-export type inferProcedureParams<TProcedure> = TProcedure extends AnyProcedure
-  ? TProcedure['_def']
-  : never;
-export type inferProcedureOutput<TProcedure> =
-  inferProcedureParams<TProcedure>['_output_out'];