appium 2.0.0-beta.18 → 2.0.0-beta.21

package/build/lib/cli/parser.js

@@ -5,157 +5,193 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = exports.SERVER_SUBCOMMAND = exports.ArgParser = void 0;
 exports.getParser = getParser;
-exports.getDefaultServerArgs = getDefaultServerArgs;
-exports.default = void 0;
 
 require("source-map-support/register");
 
-var _path = _interopRequireDefault(require("path"));
-
-var _lodash = _interopRequireDefault(require("lodash"));
+var _support = require("@appium/support");
 
 var _argparse = require("argparse");
 
-var _args = require("./args");
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
 
 var _extensionConfig = require("../extension-config");
 
+var _schema = require("../schema");
+
 var _utils = require("../utils");
 
-var _support = require("@appium/support");
+var _args = require("./args");
 
-function makeDebugParser(parser) {
-  parser.exit = (status, message = undefined) => {
-    throw new Error(message);
-  };
-}
+const SERVER_SUBCOMMAND = 'server';
+exports.SERVER_SUBCOMMAND = SERVER_SUBCOMMAND;
+const NON_SERVER_ARGS = Object.freeze(new Set([_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE, SERVER_SUBCOMMAND, '-h', '--help', '-v', '--version']));
 
-function getParser(debug = false) {
-  const parser = new _argparse.ArgumentParser({
-    add_help: true,
-    description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.',
-    prog: process.argv[1] ? _path.default.basename(process.argv[1]) : 'appium'
-  });
+const version = _support.fs.readPackageJsonFrom(_utils.rootDir).version;
 
-  if (debug) {
-    makeDebugParser(parser);
-  }
+class ArgParser {
+  constructor(debug = false) {
+    const prog = process.argv[1] ? _path.default.basename(process.argv[1]) : 'appium';
+    const parser = new _argparse.ArgumentParser({
+      add_help: true,
+      description: 'A webdriver-compatible server that facilitates automation of web, mobile, and other types of apps across various platforms.',
+      prog
+    });
 
-  parser.add_argument('-v', '--version', {
-    action: 'version',
-    version: _support.fs.readPackageJsonFrom(_utils.rootDir).version
-  });
-  const subParsers = parser.add_subparsers({
-    dest: 'subcommand'
-  });
-  const serverArgs = addServerToParser(_args.sharedArgs, subParsers, debug);
-  parser.rawArgs = serverArgs;
-  addExtensionsToParser(_args.sharedArgs, subParsers, debug);
-  parser._parse_args = parser.parse_args.bind(parser);
-
-  parser.parse_args = function (args, namespace) {
-    if (_lodash.default.isUndefined(args)) {
-      args = [...process.argv.slice(2)];
-    }
+    ArgParser._patchExit(parser);
 
-    if (!_lodash.default.includes([_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE, 'server', '-h', '--help', '-v', '--version'], args[0])) {
-      args.splice(0, 0, 'server');
-    }
+    this.prog = prog;
+    this.debug = debug;
+    this.parser = parser;
+    parser.add_argument('-v', '--version', {
+      action: 'version',
+      version
+    });
+    const subParsers = parser.add_subparsers({
+      dest: 'subcommand'
+    });
 
-    return this._parse_args(args, namespace);
-  }.bind(parser);
+    const serverArgs = ArgParser._addServerToParser(subParsers);
 
-  return parser;
-}
+    this.rawArgs = serverArgs;
 
-function addServerToParser(sharedArgs, subParsers, debug = false) {
-  const serverParser = subParsers.add_parser('server', {
-    add_help: true,
-    help: 'Run an Appium server'
-  });
+    ArgParser._addExtensionCommandsToParser(subParsers);
 
-  if (debug) {
-    makeDebugParser(serverParser);
+    this.parse_args = this.parseArgs;
   }
 
-  for (const [flagsOrNames, opts] of [...sharedArgs, ..._args.serverArgs]) {
-    serverParser.add_argument(...flagsOrNames, { ...opts
-    });
+  parseArgs(args = process.argv.slice(2)) {
+    if (!NON_SERVER_ARGS.has(args[0])) {
+      args.unshift(SERVER_SUBCOMMAND);
+    }
+
+    try {
+      const parsed = this.parser.parse_args(args);
+      return ArgParser._transformParsedArgs(parsed);
+    } catch (err) {
+      if (this.debug) {
+        throw err;
+      }
+
+      {
+        console.error();
+        console.error(err.message);
+        process.exit(1);
+      }
+    }
   }
 
-  return _args.serverArgs;
-}
+  static _transformParsedArgs(args) {
+    return _lodash.default.reduce(args, (unpacked, value, key) => {
+      if ((0, _schema.hasArgSpec)(key)) {
+        const {
+          dest
+        } = (0, _schema.getArgSpec)(key);
 
-function getDefaultServerArgs() {
-  let defaults = {};
+        _lodash.default.set(unpacked, dest, value);
+      } else {
+        unpacked[key] = value;
+      }
 
-  for (let [, arg] of _args.serverArgs) {
-    defaults[arg.dest] = arg.default;
+      return unpacked;
+    }, {});
   }
 
-  return defaults;
-}
+  static _patchExit(parser) {
+    parser.exit = (code, msg) => {
+      throw new Error(msg);
+    };
+  }
 
-function addExtensionsToParser(sharedArgs, subParsers, debug = false) {
-  for (const type of [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]) {
-    const extParser = subParsers.add_parser(type, {
+  static _addServerToParser(subParser) {
+    const serverParser = subParser.add_parser('server', {
       add_help: true,
-      help: `Access the ${type} management CLI commands`
+      help: 'Run an Appium server'
     });
 
-    if (debug) {
-      makeDebugParser(extParser);
+    ArgParser._patchExit(serverParser);
+
+    const serverArgs = (0, _args.getServerArgs)();
+
+    for (const [flagsOrNames, opts] of serverArgs) {
+      serverParser.add_argument(...flagsOrNames, { ...opts
+      });
     }
 
-    const extSubParsers = extParser.add_subparsers({
-      dest: `${type}Command`
-    });
-    const parserSpecs = [{
-      command: 'list',
-      args: _args.extensionArgs[type].list,
-      help: `List available and installed ${type}s`
-    }, {
-      command: 'install',
-      args: _args.extensionArgs[type].install,
-      help: `Install a ${type}`
-    }, {
-      command: 'uninstall',
-      args: _args.extensionArgs[type].uninstall,
-      help: `Uninstall a ${type}`
-    }, {
-      command: 'update',
-      args: _args.extensionArgs[type].update,
-      help: `Update installed ${type}s to the latest version`
-    }, {
-      command: 'run',
-      args: _args.extensionArgs[type].run,
-      help: `Run a script (defined inside the ${type}'s package.json under the ` + `“scripts” field inside the “appium” field) from an installed ${type}`
-    }];
-
-    for (const {
-      command,
-      args,
-      help
-    } of parserSpecs) {
-      const parser = extSubParsers.add_parser(command, {
-        help
+    return serverArgs;
+  }
+
+  static _addExtensionCommandsToParser(subParsers) {
+    for (const type of [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]) {
+      const extParser = subParsers.add_parser(type, {
+        add_help: true,
+        help: `Access the ${type} management CLI commands`
       });
 
-      if (debug) {
-        makeDebugParser(parser);
-      }
+      ArgParser._patchExit(extParser);
 
-      for (const [flagsOrNames, opts] of [...sharedArgs, ...args]) {
-        parser.add_argument(...flagsOrNames, { ...opts
+      const extSubParsers = extParser.add_subparsers({
+        dest: `${type}Command`
+      });
+      const extensionArgs = (0, _args.getExtensionArgs)();
+      const parserSpecs = [{
+        command: 'list',
+        args: extensionArgs[type].list,
+        help: `List available and installed ${type}s`
+      }, {
+        command: 'install',
+        args: extensionArgs[type].install,
+        help: `Install a ${type}`
+      }, {
+        command: 'uninstall',
+        args: extensionArgs[type].uninstall,
+        help: `Uninstall a ${type}`
+      }, {
+        command: 'update',
+        args: extensionArgs[type].update,
+        help: `Update installed ${type}s to the latest version`
+      }, {
+        command: 'run',
+        args: extensionArgs[type].run,
+        help: `Run a script (defined inside the ${type}'s package.json under the ` + `“scripts” field inside the “appium” field) from an installed ${type}`
+      }];
+
+      for (const {
+        command,
+        args,
+        help
+      } of parserSpecs) {
+        const parser = extSubParsers.add_parser(command, {
+          help
         });
+
+        ArgParser._patchExit(parser);
+
+        for (const [flagsOrNames, opts] of args) {
+          parser.add_argument(...flagsOrNames, { ...opts
+          });
+        }
       }
     }
   }
+
+}
+
+exports.ArgParser = ArgParser;
+
+async function getParser(debug = false) {
+  await _bluebird.default.all([_args.driverConfig.read(), _args.pluginConfig.read()]);
+  (0, _schema.finalizeSchema)();
+  return new ArgParser(debug);
 }
 
 var _default = getParser;
 exports.default = _default;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/cli/parser.js"],"names":["makeDebugParser","parser","exit","status","message","undefined","Error","getParser","debug","ArgumentParser","add_help","description","prog","process","argv","path","basename","add_argument","action","version","fs","readPackageJsonFrom","rootDir","subParsers","add_subparsers","dest","serverArgs","addServerToParser","sharedArgs","rawArgs","addExtensionsToParser","_parse_args","parse_args","bind","args","namespace","_","isUndefined","slice","includes","DRIVER_TYPE","PLUGIN_TYPE","splice","serverParser","add_parser","help","flagsOrNames","opts","getDefaultServerArgs","defaults","arg","default","type","extParser","extSubParsers","parserSpecs","command","extensionArgs","list","install","uninstall","update","run"],"mappings":"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","sourcesContent":["import path from 'path';\nimport _ from 'lodash';\nimport { ArgumentParser } from 'argparse';\nimport { sharedArgs, serverArgs, extensionArgs } from './args';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../extension-config';\nimport { rootDir } from '../utils';\nimport { fs } from '@appium/support';\n\n\nfunction makeDebugParser (parser) {\n  parser.exit = (status, message = undefined) => {\n    throw new Error(message);\n  };\n}\n\nfunction getParser (debug = false) {\n  const parser = new ArgumentParser({\n    add_help: true,\n    description: 'A webdriver-compatible server for use with native and hybrid iOS and Android applications.',\n    prog: process.argv[1] ? path.basename(process.argv[1]) : 'appium',\n  });\n  if (debug) {\n    makeDebugParser(parser);\n  }\n  parser.add_argument('-v', '--version', {\n    action: 'version',\n    version: fs.readPackageJsonFrom(rootDir).version\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 = addServerToParser(sharedArgs, subParsers, debug);\n  parser.rawArgs = serverArgs;\n\n  // add the 'driver' and 'plugin' subcommands\n  addExtensionsToParser(sharedArgs, subParsers, debug);\n\n  // modify the parse_args function to insert the 'server' subcommand if the\n  // user hasn't specified a subcommand or the global help command\n  parser._parse_args = parser.parse_args.bind(parser);\n  parser.parse_args = function (args, namespace) {\n    if (_.isUndefined(args)) {\n      args = [...process.argv.slice(2)];\n    }\n    if (!_.includes([DRIVER_TYPE, PLUGIN_TYPE, 'server', '-h', '--help', '-v', '--version'], args[0])) {\n      args.splice(0, 0, 'server');\n    }\n    return this._parse_args(args, namespace);\n  }.bind(parser);\n  return parser;\n}\n\nfunction addServerToParser (sharedArgs, subParsers, debug = false) {\n  const serverParser = subParsers.add_parser('server', {\n    add_help: true,\n    help: 'Run an Appium server',\n  });\n\n  if (debug) {\n    makeDebugParser(serverParser);\n  }\n\n  for (const [flagsOrNames, opts] of [...sharedArgs, ...serverArgs]) {\n    // add_argument mutates arguments so make copies\n    serverParser.add_argument(...flagsOrNames, {...opts});\n  }\n\n  return serverArgs;\n}\n\nfunction getDefaultServerArgs () {\n  let defaults = {};\n  for (let [, arg] of serverArgs) {\n    defaults[arg.dest] = arg.default;\n  }\n  return defaults;\n}\n\nfunction addExtensionsToParser (sharedArgs, subParsers, debug = false) {\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    if (debug) {\n      makeDebugParser(extParser);\n    }\n    const extSubParsers = extParser.add_subparsers({\n      dest: `${type}Command`,\n    });\n    const parserSpecs = [\n      {command: 'list', args: extensionArgs[type].list,\n       help: `List available and installed ${type}s`},\n      {command: 'install', args: extensionArgs[type].install,\n       help: `Install a ${type}`},\n      {command: 'uninstall', args: extensionArgs[type].uninstall,\n       help: `Uninstall a ${type}`},\n      {command: 'update', args: extensionArgs[type].update,\n       help: `Update installed ${type}s to the latest version`},\n      {command: 'run', args: extensionArgs[type].run,\n       help: `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    for (const {command, args, help} of parserSpecs) {\n      const parser = extSubParsers.add_parser(command, {help});\n      if (debug) {\n        makeDebugParser(parser);\n      }\n      for (const [flagsOrNames, opts] of [...sharedArgs, ...args]) {\n        // add_argument mutates params so make sure to send in copies instead\n        parser.add_argument(...flagsOrNames, {...opts});\n      }\n    }\n  }\n}\n\nexport default getParser;\nexport { getParser, getDefaultServerArgs };\n"],"file":"lib/cli/parser.js","sourceRoot":"../../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/cli/parser.js"],"names":["SERVER_SUBCOMMAND","NON_SERVER_ARGS","Object","freeze","Set","DRIVER_TYPE","PLUGIN_TYPE","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","set","code","msg","Error","subParser","serverParser","add_parser","help","flagsOrNames","opts","type","extParser","extSubParsers","extensionArgs","parserSpecs","command","list","install","uninstall","update","run","getParser","B","all","driverConfig","read","pluginConfig"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { fs } from '@appium/support';\nimport { ArgumentParser } from 'argparse';\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../extension-config';\nimport { finalizeSchema, getArgSpec, hasArgSpec } from '../schema';\nimport { rootDir } from '../utils';\nimport {\n  driverConfig,\n  getExtensionArgs,\n  getServerArgs,\n  pluginConfig\n} from './args';\n\nexport const SERVER_SUBCOMMAND = 'server';\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/types').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 (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      throw new Error(msg);\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.  Necessarily reads extension configuration\n * beforehand, and finalizes the config schema.\n *\n * @constructs ArgParser\n * @param {boolean} [debug] - If `true`, throw instead of exit upon parsing error\n * @returns {Promise<ArgParser>}\n */\nasync function getParser (debug = false) {\n  await B.all([driverConfig.read(), pluginConfig.read()]);\n  finalizeSchema();\n\n  return new ArgParser(debug);\n}\n\nexport default getParser;\nexport { getParser, ArgParser };\n"],"file":"lib/cli/parser.js","sourceRoot":"../../.."}

package/build/lib/cli/utils.js

@@ -5,10 +5,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.RingBuffer = exports.JSON_SPACES = void 0;
 exports.errAndQuit = errAndQuit;
 exports.log = log;
 exports.spinWith = spinWith;
-exports.RingBuffer = exports.JSON_SPACES = void 0;
 
 require("source-map-support/register");
 

package/build/lib/config-file.js

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatErrors = formatErrors;
+exports.readConfigFile = readConfigFile;
+
+require("source-map-support/register");
+
+var _betterAjvErrors = _interopRequireDefault(require("@sidvind/better-ajv-errors"));
+
+var _lilconfig = require("lilconfig");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+var _schema = require("./schema/schema");
+
+function yamlLoader(filepath, content) {
+  return _yaml.default.parse(content);
+}
+
+const rawConfig = new Map();
+
+function jsonLoader(filepath, content) {
+  rawConfig.set(filepath, content);
+  return JSON.parse(content);
+}
+
+async function loadConfigFile(lc, filepath) {
+  try {
+    return await lc.load(filepath);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      err.message = `Config file not found at user-provided path: ${filepath}`;
+      throw err;
+    } else if (err instanceof SyntaxError) {
+      err.message = `Config file at user-provided path ${filepath} is invalid:\n${err.message}`;
+      throw err;
+    }
+
+    throw err;
+  }
+}
+
+async function searchConfigFile(lc) {
+  return await lc.search();
+}
+
+function formatErrors(errors = [], config = {}, opts = {}) {
+  if (errors && !errors.length) {
+    throw new TypeError('Array of errors must be non-empty');
+  }
+
+  return (0, _betterAjvErrors.default)((0, _schema.getSchema)(opts.schemaId), config, errors, {
+    json: opts.json,
+    format: 'cli'
+  });
+}
+
+async function readConfigFile(filepath, opts = {}) {
+  const lc = (0, _lilconfig.lilconfig)('appium', {
+    loaders: {
+      '.yaml': yamlLoader,
+      '.yml': yamlLoader,
+      '.json': jsonLoader,
+      noExt: jsonLoader
+    },
+    packageProp: 'appiumConfig'
+  });
+  const result = filepath ? await loadConfigFile(lc, filepath) : await searchConfigFile(lc);
+
+  if (result && !result.isEmpty && result.filepath) {
+    const {
+      normalize = true,
+      pretty = true
+    } = opts;
+
+    try {
+      let configResult;
+      const errors = (0, _schema.validate)(result.config);
+
+      if (_lodash.default.isEmpty(errors)) {
+        configResult = { ...result,
+          errors
+        };
+      } else {
+        const reason = formatErrors(errors, result.config, {
+          json: rawConfig.get(result.filepath),
+          pretty
+        });
+        configResult = reason ? { ...result,
+          errors,
+          reason
+        } : { ...result,
+          errors
+        };
+      }
+
+      if (normalize) {
+        configResult.config = normalizeConfig(configResult.config);
+      }
+
+      return configResult;
+    } finally {
+      rawConfig.delete(result.filepath);
+    }
+  }
+
+  return result !== null && result !== void 0 ? result : {};
+}
+
+function normalizeConfig(config) {
+  const schema = (0, _schema.getSchema)();
+
+  const normalize = (config, section) => {
+    const obj = _lodash.default.isUndefined(section) ? config : _lodash.default.get(config, section, config);
+
+    const mappedObj = _lodash.default.mapKeys(obj, (__, prop) => {
+      var _schema$properties$pr, _schema$properties$pr2;
+
+      return (_schema$properties$pr = (_schema$properties$pr2 = schema.properties[prop]) === null || _schema$properties$pr2 === void 0 ? void 0 : _schema$properties$pr2.appiumCliDest) !== null && _schema$properties$pr !== void 0 ? _schema$properties$pr : _lodash.default.camelCase(prop);
+    });
+
+    return _lodash.default.mapValues(mappedObj, (value, property) => {
+      const nextSection = section ? `${section}.${property}` : property;
+      return isSchemaTypeObject(value) ? normalize(config, nextSection) : value;
+    });
+  };
+
+  const isSchemaTypeObject = schema => Boolean(schema.properties);
+
+  return normalize(config);
+}require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;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","normalize","pretty","configResult","_","reason","get","normalizeConfig","delete","schema","section","obj","isUndefined","mappedObj","mapKeys","__","prop","properties","appiumCliDest","camelCase","mapValues","value","property","nextSection","isSchemaTypeObject","Boolean"],"mappings":"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","sourcesContent":["// @ts-check\n\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 && !result.isEmpty && result.filepath) {\n    const {normalize = true, pretty = true} = opts;\n    try {\n      /** @type {ReadConfigFileResult} */\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      if (normalize) {\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\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 */\nfunction 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   * @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 {Object} 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 {AppiumConfig} [config] - The parsed configuration\n * @property {string|betterAjvErrors.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 {Object} 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 * @property {boolean} [normalize=true] If `false`, do not normalize key names to camel case.\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('../types/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('../types/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 {Object} 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"],"file":"lib/config-file.js","sourceRoot":"../.."}