appium 2.0.0-beta.3 → 2.0.0-beta.34

package/build/lib/extension/manifest.js

@@ -0,0 +1,246 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manifest = void 0;
+
+require("source-map-support/register");
+
+var _support = require("@appium/support");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+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('.')
+});
+const CONFIG_SCHEMA_REV = 2;
+const CONFIG_DATA_DRIVER_KEY = `${_constants.DRIVER_TYPE}s`;
+const CONFIG_DATA_PLUGIN_KEY = `${_constants.PLUGIN_TYPE}s`;
+const INITIAL_MANIFEST_DATA = Object.freeze({
+  [CONFIG_DATA_DRIVER_KEY]: Object.freeze({}),
+  [CONFIG_DATA_PLUGIN_KEY]: Object.freeze({}),
+  schemaRev: CONFIG_SCHEMA_REV
+});
+
+function isExtension(value) {
+  return _lodash.default.isPlainObject(value) && _lodash.default.isPlainObject(value.appium) && _lodash.default.isString(value.name) && _lodash.default.isString(value.version);
+}
+
+function isDriver(value) {
+  return isExtension(value) && _lodash.default.isString(_lodash.default.get(value, 'appium.driverName')) && _lodash.default.isString(_lodash.default.get(value, 'appium.automationName')) && _lodash.default.isArray(_lodash.default.get(value, 'appium.platformNames'));
+}
+
+function isPlugin(value) {
+  return isExtension(value) && _lodash.default.isString(_lodash.default.get(value, 'appium.pluginName'));
+}
+
+class Manifest {
+  _data;
+  _appiumHome;
+  _manifestPath;
+  _writing;
+  _reading;
+
+  constructor(appiumHome) {
+    this._appiumHome = appiumHome;
+    this._data = _lodash.default.cloneDeep(INITIAL_MANIFEST_DATA);
+  }
+
+  static getInstance = _lodash.default.memoize(function _getInstance(appiumHome) {
+    return new Manifest(appiumHome);
+  });
+
+  async syncWithInstalledExtensions({
+    depthLimit = DEFAULT_SEARCH_DEPTH
+  } = {}) {
+    const walkOpts = _lodash.default.defaults({
+      depthLimit
+    }, DEFAULT_FIND_EXTENSIONS_OPTS);
+
+    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 {}
+      }
+    }
+
+    return didChange;
+  }
+
+  hasDriver(name) {
+    return Boolean(this._data.drivers[name]);
+  }
+
+  hasPlugin(name) {
+    return Boolean(this._data.plugins[name]);
+  }
+
+  addExtensionFromPackage(pkgJson, pkgPath) {
+    const internal = {
+      pkgName: pkgJson.name,
+      version: pkgJson.version,
+      installType: _extensionConfig.INSTALL_TYPE_NPM,
+      installSpec: `${pkgJson.name}@${pkgJson.version}`
+    };
+
+    if (isDriver(pkgJson)) {
+      if (!this.hasDriver(pkgJson.appium.driverName)) {
+        this.addExtension(_constants.DRIVER_TYPE, pkgJson.appium.driverName, { ..._lodash.default.omit(pkgJson.appium, 'driverName'),
+          ...internal
+        });
+        return true;
+      }
+
+      return false;
+    } else if (isPlugin(pkgJson)) {
+      if (!this.hasPlugin(pkgJson.appium.pluginName)) {
+        this.addExtension(_constants.PLUGIN_TYPE, pkgJson.appium.pluginName, { ..._lodash.default.omit(pkgJson.appium, 'pluginName'),
+          ...internal
+        });
+        return true;
+      }
+
+      return false;
+    } else {
+      throw new TypeError(`The extension in ${_path.default.dirname(pkgPath)} is neither a valid driver nor a valid plugin.`);
+    }
+  }
+
+  addExtension(extType, extName, extData) {
+    this._data[`${extType}s`][extName] = extData;
+  }
+
+  get appiumHome() {
+    return this._appiumHome;
+  }
+
+  get manifestPath() {
+    return this._manifestPath;
+  }
+
+  getExtensionData(extType) {
+    return this._data[`${extType}s`];
+  }
+
+  async read() {
+    if (this._reading) {
+      await this._reading;
+      return this._data;
+    }
+
+    this._reading = (async () => {
+      let data;
+      let isNewFile = false;
+      await this._setManifestPath();
+
+      try {
+        _logger.default.debug(`Reading ${this._manifestPath}...`);
+
+        const yaml = await _support.fs.readFile(this._manifestPath, 'utf8');
+        data = _yaml.default.parse(yaml);
+      } catch (err) {
+        if (err.code === 'ENOENT') {
+          data = _lodash.default.cloneDeep(INITIAL_MANIFEST_DATA);
+          isNewFile = true;
+        } else {
+          if (this._manifestPath) {
+            throw new Error(`Appium had trouble loading the extension installation ` + `cache file (${this._manifestPath}). It may be invalid YAML. Specific error: ${err.message}`);
+          } else {
+            throw new Error(`Appium encountered an unknown problem. Specific error: ${err.message}`);
+          }
+        }
+      }
+
+      this._data = data;
+      let installedExtensionsChanged = false;
+
+      if ((await _support.env.hasAppiumDependency(this.appiumHome)) && (await (0, _packageChanged.packageDidChange)(this.appiumHome))) {
+        installedExtensionsChanged = await this.syncWithInstalledExtensions();
+      }
+
+      if (isNewFile || installedExtensionsChanged) {
+        await this.write();
+      }
+    })();
+
+    try {
+      await this._reading;
+      return this._data;
+    } finally {
+      this._reading = undefined;
+    }
+  }
+
+  async _setManifestPath() {
+    if (!this._manifestPath) {
+      this._manifestPath = await _support.env.resolveManifestPath(this._appiumHome);
+
+      if (_path.default.relative(this._appiumHome, this._manifestPath).startsWith('.')) {
+        throw new Error(`Mismatch between location of APPIUM_HOME and manifest file. APPIUM_HOME: ${this.appiumHome}, manifest file: ${this._manifestPath}`);
+      }
+    }
+
+    return this._manifestPath;
+  }
+
+  async write() {
+    if (this._writing) {
+      return this._writing;
+    }
+
+    this._writing = (async () => {
+      await this._setManifestPath();
+
+      try {
+        await _support.fs.mkdirp(_path.default.dirname(this._manifestPath));
+      } catch (err) {
+        throw new Error(`Appium could not create the directory for the manifest file: ${_path.default.dirname(this._manifestPath)}. Original error: ${err.message}`);
+      }
+
+      try {
+        await _support.fs.writeFile(this._manifestPath, _yaml.default.stringify(this._data), 'utf8');
+        return true;
+      } catch (err) {
+        throw new Error(`Appium could not write to manifest at ${this._manifestPath} using APPIUM_HOME ${this._appiumHome}. ` + `Please ensure it is writable. Original error: ${err.message}`);
+      }
+    })();
+
+    try {
+      return await this._writing;
+    } finally {
+      this._writing = undefined;
+    }
+  }
+
+}
+
+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","internal","pkgName","installType","INSTALL_TYPE_NPM","installSpec","driverName","addExtension","omit","pluginName","TypeError","dirname","extType","extName","extData","manifestPath","getExtensionData","read","data","isNewFile","_setManifestPath","log","debug","yaml","readFile","YAML","parse","err","code","Error","message","installedExtensionsChanged","hasAppiumDependency","write","undefined","resolveManifestPath","relative","mkdirp","writeFile","stringify"],"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 (\n    appiumHome,\n  ) {\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(\n      this._appiumHome,\n      walkOpts,\n    )) {\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(\n              pkg,\n              path.join(filepath, 'package.json'),\n            );\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    /**\n     * @type {InternalMetadata}\n     */\n    const internal = {\n      pkgName: pkgJson.name,\n      version: pkgJson.version,\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 ${path.dirname(\n          pkgPath,\n        )} 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 {void}\n   */\n  addExtension (extType, extName, extData) {\n    this._data[`${extType}s`][extName] = extData;\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      } 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(\n          this._manifestPath,\n          YAML.stringify(this._data),\n          'utf8',\n        );\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('../../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('../../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('../../types/appium-manifest').ManifestData} ManifestData\n * @typedef {import('../../types/appium-manifest').InternalMetadata} InternalMetadata\n */\n\n/**\n * @template T\n * @typedef {import('../../types/external-manifest').ExtPackageJson<T>} ExtPackageJson\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types/appium-manifest').ExtRecord<T>} ExtRecord\n */\n\n/**\n * Either `driver` or `plugin` rn\n * @typedef {import('../../types').ExtensionType} ExtensionType\n */\n\n"],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+/**
+ * Determines if extensions have changed, and updates a hash the `package.json` in `appiumHome` if so.
+ *
+ * If they have, we need to sync them with the `extensions.yaml` manifest.
+ *
+ * _Warning: this makes a blocking call to `writeFileSync`._
+ * @param {string} appiumHome
+ * @returns {Promise<boolean>} `true` if `package.json` `appiumHome` changed
+ */
+export function packageDidChange(appiumHome: string): Promise<boolean>;
+//# sourceMappingURL=package-changed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"package-changed.d.ts","sourceRoot":"","sources":["../../../lib/extension/package-changed.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,6CAHW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAgD5B"}

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

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.packageDidChange = packageDidChange;
+
+require("source-map-support/register");
+
+var _support = require("@appium/support");
+
+var _packageChanged = require("package-changed");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _constants = require("../constants");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+async function packageDidChange(appiumHome) {
+  const hashFilename = _path.default.join(appiumHome, _constants.PKG_HASHFILE_RELATIVE_PATH);
+
+  let isChanged;
+  let writeHash;
+  let hash;
+  let oldHash;
+
+  const hashFilenameDir = _path.default.dirname(hashFilename);
+
+  _logger.default.debug(`Creating hash file directory: ${hashFilenameDir}`);
+
+  try {
+    await _support.fs.mkdirp(hashFilenameDir);
+  } catch (err) {
+    throw new Error(`Appium could not create the directory for hash file: ${hashFilenameDir}. Original error: ${err.message}`);
+  }
+
+  try {
+    ({
+      isChanged,
+      writeHash,
+      oldHash,
+      hash
+    } = await (0, _packageChanged.isPackageChanged)({
+      cwd: appiumHome,
+      hashFilename: _constants.PKG_HASHFILE_RELATIVE_PATH
+    }));
+  } catch {
+    return true;
+  }
+
+  if (isChanged) {
+    try {
+      var _oldHash;
+
+      writeHash();
+
+      _logger.default.debug(`Updated hash of ${appiumHome}/package.json from: ${(_oldHash = oldHash) !== null && _oldHash !== void 0 ? _oldHash : '(none)'} to: ${hash}`);
+    } catch (err) {
+      throw new Error(`Appium could not write hash file: ${hashFilenameDir}. Original error: ${err.message}`);
+    }
+  }
+
+  return isChanged;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,62 @@
+/**
+ * @extends {ExtensionConfig<PluginType>}
+ */
+export class PluginConfig extends ExtensionConfig<"plugin"> {
+    /**
+     * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.
+     *
+     * `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.
+     *
+     * This variable tracks the `Manifest`-to-`PluginConfig` portion.
+     *
+     * @type {WeakMap<Manifest,PluginConfig>}
+     * @private
+     */
+    private static _instances;
+    /**
+     * Creates a new {@link PluginConfig} instance for a {@link Manifest} instance.
+     *
+     * @param {Manifest} manifest
+     * @param {PluginConfigOptions} [opts]
+     * @throws If `manifest` already associated with a `PluginConfig`
+     * @returns {PluginConfig}
+     */
+    static create(manifest: Manifest, { extData, logFn }?: PluginConfigOptions | undefined): PluginConfig;
+    /**
+      * Returns a PluginConfig associated with a Manifest
+      * @param {Manifest} manifest
+      * @returns {PluginConfig|undefined}
+      */
+    static getInstance(manifest: Manifest): PluginConfig | undefined;
+    /**
+    * Call {@link PluginConfig.create} instead.
+    *
+    * Just calls the superclass' constructor with the correct extension type
+    * @private
+    * @param {Manifest} manifest - IO object
+    * @param {PluginConfigOptions} [opts]
+    */
+    private constructor();
+    /**
+    *
+    * @param {(keyof PluginRecord)[]} activeNames
+    * @returns {void}
+    */
+    print(activeNames: (keyof PluginRecord)[]): void;
+}
+export type PluginConfigOptions = {
+    /**
+     * - Optional logging function
+     */
+    logFn?: import("./extension-config").ExtensionLogFn | undefined;
+    /**
+     * - Extension data
+     */
+    extData?: import("../../types").PluginRecord | undefined;
+};
+export type PluginRecord = import('../../types/appium-manifest').PluginRecord;
+export type PluginType = import('../../types').PluginType;
+export type PluginMetadata = import('../../types/external-manifest').ExtMetadata<PluginType>;
+export type Manifest = import('./manifest').Manifest;
+import { ExtensionConfig } from "./extension-config";
+//# sourceMappingURL=plugin-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-config.d.ts","sourceRoot":"","sources":["../../../lib/extension/plugin-config.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAEE;;;;;;;;;OASG;IACF,0BAAkC;IAkBlC;;;;;;;OAOG;IACH,wBALW,QAAQ,yDAGN,YAAY,CASxB;IAED;;;;QAII;IACJ,6BAHY,QAAQ,GACN,YAAY,GAAC,SAAS,CAInC;IAxCD;;;;;;;MAOE;IACF,sBAMC;IAqCD;;;;MAIE;IACF,mBAHU,CAAC,MAAM,YAAY,CAAC,EAAE,GACpB,IAAI,CAoBf;CACH;;;;;;;;;;;2BAUY,OAAO,6BAA6B,EAAE,YAAY;yBAClD,OAAO,aAAa,EAAE,UAAU;6BAChC,OAAO,+BAA+B,EAAE,WAAW,CAAC,UAAU,CAAC;uBAC/D,OAAO,YAAY,EAAE,QAAQ"}

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

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PluginConfig = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _extensionConfig = require("./extension-config");
+
+var _logger = _interopRequireDefault(require("../logger"));
+
+var _constants = require("../constants");
+
+class PluginConfig extends _extensionConfig.ExtensionConfig {
+  static _instances = new WeakMap();
+
+  constructor(manifest, {
+    extData,
+    logFn
+  } = {}) {
+    super(_constants.PLUGIN_TYPE, manifest, logFn);
+
+    if (extData) {
+      this.validate(extData);
+    }
+  }
+
+  static create(manifest, {
+    extData,
+    logFn
+  } = {}) {
+    const instance = new PluginConfig(manifest, {
+      logFn,
+      extData
+    });
+
+    if (PluginConfig.getInstance(manifest)) {
+      throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`);
+    }
+
+    PluginConfig._instances.set(manifest, instance);
+
+    return instance;
+  }
+
+  static getInstance(manifest) {
+    return PluginConfig._instances.get(manifest);
+  }
+
+  extensionDesc(pluginName, {
+    version
+  }) {
+    return `${pluginName}@${version}`;
+  }
+
+  print(activeNames) {
+    const pluginNames = Object.keys(this.installedExtensions);
+
+    if (_lodash.default.isEmpty(pluginNames)) {
+      _logger.default.info(`No plugins have been installed. Use the "appium plugin" ` + 'command to install the one(s) you want to use.');
+
+      return;
+    }
+
+    _logger.default.info(`Available plugins:`);
+
+    for (const [pluginName, pluginData] of _lodash.default.toPairs(this.installedExtensions)) {
+      const activeTxt = _lodash.default.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';
+
+      _logger.default.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
+    }
+
+    if (_lodash.default.isEmpty(activeNames)) {
+      _logger.default.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
+    }
+  }
+
+}
+
+exports.PluginConfig = PluginConfig;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/grid-register.d.ts

@@ -0,0 +1,10 @@
+export default registerNode;
+/**
+ * Registers a new node with a selenium grid
+ * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!
+ * @param {string} [addr] - Bind to this address
+ * @param {number} [port] - Bind to this port
+ * @param {string} [basePath] - Base path for the grid
+ */
+declare function registerNode(data: string | object, addr?: string | undefined, port?: number | undefined, basePath?: string | undefined): Promise<void>;
+//# sourceMappingURL=grid-register.d.ts.map

package/build/lib/grid-register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-register.d.ts","sourceRoot":"","sources":["../../lib/grid-register.js"],"names":[],"mappings":";AAWA;;;;;;GAMG;AACH,oCALW,MAAM,GAAC,MAAM,sGAwBvB"}