appium 2.0.0-beta.43 → 2.0.0-beta.45

package/build/lib/extension/index.js.map

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

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

@@ -64,10 +64,9 @@ export class Manifest {
     private _reading;
     /**
      * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.
-     * @param {SyncWithInstalledExtensionsOpts} opts
      * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.
      */
-    syncWithInstalledExtensions({ depthLimit }?: SyncWithInstalledExtensionsOpts): Promise<boolean>;
+    syncWithInstalledExtensions(): Promise<boolean>;
     /**
      * Returns `true` if driver with name `name` is registered.
      * @param {string} name - Driver name

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

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../lib/extension/manifest.js"],"names":[],"mappings":"AAmGA;;;;GAIG;AACH;IA4DE;;;;;;OAMG;IACH,yEAEG;IArBH;;;;;;OAMG;IACH,sBAGC;IAzDD;;;;;;OAMG;IACH,cAAM;IAEN;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,eAHU,MAAM,CAGF;IAEd;;;;;;;;;OASG;IACH,iBAAS;IAET;;;;;;;;;OASG;IACH,iBAAS;IAyBT;;;;OAIG;IACH,6CAHW,+BAA+B,GAC7B,QAAQ,OAAO,CAAC,CAoB5B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,0HAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;;;;;OAUG;IACH,mGAJW,MAAM,2DAQhB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,oHAEC;IAED;;;;;;;;;OASG;IACH,QAFa,QAAQ,YAAY,CAAC,CAuDjC;IAED;;;;;;OAMG;IACH,yBAaC;IAED;;;;;;;OAOG;IACH,SAFa,QAAQ,OAAO,CAAC,CAgC5B;CACF;;;;yBAIY,OAAO,eAAe,EAAE,UAAU;;;;yBAKlC,OAAO,eAAe,EAAE,UAAU;;;;;;;2BASlC,OAAO,cAAc,EAAE,YAAY;+BACnC,OAAO,cAAc,EAAE,gBAAgB;gCAKvC,OAAO,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;6BAKxC,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;2BAKrC,OAAO,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;;;;4BAKnC,OAAO,eAAe,EAAE,aAAa"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../lib/extension/manifest.js"],"names":[],"mappings":"AAoFA;;;;GAIG;AACH;IA4DE;;;;;;OAMG;IACH,yEAEG;IArBH;;;;;;OAMG;IACH,sBAGC;IAzDD;;;;;;OAMG;IACH,cAAM;IAEN;;;;OAIG;IACH,oBAAY;IAEZ;;;;OAIG;IACH,eAHU,MAAM,CAGF;IAEd;;;;;;;;;OASG;IACH,iBAAS;IAET;;;;;;;;;OASG;IACH,iBAAS;IAyBT;;;OAGG;IACH,+BAFa,QAAQ,OAAO,CAAC,CAqD5B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,0HAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;;;;;OAUG;IACH,mGAJW,MAAM,2DAQhB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,oHAEC;IAED;;;;;;;;;OASG;IACH,QAFa,QAAQ,YAAY,CAAC,CAuDjC;IAED;;;;;;OAMG;IACH,yBAaC;IAED;;;;;;;OAOG;IACH,SAFa,QAAQ,OAAO,CAAC,CAgC5B;CACF;;;;yBAIY,OAAO,eAAe,EAAE,UAAU;;;;yBAKlC,OAAO,eAAe,EAAE,UAAU;;;;;;;2BASlC,OAAO,cAAc,EAAE,YAAY;+BACnC,OAAO,cAAc,EAAE,gBAAgB;gCAKvC,OAAO,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC;6BAKxC,OAAO,cAAc,EAAE,WAAW,CAAC,CAAC,CAAC;2BAKrC,OAAO,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC;;;;4BAKnC,OAAO,eAAe,EAAE,aAAa"}

package/build/lib/extension/manifest.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,6 +7,10 @@ exports.Manifest = void 0;
 
 require("source-map-support/register");
 
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _glob = _interopRequireDefault(require("glob"));
+
 var _support = require("@appium/support");
 
 var _lodash = _interopRequireDefault(require("lodash"));
@@ -25,11 +27,8 @@ var _extensionConfig = require("./extension-config");
 
 var _packageChanged = require("./package-changed");
 
-const DEFAULT_SEARCH_DEPTH = 4;
-const DEFAULT_FIND_EXTENSIONS_OPTS = Object.freeze({
-  depthLimit: DEFAULT_SEARCH_DEPTH,
-  filter: filepath => !_path.default.basename(filepath).startsWith('.')
-});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const CONFIG_SCHEMA_REV = 2;
 const CONFIG_DATA_DRIVER_KEY = `${_constants.DRIVER_TYPE}s`;
 const CONFIG_DATA_PLUGIN_KEY = `${_constants.PLUGIN_TYPE}s`;
@@ -67,31 +66,37 @@ class Manifest {
     return new Manifest(appiumHome);
   });
 
-  async syncWithInstalledExtensions({
-    depthLimit = DEFAULT_SEARCH_DEPTH
-  } = {}) {
-    const walkOpts = _lodash.default.defaults({
-      depthLimit
-    }, DEFAULT_FIND_EXTENSIONS_OPTS);
-
+  async syncWithInstalledExtensions() {
     let didChange = false;
 
-    for await (const {
-      stats,
-      path: filepath
-    } of _support.fs.walk(this._appiumHome, walkOpts)) {
-      if (filepath !== this._appiumHome && stats.isDirectory()) {
-        try {
-          const pkg = await _support.env.readPackageInDir(filepath);
-
-          if (pkg && isExtension(pkg)) {
-            const added = this.addExtensionFromPackage(pkg, _path.default.join(filepath, 'package.json'));
-            didChange = didChange || added;
-          }
-        } catch {}
-      }
-    }
+    const onMatch = async filepath => {
+      try {
+        const pkg = JSON.parse(await _support.fs.readFile(filepath, 'utf8'));
+
+        if (isDriver(pkg) || isPlugin(pkg)) {
+          const changed = this.addExtensionFromPackage(pkg, filepath);
+          didChange = didChange || changed;
+        }
+      } catch {}
+    };
+
+    const queue = [onMatch(_path.default.join(this._appiumHome, 'package.json'))];
+    await new _bluebird.default((resolve, reject) => {
+      (0, _glob.default)('node_modules/{*,@*/*}/package.json', {
+        cwd: this._appiumHome,
+        silent: true,
+        absolute: true
+      }, err => {
+        if (err) {
+          reject(err);
+        }
 
+        resolve();
+      }).on('error', reject).on('match', filepath => {
+        queue.push(onMatch(filepath));
+      });
+    });
+    await _bluebird.default.all(queue);
     return didChange;
   }
 
@@ -253,4 +258,4 @@ class Manifest {
 }
 
 exports.Manifest = Manifest;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_SEARCH_DEPTH","DEFAULT_FIND_EXTENSIONS_OPTS","Object","freeze","depthLimit","filter","filepath","path","basename","startsWith","CONFIG_SCHEMA_REV","CONFIG_DATA_DRIVER_KEY","DRIVER_TYPE","CONFIG_DATA_PLUGIN_KEY","PLUGIN_TYPE","INITIAL_MANIFEST_DATA","schemaRev","isExtension","value","_","isPlainObject","appium","isString","name","version","isDriver","get","isArray","isPlugin","Manifest","_data","_appiumHome","_manifestPath","_writing","_reading","constructor","appiumHome","cloneDeep","getInstance","memoize","_getInstance","syncWithInstalledExtensions","walkOpts","defaults","didChange","stats","fs","walk","isDirectory","pkg","env","readPackageInDir","added","addExtensionFromPackage","join","hasDriver","Boolean","drivers","hasPlugin","plugins","pkgJson","pkgPath","extensionPath","dirname","internal","pkgName","appiumVersion","peerDependencies","installType","INSTALL_TYPE_NPM","installSpec","driverName","addExtension","omit","pluginName","TypeError","extType","extName","extData","data","clone","manifestPath","getExtensionData","read","isNewFile","_setManifestPath","log","debug","yaml","readFile","YAML","parse","JSON","stringify","err","code","Error","message","installedExtensionsChanged","hasAppiumDependency","packageDidChange","write","undefined","resolveManifestPath","relative","mkdirp","writeFile"],"sources":["../../../lib/extension/manifest.js"],"sourcesContent":["/**\n * Module containing {@link Manifest} which handles reading & writing of extension config files.\n */\n\nimport {env, fs} from '@appium/support';\nimport _ from 'lodash';\nimport path from 'path';\nimport YAML from 'yaml';\nimport {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';\nimport log from '../logger';\nimport {INSTALL_TYPE_NPM} from './extension-config';\nimport {packageDidChange} from './package-changed';\n\n/**\n * Default depth to search in directory tree for whatever it is we're looking for.\n *\n * It's 4 because smaller numbers didn't work.\n */\nconst DEFAULT_SEARCH_DEPTH = 4;\n\n/**\n * Default options for {@link findExtensions}.\n * @type {Readonly<import('klaw').Options>}\n */\nconst DEFAULT_FIND_EXTENSIONS_OPTS = Object.freeze({\n  depthLimit: DEFAULT_SEARCH_DEPTH,\n  /* istanbul ignore next */\n  filter: (filepath) => !path.basename(filepath).startsWith('.'),\n});\n\n/**\n * Current configuration schema revision!\n */\nconst CONFIG_SCHEMA_REV = 2;\n\n/**\n * The name of the prop (`drivers`) used in `extensions.yaml` for drivers.\n * @type {`${typeof DRIVER_TYPE}s`}\n */\nconst CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s`;\n\n/**\n * The name of the prop (`plugins`) used in `extensions.yaml` for plugins.\n * @type {`${typeof PLUGIN_TYPE}s`}\n */\nconst CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s`;\n\n/**\n * @type {Readonly<ManifestData>}\n */\nconst INITIAL_MANIFEST_DATA = Object.freeze({\n  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),\n  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),\n  schemaRev: CONFIG_SCHEMA_REV,\n});\n\n/**\n * Given a `package.json` return `true` if it represents an Appium Extension (either a driver or plugin).\n *\n * The `package.json` must have an `appium` property which is an object.\n * @param {any} value\n * @returns {value is ExtPackageJson<ExtensionType>}\n */\nfunction isExtension(value) {\n  return (\n    _.isPlainObject(value) &&\n    _.isPlainObject(value.appium) &&\n    _.isString(value.name) &&\n    _.isString(value.version)\n  );\n}\n/**\n * Given a `package.json`, return `true` if it represents an Appium Driver.\n *\n * To be considered a driver, a `package.json` must have a fields\n * `appium.driverName`, `appium.automationName` and `appium.platformNames`.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<DriverType>}\n */\nfunction isDriver(value) {\n  return (\n    isExtension(value) &&\n    _.isString(_.get(value, 'appium.driverName')) &&\n    _.isString(_.get(value, 'appium.automationName')) &&\n    _.isArray(_.get(value, 'appium.platformNames'))\n  );\n}\n\n/**\n * Given a `package.json`, return `true` if it represents an Appium Plugin.\n *\n * To be considered a plugin, a `package.json` must have an `appium.pluginName` field.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<PluginType>}\n */\nfunction isPlugin(value) {\n  return isExtension(value) && _.isString(_.get(value, 'appium.pluginName'));\n}\n\n/**\n * Handles reading & writing of extension config files.\n *\n * Only one instance of this class exists per value of `APPIUM_HOME`.\n */\nexport class Manifest {\n  /**\n   * The entire contents of a parsed YAML extension config file.\n   *\n   * Contains proxies for automatic persistence on disk\n   * @type {ManifestData}\n   * @private\n   */\n  _data;\n\n  /**\n   * Path to `APPIUM_HOME`.\n   * @private\n   * @type {Readonly<string>}\n   */\n  _appiumHome;\n\n  /**\n   * Path to `extensions.yaml`\n   * @type {string}\n   * Not set until {@link Manifest.read} is called.\n   */\n  _manifestPath;\n\n  /**\n   * Helps avoid writing multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.write} will cause it to be\n   * set to a `Promise`. When the call to `write()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<boolean>|undefined}\n   */\n  _writing;\n\n  /**\n   * Helps avoid reading multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.read} will cause it to be\n   * set to a `Promise`. When the call to `read()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<void>|undefined}\n   */\n  _reading;\n\n  /**\n   * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}\n   *\n   * Use {@link Manifest.getInstance} instead.\n   * @param {string} appiumHome\n   * @private\n   */\n  constructor(appiumHome) {\n    this._appiumHome = appiumHome;\n    this._data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n  }\n\n  /**\n   * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.\n   *\n   * Maintains one instance per value of `appiumHome`.\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @returns {Manifest}\n   */\n  static getInstance = _.memoize(function _getInstance(appiumHome) {\n    return new Manifest(appiumHome);\n  });\n\n  /**\n   * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.\n   * @param {SyncWithInstalledExtensionsOpts} opts\n   * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.\n   */\n  async syncWithInstalledExtensions({depthLimit = DEFAULT_SEARCH_DEPTH} = {}) {\n    const walkOpts = _.defaults({depthLimit}, DEFAULT_FIND_EXTENSIONS_OPTS);\n    // this could be parallelized, but we can't use fs.walk as an async iterator\n    let didChange = false;\n    for await (const {stats, path: filepath} of fs.walk(this._appiumHome, walkOpts)) {\n      if (filepath !== this._appiumHome && stats.isDirectory()) {\n        try {\n          const pkg = await env.readPackageInDir(filepath);\n          if (pkg && isExtension(pkg)) {\n            // it's possible that this extension already exists in the manifest,\n            // so only update `didChange` if it's new.\n            const added = this.addExtensionFromPackage(pkg, path.join(filepath, 'package.json'));\n            didChange = didChange || added;\n          }\n        } catch {}\n      }\n    }\n    return didChange;\n  }\n\n  /**\n   * Returns `true` if driver with name `name` is registered.\n   * @param {string} name - Driver name\n   * @returns {boolean}\n   */\n  hasDriver(name) {\n    return Boolean(this._data.drivers[name]);\n  }\n\n  /**\n   * Returns `true` if plugin with name `name` is registered.\n   * @param {string} name - Plugin name\n   * @returns {boolean}\n   */\n  hasPlugin(name) {\n    return Boolean(this._data.plugins[name]);\n  }\n\n  /**\n   * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.\n   *\n   * Will _not_ overwrite existing entries.\n   * @template {ExtensionType} ExtType\n   * @param {ExtPackageJson<ExtType>} pkgJson\n   * @param {string} pkgPath\n   * @returns {boolean} - `true` upon success, `false` if the extension is already registered.\n   */\n  addExtensionFromPackage(pkgJson, pkgPath) {\n    const extensionPath = path.dirname(pkgPath);\n\n    /**\n     * @type {InternalMetadata}\n     */\n    const internal = {\n      pkgName: pkgJson.name,\n      version: pkgJson.version,\n      appiumVersion: pkgJson.peerDependencies?.appium,\n      installType: INSTALL_TYPE_NPM,\n      installSpec: `${pkgJson.name}@${pkgJson.version}`,\n    };\n\n    if (isDriver(pkgJson)) {\n      if (!this.hasDriver(pkgJson.appium.driverName)) {\n        this.addExtension(DRIVER_TYPE, pkgJson.appium.driverName, {\n          ..._.omit(pkgJson.appium, 'driverName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else if (isPlugin(pkgJson)) {\n      if (!this.hasPlugin(pkgJson.appium.pluginName)) {\n        this.addExtension(PLUGIN_TYPE, pkgJson.appium.pluginName, {\n          ..._.omit(pkgJson.appium, 'pluginName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else {\n      throw new TypeError(\n        `The extension in ${extensionPath} is neither a valid driver nor a valid plugin.`\n      );\n    }\n  }\n\n  /**\n   * Adds an extension to the manifest as was installed by the `appium` CLI.  The\n   * `extData`, `extType`, and `extName` have already been determined.\n   *\n   * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType - `driver` or `plugin`\n   * @param {string} extName - Name of extension\n   * @param {ExtManifest<ExtType>} extData - Extension metadata\n   * @returns {ExtManifest<ExtType>} A clone of `extData`, potentially with a mutated `appiumVersion` field\n   */\n  addExtension(extType, extName, extData) {\n    const data = _.clone(extData);\n    this._data[`${extType}s`][extName] = data;\n    return data;\n  }\n\n  /**\n   * Returns the APPIUM_HOME path\n   */\n  get appiumHome() {\n    return this._appiumHome;\n  }\n\n  /**\n   * Returns the path to the manifest file\n   */\n  get manifestPath() {\n    return this._manifestPath;\n  }\n\n  /**\n   * Returns extension data for a particular type.\n   *\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType\n   * @returns {ExtRecord<ExtType>}\n   */\n  getExtensionData(extType) {\n    return this._data[/** @type {string} */ (`${extType}s`)];\n  }\n\n  /**\n   * Reads manifest from disk and _overwrites_ the internal data.\n   *\n   * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA \"empty\"} manifest file will be created.\n   *\n   * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.\n   *\n   * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.\n   * @returns {Promise<ManifestData>} The data\n   */\n  async read() {\n    if (this._reading) {\n      await this._reading;\n      return this._data;\n    }\n\n    this._reading = (async () => {\n      /** @type {ManifestData} */\n      let data;\n      let isNewFile = false;\n      await this._setManifestPath();\n      try {\n        log.debug(`Reading ${this._manifestPath}...`);\n        const yaml = await fs.readFile(this._manifestPath, 'utf8');\n        data = YAML.parse(yaml);\n        log.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);\n      } catch (err) {\n        if (err.code === 'ENOENT') {\n          data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n          isNewFile = true;\n        } else {\n          if (this._manifestPath) {\n            throw new Error(\n              `Appium had trouble loading the extension installation ` +\n                `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`\n            );\n          } else {\n            throw new Error(\n              `Appium encountered an unknown problem. Specific error: ${err.message}`\n            );\n          }\n        }\n      }\n\n      this._data = data;\n      let installedExtensionsChanged = false;\n      if (\n        (await env.hasAppiumDependency(this.appiumHome)) &&\n        (await packageDidChange(this.appiumHome))\n      ) {\n        installedExtensionsChanged = await this.syncWithInstalledExtensions();\n      }\n\n      if (isNewFile || installedExtensionsChanged) {\n        await this.write();\n      }\n    })();\n    try {\n      await this._reading;\n      return this._data;\n    } finally {\n      this._reading = undefined;\n    }\n  }\n\n  /**\n   * Ensures {@link Manifest._manifestPath} is set.\n   *\n   * Creates the directory if necessary.\n   * @private\n   * @returns {Promise<string>}\n   */\n  async _setManifestPath() {\n    if (!this._manifestPath) {\n      this._manifestPath = await env.resolveManifestPath(this._appiumHome);\n\n      /* istanbul ignore if */\n      if (path.relative(this._appiumHome, this._manifestPath).startsWith('.')) {\n        throw new Error(\n          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`\n        );\n      }\n    }\n\n    return this._manifestPath;\n  }\n\n  /**\n   * Writes the data if it need s writing.\n   *\n   * If the `schemaRev` prop needs updating, the file will be written.\n   *\n   * @todo If this becomes too much of a bottleneck, throttle it.\n   * @returns {Promise<boolean>} Whether the data was written\n   */\n  async write() {\n    if (this._writing) {\n      return this._writing;\n    }\n    this._writing = (async () => {\n      await this._setManifestPath();\n      try {\n        await fs.mkdirp(path.dirname(this._manifestPath));\n      } catch (err) {\n        throw new Error(\n          `Appium could not create the directory for the manifest file: ${path.dirname(\n            this._manifestPath\n          )}. Original error: ${err.message}`\n        );\n      }\n      try {\n        await fs.writeFile(this._manifestPath, YAML.stringify(this._data), 'utf8');\n        return true;\n      } catch (err) {\n        throw new Error(\n          `Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` +\n            `Please ensure it is writable. Original error: ${err.message}`\n        );\n      }\n    })();\n    try {\n      return await this._writing;\n    } finally {\n      this._writing = undefined;\n    }\n  }\n}\n\n/**\n * Type of the string referring to a driver (typically as a key or type string)\n * @typedef {import('@appium/types').DriverType} DriverType\n */\n\n/**\n * Type of the string referring to a plugin (typically as a key or type string)\n * @typedef {import('@appium/types').PluginType} PluginType\n */\n\n/**\n * @typedef SyncWithInstalledExtensionsOpts\n * @property {number} [depthLimit] - Maximum depth to recurse into subdirectories\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('appium/types').InternalMetadata} InternalMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtPackageJson<T>} ExtPackageJson\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Either `driver` or `plugin` rn\n * @typedef {import('@appium/types').ExtensionType} ExtensionType\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["CONFIG_SCHEMA_REV","CONFIG_DATA_DRIVER_KEY","DRIVER_TYPE","CONFIG_DATA_PLUGIN_KEY","PLUGIN_TYPE","INITIAL_MANIFEST_DATA","Object","freeze","schemaRev","isExtension","value","_","isPlainObject","appium","isString","name","version","isDriver","get","isArray","isPlugin","Manifest","_data","_appiumHome","_manifestPath","_writing","_reading","constructor","appiumHome","cloneDeep","getInstance","memoize","_getInstance","syncWithInstalledExtensions","didChange","onMatch","filepath","pkg","JSON","parse","fs","readFile","changed","addExtensionFromPackage","queue","path","join","B","resolve","reject","glob","cwd","silent","absolute","err","on","push","all","hasDriver","Boolean","drivers","hasPlugin","plugins","pkgJson","pkgPath","extensionPath","dirname","internal","pkgName","appiumVersion","peerDependencies","installType","INSTALL_TYPE_NPM","installSpec","driverName","addExtension","omit","pluginName","TypeError","extType","extName","extData","data","clone","manifestPath","getExtensionData","read","isNewFile","_setManifestPath","log","debug","yaml","YAML","stringify","code","Error","message","installedExtensionsChanged","env","hasAppiumDependency","packageDidChange","write","undefined","resolveManifestPath","relative","startsWith","mkdirp","writeFile"],"sources":["../../../lib/extension/manifest.js"],"sourcesContent":["/**\n * Module containing {@link Manifest} which handles reading & writing of extension config files.\n */\n\nimport B from 'bluebird';\nimport glob from 'glob';\nimport {env, fs} from '@appium/support';\nimport _ from 'lodash';\nimport path from 'path';\nimport YAML from 'yaml';\nimport {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';\nimport log from '../logger';\nimport {INSTALL_TYPE_NPM} from './extension-config';\nimport {packageDidChange} from './package-changed';\n\n/**\n * Current configuration schema revision!\n */\nconst CONFIG_SCHEMA_REV = 2;\n\n/**\n * The name of the prop (`drivers`) used in `extensions.yaml` for drivers.\n * @type {`${typeof DRIVER_TYPE}s`}\n */\nconst CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s`;\n\n/**\n * The name of the prop (`plugins`) used in `extensions.yaml` for plugins.\n * @type {`${typeof PLUGIN_TYPE}s`}\n */\nconst CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s`;\n\n/**\n * @type {Readonly<ManifestData>}\n */\nconst INITIAL_MANIFEST_DATA = Object.freeze({\n  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),\n  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),\n  schemaRev: CONFIG_SCHEMA_REV,\n});\n\n/**\n * Given a `package.json` return `true` if it represents an Appium Extension (either a driver or plugin).\n *\n * The `package.json` must have an `appium` property which is an object.\n * @param {any} value\n * @returns {value is ExtPackageJson<ExtensionType>}\n */\nfunction isExtension(value) {\n  return (\n    _.isPlainObject(value) &&\n    _.isPlainObject(value.appium) &&\n    _.isString(value.name) &&\n    _.isString(value.version)\n  );\n}\n/**\n * Given a `package.json`, return `true` if it represents an Appium Driver.\n *\n * To be considered a driver, a `package.json` must have a fields\n * `appium.driverName`, `appium.automationName` and `appium.platformNames`.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<DriverType>}\n */\nfunction isDriver(value) {\n  return (\n    isExtension(value) &&\n    _.isString(_.get(value, 'appium.driverName')) &&\n    _.isString(_.get(value, 'appium.automationName')) &&\n    _.isArray(_.get(value, 'appium.platformNames'))\n  );\n}\n\n/**\n * Given a `package.json`, return `true` if it represents an Appium Plugin.\n *\n * To be considered a plugin, a `package.json` must have an `appium.pluginName` field.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<PluginType>}\n */\nfunction isPlugin(value) {\n  return isExtension(value) && _.isString(_.get(value, 'appium.pluginName'));\n}\n\n/**\n * Handles reading & writing of extension config files.\n *\n * Only one instance of this class exists per value of `APPIUM_HOME`.\n */\nexport class Manifest {\n  /**\n   * The entire contents of a parsed YAML extension config file.\n   *\n   * Contains proxies for automatic persistence on disk\n   * @type {ManifestData}\n   * @private\n   */\n  _data;\n\n  /**\n   * Path to `APPIUM_HOME`.\n   * @private\n   * @type {Readonly<string>}\n   */\n  _appiumHome;\n\n  /**\n   * Path to `extensions.yaml`\n   * @type {string}\n   * Not set until {@link Manifest.read} is called.\n   */\n  _manifestPath;\n\n  /**\n   * Helps avoid writing multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.write} will cause it to be\n   * set to a `Promise`. When the call to `write()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<boolean>|undefined}\n   */\n  _writing;\n\n  /**\n   * Helps avoid reading multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.read} will cause it to be\n   * set to a `Promise`. When the call to `read()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<void>|undefined}\n   */\n  _reading;\n\n  /**\n   * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}\n   *\n   * Use {@link Manifest.getInstance} instead.\n   * @param {string} appiumHome\n   * @private\n   */\n  constructor(appiumHome) {\n    this._appiumHome = appiumHome;\n    this._data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n  }\n\n  /**\n   * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.\n   *\n   * Maintains one instance per value of `appiumHome`.\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @returns {Manifest}\n   */\n  static getInstance = _.memoize(function _getInstance(appiumHome) {\n    return new Manifest(appiumHome);\n  });\n\n  /**\n   * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.\n   * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.\n   */\n  async syncWithInstalledExtensions() {\n    // this could be parallelized, but we can't use fs.walk as an async iterator\n    let didChange = false;\n\n    /**\n     * Listener for the `match` event of a `glob` instance\n     * @param {string} filepath - Path to a `package.json`\n     * @returns {Promise<void>}\n     */\n    const onMatch = async (filepath) => {\n      try {\n        const pkg = JSON.parse(await fs.readFile(filepath, 'utf8'));\n        if (isDriver(pkg) || isPlugin(pkg)) {\n          const changed = this.addExtensionFromPackage(pkg, filepath);\n          didChange = didChange || changed;\n        }\n      } catch {}\n    };\n\n    /**\n     * A list of `Promise`s which read `package.json` files looking for Appium extensions.\n     * @type {Promise<void>[]}\n     */\n    const queue = [\n      // look at `package.json` in `APPIUM_HOME` only\n      onMatch(path.join(this._appiumHome, 'package.json')),\n    ];\n\n    // add dependencies to the queue\n    await new B((resolve, reject) => {\n      glob(\n        'node_modules/{*,@*/*}/package.json',\n        {cwd: this._appiumHome, silent: true, absolute: true},\n        // eslint-disable-next-line promise/prefer-await-to-callbacks\n        (err) => {\n          if (err) {\n            reject(err);\n          }\n          resolve();\n        }\n      )\n        .on('error', reject)\n        .on('match', (filepath) => {\n          queue.push(onMatch(filepath));\n        });\n    });\n\n    // wait for everything to finish\n    await B.all(queue);\n\n    return didChange;\n  }\n\n  /**\n   * Returns `true` if driver with name `name` is registered.\n   * @param {string} name - Driver name\n   * @returns {boolean}\n   */\n  hasDriver(name) {\n    return Boolean(this._data.drivers[name]);\n  }\n\n  /**\n   * Returns `true` if plugin with name `name` is registered.\n   * @param {string} name - Plugin name\n   * @returns {boolean}\n   */\n  hasPlugin(name) {\n    return Boolean(this._data.plugins[name]);\n  }\n\n  /**\n   * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.\n   *\n   * Will _not_ overwrite existing entries.\n   * @template {ExtensionType} ExtType\n   * @param {ExtPackageJson<ExtType>} pkgJson\n   * @param {string} pkgPath\n   * @returns {boolean} - `true` upon success, `false` if the extension is already registered.\n   */\n  addExtensionFromPackage(pkgJson, pkgPath) {\n    const extensionPath = path.dirname(pkgPath);\n\n    /**\n     * @type {InternalMetadata}\n     */\n    const internal = {\n      pkgName: pkgJson.name,\n      version: pkgJson.version,\n      appiumVersion: pkgJson.peerDependencies?.appium,\n      installType: INSTALL_TYPE_NPM,\n      installSpec: `${pkgJson.name}@${pkgJson.version}`,\n    };\n\n    if (isDriver(pkgJson)) {\n      if (!this.hasDriver(pkgJson.appium.driverName)) {\n        this.addExtension(DRIVER_TYPE, pkgJson.appium.driverName, {\n          ..._.omit(pkgJson.appium, 'driverName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else if (isPlugin(pkgJson)) {\n      if (!this.hasPlugin(pkgJson.appium.pluginName)) {\n        this.addExtension(PLUGIN_TYPE, pkgJson.appium.pluginName, {\n          ..._.omit(pkgJson.appium, 'pluginName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else {\n      throw new TypeError(\n        `The extension in ${extensionPath} is neither a valid driver nor a valid plugin.`\n      );\n    }\n  }\n\n  /**\n   * Adds an extension to the manifest as was installed by the `appium` CLI.  The\n   * `extData`, `extType`, and `extName` have already been determined.\n   *\n   * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType - `driver` or `plugin`\n   * @param {string} extName - Name of extension\n   * @param {ExtManifest<ExtType>} extData - Extension metadata\n   * @returns {ExtManifest<ExtType>} A clone of `extData`, potentially with a mutated `appiumVersion` field\n   */\n  addExtension(extType, extName, extData) {\n    const data = _.clone(extData);\n    this._data[`${extType}s`][extName] = data;\n    return data;\n  }\n\n  /**\n   * Returns the APPIUM_HOME path\n   */\n  get appiumHome() {\n    return this._appiumHome;\n  }\n\n  /**\n   * Returns the path to the manifest file\n   */\n  get manifestPath() {\n    return this._manifestPath;\n  }\n\n  /**\n   * Returns extension data for a particular type.\n   *\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType\n   * @returns {ExtRecord<ExtType>}\n   */\n  getExtensionData(extType) {\n    return this._data[/** @type {string} */ (`${extType}s`)];\n  }\n\n  /**\n   * Reads manifest from disk and _overwrites_ the internal data.\n   *\n   * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA \"empty\"} manifest file will be created.\n   *\n   * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.\n   *\n   * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.\n   * @returns {Promise<ManifestData>} The data\n   */\n  async read() {\n    if (this._reading) {\n      await this._reading;\n      return this._data;\n    }\n\n    this._reading = (async () => {\n      /** @type {ManifestData} */\n      let data;\n      let isNewFile = false;\n      await this._setManifestPath();\n      try {\n        log.debug(`Reading ${this._manifestPath}...`);\n        const yaml = await fs.readFile(this._manifestPath, 'utf8');\n        data = YAML.parse(yaml);\n        log.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);\n      } catch (err) {\n        if (err.code === 'ENOENT') {\n          data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n          isNewFile = true;\n        } else {\n          if (this._manifestPath) {\n            throw new Error(\n              `Appium had trouble loading the extension installation ` +\n                `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`\n            );\n          } else {\n            throw new Error(\n              `Appium encountered an unknown problem. Specific error: ${err.message}`\n            );\n          }\n        }\n      }\n\n      this._data = data;\n      let installedExtensionsChanged = false;\n      if (\n        (await env.hasAppiumDependency(this.appiumHome)) &&\n        (await packageDidChange(this.appiumHome))\n      ) {\n        installedExtensionsChanged = await this.syncWithInstalledExtensions();\n      }\n\n      if (isNewFile || installedExtensionsChanged) {\n        await this.write();\n      }\n    })();\n    try {\n      await this._reading;\n      return this._data;\n    } finally {\n      this._reading = undefined;\n    }\n  }\n\n  /**\n   * Ensures {@link Manifest._manifestPath} is set.\n   *\n   * Creates the directory if necessary.\n   * @private\n   * @returns {Promise<string>}\n   */\n  async _setManifestPath() {\n    if (!this._manifestPath) {\n      this._manifestPath = await env.resolveManifestPath(this._appiumHome);\n\n      /* istanbul ignore if */\n      if (path.relative(this._appiumHome, this._manifestPath).startsWith('.')) {\n        throw new Error(\n          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`\n        );\n      }\n    }\n\n    return this._manifestPath;\n  }\n\n  /**\n   * Writes the data if it need s writing.\n   *\n   * If the `schemaRev` prop needs updating, the file will be written.\n   *\n   * @todo If this becomes too much of a bottleneck, throttle it.\n   * @returns {Promise<boolean>} Whether the data was written\n   */\n  async write() {\n    if (this._writing) {\n      return this._writing;\n    }\n    this._writing = (async () => {\n      await this._setManifestPath();\n      try {\n        await fs.mkdirp(path.dirname(this._manifestPath));\n      } catch (err) {\n        throw new Error(\n          `Appium could not create the directory for the manifest file: ${path.dirname(\n            this._manifestPath\n          )}. Original error: ${err.message}`\n        );\n      }\n      try {\n        await fs.writeFile(this._manifestPath, YAML.stringify(this._data), 'utf8');\n        return true;\n      } catch (err) {\n        throw new Error(\n          `Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` +\n            `Please ensure it is writable. Original error: ${err.message}`\n        );\n      }\n    })();\n    try {\n      return await this._writing;\n    } finally {\n      this._writing = undefined;\n    }\n  }\n}\n\n/**\n * Type of the string referring to a driver (typically as a key or type string)\n * @typedef {import('@appium/types').DriverType} DriverType\n */\n\n/**\n * Type of the string referring to a plugin (typically as a key or type string)\n * @typedef {import('@appium/types').PluginType} PluginType\n */\n\n/**\n * @typedef SyncWithInstalledExtensionsOpts\n * @property {number} [depthLimit] - Maximum depth to recurse into subdirectories\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('appium/types').InternalMetadata} InternalMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtPackageJson<T>} ExtPackageJson\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Either `driver` or `plugin` rn\n * @typedef {import('@appium/types').ExtensionType} ExtensionType\n */\n"],"mappings":"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"}

package/build/lib/extension/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","names":["CONFIG_SCHEMA_REV","CONFIG_DATA_DRIVER_KEY","DRIVER_TYPE","CONFIG_DATA_PLUGIN_KEY","PLUGIN_TYPE","INITIAL_MANIFEST_DATA","Object","freeze","schemaRev","isExtension","value","_","isPlainObject","appium","isString","name","version","isDriver","get","isArray","isPlugin","Manifest","_data","_appiumHome","_manifestPath","_writing","_reading","constructor","appiumHome","cloneDeep","getInstance","memoize","_getInstance","syncWithInstalledExtensions","didChange","onMatch","filepath","pkg","JSON","parse","fs","readFile","changed","addExtensionFromPackage","queue","path","join","B","resolve","reject","glob","cwd","silent","absolute","err","on","push","all","hasDriver","Boolean","drivers","hasPlugin","plugins","pkgJson","pkgPath","extensionPath","dirname","internal","pkgName","appiumVersion","peerDependencies","installType","INSTALL_TYPE_NPM","installSpec","driverName","addExtension","omit","pluginName","TypeError","extType","extName","extData","data","clone","manifestPath","getExtensionData","read","isNewFile","_setManifestPath","log","debug","yaml","YAML","stringify","code","Error","message","installedExtensionsChanged","env","hasAppiumDependency","packageDidChange","write","undefined","resolveManifestPath","relative","startsWith","mkdirp","writeFile"],"sources":["../../../lib/extension/manifest.js"],"sourcesContent":["/**\n * Module containing {@link Manifest} which handles reading & writing of extension config files.\n */\n\nimport B from 'bluebird';\nimport glob from 'glob';\nimport {env, fs} from '@appium/support';\nimport _ from 'lodash';\nimport path from 'path';\nimport YAML from 'yaml';\nimport {DRIVER_TYPE, PLUGIN_TYPE} from '../constants';\nimport log from '../logger';\nimport {INSTALL_TYPE_NPM} from './extension-config';\nimport {packageDidChange} from './package-changed';\n\n/**\n * Current configuration schema revision!\n */\nconst CONFIG_SCHEMA_REV = 2;\n\n/**\n * The name of the prop (`drivers`) used in `extensions.yaml` for drivers.\n * @type {`${typeof DRIVER_TYPE}s`}\n */\nconst CONFIG_DATA_DRIVER_KEY = `${DRIVER_TYPE}s`;\n\n/**\n * The name of the prop (`plugins`) used in `extensions.yaml` for plugins.\n * @type {`${typeof PLUGIN_TYPE}s`}\n */\nconst CONFIG_DATA_PLUGIN_KEY = `${PLUGIN_TYPE}s`;\n\n/**\n * @type {Readonly<ManifestData>}\n */\nconst INITIAL_MANIFEST_DATA = Object.freeze({\n  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),\n  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),\n  schemaRev: CONFIG_SCHEMA_REV,\n});\n\n/**\n * Given a `package.json` return `true` if it represents an Appium Extension (either a driver or plugin).\n *\n * The `package.json` must have an `appium` property which is an object.\n * @param {any} value\n * @returns {value is ExtPackageJson<ExtensionType>}\n */\nfunction isExtension(value) {\n  return (\n    _.isPlainObject(value) &&\n    _.isPlainObject(value.appium) &&\n    _.isString(value.name) &&\n    _.isString(value.version)\n  );\n}\n/**\n * Given a `package.json`, return `true` if it represents an Appium Driver.\n *\n * To be considered a driver, a `package.json` must have a fields\n * `appium.driverName`, `appium.automationName` and `appium.platformNames`.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<DriverType>}\n */\nfunction isDriver(value) {\n  return (\n    isExtension(value) &&\n    _.isString(_.get(value, 'appium.driverName')) &&\n    _.isString(_.get(value, 'appium.automationName')) &&\n    _.isArray(_.get(value, 'appium.platformNames'))\n  );\n}\n\n/**\n * Given a `package.json`, return `true` if it represents an Appium Plugin.\n *\n * To be considered a plugin, a `package.json` must have an `appium.pluginName` field.\n * @param {any} value - Value to test\n * @returns {value is ExtPackageJson<PluginType>}\n */\nfunction isPlugin(value) {\n  return isExtension(value) && _.isString(_.get(value, 'appium.pluginName'));\n}\n\n/**\n * Handles reading & writing of extension config files.\n *\n * Only one instance of this class exists per value of `APPIUM_HOME`.\n */\nexport class Manifest {\n  /**\n   * The entire contents of a parsed YAML extension config file.\n   *\n   * Contains proxies for automatic persistence on disk\n   * @type {ManifestData}\n   * @private\n   */\n  _data;\n\n  /**\n   * Path to `APPIUM_HOME`.\n   * @private\n   * @type {Readonly<string>}\n   */\n  _appiumHome;\n\n  /**\n   * Path to `extensions.yaml`\n   * @type {string}\n   * Not set until {@link Manifest.read} is called.\n   */\n  _manifestPath;\n\n  /**\n   * Helps avoid writing multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.write} will cause it to be\n   * set to a `Promise`. When the call to `write()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<boolean>|undefined}\n   */\n  _writing;\n\n  /**\n   * Helps avoid reading multiple times.\n   *\n   * If this is `undefined`, calling {@link Manifest.read} will cause it to be\n   * set to a `Promise`. When the call to `read()` is complete, the `Promise`\n   * will resolve and then this value will be set to `undefined`.  Concurrent calls\n   * made while this value is a `Promise` will return the `Promise` itself.\n   * @private\n   * @type {Promise<void>|undefined}\n   */\n  _reading;\n\n  /**\n   * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}\n   *\n   * Use {@link Manifest.getInstance} instead.\n   * @param {string} appiumHome\n   * @private\n   */\n  constructor(appiumHome) {\n    this._appiumHome = appiumHome;\n    this._data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n  }\n\n  /**\n   * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.\n   *\n   * Maintains one instance per value of `appiumHome`.\n   * @param {string} appiumHome - Path to `APPIUM_HOME`\n   * @returns {Manifest}\n   */\n  static getInstance = _.memoize(function _getInstance(appiumHome) {\n    return new Manifest(appiumHome);\n  });\n\n  /**\n   * Searches `APPIUM_HOME` for installed extensions and adds them to the manifest.\n   * @returns {Promise<boolean>} `true` if any extensions were added, `false` otherwise.\n   */\n  async syncWithInstalledExtensions() {\n    // this could be parallelized, but we can't use fs.walk as an async iterator\n    let didChange = false;\n\n    /**\n     * Listener for the `match` event of a `glob` instance\n     * @param {string} filepath - Path to a `package.json`\n     * @returns {Promise<void>}\n     */\n    const onMatch = async (filepath) => {\n      try {\n        const pkg = JSON.parse(await fs.readFile(filepath, 'utf8'));\n        if (isDriver(pkg) || isPlugin(pkg)) {\n          const changed = this.addExtensionFromPackage(pkg, filepath);\n          didChange = didChange || changed;\n        }\n      } catch {}\n    };\n\n    /**\n     * A list of `Promise`s which read `package.json` files looking for Appium extensions.\n     * @type {Promise<void>[]}\n     */\n    const queue = [\n      // look at `package.json` in `APPIUM_HOME` only\n      onMatch(path.join(this._appiumHome, 'package.json')),\n    ];\n\n    // add dependencies to the queue\n    await new B((resolve, reject) => {\n      glob(\n        'node_modules/{*,@*/*}/package.json',\n        {cwd: this._appiumHome, silent: true, absolute: true},\n        // eslint-disable-next-line promise/prefer-await-to-callbacks\n        (err) => {\n          if (err) {\n            reject(err);\n          }\n          resolve();\n        }\n      )\n        .on('error', reject)\n        .on('match', (filepath) => {\n          queue.push(onMatch(filepath));\n        });\n    });\n\n    // wait for everything to finish\n    await B.all(queue);\n\n    return didChange;\n  }\n\n  /**\n   * Returns `true` if driver with name `name` is registered.\n   * @param {string} name - Driver name\n   * @returns {boolean}\n   */\n  hasDriver(name) {\n    return Boolean(this._data.drivers[name]);\n  }\n\n  /**\n   * Returns `true` if plugin with name `name` is registered.\n   * @param {string} name - Plugin name\n   * @returns {boolean}\n   */\n  hasPlugin(name) {\n    return Boolean(this._data.plugins[name]);\n  }\n\n  /**\n   * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.\n   *\n   * Will _not_ overwrite existing entries.\n   * @template {ExtensionType} ExtType\n   * @param {ExtPackageJson<ExtType>} pkgJson\n   * @param {string} pkgPath\n   * @returns {boolean} - `true` upon success, `false` if the extension is already registered.\n   */\n  addExtensionFromPackage(pkgJson, pkgPath) {\n    const extensionPath = path.dirname(pkgPath);\n\n    /**\n     * @type {InternalMetadata}\n     */\n    const internal = {\n      pkgName: pkgJson.name,\n      version: pkgJson.version,\n      appiumVersion: pkgJson.peerDependencies?.appium,\n      installType: INSTALL_TYPE_NPM,\n      installSpec: `${pkgJson.name}@${pkgJson.version}`,\n    };\n\n    if (isDriver(pkgJson)) {\n      if (!this.hasDriver(pkgJson.appium.driverName)) {\n        this.addExtension(DRIVER_TYPE, pkgJson.appium.driverName, {\n          ..._.omit(pkgJson.appium, 'driverName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else if (isPlugin(pkgJson)) {\n      if (!this.hasPlugin(pkgJson.appium.pluginName)) {\n        this.addExtension(PLUGIN_TYPE, pkgJson.appium.pluginName, {\n          ..._.omit(pkgJson.appium, 'pluginName'),\n          ...internal,\n        });\n        return true;\n      }\n      return false;\n    } else {\n      throw new TypeError(\n        `The extension in ${extensionPath} is neither a valid driver nor a valid plugin.`\n      );\n    }\n  }\n\n  /**\n   * Adds an extension to the manifest as was installed by the `appium` CLI.  The\n   * `extData`, `extType`, and `extName` have already been determined.\n   *\n   * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType - `driver` or `plugin`\n   * @param {string} extName - Name of extension\n   * @param {ExtManifest<ExtType>} extData - Extension metadata\n   * @returns {ExtManifest<ExtType>} A clone of `extData`, potentially with a mutated `appiumVersion` field\n   */\n  addExtension(extType, extName, extData) {\n    const data = _.clone(extData);\n    this._data[`${extType}s`][extName] = data;\n    return data;\n  }\n\n  /**\n   * Returns the APPIUM_HOME path\n   */\n  get appiumHome() {\n    return this._appiumHome;\n  }\n\n  /**\n   * Returns the path to the manifest file\n   */\n  get manifestPath() {\n    return this._manifestPath;\n  }\n\n  /**\n   * Returns extension data for a particular type.\n   *\n   * @template {ExtensionType} ExtType\n   * @param {ExtType} extType\n   * @returns {ExtRecord<ExtType>}\n   */\n  getExtensionData(extType) {\n    return this._data[/** @type {string} */ (`${extType}s`)];\n  }\n\n  /**\n   * Reads manifest from disk and _overwrites_ the internal data.\n   *\n   * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA \"empty\"} manifest file will be created.\n   *\n   * If `APPIUM_HOME` contains a `package.json` with an `appium` dependency, then a hash of the `package.json` will be taken. If this hash differs from the last hash, the contents of `APPIUM_HOME/node_modules` will be scanned for extensions that may have been installed outside of the `appium` CLI.  Any found extensions will be added to the manifest file, and if so, the manifest file will be written to disk.\n   *\n   * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.\n   * @returns {Promise<ManifestData>} The data\n   */\n  async read() {\n    if (this._reading) {\n      await this._reading;\n      return this._data;\n    }\n\n    this._reading = (async () => {\n      /** @type {ManifestData} */\n      let data;\n      let isNewFile = false;\n      await this._setManifestPath();\n      try {\n        log.debug(`Reading ${this._manifestPath}...`);\n        const yaml = await fs.readFile(this._manifestPath, 'utf8');\n        data = YAML.parse(yaml);\n        log.debug(`Parsed manifest file: ${JSON.stringify(data, null, 2)}`);\n      } catch (err) {\n        if (err.code === 'ENOENT') {\n          data = _.cloneDeep(INITIAL_MANIFEST_DATA);\n          isNewFile = true;\n        } else {\n          if (this._manifestPath) {\n            throw new Error(\n              `Appium had trouble loading the extension installation ` +\n                `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`\n            );\n          } else {\n            throw new Error(\n              `Appium encountered an unknown problem. Specific error: ${err.message}`\n            );\n          }\n        }\n      }\n\n      this._data = data;\n      let installedExtensionsChanged = false;\n      if (\n        (await env.hasAppiumDependency(this.appiumHome)) &&\n        (await packageDidChange(this.appiumHome))\n      ) {\n        installedExtensionsChanged = await this.syncWithInstalledExtensions();\n      }\n\n      if (isNewFile || installedExtensionsChanged) {\n        await this.write();\n      }\n    })();\n    try {\n      await this._reading;\n      return this._data;\n    } finally {\n      this._reading = undefined;\n    }\n  }\n\n  /**\n   * Ensures {@link Manifest._manifestPath} is set.\n   *\n   * Creates the directory if necessary.\n   * @private\n   * @returns {Promise<string>}\n   */\n  async _setManifestPath() {\n    if (!this._manifestPath) {\n      this._manifestPath = await env.resolveManifestPath(this._appiumHome);\n\n      /* istanbul ignore if */\n      if (path.relative(this._appiumHome, this._manifestPath).startsWith('.')) {\n        throw new Error(\n          `Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`\n        );\n      }\n    }\n\n    return this._manifestPath;\n  }\n\n  /**\n   * Writes the data if it need s writing.\n   *\n   * If the `schemaRev` prop needs updating, the file will be written.\n   *\n   * @todo If this becomes too much of a bottleneck, throttle it.\n   * @returns {Promise<boolean>} Whether the data was written\n   */\n  async write() {\n    if (this._writing) {\n      return this._writing;\n    }\n    this._writing = (async () => {\n      await this._setManifestPath();\n      try {\n        await fs.mkdirp(path.dirname(this._manifestPath));\n      } catch (err) {\n        throw new Error(\n          `Appium could not create the directory for the manifest file: ${path.dirname(\n            this._manifestPath\n          )}. Original error: ${err.message}`\n        );\n      }\n      try {\n        await fs.writeFile(this._manifestPath, YAML.stringify(this._data), 'utf8');\n        return true;\n      } catch (err) {\n        throw new Error(\n          `Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` +\n            `Please ensure it is writable. Original error: ${err.message}`\n        );\n      }\n    })();\n    try {\n      return await this._writing;\n    } finally {\n      this._writing = undefined;\n    }\n  }\n}\n\n/**\n * Type of the string referring to a driver (typically as a key or type string)\n * @typedef {import('@appium/types').DriverType} DriverType\n */\n\n/**\n * Type of the string referring to a plugin (typically as a key or type string)\n * @typedef {import('@appium/types').PluginType} PluginType\n */\n\n/**\n * @typedef SyncWithInstalledExtensionsOpts\n * @property {number} [depthLimit] - Maximum depth to recurse into subdirectories\n */\n\n/**\n * @typedef {import('appium/types').ManifestData} ManifestData\n * @typedef {import('appium/types').InternalMetadata} InternalMetadata\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtPackageJson<T>} ExtPackageJson\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('appium/types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Either `driver` or `plugin` rn\n * @typedef {import('@appium/types').ExtensionType} ExtensionType\n */\n"],"mappings":"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"}

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

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -19,6 +17,8 @@ var _constants = require("../constants");
 
 var _logger = _interopRequireDefault(require("../logger"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 async function packageDidChange(appiumHome) {
   const hashFilename = _path.default.join(appiumHome, _constants.PKG_HASHFILE_RELATIVE_PATH);
 
@@ -63,4 +63,4 @@ async function packageDidChange(appiumHome) {
 
   return isChanged;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJwYWNrYWdlRGlkQ2hhbmdlIiwiYXBwaXVtSG9tZSIsImhhc2hGaWxlbmFtZSIsInBhdGgiLCJqb2luIiwiUEtHX0hBU0hGSUxFX1JFTEFUSVZFX1BBVEgiLCJpc0NoYW5nZWQiLCJ3cml0ZUhhc2giLCJoYXNoIiwib2xkSGFzaCIsImhhc2hGaWxlbmFtZURpciIsImRpcm5hbWUiLCJsb2ciLCJkZWJ1ZyIsImZzIiwibWtkaXJwIiwiZXJyIiwiRXJyb3IiLCJtZXNzYWdlIiwiaXNQYWNrYWdlQ2hhbmdlZCIsImN3ZCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9leHRlbnNpb24vcGFja2FnZS1jaGFuZ2VkLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZnN9IGZyb20gJ0BhcHBpdW0vc3VwcG9ydCc7XG5pbXBvcnQge2lzUGFja2FnZUNoYW5nZWR9IGZyb20gJ3BhY2thZ2UtY2hhbmdlZCc7XG5pbXBvcnQgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCB7UEtHX0hBU0hGSUxFX1JFTEFUSVZFX1BBVEh9IGZyb20gJy4uL2NvbnN0YW50cyc7XG5pbXBvcnQgbG9nIGZyb20gJy4uL2xvZ2dlcic7XG5cbi8qKlxuICogRGV0ZXJtaW5lcyBpZiBleHRlbnNpb25zIGhhdmUgY2hhbmdlZCwgYW5kIHVwZGF0ZXMgYSBoYXNoIHRoZSBgcGFja2FnZS5qc29uYCBpbiBgYXBwaXVtSG9tZWAgaWYgc28uXG4gKlxuICogSWYgdGhleSBoYXZlLCB3ZSBuZWVkIHRvIHN5bmMgdGhlbSB3aXRoIHRoZSBgZXh0ZW5zaW9ucy55YW1sYCBtYW5pZmVzdC5cbiAqXG4gKiBfV2FybmluZzogdGhpcyBtYWtlcyBhIGJsb2NraW5nIGNhbGwgdG8gYHdyaXRlRmlsZVN5bmNgLl9cbiAqIEBwYXJhbSB7c3RyaW5nfSBhcHBpdW1Ib21lXG4gKiBAcmV0dXJucyB7UHJvbWlzZTxib29sZWFuPn0gYHRydWVgIGlmIGBwYWNrYWdlLmpzb25gIGBhcHBpdW1Ib21lYCBjaGFuZ2VkXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBwYWNrYWdlRGlkQ2hhbmdlKGFwcGl1bUhvbWUpIHtcbiAgY29uc3QgaGFzaEZpbGVuYW1lID0gcGF0aC5qb2luKGFwcGl1bUhvbWUsIFBLR19IQVNIRklMRV9SRUxBVElWRV9QQVRIKTtcblxuICAvLyBYWFg6IHRoZSB0eXBlcyBpbiBgcGFja2FnZS1jaGFuZ2VkYCBzZWVtIHRvIGJlIHdyb25nLlxuXG4gIC8qKiBAdHlwZSB7Ym9vbGVhbn0gKi9cbiAgbGV0IGlzQ2hhbmdlZDtcbiAgLyoqIEB0eXBlIHsoKSA9PiB2b2lkfSAqL1xuICBsZXQgd3JpdGVIYXNoO1xuICAvKiogQHR5cGUge3N0cmluZ30gKi9cbiAgbGV0IGhhc2g7XG4gIC8qKiBAdHlwZSB7c3RyaW5nfHVuZGVmaW5lZH0gKi9cbiAgbGV0IG9sZEhhc2g7XG5cbiAgLy8gZmlyc3QgbWtkaXJwIHRoZSB0YXJnZXQgZGlyLlxuICBjb25zdCBoYXNoRmlsZW5hbWVEaXIgPSBwYXRoLmRpcm5hbWUoaGFzaEZpbGVuYW1lKTtcbiAgbG9nLmRlYnVnKGBDcmVhdGluZyBoYXNoIGZpbGUgZGlyZWN0b3J5OiAke2hhc2hGaWxlbmFtZURpcn1gKTtcbiAgdHJ5IHtcbiAgICBhd2FpdCBmcy5ta2RpcnAoaGFzaEZpbGVuYW1lRGlyKTtcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgYEFwcGl1bSBjb3VsZCBub3QgY3JlYXRlIHRoZSBkaXJlY3RvcnkgZm9yIGhhc2ggZmlsZTogJHtoYXNoRmlsZW5hbWVEaXJ9LiBPcmlnaW5hbCBlcnJvcjogJHtlcnIubWVzc2FnZX1gXG4gICAgKTtcbiAgfVxuXG4gIHRyeSB7XG4gICAgKHtpc0NoYW5nZWQsIHdyaXRlSGFzaCwgb2xkSGFzaCwgaGFzaH0gPSBhd2FpdCBpc1BhY2thZ2VDaGFuZ2VkKHtcbiAgICAgIGN3ZDogYXBwaXVtSG9tZSxcbiAgICAgIGhhc2hGaWxlbmFtZTogUEtHX0hBU0hGSUxFX1JFTEFUSVZFX1BBVEgsXG4gICAgfSkpO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxuXG4gIGlmIChpc0NoYW5nZWQpIHtcbiAgICB0cnkge1xuICAgICAgd3JpdGVIYXNoKCk7XG4gICAgICBsb2cuZGVidWcoXG4gICAgICAgIGBVcGRhdGVkIGhhc2ggb2YgJHthcHBpdW1Ib21lfS9wYWNrYWdlLmpzb24gZnJvbTogJHtvbGRIYXNoID8/ICcobm9uZSknfSB0bzogJHtoYXNofWBcbiAgICAgICk7XG4gICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAgIGBBcHBpdW0gY291bGQgbm90IHdyaXRlIGhhc2ggZmlsZTogJHtoYXNoRmlsZW5hbWVEaXJ9LiBPcmlnaW5hbCBlcnJvcjogJHtlcnIubWVzc2FnZX1gXG4gICAgICApO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBpc0NoYW5nZWQ7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOzs7O0FBV08sZUFBZUEsZ0JBQWYsQ0FBZ0NDLFVBQWhDLEVBQTRDO0VBQ2pELE1BQU1DLFlBQVksR0FBR0MsYUFBQSxDQUFLQyxJQUFMLENBQVVILFVBQVYsRUFBc0JJLHFDQUF0QixDQUFyQjs7RUFLQSxJQUFJQyxTQUFKO0VBRUEsSUFBSUMsU0FBSjtFQUVBLElBQUlDLElBQUo7RUFFQSxJQUFJQyxPQUFKOztFQUdBLE1BQU1DLGVBQWUsR0FBR1AsYUFBQSxDQUFLUSxPQUFMLENBQWFULFlBQWIsQ0FBeEI7O0VBQ0FVLGVBQUEsQ0FBSUMsS0FBSixDQUFXLGlDQUFnQ0gsZUFBZ0IsRUFBM0Q7O0VBQ0EsSUFBSTtJQUNGLE1BQU1JLFdBQUEsQ0FBR0MsTUFBSCxDQUFVTCxlQUFWLENBQU47RUFDRCxDQUZELENBRUUsT0FBT00sR0FBUCxFQUFZO0lBQ1osTUFBTSxJQUFJQyxLQUFKLENBQ0gsd0RBQXVEUCxlQUFnQixxQkFBb0JNLEdBQUcsQ0FBQ0UsT0FBUSxFQURwRyxDQUFOO0VBR0Q7O0VBRUQsSUFBSTtJQUNGLENBQUM7TUFBQ1osU0FBRDtNQUFZQyxTQUFaO01BQXVCRSxPQUF2QjtNQUFnQ0Q7SUFBaEMsSUFBd0MsTUFBTSxJQUFBVyxnQ0FBQSxFQUFpQjtNQUM5REMsR0FBRyxFQUFFbkIsVUFEeUQ7TUFFOURDLFlBQVksRUFBRUc7SUFGZ0QsQ0FBakIsQ0FBL0M7RUFJRCxDQUxELENBS0UsTUFBTTtJQUNOLE9BQU8sSUFBUDtFQUNEOztFQUVELElBQUlDLFNBQUosRUFBZTtJQUNiLElBQUk7TUFDRkMsU0FBUzs7TUFDVEssZUFBQSxDQUFJQyxLQUFKLENBQ0csbUJBQWtCWixVQUFXLHVCQUFzQlEsT0FBTyxJQUFJLFFBQVMsUUFBT0QsSUFBSyxFQUR0RjtJQUdELENBTEQsQ0FLRSxPQUFPUSxHQUFQLEVBQVk7TUFDWixNQUFNLElBQUlDLEtBQUosQ0FDSCxxQ0FBb0NQLGVBQWdCLHFCQUFvQk0sR0FBRyxDQUFDRSxPQUFRLEVBRGpGLENBQU47SUFHRDtFQUNGOztFQUVELE9BQU9aLFNBQVA7QUFDRCJ9

package/build/lib/extension/package-changed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-changed.js","names":["packageDidChange","appiumHome","hashFilename","path","join","PKG_HASHFILE_RELATIVE_PATH","isChanged","writeHash","hash","oldHash","hashFilenameDir","dirname","log","debug","fs","mkdirp","err","Error","message","isPackageChanged","cwd"],"sources":["../../../lib/extension/package-changed.js"],"sourcesContent":["import {fs} from '@appium/support';\nimport {isPackageChanged} from 'package-changed';\nimport path from 'path';\nimport {PKG_HASHFILE_RELATIVE_PATH} from '../constants';\nimport log from '../logger';\n\n/**\n * Determines if extensions have changed, and updates a hash the `package.json` in `appiumHome` if so.\n *\n * If they have, we need to sync them with the `extensions.yaml` manifest.\n *\n * _Warning: this makes a blocking call to `writeFileSync`._\n * @param {string} appiumHome\n * @returns {Promise<boolean>} `true` if `package.json` `appiumHome` changed\n */\nexport async function packageDidChange(appiumHome) {\n  const hashFilename = path.join(appiumHome, PKG_HASHFILE_RELATIVE_PATH);\n\n  // XXX: the types in `package-changed` seem to be wrong.\n\n  /** @type {boolean} */\n  let isChanged;\n  /** @type {() => void} */\n  let writeHash;\n  /** @type {string} */\n  let hash;\n  /** @type {string|undefined} */\n  let oldHash;\n\n  // first mkdirp the target dir.\n  const hashFilenameDir = path.dirname(hashFilename);\n  log.debug(`Creating hash file directory: ${hashFilenameDir}`);\n  try {\n    await fs.mkdirp(hashFilenameDir);\n  } catch (err) {\n    throw new Error(\n      `Appium could not create the directory for hash file: ${hashFilenameDir}. Original error: ${err.message}`\n    );\n  }\n\n  try {\n    ({isChanged, writeHash, oldHash, hash} = await isPackageChanged({\n      cwd: appiumHome,\n      hashFilename: PKG_HASHFILE_RELATIVE_PATH,\n    }));\n  } catch {\n    return true;\n  }\n\n  if (isChanged) {\n    try {\n      writeHash();\n      log.debug(\n        `Updated hash of ${appiumHome}/package.json from: ${oldHash ?? '(none)'} to: ${hash}`\n      );\n    } catch (err) {\n      throw new Error(\n        `Appium could not write hash file: ${hashFilenameDir}. Original error: ${err.message}`\n      );\n    }\n  }\n\n  return isChanged;\n}\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;AAWO,eAAeA,gBAAf,CAAgCC,UAAhC,EAA4C;EACjD,MAAMC,YAAY,GAAGC,aAAA,CAAKC,IAAL,CAAUH,UAAV,EAAsBI,qCAAtB,CAArB;;EAKA,IAAIC,SAAJ;EAEA,IAAIC,SAAJ;EAEA,IAAIC,IAAJ;EAEA,IAAIC,OAAJ;;EAGA,MAAMC,eAAe,GAAGP,aAAA,CAAKQ,OAAL,CAAaT,YAAb,CAAxB;;EACAU,eAAA,CAAIC,KAAJ,CAAW,iCAAgCH,eAAgB,EAA3D;;EACA,IAAI;IACF,MAAMI,WAAA,CAAGC,MAAH,CAAUL,eAAV,CAAN;EACD,CAFD,CAEE,OAAOM,GAAP,EAAY;IACZ,MAAM,IAAIC,KAAJ,CACH,wDAAuDP,eAAgB,qBAAoBM,GAAG,CAACE,OAAQ,EADpG,CAAN;EAGD;;EAED,IAAI;IACF,CAAC;MAACZ,SAAD;MAAYC,SAAZ;MAAuBE,OAAvB;MAAgCD;IAAhC,IAAwC,MAAM,IAAAW,gCAAA,EAAiB;MAC9DC,GAAG,EAAEnB,UADyD;MAE9DC,YAAY,EAAEG;IAFgD,CAAjB,CAA/C;EAID,CALD,CAKE,MAAM;IACN,OAAO,IAAP;EACD;;EAED,IAAIC,SAAJ,EAAe;IACb,IAAI;MACFC,SAAS;;MACTK,eAAA,CAAIC,KAAJ,CACG,mBAAkBZ,UAAW,uBAAsBQ,OAAO,IAAI,QAAS,QAAOD,IAAK,EADtF;IAGD,CALD,CAKE,OAAOQ,GAAP,EAAY;MACZ,MAAM,IAAIC,KAAJ,CACH,qCAAoCP,eAAgB,qBAAoBM,GAAG,CAACE,OAAQ,EADjF,CAAN;IAGD;EACF;;EAED,OAAOZ,SAAP;AACD"}

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

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -17,6 +15,8 @@ var _logger = _interopRequireDefault(require("../logger"));
 
 var _constants = require("../constants");
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 class PluginConfig extends _extensionConfig.ExtensionConfig {
   static _instances = new WeakMap();
 
@@ -75,4 +75,4 @@ class PluginConfig extends _extensionConfig.ExtensionConfig {
 }
 
 exports.PluginConfig = PluginConfig;
-//# 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/plugin-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-config.js","names":["PluginConfig","ExtensionConfig","_instances","WeakMap","constructor","manifest","PLUGIN_TYPE","validate","_validate","getExtensionData","create","instance","getInstance","Error","appiumHome","set","get","extensionDesc","pluginName","version","print","activeNames","pluginNames","Object","keys","installedExtensions","_","isEmpty","log","info","pluginData","toPairs","activeTxt","includes"],"sources":["../../../lib/extension/plugin-config.js"],"sourcesContent":["import _ from 'lodash';\nimport {ExtensionConfig} from './extension-config';\nimport log from '../logger';\nimport {PLUGIN_TYPE} from '../constants';\n\n/**\n * @extends {ExtensionConfig<PluginType>}\n */\nexport class PluginConfig extends ExtensionConfig {\n  /**\n   * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.\n   *\n   * `Manifest` and {@link 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-`PluginConfig` portion.\n   *\n   * @type {WeakMap<Manifest,PluginConfig>}\n   * @private\n   */\n  static _instances = new WeakMap();\n\n  /**\n   * Call {@link PluginConfig.create} instead.\n   *\n   * Just calls the superclass' constructor with the correct extension type\n   * @private\n   * @param {Manifest} manifest - IO object\n   */\n  constructor(manifest) {\n    super(PLUGIN_TYPE, manifest);\n  }\n\n  async validate() {\n    return await super._validate(this.manifest.getExtensionData(PLUGIN_TYPE));\n  }\n\n  /**\n   * Creates a new {@link PluginConfig} instance for a {@link Manifest} instance.\n   *\n   * @param {Manifest} manifest\n   * @throws If `manifest` already associated with a `PluginConfig`\n   * @returns {PluginConfig}\n   */\n  static create(manifest) {\n    const instance = new PluginConfig(manifest);\n    if (PluginConfig.getInstance(manifest)) {\n      throw new Error(\n        `Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`\n      );\n    }\n    PluginConfig._instances.set(manifest, instance);\n    return instance;\n  }\n\n  /**\n   * Returns a PluginConfig associated with a Manifest\n   * @param {Manifest} manifest\n   * @returns {PluginConfig|undefined}\n   */\n  static getInstance(manifest) {\n    return PluginConfig._instances.get(manifest);\n  }\n\n  /**\n   * @param {string} pluginName\n   * @param {import('appium/types').ExtManifest<PluginType>} pluginData\n   * @returns {string}\n   */\n  extensionDesc(pluginName, {version}) {\n    return `${pluginName}@${version}`;\n  }\n\n  /**\n   *\n   * @param {(keyof PluginRecord)[]} activeNames\n   * @returns {void}\n   */\n  print(activeNames) {\n    const pluginNames = Object.keys(this.installedExtensions);\n\n    if (_.isEmpty(pluginNames)) {\n      log.info(\n        `No plugins have been installed. Use the \"appium plugin\" ` +\n          'command to install the one(s) you want to use.'\n      );\n      return;\n    }\n\n    log.info(`Available plugins:`);\n    for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {\n      const activeTxt = _.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';\n      log.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);\n    }\n\n    if (_.isEmpty(activeNames)) {\n      log.info(\n        'No plugins activated. Use the --use-plugins flag with names of plugins to activate'\n      );\n    }\n  }\n}\n\n/**\n * @typedef PluginConfigOptions\n * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function\n */\n\n/**\n * @typedef {import('appium/types').PluginRecord} PluginRecord\n * @typedef {import('@appium/types').PluginType} PluginType\n * @typedef {import('appium/types').ExtMetadata<PluginType>} PluginMetadata\n * @typedef {import('./manifest').Manifest} Manifest\n */\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;;;AAKO,MAAMA,YAAN,SAA2BC,gCAA3B,CAA2C;EAW/B,OAAVC,UAAU,GAAG,IAAIC,OAAJ,EAAH;;EASjBC,WAAW,CAACC,QAAD,EAAW;IACpB,MAAMC,sBAAN,EAAmBD,QAAnB;EACD;;EAEa,MAARE,QAAQ,GAAG;IACf,OAAO,MAAM,MAAMC,SAAN,CAAgB,KAAKH,QAAL,CAAcI,gBAAd,CAA+BH,sBAA/B,CAAhB,CAAb;EACD;;EASY,OAANI,MAAM,CAACL,QAAD,EAAW;IACtB,MAAMM,QAAQ,GAAG,IAAIX,YAAJ,CAAiBK,QAAjB,CAAjB;;IACA,IAAIL,YAAY,CAACY,WAAb,CAAyBP,QAAzB,CAAJ,EAAwC;MACtC,MAAM,IAAIQ,KAAJ,CACH,6BAA4BR,QAAQ,CAACS,UAAW,6EAD7C,CAAN;IAGD;;IACDd,YAAY,CAACE,UAAb,CAAwBa,GAAxB,CAA4BV,QAA5B,EAAsCM,QAAtC;;IACA,OAAOA,QAAP;EACD;;EAOiB,OAAXC,WAAW,CAACP,QAAD,EAAW;IAC3B,OAAOL,YAAY,CAACE,UAAb,CAAwBc,GAAxB,CAA4BX,QAA5B,CAAP;EACD;;EAODY,aAAa,CAACC,UAAD,EAAa;IAACC;EAAD,CAAb,EAAwB;IACnC,OAAQ,GAAED,UAAW,IAAGC,OAAQ,EAAhC;EACD;;EAODC,KAAK,CAACC,WAAD,EAAc;IACjB,MAAMC,WAAW,GAAGC,MAAM,CAACC,IAAP,CAAY,KAAKC,mBAAjB,CAApB;;IAEA,IAAIC,eAAA,CAAEC,OAAF,CAAUL,WAAV,CAAJ,EAA4B;MAC1BM,eAAA,CAAIC,IAAJ,CACG,0DAAD,GACE,gDAFJ;;MAIA;IACD;;IAEDD,eAAA,CAAIC,IAAJ,CAAU,oBAAV;;IACA,KAAK,MAAM,CAACX,UAAD,EAAaY,UAAb,CAAX,IAAuCJ,eAAA,CAAEK,OAAF,CAAU,KAAKN,mBAAf,CAAvC,EAA4E;MAC1E,MAAMO,SAAS,GAAGN,eAAA,CAAEO,QAAF,CAAWZ,WAAX,EAAwBH,UAAxB,IAAsC,WAAtC,GAAoD,EAAtE;;MACAU,eAAA,CAAIC,IAAJ,CAAU,OAAM,KAAKZ,aAAL,CAAmBC,UAAnB,EAA+BY,UAA/B,CAA2C,GAAEE,SAAU,EAAvE;IACD;;IAED,IAAIN,eAAA,CAAEC,OAAF,CAAUN,WAAV,CAAJ,EAA4B;MAC1BO,eAAA,CAAIC,IAAJ,CACE,oFADF;IAGD;EACF;;AA3F+C"}

package/build/lib/grid-register.js

@@ -1,7 +1,5 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -17,6 +15,8 @@ var _logger = _interopRequireDefault(require("./logger"));
 
 var _lodash = _interopRequireDefault(require("lodash"));
 
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 const hubUri = config => {
   const protocol = config.hubProtocol || 'http';
   return `${protocol}://${config.hubHost}:${config.hubPort}`;
@@ -150,4 +150,4 @@ async function isAlreadyRegistered(configHolder) {
 
 var _default = registerNode;
 exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["hubUri","config","protocol","hubProtocol","hubHost","hubPort","registerNode","data","addr","port","basePath","configFilePath","_","isString","fs","readFile","err","logger","error","message","JSON","parse","errorAndThrow","postRequest","registerToGrid","postOptions","configHolder","status","axios","Error","debug","configuration","has","property","url","host","id","regRequest","method","register","registerCycleInterval","registerCycle","isNaN","warn","first","setInterval","registerRetry","isAlreadyRegistered","timeout","success","msg"],"sources":["../../lib/grid-register.js"],"sourcesContent":["import axios from 'axios';\nimport {fs} from '@appium/support';\nimport logger from './logger';\nimport _ from 'lodash';\n\nconst hubUri = (config) => {\n  const protocol = config.hubProtocol || 'http';\n  return `${protocol}://${config.hubHost}:${config.hubPort}`;\n};\n\n/**\n * Registers a new node with a selenium grid\n * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!\n * @param {string} [addr] - Bind to this address\n * @param {number} [port] - Bind to this port\n * @param {string} [basePath] - Base path for the grid\n */\nasync function registerNode(data, addr, port, basePath) {\n  let configFilePath;\n  if (_.isString(data)) {\n    configFilePath = data;\n    try {\n      data = await fs.readFile(data, 'utf-8');\n    } catch (err) {\n      logger.error(\n        `Unable to load node configuration file ${configFilePath} to register with grid: ${err.message}`\n      );\n      return;\n    }\n    try {\n      data = JSON.parse(data);\n    } catch (err) {\n      logger.errorAndThrow(\n        `Syntax error in node configuration file ${configFilePath}: ${err.message}`\n      );\n      return;\n    }\n  }\n\n  postRequest(data, addr, port, basePath);\n}\n\nasync function registerToGrid(postOptions, configHolder) {\n  try {\n    const {status} = await axios(postOptions);\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    logger.debug(\n      `Appium successfully registered with the the grid on ` + hubUri(configHolder.configuration)\n    );\n  } catch (err) {\n    logger.error(`An attempt to register with the grid was unsuccessful: ${err.message}`);\n  }\n}\n\nfunction postRequest(configHolder, addr, port, basePath) {\n  // Move Selenium 3 configuration properties to configuration object\n  if (!_.has(configHolder, 'configuration')) {\n    let configuration = {};\n    for (const property in configHolder) {\n      if (_.has(configHolder, property) && property !== 'capabilities') {\n        configuration[property] = configHolder[property];\n        delete configHolder[property];\n      }\n    }\n    configHolder.configuration = configuration;\n  }\n\n  // if the node config does not have the appium/webdriver url, host, and port,\n  // automatically add it based on how appium was initialized\n  // otherwise, we will take whatever the user setup\n  // because we will always set localhost/127.0.0.1. this won't work if your\n  // node and grid aren't in the same place\n  if (\n    !configHolder.configuration.url ||\n    !configHolder.configuration.host ||\n    !configHolder.configuration.port\n  ) {\n    configHolder.configuration.url = `http://${addr}:${port}${basePath}`;\n    configHolder.configuration.host = addr;\n    configHolder.configuration.port = port;\n  }\n  // if the node config does not have id automatically add it\n  if (!configHolder.configuration.id) {\n    configHolder.configuration.id = `http://${configHolder.configuration.host}:${configHolder.configuration.port}`;\n  }\n\n  // the post options\n  const regRequest = {\n    url: `${hubUri(configHolder.configuration)}/grid/register`,\n    method: 'POST',\n    data: configHolder,\n  };\n\n  if (configHolder.configuration.register !== true) {\n    logger.debug(`No registration sent (${configHolder.configuration.register} = false)`);\n    return;\n  }\n\n  const registerCycleInterval = configHolder.configuration.registerCycle;\n  if (isNaN(registerCycleInterval) || registerCycleInterval <= 0) {\n    logger.warn(\n      `'registerCycle' is not a valid positive number. ` +\n        `No registration request will be sent to the grid.`\n    );\n    return;\n  }\n  // initiate a new Thread\n  let first = true;\n  logger.debug(\n    `Starting auto register thread for the grid. ` +\n      `Will try to register every ${registerCycleInterval} ms.`\n  );\n  setInterval(async function registerRetry() {\n    if (first) {\n      first = false;\n      await registerToGrid(regRequest, configHolder);\n    } else if (!(await isAlreadyRegistered(configHolder))) {\n      // make the http POST to the grid for registration\n      await registerToGrid(regRequest, configHolder);\n    }\n  }, registerCycleInterval);\n}\n\nasync function isAlreadyRegistered(configHolder) {\n  //check if node is already registered\n  const id = configHolder.configuration.id;\n  try {\n    const {data, status} = await axios({\n      url: `${hubUri(configHolder.configuration)}/grid/api/proxy?id=${id}`,\n      timeout: 10000,\n    });\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    if (!data.success) {\n      // if register fail, print the debug msg\n      logger.debug(`Grid registration error: ${data.msg}`);\n    }\n    return data.success;\n  } catch (err) {\n    logger.debug(`Hub down or not responding: ${err.message}`);\n  }\n}\n\nexport default registerNode;\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["hubUri","config","protocol","hubProtocol","hubHost","hubPort","registerNode","data","addr","port","basePath","configFilePath","_","isString","fs","readFile","err","logger","error","message","JSON","parse","errorAndThrow","postRequest","registerToGrid","postOptions","configHolder","status","axios","Error","debug","configuration","has","property","url","host","id","regRequest","method","register","registerCycleInterval","registerCycle","isNaN","warn","first","setInterval","registerRetry","isAlreadyRegistered","timeout","success","msg"],"sources":["../../lib/grid-register.js"],"sourcesContent":["import axios from 'axios';\nimport {fs} from '@appium/support';\nimport logger from './logger';\nimport _ from 'lodash';\n\nconst hubUri = (config) => {\n  const protocol = config.hubProtocol || 'http';\n  return `${protocol}://${config.hubHost}:${config.hubPort}`;\n};\n\n/**\n * Registers a new node with a selenium grid\n * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!\n * @param {string} [addr] - Bind to this address\n * @param {number} [port] - Bind to this port\n * @param {string} [basePath] - Base path for the grid\n */\nasync function registerNode(data, addr, port, basePath) {\n  let configFilePath;\n  if (_.isString(data)) {\n    configFilePath = data;\n    try {\n      data = await fs.readFile(data, 'utf-8');\n    } catch (err) {\n      logger.error(\n        `Unable to load node configuration file ${configFilePath} to register with grid: ${err.message}`\n      );\n      return;\n    }\n    try {\n      data = JSON.parse(data);\n    } catch (err) {\n      logger.errorAndThrow(\n        `Syntax error in node configuration file ${configFilePath}: ${err.message}`\n      );\n      return;\n    }\n  }\n\n  postRequest(data, addr, port, basePath);\n}\n\nasync function registerToGrid(postOptions, configHolder) {\n  try {\n    const {status} = await axios(postOptions);\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    logger.debug(\n      `Appium successfully registered with the the grid on ` + hubUri(configHolder.configuration)\n    );\n  } catch (err) {\n    logger.error(`An attempt to register with the grid was unsuccessful: ${err.message}`);\n  }\n}\n\nfunction postRequest(configHolder, addr, port, basePath) {\n  // Move Selenium 3 configuration properties to configuration object\n  if (!_.has(configHolder, 'configuration')) {\n    let configuration = {};\n    for (const property in configHolder) {\n      if (_.has(configHolder, property) && property !== 'capabilities') {\n        configuration[property] = configHolder[property];\n        delete configHolder[property];\n      }\n    }\n    configHolder.configuration = configuration;\n  }\n\n  // if the node config does not have the appium/webdriver url, host, and port,\n  // automatically add it based on how appium was initialized\n  // otherwise, we will take whatever the user setup\n  // because we will always set localhost/127.0.0.1. this won't work if your\n  // node and grid aren't in the same place\n  if (\n    !configHolder.configuration.url ||\n    !configHolder.configuration.host ||\n    !configHolder.configuration.port\n  ) {\n    configHolder.configuration.url = `http://${addr}:${port}${basePath}`;\n    configHolder.configuration.host = addr;\n    configHolder.configuration.port = port;\n  }\n  // if the node config does not have id automatically add it\n  if (!configHolder.configuration.id) {\n    configHolder.configuration.id = `http://${configHolder.configuration.host}:${configHolder.configuration.port}`;\n  }\n\n  // the post options\n  const regRequest = {\n    url: `${hubUri(configHolder.configuration)}/grid/register`,\n    method: 'POST',\n    data: configHolder,\n  };\n\n  if (configHolder.configuration.register !== true) {\n    logger.debug(`No registration sent (${configHolder.configuration.register} = false)`);\n    return;\n  }\n\n  const registerCycleInterval = configHolder.configuration.registerCycle;\n  if (isNaN(registerCycleInterval) || registerCycleInterval <= 0) {\n    logger.warn(\n      `'registerCycle' is not a valid positive number. ` +\n        `No registration request will be sent to the grid.`\n    );\n    return;\n  }\n  // initiate a new Thread\n  let first = true;\n  logger.debug(\n    `Starting auto register thread for the grid. ` +\n      `Will try to register every ${registerCycleInterval} ms.`\n  );\n  setInterval(async function registerRetry() {\n    if (first) {\n      first = false;\n      await registerToGrid(regRequest, configHolder);\n    } else if (!(await isAlreadyRegistered(configHolder))) {\n      // make the http POST to the grid for registration\n      await registerToGrid(regRequest, configHolder);\n    }\n  }, registerCycleInterval);\n}\n\nasync function isAlreadyRegistered(configHolder) {\n  //check if node is already registered\n  const id = configHolder.configuration.id;\n  try {\n    const {data, status} = await axios({\n      url: `${hubUri(configHolder.configuration)}/grid/api/proxy?id=${id}`,\n      timeout: 10000,\n    });\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    if (!data.success) {\n      // if register fail, print the debug msg\n      logger.debug(`Grid registration error: ${data.msg}`);\n    }\n    return data.success;\n  } catch (err) {\n    logger.debug(`Hub down or not responding: ${err.message}`);\n  }\n}\n\nexport default registerNode;\n"],"mappings":"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"}

package/build/lib/grid-register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-register.js","names":["hubUri","config","protocol","hubProtocol","hubHost","hubPort","registerNode","data","addr","port","basePath","configFilePath","_","isString","fs","readFile","err","logger","error","message","JSON","parse","errorAndThrow","postRequest","registerToGrid","postOptions","configHolder","status","axios","Error","debug","configuration","has","property","url","host","id","regRequest","method","register","registerCycleInterval","registerCycle","isNaN","warn","first","setInterval","registerRetry","isAlreadyRegistered","timeout","success","msg"],"sources":["../../lib/grid-register.js"],"sourcesContent":["import axios from 'axios';\nimport {fs} from '@appium/support';\nimport logger from './logger';\nimport _ from 'lodash';\n\nconst hubUri = (config) => {\n  const protocol = config.hubProtocol || 'http';\n  return `${protocol}://${config.hubHost}:${config.hubPort}`;\n};\n\n/**\n * Registers a new node with a selenium grid\n * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!\n * @param {string} [addr] - Bind to this address\n * @param {number} [port] - Bind to this port\n * @param {string} [basePath] - Base path for the grid\n */\nasync function registerNode(data, addr, port, basePath) {\n  let configFilePath;\n  if (_.isString(data)) {\n    configFilePath = data;\n    try {\n      data = await fs.readFile(data, 'utf-8');\n    } catch (err) {\n      logger.error(\n        `Unable to load node configuration file ${configFilePath} to register with grid: ${err.message}`\n      );\n      return;\n    }\n    try {\n      data = JSON.parse(data);\n    } catch (err) {\n      logger.errorAndThrow(\n        `Syntax error in node configuration file ${configFilePath}: ${err.message}`\n      );\n      return;\n    }\n  }\n\n  postRequest(data, addr, port, basePath);\n}\n\nasync function registerToGrid(postOptions, configHolder) {\n  try {\n    const {status} = await axios(postOptions);\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    logger.debug(\n      `Appium successfully registered with the the grid on ` + hubUri(configHolder.configuration)\n    );\n  } catch (err) {\n    logger.error(`An attempt to register with the grid was unsuccessful: ${err.message}`);\n  }\n}\n\nfunction postRequest(configHolder, addr, port, basePath) {\n  // Move Selenium 3 configuration properties to configuration object\n  if (!_.has(configHolder, 'configuration')) {\n    let configuration = {};\n    for (const property in configHolder) {\n      if (_.has(configHolder, property) && property !== 'capabilities') {\n        configuration[property] = configHolder[property];\n        delete configHolder[property];\n      }\n    }\n    configHolder.configuration = configuration;\n  }\n\n  // if the node config does not have the appium/webdriver url, host, and port,\n  // automatically add it based on how appium was initialized\n  // otherwise, we will take whatever the user setup\n  // because we will always set localhost/127.0.0.1. this won't work if your\n  // node and grid aren't in the same place\n  if (\n    !configHolder.configuration.url ||\n    !configHolder.configuration.host ||\n    !configHolder.configuration.port\n  ) {\n    configHolder.configuration.url = `http://${addr}:${port}${basePath}`;\n    configHolder.configuration.host = addr;\n    configHolder.configuration.port = port;\n  }\n  // if the node config does not have id automatically add it\n  if (!configHolder.configuration.id) {\n    configHolder.configuration.id = `http://${configHolder.configuration.host}:${configHolder.configuration.port}`;\n  }\n\n  // the post options\n  const regRequest = {\n    url: `${hubUri(configHolder.configuration)}/grid/register`,\n    method: 'POST',\n    data: configHolder,\n  };\n\n  if (configHolder.configuration.register !== true) {\n    logger.debug(`No registration sent (${configHolder.configuration.register} = false)`);\n    return;\n  }\n\n  const registerCycleInterval = configHolder.configuration.registerCycle;\n  if (isNaN(registerCycleInterval) || registerCycleInterval <= 0) {\n    logger.warn(\n      `'registerCycle' is not a valid positive number. ` +\n        `No registration request will be sent to the grid.`\n    );\n    return;\n  }\n  // initiate a new Thread\n  let first = true;\n  logger.debug(\n    `Starting auto register thread for the grid. ` +\n      `Will try to register every ${registerCycleInterval} ms.`\n  );\n  setInterval(async function registerRetry() {\n    if (first) {\n      first = false;\n      await registerToGrid(regRequest, configHolder);\n    } else if (!(await isAlreadyRegistered(configHolder))) {\n      // make the http POST to the grid for registration\n      await registerToGrid(regRequest, configHolder);\n    }\n  }, registerCycleInterval);\n}\n\nasync function isAlreadyRegistered(configHolder) {\n  //check if node is already registered\n  const id = configHolder.configuration.id;\n  try {\n    const {data, status} = await axios({\n      url: `${hubUri(configHolder.configuration)}/grid/api/proxy?id=${id}`,\n      timeout: 10000,\n    });\n    if (status !== 200) {\n      throw new Error(`Request failed with code ${status}`);\n    }\n    if (!data.success) {\n      // if register fail, print the debug msg\n      logger.debug(`Grid registration error: ${data.msg}`);\n    }\n    return data.success;\n  } catch (err) {\n    logger.debug(`Hub down or not responding: ${err.message}`);\n  }\n}\n\nexport default registerNode;\n"],"mappings":"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"}

package/build/lib/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":["log","logger","getLogger"],"sources":["../../lib/logger.js"],"sourcesContent":["import {logger} from '@appium/support';\n\nlet log = logger.getLogger('Appium');\n\nexport default log;\n"],"mappings":";;;;;;;;;AAAA;;AAEA,IAAIA,GAAG,GAAGC,eAAA,CAAOC,SAAP,CAAiB,QAAjB,CAAV;;eAEeF,G"}