appium 3.5.0 → 3.5.1

package/lib/inspector-commands.ts

@@ -1,4 +1,4 @@
-import _ from 'lodash';
+import {mapValues} from './utils';
 import {
   METHOD_MAP as BASE_METHOD_MAP,
   BIDI_COMMANDS as BASE_BIDI_COMMANDS,
@@ -24,25 +24,35 @@ import type {AppiumDriver} from './appium';
 /**
  * Returns available REST and BiDi commands for base, driver and plugins.
  */
-export async function listCommands(this: AppiumDriver, sessionId?: string): Promise<ListCommandsResponse> {
+export async function listCommands(
+  this: AppiumDriver,
+  sessionId?: string,
+): Promise<ListCommandsResponse> {
   let driverRestMethodMap: MethodMap<any> = {};
   let driverBiDiCommands: BidiModuleMap = {};
   let pluginRestMethodMaps: Record<string, MethodMap<any>> = {};
   let pluginBiDiCommands: Record<string, BidiModuleMap> = {};
   if (sessionId) {
-    const driverClass = this.driverForSession(sessionId)?.constructor as (DriverClass | undefined);
+    const driverClass = this.driverForSession(sessionId)?.constructor as DriverClass | undefined;
     driverRestMethodMap = driverClass?.newMethodMap ?? {};
     driverBiDiCommands = driverClass?.newBidiCommands ?? {};
-    const pluginClasses = this.pluginsForSession(sessionId)
-      .map((p) => p.constructor as PluginClass);
-    pluginRestMethodMaps = _.fromPairs(pluginClasses.map((c) => [c.name, c.newMethodMap ?? {}]));
-    pluginBiDiCommands = _.fromPairs(pluginClasses.map((c) => [c.name, c.newBidiCommands ?? {}]));
+    const pluginClasses = this.pluginsForSession(sessionId).map(
+      (p) => p.constructor as PluginClass,
+    );
+    pluginRestMethodMaps = Object.fromEntries(
+      pluginClasses.map((c) => [c.name, c.newMethodMap ?? {}]),
+    );
+    pluginBiDiCommands = Object.fromEntries(
+      pluginClasses.map((c) => [c.name, c.newBidiCommands ?? {}]),
+    );
   }
   return {
     rest: {
       base: methodMapToRestCommandsInfo(BASE_METHOD_MAP),
       driver: methodMapToRestCommandsInfo(driverRestMethodMap),
-      plugins: pluginRestMethodMaps ? _.mapValues(pluginRestMethodMaps, methodMapToRestCommandsInfo) : undefined,
+      plugins: pluginRestMethodMaps
+        ? mapValues(pluginRestMethodMaps, methodMapToRestCommandsInfo)
+        : undefined,
     },
     bidi: toBiDiCommandsMap(BASE_BIDI_COMMANDS, driverBiDiCommands, pluginBiDiCommands),
   };
@@ -51,33 +61,46 @@ export async function listCommands(this: AppiumDriver, sessionId?: string): Prom
 /**
  * Returns available execute methods exposed by driver and plugins.
  */
-export async function listExtensions(this: AppiumDriver, sessionId?: string): Promise<ListExtensionsResponse> {
+export async function listExtensions(
+  this: AppiumDriver,
+  sessionId?: string,
+): Promise<ListExtensionsResponse> {
   let driverExecuteMethodMap: ExecuteMethodMap<any> = {};
   let pluginExecuteMethodMaps: Record<string, ExecuteMethodMap<any>> = {};
   if (sessionId) {
-    const driverClass = this.driverForSession(sessionId)?.constructor as (DriverClass | undefined);
+    const driverClass = this.driverForSession(sessionId)?.constructor as DriverClass | undefined;
     driverExecuteMethodMap = driverClass?.executeMethodMap ?? {};
-    const pluginClasses = this.pluginsForSession(sessionId)
-      .map((p) => p.constructor as PluginClass);
-    pluginExecuteMethodMaps = _.fromPairs(pluginClasses.map((c) => [c.name, c.executeMethodMap ?? {}]));
+    const pluginClasses = this.pluginsForSession(sessionId).map(
+      (p) => p.constructor as PluginClass,
+    );
+    pluginExecuteMethodMaps = Object.fromEntries(
+      pluginClasses.map((c) => [c.name, c.executeMethodMap ?? {}]),
+    );
   }
   return {
     rest: {
       driver: executeMethodMapToCommandsInfo(driverExecuteMethodMap),
-      plugins: pluginExecuteMethodMaps ? _.mapValues(pluginExecuteMethodMaps, executeMethodMapToCommandsInfo) : undefined,
+      plugins: pluginExecuteMethodMaps
+        ? mapValues(pluginExecuteMethodMaps, executeMethodMapToCommandsInfo)
+        : undefined,
     },
   };
 }
 
-function toRestCommandParams(params: PayloadParams | undefined): RestCommandItemParam[] | undefined {
+function toRestCommandParams(
+  params: PayloadParams | undefined,
+): RestCommandItemParam[] | undefined {
   if (!params) {
     return;
   }
 
-  const toRestCommandItemParam = (x: any, isRequired: boolean): RestCommandItemParam | undefined => {
-    const isNameAnArray = _.isArray(x);
+  const toRestCommandItemParam = (
+    x: any,
+    isRequired: boolean,
+  ): RestCommandItemParam | undefined => {
+    const isNameAnArray = Array.isArray(x);
     const name = isNameAnArray ? x[0] : x;
-    if (!_.isString(name)) {
+    if (typeof name !== 'string') {
       return;
     }
 
@@ -93,22 +116,22 @@ function toRestCommandParams(params: PayloadParams | undefined): RestCommandItem
 
   const requiredParams: RestCommandItemParam[] = (params.required ?? [])
     .map((name: any) => toRestCommandItemParam(name, true))
-    .filter((x) => !_.isUndefined(x));
+    .filter((x): x is RestCommandItemParam => x !== undefined);
   const optionalParams: RestCommandItemParam[] = (params.optional ?? [])
     .map((name: any) => toRestCommandItemParam(name, false))
-    .filter((x) => !_.isUndefined(x));
+    .filter((x): x is RestCommandItemParam => x !== undefined);
   return requiredParams.length || optionalParams.length
     ? [...requiredParams, ...optionalParams]
     : undefined;
 }
 
-function methodMapToRestCommandsInfo (mm: MethodMap<any>): Record<string, RestMethodsToCommandsMap> {
+function methodMapToRestCommandsInfo(mm: MethodMap<any>): Record<string, RestMethodsToCommandsMap> {
   const res: Record<string, RestMethodsToCommandsMap> = {};
-  for (const [uriPath, methods] of _.toPairs(mm)) {
-    const methodsMap = {};
-    for (const [method, spec] of _.toPairs(methods)) {
-      methodsMap[method] = {
-        command: spec.command,
+  for (const [uriPath, methods] of Object.entries(mm)) {
+    const methodsMap: RestMethodsToCommandsMap = {};
+    for (const [method, spec] of Object.entries(methods)) {
+      methodsMap[String(method)] = {
+        command: spec.command as string,
         deprecated: spec.deprecated,
         info: spec.info,
         params: toRestCommandParams(spec.payloadParams),
@@ -121,7 +144,7 @@ function methodMapToRestCommandsInfo (mm: MethodMap<any>): Record<string, RestMe
 
 function executeMethodMapToCommandsInfo(emm: ExecuteMethodMap<any>): RestMethodsToCommandsMap {
   const result: RestMethodsToCommandsMap = {};
-  for (const [name, info] of _.toPairs(emm)) {
+  for (const [name, info] of Object.entries(emm)) {
     result[name] = {
       command: info.command as string,
       deprecated: info.deprecated,
@@ -135,17 +158,22 @@ function executeMethodMapToCommandsInfo(emm: ExecuteMethodMap<any>): RestMethods
 function toBiDiCommandsMap(
   baseModuleMap: BidiModuleMap,
   driverModuleMap: BidiModuleMap,
-  pluginModuleMaps: Record<string, BidiModuleMap>
+  pluginModuleMaps: Record<string, BidiModuleMap>,
 ): BiDiCommandsMap {
-  const toBiDiCommandParams = (params: BidiMethodParams | undefined): BiDiCommandItemParam[] | undefined => {
+  const toBiDiCommandParams = (
+    params: BidiMethodParams | undefined,
+  ): BiDiCommandItemParam[] | undefined => {
     if (!params) {
       return;
     }
 
-    const toBiDiCommandItemParam = (x: any, isRequired: boolean): BiDiCommandItemParam | undefined => {
-      const isNameAnArray = _.isArray(x);
+    const toBiDiCommandItemParam = (
+      x: any,
+      isRequired: boolean,
+    ): BiDiCommandItemParam | undefined => {
+      const isNameAnArray = Array.isArray(x);
       const name = isNameAnArray ? x[0] : x;
-      if (!_.isString(name)) {
+      if (typeof name !== 'string') {
         return;
       }
 
@@ -161,20 +189,22 @@ function toBiDiCommandsMap(
 
     const requiredParams: BiDiCommandItemParam[] = (params.required ?? [])
       .map((name) => toBiDiCommandItemParam(name, true))
-      .filter((x) => !_.isUndefined(x));
+      .filter((x): x is BiDiCommandItemParam => x !== undefined);
     const optionalParams: BiDiCommandItemParam[] = (params.optional ?? [])
       .map((name) => toBiDiCommandItemParam(name, false))
-      .filter((x) => !_.isUndefined(x));
+      .filter((x): x is BiDiCommandItemParam => x !== undefined);
     return requiredParams.length || optionalParams.length
       ? [...requiredParams, ...optionalParams]
       : undefined;
   };
 
-  const moduleMapToBiDiCommandsInfo = (mm: BidiModuleMap): Record<string, BiDiCommandNamesToInfosMap> => {
+  const moduleMapToBiDiCommandsInfo = (
+    mm: BidiModuleMap,
+  ): Record<string, BiDiCommandNamesToInfosMap> => {
     const res: Record<string, BiDiCommandNamesToInfosMap> = {};
-    for (const [domain, commands] of _.toPairs(mm)) {
-      const commandsMap = {};
-      for (const [name, spec] of _.toPairs(commands)) {
+    for (const [domain, commands] of Object.entries(mm)) {
+      const commandsMap: BiDiCommandNamesToInfosMap = {};
+      for (const [name, spec] of Object.entries(commands)) {
         commandsMap[name] = {
           command: spec.command,
           deprecated: spec.deprecated,
@@ -190,6 +220,8 @@ function toBiDiCommandsMap(
   return {
     base: moduleMapToBiDiCommandsInfo(baseModuleMap),
     driver: moduleMapToBiDiCommandsInfo(driverModuleMap),
-    plugins: pluginModuleMaps ? _.mapValues(pluginModuleMaps, moduleMapToBiDiCommandsInfo) : undefined,
+    plugins: pluginModuleMaps
+      ? mapValues(pluginModuleMaps, moduleMapToBiDiCommandsInfo)
+      : undefined,
   };
-}
+}

package/lib/logsink.ts

@@ -4,8 +4,7 @@ import type {Logger, Logform} from 'winston';
 import type Transport from 'winston-transport';
 import globalLog from '@appium/logger';
 import {createLogger, format, transports} from 'winston';
-import {fs} from '@appium/support';
-import _ from 'lodash';
+import {fs, util} from '@appium/support';
 import {adler32} from './utils';
 import {LRUCache} from 'lru-cache';
 
@@ -78,17 +77,20 @@ export async function init(args: ParsedArgs): Promise<void> {
       prefixes.push(prefix);
     }
     let msg = message;
-    if (!_.isEmpty(prefixes)) {
+    if (!util.isEmpty(prefixes)) {
       const finalPrefix = prefixes
         .map(toDecoratedPrefix)
         .map((pfx) => (isLogColorEnabled(args) ? colorizePrefix(pfx) : pfx))
         .join('');
       msg = `${finalPrefix} ${msg}`;
     }
-    const winstonLevel = TO_WINSTON_LEVELS_MAP[level] || 'info';
+    const winstonLevel =
+      level in TO_WINSTON_LEVELS_MAP
+        ? TO_WINSTON_LEVELS_MAP[level as keyof typeof TO_WINSTON_LEVELS_MAP]
+        : 'info';
     try {
       (log as Logger)[winstonLevel as keyof Logger](msg);
-      if (_.isFunction(args.logHandler)) {
+      if (typeof args.logHandler === 'function') {
         args.logHandler(level, msg);
       }
     } catch (e) {
@@ -96,9 +98,9 @@ export async function init(args: ParsedArgs): Promise<void> {
       if (!reportedLoggerErrors.has(err.message) && process.stderr.writable) {
         // eslint-disable-next-line no-console
         console.error(
-          `The log message '${_.truncate(msg, {length: 30})}' cannot be written into ` +
+          `The log message '${util.truncateString(msg, {length: 30})}' cannot be written into ` +
             `one or more requested destinations: ${[...transportNames].join(', ')}. ` +
-            `Original error: ${err.message}`
+            `Original error: ${err.message}`,
         );
         reportedLoggerErrors.add(err.message);
       }
@@ -121,7 +123,7 @@ export function clear(): void {
 
 function createConsoleTransport(
   args: ParsedArgs,
-  logLvl: string
+  logLvl: string,
 ): transports.ConsoleTransportInstance {
   const opt: transports.ConsoleTransportOptions = {
     level: logLvl,
@@ -135,27 +137,17 @@ function createConsoleTransport(
   return new transports.Console(opt);
 }
 
-function createFileTransport(
-  args: ParsedArgs,
-  logLvl: string
-): transports.FileTransportInstance {
+function createFileTransport(args: ParsedArgs, logLvl: string): transports.FileTransportInstance {
   const opt: transports.FileTransportOptions = {
     filename: args.logFile,
     maxFiles: 1,
     level: logLvl,
-    format: format.combine(
-      stripColorFormat,
-      formatTimestamp(args),
-      formatLog(args, false),
-    ),
+    format: format.combine(stripColorFormat, formatTimestamp(args), formatLog(args, false)),
   };
   return new transports.File(opt);
 }
 
-function createHttpTransport(
-  args: ParsedArgs,
-  logLvl: string
-): transports.HttpTransportInstance {
+function createHttpTransport(args: ParsedArgs, logLvl: string): transports.HttpTransportInstance {
   let host = '127.0.0.1';
   let port = 9003;
 
@@ -209,7 +201,7 @@ async function createTransports(args: ParsedArgs): Promise<Transport[]> {
       // eslint-disable-next-line no-console
       console.log(
         `Tried to attach logging to file '${args.logFile}' but an error ` +
-          `occurred: ${err.message}`
+          `occurred: ${err.message}`,
       );
     }
   }
@@ -222,7 +214,7 @@ async function createTransports(args: ParsedArgs): Promise<Transport[]> {
       // eslint-disable-next-line no-console
       console.log(
         `Tried to attach logging to Http at ${args.webhook} but ` +
-          `an error occurred: ${err.message}`
+          `an error occurred: ${err.message}`,
       );
     }
   }
@@ -260,7 +252,7 @@ function formatLog(args: ParsedArgs, targetConsole: boolean): Logform.Format {
           delete infoCopy.timestamp;
         }
 
-        if (!_.isEmpty(contextInfo)) {
+        if (!util.isEmpty(contextInfo)) {
           infoCopy.context = {...contextInfo};
         }
 
@@ -308,11 +300,15 @@ export function stripColorCodes(text: string): string {
 }
 
 // Strip the color marking within messages (depends on stripColorCodes)
-const stripColorFormat = format(function stripColor(info: {level: string; message: unknown; [key: string]: unknown}) {
+const stripColorFormat = format(function stripColor(info: {
+  level: string;
+  message: unknown;
+  [key: string]: unknown;
+}) {
   return {
     ...info,
     level: stripColorCodes(info.level),
-    message: _.isString(info.message) ? stripColorCodes(info.message) : info.message,
+    message: typeof info.message === 'string' ? stripColorCodes(info.message) : info.message,
   };
 })();
 

package/lib/schema/arg-spec.ts

@@ -1,5 +1,5 @@
-import _ from 'lodash';
 import type {ExtensionType} from '@appium/types';
+import {camelCase, kebabCase} from '../utils';
 
 /**
  * The original ID of the Appium config schema.
@@ -45,7 +45,7 @@ export class ArgSpec<D = unknown> {
   constructor(name: string, {extType, extName, dest, defaultValue}: ArgSpecOptions<D> = {}) {
     const arg = ArgSpec.toArg(name, extType, extName);
     const ref = ArgSpec.toSchemaRef(name, extType, extName);
-    const rawDest = _.camelCase(dest ?? name);
+    const rawDest = camelCase(dest ?? name);
     const destKeypath = extType && extName ? [extType, extName, rawDest].join('.') : rawDest;
 
     this.defaultValue = defaultValue;
@@ -83,9 +83,9 @@ export class ArgSpec<D = unknown> {
    * Return the unique CLI argument key for the argument.
    */
   static toArg(name: string, extType?: ExtensionType, extName?: string): string {
-    const properName = _.kebabCase(name.replace(/^--?/, ''));
+    const properName = kebabCase(name.replace(/^--?/, ''));
     if (extType && extName) {
-      return [extType, _.kebabCase(extName), properName].join('-');
+      return [extType, kebabCase(extName), properName].join('-');
     }
     return properName;
   }
@@ -94,15 +94,16 @@ export class ArgSpec<D = unknown> {
    * Normalizes a raw extension name (not including type).
    */
   static toNormalizedExtName(extName: string): string {
-    return _.kebabCase(extName);
+    return kebabCase(extName);
   }
 
   /**
    * Parse root schema ID (`<extType>-<normalizedExtName>.json`) to extension info.
    */
-  static extensionInfoFromRootSchemaId(
-    schemaId: string
-  ): {extType?: ExtensionType; normalizedExtName?: string} {
+  static extensionInfoFromRootSchemaId(schemaId: string): {
+    extType?: ExtensionType;
+    normalizedExtName?: string;
+  } {
     const matches = schemaId.match(SCHEMA_ID_REGEXP);
     if (matches?.groups) {
       const {extType, normalizedExtName} = matches.groups as {

package/lib/schema/cli-args-guards.ts

@@ -28,7 +28,7 @@ export function isServerCommandArgs(args: AnyArgs): args is Args<CliCommandServe
  * @param args - Parsed args before full subcommand-specific narrowing
  */
 export function isSetupCommandArgs(
-  args: AnyArgs
+  args: AnyArgs,
 ): args is Args<CliCommandSetup, CliCommandSetupSubcommand> {
   return args.subcommand === SETUP_SUBCOMMAND;
 }
@@ -39,7 +39,7 @@ export function isSetupCommandArgs(
  * @param args - Parsed args before full subcommand-specific narrowing
  */
 export function isExtensionCommandArgs(
-  args: AnyArgs
+  args: AnyArgs,
 ): args is Args<CliExtensionCommand, CliExtensionSubcommand> {
   return args.subcommand === DRIVER_TYPE || args.subcommand === PLUGIN_TYPE;
 }
@@ -50,7 +50,7 @@ export function isExtensionCommandArgs(
  * @param args - Parsed args before full subcommand-specific narrowing
  */
 export function isDriverCommandArgs(
-  args: AnyArgs
+  args: AnyArgs,
 ): args is Args<CliCommandDriver, CliExtensionSubcommand> {
   return args.subcommand === DRIVER_TYPE;
 }
@@ -61,7 +61,7 @@ export function isDriverCommandArgs(
  * @param args - Parsed args before full subcommand-specific narrowing
  */
 export function isPluginCommandArgs(
-  args: AnyArgs
+  args: AnyArgs,
 ): args is Args<CliCommandPlugin, CliExtensionSubcommand> {
   return args.subcommand === PLUGIN_TYPE;
 }

package/lib/schema/cli-args.ts

@@ -1,6 +1,7 @@
 import {ArgumentTypeError, type ArgumentOptions} from 'argparse';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {JSONSchema7, JSONSchema7TypeName} from 'json-schema';
+import {kebabCase} from '../utils';
 import {formatErrors} from './format-errors';
 import {flattenSchema, validate} from './schema';
 import {transformers, parseCsvLine} from './cli-transformers';
@@ -30,7 +31,7 @@ const SHORT_ARG_CUTOFF = 3;
 export function toParserArgs(): ArgumentDefinitions {
   const flattened = flattenSchema().filter(({schema}) => !schema.appiumCliIgnored);
   return new Map(
-    _.map(flattened, ({schema, argSpec}) => subSchemaToArgDef(schema as AppiumJSONSchema, argSpec))
+    flattened.map(({schema, argSpec}) => subSchemaToArgDef(schema as AppiumJSONSchema, argSpec)),
   );
 }
 
@@ -43,25 +44,25 @@ function aliasToFlag(argSpec: ArgSpec, alias?: string): string {
   const isShort = arg.length < SHORT_ARG_CUTOFF;
   if (extType && extName) {
     return isShort
-      ? `--${extType}-${_.kebabCase(extName)}-${arg}`
-      : `--${extType}-${_.kebabCase(extName)}-${_.kebabCase(arg)}`;
+      ? `--${extType}-${kebabCase(extName)}-${arg}`
+      : `--${extType}-${kebabCase(extName)}-${kebabCase(arg)}`;
   }
-  return isShort ? `-${arg}` : `--${_.kebabCase(arg)}`;
+  return isShort ? `-${arg}` : `--${kebabCase(arg)}`;
 }
 
-const screamingSnakeCase = _.flow(_.snakeCase, _.toUpper);
+const screamingSnakeCase = (s: string) => kebabCase(s).replace(/-/g, '_').toUpperCase();
 
 /**
  * Given an argument spec, return a validator/coercer function backed by schema validation.
  */
 function getSchemaValidator<Coerced>(
   {ref: schemaId}: ArgSpec,
-  coerce: (value: string) => Coerced = _.identity as (value: string) => Coerced
+  coerce: (value: string) => Coerced = (value) => value as Coerced,
 ): (value: string) => Coerced {
   return (value) => {
     const coerced = coerce(value);
     const errors = validate(coerced, schemaId);
-    if (_.isEmpty(errors)) {
+    if (util.isEmpty(errors)) {
       return coerced;
     }
     throw new ArgumentTypeError('\n\n' + formatErrors(errors, value, {schemaId}));
@@ -104,12 +105,15 @@ function subSchemaToArgDef(subSchema: AppiumJSONSchema, argSpec: ArgSpec): ArgDe
       break;
     }
     case TYPENAMES.OBJECT: {
-      argTypeFunction = _.flow(transformers.json, (o) => {
-        if (!_.isPlainObject(o)) {
-          throw new ArgumentTypeError(`'${_.truncate(String(o), {length: 100})}' must be a plain object`);
+      argTypeFunction = (value: string) => {
+        const o = transformers.json(value);
+        if (!util.isPlainObject(o)) {
+          throw new ArgumentTypeError(
+            `'${util.truncateString(String(o), {length: 100})}' must be a plain object`,
+          );
         }
         return o;
-      });
+      };
       break;
     }
     case TYPENAMES.ARRAY: {
@@ -121,7 +125,7 @@ function subSchemaToArgDef(subSchema: AppiumJSONSchema, argSpec: ArgSpec): ArgDe
       break;
     }
     case TYPENAMES.INTEGER: {
-      argTypeFunction = getSchemaValidator(argSpec, _.parseInt);
+      argTypeFunction = getSchemaValidator(argSpec, (v) => parseInt(v, 10));
       break;
     }
     case TYPENAMES.STRING: {
@@ -142,12 +146,13 @@ function subSchemaToArgDef(subSchema: AppiumJSONSchema, argSpec: ArgSpec): ArgDe
     if (type === TYPENAMES.ARRAY) {
       const csvTransformer = argTypeFunction as (x: string) => string[];
       argTypeFunction = (val) =>
-        _.flatMap(csvTransformer(val).map(transformers[appiumCliTransformer as AppiumCliTransformerName]));
+        csvTransformer(val).flatMap((item) =>
+          transformers[appiumCliTransformer as AppiumCliTransformerName](item),
+        );
     } else {
-      argTypeFunction = _.flow(
-        argTypeFunction ?? _.identity,
-        transformers[appiumCliTransformer as AppiumCliTransformerName]
-      ) as (value: string) => unknown;
+      const baseFn = argTypeFunction ?? ((value: string) => value);
+      const transformer = transformers[appiumCliTransformer as AppiumCliTransformerName];
+      argTypeFunction = (value: string) => transformer(baseFn(value) as string);
     }
   }
 
@@ -155,12 +160,12 @@ function subSchemaToArgDef(subSchema: AppiumJSONSchema, argSpec: ArgSpec): ArgDe
     argOpts.type = argTypeFunction;
   }
 
-  if (enumValues && !_.isEmpty(enumValues)) {
+  if (enumValues && !util.isEmpty(enumValues)) {
     if (type === TYPENAMES.STRING) {
       argOpts.choices = enumValues.map(String);
     } else {
       throw new TypeError(
-        `Problem with schema for ${arg}; \`enum\` is only supported for \`type: 'string'\``
+        `Problem with schema for ${arg}; \`enum\` is only supported for \`type: 'string'\``,
       );
     }
   }
@@ -168,4 +173,3 @@ function subSchemaToArgDef(subSchema: AppiumJSONSchema, argSpec: ArgSpec): ArgDe
   const finalAliases = aliases as [string] | [string, string];
   return [finalAliases, argOpts];
 }
-

package/lib/schema/cli-transformers.ts

@@ -31,7 +31,9 @@ export const transformers = {
       try {
         csv = readFileSync(csvOrPath, 'utf8');
       } catch (err) {
-        throw new ArgumentTypeError(`Could not read file '${csvOrPath}': ${(err as Error).message}`);
+        throw new ArgumentTypeError(
+          `Could not read file '${csvOrPath}': ${(err as Error).message}`,
+        );
       }
       loadedFromFile = true;
     }
@@ -56,7 +58,9 @@ export const transformers = {
         // Intentionally sync: argparse type hooks are synchronous.
         json = readFileSync(jsonOrPath, 'utf8');
       } catch (err) {
-        throw new ArgumentTypeError(`Could not read file '${jsonOrPath}': ${(err as Error).message}`);
+        throw new ArgumentTypeError(
+          `Could not read file '${jsonOrPath}': ${(err as Error).message}`,
+        );
       }
       loadedFromFile = true;
     }

package/lib/schema/format-errors.ts

@@ -31,7 +31,7 @@ export interface FormatConfigErrorsOptions {
 export function formatErrors(
   errors: ErrorObject[] = [],
   config: NormalizedAppiumConfig | Record<string, unknown> | string | undefined = {},
-  opts: FormatConfigErrorsOptions = {}
+  opts: FormatConfigErrorsOptions = {},
 ): string | IOutputError[] {
   if (errors && !errors.length) {
     throw new TypeError('Array of errors must be non-empty');