appium 2.0.0-beta.4 → 2.0.0-beta.40

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,8 +34,8 @@ class PluginCommand extends _extensionCommand.default {
     installType,
     packageName
   }) {
-    return await super.install({
-      ext: plugin,
+    return await super._install({
+      installSpec: plugin,
       installType,
       packageName
     });
@@ -47,8 +44,8 @@ class PluginCommand extends _extensionCommand.default {
   async uninstall({
     plugin
   }) {
-    return await super.uninstall({
-      ext: plugin
+    return await super._uninstall({
+      installSpec: plugin
     });
   }
 
@@ -56,12 +53,22 @@ class PluginCommand extends _extensionCommand.default {
     plugin,
     unsafe
   }) {
-    return await super.update({
-      ext: plugin,
+    return await super._update({
+      installSpec: plugin,
       unsafe
     });
   }
 
+  async run({
+    plugin,
+    scriptName
+  }) {
+    return await super._run({
+      installSpec: plugin,
+      scriptName
+    });
+  }
+
   getPostInstallText({
     extName,
     extData
@@ -69,17 +76,15 @@ class PluginCommand extends _extensionCommand.default {
     return `Plugin ${extName}@${extData.version} successfully installed`.green;
   }
 
-  validateExtensionFields(appiumPkgData) {
-    const missingFields = REQ_PLUGIN_FIELDS.reduce((acc, field) => appiumPkgData[field] ? acc : [...acc, field], []);
+  validateExtensionFields(pluginMetadata, installSpec) {
+    const missingFields = REQ_PLUGIN_FIELDS.reduce((acc, field) => pluginMetadata[field] ? acc : [...acc, field], []);
 
     if (!_lodash.default.isEmpty(missingFields)) {
-      throw new Error(`Installed plugin did not expose correct fields for compability ` + `with Appium. Missing fields: ${JSON.stringify(missingFields)}`);
+      throw new Error(`Installed plugin "${installSpec}" did not expose correct fields for compability ` + `with Appium. Missing fields: ${JSON.stringify(missingFields)}`);
     }
   }
 
 }
 
-exports.default = PluginCommand;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,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

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":"AAkEA;;;;;;;;;;;;;;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,CAwCzC;AAED;;;;GAIG;AACH,wCAHW,YAAY,GACV,sBAAsB,CA+BlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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","betterAjvErrors","getSchema","schemaId","json","format","readConfigFile","lilconfig","loaders","noExt","packageProp","result","isEmpty","pretty","configResult","validate","_","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":["import 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} */ (\n        err\n      ).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 ? await loadConfigFile(lc, filepath) : 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 ? {...result, errors, reason} : {...result, errors};\n      }\n\n      // normalize (to camel case) all top-level property names of the config file\n      configResult.config = normalizeConfig(/** @type {AppiumConfig} */ (configResult.config));\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(\n      obj,\n      (__, prop) => 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('appium/types').ParsedArgs;
+export type Args = import('appium/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('appium/types').BuildInfo}
+ */
+export function getBuildInfo(): import('appium/types').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":"yBAuUa,OAAO,cAAc,EAAE,UAAU;mBACjC,OAAO,cAAc,EAAE,IAAI;;AAzMxC;;;;;;GAMG;AACH,gCAFa,OAAO,cAAc,EAAE,SAAS,CAI5C;AAED,oCAKC;AAeD,+CAGC;AAhBD,6CAWC;AA4ID;;GAEG;AACH,uCAFW,MAAM,iBAWhB;AAjJD;;;;GAIG;AACH,oDAHW,IAAI,GACF,IAAI,CAmFhB;AApMD,wEAgCC;AAzED,6BAAsC;AAkBtC,+EAUC;AAiOD;;;;;;;;;;GAUG;AACH,0DALW,QAAQ,UAAU,CAAC,gBACnB,OAAO,eAAe,EAAE,oBAAoB,YAC5C,QAAQ,UAAU,CAAC,cACnB,UAAU,QAoBpB;AAgBD,6BAAuC"}