appium 2.0.0-beta.44 → 2.0.0-beta.46

package/build/lib/constants.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -11,6 +9,8 @@ require("source-map-support/register");
 
 var _path = _interopRequireDefault(require("path"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const DRIVER_TYPE = 'driver';
 exports.DRIVER_TYPE = DRIVER_TYPE;
 const PLUGIN_TYPE = 'plugin';
@@ -57,4 +57,4 @@ const EXT_SUBCOMMAND_UPDATE = 'update';
 exports.EXT_SUBCOMMAND_UPDATE = EXT_SUBCOMMAND_UPDATE;
 const EXT_SUBCOMMAND_RUN = 'run';
 exports.EXT_SUBCOMMAND_RUN = EXT_SUBCOMMAND_RUN;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":["DRIVER_TYPE","PLUGIN_TYPE","SERVER_SUBCOMMAND","USE_ALL_PLUGINS","KNOWN_PLUGINS","Object","freeze","images","KNOWN_DRIVERS","uiautomator2","xcuitest","youiengine","windows","mac","mac2","espresso","tizen","flutter","safari","gecko","CACHE_DIR_RELATIVE_PATH","path","join","PKG_HASHFILE_RELATIVE_PATH","EXT_SUBCOMMAND_LIST","EXT_SUBCOMMAND_INSTALL","EXT_SUBCOMMAND_UNINSTALL","EXT_SUBCOMMAND_UPDATE","EXT_SUBCOMMAND_RUN"],"sources":["../../lib/constants.js"],"sourcesContent":["import path from 'path';\n\n/**\n * The name of the extension type for drivers\n */\nexport const DRIVER_TYPE = 'driver';\n\n/**\n * The name of the extension type for plugins\n */\nexport const PLUGIN_TYPE = 'plugin';\n\n/**\n * The `server` command of the `appium` CLI\n */\nexport const SERVER_SUBCOMMAND = 'server';\n\n/**\n * The value of `--use-plugins` if _all_ plugins should be loaded\n */\nexport const USE_ALL_PLUGINS = 'all';\n\n// This is a map of plugin names to npm packages representing those plugins.\n// The plugins in this list will be available to the CLI so users can just\n// type 'appium plugin install 'name'', rather than having to specify the full\n// npm package. I.e., these are the officially recognized plugins.\nexport const KNOWN_PLUGINS = Object.freeze(\n  /** @type {const} */ ({\n    images: '@appium/images-plugin',\n    'execute-driver': '@appium/execute-driver-plugin',\n    'relaxed-caps': '@appium/relaxed-caps-plugin',\n  })\n);\n\n// This is a map of driver names to npm packages representing those drivers.\n// The drivers in this list will be available to the CLI so users can just\n// type 'appium driver install 'name'', rather than having to specify the full\n// npm package. I.e., these are the officially recognized drivers.\nexport const KNOWN_DRIVERS = Object.freeze(\n  /** @type {const} */ ({\n    uiautomator2: 'appium-uiautomator2-driver',\n    xcuitest: 'appium-xcuitest-driver',\n    youiengine: 'appium-youiengine-driver',\n    windows: 'appium-windows-driver',\n    mac: 'appium-mac-driver',\n    mac2: 'appium-mac2-driver',\n    espresso: 'appium-espresso-driver',\n    tizen: 'appium-tizen-driver',\n    flutter: 'appium-flutter-driver',\n    safari: 'appium-safari-driver',\n    gecko: 'appium-geckodriver',\n  })\n);\n\n/**\n * Relative path to directory containing any Appium internal files\n */\nexport const CACHE_DIR_RELATIVE_PATH = path.join('node_modules', '.cache', 'appium');\n\n/**\n * Relative path to hashfile (from `APPIUM_HOME`) of consuming project's `package.json` (if it exists)\n */\nexport const PKG_HASHFILE_RELATIVE_PATH = path.join(CACHE_DIR_RELATIVE_PATH, 'package.hash');\n\nexport const EXT_SUBCOMMAND_LIST = 'list';\nexport const EXT_SUBCOMMAND_INSTALL = 'install';\nexport const EXT_SUBCOMMAND_UNINSTALL = 'uninstall';\nexport const EXT_SUBCOMMAND_UPDATE = 'update';\nexport const EXT_SUBCOMMAND_RUN = 'run';\n"],"mappings":";;;;;;;;;AAAA;;;;AAKO,MAAMA,WAAW,GAAG,QAApB;;AAKA,MAAMC,WAAW,GAAG,QAApB;;AAKA,MAAMC,iBAAiB,GAAG,QAA1B;;AAKA,MAAMC,eAAe,GAAG,KAAxB;;AAMA,MAAMC,aAAa,GAAGC,MAAM,CAACC,MAAP,CACL;EACpBC,MAAM,EAAE,uBADY;EAEpB,kBAAkB,+BAFE;EAGpB,gBAAgB;AAHI,CADK,CAAtB;;AAYA,MAAMC,aAAa,GAAGH,MAAM,CAACC,MAAP,CACL;EACpBG,YAAY,EAAE,4BADM;EAEpBC,QAAQ,EAAE,wBAFU;EAGpBC,UAAU,EAAE,0BAHQ;EAIpBC,OAAO,EAAE,uBAJW;EAKpBC,GAAG,EAAE,mBALe;EAMpBC,IAAI,EAAE,oBANc;EAOpBC,QAAQ,EAAE,wBAPU;EAQpBC,KAAK,EAAE,qBARa;EASpBC,OAAO,EAAE,uBATW;EAUpBC,MAAM,EAAE,sBAVY;EAWpBC,KAAK,EAAE;AAXa,CADK,CAAtB;;;AAmBA,MAAMC,uBAAuB,GAAGC,aAAA,CAAKC,IAAL,CAAU,cAAV,EAA0B,QAA1B,EAAoC,QAApC,CAAhC;;;;AAKA,MAAMC,0BAA0B,GAAGF,aAAA,CAAKC,IAAL,CAAUF,uBAAV,EAAmC,cAAnC,CAAnC;;;AAEA,MAAMI,mBAAmB,GAAG,MAA5B;;AACA,MAAMC,sBAAsB,GAAG,SAA/B;;AACA,MAAMC,wBAAwB,GAAG,WAAjC;;AACA,MAAMC,qBAAqB,GAAG,QAA9B;;AACA,MAAMC,kBAAkB,GAAG,KAA3B"}

package/build/lib/extension/driver-config.d.ts

@@ -49,10 +49,11 @@ export class DriverConfig extends ExtensionConfig<"driver"> {
     getConfigProblems(extData: ExtManifest<DriverType>): import('./extension-config').ExtManifestProblem[];
     /**
      * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.
-     * @param {Capabilities} caps
+     * @template {import('@appium/types').StringRecord} C
+     * @param {C} caps
      * @returns {MatchedDriver}
      */
-    findMatchingDriver({ automationName, platformName }: Capabilities): MatchedDriver;
+    findMatchingDriver<C extends import("@appium/types").StringRecord>({ automationName, platformName }: C): MatchedDriver;
     /**
      * Given an automation name and platform name, find a suitable driver and return its extension data.
      * @param {string} matchAutomationName

package/build/lib/extension/driver-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/driver-config.js"],"names":[],"mappings":"AAKA;;GAEG;AACH;IAOE;;;;;;;;;OASG;IACH,0BAAkC;IAalC;;;;;;OAMG;IACH,wBAJW,QAAQ,GAEN,YAAY,CAWxB;IAED;;;;OAIG;IACH,6BAHW,QAAQ,GACN,YAAY,GAAC,SAAS,CAIlC;IApCD;;;;OAIG;IACH,sBAIC;IA3BD;;;OAGG;IACH,sBAFU,IAAI,MAAM,CAAC,CAEA;IAoDrB;;OAEG;IACH,sEAGC;IAED;;;OAGG;IACH,2BAHW,YAAY,UAAU,CAAC,GACrB,OAAO,oBAAoB,EAAE,kBAAkB,EAAE,CA+C7D;IAWD;;;;OAIG;IACH,qDAHW,YAAY,GACV,aAAa,CAuCzB;IAED;;;;;OAKG;IACH,yCAJW,MAAM,qBACN,MAAM,GACJ,YAAY,UAAU,CAAC,GAAG,OAAO,cAAc,EAAE,gBAAgB,GAAG,OAAO,cAAc,EAAE,iBAAiB,CA4BxH;CACF;6BAIY,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;6BAKrC,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;2BAIrC,OAAO,cAAc,EAAE,YAAY;yBACnC,OAAO,eAAe,EAAE,UAAU;uBAClC,OAAO,YAAY,EAAE,QAAQ;2BAK7B,OAAO,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;yBAKnC,OAAO,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;YAMhC,OAAO,eAAe,EAAE,WAAW;aACnC,MAAM;gBACN,MAAM;;2BAIP,OAAO,eAAe,EAAE,YAAY"}
+{"version":3,"file":"driver-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/driver-config.js"],"names":[],"mappings":"AAKA;;GAEG;AACH;IAOE;;;;;;;;;OASG;IACH,0BAAkC;IAalC;;;;;;OAMG;IACH,wBAJW,QAAQ,GAEN,YAAY,CAWxB;IAED;;;;OAIG;IACH,6BAHW,QAAQ,GACN,YAAY,GAAC,SAAS,CAIlC;IApCD;;;;OAIG;IACH,sBAIC;IA3BD;;;OAGG;IACH,sBAFU,IAAI,MAAM,CAAC,CAEA;IAoDrB;;OAEG;IACH,sEAGC;IAED;;;OAGG;IACH,2BAHW,YAAY,UAAU,CAAC,GACrB,OAAO,oBAAoB,EAAE,kBAAkB,EAAE,CA+C7D;IAWD;;;;;OAKG;IACH,yGAFa,aAAa,CAuCzB;IAED;;;;;OAKG;IACH,yCAJW,MAAM,qBACN,MAAM,GACJ,YAAY,UAAU,CAAC,GAAG,OAAO,cAAc,EAAE,gBAAgB,GAAG,OAAO,cAAc,EAAE,iBAAiB,CA4BxH;CACF;6BAIY,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;6BAKrC,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;2BAIrC,OAAO,cAAc,EAAE,YAAY;yBACnC,OAAO,eAAe,EAAE,UAAU;uBAClC,OAAO,YAAY,EAAE,QAAQ;2BAK7B,OAAO,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;yBAKnC,OAAO,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;YAMhC,OAAO,eAAe,EAAE,WAAW;aACnC,MAAM;gBACN,MAAM;;2BAIP,OAAO,eAAe,EAAE,YAAY"}

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

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -17,6 +15,8 @@ var _logger = _interopRequireDefault(require("../logger"));
 
 var _extensionConfig = require("./extension-config");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 class DriverConfig extends _extensionConfig.ExtensionConfig {
   knownAutomationNames;
   static _instances = new WeakMap();
@@ -174,4 +174,4 @@ class DriverConfig extends _extensionConfig.ExtensionConfig {
 }
 
 exports.DriverConfig = DriverConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","DRIVER_TYPE","Set","create","instance","getInstance","Error","appiumHome","set","get","validate","clear","_validate","getExtensionData","getConfigProblems","extData","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"sources":["../../../lib/extension/driver-config.js"],"sourcesContent":["import _ from 'lodash';\nimport {DRIVER_TYPE} from '../constants';\nimport log from '../logger';\nimport {ExtensionConfig} from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n  static _instances = new WeakMap();\n\n  /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   */\n  constructor(manifest) {\n    super(DRIVER_TYPE, manifest);\n\n    this.knownAutomationNames = new Set();\n  }\n\n  /**\n   * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n   *\n   * @param {Manifest} manifest\n   * @throws If `manifest` already associated with a `DriverConfig`\n   * @returns {DriverConfig}\n   */\n  static create(manifest) {\n    const instance = new DriverConfig(manifest);\n    if (DriverConfig.getInstance(manifest)) {\n      throw new Error(\n        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`\n      );\n    }\n    DriverConfig._instances.set(manifest, instance);\n    return instance;\n  }\n\n  /**\n   * Returns a DriverConfig associated with a Manifest\n   * @param {Manifest} manifest\n   * @returns {DriverConfig|undefined}\n   */\n  static getInstance(manifest) {\n    return DriverConfig._instances.get(manifest);\n  }\n\n  /**\n   * Checks extensions for problems\n   */\n  async validate() {\n    this.knownAutomationNames.clear();\n    return await super._validate(this.manifest.getExtensionData(DRIVER_TYPE));\n  }\n\n  /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').ExtManifestProblem[]}\n   */\n  getConfigProblems(extData) {\n    const problems = [];\n    const {platformNames, automationName} = extData;\n\n    if (!_.isArray(platformNames)) {\n      problems.push({\n        err: 'Missing or incorrect supported platformNames list.',\n        val: platformNames,\n      });\n    } else {\n      if (_.isEmpty(platformNames)) {\n        problems.push({\n          err: 'Empty platformNames list.',\n          val: platformNames,\n        });\n      } else {\n        for (const pName of platformNames) {\n          if (!_.isString(pName)) {\n            problems.push({\n              err: 'Incorrectly formatted platformName.',\n              val: pName,\n            });\n          }\n        }\n      }\n    }\n\n    if (!_.isString(automationName)) {\n      problems.push({\n        err: 'Missing or incorrect automationName',\n        val: automationName,\n      });\n    }\n\n    if (this.knownAutomationNames.has(automationName)) {\n      problems.push({\n        err: 'Multiple drivers claim support for the same automationName',\n        val: automationName,\n      });\n    }\n\n    // should we retain the name at the end of this function, once we've checked there are no problems?\n    this.knownAutomationNames.add(automationName);\n\n    return problems;\n  }\n\n  /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n  extensionDesc(driverName, {version, automationName}) {\n    return `${driverName}@${version} (automationName '${automationName}')`;\n  }\n\n  /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @param {Capabilities} caps\n   * @returns {MatchedDriver}\n   */\n  findMatchingDriver({automationName, platformName}) {\n    if (!_.isString(platformName)) {\n      throw new Error('You must include a platformName capability');\n    }\n\n    if (!_.isString(automationName)) {\n      throw new Error('You must include an automationName capability');\n    }\n\n    log.info(\n      `Attempting to find matching driver for automationName ` +\n        `'${automationName}' and platformName '${platformName}'`\n    );\n\n    try {\n      const {driverName, mainClass, version} = this._getDriverBySupport(\n        automationName,\n        platformName\n      );\n      log.info(`The '${driverName}' driver was installed and matched caps.`);\n      log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n      const driver = this.require(driverName);\n      if (!driver) {\n        throw new Error(\n          `Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`\n        );\n      }\n      return {driver, version, driverName};\n    } catch (err) {\n      const msg =\n        `Could not find a driver for automationName ` +\n        `'${automationName}' and platformName ${platformName}'. ` +\n        `Have you installed a driver that supports those ` +\n        `capabilities? Run 'appium driver list --installed' to see. ` +\n        `(Lower-level error: ${err.message})`;\n      throw new Error(msg);\n    }\n  }\n\n  /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('appium/types').InternalMetadata & import('appium/types').CommonExtMetadata}\n   */\n  _getDriverBySupport(matchAutomationName, matchPlatformName) {\n    const drivers = this.installedExtensions;\n    for (const [driverName, driverData] of _.toPairs(drivers)) {\n      const {automationName, platformNames} = driverData;\n      const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n      const pNameMatches = _.includes(\n        platformNames.map(_.toLower),\n        matchPlatformName.toLowerCase()\n      );\n\n      if (aNameMatches && pNameMatches) {\n        return {driverName, ...driverData};\n      }\n\n      if (aNameMatches) {\n        throw new Error(\n          `Driver '${driverName}' supports automationName ` +\n            `'${automationName}', but Appium could not find ` +\n            `support for platformName '${matchPlatformName}'. Supported ` +\n            `platformNames are: ` +\n            JSON.stringify(platformNames)\n        );\n      }\n    }\n\n    throw new Error(`Could not find installed driver to support given caps`);\n  }\n}\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtName<T>} ExtName\n */\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('@appium/types').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","DRIVER_TYPE","Set","create","instance","getInstance","Error","appiumHome","set","get","validate","clear","_validate","getExtensionData","getConfigProblems","extData","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"sources":["../../../lib/extension/driver-config.js"],"sourcesContent":["import _ from 'lodash';\nimport {DRIVER_TYPE} from '../constants';\nimport log from '../logger';\nimport {ExtensionConfig} from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n  static _instances = new WeakMap();\n\n  /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   */\n  constructor(manifest) {\n    super(DRIVER_TYPE, manifest);\n\n    this.knownAutomationNames = new Set();\n  }\n\n  /**\n   * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n   *\n   * @param {Manifest} manifest\n   * @throws If `manifest` already associated with a `DriverConfig`\n   * @returns {DriverConfig}\n   */\n  static create(manifest) {\n    const instance = new DriverConfig(manifest);\n    if (DriverConfig.getInstance(manifest)) {\n      throw new Error(\n        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`\n      );\n    }\n    DriverConfig._instances.set(manifest, instance);\n    return instance;\n  }\n\n  /**\n   * Returns a DriverConfig associated with a Manifest\n   * @param {Manifest} manifest\n   * @returns {DriverConfig|undefined}\n   */\n  static getInstance(manifest) {\n    return DriverConfig._instances.get(manifest);\n  }\n\n  /**\n   * Checks extensions for problems\n   */\n  async validate() {\n    this.knownAutomationNames.clear();\n    return await super._validate(this.manifest.getExtensionData(DRIVER_TYPE));\n  }\n\n  /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').ExtManifestProblem[]}\n   */\n  getConfigProblems(extData) {\n    const problems = [];\n    const {platformNames, automationName} = extData;\n\n    if (!_.isArray(platformNames)) {\n      problems.push({\n        err: 'Missing or incorrect supported platformNames list.',\n        val: platformNames,\n      });\n    } else {\n      if (_.isEmpty(platformNames)) {\n        problems.push({\n          err: 'Empty platformNames list.',\n          val: platformNames,\n        });\n      } else {\n        for (const pName of platformNames) {\n          if (!_.isString(pName)) {\n            problems.push({\n              err: 'Incorrectly formatted platformName.',\n              val: pName,\n            });\n          }\n        }\n      }\n    }\n\n    if (!_.isString(automationName)) {\n      problems.push({\n        err: 'Missing or incorrect automationName',\n        val: automationName,\n      });\n    }\n\n    if (this.knownAutomationNames.has(automationName)) {\n      problems.push({\n        err: 'Multiple drivers claim support for the same automationName',\n        val: automationName,\n      });\n    }\n\n    // should we retain the name at the end of this function, once we've checked there are no problems?\n    this.knownAutomationNames.add(automationName);\n\n    return problems;\n  }\n\n  /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n  extensionDesc(driverName, {version, automationName}) {\n    return `${driverName}@${version} (automationName '${automationName}')`;\n  }\n\n  /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @template {import('@appium/types').StringRecord} C\n   * @param {C} caps\n   * @returns {MatchedDriver}\n   */\n  findMatchingDriver({automationName, platformName}) {\n    if (!_.isString(platformName)) {\n      throw new Error('You must include a platformName capability');\n    }\n\n    if (!_.isString(automationName)) {\n      throw new Error('You must include an automationName capability');\n    }\n\n    log.info(\n      `Attempting to find matching driver for automationName ` +\n        `'${automationName}' and platformName '${platformName}'`\n    );\n\n    try {\n      const {driverName, mainClass, version} = this._getDriverBySupport(\n        automationName,\n        platformName\n      );\n      log.info(`The '${driverName}' driver was installed and matched caps.`);\n      log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n      const driver = this.require(driverName);\n      if (!driver) {\n        throw new Error(\n          `Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`\n        );\n      }\n      return {driver, version, driverName};\n    } catch (err) {\n      const msg =\n        `Could not find a driver for automationName ` +\n        `'${automationName}' and platformName ${platformName}'. ` +\n        `Have you installed a driver that supports those ` +\n        `capabilities? Run 'appium driver list --installed' to see. ` +\n        `(Lower-level error: ${err.message})`;\n      throw new Error(msg);\n    }\n  }\n\n  /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('appium/types').InternalMetadata & import('appium/types').CommonExtMetadata}\n   */\n  _getDriverBySupport(matchAutomationName, matchPlatformName) {\n    const drivers = this.installedExtensions;\n    for (const [driverName, driverData] of _.toPairs(drivers)) {\n      const {automationName, platformNames} = driverData;\n      const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n      const pNameMatches = _.includes(\n        platformNames.map(_.toLower),\n        matchPlatformName.toLowerCase()\n      );\n\n      if (aNameMatches && pNameMatches) {\n        return {driverName, ...driverData};\n      }\n\n      if (aNameMatches) {\n        throw new Error(\n          `Driver '${driverName}' supports automationName ` +\n            `'${automationName}', but Appium could not find ` +\n            `support for platformName '${matchPlatformName}'. Supported ` +\n            `platformNames are: ` +\n            JSON.stringify(platformNames)\n        );\n      }\n    }\n\n    throw new Error(`Could not find installed driver to support given caps`);\n  }\n}\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtName<T>} ExtName\n */\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('@appium/types').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"],"mappings":"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"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"driver-config.js","names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","DRIVER_TYPE","Set","create","instance","getInstance","Error","appiumHome","set","get","validate","clear","_validate","getExtensionData","getConfigProblems","extData","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"sources":["../../../lib/extension/driver-config.js"],"sourcesContent":["import _ from 'lodash';\nimport {DRIVER_TYPE} from '../constants';\nimport log from '../logger';\nimport {ExtensionConfig} from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n  static _instances = new WeakMap();\n\n  /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   */\n  constructor(manifest) {\n    super(DRIVER_TYPE, manifest);\n\n    this.knownAutomationNames = new Set();\n  }\n\n  /**\n   * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n   *\n   * @param {Manifest} manifest\n   * @throws If `manifest` already associated with a `DriverConfig`\n   * @returns {DriverConfig}\n   */\n  static create(manifest) {\n    const instance = new DriverConfig(manifest);\n    if (DriverConfig.getInstance(manifest)) {\n      throw new Error(\n        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`\n      );\n    }\n    DriverConfig._instances.set(manifest, instance);\n    return instance;\n  }\n\n  /**\n   * Returns a DriverConfig associated with a Manifest\n   * @param {Manifest} manifest\n   * @returns {DriverConfig|undefined}\n   */\n  static getInstance(manifest) {\n    return DriverConfig._instances.get(manifest);\n  }\n\n  /**\n   * Checks extensions for problems\n   */\n  async validate() {\n    this.knownAutomationNames.clear();\n    return await super._validate(this.manifest.getExtensionData(DRIVER_TYPE));\n  }\n\n  /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').ExtManifestProblem[]}\n   */\n  getConfigProblems(extData) {\n    const problems = [];\n    const {platformNames, automationName} = extData;\n\n    if (!_.isArray(platformNames)) {\n      problems.push({\n        err: 'Missing or incorrect supported platformNames list.',\n        val: platformNames,\n      });\n    } else {\n      if (_.isEmpty(platformNames)) {\n        problems.push({\n          err: 'Empty platformNames list.',\n          val: platformNames,\n        });\n      } else {\n        for (const pName of platformNames) {\n          if (!_.isString(pName)) {\n            problems.push({\n              err: 'Incorrectly formatted platformName.',\n              val: pName,\n            });\n          }\n        }\n      }\n    }\n\n    if (!_.isString(automationName)) {\n      problems.push({\n        err: 'Missing or incorrect automationName',\n        val: automationName,\n      });\n    }\n\n    if (this.knownAutomationNames.has(automationName)) {\n      problems.push({\n        err: 'Multiple drivers claim support for the same automationName',\n        val: automationName,\n      });\n    }\n\n    // should we retain the name at the end of this function, once we've checked there are no problems?\n    this.knownAutomationNames.add(automationName);\n\n    return problems;\n  }\n\n  /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n  extensionDesc(driverName, {version, automationName}) {\n    return `${driverName}@${version} (automationName '${automationName}')`;\n  }\n\n  /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @template {import('@appium/types').StringRecord} C\n   * @param {C} caps\n   * @returns {MatchedDriver}\n   */\n  findMatchingDriver({automationName, platformName}) {\n    if (!_.isString(platformName)) {\n      throw new Error('You must include a platformName capability');\n    }\n\n    if (!_.isString(automationName)) {\n      throw new Error('You must include an automationName capability');\n    }\n\n    log.info(\n      `Attempting to find matching driver for automationName ` +\n        `'${automationName}' and platformName '${platformName}'`\n    );\n\n    try {\n      const {driverName, mainClass, version} = this._getDriverBySupport(\n        automationName,\n        platformName\n      );\n      log.info(`The '${driverName}' driver was installed and matched caps.`);\n      log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n      const driver = this.require(driverName);\n      if (!driver) {\n        throw new Error(\n          `Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`\n        );\n      }\n      return {driver, version, driverName};\n    } catch (err) {\n      const msg =\n        `Could not find a driver for automationName ` +\n        `'${automationName}' and platformName ${platformName}'. ` +\n        `Have you installed a driver that supports those ` +\n        `capabilities? Run 'appium driver list --installed' to see. ` +\n        `(Lower-level error: ${err.message})`;\n      throw new Error(msg);\n    }\n  }\n\n  /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('appium/types').InternalMetadata & import('appium/types').CommonExtMetadata}\n   */\n  _getDriverBySupport(matchAutomationName, matchPlatformName) {\n    const drivers = this.installedExtensions;\n    for (const [driverName, driverData] of _.toPairs(drivers)) {\n      const {automationName, platformNames} = driverData;\n      const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n      const pNameMatches = _.includes(\n        platformNames.map(_.toLower),\n        matchPlatformName.toLowerCase()\n      );\n\n      if (aNameMatches && pNameMatches) {\n        return {driverName, ...driverData};\n      }\n\n      if (aNameMatches) {\n        throw new Error(\n          `Driver '${driverName}' supports automationName ` +\n            `'${automationName}', but Appium could not find ` +\n            `support for platformName '${matchPlatformName}'. Supported ` +\n            `platformNames are: ` +\n            JSON.stringify(platformNames)\n        );\n      }\n    }\n\n    throw new Error(`Could not find installed driver to support given caps`);\n  }\n}\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('@appium/types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtName<T>} ExtName\n */\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('@appium/types').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"],"mappings":"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"}

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

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -29,6 +27,8 @@ var _logger = _interopRequireDefault(require("../logger"));
 
 var _schema = require("../schema/schema");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const INSTALL_TYPE_NPM = 'npm';
 exports.INSTALL_TYPE_NPM = INSTALL_TYPE_NPM;
 const INSTALL_TYPE_LOCAL = 'local';
@@ -433,4 +433,4 @@ class ExtensionConfig {
 }
 
 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","_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","size","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('error', errorMap.size, true)} while validating ${\n          this.configKey\n        } 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            warningMap.size,\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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"}
+//# 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","size","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('error', errorMap.size, true)} while validating ${\n          this.configKey\n        } 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            warningMap.size,\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/extension-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-config.js","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","size","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('error', errorMap.size, true)} while validating ${\n          this.configKey\n        } 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            warningMap.size,\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":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAMA,MAAMA,gBAAgB,GAAG,KAAzB;;AACA,MAAMC,kBAAkB,GAAG,OAA3B;;AACA,MAAMC,mBAAmB,GAAG,QAA5B;;AACA,MAAMC,gBAAgB,GAAG,KAAzB;;AAGA,MAAMC,aAAa,GAAG,IAAIC,GAAJ,CAAQ,CAC5BF,gBAD4B,EAE5BD,mBAF4B,EAG5BD,kBAH4B,EAI5BD,gBAJ4B,CAAR,CAAtB;;;AAaO,MAAMM,eAAN,CAAsB;EAE3BC,aAAa;EAGbC,SAAS;EAGTC,mBAAmB;EAGnBC,GAAG;EAGHC,QAAQ;EAKRC,cAAc;;EAOdC,WAAW,CAACN,aAAD,EAAgBI,QAAhB,EAA0B;IACnC,KAAKJ,aAAL,GAAqBA,aAArB;IACA,KAAKC,SAAL,GAAkB,GAAED,aAAc,GAAlC;IACA,KAAKE,mBAAL,GAA2BE,QAAQ,CAACG,gBAAT,CAA0BP,aAA1B,CAA3B;IACA,KAAKI,QAAL,GAAgBA,QAAhB;EACD;;EAEe,IAAZI,YAAY,GAAG;IACjB,OAAO,KAAKJ,QAAL,CAAcI,YAArB;EACD;;EAEa,IAAVC,UAAU,GAAG;IACf,OAAO,KAAKL,QAAL,CAAcK,UAArB;EACD;;EASDC,WAAW,CAACC,OAAD,EAAUC,WAAV,EAAuB;IAChC,OAAO,CACL,GAAG,KAAKC,wBAAL,CAA8BD,WAA9B,EAA2CD,OAA3C,CADE,EAEL,GAAG,KAAKG,iBAAL,CAAuBF,WAAvB,EAAoCD,OAApC,CAFE,EAGL,GAAG,KAAKI,iBAAL,CAAuBH,WAAvB,EAAoCD,OAApC,CAHE,CAAP;EAKD;;EASgB,MAAXK,WAAW,CAACL,OAAD,EAAUC,WAAV,EAAuB;IACtC,MAAM,CAACK,qBAAD,EAAwBC,cAAxB,IAA0C,MAAMC,iBAAA,CAAEC,GAAF,CAAM,CAC1D,KAAKC,wBAAL,CAA8BT,WAA9B,EAA2CD,OAA3C,CAD0D,EAE1D,KAAKW,iBAAL,CAAuBV,WAAvB,EAAoCD,OAApC,CAF0D,CAAN,CAAtD;IAKA,OAAO,CAAC,GAAGM,qBAAJ,EAA2B,GAAGC,cAA9B,CAAP;EACD;;EAUsB,MAAjBI,iBAAiB,CAACV,WAAD,EAAcD,OAAd,EAAuB;IAC5C,OAAO,EAAP;EACD;;EAODY,4BAA4B,CAACC,QAAQ,GAAG,IAAIC,GAAJ,EAAZ,EAAuBC,UAAU,GAAG,IAAID,GAAJ,EAApC,EAA+C;IAKzE,MAAME,cAAc,GAAG,EAAvB;;IACA,KAAK,MAAM,CAAChB,OAAD,EAAUiB,QAAV,CAAX,IAAkCJ,QAAQ,CAACK,OAAT,EAAlC,EAAsD;MACpD,IAAIC,eAAA,CAAEC,OAAF,CAAUH,QAAV,CAAJ,EAAyB;QACvB;MACD;;MAEDD,cAAc,CAACK,IAAf,CACG,GAAE,KAAKhC,aAAc,KAAIW,OAAQ,SAAQsB,aAAA,CAAKC,SAAL,CACxC,OADwC,EAExCN,QAAQ,CAACO,MAF+B,CAGxC,6BAJJ;;MAMA,KAAK,MAAMC,OAAX,IAAsBR,QAAtB,EAAgC;QAC9BD,cAAc,CAACK,IAAf,CACG,OAAMI,OAAO,CAACC,GAAI,kBAAnB,GAAwC,GAAEC,IAAI,CAACC,SAAL,CAAeH,OAAO,CAACI,GAAvB,CAA4B,GADxE;MAGD;IACF;;IAED,MAAMC,gBAAgB,GAAG,EAAzB;;IACA,KAAK,MAAM,CAAC9B,OAAD,EAAU+B,QAAV,CAAX,IAAkChB,UAAU,CAACG,OAAX,EAAlC,EAAwD;MACtD,IAAIC,eAAA,CAAEC,OAAF,CAAUW,QAAV,CAAJ,EAAyB;QACvB;MACD;;MACD,MAAMC,WAAW,GAAGb,eAAA,CAAEc,UAAF,CAAa,KAAK5C,aAAlB,CAApB;;MACA,MAAM6C,sBAAsB,GAAGZ,aAAA,CAAKC,SAAL,CAAe,mBAAf,EAAoCQ,QAAQ,CAACP,MAA7C,EAAqD,IAArD,CAA/B;;MACAM,gBAAgB,CAACT,IAAjB,CAAuB,GAAEW,WAAY,KAAIhC,OAAQ,SAAQkC,sBAAuB,IAAhF;;MACA,KAAK,MAAMC,OAAX,IAAsBJ,QAAtB,EAAgC;QAC9BD,gBAAgB,CAACT,IAAjB,CAAuB,OAAMc,OAAQ,EAArC;MACD;IACF;;IAED,OAAO;MAACnB,cAAD;MAAiBc;IAAjB,CAAP;EACD;;EAac,MAATM,SAAS,CAACC,IAAD,EAAO;IAKpB,MAAMxB,QAAQ,GAAG,IAAIC,GAAJ,EAAjB;IAKA,MAAMC,UAAU,GAAG,IAAID,GAAJ,EAAnB;;IAEA,KAAK,MAAM,CAACd,OAAD,EAAUC,WAAV,CAAX,IAAqCkB,eAAA,CAAEmB,OAAF,CAAUD,IAAV,CAArC,EAAsD;MACpD,MAAM,CAACE,MAAD,EAASR,QAAT,IAAqB,MAAMvB,iBAAA,CAAEC,GAAF,CAAM,CACrC,KAAKV,WAAL,CAAiBC,OAAjB,EAA0BC,WAA1B,CADqC,EAErC,KAAKI,WAAL,CAAiBL,OAAjB,EAA0BC,WAA1B,CAFqC,CAAN,CAAjC;;MAIA,IAAIsC,MAAM,CAACf,MAAX,EAAmB;QACjB,OAAOa,IAAI,CAACrC,OAAD,CAAX;MACD;;MACDa,QAAQ,CAAC2B,GAAT,CAAaxC,OAAb,EAAsBuC,MAAtB;MACAxB,UAAU,CAACyB,GAAX,CAAexC,OAAf,EAAwB+B,QAAxB;IACD;;IAED,MAAM;MAACf,cAAD;MAAiBc;IAAjB,IAAqC,KAAKlB,4BAAL,CACzCC,QADyC,EAEzCE,UAFyC,CAA3C;;IAKA,IAAI,CAACI,eAAA,CAAEC,OAAF,CAAUJ,cAAV,CAAL,EAAgC;MAC9BxB,eAAA,CAAIiD,KAAJ,CACG,sBAAqBnB,aAAA,CAAKC,SAAL,CAAe,OAAf,EAAwBV,QAAQ,CAAC6B,IAAjC,EAAuC,IAAvC,CAA6C,qBACjE,KAAKpD,SACN,sBAAqB,KAAKO,YAAa,EAH1C;;MAKA,KAAK,MAAM8C,OAAX,IAAsB3B,cAAtB,EAAsC;QACpCxB,eAAA,CAAIiD,KAAJ,CAAUE,OAAV;MACD;IACF,CATD,MASO;MAGL,IAAI,CAACxB,eAAA,CAAEC,OAAF,CAAUU,gBAAV,CAAL,EAAkC;QAChCtC,eAAA,CAAIoD,IAAJ,CACG,sBAAqBtB,aAAA,CAAKC,SAAL,CACpB,SADoB,EAEpBR,UAAU,CAAC2B,IAFS,EAGpB,IAHoB,CAIpB,qBAAoB,KAAKpD,SAAU,sBAAqB,KAAKO,YAAa,EAL9E;;QAOA,KAAK,MAAM8C,OAAX,IAAsBb,gBAAtB,EAAwC;UACtCtC,eAAA,CAAIoD,IAAJ,CAASD,OAAT;QACD;MACF;IACF;;IACD,OAAON,IAAP;EACD;;EAQgB,MAAXQ,WAAW,GAAG;IAClB,IAAI,KAAKnD,cAAT,EAAyB;MACvB,OAAO,KAAKA,cAAZ;IACD;;IACD,MAAMoD,YAAY,GAAuCC,yBAAA,CAAe,KAAK1D,aAApB,CAAzD;IACA,MAAM2D,GAAG,GAAG,IAAIF,YAAJ,CAAiB;MAACG,MAAM,EAAE,IAAT;MAAeC,IAAI,EAAE;IAArB,CAAjB,CAAZ;IACA,MAAMC,QAAQ,GAAG,MAAMH,GAAG,CAACI,IAAJ,CAAS;MAACC,aAAa,EAAE,IAAhB;MAAsBC,WAAW,EAAE;IAAnC,CAAT,CAAvB;IACA,KAAK5D,cAAL,GAAsByD,QAAtB;IACA,OAAOA,QAAP;EACD;;EAY6B,MAAxBzC,wBAAwB,CAACT,WAAD,EAAcD,OAAd,EAAuB;IACnD,MAAM;MAACuD,aAAD;MAAgBC,WAAhB;MAA6BC,WAA7B;MAA0CC;IAA1C,IAAqDzD,WAA3D;IACA,MAAM8B,QAAQ,GAAG,EAAjB;IAEA,MAAM4B,aAAa,GAAG,EAAtB;;IACA,IAAI,CAACxC,eAAA,CAAEyC,QAAF,CAAWJ,WAAX,CAAL,EAA8B;MAC5BG,aAAa,CAACtC,IAAd,CAAmB,aAAnB;IACD;;IAED,IAAI,CAACnC,aAAa,CAAC2E,GAAd,CAAkBJ,WAAlB,CAAL,EAAqC;MACnCE,aAAa,CAACtC,IAAd,CAAmB,aAAnB;IACD;;IAED,MAAMW,WAAW,GAAGb,eAAA,CAAEc,UAAF,CAAa,KAAK5C,aAAlB,CAApB;;IAEA,IAAIsE,aAAa,CAACnC,MAAlB,EAA0B;MACxB,MAAMsC,4BAA4B,GAAGxC,aAAA,CAAKC,SAAL,CACnC,0BADmC,EAEnCoC,aAAa,CAACnC,MAFqB,EAGnC,IAHmC,CAArC;;MAKA,MAAMuC,iBAAiB,GAAGJ,aAAa,CAACK,GAAd,CAAmBC,KAAD,IAAY,IAAGA,KAAM,GAAvC,EAA2CC,IAA3C,CAAgD,IAAhD,CAA1B;MAEAnC,QAAQ,CAACV,IAAT,CACG,GAAEW,WAAY,KAAIhC,OAAQ,gBAAe0D,OAAQ,WAAUI,4BAA6B,KAAIC,iBAAkB,8HAA6H,KAAK1E,aAAc,cAAaW,OAAQ,mBAAkB,KAAKX,aAAc,YAAWW,OAAQ,sBAD9U;IAGD;;IAOD,MAAMmE,iBAAiB,GAAIC,MAAD,IACvB,GAAEpC,WAAY,KAAIhC,OAAQ,gBAAe0D,OAAQ,gEAA+DW,kBAAW,YAAWD,MAAO,EADhJ;;IAGA,IAAIjD,eAAA,CAAEyC,QAAF,CAAWL,aAAX,KAA6B,CAAC,IAAAe,iBAAA,EAAUD,kBAAV,EAAsBd,aAAtB,CAAlC,EAAwE;MACtE,MAAMJ,QAAQ,GAAG,MAAM,KAAKN,WAAL,EAAvB;MACA,MAAM0B,WAAW,GAA8CpB,QAAQ,CAACnD,OAAD,CAAvE;;MACA,IAAIuE,WAAJ,aAAIA,WAAJ,eAAIA,WAAW,CAAEC,SAAjB,EAA4B;QAC1B,MAAM;UAACC,aAAD;UAAgBC;QAAhB,IAA4BH,WAAlC;;QACA,IAAI,CAACG,QAAL,EAAe;UACb3C,QAAQ,CAACV,IAAT,CACE8C,iBAAiB,CACd,wCAAuCZ,aAAc,sBAAqBG,OAAQ,UAASe,aAAc,YAD3F,CADnB;QAKD,CAND,MAMO;UACL1C,QAAQ,CAACV,IAAT,CACE8C,iBAAiB,CACd,wCAAuCZ,aAAc,mCAAkCG,OAAQ,kDAAiDW,kBAAW,GAD7I,CADnB;QAKD;MACF;IACF,CAnBD,MAmBO,IAAI,CAAClD,eAAA,CAAEyC,QAAF,CAAWL,aAAX,CAAL,EAAgC;MACrC,MAAMJ,QAAQ,GAAG,MAAM,KAAKN,WAAL,EAAvB;MACA,MAAM0B,WAAW,GAA8CpB,QAAQ,CAACnD,OAAD,CAAvE;;MACA,IAAI,EAACuE,WAAD,aAACA,WAAD,eAACA,WAAW,CAAEG,QAAd,KAA0BH,WAA1B,aAA0BA,WAA1B,eAA0BA,WAAW,CAAEE,aAA3C,EAA0D;QACxD1C,QAAQ,CAACV,IAAT,CACE8C,iBAAiB,CACd,yEAAwET,OAAQ,+CAA8C1D,OAAQ,SAAQuE,WAAW,CAACE,aAAc,YAD1J,CADnB;MAKD,CAND,MAMO;QACL1C,QAAQ,CAACV,IAAT,CACE8C,iBAAiB,CACd,kFAAiFT,OAAQ,4CAA2CW,kBAAW,KADjI,CADnB;MAKD;IACF;;IACD,OAAOtC,QAAP;EACD;;EAQD3B,iBAAiB,CAACH,WAAD,EAAcD,OAAd,EAAuB;IAEtC,MAAMiB,QAAQ,GAAG,EAAjB;IACA,MAAM;MAAC0D,MAAM,EAAEC;IAAT,IAA0B3E,WAAhC;;IACA,IAAIb,eAAe,CAACyF,gBAAhB,CAAiC5E,WAAjC,CAAJ,EAAmD;MACjD,IAAIkB,eAAA,CAAEyC,QAAF,CAAWgB,aAAX,CAAJ,EAA+B;QAC7B,IAAI,IAAAE,oCAAA,EAA6BF,aAA7B,CAAJ,EAAiD;UAC/C,IAAI;YACF,KAAKG,mBAAL,CAAyB/E,OAAzB,EAAkCC,WAAlC;UACD,CAFD,CAEE,OAAOyB,GAAP,EAAY;YACZT,QAAQ,CAACI,IAAT,CAAc;cACZK,GAAG,EAAG,qCAAoCkD,aAAc,KAAIlD,GAAG,CAACsD,OAAQ,EAD5D;cAEZnD,GAAG,EAAE+C;YAFO,CAAd;UAID;QACF,CATD,MASO;UACL3D,QAAQ,CAACI,IAAT,CAAc;YACZK,GAAG,EAAG,mDAAkD,CACtD,GAAGuD,iCADmD,EAEtDf,IAFsD,CAEjD,IAFiD,CAE3C,EAHD;YAIZrC,GAAG,EAAE+C;UAJO,CAAd;QAMD;MACF,CAlBD,MAkBO,IAAIzD,eAAA,CAAE+D,aAAF,CAAgBN,aAAhB,CAAJ,EAAoC;QACzC,IAAI;UACF,KAAKG,mBAAL,CAAyB/E,OAAzB,EAAkCC,WAAlC;QACD,CAFD,CAEE,OAAOyB,GAAP,EAAY;UACZT,QAAQ,CAACI,IAAT,CAAc;YACZK,GAAG,EAAG,uCAAsCA,GAAG,CAACsD,OAAQ,EAD5C;YAEZnD,GAAG,EAAE+C;UAFO,CAAd;QAID;MACF,CATM,MASA;QACL3D,QAAQ,CAACI,IAAT,CAAc;UACZK,GAAG,EAAE,yFADO;UAEZG,GAAG,EAAE+C;QAFO,CAAd;MAID;IACF;;IACD,OAAO3D,QAAP;EACD;;EASDf,wBAAwB,CAACD,WAAD,EAAcD,OAAd,EAAuB;IAC7C,MAAM;MAACmF,OAAD;MAAUzB,OAAV;MAAmB0B;IAAnB,IAAgCnF,WAAtC;IACA,MAAMgB,QAAQ,GAAG,EAAjB;;IAEA,IAAI,CAACE,eAAA,CAAEyC,QAAF,CAAWuB,OAAX,CAAL,EAA0B;MACxBlE,QAAQ,CAACI,IAAT,CAAc;QACZK,GAAG,EAAG,2GADM;QAEZG,GAAG,EAAEsD;MAFO,CAAd;IAID;;IAED,IAAI,CAAChE,eAAA,CAAEyC,QAAF,CAAWF,OAAX,CAAL,EAA0B;MACxBzC,QAAQ,CAACI,IAAT,CAAc;QACZK,GAAG,EAAG,wGADM;QAEZG,GAAG,EAAE6B;MAFO,CAAd;IAID;;IAED,IAAI,CAACvC,eAAA,CAAEyC,QAAF,CAAWwB,SAAX,CAAL,EAA4B;MAC1BnE,QAAQ,CAACI,IAAT,CAAc;QACZK,GAAG,EAAG,2IADM;QAEZG,GAAG,EAAEuD;MAFO,CAAd;IAID;;IAED,OAAOnE,QAAP;EACD;;EASDd,iBAAiB,CAACF,WAAD,EAAcD,OAAd,EAAuB;IAEtC,OAAO,EAAP;EACD;;EAQiB,MAAZqF,YAAY,CAACrF,OAAD,EAAUC,WAAV,EAAuB;IAACqF,KAAK,GAAG;EAAT,IAAiB,EAAxC,EAA4C;IAC5D,KAAK7F,QAAL,CAAc4F,YAAd,CAA2B,KAAKhG,aAAhC,EAA+CW,OAA/C,EAAwDC,WAAxD;;IACA,IAAIqF,KAAJ,EAAW;MACT,MAAM,KAAK7F,QAAL,CAAc6F,KAAd,EAAN;IACD;EACF;;EAQoB,MAAfC,eAAe,CAACvF,OAAD,EAAUC,WAAV,EAAuB;IAACqF,KAAK,GAAG;EAAT,IAAiB,EAAxC,EAA4C;IAC/D,KAAK/F,mBAAL,CAAyBS,OAAzB,IAAoC,EAClC,GAAG,KAAKT,mBAAL,CAAyBS,OAAzB,CAD+B;MAElC,GAAGC;IAF+B,CAApC;;IAIA,IAAIqF,KAAJ,EAAW;MACT,MAAM,KAAK7F,QAAL,CAAc6F,KAAd,EAAN;IACD;EACF;;EASoB,MAAfE,eAAe,CAACxF,OAAD,EAAU;IAACsF,KAAK,GAAG;EAAT,IAAiB,EAA3B,EAA+B;IAClD,OAAO,KAAK/F,mBAAL,CAAyBS,OAAzB,CAAP;;IACA,IAAIsF,KAAJ,EAAW;MACT,MAAM,KAAK7F,QAAL,CAAc6F,KAAd,EAAN;IACD;EACF;;EAODG,KAAK,CAACC,WAAD,EAAc;IACjB,IAAIvE,eAAA,CAAEC,OAAF,CAAU,KAAK7B,mBAAf,CAAJ,EAAyC;MACvCC,eAAA,CAAImG,IAAJ,CACG,MAAK,KAAKrG,SAAU,2BAA0B,KAAKQ,UAAW,qBAAoB,KAAKT,aAAc,IAAtG,GACE,gDAFJ;;MAIA;IACD;;IAEDG,eAAA,CAAImG,IAAJ,CAAU,aAAY,KAAKrG,SAAU,GAArC;;IACA,KAAK,MAAM,CAACU,OAAD,EAAUC,WAAV,CAAX,IACEkB,eAAA,CAAEmB,OAAF,CAAU,KAAK/C,mBAAf,CADF,EAEG;MACDC,eAAA,CAAImG,IAAJ,CAAU,OAAM,KAAKC,aAAL,CAAmB5F,OAAnB,EAA4BC,WAA5B,CAAyC,EAAzD;IACD;EACF;;EAUD2F,aAAa,CAAC5F,OAAD,EAAUC,WAAV,EAAuB;IAClC,MAAM,IAAI4F,KAAJ,CAAU,wCAAV,CAAN;EACD;;EAMDC,cAAc,CAAC9F,OAAD,EAAU;IACtB,OAAO+F,aAAA,CAAK7B,IAAL,CAAU,KAAKpE,UAAf,EAA2B,cAA3B,EAA2C,KAAKP,mBAAL,CAAyBS,OAAzB,EAAkC0D,OAA7E,CAAP;EACD;;EAODsC,OAAO,CAAChG,OAAD,EAAU;IACf,MAAM;MAACoF;IAAD,IAAc,KAAK7F,mBAAL,CAAyBS,OAAzB,CAApB;IACA,MAAMiG,OAAO,GAAG,KAAKH,cAAL,CAAoB9F,OAApB,CAAhB;IAEA,IAAIkG,WAAJ;;IACA,IAAI;MACFA,WAAW,GAAGF,OAAO,CAACG,OAAR,CAAgBF,OAAhB,CAAd;IACD,CAFD,CAEE,OAAOvE,GAAP,EAAY;MACZ,MAAM,IAAI0E,cAAJ,CAAoB,oBAAmB,KAAK/G,aAAc,iBAAgB4G,OAAQ,EAAlF,CAAN;IACD;;IAED,IAAII,OAAO,CAACC,GAAR,CAAYC,wBAAZ,IAAwCP,OAAO,CAACQ,KAAR,CAAcN,WAAd,CAA5C,EAAwE;MACtE1G,eAAA,CAAIiH,KAAJ,CAAW,YAAWP,WAAY,qBAAlC;;MACA,OAAOF,OAAO,CAACQ,KAAR,CAAcN,WAAd,CAAP;IACD;;IACD1G,eAAA,CAAIiH,KAAJ,CAAW,aAAY,KAAKpH,aAAc,OAAM4G,OAAQ,EAAxD;;IACA,MAAMS,SAAS,GAAGV,OAAO,CAACC,OAAD,CAAP,CAAiBb,SAAjB,CAAlB;;IACA,IAAI,CAACsB,SAAL,EAAgB;MACd,MAAM,IAAIN,cAAJ,CACH,iCAAgChB,SAAU,iBAAgB,KAAK/F,aAAc,KAAIW,OAAQ,GADtF,CAAN;IAGD;;IACD,OAAO0G,SAAP;EACD;;EAMDC,WAAW,CAAC3G,OAAD,EAAU;IACnB,OAAOmB,eAAA,CAAEyF,QAAF,CAAWC,MAAM,CAACC,IAAP,CAAY,KAAKvH,mBAAjB,CAAX,EAAkDS,OAAlD,CAAP;EACD;;EAY0B,OAApB+G,oBAAoB,CAACjH,UAAD,EAAakH,OAAb,EAAsBhH,OAAtB,EAA+BC,WAA/B,EAA4C;IACrE,MAAM;MAACyD,OAAD;MAAUiB,MAAM,EAAEC;IAAlB,IAAmC3E,WAAzC;;IACA,IAAI,CAAC2E,aAAL,EAAoB;MAClB,MAAM,IAAIqC,SAAJ,CACH,8CAA6CD,OAAQ,IAAGtD,OAAQ,wCAD7D,CAAN;IAGD;;IACD,IAAIwD,YAAJ;;IACA,IAAI/F,eAAA,CAAEyC,QAAF,CAAWgB,aAAX,CAAJ,EAA+B;MAC7B,MAAMuC,UAAU,GAAG,IAAAC,oBAAA,EAAYtH,UAAZ,EAAwBiG,aAAA,CAAK7B,IAAL,CAAUR,OAAV,EAAmBkB,aAAnB,CAAxB,CAAnB;MACAsC,YAAY,GAAGlB,OAAO,CAACmB,UAAD,CAAtB;IACD,CAHD,MAGO;MACLD,YAAY,GAAGtC,aAAf;IACD;;IAED,MAAMD,MAAM,GAAGuC,YAAY,CAACG,UAAb,GAA0BH,YAAY,CAACI,OAAvC,GAAiDJ,YAAhE;IACA,IAAAK,sBAAA,EAAeP,OAAf,EAAwBhH,OAAxB,EAAiC2E,MAAjC;IACA,OAAOA,MAAP;EACD;;EASsB,OAAhBE,gBAAgB,CAAC5E,WAAD,EAAc;IACnC,OAAOkB,eAAA,CAAEyC,QAAF,CAAW3D,WAAX,aAAWA,WAAX,uBAAWA,WAAW,CAAE0E,MAAxB,KAAmCxD,eAAA,CAAEqG,QAAF,CAAWvH,WAAX,aAAWA,WAAX,uBAAWA,WAAW,CAAE0E,MAAxB,CAA1C;EACD;;EASDI,mBAAmB,CAAC/E,OAAD,EAAUC,WAAV,EAAuB;IACxC,OAAOb,eAAe,CAAC2H,oBAAhB,CACL,KAAKjH,UADA,EAEL,KAAKT,aAFA,EAGLW,OAHK,EAILC,WAJK,CAAP;EAMD;;AA5jB0B"}

package/build/lib/extension/index.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -25,6 +23,8 @@ var _pluginConfig = require("./plugin-config");
 
 var _bluebird = _interopRequireDefault(require("bluebird"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 async function loadExtensions(appiumHome) {
   const manifest = _manifest.Manifest.getInstance(appiumHome);
 
@@ -72,4 +72,4 @@ function getActiveDrivers(driverConfig, useDrivers = []) {
     }
   })));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","read","driverConfig","DriverConfig","create","pluginConfig","PluginConfig","B","all","validate","getActivePlugins","usePlugins","Map","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName","DriverClass"],"sources":["../../../lib/extension/index.js"],"sourcesContent":["import _ from 'lodash';\nimport {USE_ALL_PLUGINS} from '../constants';\nimport log from '../logger';\nimport {DriverConfig} from './driver-config';\nimport {Manifest} from './manifest';\nimport {PluginConfig} from './plugin-config';\nimport B from 'bluebird';\n\n/**\n * Loads extensions and creates `ExtensionConfig` instances.\n *\n * - Reads the manifest file, creating if necessary\n * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances\n * - Returns these instances\n *\n * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.\n * @param {string} appiumHome\n * @returns {Promise<ExtensionConfigs>}\n */\nexport async function loadExtensions(appiumHome) {\n  const manifest = Manifest.getInstance(appiumHome);\n  await manifest.read();\n  const driverConfig = DriverConfig.getInstance(manifest) ?? DriverConfig.create(manifest);\n  const pluginConfig = PluginConfig.getInstance(manifest) ?? PluginConfig.create(manifest);\n\n  await B.all([driverConfig.validate(), pluginConfig.validate()]);\n  return {driverConfig, pluginConfig};\n}\n\n/**\n * Find any plugin name which has been installed, and which has been requested for activation by\n * using the --use-plugins flag, and turn each one into its class, so we can send them as objects\n * to the server init. We also want to send/assign them to the umbrella driver so it can use them\n * to wrap command execution\n *\n * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config\n * @param {string[]} usePlugins\n * @returns {PluginNameMap} Mapping of PluginClass to name\n */\nexport function getActivePlugins(pluginConfig, usePlugins = []) {\n  return new Map(\n    _.compact(\n      Object.keys(pluginConfig.installedExtensions)\n        .filter(\n          (pluginName) =>\n            _.includes(usePlugins, pluginName) ||\n            (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS)\n        )\n        .map((pluginName) => {\n          try {\n            log.info(`Attempting to load plugin ${pluginName}...`);\n            const PluginClass = pluginConfig.require(pluginName);\n            return [PluginClass, pluginName];\n          } catch (err) {\n            log.error(\n              `Could not load plugin '${pluginName}', so it will not be available. Error ` +\n                `in loading the plugin was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * Find any driver name which has been installed, and turn each one into its class, so we can send\n * them as objects to the server init in case they need to add methods/routes or update the server.\n * If the --drivers flag was given, this method only loads the given drivers.\n *\n * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config\n * @param {string[]} [useDrivers] - optional list of drivers to load\n * @returns {DriverNameMap}\n */\nexport function getActiveDrivers(driverConfig, useDrivers = []) {\n  return new Map(\n    _.compact(\n      Object.keys(driverConfig.installedExtensions)\n        .filter((driverName) => _.includes(useDrivers, driverName) || useDrivers.length === 0)\n        .map((driverName) => {\n          try {\n            log.info(`Attempting to load driver ${driverName}...`);\n            const DriverClass = driverConfig.require(driverName);\n            return [DriverClass, driverName];\n          } catch (err) {\n            log.error(\n              `Could not load driver '${driverName}', so it will not be available. Error ` +\n                `in loading the driver was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * A mapping of {@linkcode PluginClass} classes to their names.\n * @typedef {Map<PluginClass,string>} PluginNameMap\n */\n\n/**\n * A mapping of {@linkcode DriverClass} classes to their names.\n * @typedef {Map<DriverClass,string>} DriverNameMap\n */\n\n/**\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('@appium/types').DriverClass} DriverClass\n */\n\n/**\n * @typedef ExtensionConfigs\n * @property {import('./driver-config').DriverConfig} driverConfig\n * @property {import('./plugin-config').PluginConfig} pluginConfig\n */\n"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,eAAeA,cAAf,CAA8BC,UAA9B,EAA0C;EAC/C,MAAMC,QAAQ,GAAGC,kBAAA,CAASC,WAAT,CAAqBH,UAArB,CAAjB;;EACA,MAAMC,QAAQ,CAACG,IAAT,EAAN;;EACA,MAAMC,YAAY,GAAGC,0BAAA,CAAaH,WAAb,CAAyBF,QAAzB,KAAsCK,0BAAA,CAAaC,MAAb,CAAoBN,QAApB,CAA3D;;EACA,MAAMO,YAAY,GAAGC,0BAAA,CAAaN,WAAb,CAAyBF,QAAzB,KAAsCQ,0BAAA,CAAaF,MAAb,CAAoBN,QAApB,CAA3D;;EAEA,MAAMS,iBAAA,CAAEC,GAAF,CAAM,CAACN,YAAY,CAACO,QAAb,EAAD,EAA0BJ,YAAY,CAACI,QAAb,EAA1B,CAAN,CAAN;EACA,OAAO;IAACP,YAAD;IAAeG;EAAf,CAAP;AACD;;AAYM,SAASK,gBAAT,CAA0BL,YAA1B,EAAwCM,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAIC,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,eAAA,CAAEO,QAAF,CAAWT,UAAX,EAAuBQ,UAAvB,KACCR,UAAU,CAACU,MAAX,KAAsB,CAAtB,IAA2BV,UAAU,CAAC,CAAD,CAAV,KAAkBW,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;IACnB,IAAI;MACFK,eAAA,CAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;MACA,MAAMO,WAAW,GAAGrB,YAAY,CAACsB,OAAb,CAAqBR,UAArB,CAApB;;MACA,OAAO,CAACO,WAAD,EAAcP,UAAd,CAAP;IACD,CAJD,CAIE,OAAOS,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAlBH,CADF,CADK,CAAP;AAuBD;;AAWM,SAASC,gBAAT,CAA0B/B,YAA1B,EAAwCgC,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAItB,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYd,YAAY,CAACe,mBAAzB,EACGC,MADH,CACWiB,UAAD,IAAgBtB,eAAA,CAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CADtF,EAEGE,GAFH,CAEQY,UAAD,IAAgB;IACnB,IAAI;MACFX,eAAA,CAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;MACA,MAAMC,WAAW,GAAGlC,YAAY,CAACyB,OAAb,CAAqBQ,UAArB,CAApB;;MACA,OAAO,CAACC,WAAD,EAAcD,UAAd,CAAP;IACD,CAJD,CAIE,OAAOP,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAdH,CADF,CADK,CAAP;AAmBD"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","read","driverConfig","DriverConfig","create","pluginConfig","PluginConfig","B","all","validate","getActivePlugins","usePlugins","Map","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName","DriverClass"],"sources":["../../../lib/extension/index.js"],"sourcesContent":["import _ from 'lodash';\nimport {USE_ALL_PLUGINS} from '../constants';\nimport log from '../logger';\nimport {DriverConfig} from './driver-config';\nimport {Manifest} from './manifest';\nimport {PluginConfig} from './plugin-config';\nimport B from 'bluebird';\n\n/**\n * Loads extensions and creates `ExtensionConfig` instances.\n *\n * - Reads the manifest file, creating if necessary\n * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances\n * - Returns these instances\n *\n * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.\n * @param {string} appiumHome\n * @returns {Promise<ExtensionConfigs>}\n */\nexport async function loadExtensions(appiumHome) {\n  const manifest = Manifest.getInstance(appiumHome);\n  await manifest.read();\n  const driverConfig = DriverConfig.getInstance(manifest) ?? DriverConfig.create(manifest);\n  const pluginConfig = PluginConfig.getInstance(manifest) ?? PluginConfig.create(manifest);\n\n  await B.all([driverConfig.validate(), pluginConfig.validate()]);\n  return {driverConfig, pluginConfig};\n}\n\n/**\n * Find any plugin name which has been installed, and which has been requested for activation by\n * using the --use-plugins flag, and turn each one into its class, so we can send them as objects\n * to the server init. We also want to send/assign them to the umbrella driver so it can use them\n * to wrap command execution\n *\n * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config\n * @param {string[]} usePlugins\n * @returns {PluginNameMap} Mapping of PluginClass to name\n */\nexport function getActivePlugins(pluginConfig, usePlugins = []) {\n  return new Map(\n    _.compact(\n      Object.keys(pluginConfig.installedExtensions)\n        .filter(\n          (pluginName) =>\n            _.includes(usePlugins, pluginName) ||\n            (usePlugins.length === 1 && usePlugins[0] === USE_ALL_PLUGINS)\n        )\n        .map((pluginName) => {\n          try {\n            log.info(`Attempting to load plugin ${pluginName}...`);\n            const PluginClass = pluginConfig.require(pluginName);\n            return [PluginClass, pluginName];\n          } catch (err) {\n            log.error(\n              `Could not load plugin '${pluginName}', so it will not be available. Error ` +\n                `in loading the plugin was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * Find any driver name which has been installed, and turn each one into its class, so we can send\n * them as objects to the server init in case they need to add methods/routes or update the server.\n * If the --drivers flag was given, this method only loads the given drivers.\n *\n * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config\n * @param {string[]} [useDrivers] - optional list of drivers to load\n * @returns {DriverNameMap}\n */\nexport function getActiveDrivers(driverConfig, useDrivers = []) {\n  return new Map(\n    _.compact(\n      Object.keys(driverConfig.installedExtensions)\n        .filter((driverName) => _.includes(useDrivers, driverName) || useDrivers.length === 0)\n        .map((driverName) => {\n          try {\n            log.info(`Attempting to load driver ${driverName}...`);\n            const DriverClass = driverConfig.require(driverName);\n            return [DriverClass, driverName];\n          } catch (err) {\n            log.error(\n              `Could not load driver '${driverName}', so it will not be available. Error ` +\n                `in loading the driver was: ${err.message}`\n            );\n            log.debug(err.stack);\n          }\n        })\n    )\n  );\n}\n\n/**\n * A mapping of {@linkcode PluginClass} classes to their names.\n * @typedef {Map<PluginClass,string>} PluginNameMap\n */\n\n/**\n * A mapping of {@linkcode DriverClass} classes to their names.\n * @typedef {Map<DriverClass,string>} DriverNameMap\n */\n\n/**\n * @typedef {import('@appium/types').PluginClass} PluginClass\n * @typedef {import('@appium/types').DriverClass} DriverClass\n */\n\n/**\n * @typedef ExtensionConfigs\n * @property {import('./driver-config').DriverConfig} driverConfig\n * @property {import('./plugin-config').PluginConfig} pluginConfig\n */\n"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;AAaO,eAAeA,cAAf,CAA8BC,UAA9B,EAA0C;EAC/C,MAAMC,QAAQ,GAAGC,kBAAA,CAASC,WAAT,CAAqBH,UAArB,CAAjB;;EACA,MAAMC,QAAQ,CAACG,IAAT,EAAN;;EACA,MAAMC,YAAY,GAAGC,0BAAA,CAAaH,WAAb,CAAyBF,QAAzB,KAAsCK,0BAAA,CAAaC,MAAb,CAAoBN,QAApB,CAA3D;;EACA,MAAMO,YAAY,GAAGC,0BAAA,CAAaN,WAAb,CAAyBF,QAAzB,KAAsCQ,0BAAA,CAAaF,MAAb,CAAoBN,QAApB,CAA3D;;EAEA,MAAMS,iBAAA,CAAEC,GAAF,CAAM,CAACN,YAAY,CAACO,QAAb,EAAD,EAA0BJ,YAAY,CAACI,QAAb,EAA1B,CAAN,CAAN;EACA,OAAO;IAACP,YAAD;IAAeG;EAAf,CAAP;AACD;;AAYM,SAASK,gBAAT,CAA0BL,YAA1B,EAAwCM,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAIC,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,eAAA,CAAEO,QAAF,CAAWT,UAAX,EAAuBQ,UAAvB,KACCR,UAAU,CAACU,MAAX,KAAsB,CAAtB,IAA2BV,UAAU,CAAC,CAAD,CAAV,KAAkBW,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;IACnB,IAAI;MACFK,eAAA,CAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;MACA,MAAMO,WAAW,GAAGrB,YAAY,CAACsB,OAAb,CAAqBR,UAArB,CAApB;;MACA,OAAO,CAACO,WAAD,EAAcP,UAAd,CAAP;IACD,CAJD,CAIE,OAAOS,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAlBH,CADF,CADK,CAAP;AAuBD;;AAWM,SAASC,gBAAT,CAA0B/B,YAA1B,EAAwCgC,UAAU,GAAG,EAArD,EAAyD;EAC9D,OAAO,IAAItB,GAAJ,CACLC,eAAA,CAAEC,OAAF,CACEC,MAAM,CAACC,IAAP,CAAYd,YAAY,CAACe,mBAAzB,EACGC,MADH,CACWiB,UAAD,IAAgBtB,eAAA,CAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CADtF,EAEGE,GAFH,CAEQY,UAAD,IAAgB;IACnB,IAAI;MACFX,eAAA,CAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;MACA,MAAMC,WAAW,GAAGlC,YAAY,CAACyB,OAAb,CAAqBQ,UAArB,CAApB;;MACA,OAAO,CAACC,WAAD,EAAcD,UAAd,CAAP;IACD,CAJD,CAIE,OAAOP,GAAP,EAAY;MACZJ,eAAA,CAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;MAIAN,eAAA,CAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;IACD;EACF,CAdH,CADF,CADK,CAAP;AAmBD"}