appium 2.0.0-beta.35 → 2.0.0-beta.39

package/build/lib/extension/extension-config.js

@@ -11,10 +11,20 @@ require("source-map-support/register");
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
 var _path = _interopRequireDefault(require("path"));
 
 var _resolveFrom = _interopRequireDefault(require("resolve-from"));
 
+var _semver = require("semver");
+
+var _support = require("@appium/support");
+
+var _extension = require("../cli/extension");
+
+var _config = require("../config");
+
 var _logger = _interopRequireDefault(require("../logger"));
 
 var _schema = require("../schema/schema");
@@ -36,13 +46,12 @@ class ExtensionConfig {
   installedExtensions;
   log;
   manifest;
+  _listDataCache;
 
-  constructor(extensionType, manifest, logFn) {
-    const logger = _lodash.default.isFunction(logFn) ? logFn : _logger.default.error.bind(_logger.default);
+  constructor(extensionType, manifest) {
     this.extensionType = extensionType;
     this.configKey = `${extensionType}s`;
     this.installedExtensions = manifest.getExtensionData(extensionType);
-    this.log = logger;
     this.manifest = manifest;
   }
 
@@ -54,50 +63,185 @@ class ExtensionConfig {
     return this.manifest.appiumHome;
   }
 
-  validate(exts) {
-    const foundProblems = {};
+  getProblems(extName, extManifest) {
+    return [...this.getGenericConfigProblems(extManifest, extName), ...this.getConfigProblems(extManifest, extName), ...this.getSchemaProblems(extManifest, extName)];
+  }
 
-    for (const [extName, extData] of _lodash.default.toPairs(exts)) {
-      foundProblems[extName] = [...this.getGenericConfigProblems(extData, extName), ...this.getConfigProblems(extData), ...this.getSchemaProblems(extData, extName)];
-    }
+  async getWarnings(extName, extManifest) {
+    const [genericConfigWarnings, configWarnings] = await _bluebird.default.all([this.getGenericConfigWarnings(extManifest, extName), this.getConfigWarnings(extManifest, extName)]);
+    return [...genericConfigWarnings, ...configWarnings];
+  }
+
+  async getConfigWarnings(extManifest, extName) {
+    return [];
+  }
 
-    const problemSummaries = [];
+  getValidationResultSummaries(errorMap = new Map(), warningMap = new Map()) {
+    const errorSummaries = [];
 
-    for (const [extName, problems] of _lodash.default.toPairs(foundProblems)) {
+    for (const [extName, problems] of errorMap.entries()) {
       if (_lodash.default.isEmpty(problems)) {
         continue;
       }
 
-      delete exts[extName];
-      problemSummaries.push(`${this.extensionType} ${extName} had errors and will not ` + `be available. Errors:`);
+      errorSummaries.push(`${this.extensionType} "${extName}" had ${_support.util.pluralize('error', problems.length)} and will not be available:`);
 
       for (const problem of problems) {
-        problemSummaries.push(`  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`);
+        errorSummaries.push(`  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`);
+      }
+    }
+
+    const warningSummaries = [];
+
+    for (const [extName, warnings] of warningMap.entries()) {
+      if (_lodash.default.isEmpty(warnings)) {
+        continue;
+      }
+
+      const extTypeText = _lodash.default.capitalize(this.extensionType);
+
+      const problemEnumerationText = _support.util.pluralize('potential problem', warnings.length, true);
+
+      warningSummaries.push(`${extTypeText} "${extName}" has ${problemEnumerationText}: `);
+
+      for (const warning of warnings) {
+        warningSummaries.push(`  - ${warning}`);
       }
     }
 
-    if (!_lodash.default.isEmpty(problemSummaries)) {
-      this.log(`Appium encountered one or more errors while validating ` + `the ${this.configKey} extension file (${this.manifestPath}):`);
+    return {
+      errorSummaries,
+      warningSummaries
+    };
+  }
+
+  async _validate(exts) {
+    const errorMap = new Map();
+    const warningMap = new Map();
 
-      for (const summary of problemSummaries) {
-        this.log(summary);
+    for (const [extName, extManifest] of _lodash.default.toPairs(exts)) {
+      const [errors, warnings] = await _bluebird.default.all([this.getProblems(extName, extManifest), this.getWarnings(extName, extManifest)]);
+
+      if (errors.length) {
+        delete exts[extName];
+      }
+
+      errorMap.set(extName, errors);
+      warningMap.set(extName, warnings);
+    }
+
+    const {
+      errorSummaries,
+      warningSummaries
+    } = this.getValidationResultSummaries(errorMap, warningMap);
+
+    if (!_lodash.default.isEmpty(errorSummaries)) {
+      _logger.default.error(`Appium encountered ${_support.util.pluralize('error', errorSummaries.length, true)} while validating ${this.configKey} found in manifest ${this.manifestPath}`);
+
+      for (const summary of errorSummaries) {
+        _logger.default.error(summary);
+      }
+    } else {
+      if (!_lodash.default.isEmpty(warningSummaries)) {
+        _logger.default.warn(`Appium encountered ${_support.util.pluralize('warning', warningSummaries.length, true)} while validating ${this.configKey} found in manifest ${this.manifestPath}`);
+
+        for (const summary of warningSummaries) {
+          _logger.default.warn(summary);
+        }
       }
     }
 
     return exts;
   }
 
-  getSchemaProblems(extData, extName) {
+  async getListData() {
+    if (this._listDataCache) {
+      return this._listDataCache;
+    }
+
+    const CommandClass = _extension.commandClasses[this.extensionType];
+    const cmd = new CommandClass({
+      config: this,
+      json: true
+    });
+    const listData = await cmd.list({
+      showInstalled: true,
+      showUpdates: true
+    });
+    this._listDataCache = listData;
+    return listData;
+  }
+
+  async getGenericConfigWarnings(extManifest, extName) {
+    const {
+      appiumVersion,
+      installSpec,
+      installType,
+      pkgName
+    } = extManifest;
+    const warnings = [];
+    const invalidFields = [];
+
+    if (!_lodash.default.isString(installSpec)) {
+      invalidFields.push('installSpec');
+    }
+
+    if (!INSTALL_TYPES.has(installType)) {
+      invalidFields.push('installType');
+    }
+
+    const extTypeText = _lodash.default.capitalize(this.extensionType);
+
+    if (invalidFields.length) {
+      const invalidFieldsEnumerationText = _support.util.pluralize('invalid or missing field', invalidFields.length, 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.`);
+    }
+
+    const createPeerWarning = reason => `${extTypeText} "${extName}" (package \`${pkgName}\`) may be incompatible with the current version of Appium (v${_config.APPIUM_VER}) due to ${reason}`;
+
+    if (_lodash.default.isString(appiumVersion) && !(0, _semver.satisfies)(_config.APPIUM_VER, appiumVersion)) {
+      const listData = await this.getListData();
+      const extListData = listData[extName];
+
+      if (extListData !== null && extListData !== void 0 && extListData.installed) {
+        const {
+          updateVersion,
+          upToDate
+        } = extListData;
+
+        if (!upToDate) {
+          warnings.push(createPeerWarning(`its peer dependency on older Appium v${appiumVersion}. Please upgrade \`${pkgName}\` to v${updateVersion} or newer.`));
+        } else {
+          warnings.push(createPeerWarning(`its peer dependency on older Appium v${appiumVersion}. Please ask the developer of \`${pkgName}\` to update the peer dependency on Appium to v${_config.APPIUM_VER}.`));
+        }
+      }
+    } else if (!_lodash.default.isString(appiumVersion)) {
+      const listData = await this.getListData();
+      const extListData = listData[extName];
+
+      if (!(extListData !== null && extListData !== void 0 && extListData.upToDate) && extListData !== null && extListData !== void 0 && 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.`));
+      } 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@${_config.APPIUM_VER}\`.`));
+      }
+    }
+
+    return warnings;
+  }
+
+  getSchemaProblems(extManifest, extName) {
     const problems = [];
     const {
       schema: argSchemaPath
-    } = extData;
+    } = extManifest;
 
-    if (ExtensionConfig.extDataHasSchema(extData)) {
+    if (ExtensionConfig.extDataHasSchema(extManifest)) {
       if (_lodash.default.isString(argSchemaPath)) {
         if ((0, _schema.isAllowedSchemaFileExtension)(argSchemaPath)) {
           try {
-            this.readExtensionSchema(extName, extData);
+            this.readExtensionSchema(extName, extManifest);
           } catch (err) {
             problems.push({
               err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,
@@ -112,7 +256,7 @@ class ExtensionConfig {
         }
       } else if (_lodash.default.isPlainObject(argSchemaPath)) {
         try {
-          this.readExtensionSchema(extName, extData);
+          this.readExtensionSchema(extName, extManifest);
         } catch (err) {
           problems.push({
             err: `Unable to register embedded schema; ${err.message}`,
@@ -130,47 +274,31 @@ class ExtensionConfig {
     return problems;
   }
 
-  getGenericConfigProblems(extData, extName) {
+  getGenericConfigProblems(extManifest, extName) {
     const {
       version,
       pkgName,
-      installSpec,
-      installType,
       mainClass
-    } = extData;
+    } = extManifest;
     const problems = [];
 
     if (!_lodash.default.isString(version)) {
       problems.push({
-        err: 'Missing or incorrect version',
+        err: `Invalid or missing \`version\` field in my \`package.json\` and/or \`extensions.yaml\` (must be a string)`,
         val: version
       });
     }
 
     if (!_lodash.default.isString(pkgName)) {
       problems.push({
-        err: 'Missing or incorrect NPM package name',
+        err: `Invalid or missing \`name\` field in my \`package.json\` and/or \`extensions.yaml\` (must be a string)`,
         val: pkgName
       });
     }
 
-    if (!_lodash.default.isString(installSpec)) {
-      problems.push({
-        err: 'Missing or incorrect installation spec',
-        val: installSpec
-      });
-    }
-
-    if (!INSTALL_TYPES.has(installType)) {
-      problems.push({
-        err: 'Missing or incorrect install type',
-        val: installType
-      });
-    }
-
     if (!_lodash.default.isString(mainClass)) {
       problems.push({
-        err: 'Missing or incorrect driver class name',
+        err: `Invalid or missing \`appium.mainClass\` field in my \`package.json\` and/or \`mainClass\` field in \`extensions.yaml\` (must be a string)`,
         val: mainClass
       });
     }
@@ -178,25 +306,25 @@ class ExtensionConfig {
     return problems;
   }
 
-  getConfigProblems(extData) {
+  getConfigProblems(extManifest, extName) {
     return [];
   }
 
-  async addExtension(extName, extData, {
+  async addExtension(extName, extManifest, {
     write = true
   } = {}) {
-    this.manifest.addExtension(this.extensionType, extName, extData);
+    this.manifest.addExtension(this.extensionType, extName, extManifest);
 
     if (write) {
       await this.manifest.write();
     }
   }
 
-  async updateExtension(extName, extData, {
+  async updateExtension(extName, extManifest, {
     write = true
   } = {}) {
     this.installedExtensions[extName] = { ...this.installedExtensions[extName],
-      ...extData
+      ...extManifest
     };
 
     if (write) {
@@ -223,12 +351,12 @@ class ExtensionConfig {
 
     _logger.default.info(`Available ${this.configKey}:`);
 
-    for (const [extName, extData] of _lodash.default.toPairs(this.installedExtensions)) {
-      _logger.default.info(`  - ${this.extensionDesc(extName, extData)}`);
+    for (const [extName, extManifest] of _lodash.default.toPairs(this.installedExtensions)) {
+      _logger.default.info(`  - ${this.extensionDesc(extName, extManifest)}`);
     }
   }
 
-  extensionDesc(extName, extData) {
+  extensionDesc(extName, extManifest) {
     throw new Error('This must be implemented in a subclass');
   }
 
@@ -241,8 +369,13 @@ class ExtensionConfig {
       mainClass
     } = this.installedExtensions[extName];
     const reqPath = this.getInstallPath(extName);
+    let reqResolved;
 
-    const reqResolved = require.resolve(reqPath);
+    try {
+      reqResolved = require.resolve(reqPath);
+    } catch (err) {
+      throw new ReferenceError(`Could not find a ${this.extensionType} installed at ${reqPath}`);
+    }
 
     if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {
       _logger.default.debug(`Removing ${reqResolved} from require cache`);
@@ -252,18 +385,24 @@ class ExtensionConfig {
 
     _logger.default.debug(`Requiring ${this.extensionType} at ${reqPath}`);
 
-    return require(reqPath)[mainClass];
+    const MainClass = require(reqPath)[mainClass];
+
+    if (!MainClass) {
+      throw new ReferenceError(`Could not find a class named "${mainClass}" exported by ${this.extensionType} "${extName}"`);
+    }
+
+    return MainClass;
   }
 
   isInstalled(extName) {
     return _lodash.default.includes(Object.keys(this.installedExtensions), extName);
   }
 
-  static _readExtensionSchema(appiumHome, extType, extName, extData) {
+  static _readExtensionSchema(appiumHome, extType, extName, extManifest) {
     const {
       pkgName,
       schema: argSchemaPath
-    } = extData;
+    } = extManifest;
 
     if (!argSchemaPath) {
       throw new TypeError(`No \`schema\` property found in config for ${extType} ${pkgName} -- why is this function being called?`);
@@ -283,15 +422,15 @@ class ExtensionConfig {
     return schema;
   }
 
-  static extDataHasSchema(extData) {
-    return _lodash.default.isString(extData === null || extData === void 0 ? void 0 : extData.schema) || _lodash.default.isObject(extData === null || extData === void 0 ? void 0 : extData.schema);
+  static extDataHasSchema(extManifest) {
+    return _lodash.default.isString(extManifest === null || extManifest === void 0 ? void 0 : extManifest.schema) || _lodash.default.isObject(extManifest === null || extManifest === void 0 ? void 0 : extManifest.schema);
   }
 
-  readExtensionSchema(extName, extData) {
-    return ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extData);
+  readExtensionSchema(extName, extManifest) {
+    return ExtensionConfig._readExtensionSchema(this.appiumHome, this.extensionType, extName, extManifest);
   }
 
 }
 
 exports.ExtensionConfig = ExtensionConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["INSTALL_TYPE_NPM","INSTALL_TYPE_LOCAL","INSTALL_TYPE_GITHUB","INSTALL_TYPE_GIT","INSTALL_TYPES","Set","ExtensionConfig","extensionType","configKey","installedExtensions","log","manifest","constructor","logFn","logger","_","isFunction","error","bind","getExtensionData","manifestPath","appiumHome","validate","exts","foundProblems","extName","extData","toPairs","getGenericConfigProblems","getConfigProblems","getSchemaProblems","problemSummaries","problems","isEmpty","push","problem","err","JSON","stringify","val","summary","schema","argSchemaPath","extDataHasSchema","isString","readExtensionSchema","message","ALLOWED_SCHEMA_EXTENSIONS","join","isPlainObject","version","pkgName","installSpec","installType","mainClass","has","addExtension","write","updateExtension","removeExtension","print","activeNames","info","extensionDesc","Error","getInstallPath","path","require","reqPath","reqResolved","resolve","process","env","APPIUM_RELOAD_EXTENSIONS","cache","debug","isInstalled","includes","Object","keys","_readExtensionSchema","extType","TypeError","moduleObject","schemaPath","__esModule","default","isObject"],"sources":["../../../lib/extension/extension-config.js"],"sourcesContent":["\nimport _ from 'lodash';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\nimport log from '../logger';\nimport {\n  ALLOWED_SCHEMA_EXTENSIONS,\n  isAllowedSchemaFileExtension,\n  registerSchema,\n} from '../schema/schema';\n\nconst INSTALL_TYPE_NPM = 'npm';\nconst INSTALL_TYPE_LOCAL = 'local';\nconst INSTALL_TYPE_GITHUB = 'github';\nconst INSTALL_TYPE_GIT = 'git';\n\n/** @type {Set<InstallType>} */\nconst INSTALL_TYPES = new Set([\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_NPM,\n]);\n\n/**\n * This class is abstract. It should not be instantiated directly.\n *\n * Subclasses should provide the generic parameter to implement.\n * @template {ExtensionType} ExtType\n */\nexport class ExtensionConfig {\n  /** @type {ExtType} */\n  extensionType;\n\n  /** @type {`${ExtType}s`} */\n  configKey;\n\n  /** @type {ExtRecord<ExtType>} */\n  installedExtensions;\n\n  /** @type {ExtensionLogFn} */\n  log;\n\n  /** @type {Manifest} */\n  manifest;\n\n  /**\n   * @protected\n   * @param {ExtType} extensionType - Type of extension\n   * @param {Manifest} manifest - `Manifest` instance\n   * @param {ExtensionLogFn} [logFn]\n   */\n  constructor (extensionType, manifest, logFn) {\n    const logger = _.isFunction(logFn) ? logFn : log.error.bind(log);\n    this.extensionType = extensionType;\n    this.configKey = `${extensionType}s`;\n    this.installedExtensions = manifest.getExtensionData(extensionType);\n    this.log = logger;\n    this.manifest = manifest;\n  }\n\n  get manifestPath () {\n    return this.manifest.manifestPath;\n  }\n\n  get appiumHome () {\n    return this.manifest.appiumHome;\n  }\n\n  /**\n   * Checks extensions for problems\n   * @param {ExtRecord<ExtType>} exts - Extension data\n   */\n  validate (exts) {\n    const foundProblems =\n      /** @type {Record<ExtName<ExtType>,Problem[]>} */ ({});\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[ExtName<ExtType>, ExtManifest<ExtType>][]} */ (\n        _.toPairs(exts)\n      )) {\n      foundProblems[extName] = [\n        ...this.getGenericConfigProblems(extData, extName),\n        ...this.getConfigProblems(extData),\n        ...this.getSchemaProblems(extData, extName),\n      ];\n    }\n\n    const problemSummaries = [];\n    for (const [extName, problems] of _.toPairs(foundProblems)) {\n      if (_.isEmpty(problems)) {\n        continue;\n      }\n      // remove this extension from the list since it's not valid\n      delete exts[extName];\n      problemSummaries.push(\n        `${this.extensionType} ${extName} had errors and will not ` +\n          `be available. Errors:`,\n      );\n      for (const problem of problems) {\n        problemSummaries.push(\n          `  - ${problem.err} (Actual value: ` +\n            `${JSON.stringify(problem.val)})`,\n        );\n      }\n    }\n\n    if (!_.isEmpty(problemSummaries)) {\n      this.log(\n        `Appium encountered one or more errors while validating ` +\n          `the ${this.configKey} extension file (${this.manifestPath}):`,\n      );\n      for (const summary of problemSummaries) {\n        this.log(summary);\n      }\n    }\n\n    return exts;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  getSchemaProblems (extData, extName) {\n    const problems = [];\n    const {schema: argSchemaPath} = extData;\n    if (ExtensionConfig.extDataHasSchema(extData)) {\n      if (_.isString(argSchemaPath)) {\n        if (isAllowedSchemaFileExtension(argSchemaPath)) {\n          try {\n            this.readExtensionSchema(extName, extData);\n          } catch (err) {\n            problems.push({\n              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,\n              val: argSchemaPath,\n            });\n          }\n        } else {\n          problems.push({\n            err: `Schema file has unsupported extension. Allowed: ${[\n              ...ALLOWED_SCHEMA_EXTENSIONS,\n            ].join(', ')}`,\n            val: argSchemaPath,\n          });\n        }\n      } else if (_.isPlainObject(argSchemaPath)) {\n        try {\n          this.readExtensionSchema(extName, extData);\n        } catch (err) {\n          problems.push({\n            err: `Unable to register embedded schema; ${err.message}`,\n            val: argSchemaPath,\n          });\n        }\n      } else {\n        problems.push({\n          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n          val: argSchemaPath,\n        });\n      }\n    }\n    return problems;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getGenericConfigProblems (extData, extName) {\n    const {version, pkgName, installSpec, installType, mainClass} =\n      extData;\n    const problems = [];\n\n    if (!_.isString(version)) {\n      problems.push({err: 'Missing or incorrect version', val: version});\n    }\n\n    if (!_.isString(pkgName)) {\n      problems.push({\n        err: 'Missing or incorrect NPM package name',\n        val: pkgName,\n      });\n    }\n\n    if (!_.isString(installSpec)) {\n      problems.push({\n        err: 'Missing or incorrect installation spec',\n        val: installSpec,\n      });\n    }\n\n    if (!INSTALL_TYPES.has(installType)) {\n      problems.push({\n        err: 'Missing or incorrect install type',\n        val: installType,\n      });\n    }\n\n    if (!_.isString(mainClass)) {\n      problems.push({\n        err: 'Missing or incorrect driver class name',\n        val: mainClass,\n      });\n    }\n\n    return problems;\n  }\n\n  /**\n   * @abstract\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getConfigProblems (extData) {\n    // shoud override this method if special validation is necessary for this extension type\n    return [];\n  }\n\n  /**\n   * @param {string} extName\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async addExtension (extName, extData, {write = true} = {}) {\n    this.manifest.addExtension(this.extensionType, extName, extData);\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async updateExtension (extName, extData, {write = true} = {}) {\n    this.installedExtensions[extName] = {\n      ...this.installedExtensions[extName],\n      ...extData,\n    };\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async removeExtension (extName, {write = true} = {}) {\n    delete this.installedExtensions[extName];\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>[]} [activeNames]\n   * @returns {void}\n   */\n  // eslint-disable-next-line no-unused-vars\n  print (activeNames) {\n    if (_.isEmpty(this.installedExtensions)) {\n      log.info(\n        `No ${this.configKey} have been installed in ${this.appiumHome}. Use the \"appium ${this.extensionType}\" ` +\n          'command to install the one(s) you want to use.',\n      );\n      return;\n    }\n\n    log.info(`Available ${this.configKey}:`);\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[string, ExtManifest<ExtType>][]} */ (\n        _.toPairs(this.installedExtensions)\n      )) {\n      log.info(`  - ${this.extensionDesc(extName, extData)}`);\n    }\n  }\n\n  /**\n   * Returns a string describing the extension. Subclasses must implement.\n   * @param {ExtName<ExtType>} extName - Extension name\n   * @param {ExtManifest<ExtType>} extData - Extension data\n   * @returns {string}\n   * @abstract\n   */\n  // eslint-disable-next-line no-unused-vars\n  extensionDesc (extName, extData) {\n    throw new Error('This must be implemented in a subclass');\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {string}\n   */\n  getInstallPath (extName) {\n    return path.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);\n  }\n\n  /**\n   * Loads extension and returns its main class (constructor)\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtClass<ExtType>}\n   */\n  require (extName) {\n    const {mainClass} = this.installedExtensions[extName];\n    const reqPath = this.getInstallPath(extName);\n    const reqResolved = require.resolve(reqPath);\n    // note: this will only reload the entry point\n    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {\n      log.debug(`Removing ${reqResolved} from require cache`);\n      delete require.cache[reqResolved];\n    }\n    log.debug(`Requiring ${this.extensionType} at ${reqPath}`);\n    return require(reqPath)[mainClass];\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {boolean}\n   */\n  isInstalled (extName) {\n    return _.includes(Object.keys(this.installedExtensions), extName);\n  }\n\n  /**\n   * Intended to be called by corresponding instance methods of subclass.\n   * @private\n   * @template {ExtensionType} ExtType\n   * @param {string} appiumHome\n   * @param {ExtType} extType\n   * @param {ExtName<ExtType>} extName - Extension name (unique to its type)\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension config\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  static _readExtensionSchema (appiumHome, extType, extName, extData) {\n    const {pkgName, schema: argSchemaPath} = extData;\n    if (!argSchemaPath) {\n      throw new TypeError(\n        `No \\`schema\\` property found in config for ${extType} ${pkgName} -- why is this function being called?`,\n      );\n    }\n    let moduleObject;\n    if (_.isString(argSchemaPath)) {\n      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));\n      moduleObject = require(schemaPath);\n    } else {\n      moduleObject = argSchemaPath;\n    }\n    // this sucks. default exports should be destroyed\n    const schema = moduleObject.__esModule\n      ? moduleObject.default\n      : moduleObject;\n    registerSchema(extType, extName, schema);\n    return schema;\n  }\n\n  /**\n   * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.\n   * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.\n   * @template {ExtensionType} ExtType\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {extData is ExtManifestWithSchema<ExtType>}\n   */\n  static extDataHasSchema (extData) {\n    return _.isString(extData?.schema) || _.isObject(extData?.schema);\n  }\n\n  /**\n   * If an extension provides a schema, this will load the schema and attempt to\n   * register it with the schema registrar.\n   * @param {ExtName<ExtType>} extName - Name of extension\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension data\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  readExtensionSchema (extName, extData) {\n    return ExtensionConfig._readExtensionSchema(\n      this.appiumHome,\n      this.extensionType,\n      extName,\n      extData,\n    );\n  }\n}\n\nexport {\n  INSTALL_TYPE_NPM,\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPES,\n};\n\n/**\n * Config problem\n * @typedef Problem\n * @property {string} err - Error message\n * @property {any} val - Associated value\n */\n\n/**\n * An optional logging function provided to an {@link ExtensionConfig} subclass.\n * @callback ExtensionLogFn\n * @param {...any} args\n * @returns {void}\n */\n\n/**\n * @typedef {import('../../types').ExtensionType} ExtensionType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifestWithSchema<T>} ExtManifestWithSchema\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtName<T>} ExtName\n */\n\n/**\n * @template T\n * @typedef {import('../../types/extension').ExtClass<T>} ExtClass\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Options for various methods in {@link ExtensionConfig}\n * @typedef ExtensionConfigMutationOpts\n * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation\n */\n\n/**\n * A valid install type\n * @typedef {typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB} InstallType\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["INSTALL_TYPE_NPM","INSTALL_TYPE_LOCAL","INSTALL_TYPE_GITHUB","INSTALL_TYPE_GIT","INSTALL_TYPES","Set","ExtensionConfig","extensionType","configKey","installedExtensions","log","manifest","_listDataCache","constructor","getExtensionData","manifestPath","appiumHome","getProblems","extName","extManifest","getGenericConfigProblems","getConfigProblems","getSchemaProblems","getWarnings","genericConfigWarnings","configWarnings","B","all","getGenericConfigWarnings","getConfigWarnings","getValidationResultSummaries","errorMap","Map","warningMap","errorSummaries","problems","entries","_","isEmpty","push","util","pluralize","length","problem","err","JSON","stringify","val","warningSummaries","warnings","extTypeText","capitalize","problemEnumerationText","warning","_validate","exts","toPairs","errors","set","error","summary","warn","getListData","CommandClass","commandClasses","cmd","config","json","listData","list","showInstalled","showUpdates","appiumVersion","installSpec","installType","pkgName","invalidFields","isString","has","invalidFieldsEnumerationText","invalidFieldsText","map","field","join","createPeerWarning","reason","APPIUM_VER","satisfies","extListData","installed","updateVersion","upToDate","schema","argSchemaPath","extDataHasSchema","isAllowedSchemaFileExtension","readExtensionSchema","message","ALLOWED_SCHEMA_EXTENSIONS","isPlainObject","version","mainClass","addExtension","write","updateExtension","removeExtension","print","activeNames","info","extensionDesc","Error","getInstallPath","path","require","reqPath","reqResolved","resolve","ReferenceError","process","env","APPIUM_RELOAD_EXTENSIONS","cache","debug","MainClass","isInstalled","includes","Object","keys","_readExtensionSchema","extType","TypeError","moduleObject","schemaPath","resolveFrom","__esModule","default","registerSchema","isObject"],"sources":["../../../lib/extension/extension-config.js"],"sourcesContent":["import _ from 'lodash';\nimport B from 'bluebird';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\nimport {satisfies} from 'semver';\nimport {util} from '@appium/support';\nimport {commandClasses} from '../cli/extension';\nimport {APPIUM_VER} from '../config';\nimport log from '../logger';\nimport {\n  ALLOWED_SCHEMA_EXTENSIONS,\n  isAllowedSchemaFileExtension,\n  registerSchema,\n} from '../schema/schema';\n\nconst INSTALL_TYPE_NPM = 'npm';\nconst INSTALL_TYPE_LOCAL = 'local';\nconst INSTALL_TYPE_GITHUB = 'github';\nconst INSTALL_TYPE_GIT = 'git';\n\n/** @type {Set<InstallType>} */\nconst INSTALL_TYPES = new Set([\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_NPM,\n]);\n\n/**\n * This class is abstract. It should not be instantiated directly.\n *\n * Subclasses should provide the generic parameter to implement.\n * @template {ExtensionType} ExtType\n */\nexport class ExtensionConfig {\n  /** @type {ExtType} */\n  extensionType;\n\n  /** @type {`${ExtType}s`} */\n  configKey;\n\n  /** @type {ExtRecord<ExtType>} */\n  installedExtensions;\n\n  /** @type {import('@appium/types').AppiumLogger} */\n  log;\n\n  /** @type {Manifest} */\n  manifest;\n\n  /**\n   * @type {ExtensionListData}\n   */\n  _listDataCache;\n\n  /**\n   * @protected\n   * @param {ExtType} extensionType - Type of extension\n   * @param {Manifest} manifest - `Manifest` instance\n   */\n  constructor(extensionType, manifest) {\n    this.extensionType = extensionType;\n    this.configKey = `${extensionType}s`;\n    this.installedExtensions = manifest.getExtensionData(extensionType);\n    this.manifest = manifest;\n  }\n\n  get manifestPath() {\n    return this.manifest.manifestPath;\n  }\n\n  get appiumHome() {\n    return this.manifest.appiumHome;\n  }\n\n  /**\n   * Returns a list of errors for a given extension.\n   *\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>} extManifest\n   * @returns {ExtManifestProblem[]}\n   */\n  getProblems(extName, extManifest) {\n    return [\n      ...this.getGenericConfigProblems(extManifest, extName),\n      ...this.getConfigProblems(extManifest, extName),\n      ...this.getSchemaProblems(extManifest, extName),\n    ];\n  }\n\n  /**\n   * Returns a list of warnings for a given extension.\n   *\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>} extManifest\n   * @returns {Promise<string[]>}\n   */\n  async getWarnings(extName, extManifest) {\n    const [genericConfigWarnings, configWarnings] = await B.all([\n      this.getGenericConfigWarnings(extManifest, extName),\n      this.getConfigWarnings(extManifest, extName),\n    ]);\n\n    return [...genericConfigWarnings, ...configWarnings];\n  }\n\n  /**\n   * Returns a list of extension-type-specific issues. To be implemented by subclasses.\n   * @abstract\n   * @param {ExtManifest<ExtType>} extManifest\n   * @param {ExtName<ExtType>} extName\n   * @returns {Promise<string[]>}\n   */\n  // eslint-disable-next-line no-unused-vars,require-await\n  async getConfigWarnings(extManifest, extName) {\n    return [];\n  }\n\n  /**\n   *\n   * @param {Map<ExtName<ExtType>,ExtManifestProblem[]>} [errorMap]\n   * @param {Map<ExtName<ExtType>,string[]>} [warningMap]\n   */\n  getValidationResultSummaries(errorMap = new Map(), warningMap = new Map()) {\n    /**\n     * Array of computed strings\n     * @type {string[]}\n     */\n    const errorSummaries = [];\n    for (const [extName, problems] of errorMap.entries()) {\n      if (_.isEmpty(problems)) {\n        continue;\n      }\n      // remove this extension from the list since it's not valid\n      errorSummaries.push(\n        `${this.extensionType} \"${extName}\" had ${util.pluralize(\n          'error',\n          problems.length\n        )} and will not be available:`\n      );\n      for (const problem of problems) {\n        errorSummaries.push(\n          `  - ${problem.err} (Actual value: ` + `${JSON.stringify(problem.val)})`\n        );\n      }\n    }\n    /** @type {string[]} */\n    const warningSummaries = [];\n    for (const [extName, warnings] of warningMap.entries()) {\n      if (_.isEmpty(warnings)) {\n        continue;\n      }\n      const extTypeText = _.capitalize(this.extensionType);\n      const problemEnumerationText = util.pluralize('potential problem', warnings.length, true);\n      warningSummaries.push(`${extTypeText} \"${extName}\" has ${problemEnumerationText}: `);\n      for (const warning of warnings) {\n        warningSummaries.push(`  - ${warning}`);\n      }\n    }\n\n    return {errorSummaries, warningSummaries};\n  }\n\n  /**\n   * Checks extensions for problems.  To be called by subclasses' `validate` method.\n   *\n   * Errors and warnings will be displayed to the user.\n   *\n   * This method mutates `exts`.\n   *\n   * @protected\n   * @param {ExtRecord<ExtType>} exts - Lookup of extension names to {@linkcode ExtManifest} objects\n   * @returns {Promise<ExtRecord<ExtType>>} The same lookup, but picking only error-free extensions\n   */\n  async _validate(exts) {\n    /**\n     * Lookup of extension names to {@linkcode ExtManifestProblem ExtManifestProblems}\n     * @type {Map<ExtName<ExtType>,ExtManifestProblem[]>}\n     */\n    const errorMap = new Map();\n    /**\n     * Lookup of extension names to warnings.\n     * @type {Map<ExtName<ExtType>,string[]>}\n     */\n    const warningMap = new Map();\n\n    for (const [extName, extManifest] of _.toPairs(exts)) {\n      const [errors, warnings] = await B.all([\n        this.getProblems(extName, extManifest),\n        this.getWarnings(extName, extManifest),\n      ]);\n      if (errors.length) {\n        delete exts[extName];\n      }\n      errorMap.set(extName, errors);\n      warningMap.set(extName, warnings);\n    }\n\n    const {errorSummaries, warningSummaries} = this.getValidationResultSummaries(\n      errorMap,\n      warningMap\n    );\n\n    if (!_.isEmpty(errorSummaries)) {\n      log.error(\n        `Appium encountered ${util.pluralize(\n          'error',\n          errorSummaries.length,\n          true\n        )} while validating ${this.configKey} found in manifest ${this.manifestPath}`\n      );\n      for (const summary of errorSummaries) {\n        log.error(summary);\n      }\n    } else {\n      // only display warnings if there are no errors!\n\n      if (!_.isEmpty(warningSummaries)) {\n        log.warn(\n          `Appium encountered ${util.pluralize(\n            'warning',\n            warningSummaries.length,\n            true\n          )} while validating ${this.configKey} found in manifest ${this.manifestPath}`\n        );\n        for (const summary of warningSummaries) {\n          log.warn(summary);\n        }\n      }\n    }\n    return exts;\n  }\n\n  /**\n   * Retrieves listing data for extensions via command class.\n   * Caches the result in {@linkcode ExtensionConfig._listDataCache}\n   * @protected\n   * @returns {Promise<ExtensionListData>}\n   */\n  async getListData() {\n    if (this._listDataCache) {\n      return this._listDataCache;\n    }\n    const CommandClass = /** @type {ExtCommand<ExtType>} */ (commandClasses[this.extensionType]);\n    const cmd = new CommandClass({config: this, json: true});\n    const listData = await cmd.list({showInstalled: true, showUpdates: true});\n    this._listDataCache = listData;\n    return listData;\n  }\n\n  /**\n   * Returns a list of warnings for a particular extension.\n   *\n   * By definition, a non-empty list of warnings does _not_ imply the extension cannot be loaded,\n   * but it may not work as expected or otherwise throw an exception at runtime.\n   *\n   * @param {ExtManifest<ExtType>} extManifest\n   * @param {ExtName<ExtType>} extName\n   * @returns {Promise<string[]>}\n   */\n  async getGenericConfigWarnings(extManifest, extName) {\n    const {appiumVersion, installSpec, installType, pkgName} = extManifest;\n    const warnings = [];\n\n    const invalidFields = [];\n    if (!_.isString(installSpec)) {\n      invalidFields.push('installSpec');\n    }\n\n    if (!INSTALL_TYPES.has(installType)) {\n      invalidFields.push('installType');\n    }\n\n    const extTypeText = _.capitalize(this.extensionType);\n\n    if (invalidFields.length) {\n      const invalidFieldsEnumerationText = util.pluralize(\n        'invalid or missing field',\n        invalidFields.length,\n        true\n      );\n      const invalidFieldsText = invalidFields.map((field) => `\"${field}\"`).join(', ');\n\n      warnings.push(\n        `${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.`\n      );\n    }\n\n    /**\n     * Helps concatenate warning messages related to peer dependencies\n     * @param {string} reason\n     * @returns string\n     */\n    const createPeerWarning = (reason) =>\n      `${extTypeText} \"${extName}\" (package \\`${pkgName}\\`) may be incompatible with the current version of Appium (v${APPIUM_VER}) due to ${reason}`;\n\n    if (_.isString(appiumVersion) && !satisfies(APPIUM_VER, appiumVersion)) {\n      const listData = await this.getListData();\n      const extListData = /** @type {InstalledExtensionListData} */ (listData[extName]);\n      if (extListData?.installed) {\n        const {updateVersion, upToDate} = extListData;\n        if (!upToDate) {\n          warnings.push(\n            createPeerWarning(\n              `its peer dependency on older Appium v${appiumVersion}. Please upgrade \\`${pkgName}\\` to v${updateVersion} or newer.`\n            )\n          );\n        } else {\n          warnings.push(\n            createPeerWarning(\n              `its peer dependency on older Appium v${appiumVersion}. Please ask the developer of \\`${pkgName}\\` to update the peer dependency on Appium to v${APPIUM_VER}.`\n            )\n          );\n        }\n      }\n    } else if (!_.isString(appiumVersion)) {\n      const listData = await this.getListData();\n      const extListData = /** @type {InstalledExtensionListData} */ (listData[extName]);\n      if (!extListData?.upToDate && extListData?.updateVersion) {\n        warnings.push(\n          createPeerWarning(\n            `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.`\n          )\n        );\n      } else {\n        warnings.push(\n          createPeerWarning(\n            `an invalid or missing peer dependency on Appium. Please ask the developer of \\`${pkgName}\\` to add a peer dependency on \\`^appium@${APPIUM_VER}\\`.`\n          )\n        );\n      }\n    }\n    return warnings;\n  }\n  /**\n   * Returns list of unrecoverable errors (if any) for the given extension _if_ it has a `schema` property.\n   *\n   * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)\n   * @param {ExtName<ExtType>} extName - Extension name (from manifest)\n   * @returns {ExtManifestProblem[]}\n   */\n  getSchemaProblems(extManifest, extName) {\n    /** @type {ExtManifestProblem[]} */\n    const problems = [];\n    const {schema: argSchemaPath} = extManifest;\n    if (ExtensionConfig.extDataHasSchema(extManifest)) {\n      if (_.isString(argSchemaPath)) {\n        if (isAllowedSchemaFileExtension(argSchemaPath)) {\n          try {\n            this.readExtensionSchema(extName, extManifest);\n          } catch (err) {\n            problems.push({\n              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,\n              val: argSchemaPath,\n            });\n          }\n        } else {\n          problems.push({\n            err: `Schema file has unsupported extension. Allowed: ${[\n              ...ALLOWED_SCHEMA_EXTENSIONS,\n            ].join(', ')}`,\n            val: argSchemaPath,\n          });\n        }\n      } else if (_.isPlainObject(argSchemaPath)) {\n        try {\n          this.readExtensionSchema(extName, extManifest);\n        } catch (err) {\n          problems.push({\n            err: `Unable to register embedded schema; ${err.message}`,\n            val: argSchemaPath,\n          });\n        }\n      } else {\n        problems.push({\n          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n          val: argSchemaPath,\n        });\n      }\n    }\n    return problems;\n  }\n\n  /**\n   * Return a list of generic unrecoverable errors for the given extension\n   * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)\n   * @param {ExtName<ExtType>} extName - Extension name (from manifest)\n   * @returns {ExtManifestProblem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getGenericConfigProblems(extManifest, extName) {\n    const {version, pkgName, mainClass} = extManifest;\n    const problems = [];\n\n    if (!_.isString(version)) {\n      problems.push({\n        err: `Invalid or missing \\`version\\` field in my \\`package.json\\` and/or \\`extensions.yaml\\` (must be a string)`,\n        val: version,\n      });\n    }\n\n    if (!_.isString(pkgName)) {\n      problems.push({\n        err: `Invalid or missing \\`name\\` field in my \\`package.json\\` and/or \\`extensions.yaml\\` (must be a string)`,\n        val: pkgName,\n      });\n    }\n\n    if (!_.isString(mainClass)) {\n      problems.push({\n        err: `Invalid or missing \\`appium.mainClass\\` field in my \\`package.json\\` and/or \\`mainClass\\` field in \\`extensions.yaml\\` (must be a string)`,\n        val: mainClass,\n      });\n    }\n\n    return problems;\n  }\n\n  /**\n   * @abstract\n   * @param {ExtManifest<ExtType>} extManifest\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtManifestProblem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getConfigProblems(extManifest, extName) {\n    // shoud override this method if special validation is necessary for this extension type\n    return [];\n  }\n\n  /**\n   * @param {string} extName\n   * @param {ExtManifest<ExtType>} extManifest\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async addExtension(extName, extManifest, {write = true} = {}) {\n    this.manifest.addExtension(this.extensionType, extName, extManifest);\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extManifest\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async updateExtension(extName, extManifest, {write = true} = {}) {\n    this.installedExtensions[extName] = {\n      ...this.installedExtensions[extName],\n      ...extManifest,\n    };\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * Remove an extension from the list of installed extensions, and optionally avoid a write to the manifest file.\n   *\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async removeExtension(extName, {write = true} = {}) {\n    delete this.installedExtensions[extName];\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>[]} [activeNames]\n   * @returns {void}\n   */\n  // eslint-disable-next-line no-unused-vars\n  print(activeNames) {\n    if (_.isEmpty(this.installedExtensions)) {\n      log.info(\n        `No ${this.configKey} have been installed in ${this.appiumHome}. Use the \"appium ${this.extensionType}\" ` +\n          'command to install the one(s) you want to use.'\n      );\n      return;\n    }\n\n    log.info(`Available ${this.configKey}:`);\n    for (const [extName, extManifest] of /** @type {[string, ExtManifest<ExtType>][]} */ (\n      _.toPairs(this.installedExtensions)\n    )) {\n      log.info(`  - ${this.extensionDesc(extName, extManifest)}`);\n    }\n  }\n\n  /**\n   * Returns a string describing the extension. Subclasses must implement.\n   * @param {ExtName<ExtType>} extName - Extension name\n   * @param {ExtManifest<ExtType>} extManifest - Extension data\n   * @returns {string}\n   * @abstract\n   */\n  // eslint-disable-next-line no-unused-vars\n  extensionDesc(extName, extManifest) {\n    throw new Error('This must be implemented in a subclass');\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {string}\n   */\n  getInstallPath(extName) {\n    return path.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);\n  }\n\n  /**\n   * Loads extension and returns its main class (constructor)\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtClass<ExtType>}\n   */\n  require(extName) {\n    const {mainClass} = this.installedExtensions[extName];\n    const reqPath = this.getInstallPath(extName);\n    /** @type {string} */\n    let reqResolved;\n    try {\n      reqResolved = require.resolve(reqPath);\n    } catch (err) {\n      throw new ReferenceError(`Could not find a ${this.extensionType} installed at ${reqPath}`);\n    }\n    // note: this will only reload the entry point\n    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {\n      log.debug(`Removing ${reqResolved} from require cache`);\n      delete require.cache[reqResolved];\n    }\n    log.debug(`Requiring ${this.extensionType} at ${reqPath}`);\n    const MainClass = require(reqPath)[mainClass];\n    if (!MainClass) {\n      throw new ReferenceError(\n        `Could not find a class named \"${mainClass}\" exported by ${this.extensionType} \"${extName}\"`\n      );\n    }\n    return MainClass;\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {boolean}\n   */\n  isInstalled(extName) {\n    return _.includes(Object.keys(this.installedExtensions), extName);\n  }\n\n  /**\n   * Intended to be called by corresponding instance methods of subclass.\n   * @private\n   * @template {ExtensionType} ExtType\n   * @param {string} appiumHome\n   * @param {ExtType} extType\n   * @param {ExtName<ExtType>} extName - Extension name (unique to its type)\n   * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension config\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  static _readExtensionSchema(appiumHome, extType, extName, extManifest) {\n    const {pkgName, schema: argSchemaPath} = extManifest;\n    if (!argSchemaPath) {\n      throw new TypeError(\n        `No \\`schema\\` property found in config for ${extType} ${pkgName} -- why is this function being called?`\n      );\n    }\n    let moduleObject;\n    if (_.isString(argSchemaPath)) {\n      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));\n      moduleObject = require(schemaPath);\n    } else {\n      moduleObject = argSchemaPath;\n    }\n    // this sucks. default exports should be destroyed\n    const schema = moduleObject.__esModule ? moduleObject.default : moduleObject;\n    registerSchema(extType, extName, schema);\n    return schema;\n  }\n\n  /**\n   * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.\n   * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.\n   * @template {ExtensionType} ExtType\n   * @param {ExtManifest<ExtType>} extManifest\n   * @returns {extManifest is ExtManifestWithSchema<ExtType>}\n   */\n  static extDataHasSchema(extManifest) {\n    return _.isString(extManifest?.schema) || _.isObject(extManifest?.schema);\n  }\n\n  /**\n   * If an extension provides a schema, this will load the schema and attempt to\n   * register it with the schema registrar.\n   * @param {ExtName<ExtType>} extName - Name of extension\n   * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension data\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  readExtensionSchema(extName, extManifest) {\n    return ExtensionConfig._readExtensionSchema(\n      this.appiumHome,\n      this.extensionType,\n      extName,\n      extManifest\n    );\n  }\n}\n\nexport {INSTALL_TYPE_NPM, INSTALL_TYPE_GIT, INSTALL_TYPE_LOCAL, INSTALL_TYPE_GITHUB, INSTALL_TYPES};\n\n/**\n * An issue with the {@linkcode ExtManifest} for a particular extension.\n *\n * The existance of such an object implies that the extension cannot be loaded.\n * @typedef ExtManifestProblem\n * @property {string} err - Error message\n * @property {any} val - Associated value\n */\n\n/**\n * An optional logging function provided to an {@link ExtensionConfig} subclass.\n * @callback ExtensionLogFn\n * @param {...any} args\n * @returns {void}\n */\n\n/**\n * @typedef {import('@appium/types').ExtensionType} ExtensionType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifestWithSchema<T>} ExtManifestWithSchema\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtName<T>} ExtName\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtClass<T>} ExtClass\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('../cli/extension').ExtCommand<T>} ExtCommand\n */\n\n/**\n * Options for various methods in {@link ExtensionConfig}\n * @typedef ExtensionConfigMutationOpts\n * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation\n */\n\n/**\n * A valid install type\n * @typedef {typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB} InstallType\n */\n\n/**\n * @typedef {import('../cli/extension-command').ExtensionListData} ExtensionListData\n * @typedef {import('../cli/extension-command').InstalledExtensionListData} InstalledExtensionListData\n */\n"],"mappings":"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"}

package/build/lib/extension/index.d.ts

@@ -18,9 +18,9 @@ export function loadExtensions(appiumHome: string): Promise<ExtensionConfigs>;
  *
  * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config
  * @param {string[]} usePlugins
- * @returns {import('../../types').PluginClass[]}
+ * @returns {PluginNameMap} Mapping of PluginClass to name
  */
-export function getActivePlugins(pluginConfig: import('./plugin-config').PluginConfig, usePlugins?: string[]): import('../../types').PluginClass[];
+export function getActivePlugins(pluginConfig: import('./plugin-config').PluginConfig, usePlugins?: string[]): PluginNameMap;
 /**
  * Find any driver name which has been installed, and turn each one into its class, so we can send
  * them as objects to the server init in case they need to add methods/routes or update the server.
@@ -28,12 +28,21 @@ export function getActivePlugins(pluginConfig: import('./plugin-config').PluginC
  *
  * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config
  * @param {string[]} [useDrivers] - optional list of drivers to load
+ * @returns {DriverNameMap}
  */
-export function getActiveDrivers(driverConfig: import('./driver-config').DriverConfig, useDrivers?: string[] | undefined): any[];
+export function getActiveDrivers(driverConfig: import('./driver-config').DriverConfig, useDrivers?: string[] | undefined): DriverNameMap;
+/**
+ * A mapping of {@linkcode PluginClass } classes to their names.
+ */
+export type PluginNameMap = Map<PluginClass, string>;
+/**
+ * A mapping of {@linkcode DriverClass } classes to their names.
+ */
+export type DriverNameMap = Map<DriverClass, string>;
+export type PluginClass = import('@appium/types').PluginClass;
+export type DriverClass = import('@appium/types').DriverClass;
 export type ExtensionConfigs = {
-    driverConfig: DriverConfig;
-    pluginConfig: PluginConfig;
+    driverConfig: import('./driver-config').DriverConfig;
+    pluginConfig: import('./plugin-config').PluginConfig;
 };
-import { DriverConfig } from "./driver-config";
-import { PluginConfig } from "./plugin-config";
 //# sourceMappingURL=index.d.ts.map

package/build/lib/extension/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/extension/index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,2CAHW,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAYrC;AAED;;;;;;;;;GASG;AACH,+CAJW,OAAO,iBAAiB,EAAE,YAAY,eACtC,MAAM,EAAE,GACN,OAAO,aAAa,EAAE,WAAW,EAAE,CA0B/C;AAED;;;;;;;GAOG;AACH,+CAHW,OAAO,iBAAiB,EAAE,YAAY,4CAuBhD;;kBAIa,YAAY;kBACZ,YAAY"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/extension/index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,2CAHW,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAUrC;AAED;;;;;;;;;GASG;AACH,+CAJW,OAAO,iBAAiB,EAAE,YAAY,eACtC,MAAM,EAAE,iBA2BlB;AAED;;;;;;;;GAQG;AACH,+CAJW,OAAO,iBAAiB,EAAE,YAAY,oDAwBhD;;;;4BAIY,IAAI,WAAW,EAAC,MAAM,CAAC;;;;4BAKvB,IAAI,WAAW,EAAC,MAAM,CAAC;0BAIvB,OAAO,eAAe,EAAE,WAAW;0BACnC,OAAO,eAAe,EAAE,WAAW;;kBAKlC,OAAO,iBAAiB,EAAE,YAAY;kBACtC,OAAO,iBAAiB,EAAE,YAAY"}