appium 2.0.0-beta.30 → 2.0.0-beta.35

package/build/lib/main.d.ts

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 export { readConfigFile } from "./config-file";
-export type ParsedArgs = import('../types/cli').ParsedArgs;
-export type PartialArgs = import('../types/cli').PartialArgs;
 export type DriverType = import('../types').DriverType;
 export type PluginType = import('../types').PluginType;
-export type DriverClass = import('../types/extension').DriverClass;
-export type PluginClass = import('../types/extension').PluginClass;
+export type DriverClass = import('../types').DriverClass;
+export type PluginClass = import('../types').PluginClass;
+export type WithServerSubcommand = import('../types').WithServerSubcommand;
 /**
  * Literally an empty object
  */
@@ -18,16 +17,19 @@ export type ServerInitData = {
     /**
      * - The parsed arguments
      */
-    parsedArgs: ParsedArgs;
+    parsedArgs: import('../types').ParsedArgs;
 };
 export type ServerInitResult = ServerInitData & import('./extension').ExtensionConfigs;
+export type Args<T = import("../types").WithServerSubcommand> = import('../types').Args<T>;
+export type ParsedArgs<T = import("../types").WithServerSubcommand> = import('../types').ParsedArgs<T>;
 /**
  * Initializes Appium's config.  Starts server if appropriate and resolves the
  * server instance if so; otherwise resolves w/ `undefined`.
- * @param {PartialArgs} [args] - Arguments from CLI or otherwise
- * @returns {Promise<import('http').Server|undefined>}
+ * @template [T=WithServerSubcommand]
+ * @param {Args<T>} [args] - Arguments from CLI or otherwise
+ * @returns {Promise<import('@appium/types').AppiumServer|undefined>}
  */
-export function main(args?: import("../types").PartialArgs | undefined): Promise<import('http').Server | undefined>;
+export function main<T = import("../types").WithServerSubcommand>(args?: Args<T> | undefined): Promise<import('@appium/types').AppiumServer | undefined>;
 /**
  * Initializes Appium, but does not start the server.
  *
@@ -35,7 +37,8 @@ export function main(args?: import("../types").PartialArgs | undefined): Promise
  *
  * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.
  *
- * @param {PartialArgs} [args] - Partial args (progammatic usage only)
+ * @template [T=WithServerSubcommand]
+ * @param {Args<T>} [args] - Partial args (progammatic usage only)
  * @returns {Promise<ServerInitResult | ExtCommandInitResult>}
  * @example
  * import {init, getSchema} from 'appium';
@@ -43,7 +46,7 @@ export function main(args?: import("../types").PartialArgs | undefined): Promise
  * await init(options);
  * const schema = getSchema(); // entire config schema including plugins and drivers
  */
-export function init(args?: import("../types").PartialArgs | undefined): Promise<ServerInitResult | ExtCommandInitResult>;
+export function init<T = import("../types").WithServerSubcommand>(args?: Args<T> | undefined): Promise<ServerInitResult | ExtCommandInitResult>;
 export const resolveAppiumHome: ((cwd?: string | undefined) => Promise<string>) & _.MemoizedFunction;
 import { AppiumDriver } from "./appium";
 import _ from "lodash";

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../lib/main.js"],"names":[],"mappings":";;yBAqVa,OAAO,cAAc,EAAE,UAAU;0BAIjC,OAAO,cAAc,EAAE,WAAW;yBAClC,OAAO,UAAU,EAAE,UAAU;yBAC7B,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,oBAAoB,EAAE,WAAW;0BACxC,OAAO,oBAAoB,EAAE,WAAW;;;;mCAKvC,EAAE;;;;;kBAKF,YAAY;;;;gBACZ,UAAU;;+BAIX,cAAc,GAAG,OAAO,aAAa,EAAE,gBAAgB;AA7HpE;;;;;GAKG;AACH,yEAFa,QAAQ,OAAO,MAAM,EAAE,MAAM,GAAC,SAAS,CAAC,CAmFpD;AArMD;;;;;;;;;;;;;;GAcG;AACH,yEAPa,QAAQ,gBAAgB,GAAG,oBAAoB,CAAC,CAoG5D"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../lib/main.js"],"names":[],"mappings":";;yBA6Va,OAAO,UAAU,EAAE,UAAU;yBAC7B,OAAO,UAAU,EAAE,UAAU;0BAC7B,OAAO,UAAU,EAAE,WAAW;0BAC9B,OAAO,UAAU,EAAE,WAAW;mCAC9B,OAAO,UAAU,EAAE,oBAAoB;;;;mCAKtC,EAAE;;;;;kBAKF,YAAY;;;;gBACZ,OAAO,UAAU,EAAE,UAAU;;+BAI9B,cAAc,GAAG,OAAO,aAAa,EAAE,gBAAgB;gEAKvD,OAAO,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC;sEAK1B,OAAO,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;AApI7C;;;;;;GAMG;AACH,+FAFa,QAAQ,OAAO,eAAe,EAAE,YAAY,GAAC,SAAS,CAAC,CAmFnE;AAjMD;;;;;;;;;;;;;;;GAeG;AACH,+FAPa,QAAQ,gBAAgB,GAAG,oBAAoB,CAAC,CA8F5D"}

package/build/lib/main.js

@@ -147,9 +147,17 @@ function getServerUpdaters(driverClasses, pluginClasses) {
 }
 
 function getExtraMethodMap(driverClasses, pluginClasses) {
-  return [...driverClasses, ...pluginClasses].reduce((map, klass) => ({ ...map,
-    ...klass.newMethodMap
-  }), {});
+  return [...driverClasses, ...pluginClasses].reduce((map, klass) => {
+    var _klass$newMethodMap;
+
+    return { ...map,
+      ...((_klass$newMethodMap = klass.newMethodMap) !== null && _klass$newMethodMap !== void 0 ? _klass$newMethodMap : {})
+    };
+  }, {});
+}
+
+function areServerCommandArgs(args) {
+  return args.subcommand === _constants.SERVER_SUBCOMMAND;
 }
 
 async function init(args) {
@@ -162,9 +170,7 @@ async function init(args) {
   } = await (0, _extension2.loadExtensions)(appiumHome);
   const parser = (0, _parser.getParser)();
   let throwInsteadOfExit = false;
-  let preConfigParsedArgs;
-  let parsedArgs;
-  let defaults = {};
+  let preConfigArgs;
 
   if (args) {
     var _args$subcommand;
@@ -174,14 +180,14 @@ async function init(args) {
       delete args.throwInsteadOfExit;
     }
 
-    preConfigParsedArgs = { ...args,
+    preConfigArgs = { ...args,
       subcommand: (_args$subcommand = args.subcommand) !== null && _args$subcommand !== void 0 ? _args$subcommand : _constants.SERVER_SUBCOMMAND
     };
   } else {
-    preConfigParsedArgs = parser.parseArgs();
+    preConfigArgs = parser.parseArgs();
   }
 
-  const configResult = await (0, _configFile.readConfigFile)(preConfigParsedArgs.configFile);
+  const configResult = await (0, _configFile.readConfigFile)(preConfigArgs.configFile);
 
   if (!_lodash.default.isEmpty(configResult.errors)) {
     var _configResult$reason;
@@ -189,58 +195,59 @@ async function init(args) {
     throw new Error(`Errors in config file ${configResult.filepath}:\n ${(_configResult$reason = configResult.reason) !== null && _configResult$reason !== void 0 ? _configResult$reason : configResult.errors}`);
   }
 
-  if (preConfigParsedArgs.subcommand === _constants.SERVER_SUBCOMMAND) {
-    var _configResult$config;
-
-    defaults = (0, _schema.getDefaultsForSchema)(false);
-    parsedArgs = _lodash.default.defaultsDeep(preConfigParsedArgs, (_configResult$config = configResult.config) === null || _configResult$config === void 0 ? void 0 : _configResult$config.server, defaults);
-
-    if (preConfigParsedArgs.showConfig) {
-      (0, _config.showConfig)((0, _config.getNonDefaultServerArgs)(preConfigParsedArgs), configResult, defaults, parsedArgs);
+  if (!areServerCommandArgs(preConfigArgs)) {
+    if (preConfigArgs.subcommand === _constants.DRIVER_TYPE) {
+      await (0, _extension.runExtensionCommand)(preConfigArgs, driverConfig);
       return {};
     }
-  } else {
-    parsedArgs = preConfigParsedArgs;
-  }
 
-  await (0, _logsink.init)(parsedArgs);
+    if (preConfigArgs.subcommand === _constants.PLUGIN_TYPE) {
+      await (0, _extension.runExtensionCommand)(preConfigArgs, pluginConfig);
+      return {};
+    }
 
-  if (parsedArgs.subcommand === _constants.DRIVER_TYPE) {
-    await (0, _extension.runExtensionCommand)(parsedArgs, driverConfig);
     return {};
-  }
+  } else {
+    var _configResult$config;
 
-  if (parsedArgs.subcommand === _constants.PLUGIN_TYPE) {
-    await (0, _extension.runExtensionCommand)(parsedArgs, pluginConfig);
-    return {};
-  }
+    const defaults = (0, _schema.getDefaultsForSchema)(false);
 
-  if (parsedArgs.logFilters) {
-    const {
-      issues,
-      rules
-    } = await _support.logger.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);
+    const serverArgs = _lodash.default.defaultsDeep(preConfigArgs, (_configResult$config = configResult.config) === null || _configResult$config === void 0 ? void 0 : _configResult$config.server, defaults);
 
-    if (!_lodash.default.isEmpty(issues)) {
-      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+    if (preConfigArgs.showConfig) {
+      (0, _config.showConfig)((0, _config.getNonDefaultServerArgs)(preConfigArgs), configResult, defaults, serverArgs);
+      return {};
     }
 
-    if (_lodash.default.isEmpty(rules)) {
-      _logger.default.warn(`Found no log filtering rules in '${parsedArgs.logFilters}'. Is that expected?`);
-    } else {
-      _logger.default.info(`Loaded ${_support.util.pluralize('filtering rule', rules.length, true)} from '${parsedArgs.logFilters}'`);
+    await (0, _logsink.init)(serverArgs);
+
+    if (serverArgs.logFilters) {
+      const {
+        issues,
+        rules
+      } = await _support.logger.loadSecureValuesPreprocessingRules(serverArgs.logFilters);
+
+      if (!_lodash.default.isEmpty(issues)) {
+        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` + JSON.stringify(issues, null, 2));
+      }
+
+      if (_lodash.default.isEmpty(rules)) {
+        _logger.default.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);
+      } else {
+        _logger.default.info(`Loaded ${_support.util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);
+      }
     }
-  }
 
-  const appiumDriver = new _appium.AppiumDriver(parsedArgs);
-  appiumDriver.driverConfig = driverConfig;
-  await preflightChecks(parsedArgs, throwInsteadOfExit);
-  return {
-    appiumDriver,
-    parsedArgs,
-    driverConfig,
-    pluginConfig
-  };
+    const appiumDriver = new _appium.AppiumDriver(serverArgs);
+    appiumDriver.driverConfig = driverConfig;
+    await preflightChecks(serverArgs, throwInsteadOfExit);
+    return {
+      appiumDriver,
+      parsedArgs: serverArgs,
+      driverConfig,
+      pluginConfig
+    };
+  }
 }
 
 async function main(args) {
@@ -331,4 +338,4 @@ async function main(args) {
 if (require.main === module) {
   (0, _asyncbox.asyncify)(main);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/main.js"],"names":["resolveAppiumHome","env","preflightChecks","args","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","getExtraMethodMap","reduce","klass","newMethodMap","init","appiumHome","driverConfig","pluginConfig","parser","preConfigParsedArgs","parsedArgs","defaults","subcommand","SERVER_SUBCOMMAND","parseArgs","configResult","configFile","errors","Error","filepath","reason","defaultsDeep","config","server","showConfig","DRIVER_TYPE","PLUGIN_TYPE","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","main","usePlugins","routeConfiguringFunction","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","debug","stack","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","e","print","p","pluginName","module"],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\n\nimport { init as logsinkInit } from './logsink'; // this import needs to come first since it sets up global npmlog\nimport logger from './logger'; // logger needs to remain second\n// @ts-ignore\nimport { routeConfiguringFunction as makeRouter, server as baseServer } from '@appium/base-driver';\nimport { logger as logFactory, util, env } from '@appium/support';\nimport { asyncify } from 'asyncbox';\nimport _ from 'lodash';\nimport { AppiumDriver } from './appium';\nimport { runExtensionCommand } from './cli/extension';\nimport { getParser } from './cli/parser';\nimport { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, showBuildInfo, validateTmpDir, warnNodeDeprecations } from './config';\nimport { readConfigFile } from './config-file';\nimport { loadExtensions, getActivePlugins, getActiveDrivers } from './extension';\nimport { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from './constants';\nimport registerNode from './grid-register';\nimport { getDefaultsForSchema, validate } from './schema/schema';\nimport { inspect } from './utils';\n\nconst {resolveAppiumHome} = env;\n\n/**\n *\n * @param {ParsedArgs} args\n * @param {boolean} [throwInsteadOfExit]\n */\nasync function preflightChecks (args, throwInsteadOfExit = false) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showBuildInfo) {\n      await showBuildInfo();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n\n    validate(args);\n\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\n/**\n * @param {Partial<ParsedArgs>} args\n */\nfunction logNonDefaultArgsWarning (args) {\n  logger.info('Non-default server args:');\n  inspect(args);\n}\n\nfunction logDefaultCapabilitiesWarning (caps) {\n  logger.info('Default capabilities, which will be added to each request ' +\n              'unless overridden by desired capabilities:');\n  inspect(caps);\n}\n\n/**\n * @param {ParsedArgs} args\n */\nasync function logStartupInfo (args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultServerArgs(args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\n/**\n * Logs the address and port the server is listening on\n * @param {string} address - Address\n * @param {number} port - Port\n * @returns {void}\n */\nfunction logServerPort (address, port) {\n  let logMessage = `Appium REST http interface listener started on ` +\n                   `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/base-driver/lib/basedriver/driver').UpdateServerCallback[]}\n */\nfunction getServerUpdaters (driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses, ...pluginClasses], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap (driverClasses, pluginClasses) {\n  return [...driverClasses, ...pluginClasses].reduce(\n    (map, klass) => ({...map, ...klass.newMethodMap}),\n    {}\n  );\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\n * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.\n *\n * @param {PartialArgs} [args] - Partial args (progammatic usage only)\n * @returns {Promise<ServerInitResult | ExtCommandInitResult>}\n * @example\n * import {init, getSchema} from 'appium';\n * const options = {}; // config object\n * await init(options);\n * const schema = getSchema(); // entire config schema including plugins and drivers\n */\nasync function init (args) {\n  const appiumHome = args?.appiumHome ?? await resolveAppiumHome();\n\n  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);\n\n  const parser = getParser();\n  let throwInsteadOfExit = false;\n  /** @type {ParsedArgs} */\n  let preConfigParsedArgs;\n  /** @type {ParsedArgs} */\n  let parsedArgs;\n  /**\n   * This is a definition (instead of declaration) because TS can't figure out\n   * the value will be defined when it's used.\n   * @type {ReturnType<getDefaultsForSchema>}\n   */\n  let defaults = {};\n  if (args) {\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n    preConfigParsedArgs = /** @type {ParsedArgs} */({...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND});\n  } else {\n    // otherwise parse from CLI\n    preConfigParsedArgs = parser.parseArgs();\n  }\n\n  const configResult = await readConfigFile(preConfigParsedArgs.configFile);\n\n  if (!_.isEmpty(configResult.errors)) {\n    throw new Error(`Errors in config file ${configResult.filepath}:\\n ${configResult.reason ?? configResult.errors}`);\n  }\n\n  // merge config and apply defaults.\n  // the order of precendece is:\n  // 1. command line args\n  // 2. config file\n  // 3. defaults from config file.\n  if (preConfigParsedArgs.subcommand === SERVER_SUBCOMMAND) {\n    defaults = getDefaultsForSchema(false);\n\n    parsedArgs = _.defaultsDeep(\n      preConfigParsedArgs,\n      configResult.config?.server,\n      defaults\n    );\n\n    if (preConfigParsedArgs.showConfig) {\n      showConfig(getNonDefaultServerArgs(preConfigParsedArgs), configResult, defaults, parsedArgs);\n      return {};\n    }\n\n  } else {\n    parsedArgs = preConfigParsedArgs;\n  }\n\n  await logsinkInit(parsedArgs);\n\n  // if the user has requested the 'driver' CLI, don't run the normal server,\n  // but instead pass control to the driver CLI\n  if (parsedArgs.subcommand === DRIVER_TYPE) {\n    await runExtensionCommand(parsedArgs, driverConfig);\n    return {};\n  }\n  if (parsedArgs.subcommand === PLUGIN_TYPE) {\n    await runExtensionCommand(parsedArgs, pluginConfig);\n    return {};\n  }\n\n  if (parsedArgs.logFilters) {\n    const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(parsedArgs.logFilters);\n    if (!_.isEmpty(issues)) {\n      throw new Error(`The log filtering rules config '${parsedArgs.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n    }\n    if (_.isEmpty(rules)) {\n      logger.warn(`Found no log filtering rules in '${parsedArgs.logFilters}'. Is that expected?`);\n    } else {\n      logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${parsedArgs.logFilters}'`);\n    }\n  }\n\n  const appiumDriver = new AppiumDriver(parsedArgs);\n  // set the config on the umbrella driver so it can match drivers to caps\n  appiumDriver.driverConfig = driverConfig;\n  await preflightChecks(parsedArgs, throwInsteadOfExit);\n\n  return /** @type {ServerInitResult} */({appiumDriver, parsedArgs, driverConfig, pluginConfig});\n}\n\n/**\n * Initializes Appium's config.  Starts server if appropriate and resolves the\n * server instance if so; otherwise resolves w/ `undefined`.\n * @param {PartialArgs} [args] - Arguments from CLI or otherwise\n * @returns {Promise<import('http').Server|undefined>}\n */\nasync function main (args) {\n  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */(await init(args));\n\n  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {\n    // if this branch is taken, we've run a different subcommand, so there's nothing\n    // left to do here.\n    return;\n  }\n\n  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);\n  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);\n  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);\n\n  const serverOpts = {\n    routeConfiguringFunction,\n    port: parsedArgs.port,\n    hostname: parsedArgs.address,\n    allowCors: parsedArgs.allowCors,\n    basePath: parsedArgs.basePath,\n    serverUpdaters,\n    extraMethodMap,\n  };\n  if (parsedArgs.keepAliveTimeout) {\n    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;\n  }\n  let server;\n  try {\n    server = await baseServer(serverOpts);\n  } catch (err) {\n    logger.error(`Could not configure Appium server. It's possible that a driver or plugin tried ` +\n                 `to update the server and failed. Original error: ${err.message}`);\n    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn('You have enabled CORS requests from any host. Be careful not ' +\n                'to visit sites which could maliciously try to start Appium ' +\n                'sessions on your machine');\n  }\n  appiumDriver.server = server;\n  try {\n    // configure as node on grid, if necessary\n    // falsy values should not cause this to run\n    if (parsedArgs.nodeconfig) {\n      await registerNode(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal () {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(parsedArgs.address, parsedArgs.port);\n  driverConfig.print();\n  pluginConfig.print(pluginClasses.map((p) => p.pluginName));\n\n  return server;\n}\n\n// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly\n// (more specifically, `build/lib/main.js`)\n// the executable is now `../index.js`, so that module will typically be `require.main`.\nif (require.main === module) {\n  asyncify(main);\n}\n\n// everything below here is intended to be a public API.\nexport { readConfigFile } from './config-file';\nexport { finalizeSchema, getSchema, validate } from './schema/schema';\nexport { main, init, resolveAppiumHome };\n\n/**\n * @typedef {import('../types/cli').ParsedArgs} ParsedArgs\n */\n\n/**\n * @typedef {import('../types/cli').PartialArgs} PartialArgs\n * @typedef {import('../types').DriverType} DriverType\n * @typedef {import('../types').PluginType} PluginType\n * @typedef {import('../types/extension').DriverClass} DriverClass\n * @typedef {import('../types/extension').PluginClass} PluginClass\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {AppiumDriver} appiumDriver - The Appium driver\n * @property {ParsedArgs} parsedArgs - The parsed arguments\n */\n\n/**\n * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["resolveAppiumHome","env","preflightChecks","args","throwInsteadOfExit","longStacktrace","require","async_trace_limit","showBuildInfo","process","exit","tmpDir","err","logger","error","message","red","logNonDefaultArgsWarning","info","logDefaultCapabilitiesWarning","caps","logStartupInfo","welcome","APPIUM_VER","appiumRev","showArgs","_","size","isEmpty","defaultCapabilities","logServerPort","address","port","logMessage","getServerUpdaters","driverClasses","pluginClasses","compact","map","getExtraMethodMap","reduce","klass","newMethodMap","areServerCommandArgs","subcommand","SERVER_SUBCOMMAND","init","appiumHome","driverConfig","pluginConfig","parser","preConfigArgs","parseArgs","configResult","configFile","errors","Error","filepath","reason","DRIVER_TYPE","PLUGIN_TYPE","defaults","serverArgs","defaultsDeep","config","server","showConfig","logFilters","issues","rules","logFactory","loadSecureValuesPreprocessingRules","JSON","stringify","warn","util","pluralize","length","appiumDriver","AppiumDriver","parsedArgs","main","usePlugins","routeConfiguringFunction","useDrivers","serverUpdaters","extraMethodMap","serverOpts","hostname","allowCors","basePath","keepAliveTimeout","debug","stack","nodeconfig","close","signal","once","onSignal","deleteAllSessions","force","e","print","p","pluginName","module"],"sources":["../../lib/main.js"],"sourcesContent":["#!/usr/bin/env node\n\n\nimport { init as logsinkInit } from './logsink'; // this import needs to come first since it sets up global npmlog\nimport logger from './logger'; // logger needs to remain second\n// @ts-ignore\nimport { routeConfiguringFunction as makeRouter, server as baseServer } from '@appium/base-driver';\nimport { logger as logFactory, util, env } from '@appium/support';\nimport { asyncify } from 'asyncbox';\nimport _ from 'lodash';\nimport { AppiumDriver } from './appium';\nimport { runExtensionCommand } from './cli/extension';\nimport { getParser } from './cli/parser';\nimport { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, showBuildInfo, validateTmpDir, warnNodeDeprecations } from './config';\nimport { readConfigFile } from './config-file';\nimport { loadExtensions, getActivePlugins, getActiveDrivers } from './extension';\nimport { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from './constants';\nimport registerNode from './grid-register';\nimport { getDefaultsForSchema, validate } from './schema/schema';\nimport { inspect } from './utils';\n\nconst {resolveAppiumHome} = env;\n\n/**\n *\n * @param {ParsedArgs} args\n * @param {boolean} [throwInsteadOfExit]\n */\nasync function preflightChecks (args, throwInsteadOfExit = false) {\n  try {\n    checkNodeOk();\n    if (args.longStacktrace) {\n      require('longjohn').async_trace_limit = -1;\n    }\n    if (args.showBuildInfo) {\n      await showBuildInfo();\n      process.exit(0);\n    }\n    warnNodeDeprecations();\n\n    validate(args);\n\n    if (args.tmpDir) {\n      await validateTmpDir(args.tmpDir);\n    }\n  } catch (err) {\n    logger.error(err.message.red);\n    if (throwInsteadOfExit) {\n      throw err;\n    }\n\n    process.exit(1);\n  }\n}\n\n/**\n * @param {Args} args\n */\nfunction logNonDefaultArgsWarning (args) {\n  logger.info('Non-default server args:');\n  inspect(args);\n}\n\n/**\n * @param {Args['defaultCapabilities']} caps\n */\nfunction logDefaultCapabilitiesWarning (caps) {\n  logger.info('Default capabilities, which will be added to each request ' +\n              'unless overridden by desired capabilities:');\n  inspect(caps);\n}\n\n/**\n * @param {ParsedArgs} args\n */\nasync function logStartupInfo (args) {\n  let welcome = `Welcome to Appium v${APPIUM_VER}`;\n  let appiumRev = await getGitRev();\n  if (appiumRev) {\n    welcome += ` (REV ${appiumRev})`;\n  }\n  logger.info(welcome);\n\n  let showArgs = getNonDefaultServerArgs(args);\n  if (_.size(showArgs)) {\n    logNonDefaultArgsWarning(showArgs);\n  }\n  if (!_.isEmpty(args.defaultCapabilities)) {\n    logDefaultCapabilitiesWarning(args.defaultCapabilities);\n  }\n  // TODO: bring back loglevel reporting below once logger is flushed out\n  // logger.info('Console LogLevel: ' + logger.transports.console.level);\n  // if (logger.transports.file) {\n  //   logger.info('File LogLevel: ' + logger.transports.file.level);\n  // }\n}\n\n/**\n * Logs the address and port the server is listening on\n * @param {string} address - Address\n * @param {number} port - Port\n * @returns {void}\n */\nfunction logServerPort (address, port) {\n  let logMessage = `Appium REST http interface listener started on ` +\n                   `${address}:${port}`;\n  logger.info(logMessage);\n}\n\n/**\n * Gets a list of `updateServer` functions from all extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/base-driver/lib/basedriver/driver').UpdateServerCallback[]}\n */\nfunction getServerUpdaters (driverClasses, pluginClasses) {\n  return _.compact(_.map([...driverClasses, ...pluginClasses], 'updateServer'));\n}\n\n/**\n * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions\n * @param {DriverClass[]} driverClasses\n * @param {PluginClass[]} pluginClasses\n * @returns {import('@appium/types').MethodMap}\n */\nfunction getExtraMethodMap (driverClasses, pluginClasses) {\n  return [...driverClasses, ...pluginClasses].reduce(\n    (map, klass) => ({...map, .../** @type {DriverClass} */(klass).newMethodMap ?? {}}),\n    {}\n  );\n}\n\n/**\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} args\n * @returns {args is Args<WithServerSubcommand>}\n */\nfunction areServerCommandArgs (args) {\n  return args.subcommand === SERVER_SUBCOMMAND;\n}\n\n/**\n * Initializes Appium, but does not start the server.\n *\n * Use this to get at the configuration schema.\n *\n * If `args` contains a non-empty `subcommand` which is not `server`, this function will return an empty object.\n *\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Partial args (progammatic usage only)\n * @returns {Promise<ServerInitResult | ExtCommandInitResult>}\n * @example\n * import {init, getSchema} from 'appium';\n * const options = {}; // config object\n * await init(options);\n * const schema = getSchema(); // entire config schema including plugins and drivers\n */\nasync function init (args) {\n  const appiumHome = args?.appiumHome ?? await resolveAppiumHome();\n\n  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);\n\n  const parser = getParser();\n  let throwInsteadOfExit = false;\n  /** @type {Args<T>} */\n  let preConfigArgs;\n\n  if (args) {\n    // if we have a containing package instead of running as a CLI process,\n    // that package might not appreciate us calling 'process.exit' willy-\n    // nilly, so give it the option to have us throw instead of exit\n    if (args.throwInsteadOfExit) {\n      throwInsteadOfExit = true;\n      // but remove it since it's not a real server arg per se\n      delete args.throwInsteadOfExit;\n    }\n    preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};\n  } else {\n    // otherwise parse from CLI\n    preConfigArgs = /** @type {Args<T>} */(parser.parseArgs());\n  }\n\n  const configResult = await readConfigFile(preConfigArgs.configFile);\n\n  if (!_.isEmpty(configResult.errors)) {\n    throw new Error(`Errors in config file ${configResult.filepath}:\\n ${configResult.reason ?? configResult.errors}`);\n  }\n\n  // merge config and apply defaults.\n  // the order of precendece is:\n  // 1. command line args\n  // 2. config file\n  // 3. defaults from config file.\n  if (!areServerCommandArgs(preConfigArgs)) {\n\n    // if the user has requested the 'driver' CLI, don't run the normal server,\n    // but instead pass control to the driver CLI\n    if (preConfigArgs.subcommand === DRIVER_TYPE) {\n      await runExtensionCommand(preConfigArgs, driverConfig);\n      return {};\n    }\n    if (preConfigArgs.subcommand === PLUGIN_TYPE) {\n      await runExtensionCommand(preConfigArgs, pluginConfig);\n      return {};\n    }\n    /* istanbul ignore next */\n    return {}; // should never happen\n  } else {\n    const defaults = getDefaultsForSchema(false);\n\n    /** @type {ParsedArgs} */\n    const serverArgs = _.defaultsDeep(\n      preConfigArgs,\n      configResult.config?.server,\n      defaults\n    );\n\n    if (preConfigArgs.showConfig) {\n      showConfig(getNonDefaultServerArgs(preConfigArgs), configResult, defaults, serverArgs);\n      return {};\n    }\n\n    await logsinkInit(serverArgs);\n\n    if (serverArgs.logFilters) {\n      const {issues, rules} = await logFactory.loadSecureValuesPreprocessingRules(serverArgs.logFilters);\n      if (!_.isEmpty(issues)) {\n        throw new Error(`The log filtering rules config '${serverArgs.logFilters}' has issues: ` +\n        JSON.stringify(issues, null, 2));\n      }\n      if (_.isEmpty(rules)) {\n        logger.warn(`Found no log filtering rules in '${serverArgs.logFilters}'. Is that expected?`);\n      } else {\n        logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)} from '${serverArgs.logFilters}'`);\n      }\n    }\n\n    const appiumDriver = new AppiumDriver(serverArgs);\n    // set the config on the umbrella driver so it can match drivers to caps\n    appiumDriver.driverConfig = driverConfig;\n    await preflightChecks(serverArgs, throwInsteadOfExit);\n\n    return /** @type {ServerInitResult} */({appiumDriver, parsedArgs: serverArgs, driverConfig, pluginConfig});\n  }\n}\n\n/**\n * Initializes Appium's config.  Starts server if appropriate and resolves the\n * server instance if so; otherwise resolves w/ `undefined`.\n * @template [T=WithServerSubcommand]\n * @param {Args<T>} [args] - Arguments from CLI or otherwise\n * @returns {Promise<import('@appium/types').AppiumServer|undefined>}\n */\nasync function main (args) {\n  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */(await init(args));\n\n  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {\n    // if this branch is taken, we've run a different subcommand, so there's nothing\n    // left to do here.\n    return;\n  }\n\n  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);\n  // set the active plugins on the umbrella driver so it can use them for commands\n  appiumDriver.pluginClasses = pluginClasses;\n\n  await logStartupInfo(parsedArgs);\n  let routeConfiguringFunction = makeRouter(appiumDriver);\n\n  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);\n  const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);\n  const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);\n\n  const serverOpts = {\n    routeConfiguringFunction,\n    port: parsedArgs.port,\n    hostname: parsedArgs.address,\n    allowCors: parsedArgs.allowCors,\n    basePath: parsedArgs.basePath,\n    serverUpdaters,\n    extraMethodMap,\n  };\n  if (parsedArgs.keepAliveTimeout) {\n    serverOpts.keepAliveTimeout = parsedArgs.keepAliveTimeout * 1000;\n  }\n  let server;\n  try {\n    server = await baseServer(serverOpts);\n  } catch (err) {\n    logger.error(`Could not configure Appium server. It's possible that a driver or plugin tried ` +\n                 `to update the server and failed. Original error: ${err.message}`);\n    logger.debug(err.stack);\n    return process.exit(1);\n  }\n\n  if (parsedArgs.allowCors) {\n    logger.warn('You have enabled CORS requests from any host. Be careful not ' +\n                'to visit sites which could maliciously try to start Appium ' +\n                'sessions on your machine');\n  }\n  appiumDriver.server = server;\n  try {\n    // configure as node on grid, if necessary\n    // falsy values should not cause this to run\n    if (parsedArgs.nodeconfig) {\n      await registerNode(parsedArgs.nodeconfig, parsedArgs.address, parsedArgs.port, parsedArgs.basePath);\n    }\n  } catch (err) {\n    await server.close();\n    throw err;\n  }\n\n  for (const signal of ['SIGINT', 'SIGTERM']) {\n    process.once(signal, async function onSignal () {\n      logger.info(`Received ${signal} - shutting down`);\n      try {\n        await appiumDriver.deleteAllSessions({\n          force: true,\n          reason: `The process has received ${signal} signal`,\n        });\n        await server.close();\n        process.exit(0);\n      } catch (e) {\n        logger.warn(e);\n        process.exit(1);\n      }\n    });\n  }\n\n  logServerPort(parsedArgs.address, parsedArgs.port);\n  driverConfig.print();\n  pluginConfig.print(pluginClasses.map((p) => p.pluginName));\n\n  return server;\n}\n\n// NOTE: this is here for backwards compat for any scripts referencing `main.js` directly\n// (more specifically, `build/lib/main.js`)\n// the executable is now `../index.js`, so that module will typically be `require.main`.\nif (require.main === module) {\n  asyncify(main);\n}\n\n// everything below here is intended to be a public API.\nexport { readConfigFile } from './config-file';\nexport { finalizeSchema, getSchema, validate } from './schema/schema';\nexport { main, init, resolveAppiumHome };\n\n/**\n * @typedef {import('../types').DriverType} DriverType\n * @typedef {import('../types').PluginType} PluginType\n * @typedef {import('../types').DriverClass} DriverClass\n * @typedef {import('../types').PluginClass} PluginClass\n * @typedef {import('../types').WithServerSubcommand} WithServerSubcommand\n */\n\n/**\n * Literally an empty object\n * @typedef { {} } ExtCommandInitResult\n */\n\n/**\n * @typedef ServerInitData\n * @property {AppiumDriver} appiumDriver - The Appium driver\n * @property {import('../types').ParsedArgs} parsedArgs - The parsed arguments\n */\n\n/**\n * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('../types').Args<T>} Args\n */\n\n/**\n * @template [T=WithServerSubcommand]\n * @typedef {import('../types').ParsedArgs<T>} ParsedArgs\n */\n\n"],"mappings":"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"}

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

@@ -116,4 +116,4 @@ class ArgSpec {
 }
 
 exports.ArgSpec = ArgSpec;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/arg-spec.js"],"names":["APPIUM_CONFIG_SCHEMA_ID","SERVER_PROP_NAME","SCHEMA_ID_REGEXP","PROPERTIES","ArgSpec","name","extType","extName","ref","arg","dest","rawDest","defaultValue","constructor","toArg","toSchemaRef","_","camelCase","destKeypath","join","baseRef","toSchemaBaseRef","toNormalizedExtName","properName","kebabCase","replace","extensionInfoFromRootSchemaId","schemaId","matches","match","groups","normalizedExtName","create","opts","Object","freeze","toString","str"],"mappings":"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","sourcesContent":["import _ from 'lodash';\n\n/**\n * The original ID of the Appium config schema.\n * We use this in the CLI to convert it to `argparse` options.\n */\nexport const APPIUM_CONFIG_SCHEMA_ID = 'appium.json';\n\n/**\n * The schema prop containing server-related options. Everything in here\n * is \"native\" to Appium.\n * Used by {@link flattenSchema} for transforming the schema into CLI args.\n */\nexport const SERVER_PROP_NAME = 'server';\n\n/**\n * Used to parse extension info from a schema ID.\n */\nconst SCHEMA_ID_REGEXP = /^(?<extType>.+?)-(?<normalizedExtName>.+)\\.json$/;\n\n/**\n * Avoid typos by using constants!\n */\nconst PROPERTIES = 'properties';\n\n/**\n * An `ArgSpec` is a class representing metadata about an argument (or config\n * option) used for cross-referencing.\n *\n * This class has no instance methods, and is basically just a read-only \"struct\".\n * @template D\n */\nexport class ArgSpec {\n  /**\n   * The canonical name of the argument. Corresponds to key in schema's `properties` prop.\n   * @type {string}\n   */\n  name;\n\n  /**\n   * The `ExtensionType` of the argument. This will be set if the arg came from an extension;\n   * otherwise it will be `undefined`.\n   * @type {ExtensionType|undefined}\n   */\n  extType;\n\n  /**\n   * The name of the extension, if this argument came from an extension.\n   *\n   * Otherwise `undefined`.\n   * @type {string|undefined}\n   */\n  extName;\n\n  /**\n   * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.\n   *\n   * @type {string}\n   */\n  ref;\n\n  /**\n   * The CLI argument, sans leading dashes.\n   * @type {string}\n   */\n  arg;\n\n  /**\n   * The desired keypath for the argument after arguments have been parsed.\n   *\n   * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with\n   * `<extType>.<extName>.`\n   * @type {string}\n   */\n  dest;\n\n  /**\n   * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.\n   */\n  rawDest;\n\n  /**\n   * Whatever the default value of this argument is, as specified by the\n   * `default` property of the schema.\n   * @type {D|undefined}\n   */\n  defaultValue;\n\n  /**\n   * Builds some computed fields and assigns them to the instance.\n   *\n   * Undefined properties are not assigned.\n   *\n   * The _constructor_ is private. Use {@link ArgSpec.create} instead.\n   * @private\n   * @param {string} name\n   * @param {ArgSpecOptions<D>} [opts]\n   */\n  constructor (name, {extType, extName, dest, defaultValue} = {}) {\n    // we must normalize the extension name to fit into our convention for CLI\n    // args.\n    const arg = ArgSpec.toArg(name, extType, extName);\n\n    const ref = ArgSpec.toSchemaRef(name, extType, extName);\n\n    // if no explicit `dest` provided, just camelCase the name to avoid needing\n    // to use bracket syntax when accessing props on the parsed args object.\n    const rawDest = _.camelCase(dest ?? name);\n\n    const destKeypath =\n      extType && extName ? [extType, extName, rawDest].join('.') : rawDest;\n\n    this.defaultValue = defaultValue;\n    this.name = name;\n    this.extType = extType;\n    this.extName = extName;\n    this.arg = arg;\n    this.dest = destKeypath;\n    this.ref = ref;\n    this.rawDest = rawDest;\n  }\n\n  /**\n   * Return the schema ID (`$id`) for the **argument** given the parameters.\n   *\n   * If you need the \"root\" or \"base\" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Schema ID\n   */\n  static toSchemaRef (name, extType, extName) {\n    const baseRef = ArgSpec.toSchemaBaseRef(extType, extName);\n    if (extType && extName) {\n      return [`${baseRef}#`, PROPERTIES, name].join('/');\n    }\n    return [`${baseRef}#`, PROPERTIES, SERVER_PROP_NAME, PROPERTIES, name].join('/');\n  }\n\n  /**\n   * Return the schema ID for an extension or the base schema ID.\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   */\n  static toSchemaBaseRef (extType, extName) {\n    if (extType && extName) {\n      return `${extType}-${ArgSpec.toNormalizedExtName(extName)}.json`;\n    }\n    return APPIUM_CONFIG_SCHEMA_ID;\n  }\n\n  /**\n   * Return the unique ID for the argument given the parameters.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Unique ID\n   */\n  static toArg (name, extType, extName) {\n    const properName = _.kebabCase(name.replace(/^--?/, ''));\n    if (extType && extName) {\n      return [extType, _.kebabCase(extName), properName].join('-');\n    }\n    return properName;\n  }\n\n  /**\n   * Normalizes a raw extension name (not including the type).\n   * @param {string} extName - Extension name\n   * @returns {string} Normalized extension name\n   */\n  static toNormalizedExtName (extName) {\n    return _.kebabCase(extName);\n  }\n\n  /**\n   * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.\n   * @param {string} schemaId - Root schema ID\n   * @returns { {extType?: ExtensionType, normalizedExtName?: string} }\n   */\n  static extensionInfoFromRootSchemaId (schemaId) {\n    const matches = schemaId.match(SCHEMA_ID_REGEXP);\n    if (matches?.groups) {\n      const {extType, normalizedExtName} =\n        /** @type { {extType: ExtensionType, normalizedExtName: string} } */ (\n          matches.groups\n        );\n      return {extType, normalizedExtName};\n    }\n    return {};\n  }\n\n  /**\n   * Creates an `ArgSpec`\n   *\n   * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's\n   * `properties` property.\n   * @template D\n   * @param {ArgSpecOptions<D>} [opts] - Options\n   * @returns {Readonly<ArgSpec>}\n   */\n  static create (name, opts) {\n    return Object.freeze(new ArgSpec(name, opts));\n  }\n\n  /**\n   * String representation, useful for debugging\n   * @returns {string}\n   */\n  /* istanbul ignore next */\n  toString () {\n    let str = `[ArgSpec] ${this.name} (${this.ref})`;\n    if (this.extType && this.extName) {\n      str += ` (ext: ${this.extType}/${this.extName})`;\n    }\n    return str;\n  }\n}\n\n/**\n * Options for {@link ArgSpec.create}\n * @template D\n * @typedef ArgSpecOptions\n * @property {string} [extName]\n * @property {ExtensionType} [extType]\n * @property {string} [dest]\n * @property {D} [defaultValue]\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["APPIUM_CONFIG_SCHEMA_ID","SERVER_PROP_NAME","SCHEMA_ID_REGEXP","PROPERTIES","ArgSpec","name","extType","extName","ref","arg","dest","rawDest","defaultValue","constructor","toArg","toSchemaRef","_","camelCase","destKeypath","join","baseRef","toSchemaBaseRef","toNormalizedExtName","properName","kebabCase","replace","extensionInfoFromRootSchemaId","schemaId","matches","match","groups","normalizedExtName","create","opts","Object","freeze","toString","str"],"sources":["../../../lib/schema/arg-spec.js"],"sourcesContent":["import _ from 'lodash';\n\n/**\n * The original ID of the Appium config schema.\n * We use this in the CLI to convert it to `argparse` options.\n */\nexport const APPIUM_CONFIG_SCHEMA_ID = 'appium.json';\n\n/**\n * The schema prop containing server-related options. Everything in here\n * is \"native\" to Appium.\n * Used by {@link flattenSchema} for transforming the schema into CLI args.\n */\nexport const SERVER_PROP_NAME = 'server';\n\n/**\n * Used to parse extension info from a schema ID.\n */\nconst SCHEMA_ID_REGEXP = /^(?<extType>.+?)-(?<normalizedExtName>.+)\\.json$/;\n\n/**\n * Avoid typos by using constants!\n */\nconst PROPERTIES = 'properties';\n\n/**\n * An `ArgSpec` is a class representing metadata about an argument (or config\n * option) used for cross-referencing.\n *\n * This class has no instance methods, and is basically just a read-only \"struct\".\n * @template D\n */\nexport class ArgSpec {\n  /**\n   * The canonical name of the argument. Corresponds to key in schema's `properties` prop.\n   * @type {string}\n   */\n  name;\n\n  /**\n   * The `ExtensionType` of the argument. This will be set if the arg came from an extension;\n   * otherwise it will be `undefined`.\n   * @type {ExtensionType|undefined}\n   */\n  extType;\n\n  /**\n   * The name of the extension, if this argument came from an extension.\n   *\n   * Otherwise `undefined`.\n   * @type {string|undefined}\n   */\n  extName;\n\n  /**\n   * The schema ID (`$id`) for the argument.  This is automatically determined, and any user-provided `$id`s will be overwritten.\n   *\n   * @type {string}\n   */\n  ref;\n\n  /**\n   * The CLI argument, sans leading dashes.\n   * @type {string}\n   */\n  arg;\n\n  /**\n   * The desired keypath for the argument after arguments have been parsed.\n   *\n   * Typically this is camelCased.  If the arg came from an extension, it will be prefixed with\n   * `<extType>.<extName>.`\n   * @type {string}\n   */\n  dest;\n\n  /**\n   * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.\n   */\n  rawDest;\n\n  /**\n   * Whatever the default value of this argument is, as specified by the\n   * `default` property of the schema.\n   * @type {D|undefined}\n   */\n  defaultValue;\n\n  /**\n   * Builds some computed fields and assigns them to the instance.\n   *\n   * Undefined properties are not assigned.\n   *\n   * The _constructor_ is private. Use {@link ArgSpec.create} instead.\n   * @private\n   * @param {string} name\n   * @param {ArgSpecOptions<D>} [opts]\n   */\n  constructor (name, {extType, extName, dest, defaultValue} = {}) {\n    // we must normalize the extension name to fit into our convention for CLI\n    // args.\n    const arg = ArgSpec.toArg(name, extType, extName);\n\n    const ref = ArgSpec.toSchemaRef(name, extType, extName);\n\n    // if no explicit `dest` provided, just camelCase the name to avoid needing\n    // to use bracket syntax when accessing props on the parsed args object.\n    const rawDest = _.camelCase(dest ?? name);\n\n    const destKeypath =\n      extType && extName ? [extType, extName, rawDest].join('.') : rawDest;\n\n    this.defaultValue = defaultValue;\n    this.name = name;\n    this.extType = extType;\n    this.extName = extName;\n    this.arg = arg;\n    this.dest = destKeypath;\n    this.ref = ref;\n    this.rawDest = rawDest;\n  }\n\n  /**\n   * Return the schema ID (`$id`) for the **argument** given the parameters.\n   *\n   * If you need the \"root\" or \"base\" schema ID, use {@link ArgSpec.toSchemaBaseRef} instead.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Schema ID\n   */\n  static toSchemaRef (name, extType, extName) {\n    const baseRef = ArgSpec.toSchemaBaseRef(extType, extName);\n    if (extType && extName) {\n      return [`${baseRef}#`, PROPERTIES, name].join('/');\n    }\n    return [`${baseRef}#`, PROPERTIES, SERVER_PROP_NAME, PROPERTIES, name].join('/');\n  }\n\n  /**\n   * Return the schema ID for an extension or the base schema ID.\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   */\n  static toSchemaBaseRef (extType, extName) {\n    if (extType && extName) {\n      return `${extType}-${ArgSpec.toNormalizedExtName(extName)}.json`;\n    }\n    return APPIUM_CONFIG_SCHEMA_ID;\n  }\n\n  /**\n   * Return the unique ID for the argument given the parameters.\n   * @param {string} name - Argument name\n   * @param {ExtensionType} [extType] - Extension type\n   * @param {string} [extName] - Extension name\n   * @returns {string} Unique ID\n   */\n  static toArg (name, extType, extName) {\n    const properName = _.kebabCase(name.replace(/^--?/, ''));\n    if (extType && extName) {\n      return [extType, _.kebabCase(extName), properName].join('-');\n    }\n    return properName;\n  }\n\n  /**\n   * Normalizes a raw extension name (not including the type).\n   * @param {string} extName - Extension name\n   * @returns {string} Normalized extension name\n   */\n  static toNormalizedExtName (extName) {\n    return _.kebabCase(extName);\n  }\n\n  /**\n   * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.\n   * @param {string} schemaId - Root schema ID\n   * @returns { {extType?: ExtensionType, normalizedExtName?: string} }\n   */\n  static extensionInfoFromRootSchemaId (schemaId) {\n    const matches = schemaId.match(SCHEMA_ID_REGEXP);\n    if (matches?.groups) {\n      const {extType, normalizedExtName} =\n        /** @type { {extType: ExtensionType, normalizedExtName: string} } */ (\n          matches.groups\n        );\n      return {extType, normalizedExtName};\n    }\n    return {};\n  }\n\n  /**\n   * Creates an `ArgSpec`\n   *\n   * @param {string} name - The canonical name of the argument. Corresponds to a key in a schema's\n   * `properties` property.\n   * @template D\n   * @param {ArgSpecOptions<D>} [opts] - Options\n   * @returns {Readonly<ArgSpec>}\n   */\n  static create (name, opts) {\n    return Object.freeze(new ArgSpec(name, opts));\n  }\n\n  /**\n   * String representation, useful for debugging\n   * @returns {string}\n   */\n  /* istanbul ignore next */\n  toString () {\n    let str = `[ArgSpec] ${this.name} (${this.ref})`;\n    if (this.extType && this.extName) {\n      str += ` (ext: ${this.extType}/${this.extName})`;\n    }\n    return str;\n  }\n}\n\n/**\n * Options for {@link ArgSpec.create}\n * @template D\n * @typedef ArgSpecOptions\n * @property {string} [extName]\n * @property {ExtensionType} [extType]\n * @property {string} [dest]\n * @property {D} [defaultValue]\n */\n\n/**\n * @typedef {import('../extension/manifest').ExtensionType} ExtensionType\n */\n"],"mappings":";;;;;;;;;;;AAAA;;AAMO,MAAMA,uBAAuB,GAAG,aAAhC;;AAOA,MAAMC,gBAAgB,GAAG,QAAzB;;AAKP,MAAMC,gBAAgB,GAAG,kDAAzB;AAKA,MAAMC,UAAU,GAAG,YAAnB;;AASO,MAAMC,OAAN,CAAc;EAKnBC,IAAI;EAOJC,OAAO;EAQPC,OAAO;EAOPC,GAAG;EAMHC,GAAG;EASHC,IAAI;EAKJC,OAAO;EAOPC,YAAY;;EAYZC,WAAW,CAAER,IAAF,EAAQ;IAACC,OAAD;IAAUC,OAAV;IAAmBG,IAAnB;IAAyBE;EAAzB,IAAyC,EAAjD,EAAqD;IAG9D,MAAMH,GAAG,GAAGL,OAAO,CAACU,KAAR,CAAcT,IAAd,EAAoBC,OAApB,EAA6BC,OAA7B,CAAZ;IAEA,MAAMC,GAAG,GAAGJ,OAAO,CAACW,WAAR,CAAoBV,IAApB,EAA0BC,OAA1B,EAAmCC,OAAnC,CAAZ;;IAIA,MAAMI,OAAO,GAAGK,gBAAEC,SAAF,CAAYP,IAAZ,aAAYA,IAAZ,cAAYA,IAAZ,GAAoBL,IAApB,CAAhB;;IAEA,MAAMa,WAAW,GACfZ,OAAO,IAAIC,OAAX,GAAqB,CAACD,OAAD,EAAUC,OAAV,EAAmBI,OAAnB,EAA4BQ,IAA5B,CAAiC,GAAjC,CAArB,GAA6DR,OAD/D;IAGA,KAAKC,YAAL,GAAoBA,YAApB;IACA,KAAKP,IAAL,GAAYA,IAAZ;IACA,KAAKC,OAAL,GAAeA,OAAf;IACA,KAAKC,OAAL,GAAeA,OAAf;IACA,KAAKE,GAAL,GAAWA,GAAX;IACA,KAAKC,IAAL,GAAYQ,WAAZ;IACA,KAAKV,GAAL,GAAWA,GAAX;IACA,KAAKG,OAAL,GAAeA,OAAf;EACD;;EAWiB,OAAXI,WAAW,CAAEV,IAAF,EAAQC,OAAR,EAAiBC,OAAjB,EAA0B;IAC1C,MAAMa,OAAO,GAAGhB,OAAO,CAACiB,eAAR,CAAwBf,OAAxB,EAAiCC,OAAjC,CAAhB;;IACA,IAAID,OAAO,IAAIC,OAAf,EAAwB;MACtB,OAAO,CAAE,GAAEa,OAAQ,GAAZ,EAAgBjB,UAAhB,EAA4BE,IAA5B,EAAkCc,IAAlC,CAAuC,GAAvC,CAAP;IACD;;IACD,OAAO,CAAE,GAAEC,OAAQ,GAAZ,EAAgBjB,UAAhB,EAA4BF,gBAA5B,EAA8CE,UAA9C,EAA0DE,IAA1D,EAAgEc,IAAhE,CAAqE,GAArE,CAAP;EACD;;EAOqB,OAAfE,eAAe,CAAEf,OAAF,EAAWC,OAAX,EAAoB;IACxC,IAAID,OAAO,IAAIC,OAAf,EAAwB;MACtB,OAAQ,GAAED,OAAQ,IAAGF,OAAO,CAACkB,mBAAR,CAA4Bf,OAA5B,CAAqC,OAA1D;IACD;;IACD,OAAOP,uBAAP;EACD;;EASW,OAALc,KAAK,CAAET,IAAF,EAAQC,OAAR,EAAiBC,OAAjB,EAA0B;IACpC,MAAMgB,UAAU,GAAGP,gBAAEQ,SAAF,CAAYnB,IAAI,CAACoB,OAAL,CAAa,MAAb,EAAqB,EAArB,CAAZ,CAAnB;;IACA,IAAInB,OAAO,IAAIC,OAAf,EAAwB;MACtB,OAAO,CAACD,OAAD,EAAUU,gBAAEQ,SAAF,CAAYjB,OAAZ,CAAV,EAAgCgB,UAAhC,EAA4CJ,IAA5C,CAAiD,GAAjD,CAAP;IACD;;IACD,OAAOI,UAAP;EACD;;EAOyB,OAAnBD,mBAAmB,CAAEf,OAAF,EAAW;IACnC,OAAOS,gBAAEQ,SAAF,CAAYjB,OAAZ,CAAP;EACD;;EAOmC,OAA7BmB,6BAA6B,CAAEC,QAAF,EAAY;IAC9C,MAAMC,OAAO,GAAGD,QAAQ,CAACE,KAAT,CAAe3B,gBAAf,CAAhB;;IACA,IAAI0B,OAAJ,aAAIA,OAAJ,eAAIA,OAAO,CAAEE,MAAb,EAAqB;MACnB,MAAM;QAACxB,OAAD;QAAUyB;MAAV,IAEFH,OAAO,CAACE,MAFZ;MAIA,OAAO;QAACxB,OAAD;QAAUyB;MAAV,CAAP;IACD;;IACD,OAAO,EAAP;EACD;;EAWY,OAANC,MAAM,CAAE3B,IAAF,EAAQ4B,IAAR,EAAc;IACzB,OAAOC,MAAM,CAACC,MAAP,CAAc,IAAI/B,OAAJ,CAAYC,IAAZ,EAAkB4B,IAAlB,CAAd,CAAP;EACD;;EAODG,QAAQ,GAAI;IACV,IAAIC,GAAG,GAAI,aAAY,KAAKhC,IAAK,KAAI,KAAKG,GAAI,GAA9C;;IACA,IAAI,KAAKF,OAAL,IAAgB,KAAKC,OAAzB,EAAkC;MAChC8B,GAAG,IAAK,UAAS,KAAK/B,OAAQ,IAAG,KAAKC,OAAQ,GAA9C;IACD;;IACD,OAAO8B,GAAP;EACD;;AAxLkB"}

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

@@ -177,4 +177,4 @@ function toParserArgs() {
     argSpec
   }) => subSchemaToArgDef(schema, argSpec)));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/schema/cli-args.js"],"names":["TYPENAMES","Object","freeze","ARRAY","OBJECT","BOOLEAN","INTEGER","NUMBER","NULL","STRING","SHORT_ARG_CUTOFF","aliasToFlag","argSpec","alias","extType","extName","name","arg","isShort","length","_","kebabCase","screamingSnakeCase","flow","snakeCase","toUpper","getSchemaValidator","ref","schemaId","coerce","identity","value","coerced","errors","isEmpty","ArgumentTypeError","makeDescription","schema","appiumCliDescription","description","appiumDeprecated","desc","subSchemaToArgDef","subSchema","type","appiumCliAliases","appiumCliTransformer","enum","enumValues","aliases","map","argOpts","required","help","argTypeFunction","action","const","transformers","json","csv","parseFloat","parseInt","TypeError","metavar","choices","String","toParserArgs","flattened","filter","appiumCliIgnored","Map"],"mappings":"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","sourcesContent":["\nimport {ArgumentTypeError} from 'argparse';\nimport _ from 'lodash';\nimport {formatErrors as formatErrors} from '../config-file';\nimport {flattenSchema, validate} from './schema';\nimport {transformers} from './cli-transformers';\n\n/**\n * This module concerns functions which convert schema definitions to\n * `argparse`-compatible data structures, for deriving CLI arguments from a\n * schema.\n */\n\n/**\n * Lookup of possible values for the `type` field in a JSON schema.\n * @type {Readonly<Record<string, import('json-schema').JSONSchema7TypeName>>}\n */\nconst TYPENAMES = Object.freeze({\n  ARRAY: 'array',\n  OBJECT: 'object',\n  BOOLEAN: 'boolean',\n  INTEGER: 'integer',\n  NUMBER: 'number',\n  NULL: 'null',\n  STRING: 'string',\n});\n\n/**\n * Options with alias lengths less than this will be considered \"short\" flags.\n */\nconst SHORT_ARG_CUTOFF = 3;\n\n/**\n * Convert an alias (`foo`) to a flag (`--foo`) or a short flag (`-f`).\n * @param {ArgSpec} argSpec - the argument specification\n * @param {string} [alias] - the alias to convert to a flag\n * @returns {string} the flag\n */\nfunction aliasToFlag (argSpec, alias) {\n  const {extType, extName, name} = argSpec;\n  const arg = alias ?? name;\n  const isShort = arg.length < SHORT_ARG_CUTOFF;\n  if (extType && extName) {\n    return isShort\n      ? `--${extType}-${_.kebabCase(extName)}-${arg}`\n      : `--${extType}-${_.kebabCase(extName)}-${_.kebabCase(arg)}`;\n  }\n  return isShort ? `-${arg}` : `--${_.kebabCase(arg)}`;\n}\n\n/**\n * Converts a string to SCREAMING_SNAKE_CASE\n */\nconst screamingSnakeCase = _.flow(_.snakeCase, _.toUpper);\n\n/**\n * Given unique property name `name`, return a function which validates a value\n * against a property within the schema.\n * @template Coerced\n * @param {ArgSpec} argSpec - Argument name\n * @param {(value: string) => Coerced} [coerce] - Function to coerce to a different\n * primitive\n * @todo See if we can remove `coerce` by allowing Ajv to coerce in its\n * constructor options\n * @returns\n */\nfunction getSchemaValidator ({ref: schemaId}, coerce = _.identity) {\n  /** @param {string} value */\n  return (value) => {\n    const coerced = coerce(value);\n    const errors = validate(coerced, schemaId);\n    if (_.isEmpty(errors)) {\n      return coerced;\n    }\n    throw new ArgumentTypeError(\n      '\\n\\n' + formatErrors(errors, value, {schemaId}),\n    );\n  };\n}\n\n/**\n * Determine the description for display on the CLI, given the schema.\n * @param {AppiumJSONSchema} schema\n * @returns {string}\n */\nfunction makeDescription (schema) {\n  const {appiumCliDescription, description = '', appiumDeprecated} = schema;\n  let desc = appiumCliDescription ?? description;\n  if (appiumDeprecated) {\n    desc = `[DEPRECATED] ${desc}`;\n  }\n  return desc;\n}\n\n/**\n * Given arg `name`, a JSON schema `subSchema`, and options, return an argument definition\n * as understood by `argparse`.\n * @param {AppiumJSONSchema} subSchema - JSON schema for the option\n * @param {ArgSpec} argSpec - Argument spec tuple\n * @returns {[string[], import('argparse').ArgumentOptions]} Tuple of flag and options\n */\nfunction subSchemaToArgDef (subSchema, argSpec) {\n  let {\n    type,\n    appiumCliAliases,\n    appiumCliTransformer,\n    enum: enumValues,\n  } = subSchema;\n\n  const {name, arg} = argSpec;\n\n  const aliases = [\n    aliasToFlag(argSpec),\n    .../** @type {string[]} */ (appiumCliAliases ?? []).map((alias) =>\n      aliasToFlag(argSpec, alias),\n    ),\n  ];\n\n  /** @type {import('argparse').ArgumentOptions} */\n  let argOpts = {\n    required: false,\n    help: makeDescription(subSchema)\n  };\n\n  /**\n   * Generally we will provide a `type` to `argparse` as a function which\n   * validates using ajv (which is much more full-featured than what `argparse`\n   * can offer). The exception is `boolean`-type options, which have no\n   * `argType`.\n   *\n   * Not sure if this type is correct, but it's not doing what I want.  I want\n   * to say \"this is a function which returns something of type `T` where `T` is\n   * never a `Promise`\".  This function must be sync.\n   * @type {((value: string) => unknown)|undefined}\n   */\n  let argTypeFunction;\n\n  // handle special cases for various types\n  switch (type) {\n    // booleans do not have a type per `ArgumentOptions`, just an \"action\"\n    // NOTE: due to limitations of `argparse`, we cannot provide fancy help text, and must rely on its internal error messaging.\n    case TYPENAMES.BOOLEAN: {\n      argOpts.action = 'store_const';\n      argOpts.const = true;\n      break;\n    }\n\n    case TYPENAMES.OBJECT: {\n      argTypeFunction = transformers.json;\n      break;\n    }\n\n    // arrays are treated as CSVs, because `argparse` doesn't handle array data.\n    case TYPENAMES.ARRAY: {\n      argTypeFunction = transformers.csv;\n      break;\n    }\n\n    // \"number\" type is coerced to float. `argparse` does this for us if we use `float` type, but\n    // we don't.\n    case TYPENAMES.NUMBER: {\n      argTypeFunction = getSchemaValidator(argSpec, parseFloat);\n      break;\n    }\n\n    // \"integer\" is coerced to an .. integer.  again, `argparse` would do this for us if we used `int`.\n    case TYPENAMES.INTEGER: {\n      argTypeFunction = getSchemaValidator(argSpec, _.parseInt);\n      break;\n    }\n\n    // strings (like number and integer) are subject to further validation\n    // (e.g., must satisfy a mask or regex or even some custom validation\n    // function)\n    case TYPENAMES.STRING: {\n      argTypeFunction = getSchemaValidator(argSpec);\n      break;\n    }\n\n    // TODO: there may be some way to restrict this at the Ajv level --\n    // that may involve patching the metaschema.\n    case TYPENAMES.NULL:\n    // falls through\n    default: {\n      throw new TypeError(\n        `Schema property \"${arg}\": \\`${type}\\` type unknown or disallowed`,\n      );\n    }\n  }\n\n  // metavar is used in help text. `boolean` cannot have a metavar--it is not\n  // displayed--and `argparse` throws if you give it one.\n  if (type !== TYPENAMES.BOOLEAN) {\n    argOpts.metavar = screamingSnakeCase(name);\n  }\n\n  // the validity of \"appiumCliTransformer\" should already have been determined\n  // by ajv during schema validation in `finalizeSchema()`. the `array` &\n  // `object` types have already added a formatter (see above, so we don't do it\n  // twice).\n  if (\n    type !== TYPENAMES.ARRAY &&\n    type !== TYPENAMES.OBJECT &&\n    appiumCliTransformer\n  ) {\n    argTypeFunction = _.flow(\n      argTypeFunction ?? _.identity,\n      transformers[appiumCliTransformer],\n    );\n  }\n\n  if (argTypeFunction) {\n    argOpts.type = argTypeFunction;\n  }\n\n  // convert JSON schema `enum` to `choices`. `enum` can contain any JSON type, but `argparse`\n  // is limited to a single type per arg (I think).  so let's make everything a string.\n  // and might as well _require_ the `type: string` while we're at it.\n  if (enumValues && !_.isEmpty(enumValues)) {\n    if (type === TYPENAMES.STRING) {\n      argOpts.choices = enumValues.map(String);\n    } else {\n      throw new TypeError(\n        `Problem with schema for ${arg}; \\`enum\\` is only supported for \\`type: 'string'\\``,\n      );\n    }\n  }\n\n  return [aliases, argOpts];\n}\n\n/**\n * Converts the finalized, flattened schema representation into\n * ArgumentDefinitions for handoff to `argparse`.\n *\n * @throws If schema has not been added to ajv (via `finalizeSchema()`)\n * @returns {import('../cli/args').ArgumentDefinitions} A map of arryas of\n * aliases to `argparse` arguments; empty if no schema found\n */\nexport function toParserArgs () {\n  const flattened = flattenSchema().filter(({schema}) => !schema.appiumCliIgnored);\n  return new Map(\n    _.map(flattened, ({schema, argSpec}) =>\n      subSchemaToArgDef(schema, argSpec),\n    ),\n  );\n}\n\n/**\n * @template T\n * @typedef {import('ajv/dist/types').FormatValidator<T>} FormatValidator<T>\n */\n\n/**\n * A JSON 7 schema with our custom keywords.\n * @typedef {import('./keywords').AppiumJSONSchemaKeywords & import('json-schema').JSONSchema7} AppiumJSONSchema\n */\n\n/**\n * @typedef {import('./arg-spec').ArgSpec} ArgSpec\n */\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["TYPENAMES","Object","freeze","ARRAY","OBJECT","BOOLEAN","INTEGER","NUMBER","NULL","STRING","SHORT_ARG_CUTOFF","aliasToFlag","argSpec","alias","extType","extName","name","arg","isShort","length","_","kebabCase","screamingSnakeCase","flow","snakeCase","toUpper","getSchemaValidator","ref","schemaId","coerce","identity","value","coerced","errors","isEmpty","ArgumentTypeError","makeDescription","schema","appiumCliDescription","description","appiumDeprecated","desc","subSchemaToArgDef","subSchema","type","appiumCliAliases","appiumCliTransformer","enum","enumValues","aliases","map","argOpts","required","help","argTypeFunction","action","const","transformers","json","csv","parseFloat","parseInt","TypeError","metavar","choices","String","toParserArgs","flattened","filter","appiumCliIgnored","Map"],"sources":["../../../lib/schema/cli-args.js"],"sourcesContent":["\nimport {ArgumentTypeError} from 'argparse';\nimport _ from 'lodash';\nimport {formatErrors as formatErrors} from '../config-file';\nimport {flattenSchema, validate} from './schema';\nimport {transformers} from './cli-transformers';\n\n/**\n * This module concerns functions which convert schema definitions to\n * `argparse`-compatible data structures, for deriving CLI arguments from a\n * schema.\n */\n\n/**\n * Lookup of possible values for the `type` field in a JSON schema.\n * @type {Readonly<Record<string, import('json-schema').JSONSchema7TypeName>>}\n */\nconst TYPENAMES = Object.freeze({\n  ARRAY: 'array',\n  OBJECT: 'object',\n  BOOLEAN: 'boolean',\n  INTEGER: 'integer',\n  NUMBER: 'number',\n  NULL: 'null',\n  STRING: 'string',\n});\n\n/**\n * Options with alias lengths less than this will be considered \"short\" flags.\n */\nconst SHORT_ARG_CUTOFF = 3;\n\n/**\n * Convert an alias (`foo`) to a flag (`--foo`) or a short flag (`-f`).\n * @param {ArgSpec} argSpec - the argument specification\n * @param {string} [alias] - the alias to convert to a flag\n * @returns {string} the flag\n */\nfunction aliasToFlag (argSpec, alias) {\n  const {extType, extName, name} = argSpec;\n  const arg = alias ?? name;\n  const isShort = arg.length < SHORT_ARG_CUTOFF;\n  if (extType && extName) {\n    return isShort\n      ? `--${extType}-${_.kebabCase(extName)}-${arg}`\n      : `--${extType}-${_.kebabCase(extName)}-${_.kebabCase(arg)}`;\n  }\n  return isShort ? `-${arg}` : `--${_.kebabCase(arg)}`;\n}\n\n/**\n * Converts a string to SCREAMING_SNAKE_CASE\n */\nconst screamingSnakeCase = _.flow(_.snakeCase, _.toUpper);\n\n/**\n * Given unique property name `name`, return a function which validates a value\n * against a property within the schema.\n * @template Coerced\n * @param {ArgSpec} argSpec - Argument name\n * @param {(value: string) => Coerced} [coerce] - Function to coerce to a different\n * primitive\n * @todo See if we can remove `coerce` by allowing Ajv to coerce in its\n * constructor options\n * @returns\n */\nfunction getSchemaValidator ({ref: schemaId}, coerce = _.identity) {\n  /** @param {string} value */\n  return (value) => {\n    const coerced = coerce(value);\n    const errors = validate(coerced, schemaId);\n    if (_.isEmpty(errors)) {\n      return coerced;\n    }\n    throw new ArgumentTypeError(\n      '\\n\\n' + formatErrors(errors, value, {schemaId}),\n    );\n  };\n}\n\n/**\n * Determine the description for display on the CLI, given the schema.\n * @param {AppiumJSONSchema} schema\n * @returns {string}\n */\nfunction makeDescription (schema) {\n  const {appiumCliDescription, description = '', appiumDeprecated} = schema;\n  let desc = appiumCliDescription ?? description;\n  if (appiumDeprecated) {\n    desc = `[DEPRECATED] ${desc}`;\n  }\n  return desc;\n}\n\n/**\n * Given arg `name`, a JSON schema `subSchema`, and options, return an argument definition\n * as understood by `argparse`.\n * @param {AppiumJSONSchema} subSchema - JSON schema for the option\n * @param {ArgSpec} argSpec - Argument spec tuple\n * @returns {[string[], import('argparse').ArgumentOptions]} Tuple of flag and options\n */\nfunction subSchemaToArgDef (subSchema, argSpec) {\n  let {\n    type,\n    appiumCliAliases,\n    appiumCliTransformer,\n    enum: enumValues,\n  } = subSchema;\n\n  const {name, arg} = argSpec;\n\n  const aliases = [\n    aliasToFlag(argSpec),\n    .../** @type {string[]} */ (appiumCliAliases ?? []).map((alias) =>\n      aliasToFlag(argSpec, alias),\n    ),\n  ];\n\n  /** @type {import('argparse').ArgumentOptions} */\n  let argOpts = {\n    required: false,\n    help: makeDescription(subSchema)\n  };\n\n  /**\n   * Generally we will provide a `type` to `argparse` as a function which\n   * validates using ajv (which is much more full-featured than what `argparse`\n   * can offer). The exception is `boolean`-type options, which have no\n   * `argType`.\n   *\n   * Not sure if this type is correct, but it's not doing what I want.  I want\n   * to say \"this is a function which returns something of type `T` where `T` is\n   * never a `Promise`\".  This function must be sync.\n   * @type {((value: string) => unknown)|undefined}\n   */\n  let argTypeFunction;\n\n  // handle special cases for various types\n  switch (type) {\n    // booleans do not have a type per `ArgumentOptions`, just an \"action\"\n    // NOTE: due to limitations of `argparse`, we cannot provide fancy help text, and must rely on its internal error messaging.\n    case TYPENAMES.BOOLEAN: {\n      argOpts.action = 'store_const';\n      argOpts.const = true;\n      break;\n    }\n\n    case TYPENAMES.OBJECT: {\n      argTypeFunction = transformers.json;\n      break;\n    }\n\n    // arrays are treated as CSVs, because `argparse` doesn't handle array data.\n    case TYPENAMES.ARRAY: {\n      argTypeFunction = transformers.csv;\n      break;\n    }\n\n    // \"number\" type is coerced to float. `argparse` does this for us if we use `float` type, but\n    // we don't.\n    case TYPENAMES.NUMBER: {\n      argTypeFunction = getSchemaValidator(argSpec, parseFloat);\n      break;\n    }\n\n    // \"integer\" is coerced to an .. integer.  again, `argparse` would do this for us if we used `int`.\n    case TYPENAMES.INTEGER: {\n      argTypeFunction = getSchemaValidator(argSpec, _.parseInt);\n      break;\n    }\n\n    // strings (like number and integer) are subject to further validation\n    // (e.g., must satisfy a mask or regex or even some custom validation\n    // function)\n    case TYPENAMES.STRING: {\n      argTypeFunction = getSchemaValidator(argSpec);\n      break;\n    }\n\n    // TODO: there may be some way to restrict this at the Ajv level --\n    // that may involve patching the metaschema.\n    case TYPENAMES.NULL:\n    // falls through\n    default: {\n      throw new TypeError(\n        `Schema property \"${arg}\": \\`${type}\\` type unknown or disallowed`,\n      );\n    }\n  }\n\n  // metavar is used in help text. `boolean` cannot have a metavar--it is not\n  // displayed--and `argparse` throws if you give it one.\n  if (type !== TYPENAMES.BOOLEAN) {\n    argOpts.metavar = screamingSnakeCase(name);\n  }\n\n  // the validity of \"appiumCliTransformer\" should already have been determined\n  // by ajv during schema validation in `finalizeSchema()`. the `array` &\n  // `object` types have already added a formatter (see above, so we don't do it\n  // twice).\n  if (\n    type !== TYPENAMES.ARRAY &&\n    type !== TYPENAMES.OBJECT &&\n    appiumCliTransformer\n  ) {\n    argTypeFunction = _.flow(\n      argTypeFunction ?? _.identity,\n      transformers[appiumCliTransformer],\n    );\n  }\n\n  if (argTypeFunction) {\n    argOpts.type = argTypeFunction;\n  }\n\n  // convert JSON schema `enum` to `choices`. `enum` can contain any JSON type, but `argparse`\n  // is limited to a single type per arg (I think).  so let's make everything a string.\n  // and might as well _require_ the `type: string` while we're at it.\n  if (enumValues && !_.isEmpty(enumValues)) {\n    if (type === TYPENAMES.STRING) {\n      argOpts.choices = enumValues.map(String);\n    } else {\n      throw new TypeError(\n        `Problem with schema for ${arg}; \\`enum\\` is only supported for \\`type: 'string'\\``,\n      );\n    }\n  }\n\n  return [aliases, argOpts];\n}\n\n/**\n * Converts the finalized, flattened schema representation into\n * ArgumentDefinitions for handoff to `argparse`.\n *\n * @throws If schema has not been added to ajv (via `finalizeSchema()`)\n * @returns {import('../cli/args').ArgumentDefinitions} A map of arryas of\n * aliases to `argparse` arguments; empty if no schema found\n */\nexport function toParserArgs () {\n  const flattened = flattenSchema().filter(({schema}) => !schema.appiumCliIgnored);\n  return new Map(\n    _.map(flattened, ({schema, argSpec}) =>\n      subSchemaToArgDef(schema, argSpec),\n    ),\n  );\n}\n\n/**\n * @template T\n * @typedef {import('ajv/dist/types').FormatValidator<T>} FormatValidator<T>\n */\n\n/**\n * A JSON 7 schema with our custom keywords.\n * @typedef {import('./keywords').AppiumJSONSchemaKeywords & import('json-schema').JSONSchema7} AppiumJSONSchema\n */\n\n/**\n * @typedef {import('./arg-spec').ArgSpec} ArgSpec\n */\n"],"mappings":";;;;;;;;;;;AACA;;AACA;;AACA;;AACA;;AACA;;AAYA,MAAMA,SAAS,GAAGC,MAAM,CAACC,MAAP,CAAc;EAC9BC,KAAK,EAAE,OADuB;EAE9BC,MAAM,EAAE,QAFsB;EAG9BC,OAAO,EAAE,SAHqB;EAI9BC,OAAO,EAAE,SAJqB;EAK9BC,MAAM,EAAE,QALsB;EAM9BC,IAAI,EAAE,MANwB;EAO9BC,MAAM,EAAE;AAPsB,CAAd,CAAlB;AAaA,MAAMC,gBAAgB,GAAG,CAAzB;;AAQA,SAASC,WAAT,CAAsBC,OAAtB,EAA+BC,KAA/B,EAAsC;EACpC,MAAM;IAACC,OAAD;IAAUC,OAAV;IAAmBC;EAAnB,IAA2BJ,OAAjC;EACA,MAAMK,GAAG,GAAGJ,KAAH,aAAGA,KAAH,cAAGA,KAAH,GAAYG,IAArB;EACA,MAAME,OAAO,GAAGD,GAAG,CAACE,MAAJ,GAAaT,gBAA7B;;EACA,IAAII,OAAO,IAAIC,OAAf,EAAwB;IACtB,OAAOG,OAAO,GACT,KAAIJ,OAAQ,IAAGM,gBAAEC,SAAF,CAAYN,OAAZ,CAAqB,IAAGE,GAAI,EADlC,GAET,KAAIH,OAAQ,IAAGM,gBAAEC,SAAF,CAAYN,OAAZ,CAAqB,IAAGK,gBAAEC,SAAF,CAAYJ,GAAZ,CAAiB,EAF7D;EAGD;;EACD,OAAOC,OAAO,GAAI,IAAGD,GAAI,EAAX,GAAgB,KAAIG,gBAAEC,SAAF,CAAYJ,GAAZ,CAAiB,EAAnD;AACD;;AAKD,MAAMK,kBAAkB,GAAGF,gBAAEG,IAAF,CAAOH,gBAAEI,SAAT,EAAoBJ,gBAAEK,OAAtB,CAA3B;;AAaA,SAASC,kBAAT,CAA6B;EAACC,GAAG,EAAEC;AAAN,CAA7B,EAA8CC,MAAM,GAAGT,gBAAEU,QAAzD,EAAmE;EAEjE,OAAQC,KAAD,IAAW;IAChB,MAAMC,OAAO,GAAGH,MAAM,CAACE,KAAD,CAAtB;IACA,MAAME,MAAM,GAAG,sBAASD,OAAT,EAAkBJ,QAAlB,CAAf;;IACA,IAAIR,gBAAEc,OAAF,CAAUD,MAAV,CAAJ,EAAuB;MACrB,OAAOD,OAAP;IACD;;IACD,MAAM,IAAIG,2BAAJ,CACJ,SAAS,8BAAaF,MAAb,EAAqBF,KAArB,EAA4B;MAACH;IAAD,CAA5B,CADL,CAAN;EAGD,CATD;AAUD;;AAOD,SAASQ,eAAT,CAA0BC,MAA1B,EAAkC;EAChC,MAAM;IAACC,oBAAD;IAAuBC,WAAW,GAAG,EAArC;IAAyCC;EAAzC,IAA6DH,MAAnE;EACA,IAAII,IAAI,GAAGH,oBAAH,aAAGA,oBAAH,cAAGA,oBAAH,GAA2BC,WAAnC;;EACA,IAAIC,gBAAJ,EAAsB;IACpBC,IAAI,GAAI,gBAAeA,IAAK,EAA5B;EACD;;EACD,OAAOA,IAAP;AACD;;AASD,SAASC,iBAAT,CAA4BC,SAA5B,EAAuC/B,OAAvC,EAAgD;EAC9C,IAAI;IACFgC,IADE;IAEFC,gBAFE;IAGFC,oBAHE;IAIFC,IAAI,EAAEC;EAJJ,IAKAL,SALJ;EAOA,MAAM;IAAC3B,IAAD;IAAOC;EAAP,IAAcL,OAApB;EAEA,MAAMqC,OAAO,GAAG,CACdtC,WAAW,CAACC,OAAD,CADG,EAEd,GAA2B,CAACiC,gBAAD,aAACA,gBAAD,cAACA,gBAAD,GAAqB,EAArB,EAAyBK,GAAzB,CAA8BrC,KAAD,IACtDF,WAAW,CAACC,OAAD,EAAUC,KAAV,CADc,CAFb,CAAhB;EAQA,IAAIsC,OAAO,GAAG;IACZC,QAAQ,EAAE,KADE;IAEZC,IAAI,EAAEjB,eAAe,CAACO,SAAD;EAFT,CAAd;EAgBA,IAAIW,eAAJ;;EAGA,QAAQV,IAAR;IAGE,KAAK5C,SAAS,CAACK,OAAf;MAAwB;QACtB8C,OAAO,CAACI,MAAR,GAAiB,aAAjB;QACAJ,OAAO,CAACK,KAAR,GAAgB,IAAhB;QACA;MACD;;IAED,KAAKxD,SAAS,CAACI,MAAf;MAAuB;QACrBkD,eAAe,GAAGG,8BAAaC,IAA/B;QACA;MACD;;IAGD,KAAK1D,SAAS,CAACG,KAAf;MAAsB;QACpBmD,eAAe,GAAGG,8BAAaE,GAA/B;QACA;MACD;;IAID,KAAK3D,SAAS,CAACO,MAAf;MAAuB;QACrB+C,eAAe,GAAG5B,kBAAkB,CAACd,OAAD,EAAUgD,UAAV,CAApC;QACA;MACD;;IAGD,KAAK5D,SAAS,CAACM,OAAf;MAAwB;QACtBgD,eAAe,GAAG5B,kBAAkB,CAACd,OAAD,EAAUQ,gBAAEyC,QAAZ,CAApC;QACA;MACD;;IAKD,KAAK7D,SAAS,CAACS,MAAf;MAAuB;QACrB6C,eAAe,GAAG5B,kBAAkB,CAACd,OAAD,CAApC;QACA;MACD;;IAID,KAAKZ,SAAS,CAACQ,IAAf;IAEA;MAAS;QACP,MAAM,IAAIsD,SAAJ,CACH,oBAAmB7C,GAAI,QAAO2B,IAAK,+BADhC,CAAN;MAGD;EAjDH;;EAsDA,IAAIA,IAAI,KAAK5C,SAAS,CAACK,OAAvB,EAAgC;IAC9B8C,OAAO,CAACY,OAAR,GAAkBzC,kBAAkB,CAACN,IAAD,CAApC;EACD;;EAMD,IACE4B,IAAI,KAAK5C,SAAS,CAACG,KAAnB,IACAyC,IAAI,KAAK5C,SAAS,CAACI,MADnB,IAEA0C,oBAHF,EAIE;IAAA;;IACAQ,eAAe,GAAGlC,gBAAEG,IAAF,qBAChB+B,eADgB,+DACGlC,gBAAEU,QADL,EAEhB2B,8BAAaX,oBAAb,CAFgB,CAAlB;EAID;;EAED,IAAIQ,eAAJ,EAAqB;IACnBH,OAAO,CAACP,IAAR,GAAeU,eAAf;EACD;;EAKD,IAAIN,UAAU,IAAI,CAAC5B,gBAAEc,OAAF,CAAUc,UAAV,CAAnB,EAA0C;IACxC,IAAIJ,IAAI,KAAK5C,SAAS,CAACS,MAAvB,EAA+B;MAC7B0C,OAAO,CAACa,OAAR,GAAkBhB,UAAU,CAACE,GAAX,CAAee,MAAf,CAAlB;IACD,CAFD,MAEO;MACL,MAAM,IAAIH,SAAJ,CACH,2BAA0B7C,GAAI,qDAD3B,CAAN;IAGD;EACF;;EAED,OAAO,CAACgC,OAAD,EAAUE,OAAV,CAAP;AACD;;AAUM,SAASe,YAAT,GAAyB;EAC9B,MAAMC,SAAS,GAAG,6BAAgBC,MAAhB,CAAuB,CAAC;IAAC/B;EAAD,CAAD,KAAc,CAACA,MAAM,CAACgC,gBAA7C,CAAlB;EACA,OAAO,IAAIC,GAAJ,CACLlD,gBAAE8B,GAAF,CAAMiB,SAAN,EAAiB,CAAC;IAAC9B,MAAD;IAASzB;EAAT,CAAD,KACf8B,iBAAiB,CAACL,MAAD,EAASzB,OAAT,CADnB,CADK,CAAP;AAKD"}

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

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

package/build/lib/schema/index.js

@@ -31,4 +31,4 @@ Object.keys(_cliArgs).forEach(function (key) {
     }
   });
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2xpYi9zY2hlbWEvaW5kZXguanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTs7QUFDQTs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vY2xpLWFyZ3MnO1xuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vbGliL3NjaGVtYS9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NjaGVtYSc7XG5leHBvcnQgKiBmcm9tICcuL2NsaS1hcmdzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFBQTs7QUFBQTtFQUFBO0VBQUE7RUFBQTtJQUFBO0lBQUE7TUFBQTtJQUFBO0VBQUE7QUFBQTs7QUFDQTs7QUFBQTtFQUFBO0VBQUE7RUFBQTtJQUFBO0lBQUE7TUFBQTtJQUFBO0VBQUE7QUFBQSJ9

package/build/lib/schema/keywords.js

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