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

package/build/lib/extension/index.js

@@ -74,4 +74,4 @@ function getActiveDrivers(driverConfig, useDrivers = []) {
     }
   }));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/index.js"],"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","drivers","plugins","read","driverConfig","DriverConfig","create","extData","pluginConfig","PluginConfig","getActivePlugins","usePlugins","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName"],"mappings":";;;;;;;;;;;;;AAEA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,eAAeA,cAAf,CAA+BC,UAA/B,EAA2C;AAAA;;AAChD,QAAMC,QAAQ,GAAGC,mBAASC,WAAT,CAAqBH,UAArB,CAAjB;;AACA,QAAM;AAACI,IAAAA,OAAD;AAAUC,IAAAA;AAAV,MAAqB,MAAMJ,QAAQ,CAACK,IAAT,EAAjC;AACA,QAAMC,YAAY,4BAChBC,2BAAaL,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBO,2BAAaC,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEN;AAAV,GAA9B,CAFF;AAGA,QAAMO,YAAY,4BAChBC,2BAAaT,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBW,2BAAaH,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEL;AAAV,GAA9B,CAFF;AAGA,SAAO;AAACE,IAAAA,YAAD;AAAeI,IAAAA;AAAf,GAAP;AACD;;AAYM,SAASE,gBAAT,CAA2BF,YAA3B,EAAyCG,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOC,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYP,YAAY,CAACQ,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,gBAAEO,QAAF,CAAWR,UAAX,EAAuBO,UAAvB,KACCP,UAAU,CAACS,MAAX,KAAsB,CAAtB,IAA2BT,UAAU,CAAC,CAAD,CAAV,KAAkBU,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;AACnB,QAAI;AACFK,sBAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;AACA,YAAMO,WAAW,GAAGjB,YAAY,CAACkB,OAAb,CAAqBR,UAArB,CAApB;;AAEAO,MAAAA,WAAW,CAACP,UAAZ,GAAyBA,UAAzB;AACA,aAAOO,WAAP;AACD,KAND,CAME,OAAOE,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GApBH,CADK,CAAP;AAuBD;;AAUM,SAASC,gBAAT,CAA2B5B,YAA3B,EAAyC6B,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOrB,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKiB,UAAD,IACEtB,gBAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CAHlE,EAKGE,GALH,CAKQY,UAAD,IAAgB;AACnB,QAAI;AACFX,sBAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;AACA,aAAO9B,YAAY,CAACsB,OAAb,CAAqBQ,UAArB,CAAP;AACD,KAHD,CAGE,OAAOP,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GAhBH,CADK,CAAP;AAmBD","sourcesContent":["// @ts-check\n\nimport _ 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';\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  const {drivers, plugins} = await manifest.read();\n  const driverConfig =\n    DriverConfig.getInstance(manifest) ??\n    DriverConfig.create(manifest, {extData: drivers});\n  const pluginConfig =\n    PluginConfig.getInstance(manifest) ??\n    PluginConfig.create(manifest, {extData: plugins});\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 {import('./manifest').PluginClass[]}\n */\nexport function getActivePlugins (pluginConfig, usePlugins = []) {\n  return _.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\n          PluginClass.pluginName = pluginName; // store the plugin name on the class so it can be used later\n          return PluginClass;\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 * 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 */\nexport function getActiveDrivers (driverConfig, useDrivers = []) {\n  return _.compact(\n    Object.keys(driverConfig.installedExtensions)\n      .filter(\n        (driverName) =>\n          _.includes(useDrivers, driverName) || useDrivers.length === 0,\n      )\n      .map((driverName) => {\n        try {\n          log.info(`Attempting to load driver ${driverName}...`);\n          return driverConfig.require(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 * @typedef ExtensionConfigs\n * @property {DriverConfig} driverConfig\n * @property {PluginConfig} pluginConfig\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/index.js"],"names":["loadExtensions","appiumHome","manifest","Manifest","getInstance","drivers","plugins","read","driverConfig","DriverConfig","create","extData","pluginConfig","PluginConfig","getActivePlugins","usePlugins","_","compact","Object","keys","installedExtensions","filter","pluginName","includes","length","USE_ALL_PLUGINS","map","log","info","PluginClass","require","err","error","message","debug","stack","getActiveDrivers","useDrivers","driverName"],"mappings":";;;;;;;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAaO,eAAeA,cAAf,CAA+BC,UAA/B,EAA2C;AAAA;;AAChD,QAAMC,QAAQ,GAAGC,mBAASC,WAAT,CAAqBH,UAArB,CAAjB;;AACA,QAAM;AAACI,IAAAA,OAAD;AAAUC,IAAAA;AAAV,MAAqB,MAAMJ,QAAQ,CAACK,IAAT,EAAjC;AACA,QAAMC,YAAY,4BAChBC,2BAAaL,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBO,2BAAaC,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEN;AAAV,GAA9B,CAFF;AAGA,QAAMO,YAAY,4BAChBC,2BAAaT,WAAb,CAAyBF,QAAzB,CADgB,yEAEhBW,2BAAaH,MAAb,CAAoBR,QAApB,EAA8B;AAACS,IAAAA,OAAO,EAAEL;AAAV,GAA9B,CAFF;AAGA,SAAO;AAACE,IAAAA,YAAD;AAAeI,IAAAA;AAAf,GAAP;AACD;;AAYM,SAASE,gBAAT,CAA2BF,YAA3B,EAAyCG,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOC,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYP,YAAY,CAACQ,mBAAzB,EACGC,MADH,CAEKC,UAAD,IACEN,gBAAEO,QAAF,CAAWR,UAAX,EAAuBO,UAAvB,KACCP,UAAU,CAACS,MAAX,KAAsB,CAAtB,IAA2BT,UAAU,CAAC,CAAD,CAAV,KAAkBU,0BAJpD,EAMGC,GANH,CAMQJ,UAAD,IAAgB;AACnB,QAAI;AACFK,sBAAIC,IAAJ,CAAU,6BAA4BN,UAAW,KAAjD;;AACA,YAAMO,WAAW,GAAGjB,YAAY,CAACkB,OAAb,CAAqBR,UAArB,CAApB;;AAEAO,MAAAA,WAAW,CAACP,UAAZ,GAAyBA,UAAzB;AACA,aAAOO,WAAP;AACD,KAND,CAME,OAAOE,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBV,UAAW,wCAArC,GACG,8BAA6BS,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GApBH,CADK,CAAP;AAuBD;;AAUM,SAASC,gBAAT,CAA2B5B,YAA3B,EAAyC6B,UAAU,GAAG,EAAtD,EAA0D;AAC/D,SAAOrB,gBAAEC,OAAF,CACLC,MAAM,CAACC,IAAP,CAAYX,YAAY,CAACY,mBAAzB,EACGC,MADH,CAEKiB,UAAD,IACEtB,gBAAEO,QAAF,CAAWc,UAAX,EAAuBC,UAAvB,KAAsCD,UAAU,CAACb,MAAX,KAAsB,CAHlE,EAKGE,GALH,CAKQY,UAAD,IAAgB;AACnB,QAAI;AACFX,sBAAIC,IAAJ,CAAU,6BAA4BU,UAAW,KAAjD;;AACA,aAAO9B,YAAY,CAACsB,OAAb,CAAqBQ,UAArB,CAAP;AACD,KAHD,CAGE,OAAOP,GAAP,EAAY;AACZJ,sBAAIK,KAAJ,CACG,0BAAyBM,UAAW,wCAArC,GACG,8BAA6BP,GAAG,CAACE,OAAQ,EAF9C;;AAIAN,sBAAIO,KAAJ,CAAUH,GAAG,CAACI,KAAd;AACD;AACF,GAhBH,CADK,CAAP;AAmBD","sourcesContent":["\nimport _ 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';\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  const {drivers, plugins} = await manifest.read();\n  const driverConfig =\n    DriverConfig.getInstance(manifest) ??\n    DriverConfig.create(manifest, {extData: drivers});\n  const pluginConfig =\n    PluginConfig.getInstance(manifest) ??\n    PluginConfig.create(manifest, {extData: plugins});\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 {import('../../types').PluginClass[]}\n */\nexport function getActivePlugins (pluginConfig, usePlugins = []) {\n  return _.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\n          PluginClass.pluginName = pluginName; // store the plugin name on the class so it can be used later\n          return PluginClass;\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 * 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 */\nexport function getActiveDrivers (driverConfig, useDrivers = []) {\n  return _.compact(\n    Object.keys(driverConfig.installedExtensions)\n      .filter(\n        (driverName) =>\n          _.includes(useDrivers, driverName) || useDrivers.length === 0,\n      )\n      .map((driverName) => {\n        try {\n          log.info(`Attempting to load driver ${driverName}...`);\n          return driverConfig.require(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 * @typedef ExtensionConfigs\n * @property {DriverConfig} driverConfig\n * @property {PluginConfig} pluginConfig\n */\n"]}

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

@@ -0,0 +1,174 @@
+/**
+ * Handles reading & writing of extension config files.
+ *
+ * Only one instance of this class exists per value of `APPIUM_HOME`.
+ */
+export class Manifest {
+    /**
+     * Returns a new or existing {@link Manifest} instance, based on the value of `appiumHome`.
+     *
+     * Maintains one instance per value of `appiumHome`.
+     * @param {string} appiumHome - Path to `APPIUM_HOME`
+     * @returns {Manifest}
+     */
+    static getInstance: ((appiumHome: any) => Manifest) & _.MemoizedFunction;
+    /**
+     * Sets internal data to a fresh clone of {@link INITIAL_MANIFEST_DATA}
+     *
+     * Use {@link Manifest.getInstance} instead.
+     * @param {string} appiumHome
+     * @private
+     */
+    private constructor();
+    /**
+     * The entire contents of a parsed YAML extension config file.
+     *
+     * Contains proxies for automatic persistence on disk
+     * @type {ManifestData}
+     * @private
+     */
+    private _data;
+    /**
+     * Path to `APPIUM_HOME`.
+     * @private
+     * @type {Readonly<string>}
+     */
+    private _appiumHome;
+    /**
+     * Path to `extensions.yaml`
+     * @type {string}
+     * Not set until {@link Manifest.read} is called.
+     */
+    _manifestPath: string;
+    /**
+     * Helps avoid writing multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.write} will cause it to be
+     * set to a `Promise`. When the call to `write()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<boolean>|undefined}
+     */
+    private _writing;
+    /**
+     * Helps avoid reading multiple times.
+     *
+     * If this is `undefined`, calling {@link Manifest.read} will cause it to be
+     * set to a `Promise`. When the call to `read()` is complete, the `Promise`
+     * will resolve and then this value will be set to `undefined`.  Concurrent calls
+     * made while this value is a `Promise` will return the `Promise` itself.
+     * @private
+     * @type {Promise<void>|undefined}
+     */
+    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>;
+    /**
+     * Returns `true` if driver with name `name` is registered.
+     * @param {string} name - Driver name
+     * @returns {boolean}
+     */
+    hasDriver(name: string): boolean;
+    /**
+     * Returns `true` if plugin with name `name` is registered.
+     * @param {string} name - Plugin name
+     * @returns {boolean}
+     */
+    hasPlugin(name: string): boolean;
+    /**
+     * Given a path to a `package.json`, add it as either a driver or plugin to the manifest.
+     *
+     * Will _not_ overwrite existing entries.
+     * @template {ExtensionType} ExtType
+     * @param {ExtPackageJson<ExtType>} pkgJson
+     * @param {string} pkgPath
+     * @returns {boolean} - `true` upon success, `false` if the extension is already registered.
+     */
+    addExtensionFromPackage<ExtType extends import("../../types").ExtensionType>(pkgJson: ExtPackageJson<ExtType>, pkgPath: string): boolean;
+    /**
+     * Adds an extension to the manifest as was installed by the `appium` CLI.  The
+     * `extData`, `extType`, and `extName` have already been determined.
+     *
+     * See {@link Manifest.addExtensionFromPackage} for adding an extension from an on-disk package.
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType - `driver` or `plugin`
+     * @param {string} extName - Name of extension
+     * @param {ExtManifest<ExtType>} extData - Extension metadata
+     * @returns {void}
+     */
+    addExtension<ExtType_1 extends import("../../types").ExtensionType>(extType: ExtType_1, extName: string, extData: ExtManifest<ExtType_1>): void;
+    /**
+     * Returns the APPIUM_HOME path
+     */
+    get appiumHome(): string;
+    /**
+     * Returns the path to the manifest file
+     */
+    get manifestPath(): string;
+    /**
+     * Returns extension data for a particular type.
+     *
+     * @template {ExtensionType} ExtType
+     * @param {ExtType} extType
+     * @returns {ExtRecord<ExtType>}
+     */
+    getExtensionData<ExtType_2 extends import("../../types").ExtensionType>(extType: ExtType_2): ExtRecord<ExtType_2>;
+    /**
+     * Reads manifest from disk and _overwrites_ the internal data.
+     *
+     * If the manifest does not exist on disk, an {@link INITIAL_MANIFEST_DATA "empty"} manifest file will be created.
+     *
+     * 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.
+     *
+     * Only one read operation should happen at a time.  This is controlled via the {@link Manifest._reading} property.
+     * @returns {Promise<ManifestData>} The data
+     */
+    read(): Promise<ManifestData>;
+    /**
+     * Ensures {@link Manifest._manifestPath} is set.
+     *
+     * Creates the directory if necessary.
+     * @private
+     * @returns {Promise<string>}
+     */
+    private _setManifestPath;
+    /**
+     * Writes the data if it need s writing.
+     *
+     * If the `schemaRev` prop needs updating, the file will be written.
+     *
+     * @todo If this becomes too much of a bottleneck, throttle it.
+     * @returns {Promise<boolean>} Whether the data was written
+     */
+    write(): Promise<boolean>;
+}
+/**
+ * Type of the string referring to a driver (typically as a key or type string)
+ */
+export type DriverType = import('../../types').DriverType;
+/**
+ * Type of the string referring to a plugin (typically as a key or type string)
+ */
+export type PluginType = import('../../types').PluginType;
+export type SyncWithInstalledExtensionsOpts = {
+    /**
+     * - Maximum depth to recurse into subdirectories
+     */
+    depthLimit?: number | undefined;
+};
+export type ManifestData = import('../../types/appium-manifest').ManifestData;
+export type InternalMetadata = import('../../types/appium-manifest').InternalMetadata;
+export type ExtPackageJson<T> = import('../../types/external-manifest').ExtPackageJson<T>;
+export type ExtManifest<T> = import('../../types/appium-manifest').ExtManifest<T>;
+export type ExtRecord<T> = import('../../types/appium-manifest').ExtRecord<T>;
+/**
+ * Either `driver` or `plugin` rn
+ */
+export type ExtensionType = import('../../types').ExtensionType;
+import _ from "lodash";
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../../lib/extension/manifest.js"],"names":[],"mappings":"AAqGA;;;;GAIG;AACH;IA4DE;;;;;;OAMG;IACH,yEAIG;IAvBH;;;;;;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;IA2BT;;;;OAIG;IACH,6CAHW,+BAA+B,GAC7B,QAAQ,OAAO,CAAC,CA0B5B;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,wHAHW,MAAM,GACJ,OAAO,CAsCnB;IAED;;;;;;;;;;OAUG;IACH,iGAJW,MAAM,oCAEJ,IAAI,CAIhB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,kHAEC;IAED;;;;;;;;;OASG;IACH,QAFa,QAAQ,YAAY,CAAC,CAsDjC;IAED;;;;;;OAMG;IACH,yBAaC;IAED;;;;;;;OAOG;IACH,SAFa,QAAQ,OAAO,CAAC,CAoC5B;CACF;;;;yBAIY,OAAO,aAAa,EAAE,UAAU;;;;yBAKhC,OAAO,aAAa,EAAE,UAAU;;;;;;;2BAShC,OAAO,6BAA6B,EAAE,YAAY;+BAClD,OAAO,6BAA6B,EAAE,gBAAgB;gCAKtD,OAAO,+BAA+B,EAAE,cAAc,CAAC,CAAC,CAAC;6BAKzD,OAAO,6BAA6B,EAAE,WAAW,CAAC,CAAC,CAAC;2BAKpD,OAAO,6BAA6B,EAAE,SAAS,CAAC,CAAC,CAAC;;;;4BAKlD,OAAO,aAAa,EAAE,aAAa"}

package/build/lib/extension/manifest.js

@@ -243,4 +243,4 @@ class Manifest {
 }
 
 exports.Manifest = Manifest;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/manifest.js"],"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"],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\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 ExtensionPackageJson<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 ExtensionPackageJson<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 ExtensionPackageJson<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 {ExtensionPackageJson<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 {InternalData}\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 {ExtData<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 * Either `driver` or `plugin` rn\n * @typedef {typeof DRIVER_TYPE | typeof PLUGIN_TYPE} ExtensionType\n */\n\n/**\n * Represents an entire YAML manifest (`extensions.yaml`)\n * @typedef ManifestData\n * @property {ExtRecord<DriverType>} drivers - Record of drivers, keyed by name\n * @property {ExtRecord<PluginType>} plugins - Record of plugins, keyed by name\n * @property {number} [schemaRev] - The schema revision of the manifest\n */\n\n/**\n * Combination of external + internal extension data with `driverName`/`pluginName` removed (it becomes a key in an {@link ExtRecord} object).\n * @template {ExtensionType} ExtType\n * @typedef {(Omit<ExternalData<ExtType>, ExtType extends DriverType ? 'driverName' : 'pluginName'>) & InternalData & CommonData} ExtensionManifest\n */\n\n/**\n * Manifest extension data which is _not_ provided in `package.json`.  It may be derived\n * (e.g., `installSpec`) or copied from elsewhere in a `package.json` (e.g.,\n * `version`).\n * @typedef InternalData\n * @property {string} pkgName - Name of package (e.g., `appium-xcuitest-driver`)\n * @property {string} version - Version of package\n * @property {import('./extension-config').InstallType} installType - Install type\n * @property {string} installSpec - Whatever the user typed as the extension to install. May be derived from `package.json`\n */\n\n/**\n * Convert external (`package.json`) extension data into manifest data\n * @typedef {ExtensionManifest<DriverType>} ManifestDriverData\n */\n\n/**\n * Convert external (`package.json`) extension data into manifest data\n * @typedef {ExtensionManifest<PluginType>} ManifestPluginData\n */\n\n/**\n * Data points shared by all Appium extensions\n * @typedef CommonData\n * @property {string} mainClass - Name of main class in the extension\n * @property {Record<string,string>} [scripts] - Collection of scripts which an extension may run\n * @property {string | (import('ajv').SchemaObject & {[key: number]: never})} [schema] - Argument schema object\n */\n\n/**\n * Driver-specific manifest data.\n * @typedef DriverData\n * @property {string} automationName - Automation engine to use\n * @property {string[]} platformNames - Platforms to run on\n * @property {string} driverName - Name of driver (_not_ the same as the package name, probably)\n */\n\n/**\n * Plugin-specific manifest data.\n * @typedef PluginData\n * @property {string} pluginName - Name of plugin (_not_ the same as the package name, probably)\n */\n\n/**\n * Generic type to refer to either {@link DriverData} or {@link PluginData}\n * @template {ExtensionType} ExtType\n * @typedef {CommonData & (ExtType extends DriverType ? DriverData : PluginData)} ExternalData\n */\n\n/**\n * Main class/constructor of third-party plugin\n *\n * Referenced by {@link CommonData.mainClass}\n * @typedef { {pluginName: string} & import('type-fest').Class<unknown> & ExtClassStaticMembers} PluginClass\n */\n\n/**\n * Main class/constructor of third-party driver\n *\n * Referenced by {@link CommonData.mainClass}\n * @typedef { {driverName: string} & import('type-fest').Class<unknown> & ExtClassStaticMembers } DriverClass\n */\n\n/**\n * @typedef ExtClassStaticMembers\n * @property {UpdateServerFn} [updateServer]\n * @property {import('@appium/base-driver').MethodMap} [newMethodMap]\n */\n\n/**\n * @callback UpdateServerFn\n * @param {import('express').Express} app - Express app\n * @param {import('http').Server} httpServer - HTTP server\n * @returns {import('type-fest').Promisable<void>}\n */\n/**\n * Generic type for an object keyed by extension name, with values of type {@link ExtData}\n * @template {ExtensionType} ExtType\n * @typedef {Record<string,ExtData<ExtType>>} ExtRecord\n */\n\n/**\n * Generic type to refer to the data in an {@link ExtRecord}; this is the data for each extension in `extensions.yaml`.\n * @template {ExtensionType} ExtType\n * @typedef {ExtensionManifest<ExtType>} ExtData\n */\n\n/**\n * Like {@link ExtData} except it _for sure_ has a `schema` property.\n * @template {ExtensionType} ExtType\n * @typedef {(ExtensionManifest<ExtType>) & {schema: import('ajv').SchemaObject|string} } ExtDataWithSchema\n */\n\n/**\n * Generic type to refer to the main class constructor of an extension\n * @template {ExtensionType} ExtType\n * @typedef {ExtType extends DriverType ? DriverClass : PluginClass} ExtClass\n */\n\n/**\n * Generic type for the key of an {@link ExtRecord} which corresponds to an extension name.\n * @template {ExtensionType} ExtType\n * @typedef {keyof ExtRecord<ExtType>} ExtName\n */\n\n/**\n * Type of the string referring to a driver (typically as a key or type string)\n * @typedef {typeof import('../constants').DRIVER_TYPE} DriverType\n */\n\n/**\n * Type of the string referring to a plugin (typically as a key or type string)\n * @typedef {typeof import('../constants').PLUGIN_TYPE} PluginType\n */\n\n/**\n * A `package.json` containing extension data.\n * @template {ExtensionType} ExtType\n * @typedef {import('type-fest').SetRequired<import('type-fest').PackageJson, 'name' | 'version'> & {appium: ExternalData<ExtType>} } ExtensionPackageJson\n */\n\n/**\n * @typedef SyncWithInstalledExtensionsOpts\n * @property {number} [depthLimit] - Maximum depth to recurse into subdirectories\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/manifest.js"],"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"],"mappings":"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","sourcesContent":["/// <reference path=\"../../types/appium-manifest.d.ts\" />\n\n/**\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"]}

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

@@ -65,4 +65,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,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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

@@ -84,4 +84,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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9leHRlbnNpb24vcGx1Z2luLWNvbmZpZy5qcyJdLCJuYW1lcyI6WyJQbHVnaW5Db25maWciLCJFeHRlbnNpb25Db25maWciLCJfaW5zdGFuY2VzIiwiV2Vha01hcCIsImNvbnN0cnVjdG9yIiwibWFuaWZlc3QiLCJleHREYXRhIiwibG9nRm4iLCJQTFVHSU5fVFlQRSIsInZhbGlkYXRlIiwiY3JlYXRlIiwiaW5zdGFuY2UiLCJnZXRJbnN0YW5jZSIsIkVycm9yIiwiYXBwaXVtSG9tZSIsInNldCIsImdldCIsImV4dGVuc2lvbkRlc2MiLCJwbHVnaW5OYW1lIiwidmVyc2lvbiIsInByaW50IiwiYWN0aXZlTmFtZXMiLCJwbHVnaW5OYW1lcyIsIk9iamVjdCIsImtleXMiLCJpbnN0YWxsZWRFeHRlbnNpb25zIiwiXyIsImlzRW1wdHkiLCJsb2ciLCJpbmZvIiwicGx1Z2luRGF0YSIsInRvUGFpcnMiLCJhY3RpdmVUeHQiLCJpbmNsdWRlcyJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFDQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFLTyxNQUFNQSxZQUFOLFNBQTJCQyxnQ0FBM0IsQ0FBMkM7QUFZOUIsU0FBVkMsVUFBVSxHQUFHLElBQUlDLE9BQUosRUFBSDs7QUFVakJDLEVBQUFBLFdBQVcsQ0FBRUMsUUFBRixFQUFZO0FBQUNDLElBQUFBLE9BQUQ7QUFBVUMsSUFBQUE7QUFBVixNQUFtQixFQUEvQixFQUFtQztBQUM1QyxVQUFNQyxzQkFBTixFQUFtQkgsUUFBbkIsRUFBNkJFLEtBQTdCOztBQUVBLFFBQUlELE9BQUosRUFBYTtBQUNYLFdBQUtHLFFBQUwsQ0FBY0gsT0FBZDtBQUNEO0FBQ0Y7O0FBVVksU0FBTkksTUFBTSxDQUFFTCxRQUFGLEVBQVk7QUFBQ0MsSUFBQUEsT0FBRDtBQUFVQyxJQUFBQTtBQUFWLE1BQW1CLEVBQS9CLEVBQW1DO0FBQzlDLFVBQU1JLFFBQVEsR0FBRyxJQUFJWCxZQUFKLENBQWlCSyxRQUFqQixFQUEyQjtBQUFDRSxNQUFBQSxLQUFEO0FBQVFELE1BQUFBO0FBQVIsS0FBM0IsQ0FBakI7O0FBQ0EsUUFBSU4sWUFBWSxDQUFDWSxXQUFiLENBQXlCUCxRQUF6QixDQUFKLEVBQXdDO0FBQ3RDLFlBQU0sSUFBSVEsS0FBSixDQUFXLDZCQUE0QlIsUUFBUSxDQUFDUyxVQUFXLDZFQUEzRCxDQUFOO0FBQ0Q7O0FBQ0RkLElBQUFBLFlBQVksQ0FBQ0UsVUFBYixDQUF3QmEsR0FBeEIsQ0FBNEJWLFFBQTVCLEVBQXNDTSxRQUF0Qzs7QUFDQSxXQUFPQSxRQUFQO0FBQ0Q7O0FBT2lCLFNBQVhDLFdBQVcsQ0FBRVAsUUFBRixFQUFZO0FBQzVCLFdBQU9MLFlBQVksQ0FBQ0UsVUFBYixDQUF3QmMsR0FBeEIsQ0FBNEJYLFFBQTVCLENBQVA7QUFDRDs7QUFPRFksRUFBQUEsYUFBYSxDQUFFQyxVQUFGLEVBQWM7QUFBQ0MsSUFBQUE7QUFBRCxHQUFkLEVBQXlCO0FBQ3BDLFdBQVEsR0FBRUQsVUFBVyxJQUFHQyxPQUFRLEVBQWhDO0FBQ0Q7O0FBT0RDLEVBQUFBLEtBQUssQ0FBRUMsV0FBRixFQUFlO0FBQ2xCLFVBQU1DLFdBQVcsR0FBR0MsTUFBTSxDQUFDQyxJQUFQLENBQVksS0FBS0MsbUJBQWpCLENBQXBCOztBQUVBLFFBQUlDLGdCQUFFQyxPQUFGLENBQVVMLFdBQVYsQ0FBSixFQUE0QjtBQUMxQk0sc0JBQUlDLElBQUosQ0FBVSwwREFBRCxHQUNELGdEQURSOztBQUVBO0FBQ0Q7O0FBRURELG9CQUFJQyxJQUFKLENBQVUsb0JBQVY7O0FBQ0EsU0FBSyxNQUFNLENBQUNYLFVBQUQsRUFBYVksVUFBYixDQUFYLElBQXVDSixnQkFBRUssT0FBRixDQUFVLEtBQUtOLG1CQUFmLENBQXZDLEVBQTRFO0FBQzFFLFlBQU1PLFNBQVMsR0FBR04sZ0JBQUVPLFFBQUYsQ0FBV1osV0FBWCxFQUF3QkgsVUFBeEIsSUFBc0MsV0FBdEMsR0FBb0QsRUFBdEU7O0FBQ0FVLHNCQUFJQyxJQUFKLENBQVUsT0FBTSxLQUFLWixhQUFMLENBQW1CQyxVQUFuQixFQUErQlksVUFBL0IsQ0FBMkMsR0FBRUUsU0FBVSxFQUF2RTtBQUNEOztBQUVELFFBQUlOLGdCQUFFQyxPQUFGLENBQVVOLFdBQVYsQ0FBSixFQUE0QjtBQUMxQk8sc0JBQUlDLElBQUosQ0FBUyxvRkFBVDtBQUNEO0FBQ0Y7O0FBeEY4QyIsInNvdXJjZXNDb250ZW50IjpbIlxuaW1wb3J0IF8gZnJvbSAnbG9kYXNoJztcbmltcG9ydCB7RXh0ZW5zaW9uQ29uZmlnfSBmcm9tICcuL2V4dGVuc2lvbi1jb25maWcnO1xuaW1wb3J0IGxvZyBmcm9tICcuLi9sb2dnZXInO1xuaW1wb3J0IHtQTFVHSU5fVFlQRX0gZnJvbSAnLi4vY29uc3RhbnRzJztcblxuLyoqXG4gKiBAZXh0ZW5kcyB7RXh0ZW5zaW9uQ29uZmlnPFBsdWdpblR5cGU+fVxuICovXG5leHBvcnQgY2xhc3MgUGx1Z2luQ29uZmlnIGV4dGVuZHMgRXh0ZW5zaW9uQ29uZmlnIHtcblxuICAvKipcbiAgICogQSBtYXBwaW5nIG9mIHtAbGluayBNYW5pZmVzdH0gaW5zdGFuY2VzIHRvIHtAbGluayBQbHVnaW5Db25maWd9IGluc3RhbmNlcy5cbiAgICpcbiAgICogYE1hbmlmZXN0YCBhbmQge0BsaW5rIEV4dGVuc2lvbkNvbmZpZ30gaGF2ZSBhIG9uZS10by1tYW55IHJlbGF0aW9uc2hpcDsgZWFjaCBgTWFuaWZlc3RgIHNob3VsZCBiZSBhc3NvY2lhdGVkIHdpdGggYSBgRHJpdmVyQ29uZmlnYCBhbmQgYSBgUGx1Z2luQ29uZmlnYDsgbm8gbW9yZSwgbm8gbGVzcy5cbiAgICpcbiAgICogVGhpcyB2YXJpYWJsZSB0cmFja3MgdGhlIGBNYW5pZmVzdGAtdG8tYFBsdWdpbkNvbmZpZ2AgcG9ydGlvbi5cbiAgICpcbiAgICogQHR5cGUge1dlYWtNYXA8TWFuaWZlc3QsUGx1Z2luQ29uZmlnPn1cbiAgICogQHByaXZhdGVcbiAgICovXG4gICBzdGF0aWMgX2luc3RhbmNlcyA9IG5ldyBXZWFrTWFwKCk7XG5cbiAgIC8qKlxuICAgKiBDYWxsIHtAbGluayBQbHVnaW5Db25maWcuY3JlYXRlfSBpbnN0ZWFkLlxuICAgKlxuICAgKiBKdXN0IGNhbGxzIHRoZSBzdXBlcmNsYXNzJyBjb25zdHJ1Y3RvciB3aXRoIHRoZSBjb3JyZWN0IGV4dGVuc2lvbiB0eXBlXG4gICAqIEBwcml2YXRlXG4gICAqIEBwYXJhbSB7TWFuaWZlc3R9IG1hbmlmZXN0IC0gSU8gb2JqZWN0XG4gICAqIEBwYXJhbSB7UGx1Z2luQ29uZmlnT3B0aW9uc30gW29wdHNdXG4gICAqL1xuICAgY29uc3RydWN0b3IgKG1hbmlmZXN0LCB7ZXh0RGF0YSwgbG9nRm59ID0ge30pIHtcbiAgICAgc3VwZXIoUExVR0lOX1RZUEUsIG1hbmlmZXN0LCBsb2dGbik7XG5cbiAgICAgaWYgKGV4dERhdGEpIHtcbiAgICAgICB0aGlzLnZhbGlkYXRlKGV4dERhdGEpO1xuICAgICB9XG4gICB9XG5cbiAgIC8qKlxuICAgICogQ3JlYXRlcyBhIG5ldyB7QGxpbmsgUGx1Z2luQ29uZmlnfSBpbnN0YW5jZSBmb3IgYSB7QGxpbmsgTWFuaWZlc3R9IGluc3RhbmNlLlxuICAgICpcbiAgICAqIEBwYXJhbSB7TWFuaWZlc3R9IG1hbmlmZXN0XG4gICAgKiBAcGFyYW0ge1BsdWdpbkNvbmZpZ09wdGlvbnN9IFtvcHRzXVxuICAgICogQHRocm93cyBJZiBgbWFuaWZlc3RgIGFscmVhZHkgYXNzb2NpYXRlZCB3aXRoIGEgYFBsdWdpbkNvbmZpZ2BcbiAgICAqIEByZXR1cm5zIHtQbHVnaW5Db25maWd9XG4gICAgKi9cbiAgIHN0YXRpYyBjcmVhdGUgKG1hbmlmZXN0LCB7ZXh0RGF0YSwgbG9nRm59ID0ge30pIHtcbiAgICAgY29uc3QgaW5zdGFuY2UgPSBuZXcgUGx1Z2luQ29uZmlnKG1hbmlmZXN0LCB7bG9nRm4sIGV4dERhdGF9KTtcbiAgICAgaWYgKFBsdWdpbkNvbmZpZy5nZXRJbnN0YW5jZShtYW5pZmVzdCkpIHtcbiAgICAgICB0aHJvdyBuZXcgRXJyb3IoYE1hbmlmZXN0IHdpdGggQVBQSVVNX0hPTUUgJHttYW5pZmVzdC5hcHBpdW1Ib21lfSBhbHJlYWR5IGhhcyBhIFBsdWdpbkNvbmZpZzsgdXNlIFBsdWdpbkNvbmZpZy5nZXRJbnN0YW5jZSgpIHRvIHJldHJpZXZlIGl0LmApO1xuICAgICB9XG4gICAgIFBsdWdpbkNvbmZpZy5faW5zdGFuY2VzLnNldChtYW5pZmVzdCwgaW5zdGFuY2UpO1xuICAgICByZXR1cm4gaW5zdGFuY2U7XG4gICB9XG5cbiAgIC8qKlxuICAgICAqIFJldHVybnMgYSBQbHVnaW5Db25maWcgYXNzb2NpYXRlZCB3aXRoIGEgTWFuaWZlc3RcbiAgICAgKiBAcGFyYW0ge01hbmlmZXN0fSBtYW5pZmVzdFxuICAgICAqIEByZXR1cm5zIHtQbHVnaW5Db25maWd8dW5kZWZpbmVkfVxuICAgICAqL1xuICAgc3RhdGljIGdldEluc3RhbmNlIChtYW5pZmVzdCkge1xuICAgICByZXR1cm4gUGx1Z2luQ29uZmlnLl9pbnN0YW5jZXMuZ2V0KG1hbmlmZXN0KTtcbiAgIH1cblxuICAgLyoqXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBwbHVnaW5OYW1lXG4gICAqIEBwYXJhbSB7aW1wb3J0KCcuLi8uLi90eXBlcy9hcHBpdW0tbWFuaWZlc3QnKS5FeHRNYW5pZmVzdDxQbHVnaW5UeXBlPn0gcGx1Z2luRGF0YVxuICAgKiBAcmV0dXJucyB7c3RyaW5nfVxuICAgKi9cbiAgIGV4dGVuc2lvbkRlc2MgKHBsdWdpbk5hbWUsIHt2ZXJzaW9ufSkge1xuICAgICByZXR1cm4gYCR7cGx1Z2luTmFtZX1AJHt2ZXJzaW9ufWA7XG4gICB9XG5cbiAgIC8qKlxuICAgKlxuICAgKiBAcGFyYW0geyhrZXlvZiBQbHVnaW5SZWNvcmQpW119IGFjdGl2ZU5hbWVzXG4gICAqIEByZXR1cm5zIHt2b2lkfVxuICAgKi9cbiAgIHByaW50IChhY3RpdmVOYW1lcykge1xuICAgICBjb25zdCBwbHVnaW5OYW1lcyA9IE9iamVjdC5rZXlzKHRoaXMuaW5zdGFsbGVkRXh0ZW5zaW9ucyk7XG5cbiAgICAgaWYgKF8uaXNFbXB0eShwbHVnaW5OYW1lcykpIHtcbiAgICAgICBsb2cuaW5mbyhgTm8gcGx1Z2lucyBoYXZlIGJlZW4gaW5zdGFsbGVkLiBVc2UgdGhlIFwiYXBwaXVtIHBsdWdpblwiIGAgK1xuICAgICAgICAgICAgICAgJ2NvbW1hbmQgdG8gaW5zdGFsbCB0aGUgb25lKHMpIHlvdSB3YW50IHRvIHVzZS4nKTtcbiAgICAgICByZXR1cm47XG4gICAgIH1cblxuICAgICBsb2cuaW5mbyhgQXZhaWxhYmxlIHBsdWdpbnM6YCk7XG4gICAgIGZvciAoY29uc3QgW3BsdWdpbk5hbWUsIHBsdWdpbkRhdGFdIG9mIF8udG9QYWlycyh0aGlzLmluc3RhbGxlZEV4dGVuc2lvbnMpKSB7XG4gICAgICAgY29uc3QgYWN0aXZlVHh0ID0gXy5pbmNsdWRlcyhhY3RpdmVOYW1lcywgcGx1Z2luTmFtZSkgPyAnIChBQ1RJVkUpJyA6ICcnO1xuICAgICAgIGxvZy5pbmZvKGAgIC0gJHt0aGlzLmV4dGVuc2lvbkRlc2MocGx1Z2luTmFtZSwgcGx1Z2luRGF0YSl9JHthY3RpdmVUeHR9YCk7XG4gICAgIH1cblxuICAgICBpZiAoXy5pc0VtcHR5KGFjdGl2ZU5hbWVzKSkge1xuICAgICAgIGxvZy5pbmZvKCdObyBwbHVnaW5zIGFjdGl2YXRlZC4gVXNlIHRoZSAtLXVzZS1wbHVnaW5zIGZsYWcgd2l0aCBuYW1lcyBvZiBwbHVnaW5zIHRvIGFjdGl2YXRlJyk7XG4gICAgIH1cbiAgIH1cbn1cblxuLyoqXG4gKiBAdHlwZWRlZiBQbHVnaW5Db25maWdPcHRpb25zXG4gKiBAcHJvcGVydHkge2ltcG9ydCgnLi9leHRlbnNpb24tY29uZmlnJykuRXh0ZW5zaW9uTG9nRm59IFtsb2dGbl0gLSBPcHRpb25hbCBsb2dnaW5nIGZ1bmN0aW9uXG4gKiBAcHJvcGVydHkge2ltcG9ydCgnLi4vLi4vdHlwZXMvYXBwaXVtLW1hbmlmZXN0JykuUGx1Z2luUmVjb3JkfSBbZXh0RGF0YV0gLSBFeHRlbnNpb24gZGF0YVxuICovXG5cblxuLyoqXG4gKiBAdHlwZWRlZiB7aW1wb3J0KCcuLi8uLi90eXBlcy9hcHBpdW0tbWFuaWZlc3QnKS5QbHVnaW5SZWNvcmR9IFBsdWdpblJlY29yZFxuICogQHR5cGVkZWYge2ltcG9ydCgnLi4vLi4vdHlwZXMnKS5QbHVnaW5UeXBlfSBQbHVnaW5UeXBlXG4gKiBAdHlwZWRlZiB7aW1wb3J0KCcuLi8uLi90eXBlcy9leHRlcm5hbC1tYW5pZmVzdCcpLkV4dE1ldGFkYXRhPFBsdWdpblR5cGU+fSBQbHVnaW5NZXRhZGF0YVxuICogQHR5cGVkZWYge2ltcG9ydCgnLi9tYW5pZmVzdCcpLk1hbmlmZXN0fSBNYW5pZmVzdFxuICovXG4iXX0=

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"}

package/build/lib/logger.d.ts

@@ -0,0 +1,3 @@
+export default log;
+declare let log: import("@appium/types").AppiumLogger;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../lib/logger.js"],"names":[],"mappings":";AAGA,sDAAqC"}

package/build/lib/logsink.d.ts

@@ -0,0 +1,4 @@
+export default init;
+export function init(args: any): Promise<void>;
+export function clear(): void;
+//# sourceMappingURL=logsink.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logsink.d.ts","sourceRoot":"","sources":["../../lib/logsink.js"],"names":[],"mappings":";AA6LA,+CA0BC;AAED,8BAOC"}