@trpc/server 11.0.0-alpha-tmp-export-from-main.218 → 11.0.0-alpha-tmp-export-from-main-nuke-core.239

package/src/unstable-core-do-not-import/rpc/parseTRPCMessage.ts

@@ -0,0 +1,85 @@
+import { procedureTypes, type ProcedureType } from '../procedure';
+import type { CombinedDataTransformer } from '../transformer';
+import { isObject } from '../utils';
+import type { TRPCClientOutgoingMessage } from './envelopes';
+
+/* istanbul ignore next -- @preserve */
+function assertIsObject(obj: unknown): asserts obj is Record<string, unknown> {
+  if (!isObject(obj)) {
+    throw new Error('Not an object');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsProcedureType(obj: unknown): asserts obj is ProcedureType {
+  if (!procedureTypes.includes(obj as any)) {
+    throw new Error('Invalid procedure type');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsRequestId(
+  obj: unknown,
+): asserts obj is number | string | null {
+  if (
+    obj !== null &&
+    typeof obj === 'number' &&
+    isNaN(obj) &&
+    typeof obj !== 'string'
+  ) {
+    throw new Error('Invalid request id');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsString(obj: unknown): asserts obj is string {
+  if (typeof obj !== 'string') {
+    throw new Error('Invalid string');
+  }
+}
+
+/* istanbul ignore next -- @preserve */
+function assertIsJSONRPC2OrUndefined(
+  obj: unknown,
+): asserts obj is '2.0' | undefined {
+  if (typeof obj !== 'undefined' && obj !== '2.0') {
+    throw new Error('Must be JSONRPC 2.0');
+  }
+}
+
+/** @public */
+export function parseTRPCMessage(
+  obj: unknown,
+  transformer: CombinedDataTransformer,
+): TRPCClientOutgoingMessage {
+  assertIsObject(obj);
+
+  const { id, jsonrpc, method, params } = obj;
+  assertIsRequestId(id);
+  assertIsJSONRPC2OrUndefined(jsonrpc);
+
+  if (method === 'subscription.stop') {
+    return {
+      id,
+      jsonrpc,
+      method,
+    };
+  }
+  assertIsProcedureType(method);
+  assertIsObject(params);
+  const { input: rawInput, path } = params;
+
+  assertIsString(path);
+
+  const input = transformer.input.deserialize(rawInput);
+
+  return {
+    id,
+    jsonrpc,
+    method,
+    params: {
+      input,
+      path,
+    },
+  };
+}

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

@@ -0,0 +1,122 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import type { Simplify, WithoutIndexSignature } from './types';
+
+/**
+ * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
+ */
+type JsonPrimitive = boolean | number | string | null;
+// eslint-disable-next-line @typescript-eslint/ban-types
+type NonJsonPrimitive = Function | symbol | undefined;
+/*
+ * `any` is the only type that can let you equate `0` with `1`
+ * See https://stackoverflow.com/a/49928360/1490091
+ */
+type IsAny<T> = 0 extends T & 1 ? true : false;
+
+// `undefined` is a weird one that's technically not valid JSON,
+// but the return value of `JSON.parse` can be `undefined` so we
+// support it as both a Primitive and a NonJsonPrimitive
+type JsonReturnable = JsonPrimitive | undefined;
+
+type IsRecord<T extends object> = keyof WithoutIndexSignature<T> extends never
+  ? true
+  : false;
+
+/* prettier-ignore */
+export type Serialize<T> =
+  IsAny<T> extends true ? any :
+  unknown extends T ? unknown :
+  T extends JsonReturnable ? T :
+  T extends Map<any, any> | Set<any> ? object :
+  T extends NonJsonPrimitive ? never :
+  T extends { toJSON(): infer U } ? U :
+  T extends [] ? [] :
+  T extends [unknown, ...unknown[]] ? SerializeTuple<T> :
+  T extends readonly (infer U)[] ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] :
+  T extends object ?
+    IsRecord<T> extends true ? Record<keyof T, Serialize<T[keyof T]>> :
+    Simplify<SerializeObject<UndefinedToOptional<T>>> :
+  never;
+
+/** JSON serialize [tuples](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) */
+type SerializeTuple<T extends [unknown, ...unknown[]]> = {
+  [K in keyof T]: T[K] extends NonJsonPrimitive ? null : Serialize<T[K]>;
+};
+
+// prettier-ignore
+type SerializeObjectKey<T extends Record<any, any>, K> = 
+  // never include entries where the key is a symbol
+  K extends symbol ? never : 
+  // always include entries where the value is any
+  IsAny<T[K]> extends true ? K :
+  // always include entries where the value is unknown
+  unknown extends T[K] ? K : 
+  // never include entries where the value is a non-JSON primitive
+  T[K] extends NonJsonPrimitive ? never : 
+  // otherwise serialize the value
+  K;
+/**
+ * JSON serialize objects (not including arrays) and classes
+ * @internal
+ **/
+export type SerializeObject<T extends object> = {
+  [K in keyof T as SerializeObjectKey<T, K>]: Serialize<T[K]>;
+};
+
+/**
+ * Extract keys from T where the value dosen't extend undefined
+ * Note: Can't parse IndexSignature or Record types
+ */
+type FilterDefinedKeys<T extends object> = Exclude<
+  {
+    [K in keyof T]: undefined extends T[K] ? never : K;
+  }[keyof T],
+  undefined
+>;
+
+/**
+ * Get value of exactOptionalPropertyTypes config
+ */
+type ExactOptionalPropertyTypes = { a?: 0 | undefined } extends {
+  a?: 0;
+}
+  ? false
+  : true;
+
+/**
+ * Check if T has an index signature
+ */
+type HasIndexSignature<T extends object> = string extends keyof T
+  ? true
+  : false;
+
+/**
+ * { [key: string]: number | undefined } --> { [key: string]: number }
+ */
+type HandleIndexSignature<T extends object> = {
+  [K in keyof Omit<T, keyof WithoutIndexSignature<T>>]: Exclude<
+    T[K],
+    undefined
+  >;
+};
+
+/**
+ * { a: number | undefined } --> { a?: number }
+ * Note: Can't parse IndexSignature or Record types
+ */
+type HandleUndefined<T extends object> = {
+  [K in keyof Omit<T, FilterDefinedKeys<T>>]?: Exclude<T[K], undefined>;
+};
+
+/**
+ * Handle undefined, index signature and records
+ */
+type UndefinedToOptional<T extends object> =
+  // Property is not a union with `undefined`, keep as-is
+  Pick<WithoutIndexSignature<T>, FilterDefinedKeys<WithoutIndexSignature<T>>> &
+    // If following is true, don't merge undefined or optional into index signature if any in T
+    (ExactOptionalPropertyTypes extends true
+      ? HandleIndexSignature<T> & HandleUndefined<WithoutIndexSignature<T>>
+      : HasIndexSignature<T> extends true
+      ? HandleIndexSignature<T>
+      : HandleUndefined<T>);

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

@@ -0,0 +1,202 @@
+import type { AnyRootConfig } from './rootConfig';
+import type { AnyRouter, inferRouterError } from './router';
+import type {
+  TRPCResponse,
+  TRPCResponseMessage,
+  TRPCResultMessage,
+} from './rpc';
+import { isObject } from './utils';
+
+/**
+ * @public
+ */
+export interface DataTransformer {
+  serialize: (object: any) => any;
+  deserialize: (object: any) => any;
+}
+
+interface InputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the client** before sending the data to the server.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **on the server** to transform the data before it is passed to the resolver
+   */
+  deserialize: (object: any) => any;
+}
+
+interface OutputDataTransformer extends DataTransformer {
+  /**
+   * This function runs **on the server** before sending the data to the client.
+   */
+  serialize: (object: any) => any;
+  /**
+   * This function runs **only on the client** to transform the data sent from the server.
+   */
+  deserialize: (object: any) => any;
+}
+
+/**
+ * @public
+ */
+export interface CombinedDataTransformer {
+  /**
+   * Specify how the data sent from the client to the server should be transformed.
+   */
+  input: InputDataTransformer;
+  /**
+   * Specify how the data sent from the server to the client should be transformed.
+   */
+  output: OutputDataTransformer;
+}
+
+/**
+ * @public
+ */
+export type CombinedDataTransformerClient = {
+  input: Pick<CombinedDataTransformer['input'], 'serialize'>;
+  output: Pick<CombinedDataTransformer['output'], 'deserialize'>;
+};
+
+/**
+ * @public
+ */
+export type DataTransformerOptions = CombinedDataTransformer | DataTransformer;
+
+/**
+ * @internal
+ */
+export function getDataTransformer(
+  transformer: DataTransformerOptions,
+): CombinedDataTransformer {
+  if ('input' in transformer) {
+    return transformer;
+  }
+  return { input: transformer, output: transformer };
+}
+
+/**
+ * @internal
+ */
+export type DefaultDataTransformer = CombinedDataTransformer & {
+  _default: true;
+};
+
+/**
+ * @internal
+ */
+export const defaultTransformer: DefaultDataTransformer = {
+  _default: true,
+  input: { serialize: (obj) => obj, deserialize: (obj) => obj },
+  output: { serialize: (obj) => obj, deserialize: (obj) => obj },
+};
+
+function transformTRPCResponseItem<
+  TResponseItem extends TRPCResponse | TRPCResponseMessage,
+>(config: AnyRootConfig, item: TResponseItem): TResponseItem {
+  if ('error' in item) {
+    return {
+      ...item,
+      error: config.transformer.output.serialize(item.error),
+    };
+  }
+
+  if ('data' in item.result) {
+    return {
+      ...item,
+      result: {
+        ...item.result,
+        data: config.transformer.output.serialize(item.result.data),
+      },
+    };
+  }
+
+  return item;
+}
+
+/**
+ * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
+ **/
+export function transformTRPCResponse<
+  TResponse extends
+    | TRPCResponse
+    | TRPCResponse[]
+    | TRPCResponseMessage
+    | TRPCResponseMessage[],
+>(config: AnyRootConfig, itemOrItems: TResponse) {
+  return Array.isArray(itemOrItems)
+    ? itemOrItems.map((item) => transformTRPCResponseItem(config, item))
+    : transformTRPCResponseItem(config, itemOrItems);
+}
+
+// FIXME:
+// - the generics here are probably unnecessary
+// - the RPC-spec could probably be simplified to combine HTTP + WS
+/** @internal */
+function transformResultInner<TRouter extends AnyRouter, TOutput>(
+  response:
+    | TRPCResponse<TOutput, inferRouterError<TRouter>>
+    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,
+  transformer: DataTransformer,
+) {
+  if ('error' in response) {
+    const error = transformer.deserialize(
+      response.error,
+    ) as inferRouterError<TRouter>;
+    return {
+      ok: false,
+      error: {
+        ...response,
+        error,
+      },
+    } as const;
+  }
+
+  const result = {
+    ...response.result,
+    ...((!response.result.type || response.result.type === 'data') && {
+      type: 'data',
+      data: transformer.deserialize(response.result.data),
+    }),
+  } as TRPCResultMessage<TOutput>['result'];
+  return { ok: true, result } as const;
+}
+
+class TransformResultError extends Error {
+  constructor() {
+    super('Unable to transform response from server');
+  }
+}
+
+/**
+ * Transforms and validates that the result is a valid TRPCResponse
+ * @internal
+ */
+export function transformResult<TRouter extends AnyRouter, TOutput>(
+  response:
+    | TRPCResponse<TOutput, inferRouterError<TRouter>>
+    | TRPCResponseMessage<TOutput, inferRouterError<TRouter>>,
+  transformer: DataTransformer,
+): ReturnType<typeof transformResultInner> {
+  let result: ReturnType<typeof transformResultInner>;
+  try {
+    // Use the data transformers on the JSON-response
+    result = transformResultInner(response, transformer);
+  } catch (err) {
+    throw new TransformResultError();
+  }
+
+  // check that output of the transformers is a valid TRPCResponse
+  if (
+    !result.ok &&
+    (!isObject(result.error.error) ||
+      typeof result.error.error['code'] !== 'number')
+  ) {
+    throw new TransformResultError();
+  }
+  if (result.ok && !isObject(result.result)) {
+    throw new TransformResultError();
+  }
+  return result;
+}

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

@@ -0,0 +1,151 @@
+/**
+ * ================================
+ * Useful utility types that doesn't have anything to do with tRPC in particular
+ * ================================
+ */
+
+/**
+ * @public
+ */
+export type Maybe<TType> = TType | null | undefined;
+
+/**
+ * @internal
+ * @link https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+export type Simplify<TType> = TType extends any[] | Date
+  ? TType
+  : { [K in keyof TType]: TType[K] };
+
+/**
+ * @public
+ */
+export type Dict<TType> = Record<string, TType | undefined>;
+
+/**
+ * @public
+ */
+export type MaybePromise<TType> = Promise<TType> | TType;
+
+export type FilterKeys<TObj extends object, TFilter> = {
+  [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
+
+/**
+ * @internal
+ */
+export type Filter<TObj extends object, TFilter> = Pick<
+  TObj,
+  FilterKeys<TObj, TFilter>
+>;
+
+/**
+ * Unwrap return type if the type is a function (sync or async), else use the type as is
+ * @internal
+ */
+export type Unwrap<TType> = TType extends (...args: any[]) => infer R
+  ? Awaited<R>
+  : TType;
+
+/**
+ * Makes the object recursively optional
+ * @internal
+ */
+export type DeepPartial<TObject> = TObject extends object
+  ? {
+      [P in keyof TObject]?: DeepPartial<TObject[P]>;
+    }
+  : TObject;
+
+/**
+ * Omits the key without removing a potential union
+ * @internal
+ */
+export type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any
+  ? Omit<TObj, TKey>
+  : never;
+
+/**
+ * See https://github.com/microsoft/TypeScript/issues/41966#issuecomment-758187996
+ * Fixes issues with iterating over keys of objects with index signatures.
+ * Without this, iterations over keys of objects with index signatures will lose
+ * type information about the keys and only the index signature will remain.
+ * @internal
+ */
+export type WithoutIndexSignature<TObj> = {
+  [K in keyof TObj as string extends K
+    ? never
+    : number extends K
+    ? never
+    : K]: TObj[K];
+};
+
+/**
+ * @internal
+ * Overwrite properties in `TType` with properties in `TWith`
+ * Only overwrites properties when the type to be overwritten
+ * is an object. Otherwise it will just use the type from `TWith`.
+ */
+export type Overwrite<TType, TWith> = TWith extends any
+  ? TType extends object
+    ? {
+        [K in  // Exclude index signature from keys
+          | keyof WithoutIndexSignature<TType>
+          | keyof WithoutIndexSignature<TWith>]: K extends keyof TWith
+          ? TWith[K]
+          : K extends keyof TType
+          ? TType[K]
+          : never;
+      } & (string extends keyof TWith // Handle cases with an index signature
+        ? { [key: string]: TWith[string] }
+        : number extends keyof TWith
+        ? { [key: number]: TWith[number] }
+        : // eslint-disable-next-line @typescript-eslint/ban-types
+          {})
+    : TWith
+  : never;
+
+/**
+ * @internal
+ */
+export type ValidateShape<TActualShape, TExpectedShape> =
+  TActualShape extends TExpectedShape
+    ? Exclude<keyof TActualShape, keyof TExpectedShape> extends never
+      ? TActualShape
+      : TExpectedShape
+    : never;
+
+/**
+ * @internal
+ */
+export type PickFirstDefined<TType, TPick> = undefined extends TType
+  ? undefined extends TPick
+    ? never
+    : TPick
+  : TType;
+
+/**
+ * ================================
+ * tRPC specific types
+ * ================================
+ */
+
+/**
+ * @internal
+ */
+export type IntersectionError<TKey extends string> =
+  `The property '${TKey}' in your router collides with a built-in method, rename this router or procedure on your backend.`;
+
+/**
+ * @internal
+ */
+export type ProtectedIntersection<TType, TWith> = keyof TType &
+  keyof TWith extends never
+  ? TType & TWith
+  : IntersectionError<string & keyof TType & keyof TWith>;
+
+/**
+ * @internal
+ * Returns the raw input type of a procedure
+ */
+export type GetRawInputFn = () => Promise<unknown>;

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

@@ -0,0 +1,59 @@
+type KeyFromValue<TValue, TType extends Record<PropertyKey, PropertyKey>> = {
+  [K in keyof TType]: TValue extends TType[K] ? K : never;
+}[keyof TType];
+
+type Invert<TType extends Record<PropertyKey, PropertyKey>> = {
+  [TValue in TType[keyof TType]]: KeyFromValue<TValue, TType>;
+};
+/**
+ * @internal
+ */
+export function invert<TRecord extends Record<PropertyKey, PropertyKey>>(
+  obj: TRecord,
+): Invert<TRecord> {
+  const newObj = Object.create(null);
+  for (const key in obj) {
+    const v = obj[key];
+    newObj[v] = key;
+  }
+  return newObj;
+}
+
+/**
+ * Ensures there are no duplicate keys when building a procedure.
+ * @internal
+ */
+export function mergeWithoutOverrides<TType extends Record<string, unknown>>(
+  obj1: TType,
+  ...objs: Partial<TType>[]
+): TType {
+  const newObj: TType = Object.assign(Object.create(null), obj1);
+
+  for (const overrides of objs) {
+    for (const key in overrides) {
+      if (key in newObj && newObj[key] !== overrides[key]) {
+        throw new Error(`Duplicate key ${key}`);
+      }
+      newObj[key as keyof TType] = overrides[key] as TType[keyof TType];
+    }
+  }
+  return newObj;
+}
+
+/**
+ * Check that value is object
+ * @internal
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return !!value && !Array.isArray(value) && typeof value === 'object';
+}
+
+/**
+ * Create an object without inheriting anything from `Object.prototype`
+ * @internal
+ */
+export function omitPrototype<TObj extends Record<string, unknown>>(
+  obj: TObj,
+): TObj {
+  return Object.assign(Object.create(null), obj);
+}

package/unstable-core-do-not-import/index.d.ts

@@ -0,0 +1 @@
+export * from '../dist/unstable-core-do-not-import';

package/unstable-core-do-not-import/index.js

@@ -0,0 +1 @@
+module.exports = require('../dist/unstable-core-do-not-import');

package/dist/@trpc-core-unstable-do-not-import-this-please.d.ts

@@ -1,10 +0,0 @@
-/**
- * This file is here to make TypeScript happy and prevent _"The inferred type of 'createContext' cannot be named without a reference to [...]"_.
- *
- * We're basically just re-exporting everything from @trpc/core here.
- *
- * If you need to import anything from here, please open an issue at https://github.com/trpc/trpc/issues
- */
-export type { AnyMiddlewareFunction, AnyRouter, AnyMutationProcedure, AnyProcedure, AnyQueryProcedure, AnyRootConfig, AnyRouterDef, AnySubscriptionProcedure, BaseContentTypeHandler, BaseHandlerOptions, BodyResult, CombinedDataTransformer, CombinedDataTransformerClient, CreateRouterInner, DataTransformer, DataTransformerOptions, DeepPartial, DefaultDataTransformer, DefaultErrorData, DefaultErrorShape, Dict, DistributiveOmit, Filter, FilterKeys, HTTPBaseHandlerOptions, HTTPHeaders, HTTPRequest, HTTPResponse, IntersectionError, JSONRPC2, Maybe, MaybePromise, MiddlewareBuilder, MiddlewareFunction, MutationProcedure, Observable, Observer, OnErrorFunction, Overwrite, PickFirstDefined, Procedure, ProcedureArgs, ProcedureBuilder, ProcedureCall, ProcedureOptions, ProcedureRecord, ProcedureRouterRecord, ProcedureType, ProtectedIntersection, QueryProcedure, ResolveHTTPRequestOptionsContextFn, ResponseChunk, ResponseMeta, ResponseMetaFn, RootConfig, Router, RouterCaller, Serialize, SerializeObject, Simplify, SubscriptionProcedure, TRPCClientIncomingMessage, TRPCClientIncomingRequest, TRPCClientOutgoingMessage, TRPCClientOutgoingRequest, TRPCErrorResponse, TRPCErrorShape, TRPCInferrable, TRPCReconnectNotification, TRPCRequest, TRPCRequestInfo, TRPCRequestMessage, TRPCResponse, TRPCResponseMessage, TRPCResult, TRPCResultMessage, TRPCSubscriptionStopNotification, TRPCSuccessResponse, TRPC_ERROR_CODE_KEY, TRPC_ERROR_CODE_NUMBER, TeardownLogic, Unsubscribable, UnsubscribeFn, Unwrap, ValidateShape, WithoutIndexSignature, inferErrorShape, inferHandlerInput, inferObservableValue, inferParser, inferProcedureInput, inferProcedureOutput, inferProcedureParams, inferRouterContext, inferRouterError, inferRouterInputs, inferRouterMeta, inferRouterOutputs, inferTransformedProcedureOutput, inferTransformedSubscriptionOutput, } from '@trpc/core';
-export { TRPCError, TRPC_ERROR_CODES_BY_KEY, TRPC_ERROR_CODES_BY_NUMBER, callProcedure, createBuilder, createFlatProxy, createInputMiddleware, createOutputMiddleware, createRecursiveProxy, createRouterFactory, experimental_standaloneMiddleware, getBatchStreamFormatter, getCauseFromUnknown, getErrorShape, getHTTPStatusCode, getHTTPStatusCodeFromError, getJsonContentTypeInputs, getTRPCErrorFromUnknown, initTRPC, isObject, isObservable, map, mergeRouters, middlewareMarker, observable, observableToPromise, parseTRPCMessage, procedureTypes, resolveHTTPResponse, share, tap, transformResult, transformTRPCResponse, unsetMarker, } from '@trpc/core';
-//# sourceMappingURL=@trpc-core-unstable-do-not-import-this-please.d.ts.map

package/dist/@trpc-core-unstable-do-not-import-this-please.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"@trpc-core-unstable-do-not-import-this-please.d.ts","sourceRoot":"","sources":["../src/@trpc-core-unstable-do-not-import-this-please.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EACV,qBAAqB,EACrB,SAAS,EACT,oBAAoB,EACpB,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,wBAAwB,EACxB,sBAAsB,EACtB,kBAAkB,EAClB,UAAU,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,IAAI,EACJ,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,YAAY,EACZ,iBAAiB,EACjB,QAAQ,EACR,KAAK,EACL,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,QAAQ,EACR,eAAe,EACf,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,qBAAqB,EACrB,cAAc,EACd,kCAAkC,EAClC,aAAa,EACb,YAAY,EACZ,cAAc,EACd,UAAU,EACV,MAAM,EACN,YAAY,EACZ,SAAS,EACT,eAAe,EACf,QAAQ,EACR,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,yBAAyB,EACzB,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EACjB,gCAAgC,EAChC,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,cAAc,EACd,aAAa,EACb,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,+BAA+B,EAC/B,kCAAkC,GACnC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,SAAS,EACT,uBAAuB,EACvB,0BAA0B,EAC1B,aAAa,EACb,aAAa,EACb,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,iCAAiC,EACjC,uBAAuB,EACvB,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,EACvB,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,GAAG,EACH,YAAY,EACZ,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,GAAG,EACH,eAAe,EACf,qBAAqB,EACrB,WAAW,GACZ,MAAM,YAAY,CAAC"}

package/dist/@trpc-server/http.d.ts

@@ -1,2 +0,0 @@
-export * from '@trpc/core';
-//# sourceMappingURL=http.d.ts.map

package/dist/@trpc-server/http.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/@trpc-server/http.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC"}

package/dist/observable.d.ts

@@ -1,3 +0,0 @@
-export type { Observable, Observer, TeardownLogic, Unsubscribable, UnsubscribeFn, inferObservableValue, } from './@trpc-core-unstable-do-not-import-this-please';
-export { isObservable, map, observable, observableToPromise, share, tap, } from './@trpc-core-unstable-do-not-import-this-please';
-//# sourceMappingURL=observable.d.ts.map

package/dist/observable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../src/observable.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,QAAQ,EACR,aAAa,EACb,cAAc,EACd,aAAa,EACb,oBAAoB,GACrB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EACL,YAAY,EACZ,GAAG,EACH,UAAU,EACV,mBAAmB,EACnB,KAAK,EACL,GAAG,GACJ,MAAM,iDAAiD,CAAC"}

package/dist/observable.js

@@ -1,30 +0,0 @@
-'use strict';
-
-var core = require('@trpc/core');
-
-
-
-Object.defineProperty(exports, "isObservable", {
-  enumerable: true,
-  get: function () { return core.isObservable; }
-});
-Object.defineProperty(exports, "map", {
-  enumerable: true,
-  get: function () { return core.map; }
-});
-Object.defineProperty(exports, "observable", {
-  enumerable: true,
-  get: function () { return core.observable; }
-});
-Object.defineProperty(exports, "observableToPromise", {
-  enumerable: true,
-  get: function () { return core.observableToPromise; }
-});
-Object.defineProperty(exports, "share", {
-  enumerable: true,
-  get: function () { return core.share; }
-});
-Object.defineProperty(exports, "tap", {
-  enumerable: true,
-  get: function () { return core.tap; }
-});