appium 2.0.0-beta.30 → 2.0.0-beta.35

package/build/lib/cli/parser.d.ts

@@ -70,10 +70,11 @@ export class ArgParser {
      * If no subcommand is passed in, this method will inject the `server` subcommand.
      *
      * `ArgParser.prototype.parse_args` is an alias of this method.
+     * @template [T=import('../../types').WithServerSubcommand]
      * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.
-     * @returns {import('../../types/cli').ParsedArgs} - The parsed arguments
+     * @returns {import('../../types').Args<T>} - The parsed arguments
      */
-    parseArgs(args?: string[] | undefined): import('../../types/cli').ParsedArgs;
+    parseArgs<T = import("../../types").WithServerSubcommand>(args?: string[] | undefined): import("../../types").Args<T>;
 }
 import { ArgumentParser } from "argparse";
 //# sourceMappingURL=parser.d.ts.map

package/build/lib/cli/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../lib/cli/parser.js"],"names":[],"mappings":"AA6PA;;;;;;GAMG;AACH,wDAFa,SAAS,CAMrB;AAzOD;;;;;;GAMG;AACH;IA2FE;;;;;;;;OAQG;IACH,kCAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,0BAFW,cAAc,QASxB;IAED;;;;OAIG;IACH,qCAHW,OAAO,UAAU,EAAE,SAAS,GAC1B,OAAO,QAAQ,EAAE,mBAAmB,CAkBhD;IAED;;;OAGG;IACH,iDAFW,OAAO,UAAU,EAAE,SAAS,QAyDtC;IAnND;;OAEG;IACH,yCAmDC;IAxCC;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,QAFU,cAAc,CAEJ;IAcpB,8CAAyB;IAMzB;;OAEG;IACH,YAFU,SAAS,CAAC,WAAW,CAAC,CAEA;IAGlC;;;;;;;;OAQG;IACH,wCAFa,OAAO,iBAAiB,EAAE,UAAU,CAyBhD;CA4HF"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../lib/cli/parser.js"],"names":[],"mappings":"AA8PA;;;;;;GAMG;AACH,wDAFa,SAAS,CAMrB;AA1OD;;;;;;GAMG;AACH;IA4FE;;;;;;;;OAQG;IACH,kCAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;OAGG;IACH,0BAFW,cAAc,QASxB;IAED;;;;OAIG;IACH,qCAHW,OAAO,UAAU,EAAE,SAAS,GAC1B,OAAO,QAAQ,EAAE,mBAAmB,CAkBhD;IAED;;;OAGG;IACH,iDAFW,OAAO,UAAU,EAAE,SAAS,QAyDtC;IApND;;OAEG;IACH,yCAmDC;IAxCC;;;OAGG;IACH,MAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,OAFU,OAAO,CAEC;IAElB;;;OAGG;IACH,QAFU,cAAc,CAEJ;IAcpB,8CAAyB;IAMzB;;OAEG;IACH,YAFU,SAAS,CAAC,WAAW,CAAC,CAEA;IAGlC;;;;;;;;;OASG;IACH,sHAuBC;CA4HF"}

package/build/lib/cli/parser.js

@@ -188,4 +188,4 @@ function getParser(debug) {
   (0, _schema.finalizeSchema)();
   return new ArgParser(debug);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/cli/parser.js"],"names":["NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","SERVER_SUBCOMMAND","version","fs","readPackageJsonFrom","rootDir","ArgParser","constructor","debug","prog","process","argv","path","basename","parser","ArgumentParser","add_help","description","_patchExit","add_argument","action","subParsers","add_subparsers","dest","serverArgs","_addServerToParser","rawArgs","_addExtensionCommandsToParser","parse_args","parseArgs","args","slice","has","unshift","parsed","_transformParsedArgs","err","console","error","message","exit","_","reduce","unpacked","value","key","isUndefined","set","code","msg","Error","subParser","serverParser","add_parser","help","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser"],"mappings":"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","sourcesContent":["\nimport { fs } from '@appium/support';\nimport { ArgumentParser } from 'argparse';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from '../constants';\nimport { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';\nimport { rootDir } from '../config';\nimport {\n  getExtensionArgs,\n  getServerArgs\n} from './args';\n\n/**\n * If the parsed args do not contain any of these values, then we\n * will automatially inject the `server` subcommand.\n */\nconst NON_SERVER_ARGS = Object.freeze(\n  new Set([\n    DRIVER_TYPE,\n    PLUGIN_TYPE,\n    SERVER_SUBCOMMAND,\n    '-h',\n    '--help',\n    '-v',\n    '--version'\n  ])\n);\n\nconst version = fs.readPackageJsonFrom(rootDir).version;\n\n/**\n * A wrapper around `argparse`\n *\n * - Handles instantiation, configuration, and monkeypatching of an\n *    `ArgumentParser` instance for Appium server and its extensions\n * - Handles error conditions, messages, and exit behavior\n */\nclass ArgParser {\n  /**\n   * @param {boolean} [debug] - If true, throw instead of exit on error.\n   */\n  constructor (debug = false) {\n    const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';\n    const parser = new ArgumentParser({\n      add_help: true,\n      description:\n        'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',\n      prog,\n    });\n\n    ArgParser._patchExit(parser);\n\n    /**\n     * Program name (typically `appium`)\n     * @type {string}\n     */\n    this.prog = prog;\n\n    /**\n     * If `true`, throw an error on parse failure instead of printing help\n     * @type {boolean}\n     */\n    this.debug = debug;\n\n    /**\n     * Wrapped `ArgumentParser` instance\n     * @type {ArgumentParser}\n     */\n    this.parser = parser;\n\n    parser.add_argument('-v', '--version', {\n      action: 'version',\n      version,\n    });\n\n    const subParsers = parser.add_subparsers({dest: 'subcommand'});\n\n    // add the 'server' subcommand, and store the raw arguments on the parser\n    // object as a way for other parts of the code to work with the arguments\n    // conceptually rather than just through argparse\n    const serverArgs = ArgParser._addServerToParser(subParsers);\n\n    this.rawArgs = serverArgs;\n\n    // add the 'driver' and 'plugin' subcommands\n    ArgParser._addExtensionCommandsToParser(subParsers);\n\n    // backwards compatibility / drop-in wrapper\n    /**\n     * @type {ArgParser['parseArgs']}\n     */\n    this.parse_args = this.parseArgs;\n  }\n\n  /**\n   * Parse arguments from the command line.\n   *\n   * If no subcommand is passed in, this method will inject the `server` subcommand.\n   *\n   * `ArgParser.prototype.parse_args` is an alias of this method.\n   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.\n   * @returns {import('../../types/cli').ParsedArgs} - The parsed arguments\n   */\n  parseArgs (args = process.argv.slice(2)) {\n    if (!NON_SERVER_ARGS.has(args[0])) {\n      args.unshift(SERVER_SUBCOMMAND);\n    }\n\n    try {\n      const parsed = this.parser.parse_args(args);\n      return ArgParser._transformParsedArgs(parsed);\n    } catch (err) {\n      if (this.debug) {\n        throw err;\n      }\n      // this isn't tested via unit tests (we use `debug: true`) so may escape coverage.\n\n      /* istanbul ignore next */\n      {\n        // eslint-disable-next-line no-console\n        console.error(); // need an extra space since argparse prints usage.\n        // eslint-disable-next-line no-console\n        console.error(err.message);\n        process.exit(1);\n      }\n    }\n  }\n\n  /**\n   * Given an object full of arguments as returned by `argparser.parse_args`,\n   * expand the ones for extensions into a nested object structure and rename\n   * keys to match the intended destination.\n   *\n   * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`\n   * @param {object} args\n   * @returns {object}\n   */\n  static _transformParsedArgs (args) {\n    return _.reduce(\n      args,\n      (unpacked, value, key) => {\n        if (!_.isUndefined(value) && hasArgSpec(key)) {\n          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */(getArgSpec(key));\n          _.set(unpacked, dest, value);\n        } else {\n          // this could be anything that _isn't_ a server arg\n          unpacked[key] = value;\n        }\n        return unpacked;\n      },\n      {},\n    );\n  }\n\n  /**\n   * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.\n   * @param {ArgumentParser} parser\n   */\n  static _patchExit (parser) {\n    parser.exit = (code, msg) => {\n      if (code) {\n        throw new Error(msg);\n      }\n      process.exit();\n    };\n  }\n\n  /**\n   *\n   * @param {import('argparse').SubParser} subParser\n   * @returns {import('./args').ArgumentDefinitions}\n   */\n  static _addServerToParser (subParser) {\n    const serverParser = subParser.add_parser('server', {\n      add_help: true,\n      help: 'Run an Appium server',\n    });\n\n    ArgParser._patchExit(serverParser);\n\n    const serverArgs = getServerArgs();\n    for (const [flagsOrNames, opts] of serverArgs) {\n      // TS doesn't like the spread operator here.\n      // @ts-ignore\n      serverParser.add_argument(...flagsOrNames, {...opts});\n    }\n\n    return serverArgs;\n  }\n\n  /**\n   * Adds extension sub-sub-commands to `driver`/`plugin` subcommands\n   * @param {import('argparse').SubParser} subParsers\n   */\n  static _addExtensionCommandsToParser (subParsers) {\n    for (const type of [DRIVER_TYPE, PLUGIN_TYPE]) {\n      const extParser = subParsers.add_parser(type, {\n        add_help: true,\n        help: `Access the ${type} management CLI commands`,\n      });\n\n      ArgParser._patchExit(extParser);\n\n      const extSubParsers = extParser.add_subparsers({\n        dest: `${type}Command`,\n      });\n      const extensionArgs = getExtensionArgs();\n      const parserSpecs = [\n        {\n          command: 'list',\n          args: extensionArgs[type].list,\n          help: `List available and installed ${type}s`,\n        },\n        {\n          command: 'install',\n          args: extensionArgs[type].install,\n          help: `Install a ${type}`,\n        },\n        {\n          command: 'uninstall',\n          args: extensionArgs[type].uninstall,\n          help: `Uninstall a ${type}`,\n        },\n        {\n          command: 'update',\n          args: extensionArgs[type].update,\n          help: `Update installed ${type}s to the latest version`,\n        },\n        {\n          command: 'run',\n          args: extensionArgs[type].run,\n          help:\n            `Run a script (defined inside the ${type}'s package.json under the ` +\n            `“scripts” field inside the “appium” field) from an installed ${type}`,\n        },\n      ];\n\n      for (const {command, args, help} of parserSpecs) {\n        const parser = extSubParsers.add_parser(command, {help});\n\n        ArgParser._patchExit(parser);\n\n        for (const [flagsOrNames, opts] of args) {\n          // add_argument mutates params so make sure to send in copies instead\n          // @ts-ignore\n          parser.add_argument(...flagsOrNames, {...opts});\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates a {@link ArgParser} instance; finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {ArgParser}\n */\nfunction getParser (debug) {\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport { getParser, ArgParser };\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","SERVER_SUBCOMMAND","version","fs","readPackageJsonFrom","rootDir","ArgParser","constructor","debug","prog","process","argv","path","basename","parser","ArgumentParser","add_help","description","_patchExit","add_argument","action","subParsers","add_subparsers","dest","serverArgs","_addServerToParser","rawArgs","_addExtensionCommandsToParser","parse_args","parseArgs","args","slice","has","unshift","parsed","_transformParsedArgs","err","console","error","message","exit","_","reduce","unpacked","value","key","isUndefined","set","code","msg","Error","subParser","serverParser","add_parser","help","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser"],"sources":["../../../lib/cli/parser.js"],"sourcesContent":["\nimport { fs } from '@appium/support';\nimport { ArgumentParser } from 'argparse';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from '../constants';\nimport { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';\nimport { rootDir } from '../config';\nimport {\n  getExtensionArgs,\n  getServerArgs\n} from './args';\n\n/**\n * If the parsed args do not contain any of these values, then we\n * will automatially inject the `server` subcommand.\n */\nconst NON_SERVER_ARGS = Object.freeze(\n  new Set([\n    DRIVER_TYPE,\n    PLUGIN_TYPE,\n    SERVER_SUBCOMMAND,\n    '-h',\n    '--help',\n    '-v',\n    '--version'\n  ])\n);\n\nconst version = fs.readPackageJsonFrom(rootDir).version;\n\n/**\n * A wrapper around `argparse`\n *\n * - Handles instantiation, configuration, and monkeypatching of an\n *    `ArgumentParser` instance for Appium server and its extensions\n * - Handles error conditions, messages, and exit behavior\n */\nclass ArgParser {\n  /**\n   * @param {boolean} [debug] - If true, throw instead of exit on error.\n   */\n  constructor (debug = false) {\n    const prog = process.argv[1] ? path.basename(process.argv[1]) : 'appium';\n    const parser = new ArgumentParser({\n      add_help: true,\n      description:\n        'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',\n      prog,\n    });\n\n    ArgParser._patchExit(parser);\n\n    /**\n     * Program name (typically `appium`)\n     * @type {string}\n     */\n    this.prog = prog;\n\n    /**\n     * If `true`, throw an error on parse failure instead of printing help\n     * @type {boolean}\n     */\n    this.debug = debug;\n\n    /**\n     * Wrapped `ArgumentParser` instance\n     * @type {ArgumentParser}\n     */\n    this.parser = parser;\n\n    parser.add_argument('-v', '--version', {\n      action: 'version',\n      version,\n    });\n\n    const subParsers = parser.add_subparsers({dest: 'subcommand'});\n\n    // add the 'server' subcommand, and store the raw arguments on the parser\n    // object as a way for other parts of the code to work with the arguments\n    // conceptually rather than just through argparse\n    const serverArgs = ArgParser._addServerToParser(subParsers);\n\n    this.rawArgs = serverArgs;\n\n    // add the 'driver' and 'plugin' subcommands\n    ArgParser._addExtensionCommandsToParser(subParsers);\n\n    // backwards compatibility / drop-in wrapper\n    /**\n     * @type {ArgParser['parseArgs']}\n     */\n    this.parse_args = this.parseArgs;\n  }\n\n  /**\n   * Parse arguments from the command line.\n   *\n   * If no subcommand is passed in, this method will inject the `server` subcommand.\n   *\n   * `ArgParser.prototype.parse_args` is an alias of this method.\n   * @template [T=import('../../types').WithServerSubcommand]\n   * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.\n   * @returns {import('../../types').Args<T>} - The parsed arguments\n   */\n  parseArgs (args = process.argv.slice(2)) {\n    if (!NON_SERVER_ARGS.has(args[0])) {\n      args.unshift(SERVER_SUBCOMMAND);\n    }\n\n    try {\n      const parsed = this.parser.parse_args(args);\n      return ArgParser._transformParsedArgs(parsed);\n    } catch (err) {\n      if (this.debug) {\n        throw err;\n      }\n      // this isn't tested via unit tests (we use `debug: true`) so may escape coverage.\n\n      /* istanbul ignore next */\n      {\n        // eslint-disable-next-line no-console\n        console.error(); // need an extra space since argparse prints usage.\n        // eslint-disable-next-line no-console\n        console.error(err.message);\n        process.exit(1);\n      }\n    }\n  }\n\n  /**\n   * Given an object full of arguments as returned by `argparser.parse_args`,\n   * expand the ones for extensions into a nested object structure and rename\n   * keys to match the intended destination.\n   *\n   * E.g., `{'driver-foo-bar': baz}` becomes `{driver: {foo: {bar: 'baz'}}}`\n   * @param {object} args\n   * @returns {object}\n   */\n  static _transformParsedArgs (args) {\n    return _.reduce(\n      args,\n      (unpacked, value, key) => {\n        if (!_.isUndefined(value) && hasArgSpec(key)) {\n          const {dest} = /** @type {import('../schema/arg-spec').ArgSpec} */(getArgSpec(key));\n          _.set(unpacked, dest, value);\n        } else {\n          // this could be anything that _isn't_ a server arg\n          unpacked[key] = value;\n        }\n        return unpacked;\n      },\n      {},\n    );\n  }\n\n  /**\n   * Patches the `exit()` method of the parser to throw an error, so we can handle it manually.\n   * @param {ArgumentParser} parser\n   */\n  static _patchExit (parser) {\n    parser.exit = (code, msg) => {\n      if (code) {\n        throw new Error(msg);\n      }\n      process.exit();\n    };\n  }\n\n  /**\n   *\n   * @param {import('argparse').SubParser} subParser\n   * @returns {import('./args').ArgumentDefinitions}\n   */\n  static _addServerToParser (subParser) {\n    const serverParser = subParser.add_parser('server', {\n      add_help: true,\n      help: 'Run an Appium server',\n    });\n\n    ArgParser._patchExit(serverParser);\n\n    const serverArgs = getServerArgs();\n    for (const [flagsOrNames, opts] of serverArgs) {\n      // TS doesn't like the spread operator here.\n      // @ts-ignore\n      serverParser.add_argument(...flagsOrNames, {...opts});\n    }\n\n    return serverArgs;\n  }\n\n  /**\n   * Adds extension sub-sub-commands to `driver`/`plugin` subcommands\n   * @param {import('argparse').SubParser} subParsers\n   */\n  static _addExtensionCommandsToParser (subParsers) {\n    for (const type of [DRIVER_TYPE, PLUGIN_TYPE]) {\n      const extParser = subParsers.add_parser(type, {\n        add_help: true,\n        help: `Access the ${type} management CLI commands`,\n      });\n\n      ArgParser._patchExit(extParser);\n\n      const extSubParsers = extParser.add_subparsers({\n        dest: `${type}Command`,\n      });\n      const extensionArgs = getExtensionArgs();\n      const parserSpecs = [\n        {\n          command: 'list',\n          args: extensionArgs[type].list,\n          help: `List available and installed ${type}s`,\n        },\n        {\n          command: 'install',\n          args: extensionArgs[type].install,\n          help: `Install a ${type}`,\n        },\n        {\n          command: 'uninstall',\n          args: extensionArgs[type].uninstall,\n          help: `Uninstall a ${type}`,\n        },\n        {\n          command: 'update',\n          args: extensionArgs[type].update,\n          help: `Update installed ${type}s to the latest version`,\n        },\n        {\n          command: 'run',\n          args: extensionArgs[type].run,\n          help:\n            `Run a script (defined inside the ${type}'s package.json under the ` +\n            `“scripts” field inside the “appium” field) from an installed ${type}`,\n        },\n      ];\n\n      for (const {command, args, help} of parserSpecs) {\n        const parser = extSubParsers.add_parser(command, {help});\n\n        ArgParser._patchExit(parser);\n\n        for (const [flagsOrNames, opts] of args) {\n          // add_argument mutates params so make sure to send in copies instead\n          // @ts-ignore\n          parser.add_argument(...flagsOrNames, {...opts});\n        }\n      }\n    }\n  }\n}\n\n/**\n * Creates a {@link ArgParser} instance; finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {ArgParser}\n */\nfunction getParser (debug) {\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport { getParser, ArgParser };\n"],"mappings":"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"}

package/build/lib/cli/plugin-command.d.ts

@@ -1,22 +1,20 @@
-export default class PluginCommand extends ExtensionCommand<any> {
+/**
+ * @extends {ExtensionCommand<PluginType>}
+ */
+export default class PluginCommand extends ExtensionCommand<"plugin"> {
     /**
      *
-     * @param {PluginCommandOptions} opts
+     * @param {import('./extension-command').ExtensionCommandOptions<PluginType>} opts
      */
-    constructor({ config, json }: PluginCommandOptions);
-    knownExtensions: Readonly<{
-        readonly images: "@appium/images-plugin";
-        readonly 'execute-driver': "@appium/execute-driver-plugin";
-        readonly 'relaxed-caps': "@appium/relaxed-caps-plugin";
-    }>;
+    constructor({ config, json }: import('./extension-command').ExtensionCommandOptions<PluginType>);
     install({ plugin, installType, packageName }: {
         plugin: any;
         installType: any;
         packageName: any;
-    }): Promise<import("./extension-command").ExtRecord<any>>;
+    }): Promise<import("./extension-command").ExtRecord<"plugin">>;
     uninstall({ plugin }: {
         plugin: any;
-    }): Promise<import("./extension-command").ExtRecord<any>>;
+    }): Promise<import("./extension-command").ExtRecord<"plugin">>;
     update({ plugin, unsafe }: {
         plugin: any;
         unsafe: any;
@@ -29,11 +27,7 @@ export default class PluginCommand extends ExtensionCommand<any> {
         extName: any;
         extData: any;
     }): string;
-    validateExtensionFields(appiumPkgData: any): void;
 }
-export type PluginCommandOptions = {
-    config: import('../extension/extension-config').ExtensionConfig<import('../extension/manifest').PluginType>;
-    json: boolean;
-};
+export type PluginType = import('appium/types').PluginType;
 import ExtensionCommand from "./extension-command";
 //# sourceMappingURL=plugin-command.d.ts.map

package/build/lib/cli/plugin-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-command.d.ts","sourceRoot":"","sources":["../../../lib/cli/plugin-command.js"],"names":[],"mappings":"AAMA;IAEE;;;OAGG;IACH,8BAFW,oBAAoB,EAK9B;IADC;;;;OAAoC;IAGtC;;;;8DAEC;IAED;;8DAEC;IAED;;;qEAEC;IAED;;;yDAEC;IAED;;;eAEC;IAED,kDAUC;CAEF;;YAIa,OAAO,+BAA+B,EAAE,eAAe,CAAC,OAAO,uBAAuB,EAAE,UAAU,CAAC;UACnG,OAAO"}
+{"version":3,"file":"plugin-command.d.ts","sourceRoot":"","sources":["../../../lib/cli/plugin-command.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IACE;;;OAGG;IACH,8BAFW,OAAO,qBAAqB,EAAE,uBAAuB,CAAC,UAAU,CAAC,EAK3E;IAED;;;;mEAMC;IAED;;mEAEC;IAED;;;qEAEC;IAED;;;yDAEC;IAED;;;eAEC;CAyBF;yBAGY,OAAO,cAAc,EAAE,UAAU"}

package/build/lib/cli/plugin-command.js

@@ -35,7 +35,7 @@ class PluginCommand extends _extensionCommand.default {
     packageName
   }) {
     return await super._install({
-      ext: plugin,
+      installSpec: plugin,
       installType,
       packageName
     });
@@ -45,7 +45,7 @@ class PluginCommand extends _extensionCommand.default {
     plugin
   }) {
     return await super._uninstall({
-      ext: plugin
+      installSpec: plugin
     });
   }
 
@@ -54,7 +54,7 @@ class PluginCommand extends _extensionCommand.default {
     unsafe
   }) {
     return await super._update({
-      ext: plugin,
+      installSpec: plugin,
       unsafe
     });
   }
@@ -64,7 +64,7 @@ class PluginCommand extends _extensionCommand.default {
     scriptName
   }) {
     return await super._run({
-      ext: plugin,
+      installSpec: plugin,
       scriptName
     });
   }
@@ -76,15 +76,15 @@ class PluginCommand extends _extensionCommand.default {
     return `Plugin ${extName}@${extData.version} successfully installed`.green;
   }
 
-  validateExtensionFields(appiumPkgData) {
-    const missingFields = REQ_PLUGIN_FIELDS.reduce((acc, field) => appiumPkgData[field] ? acc : [...acc, field], []);
+  validateExtensionFields(pluginMetadata, installSpec) {
+    const missingFields = REQ_PLUGIN_FIELDS.reduce((acc, field) => pluginMetadata[field] ? acc : [...acc, field], []);
 
     if (!_lodash.default.isEmpty(missingFields)) {
-      throw new Error(`Installed plugin did not expose correct fields for compability ` + `with Appium. Missing fields: ${JSON.stringify(missingFields)}`);
+      throw new Error(`Installed plugin "${installSpec}" did not expose correct fields for compability ` + `with Appium. Missing fields: ${JSON.stringify(missingFields)}`);
     }
   }
 
 }
 
 exports.default = PluginCommand;
-//# 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/cli/utils.js

@@ -80,4 +80,4 @@ class RingBuffer {
 }
 
 exports.RingBuffer = RingBuffer;
-//# 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/config-file.js

@@ -133,4 +133,4 @@ function normalizeConfig(config) {
 
   return normalize(config);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/config-file.js"],"names":["yamlLoader","filepath","content","yaml","parse","rawConfig","Map","jsonLoader","set","JSON","loadConfigFile","lc","load","err","code","message","SyntaxError","searchConfigFile","search","formatErrors","errors","config","opts","length","TypeError","schemaId","json","format","readConfigFile","loaders","noExt","packageProp","result","isEmpty","pretty","configResult","_","reason","get","normalizeConfig","delete","schema","normalize","section","obj","isUndefined","mappedObj","mapKeys","__","prop","properties","appiumCliDest","camelCase","mapValues","value","property","nextSection","isSchemaTypeObject","Boolean"],"mappings":"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","sourcesContent":["\nimport betterAjvErrors from '@sidvind/better-ajv-errors';\nimport { lilconfig } from 'lilconfig';\nimport _ from 'lodash';\nimport yaml from 'yaml';\nimport { getSchema, validate } from './schema/schema';\n\n/**\n * lilconfig loader to handle `.yaml` files\n * @type {import('lilconfig').LoaderSync}\n */\nfunction yamlLoader (filepath, content) {\n  return yaml.parse(content);\n}\n\n/**\n * A cache of the raw config file (a JSON string) at a filepath.\n * This is used for better error reporting.\n * Note that config files needn't be JSON, but it helps if they are.\n * @type {Map<string,RawJson>}\n */\nconst rawConfig = new Map();\n\n/**\n * Custom JSON loader that caches the raw config file (for use with `better-ajv-errors`).\n * If it weren't for this cache, this would be unnecessary.\n * @type {import('lilconfig').LoaderSync}\n */\nfunction jsonLoader (filepath, content) {\n  rawConfig.set(filepath, content);\n  return JSON.parse(content);\n}\n\n/**\n * Loads a config file from an explicit path\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @param {string} filepath - Path to config file\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function loadConfigFile (lc, filepath) {\n  try {\n    // removing \"await\" will cause any rejection to _not_ be caught in this block!\n    return await lc.load(filepath);\n  } catch (/** @type {unknown} */err) {\n    if (/** @type {NodeJS.ErrnoException} */(err).code === 'ENOENT') {\n      /** @type {NodeJS.ErrnoException} */(err).message = `Config file not found at user-provided path: ${filepath}`;\n      throw err;\n    } else if (err instanceof SyntaxError) {\n      // generally invalid JSON\n      err.message = `Config file at user-provided path ${filepath} is invalid:\\n${err.message}`;\n      throw err;\n    }\n    throw err;\n  }\n}\n\n/**\n * Searches for a config file\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function searchConfigFile (lc) {\n  return await lc.search();\n}\n\n/**\n * Given an array of errors and the result of loading a config file, generate a\n * helpful string for the user.\n *\n * - If `opts` contains a `json` property, this should be the original JSON\n *   _string_ of the config file.  This is only applicable if the config file\n *   was in JSON format. If present, it will associate line numbers with errors.\n * - If `errors` happens to be empty, this will throw.\n * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.\n * @param {ReadConfigFileResult['config']|any} [config] -\n * Configuration & metadata\n * @param {FormatConfigErrorsOptions} [opts]\n * @throws {TypeError} If `errors` is empty\n * @returns {string}\n */\nexport function formatErrors (errors = [], config = {}, opts = {}) {\n  if (errors && !errors.length) {\n    throw new TypeError('Array of errors must be non-empty');\n  }\n  return betterAjvErrors(getSchema(opts.schemaId), config, errors, {\n    json: opts.json,\n    format: 'cli',\n  });\n}\n\n/**\n * Given an optional path, read a config file. Validates the config file.\n *\n * Call {@link validate} if you already have a config object.\n * @param {string} [filepath] - Path to config file, if we have one\n * @param {ReadConfigFileOptions} [opts] - Options\n * @public\n * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors\n */\nexport async function readConfigFile (filepath, opts = {}) {\n  const lc = lilconfig('appium', {\n    loaders: {\n      '.yaml': yamlLoader,\n      '.yml': yamlLoader,\n      '.json': jsonLoader,\n      noExt: jsonLoader,\n    },\n    packageProp: 'appiumConfig'\n  });\n\n  const result = filepath\n    ? await loadConfigFile(lc, filepath)\n    : await searchConfigFile(lc);\n\n  if (result?.filepath && !result?.isEmpty) {\n    const {pretty = true} = opts;\n    try {\n      let configResult;\n      const errors = validate(result.config);\n      if (_.isEmpty(errors)) {\n        configResult = {...result, errors};\n      } else {\n        const reason = formatErrors(errors, result.config, {\n          json: rawConfig.get(result.filepath),\n          pretty,\n        });\n        configResult = reason\n          ? {...result, errors, reason}\n          : {...result, errors};\n      }\n\n      // normalize (to camel case) all top-level property names of the config file\n      configResult.config = normalizeConfig(\n        /** @type {AppiumConfig} */ (configResult.config),\n      );\n\n      return configResult;\n    } finally {\n      // clean up the raw config file cache, which is only kept to better report errors.\n      rawConfig.delete(result.filepath);\n    }\n  }\n  return result ?? {};\n}\n\n/**\n * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case\n * @param {AppiumConfig} config - Configuration object\n * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).\n */\nexport function normalizeConfig (config) {\n  const schema = getSchema();\n  /**\n   * @param {AppiumConfig} config\n   * @param {string} [section] - Keypath (lodash `_.get()` style) to section of config. If omitted, assume root Appium config schema\n   * @todo Rewrite as a loop\n   * @returns Normalized section of config\n   */\n  const normalize = (config, section) => {\n    const obj = _.isUndefined(section) ? config : _.get(config, section, config);\n\n    const mappedObj = _.mapKeys(obj, (__, prop) =>\n      schema.properties[prop]?.appiumCliDest ?? _.camelCase(prop),\n    );\n\n    return _.mapValues(mappedObj, (value, property) => {\n      const nextSection = section ? `${section}.${property}` : property;\n      return isSchemaTypeObject(value) ? normalize(config, nextSection) : value;\n    });\n  };\n\n  /**\n   * Returns `true` if the schema prop references an object, or if it's an object itself\n   * @param {import('ajv').SchemaObject|object} schema - Referencing schema object\n   */\n  const isSchemaTypeObject = (schema) => Boolean(schema.properties);\n\n  return normalize(config);\n}\n\n/**\n * Result of calling {@link readConfigFile}.\n * @typedef ReadConfigFileResult\n * @property {import('ajv').ErrorObject[]} [errors] - Validation errors\n * @property {string} [filepath] - The path to the config file, if found\n * @property {boolean} [isEmpty] - If `true`, the config file exists but is empty\n * @property {NormalizedAppiumConfig} [config] - The parsed configuration\n * @property {string|import('@sidvind/better-ajv-errors').IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.\n */\n\n/**\n * Options for {@link readConfigFile}.\n * @typedef ReadConfigFileOptions\n * @property {boolean} [pretty=true] If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult}. The value of `reason` is then suitable for machine-reading.\n */\n\n/**\n * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.\n * @typedef {ReturnType<import('lilconfig')[\"lilconfig\"]>} LilconfigAsyncSearcher\n */\n\n/**\n * The contents of an Appium config file. Generated from schema\n * @typedef {import('@appium/types').AppiumConfig} AppiumConfig\n */\n\n/**\n * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}\n * @typedef {import('@appium/types').NormalizedAppiumConfig} NormalizedAppiumConfig\n */\n\n/**\n * The string should be a raw JSON string.\n * @typedef {string} RawJson\n */\n\n/**\n * Options for {@link formatErrors}.\n * @typedef FormatConfigErrorsOptions\n * @property {import('./config-file').RawJson} [json] - Raw JSON config (as string)\n * @property {boolean} [pretty=true] - Whether to format errors as a CLI-friendly string\n * @property {string}  [schemaId] - Specific ID of a prop; otherwise entire schema\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["yamlLoader","filepath","content","yaml","parse","rawConfig","Map","jsonLoader","set","JSON","loadConfigFile","lc","load","err","code","message","SyntaxError","searchConfigFile","search","formatErrors","errors","config","opts","length","TypeError","schemaId","json","format","readConfigFile","loaders","noExt","packageProp","result","isEmpty","pretty","configResult","_","reason","get","normalizeConfig","delete","schema","normalize","section","obj","isUndefined","mappedObj","mapKeys","__","prop","properties","appiumCliDest","camelCase","mapValues","value","property","nextSection","isSchemaTypeObject","Boolean"],"sources":["../../lib/config-file.js"],"sourcesContent":["\nimport betterAjvErrors from '@sidvind/better-ajv-errors';\nimport { lilconfig } from 'lilconfig';\nimport _ from 'lodash';\nimport yaml from 'yaml';\nimport { getSchema, validate } from './schema/schema';\n\n/**\n * lilconfig loader to handle `.yaml` files\n * @type {import('lilconfig').LoaderSync}\n */\nfunction yamlLoader (filepath, content) {\n  return yaml.parse(content);\n}\n\n/**\n * A cache of the raw config file (a JSON string) at a filepath.\n * This is used for better error reporting.\n * Note that config files needn't be JSON, but it helps if they are.\n * @type {Map<string,RawJson>}\n */\nconst rawConfig = new Map();\n\n/**\n * Custom JSON loader that caches the raw config file (for use with `better-ajv-errors`).\n * If it weren't for this cache, this would be unnecessary.\n * @type {import('lilconfig').LoaderSync}\n */\nfunction jsonLoader (filepath, content) {\n  rawConfig.set(filepath, content);\n  return JSON.parse(content);\n}\n\n/**\n * Loads a config file from an explicit path\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @param {string} filepath - Path to config file\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function loadConfigFile (lc, filepath) {\n  try {\n    // removing \"await\" will cause any rejection to _not_ be caught in this block!\n    return await lc.load(filepath);\n  } catch (/** @type {unknown} */err) {\n    if (/** @type {NodeJS.ErrnoException} */(err).code === 'ENOENT') {\n      /** @type {NodeJS.ErrnoException} */(err).message = `Config file not found at user-provided path: ${filepath}`;\n      throw err;\n    } else if (err instanceof SyntaxError) {\n      // generally invalid JSON\n      err.message = `Config file at user-provided path ${filepath} is invalid:\\n${err.message}`;\n      throw err;\n    }\n    throw err;\n  }\n}\n\n/**\n * Searches for a config file\n * @param {LilconfigAsyncSearcher} lc - lilconfig instance\n * @returns {Promise<import('lilconfig').LilconfigResult>}\n */\nasync function searchConfigFile (lc) {\n  return await lc.search();\n}\n\n/**\n * Given an array of errors and the result of loading a config file, generate a\n * helpful string for the user.\n *\n * - If `opts` contains a `json` property, this should be the original JSON\n *   _string_ of the config file.  This is only applicable if the config file\n *   was in JSON format. If present, it will associate line numbers with errors.\n * - If `errors` happens to be empty, this will throw.\n * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.\n * @param {ReadConfigFileResult['config']|any} [config] -\n * Configuration & metadata\n * @param {FormatConfigErrorsOptions} [opts]\n * @throws {TypeError} If `errors` is empty\n * @returns {string}\n */\nexport function formatErrors (errors = [], config = {}, opts = {}) {\n  if (errors && !errors.length) {\n    throw new TypeError('Array of errors must be non-empty');\n  }\n  return betterAjvErrors(getSchema(opts.schemaId), config, errors, {\n    json: opts.json,\n    format: 'cli',\n  });\n}\n\n/**\n * Given an optional path, read a config file. Validates the config file.\n *\n * Call {@link validate} if you already have a config object.\n * @param {string} [filepath] - Path to config file, if we have one\n * @param {ReadConfigFileOptions} [opts] - Options\n * @public\n * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors\n */\nexport async function readConfigFile (filepath, opts = {}) {\n  const lc = lilconfig('appium', {\n    loaders: {\n      '.yaml': yamlLoader,\n      '.yml': yamlLoader,\n      '.json': jsonLoader,\n      noExt: jsonLoader,\n    },\n    packageProp: 'appiumConfig'\n  });\n\n  const result = filepath\n    ? await loadConfigFile(lc, filepath)\n    : await searchConfigFile(lc);\n\n  if (result?.filepath && !result?.isEmpty) {\n    const {pretty = true} = opts;\n    try {\n      let configResult;\n      const errors = validate(result.config);\n      if (_.isEmpty(errors)) {\n        configResult = {...result, errors};\n      } else {\n        const reason = formatErrors(errors, result.config, {\n          json: rawConfig.get(result.filepath),\n          pretty,\n        });\n        configResult = reason\n          ? {...result, errors, reason}\n          : {...result, errors};\n      }\n\n      // normalize (to camel case) all top-level property names of the config file\n      configResult.config = normalizeConfig(\n        /** @type {AppiumConfig} */ (configResult.config),\n      );\n\n      return configResult;\n    } finally {\n      // clean up the raw config file cache, which is only kept to better report errors.\n      rawConfig.delete(result.filepath);\n    }\n  }\n  return result ?? {};\n}\n\n/**\n * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case\n * @param {AppiumConfig} config - Configuration object\n * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).\n */\nexport function normalizeConfig (config) {\n  const schema = getSchema();\n  /**\n   * @param {AppiumConfig} config\n   * @param {string} [section] - Keypath (lodash `_.get()` style) to section of config. If omitted, assume root Appium config schema\n   * @todo Rewrite as a loop\n   * @returns Normalized section of config\n   */\n  const normalize = (config, section) => {\n    const obj = _.isUndefined(section) ? config : _.get(config, section, config);\n\n    const mappedObj = _.mapKeys(obj, (__, prop) =>\n      schema.properties[prop]?.appiumCliDest ?? _.camelCase(prop),\n    );\n\n    return _.mapValues(mappedObj, (value, property) => {\n      const nextSection = section ? `${section}.${property}` : property;\n      return isSchemaTypeObject(value) ? normalize(config, nextSection) : value;\n    });\n  };\n\n  /**\n   * Returns `true` if the schema prop references an object, or if it's an object itself\n   * @param {import('ajv').SchemaObject|object} schema - Referencing schema object\n   */\n  const isSchemaTypeObject = (schema) => Boolean(schema.properties);\n\n  return normalize(config);\n}\n\n/**\n * Result of calling {@link readConfigFile}.\n * @typedef ReadConfigFileResult\n * @property {import('ajv').ErrorObject[]} [errors] - Validation errors\n * @property {string} [filepath] - The path to the config file, if found\n * @property {boolean} [isEmpty] - If `true`, the config file exists but is empty\n * @property {NormalizedAppiumConfig} [config] - The parsed configuration\n * @property {string|import('@sidvind/better-ajv-errors').IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.\n */\n\n/**\n * Options for {@link readConfigFile}.\n * @typedef ReadConfigFileOptions\n * @property {boolean} [pretty=true] If `false`, do not use color and fancy formatting in the `reason` property of the {@link ReadConfigFileResult}. The value of `reason` is then suitable for machine-reading.\n */\n\n/**\n * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.\n * @typedef {ReturnType<import('lilconfig')[\"lilconfig\"]>} LilconfigAsyncSearcher\n */\n\n/**\n * The contents of an Appium config file. Generated from schema\n * @typedef {import('@appium/types').AppiumConfig} AppiumConfig\n */\n\n/**\n * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}\n * @typedef {import('@appium/types').NormalizedAppiumConfig} NormalizedAppiumConfig\n */\n\n/**\n * The string should be a raw JSON string.\n * @typedef {string} RawJson\n */\n\n/**\n * Options for {@link formatErrors}.\n * @typedef FormatConfigErrorsOptions\n * @property {import('./config-file').RawJson} [json] - Raw JSON config (as string)\n * @property {boolean} [pretty=true] - Whether to format errors as a CLI-friendly string\n * @property {string}  [schemaId] - Specific ID of a prop; otherwise entire schema\n */\n"],"mappings":"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"}

package/build/lib/config.d.ts

@@ -1,4 +1,5 @@
-export type ParsedArgs = import('../types/cli').ParsedArgs;
+export type ParsedArgs = import('../types').ParsedArgs;
+export type Args = import('../types').Args;
 export type ArgSpec = import("./schema/arg-spec").ArgSpec<any>;
 /**
  * Mutable object containing Appium build information. By default it
@@ -17,10 +18,10 @@ export function warnNodeDeprecations(): void;
 export function validateTmpDir(tmpDir: string): Promise<void>;
 /**
  * Returns k/v pairs of server arguments which are _not_ the defaults.
- * @param {ParsedArgs} parsedArgs
- * @returns {Partial<ParsedArgs>}
+ * @param {Args} parsedArgs
+ * @returns {Args}
  */
-export function getNonDefaultServerArgs(parsedArgs: ParsedArgs): Partial<ParsedArgs>;
+export function getNonDefaultServerArgs(parsedArgs: Args): Args;
 export function getGitRev(useGithubApiFallback?: boolean): Promise<any>;
 export const APPIUM_VER: any;
 export function updateBuildInfo(useGithubApiFallback?: boolean): Promise<void>;

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../lib/config.js"],"names":[],"mappings":"yBAoTa,OAAO,cAAc,EAAE,UAAU;;AAzL9C;;;;;;GAMG;AACH,gCAFa,OAAO,cAAc,EAAE,SAAS,CAI5C;AAED,oCAKC;AAgBD,+CAGC;AAjBD,6CAYC;AAsID;;GAEG;AACH,uCAFW,MAAM,iBAShB;AAzID;;;;GAIG;AACH,oDAHW,UAAU,GACR,QAAQ,UAAU,CAAC,CA8E/B;AA5LD,wEA8BC;AAvED,6BAAsC;AAkBtC,+EAUC;AAwND;;;;;;;;;;GAUG;AACH,0DALW,QAAQ,UAAU,CAAC,gBACnB,OAAO,eAAe,EAAE,oBAAoB,YAC5C,QAAQ,UAAU,CAAC,cACnB,UAAU,QAoBpB;AAcD,6BAAuC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../lib/config.js"],"names":[],"mappings":"yBAoTa,OAAO,UAAU,EAAE,UAAU;mBAC7B,OAAO,UAAU,EAAE,IAAI;;AA1LpC;;;;;;GAMG;AACH,gCAFa,OAAO,cAAc,EAAE,SAAS,CAI5C;AAED,oCAKC;AAgBD,+CAGC;AAjBD,6CAYC;AAsID;;GAEG;AACH,uCAFW,MAAM,iBAShB;AAzID;;;;GAIG;AACH,oDAHW,IAAI,GACF,IAAI,CA8EhB;AA5LD,wEA8BC;AAvED,6BAAsC;AAkBtC,+EAUC;AAwND;;;;;;;;;;GAUG;AACH,0DALW,QAAQ,UAAU,CAAC,gBACnB,OAAO,eAAe,EAAE,oBAAoB,YAC5C,QAAQ,UAAU,CAAC,cACnB,UAAU,QAoBpB;AAcD,6BAAuC"}

package/build/lib/config.js

@@ -252,4 +252,4 @@ async function validateTmpDir(tmpDir) {
 const rootDir = _support.fs.findRoot(__dirname);
 
 exports.rootDir = rootDir;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/config.js"],"names":["npmPackage","fs","readPackageJsonFrom","__dirname","APPIUM_VER","version","MIN_NODE_VERSION","engines","node","GIT_META_ROOT","GIT_BINARY","system","isWindows","GITHUB_API","BUILD_INFO","getNodeVersion","semver","coerce","process","updateBuildInfo","useGithubApiFallback","sha","getGitRev","built","getGitTimestamp","findGitRoot","cwd","rootDir","type","gitRoot","stdout","trim","ign","resBodyObj","axios","get","headers","data","_","isArray","name","commit","commitSha","committer","date","author","getBuildInfo","checkNodeOk","satisfies","logger","errorAndThrow","warnNodeDeprecations","showBuildInfo","console","log","JSON","stringify","getNonDefaultServerArgs","parsedArgs","flatten","args","argSpecs","flattened","reduce","values","acc","argSpec","has","dest","value","typesDiffer","defaultsFromSchema","defaultValueIsArray","argsValueIsArray","arraysDiffer","gt","size","difference","valuesDiffer","defaultIsDefined","isUndefined","argValueNotArrayOrArraysDiffer","overSome","negate","defaultValueNotArrayAndValuesDiffer","overEvery","isNotDefault","pickBy","__","key","set","compactConfig","partial","omitBy","isObject","isEmpty","showConfig","nonDefaultPreConfigParsedArgs","configResult","defaults","dir","config","filepath","validateTmpDir","tmpDir","mkdirp","e","Error","findRoot"],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport _ from 'lodash';\nimport { system, fs } from '@appium/support';\nimport axios from 'axios';\nimport { exec } from 'teen_process';\nimport logger from './logger';\nimport semver from 'semver';\nimport findUp from 'find-up';\nimport { getDefaultsForSchema, getAllArgSpecs } from './schema/schema';\n\nconst npmPackage = fs.readPackageJsonFrom(__dirname);\n\nconst APPIUM_VER = npmPackage.version;\nconst MIN_NODE_VERSION = npmPackage.engines.node;\n\nconst GIT_META_ROOT = '.git';\nconst GIT_BINARY = `git${system.isWindows() ? '.exe' : ''}`;\nconst GITHUB_API = 'https://api.github.com/repos/appium/appium';\n\n/**\n * @type {import('../types/cli').BuildInfo}\n */\nconst BUILD_INFO = {\n  version: APPIUM_VER,\n};\n\nfunction getNodeVersion () {\n  return /** @type {import('semver').SemVer} */(semver.coerce(process.version));\n}\n\nasync function updateBuildInfo (useGithubApiFallback = false) {\n  const sha = await getGitRev(useGithubApiFallback);\n  if (!sha) {\n    return;\n  }\n  BUILD_INFO['git-sha'] = sha;\n  const built = await getGitTimestamp(sha, useGithubApiFallback);\n  if (built) {\n    BUILD_INFO.built = built;\n  }\n}\n\n/**\n * Finds the Git metadata dir (see `GIT_META_ROOT`)\n *\n * This is needed because Appium cannot assume `package.json` and `.git` are in the same\n * directory.  Monorepos, see?\n * @returns {Promise<string|undefined>} Path to dir or `undefined` if not found\n */\nasync function findGitRoot () {\n  return await findUp(GIT_META_ROOT, {cwd: rootDir, type: 'directory'});\n}\n\nasync function getGitRev (useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['rev-parse', 'HEAD'], {\n        cwd: gitRoot\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    const resBodyObj = (await axios.get(`${GITHUB_API}/tags`, {\n      headers: {\n        'User-Agent': `Appium ${APPIUM_VER}`\n      }\n    })).data;\n    if (_.isArray(resBodyObj)) {\n      for (const {name, commit} of resBodyObj) {\n        if (name === `v${APPIUM_VER}` && commit && commit.sha) {\n          return commit.sha;\n        }\n      }\n    }\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * @param {string} commitSha\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitTimestamp (commitSha, useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['show', '-s', '--format=%ci', commitSha], {\n        cwd: gitRoot\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    const resBodyObj = (await axios.get(`${GITHUB_API}/commits/${commitSha}`, {\n      headers: {\n        'User-Agent': `Appium ${APPIUM_VER}`\n      }\n    })).data;\n    if (resBodyObj && resBodyObj.commit) {\n      if (resBodyObj.commit.committer && resBodyObj.commit.committer.date) {\n        return resBodyObj.commit.committer.date;\n      }\n      if (resBodyObj.commit.author && resBodyObj.commit.author.date) {\n        return resBodyObj.commit.author.date;\n      }\n    }\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * Mutable object containing Appium build information. By default it\n * only contains the Appium version, but is updated with the build timestamp\n * and git commit hash asynchronously as soon as `updateBuildInfo` is called\n * and succeeds.\n * @returns {import('../types/cli').BuildInfo}\n */\nfunction getBuildInfo () {\n  return BUILD_INFO;\n}\n\nfunction checkNodeOk () {\n  const version = getNodeVersion();\n  if (!semver.satisfies(version, MIN_NODE_VERSION)) {\n    logger.errorAndThrow(`Node version must be ${MIN_NODE_VERSION}. Currently ${version.version}`);\n  }\n}\n\nfunction warnNodeDeprecations () {\n  /**\n   * Uncomment this section to get node version deprecation warnings\n   * Also add test cases to config-specs.js to cover the cases added\n   **/\n\n  // const version = getNodeVersion();\n  // if (version.major < 8) {\n  //   logger.warn(`Appium support for versions of node < ${version.major} has been ` +\n  //               'deprecated and will be removed in a future version. Please ' +\n  //               'upgrade!');\n  // }\n}\n\nasync function showBuildInfo () {\n  await updateBuildInfo(true);\n  console.log(JSON.stringify(getBuildInfo())); // eslint-disable-line no-console\n}\n\n/**\n * Returns k/v pairs of server arguments which are _not_ the defaults.\n * @param {ParsedArgs} parsedArgs\n * @returns {Partial<ParsedArgs>}\n */\nfunction getNonDefaultServerArgs (parsedArgs) {\n  /**\n   * Flattens parsed args into a single level object for comparison with\n   * flattened defaults across server args and extension args.\n   * @param {ParsedArgs} args\n   * @returns {Record<string, { value: any, argSpec: ArgSpec }>}\n   */\n  const flatten = (args) => {\n    const argSpecs = getAllArgSpecs();\n    const flattened = _.reduce([...argSpecs.values()], (acc, argSpec) => {\n      if (_.has(args, argSpec.dest)) {\n        acc[argSpec.dest] = {value: _.get(args, argSpec.dest), argSpec};\n      }\n      return acc;\n    }, /** @type {Record<string, { value: any, argSpec: ArgSpec }>} */({}));\n\n    return flattened;\n  };\n\n  const args = flatten(parsedArgs);\n\n  // hopefully these function names are descriptive enough\n  const typesDiffer = /** @param {string} dest */(dest) => typeof args[dest].value !== typeof defaultsFromSchema[dest];\n\n  const defaultValueIsArray = /** @param {string} dest */(dest) => _.isArray(defaultsFromSchema[dest]);\n\n  const argsValueIsArray = /** @param {string} dest */(dest) => _.isArray(args[dest].value);\n\n  const arraysDiffer = /** @param {string} dest */(dest) => _.gt(_.size(_.difference(args[dest].value, defaultsFromSchema[dest])), 0);\n\n  const valuesDiffer = /** @param {string} dest */(dest) => args[dest].value !== defaultsFromSchema[dest];\n\n  const defaultIsDefined = /** @param {string} dest */(dest) => !_.isUndefined(defaultsFromSchema[dest]);\n\n  // note that `_.overEvery` is like an \"AND\", and `_.overSome` is like an \"OR\"\n\n  const argValueNotArrayOrArraysDiffer = _.overSome([\n    _.negate(argsValueIsArray),\n    arraysDiffer\n  ]);\n\n  const defaultValueNotArrayAndValuesDiffer = _.overEvery([\n    _.negate(defaultValueIsArray), valuesDiffer\n  ]);\n\n  /**\n   * This used to be a hideous conditional, but it's broken up into a hideous function instead.\n   * hopefully this makes things a little more understandable.\n   * - checks if the default value is defined\n   * - if so, and the default is not an array:\n   *   - ensures the types are the same\n   *   - ensures the values are equal\n   * - if so, and the default is an array:\n   *   - ensures the args value is an array\n   *   - ensures the args values do not differ from the default values\n   * @type {(dest: string) => boolean}\n   */\n  const isNotDefault = _.overEvery([\n    defaultIsDefined,\n    _.overSome([\n      typesDiffer,\n      _.overEvery([\n        defaultValueIsArray,\n        argValueNotArrayOrArraysDiffer\n      ]),\n      defaultValueNotArrayAndValuesDiffer\n    ])\n  ]);\n\n  const defaultsFromSchema = getDefaultsForSchema(true);\n\n  return _.reduce(\n    _.pickBy(args, (__, key) => isNotDefault(key)),\n    // explodes the flattened object back into nested one\n    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value), /** @type {Partial<ParsedArgs>} */({})\n  );\n}\n\n/**\n * Compacts an object for {@link showConfig}:\n * 1. Removes `subcommand` key/value\n * 2. Removes `undefined` values\n * 3. Removes empty objects (but not `false` values)\n * Does not operate recursively.\n */\nconst compactConfig = _.partial(\n  _.omitBy,\n  _,\n  (value, key) => key === 'subcommand' || _.isUndefined(value) || (_.isObject(value) && _.isEmpty(value))\n);\n\n/**\n * Shows a breakdown of the current config after CLI params, config file loaded & defaults applied.\n *\n * The actual shape of `preConfigParsedArgs` and `defaults` does not matter for the purposes of this function,\n * but it's intended to be called with values of type {@link ParsedArgs} and `DefaultValues<true>`, respectively.\n *\n * @param {Partial<ParsedArgs>} nonDefaultPreConfigParsedArgs - Parsed CLI args (or param to `init()`) before config & defaults applied\n * @param {import('./config-file').ReadConfigFileResult} configResult - Result of attempting to load a config file.  _Must_ be normalized\n * @param {Partial<ParsedArgs>} defaults - Configuration defaults from schemas\n * @param {ParsedArgs} parsedArgs - Entire parsed args object\n */\nfunction showConfig (nonDefaultPreConfigParsedArgs, configResult, defaults, parsedArgs) {\n  console.log('Appium Configuration\\n');\n  console.log('from defaults:\\n');\n  console.dir(compactConfig(defaults));\n  if (configResult.config) {\n    console.log(`\\nfrom config file at ${configResult.filepath}:\\n`);\n    console.dir(compactConfig(configResult.config));\n  } else {\n    console.log(`\\n(no configuration file loaded)`);\n  }\n  if (_.isEmpty(nonDefaultPreConfigParsedArgs)) {\n    console.log(`\\n(no CLI parameters provided)`);\n  } else {\n    console.log('\\nvia CLI or function call:\\n');\n    console.dir(compactConfig(nonDefaultPreConfigParsedArgs));\n  }\n  console.log('\\nfinal configuration:\\n');\n  console.dir(compactConfig(parsedArgs));\n}\n\n/**\n * @param {string} tmpDir\n */\nasync function validateTmpDir (tmpDir) {\n  try {\n    await fs.mkdirp(tmpDir);\n  } catch (e) {\n    throw new Error(`We could not ensure that the temp dir you specified ` +\n                    `(${tmpDir}) exists. Please make sure it's writeable.`);\n  }\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\nexport {\n  getBuildInfo, checkNodeOk, showBuildInfo,\n  warnNodeDeprecations, validateTmpDir, getNonDefaultServerArgs,\n  getGitRev, APPIUM_VER, updateBuildInfo, showConfig, rootDir\n};\n\n/**\n * @typedef {import('../types/cli').ParsedArgs} ParsedArgs\n * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec\n */\n\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["npmPackage","fs","readPackageJsonFrom","__dirname","APPIUM_VER","version","MIN_NODE_VERSION","engines","node","GIT_META_ROOT","GIT_BINARY","system","isWindows","GITHUB_API","BUILD_INFO","getNodeVersion","semver","coerce","process","updateBuildInfo","useGithubApiFallback","sha","getGitRev","built","getGitTimestamp","findGitRoot","cwd","rootDir","type","gitRoot","stdout","trim","ign","resBodyObj","axios","get","headers","data","_","isArray","name","commit","commitSha","committer","date","author","getBuildInfo","checkNodeOk","satisfies","logger","errorAndThrow","warnNodeDeprecations","showBuildInfo","console","log","JSON","stringify","getNonDefaultServerArgs","parsedArgs","flatten","args","argSpecs","flattened","reduce","values","acc","argSpec","has","dest","value","typesDiffer","defaultsFromSchema","defaultValueIsArray","argsValueIsArray","arraysDiffer","gt","size","difference","valuesDiffer","defaultIsDefined","isUndefined","argValueNotArrayOrArraysDiffer","overSome","negate","defaultValueNotArrayAndValuesDiffer","overEvery","isNotDefault","pickBy","__","key","set","compactConfig","partial","omitBy","isObject","isEmpty","showConfig","nonDefaultPreConfigParsedArgs","configResult","defaults","dir","config","filepath","validateTmpDir","tmpDir","mkdirp","e","Error","findRoot"],"sources":["../../lib/config.js"],"sourcesContent":["/* eslint-disable no-console */\nimport _ from 'lodash';\nimport { system, fs } from '@appium/support';\nimport axios from 'axios';\nimport { exec } from 'teen_process';\nimport logger from './logger';\nimport semver from 'semver';\nimport findUp from 'find-up';\nimport { getDefaultsForSchema, getAllArgSpecs } from './schema/schema';\n\nconst npmPackage = fs.readPackageJsonFrom(__dirname);\n\nconst APPIUM_VER = npmPackage.version;\nconst MIN_NODE_VERSION = npmPackage.engines.node;\n\nconst GIT_META_ROOT = '.git';\nconst GIT_BINARY = `git${system.isWindows() ? '.exe' : ''}`;\nconst GITHUB_API = 'https://api.github.com/repos/appium/appium';\n\n/**\n * @type {import('../types/cli').BuildInfo}\n */\nconst BUILD_INFO = {\n  version: APPIUM_VER,\n};\n\nfunction getNodeVersion () {\n  return /** @type {import('semver').SemVer} */(semver.coerce(process.version));\n}\n\nasync function updateBuildInfo (useGithubApiFallback = false) {\n  const sha = await getGitRev(useGithubApiFallback);\n  if (!sha) {\n    return;\n  }\n  BUILD_INFO['git-sha'] = sha;\n  const built = await getGitTimestamp(sha, useGithubApiFallback);\n  if (built) {\n    BUILD_INFO.built = built;\n  }\n}\n\n/**\n * Finds the Git metadata dir (see `GIT_META_ROOT`)\n *\n * This is needed because Appium cannot assume `package.json` and `.git` are in the same\n * directory.  Monorepos, see?\n * @returns {Promise<string|undefined>} Path to dir or `undefined` if not found\n */\nasync function findGitRoot () {\n  return await findUp(GIT_META_ROOT, {cwd: rootDir, type: 'directory'});\n}\n\nasync function getGitRev (useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['rev-parse', 'HEAD'], {\n        cwd: gitRoot\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    const resBodyObj = (await axios.get(`${GITHUB_API}/tags`, {\n      headers: {\n        'User-Agent': `Appium ${APPIUM_VER}`\n      }\n    })).data;\n    if (_.isArray(resBodyObj)) {\n      for (const {name, commit} of resBodyObj) {\n        if (name === `v${APPIUM_VER}` && commit && commit.sha) {\n          return commit.sha;\n        }\n      }\n    }\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * @param {string} commitSha\n * @param {boolean} [useGithubApiFallback]\n * @returns {Promise<string?>}\n */\nasync function getGitTimestamp (commitSha, useGithubApiFallback = false) {\n  const gitRoot = await findGitRoot();\n  if (gitRoot) {\n    try {\n      const {stdout} = await exec(GIT_BINARY, ['show', '-s', '--format=%ci', commitSha], {\n        cwd: gitRoot\n      });\n      return stdout.trim();\n    } catch (ign) {}\n  }\n\n  if (!useGithubApiFallback) {\n    return null;\n  }\n\n  try {\n    const resBodyObj = (await axios.get(`${GITHUB_API}/commits/${commitSha}`, {\n      headers: {\n        'User-Agent': `Appium ${APPIUM_VER}`\n      }\n    })).data;\n    if (resBodyObj && resBodyObj.commit) {\n      if (resBodyObj.commit.committer && resBodyObj.commit.committer.date) {\n        return resBodyObj.commit.committer.date;\n      }\n      if (resBodyObj.commit.author && resBodyObj.commit.author.date) {\n        return resBodyObj.commit.author.date;\n      }\n    }\n  } catch (ign) {}\n  return null;\n}\n\n/**\n * Mutable object containing Appium build information. By default it\n * only contains the Appium version, but is updated with the build timestamp\n * and git commit hash asynchronously as soon as `updateBuildInfo` is called\n * and succeeds.\n * @returns {import('../types/cli').BuildInfo}\n */\nfunction getBuildInfo () {\n  return BUILD_INFO;\n}\n\nfunction checkNodeOk () {\n  const version = getNodeVersion();\n  if (!semver.satisfies(version, MIN_NODE_VERSION)) {\n    logger.errorAndThrow(`Node version must be ${MIN_NODE_VERSION}. Currently ${version.version}`);\n  }\n}\n\nfunction warnNodeDeprecations () {\n  /**\n   * Uncomment this section to get node version deprecation warnings\n   * Also add test cases to config-specs.js to cover the cases added\n   **/\n\n  // const version = getNodeVersion();\n  // if (version.major < 8) {\n  //   logger.warn(`Appium support for versions of node < ${version.major} has been ` +\n  //               'deprecated and will be removed in a future version. Please ' +\n  //               'upgrade!');\n  // }\n}\n\nasync function showBuildInfo () {\n  await updateBuildInfo(true);\n  console.log(JSON.stringify(getBuildInfo())); // eslint-disable-line no-console\n}\n\n/**\n * Returns k/v pairs of server arguments which are _not_ the defaults.\n * @param {Args} parsedArgs\n * @returns {Args}\n */\nfunction getNonDefaultServerArgs (parsedArgs) {\n  /**\n   * Flattens parsed args into a single level object for comparison with\n   * flattened defaults across server args and extension args.\n   * @param {Args} args\n   * @returns {Record<string, { value: any, argSpec: ArgSpec }>}\n   */\n  const flatten = (args) => {\n    const argSpecs = getAllArgSpecs();\n    const flattened = _.reduce([...argSpecs.values()], (acc, argSpec) => {\n      if (_.has(args, argSpec.dest)) {\n        acc[argSpec.dest] = {value: _.get(args, argSpec.dest), argSpec};\n      }\n      return acc;\n    }, /** @type {Record<string, { value: any, argSpec: ArgSpec }>} */({}));\n\n    return flattened;\n  };\n\n  const args = flatten(parsedArgs);\n\n  // hopefully these function names are descriptive enough\n  const typesDiffer = /** @param {string} dest */(dest) => typeof args[dest].value !== typeof defaultsFromSchema[dest];\n\n  const defaultValueIsArray = /** @param {string} dest */(dest) => _.isArray(defaultsFromSchema[dest]);\n\n  const argsValueIsArray = /** @param {string} dest */(dest) => _.isArray(args[dest].value);\n\n  const arraysDiffer = /** @param {string} dest */(dest) => _.gt(_.size(_.difference(args[dest].value, defaultsFromSchema[dest])), 0);\n\n  const valuesDiffer = /** @param {string} dest */(dest) => args[dest].value !== defaultsFromSchema[dest];\n\n  const defaultIsDefined = /** @param {string} dest */(dest) => !_.isUndefined(defaultsFromSchema[dest]);\n\n  // note that `_.overEvery` is like an \"AND\", and `_.overSome` is like an \"OR\"\n\n  const argValueNotArrayOrArraysDiffer = _.overSome([\n    _.negate(argsValueIsArray),\n    arraysDiffer\n  ]);\n\n  const defaultValueNotArrayAndValuesDiffer = _.overEvery([\n    _.negate(defaultValueIsArray), valuesDiffer\n  ]);\n\n  /**\n   * This used to be a hideous conditional, but it's broken up into a hideous function instead.\n   * hopefully this makes things a little more understandable.\n   * - checks if the default value is defined\n   * - if so, and the default is not an array:\n   *   - ensures the types are the same\n   *   - ensures the values are equal\n   * - if so, and the default is an array:\n   *   - ensures the args value is an array\n   *   - ensures the args values do not differ from the default values\n   * @type {(dest: string) => boolean}\n   */\n  const isNotDefault = _.overEvery([\n    defaultIsDefined,\n    _.overSome([\n      typesDiffer,\n      _.overEvery([\n        defaultValueIsArray,\n        argValueNotArrayOrArraysDiffer\n      ]),\n      defaultValueNotArrayAndValuesDiffer\n    ])\n  ]);\n\n  const defaultsFromSchema = getDefaultsForSchema(true);\n\n  return _.reduce(\n    _.pickBy(args, (__, key) => isNotDefault(key)),\n    // explodes the flattened object back into nested one\n    (acc, {value, argSpec}) => _.set(acc, argSpec.dest, value), /** @type {Args} */({})\n  );\n}\n\n/**\n * Compacts an object for {@link showConfig}:\n * 1. Removes `subcommand` key/value\n * 2. Removes `undefined` values\n * 3. Removes empty objects (but not `false` values)\n * Does not operate recursively.\n */\nconst compactConfig = _.partial(\n  _.omitBy,\n  _,\n  (value, key) => key === 'subcommand' || _.isUndefined(value) || (_.isObject(value) && _.isEmpty(value))\n);\n\n/**\n * Shows a breakdown of the current config after CLI params, config file loaded & defaults applied.\n *\n * The actual shape of `preConfigParsedArgs` and `defaults` does not matter for the purposes of this function,\n * but it's intended to be called with values of type {@link ParsedArgs} and `DefaultValues<true>`, respectively.\n *\n * @param {Partial<ParsedArgs>} nonDefaultPreConfigParsedArgs - Parsed CLI args (or param to `init()`) before config & defaults applied\n * @param {import('./config-file').ReadConfigFileResult} configResult - Result of attempting to load a config file.  _Must_ be normalized\n * @param {Partial<ParsedArgs>} defaults - Configuration defaults from schemas\n * @param {ParsedArgs} parsedArgs - Entire parsed args object\n */\nfunction showConfig (nonDefaultPreConfigParsedArgs, configResult, defaults, parsedArgs) {\n  console.log('Appium Configuration\\n');\n  console.log('from defaults:\\n');\n  console.dir(compactConfig(defaults));\n  if (configResult.config) {\n    console.log(`\\nfrom config file at ${configResult.filepath}:\\n`);\n    console.dir(compactConfig(configResult.config));\n  } else {\n    console.log(`\\n(no configuration file loaded)`);\n  }\n  if (_.isEmpty(nonDefaultPreConfigParsedArgs)) {\n    console.log(`\\n(no CLI parameters provided)`);\n  } else {\n    console.log('\\nvia CLI or function call:\\n');\n    console.dir(compactConfig(nonDefaultPreConfigParsedArgs));\n  }\n  console.log('\\nfinal configuration:\\n');\n  console.dir(compactConfig(parsedArgs));\n}\n\n/**\n * @param {string} tmpDir\n */\nasync function validateTmpDir (tmpDir) {\n  try {\n    await fs.mkdirp(tmpDir);\n  } catch (e) {\n    throw new Error(`We could not ensure that the temp dir you specified ` +\n                    `(${tmpDir}) exists. Please make sure it's writeable.`);\n  }\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\nexport {\n  getBuildInfo, checkNodeOk, showBuildInfo,\n  warnNodeDeprecations, validateTmpDir, getNonDefaultServerArgs,\n  getGitRev, APPIUM_VER, updateBuildInfo, showConfig, rootDir\n};\n\n/**\n * @typedef {import('../types').ParsedArgs} ParsedArgs\n * @typedef {import('../types').Args} Args\n * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec\n */\n\n"],"mappings":"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"}

package/build/lib/constants.js

@@ -57,4 +57,4 @@ const EXT_SUBCOMMAND_UPDATE = 'update';
 exports.EXT_SUBCOMMAND_UPDATE = EXT_SUBCOMMAND_UPDATE;
 const EXT_SUBCOMMAND_RUN = 'run';
 exports.EXT_SUBCOMMAND_RUN = EXT_SUBCOMMAND_RUN;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -187,4 +187,4 @@ class DriverConfig extends _extensionConfig.ExtensionConfig {
 }
 
 exports.DriverConfig = DriverConfig;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/extension/driver-config.js"],"names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","logFn","extData","DRIVER_TYPE","Set","validate","create","instance","getInstance","Error","appiumHome","set","get","exts","clear","getConfigProblems","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"mappings":"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","sourcesContent":["\nimport _ from 'lodash';\nimport { DRIVER_TYPE } from '../constants';\nimport log from '../logger';\nimport { ExtensionConfig } from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n   static _instances = new WeakMap();\n\n   /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   * @param {DriverConfigOptions} [opts]\n   */\n   constructor (manifest, {logFn, extData} = {}) {\n     super(DRIVER_TYPE, manifest, logFn);\n\n     this.knownAutomationNames = new Set();\n\n     if (extData) {\n       this.validate(extData);\n     }\n   }\n\n   /**\n    * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n    *\n    * @param {Manifest} manifest\n    * @param {DriverConfigOptions} [opts]\n    * @throws If `manifest` already associated with a `DriverConfig`\n    * @returns {DriverConfig}\n    */\n   static create (manifest, {extData, logFn} = {}) {\n     const instance = new DriverConfig(manifest, {logFn, extData});\n     if (DriverConfig.getInstance(manifest)) {\n       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);\n     }\n     DriverConfig._instances.set(manifest, instance);\n     return instance;\n   }\n\n   /**\n    * Returns a DriverConfig associated with a Manifest\n    * @param {Manifest} manifest\n    * @returns {DriverConfig|undefined}\n    */\n   static getInstance (manifest) {\n     return DriverConfig._instances.get(manifest);\n   }\n\n   /**\n   * Checks extensions for problems\n   * @param {ExtRecord<DriverType>} exts\n   */\n   validate (exts) {\n     this.knownAutomationNames.clear();\n     return super.validate(exts);\n   }\n\n   /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').Problem[]}\n   */\n   getConfigProblems (extData) {\n     const problems = [];\n     const {platformNames, automationName} = extData;\n\n     if (!_.isArray(platformNames)) {\n       problems.push({\n         err: 'Missing or incorrect supported platformNames list.',\n         val: platformNames\n       });\n     } else {\n       if (_.isEmpty(platformNames)) {\n         problems.push({\n           err: 'Empty platformNames list.',\n           val: platformNames\n         });\n       } else {\n         for (const pName of platformNames) {\n           if (!_.isString(pName)) {\n             problems.push({err: 'Incorrectly formatted platformName.', val: pName});\n           }\n         }\n       }\n     }\n\n     if (!_.isString(automationName)) {\n       problems.push({err: 'Missing or incorrect automationName', val: automationName});\n     }\n\n     if (this.knownAutomationNames.has(automationName)) {\n       problems.push({\n         err: 'Multiple drivers claim support for the same automationName',\n         val: automationName\n       });\n     }\n\n     // should we retain the name at the end of this function, once we've checked there are no problems?\n     this.knownAutomationNames.add(automationName);\n\n     return problems;\n   }\n\n   /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n   extensionDesc (driverName, {version, automationName}) {\n     return `${driverName}@${version} (automationName '${automationName}')`;\n   }\n\n   /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @param {Capabilities} caps\n   * @returns {MatchedDriver}\n   */\n   findMatchingDriver ({automationName, platformName}) {\n     if (!_.isString(platformName)) {\n       throw new Error('You must include a platformName capability');\n     }\n\n     if (!_.isString(automationName)) {\n       throw new Error('You must include an automationName capability');\n     }\n\n     log.info(`Attempting to find matching driver for automationName ` +\n             `'${automationName}' and platformName '${platformName}'`);\n\n     try {\n       const {\n         driverName,\n         mainClass,\n         version,\n       } = this._getDriverBySupport(automationName, platformName);\n       log.info(`The '${driverName}' driver was installed and matched caps.`);\n       log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n       const driver = this.require(driverName);\n       if (!driver) {\n         throw new Error(`Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`);\n       }\n       return {driver, version, driverName};\n     } catch (err) {\n       const msg = `Could not find a driver for automationName ` +\n                  `'${automationName}' and platformName ${platformName}'. ` +\n                  `Have you installed a driver that supports those ` +\n                  `capabilities? Run 'appium driver list --installed' to see. ` +\n                  `(Lower-level error: ${err.message})`;\n       throw new Error(msg);\n     }\n   }\n\n   /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata}\n   */\n   _getDriverBySupport (matchAutomationName, matchPlatformName) {\n     const drivers = this.installedExtensions;\n     for (const [driverName, driverData] of _.toPairs(drivers)) {\n       const {automationName, platformNames} = driverData;\n       const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n       const pNameMatches = _.includes(platformNames.map(_.toLower),\n                                      matchPlatformName.toLowerCase());\n\n       if (aNameMatches && pNameMatches) {\n         return {driverName, ...driverData};\n       }\n\n       if (aNameMatches) {\n         throw new Error(`Driver '${driverName}' supports automationName ` +\n                        `'${automationName}', but Appium could not find ` +\n                        `support for platformName '${matchPlatformName}'. Supported ` +\n                        `platformNames are: ` +\n                        JSON.stringify(platformNames));\n       }\n     }\n\n     throw new Error(`Could not find installed driver to support given caps`);\n   }\n}\n\n/**\n * @typedef DriverConfigOptions\n * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function\n * @property {ManifestData['drivers']} [extData] - Extension data\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('../../types').ManifestData} ManifestData\n * @typedef {import('../../types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtName<T>} ExtName\n */\n\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('../../types/extension').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DriverConfig","ExtensionConfig","knownAutomationNames","_instances","WeakMap","constructor","manifest","logFn","extData","DRIVER_TYPE","Set","validate","create","instance","getInstance","Error","appiumHome","set","get","exts","clear","getConfigProblems","problems","platformNames","automationName","_","isArray","push","err","val","isEmpty","pName","isString","has","add","extensionDesc","driverName","version","findMatchingDriver","platformName","log","info","mainClass","_getDriverBySupport","getInstallPath","driver","require","msg","message","matchAutomationName","matchPlatformName","drivers","installedExtensions","driverData","toPairs","aNameMatches","toLowerCase","pNameMatches","includes","map","toLower","JSON","stringify"],"sources":["../../../lib/extension/driver-config.js"],"sourcesContent":["\nimport _ from 'lodash';\nimport { DRIVER_TYPE } from '../constants';\nimport log from '../logger';\nimport { ExtensionConfig } from './extension-config';\n\n/**\n * @extends {ExtensionConfig<DriverType>}\n */\nexport class DriverConfig extends ExtensionConfig {\n\n  /**\n   * A set of unique automation names used by drivers.\n   * @type {Set<string>}\n   */\n  knownAutomationNames;\n\n  /**\n   * A mapping of {@link Manifest} instances to {@link DriverConfig} instances.\n   *\n   * `Manifest` and `ExtensionConfig` have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.\n   *\n   * This variable tracks the `Manifest`-to-`DriverConfig` portion.\n   *\n   * @type {WeakMap<Manifest,DriverConfig>}\n   * @private\n   */\n   static _instances = new WeakMap();\n\n   /**\n   * Call {@link DriverConfig.create} instead.\n   * @private\n   * @param {import('./manifest').Manifest} manifest - Manifest instance\n   * @param {DriverConfigOptions} [opts]\n   */\n   constructor (manifest, {logFn, extData} = {}) {\n     super(DRIVER_TYPE, manifest, logFn);\n\n     this.knownAutomationNames = new Set();\n\n     if (extData) {\n       this.validate(extData);\n     }\n   }\n\n   /**\n    * Creates a new {@link DriverConfig} instance for a {@link Manifest} instance.\n    *\n    * @param {Manifest} manifest\n    * @param {DriverConfigOptions} [opts]\n    * @throws If `manifest` already associated with a `DriverConfig`\n    * @returns {DriverConfig}\n    */\n   static create (manifest, {extData, logFn} = {}) {\n     const instance = new DriverConfig(manifest, {logFn, extData});\n     if (DriverConfig.getInstance(manifest)) {\n       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a DriverConfig; use DriverConfig.getInstance() to retrieve it.`);\n     }\n     DriverConfig._instances.set(manifest, instance);\n     return instance;\n   }\n\n   /**\n    * Returns a DriverConfig associated with a Manifest\n    * @param {Manifest} manifest\n    * @returns {DriverConfig|undefined}\n    */\n   static getInstance (manifest) {\n     return DriverConfig._instances.get(manifest);\n   }\n\n   /**\n   * Checks extensions for problems\n   * @param {ExtRecord<DriverType>} exts\n   */\n   validate (exts) {\n     this.knownAutomationNames.clear();\n     return super.validate(exts);\n   }\n\n   /**\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {import('./extension-config').Problem[]}\n   */\n   getConfigProblems (extData) {\n     const problems = [];\n     const {platformNames, automationName} = extData;\n\n     if (!_.isArray(platformNames)) {\n       problems.push({\n         err: 'Missing or incorrect supported platformNames list.',\n         val: platformNames\n       });\n     } else {\n       if (_.isEmpty(platformNames)) {\n         problems.push({\n           err: 'Empty platformNames list.',\n           val: platformNames\n         });\n       } else {\n         for (const pName of platformNames) {\n           if (!_.isString(pName)) {\n             problems.push({err: 'Incorrectly formatted platformName.', val: pName});\n           }\n         }\n       }\n     }\n\n     if (!_.isString(automationName)) {\n       problems.push({err: 'Missing or incorrect automationName', val: automationName});\n     }\n\n     if (this.knownAutomationNames.has(automationName)) {\n       problems.push({\n         err: 'Multiple drivers claim support for the same automationName',\n         val: automationName\n       });\n     }\n\n     // should we retain the name at the end of this function, once we've checked there are no problems?\n     this.knownAutomationNames.add(automationName);\n\n     return problems;\n   }\n\n   /**\n   * @param {ExtName<DriverType>} driverName\n   * @param {ExtManifest<DriverType>} extData\n   * @returns {string}\n   */\n   extensionDesc (driverName, {version, automationName}) {\n     return `${driverName}@${version} (automationName '${automationName}')`;\n   }\n\n   /**\n   * Given capabilities, find a matching driver within the config. Load its class and return it along with version and driver name.\n   * @param {Capabilities} caps\n   * @returns {MatchedDriver}\n   */\n   findMatchingDriver ({automationName, platformName}) {\n     if (!_.isString(platformName)) {\n       throw new Error('You must include a platformName capability');\n     }\n\n     if (!_.isString(automationName)) {\n       throw new Error('You must include an automationName capability');\n     }\n\n     log.info(`Attempting to find matching driver for automationName ` +\n             `'${automationName}' and platformName '${platformName}'`);\n\n     try {\n       const {\n         driverName,\n         mainClass,\n         version,\n       } = this._getDriverBySupport(automationName, platformName);\n       log.info(`The '${driverName}' driver was installed and matched caps.`);\n       log.info(`Will require it at ${this.getInstallPath(driverName)}`);\n       const driver = this.require(driverName);\n       if (!driver) {\n         throw new Error(`Driver '${driverName}' did not export a class with name '${mainClass}'. Contact the author of the driver!`);\n       }\n       return {driver, version, driverName};\n     } catch (err) {\n       const msg = `Could not find a driver for automationName ` +\n                  `'${automationName}' and platformName ${platformName}'. ` +\n                  `Have you installed a driver that supports those ` +\n                  `capabilities? Run 'appium driver list --installed' to see. ` +\n                  `(Lower-level error: ${err.message})`;\n       throw new Error(msg);\n     }\n   }\n\n   /**\n   * Given an automation name and platform name, find a suitable driver and return its extension data.\n   * @param {string} matchAutomationName\n   * @param {string} matchPlatformName\n   * @returns {ExtMetadata<DriverType> & import('../../types/appium-manifest').InternalMetadata & import('../../types/external-manifest').CommonMetadata}\n   */\n   _getDriverBySupport (matchAutomationName, matchPlatformName) {\n     const drivers = this.installedExtensions;\n     for (const [driverName, driverData] of _.toPairs(drivers)) {\n       const {automationName, platformNames} = driverData;\n       const aNameMatches = automationName.toLowerCase() === matchAutomationName.toLowerCase();\n       const pNameMatches = _.includes(platformNames.map(_.toLower),\n                                      matchPlatformName.toLowerCase());\n\n       if (aNameMatches && pNameMatches) {\n         return {driverName, ...driverData};\n       }\n\n       if (aNameMatches) {\n         throw new Error(`Driver '${driverName}' supports automationName ` +\n                        `'${automationName}', but Appium could not find ` +\n                        `support for platformName '${matchPlatformName}'. Supported ` +\n                        `platformNames are: ` +\n                        JSON.stringify(platformNames));\n       }\n     }\n\n     throw new Error(`Could not find installed driver to support given caps`);\n   }\n}\n\n/**\n * @typedef DriverConfigOptions\n * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function\n * @property {ManifestData['drivers']} [extData] - Extension data\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtMetadata<T>} ExtMetadata\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtManifest<T>} ExtManifest\n */\n\n/**\n * @typedef {import('../../types').ManifestData} ManifestData\n * @typedef {import('../../types').DriverType} DriverType\n * @typedef {import('./manifest').Manifest} Manifest\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtRecord<T>} ExtRecord\n */\n\n/**\n * @template T\n * @typedef {import('../../types').ExtName<T>} ExtName\n */\n\n\n/**\n * Return value of {@linkcode DriverConfig.findMatchingDriver}\n * @typedef MatchedDriver\n * @property {import('../../types/extension').DriverClass} driver\n * @property {string} version\n * @property {string} driverName\n */\n\n/**\n * @typedef {import('@appium/types').Capabilities} Capabilities\n */\n"],"mappings":"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"}