appium 2.0.0-beta.26 → 2.0.0-beta.29

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

@@ -71,4 +71,4 @@ const transformers = {
   }
 };
 exports.transformers = transformers;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# 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/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

@@ -67,4 +67,4 @@ const keywords = {
   }
 };
 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":";;;;;;;;;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 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"]}
+//# 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"]}

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

@@ -0,0 +1,259 @@
+/**
+ * Key/value pairs go in... but they don't come out.
+ *
+ * @template K,V
+ * @extends {Map<K,V>}
+ */
+export class RoachHotelMap<K, V> extends Map<K, V> {
+    constructor();
+    constructor(entries?: readonly (readonly [K, V])[] | null | undefined);
+    constructor();
+    constructor(iterable?: Iterable<readonly [K, V]> | null | undefined);
+}
+/**
+ * Extensions that an extension schema file can have.
+ */
+export const ALLOWED_SCHEMA_EXTENSIONS: Set<string>;
+/**
+ * Thrown when the {@link AppiumSchema} instance has not yet been finalized, but
+ * the method called requires it.
+ */
+export class SchemaFinalizationError extends Error {
+    constructor();
+    /**
+     * @type {Readonly<string>}
+     */
+    code: Readonly<string>;
+}
+/**
+ * Thrown when a "unique" schema ID conflicts with an existing schema ID.
+ *
+ * This is likely going to be caused by attempting to register the same schema twice.
+ */
+export class SchemaNameConflictError extends Error {
+    /**
+     * @param {ExtensionType} extType
+     * @param {string} extName
+     */
+    constructor(extType: ExtensionType, extName: string);
+    /**
+     * @type {Readonly<string>}
+     */
+    code: Readonly<string>;
+    /**
+     * @type {Readonly<{extType: ExtensionType, extName: string}>}
+     */
+    data: Readonly<{
+        extType: ExtensionType;
+        extName: string;
+    }>;
+}
+/**
+ * Thrown when a schema ID was expected, but it doesn't exist on the {@link Ajv} instance.
+ */
+export class SchemaUnknownSchemaError extends ReferenceError {
+    /**
+     * @param {string} schemaId
+     */
+    constructor(schemaId: string);
+    /**
+     * @type {Readonly<string>}
+     */
+    code: Readonly<string>;
+    /**
+     * @type {Readonly<{schemaId: string}>}
+     */
+    data: Readonly<{
+        schemaId: string;
+    }>;
+}
+/**
+ * Thrown when a schema is provided, but it's of an unsupported type.
+ *
+ * "Valid" schemas which are unsupported include boolean schemas and async schemas
+ * (having a `true` `$async` property).
+ */
+export class SchemaUnsupportedSchemaError extends TypeError {
+    /**
+     * @param {any} schema
+     * @param {ExtensionType} extType
+     * @param {string} extName
+     */
+    constructor(schema: any, extType: ExtensionType, extName: string);
+    /**
+     * @type {Readonly<string>}
+     */
+    code: Readonly<string>;
+    /**
+     * @type {Readonly<{schema: any, extType: ExtensionType, extName: string}>}
+     */
+    data: Readonly<{
+        schema: any;
+        extType: ExtensionType;
+        extName: string;
+    }>;
+}
+/**
+ * Registers a schema from an extension.
+ *
+ * This is "fail-fast" in that the schema will immediately be validated against JSON schema draft-07 _or_ whatever the value of the schema's `$schema` prop is.
+ *
+ * Does _not_ add the schema to the `ajv` instance (this is done by {@link AppiumSchema.finalize}).
+ * @param {ExtensionType} extType - Extension type
+ * @param {string} extName - Unique extension name for `type`
+ * @param {SchemaObject} schema - Schema object
+ * @throws {SchemaNameConflictError} If the schema is an invalid
+ * @returns {void}
+ */
+export function registerSchema(extType: ExtensionType, extName: string, schema: SchemaObject): void;
+export function getAllArgSpecs(): RoachHotelMap<string, ArgSpec<any>>;
+/**
+ * Returns a {@link ArgSpec} for the given argument name.
+ * @param {string} name - CLI argument name
+ * @param {ExtensionType} [extType] - Extension type
+ * @param {string} [extName] - Extension name
+ * @returns {ArgSpec|undefined} ArgSpec or `undefined` if not found
+ */
+export function getArgSpec(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): ArgSpec<any> | undefined;
+/**
+ * Returns `true` if the instance knows about an argument by the given `name`.
+ * @param {string} name - CLI argument name
+ * @param {ExtensionType} [extType] - Extension type
+ * @param {string} [extName] - Extension name
+ * @returns {boolean} `true` if such an {@link ArgSpec} exists
+ */
+export function hasArgSpec(name: string, extType?: import("../../types").ExtensionType | undefined, extName?: string | undefined): boolean;
+/**
+ * Return `true` if {@link AppiumSchema.finalize finalize} has been called
+ * successfully and {@link AppiumSchema.reset reset} has not been called since.
+ * @returns {boolean} If finalized
+ */
+export function isFinalized(): boolean;
+/**
+ * Call this when no more schemas will be registered.
+ *
+ * This does three things:
+ * 1. It combines all schemas from extensions into the Appium config schema,
+ *    then adds the result to the `Ajv` instance.
+ * 2. It adds schemas for _each_ argument/property for validation purposes.
+ *    The CLI uses these schemas to validate specific arguments.
+ * 3. The schemas are validated against JSON schema draft-07 (which is the
+ *    only one supported at this time)
+ *
+ * Any method in this instance that needs to interact with the `Ajv` instance
+ * will throw if this method has not been called.
+ *
+ * If the instance has already been finalized, this is a no-op.
+ * @public
+ * @throws {Error} If the schema is not valid
+ * @returns {Readonly<Record<string,StrictSchemaObject>>} Record of schema IDs to full schema objects
+ */
+export function finalizeSchema(): Readonly<Record<string, StrictSchemaObject>>;
+/**
+ * Resets this instance to its original state.
+ *
+ * - Removes all added schemas from the `Ajv` instance
+ * - Resets the map of {@link ArgSpec ArgSpecs}
+ * - Resets the map of registered schemas
+ * - Sets the {@link AppiumSchema._finalized _finalized} flag to `false`
+ *
+ * If you need to call {@link AppiumSchema.finalize} again, you'll want to call this first.
+ * @returns {void}
+ */
+export function resetSchema(): void;
+/**
+ * Given an object, validates it against the Appium config schema.
+ * If errors occur, the returned array will be non-empty.
+ * @param {any} value - The value (hopefully an object) to validate against the schema
+ * @param {string} [ref] - Schema ID or ref.
+ * @public
+ * @returns {import('ajv').ErrorObject[]} Array of errors, if any.
+ */
+export function validate(value: any, ref?: string | undefined): import('ajv').ErrorObject[];
+/**
+ * Retrieves the schema itself
+ * @public
+ * @param {string} [ref] - Schema ID
+ * @throws If the schema has not yet been finalized
+ * @returns {SchemaObject}
+ */
+export function getSchema(ref?: string | undefined): SchemaObject;
+/**
+ * Flatten schema into an array of `SchemaObject`s and associated
+ * {@link ArgSpec ArgSpecs}.
+ *
+ * Converts nested extension schemas to keys based on the extension type and
+ * name. Used when translating to `argparse` options or getting the list of
+ * default values (see {@link AppiumSchema.getDefaults}) for CLI or otherwise.
+ *
+ * The return value is an intermediate reprsentation used by `cli-args`
+ * module's `toParserArgs`, which converts the finalized schema to parameters
+ * used by `argparse`.
+ * @throws If {@link AppiumSchema.finalize} has not been called yet.
+ * @returns {FlattenedSchema}
+ */
+export function flattenSchema(): FlattenedSchema;
+/**
+ * Returns a `Record` of argument "dest" strings to default values.
+ *
+ * The "dest" string is the property name in object returned by
+ * `argparse.ArgumentParser['parse_args']`.
+ * @template {boolean|undefined} Flattened
+ * @param {Flattened} [flatten=true] - If `true`, flattens the returned object
+ * using "keypath"-style keys of the format `<extType>.<extName>.<argName>`.
+ * Otherwise, returns a nested object using `extType` and `extName` as
+ * properties. Base arguments (server arguments) are always at the top level.
+ * @returns {DefaultValues<Flattened>}
+ */
+export function getDefaultsForSchema<Flattened extends boolean | undefined>(flatten?: Flattened | undefined): DefaultValues<Flattened>;
+/**
+ * Returns a flattened Record of defaults for a specific extension. Keys will
+ * be of format `<argName>`.
+ * @param {ExtensionType} extType - Extension type
+ * @param {string} extName - Extension name
+ * @returns {Record<string,ArgSpecDefaultValue>}
+ */
+export function getDefaultsForExtension(extType: ExtensionType, extName: string): Record<string, ArgSpecDefaultValue>;
+/**
+ * Returns `true` if `filename`'s file extension is allowed (in {@link ALLOWED_SCHEMA_EXTENSIONS}).
+ * @param {string} filename
+ * @returns {boolean}
+ */
+export function isAllowedSchemaFileExtension(filename: string): boolean;
+/**
+ * Appium only supports schemas that are plain objects; not arrays.
+ */
+export type SchemaObject = import("ajv").SchemaObject & {
+    [key: number]: never;
+};
+export type ExtensionType = import('../extension/manifest').ExtensionType;
+/**
+ * An object having property `additionalProperties: false`
+ */
+export type StrictProp = {
+    additionalProperties: false;
+};
+/**
+ * A {@link SchemaObject } with `additionalProperties: false`
+ */
+export type StrictSchemaObject = SchemaObject & StrictProp;
+/**
+ * A list of schemas associated with properties and their corresponding {@link ArgSpec } objects.
+ *
+ * Intermediate data structure used when converting the entire schema down to CLI arguments.
+ */
+export type FlattenedSchema = {
+    schema: SchemaObject;
+    argSpec: ArgSpec<any>;
+}[];
+export type ArgSpecDefaultValue = ArgSpec<any>['defaultValue'];
+/**
+ * e.g. `{driver: {foo: 'bar'}}` where `foo` is the arg name and `bar` is the default value.
+ */
+export type NestedArgSpecDefaultValue = Record<string, Record<string, ArgSpecDefaultValue>>;
+/**
+ * Helper type for the return value of {@link AppiumSchema.getDefaults }
+ */
+export type DefaultValues<Flattened extends boolean | undefined> = Record<string, Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue>;
+import { ArgSpec } from "./arg-spec";
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../lib/schema/schema.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH;IAqCG,cAAwB;IAAA,uEAEV;IAsHV,cAA2B;IAAA,qEACP;CAvI1B;AAED;;GAEG;AACH,oDAA2E;AAqgB3E;;;GAGG;AACH;IAME,cAEC;IAPD;;OAEG;IACH,MAFU,SAAS,MAAM,CAAC,CAEa;CAKxC;AAED;;;;GAIG;AACH;IAWE;;;OAGG;IACH,qBAHW,aAAa,WACb,MAAM,EAOhB;IAnBD;;OAEG;IACH,MAFU,SAAS,MAAM,CAAC,CAEc;IAExC;;OAEG;IACH,MAFU,SAAS;QAAC,OAAO,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAExD;CAYN;AAED;;GAEG;AACH;IAWE;;OAEG;IACH,sBAFW,MAAM,EAKhB;IAhBD;;OAEG;IACH,MAFU,SAAS,MAAM,CAAC,CAEe;IAEzC;;OAEG;IACH,MAFU,SAAS;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAAC,CAEjC;CASN;AAED;;;;;GAKG;AACH;IAWE;;;;OAIG;IACH,oBAJW,GAAG,WACH,aAAa,WACb,MAAM,EAyBhB;IAtCD;;OAEG;IACH,MAFU,SAAS,MAAM,CAAC,CAEmB;IAE7C;;OAEG;IACH,MAFU,SAAS;QAAC,MAAM,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,CAErE;CA+BN;AAlXC;;;;;;;;;;;GAWG;AACH,wCANW,aAAa,WACb,MAAM,UACN,YAAY,GAEV,IAAI,CAqBhB;AAhLD,sEAEC;AAgLD;;;;;;GAMG;AACH,iCALW,MAAM,4FAGJ,eAAQ,SAAS,CAI7B;AAED;;;;;;GAMG;AACH,iCALW,MAAM,4FAGJ,OAAO,CAInB;AA/MD;;;;GAIG;AACH,+BAFa,OAAO,CAInB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,kCAFa,SAAS,OAAO,MAAM,EAAC,kBAAkB,CAAC,CAAC,CA2EvD;AAuBD;;;;;;;;;;GAUG;AACH,+BAFa,IAAI,CAehB;AAkOD;;;;;;;GAOG;AACH,gCALW,GAAG,6BAGD,OAAO,KAAK,EAAE,WAAW,EAAE,CAOvC;AA1CD;;;;;;GAMG;AACH,qDAFa,YAAY,CAIxB;AAnFD;;;;;;;;;;;;;GAaG;AACH,iDA0DC;AA1ID;;;;;;;;;;;GAWG;AACH,uIA8BC;AAED;;;;;;GAMG;AACH,iDAJW,aAAa,WACb,MAAM,GACJ,OAAO,MAAM,EAAC,mBAAmB,CAAC,CAe9C;AAwHD;;;;GAIG;AACH,uDAHW,MAAM,GACJ,OAAO,CAInB;;;;;;;4BAsJU,OAAO,uBAAuB,EAAE,aAAa;;;;;0BAM5C,KAAK;;;;;iCAKN,YAAY,GAAG,UAAU;;;;;;8BAOxB;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,OAAO,eAAS;CAAC,EAAE;kCAI3C,aAAQ,cAAc,CAAC;;;;wCAKvB,OAAO,MAAM,EAAC,OAAO,MAAM,EAAC,mBAAmB,CAAC,CAAC;;;;mEAMjD,OAAO,MAAM,EAAC,SAAS,SAAS,IAAI,GAAG,mBAAmB,GAAG,mBAAmB,GAAG,yBAAyB,CAAC"}

package/build/lib/schema/schema.js

@@ -19,7 +19,7 @@ var _path = _interopRequireDefault(require("path"));
 
 var _constants = require("../constants");
 
-var _appiumConfigSchema = _interopRequireDefault(require("./appium-config-schema"));
+var _schema = require("@appium/schema");
 
 var _argSpec = require("./arg-spec");
 
@@ -92,7 +92,7 @@ class AppiumSchema {
 
     const ajv = this._ajv;
 
-    const baseSchema = _lodash.default.cloneDeep(_appiumConfigSchema.default);
+    const baseSchema = _lodash.default.cloneDeep(_schema.AppiumConfigJsonSchema);
 
     const addArgSpecs = (schema, extType, extName) => {
       for (let [propName, propSchema] of Object.entries(schema)) {
@@ -449,4 +449,4 @@ const {
   isAllowedSchemaFileExtension
 } = AppiumSchema;
 exports.isAllowedSchemaFileExtension = isAllowedSchemaFileExtension;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/schema.js"],"names":["RoachHotelMap","Map","set","key","value","has","Error","delete","clear","ALLOWED_SCHEMA_EXTENSIONS","Set","AppiumSchema","_argSpecs","_registeredSchemas","DRIVER_TYPE","PLUGIN_TYPE","_ajv","_instance","_finalizedSchemas","constructor","_instantiateAjv","create","instance","_","bindAll","hasRegisteredSchema","extType","extName","isFinalized","Boolean","getAllArgSpecs","finalize","ajv","baseSchema","cloneDeep","appiumConfigSchema","addArgSpecs","schema","propName","propSchema","Object","entries","argSpec","ArgSpec","dest","appiumCliDest","defaultValue","default","arg","omit","properties","server","finalizedSchemas","finalSchema","reduce","extensionSchemas","forEach","$ref","toSchemaBaseRef","$id","additionalProperties","$comment","validateSchema","addSchema","APPIUM_CONFIG_SCHEMA_ID","freeze","Ajv","allErrors","keywords","keyword","addKeyword","reset","schemaId","keys","removeSchema","registerSchema","isUndefined","TypeError","isSupportedSchemaType","SchemaUnsupportedSchemaError","normalizedExtName","kebabCase","get","SchemaNameConflictError","getArgSpec","name","toArg","hasArgSpec","getDefaults","flatten","SchemaFinalizationError","reducer","defaults","retval","values","getDefaultsForExtension","specs","filter","spec","rawDest","getSchema","stack","prefix","flattened","pairs","toPairs","push","SERVER_PROP_NAME","refSchema","err","SchemaUnknownSchemaError","extensionInfoFromRootSchemaId","ReferenceError","ref","_getValidator","id","validator","validate","isArray","errors","isAllowedSchemaFileExtension","filename","path","extname","isPlainObject","$async","code","data","msg","isBoolean","JSON","stringify","appiumSchema","finalizeSchema","resetSchema","flattenSchema","getDefaultsForSchema"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Ajv from 'ajv';\nimport addFormats from 'ajv-formats';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../constants';\nimport appiumConfigSchema from './appium-config-schema';\nimport { APPIUM_CONFIG_SCHEMA_ID, ArgSpec, SERVER_PROP_NAME } from './arg-spec';\nimport { keywords } from './keywords';\n\n/**\n * Key/value pairs go in... but they don't come out.\n *\n * @template K,V\n * @extends {Map<K,V>}\n */\nexport class RoachHotelMap extends Map {\n  /**\n   * @param {K} key\n   * @param {V} value\n   */\n  set (key, value) {\n    if (this.has(key)) {\n      throw new Error(`${key} is already set`);\n    }\n    return super.set(key, value);\n  }\n\n  /**\n   * @param {K} key\n   */\n  // eslint-disable-next-line no-unused-vars\n  delete (key) {\n    return false;\n  }\n\n  clear () {\n    throw new Error(`Cannot clear RoachHotelMap`);\n  }\n}\n\n/**\n * Extensions that an extension schema file can have.\n */\nexport const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);\n\n/**\n * A wrapper around Ajv and schema-related functions.\n *\n * Should have been named Highlander, because _there can only be one_\n */\nclass AppiumSchema {\n  /**\n   * A mapping of unique argument IDs to their corresponding {@link ArgSpec}s.\n   *\n   * An \"argument\" is a CLI argument or a config property.\n   *\n   * Used to provide easy lookups of argument metadata when converting between different representations of those arguments.\n   * @private\n   * @type {RoachHotelMap<string,ArgSpec>}\n   */\n  _argSpecs = new RoachHotelMap();\n\n  /**\n   * A map of extension types to extension names to schema objects.\n   *\n   * This data structure is used to ensure there are no naming conflicts. The schemas\n   * are stored here in memory until the instance is _finalized_.\n   * @private\n   * @type {Record<ExtensionType,Map<string,SchemaObject>>}\n   */\n  _registeredSchemas = {[DRIVER_TYPE]: new Map(), [PLUGIN_TYPE]: new Map()};\n\n  /**\n   * Ajv instance\n   *\n   * @private\n   * @type {Ajv}\n   */\n  _ajv;\n\n  /**\n   * Singleton instance.\n   * @private\n   * @type {AppiumSchema}\n   */\n  static _instance;\n\n  /**\n   * Lookup of schema IDs to finalized schemas.\n   *\n   * This does not include references, but rather the root schemas themselves.\n   * @private\n   * @type {Record<string,StrictSchemaObject>?}\n   */\n  _finalizedSchemas = null;\n\n  /**\n   * Initializes Ajv, adds standard formats and our custom keywords.\n   * @see https://npm.im/ajv-formats\n   * @private\n   */\n  constructor () {\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Factory function for {@link AppiumSchema} instances.\n   *\n   * Returns a singleton instance if one exists, otherwise creates a new one.\n   * Binds public methods to the instance.\n   * @returns {AppiumSchema}\n   */\n  static create () {\n    if (!AppiumSchema._instance) {\n      const instance = new AppiumSchema();\n      AppiumSchema._instance = instance;\n      _.bindAll(instance, [\n        'finalize',\n        'flatten',\n        'getAllArgSpecs',\n        'getArgSpec',\n        'getDefaults',\n        'getDefaultsForExtension',\n        'getSchema',\n        'hasArgSpec',\n        'isFinalized',\n        'registerSchema',\n        'hasRegisteredSchema',\n        'reset',\n        'validate',\n      ]);\n    }\n\n    return AppiumSchema._instance;\n  }\n\n  /**\n   * Returns `true` if a schema has been registered using given extension type and name.\n   *\n   * This does not depend on whether or not the instance has been _finalized_.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Name\n   * @returns {boolean} If registered\n   */\n  hasRegisteredSchema (extType, extName) {\n    return this._registeredSchemas[extType].has(extName);\n  }\n\n  /**\n   * Return `true` if {@link AppiumSchema.finalize finalize} has been called\n   * successfully and {@link AppiumSchema.reset reset} has not been called since.\n   * @returns {boolean} If finalized\n   */\n  isFinalized () {\n    return Boolean(this._finalizedSchemas);\n  }\n\n  getAllArgSpecs () {\n    return this._argSpecs;\n  }\n\n  /**\n   * Call this when no more schemas will be registered.\n   *\n   * This does three things:\n   * 1. It combines all schemas from extensions into the Appium config schema,\n   *    then adds the result to the `Ajv` instance.\n   * 2. It adds schemas for _each_ argument/property for validation purposes.\n   *    The CLI uses these schemas to validate specific arguments.\n   * 3. The schemas are validated against JSON schema draft-07 (which is the\n   *    only one supported at this time)\n   *\n   * Any method in this instance that needs to interact with the `Ajv` instance\n   * will throw if this method has not been called.\n   *\n   * If the instance has already been finalized, this is a no-op.\n   * @public\n   * @throws {Error} If the schema is not valid\n   * @returns {Readonly<Record<string,StrictSchemaObject>>} Record of schema IDs to full schema objects\n   */\n  finalize () {\n    if (this.isFinalized()) {\n      return /** @type {NonNullable<typeof this._finalizedSchemas>} */ (\n        this._finalizedSchemas\n      );\n    }\n\n    const ajv = this._ajv;\n\n    // Ajv will _mutate_ the schema, so we need to clone it.\n    const baseSchema = _.cloneDeep(appiumConfigSchema);\n\n    /**\n     *\n     * @param {SchemaObject} schema\n     * @param {ExtensionType} [extType]\n     * @param {string} [extName]\n     */\n    const addArgSpecs = (schema, extType, extName) => {\n      for (let [propName, propSchema] of Object.entries(schema)) {\n        const argSpec = ArgSpec.create(propName, {\n          dest: propSchema.appiumCliDest,\n          defaultValue: propSchema.default,\n          extType,\n          extName,\n        });\n        const {arg} = argSpec;\n        this._argSpecs.set(arg, argSpec);\n      }\n    };\n\n    addArgSpecs(\n      _.omit(baseSchema.properties.server.properties, [\n        DRIVER_TYPE,\n        PLUGIN_TYPE,\n      ]),\n    );\n\n    /**\n     * @type {Record<string,StrictSchemaObject>}\n     */\n    const finalizedSchemas = {};\n\n    const finalSchema = _.reduce(\n      this._registeredSchemas,\n      /**\n       * @param {typeof baseSchema} baseSchema\n       * @param {Map<string,SchemaObject>} extensionSchemas\n       * @param {ExtensionType} extType\n       */\n      (baseSchema, extensionSchemas, extType) => {\n        extensionSchemas.forEach((schema, extName) => {\n          const $ref = ArgSpec.toSchemaBaseRef(extType, extName);\n          schema.$id = $ref;\n          schema.additionalProperties = false; // this makes `schema` become a `StrictSchemaObject`\n          baseSchema.properties.server.properties[extType].properties[extName] =\n            {$ref, $comment: extName};\n          ajv.validateSchema(schema, true);\n          addArgSpecs(schema.properties, extType, extName);\n          ajv.addSchema(schema, $ref);\n          finalizedSchemas[$ref] = /** @type {StrictSchemaObject} */ (schema);\n        });\n        return baseSchema;\n      },\n      baseSchema,\n    );\n\n    ajv.addSchema(finalSchema, APPIUM_CONFIG_SCHEMA_ID);\n    finalizedSchemas[APPIUM_CONFIG_SCHEMA_ID] = finalSchema;\n    ajv.validateSchema(finalSchema, true);\n\n    this._finalizedSchemas = finalizedSchemas;\n    return Object.freeze(finalizedSchemas);\n  }\n\n  /**\n   * Configures and creates an Ajv instance.\n   * @private\n   * @returns {Ajv}\n   */\n  static _instantiateAjv () {\n    const ajv = addFormats(\n      new Ajv({\n        // without this not much validation actually happens\n        allErrors: true,\n      }),\n    );\n\n    // add custom keywords to ajv. see schema-keywords.js\n    _.forEach(keywords, (keyword) => {\n      ajv.addKeyword(keyword);\n    });\n\n    return ajv;\n  }\n\n  /**\n   * Resets this instance to its original state.\n   *\n   * - Removes all added schemas from the `Ajv` instance\n   * - Resets the map of {@link ArgSpec ArgSpecs}\n   * - Resets the map of registered schemas\n   * - Sets the {@link AppiumSchema._finalized _finalized} flag to `false`\n   *\n   * If you need to call {@link AppiumSchema.finalize} again, you'll want to call this first.\n   * @returns {void}\n   */\n  reset () {\n    for (const schemaId of Object.keys(this._finalizedSchemas ?? {})) {\n      this._ajv.removeSchema(schemaId);\n    }\n    this._argSpecs = new RoachHotelMap();\n    this._registeredSchemas = {\n      [DRIVER_TYPE]: new Map(),\n      [PLUGIN_TYPE]: new Map(),\n    };\n    this._finalizedSchemas = null;\n\n    // Ajv seems to have an over-eager cache, so we have to dump the object entirely.\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Registers a schema from an extension.\n   *\n   * This is \"fail-fast\" in that the schema will immediately be validated against JSON schema draft-07 _or_ whatever the value of the schema's `$schema` prop is.\n   *\n   * Does _not_ add the schema to the `ajv` instance (this is done by {@link AppiumSchema.finalize}).\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Unique extension name for `type`\n   * @param {SchemaObject} schema - Schema object\n   * @throws {SchemaNameConflictError} If the schema is an invalid\n   * @returns {void}\n   */\n  registerSchema (extType, extName, schema) {\n    if (!(extType && extName) || _.isUndefined(schema)) {\n      throw new TypeError(\n        'Expected extension type, extension name, and a defined schema',\n      );\n    }\n    if (!AppiumSchema.isSupportedSchemaType(schema)) {\n      throw new SchemaUnsupportedSchemaError(schema, extType, extName);\n    }\n    const normalizedExtName = _.kebabCase(extName);\n    if (this.hasRegisteredSchema(extType, normalizedExtName)) {\n      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {\n        return;\n      }\n      throw new SchemaNameConflictError(extType, extName);\n    }\n    this._ajv.validateSchema(schema, true);\n\n    this._registeredSchemas[extType].set(normalizedExtName, schema);\n  }\n\n  /**\n   * Returns a {@link ArgSpec} for the given argument name.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {ArgSpec|undefined} ArgSpec or `undefined` if not found\n   */\n  getArgSpec (name, extType, extName) {\n    return this._argSpecs.get(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns `true` if the instance knows about an argument by the given `name`.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {boolean} `true` if such an {@link ArgSpec} exists\n   */\n  hasArgSpec (name, extType, extName) {\n    return this._argSpecs.has(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns a `Record` of argument \"dest\" strings to default values.\n   *\n   * The \"dest\" string is the property name in object returned by\n   * `argparse.ArgumentParser['parse_args']`.\n   * @template {boolean|undefined} Flattened\n   * @param {Flattened} [flatten=true] - If `true`, flattens the returned object\n   * using \"keypath\"-style keys of the format `<extType>.<extName>.<argName>`.\n   * Otherwise, returns a nested object using `extType` and `extName` as\n   * properties. Base arguments (server arguments) are always at the top level.\n   * @returns {DefaultValues<Flattened>}\n   */\n  getDefaults (flatten = /** @type {Flattened} */ (true)) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n\n    /**\n     * @private\n     * @callback DefaultReducer\n     * @param {DefaultValues<Flattened>} defaults\n     * @param {ArgSpec} argSpec\n     * @returns {DefaultValues<Flattened>}\n     */\n    /** @type {DefaultReducer} */\n    const reducer = flatten\n      ? (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          defaults[dest] = defaultValue;\n        }\n        return defaults;\n      }\n      : (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          _.set(defaults, dest, defaultValue);\n        }\n        return defaults;\n      };\n\n    /** @type {DefaultValues<Flattened>} */\n    const retval = {};\n    return [...this._argSpecs.values()].reduce(reducer, retval);\n  }\n\n  /**\n   * Returns a flattened Record of defaults for a specific extension. Keys will\n   * be of format `<argName>`.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Extension name\n   * @returns {Record<string,ArgSpecDefaultValue>}\n   */\n  getDefaultsForExtension (extType, extName) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n    const specs = [...this._argSpecs.values()].filter(\n      (spec) => spec.extType === extType && spec.extName === extName,\n    );\n    return specs.reduce((defaults, {defaultValue, rawDest}) => {\n      if (!_.isUndefined(defaultValue)) {\n        defaults[rawDest] = defaultValue;\n      }\n      return defaults;\n    }, {});\n  }\n\n  /**\n   * Flatten schema into an array of `SchemaObject`s and associated\n   * {@link ArgSpec ArgSpecs}.\n   *\n   * Converts nested extension schemas to keys based on the extension type and\n   * name. Used when translating to `argparse` options or getting the list of\n   * default values (see {@link AppiumSchema.getDefaults}) for CLI or otherwise.\n   *\n   * The return value is an intermediate reprsentation used by `cli-args`\n   * module's `toParserArgs`, which converts the finalized schema to parameters\n   * used by `argparse`.\n   * @throws If {@link AppiumSchema.finalize} has not been called yet.\n   * @returns {FlattenedSchema}\n   */\n  flatten () {\n    const schema = this.getSchema();\n\n    /** @type { {properties: SchemaObject, prefix: string[]}[] } */\n    const stack = [{properties: schema.properties, prefix: []}];\n    /** @type {FlattenedSchema} */\n    const flattened = [];\n\n    // this bit is a recursive algorithm rewritten as a for loop.\n    // when we find something we want to traverse, we add it to `stack`\n    for (const {properties, prefix} of stack) {\n      const pairs = _.toPairs(properties);\n      for (const [key, value] of pairs) {\n        const {properties, $ref} = value;\n        if (properties) {\n          stack.push({\n            properties,\n            prefix: key === SERVER_PROP_NAME ? [] : [...prefix, key],\n          });\n        } else if ($ref) {\n          let refSchema;\n          try {\n            refSchema = this.getSchema($ref);\n          } catch (err) {\n            // this can happen if an extension schema supplies a $ref to a non-existent schema\n            throw new SchemaUnknownSchemaError($ref);\n          }\n          const {normalizedExtName} =\n            ArgSpec.extensionInfoFromRootSchemaId($ref);\n          if (!normalizedExtName) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Could not determine extension name from schema ID ${$ref}. This is a bug.`,\n            );\n          }\n          stack.push({\n            properties: refSchema.properties,\n            prefix: [...prefix, key, normalizedExtName],\n          });\n        } else if (key !== DRIVER_TYPE && key !== PLUGIN_TYPE) {\n          const [extType, extName] = prefix;\n          const argSpec = this.getArgSpec(\n            key,\n            /** @type {ExtensionType} */ (extType),\n            extName,\n          );\n          if (!argSpec) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`,\n            );\n          }\n          flattened.push({schema: _.cloneDeep(value), argSpec});\n        }\n      }\n    }\n\n    return flattened;\n  }\n\n  /**\n   * Retrieves the schema itself\n   * @public\n   * @param {string} [ref] - Schema ID\n   * @throws If the schema has not yet been finalized\n   * @returns {SchemaObject}\n   */\n  getSchema (ref = APPIUM_CONFIG_SCHEMA_ID) {\n    return /** @type {SchemaObject} */ (this._getValidator(ref).schema);\n  }\n\n  /**\n   * Retrieves schema validator function from Ajv\n   * @param {string} [id] - Schema ID\n   * @private\n   * @returns {import('ajv').ValidateFunction}\n   */\n  _getValidator (id = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = this._ajv.getSchema(id);\n    if (!validator) {\n      if (id === APPIUM_CONFIG_SCHEMA_ID) {\n        throw new SchemaFinalizationError();\n      } else {\n        throw new SchemaUnknownSchemaError(id);\n      }\n    }\n    return validator;\n  }\n\n  /**\n   * Given an object, validates it against the Appium config schema.\n   * If errors occur, the returned array will be non-empty.\n   * @param {any} value - The value (hopefully an object) to validate against the schema\n   * @param {string} [ref] - Schema ID or ref.\n   * @public\n   * @returns {import('ajv').ErrorObject[]} Array of errors, if any.\n   */\n  validate (value, ref = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = this._getValidator(ref);\n    return !validator(value) && _.isArray(validator.errors)\n      ? [...validator.errors]\n      : [];\n  }\n\n  /**\n   * Returns `true` if `filename`'s file extension is allowed (in {@link ALLOWED_SCHEMA_EXTENSIONS}).\n   * @param {string} filename\n   * @returns {boolean}\n   */\n  static isAllowedSchemaFileExtension (filename) {\n    return ALLOWED_SCHEMA_EXTENSIONS.has(path.extname(filename));\n  }\n\n  /**\n   * Returns `true` if `schema` is a plain object with a non-true `$async` property.\n   * @param {any} schema - Schema to check\n   * @returns {schema is SchemaObject}\n   */\n  static isSupportedSchemaType (schema) {\n    return _.isPlainObject(schema) && schema.$async !== true;\n  }\n}\n\n/**\n * Thrown when the {@link AppiumSchema} instance has not yet been finalized, but\n * the method called requires it.\n */\nexport class SchemaFinalizationError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_FINALIZATION';\n\n  constructor () {\n    super('Schema not yet finalized; `finalize()` must be called first.');\n  }\n}\n\n/**\n * Thrown when a \"unique\" schema ID conflicts with an existing schema ID.\n *\n * This is likely going to be caused by attempting to register the same schema twice.\n */\nexport class SchemaNameConflictError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';\n\n  /**\n   * @type {Readonly<{extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (extType, extName) {\n    super(\n      `Name for ${extType} schema \"${extName}\" conflicts with an existing schema`,\n    );\n    this.data = {extType, extName};\n  }\n}\n\n/**\n * Thrown when a schema ID was expected, but it doesn't exist on the {@link Ajv} instance.\n */\nexport class SchemaUnknownSchemaError extends ReferenceError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';\n\n  /**\n   * @type {Readonly<{schemaId: string}>}\n   */\n  data;\n\n  /**\n   * @param {string} schemaId\n   */\n  constructor (schemaId) {\n    super(`Unknown schema: \"${schemaId}\"`);\n    this.data = {schemaId};\n  }\n}\n\n/**\n * Thrown when a schema is provided, but it's of an unsupported type.\n *\n * \"Valid\" schemas which are unsupported include boolean schemas and async schemas\n * (having a `true` `$async` property).\n */\nexport class SchemaUnsupportedSchemaError extends TypeError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';\n\n  /**\n   * @type {Readonly<{schema: any, extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {any} schema\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (schema, extType, extName) {\n    // https://github.com/Microsoft/TypeScript/issues/8277\n    super(\n      (() => {\n        let msg = `Unsupported schema from ${extType} \"${extName}\":`;\n        if (_.isBoolean(schema)) {\n          return `${msg} schema cannot be a boolean`;\n        }\n        if (_.isPlainObject(schema)) {\n          if (schema.$async) {\n            return `${msg} schema cannot be an async schema`;\n          }\n          /* istanbul ignore next */\n          throw new TypeError(\n            `schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(\n              schema,\n            )}`,\n          );\n        }\n        return `${msg} schema must be a plain object without a true \"$async\" property`;\n      })(),\n    );\n    this.data = {schema, extType, extName};\n  }\n}\n\nconst appiumSchema = AppiumSchema.create();\n\nexport const {\n  registerSchema,\n  getAllArgSpecs,\n  getArgSpec,\n  hasArgSpec,\n  isFinalized,\n  finalize: finalizeSchema,\n  reset: resetSchema,\n  validate,\n  getSchema,\n  flatten: flattenSchema,\n  getDefaults: getDefaultsForSchema,\n  getDefaultsForExtension,\n} = appiumSchema;\nexport const {isAllowedSchemaFileExtension} = AppiumSchema;\n\n/**\n * Appium only supports schemas that are plain objects; not arrays.\n * @typedef {import('ajv').SchemaObject & {[key: number]: never}} SchemaObject\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n\n/**\n * An object having property `additionalProperties: false`\n * @typedef StrictProp\n * @property {false} additionalProperties\n */\n\n/**\n * A {@link SchemaObject} with `additionalProperties: false`\n * @typedef {SchemaObject & StrictProp} StrictSchemaObject\n */\n\n/**\n * A list of schemas associated with properties and their corresponding {@link ArgSpec} objects.\n *\n * Intermediate data structure used when converting the entire schema down to CLI arguments.\n * @typedef { {schema: SchemaObject, argSpec: ArgSpec}[] } FlattenedSchema\n */\n\n/**\n * @typedef {ArgSpec['defaultValue']} ArgSpecDefaultValue\n */\n\n/**\n * e.g. `{driver: {foo: 'bar'}}` where `foo` is the arg name and `bar` is the default value.\n * @typedef {Record<string,Record<string,ArgSpecDefaultValue>>} NestedArgSpecDefaultValue\n */\n\n/**\n * Helper type for the return value of {@link AppiumSchema.getDefaults}\n * @template {boolean|undefined} Flattened\n * @typedef {Record<string,Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue>} DefaultValues\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/schema.js"],"names":["RoachHotelMap","Map","set","key","value","has","Error","delete","clear","ALLOWED_SCHEMA_EXTENSIONS","Set","AppiumSchema","_argSpecs","_registeredSchemas","DRIVER_TYPE","PLUGIN_TYPE","_ajv","_instance","_finalizedSchemas","constructor","_instantiateAjv","create","instance","_","bindAll","hasRegisteredSchema","extType","extName","isFinalized","Boolean","getAllArgSpecs","finalize","ajv","baseSchema","cloneDeep","AppiumConfigJsonSchema","addArgSpecs","schema","propName","propSchema","Object","entries","argSpec","ArgSpec","dest","appiumCliDest","defaultValue","default","arg","omit","properties","server","finalizedSchemas","finalSchema","reduce","extensionSchemas","forEach","$ref","toSchemaBaseRef","$id","additionalProperties","$comment","validateSchema","addSchema","APPIUM_CONFIG_SCHEMA_ID","freeze","Ajv","allErrors","keywords","keyword","addKeyword","reset","schemaId","keys","removeSchema","registerSchema","isUndefined","TypeError","isSupportedSchemaType","SchemaUnsupportedSchemaError","normalizedExtName","kebabCase","get","SchemaNameConflictError","getArgSpec","name","toArg","hasArgSpec","getDefaults","flatten","SchemaFinalizationError","reducer","defaults","retval","values","getDefaultsForExtension","specs","filter","spec","rawDest","getSchema","stack","prefix","flattened","pairs","toPairs","push","SERVER_PROP_NAME","refSchema","err","SchemaUnknownSchemaError","extensionInfoFromRootSchemaId","ReferenceError","ref","_getValidator","id","validator","validate","isArray","errors","isAllowedSchemaFileExtension","filename","path","extname","isPlainObject","$async","code","data","msg","isBoolean","JSON","stringify","appiumSchema","finalizeSchema","resetSchema","flattenSchema","getDefaultsForSchema"],"mappings":"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","sourcesContent":["\nimport Ajv from 'ajv';\nimport addFormats from 'ajv-formats';\nimport _ from 'lodash';\nimport path from 'path';\nimport { DRIVER_TYPE, PLUGIN_TYPE } from '../constants';\nimport { AppiumConfigJsonSchema } from '@appium/schema';\nimport { APPIUM_CONFIG_SCHEMA_ID, ArgSpec, SERVER_PROP_NAME } from './arg-spec';\nimport { keywords } from './keywords';\n\n/**\n * Key/value pairs go in... but they don't come out.\n *\n * @template K,V\n * @extends {Map<K,V>}\n */\nexport class RoachHotelMap extends Map {\n  /**\n   * @param {K} key\n   * @param {V} value\n   */\n  set (key, value) {\n    if (this.has(key)) {\n      throw new Error(`${key} is already set`);\n    }\n    return super.set(key, value);\n  }\n\n  /**\n   * @param {K} key\n   */\n  // eslint-disable-next-line no-unused-vars\n  delete (key) {\n    return false;\n  }\n\n  clear () {\n    throw new Error(`Cannot clear RoachHotelMap`);\n  }\n}\n\n/**\n * Extensions that an extension schema file can have.\n */\nexport const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);\n\n/**\n * A wrapper around Ajv and schema-related functions.\n *\n * Should have been named Highlander, because _there can only be one_\n */\nclass AppiumSchema {\n  /**\n   * A mapping of unique argument IDs to their corresponding {@link ArgSpec}s.\n   *\n   * An \"argument\" is a CLI argument or a config property.\n   *\n   * Used to provide easy lookups of argument metadata when converting between different representations of those arguments.\n   * @private\n   * @type {RoachHotelMap<string,ArgSpec>}\n   */\n  _argSpecs = new RoachHotelMap();\n\n  /**\n   * A map of extension types to extension names to schema objects.\n   *\n   * This data structure is used to ensure there are no naming conflicts. The schemas\n   * are stored here in memory until the instance is _finalized_.\n   * @private\n   * @type {Record<ExtensionType,Map<string,SchemaObject>>}\n   */\n  _registeredSchemas = {[DRIVER_TYPE]: new Map(), [PLUGIN_TYPE]: new Map()};\n\n  /**\n   * Ajv instance\n   *\n   * @private\n   * @type {Ajv}\n   */\n  _ajv;\n\n  /**\n   * Singleton instance.\n   * @private\n   * @type {AppiumSchema}\n   */\n  static _instance;\n\n  /**\n   * Lookup of schema IDs to finalized schemas.\n   *\n   * This does not include references, but rather the root schemas themselves.\n   * @private\n   * @type {Record<string,StrictSchemaObject>?}\n   */\n  _finalizedSchemas = null;\n\n  /**\n   * Initializes Ajv, adds standard formats and our custom keywords.\n   * @see https://npm.im/ajv-formats\n   * @private\n   */\n  constructor () {\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Factory function for {@link AppiumSchema} instances.\n   *\n   * Returns a singleton instance if one exists, otherwise creates a new one.\n   * Binds public methods to the instance.\n   * @returns {AppiumSchema}\n   */\n  static create () {\n    if (!AppiumSchema._instance) {\n      const instance = new AppiumSchema();\n      AppiumSchema._instance = instance;\n      _.bindAll(instance, [\n        'finalize',\n        'flatten',\n        'getAllArgSpecs',\n        'getArgSpec',\n        'getDefaults',\n        'getDefaultsForExtension',\n        'getSchema',\n        'hasArgSpec',\n        'isFinalized',\n        'registerSchema',\n        'hasRegisteredSchema',\n        'reset',\n        'validate',\n      ]);\n    }\n\n    return AppiumSchema._instance;\n  }\n\n  /**\n   * Returns `true` if a schema has been registered using given extension type and name.\n   *\n   * This does not depend on whether or not the instance has been _finalized_.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Name\n   * @returns {boolean} If registered\n   */\n  hasRegisteredSchema (extType, extName) {\n    return this._registeredSchemas[extType].has(extName);\n  }\n\n  /**\n   * Return `true` if {@link AppiumSchema.finalize finalize} has been called\n   * successfully and {@link AppiumSchema.reset reset} has not been called since.\n   * @returns {boolean} If finalized\n   */\n  isFinalized () {\n    return Boolean(this._finalizedSchemas);\n  }\n\n  getAllArgSpecs () {\n    return this._argSpecs;\n  }\n\n  /**\n   * Call this when no more schemas will be registered.\n   *\n   * This does three things:\n   * 1. It combines all schemas from extensions into the Appium config schema,\n   *    then adds the result to the `Ajv` instance.\n   * 2. It adds schemas for _each_ argument/property for validation purposes.\n   *    The CLI uses these schemas to validate specific arguments.\n   * 3. The schemas are validated against JSON schema draft-07 (which is the\n   *    only one supported at this time)\n   *\n   * Any method in this instance that needs to interact with the `Ajv` instance\n   * will throw if this method has not been called.\n   *\n   * If the instance has already been finalized, this is a no-op.\n   * @public\n   * @throws {Error} If the schema is not valid\n   * @returns {Readonly<Record<string,StrictSchemaObject>>} Record of schema IDs to full schema objects\n   */\n  finalize () {\n    if (this.isFinalized()) {\n      return /** @type {NonNullable<typeof this._finalizedSchemas>} */ (\n        this._finalizedSchemas\n      );\n    }\n\n    const ajv = this._ajv;\n\n    // Ajv will _mutate_ the schema, so we need to clone it.\n    const baseSchema = _.cloneDeep(AppiumConfigJsonSchema);\n\n    /**\n     *\n     * @param {SchemaObject} schema\n     * @param {ExtensionType} [extType]\n     * @param {string} [extName]\n     */\n    const addArgSpecs = (schema, extType, extName) => {\n      for (let [propName, propSchema] of Object.entries(schema)) {\n        const argSpec = ArgSpec.create(propName, {\n          dest: propSchema.appiumCliDest,\n          defaultValue: propSchema.default,\n          extType,\n          extName,\n        });\n        const {arg} = argSpec;\n        this._argSpecs.set(arg, argSpec);\n      }\n    };\n\n    addArgSpecs(\n      _.omit(baseSchema.properties.server.properties, [\n        DRIVER_TYPE,\n        PLUGIN_TYPE,\n      ]),\n    );\n\n    /**\n     * @type {Record<string,StrictSchemaObject>}\n     */\n    const finalizedSchemas = {};\n\n    const finalSchema = _.reduce(\n      this._registeredSchemas,\n      /**\n       * @param {typeof baseSchema} baseSchema\n       * @param {Map<string,SchemaObject>} extensionSchemas\n       * @param {ExtensionType} extType\n       */\n      (baseSchema, extensionSchemas, extType) => {\n        extensionSchemas.forEach((schema, extName) => {\n          const $ref = ArgSpec.toSchemaBaseRef(extType, extName);\n          schema.$id = $ref;\n          schema.additionalProperties = false; // this makes `schema` become a `StrictSchemaObject`\n          baseSchema.properties.server.properties[extType].properties[extName] =\n            {$ref, $comment: extName};\n          ajv.validateSchema(schema, true);\n          addArgSpecs(schema.properties, extType, extName);\n          ajv.addSchema(schema, $ref);\n          finalizedSchemas[$ref] = /** @type {StrictSchemaObject} */ (schema);\n        });\n        return baseSchema;\n      },\n      baseSchema,\n    );\n\n    ajv.addSchema(finalSchema, APPIUM_CONFIG_SCHEMA_ID);\n    finalizedSchemas[APPIUM_CONFIG_SCHEMA_ID] = finalSchema;\n    ajv.validateSchema(finalSchema, true);\n\n    this._finalizedSchemas = finalizedSchemas;\n    return Object.freeze(finalizedSchemas);\n  }\n\n  /**\n   * Configures and creates an Ajv instance.\n   * @private\n   * @returns {Ajv}\n   */\n  static _instantiateAjv () {\n    const ajv = addFormats(\n      new Ajv({\n        // without this not much validation actually happens\n        allErrors: true,\n      }),\n    );\n\n    // add custom keywords to ajv. see schema-keywords.js\n    _.forEach(keywords, (keyword) => {\n      ajv.addKeyword(keyword);\n    });\n\n    return ajv;\n  }\n\n  /**\n   * Resets this instance to its original state.\n   *\n   * - Removes all added schemas from the `Ajv` instance\n   * - Resets the map of {@link ArgSpec ArgSpecs}\n   * - Resets the map of registered schemas\n   * - Sets the {@link AppiumSchema._finalized _finalized} flag to `false`\n   *\n   * If you need to call {@link AppiumSchema.finalize} again, you'll want to call this first.\n   * @returns {void}\n   */\n  reset () {\n    for (const schemaId of Object.keys(this._finalizedSchemas ?? {})) {\n      this._ajv.removeSchema(schemaId);\n    }\n    this._argSpecs = new RoachHotelMap();\n    this._registeredSchemas = {\n      [DRIVER_TYPE]: new Map(),\n      [PLUGIN_TYPE]: new Map(),\n    };\n    this._finalizedSchemas = null;\n\n    // Ajv seems to have an over-eager cache, so we have to dump the object entirely.\n    this._ajv = AppiumSchema._instantiateAjv();\n  }\n\n  /**\n   * Registers a schema from an extension.\n   *\n   * This is \"fail-fast\" in that the schema will immediately be validated against JSON schema draft-07 _or_ whatever the value of the schema's `$schema` prop is.\n   *\n   * Does _not_ add the schema to the `ajv` instance (this is done by {@link AppiumSchema.finalize}).\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Unique extension name for `type`\n   * @param {SchemaObject} schema - Schema object\n   * @throws {SchemaNameConflictError} If the schema is an invalid\n   * @returns {void}\n   */\n  registerSchema (extType, extName, schema) {\n    if (!(extType && extName) || _.isUndefined(schema)) {\n      throw new TypeError(\n        'Expected extension type, extension name, and a defined schema',\n      );\n    }\n    if (!AppiumSchema.isSupportedSchemaType(schema)) {\n      throw new SchemaUnsupportedSchemaError(schema, extType, extName);\n    }\n    const normalizedExtName = _.kebabCase(extName);\n    if (this.hasRegisteredSchema(extType, normalizedExtName)) {\n      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {\n        return;\n      }\n      throw new SchemaNameConflictError(extType, extName);\n    }\n    this._ajv.validateSchema(schema, true);\n\n    this._registeredSchemas[extType].set(normalizedExtName, schema);\n  }\n\n  /**\n   * Returns a {@link ArgSpec} for the given argument name.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {ArgSpec|undefined} ArgSpec or `undefined` if not found\n   */\n  getArgSpec (name, extType, extName) {\n    return this._argSpecs.get(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns `true` if the instance knows about an argument by the given `name`.\n   * @param {string} name - CLI argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {boolean} `true` if such an {@link ArgSpec} exists\n   */\n  hasArgSpec (name, extType, extName) {\n    return this._argSpecs.has(ArgSpec.toArg(name, extType, extName));\n  }\n\n  /**\n   * Returns a `Record` of argument \"dest\" strings to default values.\n   *\n   * The \"dest\" string is the property name in object returned by\n   * `argparse.ArgumentParser['parse_args']`.\n   * @template {boolean|undefined} Flattened\n   * @param {Flattened} [flatten=true] - If `true`, flattens the returned object\n   * using \"keypath\"-style keys of the format `<extType>.<extName>.<argName>`.\n   * Otherwise, returns a nested object using `extType` and `extName` as\n   * properties. Base arguments (server arguments) are always at the top level.\n   * @returns {DefaultValues<Flattened>}\n   */\n  getDefaults (flatten = /** @type {Flattened} */ (true)) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n\n    /**\n     * @private\n     * @callback DefaultReducer\n     * @param {DefaultValues<Flattened>} defaults\n     * @param {ArgSpec} argSpec\n     * @returns {DefaultValues<Flattened>}\n     */\n    /** @type {DefaultReducer} */\n    const reducer = flatten\n      ? (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          defaults[dest] = defaultValue;\n        }\n        return defaults;\n      }\n      : (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          _.set(defaults, dest, defaultValue);\n        }\n        return defaults;\n      };\n\n    /** @type {DefaultValues<Flattened>} */\n    const retval = {};\n    return [...this._argSpecs.values()].reduce(reducer, retval);\n  }\n\n  /**\n   * Returns a flattened Record of defaults for a specific extension. Keys will\n   * be of format `<argName>`.\n   * @param {ExtensionType} extType - Extension type\n   * @param {string} extName - Extension name\n   * @returns {Record<string,ArgSpecDefaultValue>}\n   */\n  getDefaultsForExtension (extType, extName) {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n    const specs = [...this._argSpecs.values()].filter(\n      (spec) => spec.extType === extType && spec.extName === extName,\n    );\n    return specs.reduce((defaults, {defaultValue, rawDest}) => {\n      if (!_.isUndefined(defaultValue)) {\n        defaults[rawDest] = defaultValue;\n      }\n      return defaults;\n    }, {});\n  }\n\n  /**\n   * Flatten schema into an array of `SchemaObject`s and associated\n   * {@link ArgSpec ArgSpecs}.\n   *\n   * Converts nested extension schemas to keys based on the extension type and\n   * name. Used when translating to `argparse` options or getting the list of\n   * default values (see {@link AppiumSchema.getDefaults}) for CLI or otherwise.\n   *\n   * The return value is an intermediate reprsentation used by `cli-args`\n   * module's `toParserArgs`, which converts the finalized schema to parameters\n   * used by `argparse`.\n   * @throws If {@link AppiumSchema.finalize} has not been called yet.\n   * @returns {FlattenedSchema}\n   */\n  flatten () {\n    const schema = this.getSchema();\n\n    /** @type { {properties: SchemaObject, prefix: string[]}[] } */\n    const stack = [{properties: schema.properties, prefix: []}];\n    /** @type {FlattenedSchema} */\n    const flattened = [];\n\n    // this bit is a recursive algorithm rewritten as a for loop.\n    // when we find something we want to traverse, we add it to `stack`\n    for (const {properties, prefix} of stack) {\n      const pairs = _.toPairs(properties);\n      for (const [key, value] of pairs) {\n        const {properties, $ref} = value;\n        if (properties) {\n          stack.push({\n            properties,\n            prefix: key === SERVER_PROP_NAME ? [] : [...prefix, key],\n          });\n        } else if ($ref) {\n          let refSchema;\n          try {\n            refSchema = this.getSchema($ref);\n          } catch (err) {\n            // this can happen if an extension schema supplies a $ref to a non-existent schema\n            throw new SchemaUnknownSchemaError($ref);\n          }\n          const {normalizedExtName} =\n            ArgSpec.extensionInfoFromRootSchemaId($ref);\n          if (!normalizedExtName) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Could not determine extension name from schema ID ${$ref}. This is a bug.`,\n            );\n          }\n          stack.push({\n            properties: refSchema.properties,\n            prefix: [...prefix, key, normalizedExtName],\n          });\n        } else if (key !== DRIVER_TYPE && key !== PLUGIN_TYPE) {\n          const [extType, extName] = prefix;\n          const argSpec = this.getArgSpec(\n            key,\n            /** @type {ExtensionType} */ (extType),\n            extName,\n          );\n          if (!argSpec) {\n            /* istanbul ignore next */\n            throw new ReferenceError(\n              `Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`,\n            );\n          }\n          flattened.push({schema: _.cloneDeep(value), argSpec});\n        }\n      }\n    }\n\n    return flattened;\n  }\n\n  /**\n   * Retrieves the schema itself\n   * @public\n   * @param {string} [ref] - Schema ID\n   * @throws If the schema has not yet been finalized\n   * @returns {SchemaObject}\n   */\n  getSchema (ref = APPIUM_CONFIG_SCHEMA_ID) {\n    return /** @type {SchemaObject} */ (this._getValidator(ref).schema);\n  }\n\n  /**\n   * Retrieves schema validator function from Ajv\n   * @param {string} [id] - Schema ID\n   * @private\n   * @returns {import('ajv').ValidateFunction}\n   */\n  _getValidator (id = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = this._ajv.getSchema(id);\n    if (!validator) {\n      if (id === APPIUM_CONFIG_SCHEMA_ID) {\n        throw new SchemaFinalizationError();\n      } else {\n        throw new SchemaUnknownSchemaError(id);\n      }\n    }\n    return validator;\n  }\n\n  /**\n   * Given an object, validates it against the Appium config schema.\n   * If errors occur, the returned array will be non-empty.\n   * @param {any} value - The value (hopefully an object) to validate against the schema\n   * @param {string} [ref] - Schema ID or ref.\n   * @public\n   * @returns {import('ajv').ErrorObject[]} Array of errors, if any.\n   */\n  validate (value, ref = APPIUM_CONFIG_SCHEMA_ID) {\n    const validator = this._getValidator(ref);\n    return !validator(value) && _.isArray(validator.errors)\n      ? [...validator.errors]\n      : [];\n  }\n\n  /**\n   * Returns `true` if `filename`'s file extension is allowed (in {@link ALLOWED_SCHEMA_EXTENSIONS}).\n   * @param {string} filename\n   * @returns {boolean}\n   */\n  static isAllowedSchemaFileExtension (filename) {\n    return ALLOWED_SCHEMA_EXTENSIONS.has(path.extname(filename));\n  }\n\n  /**\n   * Returns `true` if `schema` is a plain object with a non-true `$async` property.\n   * @param {any} schema - Schema to check\n   * @returns {schema is SchemaObject}\n   */\n  static isSupportedSchemaType (schema) {\n    return _.isPlainObject(schema) && schema.$async !== true;\n  }\n}\n\n/**\n * Thrown when the {@link AppiumSchema} instance has not yet been finalized, but\n * the method called requires it.\n */\nexport class SchemaFinalizationError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_FINALIZATION';\n\n  constructor () {\n    super('Schema not yet finalized; `finalize()` must be called first.');\n  }\n}\n\n/**\n * Thrown when a \"unique\" schema ID conflicts with an existing schema ID.\n *\n * This is likely going to be caused by attempting to register the same schema twice.\n */\nexport class SchemaNameConflictError extends Error {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';\n\n  /**\n   * @type {Readonly<{extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (extType, extName) {\n    super(\n      `Name for ${extType} schema \"${extName}\" conflicts with an existing schema`,\n    );\n    this.data = {extType, extName};\n  }\n}\n\n/**\n * Thrown when a schema ID was expected, but it doesn't exist on the {@link Ajv} instance.\n */\nexport class SchemaUnknownSchemaError extends ReferenceError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';\n\n  /**\n   * @type {Readonly<{schemaId: string}>}\n   */\n  data;\n\n  /**\n   * @param {string} schemaId\n   */\n  constructor (schemaId) {\n    super(`Unknown schema: \"${schemaId}\"`);\n    this.data = {schemaId};\n  }\n}\n\n/**\n * Thrown when a schema is provided, but it's of an unsupported type.\n *\n * \"Valid\" schemas which are unsupported include boolean schemas and async schemas\n * (having a `true` `$async` property).\n */\nexport class SchemaUnsupportedSchemaError extends TypeError {\n  /**\n   * @type {Readonly<string>}\n   */\n  code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';\n\n  /**\n   * @type {Readonly<{schema: any, extType: ExtensionType, extName: string}>}\n   */\n  data;\n\n  /**\n   * @param {any} schema\n   * @param {ExtensionType} extType\n   * @param {string} extName\n   */\n  constructor (schema, extType, extName) {\n    // https://github.com/Microsoft/TypeScript/issues/8277\n    super(\n      (() => {\n        let msg = `Unsupported schema from ${extType} \"${extName}\":`;\n        if (_.isBoolean(schema)) {\n          return `${msg} schema cannot be a boolean`;\n        }\n        if (_.isPlainObject(schema)) {\n          if (schema.$async) {\n            return `${msg} schema cannot be an async schema`;\n          }\n          /* istanbul ignore next */\n          throw new TypeError(\n            `schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(\n              schema,\n            )}`,\n          );\n        }\n        return `${msg} schema must be a plain object without a true \"$async\" property`;\n      })(),\n    );\n    this.data = {schema, extType, extName};\n  }\n}\n\nconst appiumSchema = AppiumSchema.create();\n\nexport const {\n  registerSchema,\n  getAllArgSpecs,\n  getArgSpec,\n  hasArgSpec,\n  isFinalized,\n  finalize: finalizeSchema,\n  reset: resetSchema,\n  validate,\n  getSchema,\n  flatten: flattenSchema,\n  getDefaults: getDefaultsForSchema,\n  getDefaultsForExtension,\n} = appiumSchema;\nexport const {isAllowedSchemaFileExtension} = AppiumSchema;\n\n/**\n * Appium only supports schemas that are plain objects; not arrays.\n * @typedef {import('ajv').SchemaObject & {[key: number]: never}} SchemaObject\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n\n/**\n * An object having property `additionalProperties: false`\n * @typedef StrictProp\n * @property {false} additionalProperties\n */\n\n/**\n * A {@link SchemaObject} with `additionalProperties: false`\n * @typedef {SchemaObject & StrictProp} StrictSchemaObject\n */\n\n/**\n * A list of schemas associated with properties and their corresponding {@link ArgSpec} objects.\n *\n * Intermediate data structure used when converting the entire schema down to CLI arguments.\n * @typedef { {schema: SchemaObject, argSpec: ArgSpec}[] } FlattenedSchema\n */\n\n/**\n * @typedef {ArgSpec['defaultValue']} ArgSpecDefaultValue\n */\n\n/**\n * e.g. `{driver: {foo: 'bar'}}` where `foo` is the arg name and `bar` is the default value.\n * @typedef {Record<string,Record<string,ArgSpecDefaultValue>>} NestedArgSpecDefaultValue\n */\n\n/**\n * Helper type for the return value of {@link AppiumSchema.getDefaults}\n * @template {boolean|undefined} Flattened\n * @typedef {Record<string,Flattened extends true ? ArgSpecDefaultValue : ArgSpecDefaultValue | NestedArgSpecDefaultValue>} DefaultValues\n */\n"]}