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

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,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJKU09OX1NQQUNFUyIsImVyckFuZFF1aXQiLCJqc29uIiwibXNnIiwiY29uc29sZSIsImxvZyIsIkpTT04iLCJzdHJpbmdpZnkiLCJlcnJvciIsInJlZCIsInN0ZGVyciIsInByb2Nlc3MiLCJleGl0Iiwic3BpbldpdGgiLCJmbiIsInNwaW5uZXIiLCJzdGFydCIsInJlcyIsInN1Y2NlZWQiLCJlcnIiLCJmYWlsIiwiUmluZ0J1ZmZlciIsImNvbnN0cnVjdG9yIiwic2l6ZSIsImJ1ZmZlciIsImdldEJ1ZmYiLCJkZXF1ZXVlIiwic2hpZnQiLCJlbnF1ZXVlIiwiaXRlbSIsImxlbmd0aCIsInB1c2giXSwic291cmNlcyI6WyIuLi8uLi8uLi9saWIvY2xpL3V0aWxzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qIGVzbGludC1kaXNhYmxlIG5vLWNvbnNvbGUgKi9cblxuaW1wb3J0IG9yYSBmcm9tICdvcmEnO1xuXG5jb25zdCBKU09OX1NQQUNFUyA9IDQ7XG5cbi8qKipcbiAqIExvZyBhbiBlcnJvciB0byB0aGUgY29uc29sZSBhbmQgZXhpdCB0aGUgcHJvY2Vzcy5cbiAqIEBwYXJhbSB7Ym9vbGVhbn0ganNvbiAtIHdoZXRoZXIgd2Ugc2hvdWxkIGxvZyBqc29uIG9yIHRleHRcbiAqIEBwYXJhbSB7YW55fSBtc2cgLSBlcnJvciBtZXNzYWdlLCBvYmplY3QsIEVycm9yIGluc3RhbmNlLCBldGMuXG4gKi9cbmZ1bmN0aW9uIGVyckFuZFF1aXQgKGpzb24sIG1zZykge1xuICBpZiAoanNvbikge1xuICAgIGNvbnNvbGUubG9nKEpTT04uc3RyaW5naWZ5KHtlcnJvcjogYCR7bXNnfWB9LCBudWxsLCBKU09OX1NQQUNFUykpO1xuICB9IGVsc2Uge1xuICAgIGNvbnNvbGUuZXJyb3IoYCR7bXNnfWAucmVkKTtcbiAgICBpZiAobXNnLnN0ZGVycikge1xuICAgICAgY29uc29sZS5lcnJvcihgJHttc2cuc3RkZXJyfWAucmVkKTtcbiAgICB9XG4gIH1cbiAgcHJvY2Vzcy5leGl0KDEpO1xufVxuXG4vKipcbiAqIENvbmRpdGlvbmFsbHkgbG9nIHNvbWV0aGluZyB0byB0aGUgY29uc29sZVxuICogQHBhcmFtIHtib29sZWFufSBqc29uIC0gd2hldGhlciB3ZSBhcmUgaW4ganNvbiBtb2RlIChhbmQgc2hvdWxkIHRoZXJlZm9yZSBub3QgbG9nKVxuICogQHBhcmFtIHtzdHJpbmd9IG1zZyAtIHN0cmluZyB0byBsb2dcbiAqL1xuZnVuY3Rpb24gbG9nIChqc29uLCBtc2cpIHtcbiAgIWpzb24gJiYgY29uc29sZS5sb2cobXNnKTtcbn1cblxuLyoqXG4gKiBTdGFydCBhIHNwaW5uZXIsIGV4ZWN1dGUgYW4gYXN5bmMgZnVuY3Rpb24sIGFuZCB0aGVuIHN0b3AgdGhlIHNwaW5uZXJcbiAqIEBwYXJhbSB7Ym9vbGVhbn0ganNvbiAtIHdoZXRoZXIgd2UgYXJlIGluIGpzb24gbW9kZSAoYW5kIHNob3VsZCB0aGVyZWZvcmUgbm90IGxvZylcbiAqIEBwYXJhbSB7c3RyaW5nfSBtc2cgLSBzdHJpbmcgdG8gbG9nXG4gKiBAcGFyYW0ge2Z1bmN0aW9ufSBmbiAtIGZ1bmN0aW9uIHRvIHdyYXAgd2l0aCBzcGlubmluZ1xuICovXG5hc3luYyBmdW5jdGlvbiBzcGluV2l0aCAoanNvbiwgbXNnLCBmbikge1xuICBpZiAoanNvbikge1xuICAgIHJldHVybiBhd2FpdCBmbigpO1xuICB9XG4gIGNvbnN0IHNwaW5uZXIgPSBvcmEobXNnKS5zdGFydCgpO1xuICBsZXQgcmVzO1xuICB0cnkge1xuICAgIHJlcyA9IGF3YWl0IGZuKCk7XG4gICAgc3Bpbm5lci5zdWNjZWVkKCk7XG4gICAgcmV0dXJuIHJlcztcbiAgfSBjYXRjaCAoZXJyKSB7XG4gICAgc3Bpbm5lci5mYWlsKCk7XG4gICAgdGhyb3cgZXJyO1xuICB9XG59XG5cbmNsYXNzIFJpbmdCdWZmZXIge1xuICBjb25zdHJ1Y3RvciAoc2l6ZSA9IDUwKSB7XG4gICAgdGhpcy5zaXplID0gc2l6ZTtcbiAgICB0aGlzLmJ1ZmZlciA9IFtdO1xuICB9XG4gIGdldEJ1ZmYgKCkge1xuICAgIHJldHVybiB0aGlzLmJ1ZmZlcjtcbiAgfVxuICBkZXF1ZXVlICgpIHtcbiAgICB0aGlzLmJ1ZmZlci5zaGlmdCgpO1xuICB9XG4gIGVucXVldWUgKGl0ZW0pIHtcbiAgICBpZiAodGhpcy5idWZmZXIubGVuZ3RoID49IHRoaXMuc2l6ZSkge1xuICAgICAgdGhpcy5kZXF1ZXVlKCk7XG4gICAgfVxuICAgIHRoaXMuYnVmZmVyLnB1c2goaXRlbSk7XG4gIH1cbn1cblxuZXhwb3J0IHtcbiAgZXJyQW5kUXVpdCxcbiAgbG9nLFxuICBzcGluV2l0aCxcbiAgSlNPTl9TUEFDRVMsXG4gIFJpbmdCdWZmZXJcbn07XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7O0FBRUE7O0FBRUEsTUFBTUEsV0FBVyxHQUFHLENBQXBCOzs7QUFPQSxTQUFTQyxVQUFULENBQXFCQyxJQUFyQixFQUEyQkMsR0FBM0IsRUFBZ0M7RUFDOUIsSUFBSUQsSUFBSixFQUFVO0lBQ1JFLE9BQU8sQ0FBQ0MsR0FBUixDQUFZQyxJQUFJLENBQUNDLFNBQUwsQ0FBZTtNQUFDQyxLQUFLLEVBQUcsR0FBRUwsR0FBSTtJQUFmLENBQWYsRUFBa0MsSUFBbEMsRUFBd0NILFdBQXhDLENBQVo7RUFDRCxDQUZELE1BRU87SUFDTEksT0FBTyxDQUFDSSxLQUFSLENBQWUsR0FBRUwsR0FBSSxFQUFQLENBQVNNLEdBQXZCOztJQUNBLElBQUlOLEdBQUcsQ0FBQ08sTUFBUixFQUFnQjtNQUNkTixPQUFPLENBQUNJLEtBQVIsQ0FBZSxHQUFFTCxHQUFHLENBQUNPLE1BQU8sRUFBZCxDQUFnQkQsR0FBOUI7SUFDRDtFQUNGOztFQUNERSxPQUFPLENBQUNDLElBQVIsQ0FBYSxDQUFiO0FBQ0Q7O0FBT0QsU0FBU1AsR0FBVCxDQUFjSCxJQUFkLEVBQW9CQyxHQUFwQixFQUF5QjtFQUN2QixDQUFDRCxJQUFELElBQVNFLE9BQU8sQ0FBQ0MsR0FBUixDQUFZRixHQUFaLENBQVQ7QUFDRDs7QUFRRCxlQUFlVSxRQUFmLENBQXlCWCxJQUF6QixFQUErQkMsR0FBL0IsRUFBb0NXLEVBQXBDLEVBQXdDO0VBQ3RDLElBQUlaLElBQUosRUFBVTtJQUNSLE9BQU8sTUFBTVksRUFBRSxFQUFmO0VBQ0Q7O0VBQ0QsTUFBTUMsT0FBTyxHQUFHLGtCQUFJWixHQUFKLEVBQVNhLEtBQVQsRUFBaEI7RUFDQSxJQUFJQyxHQUFKOztFQUNBLElBQUk7SUFDRkEsR0FBRyxHQUFHLE1BQU1ILEVBQUUsRUFBZDtJQUNBQyxPQUFPLENBQUNHLE9BQVI7SUFDQSxPQUFPRCxHQUFQO0VBQ0QsQ0FKRCxDQUlFLE9BQU9FLEdBQVAsRUFBWTtJQUNaSixPQUFPLENBQUNLLElBQVI7SUFDQSxNQUFNRCxHQUFOO0VBQ0Q7QUFDRjs7QUFFRCxNQUFNRSxVQUFOLENBQWlCO0VBQ2ZDLFdBQVcsQ0FBRUMsSUFBSSxHQUFHLEVBQVQsRUFBYTtJQUN0QixLQUFLQSxJQUFMLEdBQVlBLElBQVo7SUFDQSxLQUFLQyxNQUFMLEdBQWMsRUFBZDtFQUNEOztFQUNEQyxPQUFPLEdBQUk7SUFDVCxPQUFPLEtBQUtELE1BQVo7RUFDRDs7RUFDREUsT0FBTyxHQUFJO0lBQ1QsS0FBS0YsTUFBTCxDQUFZRyxLQUFaO0VBQ0Q7O0VBQ0RDLE9BQU8sQ0FBRUMsSUFBRixFQUFRO0lBQ2IsSUFBSSxLQUFLTCxNQUFMLENBQVlNLE1BQVosSUFBc0IsS0FBS1AsSUFBL0IsRUFBcUM7TUFDbkMsS0FBS0csT0FBTDtJQUNEOztJQUNELEtBQUtGLE1BQUwsQ0FBWU8sSUFBWixDQUFpQkYsSUFBakI7RUFDRDs7QUFoQmMifQ==

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

@@ -0,0 +1,41 @@
+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
+ * 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 {Args} parsedArgs
+ * @returns {Args}
+ */
+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>;
+/**
+ * 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,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"}