appium 3.5.0 → 3.5.1

package/lib/bidi-commands.ts

@@ -1,5 +1,6 @@
-import _ from 'lodash';
+import {util} from '@appium/support';
 import {promisify} from 'node:util';
+import {capitalize} from './utils';
 import type {ExtensionCore} from '@appium/base-driver';
 import {errors} from '@appium/base-driver';
 import {BIDI_BASE_PATH, BIDI_EVENT_NAME} from './constants';
@@ -14,7 +15,7 @@ import type {
   ExternalDriver,
   StringRecord,
   Plugin,
-  BiDiResultData
+  BiDiResultData,
 } from '@appium/types';
 
 type ExtensionPlugin = Plugin & ExtensionCore;
@@ -30,7 +31,6 @@ interface InitBiDiSocketResult {
   logSocketErr: LogSocketError;
 }
 
-
 const MIN_WS_CODE_VAL = 1000;
 const MAX_WS_CODE_VAL = 1015;
 const WS_FALLBACK_CODE = 1011; // server encountered an error while fulfilling request
@@ -50,8 +50,9 @@ export function determineBiDiHost(address: string): string {
     return address;
   }
 
-  const nonLocalInterfaces = fetchInterfaces(address === V4_BROADCAST_IP ? 4 : 6)
-    .filter((iface) => !iface.internal);
+  const nonLocalInterfaces = fetchInterfaces(address === V4_BROADCAST_IP ? 4 : 6).filter(
+    (iface) => !iface.internal,
+  );
   return nonLocalInterfaces.length === 1 ? nonLocalInterfaces[0].address : os.hostname();
 }
 
@@ -63,13 +64,11 @@ export function determineBiDiHost(address: string): string {
 export function onBidiConnection(this: AppiumDriver, ws: WebSocket, req: IncomingMessage): void {
   try {
     const initBiDiSocketFunc: OmitThisParameter<typeof initBidiSocket> = initBidiSocket.bind(this);
-    const {bidiHandlerDriver, bidiHandlerPlugins, proxyClient, send, sendToProxy, logSocketErr} = initBiDiSocketFunc(
-      ws,
-      req,
-    );
+    const {bidiHandlerDriver, bidiHandlerPlugins, proxyClient, send, sendToProxy, logSocketErr} =
+      initBiDiSocketFunc(ws, req);
 
-    const initBidiSocketHandlersFunc: OmitThisParameter<typeof initBidiSocketHandlers> = initBidiSocketHandlers
-      .bind(this);
+    const initBidiSocketHandlersFunc: OmitThisParameter<typeof initBidiSocketHandlers> =
+      initBidiSocketHandlers.bind(this);
     initBidiSocketHandlersFunc(
       ws,
       proxyClient,
@@ -80,12 +79,12 @@ export function onBidiConnection(this: AppiumDriver, ws: WebSocket, req: Incomin
       logSocketErr,
     );
     if (proxyClient) {
-      const initBidiProxyHandlersFunc: OmitThisParameter<typeof initBidiProxyHandlers> = initBidiProxyHandlers
-        .bind(bidiHandlerDriver);
+      const initBidiProxyHandlersFunc: OmitThisParameter<typeof initBidiProxyHandlers> =
+        initBidiProxyHandlers.bind(bidiHandlerDriver);
       initBidiProxyHandlersFunc(proxyClient, ws, send);
     }
-    const initBidiEventListenersFunc: OmitThisParameter<typeof initBidiEventListeners> = initBidiEventListeners
-      .bind(this);
+    const initBidiEventListenersFunc: OmitThisParameter<typeof initBidiEventListeners> =
+      initBidiEventListeners.bind(this);
     initBidiEventListenersFunc(ws, bidiHandlerDriver, bidiHandlerPlugins, send);
   } catch (err) {
     this.log.error(err);
@@ -104,20 +103,21 @@ export async function onBidiMessage(
   this: AppiumDriver,
   data: Buffer,
   driver: AnyDriver,
-  plugins: ExtensionPlugin[]
+  plugins: ExtensionPlugin[],
 ): Promise<SuccessBiDiCommandResponse | ErrorBiDiCommandResponse> {
   let resMessage: SuccessBiDiCommandResponse | ErrorBiDiCommandResponse;
   let id: number = 0;
   const driverLog = driver.log;
-  const dataTruncated = _.truncate(data.toString(), {length: MAX_LOGGED_DATA_LENGTH});
+  const dataTruncated = util.truncateString(data.toString(), {length: MAX_LOGGED_DATA_LENGTH});
   try {
     let method: string;
     let params: StringRecord;
     try {
       ({id, method, params} = JSON.parse(data.toString('utf8')));
     } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
       throw new errors.InvalidArgumentError(
-        `Could not parse Bidi command '${dataTruncated}': ${err.message}`,
+        `Could not parse Bidi command '${dataTruncated}': ${message}`,
       );
     }
     driverLog.info(`--> BIDI message #${id}`);
@@ -131,7 +131,12 @@ export async function onBidiMessage(
         `Missing params for BiDi operation in '${dataTruncated}`,
       );
     }
-    const executeWrappedCommand = wrapCommandWithPlugins(driver as ExtensionCore, plugins, method, params);
+    const executeWrappedCommand = wrapCommandWithPlugins(
+      driver as ExtensionCore,
+      plugins,
+      method,
+      params,
+    );
     const result = await executeWrappedCommand();
     resMessage = {
       id,
@@ -139,15 +144,24 @@ export async function onBidiMessage(
       result,
     };
   } catch (err) {
-    resMessage = _.has(err, 'bidiErrObject')
-      ? err.bidiErrObject(id)
-      : {
+    if (
+      err !== null &&
+      typeof err === 'object' &&
+      'bidiErrObject' in err &&
+      typeof (err as {bidiErrObject: unknown}).bidiErrObject === 'function'
+    ) {
+      resMessage = (
+        err as {bidiErrObject: (msgId: number) => ErrorBiDiCommandResponse}
+      ).bidiErrObject(id);
+    } else {
+      resMessage = {
         id,
         type: 'error',
         error: errors.UnknownError.error(),
-        message: (err as Error).message,
-        stacktrace: (err as Error).stack,
+        message: err instanceof Error ? err.message : String(err),
+        stacktrace: err instanceof Error ? err.stack : undefined,
       };
+    }
   }
   driverLog.info(`<-- BIDI message #${id}`);
   return resMessage;
@@ -191,11 +205,19 @@ export function cleanupBidiSockets(this: AppiumDriver, sessionId: string): void
   delete this.bidiProxyClients[sessionId];
 }
 
-function wrapCommandWithPlugins(driver: ExtensionCore, plugins: ExtensionCore[], method: string, params: StringRecord): () => Promise<BiDiResultData> {
+function wrapCommandWithPlugins(
+  driver: ExtensionCore,
+  plugins: ExtensionCore[],
+  method: string,
+  params: StringRecord,
+): () => Promise<BiDiResultData> {
   const [moduleName, methodName] = method.split('.');
   let next = async () => await driver.executeBidiCommand(method, params);
   for (const plugin of plugins.filter((p) => p.doesBidiCommandExist(moduleName, methodName))) {
-    next = ((_next) => async () => await plugin.executeBidiCommand(method, params, _next, driver))(next);
+    next = (
+      (_next) => async () =>
+        await plugin.executeBidiCommand(method, params, _next, driver)
+    )(next);
   }
   return next;
 }
@@ -207,7 +229,11 @@ function wrapCommandWithPlugins(driver: ExtensionCore, plugins: ExtensionCore[],
  * @param ws The websocket connection object
  * @param req The connection pathname, which might include the session id
  */
-function initBidiSocket(this: AppiumDriver, ws: WebSocket, req: IncomingMessage): InitBiDiSocketResult {
+function initBidiSocket(
+  this: AppiumDriver,
+  ws: WebSocket,
+  req: IncomingMessage,
+): InitBiDiSocketResult {
   const pathname = req.url;
   if (!pathname) {
     throw new Error('Invalid connection request: pathname missing from request');
@@ -260,22 +286,24 @@ function initBidiSocket(this: AppiumDriver, ws: WebSocket, req: IncomingMessage)
         throw new Error(
           `Got request for ${driverName} to proxy bidi connections to upstream socket with ` +
             `url ${bidiProxyUrl}, but this was not a valid url`,
-          {cause: e}
+          {cause: e},
         );
       }
-      this.log.info(`Bidi connection for ${driverName} will be proxied to ${bidiProxyUrl}. ` +
-                    `Plugins will not handle bidi commands`);
+      this.log.info(
+        `Bidi connection for ${driverName} will be proxied to ${bidiProxyUrl}. ` +
+          `Plugins will not handle bidi commands`,
+      );
       proxyClient = new WebSocket(bidiProxyUrl);
       this.bidiProxyClients[sessionId] = proxyClient;
     } else {
-      bidiHandlerPlugins.push(...this.pluginsForSession(sessionId) as ExtensionPlugin[]);
+      bidiHandlerPlugins.push(...(this.pluginsForSession(sessionId) as ExtensionPlugin[]));
     }
   } else {
     this.log.info('Bidi websocket connection made to main server');
     // no need to store the socket connection if it's to the main server since it will just
     // stay open as long as the server itself is and will close when the server closes.
     bidiHandlerDriver = this; // eslint-disable-line @typescript-eslint/no-this-alias
-    bidiHandlerPlugins.push(...this.pluginsForSession() as ExtensionPlugin[]);
+    bidiHandlerPlugins.push(...(this.pluginsForSession() as ExtensionPlugin[]));
   }
 
   const driverLog = bidiHandlerDriver.log;
@@ -287,13 +315,15 @@ function initBidiSocket(this: AppiumDriver, ws: WebSocket, req: IncomingMessage)
   // 1. Make it async-await friendly
   // 2. Do some logging if there's a send error
   const sendFactory = (socket: WebSocket) => {
-    const socketSend = promisify(socket.send.bind(socket)) as (data: string | Buffer) => Promise<void>;
+    const socketSend = promisify(socket.send.bind(socket)) as (
+      data: string | Buffer,
+    ) => Promise<void>;
     return async (data: string | Buffer) => {
       try {
         await assertIsOpen(socket);
         await socketSend(data);
       } catch (err) {
-        logSocketErr(err);
+        logSocketErr(err instanceof Error ? err : new Error(String(err)));
       }
     };
   };
@@ -338,8 +368,8 @@ function initBidiProxyHandlers(
       `Upstream bidi socket closed connection (code ${code}, reason: '${reason}'). ` +
         `Closing proxy connection to client`,
     );
-    const intCode: number = _.isNumber(code) ? (code as number) : parseInt(code, 10);
-    if (_.isNaN(intCode) || intCode < MIN_WS_CODE_VAL || intCode > MAX_WS_CODE_VAL) {
+    const intCode: number = typeof code === 'number' ? (code as number) : parseInt(code, 10);
+    if (Number.isNaN(intCode) || intCode < MIN_WS_CODE_VAL || intCode > MAX_WS_CODE_VAL) {
       driverLog.warn(
         `Received code ${code} from upstream socket, but this is not a valid ` +
           `websocket code. Rewriting to ${WS_FALLBACK_CODE} for ws compatibility`,
@@ -417,7 +447,7 @@ function initBidiSocketHandlers(
     }
 
     const eventLogCounts = BIDI_EVENTS_MAP.get(bidiHandlerDriver);
-    if (!_.isEmpty(eventLogCounts)) {
+    if (!util.isEmpty(eventLogCounts)) {
       driverLog.debug(`BiDi events statistics: ${JSON.stringify(eventLogCounts, null, 2)}`);
     }
   });
@@ -444,19 +474,31 @@ function initBidiEventListeners(
   const eventLogCounts: Record<string, number> = BIDI_EVENTS_MAP.get(bidiHandlerDriver) ?? {};
   BIDI_EVENTS_MAP.set(bidiHandlerDriver, eventLogCounts);
   const eventListenerFactory = (extType: 'driver' | 'plugin', ext: ExtensionCore) => {
-    const eventListener = async ({context, method, params = {}}) => {
+    const eventListener = async ({
+      context,
+      method,
+      params = {},
+    }: {
+      context?: string;
+      method: string;
+      params?: StringRecord;
+    }) => {
       // if the driver didn't specify a context, use the empty context
       if (!context) {
         context = '';
       }
       if (!method || !params) {
-        ext.log?.warn( // some old plugins might not have the `log` property
-          `${_.capitalize(extType)} emitted a bidi event that was malformed. Require method and params keys ` +
-            `(with optional context). But instead received: ${_.truncate(JSON.stringify({
-              context,
-              method,
-              params,
-            }), {length: MAX_LOGGED_DATA_LENGTH})}`,
+        ext.log?.warn(
+          // some old plugins might not have the `log` property
+          `${capitalize(extType)} emitted a bidi event that was malformed. Require method and params keys ` +
+            `(with optional context). But instead received: ${util.truncateString(
+              JSON.stringify({
+                context,
+                method,
+                params,
+              }),
+              {length: MAX_LOGGED_DATA_LENGTH},
+            )}`,
         );
         return;
       }
@@ -472,14 +514,15 @@ function initBidiEventListeners(
       }
 
       const eventSubs = bidiHandlerDriver.bidiEventSubs[method];
-      if (_.isArray(eventSubs) && eventSubs.includes(context)) {
+      if (Array.isArray(eventSubs) && eventSubs.includes(context)) {
         if (method in eventLogCounts) {
           ++eventLogCounts[method];
         } else {
-          ext.log?.debug( // some old plugins might not have the `log` property
+          ext.log?.debug(
+            // some old plugins might not have the `log` property
             `<-- BIDI EVENT ${method} (context: '${context}', ` +
-            `params: ${_.truncate(JSON.stringify(params), {length: MAX_LOGGED_DATA_LENGTH})}). ` +
-            `All further similar events won't be logged.`,
+              `params: ${util.truncateString(JSON.stringify(params), {length: MAX_LOGGED_DATA_LENGTH})}). ` +
+              `All further similar events won't be logged.`,
           );
           eventLogCounts[method] = 1;
         }
@@ -490,17 +533,17 @@ function initBidiEventListeners(
     };
     return eventListener;
   };
-  bidiHandlerDriver.eventEmitter.on(BIDI_EVENT_NAME, eventListenerFactory('driver', bidiHandlerDriver as ExtensionCore));
+  bidiHandlerDriver.eventEmitter.on(
+    BIDI_EVENT_NAME,
+    eventListenerFactory('driver', bidiHandlerDriver as ExtensionCore),
+  );
   for (const plugin of bidiHandlerPlugins) {
     // some old plugins might not have the eventEmitter property
     plugin.eventEmitter?.on(BIDI_EVENT_NAME, eventListenerFactory('plugin', plugin));
   }
 }
 
-async function assertIsOpen(
-  ws: WebSocket,
-  timeoutMs: number = 5000,
-): Promise<WebSocket> {
+async function assertIsOpen(ws: WebSocket, timeoutMs: number = 5000): Promise<WebSocket> {
   if (ws.readyState === ws.OPEN) {
     return ws;
   }
@@ -513,12 +556,15 @@ async function assertIsOpen(
   // The socket is in CONNECTING state. Wait up to `timeoutMs` until it is open
   try {
     await new Promise((resolve, reject) => {
-      setTimeout(() => reject(
-        new Error(
-          `The BiDi web socket at ${ws.url} did not ` +
-          `open after ${timeoutMs}ms timeout`
-        )
-      ), timeoutMs);
+      setTimeout(
+        () =>
+          reject(
+            new Error(
+              `The BiDi web socket at ${ws.url} did not ` + `open after ${timeoutMs}ms timeout`,
+            ),
+          ),
+        timeoutMs,
+      );
       ws.once('error', reject);
       errorListener = reject;
       ws.once('open', resolve);

package/lib/bootstrap/appium-initializer.ts

@@ -1,8 +1,8 @@
 import {init as logsinkInit} from '../logsink';
 import {log as logger} from '../logger';
 import {util, env} from '@appium/support';
-import _ from 'lodash';
 import type {DriverOpts} from '@appium/types';
+import {defaultsDeep} from '../utils';
 import {AppiumDriver, type AppiumDriverConstraints} from '../appium';
 import {runExtensionCommand} from '../cli/extension';
 import {runSetupCommand} from '../cli/setup-command';
@@ -88,7 +88,9 @@ export class AppiumInitializer {
   private async parsePreConfigArgs<
     Cmd extends CliCommand,
     SubCmd extends CliExtensionSubcommand | CliCommandSetupSubcommand | void,
-  >(args?: Args<Cmd, SubCmd>): Promise<{preConfigArgs: PreConfigArgs; throwInsteadOfExit: boolean}> {
+  >(
+    args?: Args<Cmd, SubCmd>,
+  ): Promise<{preConfigArgs: PreConfigArgs; throwInsteadOfExit: boolean}> {
     const parser = await getParser();
     let throwInsteadOfExit = false;
 
@@ -97,7 +99,10 @@ export class AppiumInitializer {
         throwInsteadOfExit = true;
         delete args.throwInsteadOfExit;
       }
-      const preConfigArgs = {...args, subcommand: args.subcommand ?? SERVER_SUBCOMMAND} as PreConfigArgs;
+      const preConfigArgs = {
+        ...args,
+        subcommand: args.subcommand ?? SERVER_SUBCOMMAND,
+      } as PreConfigArgs;
       ArgParser.normalizeServerArgs(preConfigArgs);
       return {preConfigArgs, throwInsteadOfExit};
     }
@@ -106,7 +111,7 @@ export class AppiumInitializer {
   }
 
   private assertConfigFileOk(configResult: Awaited<ReturnType<typeof readConfigFile>>): void {
-    if (!_.isEmpty(configResult.errors)) {
+    if (!util.isEmpty(configResult.errors)) {
       throw new Error(
         `Errors in config file ${configResult.filepath}:\n ${configResult.reason ?? configResult.errors}`,
       );
@@ -122,15 +127,20 @@ export class AppiumInitializer {
     appiumHomeSourceName: string,
   ): Promise<InitResult<Cmd>> {
     const defaults = getDefaultsForSchema(false);
-    const serverArgs = _.defaultsDeep(
+    const serverArgs = defaultsDeep(
       {},
-      preConfigArgs,
-      configResult.config?.server,
-      defaults,
-    ) as ParsedArgs<CliCommandServer>;
+      preConfigArgs as Record<string, unknown>,
+      configResult.config?.server as Record<string, unknown> | undefined,
+      defaults as Record<string, unknown>,
+    ) as unknown as ParsedArgs<CliCommandServer>;
 
     if (preConfigArgs.showConfig) {
-      showConfig(getNonDefaultServerArgs(preConfigArgs as Args), configResult, defaults, serverArgs);
+      showConfig(
+        getNonDefaultServerArgs(preConfigArgs as Args),
+        configResult,
+        defaults,
+        serverArgs,
+      );
       return {} as InitResult<Cmd>;
     }
 
@@ -167,19 +177,17 @@ export class AppiumInitializer {
     if (!serverArgs.logFilters) {
       return;
     }
-    const {issues, rules} = await logger.unwrap().loadSecureValuesPreprocessingRules(serverArgs.logFilters);
-    const argToLog = _.truncate(JSON.stringify(serverArgs.logFilters), {
-      length: 150,
-    });
-    if (!_.isEmpty(issues)) {
+    const {issues, rules} = await logger
+      .unwrap()
+      .loadSecureValuesPreprocessingRules(serverArgs.logFilters);
+    const argToLog = util.truncateString(JSON.stringify(serverArgs.logFilters), {length: 150});
+    if (!util.isEmpty(issues)) {
       throw new Error(
         `The log filtering rules config ${argToLog} has issues: ` + JSON.stringify(issues, null, 2),
       );
     }
-    if (_.isEmpty(rules)) {
-      logger.warn(
-        `Found no log filtering rules in the ${argToLog} config. ` + `Is that expected?`,
-      );
+    if (util.isEmpty(rules)) {
+      logger.warn(`Found no log filtering rules in the ${argToLog} config. ` + `Is that expected?`);
     } else {
       logger.info(`Loaded ${util.pluralize('filtering rule', rules.length, true)}`);
     }

package/lib/bootstrap/appium-main-runner.ts

@@ -1,5 +1,5 @@
 import {log as logger} from '../logger';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import type {AppiumServer} from '@appium/types';
 import {getActivePlugins, getActiveDrivers} from '../extension';
 import registerNode from './grid-v3-register';
@@ -37,12 +37,16 @@ export class AppiumMainRunner {
   async run<
     Cmd extends CliCommand = CliCommandServer,
     SubCmd extends CliExtensionSubcommand | CliCommandSetupSubcommand | void = void,
-  >(initResult: InitResult<Cmd>, args?: Args<Cmd, SubCmd>): Promise<Cmd extends CliCommandServer ? AppiumServer : void> {
-    if (_.isEmpty(initResult)) {
+  >(
+    initResult: InitResult<Cmd>,
+    args?: Args<Cmd, SubCmd>,
+  ): Promise<Cmd extends CliCommandServer ? AppiumServer : void> {
+    if (util.isEmpty(initResult)) {
       return undefined as Cmd extends CliCommandServer ? AppiumServer : void;
     }
 
-    const {appiumDriver, pluginConfig, driverConfig, parsedArgs, appiumHome} = initResult as ServerInitData;
+    const {appiumDriver, pluginConfig, driverConfig, parsedArgs, appiumHome} =
+      initResult as ServerInitData;
 
     const pluginClasses = await getActivePlugins(
       pluginConfig,

package/lib/bootstrap/config-file.ts

@@ -1,8 +1,9 @@
 import type {IOutputError} from '@sidvind/better-ajv-errors';
 import type {ErrorObject, SchemaObject} from 'ajv';
 import {lilconfig, type LoaderSync, type LilconfigResult} from 'lilconfig';
-import _ from 'lodash';
+import {util} from '@appium/support';
 import * as yaml from 'yaml';
+import {camelCase, getPath, mapKeys, mapValues} from '../utils';
 import type {AppiumConfig, NormalizedAppiumConfig} from '@appium/types';
 import {getSchema, validate} from '../schema/schema';
 import {formatErrors} from '../schema/format-errors';
@@ -48,7 +49,7 @@ type LilconfigAsyncSearcher = ReturnType<typeof lilconfig>;
  */
 export async function readConfigFile(
   filepath?: string,
-  opts: ReadConfigFileOptions = {}
+  opts: ReadConfigFileOptions = {},
 ): Promise<ReadConfigFileResult> {
   const lc = lilconfig('appium', {
     loaders: {
@@ -67,7 +68,7 @@ export async function readConfigFile(
     try {
       let configResult: ReadConfigFileResult;
       const errors = validate(result.config) as ErrorObject[];
-      if (_.isEmpty(errors)) {
+      if (util.isEmpty(errors)) {
         configResult = {...result, errors};
       } else {
         const reason = formatErrors(errors, result.config as Record<string, unknown>, {
@@ -98,19 +99,31 @@ export async function readConfigFile(
 export function normalizeConfig(config: AppiumConfig): NormalizedAppiumConfig {
   const schema = getSchema();
 
-  const isSchemaTypeObject = (schemaObj: SchemaObject | Record<string, unknown> | undefined): boolean =>
-    Boolean((schemaObj as SchemaObject | undefined)?.properties || (schemaObj as SchemaObject | undefined)?.type === 'object');
+  const isSchemaTypeObject = (
+    schemaObj: SchemaObject | Record<string, unknown> | undefined,
+  ): boolean =>
+    Boolean(
+      (schemaObj as SchemaObject | undefined)?.properties ||
+      (schemaObj as SchemaObject | undefined)?.type === 'object',
+    );
 
   const normalize = (rootConfig: AppiumConfig, section?: string): Record<string, unknown> => {
-    const obj = _.isUndefined(section)
-      ? rootConfig
-      : (_.get(rootConfig, section, rootConfig) as Record<string, unknown>);
-
-    const mappedObj = _.mapKeys(obj, (_v, prop) =>
-      _.get(schema, `properties.server.properties[${prop}].appiumCliDest`, _.camelCase(prop))
+    const obj =
+      section === undefined
+        ? rootConfig
+        : (getPath(rootConfig, section, rootConfig) as Record<string, unknown>);
+
+    const mappedObj = mapKeys(obj as Record<string, unknown>, (_v, prop) =>
+      String(
+        getPath(
+          schema,
+          `properties.server.properties.${prop}.appiumCliDest`,
+          camelCase(String(prop)),
+        ),
+      ),
     );
 
-    return _.mapValues(mappedObj, (value, property) => {
+    return mapValues(mappedObj, (value, property) => {
       const nextSection = section ? `${section}.${property}` : property;
       return isSchemaTypeObject((schema as any).properties?.[property])
         ? normalize(rootConfig, nextSection)
@@ -130,7 +143,7 @@ function yamlLoader(filepath: string, content: string): unknown {
   } catch (e) {
     throw new Error(
       `The YAML config at '${filepath}' cannot be loaded. Original error: ${(e as Error).message}`,
-      {cause: e}
+      {cause: e},
     );
   }
 }
@@ -147,7 +160,7 @@ function jsonLoader(filepath: string, content: string): unknown {
     rawConfig.delete(filepath);
     throw new Error(
       `The JSON config at '${filepath}' cannot be loaded. Original error: ${(e as Error).message}`,
-      {cause: e}
+      {cause: e},
     );
   }
 }
@@ -155,13 +168,17 @@ function jsonLoader(filepath: string, content: string): unknown {
 /**
  * Loads a config file from an explicit path
  */
-async function loadConfigFile(lc: LilconfigAsyncSearcher, filepath: string): Promise<LilconfigResult> {
+async function loadConfigFile(
+  lc: LilconfigAsyncSearcher,
+  filepath: string,
+): Promise<LilconfigResult> {
   try {
     // removing "await" will cause any rejection to _not_ be caught in this block!
     return await lc.load(filepath);
   } catch (err) {
     if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-      (err as NodeJS.ErrnoException).message = `Config file not found at user-provided path: ${filepath}`;
+      (err as NodeJS.ErrnoException).message =
+        `Config file not found at user-provided path: ${filepath}`;
       throw err;
     } else if (err instanceof SyntaxError) {
       // generally invalid JSON