appium 2.0.0-beta.34 → 2.0.0-beta.38

package/build/lib/constants.js

@@ -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/extension/driver-config.d.ts

@@ -17,11 +17,10 @@ export class DriverConfig extends ExtensionConfig<"driver"> {
      * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.
      *
      * @param {Manifest} manifest
-     * @param {DriverConfigOptions} [opts]
      * @throws If `manifest` already associated with a `DriverConfig`
      * @returns {DriverConfig}
      */
-    static create(manifest: Manifest, { extData, logFn }?: DriverConfigOptions | undefined): DriverConfig;
+    static create(manifest: Manifest): DriverConfig;
     /**
      * Returns a DriverConfig associated with a Manifest
      * @param {Manifest} manifest
@@ -29,11 +28,10 @@ export class DriverConfig extends ExtensionConfig<"driver"> {
      */
     static getInstance(manifest: Manifest): DriverConfig | undefined;
     /**
-    * Call {@link DriverConfig.create} instead.
-    * @private
-    * @param {import('./manifest').Manifest} manifest - Manifest instance
-    * @param {DriverConfigOptions} [opts]
-    */
+     * Call {@link DriverConfig.create} instead.
+     * @private
+     * @param {import('./manifest').Manifest} manifest - Manifest instance
+     */
     private constructor();
     /**
      * A set of unique automation names used by drivers.
@@ -41,41 +39,40 @@ export class DriverConfig extends ExtensionConfig<"driver"> {
      */
     knownAutomationNames: Set<string>;
     /**
-    * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.
-    * @param {Capabilities} caps
-    * @returns {MatchedDriver}
-    */
-    findMatchingDriver({ automationName, platformName }: Capabilities): MatchedDriver;
+     * Checks extensions for problems
+     */
+    validate(): Promise<import("./extension-config").ExtRecord<"driver">>;
     /**
-    * Given an automation name and platform name, find a suitable driver and return its extension data.
-    * @param {string} matchAutomationName
-    * @param {string} matchPlatformName
-    * @returns {ExtMetadata<DriverType> & import('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata}
-    */
-    _getDriverBySupport(matchAutomationName: string, matchPlatformName: string): ExtMetadata<DriverType> & import('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata;
-}
-export type DriverConfigOptions = {
+     * @param {ExtManifest<DriverType>} extData
+     * @returns {import('./extension-config').ExtManifestProblem[]}
+     */
+    getConfigProblems(extData: ExtManifest<DriverType>): import('./extension-config').ExtManifestProblem[];
     /**
-     * - Optional logging function
+     * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.
+     * @param {Capabilities} caps
+     * @returns {MatchedDriver}
      */
-    logFn?: import("./extension-config").ExtensionLogFn | undefined;
+    findMatchingDriver({ automationName, platformName }: Capabilities): MatchedDriver;
     /**
-     * - Extension data
+     * Given an automation name and platform name, find a suitable driver and return its extension data.
+     * @param {string} matchAutomationName
+     * @param {string} matchPlatformName
+     * @returns {ExtMetadata<DriverType> & import('appium/types').InternalMetadata & import('appium/types').CommonExtMetadata}
      */
-    extData?: import("../../types").DriverRecord | undefined;
-};
-export type ExtMetadata<T> = import('../../types').ExtMetadata<T>;
-export type ExtManifest<T> = import('../../types').ExtManifest<T>;
-export type ManifestData = import('../../types').ManifestData;
-export type DriverType = import('../../types').DriverType;
+    _getDriverBySupport(matchAutomationName: string, matchPlatformName: string): ExtMetadata<DriverType> & import('appium/types').InternalMetadata & import('appium/types').CommonExtMetadata;
+}
+export type ExtMetadata<T> = import('appium/types').ExtMetadata<T>;
+export type ExtManifest<T> = import('appium/types').ExtManifest<T>;
+export type ManifestData = import('appium/types').ManifestData;
+export type DriverType = import('@appium/types').DriverType;
 export type Manifest = import('./manifest').Manifest;
-export type ExtRecord<T> = import('../../types').ExtRecord<T>;
-export type ExtName<T> = import('../../types').ExtName<T>;
+export type ExtRecord<T> = import('appium/types').ExtRecord<T>;
+export type ExtName<T> = import('appium/types').ExtName<T>;
 /**
  * Return value of {@linkcode DriverConfig.findMatchingDriver }
  */
 export type MatchedDriver = {
-    driver: BaseDriverBase<import("@appium/types").ExternalDriver, import("../../types").ExternalDriverStatic>;
+    driver: import('@appium/types').DriverClass;
     version: string;
     driverName: string;
 };

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":"AAMA;;GAEG;AACH;IAQE;;;;;;;;;OASG;IACF,0BAAkC;IAkBlC;;;;;;;OAOG;IACH,wBALW,QAAQ,yDAGN,YAAY,CASxB;IAED;;;;OAIG;IACH,6BAHW,QAAQ,GACN,YAAY,GAAC,SAAS,CAIlC;IAxCD;;;;;MAKE;IACF,sBAQC;IAhCF;;;OAGG;IACH,sBAFU,IAAI,MAAM,CAAC,CAEA;IAuHpB;;;;MAIE;IACF,qDAHU,YAAY,GACV,aAAa,CAmCxB;IAED;;;;;MAKE;IACF,yCAJU,MAAM,qBACN,MAAM,GACJ,YAAY,UAAU,CAAC,GAAG,OAAO,6BAA6B,EAAE,gBAAgB,GAAG,OAAO,+BAA+B,EAAE,cAAc,CAwBpJ;CACH;;;;;;;;;;;6BAUY,OAAO,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;6BAKpC,OAAO,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;2BAIpC,OAAO,aAAa,EAAE,YAAY;yBAClC,OAAO,aAAa,EAAE,UAAU;uBAChC,OAAO,YAAY,EAAE,QAAQ;2BAK7B,OAAO,aAAa,EAAE,SAAS,CAAC,CAAC,CAAC;yBAKlC,OAAO,aAAa,EAAE,OAAO,CAAC,CAAC,CAAC;;;;;;aAQ/B,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;;;;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"}

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

@@ -21,26 +21,13 @@ class DriverConfig extends _extensionConfig.ExtensionConfig {
   knownAutomationNames;
   static _instances = new WeakMap();
 
-  constructor(manifest, {
-    logFn,
-    extData
-  } = {}) {
-    super(_constants.DRIVER_TYPE, manifest, logFn);
+  constructor(manifest) {
+    super(_constants.DRIVER_TYPE, manifest);
     this.knownAutomationNames = new Set();
-
-    if (extData) {
-      this.validate(extData);
-    }
   }
 
-  static create(manifest, {
-    extData,
-    logFn
-  } = {}) {
-    const instance = new DriverConfig(manifest, {
-      logFn,
-      extData
-    });
+  static create(manifest) {
+    const instance = new DriverConfig(manifest);
 
     if (DriverConfig.getInstance(manifest)) {
       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);
@@ -55,9 +42,9 @@ class DriverConfig extends _extensionConfig.ExtensionConfig {
     return DriverConfig._instances.get(manifest);
   }
 
-  validate(exts) {
+  async validate() {
     this.knownAutomationNames.clear();
-    return super.validate(exts);
+    return await super._validate(this.manifest.getExtensionData(_constants.DRIVER_TYPE));
   }
 
   getConfigProblems(extData) {
@@ -187,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","logFn","extData","DRIVER_TYPE","Set","validate","create","instance","getInstance","Error","appiumHome","set","get","exts","clear","getConfigProblems","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":["\nimport _ 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  /**\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   * @param {DriverConfigOptions} [opts]\n   */\n   constructor (manifest, {logFn, extData} = {}) {\n     super(DRIVER_TYPE, manifest, logFn);\n\n     this.knownAutomationNames = new Set();\n\n     if (extData) {\n       this.validate(extData);\n     }\n   }\n\n   /**\n    * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n    *\n    * @param {Manifest} manifest\n    * @param {DriverConfigOptions} [opts]\n    * @throws If `manifest` already associated with a `DriverConfig`\n    * @returns {DriverConfig}\n    */\n   static create (manifest, {extData, logFn} = {}) {\n     const instance = new DriverConfig(manifest, {logFn, extData});\n     if (DriverConfig.getInstance(manifest)) {\n       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);\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   * @param {ExtRecord<DriverType>} exts\n   */\n   validate (exts) {\n     this.knownAutomationNames.clear();\n     return super.validate(exts);\n   }\n\n   /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').Problem[]}\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({err: 'Incorrectly formatted platformName.', val: pName});\n           }\n         }\n       }\n     }\n\n     if (!_.isString(automationName)) {\n       problems.push({err: 'Missing or incorrect automationName', val: automationName});\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(`Attempting to find matching driver for automationName ` +\n             `'${automationName}' and platformName '${platformName}'`);\n\n     try {\n       const {\n         driverName,\n         mainClass,\n         version,\n       } = this._getDriverBySupport(automationName, platformName);\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(`Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`);\n       }\n       return {driver, version, driverName};\n     } catch (err) {\n       const msg = `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('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata}\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(platformNames.map(_.toLower),\n                                      matchPlatformName.toLowerCase());\n\n       if (aNameMatches && pNameMatches) {\n         return {driverName, ...driverData};\n       }\n\n       if (aNameMatches) {\n         throw new Error(`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     throw new Error(`Could not find installed driver to support given caps`);\n   }\n}\n\n/**\n * @typedef DriverConfigOptions\n * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function\n * @property {ManifestData['drivers']} [extData] - Extension data\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('../../types').ManifestData} ManifestData\n * @typedef {import('../../types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtName<T>} ExtName\n */\n\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('../../types/extension').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   * @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":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAKO,MAAMA,YAAN,SAA2BC,gCAA3B,CAA2C;EAKhDC,oBAAoB;EAYH,OAAVC,UAAU,GAAG,IAAIC,OAAJ,EAAH;;EAOjBC,WAAW,CAACC,QAAD,EAAW;IACpB,MAAMC,sBAAN,EAAmBD,QAAnB;IAEA,KAAKJ,oBAAL,GAA4B,IAAIM,GAAJ,EAA5B;EACD;;EASY,OAANC,MAAM,CAACH,QAAD,EAAW;IACtB,MAAMI,QAAQ,GAAG,IAAIV,YAAJ,CAAiBM,QAAjB,CAAjB;;IACA,IAAIN,YAAY,CAACW,WAAb,CAAyBL,QAAzB,CAAJ,EAAwC;MACtC,MAAM,IAAIM,KAAJ,CACH,6BAA4BN,QAAQ,CAACO,UAAW,6EAD7C,CAAN;IAGD;;IACDb,YAAY,CAACG,UAAb,CAAwBW,GAAxB,CAA4BR,QAA5B,EAAsCI,QAAtC;;IACA,OAAOA,QAAP;EACD;;EAOiB,OAAXC,WAAW,CAACL,QAAD,EAAW;IAC3B,OAAON,YAAY,CAACG,UAAb,CAAwBY,GAAxB,CAA4BT,QAA5B,CAAP;EACD;;EAKa,MAARU,QAAQ,GAAG;IACf,KAAKd,oBAAL,CAA0Be,KAA1B;IACA,OAAO,MAAM,MAAMC,SAAN,CAAgB,KAAKZ,QAAL,CAAca,gBAAd,CAA+BZ,sBAA/B,CAAhB,CAAb;EACD;;EAMDa,iBAAiB,CAACC,OAAD,EAAU;IACzB,MAAMC,QAAQ,GAAG,EAAjB;IACA,MAAM;MAACC,aAAD;MAAgBC;IAAhB,IAAkCH,OAAxC;;IAEA,IAAI,CAACI,eAAA,CAAEC,OAAF,CAAUH,aAAV,CAAL,EAA+B;MAC7BD,QAAQ,CAACK,IAAT,CAAc;QACZC,GAAG,EAAE,oDADO;QAEZC,GAAG,EAAEN;MAFO,CAAd;IAID,CALD,MAKO;MACL,IAAIE,eAAA,CAAEK,OAAF,CAAUP,aAAV,CAAJ,EAA8B;QAC5BD,QAAQ,CAACK,IAAT,CAAc;UACZC,GAAG,EAAE,2BADO;UAEZC,GAAG,EAAEN;QAFO,CAAd;MAID,CALD,MAKO;QACL,KAAK,MAAMQ,KAAX,IAAoBR,aAApB,EAAmC;UACjC,IAAI,CAACE,eAAA,CAAEO,QAAF,CAAWD,KAAX,CAAL,EAAwB;YACtBT,QAAQ,CAACK,IAAT,CAAc;cACZC,GAAG,EAAE,qCADO;cAEZC,GAAG,EAAEE;YAFO,CAAd;UAID;QACF;MACF;IACF;;IAED,IAAI,CAACN,eAAA,CAAEO,QAAF,CAAWR,cAAX,CAAL,EAAiC;MAC/BF,QAAQ,CAACK,IAAT,CAAc;QACZC,GAAG,EAAE,qCADO;QAEZC,GAAG,EAAEL;MAFO,CAAd;IAID;;IAED,IAAI,KAAKtB,oBAAL,CAA0B+B,GAA1B,CAA8BT,cAA9B,CAAJ,EAAmD;MACjDF,QAAQ,CAACK,IAAT,CAAc;QACZC,GAAG,EAAE,4DADO;QAEZC,GAAG,EAAEL;MAFO,CAAd;IAID;;IAGD,KAAKtB,oBAAL,CAA0BgC,GAA1B,CAA8BV,cAA9B;IAEA,OAAOF,QAAP;EACD;;EAODa,aAAa,CAACC,UAAD,EAAa;IAACC,OAAD;IAAUb;EAAV,CAAb,EAAwC;IACnD,OAAQ,GAAEY,UAAW,IAAGC,OAAQ,qBAAoBb,cAAe,IAAnE;EACD;;EAODc,kBAAkB,CAAC;IAACd,cAAD;IAAiBe;EAAjB,CAAD,EAAiC;IACjD,IAAI,CAACd,eAAA,CAAEO,QAAF,CAAWO,YAAX,CAAL,EAA+B;MAC7B,MAAM,IAAI3B,KAAJ,CAAU,4CAAV,CAAN;IACD;;IAED,IAAI,CAACa,eAAA,CAAEO,QAAF,CAAWR,cAAX,CAAL,EAAiC;MAC/B,MAAM,IAAIZ,KAAJ,CAAU,+CAAV,CAAN;IACD;;IAED4B,eAAA,CAAIC,IAAJ,CACG,wDAAD,GACG,IAAGjB,cAAe,uBAAsBe,YAAa,GAF1D;;IAKA,IAAI;MACF,MAAM;QAACH,UAAD;QAAaM,SAAb;QAAwBL;MAAxB,IAAmC,KAAKM,mBAAL,CACvCnB,cADuC,EAEvCe,YAFuC,CAAzC;;MAIAC,eAAA,CAAIC,IAAJ,CAAU,QAAOL,UAAW,0CAA5B;;MACAI,eAAA,CAAIC,IAAJ,CAAU,sBAAqB,KAAKG,cAAL,CAAoBR,UAApB,CAAgC,EAA/D;;MACA,MAAMS,MAAM,GAAG,KAAKC,OAAL,CAAaV,UAAb,CAAf;;MACA,IAAI,CAACS,MAAL,EAAa;QACX,MAAM,IAAIjC,KAAJ,CACH,WAAUwB,UAAW,uCAAsCM,SAAU,sCADlE,CAAN;MAGD;;MACD,OAAO;QAACG,MAAD;QAASR,OAAT;QAAkBD;MAAlB,CAAP;IACD,CAdD,CAcE,OAAOR,GAAP,EAAY;MACZ,MAAMmB,GAAG,GACN,6CAAD,GACC,IAAGvB,cAAe,sBAAqBe,YAAa,KADrD,GAEC,kDAFD,GAGC,6DAHD,GAIC,uBAAsBX,GAAG,CAACoB,OAAQ,GALrC;MAMA,MAAM,IAAIpC,KAAJ,CAAUmC,GAAV,CAAN;IACD;EACF;;EAQDJ,mBAAmB,CAACM,mBAAD,EAAsBC,iBAAtB,EAAyC;IAC1D,MAAMC,OAAO,GAAG,KAAKC,mBAArB;;IACA,KAAK,MAAM,CAAChB,UAAD,EAAaiB,UAAb,CAAX,IAAuC5B,eAAA,CAAE6B,OAAF,CAAUH,OAAV,CAAvC,EAA2D;MACzD,MAAM;QAAC3B,cAAD;QAAiBD;MAAjB,IAAkC8B,UAAxC;MACA,MAAME,YAAY,GAAG/B,cAAc,CAACgC,WAAf,OAAiCP,mBAAmB,CAACO,WAApB,EAAtD;;MACA,MAAMC,YAAY,GAAGhC,eAAA,CAAEiC,QAAF,CACnBnC,aAAa,CAACoC,GAAd,CAAkBlC,eAAA,CAAEmC,OAApB,CADmB,EAEnBV,iBAAiB,CAACM,WAAlB,EAFmB,CAArB;;MAKA,IAAID,YAAY,IAAIE,YAApB,EAAkC;QAChC,OAAO;UAACrB,UAAD;UAAa,GAAGiB;QAAhB,CAAP;MACD;;MAED,IAAIE,YAAJ,EAAkB;QAChB,MAAM,IAAI3C,KAAJ,CACH,WAAUwB,UAAW,4BAAtB,GACG,IAAGZ,cAAe,+BADrB,GAEG,6BAA4B0B,iBAAkB,eAFjD,GAGG,qBAHH,GAIEW,IAAI,CAACC,SAAL,CAAevC,aAAf,CALE,CAAN;MAOD;IACF;;IAED,MAAM,IAAIX,KAAJ,CAAW,uDAAX,CAAN;EACD;;AAzM+C"}

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

@@ -4,7 +4,7 @@
  * Subclasses should provide the generic parameter to implement.
  * @template {ExtensionType} ExtType
  */
-export class ExtensionConfig<ExtType extends import("../../types").ExtensionType> {
+export class ExtensionConfig<ExtType extends import("@appium/types").ExtensionType> {
     /**
      * Intended to be called by corresponding instance methods of subclass.
      * @private
@@ -12,7 +12,7 @@ export class ExtensionConfig<ExtType extends import("../../types").ExtensionType
      * @param {string} appiumHome
      * @param {ExtType} extType
      * @param {ExtName<ExtType>} extName - Extension name (unique to its type)
-     * @param {ExtManifestWithSchema<ExtType>} extData - Extension config
+     * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension config
      * @returns {import('ajv').SchemaObject|undefined}
      */
     private static _readExtensionSchema;
@@ -20,15 +20,14 @@ export class ExtensionConfig<ExtType extends import("../../types").ExtensionType
      * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.
      * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.
      * @template {ExtensionType} ExtType
-     * @param {ExtManifest<ExtType>} extData
-     * @returns {extData is ExtManifestWithSchema<ExtType>}
+     * @param {ExtManifest<ExtType>} extManifest
+     * @returns {extManifest is ExtManifestWithSchema<ExtType>}
      */
-    static extDataHasSchema<ExtType_1 extends import("../../types").ExtensionType>(extData: ExtManifest<ExtType_1>): extData is ExtManifestWithSchema<ExtType_1>;
+    static extDataHasSchema<ExtType_1 extends import("@appium/types").ExtensionType>(extManifest: ExtManifest<ExtType_1>): extManifest is ExtManifestWithSchema<ExtType_1>;
     /**
      * @protected
      * @param {ExtType} extensionType - Type of extension
      * @param {Manifest} manifest - `Manifest` instance
-     * @param {ExtensionLogFn} [logFn]
      */
     protected constructor();
     /** @type {ExtType} */
@@ -37,50 +36,118 @@ export class ExtensionConfig<ExtType extends import("../../types").ExtensionType
     configKey: `${ExtType}s`;
     /** @type {ExtRecord<ExtType>} */
     installedExtensions: ExtRecord<ExtType>;
-    /** @type {ExtensionLogFn} */
-    log: ExtensionLogFn;
+    /** @type {import('@appium/types').AppiumLogger} */
+    log: import('@appium/types').AppiumLogger;
     /** @type {Manifest} */
     manifest: Manifest;
+    /**
+     * @type {ExtensionListData}
+     */
+    _listDataCache: ExtensionListData;
     get manifestPath(): string;
     get appiumHome(): string;
     /**
-     * Checks extensions for problems
-     * @param {ExtRecord<ExtType>} exts - Extension data
+     * Returns a list of errors for a given extension.
+     *
+     * @param {ExtName<ExtType>} extName
+     * @param {ExtManifest<ExtType>} extManifest
+     * @returns {ExtManifestProblem[]}
      */
-    validate(exts: ExtRecord<ExtType>): ExtRecord<ExtType>;
+    getProblems(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType>): ExtManifestProblem[];
     /**
-     * @param {ExtManifest<ExtType>} extData
+     * Returns a list of warnings for a given extension.
+     *
      * @param {ExtName<ExtType>} extName
-     * @returns {Problem[]}
+     * @param {ExtManifest<ExtType>} extManifest
+     * @returns {Promise<string[]>}
      */
-    getSchemaProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    getWarnings(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType>): Promise<string[]>;
     /**
-     * @param {ExtManifest<ExtType>} extData
+     * Returns a list of extension-type-specific issues. To be implemented by subclasses.
+     * @abstract
+     * @param {ExtManifest<ExtType>} extManifest
      * @param {ExtName<ExtType>} extName
-     * @returns {Problem[]}
+     * @returns {Promise<string[]>}
+     */
+    getConfigWarnings(extManifest: ExtManifest<ExtType>, extName: ExtName<ExtType>): Promise<string[]>;
+    /**
+     *
+     * @param {Map<ExtName<ExtType>,ExtManifestProblem[]>} [errorMap]
+     * @param {Map<ExtName<ExtType>,string[]>} [warningMap]
      */
-    getGenericConfigProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    getValidationResultSummaries(errorMap?: Map<string, ExtManifestProblem[]> | undefined, warningMap?: Map<string, string[]> | undefined): {
+        errorSummaries: string[];
+        warningSummaries: string[];
+    };
+    /**
+     * Checks extensions for problems.  To be called by subclasses' `validate` method.
+     *
+     * Errors and warnings will be displayed to the user.
+     *
+     * This method mutates `exts`.
+     *
+     * @protected
+     * @param {ExtRecord<ExtType>} exts - Lookup of extension names to {@linkcode ExtManifest} objects
+     * @returns {Promise<ExtRecord<ExtType>>} The same lookup, but picking only error-free extensions
+     */
+    protected _validate(exts: ExtRecord<ExtType>): Promise<ExtRecord<ExtType>>;
+    /**
+     * Retrieves listing data for extensions via command class.
+     * Caches the result in {@linkcode ExtensionConfig._listDataCache}
+     * @protected
+     * @returns {Promise<ExtensionListData>}
+     */
+    protected getListData(): Promise<ExtensionListData>;
+    /**
+     * Returns a list of warnings for a particular extension.
+     *
+     * By definition, a non-empty list of warnings does _not_ imply the extension cannot be loaded,
+     * but it may not work as expected or otherwise throw an exception at runtime.
+     *
+     * @param {ExtManifest<ExtType>} extManifest
+     * @param {ExtName<ExtType>} extName
+     * @returns {Promise<string[]>}
+     */
+    getGenericConfigWarnings(extManifest: ExtManifest<ExtType>, extName: ExtName<ExtType>): Promise<string[]>;
+    /**
+     * Returns list of unrecoverable errors (if any) for the given extension _if_ it has a `schema` property.
+     *
+     * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)
+     * @param {ExtName<ExtType>} extName - Extension name (from manifest)
+     * @returns {ExtManifestProblem[]}
+     */
+    getSchemaProblems(extManifest: ExtManifest<ExtType>, extName: ExtName<ExtType>): ExtManifestProblem[];
+    /**
+     * Return a list of generic unrecoverable errors for the given extension
+     * @param {ExtManifest<ExtType>} extManifest - Extension data (from manifest)
+     * @param {ExtName<ExtType>} extName - Extension name (from manifest)
+     * @returns {ExtManifestProblem[]}
+     */
+    getGenericConfigProblems(extManifest: ExtManifest<ExtType>, extName: ExtName<ExtType>): ExtManifestProblem[];
     /**
      * @abstract
-     * @param {ExtManifest<ExtType>} extData
-     * @returns {Problem[]}
+     * @param {ExtManifest<ExtType>} extManifest
+     * @param {ExtName<ExtType>} extName
+     * @returns {ExtManifestProblem[]}
      */
-    getConfigProblems(extData: ExtManifest<ExtType>): Problem[];
+    getConfigProblems(extManifest: ExtManifest<ExtType>, extName: ExtName<ExtType>): ExtManifestProblem[];
     /**
      * @param {string} extName
-     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtManifest<ExtType>} extManifest
      * @param {ExtensionConfigMutationOpts} [opts]
      * @returns {Promise<void>}
      */
-    addExtension(extName: string, extData: ExtManifest<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    addExtension(extName: string, extManifest: ExtManifest<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
     /**
      * @param {ExtName<ExtType>} extName
-     * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData
+     * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extManifest
      * @param {ExtensionConfigMutationOpts} [opts]
      * @returns {Promise<void>}
      */
-    updateExtension(extName: ExtName<ExtType>, extData: ExtManifest<ExtType> | import('../cli/extension-command').ExtensionFields<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    updateExtension(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType> | import('../cli/extension-command').ExtensionFields<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
     /**
+     * Remove an extension from the list of installed extensions, and optionally avoid a write to the manifest file.
+     *
      * @param {ExtName<ExtType>} extName
      * @param {ExtensionConfigMutationOpts} [opts]
      * @returns {Promise<void>}
@@ -94,11 +161,11 @@ export class ExtensionConfig<ExtType extends import("../../types").ExtensionType
     /**
      * Returns a string describing the extension. Subclasses must implement.
      * @param {ExtName<ExtType>} extName - Extension name
-     * @param {ExtManifest<ExtType>} extData - Extension data
+     * @param {ExtManifest<ExtType>} extManifest - Extension data
      * @returns {string}
      * @abstract
      */
-    extensionDesc(extName: ExtName<ExtType>, extData: ExtManifest<ExtType>): string;
+    extensionDesc(extName: ExtName<ExtType>, extManifest: ExtManifest<ExtType>): string;
     /**
      * @param {string} extName
      * @returns {string}
@@ -119,15 +186,17 @@ export class ExtensionConfig<ExtType extends import("../../types").ExtensionType
      * If an extension provides a schema, this will load the schema and attempt to
      * register it with the schema registrar.
      * @param {ExtName<ExtType>} extName - Name of extension
-     * @param {ExtManifestWithSchema<ExtType>} extData - Extension data
+     * @param {ExtManifestWithSchema<ExtType>} extManifest - Extension data
      * @returns {import('ajv').SchemaObject|undefined}
      */
-    readExtensionSchema(extName: ExtName<ExtType>, extData: ExtManifestWithSchema<ExtType>): import('ajv').SchemaObject | undefined;
+    readExtensionSchema(extName: ExtName<ExtType>, extManifest: ExtManifestWithSchema<ExtType>): import('ajv').SchemaObject | undefined;
 }
 /**
- * Config problem
+ * An issue with the {@linkcode ExtManifest } for a particular extension.
+ *
+ * The existance of such an object implies that the extension cannot be loaded.
  */
-export type Problem = {
+export type ExtManifestProblem = {
     /**
      * - Error message
      */
@@ -141,13 +210,14 @@ export type Problem = {
  * An optional logging function provided to an {@link ExtensionConfig } subclass.
  */
 export type ExtensionLogFn = (...args: any[]) => void;
-export type ExtensionType = import('../../types').ExtensionType;
+export type ExtensionType = import('@appium/types').ExtensionType;
 export type Manifest = import('./manifest').Manifest;
-export type ExtManifest<T> = import('../../types/appium-manifest').ExtManifest<T>;
-export type ExtManifestWithSchema<T> = import('../../types/appium-manifest').ExtManifestWithSchema<T>;
-export type ExtName<T> = import('../../types/appium-manifest').ExtName<T>;
-export type ExtClass<T> = import('../../types/extension').ExtClass<T>;
-export type ExtRecord<T> = import('../../types/appium-manifest').ExtRecord<T>;
+export type ExtManifest<T> = import('appium/types').ExtManifest<T>;
+export type ExtManifestWithSchema<T> = import('appium/types').ExtManifestWithSchema<T>;
+export type ExtName<T> = import('appium/types').ExtName<T>;
+export type ExtClass<T> = import('appium/types').ExtClass<T>;
+export type ExtRecord<T> = import('appium/types').ExtRecord<T>;
+export type ExtCommand<T> = import('../cli/extension').ExtCommand<T>;
 /**
  * Options for various methods in {@link ExtensionConfig }
  */
@@ -161,6 +231,8 @@ export type ExtensionConfigMutationOpts = {
  * A valid install type
  */
 export type InstallType = typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB;
+export type ExtensionListData = import('../cli/extension-command').ExtensionListData;
+export type InstalledExtensionListData = import('../cli/extension-command').InstalledExtensionListData;
 export const INSTALL_TYPE_NPM: "npm";
 export const INSTALL_TYPE_GIT: "git";
 export const INSTALL_TYPE_LOCAL: "local";

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

@@ -1 +1 @@
-{"version":3,"file":"extension-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/extension-config.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAkTE;;;;;;;;;OASG;IACH,oCAoBC;IAED;;;;;;OAMG;IACH,6JAEC;IA3UD;;;;;OAKG;IACH,wBAOC;IA5BD,sBAAsB;IACtB,eADW,OAAO,CACJ;IAEd,4BAA4B;IAC5B,WADW,GAAG,OAAO,GAAG,CACd;IAEV,iCAAiC;IACjC,qBADW,UAAU,OAAO,CAAC,CACT;IAEpB,6BAA6B;IAC7B,KADW,cAAc,CACrB;IAEJ,uBAAuB;IACvB,UADW,QAAQ,CACV;IAiBT,2BAEC;IAED,yBAEC;IAED;;;OAGG;IACH,eAFW,UAAU,OAAO,CAAC,sBAgD5B;IAED;;;;OAIG;IACH,2BAJW,YAAY,OAAO,CAAC,WACpB,QAAQ,OAAO,CAAC,GACd,OAAO,EAAE,CAyCrB;IAED;;;;OAIG;IAEH,kCALW,YAAY,OAAO,CAAC,WACpB,QAAQ,OAAO,CAAC,GACd,OAAO,EAAE,CAyCrB;IAED;;;;OAIG;IAEH,2BAJW,YAAY,OAAO,CAAC,GAClB,OAAO,EAAE,CAMrB;IAED;;;;;OAKG;IACH,sBALW,MAAM,WACN,YAAY,OAAO,CAAC,wDAElB,QAAQ,IAAI,CAAC,CAOzB;IAED;;;;;OAKG;IACH,yBALW,QAAQ,OAAO,CAAC,WAChB,YAAY,OAAO,CAAC,GAAC,OAAO,0BAA0B,EAAE,eAAe,CAAC,OAAO,CAAC,wDAE9E,QAAQ,IAAI,CAAC,CAUzB;IAED;;;;OAIG;IACH,yBAJW,QAAQ,OAAO,CAAC,wDAEd,QAAQ,IAAI,CAAC,CAOzB;IAED;;;OAGG;IAEH,2CAHa,IAAI,CAqBhB;IAED;;;;;;OAMG;IAEH,uBANW,QAAQ,OAAO,CAAC,WAChB,YAAY,OAAO,CAAC,GAClB,MAAM,CAMlB;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,QAAQ,OAAO,CAAC,GACd,SAAS,OAAO,CAAC,CAa7B;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAInB;IA6CD;;;;;;OAMG;IACH,6BAJW,QAAQ,OAAO,CAAC,WAChB,sBAAsB,OAAO,CAAC,GAC5B,OAAO,KAAK,EAAE,YAAY,GAAC,SAAS,CAShD;CACF;;;;;;;;SAaa,MAAM;;;;SACN,GAAG;;;;;uCAMH,GAAG,OACJ,IAAI;4BAIJ,OAAO,aAAa,EAAE,aAAa;uBACnC,OAAO,YAAY,EAAE,QAAQ;6BAK7B,OAAO,6BAA6B,EAAE,WAAW,CAAC,CAAC,CAAC;uCAKpD,OAAO,6BAA6B,EAAE,qBAAqB,CAAC,CAAC,CAAC;yBAK9D,OAAO,6BAA6B,EAAE,OAAO,CAAC,CAAC,CAAC;0BAKhD,OAAO,uBAAuB,EAAE,QAAQ,CAAC,CAAC,CAAC;2BAK3C,OAAO,6BAA6B,EAAE,SAAS,CAAC,CAAC,CAAC;;;;;;;;;;;;;0BAWlD,uBAAuB,GAAG,uBAAuB,GAAG,yBAAyB,GAAG,0BAA0B;AA7bvH,qCAA+B;AAG/B,qCAA+B;AAF/B,yCAAmC;AACnC,2CAAqC;AAGrC,+BAA+B;AAC/B,4BADW,IAAI,WAAW,CAAC,CAMxB"}
+{"version":3,"file":"extension-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/extension-config.js"],"names":[],"mappings":"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"}