appium 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -13,9 +13,7 @@ var _lodash = _interopRequireDefault(require("lodash"));
 
 var _extensionCommand = _interopRequireDefault(require("./extension-command"));
 
-var _extensionConfig = require("../extension-config");
-
-var _plugins = require("../plugins");
+var _constants = require("../constants");
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
 
@@ -26,10 +24,9 @@ class PluginCommand extends _extensionCommand.default {
   }) {
     super({
       config,
-      json,
-      type: _extensionConfig.PLUGIN_TYPE
+      json
     });
-    this.knownExtensions = _plugins.KNOWN_PLUGINS;
+    this.knownExtensions = _constants.KNOWN_PLUGINS;
   }
 
   async install({
@@ -37,7 +34,7 @@ class PluginCommand extends _extensionCommand.default {
     installType,
     packageName
   }) {
-    return await super.install({
+    return await super._install({
       ext: plugin,
       installType,
       packageName
@@ -47,7 +44,7 @@ class PluginCommand extends _extensionCommand.default {
   async uninstall({
     plugin
   }) {
-    return await super.uninstall({
+    return await super._uninstall({
       ext: plugin
     });
   }
@@ -56,12 +53,22 @@ class PluginCommand extends _extensionCommand.default {
     plugin,
     unsafe
   }) {
-    return await super.update({
+    return await super._update({
       ext: plugin,
       unsafe
     });
   }
 
+  async run({
+    plugin,
+    scriptName
+  }) {
+    return await super._run({
+      ext: plugin,
+      scriptName
+    });
+  }
+
   getPostInstallText({
     extName,
     extData
@@ -79,7 +86,5 @@ class PluginCommand extends _extensionCommand.default {
 
 }
 
-exports.default = PluginCommand;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.default = PluginCommand;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,29 @@
+/***
+ * Log an error to the console and exit the process.
+ * @param {boolean} json - whether we should log json or text
+ * @param {any} msg - error message, object, Error instance, etc.
+ */
+export function errAndQuit(json: boolean, msg: any): void;
+/**
+ * Conditionally log something to the console
+ * @param {boolean} json - whether we are in json mode (and should therefore not log)
+ * @param {string} msg - string to log
+ */
+export function log(json: boolean, msg: string): void;
+/**
+ * Start a spinner, execute an async function, and then stop the spinner
+ * @param {boolean} json - whether we are in json mode (and should therefore not log)
+ * @param {string} msg - string to log
+ * @param {function} fn - function to wrap with spinning
+ */
+export function spinWith(json: boolean, msg: string, fn: Function): Promise<any>;
+export const JSON_SPACES: 4;
+export class RingBuffer {
+    constructor(size?: number);
+    size: number;
+    buffer: any[];
+    getBuff(): any[];
+    dequeue(): void;
+    enqueue(item: any): void;
+}
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../lib/cli/utils.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,iCAHW,OAAO,OACP,GAAG,QAYb;AAED;;;;GAIG;AACH,0BAHW,OAAO,OACP,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+BAJW,OAAO,OACP,MAAM,8BAiBhB;AAhDD,4BAAsB;AAkDtB;IACE,2BAGC;IAFC,aAAgB;IAChB,cAAgB;IAElB,iBAEC;IACD,gBAEC;IACD,yBAKC;CACF"}

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.JSON_SPACES = void 0;
 
 require("source-map-support/register");
 
@@ -53,7 +53,31 @@ async function spinWith(json, msg, fn) {
     spinner.fail();
     throw err;
   }
-}require('source-map-support').install();
+}
+
+class RingBuffer {
+  constructor(size = 50) {
+    this.size = size;
+    this.buffer = [];
+  }
+
+  getBuff() {
+    return this.buffer;
+  }
+
+  dequeue() {
+    this.buffer.shift();
+  }
+
+  enqueue(item) {
+    if (this.buffer.length >= this.size) {
+      this.dequeue();
+    }
 
+    this.buffer.push(item);
+  }
+
+}
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.RingBuffer = RingBuffer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9jbGkvdXRpbHMuanMiXSwibmFtZXMiOlsiSlNPTl9TUEFDRVMiLCJlcnJBbmRRdWl0IiwianNvbiIsIm1zZyIsImNvbnNvbGUiLCJsb2ciLCJKU09OIiwic3RyaW5naWZ5IiwiZXJyb3IiLCJyZWQiLCJzdGRlcnIiLCJwcm9jZXNzIiwiZXhpdCIsInNwaW5XaXRoIiwiZm4iLCJzcGlubmVyIiwic3RhcnQiLCJyZXMiLCJzdWNjZWVkIiwiZXJyIiwiZmFpbCIsIlJpbmdCdWZmZXIiLCJjb25zdHJ1Y3RvciIsInNpemUiLCJidWZmZXIiLCJnZXRCdWZmIiwiZGVxdWV1ZSIsInNoaWZ0IiwiZW5xdWV1ZSIsIml0ZW0iLCJsZW5ndGgiLCJwdXNoIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7OztBQUVBOztBQUVBLE1BQU1BLFdBQVcsR0FBRyxDQUFwQjs7O0FBT0EsU0FBU0MsVUFBVCxDQUFxQkMsSUFBckIsRUFBMkJDLEdBQTNCLEVBQWdDO0FBQzlCLE1BQUlELElBQUosRUFBVTtBQUNSRSxJQUFBQSxPQUFPLENBQUNDLEdBQVIsQ0FBWUMsSUFBSSxDQUFDQyxTQUFMLENBQWU7QUFBQ0MsTUFBQUEsS0FBSyxFQUFHLEdBQUVMLEdBQUk7QUFBZixLQUFmLEVBQWtDLElBQWxDLEVBQXdDSCxXQUF4QyxDQUFaO0FBQ0QsR0FGRCxNQUVPO0FBQ0xJLElBQUFBLE9BQU8sQ0FBQ0ksS0FBUixDQUFlLEdBQUVMLEdBQUksRUFBUCxDQUFTTSxHQUF2Qjs7QUFDQSxRQUFJTixHQUFHLENBQUNPLE1BQVIsRUFBZ0I7QUFDZE4sTUFBQUEsT0FBTyxDQUFDSSxLQUFSLENBQWUsR0FBRUwsR0FBRyxDQUFDTyxNQUFPLEVBQWQsQ0FBZ0JELEdBQTlCO0FBQ0Q7QUFDRjs7QUFDREUsRUFBQUEsT0FBTyxDQUFDQyxJQUFSLENBQWEsQ0FBYjtBQUNEOztBQU9ELFNBQVNQLEdBQVQsQ0FBY0gsSUFBZCxFQUFvQkMsR0FBcEIsRUFBeUI7QUFDdkIsR0FBQ0QsSUFBRCxJQUFTRSxPQUFPLENBQUNDLEdBQVIsQ0FBWUYsR0FBWixDQUFUO0FBQ0Q7O0FBUUQsZUFBZVUsUUFBZixDQUF5QlgsSUFBekIsRUFBK0JDLEdBQS9CLEVBQW9DVyxFQUFwQyxFQUF3QztBQUN0QyxNQUFJWixJQUFKLEVBQVU7QUFDUixXQUFPLE1BQU1ZLEVBQUUsRUFBZjtBQUNEOztBQUNELFFBQU1DLE9BQU8sR0FBRyxrQkFBSVosR0FBSixFQUFTYSxLQUFULEVBQWhCO0FBQ0EsTUFBSUMsR0FBSjs7QUFDQSxNQUFJO0FBQ0ZBLElBQUFBLEdBQUcsR0FBRyxNQUFNSCxFQUFFLEVBQWQ7QUFDQUMsSUFBQUEsT0FBTyxDQUFDRyxPQUFSO0FBQ0EsV0FBT0QsR0FBUDtBQUNELEdBSkQsQ0FJRSxPQUFPRSxHQUFQLEVBQVk7QUFDWkosSUFBQUEsT0FBTyxDQUFDSyxJQUFSO0FBQ0EsVUFBTUQsR0FBTjtBQUNEO0FBQ0Y7O0FBRUQsTUFBTUUsVUFBTixDQUFpQjtBQUNmQyxFQUFBQSxXQUFXLENBQUVDLElBQUksR0FBRyxFQUFULEVBQWE7QUFDdEIsU0FBS0EsSUFBTCxHQUFZQSxJQUFaO0FBQ0EsU0FBS0MsTUFBTCxHQUFjLEVBQWQ7QUFDRDs7QUFDREMsRUFBQUEsT0FBTyxHQUFJO0FBQ1QsV0FBTyxLQUFLRCxNQUFaO0FBQ0Q7O0FBQ0RFLEVBQUFBLE9BQU8sR0FBSTtBQUNULFNBQUtGLE1BQUwsQ0FBWUcsS0FBWjtBQUNEOztBQUNEQyxFQUFBQSxPQUFPLENBQUVDLElBQUYsRUFBUTtBQUNiLFFBQUksS0FBS0wsTUFBTCxDQUFZTSxNQUFaLElBQXNCLEtBQUtQLElBQS9CLEVBQXFDO0FBQ25DLFdBQUtHLE9BQUw7QUFDRDs7QUFDRCxTQUFLRixNQUFMLENBQVlPLElBQVosQ0FBaUJGLElBQWpCO0FBQ0Q7O0FBaEJjIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgbm8tY29uc29sZSAqL1xuXG5pbXBvcnQgb3JhIGZyb20gJ29yYSc7XG5cbmNvbnN0IEpTT05fU1BBQ0VTID0gNDtcblxuLyoqKlxuICogTG9nIGFuIGVycm9yIHRvIHRoZSBjb25zb2xlIGFuZCBleGl0IHRoZSBwcm9jZXNzLlxuICogQHBhcmFtIHtib29sZWFufSBqc29uIC0gd2hldGhlciB3ZSBzaG91bGQgbG9nIGpzb24gb3IgdGV4dFxuICogQHBhcmFtIHthbnl9IG1zZyAtIGVycm9yIG1lc3NhZ2UsIG9iamVjdCwgRXJyb3IgaW5zdGFuY2UsIGV0Yy5cbiAqL1xuZnVuY3Rpb24gZXJyQW5kUXVpdCAoanNvbiwgbXNnKSB7XG4gIGlmIChqc29uKSB7XG4gICAgY29uc29sZS5sb2coSlNPTi5zdHJpbmdpZnkoe2Vycm9yOiBgJHttc2d9YH0sIG51bGwsIEpTT05fU1BBQ0VTKSk7XG4gIH0gZWxzZSB7XG4gICAgY29uc29sZS5lcnJvcihgJHttc2d9YC5yZWQpO1xuICAgIGlmIChtc2cuc3RkZXJyKSB7XG4gICAgICBjb25zb2xlLmVycm9yKGAke21zZy5zdGRlcnJ9YC5yZWQpO1xuICAgIH1cbiAgfVxuICBwcm9jZXNzLmV4aXQoMSk7XG59XG5cbi8qKlxuICogQ29uZGl0aW9uYWxseSBsb2cgc29tZXRoaW5nIHRvIHRoZSBjb25zb2xlXG4gKiBAcGFyYW0ge2Jvb2xlYW59IGpzb24gLSB3aGV0aGVyIHdlIGFyZSBpbiBqc29uIG1vZGUgKGFuZCBzaG91bGQgdGhlcmVmb3JlIG5vdCBsb2cpXG4gKiBAcGFyYW0ge3N0cmluZ30gbXNnIC0gc3RyaW5nIHRvIGxvZ1xuICovXG5mdW5jdGlvbiBsb2cgKGpzb24sIG1zZykge1xuICAhanNvbiAmJiBjb25zb2xlLmxvZyhtc2cpO1xufVxuXG4vKipcbiAqIFN0YXJ0IGEgc3Bpbm5lciwgZXhlY3V0ZSBhbiBhc3luYyBmdW5jdGlvbiwgYW5kIHRoZW4gc3RvcCB0aGUgc3Bpbm5lclxuICogQHBhcmFtIHtib29sZWFufSBqc29uIC0gd2hldGhlciB3ZSBhcmUgaW4ganNvbiBtb2RlIChhbmQgc2hvdWxkIHRoZXJlZm9yZSBub3QgbG9nKVxuICogQHBhcmFtIHtzdHJpbmd9IG1zZyAtIHN0cmluZyB0byBsb2dcbiAqIEBwYXJhbSB7ZnVuY3Rpb259IGZuIC0gZnVuY3Rpb24gdG8gd3JhcCB3aXRoIHNwaW5uaW5nXG4gKi9cbmFzeW5jIGZ1bmN0aW9uIHNwaW5XaXRoIChqc29uLCBtc2csIGZuKSB7XG4gIGlmIChqc29uKSB7XG4gICAgcmV0dXJuIGF3YWl0IGZuKCk7XG4gIH1cbiAgY29uc3Qgc3Bpbm5lciA9IG9yYShtc2cpLnN0YXJ0KCk7XG4gIGxldCByZXM7XG4gIHRyeSB7XG4gICAgcmVzID0gYXdhaXQgZm4oKTtcbiAgICBzcGlubmVyLnN1Y2NlZWQoKTtcbiAgICByZXR1cm4gcmVzO1xuICB9IGNhdGNoIChlcnIpIHtcbiAgICBzcGlubmVyLmZhaWwoKTtcbiAgICB0aHJvdyBlcnI7XG4gIH1cbn1cblxuY2xhc3MgUmluZ0J1ZmZlciB7XG4gIGNvbnN0cnVjdG9yIChzaXplID0gNTApIHtcbiAgICB0aGlzLnNpemUgPSBzaXplO1xuICAgIHRoaXMuYnVmZmVyID0gW107XG4gIH1cbiAgZ2V0QnVmZiAoKSB7XG4gICAgcmV0dXJuIHRoaXMuYnVmZmVyO1xuICB9XG4gIGRlcXVldWUgKCkge1xuICAgIHRoaXMuYnVmZmVyLnNoaWZ0KCk7XG4gIH1cbiAgZW5xdWV1ZSAoaXRlbSkge1xuICAgIGlmICh0aGlzLmJ1ZmZlci5sZW5ndGggPj0gdGhpcy5zaXplKSB7XG4gICAgICB0aGlzLmRlcXVldWUoKTtcbiAgICB9XG4gICAgdGhpcy5idWZmZXIucHVzaChpdGVtKTtcbiAgfVxufVxuXG5leHBvcnQge1xuICBlcnJBbmRRdWl0LFxuICBsb2csXG4gIHNwaW5XaXRoLFxuICBKU09OX1NQQUNFUyxcbiAgUmluZ0J1ZmZlclxufTtcbiJdfQ==

package/build/lib/config-file.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Given an array of errors and the result of loading a config file, generate a
+ * helpful string for the user.
+ *
+ * - If `opts` contains a `json` property, this should be the original JSON
+ *   _string_ of the config file.  This is only applicable if the config file
+ *   was in JSON format. If present, it will associate line numbers with errors.
+ * - If `errors` happens to be empty, this will throw.
+ * @param {import('ajv').ErrorObject[]} errors - Non-empty array of errors. Required.
+ * @param {ReadConfigFileResult['config']|any} [config] -
+ * Configuration & metadata
+ * @param {FormatConfigErrorsOptions} [opts]
+ * @throws {TypeError} If `errors` is empty
+ * @returns {string}
+ */
+export function formatErrors(errors?: import('ajv').ErrorObject[], config?: ReadConfigFileResult['config'] | any, opts?: FormatConfigErrorsOptions | undefined): string;
+/**
+ * Given an optional path, read a config file. Validates the config file.
+ *
+ * Call {@link validate} if you already have a config object.
+ * @param {string} [filepath] - Path to config file, if we have one
+ * @param {ReadConfigFileOptions} [opts] - Options
+ * @public
+ * @returns {Promise<ReadConfigFileResult>} Contains config and filepath, if found, and any errors
+ */
+export function readConfigFile(filepath?: string | undefined, opts?: ReadConfigFileOptions | undefined): Promise<ReadConfigFileResult>;
+/**
+ * Convert schema property names to either a) the value of the `appiumCliDest` property, if any; or b) camel-case
+ * @param {AppiumConfig} config - Configuration object
+ * @returns {NormalizedAppiumConfig} New object with camel-cased keys (or `dest` keys).
+ */
+export function normalizeConfig(config: AppiumConfig): NormalizedAppiumConfig;
+/**
+ * Result of calling {@link readConfigFile }.
+ */
+export type ReadConfigFileResult = {
+    /**
+     * - Validation errors
+     */
+    errors?: import("ajv").ErrorObject<string, Record<string, any>, any>[] | undefined;
+    /**
+     * - The path to the config file, if found
+     */
+    filepath?: string | undefined;
+    /**
+     * - If `true`, the config file exists but is empty
+     */
+    isEmpty?: boolean | undefined;
+    /**
+     * - The parsed configuration
+     */
+    config?: import("@appium/types").NormalizedAppiumConfig | undefined;
+    /**
+     * - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.
+     */
+    reason?: string | import("@sidvind/better-ajv-errors").IOutputError[] | undefined;
+};
+/**
+ * Options for {@link readConfigFile }.
+ */
+export type ReadConfigFileOptions = {
+    /**
+     * 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.
+     */
+    pretty?: boolean | undefined;
+};
+/**
+ * This is an `AsyncSearcher` which is inexplicably _not_ exported by the `lilconfig` type definition.
+ */
+export type LilconfigAsyncSearcher = ReturnType<typeof import("lilconfig")["lilconfig"]>;
+/**
+ * The contents of an Appium config file. Generated from schema
+ */
+export type AppiumConfig = import('@appium/types').AppiumConfig;
+/**
+ * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig }
+ */
+export type NormalizedAppiumConfig = import('@appium/types').NormalizedAppiumConfig;
+/**
+ * The string should be a raw JSON string.
+ */
+export type RawJson = string;
+/**
+ * Options for {@link formatErrors }.
+ */
+export type FormatConfigErrorsOptions = {
+    /**
+     * - Raw JSON config (as string)
+     */
+    json?: string | undefined;
+    /**
+     * - Whether to format errors as a CLI-friendly string
+     */
+    pretty?: boolean | undefined;
+    /**
+     * - Specific ID of a prop; otherwise entire schema
+     */
+    schemaId?: string | undefined;
+};
+//# sourceMappingURL=config-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-file.d.ts","sourceRoot":"","sources":["../../lib/config-file.js"],"names":[],"mappings":"AAiEA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,OAAO,KAAK,EAAE,WAAW,EAAE,WAC3B,oBAAoB,CAAC,QAAQ,CAAC,GAAC,GAAG,iDAIhC,MAAM,CAUlB;AAED;;;;;;;;GAQG;AACH,yGAFa,QAAQ,oBAAoB,CAAC,CA8CzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CA8BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAoBY,WAAW,2BAAoB,WAAW,CAAC,CAAC;;;;2BAK5C,OAAO,eAAe,EAAE,YAAY;;;;qCAKpC,OAAO,eAAe,EAAE,sBAAsB;;;;sBAK9C,MAAM"}

package/build/lib/config-file.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatErrors = formatErrors;
+exports.normalizeConfig = normalizeConfig;
+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 !== null && result !== void 0 && result.filepath && !(result !== null && result !== void 0 && result.isEmpty)) {
+    const {
+      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
+        };
+      }
+
+      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);
+}
+//# 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"]}

package/build/lib/config.d.ts

@@ -0,0 +1,40 @@
+export type ParsedArgs = import('../types/cli').ParsedArgs;
+export type ArgSpec = import("./schema/arg-spec").ArgSpec<any>;
+/**
+ * Mutable object containing Appium build information. By default it
+ * only contains the Appium version, but is updated with the build timestamp
+ * and git commit hash asynchronously as soon as `updateBuildInfo` is called
+ * and succeeds.
+ * @returns {import('../types/cli').BuildInfo}
+ */
+export function getBuildInfo(): import('../types/cli').BuildInfo;
+export function checkNodeOk(): void;
+export function showBuildInfo(): Promise<void>;
+export function warnNodeDeprecations(): void;
+/**
+ * @param {string} tmpDir
+ */
+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>}
+ */
+export function getNonDefaultServerArgs(parsedArgs: ParsedArgs): Partial<ParsedArgs>;
+export function getGitRev(useGithubApiFallback?: boolean): Promise<any>;
+export const APPIUM_VER: any;
+export function updateBuildInfo(useGithubApiFallback?: boolean): Promise<void>;
+/**
+ * Shows a breakdown of the current config after CLI params, config file loaded & defaults applied.
+ *
+ * The actual shape of `preConfigParsedArgs` and `defaults` does not matter for the purposes of this function,
+ * but it's intended to be called with values of type {@link ParsedArgs} and `DefaultValues<true>`, respectively.
+ *
+ * @param {Partial<ParsedArgs>} nonDefaultPreConfigParsedArgs - Parsed CLI args (or param to `init()`) before config & defaults applied
+ * @param {import('./config-file').ReadConfigFileResult} configResult - Result of attempting to load a config file.  _Must_ be normalized
+ * @param {Partial<ParsedArgs>} defaults - Configuration defaults from schemas
+ * @param {ParsedArgs} parsedArgs - Entire parsed args object
+ */
+export function showConfig(nonDefaultPreConfigParsedArgs: Partial<ParsedArgs>, configResult: import('./config-file').ReadConfigFileResult, defaults: Partial<ParsedArgs>, parsedArgs: ParsedArgs): void;
+export const rootDir: string;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +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"}