appium 2.0.0-beta.25 → 2.0.0-beta.28

package/build/lib/schema/arg-spec.d.ts

@@ -0,0 +1,143 @@
+/**
+ * The original ID of the Appium config schema.
+ * We use this in the CLI to convert it to `argparse` options.
+ */
+export const APPIUM_CONFIG_SCHEMA_ID: "appium.json";
+/**
+ * The schema prop containing server-related options. Everything in here
+ * is "native" to Appium.
+ * Used by {@link flattenSchema} for transforming the schema into CLI args.
+ */
+export const SERVER_PROP_NAME: "server";
+/**
+ * An `ArgSpec` is a class representing metadata about an argument (or config
+ * option) used for cross-referencing.
+ *
+ * This class has no instance methods, and is basically just a read-only "struct".
+ * @template D
+ */
+export class ArgSpec<D> {
+    /**
+     * Return the schema ID (`$id`) for the **argument** given the parameters.
+     *
+     * If you need the "root" or "base" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Schema ID
+     */
+    static toSchemaRef(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the schema ID for an extension or the base schema ID.
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     */
+    static toSchemaBaseRef(extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Return the unique ID for the argument given the parameters.
+     * @param {string} name - Argument name
+     * @param {ExtensionType} [extType] - Extension type
+     * @param {string} [extName] - Extension name
+     * @returns {string} Unique ID
+     */
+    static toArg(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): string;
+    /**
+     * Normalizes a raw extension name (not including the type).
+     * @param {string} extName - Extension name
+     * @returns {string} Normalized extension name
+     */
+    static toNormalizedExtName(extName: string): string;
+    /**
+     * 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.
+     * @param {string} schemaId - Root schema ID
+     * @returns { {extType?: ExtensionType, normalizedExtName?: string} }
+     */
+    static extensionInfoFromRootSchemaId(schemaId: string): {
+        extType?: ExtensionType;
+        normalizedExtName?: string;
+    };
+    /**
+     * Creates an `ArgSpec`
+     *
+     * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's
+     * `properties` property.
+     * @template D
+     * @param {ArgSpecOptions<D>} [opts] - Options
+     * @returns {Readonly<ArgSpec>}
+     */
+    static create<D_1>(name: string, opts?: ArgSpecOptions<D_1> | undefined): Readonly<ArgSpec<any>>;
+    /**
+     * Builds some computed fields and assigns them to the instance.
+     *
+     * Undefined properties are not assigned.
+     *
+     * The _constructor_ is private. Use {@link ArgSpec.create} instead.
+     * @private
+     * @param {string} name
+     * @param {ArgSpecOptions<D>} [opts]
+     */
+    private constructor();
+    /**
+     * The canonical name of the argument. Corresponds to key in schema's `properties` prop.
+     * @type {string}
+     */
+    name: string;
+    /**
+     * The `ExtensionType` of the argument. This will be set if the arg came from an extension;
+     * otherwise it will be `undefined`.
+     * @type {ExtensionType|undefined}
+     */
+    extType: ExtensionType | undefined;
+    /**
+     * The name of the extension, if this argument came from an extension.
+     *
+     * Otherwise `undefined`.
+     * @type {string|undefined}
+     */
+    extName: string | undefined;
+    /**
+     * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.
+     *
+     * @type {string}
+     */
+    ref: string;
+    /**
+     * The CLI argument, sans leading dashes.
+     * @type {string}
+     */
+    arg: string;
+    /**
+     * The desired keypath for the argument after arguments have been parsed.
+     *
+     * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with
+     * `<extType>.<extName>.`
+     * @type {string}
+     */
+    dest: string;
+    /**
+     * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.
+     */
+    rawDest: string;
+    /**
+     * Whatever the default value of this argument is, as specified by the
+     * `default` property of the schema.
+     * @type {D|undefined}
+     */
+    defaultValue: D | undefined;
+    /**
+     * String representation, useful for debugging
+     * @returns {string}
+     */
+    toString(): string;
+}
+/**
+ * Options for {@link ArgSpec.create }
+ */
+export type ArgSpecOptions<D> = {
+    extName?: string | undefined;
+    extType?: import("../../types").ExtensionType | undefined;
+    dest?: string | undefined;
+    defaultValue?: D | undefined;
+};
+export type ExtensionType = import('../extension/manifest').ExtensionType;
+//# sourceMappingURL=arg-spec.d.ts.map

package/build/lib/schema/arg-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arg-spec.d.ts","sourceRoot":"","sources":["../../../lib/schema/arg-spec.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oDAAqD;AAErD;;;;GAIG;AACH,wCAAyC;AAYzC;;;;;;GAMG;AACH;IA0FE;;;;;;;;OAQG;IACH,yBALW,MAAM,4FAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,wHAKC;IAED;;;;;;OAMG;IACH,mBALW,MAAM,4FAGJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,oCAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,+CAHW,MAAM,GACH;QAAC,OAAO,CAAC,EAAE,aAAa,CAAC;QAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAC,CAYlE;IAED;;;;;;;;OAQG;IACH,yBANW,MAAM,2CAIJ,sBAAiB,CAI7B;IAnHD;;;;;;;;;OASG;IACH,sBAsBC;IAvFD;;;OAGG;IACH,MAFU,MAAM,CAEX;IAEL;;;;OAIG;IACH,SAFU,aAAa,GAAC,SAAS,CAEzB;IAER;;;;;OAKG;IACH,SAFU,MAAM,GAAC,SAAS,CAElB;IAER;;;;OAIG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;OAGG;IACH,KAFU,MAAM,CAEZ;IAEJ;;;;;;OAMG;IACH,MAFU,MAAM,CAEX;IAEL;;OAEG;IACH,gBAAQ;IAER;;;;OAIG;IACH,cAFU,CAAC,GAAC,SAAS,CAER;IAuHb;;;OAGG;IAEH,YAHa,MAAM,CASlB;CACF;;;;;;;;;;4BAaY,OAAO,uBAAuB,EAAE,aAAa"}

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

@@ -7,8 +7,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.SERVER_PROP_NAME = exports.ArgSpec = exports.APPIUM_CONFIG_SCHEMA_ID = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 require("source-map-support/register");
 
 var _lodash = _interopRequireDefault(require("lodash"));
@@ -21,20 +19,21 @@ 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
   } = {}) {
-    (0, _defineProperty2.default)(this, "name", void 0);
-    (0, _defineProperty2.default)(this, "extType", void 0);
-    (0, _defineProperty2.default)(this, "extName", void 0);
-    (0, _defineProperty2.default)(this, "ref", void 0);
-    (0, _defineProperty2.default)(this, "arg", void 0);
-    (0, _defineProperty2.default)(this, "dest", void 0);
-    (0, _defineProperty2.default)(this, "rawDest", void 0);
-    (0, _defineProperty2.default)(this, "defaultValue", void 0);
     const arg = ArgSpec.toArg(name, extType, extName);
     const ref = ArgSpec.toSchemaRef(name, extType, extName);
 
@@ -116,7 +115,5 @@ class ArgSpec {
 
 }
 
-exports.ArgSpec = ArgSpec;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/schema/arg-spec.js"],"names":["APPIUM_CONFIG_SCHEMA_ID","SERVER_PROP_NAME","SCHEMA_ID_REGEXP","PROPERTIES","ArgSpec","constructor","name","extType","extName","dest","defaultValue","arg","toArg","ref","toSchemaRef","rawDest","_","camelCase","destKeypath","join","baseRef","toSchemaBaseRef","toNormalizedExtName","properName","kebabCase","replace","extensionInfoFromRootSchemaId","schemaId","matches","match","groups","normalizedExtName","create","opts","Object","freeze","toString","str"],"mappings":"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","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 */\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}\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   * @template D\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 =\n      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|undefined, normalizedExtName: string|undefined} }\n   */\n  static extensionInfoFromRootSchemaId (schemaId) {\n    const matches = schemaId.match(SCHEMA_ID_REGEXP);\n    if (matches?.groups) {\n      const {extType, normalizedExtName} = 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   * @param {ArgSpecOptions} [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 {Object} ArgSpecOptions\n * @property {string} [extName]\n * @property {ExtensionType} [extType]\n * @property {string} [dest]\n * @property {D} [defaultValue]\n */\n\n/**\n * @typedef {import('../ext-config-io').ExtensionType} ExtensionType\n */\n"],"file":"lib/schema/arg-spec.js","sourceRoot":"../../.."}
+exports.ArgSpec = ArgSpec;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/arg-spec.js"],"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"],"mappings":"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","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 =\n      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} } */ (\n          matches.groups\n        );\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"]}

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":"AAuOA;;;;;;;GAOG;AACH,gCAHa,OAAO,aAAa,EAAE,mBAAmB,CAUrD;;;;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

@@ -176,7 +176,5 @@ function toParserArgs() {
     schema,
     argSpec
   }) => subSchemaToArgDef(schema, argSpec)));
-}require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/schema/cli-args.js"],"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","isEmpty","ArgumentTypeError","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","filter","appiumCliIgnored","Map"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {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\\n' + formatErrors(errors, value, {schemaId}),\n    );\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 {\n    type,\n    appiumCliAliases,\n    appiumCliTransformer,\n    enum: enumValues,\n  } = subSchema;\n\n  const {name, arg} = argSpec;\n\n  const aliases = [\n    aliasToFlag(argSpec),\n    .../** @type {string[]} */ (appiumCliAliases ?? []).map((alias) =>\n      aliasToFlag(argSpec, alias),\n    ),\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    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(\n        `Schema property \"${arg}\": \\`${type}\\` type unknown or disallowed`,\n      );\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 (\n    type !== TYPENAMES.ARRAY &&\n    type !== TYPENAMES.OBJECT &&\n    appiumCliTransformer\n  ) {\n    argTypeFunction = _.flow(\n      argTypeFunction ?? _.identity,\n      transformers[appiumCliTransformer],\n    );\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(\n    _.map(flattened, ({schema, argSpec}) =>\n      subSchemaToArgDef(schema, argSpec),\n    ),\n  );\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"],"file":"lib/schema/cli-args.js","sourceRoot":"../../.."}
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/cli-args.js"],"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","isEmpty","ArgumentTypeError","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","filter","appiumCliIgnored","Map"],"mappings":"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","sourcesContent":["\nimport {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\\n' + formatErrors(errors, value, {schemaId}),\n    );\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 {\n    type,\n    appiumCliAliases,\n    appiumCliTransformer,\n    enum: enumValues,\n  } = subSchema;\n\n  const {name, arg} = argSpec;\n\n  const aliases = [\n    aliasToFlag(argSpec),\n    .../** @type {string[]} */ (appiumCliAliases ?? []).map((alias) =>\n      aliasToFlag(argSpec, alias),\n    ),\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(\n        `Schema property \"${arg}\": \\`${type}\\` type unknown or disallowed`,\n      );\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 (\n    type !== TYPENAMES.ARRAY &&\n    type !== TYPENAMES.OBJECT &&\n    appiumCliTransformer\n  ) {\n    argTypeFunction = _.flow(\n      argTypeFunction ?? _.identity,\n      transformers[appiumCliTransformer],\n    );\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(\n    _.map(flattened, ({schema, argSpec}) =>\n      subSchemaToArgDef(schema, argSpec),\n    ),\n  );\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"]}

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":";IA6DO,sCAqBJ;IAOK,uCA+BL"}

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

@@ -70,7 +70,5 @@ const transformers = {
     }
   }
 };
-exports.transformers = transformers;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+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

@@ -30,7 +30,5 @@ Object.keys(_cliArgs).forEach(function (key) {
       return _cliArgs[key];
     }
   });
-});require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9zY2hlbWEvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTs7QUFDQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vY2xpLWFyZ3MnO1xuIl0sImZpbGUiOiJsaWIvc2NoZW1hL2luZGV4LmpzIiwic291cmNlUm9vdCI6Ii4uLy4uLy4uIn0=
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9zY2hlbWEvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTs7QUFDQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vY2xpLWFyZ3MnO1xuIl19

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":"AAGA;;;GAGG;AACH,uBAFU,OAAO,MAAM,EAAC,iBAAiB,CAAC,CAwGxC;;;;;;uCAMW,KAAK,GAAC,MAAM;;;;;;;;;;;;gCAiBZ,OAAO,KAAK,EAAE,iBAAiB"}

package/build/lib/schema/keywords.js

@@ -66,7 +66,5 @@ const keywords = {
     }
   }
 };
-exports.keywords = keywords;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/schema/keywords.js"],"names":["keywords","appiumCliAliases","keyword","metaSchema","type","items","minLength","minItems","uniqueItems","description","appiumCliDest","appiumCliDescription","schemaType","appiumCliTransformer","enum","Object","keys","transformers","appiumCliIgnored","appiumDeprecated","$comment"],"mappings":";;;;;;;;;AAEA;;AAMO,MAAMA,QAAQ,GAAG;AAYtBC,EAAAA,gBAAgB,EAAE;AAChBC,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,OADI;AAEVC,MAAAA,KAAK,EAAE;AACLD,QAAAA,IAAI,EAAE,QADD;AAELE,QAAAA,SAAS,EAAE;AAFN,OAFG;AAMVC,MAAAA,QAAQ,EAAE,CANA;AAOVC,MAAAA,WAAW,EAAE,IAPH;AAQVC,MAAAA,WAAW,EAAE;AARH;AAFI,GAZI;AAmCtBC,EAAAA,aAAa,EAAE;AACbR,IAAAA,OAAO,EAAE,eADI;AAEbC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVE,MAAAA,SAAS,EAAE,CAFD;AAGVG,MAAAA,WAAW,EAAE;AAHH;AAFC,GAnCO;AAoDtBE,EAAAA,oBAAoB,EAAE;AACpBT,IAAAA,OAAO,EAAE,sBADW;AAEpBU,IAAAA,UAAU,EAAE,QAFQ;AAGpBT,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVE,MAAAA,SAAS,EAAE,CAFD;AAGVG,MAAAA,WAAW,EAAE;AAHH;AAHQ,GApDA;AAmEtBI,EAAAA,oBAAoB,EAAE;AACpBX,IAAAA,OAAO,EAAE,sBADW;AAEpBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVU,MAAAA,IAAI,EAAEC,MAAM,CAACC,IAAP,CAAYC,6BAAZ,CAFI;AAGVR,MAAAA,WAAW,EAAE;AAHH;AAFQ,GAnEA;AAgFtBS,EAAAA,gBAAgB,EAAE;AAChBhB,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,SADI;AAEVK,MAAAA,WAAW,EAAE,kHAFH;AAGVK,MAAAA,IAAI,EAAE,CAAC,IAAD;AAHI;AAFI,GAhFI;AA6FtBK,EAAAA,gBAAgB,EAAE;AAChBjB,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,SADI;AAEVK,MAAAA,WAAW,EAAE,wEAFH;AAGVK,MAAAA,IAAI,EAAE,CAAC,IAAD,CAHI;AAIVM,MAAAA,QAAQ,EAAE;AAJA;AAFI;AA7FI,CAAjB","sourcesContent":["// @ts-check\n\nimport { transformers } from './cli-transformers';\n\n/**\n * Collection of keyword definitions to add to the singleton `Ajv` instance.\n * @type {Record<string,KeywordDefinition>}\n */\nexport const keywords = {\n  /**\n   * Keyword to provide a list of command alias names for the CLI.\n   *\n   * If defined, there must be at least one item in the array and it must be non-empty.\n   * All items in the array must be unique.\n   *\n   * @todo Avoid alias collisions!\n   * @type {KeywordDefinition}\n   * @example\n   * {appiumCliAliases: ['B', 'bobby', 'robert']}\n   */\n  appiumCliAliases: {\n    keyword: 'appiumCliAliases',\n    metaSchema: {\n      type: 'array',\n      items: {\n        type: 'string',\n        minLength: 1,\n      },\n      minItems: 1,\n      uniqueItems: true,\n      description: 'List of aliases for the argument. Aliases shorter than three (3) characters will be prefixed with a single dash; otherwise two (2).'\n    },\n  },\n  /**\n   * Keyword to provide the name of the property in the destination (parsed\n   * args) object. By default, this value will be whatever the property name is,\n   * but camel-cased. If a flag needs something _other_ than just camel-casing,\n   * use this.\n   * @type {KeywordDefinition}\n   * @example\n   * // for prop 'no-color'\n   * {appiumCliDest: 'NOCOLOR'} // value will be stored as property `NOCOLOR` instead of `noColor`\n   */\n  appiumCliDest: {\n    keyword: 'appiumCliDest',\n    metaSchema: {\n      type: 'string',\n      minLength: 1,\n      description: 'Name of the associated property in the parsed CLI arguments object'\n    },\n  },\n\n  /**\n   * CLI-specific description of the property.  Sometimes the allowed type can\n   * be different enough on the CLI that providing a description written for a\n   * config file context wouldn't make sense.\n   * @type {KeywordDefinition}\n   * @example\n   * {appiumCliDescription: 'This is a comma-delimited string, but in the config file it is an array'}\n   */\n  appiumCliDescription: {\n    keyword: 'appiumCliDescription',\n    schemaType: 'string',\n    metaSchema: {\n      type: 'string',\n      minLength: 1,\n      description: 'Description to provide in the --help text of the CLI. Overrides `description`'\n    },\n  },\n\n  /**\n   * Transformers for CLI args. These usually take strings then do something with them, like\n   * read a file or parse further.\n   * @type {KeywordDefinition}\n   */\n  appiumCliTransformer: {\n    keyword: 'appiumCliTransformer',\n    metaSchema: {\n      type: 'string',\n      enum: Object.keys(transformers),\n      description: 'The name of a custom transformer to run against the value as provided via the CLI.'\n    },\n  },\n\n  /**\n   * Flag to tell Appium to _not_ provide this property as a CLI argument.\n   * @type {KeywordDefinition}\n   */\n  appiumCliIgnored: {\n    keyword: 'appiumCliIgnored',\n    metaSchema: {\n      type: 'boolean',\n      description: 'If `true`, Appium will not provide this property as a CLI argument. This is NOT the same as a \"hidden\" argument.',\n      enum: [true]\n    }\n  },\n\n  /**\n   * Mark this property as deprecated.\n   * @type {KeywordDefinition}\n   */\n  appiumDeprecated: {\n    keyword: 'appiumDeprecated',\n    metaSchema: {\n      type: 'boolean',\n      description: 'If `true`, this property will be displayed as \"deprecated\" to the user',\n      enum: [true],\n      $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!'\n    }\n  }\n};\n\n/**\n * These are the valid values for the `appiumCliTransformer` keyword.\n * Unfortunately, TS cannot infer this in a JS context.  In TS, we'd use\n * `as const` when defining `argTransformers`, then get `keyof typeof argTransformers`. alas.\n * @typedef {'csv'|'json'} AppiumCliTransformerName\n */\n\n/**\n * These are the custom keywords that Appium recognizes.\n *\n * @typedef {Object} AppiumJSONSchemaKeywords\n * @property {string} [appiumCliDest]\n * @property {string} [appiumCliDescription]\n * @property {string[]} [appiumCliAliases]\n * @property {boolean} [appiumCliIgnored]\n * @property {AppiumCliTransformerName} [appiumCliTransformer]\n * @property {boolean} [appiumDeprecated]\n */\n\n\n/**\n * @typedef {import('ajv').KeywordDefinition} KeywordDefinition\n */\n"],"file":"lib/schema/keywords.js","sourceRoot":"../../.."}
+exports.keywords = keywords;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/keywords.js"],"names":["keywords","appiumCliAliases","keyword","metaSchema","type","items","minLength","minItems","uniqueItems","description","appiumCliDest","appiumCliDescription","schemaType","appiumCliTransformer","enum","Object","keys","transformers","appiumCliIgnored","appiumDeprecated","$comment"],"mappings":";;;;;;;;;AACA;;AAMO,MAAMA,QAAQ,GAAG;AAYtBC,EAAAA,gBAAgB,EAAE;AAChBC,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,OADI;AAEVC,MAAAA,KAAK,EAAE;AACLD,QAAAA,IAAI,EAAE,QADD;AAELE,QAAAA,SAAS,EAAE;AAFN,OAFG;AAMVC,MAAAA,QAAQ,EAAE,CANA;AAOVC,MAAAA,WAAW,EAAE,IAPH;AAQVC,MAAAA,WAAW,EAAE;AARH;AAFI,GAZI;AAmCtBC,EAAAA,aAAa,EAAE;AACbR,IAAAA,OAAO,EAAE,eADI;AAEbC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVE,MAAAA,SAAS,EAAE,CAFD;AAGVG,MAAAA,WAAW,EAAE;AAHH;AAFC,GAnCO;AAoDtBE,EAAAA,oBAAoB,EAAE;AACpBT,IAAAA,OAAO,EAAE,sBADW;AAEpBU,IAAAA,UAAU,EAAE,QAFQ;AAGpBT,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVE,MAAAA,SAAS,EAAE,CAFD;AAGVG,MAAAA,WAAW,EAAE;AAHH;AAHQ,GApDA;AAmEtBI,EAAAA,oBAAoB,EAAE;AACpBX,IAAAA,OAAO,EAAE,sBADW;AAEpBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,QADI;AAEVU,MAAAA,IAAI,EAAEC,MAAM,CAACC,IAAP,CAAYC,6BAAZ,CAFI;AAGVR,MAAAA,WAAW,EAAE;AAHH;AAFQ,GAnEA;AAgFtBS,EAAAA,gBAAgB,EAAE;AAChBhB,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,SADI;AAEVK,MAAAA,WAAW,EAAE,kHAFH;AAGVK,MAAAA,IAAI,EAAE,CAAC,IAAD;AAHI;AAFI,GAhFI;AA6FtBK,EAAAA,gBAAgB,EAAE;AAChBjB,IAAAA,OAAO,EAAE,kBADO;AAEhBC,IAAAA,UAAU,EAAE;AACVC,MAAAA,IAAI,EAAE,SADI;AAEVK,MAAAA,WAAW,EAAE,wEAFH;AAGVK,MAAAA,IAAI,EAAE,CAAC,IAAD,CAHI;AAIVM,MAAAA,QAAQ,EAAE;AAJA;AAFI;AA7FI,CAAjB","sourcesContent":["\nimport { transformers } from './cli-transformers';\n\n/**\n * Collection of keyword definitions to add to the singleton `Ajv` instance.\n * @type {Record<string,KeywordDefinition>}\n */\nexport const keywords = {\n  /**\n   * Keyword to provide a list of command alias names for the CLI.\n   *\n   * If defined, there must be at least one item in the array and it must be non-empty.\n   * All items in the array must be unique.\n   *\n   * @todo Avoid alias collisions!\n   * @type {KeywordDefinition}\n   * @example\n   * {appiumCliAliases: ['B', 'bobby', 'robert']}\n   */\n  appiumCliAliases: {\n    keyword: 'appiumCliAliases',\n    metaSchema: {\n      type: 'array',\n      items: {\n        type: 'string',\n        minLength: 1,\n      },\n      minItems: 1,\n      uniqueItems: true,\n      description: 'List of aliases for the argument. Aliases shorter than three (3) characters will be prefixed with a single dash; otherwise two (2).'\n    },\n  },\n  /**\n   * Keyword to provide the name of the property in the destination (parsed\n   * args) object. By default, this value will be whatever the property name is,\n   * but camel-cased. If a flag needs something _other_ than just camel-casing,\n   * use this.\n   * @type {KeywordDefinition}\n   * @example\n   * // for prop 'no-color'\n   * {appiumCliDest: 'NOCOLOR'} // value will be stored as property `NOCOLOR` instead of `noColor`\n   */\n  appiumCliDest: {\n    keyword: 'appiumCliDest',\n    metaSchema: {\n      type: 'string',\n      minLength: 1,\n      description: 'Name of the associated property in the parsed CLI arguments object'\n    },\n  },\n\n  /**\n   * CLI-specific description of the property.  Sometimes the allowed type can\n   * be different enough on the CLI that providing a description written for a\n   * config file context wouldn't make sense.\n   * @type {KeywordDefinition}\n   * @example\n   * {appiumCliDescription: 'This is a comma-delimited string, but in the config file it is an array'}\n   */\n  appiumCliDescription: {\n    keyword: 'appiumCliDescription',\n    schemaType: 'string',\n    metaSchema: {\n      type: 'string',\n      minLength: 1,\n      description: 'Description to provide in the --help text of the CLI. Overrides `description`'\n    },\n  },\n\n  /**\n   * Transformers for CLI args. These usually take strings then do something with them, like\n   * read a file or parse further.\n   * @type {KeywordDefinition}\n   */\n  appiumCliTransformer: {\n    keyword: 'appiumCliTransformer',\n    metaSchema: {\n      type: 'string',\n      enum: Object.keys(transformers),\n      description: 'The name of a custom transformer to run against the value as provided via the CLI.'\n    },\n  },\n\n  /**\n   * Flag to tell Appium to _not_ provide this property as a CLI argument.\n   * @type {KeywordDefinition}\n   */\n  appiumCliIgnored: {\n    keyword: 'appiumCliIgnored',\n    metaSchema: {\n      type: 'boolean',\n      description: 'If `true`, Appium will not provide this property as a CLI argument. This is NOT the same as a \"hidden\" argument.',\n      enum: [true]\n    }\n  },\n\n  /**\n   * Mark this property as deprecated.\n   * @type {KeywordDefinition}\n   */\n  appiumDeprecated: {\n    keyword: 'appiumDeprecated',\n    metaSchema: {\n      type: 'boolean',\n      description: 'If `true`, this property will be displayed as \"deprecated\" to the user',\n      enum: [true],\n      $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!'\n    }\n  }\n};\n\n/**\n * These are the valid values for the `appiumCliTransformer` keyword.\n * Unfortunately, TS cannot infer this in a JS context.  In TS, we'd use\n * `as const` when defining `argTransformers`, then get `keyof typeof argTransformers`. alas.\n * @typedef {'csv'|'json'} AppiumCliTransformerName\n */\n\n/**\n * These are the custom keywords that Appium recognizes.\n *\n * @typedef AppiumJSONSchemaKeywords\n * @property {string} [appiumCliDest]\n * @property {string} [appiumCliDescription]\n * @property {string[]} [appiumCliAliases]\n * @property {boolean} [appiumCliIgnored]\n * @property {AppiumCliTransformerName} [appiumCliTransformer]\n * @property {boolean} [appiumDeprecated]\n */\n\n\n/**\n * @typedef {import('ajv').KeywordDefinition} KeywordDefinition\n */\n"]}