appium 2.0.0-beta.3 → 2.0.0-beta.30

package/build/lib/schema/schema.js

@@ -0,0 +1,452 @@
+"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.getDefaultsForSchema = exports.getDefaultsForExtension = exports.getArgSpec = exports.getAllArgSpecs = exports.flattenSchema = exports.finalizeSchema = exports.SchemaUnsupportedSchemaError = exports.SchemaUnknownSchemaError = exports.SchemaNameConflictError = exports.SchemaFinalizationError = exports.RoachHotelMap = exports.ALLOWED_SCHEMA_EXTENSIONS = void 0;
+
+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 _constants = require("../constants");
+
+var _schema = require("@appium/schema");
+
+var _argSpec = require("./arg-spec");
+
+var _keywords = require("./keywords");
+
+class RoachHotelMap extends Map {
+  set(key, value) {
+    if (this.has(key)) {
+      throw new Error(`${key} is already set`);
+    }
+
+    return super.set(key, value);
+  }
+
+  delete(key) {
+    return false;
+  }
+
+  clear() {
+    throw new Error(`Cannot clear RoachHotelMap`);
+  }
+
+}
+
+exports.RoachHotelMap = RoachHotelMap;
+const ALLOWED_SCHEMA_EXTENSIONS = new Set(['.json', '.js', '.cjs']);
+exports.ALLOWED_SCHEMA_EXTENSIONS = ALLOWED_SCHEMA_EXTENSIONS;
+
+class AppiumSchema {
+  _argSpecs = new RoachHotelMap();
+  _registeredSchemas = {
+    [_constants.DRIVER_TYPE]: new Map(),
+    [_constants.PLUGIN_TYPE]: new Map()
+  };
+  _ajv;
+  static _instance;
+  _finalizedSchemas = null;
+
+  constructor() {
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  static create() {
+    if (!AppiumSchema._instance) {
+      const instance = new AppiumSchema();
+      AppiumSchema._instance = instance;
+
+      _lodash.default.bindAll(instance, ['finalize', 'flatten', 'getAllArgSpecs', 'getArgSpec', 'getDefaults', 'getDefaultsForExtension', 'getSchema', 'hasArgSpec', 'isFinalized', 'registerSchema', 'hasRegisteredSchema', 'reset', 'validate']);
+    }
+
+    return AppiumSchema._instance;
+  }
+
+  hasRegisteredSchema(extType, extName) {
+    return this._registeredSchemas[extType].has(extName);
+  }
+
+  isFinalized() {
+    return Boolean(this._finalizedSchemas);
+  }
+
+  getAllArgSpecs() {
+    return this._argSpecs;
+  }
+
+  finalize() {
+    if (this.isFinalized()) {
+      return this._finalizedSchemas;
+    }
+
+    const ajv = this._ajv;
+
+    const baseSchema = _lodash.default.cloneDeep(_schema.AppiumConfigJsonSchema);
+
+    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, [_constants.DRIVER_TYPE, _constants.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 RoachHotelMap();
+    this._registeredSchemas = {
+      [_constants.DRIVER_TYPE]: new Map(),
+      [_constants.PLUGIN_TYPE]: new Map()
+    };
+    this._finalizedSchemas = null;
+    this._ajv = AppiumSchema._instantiateAjv();
+  }
+
+  registerSchema(extType, extName, schema) {
+    if (!(extType && extName) || _lodash.default.isUndefined(schema)) {
+      throw new TypeError('Expected extension type, extension name, and a defined schema');
+    }
+
+    if (!AppiumSchema.isSupportedSchemaType(schema)) {
+      throw new SchemaUnsupportedSchemaError(schema, extType, extName);
+    }
+
+    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(flatten = true) {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    const reducer = flatten ? (defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[dest] = defaultValue;
+      }
+
+      return defaults;
+    } : (defaults, {
+      defaultValue,
+      dest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        _lodash.default.set(defaults, dest, defaultValue);
+      }
+
+      return defaults;
+    };
+    const retval = {};
+    return [...this._argSpecs.values()].reduce(reducer, retval);
+  }
+
+  getDefaultsForExtension(extType, extName) {
+    if (!this.isFinalized()) {
+      throw new SchemaFinalizationError();
+    }
+
+    const specs = [...this._argSpecs.values()].filter(spec => spec.extType === extType && spec.extName === extName);
+    return specs.reduce((defaults, {
+      defaultValue,
+      rawDest
+    }) => {
+      if (!_lodash.default.isUndefined(defaultValue)) {
+        defaults[rawDest] = 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 !== _constants.DRIVER_TYPE && key !== _constants.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));
+  }
+
+  static isSupportedSchemaType(schema) {
+    return _lodash.default.isPlainObject(schema) && schema.$async !== true;
+  }
+
+}
+
+class SchemaFinalizationError extends Error {
+  code = 'APPIUMERR_SCHEMA_FINALIZATION';
+
+  constructor() {
+    super('Schema not yet finalized; `finalize()` must be called first.');
+  }
+
+}
+
+exports.SchemaFinalizationError = SchemaFinalizationError;
+
+class SchemaNameConflictError extends Error {
+  code = 'APPIUMERR_SCHEMA_NAME_CONFLICT';
+  data;
+
+  constructor(extType, extName) {
+    super(`Name for ${extType} schema "${extName}" conflicts with an existing schema`);
+    this.data = {
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaNameConflictError = SchemaNameConflictError;
+
+class SchemaUnknownSchemaError extends ReferenceError {
+  code = 'APPIUMERR_SCHEMA_UNKNOWN_SCHEMA';
+  data;
+
+  constructor(schemaId) {
+    super(`Unknown schema: "${schemaId}"`);
+    this.data = {
+      schemaId
+    };
+  }
+
+}
+
+exports.SchemaUnknownSchemaError = SchemaUnknownSchemaError;
+
+class SchemaUnsupportedSchemaError extends TypeError {
+  code = 'APPIUMERR_SCHEMA_UNSUPPORTED_SCHEMA';
+  data;
+
+  constructor(schema, extType, extName) {
+    super((() => {
+      let msg = `Unsupported schema from ${extType} "${extName}":`;
+
+      if (_lodash.default.isBoolean(schema)) {
+        return `${msg} schema cannot be a boolean`;
+      }
+
+      if (_lodash.default.isPlainObject(schema)) {
+        if (schema.$async) {
+          return `${msg} schema cannot be an async schema`;
+        }
+
+        throw new TypeError(`schema IS supported; this error should not be thrown (this is a bug). value of schema: ${JSON.stringify(schema)}`);
+      }
+
+      return `${msg} schema must be a plain object without a true "$async" property`;
+    })());
+    this.data = {
+      schema,
+      extType,
+      extName
+    };
+  }
+
+}
+
+exports.SchemaUnsupportedSchemaError = SchemaUnsupportedSchemaError;
+const appiumSchema = AppiumSchema.create();
+const {
+  registerSchema,
+  getAllArgSpecs,
+  getArgSpec,
+  hasArgSpec,
+  isFinalized,
+  finalize: finalizeSchema,
+  reset: resetSchema,
+  validate,
+  getSchema,
+  flatten: flattenSchema,
+  getDefaults: getDefaultsForSchema,
+  getDefaultsForExtension
+} = appiumSchema;
+exports.getDefaultsForExtension = getDefaultsForExtension;
+exports.getDefaultsForSchema = getDefaultsForSchema;
+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.getAllArgSpecs = getAllArgSpecs;
+exports.registerSchema = registerSchema;
+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","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":";;;;;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AAQO,MAAMA,aAAN,SAA4BC,GAA5B,CAAgC;AAKrCC,EAAAA,GAAG,CAAEC,GAAF,EAAOC,KAAP,EAAc;AACf,QAAI,KAAKC,GAAL,CAASF,GAAT,CAAJ,EAAmB;AACjB,YAAM,IAAIG,KAAJ,CAAW,GAAEH,GAAI,iBAAjB,CAAN;AACD;;AACD,WAAO,MAAMD,GAAN,CAAUC,GAAV,EAAeC,KAAf,CAAP;AACD;;AAMDG,EAAAA,MAAM,CAAEJ,GAAF,EAAO;AACX,WAAO,KAAP;AACD;;AAEDK,EAAAA,KAAK,GAAI;AACP,UAAM,IAAIF,KAAJ,CAAW,4BAAX,CAAN;AACD;;AAtBoC;;;AA4BhC,MAAMG,yBAAyB,GAAG,IAAIC,GAAJ,CAAQ,CAAC,OAAD,EAAU,KAAV,EAAiB,MAAjB,CAAR,CAAlC;;;AAOP,MAAMC,YAAN,CAAmB;AAUjBC,EAAAA,SAAS,GAAG,IAAIZ,aAAJ,EAAH;AAUTa,EAAAA,kBAAkB,GAAG;AAAC,KAACC,sBAAD,GAAe,IAAIb,GAAJ,EAAhB;AAA2B,KAACc,sBAAD,GAAe,IAAId,GAAJ;AAA1C,GAAH;AAQlBe,EAAAA,IAAI;AAOY,SAATC,SAAS;AAShBC,EAAAA,iBAAiB,GAAG,IAAH;;AAOjBC,EAAAA,WAAW,GAAI;AACb,SAAKH,IAAL,GAAYL,YAAY,CAACS,eAAb,EAAZ;AACD;;AASY,SAANC,MAAM,GAAI;AACf,QAAI,CAACV,YAAY,CAACM,SAAlB,EAA6B;AAC3B,YAAMK,QAAQ,GAAG,IAAIX,YAAJ,EAAjB;AACAA,MAAAA,YAAY,CAACM,SAAb,GAAyBK,QAAzB;;AACAC,sBAAEC,OAAF,CAAUF,QAAV,EAAoB,CAClB,UADkB,EAElB,SAFkB,EAGlB,gBAHkB,EAIlB,YAJkB,EAKlB,aALkB,EAMlB,yBANkB,EAOlB,WAPkB,EAQlB,YARkB,EASlB,aATkB,EAUlB,gBAVkB,EAWlB,qBAXkB,EAYlB,OAZkB,EAalB,UAbkB,CAApB;AAeD;;AAED,WAAOX,YAAY,CAACM,SAApB;AACD;;AAUDQ,EAAAA,mBAAmB,CAAEC,OAAF,EAAWC,OAAX,EAAoB;AACrC,WAAO,KAAKd,kBAAL,CAAwBa,OAAxB,EAAiCrB,GAAjC,CAAqCsB,OAArC,CAAP;AACD;;AAODC,EAAAA,WAAW,GAAI;AACb,WAAOC,OAAO,CAAC,KAAKX,iBAAN,CAAd;AACD;;AAEDY,EAAAA,cAAc,GAAI;AAChB,WAAO,KAAKlB,SAAZ;AACD;;AAqBDmB,EAAAA,QAAQ,GAAI;AACV,QAAI,KAAKH,WAAL,EAAJ,EAAwB;AACtB,aACE,KAAKV,iBADP;AAGD;;AAED,UAAMc,GAAG,GAAG,KAAKhB,IAAjB;;AAGA,UAAMiB,UAAU,GAAGV,gBAAEW,SAAF,CAAYC,8BAAZ,CAAnB;;AAQA,UAAMC,WAAW,GAAG,CAACC,MAAD,EAASX,OAAT,EAAkBC,OAAlB,KAA8B;AAChD,WAAK,IAAI,CAACW,QAAD,EAAWC,UAAX,CAAT,IAAmCC,MAAM,CAACC,OAAP,CAAeJ,MAAf,CAAnC,EAA2D;AACzD,cAAMK,OAAO,GAAGC,iBAAQtB,MAAR,CAAeiB,QAAf,EAAyB;AACvCM,UAAAA,IAAI,EAAEL,UAAU,CAACM,aADsB;AAEvCC,UAAAA,YAAY,EAAEP,UAAU,CAACQ,OAFc;AAGvCrB,UAAAA,OAHuC;AAIvCC,UAAAA;AAJuC,SAAzB,CAAhB;;AAMA,cAAM;AAACqB,UAAAA;AAAD,YAAQN,OAAd;;AACA,aAAK9B,SAAL,CAAeV,GAAf,CAAmB8C,GAAnB,EAAwBN,OAAxB;AACD;AACF,KAXD;;AAaAN,IAAAA,WAAW,CACTb,gBAAE0B,IAAF,CAAOhB,UAAU,CAACiB,UAAX,CAAsBC,MAAtB,CAA6BD,UAApC,EAAgD,CAC9CpC,sBAD8C,EAE9CC,sBAF8C,CAAhD,CADS,CAAX;AAUA,UAAMqC,gBAAgB,GAAG,EAAzB;;AAEA,UAAMC,WAAW,GAAG9B,gBAAE+B,MAAF,CAClB,KAAKzC,kBADa,EAOlB,CAACoB,UAAD,EAAasB,gBAAb,EAA+B7B,OAA/B,KAA2C;AACzC6B,MAAAA,gBAAgB,CAACC,OAAjB,CAAyB,CAACnB,MAAD,EAASV,OAAT,KAAqB;AAC5C,cAAM8B,IAAI,GAAGd,iBAAQe,eAAR,CAAwBhC,OAAxB,EAAiCC,OAAjC,CAAb;;AACAU,QAAAA,MAAM,CAACsB,GAAP,GAAaF,IAAb;AACApB,QAAAA,MAAM,CAACuB,oBAAP,GAA8B,KAA9B;AACA3B,QAAAA,UAAU,CAACiB,UAAX,CAAsBC,MAAtB,CAA6BD,UAA7B,CAAwCxB,OAAxC,EAAiDwB,UAAjD,CAA4DvB,OAA5D,IACE;AAAC8B,UAAAA,IAAD;AAAOI,UAAAA,QAAQ,EAAElC;AAAjB,SADF;AAEAK,QAAAA,GAAG,CAAC8B,cAAJ,CAAmBzB,MAAnB,EAA2B,IAA3B;AACAD,QAAAA,WAAW,CAACC,MAAM,CAACa,UAAR,EAAoBxB,OAApB,EAA6BC,OAA7B,CAAX;AACAK,QAAAA,GAAG,CAAC+B,SAAJ,CAAc1B,MAAd,EAAsBoB,IAAtB;AACAL,QAAAA,gBAAgB,CAACK,IAAD,CAAhB,GAA4DpB,MAA5D;AACD,OAVD;AAWA,aAAOJ,UAAP;AACD,KApBiB,EAqBlBA,UArBkB,CAApB;;AAwBAD,IAAAA,GAAG,CAAC+B,SAAJ,CAAcV,WAAd,EAA2BW,gCAA3B;AACAZ,IAAAA,gBAAgB,CAACY,gCAAD,CAAhB,GAA4CX,WAA5C;AACArB,IAAAA,GAAG,CAAC8B,cAAJ,CAAmBT,WAAnB,EAAgC,IAAhC;AAEA,SAAKnC,iBAAL,GAAyBkC,gBAAzB;AACA,WAAOZ,MAAM,CAACyB,MAAP,CAAcb,gBAAd,CAAP;AACD;;AAOqB,SAAfhC,eAAe,GAAI;AACxB,UAAMY,GAAG,GAAG,yBACV,IAAIkC,YAAJ,CAAQ;AAENC,MAAAA,SAAS,EAAE;AAFL,KAAR,CADU,CAAZ;;AAQA5C,oBAAEiC,OAAF,CAAUY,kBAAV,EAAqBC,OAAD,IAAa;AAC/BrC,MAAAA,GAAG,CAACsC,UAAJ,CAAeD,OAAf;AACD,KAFD;;AAIA,WAAOrC,GAAP;AACD;;AAaDuC,EAAAA,KAAK,GAAI;AACP,SAAK,MAAMC,QAAX,IAAuBhC,MAAM,CAACiC,IAAP,0BAAY,KAAKvD,iBAAjB,yEAAsC,EAAtC,CAAvB,EAAkE;AAAA;;AAChE,WAAKF,IAAL,CAAU0D,YAAV,CAAuBF,QAAvB;AACD;;AACD,SAAK5D,SAAL,GAAiB,IAAIZ,aAAJ,EAAjB;AACA,SAAKa,kBAAL,GAA0B;AACxB,OAACC,sBAAD,GAAe,IAAIb,GAAJ,EADS;AAExB,OAACc,sBAAD,GAAe,IAAId,GAAJ;AAFS,KAA1B;AAIA,SAAKiB,iBAAL,GAAyB,IAAzB;AAGA,SAAKF,IAAL,GAAYL,YAAY,CAACS,eAAb,EAAZ;AACD;;AAcDuD,EAAAA,cAAc,CAAEjD,OAAF,EAAWC,OAAX,EAAoBU,MAApB,EAA4B;AACxC,QAAI,EAAEX,OAAO,IAAIC,OAAb,KAAyBJ,gBAAEqD,WAAF,CAAcvC,MAAd,CAA7B,EAAoD;AAClD,YAAM,IAAIwC,SAAJ,CACJ,+DADI,CAAN;AAGD;;AACD,QAAI,CAAClE,YAAY,CAACmE,qBAAb,CAAmCzC,MAAnC,CAAL,EAAiD;AAC/C,YAAM,IAAI0C,4BAAJ,CAAiC1C,MAAjC,EAAyCX,OAAzC,EAAkDC,OAAlD,CAAN;AACD;;AACD,UAAMqD,iBAAiB,GAAGzD,gBAAE0D,SAAF,CAAYtD,OAAZ,CAA1B;;AACA,QAAI,KAAKF,mBAAL,CAAyBC,OAAzB,EAAkCsD,iBAAlC,CAAJ,EAA0D;AACxD,UAAI,KAAKnE,kBAAL,CAAwBa,OAAxB,EAAiCwD,GAAjC,CAAqCF,iBAArC,MAA4D3C,MAAhE,EAAwE;AACtE;AACD;;AACD,YAAM,IAAI8C,uBAAJ,CAA4BzD,OAA5B,EAAqCC,OAArC,CAAN;AACD;;AACD,SAAKX,IAAL,CAAU8C,cAAV,CAAyBzB,MAAzB,EAAiC,IAAjC;;AAEA,SAAKxB,kBAAL,CAAwBa,OAAxB,EAAiCxB,GAAjC,CAAqC8E,iBAArC,EAAwD3C,MAAxD;AACD;;AASD+C,EAAAA,UAAU,CAAEC,IAAF,EAAQ3D,OAAR,EAAiBC,OAAjB,EAA0B;AAClC,WAAO,KAAKf,SAAL,CAAesE,GAAf,CAAmBvC,iBAAQ2C,KAAR,CAAcD,IAAd,EAAoB3D,OAApB,EAA6BC,OAA7B,CAAnB,CAAP;AACD;;AASD4D,EAAAA,UAAU,CAAEF,IAAF,EAAQ3D,OAAR,EAAiBC,OAAjB,EAA0B;AAClC,WAAO,KAAKf,SAAL,CAAeP,GAAf,CAAmBsC,iBAAQ2C,KAAR,CAAcD,IAAd,EAAoB3D,OAApB,EAA6BC,OAA7B,CAAnB,CAAP;AACD;;AAcD6D,EAAAA,WAAW,CAAEC,OAAO,GAA6B,IAAtC,EAA6C;AACtD,QAAI,CAAC,KAAK7D,WAAL,EAAL,EAAyB;AACvB,YAAM,IAAI8D,uBAAJ,EAAN;AACD;;AAUD,UAAMC,OAAO,GAAGF,OAAO,GACnB,CAACG,QAAD,EAAW;AAAC9C,MAAAA,YAAD;AAAeF,MAAAA;AAAf,KAAX,KAAoC;AACpC,UAAI,CAACrB,gBAAEqD,WAAF,CAAc9B,YAAd,CAAL,EAAkC;AAChC8C,QAAAA,QAAQ,CAAChD,IAAD,CAAR,GAAiBE,YAAjB;AACD;;AACD,aAAO8C,QAAP;AACD,KANoB,GAOnB,CAACA,QAAD,EAAW;AAAC9C,MAAAA,YAAD;AAAeF,MAAAA;AAAf,KAAX,KAAoC;AACpC,UAAI,CAACrB,gBAAEqD,WAAF,CAAc9B,YAAd,CAAL,EAAkC;AAChCvB,wBAAErB,GAAF,CAAM0F,QAAN,EAAgBhD,IAAhB,EAAsBE,YAAtB;AACD;;AACD,aAAO8C,QAAP;AACD,KAZH;AAeA,UAAMC,MAAM,GAAG,EAAf;AACA,WAAO,CAAC,GAAG,KAAKjF,SAAL,CAAekF,MAAf,EAAJ,EAA6BxC,MAA7B,CAAoCqC,OAApC,EAA6CE,MAA7C,CAAP;AACD;;AASDE,EAAAA,uBAAuB,CAAErE,OAAF,EAAWC,OAAX,EAAoB;AACzC,QAAI,CAAC,KAAKC,WAAL,EAAL,EAAyB;AACvB,YAAM,IAAI8D,uBAAJ,EAAN;AACD;;AACD,UAAMM,KAAK,GAAG,CAAC,GAAG,KAAKpF,SAAL,CAAekF,MAAf,EAAJ,EAA6BG,MAA7B,CACXC,IAAD,IAAUA,IAAI,CAACxE,OAAL,KAAiBA,OAAjB,IAA4BwE,IAAI,CAACvE,OAAL,KAAiBA,OAD3C,CAAd;AAGA,WAAOqE,KAAK,CAAC1C,MAAN,CAAa,CAACsC,QAAD,EAAW;AAAC9C,MAAAA,YAAD;AAAeqD,MAAAA;AAAf,KAAX,KAAuC;AACzD,UAAI,CAAC5E,gBAAEqD,WAAF,CAAc9B,YAAd,CAAL,EAAkC;AAChC8C,QAAAA,QAAQ,CAACO,OAAD,CAAR,GAAoBrD,YAApB;AACD;;AACD,aAAO8C,QAAP;AACD,KALM,EAKJ,EALI,CAAP;AAMD;;AAgBDH,EAAAA,OAAO,GAAI;AACT,UAAMpD,MAAM,GAAG,KAAK+D,SAAL,EAAf;AAGA,UAAMC,KAAK,GAAG,CAAC;AAACnD,MAAAA,UAAU,EAAEb,MAAM,CAACa,UAApB;AAAgCoD,MAAAA,MAAM,EAAE;AAAxC,KAAD,CAAd;AAEA,UAAMC,SAAS,GAAG,EAAlB;;AAIA,SAAK,MAAM;AAACrD,MAAAA,UAAD;AAAaoD,MAAAA;AAAb,KAAX,IAAmCD,KAAnC,EAA0C;AACxC,YAAMG,KAAK,GAAGjF,gBAAEkF,OAAF,CAAUvD,UAAV,CAAd;;AACA,WAAK,MAAM,CAAC/C,GAAD,EAAMC,KAAN,CAAX,IAA2BoG,KAA3B,EAAkC;AAChC,cAAM;AAACtD,UAAAA,UAAD;AAAaO,UAAAA;AAAb,YAAqBrD,KAA3B;;AACA,YAAI8C,UAAJ,EAAgB;AACdmD,UAAAA,KAAK,CAACK,IAAN,CAAW;AACTxD,YAAAA,UADS;AAEToD,YAAAA,MAAM,EAAEnG,GAAG,KAAKwG,yBAAR,GAA2B,EAA3B,GAAgC,CAAC,GAAGL,MAAJ,EAAYnG,GAAZ;AAF/B,WAAX;AAID,SALD,MAKO,IAAIsD,IAAJ,EAAU;AACf,cAAImD,SAAJ;;AACA,cAAI;AACFA,YAAAA,SAAS,GAAG,KAAKR,SAAL,CAAe3C,IAAf,CAAZ;AACD,WAFD,CAEE,OAAOoD,GAAP,EAAY;AAEZ,kBAAM,IAAIC,wBAAJ,CAA6BrD,IAA7B,CAAN;AACD;;AACD,gBAAM;AAACuB,YAAAA;AAAD,cACJrC,iBAAQoE,6BAAR,CAAsCtD,IAAtC,CADF;;AAEA,cAAI,CAACuB,iBAAL,EAAwB;AAEtB,kBAAM,IAAIgC,cAAJ,CACH,qDAAoDvD,IAAK,kBADtD,CAAN;AAGD;;AACD4C,UAAAA,KAAK,CAACK,IAAN,CAAW;AACTxD,YAAAA,UAAU,EAAE0D,SAAS,CAAC1D,UADb;AAEToD,YAAAA,MAAM,EAAE,CAAC,GAAGA,MAAJ,EAAYnG,GAAZ,EAAiB6E,iBAAjB;AAFC,WAAX;AAID,SApBM,MAoBA,IAAI7E,GAAG,KAAKW,sBAAR,IAAuBX,GAAG,KAAKY,sBAAnC,EAAgD;AACrD,gBAAM,CAACW,OAAD,EAAUC,OAAV,IAAqB2E,MAA3B;AACA,gBAAM5D,OAAO,GAAG,KAAK0C,UAAL,CACdjF,GADc,EAEgBuB,OAFhB,EAGdC,OAHc,CAAhB;;AAKA,cAAI,CAACe,OAAL,EAAc;AAEZ,kBAAM,IAAIsE,cAAJ,CACH,6BAA4B7G,GAAI,aAAYuB,OAAQ,gBAAeC,OAAQ,kBADxE,CAAN;AAGD;;AACD4E,UAAAA,SAAS,CAACG,IAAV,CAAe;AAACrE,YAAAA,MAAM,EAAEd,gBAAEW,SAAF,CAAY9B,KAAZ,CAAT;AAA6BsC,YAAAA;AAA7B,WAAf;AACD;AACF;AACF;;AAED,WAAO6D,SAAP;AACD;;AASDH,EAAAA,SAAS,CAAEa,GAAG,GAAGjD,gCAAR,EAAiC;AACxC,WAAoC,KAAKkD,aAAL,CAAmBD,GAAnB,EAAwB5E,MAA5D;AACD;;AAQD6E,EAAAA,aAAa,CAAEC,EAAE,GAAGnD,gCAAP,EAAgC;AAC3C,UAAMoD,SAAS,GAAG,KAAKpG,IAAL,CAAUoF,SAAV,CAAoBe,EAApB,CAAlB;;AACA,QAAI,CAACC,SAAL,EAAgB;AACd,UAAID,EAAE,KAAKnD,gCAAX,EAAoC;AAClC,cAAM,IAAI0B,uBAAJ,EAAN;AACD,OAFD,MAEO;AACL,cAAM,IAAIoB,wBAAJ,CAA6BK,EAA7B,CAAN;AACD;AACF;;AACD,WAAOC,SAAP;AACD;;AAUDC,EAAAA,QAAQ,CAAEjH,KAAF,EAAS6G,GAAG,GAAGjD,gCAAf,EAAwC;AAC9C,UAAMoD,SAAS,GAAG,KAAKF,aAAL,CAAmBD,GAAnB,CAAlB;;AACA,WAAO,CAACG,SAAS,CAAChH,KAAD,CAAV,IAAqBmB,gBAAE+F,OAAF,CAAUF,SAAS,CAACG,MAApB,CAArB,GACH,CAAC,GAAGH,SAAS,CAACG,MAAd,CADG,GAEH,EAFJ;AAGD;;AAOkC,SAA5BC,4BAA4B,CAAEC,QAAF,EAAY;AAC7C,WAAOhH,yBAAyB,CAACJ,GAA1B,CAA8BqH,cAAKC,OAAL,CAAaF,QAAb,CAA9B,CAAP;AACD;;AAO2B,SAArB3C,qBAAqB,CAAEzC,MAAF,EAAU;AACpC,WAAOd,gBAAEqG,aAAF,CAAgBvF,MAAhB,KAA2BA,MAAM,CAACwF,MAAP,KAAkB,IAApD;AACD;;AA3fgB;;AAkgBZ,MAAMnC,uBAAN,SAAsCpF,KAAtC,CAA4C;AAIjDwH,EAAAA,IAAI,GAAG,+BAAH;;AAEJ3G,EAAAA,WAAW,GAAI;AACb,UAAM,8DAAN;AACD;;AARgD;;;;AAgB5C,MAAMgE,uBAAN,SAAsC7E,KAAtC,CAA4C;AAIjDwH,EAAAA,IAAI,GAAG,gCAAH;AAKJC,EAAAA,IAAI;;AAMJ5G,EAAAA,WAAW,CAAEO,OAAF,EAAWC,OAAX,EAAoB;AAC7B,UACG,YAAWD,OAAQ,YAAWC,OAAQ,qCADzC;AAGA,SAAKoG,IAAL,GAAY;AAACrG,MAAAA,OAAD;AAAUC,MAAAA;AAAV,KAAZ;AACD;;AApBgD;;;;AA0B5C,MAAMmF,wBAAN,SAAuCE,cAAvC,CAAsD;AAI3Dc,EAAAA,IAAI,GAAG,iCAAH;AAKJC,EAAAA,IAAI;;AAKJ5G,EAAAA,WAAW,CAAEqD,QAAF,EAAY;AACrB,UAAO,oBAAmBA,QAAS,GAAnC;AACA,SAAKuD,IAAL,GAAY;AAACvD,MAAAA;AAAD,KAAZ;AACD;;AAjB0D;;;;AA0BtD,MAAMO,4BAAN,SAA2CF,SAA3C,CAAqD;AAI1DiD,EAAAA,IAAI,GAAG,qCAAH;AAKJC,EAAAA,IAAI;;AAOJ5G,EAAAA,WAAW,CAAEkB,MAAF,EAAUX,OAAV,EAAmBC,OAAnB,EAA4B;AAErC,UACE,CAAC,MAAM;AACL,UAAIqG,GAAG,GAAI,2BAA0BtG,OAAQ,KAAIC,OAAQ,IAAzD;;AACA,UAAIJ,gBAAE0G,SAAF,CAAY5F,MAAZ,CAAJ,EAAyB;AACvB,eAAQ,GAAE2F,GAAI,6BAAd;AACD;;AACD,UAAIzG,gBAAEqG,aAAF,CAAgBvF,MAAhB,CAAJ,EAA6B;AAC3B,YAAIA,MAAM,CAACwF,MAAX,EAAmB;AACjB,iBAAQ,GAAEG,GAAI,mCAAd;AACD;;AAED,cAAM,IAAInD,SAAJ,CACH,0FAAyFqD,IAAI,CAACC,SAAL,CACxF9F,MADwF,CAExF,EAHE,CAAN;AAKD;;AACD,aAAQ,GAAE2F,GAAI,iEAAd;AACD,KAjBD,GADF;AAoBA,SAAKD,IAAL,GAAY;AAAC1F,MAAAA,MAAD;AAASX,MAAAA,OAAT;AAAkBC,MAAAA;AAAlB,KAAZ;AACD;;AAvCyD;;;AA0C5D,MAAMyG,YAAY,GAAGzH,YAAY,CAACU,MAAb,EAArB;AAEO,MAAM;AACXsD,EAAAA,cADW;AAEX7C,EAAAA,cAFW;AAGXsD,EAAAA,UAHW;AAIXG,EAAAA,UAJW;AAKX3D,EAAAA,WALW;AAMXG,EAAAA,QAAQ,EAAEsG,cANC;AAOX9D,EAAAA,KAAK,EAAE+D,WAPI;AAQXjB,EAAAA,QARW;AASXjB,EAAAA,SATW;AAUXX,EAAAA,OAAO,EAAE8C,aAVE;AAWX/C,EAAAA,WAAW,EAAEgD,oBAXF;AAYXzC,EAAAA;AAZW,IAaTqC,YAbG;;;;;;;;;;;;;AAcA,MAAM;AAACZ,EAAAA;AAAD,IAAiC7G,YAAvC","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"]}

package/build/lib/utils.d.ts

@@ -0,0 +1,66 @@
+export type ParsedDriverCaps = {
+    desiredCaps: Capabilities;
+    protocol: string;
+    processedJsonwpCapabilities?: any;
+    processedW3CCapabilities?: W3CCapabilities | undefined;
+};
+export type InvalidCaps = {
+    error: Error;
+    protocol: string;
+    desiredCaps?: Partial<import("@wdio/types/build/Capabilities").Capabilities & import("@wdio/types/build/Capabilities").AppiumCapabilities & {
+        [x: string]: any;
+    }> | undefined;
+    processedJsonwpCapabilities?: any;
+    processedW3CCapabilities?: W3CCapabilities | undefined;
+};
+export type W3CCapabilities = import('@appium/types').W3CCapabilities;
+export type Capabilities = import('@appium/types').Capabilities;
+export type AppiumW3CCapabilities = import('@appium/types').AppiumW3CCapabilities;
+/**
+ * Dumps to value to the console using `info` logger.
+ *
+ * @todo May want to force color to be `false` if {@link isStdoutTTY} is `false`.
+ */
+export const inspect: (t1: any) => void;
+/**
+ * Takes the caps that were provided in the request and translates them
+ * into caps that can be used by the inner drivers.
+ *
+ * @param {any} jsonwpCapabilities
+ * @param {W3CCapabilities} w3cCapabilities
+ * @param {import('@appium/types').Constraints} constraints
+ * @param {import('@appium/types').DefaultCapabilitiesConfig} [defaultCapabilities]
+ * @returns {ParsedDriverCaps|InvalidCaps}
+ */
+export function parseCapsForInnerDriver(jsonwpCapabilities: any, w3cCapabilities: W3CCapabilities, constraints?: import('@appium/types').Constraints, defaultCapabilities?: import("@appium/types").DefaultCapabilitiesConfig | undefined): ParsedDriverCaps | InvalidCaps;
+/**
+ * Takes a capabilities objects and prefixes capabilities with `appium:`
+ * @param {Capabilities} caps Desired capabilities object
+ * @returns {AppiumW3CCapabilities}
+ */
+export function insertAppiumPrefixes(caps: Capabilities): AppiumW3CCapabilities;
+export function getPackageVersion(pkgName: any): any;
+/**
+ * Pulls the initial values of Appium settings from the given capabilities argument.
+ * Each setting item must satisfy the following format:
+ * `setting[setting_name]: setting_value`
+ * The capabilities argument itself gets mutated, so it does not contain parsed
+ * settings anymore to avoid further parsing issues.
+ * Check
+ * https://github.com/appium/appium/blob/master/docs/en/advanced-concepts/settings.md
+ * for more details on the available settings.
+ *
+ * @param {?Object} caps - Capabilities dictionary. It is mutated if
+ * one or more settings have been pulled from it
+ * @return {Object} - An empty dictionary if the given caps contains no
+ * setting items or a dictionary containing parsed Appium setting names along with
+ * their values.
+ */
+export function pullSettings(caps: any | null): any;
+/**
+ *
+ * @param {AppiumW3CCapabilities} caps
+ * @returns {Capabilities}
+ */
+export function removeAppiumPrefixes(caps: AppiumW3CCapabilities): Capabilities;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":";iBAwOc,YAAY;cACZ,MAAM;kCACN,GAAG;;;;WAOH,KAAK;cACL,MAAM;;;;kCAEN,GAAG;;;8BAKJ,OAAO,eAAe,EAAE,eAAe;2BACvC,OAAO,eAAe,EAAE,YAAY;oCACpC,OAAO,eAAe,EAAE,qBAAqB;AA1O1D;;;;GAIG;AACH,wCAOK;AAEL;;;;;;;;;GASG;AACH,4DANW,GAAG,mBACH,eAAe,gBACf,OAAO,eAAe,EAAE,WAAW,wFAEjC,gBAAgB,GAAC,WAAW,CA2FxC;AAED;;;;GAIG;AACH,2CAHW,YAAY,GACV,qBAAqB,CAyBjC;AAyBD,qDAGC;AAED;;;;;;;;;;;;;;;GAeG;AACH,oDAgBC;AA5DD;;;;GAIG;AACH,2CAHW,qBAAqB,GACnB,YAAY,CAaxB"}