appium 3.4.2 → 3.5.1

package/lib/extension/extension-config.ts

@@ -2,11 +2,9 @@ import type {ExtensionType} from '@appium/types';
 import type {ExtClass, ExtManifest, ExtName, ExtRecord, InstallType} from 'appium/types';
 import type {SchemaObject} from 'ajv';
 import {util, fs, system} from '@appium/support';
-import B from 'bluebird';
-import _ from 'lodash';
 import path from 'node:path';
+import {capitalize, resolveFrom} from '../utils';
 import {pathToFileURL} from 'node:url';
-import resolveFrom from 'resolve-from';
 import {satisfies} from 'semver';
 import {commandClasses} from '../cli/extension';
 import type {
@@ -101,26 +99,29 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extManifest - Parsed extension metadata
    */
   static extDataHasSchema<E extends ExtensionType>(
-    extManifest: ExtManifest<E>
+    extManifest: ExtManifest<E>,
   ): extManifest is ExtManifestWithSchema<E> {
-    return _.isString(extManifest?.schema) || _.isObject(extManifest?.schema);
+    return (
+      typeof extManifest?.schema === 'string' ||
+      (extManifest?.schema !== null && typeof extManifest?.schema === 'object')
+    );
   }
 
   private static async _readExtensionSchema<E extends ExtensionType>(
     appiumHome: string,
     extType: E,
     extName: string,
-    extManifest: ExtManifestWithSchema<E>
+    extManifest: ExtManifestWithSchema<E>,
   ): Promise<SchemaObject | undefined> {
     const {pkgName, schema: argSchemaPath} = extManifest;
     if (!argSchemaPath) {
       throw new TypeError(
-        `No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`
+        `No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`,
       );
     }
     let moduleObject: any;
-    if (_.isString(argSchemaPath)) {
-      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));
+    if (typeof argSchemaPath === 'string') {
+      const schemaPath = await resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));
       moduleObject = require(schemaPath);
     } else {
       moduleObject = argSchemaPath;
@@ -137,7 +138,10 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extName - Extension key as stored in the manifest
    * @param extManifest - Manifest entry for that extension
    */
-  async getProblems(extName: string, extManifest: ExtManifest<ExtType>): Promise<ExtManifestProblem[]> {
+  async getProblems(
+    extName: string,
+    extManifest: ExtManifest<ExtType>,
+  ): Promise<ExtManifestProblem[]> {
     return [
       ...this.getGenericConfigProblems(extManifest, extName),
       ...this.getConfigProblems(extManifest, extName),
@@ -153,7 +157,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extManifest - Manifest entry for that extension
    */
   async getWarnings(extName: string, extManifest: ExtManifest<ExtType>): Promise<string[]> {
-    const [genericConfigWarnings, configWarnings] = await B.all([
+    const [genericConfigWarnings, configWarnings] = await Promise.all([
       this.getGenericConfigWarnings(extManifest, extName),
       this.getConfigWarnings(extManifest, extName),
     ]);
@@ -169,32 +173,32 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    */
   getValidationResultSummaries(
     errorMap: Map<string, ExtManifestProblem[]> = new Map(),
-    warningMap: Map<string, string[]> = new Map()
+    warningMap: Map<string, string[]> = new Map(),
   ): {errorSummaries: string[]; warningSummaries: string[]} {
     const errorSummaries: string[] = [];
     for (const [extName, problems] of errorMap.entries()) {
-      if (_.isEmpty(problems)) {
+      if (util.isEmpty(problems)) {
         continue;
       }
       // remove this extension from the list since it's not valid
       errorSummaries.push(
         `${this.extensionType} "${extName}" had ${util.pluralize(
           'error',
-          problems.length
-        )} and will not be available:`
+          problems.length,
+        )} and will not be available:`,
       );
       for (const problem of problems) {
         errorSummaries.push(
-          `  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`
+          `  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`,
         );
       }
     }
     const warningSummaries: string[] = [];
     for (const [extName, warnings] of warningMap.entries()) {
-      if (_.isEmpty(warnings)) {
+      if (util.isEmpty(warnings)) {
         continue;
       }
-      const extTypeText = _.capitalize(this.extensionType);
+      const extTypeText = capitalize(this.extensionType);
       const problemEnumerationText = util.pluralize('potential problem', warnings.length, true);
       warningSummaries.push(`${extTypeText} "${extName}" has ${problemEnumerationText}: `);
       for (const warning of warnings) {
@@ -216,7 +220,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   async addExtension(
     extName: string,
     extManifest: ExtManifest<ExtType>,
-    {write = true}: ExtensionConfigMutationOpts = {}
+    {write = true}: ExtensionConfigMutationOpts = {},
   ): Promise<void> {
     this.manifest.setExtension(this.extensionType, extName, extManifest);
     if (write) {
@@ -235,7 +239,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   async updateExtension(
     extName: ExtName<ExtType>,
     extManifest: ExtManifest<ExtType>,
-    {write = true}: ExtensionConfigMutationOpts = {}
+    {write = true}: ExtensionConfigMutationOpts = {},
   ): Promise<void> {
     const existing = this.installedExtensions[extName];
     this.manifest.setExtension(this.extensionType, extName as string, {
@@ -256,7 +260,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    */
   async removeExtension(
     extName: ExtName<ExtType>,
-    {write = true}: ExtensionConfigMutationOpts = {}
+    {write = true}: ExtensionConfigMutationOpts = {},
   ): Promise<void> {
     this.manifest.deleteExtension(this.extensionType, extName);
     if (write) {
@@ -269,16 +273,16 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    */
   print(_activeNames?: ExtName<ExtType>[]): void {
     void _activeNames;
-    if (_.isEmpty(this.installedExtensions)) {
+    if (util.isEmpty(this.installedExtensions)) {
       log.info(
         `No ${this.extensionType}s have been installed in ${this.appiumHome}. Use the "appium ${this.extensionType}" ` +
-          'command to install the one(s) you want to use.'
+          'command to install the one(s) you want to use.',
       );
       return;
     }
 
     log.info(`Available ${this.extensionType}s:`);
-    for (const [extName, extManifest] of _.toPairs(this.installedExtensions) as Array<
+    for (const [extName, extManifest] of Object.entries(this.installedExtensions) as Array<
       [string, ExtManifest<ExtType>]
     >) {
       log.info(`  - ${this.extensionDesc(extName, extManifest)}`);
@@ -311,7 +315,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     const MainClass = mod[mainClass];
     if (!MainClass) {
       throw new ReferenceError(
-        `Could not find a class named "${mainClass}" exported by ${this.extensionType} "${extName}"`
+        `Could not find a class named "${mainClass}" exported by ${this.extensionType} "${extName}"`,
       );
     }
     return MainClass;
@@ -330,20 +334,20 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    */
   async readExtensionSchema(
     extName: string,
-    extManifest: ExtManifestWithSchema<ExtType>
+    extManifest: ExtManifestWithSchema<ExtType>,
   ): Promise<SchemaObject | undefined> {
     return await ExtensionConfig._readExtensionSchema(
       this.appiumHome,
       this.extensionType,
       extName,
-      extManifest
+      extManifest,
     );
   }
 
   /** Optional async warnings for this extension kind; override in subclasses when needed. */
   protected async getConfigWarnings(
     _extManifest: ExtManifest<ExtType>,
-    _extName: string
+    _extName: string,
   ): Promise<string[]> {
     void _extManifest;
     void _extName;
@@ -358,8 +362,8 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     const errorMap = new Map<string, ExtManifestProblem[]>();
     const warningMap = new Map<string, string[]>();
 
-    for (const [extName, extManifest] of _.toPairs(exts)) {
-      const [errors, warnings] = await B.all([
+    for (const [extName, extManifest] of Object.entries(exts)) {
+      const [errors, warnings] = await Promise.all([
         this.getProblems(extName, extManifest),
         this.getWarnings(extName, extManifest),
       ]);
@@ -372,26 +376,26 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
 
     const {errorSummaries, warningSummaries} = this.getValidationResultSummaries(
       errorMap,
-      warningMap
+      warningMap,
     );
 
-    if (!_.isEmpty(errorSummaries)) {
+    if (!util.isEmpty(errorSummaries)) {
       log.error(
         `Appium encountered ${util.pluralize('error', errorMap.size, true)} while validating ${
           this.extensionType
-        }s found in manifest ${this.manifestPath}`
+        }s found in manifest ${this.manifestPath}`,
       );
       for (const summary of errorSummaries) {
         log.error(summary);
       }
-    } else if (!_.isEmpty(warningSummaries)) {
+    } else if (!util.isEmpty(warningSummaries)) {
       // only display warnings if there are no errors!
       log.warn(
         `Appium encountered ${util.pluralize(
           'warning',
           warningMap.size,
-          true
-        )} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`
+          true,
+        )} while validating ${this.extensionType}s found in manifest ${this.manifestPath}`,
       );
       for (const summary of warningSummaries) {
         log.warn(summary);
@@ -419,13 +423,13 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    */
   protected async getGenericConfigWarnings(
     extManifest: ExtManifest<ExtType>,
-    extName: string
+    extName: string,
   ): Promise<string[]> {
     const {appiumVersion, installSpec, installType, pkgName} = extManifest;
     const warnings: string[] = [];
 
     const invalidFields: string[] = [];
-    if (!_.isString(installSpec)) {
+    if (typeof installSpec !== 'string') {
       invalidFields.push('installSpec');
     }
 
@@ -433,27 +437,27 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
       invalidFields.push('installType');
     }
 
-    const extTypeText = _.capitalize(this.extensionType);
+    const extTypeText = capitalize(this.extensionType);
 
     if (invalidFields.length) {
       const invalidFieldsEnumerationText = util.pluralize(
         'invalid or missing field',
         invalidFields.length,
-        true
+        true,
       );
       const invalidFieldsText = invalidFields.map((field) => `"${field}"`).join(', ');
 
       warnings.push(
         `${extTypeText} "${extName}" (package \`${pkgName}\`) has ${invalidFieldsEnumerationText} (${invalidFieldsText}) in \`extensions.yaml\`; ` +
-        `this may cause upgrades done via the \`appium\` CLI tool to fail. Please reinstall with \`appium ${this.extensionType} uninstall ` +
-        `${extName}\` and \`appium ${this.extensionType} install ${extName}\` to attempt a fix.`
+          `this may cause upgrades done via the \`appium\` CLI tool to fail. Please reinstall with \`appium ${this.extensionType} uninstall ` +
+          `${extName}\` and \`appium ${this.extensionType} install ${extName}\` to attempt a fix.`,
       );
     }
 
     const createPeerWarning = (reason: string): string =>
       `${extTypeText} "${extName}" (package \`${pkgName}\`) may be incompatible with the current version of Appium (v${APPIUM_VER}) due to ${reason}`;
 
-    if (_.isString(appiumVersion) && !satisfies(APPIUM_VER, appiumVersion)) {
+    if (typeof appiumVersion === 'string' && !satisfies(APPIUM_VER, appiumVersion)) {
       const listData = await this.getListData();
       const extListData = listData[extName] as ExtensionListData<ExtType> | undefined;
       if (extListData?.installed) {
@@ -461,33 +465,33 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
         if (!upToDate && updateVersion) {
           warnings.push(
             createPeerWarning(
-              `its peer dependency on Appium ${appiumVersion}. Try to upgrade \`${pkgName}\` to v${updateVersion} or newer.`
-            )
+              `its peer dependency on Appium ${appiumVersion}. Try to upgrade \`${pkgName}\` to v${updateVersion} or newer.`,
+            ),
           );
         } else {
           warnings.push(
             createPeerWarning(
-              `its peer dependency on Appium ${appiumVersion}. Please install a compatible version of the ${_.toLower(extTypeText)}.`
-            )
+              `its peer dependency on Appium ${appiumVersion}. Please install a compatible version of the ${extTypeText.toLowerCase()}.`,
+            ),
           );
         }
       }
-    } else if (!_.isString(appiumVersion)) {
+    } else if (typeof appiumVersion !== 'string') {
       const listData = await this.getListData();
       const extListData = listData[extName] as InstalledExtensionListData<ExtType> | undefined;
       if (!extListData?.upToDate && extListData?.updateVersion) {
         warnings.push(
           createPeerWarning(
             `an invalid or missing peer dependency on Appium. A newer version of \`${pkgName}\` is available; ` +
-            `please attempt to upgrade "${extName}" to v${extListData.updateVersion} or newer.`
-          )
+              `please attempt to upgrade "${extName}" to v${extListData.updateVersion} or newer.`,
+          ),
         );
       } else {
         warnings.push(
           createPeerWarning(
             `an invalid or missing peer dependency on Appium. ` +
-            `Please ask the developer of \`${pkgName}\` to add a peer dependency on \`^appium@${APPIUM_VER}\`.`
-          )
+              `Please ask the developer of \`${pkgName}\` to add a peer dependency on \`^appium@${APPIUM_VER}\`.`,
+          ),
         );
       }
     }
@@ -497,12 +501,12 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   /** Validates and registers extension CLI/config schema when the manifest defines a `schema` field. */
   protected async getSchemaProblems(
     extManifest: ExtManifest<ExtType>,
-    extName: string
+    extName: string,
   ): Promise<ExtManifestProblem[]> {
     const problems: ExtManifestProblem[] = [];
     const {schema: argSchemaPath} = extManifest;
     if (ExtensionConfig.extDataHasSchema(extManifest)) {
-      if (_.isString(argSchemaPath)) {
+      if (typeof argSchemaPath === 'string') {
         if (isAllowedSchemaFileExtension(argSchemaPath)) {
           try {
             await this.readExtensionSchema(extName, extManifest);
@@ -520,7 +524,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
             val: argSchemaPath,
           });
         }
-      } else if (_.isPlainObject(argSchemaPath)) {
+      } else if (util.isPlainObject(argSchemaPath)) {
         try {
           await this.readExtensionSchema(extName, extManifest);
         } catch (err: any) {
@@ -542,27 +546,27 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   /** Blocking issues for required manifest fields shared by all extensions (version, package name, main class). */
   protected getGenericConfigProblems(
     extManifest: ExtManifest<ExtType>,
-    extName: string
+    extName: string,
   ): ExtManifestProblem[] {
     void extName;
     const {version, pkgName, mainClass} = extManifest;
     const problems: ExtManifestProblem[] = [];
 
-    if (!_.isString(version)) {
+    if (typeof version !== 'string') {
       problems.push({
         err: `Invalid or missing \`version\` field in my \`package.json\` and/or \`extensions.yaml\` (must be a string)`,
         val: version,
       });
     }
 
-    if (!_.isString(pkgName)) {
+    if (typeof pkgName !== 'string') {
       problems.push({
         err: `Invalid or missing \`name\` field in my \`package.json\` and/or \`extensions.yaml\` (must be a string)`,
         val: pkgName,
       });
     }
 
-    if (!_.isString(mainClass)) {
+    if (typeof mainClass !== 'string') {
       problems.push({
         err: `Invalid or missing \`appium.mainClass\` field in my \`package.json\` and/or \`mainClass\` field in \`extensions.yaml\` (must be a string)`,
         val: mainClass,
@@ -575,7 +579,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
   /** Driver- or plugin-specific blocking validation; override in subclasses when needed. */
   protected getConfigProblems(
     _extManifest: ExtManifest<ExtType>,
-    _extName: string
+    _extName: string,
   ): ExtManifestProblem[] {
     void _extManifest;
     void _extName;
@@ -592,7 +596,7 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
     } catch (e: any) {
       throw new ReferenceError(
         `Could not read the ${this.extensionType} manifest at ${packageJsonPath}: ${e.message}`,
-        {cause: e}
+        {cause: e},
       );
     }
     let entryPointRelativePath: string | undefined;
@@ -600,18 +604,19 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
       if (extensionManifest.type === 'module' && extensionManifest.exports) {
         entryPointRelativePath = resolveEsmEntryPoint(extensionManifest.exports);
       }
-      entryPointRelativePath = entryPointRelativePath ?? extensionManifest.main ?? DEFAULT_ENTRY_POINT;
+      entryPointRelativePath =
+        entryPointRelativePath ?? extensionManifest.main ?? DEFAULT_ENTRY_POINT;
     } catch (e: any) {
       throw new ReferenceError(
         `Could not find the ${this.extensionType} installed at ${moduleRoot}: ${e.message}`,
-        {cause: e}
+        {cause: e},
       );
     }
     const entryPointFullPath = path.resolve(moduleRoot, entryPointRelativePath as string);
-    if (!await fs.exists(entryPointFullPath)) {
+    if (!(await fs.exists(entryPointFullPath))) {
       throw new ReferenceError(
         `Cannot find a valid ${this.extensionType} main entry point in '${packageJsonPath}'. ` +
-        `Assumed entry point: '${entryPointFullPath}'`
+          `Assumed entry point: '${entryPointFullPath}'`,
       );
     }
     // note: this will only reload the entry point
@@ -628,8 +633,10 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
    * @param extName - Manifest key
    * @param extManifest - Entry used for version and kind-specific labels
    */
-  public abstract extensionDesc(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType>): string;
-
+  public abstract extensionDesc(
+    extName: ExtName<ExtType>,
+    extManifest: ExtManifest<ExtType>,
+  ): string;
 }
 
 /**
@@ -638,10 +645,10 @@ export abstract class ExtensionConfig<ExtType extends ExtensionType> {
  * @param exportsValue - `package.json` `exports` value or nested fragment
  */
 export function resolveEsmEntryPoint(exportsValue: unknown): string | undefined {
-  if (_.isString(exportsValue) && exportsValue) {
+  if (typeof exportsValue === 'string' && exportsValue) {
     return exportsValue;
   }
-  if (!_.isPlainObject(exportsValue)) {
+  if (!util.isPlainObject(exportsValue)) {
     return;
   }
 

package/lib/extension/index.ts

@@ -1,12 +1,12 @@
-import _ from 'lodash';
-import B from 'bluebird';
+import {util, timing} from '@appium/support';
+import {asyncmap} from 'asyncbox';
 import type {DriverClass, ExtensionType, PluginClass} from '@appium/types';
 import type {ExtClass} from 'appium/types';
 import {USE_ALL_PLUGINS} from '../constants';
 import {log} from '../logger';
 import {DriverConfig} from './driver-config';
 import {Manifest} from './manifest';
-import {timing} from '@appium/support';
+import {zip} from '../utils';
 import {PluginConfig} from './plugin-config';
 
 export type ExtensionConfigs = {
@@ -32,7 +32,7 @@ export async function loadExtensions(appiumHome: string): Promise<ExtensionConfi
   const driverConfig = DriverConfig.getInstance(manifest) ?? DriverConfig.create(manifest);
   const pluginConfig = PluginConfig.getInstance(manifest) ?? PluginConfig.create(manifest);
 
-  await B.all([driverConfig.validate(), pluginConfig.validate()]);
+  await Promise.all([driverConfig.validate(), pluginConfig.validate()]);
   return {driverConfig, pluginConfig};
 }
 
@@ -45,31 +45,40 @@ export async function loadExtensions(appiumHome: string): Promise<ExtensionConfi
 export async function getActivePlugins(
   pluginConfig: PluginConfig,
   maxParallelImports: number,
-  usePlugins: string[] = []
+  usePlugins: string[] = [],
 ): Promise<PluginNameMap> {
-  if (_.isEmpty(usePlugins)) {
+  if (util.isEmpty(usePlugins)) {
     return new Map();
   }
 
   let filteredPluginNames: string[] = [];
   if (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS) {
-    filteredPluginNames = _.keys(pluginConfig.installedExtensions);
+    filteredPluginNames = Object.keys(pluginConfig.installedExtensions);
   } else {
     for (const pluginName of usePlugins) {
       if (pluginName in pluginConfig.installedExtensions) {
         filteredPluginNames.push(pluginName);
       } else if (pluginName === USE_ALL_PLUGINS) {
-        throw new Error(`The reserved plugin name '${pluginName}' cannot be combined with other names.`);
+        throw new Error(
+          `The reserved plugin name '${pluginName}' cannot be combined with other names.`,
+        );
       } else {
-        const suffix = _.isEmpty(pluginConfig.installedExtensions)
+        const suffix = util.isEmpty(pluginConfig.installedExtensions)
           ? `You don't have any plugins installed yet.`
-          : `Only the following ${_.size(pluginConfig.installedExtensions) === 1 ? `plugin is` : `plugins are`} ` +
-            `available: ${_.keys(pluginConfig.installedExtensions)}`;
-        throw new Error(`Could not load the plugin '${pluginName}' because it is not installed. ${suffix}`);
+          : `Only the following ${Object.keys(pluginConfig.installedExtensions).length === 1 ? `plugin is` : `plugins are`} ` +
+            `available: ${Object.keys(pluginConfig.installedExtensions)}`;
+        throw new Error(
+          `Could not load the plugin '${pluginName}' because it is not installed. ${suffix}`,
+        );
       }
     }
   }
-  const pairs = await importExtensions('plugin', pluginConfig, filteredPluginNames, maxParallelImports);
+  const pairs = await importExtensions(
+    'plugin',
+    pluginConfig,
+    filteredPluginNames,
+    maxParallelImports,
+  );
   return new Map(pairs as Array<[PluginClass, string]>);
 }
 
@@ -81,63 +90,63 @@ export async function getActivePlugins(
 export async function getActiveDrivers(
   driverConfig: DriverConfig,
   maxParallelImports: number,
-  useDrivers: string[] = []
+  useDrivers: string[] = [],
 ): Promise<DriverNameMap> {
   let filteredDriverNames: string[] = [];
-  if (_.isEmpty(useDrivers)) {
-    filteredDriverNames = _.keys(driverConfig.installedExtensions);
+  if (util.isEmpty(useDrivers)) {
+    filteredDriverNames = Object.keys(driverConfig.installedExtensions);
   } else {
     for (const driverName of useDrivers) {
       if (driverName in driverConfig.installedExtensions) {
         filteredDriverNames.push(driverName);
       } else {
-        const suffix = _.isEmpty(driverConfig.installedExtensions)
+        const suffix = util.isEmpty(driverConfig.installedExtensions)
           ? `You don't have any drivers installed yet.`
-          : `Only the following ${_.size(driverConfig.installedExtensions) === 1 ? `driver is` : `drivers are`} ` +
-            `available: ${_.keys(driverConfig.installedExtensions)}`;
-        throw new Error(`Could not load the driver '${driverName}' because it is not installed. ${suffix}`);
+          : `Only the following ${Object.keys(driverConfig.installedExtensions).length === 1 ? `driver is` : `drivers are`} ` +
+            `available: ${Object.keys(driverConfig.installedExtensions)}`;
+        throw new Error(
+          `Could not load the driver '${driverName}' because it is not installed. ${suffix}`,
+        );
       }
     }
   }
-  const pairs = await importExtensions('driver', driverConfig, filteredDriverNames, maxParallelImports);
+  const pairs = await importExtensions(
+    'driver',
+    driverConfig,
+    filteredDriverNames,
+    maxParallelImports,
+  );
   return new Map(pairs as Array<[DriverClass, string]>);
 }
 
-
 async function importExtensions(
   extType: 'driver' | 'plugin',
   config: DriverConfig | PluginConfig,
   extNames: string[],
-  asyncImportChunkSize: number
+  asyncImportChunkSize: number,
 ): Promise<Array<[ExtClass<ExtensionType>, string]>> {
-  const allPromises: Array<B<ExtClass<ExtensionType> | undefined>> = [];
-  const activePromisesChunk: Array<B<ExtClass<ExtensionType> | undefined>> = [];
-  for (const extName of extNames) {
-    _.remove(activePromisesChunk, (p) => p.isFulfilled());
-    if (activePromisesChunk.length >= asyncImportChunkSize) {
-      await B.any(activePromisesChunk);
-    }
-    const promise = B.resolve(
-      (async () => {
-        log.info(`Attempting to load ${extType} ${extName}...`);
-        const timer = new timing.Timer().start();
-        try {
-          const extClass = await config.requireAsync(extName as never);
-          log.debug(`${extClass.name} has been successfully loaded in ${timer.getDuration().asSeconds.toFixed(3)}s`);
-          return extClass as ExtClass<ExtensionType>;
-        } catch (err: any) {
-          log.error(
-            `Could not load ${extType} '${extName}', so it will not be available. Error ` +
-              `in loading the ${extType} was: ${err.message}`
-          );
-          log.debug(err.stack);
-        }
-      })()
-    );
-    activePromisesChunk.push(promise);
-    allPromises.push(promise);
-  }
-  return _.zip(await B.all(allPromises), extNames).filter(([extClass]) => Boolean(extClass)) as Array<
+  const extClasses = await asyncmap(
+    extNames,
+    async (extName) => {
+      log.info(`Attempting to load ${extType} ${extName}...`);
+      const timer = new timing.Timer().start();
+      try {
+        const extClass = await config.requireAsync(extName as never);
+        log.debug(
+          `${extClass.name} has been successfully loaded in ${timer.getDuration().asSeconds.toFixed(3)}s`,
+        );
+        return extClass as ExtClass<ExtensionType>;
+      } catch (err: any) {
+        log.error(
+          `Could not load ${extType} '${extName}', so it will not be available. Error ` +
+            `in loading the ${extType} was: ${err.message}`,
+        );
+        log.debug(err.stack);
+      }
+    },
+    {concurrency: asyncImportChunkSize},
+  );
+  return zip(extClasses, extNames).filter(([extClass]) => Boolean(extClass)) as Array<
     [ExtClass<ExtensionType>, string]
   >;
 }