appium 2.0.0-beta.23 → 2.0.0-beta.26

package/lib/extension/plugin-config.js

@@ -0,0 +1,111 @@
+// @ts-check
+
+import _ from 'lodash';
+import {ExtensionConfig} from './extension-config';
+import log from '../logger';
+import {PLUGIN_TYPE} from '../constants';
+
+/**
+ * @extends {ExtensionConfig<PluginType>}
+ */
+export class PluginConfig extends ExtensionConfig {
+
+  /**
+   * A mapping of {@link Manifest} instances to {@link PluginConfig} instances.
+   *
+   * `Manifest` and {@link ExtensionConfig} have a one-to-many relationship; each `Manifest` should be associated with a `DriverConfig` and a `PluginConfig`; no more, no less.
+   *
+   * This variable tracks the `Manifest`-to-`PluginConfig` portion.
+   *
+   * @type {WeakMap<Manifest,PluginConfig>}
+   * @private
+   */
+   static _instances = new WeakMap();
+
+   /**
+   * Call {@link PluginConfig.create} instead.
+   *
+   * Just calls the superclass' constructor with the correct extension type
+   * @private
+   * @param {import('./manifest').Manifest} manifest - IO object
+   * @param {PluginConfigOptions} [opts]
+   */
+   constructor (manifest, {extData, logFn} = {}) {
+     super(PLUGIN_TYPE, manifest, logFn);
+
+     if (extData) {
+       this.validate(extData);
+     }
+   }
+
+   /**
+    * Creates a new {@link PluginConfig} instance for a {@link Manifest} instance.
+    *
+    * @param {Manifest} manifest
+    * @param {PluginConfigOptions} [opts]
+    * @throws If `manifest` already associated with a `PluginConfig`
+    * @returns {PluginConfig}
+    */
+   static create (manifest, {extData, logFn} = {}) {
+     const instance = new PluginConfig(manifest, {logFn, extData});
+     if (PluginConfig.getInstance(manifest)) {
+       throw new Error(`Manifest with APPIUM_HOME ${manifest.appiumHome} already has a PluginConfig; use PluginConfig.getInstance() to retrieve it.`);
+     }
+     PluginConfig._instances.set(manifest, instance);
+     return instance;
+   }
+
+   /**
+     * Returns a PluginConfig associated with a Manifest
+     * @param {Manifest} manifest
+     * @returns {PluginConfig|undefined}
+     */
+   static getInstance (manifest) {
+     return PluginConfig._instances.get(manifest);
+   }
+   /**
+   * @param {string} pluginName
+   * @param {PluginData} pluginData
+   * @returns {string}
+   */
+   extensionDesc (pluginName, {version}) {
+     return `${pluginName}@${version}`;
+   }
+
+   /**
+   *
+   * @param {(keyof import('./manifest').ExtRecord<PluginType>)[]} activeNames
+   * @returns {void}
+   */
+   print (activeNames) {
+     const pluginNames = Object.keys(this.installedExtensions);
+
+     if (_.isEmpty(pluginNames)) {
+       log.info(`No plugins have been installed. Use the "appium plugin" ` +
+               'command to install the one(s) you want to use.');
+       return;
+     }
+
+     log.info(`Available plugins:`);
+     for (const [pluginName, pluginData] of _.toPairs(this.installedExtensions)) {
+       const activeTxt = _.includes(activeNames, pluginName) ? ' (ACTIVE)' : '';
+       log.info(`  - ${this.extensionDesc(pluginName, pluginData)}${activeTxt}`);
+     }
+
+     if (_.isEmpty(activeNames)) {
+       log.info('No plugins activated. Use the --use-plugins flag with names of plugins to activate');
+     }
+   }
+}
+
+/**
+ * @typedef PluginConfigOptions
+ * @property {import('./extension-config').ExtensionLogFn} [logFn] - Optional logging function
+ * @property {import('./manifest').ExtRecord<PluginType>} [extData] - Extension data
+ */
+
+/**
+ * @typedef {import('./manifest').PluginType} PluginType
+ * @typedef {import('./manifest').ExtData<PluginType>} PluginData
+ * @typedef {import('./manifest').Manifest} Manifest
+ */

package/lib/grid-register.js

@@ -11,10 +11,10 @@ const hubUri = (config) => {
 
 /**
  * Registers a new node with a selenium grid
- * @param {string|object} data - Path or object representing selenium grid node config file
- * @param {string} addr - Bind to this address
- * @param {number} port - Bind to this port
- * @param {string} basePath - Base path for the grid
+ * @param {string|object} data - Path or object representing selenium grid node config file. If a `string`, all subsequent arguments are required!
+ * @param {string} [addr] - Bind to this address
+ * @param {number} [port] - Bind to this port
+ * @param {string} [basePath] - Base path for the grid
  */
 async function registerNode (data, addr, port, basePath) {
   let configFilePath;

package/lib/main.js

@@ -3,23 +3,25 @@
 // transpile:main
 // @ts-check
 
+import { init as logsinkInit } from './logsink'; // this import needs to come first since it sets up global npmlog
+import logger from './logger'; // logger needs to remain second
 // @ts-ignore
 import { routeConfiguringFunction as makeRouter, server as baseServer } from '@appium/base-driver';
-import { logger as logFactory, util } from '@appium/support';
+import { logger as logFactory, util, env } from '@appium/support';
 import { asyncify } from 'asyncbox';
 import _ from 'lodash';
 import { AppiumDriver } from './appium';
-import { driverConfig, pluginConfig, USE_ALL_PLUGINS } from './cli/args';
 import { runExtensionCommand } from './cli/extension';
-import { default as getParser, SERVER_SUBCOMMAND } from './cli/parser';
-import { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, validateTmpDir, warnNodeDeprecations } from './config';
+import { getParser } from './cli/parser';
+import { APPIUM_VER, checkNodeOk, getGitRev, getNonDefaultServerArgs, showConfig, showBuildInfo, validateTmpDir, warnNodeDeprecations } from './config';
 import { readConfigFile } from './config-file';
-import { DRIVER_TYPE, PLUGIN_TYPE } from './extension-config';
+import { loadExtensions, getActivePlugins, getActiveDrivers } from './extension';
+import { DRIVER_TYPE, PLUGIN_TYPE, SERVER_SUBCOMMAND } from './constants';
 import registerNode from './grid-register';
-import logger from './logger'; // logger needs to remain first of imports
-import { init as logsinkInit } from './logsink';
-import { getDefaultsFromSchema, validate } from './schema/schema';
-import { inspectObject } from './utils';
+import { getDefaultsForSchema, validate } from './schema/schema';
+import { inspect } from './utils';
+
+const {resolveAppiumHome} = env;
 
 /**
  *
@@ -32,8 +34,8 @@ async function preflightChecks (args, throwInsteadOfExit = false) {
     if (args.longStacktrace) {
       require('longjohn').async_trace_limit = -1;
     }
-    if (args.showConfig) {
-      await showConfig();
+    if (args.showBuildInfo) {
+      await showBuildInfo();
       process.exit(0);
     }
     warnNodeDeprecations();
@@ -53,18 +55,24 @@ async function preflightChecks (args, throwInsteadOfExit = false) {
   }
 }
 
+/**
+ * @param {Partial<ParsedArgs>} args
+ */
 function logNonDefaultArgsWarning (args) {
   logger.info('Non-default server args:');
-  inspectObject(args);
+  inspect(args);
 }
 
 function logDefaultCapabilitiesWarning (caps) {
   logger.info('Default capabilities, which will be added to each request ' +
               'unless overridden by desired capabilities:');
-  inspectObject(caps);
+  inspect(caps);
 }
 
-async function logStartupInfo (parser, args) {
+/**
+ * @param {ParsedArgs} args
+ */
+async function logStartupInfo (args) {
   let welcome = `Welcome to Appium v${APPIUM_VER}`;
   let appiumRev = await getGitRev();
   if (appiumRev) {
@@ -72,7 +80,7 @@ async function logStartupInfo (parser, args) {
   }
   logger.info(welcome);
 
-  let showArgs = getNonDefaultServerArgs(parser, args);
+  let showArgs = getNonDefaultServerArgs(args);
   if (_.size(showArgs)) {
     logNonDefaultArgsWarning(showArgs);
   }
@@ -86,6 +94,12 @@ async function logStartupInfo (parser, args) {
   // }
 }
 
+/**
+ * Logs the address and port the server is listening on
+ * @param {string} address - Address
+ * @param {number} port - Port
+ * @returns {void}
+ */
 function logServerPort (address, port) {
   let logMessage = `Appium REST http interface listener started on ` +
                    `${address}:${port}`;
@@ -93,61 +107,21 @@ function logServerPort (address, port) {
 }
 
 /**
- * Find any plugin name which has been installed, and which has been requested for activation by
- * using the --use-plugins flag, and turn each one into its class, so we can send them as objects
- * to the server init. We also want to send/assign them to the umbrella driver so it can use them
- * to wrap command execution
- *
- * @param {Object} args - argparser parsed dict
- * @param {import('./plugin-config').default} pluginConfig - a plugin extension config
- * @returns {({pluginName: string} & ((...args: any[]) => unknown))[]}
+ * Gets a list of `updateServer` functions from all extensions
+ * @param {DriverClass[]} driverClasses
+ * @param {PluginClass[]} pluginClasses
+ * @returns {import('./extension/manifest').UpdateServerFn[]}
  */
-function getActivePlugins (args, pluginConfig) {
-  return _.compact(Object.keys(pluginConfig.installedExtensions).filter((pluginName) =>
-    _.includes(args.usePlugins, pluginName) ||
-    (args.usePlugins.length === 1 && args.usePlugins[0] === USE_ALL_PLUGINS)
-  ).map((pluginName) => {
-    try {
-      logger.info(`Attempting to load plugin ${pluginName}...`);
-      const PluginClass = /** @type {{pluginName: string} & ((...args: any[]) => unknown)} */(pluginConfig.require(pluginName));
-
-      PluginClass.pluginName = pluginName; // store the plugin name on the class so it can be used later
-      return PluginClass;
-    } catch (err) {
-      logger.error(`Could not load plugin '${pluginName}', so it will not be available. Error ` +
-                   `in loading the plugin was: ${err.message}`);
-      logger.debug(err.stack);
-    }
-  }));
+function getServerUpdaters (driverClasses, pluginClasses) {
+  return _.compact(_.map([...driverClasses, ...pluginClasses], 'updateServer'));
 }
 
 /**
- * Find any driver name which has been installed, and turn each one into its class, so we can send
- * them as objects to the server init in case they need to add methods/routes or update the server.
- * If the --drivers flag was given, this method only loads the given drivers.
- *
- * @param {Object} args - argparser parsed dict
- * @param {import('./driver-config').default} driverConfig - a driver extension config
+ * Makes a big `MethodMap` from all the little `MethodMap`s in the extensions
+ * @param {DriverClass[]} driverClasses
+ * @param {PluginClass[]} pluginClasses
+ * @returns {import('@appium/base-driver').MethodMap}
  */
-function getActiveDrivers (args, driverConfig) {
-  return _.compact(Object.keys(driverConfig.installedExtensions).filter((driverName) =>
-    _.includes(args.useDrivers, driverName) || args.useDrivers.length === 0
-  ).map((driverName) => {
-    try {
-      logger.info(`Attempting to load driver ${driverName}...`);
-      return driverConfig.require(driverName);
-    } catch (err) {
-      logger.error(`Could not load driver '${driverName}', so it will not be available. Error ` +
-                   `in loading the driver was: ${err.message}`);
-      logger.debug(err.stack);
-    }
-  }));
-}
-
-function getServerUpdaters (driverClasses, pluginClasses) {
-  return [...driverClasses, ...pluginClasses].map((klass) => klass.updateServer).filter(Boolean);
-}
-
 function getExtraMethodMap (driverClasses, pluginClasses) {
   return [...driverClasses, ...pluginClasses].reduce(
     (map, klass) => ({...map, ...klass.newMethodMap}),
@@ -160,19 +134,33 @@ function getExtraMethodMap (driverClasses, pluginClasses) {
  *
  * Use this to get at the configuration schema.
  *
+ * 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)
+ * @returns {Promise<ServerInitResult | ExtCommandInitResult>}
  * @example
  * import {init, getSchema} from 'appium';
  * const options = {}; // config object
  * await init(options);
  * const schema = getSchema(); // entire config schema including plugins and drivers
- * @param {ParsedArgs} [args] - Parsed args
- * @returns {Promise<{parser: import('./cli/parser').ArgParser} & Partial<{appiumDriver: AppiumDriver, parsedArgs: ParsedArgs}>>}
  */
 async function init (args) {
-  const parser = await getParser();
+  const appiumHome = args?.appiumHome ?? await resolveAppiumHome();
+
+  const {driverConfig, pluginConfig} = await loadExtensions(appiumHome);
+
+  const parser = getParser();
   let throwInsteadOfExit = false;
   /** @type {ParsedArgs} */
+  let preConfigParsedArgs;
+  /** @type {ParsedArgs} */
   let parsedArgs;
+  /**
+   * This is a definition (instead of declaration) because TS can't figure out
+   * the value will be defined when it's used.
+   * @type {ReturnType<getDefaultsForSchema>}
+   */
+  let defaults = {};
   if (args) {
     // if we have a containing package instead of running as a CLI process,
     // that package might not appreciate us calling 'process.exit' willy-
@@ -182,13 +170,13 @@ async function init (args) {
       // but remove it since it's not a real server arg per se
       delete args.throwInsteadOfExit;
     }
-    parsedArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND};
+    preConfigParsedArgs = /** @type {ParsedArgs} */({...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND});
   } else {
     // otherwise parse from CLI
-    parsedArgs = parser.parseArgs();
+    preConfigParsedArgs = parser.parseArgs();
   }
 
-  const configResult = await readConfigFile(parsedArgs.configFile);
+  const configResult = await readConfigFile(preConfigParsedArgs.configFile);
 
   if (!_.isEmpty(configResult.errors)) {
     throw new Error(`Errors in config file ${configResult.filepath}:\n ${configResult.reason ?? configResult.errors}`);
@@ -199,30 +187,35 @@ async function init (args) {
   // 1. command line args
   // 2. config file
   // 3. defaults from config file.
-  if (parsedArgs.subcommand === SERVER_SUBCOMMAND) {
+  if (preConfigParsedArgs.subcommand === SERVER_SUBCOMMAND) {
+    defaults = getDefaultsForSchema(false);
+
     parsedArgs = _.defaultsDeep(
-      parsedArgs,
+      preConfigParsedArgs,
       configResult.config?.server,
-      getDefaultsFromSchema()
+      defaults
     );
-  }
 
-  parsedArgs = _.defaultsDeep(
-    parsedArgs,
-    configResult.config ?? {},
-  );
+    if (preConfigParsedArgs.showConfig) {
+      showConfig(getNonDefaultServerArgs(preConfigParsedArgs), configResult, defaults, parsedArgs);
+      return {};
+    }
+
+  } else {
+    parsedArgs = preConfigParsedArgs;
+  }
 
   await logsinkInit(parsedArgs);
 
   // if the user has requested the 'driver' CLI, don't run the normal server,
   // but instead pass control to the driver CLI
   if (parsedArgs.subcommand === DRIVER_TYPE) {
-    await runExtensionCommand(parsedArgs, parsedArgs.subcommand, driverConfig);
-    return {parser};
+    await runExtensionCommand(parsedArgs, driverConfig);
+    return {};
   }
   if (parsedArgs.subcommand === PLUGIN_TYPE) {
-    await runExtensionCommand(parsedArgs, parsedArgs.subcommand, pluginConfig);
-    return {parser};
+    await runExtensionCommand(parsedArgs, pluginConfig);
+    return {};
   }
 
   if (parsedArgs.logFilters) {
@@ -243,31 +236,32 @@ async function init (args) {
   appiumDriver.driverConfig = driverConfig;
   await preflightChecks(parsedArgs, throwInsteadOfExit);
 
-  return {parser, appiumDriver, parsedArgs};
+  return /** @type {ServerInitResult} */({appiumDriver, parsedArgs, driverConfig, pluginConfig});
 }
 
 /**
- *
- * @param {ParsedArgs} [args]
- * @returns
+ * 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>}
  */
 async function main (args) {
-  const {parser, appiumDriver, parsedArgs} = await init(args);
+  const {appiumDriver, parsedArgs, pluginConfig, driverConfig} = /** @type {ServerInitResult} */(await init(args));
 
-  if (!appiumDriver || !parsedArgs) {
+  if (!appiumDriver || !parsedArgs || !pluginConfig || !driverConfig) {
     // if this branch is taken, we've run a different subcommand, so there's nothing
     // left to do here.
     return;
   }
 
-  const pluginClasses = getActivePlugins(parsedArgs, pluginConfig);
+  const pluginClasses = getActivePlugins(pluginConfig, parsedArgs.usePlugins);
   // set the active plugins on the umbrella driver so it can use them for commands
   appiumDriver.pluginClasses = pluginClasses;
 
-  await logStartupInfo(parser, parsedArgs);
+  await logStartupInfo(parsedArgs);
   let routeConfiguringFunction = makeRouter(appiumDriver);
 
-  const driverClasses = getActiveDrivers(parsedArgs, driverConfig);
+  const driverClasses = getActiveDrivers(driverConfig, parsedArgs.useDrivers);
   const serverUpdaters = getServerUpdaters(driverClasses, pluginClasses);
   const extraMethodMap = getExtraMethodMap(driverClasses, pluginClasses);
 
@@ -298,7 +292,6 @@ async function main (args) {
                 'to visit sites which could maliciously try to start Appium ' +
                 'sessions on your machine');
   }
-  // @ts-ignore
   appiumDriver.server = server;
   try {
     // configure as node on grid, if necessary
@@ -343,11 +336,32 @@ if (require.main === module) {
 }
 
 // everything below here is intended to be a public API.
-export { main, init };
-export { APPIUM_HOME } from './extension-config';
-export { getSchema, validate, finalizeSchema } from './schema/schema';
 export { readConfigFile } from './config-file';
+export { finalizeSchema, getSchema, validate } from './schema/schema';
+export { main, init, resolveAppiumHome };
 
 /**
  * @typedef {import('../types/types').ParsedArgs} ParsedArgs
  */
+
+/**
+ * @typedef {import('../types/types').PartialArgs} PartialArgs
+ * @typedef {import('./extension/manifest').DriverType} DriverType
+ * @typedef {import('./extension/manifest').PluginType} PluginType
+ * @typedef {import('./extension/manifest').DriverClass} DriverClass
+ * @typedef {import('./extension/manifest').PluginClass} PluginClass
+ */
+
+/**
+ * @typedef { {} } ExtCommandInitResult
+ */
+
+/**
+ * @typedef ServerInitData
+ * @property {AppiumDriver} appiumDriver - The Appium driver
+ * @property {ParsedArgs} parsedArgs - The parsed arguments
+ */
+
+/**
+ * @typedef {ServerInitData & import('./extension').ExtensionConfigs} ServerInitResult
+ */

package/lib/schema/arg-spec.js

@@ -73,6 +73,11 @@ export class ArgSpec {
    */
   dest;
 
+  /**
+   * The same as {@link ArgSpec.dest} but without the leading `<extType>.<extName>.` prefix.
+   */
+  rawDest;
+
   /**
    * Whatever the default value of this argument is, as specified by the
    * `default` property of the schema.
@@ -100,10 +105,10 @@ export class ArgSpec {
 
     // if no explicit `dest` provided, just camelCase the name to avoid needing
     // to use bracket syntax when accessing props on the parsed args object.
-    const baseDest = _.camelCase(dest ?? name);
+    const rawDest = _.camelCase(dest ?? name);
 
     const destKeypath =
-      extType && extName ? [extType, extName, baseDest].join('.') : baseDest;
+      extType && extName ? [extType, extName, rawDest].join('.') : rawDest;
 
     this.defaultValue = defaultValue;
     this.name = name;
@@ -112,6 +117,7 @@ export class ArgSpec {
     this.arg = arg;
     this.dest = destKeypath;
     this.ref = ref;
+    this.rawDest = rawDest;
   }
 
   /**
@@ -170,7 +176,7 @@ export class ArgSpec {
   /**
    * When given the root ID of a schema for an extension (`<extType>-<normalizedExtName>.json`) Returns an object containing the extension type and the _normalized_ extension name.
    * @param {string} schemaId - Root schema ID
-   * @returns {{extType: ExtensionType|undefined, normalizedExtName: string|undefined}}
+   * @returns { {extType: ExtensionType|undefined, normalizedExtName: string|undefined} }
    */
   static extensionInfoFromRootSchemaId (schemaId) {
     const matches = schemaId.match(SCHEMA_ID_REGEXP);
@@ -210,7 +216,7 @@ export class ArgSpec {
 /**
  * Options for {@link ArgSpec.create}
  * @template D
- * @typedef {Object} ArgSpecOptions
+ * @typedef ArgSpecOptions
  * @property {string} [extName]
  * @property {ExtensionType} [extType]
  * @property {string} [dest]
@@ -218,5 +224,5 @@ export class ArgSpec {
  */
 
 /**
- * @typedef {import('../ext-config-io').ExtensionType} ExtensionType
+ * @typedef {import('../manifest').ExtensionType} ExtensionType
  */

package/lib/schema/cli-args.js

@@ -98,11 +98,9 @@ function makeDescription (schema) {
  * as understood by `argparse`.
  * @param {AppiumJSONSchema} subSchema - JSON schema for the option
  * @param {ArgSpec} argSpec - Argument spec tuple
- * @param {SubSchemaToArgDefOptions} [opts] - Options
  * @returns {[string[], import('argparse').ArgumentOptions]} Tuple of flag and options
  */
-function subSchemaToArgDef (subSchema, argSpec, opts = {}) {
-  const {overrides = {}} = opts;
+function subSchemaToArgDef (subSchema, argSpec) {
   let {
     type,
     appiumCliAliases,
@@ -110,7 +108,7 @@ function subSchemaToArgDef (subSchema, argSpec, opts = {}) {
     enum: enumValues,
   } = subSchema;
 
-  const {name, arg, dest} = argSpec;
+  const {name, arg} = argSpec;
 
   const aliases = [
     aliasToFlag(argSpec),
@@ -141,8 +139,10 @@ function subSchemaToArgDef (subSchema, argSpec, opts = {}) {
   // handle special cases for various types
   switch (type) {
     // booleans do not have a type per `ArgumentOptions`, just an "action"
+    // NOTE: due to limitations of `argparse`, we cannot provide fancy help text, and must rely on its internal error messaging.
     case TYPENAMES.BOOLEAN: {
-      argOpts.action = 'store_true';
+      argOpts.action = 'store_const';
+      argOpts.const = true;
       break;
     }
 
@@ -227,16 +227,6 @@ function subSchemaToArgDef (subSchema, argSpec, opts = {}) {
     }
   }
 
-  // overrides override anything we computed here.  usually this involves "custom types",
-  // which are really just transform functions.
-  argOpts = _.merge(
-    argOpts,
-    /** should the override keys correspond to the prop name or the prop dest?
-     * the prop dest is computed by {@link aliasToDest}.
-     */
-    overrides[dest] ?? {},
-  );
-
   return [aliases, argOpts];
 }
 
@@ -244,32 +234,19 @@ function subSchemaToArgDef (subSchema, argSpec, opts = {}) {
  * Converts the finalized, flattened schema representation into
  * ArgumentDefinitions for handoff to `argparse`.
  *
- * @param {ToParserArgsOptions} opts - Options
  * @throws If schema has not been added to ajv (via `finalizeSchema()`)
  * @returns {import('../cli/args').ArgumentDefinitions} A map of arryas of
  * aliases to `argparse` arguments; empty if no schema found
  */
-export function toParserArgs (opts = {}) {
+export function toParserArgs () {
   const flattened = flattenSchema().filter(({schema}) => !schema.appiumCliIgnored);
   return new Map(
     _.map(flattened, ({schema, argSpec}) =>
-      subSchemaToArgDef(schema, argSpec, opts),
+      subSchemaToArgDef(schema, argSpec),
     ),
   );
 }
 
-/**
- * Options for {@link toParserArgs}
- * @typedef {SubSchemaToArgDefOptions} ToParserArgsOptions
- */
-
-/**
- * Options for {@link subSchemaToArgDef}.
- * @typedef {Object} SubSchemaToArgDefOptions
- * @property {string} [prefix] - The prefix to use for the flag, if any
- * @property {{[key: string]: import('argparse').ArgumentOptions}} [overrides] - An object of key/value pairs to override the default values
- */
-
 /**
  * @template T
  * @typedef {import('ajv/dist/types').FormatValidator<T>} FormatValidator<T>

package/lib/schema/keywords.js

@@ -120,7 +120,7 @@ export const keywords = {
 /**
  * These are the custom keywords that Appium recognizes.
  *
- * @typedef {Object} AppiumJSONSchemaKeywords
+ * @typedef AppiumJSONSchemaKeywords
  * @property {string} [appiumCliDest]
  * @property {string} [appiumCliDescription]
  * @property {string[]} [appiumCliAliases]