appium 2.0.0-beta.26 → 2.0.0-beta.29

package/build/lib/constants.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The name of the extension type for drivers
+ */
+export const DRIVER_TYPE: "driver";
+/**
+ * The name of the extension type for plugins
+ */
+export const PLUGIN_TYPE: "plugin";
+/**
+ * The `server` command of the `appium` CLI
+ */
+export const SERVER_SUBCOMMAND: "server";
+/**
+ * The value of `--use-plugins` if _all_ plugins should be loaded
+ */
+export const USE_ALL_PLUGINS: "all";
+export const KNOWN_PLUGINS: Readonly<{
+    readonly images: "@appium/images-plugin";
+    readonly 'execute-driver': "@appium/execute-driver-plugin";
+    readonly 'relaxed-caps': "@appium/relaxed-caps-plugin";
+}>;
+export const KNOWN_DRIVERS: Readonly<{
+    readonly uiautomator2: "appium-uiautomator2-driver";
+    readonly xcuitest: "appium-xcuitest-driver";
+    readonly youiengine: "appium-youiengine-driver";
+    readonly windows: "appium-windows-driver";
+    readonly mac: "appium-mac-driver";
+    readonly mac2: "appium-mac2-driver";
+    readonly espresso: "appium-espresso-driver";
+    readonly tizen: "appium-tizen-driver";
+    readonly flutter: "appium-flutter-driver";
+    readonly safari: "appium-safari-driver";
+    readonly gecko: "appium-geckodriver";
+}>;
+/**
+ * Relative path to directory containing any Appium internal files
+ */
+export const CACHE_DIR_RELATIVE_PATH: string;
+/**
+ * Relative path to hashfile (from `APPIUM_HOME`) of consuming project's `package.json` (if it exists)
+ */
+export const PKG_HASHFILE_RELATIVE_PATH: string;
+export const EXT_SUBCOMMAND_LIST: "list";
+export const EXT_SUBCOMMAND_INSTALL: "install";
+export const EXT_SUBCOMMAND_UNINSTALL: "uninstall";
+export const EXT_SUBCOMMAND_UPDATE: "update";
+export const EXT_SUBCOMMAND_RUN: "run";
+//# sourceMappingURL=constants.d.ts.map

package/build/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../lib/constants.js"],"names":[],"mappings":"AAGA;;GAEG;AACH,mCAAoC;AAEpC;;GAEG;AACH,mCAAoC;AAEpC;;GAEG;AACH,yCAA0C;AAE1C;;GAEG;AACH,oCAAqC;AAMrC;;;;GAME;AAMF;;;;;;;;;;;;GAcE;AAEF;;GAEG;AACH,6CAIE;AAEF;;GAEG;AACH,gDAGE;AAGF,yCAA0C;AAC1C,+CAAgD;AAChD,mDAAoD;AACpD,6CAA8C;AAC9C,uCAAwC"}

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

@@ -0,0 +1,84 @@
+/**
+ * @extends {ExtensionConfig<DriverType>}
+ */
+export class DriverConfig extends ExtensionConfig<"driver"> {
+    /**
+     * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.
+     *
+     * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.
+     *
+     * This variable tracks the `Manifest`-to-`DriverConfig` portion.
+     *
+     * @type {WeakMap<Manifest,DriverConfig>}
+     * @private
+     */
+    private static _instances;
+    /**
+     * 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;
+    /**
+     * Returns a DriverConfig associated with a Manifest
+     * @param {Manifest} manifest
+     * @returns {DriverConfig|undefined}
+     */
+    static getInstance(manifest: Manifest): DriverConfig | undefined;
+    /**
+    * Call {@link DriverConfig.create} instead.
+    * @private
+    * @param {import('./manifest').Manifest} manifest - Manifest instance
+    * @param {DriverConfigOptions} [opts]
+    */
+    private constructor();
+    /**
+     * A set of unique automation names used by drivers.
+     * @type {Set<string>}
+     */
+    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;
+    /**
+    * 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 = {
+    /**
+     * - Optional logging function
+     */
+    logFn?: import("./extension-config").ExtensionLogFn | undefined;
+    /**
+     * - Extension data
+     */
+    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;
+export type Manifest = import('./manifest').Manifest;
+export type ExtRecord<T> = import('../../types').ExtRecord<T>;
+export type ExtName<T> = import('../../types').ExtName<T>;
+/**
+ * Return value of {@linkcode DriverConfig.findMatchingDriver }
+ */
+export type MatchedDriver = {
+    driver: BaseDriverBase<import("@appium/types").ExternalDriver, import("../../types").ExternalDriverStatic>;
+    version: string;
+    driverName: string;
+};
+export type Capabilities = import('@appium/types').Capabilities;
+import { ExtensionConfig } from "./extension-config";
+//# sourceMappingURL=driver-config.d.ts.map

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

@@ -0,0 +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"}

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

@@ -187,4 +187,4 @@ class DriverConfig extends _extensionConfig.ExtensionConfig {
 }
 
 exports.DriverConfig = DriverConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/driver-config.js"],"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"],"mappings":"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","sourcesContent":["// @ts-check\n\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 {ManifestDriverData} 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 {ManifestDriverData} 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 { { automationName: string, platformName: string } } caps\n   * @returns { { driver: import('./manifest').DriverClass, version: string, driverName: string } }\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 {ManifestDriverData & { driverName: string } }\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 * @typedef {import('./manifest').ExternalData<DriverType>} ExternalDriverData\n * @typedef {import('./manifest').ManifestDriverData} ManifestDriverData\n * @typedef {import('./manifest').ManifestData} ManifestData\n * @typedef {import('./manifest').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('./extension-config').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('./extension-config').ExtName<T>} ExtName\n */\n\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/driver-config.js"],"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"],"mappings":"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","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"]}

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

@@ -0,0 +1,170 @@
+/**
+ * This class is abstract. It should not be instantiated directly.
+ *
+ * Subclasses should provide the generic parameter to implement.
+ * @template {ExtensionType} ExtType
+ */
+export class ExtensionConfig<ExtType extends import("../../types").ExtensionType> {
+    /**
+     * Intended to be called by corresponding instance methods of subclass.
+     * @private
+     * @template {ExtensionType} ExtType
+     * @param {string} appiumHome
+     * @param {ExtType} extType
+     * @param {ExtName<ExtType>} extName - Extension name (unique to its type)
+     * @param {ExtManifestWithSchema<ExtType>} extData - Extension config
+     * @returns {import('ajv').SchemaObject|undefined}
+     */
+    private static _readExtensionSchema;
+    /**
+     * 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>}
+     */
+    static extDataHasSchema<ExtType_1 extends import("../../types").ExtensionType>(extData: ExtManifest<ExtType_1>): extData is ExtManifestWithSchema<ExtType_1>;
+    /**
+     * @protected
+     * @param {ExtType} extensionType - Type of extension
+     * @param {Manifest} manifest - `Manifest` instance
+     * @param {ExtensionLogFn} [logFn]
+     */
+    protected constructor();
+    /** @type {ExtType} */
+    extensionType: ExtType;
+    /** @type {`${ExtType}s`} */
+    configKey: `${ExtType}s`;
+    /** @type {ExtRecord<ExtType>} */
+    installedExtensions: ExtRecord<ExtType>;
+    /** @type {ExtensionLogFn} */
+    log: ExtensionLogFn;
+    /** @type {Manifest} */
+    manifest: Manifest;
+    get manifestPath(): string;
+    get appiumHome(): string;
+    /**
+     * Checks extensions for problems
+     * @param {ExtRecord<ExtType>} exts - Extension data
+     */
+    validate(exts: ExtRecord<ExtType>): ExtRecord<ExtType>;
+    /**
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtName<ExtType>} extName
+     * @returns {Problem[]}
+     */
+    getSchemaProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    /**
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtName<ExtType>} extName
+     * @returns {Problem[]}
+     */
+    getGenericConfigProblems(extData: ExtManifest<ExtType>, extName: ExtName<ExtType>): Problem[];
+    /**
+     * @abstract
+     * @param {ExtManifest<ExtType>} extData
+     * @returns {Problem[]}
+     */
+    getConfigProblems(extData: ExtManifest<ExtType>): Problem[];
+    /**
+     * @param {string} extName
+     * @param {ExtManifest<ExtType>} extData
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    addExtension(extName: string, extData: ExtManifest<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>} extName
+     * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    updateExtension(extName: ExtName<ExtType>, extData: ExtManifest<ExtType> | import('../cli/extension-command').ExtensionFields<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>} extName
+     * @param {ExtensionConfigMutationOpts} [opts]
+     * @returns {Promise<void>}
+     */
+    removeExtension(extName: ExtName<ExtType>, { write }?: ExtensionConfigMutationOpts | undefined): Promise<void>;
+    /**
+     * @param {ExtName<ExtType>[]} [activeNames]
+     * @returns {void}
+     */
+    print(activeNames?: string[] | undefined): void;
+    /**
+     * Returns a string describing the extension. Subclasses must implement.
+     * @param {ExtName<ExtType>} extName - Extension name
+     * @param {ExtManifest<ExtType>} extData - Extension data
+     * @returns {string}
+     * @abstract
+     */
+    extensionDesc(extName: ExtName<ExtType>, extData: ExtManifest<ExtType>): string;
+    /**
+     * @param {string} extName
+     * @returns {string}
+     */
+    getInstallPath(extName: string): string;
+    /**
+     * Loads extension and returns its main class (constructor)
+     * @param {ExtName<ExtType>} extName
+     * @returns {ExtClass<ExtType>}
+     */
+    require(extName: ExtName<ExtType>): ExtClass<ExtType>;
+    /**
+     * @param {string} extName
+     * @returns {boolean}
+     */
+    isInstalled(extName: string): boolean;
+    /**
+     * 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
+     * @returns {import('ajv').SchemaObject|undefined}
+     */
+    readExtensionSchema(extName: ExtName<ExtType>, extData: ExtManifestWithSchema<ExtType>): import('ajv').SchemaObject | undefined;
+}
+/**
+ * Config problem
+ */
+export type Problem = {
+    /**
+     * - Error message
+     */
+    err: string;
+    /**
+     * - Associated value
+     */
+    val: any;
+};
+/**
+ * An optional logging function provided to an {@link ExtensionConfig } subclass.
+ */
+export type ExtensionLogFn = (...args: any[]) => void;
+export type ExtensionType = import('../../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>;
+/**
+ * Options for various methods in {@link ExtensionConfig }
+ */
+export type ExtensionConfigMutationOpts = {
+    /**
+     * Whether or not to write the manifest to disk after a mutation operation
+     */
+    write?: boolean | undefined;
+};
+/**
+ * A valid install type
+ */
+export type InstallType = typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB;
+export const INSTALL_TYPE_NPM: "npm";
+export const INSTALL_TYPE_GIT: "git";
+export const INSTALL_TYPE_LOCAL: "local";
+export const INSTALL_TYPE_GITHUB: "github";
+/** @type {Set<InstallType>} */
+export const INSTALL_TYPES: Set<InstallType>;
+//# sourceMappingURL=extension-config.d.ts.map

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

@@ -0,0 +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"}

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

@@ -185,7 +185,7 @@ class ExtensionConfig {
   async addExtension(extName, extData, {
     write = true
   } = {}) {
-    await this.manifest.addExtension(this.extensionType, extName, extData);
+    this.manifest.addExtension(this.extensionType, extName, extData);
 
     if (write) {
       await this.manifest.write();
@@ -294,4 +294,4 @@ class ExtensionConfig {
 }
 
 exports.ExtensionConfig = ExtensionConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/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","constructor","logFn","logger","_","isFunction","error","bind","getExtensionData","manifestPath","appiumHome","validate","exts","foundProblems","extName","extData","toPairs","getGenericConfigProblems","getConfigProblems","getSchemaProblems","problemSummaries","problems","isEmpty","push","problem","err","JSON","stringify","val","summary","schema","argSchemaPath","extDataHasSchema","isString","readExtensionSchema","message","ALLOWED_SCHEMA_EXTENSIONS","join","isPlainObject","version","pkgName","installSpec","installType","mainClass","has","addExtension","write","updateExtension","removeExtension","print","activeNames","info","extensionDesc","Error","getInstallPath","path","require","reqPath","reqResolved","resolve","process","env","APPIUM_RELOAD_EXTENSIONS","cache","debug","isInstalled","includes","Object","keys","_readExtensionSchema","extType","TypeError","moduleObject","schemaPath","__esModule","default","isObject"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport _ from 'lodash';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\nimport log from '../logger';\nimport {\n  ALLOWED_SCHEMA_EXTENSIONS,\n  isAllowedSchemaFileExtension,\n  registerSchema,\n} from '../schema/schema';\n\nconst INSTALL_TYPE_NPM = 'npm';\nconst INSTALL_TYPE_LOCAL = 'local';\nconst INSTALL_TYPE_GITHUB = 'github';\nconst INSTALL_TYPE_GIT = 'git';\n\n/** @type {Set<InstallType>} */\nconst INSTALL_TYPES = new Set([\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_NPM,\n]);\n\n/**\n * This class is abstract. It should not be instantiated directly.\n *\n * Subclasses should provide the generic parameter to implement.\n * @template {ExtensionType} ExtType\n */\nexport class ExtensionConfig {\n  /** @type {ExtType} */\n  extensionType;\n\n  /** @type {`${ExtType}s`} */\n  configKey;\n\n  /** @type {ExtRecord<ExtType>} */\n  installedExtensions;\n\n  /** @type {ExtensionLogFn} */\n  log;\n\n  /** @type {Manifest} */\n  manifest;\n\n  /**\n   * @protected\n   * @param {ExtType} extensionType - Type of extension\n   * @param {Manifest} manifest - `Manifest` instance\n   * @param {ExtensionLogFn} [logFn]\n   */\n  constructor (extensionType, manifest, logFn) {\n    const logger = _.isFunction(logFn) ? logFn : log.error.bind(log);\n    this.extensionType = extensionType;\n    this.configKey = `${extensionType}s`;\n    this.installedExtensions = manifest.getExtensionData(extensionType);\n    this.log = logger;\n    this.manifest = manifest;\n  }\n\n  get manifestPath () {\n    return this.manifest.manifestPath;\n  }\n\n  get appiumHome () {\n    return this.manifest.appiumHome;\n  }\n\n  /**\n   * Checks extensions for problems\n   * @param {ExtRecord<ExtType>} exts - Extension data\n   */\n  validate (exts) {\n    const foundProblems =\n      /** @type {Record<ExtName<ExtType>,Problem[]>} */ ({});\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[ExtName<ExtType>, ExtData<ExtType>][]} */ (\n        _.toPairs(exts)\n      )) {\n      foundProblems[extName] = [\n        ...this.getGenericConfigProblems(extData, extName),\n        ...this.getConfigProblems(extData),\n        ...this.getSchemaProblems(extData, extName),\n      ];\n    }\n\n    const problemSummaries = [];\n    for (const [extName, problems] of _.toPairs(foundProblems)) {\n      if (_.isEmpty(problems)) {\n        continue;\n      }\n      // remove this extension from the list since it's not valid\n      delete exts[extName];\n      problemSummaries.push(\n        `${this.extensionType} ${extName} had errors and will not ` +\n          `be available. Errors:`,\n      );\n      for (const problem of problems) {\n        problemSummaries.push(\n          `  - ${problem.err} (Actual value: ` +\n            `${JSON.stringify(problem.val)})`,\n        );\n      }\n    }\n\n    if (!_.isEmpty(problemSummaries)) {\n      this.log(\n        `Appium encountered one or more errors while validating ` +\n          `the ${this.configKey} extension file (${this.manifestPath}):`,\n      );\n      for (const summary of problemSummaries) {\n        this.log(summary);\n      }\n    }\n\n    return exts;\n  }\n\n  /**\n   * @param {ExtData<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  getSchemaProblems (extData, extName) {\n    const problems = [];\n    const {schema: argSchemaPath} = extData;\n    if (ExtensionConfig.extDataHasSchema(extData)) {\n      if (_.isString(argSchemaPath)) {\n        if (isAllowedSchemaFileExtension(argSchemaPath)) {\n          try {\n            this.readExtensionSchema(extName, extData);\n          } catch (err) {\n            problems.push({\n              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,\n              val: argSchemaPath,\n            });\n          }\n        } else {\n          problems.push({\n            err: `Schema file has unsupported extension. Allowed: ${[\n              ...ALLOWED_SCHEMA_EXTENSIONS,\n            ].join(', ')}`,\n            val: argSchemaPath,\n          });\n        }\n      } else if (_.isPlainObject(argSchemaPath)) {\n        try {\n          this.readExtensionSchema(extName, extData);\n        } catch (err) {\n          problems.push({\n            err: `Unable to register embedded schema; ${err.message}`,\n            val: argSchemaPath,\n          });\n        }\n      } else {\n        problems.push({\n          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n          val: argSchemaPath,\n        });\n      }\n    }\n    return problems;\n  }\n\n  /**\n   * @param {ExtData<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getGenericConfigProblems (extData, extName) {\n    const {version, pkgName, installSpec, installType, mainClass} =\n      extData;\n    const problems = [];\n\n    if (!_.isString(version)) {\n      problems.push({err: 'Missing or incorrect version', val: version});\n    }\n\n    if (!_.isString(pkgName)) {\n      problems.push({\n        err: 'Missing or incorrect NPM package name',\n        val: pkgName,\n      });\n    }\n\n    if (!_.isString(installSpec)) {\n      problems.push({\n        err: 'Missing or incorrect installation spec',\n        val: installSpec,\n      });\n    }\n\n    if (!INSTALL_TYPES.has(installType)) {\n      problems.push({\n        err: 'Missing or incorrect install type',\n        val: installType,\n      });\n    }\n\n    if (!_.isString(mainClass)) {\n      problems.push({\n        err: 'Missing or incorrect driver class name',\n        val: mainClass,\n      });\n    }\n\n    return problems;\n  }\n\n  /**\n   * @abstract\n   * @param {ExtData<ExtType>} extData\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getConfigProblems (extData) {\n    // shoud override this method if special validation is necessary for this extension type\n    return [];\n  }\n\n  /**\n   * @param {string} extName\n   * @param {ExtData<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async addExtension (extName, extData, {write = true} = {}) {\n    await this.manifest.addExtension(this.extensionType, extName, extData);\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtData<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async updateExtension (extName, extData, {write = true} = {}) {\n    this.installedExtensions[extName] = {\n      ...this.installedExtensions[extName],\n      ...extData,\n    };\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async removeExtension (extName, {write = true} = {}) {\n    delete this.installedExtensions[extName];\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>[]} [activeNames]\n   * @returns {void}\n   */\n  // eslint-disable-next-line no-unused-vars\n  print (activeNames) {\n    if (_.isEmpty(this.installedExtensions)) {\n      log.info(\n        `No ${this.configKey} have been installed in ${this.appiumHome}. Use the \"appium ${this.extensionType}\" ` +\n          'command to install the one(s) you want to use.',\n      );\n      return;\n    }\n\n    log.info(`Available ${this.configKey}:`);\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[string, ExtData<ExtType>][]} */ (\n        _.toPairs(this.installedExtensions)\n      )) {\n      log.info(`  - ${this.extensionDesc(extName, extData)}`);\n    }\n  }\n\n  /**\n   * Returns a string describing the extension. Subclasses must implement.\n   * @param {ExtName<ExtType>} extName - Extension name\n   * @param {ExtData<ExtType>} extData - Extension data\n   * @returns {string}\n   * @abstract\n   */\n  // eslint-disable-next-line no-unused-vars\n  extensionDesc (extName, extData) {\n    throw new Error('This must be implemented in a subclass');\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {string}\n   */\n  getInstallPath (extName) {\n    return path.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);\n  }\n\n  /**\n   * Loads extension and returns its main class (constructor)\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtClass<ExtType>}\n   */\n  require (extName) {\n    const {mainClass} = this.installedExtensions[extName];\n    const reqPath = this.getInstallPath(extName);\n    const reqResolved = require.resolve(reqPath);\n    // note: this will only reload the entry point\n    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {\n      log.debug(`Removing ${reqResolved} from require cache`);\n      delete require.cache[reqResolved];\n    }\n    log.debug(`Requiring ${this.extensionType} at ${reqPath}`);\n    return require(reqPath)[mainClass];\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {boolean}\n   */\n  isInstalled (extName) {\n    return _.includes(Object.keys(this.installedExtensions), extName);\n  }\n\n  /**\n   * Intended to be called by corresponding instance methods of subclass.\n   * @private\n   * @template {ExtensionType} ExtType\n   * @param {string} appiumHome\n   * @param {ExtType} extType\n   * @param {ExtName<ExtType>} extName - Extension name (unique to its type)\n   * @param {ExtDataWithSchema<ExtType>} extData - Extension config\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  static _readExtensionSchema (appiumHome, extType, extName, extData) {\n    const {pkgName, schema: argSchemaPath} = extData;\n    if (!argSchemaPath) {\n      throw new TypeError(\n        `No \\`schema\\` property found in config for ${extType} ${pkgName} -- why is this function being called?`,\n      );\n    }\n    let moduleObject;\n    if (_.isString(argSchemaPath)) {\n      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));\n      moduleObject = require(schemaPath);\n    } else {\n      moduleObject = argSchemaPath;\n    }\n    // this sucks. default exports should be destroyed\n    const schema = moduleObject.__esModule\n      ? moduleObject.default\n      : moduleObject;\n    registerSchema(extType, extName, schema);\n    return schema;\n  }\n\n  /**\n   * Returns `true` if a specific {@link ExtData} object has a `schema` prop.\n   * The {@link ExtData} object becomes a {@link ExtDataWithSchema} object.\n   * @template {ExtensionType} ExtType\n   * @param {ExtData<ExtType>} extData\n   * @returns {extData is ExtDataWithSchema<ExtType>}\n   */\n  static extDataHasSchema (extData) {\n    return _.isString(extData?.schema) || _.isObject(extData?.schema);\n  }\n\n  /**\n   * If an extension provides a schema, this will load the schema and attempt to\n   * register it with the schema registrar.\n   * @param {ExtName<ExtType>} extName - Name of extension\n   * @param {ExtDataWithSchema<ExtType>} extData - Extension data\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  readExtensionSchema (extName, extData) {\n    return ExtensionConfig._readExtensionSchema(\n      this.appiumHome,\n      this.extensionType,\n      extName,\n      extData,\n    );\n  }\n}\n\nexport {\n  INSTALL_TYPE_NPM,\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPES,\n};\n\n/**\n * Config problem\n * @typedef Problem\n * @property {string} err - Error message\n * @property {any} val - Associated value\n */\n\n/**\n * An optional logging function provided to an {@link ExtensionConfig} subclass.\n * @callback ExtensionLogFn\n * @param {...any} args\n * @returns {void}\n */\n\n/**\n * @typedef {import('./manifest').ExtensionType} ExtensionType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('./manifest').ExtData<T>} ExtData\n */\n\n/**\n * @template T\n * @typedef {import('./manifest').ExtDataWithSchema<T>} ExtDataWithSchema\n */\n\n/**\n * @template T\n * @typedef {import('./manifest').ExtName<T>} ExtName\n */\n\n/**\n * @template T\n * @typedef {import('./manifest').ExtClass<T>} ExtClass\n */\n\n/**\n * @template T\n * @typedef {import('./manifest').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Options for various methods in {@link ExtensionConfig}\n * @typedef ExtensionConfigMutationOpts\n * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation\n */\n\n/**\n * A valid install type\n * @typedef {typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB} InstallType\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/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","constructor","logFn","logger","_","isFunction","error","bind","getExtensionData","manifestPath","appiumHome","validate","exts","foundProblems","extName","extData","toPairs","getGenericConfigProblems","getConfigProblems","getSchemaProblems","problemSummaries","problems","isEmpty","push","problem","err","JSON","stringify","val","summary","schema","argSchemaPath","extDataHasSchema","isString","readExtensionSchema","message","ALLOWED_SCHEMA_EXTENSIONS","join","isPlainObject","version","pkgName","installSpec","installType","mainClass","has","addExtension","write","updateExtension","removeExtension","print","activeNames","info","extensionDesc","Error","getInstallPath","path","require","reqPath","reqResolved","resolve","process","env","APPIUM_RELOAD_EXTENSIONS","cache","debug","isInstalled","includes","Object","keys","_readExtensionSchema","extType","TypeError","moduleObject","schemaPath","__esModule","default","isObject"],"mappings":"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","sourcesContent":["\nimport _ from 'lodash';\nimport path from 'path';\nimport resolveFrom from 'resolve-from';\nimport log from '../logger';\nimport {\n  ALLOWED_SCHEMA_EXTENSIONS,\n  isAllowedSchemaFileExtension,\n  registerSchema,\n} from '../schema/schema';\n\nconst INSTALL_TYPE_NPM = 'npm';\nconst INSTALL_TYPE_LOCAL = 'local';\nconst INSTALL_TYPE_GITHUB = 'github';\nconst INSTALL_TYPE_GIT = 'git';\n\n/** @type {Set<InstallType>} */\nconst INSTALL_TYPES = new Set([\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_NPM,\n]);\n\n/**\n * This class is abstract. It should not be instantiated directly.\n *\n * Subclasses should provide the generic parameter to implement.\n * @template {ExtensionType} ExtType\n */\nexport class ExtensionConfig {\n  /** @type {ExtType} */\n  extensionType;\n\n  /** @type {`${ExtType}s`} */\n  configKey;\n\n  /** @type {ExtRecord<ExtType>} */\n  installedExtensions;\n\n  /** @type {ExtensionLogFn} */\n  log;\n\n  /** @type {Manifest} */\n  manifest;\n\n  /**\n   * @protected\n   * @param {ExtType} extensionType - Type of extension\n   * @param {Manifest} manifest - `Manifest` instance\n   * @param {ExtensionLogFn} [logFn]\n   */\n  constructor (extensionType, manifest, logFn) {\n    const logger = _.isFunction(logFn) ? logFn : log.error.bind(log);\n    this.extensionType = extensionType;\n    this.configKey = `${extensionType}s`;\n    this.installedExtensions = manifest.getExtensionData(extensionType);\n    this.log = logger;\n    this.manifest = manifest;\n  }\n\n  get manifestPath () {\n    return this.manifest.manifestPath;\n  }\n\n  get appiumHome () {\n    return this.manifest.appiumHome;\n  }\n\n  /**\n   * Checks extensions for problems\n   * @param {ExtRecord<ExtType>} exts - Extension data\n   */\n  validate (exts) {\n    const foundProblems =\n      /** @type {Record<ExtName<ExtType>,Problem[]>} */ ({});\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[ExtName<ExtType>, ExtManifest<ExtType>][]} */ (\n        _.toPairs(exts)\n      )) {\n      foundProblems[extName] = [\n        ...this.getGenericConfigProblems(extData, extName),\n        ...this.getConfigProblems(extData),\n        ...this.getSchemaProblems(extData, extName),\n      ];\n    }\n\n    const problemSummaries = [];\n    for (const [extName, problems] of _.toPairs(foundProblems)) {\n      if (_.isEmpty(problems)) {\n        continue;\n      }\n      // remove this extension from the list since it's not valid\n      delete exts[extName];\n      problemSummaries.push(\n        `${this.extensionType} ${extName} had errors and will not ` +\n          `be available. Errors:`,\n      );\n      for (const problem of problems) {\n        problemSummaries.push(\n          `  - ${problem.err} (Actual value: ` +\n            `${JSON.stringify(problem.val)})`,\n        );\n      }\n    }\n\n    if (!_.isEmpty(problemSummaries)) {\n      this.log(\n        `Appium encountered one or more errors while validating ` +\n          `the ${this.configKey} extension file (${this.manifestPath}):`,\n      );\n      for (const summary of problemSummaries) {\n        this.log(summary);\n      }\n    }\n\n    return exts;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  getSchemaProblems (extData, extName) {\n    const problems = [];\n    const {schema: argSchemaPath} = extData;\n    if (ExtensionConfig.extDataHasSchema(extData)) {\n      if (_.isString(argSchemaPath)) {\n        if (isAllowedSchemaFileExtension(argSchemaPath)) {\n          try {\n            this.readExtensionSchema(extName, extData);\n          } catch (err) {\n            problems.push({\n              err: `Unable to register schema at path ${argSchemaPath}; ${err.message}`,\n              val: argSchemaPath,\n            });\n          }\n        } else {\n          problems.push({\n            err: `Schema file has unsupported extension. Allowed: ${[\n              ...ALLOWED_SCHEMA_EXTENSIONS,\n            ].join(', ')}`,\n            val: argSchemaPath,\n          });\n        }\n      } else if (_.isPlainObject(argSchemaPath)) {\n        try {\n          this.readExtensionSchema(extName, extData);\n        } catch (err) {\n          problems.push({\n            err: `Unable to register embedded schema; ${err.message}`,\n            val: argSchemaPath,\n          });\n        }\n      } else {\n        problems.push({\n          err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n          val: argSchemaPath,\n        });\n      }\n    }\n    return problems;\n  }\n\n  /**\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtName<ExtType>} extName\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getGenericConfigProblems (extData, extName) {\n    const {version, pkgName, installSpec, installType, mainClass} =\n      extData;\n    const problems = [];\n\n    if (!_.isString(version)) {\n      problems.push({err: 'Missing or incorrect version', val: version});\n    }\n\n    if (!_.isString(pkgName)) {\n      problems.push({\n        err: 'Missing or incorrect NPM package name',\n        val: pkgName,\n      });\n    }\n\n    if (!_.isString(installSpec)) {\n      problems.push({\n        err: 'Missing or incorrect installation spec',\n        val: installSpec,\n      });\n    }\n\n    if (!INSTALL_TYPES.has(installType)) {\n      problems.push({\n        err: 'Missing or incorrect install type',\n        val: installType,\n      });\n    }\n\n    if (!_.isString(mainClass)) {\n      problems.push({\n        err: 'Missing or incorrect driver class name',\n        val: mainClass,\n      });\n    }\n\n    return problems;\n  }\n\n  /**\n   * @abstract\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {Problem[]}\n   */\n  // eslint-disable-next-line no-unused-vars\n  getConfigProblems (extData) {\n    // shoud override this method if special validation is necessary for this extension type\n    return [];\n  }\n\n  /**\n   * @param {string} extName\n   * @param {ExtManifest<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async addExtension (extName, extData, {write = true} = {}) {\n    this.manifest.addExtension(this.extensionType, extName, extData);\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtManifest<ExtType>|import('../cli/extension-command').ExtensionFields<ExtType>} extData\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async updateExtension (extName, extData, {write = true} = {}) {\n    this.installedExtensions[extName] = {\n      ...this.installedExtensions[extName],\n      ...extData,\n    };\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>} extName\n   * @param {ExtensionConfigMutationOpts} [opts]\n   * @returns {Promise<void>}\n   */\n  async removeExtension (extName, {write = true} = {}) {\n    delete this.installedExtensions[extName];\n    if (write) {\n      await this.manifest.write();\n    }\n  }\n\n  /**\n   * @param {ExtName<ExtType>[]} [activeNames]\n   * @returns {void}\n   */\n  // eslint-disable-next-line no-unused-vars\n  print (activeNames) {\n    if (_.isEmpty(this.installedExtensions)) {\n      log.info(\n        `No ${this.configKey} have been installed in ${this.appiumHome}. Use the \"appium ${this.extensionType}\" ` +\n          'command to install the one(s) you want to use.',\n      );\n      return;\n    }\n\n    log.info(`Available ${this.configKey}:`);\n    for (const [\n      extName,\n      extData,\n    ] of /** @type {[string, ExtManifest<ExtType>][]} */ (\n        _.toPairs(this.installedExtensions)\n      )) {\n      log.info(`  - ${this.extensionDesc(extName, extData)}`);\n    }\n  }\n\n  /**\n   * Returns a string describing the extension. Subclasses must implement.\n   * @param {ExtName<ExtType>} extName - Extension name\n   * @param {ExtManifest<ExtType>} extData - Extension data\n   * @returns {string}\n   * @abstract\n   */\n  // eslint-disable-next-line no-unused-vars\n  extensionDesc (extName, extData) {\n    throw new Error('This must be implemented in a subclass');\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {string}\n   */\n  getInstallPath (extName) {\n    return path.join(this.appiumHome, 'node_modules', this.installedExtensions[extName].pkgName);\n  }\n\n  /**\n   * Loads extension and returns its main class (constructor)\n   * @param {ExtName<ExtType>} extName\n   * @returns {ExtClass<ExtType>}\n   */\n  require (extName) {\n    const {mainClass} = this.installedExtensions[extName];\n    const reqPath = this.getInstallPath(extName);\n    const reqResolved = require.resolve(reqPath);\n    // note: this will only reload the entry point\n    if (process.env.APPIUM_RELOAD_EXTENSIONS && require.cache[reqResolved]) {\n      log.debug(`Removing ${reqResolved} from require cache`);\n      delete require.cache[reqResolved];\n    }\n    log.debug(`Requiring ${this.extensionType} at ${reqPath}`);\n    return require(reqPath)[mainClass];\n  }\n\n  /**\n   * @param {string} extName\n   * @returns {boolean}\n   */\n  isInstalled (extName) {\n    return _.includes(Object.keys(this.installedExtensions), extName);\n  }\n\n  /**\n   * Intended to be called by corresponding instance methods of subclass.\n   * @private\n   * @template {ExtensionType} ExtType\n   * @param {string} appiumHome\n   * @param {ExtType} extType\n   * @param {ExtName<ExtType>} extName - Extension name (unique to its type)\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension config\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  static _readExtensionSchema (appiumHome, extType, extName, extData) {\n    const {pkgName, schema: argSchemaPath} = extData;\n    if (!argSchemaPath) {\n      throw new TypeError(\n        `No \\`schema\\` property found in config for ${extType} ${pkgName} -- why is this function being called?`,\n      );\n    }\n    let moduleObject;\n    if (_.isString(argSchemaPath)) {\n      const schemaPath = resolveFrom(appiumHome, path.join(pkgName, argSchemaPath));\n      moduleObject = require(schemaPath);\n    } else {\n      moduleObject = argSchemaPath;\n    }\n    // this sucks. default exports should be destroyed\n    const schema = moduleObject.__esModule\n      ? moduleObject.default\n      : moduleObject;\n    registerSchema(extType, extName, schema);\n    return schema;\n  }\n\n  /**\n   * Returns `true` if a specific {@link ExtManifest} object has a `schema` prop.\n   * The {@link ExtManifest} object becomes a {@link ExtManifestWithSchema} object.\n   * @template {ExtensionType} ExtType\n   * @param {ExtManifest<ExtType>} extData\n   * @returns {extData is ExtManifestWithSchema<ExtType>}\n   */\n  static extDataHasSchema (extData) {\n    return _.isString(extData?.schema) || _.isObject(extData?.schema);\n  }\n\n  /**\n   * If an extension provides a schema, this will load the schema and attempt to\n   * register it with the schema registrar.\n   * @param {ExtName<ExtType>} extName - Name of extension\n   * @param {ExtManifestWithSchema<ExtType>} extData - Extension data\n   * @returns {import('ajv').SchemaObject|undefined}\n   */\n  readExtensionSchema (extName, extData) {\n    return ExtensionConfig._readExtensionSchema(\n      this.appiumHome,\n      this.extensionType,\n      extName,\n      extData,\n    );\n  }\n}\n\nexport {\n  INSTALL_TYPE_NPM,\n  INSTALL_TYPE_GIT,\n  INSTALL_TYPE_LOCAL,\n  INSTALL_TYPE_GITHUB,\n  INSTALL_TYPES,\n};\n\n/**\n * Config problem\n * @typedef Problem\n * @property {string} err - Error message\n * @property {any} val - Associated value\n */\n\n/**\n * An optional logging function provided to an {@link ExtensionConfig} subclass.\n * @callback ExtensionLogFn\n * @param {...any} args\n * @returns {void}\n */\n\n/**\n * @typedef {import('../../types').ExtensionType} ExtensionType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifestWithSchema<T>} ExtManifestWithSchema\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtName<T>} ExtName\n */\n\n/**\n * @template T\n * @typedef {import('../../types/extension').ExtClass<T>} ExtClass\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Options for various methods in {@link ExtensionConfig}\n * @typedef ExtensionConfigMutationOpts\n * @property {boolean} [write=true] Whether or not to write the manifest to disk after a mutation operation\n */\n\n/**\n * A valid install type\n * @typedef {typeof INSTALL_TYPE_NPM | typeof INSTALL_TYPE_GIT | typeof INSTALL_TYPE_LOCAL | typeof INSTALL_TYPE_GITHUB} InstallType\n */\n"]}

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

@@ -0,0 +1,39 @@
+/**
+ * Loads extensions and creates `ExtensionConfig` instances.
+ *
+ * - Reads the manifest file, creating if necessary
+ * - Using the parsed extension data, creates/gets the `ExtensionConfig` subclass instances
+ * - Returns these instances
+ *
+ * If `appiumHome` is needed, use `resolveAppiumHome` from the `env` module in `@appium/support`.
+ * @param {string} appiumHome
+ * @returns {Promise<ExtensionConfigs>}
+ */
+export function loadExtensions(appiumHome: string): Promise<ExtensionConfigs>;
+/**
+ * Find any plugin name which has been installed, and which has been requested for activation by
+ * using the --use-plugins flag, and turn each one into its class, so we can send them as objects
+ * to the server init. We also want to send/assign them to the umbrella driver so it can use them
+ * to wrap command execution
+ *
+ * @param {import('./plugin-config').PluginConfig} pluginConfig - a plugin extension config
+ * @param {string[]} usePlugins
+ * @returns {import('../../types').PluginClass[]}
+ */
+export function getActivePlugins(pluginConfig: import('./plugin-config').PluginConfig, usePlugins?: string[]): import('../../types').PluginClass[];
+/**
+ * Find any driver name which has been installed, and turn each one into its class, so we can send
+ * them as objects to the server init in case they need to add methods/routes or update the server.
+ * If the --drivers flag was given, this method only loads the given drivers.
+ *
+ * @param {import('./driver-config').DriverConfig} driverConfig - a driver extension config
+ * @param {string[]} [useDrivers] - optional list of drivers to load
+ */
+export function getActiveDrivers(driverConfig: import('./driver-config').DriverConfig, useDrivers?: string[] | undefined): any[];
+export type ExtensionConfigs = {
+    driverConfig: DriverConfig;
+    pluginConfig: PluginConfig;
+};
+import { DriverConfig } from "./driver-config";
+import { PluginConfig } from "./plugin-config";
+//# sourceMappingURL=index.d.ts.map

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

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