appium 2.0.0-beta.19 → 2.0.0-beta.22

package/build/lib/schema/schema.js

@@ -0,0 +1,357 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = exports.resetSchema = exports.registerSchema = exports.isFinalized = exports.isAllowedSchemaFileExtension = exports.hasArgSpec = exports.getSchema = exports.getDefaultsFromSchema = exports.getArgSpec = exports.flattenSchema = exports.finalizeSchema = exports.SchemaUnknownSchemaError = exports.SchemaNameConflictError = exports.SchemaFinalizationError = exports.ALLOWED_SCHEMA_EXTENSIONS = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+require("source-map-support/register");
+
+var _ajv = _interopRequireDefault(require("ajv"));
+
+var _ajvFormats = _interopRequireDefault(require("ajv-formats"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _extensionConfig = require("../extension-config");
+
+var _utils = require("../utils");
+
+var _appiumConfigSchema = _interopRequireDefault(require("./appium-config-schema"));
+
+var _argSpec = require("./arg-spec");
+
+var _keywords = require("./keywords");
+
+const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);
+exports.ALLOWED_SCHEMA_EXTENSIONS = ALLOWED_SCHEMA_EXTENSIONS;
+
+class AppiumSchema {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_argSpecs", new _utils.ReadonlyMap());
+    (0, _defineProperty2.default)(this, "_registeredSchemas", {
+      [_extensionConfig.DRIVER_TYPE]: new Map(),
+      [_extensionConfig.PLUGIN_TYPE]: new Map()
+    });
+    (0, _defineProperty2.default)(this, "_ajv", void 0);
+    (0, _defineProperty2.default)(this, "_finalizedSchemas", null);
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  static create() {
+    var _AppiumSchema$_instan;
+
+    const instance = (_AppiumSchema$_instan = AppiumSchema._instance) !== null && _AppiumSchema$_instan !== void 0 ? _AppiumSchema$_instan : new AppiumSchema();
+    AppiumSchema._instance = instance;
+
+    _lodash.default.bindAll(instance, ['finalize', 'flatten', 'getArgSpec', 'getDefaults', 'getSchema', 'hasArgSpec', 'isFinalized', 'registerSchema', 'reset', 'validate']);
+
+    return instance;
+  }
+
+  hasRegisteredSchema(extType, extName) {
+    return this._registeredSchemas[extType].has(extName);
+  }
+
+  isFinalized() {
+    return Boolean(this._finalizedSchemas);
+  }
+
+  finalize() {
+    if (this.isFinalized()) {
+      return this._finalizedSchemas;
+    }
+
+    const ajv = this._ajv;
+
+    const baseSchema = _lodash.default.cloneDeep(_appiumConfigSchema.default);
+
+    const addArgSpecs = (schema, extType, extName) => {
+      for (let [propName, propSchema] of Object.entries(schema)) {
+        const argSpec = _argSpec.ArgSpec.create(propName, {
+          dest: propSchema.appiumCliDest,
+          defaultValue: propSchema.default,
+          extType,
+          extName
+        });
+
+        const {
+          arg
+        } = argSpec;
+
+        this._argSpecs.set(arg, argSpec);
+      }
+    };
+
+    addArgSpecs(_lodash.default.omit(baseSchema.properties.server.properties, [_extensionConfig.DRIVER_TYPE, _extensionConfig.PLUGIN_TYPE]));
+    const finalizedSchemas = {};
+
+    const finalSchema = _lodash.default.reduce(this._registeredSchemas, (baseSchema, extensionSchemas, extType) => {
+      extensionSchemas.forEach((schema, extName) => {
+        const $ref = _argSpec.ArgSpec.toSchemaBaseRef(extType, extName);
+
+        schema.$id = $ref;
+        schema.additionalProperties = false;
+        baseSchema.properties.server.properties[extType].properties[extName] = {
+          $ref,
+          $comment: extName
+        };
+        ajv.validateSchema(schema, true);
+        addArgSpecs(schema.properties, extType, extName);
+        ajv.addSchema(schema, $ref);
+        finalizedSchemas[$ref] = schema;
+      });
+      return baseSchema;
+    }, baseSchema);
+
+    ajv.addSchema(finalSchema, _argSpec.APPIUM_CONFIG_SCHEMA_ID);
+    finalizedSchemas[_argSpec.APPIUM_CONFIG_SCHEMA_ID] = finalSchema;
+    ajv.validateSchema(finalSchema, true);
+    this._finalizedSchemas = finalizedSchemas;
+    return Object.freeze(finalizedSchemas);
+  }
+
+  static _instantiateAjv() {
+    const ajv = (0, _ajvFormats.default)(new _ajv.default({
+      allErrors: true
+    }));
+
+    _lodash.default.forEach(_keywords.keywords, keyword => {
+      ajv.addKeyword(keyword);
+    });
+
+    return ajv;
+  }
+
+  reset() {
+    for (const schemaId of Object.keys((_this$_finalizedSchem = this._finalizedSchemas) !== null && _this$_finalizedSchem !== void 0 ? _this$_finalizedSchem : {})) {
+      var _this$_finalizedSchem;
+
+      this._ajv.removeSchema(schemaId);
+    }
+
+    this._argSpecs = new _utils.ReadonlyMap();
+    this._registeredSchemas = {
+      [_extensionConfig.DRIVER_TYPE]: new Map(),
+      [_extensionConfig.PLUGIN_TYPE]: new Map()
+    };
+    this._finalizedSchemas = null;
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  registerSchema(extType, extName, schema) {
+    if (!(extType && extName && !_lodash.default.isEmpty(schema))) {
+      throw new TypeError('Expected nonempty extension type, extension name and schema parameters');
+    }
+
+    const normalizedExtName = _lodash.default.kebabCase(extName);
+
+    if (this.hasRegisteredSchema(extType, normalizedExtName)) {
+      if (this._registeredSchemas[extType].get(normalizedExtName) === schema) {
+        return;
+      }
+
+      throw new SchemaNameConflictError(extType, extName);
+    }
+
+    this._ajv.validateSchema(schema, true);
+
+    this._registeredSchemas[extType].set(normalizedExtName, schema);
+  }
+
+  getArgSpec(name, extType, extName) {
+    return this._argSpecs.get(_argSpec.ArgSpec.toArg(name, extType, extName));
+  }
+
+  hasArgSpec(name, extType, extName) {
+    return this._argSpecs.has(_argSpec.ArgSpec.toArg(name, extType, extName));
+  }
+
+  getDefaults() {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    return [...this._argSpecs.values()].reduce((defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[dest] = defaultValue;
+      }
+
+      return defaults;
+    }, {});
+  }
+
+  flatten() {
+    const schema = this.getSchema();
+    const stack = [{
+      properties: schema.properties,
+      prefix: []
+    }];
+    const flattened = [];
+
+    for (const {
+      properties,
+      prefix
+    } of stack) {
+      const pairs = _lodash.default.toPairs(properties);
+
+      for (const [key, value] of pairs) {
+        const {
+          properties,
+          $ref
+        } = value;
+
+        if (properties) {
+          stack.push({
+            properties,
+            prefix: key === _argSpec.SERVER_PROP_NAME ? [] : [...prefix, key]
+          });
+        } else if ($ref) {
+          let refSchema;
+
+          try {
+            refSchema = this.getSchema($ref);
+          } catch (err) {
+            throw new SchemaUnknownSchemaError($ref);
+          }
+
+          const {
+            normalizedExtName
+          } = _argSpec.ArgSpec.extensionInfoFromRootSchemaId($ref);
+
+          if (!normalizedExtName) {
+            throw new ReferenceError(`Could not determine extension name from schema ID ${$ref}. This is a bug.`);
+          }
+
+          stack.push({
+            properties: refSchema.properties,
+            prefix: [...prefix, key, normalizedExtName]
+          });
+        } else if (key !== _extensionConfig.DRIVER_TYPE && key !== _extensionConfig.PLUGIN_TYPE) {
+          const [extType, extName] = prefix;
+          const argSpec = this.getArgSpec(key, extType, extName);
+
+          if (!argSpec) {
+            throw new ReferenceError(`Unknown argument with key ${key}, extType ${extType} and extName ${extName}. This is a bug.`);
+          }
+
+          flattened.push({
+            schema: _lodash.default.cloneDeep(value),
+            argSpec
+          });
+        }
+      }
+    }
+
+    return flattened;
+  }
+
+  getSchema(ref = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    return this._getValidator(ref).schema;
+  }
+
+  _getValidator(id = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    const validator = this._ajv.getSchema(id);
+
+    if (!validator) {
+      if (id === _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+        throw new SchemaFinalizationError();
+      } else {
+        throw new SchemaUnknownSchemaError(id);
+      }
+    }
+
+    return validator;
+  }
+
+  validate(value, ref = _argSpec.APPIUM_CONFIG_SCHEMA_ID) {
+    const validator = this._getValidator(ref);
+
+    return !validator(value) && _lodash.default.isArray(validator.errors) ? [...validator.errors] : [];
+  }
+
+  static isAllowedSchemaFileExtension(filename) {
+    return ALLOWED_SCHEMA_EXTENSIONS.has(_path.default.extname(filename));
+  }
+
+}
+
+(0, _defineProperty2.default)(AppiumSchema, "_instance", void 0);
+
+class SchemaFinalizationError extends Error {
+  constructor() {
+    super('Schema not yet finalized; `finalize()` must be called first.');
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_FINALIZATION');
+  }
+
+}
+
+exports.SchemaFinalizationError = SchemaFinalizationError;
+
+class SchemaNameConflictError extends Error {
+  constructor(extType, extName) {
+    super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_NAME_CONFLICT');
+    (0, _defineProperty2.default)(this, "data", void 0);
+    this.data = {
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaNameConflictError = SchemaNameConflictError;
+
+class SchemaUnknownSchemaError extends ReferenceError {
+  constructor(schemaId) {
+    super(`Unknown schema: "${schemaId}"`);
+    (0, _defineProperty2.default)(this, "code", 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA');
+    (0, _defineProperty2.default)(this, "data", void 0);
+    this.data = {
+      schemaId
+    };
+  }
+
+}
+
+exports.SchemaUnknownSchemaError = SchemaUnknownSchemaError;
+const appiumSchema = AppiumSchema.create();
+const {
+  registerSchema,
+  getArgSpec,
+  hasArgSpec,
+  isFinalized,
+  finalize: finalizeSchema,
+  reset: resetSchema,
+  validate,
+  getSchema,
+  flatten: flattenSchema,
+  getDefaults: getDefaultsFromSchema
+} = appiumSchema;
+exports.getDefaultsFromSchema = getDefaultsFromSchema;
+exports.flattenSchema = flattenSchema;
+exports.getSchema = getSchema;
+exports.validate = validate;
+exports.resetSchema = resetSchema;
+exports.finalizeSchema = finalizeSchema;
+exports.isFinalized = isFinalized;
+exports.hasArgSpec = hasArgSpec;
+exports.getArgSpec = getArgSpec;
+exports.registerSchema = registerSchema;
+const {
+  isAllowedSchemaFileExtension
+} = AppiumSchema;
+exports.isAllowedSchemaFileExtension = isAllowedSchemaFileExtension;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/schema/schema.js"],"names":["ALLOWED_SCHEMA_EXTENSIONS","Set","AppiumSchema","constructor","ReadonlyMap","DRIVER_TYPE","Map","PLUGIN_TYPE","_ajv","_instantiateAjv","create","instance","_instance","_","bindAll","hasRegisteredSchema","extType","extName","_registeredSchemas","has","isFinalized","Boolean","_finalizedSchemas","finalize","ajv","baseSchema","cloneDeep","appiumConfigSchema","addArgSpecs","schema","propName","propSchema","Object","entries","argSpec","ArgSpec","dest","appiumCliDest","defaultValue","default","arg","_argSpecs","set","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","isEmpty","TypeError","normalizedExtName","kebabCase","get","SchemaNameConflictError","getArgSpec","name","toArg","hasArgSpec","getDefaults","SchemaFinalizationError","values","defaults","isUndefined","flatten","getSchema","stack","prefix","flattened","pairs","toPairs","key","value","push","SERVER_PROP_NAME","refSchema","err","SchemaUnknownSchemaError","extensionInfoFromRootSchemaId","ReferenceError","ref","_getValidator","id","validator","validate","isArray","errors","isAllowedSchemaFileExtension","filename","path","extname","Error","data","appiumSchema","finalizeSchema","resetSchema","flattenSchema","getDefaultsFromSchema"],"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 '../extension-config';\nimport {ReadonlyMap} from '../utils';\nimport appiumConfigSchema from './appium-config-schema';\nimport {ArgSpec, SERVER_PROP_NAME, APPIUM_CONFIG_SCHEMA_ID} from './arg-spec';\nimport {keywords} from './keywords';\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 {ReadonlyMap<string,ArgSpec>}\n   */\n  _argSpecs = new ReadonlyMap();\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    const instance = AppiumSchema._instance ?? new AppiumSchema();\n    AppiumSchema._instance = instance;\n\n    _.bindAll(instance, [\n      'finalize',\n      'flatten',\n      'getArgSpec',\n      'getDefaults',\n      'getSchema',\n      'hasArgSpec',\n      'isFinalized',\n      'registerSchema',\n      'reset',\n      'validate',\n    ]);\n\n    return 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  /**\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 {Record<string,StrictSchemaObject>} */ (\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(/** @type {StrictSchemaObject} */(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 ReadonlyMap();\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 {import('../ext-config-io').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 && !_.isEmpty(schema))) {\n      throw new TypeError(\n        'Expected nonempty extension type, extension name and schema parameters',\n      );\n    }\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 `argparse.ArgumentParser['parse_args']`.\n   * @returns {Record<string,ArgSpec['defaultValue']>}\n   */\n  getDefaults () {\n    if (!this.isFinalized()) {\n      throw new SchemaFinalizationError();\n    }\n    return [...this._argSpecs.values()].reduce(\n      (defaults, {defaultValue, dest}) => {\n        if (!_.isUndefined(defaultValue)) {\n          defaults[dest] = defaultValue;\n        }\n        return defaults;\n      },\n      {},\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 = /** @type {import('ajv').ValidateFunction} */ (\n      this._getValidator(ref)\n    );\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/**\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\nconst appiumSchema = AppiumSchema.create();\n\nexport const {\n  registerSchema,\n  getArgSpec,\n  hasArgSpec,\n  isFinalized,\n  finalize: finalizeSchema,\n  reset: resetSchema,\n  validate,\n  getSchema,\n  flatten: flattenSchema,\n  getDefaults: getDefaultsFromSchema,\n} = appiumSchema;\nexport const {isAllowedSchemaFileExtension} = AppiumSchema;\n\n/**\n * @typedef {import('ajv').SchemaObject} SchemaObject\n */\n\n/**\n * @typedef {import('../ext-config-io').ExtensionType} ExtensionType\n */\n\n/**\n * An object having property `additionalProperties: false`\n * @typedef {Object} 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"],"file":"lib/schema/schema.js","sourceRoot":"../../.."}

package/build/lib/utils.js

@@ -5,7 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getExtensionArgs = getExtensionArgs;
+exports.ReadonlyMap = void 0;
 exports.getPackageVersion = getPackageVersion;
 exports.insertAppiumPrefixes = insertAppiumPrefixes;
 exports.inspectObject = inspectObject;
@@ -13,7 +13,6 @@ exports.parseCapsForInnerDriver = parseCapsForInnerDriver;
 exports.pullSettings = pullSettings;
 exports.removeAppiumPrefixes = removeAppiumPrefixes;
 exports.rootDir = void 0;
-exports.validateExtensionArgs = validateExtensionArgs;
 
 require("source-map-support/register");
 
@@ -60,35 +59,6 @@ function inspectObject(args) {
   }
 }
 
-function getExtensionArgs(extensionArgs, extensionName) {
-  if (!_lodash.default.has(extensionArgs, extensionName)) {
-    return {};
-  }
-
-  if (!_lodash.default.isPlainObject(extensionArgs[extensionName])) {
-    throw new TypeError(`Driver or plugin arguments must be plain objects`);
-  }
-
-  return extensionArgs[extensionName];
-}
-
-function ensureNoUnknownArgs(extensionArgs, argsConstraints) {
-  const knownArgNames = Object.keys(argsConstraints);
-
-  const unknownArgs = _lodash.default.difference(Object.keys(extensionArgs), knownArgNames);
-
-  if (unknownArgs.length > 0) {
-    throw new Error(`Some arguments were not recognized: ${JSON.stringify(unknownArgs)}. ` + `Are you sure they are in the list of supported args? ${JSON.stringify(knownArgNames)}`);
-  }
-}
-
-function validateExtensionArgs(extensionArgs, argsConstraints) {
-  if (!_lodash.default.isEmpty(extensionArgs) && !_lodash.default.isEmpty(argsConstraints)) {
-    ensureNoUnknownArgs(extensionArgs, argsConstraints);
-    (0, _baseDriver.validateCaps)(extensionArgs, argsConstraints);
-  }
-}
-
 function parseCapsForInnerDriver(jsonwpCapabilities, w3cCapabilities, constraints = {}, defaultCapabilities = {}) {
   const hasW3CCaps = _lodash.default.isPlainObject(w3cCapabilities) && (_lodash.default.has(w3cCapabilities, 'alwaysMatch') || _lodash.default.has(w3cCapabilities, 'firstMatch'));
 
@@ -243,7 +213,28 @@ function pullSettings(caps) {
 
 const rootDir = _support.fs.findRoot(__dirname);
 
-exports.rootDir = rootDir;require('source-map-support').install();
+exports.rootDir = rootDir;
+
+class ReadonlyMap extends Map {
+  set(key, value) {
+    if (this.has(key)) {
+      throw new Error(`${key} is already set`);
+    }
+
+    return super.set(key, value);
+  }
+
+  delete(key) {
+    throw new Error(`${key} cannot be deleted`);
+  }
+
+  clear() {
+    throw new Error(`Cannot clear ReadonlyMap`);
+  }
+
+}
+
+exports.ReadonlyMap = ReadonlyMap;require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/utils.js"],"names":["W3C_APPIUM_PREFIX","inspectObject","args","getValueArray","obj","indent","_","isObject","strArr","arg","value","toPairs","push","shift","logger","info","val","getExtensionArgs","extensionArgs","extensionName","has","isPlainObject","TypeError","ensureNoUnknownArgs","argsConstraints","knownArgNames","Object","keys","unknownArgs","difference","length","Error","JSON","stringify","validateExtensionArgs","isEmpty","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","cloneDeep","defaultCapKey","defaultCapValue","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","assign","message","insertAppiumPrefixes","caps","STANDARD_CAPS","prefixedCaps","name","includes","fixedCaps","key","prefix","startsWith","substring","getPackageVersion","pkgName","pkgInfo","require","version","pullSettings","result","match","exec","rootDir","fs","findRoot","__dirname"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAEA,MAAMA,iBAAiB,GAAG,QAA1B;;AAEA,SAASC,aAAT,CAAwBC,IAAxB,EAA8B;AAC5B,WAASC,aAAT,CAAwBC,GAAxB,EAA6BC,MAAM,GAAG,IAAtC,EAA4C;AAC1C,QAAI,CAACC,gBAAEC,QAAF,CAAWH,GAAX,CAAL,EAAsB;AACpB,aAAO,CAACA,GAAD,CAAP;AACD;;AAED,QAAII,MAAM,GAAG,CAAC,GAAD,CAAb;;AACA,SAAK,IAAI,CAACC,GAAD,EAAMC,KAAN,CAAT,IAAyBJ,gBAAEK,OAAF,CAAUP,GAAV,CAAzB,EAAyC;AACvC,UAAI,CAACE,gBAAEC,QAAF,CAAWG,KAAX,CAAL,EAAwB;AACtBF,QAAAA,MAAM,CAACI,IAAP,CAAa,GAAEP,MAAO,KAAII,GAAI,KAAIC,KAAM,EAAxC;AACD,OAFD,MAEO;AACLA,QAAAA,KAAK,GAAGP,aAAa,CAACO,KAAD,EAAS,GAAEL,MAAO,IAAlB,CAArB;AACAG,QAAAA,MAAM,CAACI,IAAP,CAAa,GAAEP,MAAO,KAAII,GAAI,KAAIC,KAAK,CAACG,KAAN,EAAc,EAAhD;AACAL,QAAAA,MAAM,CAACI,IAAP,CAAY,GAAGF,KAAf;AACD;AACF;;AACDF,IAAAA,MAAM,CAACI,IAAP,CAAa,GAAEP,MAAO,GAAtB;AACA,WAAOG,MAAP;AACD;;AACD,OAAK,IAAI,CAACC,GAAD,EAAMC,KAAN,CAAT,IAAyBJ,gBAAEK,OAAF,CAAUT,IAAV,CAAzB,EAA0C;AACxCQ,IAAAA,KAAK,GAAGP,aAAa,CAACO,KAAD,CAArB;;AACAI,oBAAOC,IAAP,CAAa,KAAIN,GAAI,KAAIC,KAAK,CAACG,KAAN,EAAc,EAAvC;;AACA,SAAK,IAAIG,GAAT,IAAgBN,KAAhB,EAAuB;AACrBI,sBAAOC,IAAP,CAAYC,GAAZ;AACD;AACF;AACF;;AAQD,SAASC,gBAAT,CAA2BC,aAA3B,EAA0CC,aAA1C,EAAyD;AACvD,MAAI,CAACb,gBAAEc,GAAF,CAAMF,aAAN,EAAqBC,aAArB,CAAL,EAA0C;AACxC,WAAO,EAAP;AACD;;AACD,MAAI,CAACb,gBAAEe,aAAF,CAAgBH,aAAa,CAACC,aAAD,CAA7B,CAAL,EAAoD;AAClD,UAAM,IAAIG,SAAJ,CAAe,kDAAf,CAAN;AACD;;AACD,SAAOJ,aAAa,CAACC,aAAD,CAApB;AACD;;AAUD,SAASI,mBAAT,CAA8BL,aAA9B,EAA6CM,eAA7C,EAA8D;AAC5D,QAAMC,aAAa,GAAGC,MAAM,CAACC,IAAP,CAAYH,eAAZ,CAAtB;;AACA,QAAMI,WAAW,GAAGtB,gBAAEuB,UAAF,CAAaH,MAAM,CAACC,IAAP,CAAYT,aAAZ,CAAb,EAAyCO,aAAzC,CAApB;;AACA,MAAIG,WAAW,CAACE,MAAZ,GAAqB,CAAzB,EAA4B;AAC1B,UAAM,IAAIC,KAAJ,CAAW,uCAAsCC,IAAI,CAACC,SAAL,CAAeL,WAAf,CAA4B,IAAnE,GACC,wDAAuDI,IAAI,CAACC,SAAL,CAAeR,aAAf,CAA8B,EADhG,CAAN;AAED;AACF;;AAUD,SAASS,qBAAT,CAAgChB,aAAhC,EAA+CM,eAA/C,EAAgE;AAC9D,MAAI,CAAClB,gBAAE6B,OAAF,CAAUjB,aAAV,CAAD,IAA6B,CAACZ,gBAAE6B,OAAF,CAAUX,eAAV,CAAlC,EAA8D;AAC5DD,IAAAA,mBAAmB,CAACL,aAAD,EAAgBM,eAAhB,CAAnB;AACA,kCAAaN,aAAb,EAA4BM,eAA5B;AACD;AACF;;AAYD,SAASY,uBAAT,CAAkCC,kBAAlC,EAAsDC,eAAtD,EAAuEC,WAAW,GAAG,EAArF,EAAyFC,mBAAmB,GAAG,EAA/G,EAAmH;AAEjH,QAAMC,UAAU,GAAGnC,gBAAEe,aAAF,CAAgBiB,eAAhB,MAChBhC,gBAAEc,GAAF,CAAMkB,eAAN,EAAuB,aAAvB,KAAyChC,gBAAEc,GAAF,CAAMkB,eAAN,EAAuB,YAAvB,CADzB,CAAnB;;AAEA,QAAMI,aAAa,GAAGpC,gBAAEe,aAAF,CAAgBgB,kBAAhB,CAAtB;;AACA,MAAIM,WAAW,GAAG,EAAlB;AACA,MAAIC,wBAAwB,GAAG,IAA/B;AACA,MAAIC,2BAA2B,GAAG,IAAlC;;AAEA,MAAI,CAACJ,UAAL,EAAiB;AACf,WAAO;AACLK,MAAAA,QAAQ,EAAEC,sBAAUC,GADf;AAELC,MAAAA,KAAK,EAAE,IAAIlB,KAAJ,CAAU,qCAAV;AAFF,KAAP;AAID;;AAED,QAAM;AAACiB,IAAAA;AAAD,MAAQD,qBAAd;AACA,QAAMD,QAAQ,GAAGE,GAAjB;AAGAX,EAAAA,kBAAkB,GAAG/B,gBAAE4C,SAAF,CAAYb,kBAAZ,CAArB;AACAC,EAAAA,eAAe,GAAGhC,gBAAE4C,SAAF,CAAYZ,eAAZ,CAAlB;AACAE,EAAAA,mBAAmB,GAAGlC,gBAAE4C,SAAF,CAAYV,mBAAZ,CAAtB;;AAEA,MAAI,CAAClC,gBAAE6B,OAAF,CAAUK,mBAAV,CAAL,EAAqC;AACnC,QAAIC,UAAJ,EAAgB;AACd,WAAK,MAAM,CAACU,aAAD,EAAgBC,eAAhB,CAAX,IAA+C9C,gBAAEK,OAAF,CAAU6B,mBAAV,CAA/C,EAA+E;AAC7E,YAAIa,eAAe,GAAG,KAAtB;;AAEA,aAAK,MAAMC,eAAX,IAA+BhB,eAAe,CAACiB,UAAhB,IAA8B,EAA7D,EAAkE;AAChE,cAAIjD,gBAAEe,aAAF,CAAgBiC,eAAhB,KACGhD,gBAAEc,GAAF,CAAMoC,oBAAoB,CAACF,eAAD,CAA1B,EAA6CG,kBAAkB,CAACN,aAAD,CAA/D,CADP,EACwF;AACtFE,YAAAA,eAAe,GAAG,IAAlB;AACA;AACD;AACF;;AAEDA,QAAAA,eAAe,GAAGA,eAAe,IAAK/C,gBAAEe,aAAF,CAAgBiB,eAAe,CAACoB,WAAhC,KACjCpD,gBAAEc,GAAF,CAAMoC,oBAAoB,CAAClB,eAAe,CAACoB,WAAjB,CAA1B,EAAyDD,kBAAkB,CAACN,aAAD,CAA3E,CADL;;AAEA,YAAIE,eAAJ,EAAqB;AAEnB;AACD;;AAGD,YAAI/C,gBAAE6B,OAAF,CAAUG,eAAe,CAACiB,UAA1B,CAAJ,EAA2C;AACzCjB,UAAAA,eAAe,CAACiB,UAAhB,GAA6B,CAAC;AAAC,aAACJ,aAAD,GAAiBC;AAAlB,WAAD,CAA7B;AACD,SAFD,MAEO;AACLd,UAAAA,eAAe,CAACiB,UAAhB,CAA2B,CAA3B,EAA8BJ,aAA9B,IAA+CC,eAA/C;AACD;AACF;AACF;;AACD,QAAIV,aAAJ,EAAmB;AACjBL,MAAAA,kBAAkB,GAAGX,MAAM,CAACiC,MAAP,CAAc,EAAd,EAAkBH,oBAAoB,CAAChB,mBAAD,CAAtC,EAA6DH,kBAA7D,CAArB;AACD;AACF;;AAGD,MAAIK,aAAJ,EAAmB;AACjBG,IAAAA,2BAA2B,GAAG,EAAC,GAAGR;AAAJ,KAA9B;AACD;;AAGD,MAAII,UAAJ,EAAgB;AAGd,QAAI;AACFE,MAAAA,WAAW,GAAG,qCAAoBL,eAApB,EAAqCC,WAArC,EAAkD,IAAlD,CAAd;AACD,KAFD,CAEE,OAAOU,KAAP,EAAc;AACdnC,sBAAOC,IAAP,CAAa,qCAAoCkC,KAAK,CAACW,OAAQ,EAA/D;;AACA,aAAO;AACLjB,QAAAA,WADK;AAELE,QAAAA,2BAFK;AAGLD,QAAAA,wBAHK;AAILE,QAAAA,QAJK;AAKLG,QAAAA;AALK,OAAP;AAOD;;AAGDL,IAAAA,wBAAwB,GAAG;AACzBc,MAAAA,WAAW,EAAE,EAAC,GAAGG,oBAAoB,CAAClB,WAAD;AAAxB,OADY;AAEzBY,MAAAA,UAAU,EAAE,CAAC,EAAD;AAFa,KAA3B;AAID;;AAED,SAAO;AAACZ,IAAAA,WAAD;AAAcE,IAAAA,2BAAd;AAA2CD,IAAAA,wBAA3C;AAAqEE,IAAAA;AAArE,GAAP;AACD;;AAMD,SAASe,oBAAT,CAA+BC,IAA/B,EAAqC;AAEnC,QAAMC,aAAa,GAAG,CACpB,aADoB,EAEpB,gBAFoB,EAGpB,cAHoB,EAIpB,qBAJoB,EAKpB,kBALoB,EAMpB,OANoB,EAOpB,eAPoB,EAQpB,UARoB,EASpB,yBAToB,CAAtB;AAYA,MAAIC,YAAY,GAAG,EAAnB;;AACA,OAAK,IAAI,CAACC,IAAD,EAAOvD,KAAP,CAAT,IAA0BJ,gBAAEK,OAAF,CAAUmD,IAAV,CAA1B,EAA2C;AACzC,QAAIC,aAAa,CAACG,QAAd,CAAuBD,IAAvB,KAAgCA,IAAI,CAACC,QAAL,CAAc,GAAd,CAApC,EAAwD;AACtDF,MAAAA,YAAY,CAACC,IAAD,CAAZ,GAAqBvD,KAArB;AACD,KAFD,MAEO;AACLsD,MAAAA,YAAY,CAAE,GAAEhE,iBAAkB,IAAGiE,IAAK,EAA9B,CAAZ,GAA+CvD,KAA/C;AACD;AACF;;AACD,SAAOsD,YAAP;AACD;;AAED,SAASR,oBAAT,CAA+BM,IAA/B,EAAqC;AACnC,MAAI,CAACxD,gBAAEe,aAAF,CAAgByC,IAAhB,CAAL,EAA4B;AAC1B,WAAOA,IAAP;AACD;;AAED,QAAMK,SAAS,GAAG,EAAlB;;AACA,OAAK,IAAI,CAACF,IAAD,EAAOvD,KAAP,CAAT,IAA0BJ,gBAAEK,OAAF,CAAUmD,IAAV,CAA1B,EAA2C;AACzCK,IAAAA,SAAS,CAACV,kBAAkB,CAACQ,IAAD,CAAnB,CAAT,GAAsCvD,KAAtC;AACD;;AACD,SAAOyD,SAAP;AACD;;AAED,SAASV,kBAAT,CAA6BW,GAA7B,EAAkC;AAChC,QAAMC,MAAM,GAAI,GAAErE,iBAAkB,GAApC;AACA,SAAOM,gBAAEgE,UAAF,CAAaF,GAAb,EAAkBC,MAAlB,IAA4BD,GAAG,CAACG,SAAJ,CAAcF,MAAM,CAACvC,MAArB,CAA5B,GAA2DsC,GAAlE;AACD;;AAED,SAASI,iBAAT,CAA4BC,OAA5B,EAAqC;AACnC,QAAMC,OAAO,GAAGC,OAAO,CAAE,GAAEF,OAAQ,eAAZ,CAAP,IAAsC,EAAtD;AACA,SAAOC,OAAO,CAACE,OAAf;AACD;;AAkBD,SAASC,YAAT,CAAuBf,IAAvB,EAA6B;AAC3B,MAAI,CAACxD,gBAAEe,aAAF,CAAgByC,IAAhB,CAAD,IAA0BxD,gBAAE6B,OAAF,CAAU2B,IAAV,CAA9B,EAA+C;AAC7C,WAAO,EAAP;AACD;;AAED,QAAMgB,MAAM,GAAG,EAAf;;AACA,OAAK,MAAM,CAACV,GAAD,EAAM1D,KAAN,CAAX,IAA2BJ,gBAAEK,OAAF,CAAUmD,IAAV,CAA3B,EAA4C;AAC1C,UAAMiB,KAAK,GAAG,uBAAuBC,IAAvB,CAA4BZ,GAA5B,CAAd;;AACA,QAAI,CAACW,KAAL,EAAY;AACV;AACD;;AAEDD,IAAAA,MAAM,CAACC,KAAK,CAAC,CAAD,CAAN,CAAN,GAAmBrE,KAAnB;AACA,WAAOoD,IAAI,CAACM,GAAD,CAAX;AACD;;AACD,SAAOU,MAAP;AACD;;AAED,MAAMG,OAAO,GAAGC,YAAGC,QAAH,CAAYC,SAAZ,CAAhB","sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport { processCapabilities, PROTOCOLS, validateCaps as validateArgs } from '@appium/base-driver';\nimport { fs } from '@appium/support';\n\nconst W3C_APPIUM_PREFIX = 'appium';\n\nfunction inspectObject (args) {\n  function getValueArray (obj, indent = '  ') {\n    if (!_.isObject(obj)) {\n      return [obj];\n    }\n\n    let strArr = ['{'];\n    for (let [arg, value] of _.toPairs(obj)) {\n      if (!_.isObject(value)) {\n        strArr.push(`${indent}  ${arg}: ${value}`);\n      } else {\n        value = getValueArray(value, `${indent}  `);\n        strArr.push(`${indent}  ${arg}: ${value.shift()}`);\n        strArr.push(...value);\n      }\n    }\n    strArr.push(`${indent}}`);\n    return strArr;\n  }\n  for (let [arg, value] of _.toPairs(args)) {\n    value = getValueArray(value);\n    logger.info(`  ${arg}: ${value.shift()}`);\n    for (let val of value) {\n      logger.info(val);\n    }\n  }\n}\n\n/**\n * Given a set of CLI args and the name of a driver or plugin, extract those args for that plugin\n * @param {Object} extensionArgs - arguments of the form {[extName]: {[argName]: [argValue]}}\n * @param {string} extensionName - the name of the extension\n * @return {Object} the arg object for that extension alone\n */\nfunction getExtensionArgs (extensionArgs, extensionName) {\n  if (!_.has(extensionArgs, extensionName)) {\n    return {};\n  }\n  if (!_.isPlainObject(extensionArgs[extensionName])) {\n    throw new TypeError(`Driver or plugin arguments must be plain objects`);\n  }\n  return extensionArgs[extensionName];\n}\n\n\n/**\n * Given a set of args and a set of constraints, throw an error if any args are not mentioned in\n * the set of constraints\n * @param {Object} extensionArgs the args\n * @param {Object} argsConstraints the constraints object\n * @throws {Error} if any args were not recognized\n */\nfunction ensureNoUnknownArgs (extensionArgs, argsConstraints) {\n  const knownArgNames = Object.keys(argsConstraints);\n  const unknownArgs = _.difference(Object.keys(extensionArgs), knownArgNames);\n  if (unknownArgs.length > 0) {\n    throw new Error(`Some arguments were not recognized: ${JSON.stringify(unknownArgs)}. ` +\n                    `Are you sure they are in the list of supported args? ${JSON.stringify(knownArgNames)}`);\n  }\n}\n\n/**\n * Takes in a set of driver/plugin args passed in by user, and arg constraints\n * and throws an error if any arg is unknown or of the incorrect type\n *\n * @param {object} extensionArgs - Driver or Plugin specific args\n * @param {object} argsConstraints - Constraints for arguments\n * @throws {Error} if any args are not recognized or are of an invalid type\n*/\nfunction validateExtensionArgs (extensionArgs, argsConstraints) {\n  if (!_.isEmpty(extensionArgs) && !_.isEmpty(argsConstraints)) {\n    ensureNoUnknownArgs(extensionArgs, argsConstraints);\n    validateArgs(extensionArgs, argsConstraints);\n  }\n}\n\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @param {Object} jsonwpCapabilities\n * @param {Object} w3cCapabilities\n * @param {Object} constraints\n * @param {Object} defaultCapabilities\n */\nfunction parseCapsForInnerDriver (jsonwpCapabilities, w3cCapabilities, constraints = {}, defaultCapabilities = {}) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps = _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = {};\n  let processedW3CCapabilities = null;\n  let processedJsonwpCapabilities = null;\n\n  if (!hasW3CCaps) {\n    return {\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    };\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of (w3cCapabilities.firstMatch || [])) {\n          if (_.isPlainObject(firstMatchEntry)\n              && _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet = isCapAlreadySet || (_.isPlainObject(w3cCapabilities.alwaysMatch)\n          && _.has(removeAppiumPrefixes(w3cCapabilities.alwaysMatch), removeAppiumPrefix(defaultCapKey)));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = [{[defaultCapKey]: defaultCapValue}];\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = Object.assign({}, removeAppiumPrefixes(defaultCapabilities), jsonwpCapabilities);\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return {\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      };\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, protocol};\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @param {Object} caps Desired capabilities object\n */\nfunction insertAppiumPrefixes (caps) {\n  // Standard, non-prefixed capabilities (see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)\n  const STANDARD_CAPS = [\n    'browserName',\n    'browserVersion',\n    'platformName',\n    'acceptInsecureCerts',\n    'pageLoadStrategy',\n    'proxy',\n    'setWindowRect',\n    'timeouts',\n    'unhandledPromptBehavior'\n  ];\n\n  let prefixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    if (STANDARD_CAPS.includes(name) || name.includes(':')) {\n      prefixedCaps[name] = value;\n    } else {\n      prefixedCaps[`${W3C_APPIUM_PREFIX}:${name}`] = value;\n    }\n  }\n  return prefixedCaps;\n}\n\nfunction removeAppiumPrefixes (caps) {\n  if (!_.isPlainObject(caps)) {\n    return caps;\n  }\n\n  const fixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    fixedCaps[removeAppiumPrefix(name)] = value;\n  }\n  return fixedCaps;\n}\n\nfunction removeAppiumPrefix (key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\nfunction getPackageVersion (pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings (caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\nexport {\n  inspectObject, parseCapsForInnerDriver, insertAppiumPrefixes, rootDir,\n  getPackageVersion, pullSettings, removeAppiumPrefixes, getExtensionArgs,\n  validateExtensionArgs\n};\n"],"file":"lib/utils.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/utils.js"],"names":["W3C_APPIUM_PREFIX","inspectObject","args","getValueArray","obj","indent","_","isObject","strArr","arg","value","toPairs","push","shift","logger","info","val","parseCapsForInnerDriver","jsonwpCapabilities","w3cCapabilities","constraints","defaultCapabilities","hasW3CCaps","isPlainObject","has","hasJSONWPCaps","desiredCaps","processedW3CCapabilities","processedJsonwpCapabilities","protocol","PROTOCOLS","W3C","error","Error","cloneDeep","isEmpty","defaultCapKey","defaultCapValue","isCapAlreadySet","firstMatchEntry","firstMatch","removeAppiumPrefixes","removeAppiumPrefix","alwaysMatch","Object","assign","message","insertAppiumPrefixes","caps","STANDARD_CAPS","prefixedCaps","name","includes","fixedCaps","key","prefix","startsWith","substring","length","getPackageVersion","pkgName","pkgInfo","require","version","pullSettings","result","match","exec","rootDir","fs","findRoot","__dirname","ReadonlyMap","Map","set","delete","clear"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport logger from './logger';\nimport { processCapabilities, PROTOCOLS } from '@appium/base-driver';\nimport { fs } from '@appium/support';\n\nconst W3C_APPIUM_PREFIX = 'appium';\n\nfunction inspectObject (args) {\n  function getValueArray (obj, indent = '  ') {\n    if (!_.isObject(obj)) {\n      return [obj];\n    }\n\n    let strArr = ['{'];\n    for (let [arg, value] of _.toPairs(obj)) {\n      if (!_.isObject(value)) {\n        strArr.push(`${indent}  ${arg}: ${value}`);\n      } else {\n        value = getValueArray(value, `${indent}  `);\n        strArr.push(`${indent}  ${arg}: ${value.shift()}`);\n        strArr.push(...value);\n      }\n    }\n    strArr.push(`${indent}}`);\n    return strArr;\n  }\n  for (let [arg, value] of _.toPairs(args)) {\n    value = getValueArray(value);\n    logger.info(`  ${arg}: ${value.shift()}`);\n    for (let val of value) {\n      logger.info(val);\n    }\n  }\n}\n\n/**\n * Takes the caps that were provided in the request and translates them\n * into caps that can be used by the inner drivers.\n *\n * @param {Object} jsonwpCapabilities\n * @param {Object} w3cCapabilities\n * @param {Object} constraints\n * @param {Object} defaultCapabilities\n */\nfunction parseCapsForInnerDriver (jsonwpCapabilities, w3cCapabilities, constraints = {}, defaultCapabilities = {}) {\n  // Check if the caller sent JSONWP caps, W3C caps, or both\n  const hasW3CCaps = _.isPlainObject(w3cCapabilities) &&\n    (_.has(w3cCapabilities, 'alwaysMatch') || _.has(w3cCapabilities, 'firstMatch'));\n  const hasJSONWPCaps = _.isPlainObject(jsonwpCapabilities);\n  let desiredCaps = {};\n  let processedW3CCapabilities = null;\n  let processedJsonwpCapabilities = null;\n\n  if (!hasW3CCaps) {\n    return {\n      protocol: PROTOCOLS.W3C,\n      error: new Error('W3C capabilities should be provided'),\n    };\n  }\n\n  const {W3C} = PROTOCOLS;\n  const protocol = W3C;\n\n  // Make sure we don't mutate the original arguments\n  jsonwpCapabilities = _.cloneDeep(jsonwpCapabilities);\n  w3cCapabilities = _.cloneDeep(w3cCapabilities);\n  defaultCapabilities = _.cloneDeep(defaultCapabilities);\n\n  if (!_.isEmpty(defaultCapabilities)) {\n    if (hasW3CCaps) {\n      for (const [defaultCapKey, defaultCapValue] of _.toPairs(defaultCapabilities)) {\n        let isCapAlreadySet = false;\n        // Check if the key is already present in firstMatch entries\n        for (const firstMatchEntry of (w3cCapabilities.firstMatch || [])) {\n          if (_.isPlainObject(firstMatchEntry)\n              && _.has(removeAppiumPrefixes(firstMatchEntry), removeAppiumPrefix(defaultCapKey))) {\n            isCapAlreadySet = true;\n            break;\n          }\n        }\n        // Check if the key is already present in alwaysMatch entries\n        isCapAlreadySet = isCapAlreadySet || (_.isPlainObject(w3cCapabilities.alwaysMatch)\n          && _.has(removeAppiumPrefixes(w3cCapabilities.alwaysMatch), removeAppiumPrefix(defaultCapKey)));\n        if (isCapAlreadySet) {\n          // Skip if the key is already present in the provided caps\n          continue;\n        }\n\n        // Only add the default capability if it is not overridden\n        if (_.isEmpty(w3cCapabilities.firstMatch)) {\n          w3cCapabilities.firstMatch = [{[defaultCapKey]: defaultCapValue}];\n        } else {\n          w3cCapabilities.firstMatch[0][defaultCapKey] = defaultCapValue;\n        }\n      }\n    }\n    if (hasJSONWPCaps) {\n      jsonwpCapabilities = Object.assign({}, removeAppiumPrefixes(defaultCapabilities), jsonwpCapabilities);\n    }\n  }\n\n  // Get MJSONWP caps\n  if (hasJSONWPCaps) {\n    processedJsonwpCapabilities = {...jsonwpCapabilities};\n  }\n\n  // Get W3C caps\n  if (hasW3CCaps) {\n    // Call the process capabilities algorithm to find matching caps on the W3C\n    // (see: https://github.com/jlipps/simple-wd-spec#processing-capabilities)\n    try {\n      desiredCaps = processCapabilities(w3cCapabilities, constraints, true);\n    } catch (error) {\n      logger.info(`Could not parse W3C capabilities: ${error.message}`);\n      return {\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities,\n        protocol,\n        error,\n      };\n    }\n\n    // Create a new w3c capabilities payload that contains only the matching caps in `alwaysMatch`\n    processedW3CCapabilities = {\n      alwaysMatch: {...insertAppiumPrefixes(desiredCaps)},\n      firstMatch: [{}],\n    };\n  }\n\n  return {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, protocol};\n}\n\n/**\n * Takes a capabilities objects and prefixes capabilities with `appium:`\n * @param {Object} caps Desired capabilities object\n */\nfunction insertAppiumPrefixes (caps) {\n  // Standard, non-prefixed capabilities (see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)\n  const STANDARD_CAPS = [\n    'browserName',\n    'browserVersion',\n    'platformName',\n    'acceptInsecureCerts',\n    'pageLoadStrategy',\n    'proxy',\n    'setWindowRect',\n    'timeouts',\n    'unhandledPromptBehavior'\n  ];\n\n  let prefixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    if (STANDARD_CAPS.includes(name) || name.includes(':')) {\n      prefixedCaps[name] = value;\n    } else {\n      prefixedCaps[`${W3C_APPIUM_PREFIX}:${name}`] = value;\n    }\n  }\n  return prefixedCaps;\n}\n\nfunction removeAppiumPrefixes (caps) {\n  if (!_.isPlainObject(caps)) {\n    return caps;\n  }\n\n  const fixedCaps = {};\n  for (let [name, value] of _.toPairs(caps)) {\n    fixedCaps[removeAppiumPrefix(name)] = value;\n  }\n  return fixedCaps;\n}\n\nfunction removeAppiumPrefix (key) {\n  const prefix = `${W3C_APPIUM_PREFIX}:`;\n  return _.startsWith(key, prefix) ? key.substring(prefix.length) : key;\n}\n\nfunction getPackageVersion (pkgName) {\n  const pkgInfo = require(`${pkgName}/package.json`) || {};\n  return pkgInfo.version;\n}\n\n/**\n * Pulls the initial values of Appium settings from the given capabilities argument.\n * Each setting item must satisfy the following format:\n * `setting[setting_name]: setting_value`\n * The capabilities argument itself gets mutated, so it does not contain parsed\n * settings anymore to avoid further parsing issues.\n * Check\n * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md\n * for more details on the available settings.\n *\n * @param {?Object} caps - Capabilities dictionary. It is mutated if\n * one or more settings have been pulled from it\n * @return {Object} - An empty dictionary if the given caps contains no\n * setting items or a dictionary containing parsed Appium setting names along with\n * their values.\n */\nfunction pullSettings (caps) {\n  if (!_.isPlainObject(caps) || _.isEmpty(caps)) {\n    return {};\n  }\n\n  const result = {};\n  for (const [key, value] of _.toPairs(caps)) {\n    const match = /\\bsettings\\[(\\S+)\\]$/.exec(key);\n    if (!match) {\n      continue;\n    }\n\n    result[match[1]] = value;\n    delete caps[key];\n  }\n  return result;\n}\n\nconst rootDir = fs.findRoot(__dirname);\n\n\n/**\n * A Map where you can set properties, but only once. And you can't remove anything. So there.\n * @template K,V\n * @extends {Map<K,V>}\n */\nclass ReadonlyMap 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  delete (key) {\n    throw new Error(`${key} cannot be deleted`);\n  }\n\n  clear () {\n    throw new Error(`Cannot clear ReadonlyMap`);\n  }\n}\n\nexport {\n  inspectObject, parseCapsForInnerDriver, insertAppiumPrefixes, rootDir,\n  getPackageVersion, pullSettings, removeAppiumPrefixes, ReadonlyMap\n};\n"],"file":"lib/utils.js","sourceRoot":"../.."}