metro 0.83.4 → 0.83.5

package/src/Server.js.flow

@@ -52,6 +52,7 @@ import getRamBundleInfo from './DeltaBundler/Serializers/getRamBundleInfo';
 import {sourceMapStringNonBlocking} from './DeltaBundler/Serializers/sourceMapString';
 import IncrementalBundler from './IncrementalBundler';
 import ResourceNotFoundError from './IncrementalBundler/ResourceNotFoundError';
+import {calculateBundleProgressRatio} from './lib/bundleProgressUtils';
 import bundleToString from './lib/bundleToString';
 import formatBundlingError from './lib/formatBundlingError';
 import getGraphId from './lib/getGraphId';
@@ -130,6 +131,13 @@ export type ServerOptions = Readonly<{
 const DELTA_ID_HEADER = 'X-Metro-Delta-ID';
 const FILES_CHANGED_COUNT_HEADER = 'X-Metro-Files-Changed-Count';
 
+type FetchTiming = {
+  graphId: GraphId,
+  startTime: number,
+  endTime: number | null,
+  isPrefetch: boolean,
+};
+
 export default class Server {
   _bundler: IncrementalBundler;
   _config: ConfigT;
@@ -144,6 +152,8 @@ export default class Server {
   _sourceRequestRoutingMap: ReadonlyArray<
     [pathnamePrefix: string, normalizedRootDir: string],
   >;
+  _fetchTimings: Array<FetchTiming>;
+  _activeFetchCount: number;
 
   constructor(config: ConfigT, options?: ServerOptions) {
     this._config = config;
@@ -176,6 +186,8 @@ export default class Server {
       ]),
     ];
     this._isEnded = false;
+    this._fetchTimings = [];
+    this._activeFetchCount = 0;
 
     // TODO(T34760917): These two properties should eventually be instantiated
     // elsewhere and passed as parameters, since they are also needed by
@@ -846,25 +858,23 @@ export default class Server {
       const mres = MultipartResponse.wrapIfSupported(req, res);
 
       let onProgress = null;
-      let lastProgress = -1;
+      let lastRatio = -1;
       if (this._config.reporter) {
         onProgress = (transformedFileCount: number, totalFileCount: number) => {
-          const currentProgress = parseInt(
-            (transformedFileCount / totalFileCount) * 100,
-            10,
+          const newRatio = calculateBundleProgressRatio(
+            transformedFileCount,
+            totalFileCount,
+            lastRatio,
           );
 
-          // We want to throttle the updates so that we only show meaningful
-          // UI updates slow enough for the client to actually handle them. For
-          // that, we check the percentage, and only send percentages that are
-          // actually different and that have increased from the last one we sent.
-          if (currentProgress > lastProgress || totalFileCount < 10) {
+          if (newRatio > lastRatio) {
             if (mres instanceof MultipartResponse) {
               mres.writeChunk(
                 {'Content-Type': 'application/json'},
                 JSON.stringify({
                   done: transformedFileCount,
                   total: totalFileCount,
+                  percent: Math.floor(newRatio * 100),
                 }),
               );
             }
@@ -880,7 +890,7 @@ export default class Server {
               res.socket.uncork();
             }
 
-            lastProgress = currentProgress;
+            lastRatio = newRatio;
           }
 
           this._reporter.update({
@@ -926,8 +936,18 @@ export default class Server {
         createActionStartEntry(createStartEntry(startContext)),
       );
 
+      const fetchTiming: FetchTiming = {
+        graphId,
+        startTime: requestStartTimestamp,
+        endTime: null,
+        isPrefetch: req.method === 'HEAD',
+      };
+
       let result;
       try {
+        this._fetchTimings.push(fetchTiming);
+        this._activeFetchCount++;
+
         result = await build(startContext);
       } catch (error) {
         const formattedError = formatBundlingError(error);
@@ -960,6 +980,33 @@ export default class Server {
         buildContext.bundlePerfLogger.end('FAIL');
 
         return;
+      } finally {
+        fetchTiming.endTime = performance.timeOrigin + performance.now();
+
+        if (!fetchTiming.isPrefetch) {
+          buildContext.bundlePerfLogger.annotate({
+            bool: {
+              had_competing_prefetch: this._fetchTimings
+                // fetching the same bundle as a prefetch don't compete, since they resolve a shared promise for the same graph id
+                .filter(t => t.isPrefetch && t.graphId !== graphId)
+                .some(prefetch => {
+                  const prefetchEndTime =
+                    prefetch.endTime ?? Number.MAX_SAFE_INTEGER;
+                  const fetchEndTime =
+                    fetchTiming.endTime ?? Number.MAX_SAFE_INTEGER;
+                  return (
+                    prefetch.startTime < fetchEndTime &&
+                    prefetchEndTime > fetchTiming.startTime
+                  );
+                }),
+            },
+          });
+        }
+
+        this._activeFetchCount--;
+        if (this._activeFetchCount === 0) {
+          this._fetchTimings = [];
+        }
       }
 
       const endContext: ProcessEndContext<T> = {

package/src/cli/parseKeyValueParamArray.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+declare function coerceKeyValueArray(keyValueArray: ReadonlyArray<string>): {
+  [key: string]: string;
+};
+export default coerceKeyValueArray;

package/src/cli-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+export declare const watchFile: (
+  filename: string,
+  callback: () => unknown,
+) => Promise<void>;
+export declare type watchFile = typeof watchFile;
+export declare const makeAsyncCommand: <T>(
+  command: (argv: T) => Promise<void>,
+) => (argv: T) => void;
+export declare type makeAsyncCommand = typeof makeAsyncCommand;

package/src/cli-utils.js

@@ -6,11 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.watchFile = exports.makeAsyncCommand = void 0;
 var _fs = _interopRequireDefault(require("fs"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const watchFile = async function (filename, callback) {
   _fs.default.watchFile(filename, () => {

package/src/commands/build.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {CommandModule} from 'yargs';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: () => CommandModule;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/commands/build.js

@@ -14,11 +14,7 @@ var _TerminalReporter = _interopRequireDefault(
 var _metroConfig = require("metro-config");
 var _metroCore = require("metro-core");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const term = new _metroCore.Terminal(process.stdout);
 const updateReporter = new _TerminalReporter.default(term);

package/src/commands/dependencies.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {CommandModule} from 'yargs';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: () => CommandModule;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/commands/dependencies.js

@@ -11,11 +11,7 @@ var _metroConfig = require("metro-config");
 var _path = _interopRequireDefault(require("path"));
 var _util = require("util");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 async function dependencies(args, config) {
   const rootModuleAbsolutePath = args.entryFile;

package/src/commands/serve.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {CommandModule} from 'yargs';
+
+declare const $$EXPORT_DEFAULT_DECLARATION$$: () => CommandModule;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {AssetData} from './Assets';
+import type {ReadOnlyGraph} from './DeltaBundler';
+import type {ServerOptions} from './Server';
+import type {BuildOptions, OutputOptions, RequestOptions} from './shared/types';
+import type {HandleFunction} from 'connect';
+import type {Server as HttpServer} from 'http';
+import type {
+  Server as HttpsServer,
+  ServerOptions as HttpsServerOptions,
+} from 'https';
+import type {TransformProfile} from 'metro-babel-transformer';
+import type {
+  ConfigT,
+  InputConfigT,
+  MetroConfig,
+  Middleware,
+} from 'metro-config';
+import type {CustomResolverOptions} from 'metro-resolver';
+import type {CustomTransformOptions} from 'metro-transform-worker';
+import type {Server as WebSocketServer} from 'ws';
+import type $$IMPORT_TYPEOF_1$$ from 'yargs';
+
+import JsonReporter from './lib/JsonReporter';
+import TerminalReporter from './lib/TerminalReporter';
+import MetroServer from './Server';
+import {loadConfig, mergeConfig, resolveConfig} from 'metro-config';
+import {Terminal} from 'metro-core';
+
+type Yargs = typeof $$IMPORT_TYPEOF_1$$;
+type MetroMiddleWare = {
+  attachHmrServer: (httpServer: HttpServer | HttpsServer) => void;
+  end: () => Promise<void>;
+  metroServer: MetroServer;
+  middleware: Middleware;
+};
+export type RunMetroOptions = Omit<
+  ServerOptions,
+  keyof {waitForBundler?: boolean}
+> & {waitForBundler?: boolean};
+export type RunServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  host?: string;
+  onError?: ($$PARAM_0$$: Error & {code?: string}) => void;
+  onReady?: (server: HttpServer | HttpsServer) => void;
+  onClose?: () => void;
+  secureServerOptions?: HttpsServerOptions;
+  secure?: boolean;
+  secureCert?: string;
+  secureKey?: string;
+  unstable_extraMiddleware?: ReadonlyArray<HandleFunction>;
+  waitForBundler?: boolean;
+  watch?: boolean;
+  websocketEndpoints?: Readonly<{[path: string]: WebSocketServer}>;
+}>;
+export type RunServerResult = {httpServer: HttpServer | HttpsServer};
+type BuildGraphOptions = {
+  entries: ReadonlyArray<string>;
+  customTransformOptions?: CustomTransformOptions;
+  dev?: boolean;
+  minify?: boolean;
+  onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
+  platform?: string;
+  type?: 'module' | 'script';
+};
+export type RunBuildOptions = {
+  entry: string;
+  assets?: boolean;
+  dev?: boolean;
+  out?: string;
+  bundleOut?: string;
+  sourceMapOut?: string;
+  onBegin?: () => void;
+  onComplete?: () => void;
+  onProgress?: (transformedFileCount: number, totalFileCount: number) => void;
+  minify?: boolean;
+  output?: Readonly<{
+    build: (
+      $$PARAM_0$$: MetroServer,
+      $$PARAM_1$$: RequestOptions,
+      $$PARAM_2$$: void | BuildOptions,
+    ) => Promise<{
+      code: string;
+      map: string;
+      assets?: ReadonlyArray<AssetData>;
+    }>;
+    save: (
+      $$PARAM_0$$: {code: string; map: string},
+      $$PARAM_1$$: OutputOptions,
+      $$PARAM_2$$: (logMessage: string) => void,
+    ) => Promise<unknown>;
+  }>;
+  platform?: string;
+  sourceMap?: boolean;
+  sourceMapUrl?: string;
+  customResolverOptions?: CustomResolverOptions;
+  customTransformOptions?: CustomTransformOptions;
+  unstable_transformProfile?: TransformProfile;
+};
+export type RunBuildResult = {
+  code: string;
+  map: string;
+  assets?: ReadonlyArray<AssetData>;
+};
+type BuildCommandOptions = Readonly<{[$$Key$$: string]: unknown}> | null;
+type ServeCommandOptions = Readonly<{[$$Key$$: string]: unknown}> | null;
+type DependenciesCommandOptions = Readonly<{
+  [$$Key$$: string]: unknown;
+}> | null;
+export {Terminal, JsonReporter, TerminalReporter};
+export type {AssetData} from './Assets';
+export type {Reporter, ReportableEvent} from './lib/reporting';
+export type {TerminalReportableEvent} from './lib/TerminalReporter';
+export type {MetroConfig};
+export declare function runMetro(
+  config: InputConfigT,
+  options?: RunMetroOptions,
+): Promise<MetroServer>;
+export {loadConfig, mergeConfig, resolveConfig};
+export declare const createConnectMiddleware: (
+  config: ConfigT,
+  options?: RunMetroOptions,
+) => Promise<MetroMiddleWare>;
+export declare type createConnectMiddleware = typeof createConnectMiddleware;
+export declare const runServer: (
+  config: ConfigT,
+  $$PARAM_1$$?: RunServerOptions,
+) => Promise<RunServerResult>;
+export declare type runServer = typeof runServer;
+export declare const runBuild: (
+  config: ConfigT,
+  $$PARAM_1$$: RunBuildOptions,
+) => Promise<RunBuildResult>;
+export declare type runBuild = typeof runBuild;
+export declare const buildGraph: (
+  config: InputConfigT,
+  $$PARAM_1$$: BuildGraphOptions,
+) => Promise<ReadOnlyGraph>;
+export declare type buildGraph = typeof buildGraph;
+type AttachMetroCLIOptions = {
+  build?: BuildCommandOptions;
+  serve?: ServeCommandOptions;
+  dependencies?: DependenciesCommandOptions;
+};
+export declare const attachMetroCli: (
+  yargs: Yargs,
+  options?: AttachMetroCLIOptions,
+) => Yargs;
+export declare type attachMetroCli = typeof attachMetroCli;
+/**
+ * Backwards-compatibility with CommonJS consumers using interopRequireDefault.
+ * Do not add to this list.
+ *
+ * @deprecated Default import from 'metro' is deprecated, use named exports.
+ */
+declare const $$EXPORT_DEFAULT_DECLARATION$$: {
+  attachMetroCli: typeof attachMetroCli;
+  runServer: typeof runServer;
+  Terminal: typeof Terminal;
+  JsonReporter: typeof JsonReporter;
+  TerminalReporter: typeof TerminalReporter;
+  loadConfig: typeof loadConfig;
+  mergeConfig: typeof mergeConfig;
+  resolveConfig: typeof resolveConfig;
+  createConnectMiddleware: typeof createConnectMiddleware;
+  runBuild: typeof runBuild;
+  buildGraph: typeof buildGraph;
+};
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

package/src/index.flow.js

@@ -79,10 +79,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -102,11 +99,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const DEFAULTS = _Server.default.DEFAULT_BUNDLE_OPTIONS;
 async function getConfig(config) {
@@ -211,7 +204,7 @@ const runServer = async (
       _chalk.default.inverse.yellow.bold(" DEPRECATED "),
       "The `secure`, `secureCert`, and `secureKey` options are now deprecated. " +
         "Please use the `secureServerOptions` object instead to pass options to " +
-        "Metro's https development server.",
+        "Metro's https development server, or `config.server.tls` in Metro's configuration",
     );
   }
   const connect = require("connect");
@@ -230,15 +223,29 @@ const runServer = async (
   }
   serverApp.use(middleware);
   let httpServer;
-  if (secure === true || secureServerOptions != null) {
-    let options = secureServerOptions;
-    if (typeof secureKey === "string" && typeof secureCert === "string") {
-      options = {
-        key: _fs.default.readFileSync(secureKey),
-        cert: _fs.default.readFileSync(secureCert),
-        ...secureServerOptions,
-      };
-    }
+  const { tls } = config.server;
+  if (
+    secure === true ||
+    secureServerOptions != null ||
+    typeof tls === "object"
+  ) {
+    const options = {
+      key:
+        typeof tls === "object"
+          ? tls.key
+          : typeof secureKey === "string"
+            ? _fs.default.readFileSync(secureKey)
+            : undefined,
+      cert:
+        typeof tls === "object"
+          ? tls.cert
+          : typeof secureCert === "string"
+            ? _fs.default.readFileSync(secureCert)
+            : undefined,
+      ca: typeof tls === "object" ? tls.ca : undefined,
+      requestCert: typeof tls === "object" ? tls.requestCert : undefined,
+      ...(secureServerOptions ?? {}),
+    };
     httpServer = _https.default.createServer(options, serverApp);
   } else {
     httpServer = _http.default.createServer(serverApp);

package/src/index.flow.js.flow

@@ -280,7 +280,7 @@ export const runServer = async (
       chalk.inverse.yellow.bold(' DEPRECATED '),
       'The `secure`, `secureCert`, and `secureKey` options are now deprecated. ' +
         'Please use the `secureServerOptions` object instead to pass options to ' +
-        "Metro's https development server.",
+        "Metro's https development server, or `config.server.tls` in Metro's configuration",
     );
   }
   // Lazy require
@@ -307,15 +307,30 @@ export const runServer = async (
 
   let httpServer;
 
-  if (secure === true || secureServerOptions != null) {
-    let options = secureServerOptions;
-    if (typeof secureKey === 'string' && typeof secureCert === 'string') {
-      options = {
-        key: fs.readFileSync(secureKey),
-        cert: fs.readFileSync(secureCert),
-        ...secureServerOptions,
-      };
-    }
+  const {tls} = config.server;
+  if (
+    secure === true ||
+    secureServerOptions != null ||
+    typeof tls === 'object'
+  ) {
+    const options = {
+      key:
+        typeof tls === 'object'
+          ? tls.key
+          : typeof secureKey === 'string'
+            ? fs.readFileSync(secureKey)
+            : undefined,
+      cert:
+        typeof tls === 'object'
+          ? tls.cert
+          : typeof secureCert === 'string'
+            ? fs.readFileSync(secureCert)
+            : undefined,
+      ca: typeof tls === 'object' ? tls.ca : undefined,
+      requestCert: typeof tls === 'object' ? tls.requestCert : undefined,
+      ...(secureServerOptions ?? {}),
+    };
+
     // $FlowFixMe[incompatible-type] 'http' and 'https' Flow types do not match
     httpServer = https.createServer(options, serverApp);
   } else {

package/src/integration_tests/basic_bundle/build-errors/cannot-resolve-import.js

@@ -2,10 +2,6 @@
 
 var _doesNotExist = _interopRequireDefault(require("./does-not-exist"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 global.x = _doesNotExist.default;

package/src/integration_tests/basic_bundle/build-errors/inline-requires-cannot-resolve-import.js

@@ -2,10 +2,6 @@
 
 var _doesNotExist = _interopRequireDefault(require("./does-not-exist"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 global.x = _doesNotExist.default;

package/src/integration_tests/basic_bundle/import-export/index.js

@@ -30,11 +30,7 @@ var _exportPrimitiveDefault = _interopRequireWildcard(
 var _export3 = _interopRequireDefault(require("./export-3"));
 var _export4 = require("./export-4");
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function _interopRequireWildcard(e, t) {
   if ("function" == typeof WeakMap)
@@ -44,10 +40,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {

package/src/integration_tests/execBundle.js

@@ -2,11 +2,7 @@
 
 var _vm = _interopRequireDefault(require("vm"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 module.exports = function execBundle(code, context = {}) {
   if (_vm.default.isContext(context)) {

package/src/lib/BatchProcessor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import {setTimeout} from 'timers';
+
+type ProcessBatch<TItem, TResult> = (
+  batch: Array<TItem>,
+) => Promise<Array<TResult>>;
+type BatchProcessorOptions = {
+  maximumDelayMs: number;
+  maximumItems: number;
+  concurrency: number;
+};
+type QueueItem<TItem, TResult> = {
+  item: TItem;
+  reject: (error: unknown) => unknown;
+  resolve: (result: TResult) => unknown;
+};
+/**
+ * We batch items together trying to minimize their processing, for example as
+ * network queries. For that we wait a small moment before processing a batch.
+ * We limit also the number of items we try to process in a single batch so that
+ * if we have many items pending in a short amount of time, we can start
+ * processing right away.
+ */
+declare class BatchProcessor<TItem, TResult> {
+  _currentProcessCount: number;
+  _options: BatchProcessorOptions;
+  _processBatch: ProcessBatch<TItem, TResult>;
+  _queue: Array<QueueItem<TItem, TResult>>;
+  _timeoutHandle: null | undefined | ReturnType<typeof setTimeout>;
+  constructor(
+    options: BatchProcessorOptions,
+    processBatch: ProcessBatch<TItem, TResult>,
+  );
+  _onBatchFinished(): void;
+  _onBatchResults(
+    jobs: Array<QueueItem<TItem, TResult>>,
+    results: Array<TResult>,
+  ): void;
+  _onBatchError(jobs: Array<QueueItem<TItem, TResult>>, error: unknown): void;
+  _processQueue(): void;
+  _processQueueOnceReady(): void;
+  queue(item: TItem): Promise<TResult>;
+  getQueueLength(): number;
+}
+export default BatchProcessor;