@trpc/server 11.0.0-next-beta.241 → 11.0.0-next-beta.248

package/src/adapters/node-http/types.ts

@@ -7,7 +7,7 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type { IncomingMessage, ServerResponse } from 'http';
+import type * as http from 'http';
 // @trpc/server
 import type { AnyRouter, inferRouterContext } from '../../@trpc/server';
 // @trpc/server/http
@@ -23,11 +23,11 @@ interface ParsedQs {
   [key: string]: ParsedQs | ParsedQs[] | string[] | string | undefined;
 }
 
-export type NodeHTTPRequest = IncomingMessage & {
+export type NodeHTTPRequest = http.IncomingMessage & {
   query?: ParsedQs;
   body?: unknown;
 };
-export type NodeHTTPResponse = ServerResponse & {
+export type NodeHTTPResponse = http.ServerResponse & {
   /**
    * Force the partially-compressed response to be flushed to the client.
    *

package/src/unstable-core-do-not-import/http/getHTTPStatusCode.ts

@@ -1,3 +1,4 @@
+import type { DefaultErrorData } from '../error/formatter';
 import type { TRPCError } from '../error/TRPCError';
 import type { TRPC_ERROR_CODES_BY_KEY, TRPCResponse } from '../rpc';
 import { TRPC_ERROR_CODES_BY_NUMBER } from '../rpc';
@@ -32,9 +33,11 @@ export function getHTTPStatusCode(json: TRPCResponse | TRPCResponse[]) {
   const httpStatuses = new Set(
     arr.map((res) => {
       if ('error' in res) {
-        const data = res.error.data;
-        if (typeof data['httpStatus'] === 'number') {
-          return data['httpStatus'];
+        const data = res.error.data as
+          | Record<string, unknown>
+          | DefaultErrorData;
+        if (typeof data.httpStatus === 'number') {
+          return data.httpStatus;
         }
         const code = TRPC_ERROR_CODES_BY_NUMBER[res.error.code];
         return getStatusCodeFromKey(code);

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

@@ -52,10 +52,6 @@ export type { ProcedureBuilder } from './procedureBuilder';
 export * from './rootConfig';
 export type {
   AnyRouter,
-  AnyRouterDef,
-  CreateRouterInner,
-  ProcedureRecord,
-  ProcedureRouterRecord,
   Router,
   RouterCaller,
   createRouterFactory,

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

@@ -9,29 +9,13 @@ import type {
 import type { ProcedureCallOptions } from './procedureBuilder';
 import type { AnyRootTypes, RootConfig } from './rootConfig';
 import { defaultTransformer } from './transformer';
-import type { MaybePromise } from './types';
+import type { MaybePromise, ValueOf } from './types';
 import { mergeWithoutOverrides, omitPrototype } from './utils';
 
-/** @internal **/
-export type ProcedureRecord = Record<string, AnyProcedure>;
-
-export interface ProcedureRouterRecord {
-  [key: string]: AnyProcedure | AnyRouter;
-}
-
-export interface RouterDef<
-  TRoot extends AnyRootTypes,
-  TRecord extends ProcedureRouterRecord,
-> {
-  _config: RootConfig<TRoot>;
-  router: true;
-  procedure?: never;
-  procedures: TRecord;
-  record: TRecord;
+export interface RouterRecord {
+  [key: string]: AnyProcedure | RouterRecord;
 }
 
-export type AnyRouterDef = RouterDef<any, any>;
-
 type DecorateProcedure<TProcedure extends AnyProcedure> = (
   input: inferProcedureInput<TProcedure>,
 ) => Promise<TProcedure['_def']['_output_out']>;
@@ -39,85 +23,96 @@ type DecorateProcedure<TProcedure extends AnyProcedure> = (
 /**
  * @internal
  */
-type DecoratedProcedureRecord<TProcedures extends ProcedureRouterRecord> = {
-  [TKey in keyof TProcedures]: TProcedures[TKey] extends AnyRouter
-    ? DecoratedProcedureRecord<TProcedures[TKey]['_def']['record']>
-    : TProcedures[TKey] extends AnyProcedure
-    ? DecorateProcedure<TProcedures[TKey]>
+export type DecorateRouterRecord<TRecord extends RouterRecord> = {
+  [TKey in keyof TRecord]: TRecord[TKey] extends AnyProcedure
+    ? DecorateProcedure<TRecord[TKey]>
+    : TRecord[TKey] extends RouterRecord
+    ? DecorateRouterRecord<TRecord[TKey]>
     : never;
 };
 
 /**
  * @internal
  */
-export type RouterCaller<TDef extends AnyRouterDef> = (
+export type RouterCaller<
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
+> = (
   /**
    * @note
    * If passing a function, we recommend it's a cached function
    * e.g. wrapped in `React.cache` to avoid unnecessary computations
    */
-  ctx:
-    | TDef['_config']['$types']['ctx']
-    | (() => MaybePromise<TDef['_config']['$types']['ctx']>),
-) => DecoratedProcedureRecord<TDef['record']>;
+  ctx: TRoot['ctx'] | (() => MaybePromise<TRoot['ctx']>),
+) => DecorateRouterRecord<TRecord>;
 
-export interface Router<TDef extends AnyRouterDef> {
-  _def: TDef;
+export interface Router<
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
+> {
+  _def: {
+    _config: RootConfig<TRoot>;
+    router: true;
+    procedure?: never;
+    procedures: TRecord;
+    record: TRecord;
+  };
   /**
    * @deprecated use `t.createCallerFactory(router)` instead
    * @link https://trpc.io/docs/v11/server/server-side-calls
    */
-  createCaller: RouterCaller<TDef>;
+  createCaller: RouterCaller<TRoot, TRecord>;
 }
 
-export type AnyRouter = Router<AnyRouterDef>;
+export type BuiltRouter<
+  TRoot extends AnyRootTypes,
+  TDef extends RouterRecord,
+> = Router<TRoot, TDef> & TDef;
+
+export type AnyRouter = Router<any, any>;
 
-type inferRouterDef<TRouter extends AnyRouter> = TRouter extends Router<
-  infer TParams
->
-  ? TParams extends AnyRouterDef
-    ? TParams
-    : never
-  : never;
-type inferRouterConfig<TRouter extends AnyRouter> =
-  inferRouterDef<TRouter>['_config'];
+export type inferRouterRootTypes<TRouter extends AnyRouter> =
+  TRouter['_def']['_config']['$types'];
 
 export type inferRouterContext<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['ctx'];
+  inferRouterRootTypes<TRouter>['ctx'];
 export type inferRouterError<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['errorShape'];
+  inferRouterRootTypes<TRouter>['errorShape'];
 export type inferRouterMeta<TRouter extends AnyRouter> =
-  inferRouterConfig<TRouter>['$types']['meta'];
+  inferRouterRootTypes<TRouter>['meta'];
 
-type GetInferenceHelpers<
+export type GetInferenceHelpers<
   TType extends 'input' | 'output',
-  TRouter extends AnyRouter,
+  TRoot extends AnyRootTypes,
+  TRecord extends RouterRecord,
 > = {
-  [TKey in keyof TRouter['_def']['record']]: TRouter['_def']['record'][TKey] extends infer TRouterOrProcedure
-    ? TRouterOrProcedure extends AnyRouter
-      ? GetInferenceHelpers<TType, TRouterOrProcedure>
-      : TRouterOrProcedure extends AnyProcedure
+  [TKey in keyof TRecord]: TRecord[TKey] extends infer $Value
+    ? $Value extends RouterRecord
+      ? GetInferenceHelpers<TType, TRoot, $Value>
+      : $Value extends AnyProcedure
       ? TType extends 'input'
-        ? inferProcedureInput<TRouterOrProcedure>
-        : inferTransformedProcedureOutput<TRouter, TRouterOrProcedure>
+        ? inferProcedureInput<$Value>
+        : inferTransformedProcedureOutput<TRoot, $Value>
       : never
     : never;
 };
 
 export type inferRouterInputs<TRouter extends AnyRouter> = GetInferenceHelpers<
   'input',
-  TRouter
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
 >;
 
 export type inferRouterOutputs<TRouter extends AnyRouter> = GetInferenceHelpers<
   'output',
-  TRouter
+  TRouter['_def']['_config']['$types'],
+  TRouter['_def']['record']
 >;
 
 function isRouter(
-  procedureOrRouter: AnyProcedure | AnyRouter,
+  procedureOrRouter: ValueOf<CreateRouterOptions>,
 ): procedureOrRouter is AnyRouter {
-  return 'router' in procedureOrRouter._def;
+  return procedureOrRouter._def && 'router' in procedureOrRouter._def;
 }
 
 const emptyRouter = {
@@ -142,17 +137,23 @@ const reservedWords = [
   'then',
 ];
 
-/**
- * @internal
- */
-export type CreateRouterInner<
-  TRoot extends AnyRootTypes,
-  TProcRouterRecord extends ProcedureRouterRecord,
-> = Router<RouterDef<TRoot, TProcRouterRecord>> &
-  /**
-   * This adds ability to call procedures directly but is primarily used for quick access in type inference
-   */
-  TProcRouterRecord;
+export type CreateRouterOptions = {
+  [key: string]: AnyProcedure | AnyRouter | CreateRouterOptions;
+};
+
+export type DecorateCreateRouterOptions<
+  TRouterOptions extends CreateRouterOptions,
+> = {
+  [K in keyof TRouterOptions]: TRouterOptions[K] extends infer $Value
+    ? $Value extends AnyProcedure
+      ? $Value
+      : $Value extends Router<any, infer TRecord>
+      ? TRecord
+      : $Value extends CreateRouterOptions
+      ? DecorateCreateRouterOptions<$Value>
+      : never
+    : never;
+};
 
 /**
  * @internal
@@ -160,13 +161,15 @@ export type CreateRouterInner<
 export function createRouterFactory<TRoot extends AnyRootTypes>(
   config: RootConfig<TRoot>,
 ) {
-  return function createRouterInner<
-    TProcRouterRecord extends ProcedureRouterRecord,
-  >(
-    procedures: TProcRouterRecord,
-  ): CreateRouterInner<TRoot, TProcRouterRecord> {
+  function createRouterInner<TInput extends RouterRecord>(
+    input: TInput,
+  ): BuiltRouter<TRoot, TInput>;
+  function createRouterInner<TInput extends CreateRouterOptions>(
+    input: TInput,
+  ): BuiltRouter<TRoot, DecorateCreateRouterOptions<TInput>>;
+  function createRouterInner(input: RouterRecord | CreateRouterOptions) {
     const reservedWordsUsed = new Set(
-      Object.keys(procedures).filter((v) => reservedWords.includes(v)),
+      Object.keys(input).filter((v) => reservedWords.includes(v)),
     );
     if (reservedWordsUsed.size > 0) {
       throw new Error(
@@ -175,37 +178,47 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
       );
     }
 
-    const routerProcedures: ProcedureRecord = omitPrototype({});
-    function recursiveGetPaths(procedures: ProcedureRouterRecord, path = '') {
-      for (const [key, procedureOrRouter] of Object.entries(procedures ?? {})) {
-        const newPath = `${path}${key}`;
+    const procedures: Record<string, AnyProcedure> = omitPrototype({});
 
-        if (isRouter(procedureOrRouter)) {
-          recursiveGetPaths(procedureOrRouter._def.procedures, `${newPath}.`);
+    function step(from: CreateRouterOptions, path: string[] = []) {
+      const aggregate: RouterRecord = omitPrototype({});
+      for (const [key, item] of Object.entries(from ?? {})) {
+        if (isRouter(item)) {
+          aggregate[key] = step(item._def.record, [...path, key]);
           continue;
         }
+        if (!isProcedure(item)) {
+          // RouterRecord
+          aggregate[key] = step(item, [...path, key]);
+          continue;
+        }
+
+        const newPath = [...path, key].join('.');
 
-        if (routerProcedures[newPath]) {
+        if (procedures[newPath]) {
           throw new Error(`Duplicate key: ${newPath}`);
         }
 
-        routerProcedures[newPath] = procedureOrRouter;
+        procedures[newPath] = item;
+        aggregate[key] = item;
       }
+
+      return aggregate;
     }
-    recursiveGetPaths(procedures);
+    const record = step(input);
 
-    const _def: AnyRouterDef = {
+    const _def: AnyRouter['_def'] = {
       _config: config,
       router: true,
-      procedures: routerProcedures,
+      procedures,
       ...emptyRouter,
-      record: procedures,
+      record,
     };
 
-    const router: AnyRouter = {
-      ...procedures,
+    return {
+      ...record,
       _def,
-      createCaller(ctx) {
+      createCaller(ctx: TRoot['ctx']) {
         const proxy = createRecursiveProxy(({ path, args }) => {
           const fullPath = path.join('.');
           const procedure = _def.procedures[fullPath] as AnyProcedure;
@@ -218,24 +231,24 @@ export function createRouterFactory<TRoot extends AnyRootTypes>(
           });
         });
 
-        return proxy as ReturnType<RouterCaller<any>>;
+        return proxy as ReturnType<RouterCaller<any, any>>;
       },
     };
+  }
 
-    return router as any;
-  };
+  return createRouterInner;
 }
 
 function isProcedure(
-  procedureOrRouter: AnyProcedure | AnyRouter,
+  procedureOrRouter: ValueOf<CreateRouterOptions>,
 ): procedureOrRouter is AnyProcedure {
-  return !!procedureOrRouter._def.procedure;
+  return typeof procedureOrRouter === 'function';
 }
 /**
  * @internal
  */
 export function callProcedure(
-  opts: ProcedureCallOptions & { procedures: ProcedureRouterRecord },
+  opts: ProcedureCallOptions & { procedures: RouterRecord },
 ) {
   const { type, path } = opts;
   const proc = opts.procedures[path];
@@ -250,15 +263,16 @@ export function callProcedure(
 }
 
 export function createCallerFactory<TRoot extends AnyRootTypes>() {
-  return function createCallerInner<
-    TRouter extends Router<RouterDef<TRoot, any>>,
-  >(router: TRouter): RouterCaller<TRouter['_def']> {
+  return function createCallerInner<TRecord extends RouterRecord>(
+    router: Router<TRoot, TRecord>,
+  ): RouterCaller<TRoot, TRecord> {
     const _def = router._def;
     type Context = TRoot['ctx'];
 
     return function createCaller(maybeContext) {
       const proxy = createRecursiveProxy(({ path, args }) => {
         const fullPath = path.join('.');
+
         const procedure = _def.procedures[fullPath] as AnyProcedure;
 
         const callProc = (ctx: Context) =>
@@ -280,7 +294,7 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
         return callProc(maybeContext);
       });
 
-      return proxy as ReturnType<RouterCaller<any>>;
+      return proxy as ReturnType<RouterCaller<any, any>>;
     };
   };
 }
@@ -288,25 +302,15 @@ export function createCallerFactory<TRoot extends AnyRootTypes>() {
 /** @internal */
 type MergeRouters<
   TRouters extends AnyRouter[],
-  TRouterDef extends AnyRouterDef = RouterDef<
-    TRouters[0]['_def']['_config']['$types'],
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    {}
-  >,
+  TRoot extends AnyRootTypes = TRouters[0]['_def']['_config']['$types'],
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  TRecord extends RouterRecord = {},
 > = TRouters extends [
   infer Head extends AnyRouter,
   ...infer Tail extends AnyRouter[],
 ]
-  ? MergeRouters<
-      Tail,
-      {
-        _config: TRouterDef['_config'];
-        router: true;
-        procedures: Head['_def']['procedures'] & TRouterDef['procedures'];
-        record: Head['_def']['record'] & TRouterDef['record'];
-      }
-    >
-  : Router<TRouterDef> & TRouterDef['record'];
+  ? MergeRouters<Tail, TRoot, Head['_def']['record'] & TRecord>
+  : BuiltRouter<TRoot, TRecord>;
 
 export function mergeRouters<TRouters extends AnyRouter[]>(
   ...routerList: [...TRouters]
@@ -353,12 +357,13 @@ export function mergeRouters<TRouters extends AnyRouter[]>(
   const router = createRouterFactory({
     errorFormatter,
     transformer,
-    isDev: routerList.some((r) => r._def._config.isDev),
-    allowOutsideOfServer: routerList.some(
+    isDev: routerList.every((r) => r._def._config.isDev),
+    allowOutsideOfServer: routerList.every(
       (r) => r._def._config.allowOutsideOfServer,
     ),
-    isServer: routerList.some((r) => r._def._config.isServer),
+    isServer: routerList.every((r) => r._def._config.isServer),
     $types: routerList[0]?._def._config.$types,
   })(record);
-  return router as any;
+
+  return router as MergeRouters<TRouters>;
 }

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

@@ -1,3 +1,4 @@
+import type { ValueOf } from '../types';
 import { invert } from '../utils';
 
 // reference: https://www.jsonrpc.org/specification
@@ -39,6 +40,5 @@ export const TRPC_ERROR_CODES_BY_KEY = {
 
 export const TRPC_ERROR_CODES_BY_NUMBER = invert(TRPC_ERROR_CODES_BY_KEY);
 
-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/unstable-core-do-not-import/rpc/envelopes.ts

@@ -5,9 +5,7 @@ import type { TRPC_ERROR_CODE_NUMBER } from './codes';
 /**
  * Error response
  */
-export interface TRPCErrorShape<
-  TData extends Record<string, unknown> = Record<string, unknown>,
-> {
+export interface TRPCErrorShape<TData extends object = object> {
   code: TRPC_ERROR_CODE_NUMBER;
   message: string;
   data: TData;

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

@@ -154,3 +154,4 @@ export const ERROR_SYMBOL = Symbol('TypeError');
 export type TypeError<TMessage extends string> = TMessage & {
   _: typeof ERROR_SYMBOL;
 };
+export type ValueOf<TObj> = TObj[keyof TObj];

package/dist/node_modules/.pnpm/@web3-storage_multipart-parser@1.0.0/node_modules/@web3-storage/multipart-parser/esm/src/index.js

@@ -1,203 +0,0 @@
-'use strict';
-
-var search = require('./search.js');
-var utils = require('./utils.js');
-
-const mergeArrays2 = Function.prototype.apply.bind(utils.mergeArrays, undefined);
-const dash = utils.stringToArray('--');
-const CRLF = utils.stringToArray('\r\n');
-function parseContentDisposition(header) {
-  const parts = header.split(';').map(part => part.trim());
-  if (parts.shift() !== 'form-data') {
-    throw new Error('malformed content-disposition header: missing "form-data" in `' + JSON.stringify(parts) + '`');
-  }
-  const out = {};
-  for (const part of parts) {
-    const kv = part.split('=', 2);
-    if (kv.length !== 2) {
-      throw new Error('malformed content-disposition header: key-value pair not found - ' + part + ' in `' + header + '`');
-    }
-    const [name, value] = kv;
-    if (value[0] === '"' && value[value.length - 1] === '"') {
-      out[name] = value.slice(1, -1).replace(/\\"/g, '"');
-    } else if (value[0] !== '"' && value[value.length - 1] !== '"') {
-      out[name] = value;
-    } else if (value[0] === '"' && value[value.length - 1] !== '"' || value[0] !== '"' && value[value.length - 1] === '"') {
-      throw new Error('malformed content-disposition header: mismatched quotations in `' + header + '`');
-    }
-  }
-  if (!out.name) {
-    throw new Error('malformed content-disposition header: missing field name in `' + header + '`');
-  }
-  return out;
-}
-function parsePartHeaders(lines) {
-  const entries = [];
-  let disposition = false;
-  let line;
-  while (typeof (line = lines.shift()) !== 'undefined') {
-    const colon = line.indexOf(':');
-    if (colon === -1) {
-      throw new Error('malformed multipart-form header: missing colon');
-    }
-    const header = line.slice(0, colon).trim().toLowerCase();
-    const value = line.slice(colon + 1).trim();
-    switch (header) {
-    case 'content-disposition':
-      disposition = true;
-      entries.push(...Object.entries(parseContentDisposition(value)));
-      break;
-    case 'content-type':
-      entries.push([
-        'contentType',
-        value
-      ]);
-    }
-  }
-  if (!disposition) {
-    throw new Error('malformed multipart-form header: missing content-disposition');
-  }
-  return Object.fromEntries(entries);
-}
-async function readHeaderLines(it, needle) {
-  let firstChunk = true;
-  let lastTokenWasMatch = false;
-  const headerLines = [[]];
-  const crlfSearch = new search.StreamSearch(CRLF);
-  for (;;) {
-    const result = await it.next();
-    if (result.done) {
-      throw new Error('malformed multipart-form data: unexpected end of stream');
-    }
-    if (firstChunk && result.value !== search.MATCH && utils.arraysEqual(result.value.slice(0, 2), dash)) {
-      return [
-        undefined,
-        new Uint8Array()
-      ];
-    }
-    let chunk;
-    if (result.value !== search.MATCH) {
-      chunk = result.value;
-    } else if (!lastTokenWasMatch) {
-      chunk = needle;
-    } else {
-      throw new Error('malformed multipart-form data: unexpected boundary');
-    }
-    if (!chunk.length) {
-      continue;
-    }
-    if (firstChunk) {
-      firstChunk = false;
-    }
-    const tokens = crlfSearch.feed(chunk);
-    for (const [i, token] of tokens.entries()) {
-      const isMatch = token === search.MATCH;
-      if (!isMatch && !token.length) {
-        continue;
-      }
-      if (lastTokenWasMatch && isMatch) {
-        tokens.push(crlfSearch.end());
-        return [
-          headerLines.filter(chunks => chunks.length).map(mergeArrays2).map(utils.arrayToString),
-          utils.mergeArrays(...tokens.slice(i + 1).map(token => token === search.MATCH ? CRLF : token))
-        ];
-      }
-      if (lastTokenWasMatch = isMatch) {
-        headerLines.push([]);
-      } else {
-        headerLines[headerLines.length - 1].push(token);
-      }
-    }
-  }
-}
-async function* streamMultipart(body, boundary) {
-  const needle = utils.mergeArrays(dash, utils.stringToArray(boundary));
-  const it = new search.ReadableStreamSearch(needle, body)[Symbol.asyncIterator]();
-  for (;;) {
-    const result = await it.next();
-    if (result.done) {
-      return;
-    }
-    if (result.value === search.MATCH) {
-      break;
-    }
-  }
-  const crlfSearch = new search.StreamSearch(CRLF);
-  for (;;) {
-    const [headerLines, tail] = await readHeaderLines(it, needle);
-    if (!headerLines) {
-      return;
-    }
-    async function nextToken() {
-      const result = await it.next();
-      if (result.done) {
-        throw new Error('malformed multipart-form data: unexpected end of stream');
-      }
-      return result;
-    }
-    let trailingCRLF = false;
-    function feedChunk(chunk) {
-      const chunks = [];
-      for (const token of crlfSearch.feed(chunk)) {
-        if (trailingCRLF) {
-          chunks.push(CRLF);
-        }
-        if (!(trailingCRLF = token === search.MATCH)) {
-          chunks.push(token);
-        }
-      }
-      return utils.mergeArrays(...chunks);
-    }
-    let done = false;
-    async function nextChunk() {
-      const result = await nextToken();
-      let chunk;
-      if (result.value !== search.MATCH) {
-        chunk = result.value;
-      } else if (!trailingCRLF) {
-        chunk = CRLF;
-      } else {
-        done = true;
-        return { value: crlfSearch.end() };
-      }
-      return { value: feedChunk(chunk) };
-    }
-    const bufferedChunks = [{ value: feedChunk(tail) }];
-    yield {
-      ...parsePartHeaders(headerLines),
-      data: {
-        [Symbol.asyncIterator]() {
-          return this;
-        },
-        async next() {
-          for (;;) {
-            const result = bufferedChunks.shift();
-            if (!result) {
-              break;
-            }
-            if (result.value.length > 0) {
-              return result;
-            }
-          }
-          for (;;) {
-            if (done) {
-              return {
-                done,
-                value: undefined
-              };
-            }
-            const result = await nextChunk();
-            if (result.value.length > 0) {
-              return result;
-            }
-          }
-        }
-      }
-    };
-    while (!done) {
-      bufferedChunks.push(await nextChunk());
-    }
-  }
-}
-
-exports.streamMultipart = streamMultipart;