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

package/build/lib/schema/arg-spec.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SERVER_PROP_NAME = exports.ArgSpec = exports.APPIUM_CONFIG_SCHEMA_ID = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+const APPIUM_CONFIG_SCHEMA_ID = 'appium.json';
+exports.APPIUM_CONFIG_SCHEMA_ID = APPIUM_CONFIG_SCHEMA_ID;
+const SERVER_PROP_NAME = 'server';
+exports.SERVER_PROP_NAME = SERVER_PROP_NAME;
+const SCHEMA_ID_REGEXP = /^(?<extType>.+?)-(?<normalizedExtName>.+)\.json$/;
+const PROPERTIES = 'properties';
+
+class ArgSpec {
+  name;
+  extType;
+  extName;
+  ref;
+  arg;
+  dest;
+  rawDest;
+  defaultValue;
+
+  constructor(name, {
+    extType,
+    extName,
+    dest,
+    defaultValue
+  } = {}) {
+    const arg = ArgSpec.toArg(name, extType, extName);
+    const ref = ArgSpec.toSchemaRef(name, extType, extName);
+
+    const rawDest = _lodash.default.camelCase(dest !== null && dest !== void 0 ? dest : name);
+
+    const destKeypath = extType && extName ? [extType, extName, rawDest].join('.') : rawDest;
+    this.defaultValue = defaultValue;
+    this.name = name;
+    this.extType = extType;
+    this.extName = extName;
+    this.arg = arg;
+    this.dest = destKeypath;
+    this.ref = ref;
+    this.rawDest = rawDest;
+  }
+
+  static toSchemaRef(name, extType, extName) {
+    const baseRef = ArgSpec.toSchemaBaseRef(extType, extName);
+
+    if (extType && extName) {
+      return [`${baseRef}#`, PROPERTIES, name].join('/');
+    }
+
+    return [`${baseRef}#`, PROPERTIES, SERVER_PROP_NAME, PROPERTIES, name].join('/');
+  }
+
+  static toSchemaBaseRef(extType, extName) {
+    if (extType && extName) {
+      return `${extType}-${ArgSpec.toNormalizedExtName(extName)}.json`;
+    }
+
+    return APPIUM_CONFIG_SCHEMA_ID;
+  }
+
+  static toArg(name, extType, extName) {
+    const properName = _lodash.default.kebabCase(name.replace(/^--?/, ''));
+
+    if (extType && extName) {
+      return [extType, _lodash.default.kebabCase(extName), properName].join('-');
+    }
+
+    return properName;
+  }
+
+  static toNormalizedExtName(extName) {
+    return _lodash.default.kebabCase(extName);
+  }
+
+  static extensionInfoFromRootSchemaId(schemaId) {
+    const matches = schemaId.match(SCHEMA_ID_REGEXP);
+
+    if (matches !== null && matches !== void 0 && matches.groups) {
+      const {
+        extType,
+        normalizedExtName
+      } = matches.groups;
+      return {
+        extType,
+        normalizedExtName
+      };
+    }
+
+    return {};
+  }
+
+  static create(name, opts) {
+    return Object.freeze(new ArgSpec(name, opts));
+  }
+
+  toString() {
+    let str = `[ArgSpec] ${this.name} (${this.ref})`;
+
+    if (this.extType && this.extName) {
+      str += ` (ext: ${this.extType}/${this.extName})`;
+    }
+
+    return str;
+  }
+
+}
+
+exports.ArgSpec = ArgSpec;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APPIUM_CONFIG_SCHEMA_ID","SERVER_PROP_NAME","SCHEMA_ID_REGEXP","PROPERTIES","ArgSpec","name","extType","extName","ref","arg","dest","rawDest","defaultValue","constructor","toArg","toSchemaRef","_","camelCase","destKeypath","join","baseRef","toSchemaBaseRef","toNormalizedExtName","properName","kebabCase","replace","extensionInfoFromRootSchemaId","schemaId","matches","match","groups","normalizedExtName","create","opts","Object","freeze","toString","str"],"sources":["../../../lib/schema/arg-spec.js"],"sourcesContent":["import _ from 'lodash';\n\n/**\n * The original ID of the Appium config schema.\n * We use this in the CLI to convert it to `argparse` options.\n */\nexport const APPIUM_CONFIG_SCHEMA_ID = 'appium.json';\n\n/**\n * The schema prop containing server-related options. Everything in here\n * is \"native\" to Appium.\n * Used by {@link flattenSchema} for transforming the schema into CLI args.\n */\nexport const SERVER_PROP_NAME = 'server';\n\n/**\n * Used to parse extension info from a schema ID.\n */\nconst SCHEMA_ID_REGEXP = /^(?<extType>.+?)-(?<normalizedExtName>.+)\\.json$/;\n\n/**\n * Avoid typos by using constants!\n */\nconst PROPERTIES = 'properties';\n\n/**\n * An `ArgSpec` is a class representing metadata about an argument (or config\n * option) used for cross-referencing.\n *\n * This class has no instance methods, and is basically just a read-only \"struct\".\n * @template D\n */\nexport class ArgSpec {\n  /**\n   * The canonical name of the argument. Corresponds to key in schema's `properties` prop.\n   * @type {string}\n   */\n  name;\n\n  /**\n   * The `ExtensionType` of the argument. This will be set if the arg came from an extension;\n   * otherwise it will be `undefined`.\n   * @type {ExtensionType|undefined}\n   */\n  extType;\n\n  /**\n   * The name of the extension, if this argument came from an extension.\n   *\n   * Otherwise `undefined`.\n   * @type {string|undefined}\n   */\n  extName;\n\n  /**\n   * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.\n   *\n   * @type {string}\n   */\n  ref;\n\n  /**\n   * The CLI argument, sans leading dashes.\n   * @type {string}\n   */\n  arg;\n\n  /**\n   * The desired keypath for the argument after arguments have been parsed.\n   *\n   * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with\n   * `<extType>.<extName>.`\n   * @type {string}\n   */\n  dest;\n\n  /**\n   * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.\n   */\n  rawDest;\n\n  /**\n   * Whatever the default value of this argument is, as specified by the\n   * `default` property of the schema.\n   * @type {D|undefined}\n   */\n  defaultValue;\n\n  /**\n   * Builds some computed fields and assigns them to the instance.\n   *\n   * Undefined properties are not assigned.\n   *\n   * The _constructor_ is private. Use {@link ArgSpec.create} instead.\n   * @private\n   * @param {string} name\n   * @param {ArgSpecOptions<D>} [opts]\n   */\n  constructor(name, {extType, extName, dest, defaultValue} = {}) {\n    // we must normalize the extension name to fit into our convention for CLI\n    // args.\n    const arg = ArgSpec.toArg(name, extType, extName);\n\n    const ref = ArgSpec.toSchemaRef(name, extType, extName);\n\n    // if no explicit `dest` provided, just camelCase the name to avoid needing\n    // to use bracket syntax when accessing props on the parsed args object.\n    const rawDest = _.camelCase(dest ?? name);\n\n    const destKeypath = extType && extName ? [extType, extName, rawDest].join('.') : rawDest;\n\n    this.defaultValue = defaultValue;\n    this.name = name;\n    this.extType = extType;\n    this.extName = extName;\n    this.arg = arg;\n    this.dest = destKeypath;\n    this.ref = ref;\n    this.rawDest = rawDest;\n  }\n\n  /**\n   * Return the schema ID (`$id`) for the **argument** given the parameters.\n   *\n   * If you need the \"root\" or \"base\" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Schema ID\n   */\n  static toSchemaRef(name, extType, extName) {\n    const baseRef = ArgSpec.toSchemaBaseRef(extType, extName);\n    if (extType && extName) {\n      return [`${baseRef}#`, PROPERTIES, name].join('/');\n    }\n    return [`${baseRef}#`, PROPERTIES, SERVER_PROP_NAME, PROPERTIES, name].join('/');\n  }\n\n  /**\n   * Return the schema ID for an extension or the base schema ID.\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   */\n  static toSchemaBaseRef(extType, extName) {\n    if (extType && extName) {\n      return `${extType}-${ArgSpec.toNormalizedExtName(extName)}.json`;\n    }\n    return APPIUM_CONFIG_SCHEMA_ID;\n  }\n\n  /**\n   * Return the unique ID for the argument given the parameters.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Unique ID\n   */\n  static toArg(name, extType, extName) {\n    const properName = _.kebabCase(name.replace(/^--?/, ''));\n    if (extType && extName) {\n      return [extType, _.kebabCase(extName), properName].join('-');\n    }\n    return properName;\n  }\n\n  /**\n   * Normalizes a raw extension name (not including the type).\n   * @param {string} extName - Extension name\n   * @returns {string} Normalized extension name\n   */\n  static toNormalizedExtName(extName) {\n    return _.kebabCase(extName);\n  }\n\n  /**\n   * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.\n   * @param {string} schemaId - Root schema ID\n   * @returns { {extType?: ExtensionType, normalizedExtName?: string} }\n   */\n  static extensionInfoFromRootSchemaId(schemaId) {\n    const matches = schemaId.match(SCHEMA_ID_REGEXP);\n    if (matches?.groups) {\n      const {extType, normalizedExtName} =\n        /** @type { {extType: ExtensionType, normalizedExtName: string} } */ (matches.groups);\n      return {extType, normalizedExtName};\n    }\n    return {};\n  }\n\n  /**\n   * Creates an `ArgSpec`\n   *\n   * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's\n   * `properties` property.\n   * @template D\n   * @param {ArgSpecOptions<D>} [opts] - Options\n   * @returns {Readonly<ArgSpec>}\n   */\n  static create(name, opts) {\n    return Object.freeze(new ArgSpec(name, opts));\n  }\n\n  /**\n   * String representation, useful for debugging\n   * @returns {string}\n   */\n  /* istanbul ignore next */\n  toString() {\n    let str = `[ArgSpec] ${this.name} (${this.ref})`;\n    if (this.extType && this.extName) {\n      str += ` (ext: ${this.extType}/${this.extName})`;\n    }\n    return str;\n  }\n}\n\n/**\n * Options for {@link ArgSpec.create}\n * @template D\n * @typedef ArgSpecOptions\n * @property {string} [extName]\n * @property {ExtensionType} [extType]\n * @property {string} [dest]\n * @property {D} [defaultValue]\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n"],"mappings":"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"}

package/build/lib/schema/cli-args.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts the finalized, flattened schema representation into
+ * ArgumentDefinitions for handoff to `argparse`.
+ *
+ * @throws If schema has not been added to ajv (via `finalizeSchema()`)
+ * @returns {import('../cli/args').ArgumentDefinitions} A map of arryas of
+ * aliases to `argparse` arguments; empty if no schema found
+ */
+export function toParserArgs(): import('../cli/args').ArgumentDefinitions;
+/**
+ * <T>
+ */
+export type FormatValidator<T> = import('ajv/dist/types').FormatValidator<T>;
+/**
+ * A JSON 7 schema with our custom keywords.
+ */
+export type AppiumJSONSchema = import('./keywords').AppiumJSONSchemaKeywords & import('json-schema').JSONSchema7;
+export type ArgSpec = import("./arg-spec").ArgSpec<any>;
+//# sourceMappingURL=cli-args.d.ts.map

package/build/lib/schema/cli-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../../../lib/schema/cli-args.js"],"names":[],"mappings":"AAoNA;;;;;;;GAOG;AACH,gCAHa,OAAO,aAAa,EAAE,mBAAmB,CAMrD;;;;iCAIY,OAAO,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC;;;;+BAK3C,OAAO,YAAY,EAAE,wBAAwB,GAAG,OAAO,aAAa,EAAE,WAAW"}

package/build/lib/schema/cli-args.js

@@ -0,0 +1,180 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toParserArgs = toParserArgs;
+
+require("source-map-support/register");
+
+var _argparse = require("argparse");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _configFile = require("../config-file");
+
+var _schema = require("./schema");
+
+var _cliTransformers = require("./cli-transformers");
+
+const TYPENAMES = Object.freeze({
+  ARRAY: 'array',
+  OBJECT: 'object',
+  BOOLEAN: 'boolean',
+  INTEGER: 'integer',
+  NUMBER: 'number',
+  NULL: 'null',
+  STRING: 'string'
+});
+const SHORT_ARG_CUTOFF = 3;
+
+function aliasToFlag(argSpec, alias) {
+  const {
+    extType,
+    extName,
+    name
+  } = argSpec;
+  const arg = alias !== null && alias !== void 0 ? alias : name;
+  const isShort = arg.length < SHORT_ARG_CUTOFF;
+
+  if (extType && extName) {
+    return isShort ? `--${extType}-${_lodash.default.kebabCase(extName)}-${arg}` : `--${extType}-${_lodash.default.kebabCase(extName)}-${_lodash.default.kebabCase(arg)}`;
+  }
+
+  return isShort ? `-${arg}` : `--${_lodash.default.kebabCase(arg)}`;
+}
+
+const screamingSnakeCase = _lodash.default.flow(_lodash.default.snakeCase, _lodash.default.toUpper);
+
+function getSchemaValidator({
+  ref: schemaId
+}, coerce = _lodash.default.identity) {
+  return value => {
+    const coerced = coerce(value);
+    const errors = (0, _schema.validate)(coerced, schemaId);
+
+    if (_lodash.default.isEmpty(errors)) {
+      return coerced;
+    }
+
+    throw new _argparse.ArgumentTypeError('\n\n' + (0, _configFile.formatErrors)(errors, value, {
+      schemaId
+    }));
+  };
+}
+
+function makeDescription(schema) {
+  const {
+    appiumCliDescription,
+    description = '',
+    appiumDeprecated
+  } = schema;
+  let desc = appiumCliDescription !== null && appiumCliDescription !== void 0 ? appiumCliDescription : description;
+
+  if (appiumDeprecated) {
+    desc = `[DEPRECATED] ${desc}`;
+  }
+
+  return desc;
+}
+
+function subSchemaToArgDef(subSchema, argSpec) {
+  let {
+    type,
+    appiumCliAliases,
+    appiumCliTransformer,
+    enum: enumValues
+  } = subSchema;
+  const {
+    name,
+    arg
+  } = argSpec;
+  const aliases = [aliasToFlag(argSpec), ...(appiumCliAliases !== null && appiumCliAliases !== void 0 ? appiumCliAliases : []).map(alias => aliasToFlag(argSpec, alias))];
+  let argOpts = {
+    required: false,
+    help: makeDescription(subSchema)
+  };
+  let argTypeFunction;
+
+  switch (type) {
+    case TYPENAMES.BOOLEAN:
+      {
+        argOpts.action = 'store_const';
+        argOpts.const = true;
+        break;
+      }
+
+    case TYPENAMES.OBJECT:
+      {
+        argTypeFunction = _cliTransformers.transformers.json;
+        break;
+      }
+
+    case TYPENAMES.ARRAY:
+      {
+        argTypeFunction = _cliTransformers.transformers.csv;
+        break;
+      }
+
+    case TYPENAMES.NUMBER:
+      {
+        argTypeFunction = getSchemaValidator(argSpec, parseFloat);
+        break;
+      }
+
+    case TYPENAMES.INTEGER:
+      {
+        argTypeFunction = getSchemaValidator(argSpec, _lodash.default.parseInt);
+        break;
+      }
+
+    case TYPENAMES.STRING:
+      {
+        argTypeFunction = getSchemaValidator(argSpec);
+        break;
+      }
+
+    case TYPENAMES.NULL:
+    default:
+      {
+        throw new TypeError(`Schema property "${arg}": \`${type}\` type unknown or disallowed`);
+      }
+  }
+
+  if (type !== TYPENAMES.BOOLEAN) {
+    argOpts.metavar = screamingSnakeCase(name);
+  }
+
+  if (type !== TYPENAMES.ARRAY && type !== TYPENAMES.OBJECT && appiumCliTransformer) {
+    var _argTypeFunction;
+
+    argTypeFunction = _lodash.default.flow((_argTypeFunction = argTypeFunction) !== null && _argTypeFunction !== void 0 ? _argTypeFunction : _lodash.default.identity, _cliTransformers.transformers[appiumCliTransformer]);
+  }
+
+  if (argTypeFunction) {
+    argOpts.type = argTypeFunction;
+  }
+
+  if (enumValues && !_lodash.default.isEmpty(enumValues)) {
+    if (type === TYPENAMES.STRING) {
+      argOpts.choices = enumValues.map(String);
+    } else {
+      throw new TypeError(`Problem with schema for ${arg}; \`enum\` is only supported for \`type: 'string'\``);
+    }
+  }
+
+  return [aliases, argOpts];
+}
+
+function toParserArgs() {
+  const flattened = (0, _schema.flattenSchema)().filter(({
+    schema
+  }) => !schema.appiumCliIgnored);
+  return new Map(_lodash.default.map(flattened, ({
+    schema,
+    argSpec
+  }) => subSchemaToArgDef(schema, argSpec)));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["TYPENAMES","Object","freeze","ARRAY","OBJECT","BOOLEAN","INTEGER","NUMBER","NULL","STRING","SHORT_ARG_CUTOFF","aliasToFlag","argSpec","alias","extType","extName","name","arg","isShort","length","_","kebabCase","screamingSnakeCase","flow","snakeCase","toUpper","getSchemaValidator","ref","schemaId","coerce","identity","value","coerced","errors","validate","isEmpty","ArgumentTypeError","formatErrors","makeDescription","schema","appiumCliDescription","description","appiumDeprecated","desc","subSchemaToArgDef","subSchema","type","appiumCliAliases","appiumCliTransformer","enum","enumValues","aliases","map","argOpts","required","help","argTypeFunction","action","const","transformers","json","csv","parseFloat","parseInt","TypeError","metavar","choices","String","toParserArgs","flattened","flattenSchema","filter","appiumCliIgnored","Map"],"sources":["../../../lib/schema/cli-args.js"],"sourcesContent":["import {ArgumentTypeError} from 'argparse';\nimport _ from 'lodash';\nimport {formatErrors as formatErrors} from '../config-file';\nimport {flattenSchema, validate} from './schema';\nimport {transformers} from './cli-transformers';\n\n/**\n * This module concerns functions which convert schema definitions to\n * `argparse`-compatible data structures, for deriving CLI arguments from a\n * schema.\n */\n\n/**\n * Lookup of possible values for the `type` field in a JSON schema.\n * @type {Readonly<Record<string, import('json-schema').JSONSchema7TypeName>>}\n */\nconst TYPENAMES = Object.freeze({\n  ARRAY: 'array',\n  OBJECT: 'object',\n  BOOLEAN: 'boolean',\n  INTEGER: 'integer',\n  NUMBER: 'number',\n  NULL: 'null',\n  STRING: 'string',\n});\n\n/**\n * Options with alias lengths less than this will be considered \"short\" flags.\n */\nconst SHORT_ARG_CUTOFF = 3;\n\n/**\n * Convert an alias (`foo`) to a flag (`--foo`) or a short flag (`-f`).\n * @param {ArgSpec} argSpec - the argument specification\n * @param {string} [alias] - the alias to convert to a flag\n * @returns {string} the flag\n */\nfunction aliasToFlag(argSpec, alias) {\n  const {extType, extName, name} = argSpec;\n  const arg = alias ?? name;\n  const isShort = arg.length < SHORT_ARG_CUTOFF;\n  if (extType && extName) {\n    return isShort\n      ? `--${extType}-${_.kebabCase(extName)}-${arg}`\n      : `--${extType}-${_.kebabCase(extName)}-${_.kebabCase(arg)}`;\n  }\n  return isShort ? `-${arg}` : `--${_.kebabCase(arg)}`;\n}\n\n/**\n * Converts a string to SCREAMING_SNAKE_CASE\n */\nconst screamingSnakeCase = _.flow(_.snakeCase, _.toUpper);\n\n/**\n * Given unique property name `name`, return a function which validates a value\n * against a property within the schema.\n * @template Coerced\n * @param {ArgSpec} argSpec - Argument name\n * @param {(value: string) => Coerced} [coerce] - Function to coerce to a different\n * primitive\n * @todo See if we can remove `coerce` by allowing Ajv to coerce in its\n * constructor options\n * @returns\n */\nfunction getSchemaValidator({ref: schemaId}, coerce = _.identity) {\n  /** @param {string} value */\n  return (value) => {\n    const coerced = coerce(value);\n    const errors = validate(coerced, schemaId);\n    if (_.isEmpty(errors)) {\n      return coerced;\n    }\n    throw new ArgumentTypeError('\\n\\n' + formatErrors(errors, value, {schemaId}));\n  };\n}\n\n/**\n * Determine the description for display on the CLI, given the schema.\n * @param {AppiumJSONSchema} schema\n * @returns {string}\n */\nfunction makeDescription(schema) {\n  const {appiumCliDescription, description = '', appiumDeprecated} = schema;\n  let desc = appiumCliDescription ?? description;\n  if (appiumDeprecated) {\n    desc = `[DEPRECATED] ${desc}`;\n  }\n  return desc;\n}\n\n/**\n * Given arg `name`, a JSON schema `subSchema`, and options, return an argument definition\n * as understood by `argparse`.\n * @param {AppiumJSONSchema} subSchema - JSON schema for the option\n * @param {ArgSpec} argSpec - Argument spec tuple\n * @returns {[string[], import('argparse').ArgumentOptions]} Tuple of flag and options\n */\nfunction subSchemaToArgDef(subSchema, argSpec) {\n  let {type, appiumCliAliases, appiumCliTransformer, enum: enumValues} = subSchema;\n\n  const {name, arg} = argSpec;\n\n  const aliases = [\n    aliasToFlag(argSpec),\n    .../** @type {string[]} */ (appiumCliAliases ?? []).map((alias) => aliasToFlag(argSpec, alias)),\n  ];\n\n  /** @type {import('argparse').ArgumentOptions} */\n  let argOpts = {\n    required: false,\n    help: makeDescription(subSchema),\n  };\n\n  /**\n   * Generally we will provide a `type` to `argparse` as a function which\n   * validates using ajv (which is much more full-featured than what `argparse`\n   * can offer). The exception is `boolean`-type options, which have no\n   * `argType`.\n   *\n   * Not sure if this type is correct, but it's not doing what I want.  I want\n   * to say \"this is a function which returns something of type `T` where `T` is\n   * never a `Promise`\".  This function must be sync.\n   * @type {((value: string) => unknown)|undefined}\n   */\n  let argTypeFunction;\n\n  // handle special cases for various types\n  switch (type) {\n    // booleans do not have a type per `ArgumentOptions`, just an \"action\"\n    // NOTE: due to limitations of `argparse`, we cannot provide fancy help text, and must rely on its internal error messaging.\n    case TYPENAMES.BOOLEAN: {\n      argOpts.action = 'store_const';\n      argOpts.const = true;\n      break;\n    }\n\n    case TYPENAMES.OBJECT: {\n      argTypeFunction = transformers.json;\n      break;\n    }\n\n    // arrays are treated as CSVs, because `argparse` doesn't handle array data.\n    case TYPENAMES.ARRAY: {\n      argTypeFunction = transformers.csv;\n      break;\n    }\n\n    // \"number\" type is coerced to float. `argparse` does this for us if we use `float` type, but\n    // we don't.\n    case TYPENAMES.NUMBER: {\n      argTypeFunction = getSchemaValidator(argSpec, parseFloat);\n      break;\n    }\n\n    // \"integer\" is coerced to an .. integer.  again, `argparse` would do this for us if we used `int`.\n    case TYPENAMES.INTEGER: {\n      argTypeFunction = getSchemaValidator(argSpec, _.parseInt);\n      break;\n    }\n\n    // strings (like number and integer) are subject to further validation\n    // (e.g., must satisfy a mask or regex or even some custom validation\n    // function)\n    case TYPENAMES.STRING: {\n      argTypeFunction = getSchemaValidator(argSpec);\n      break;\n    }\n\n    // TODO: there may be some way to restrict this at the Ajv level --\n    // that may involve patching the metaschema.\n    case TYPENAMES.NULL:\n    // falls through\n    default: {\n      throw new TypeError(`Schema property \"${arg}\": \\`${type}\\` type unknown or disallowed`);\n    }\n  }\n\n  // metavar is used in help text. `boolean` cannot have a metavar--it is not\n  // displayed--and `argparse` throws if you give it one.\n  if (type !== TYPENAMES.BOOLEAN) {\n    argOpts.metavar = screamingSnakeCase(name);\n  }\n\n  // the validity of \"appiumCliTransformer\" should already have been determined\n  // by ajv during schema validation in `finalizeSchema()`. the `array` &\n  // `object` types have already added a formatter (see above, so we don't do it\n  // twice).\n  if (type !== TYPENAMES.ARRAY && type !== TYPENAMES.OBJECT && appiumCliTransformer) {\n    argTypeFunction = _.flow(argTypeFunction ?? _.identity, transformers[appiumCliTransformer]);\n  }\n\n  if (argTypeFunction) {\n    argOpts.type = argTypeFunction;\n  }\n\n  // convert JSON schema `enum` to `choices`. `enum` can contain any JSON type, but `argparse`\n  // is limited to a single type per arg (I think).  so let's make everything a string.\n  // and might as well _require_ the `type: string` while we're at it.\n  if (enumValues && !_.isEmpty(enumValues)) {\n    if (type === TYPENAMES.STRING) {\n      argOpts.choices = enumValues.map(String);\n    } else {\n      throw new TypeError(\n        `Problem with schema for ${arg}; \\`enum\\` is only supported for \\`type: 'string'\\``\n      );\n    }\n  }\n\n  return [aliases, argOpts];\n}\n\n/**\n * Converts the finalized, flattened schema representation into\n * ArgumentDefinitions for handoff to `argparse`.\n *\n * @throws If schema has not been added to ajv (via `finalizeSchema()`)\n * @returns {import('../cli/args').ArgumentDefinitions} A map of arryas of\n * aliases to `argparse` arguments; empty if no schema found\n */\nexport function toParserArgs() {\n  const flattened = flattenSchema().filter(({schema}) => !schema.appiumCliIgnored);\n  return new Map(_.map(flattened, ({schema, argSpec}) => subSchemaToArgDef(schema, argSpec)));\n}\n\n/**\n * @template T\n * @typedef {import('ajv/dist/types').FormatValidator<T>} FormatValidator<T>\n */\n\n/**\n * A JSON 7 schema with our custom keywords.\n * @typedef {import('./keywords').AppiumJSONSchemaKeywords & import('json-schema').JSONSchema7} AppiumJSONSchema\n */\n\n/**\n * @typedef {import('./arg-spec').ArgSpec} ArgSpec\n */\n"],"mappings":"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"}

package/build/lib/schema/cli-transformers.d.ts

@@ -0,0 +1,5 @@
+export namespace transformers {
+    function csv(value: string): string[];
+    function json(jsonOrPath: string): any;
+}
+//# sourceMappingURL=cli-transformers.d.ts.map

package/build/lib/schema/cli-transformers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-transformers.d.ts","sourceRoot":"","sources":["../../../lib/schema/cli-transformers.js"],"names":[],"mappings":";IA4DO,sCAiBJ;IAOK,uCA6BL"}

package/build/lib/schema/cli-transformers.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformers = void 0;
+
+require("source-map-support/register");
+
+var _argparse = require("argparse");
+
+var _fs = require("fs");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+function parseCsvLine(value) {
+  return value.split(',').map(v => v.trim()).filter(Boolean);
+}
+
+function parseCsvFile(value) {
+  return value.split(/\r?\n/).map(v => v.trim()).filter(Boolean).flatMap(parseCsvLine);
+}
+
+const transformers = {
+  csv: value => {
+    let body;
+
+    try {
+      body = (0, _fs.readFileSync)(value, 'utf8');
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw new _argparse.ArgumentTypeError(`Could not read file ${body}: ${err.message}`);
+      }
+    }
+
+    try {
+      return body ? parseCsvFile(body) : parseCsvLine(value);
+    } catch (err) {
+      throw new _argparse.ArgumentTypeError('Must be a comma-delimited string, e.g., "foo,bar,baz"');
+    }
+  },
+  json: jsonOrPath => {
+    let json = jsonOrPath;
+    let loadedFromFile = false;
+
+    try {
+      json = (0, _fs.readFileSync)(jsonOrPath, 'utf8');
+      loadedFromFile = true;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        throw err;
+      }
+    }
+
+    try {
+      const result = JSON.parse(json);
+
+      if (!_lodash.default.isPlainObject(result)) {
+        throw new Error(`'${_lodash.default.truncate(result, {
+          length: 100
+        })}' is not an object`);
+      }
+
+      return result;
+    } catch (e) {
+      const msg = loadedFromFile ? `The provided value of '${jsonOrPath}' must be a valid JSON` : `The provided value must be a valid JSON`;
+      throw new TypeError(`${msg}. Original error: ${e.message}`);
+    }
+  }
+};
+exports.transformers = transformers;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/schema/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./schema";
+export * from "./cli-args";
+//# sourceMappingURL=index.d.ts.map

package/build/lib/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/schema/index.js"],"names":[],"mappings":""}

package/build/lib/schema/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+require("source-map-support/register");
+
+var _schema = require("./schema");
+
+Object.keys(_schema).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _schema[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _schema[key];
+    }
+  });
+});
+
+var _cliArgs = require("./cli-args");
+
+Object.keys(_cliArgs).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cliArgs[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cliArgs[key];
+    }
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3NjaGVtYS9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL2NsaS1hcmdzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtFQUFBO0VBQUE7RUFBQTtJQUFBO0lBQUE7TUFBQTtJQUFBO0VBQUE7QUFBQTs7QUFDQTs7QUFBQTtFQUFBO0VBQUE7RUFBQTtJQUFBO0lBQUE7TUFBQTtJQUFBO0VBQUE7QUFBQSJ9

package/build/lib/schema/keywords.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Collection of keyword definitions to add to the singleton `Ajv` instance.
+ * @type {Record<string,KeywordDefinition>}
+ */
+export const keywords: Record<string, KeywordDefinition>;
+/**
+ * These are the valid values for the `appiumCliTransformer` keyword.
+ * Unfortunately, TS cannot infer this in a JS context.  In TS, we'd use
+ * `as const` when defining `argTransformers`, then get `keyof typeof argTransformers`. alas.
+ */
+export type AppiumCliTransformerName = 'csv' | 'json';
+/**
+ * These are the custom keywords that Appium recognizes.
+ */
+export type AppiumJSONSchemaKeywords = {
+    appiumCliDest?: string | undefined;
+    appiumCliDescription?: string | undefined;
+    appiumCliAliases?: string[] | undefined;
+    appiumCliIgnored?: boolean | undefined;
+    appiumCliTransformer?: AppiumCliTransformerName | undefined;
+    appiumDeprecated?: boolean | undefined;
+};
+export type KeywordDefinition = import('ajv').KeywordDefinition;
+//# sourceMappingURL=keywords.d.ts.map

package/build/lib/schema/keywords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../../lib/schema/keywords.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,uBAFU,OAAO,MAAM,EAAC,iBAAiB,CAAC,CA4GxC;;;;;;uCAMW,KAAK,GAAC,MAAM;;;;;;;;;;;;gCAgBZ,OAAO,KAAK,EAAE,iBAAiB"}

package/build/lib/schema/keywords.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.keywords = void 0;
+
+require("source-map-support/register");
+
+var _cliTransformers = require("./cli-transformers");
+
+const keywords = {
+  appiumCliAliases: {
+    keyword: 'appiumCliAliases',
+    metaSchema: {
+      type: 'array',
+      items: {
+        type: 'string',
+        minLength: 1
+      },
+      minItems: 1,
+      uniqueItems: true,
+      description: 'List of aliases for the argument. Aliases shorter than three (3) characters will be prefixed with a single dash; otherwise two (2).'
+    }
+  },
+  appiumCliDest: {
+    keyword: 'appiumCliDest',
+    metaSchema: {
+      type: 'string',
+      minLength: 1,
+      description: 'Name of the associated property in the parsed CLI arguments object'
+    }
+  },
+  appiumCliDescription: {
+    keyword: 'appiumCliDescription',
+    schemaType: 'string',
+    metaSchema: {
+      type: 'string',
+      minLength: 1,
+      description: 'Description to provide in the --help text of the CLI. Overrides `description`'
+    }
+  },
+  appiumCliTransformer: {
+    keyword: 'appiumCliTransformer',
+    metaSchema: {
+      type: 'string',
+      enum: Object.keys(_cliTransformers.transformers),
+      description: 'The name of a custom transformer to run against the value as provided via the CLI.'
+    }
+  },
+  appiumCliIgnored: {
+    keyword: 'appiumCliIgnored',
+    metaSchema: {
+      type: 'boolean',
+      description: 'If `true`, Appium will not provide this property as a CLI argument. This is NOT the same as a "hidden" argument.',
+      enum: [true]
+    }
+  },
+  appiumDeprecated: {
+    keyword: 'appiumDeprecated',
+    metaSchema: {
+      type: 'boolean',
+      description: 'If `true`, this property will be displayed as "deprecated" to the user',
+      enum: [true],
+      $comment: 'JSON schema draft-2019-09 keyword `deprecated` serves the same purpose. This keyword should itself be deprecated if we move to draft-2019-09!'
+    }
+  }
+};
+exports.keywords = keywords;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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