appium-ios-device 3.1.12 → 3.1.13

package/lib/syslog/transformer/syslog-decoder.js

@@ -10,6 +10,40 @@ const ARROW_CODE = '^'.charCodeAt(0);
 const ARROW_SHIFT = 0x40;
 const ESCAPE_TOKEN_LEN = 4;
 
+export class SyslogDecoder extends Stream.Transform {
+  constructor(bufferLength) {
+    super({objectMode: true});
+    this.bufferIndex = 0;
+    this.buffer = Buffer.allocUnsafe(bufferLength);
+  }
+
+  _transform(data, encoding, onData) {
+    this._decode(data);
+    onData();
+  }
+
+  _decode(data) {
+    for (const byte of data) {
+      // Don't store the null delimiter messages
+      if (byte === NULL_DELIMITER_CODE) {
+        continue;
+      }
+      // Push the data when new line is sent
+      if (byte === NEW_LINE_CODE) {
+        if (this.bufferIndex > 0) {
+          const stringBuffer = Buffer.allocUnsafe(this.bufferIndex);
+          this.buffer.copy(stringBuffer, 0, 0, this.bufferIndex);
+          this.push(toUtf8String(stringBuffer), 'utf8');
+          this.bufferIndex = 0;
+        }
+        continue;
+      }
+      this.buffer[this.bufferIndex] = byte;
+      this.bufferIndex++;
+    }
+  }
+}
+
 /**
  * Unescapes utf8-encoded characters, so the output looks
  * like a valid string. See https://github.com/appium/appium/issues/14476
@@ -19,7 +53,7 @@ const ESCAPE_TOKEN_LEN = 4;
  * @returns {string} The unescaped string or the same string if no unescaping
  * is necessary.
  */
-function toUtf8String(logBuffer) {
+export function toUtf8String(logBuffer) {
   const parseUtf8Bytes = (start) => {
     let cursor = start;
     const token = new Uint8Array(ESCAPE_TOKEN_LEN);
@@ -57,39 +91,4 @@ function toUtf8String(logBuffer) {
   return Buffer.from(utf8Codes).toString('utf8');
 }
 
-class SyslogDecoder extends Stream.Transform {
-  constructor(bufferLength) {
-    super({objectMode: true});
-    this.bufferIndex = 0;
-    this.buffer = Buffer.allocUnsafe(bufferLength);
-  }
-
-  _transform(data, encoding, onData) {
-    this._decode(data);
-    onData();
-  }
-
-  _decode(data) {
-    for (const byte of data) {
-      // Don't store the null delimiter messages
-      if (byte === NULL_DELIMITER_CODE) {
-        continue;
-      }
-      // Push the data when new line is sent
-      if (byte === NEW_LINE_CODE) {
-        if (this.bufferIndex > 0) {
-          const stringBuffer = Buffer.allocUnsafe(this.bufferIndex);
-          this.buffer.copy(stringBuffer, 0, 0, this.bufferIndex);
-          this.push(toUtf8String(stringBuffer), 'utf8');
-          this.bufferIndex = 0;
-        }
-        continue;
-      }
-      this.buffer[this.bufferIndex] = byte;
-      this.bufferIndex++;
-    }
-  }
-}
-
-export {SyslogDecoder, toUtf8String};
 export default SyslogDecoder;

package/lib/testmanagerd/index.js

@@ -1,18 +1,11 @@
 import {InstrumentService} from '../instrument';
 
-const TESTMANAGERD_SERVICE_NAME_VERSION_14 = 'com.apple.testmanagerd.lockdown.secure';
-const TESTMANAGERD_SERVICE_NAME = 'com.apple.testmanagerd.lockdown';
+export const TESTMANAGERD_SERVICE_NAME_VERSION_14 = 'com.apple.testmanagerd.lockdown.secure';
+export const TESTMANAGERD_SERVICE_NAME = 'com.apple.testmanagerd.lockdown';
 
-const TESTMANAGERD_CHANNEL = Object.freeze({
+export const TESTMANAGERD_CHANNEL = Object.freeze({
   DAEMON_CONNECTION_INTERFACE:
     'dtxproxy:XCTestManager_IDEInterface:XCTestManager_DaemonConnectionInterface',
 });
 
-class TestmanagerdService extends InstrumentService {}
-
-export {
-  TestmanagerdService,
-  TESTMANAGERD_SERVICE_NAME_VERSION_14,
-  TESTMANAGERD_SERVICE_NAME,
-  TESTMANAGERD_CHANNEL,
-};
+export class TestmanagerdService extends InstrumentService {}

package/lib/usbmux/index.js

@@ -38,117 +38,7 @@ const DEFAULT_USBMUXD_HOST = '127.0.0.1';
 const PROG_NAME = name;
 const CLIENT_VERSION_STRING = `${name}-${version}`;
 
-function swap16(val) {
-  return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
-}
-
-/**
- * @typedef {Object} SocketOptions
- * @property {string} [socketPath="/var/run/usbmuxd"] The full path to the usbmuxd Unix socket
- * @property {number} [socketPort=27015] The port number to connect to
- * @property {string} [socketHost="127.0.0.1"] The host name to connect to
- * @property {number} [timeout=5000] The number of milliseconds to wait until
- * the socket is connected
- */
-
-/**
- * Connects a socket to usbmuxd service
- *
- * @param {SocketOptions} opts
- * @throws {Error} If there was an error while accessing the socket or
- * a connection error happened
- * @throws {B.TimeoutError} if connection timeout happened
- * @returns {Promise<NodeJS.Socket>} Connected socket instance
- */
-async function getDefaultSocket(opts = {}) {
-  const defaults = {
-    socketPath: DEFAULT_USBMUXD_SOCKET,
-    socketPort: DEFAULT_USBMUXD_PORT,
-    socketHost: DEFAULT_USBMUXD_HOST,
-    timeout: 5000,
-  };
-
-  const hasOpts = Object.values(opts).some((v) => !_.isNil(v));
-  const envOpts = hasOpts ? {} : getSocketOptionsFromEnv();
-
-  /**
-   * Retrieves the first non-nullable value of a socket option based on the provided key.
-   * The value is resolved in the following order of precedence:
-   * 1. The value from the `opts` parameter
-   * 2. The value from `USBMUXD_SOCKET_ADDRESS` environment variable
-   * 3. The default value from `defaults` object
-   *
-   * @template {keyof SocketOptions} K
-   * @param {K} key
-   * @returns {NonNullable<SocketOptions[K]>}
-   */
-  const getOption = (key) => opts[key] ?? envOpts[key] ?? defaults[key];
-
-  const socketPath = getOption('socketPath');
-  const socketPort = getOption('socketPort');
-  const socketHost = getOption('socketHost');
-  const timeout = opts.timeout ?? defaults.timeout;
-
-  const hasExplicitPath = !!(opts.socketPath || envOpts.socketPath);
-  const hasExplicitHostPort = !!(
-    opts.socketHost ||
-    opts.socketPort ||
-    envOpts.socketHost ||
-    envOpts.socketPort
-  );
-  const isWinOrWsl =
-    process.platform === 'win32' ||
-    (process.platform === 'linux' && /microsoft/i.test(os.release()));
-  const preferPath = hasExplicitPath || !(hasExplicitHostPort || isWinOrWsl);
-
-  let socket;
-
-  if (preferPath) {
-    const pathExists = await fs.exists(socketPath);
-    if (!pathExists) {
-      throw new Error(
-        `The usbmuxd socket path '${socketPath}' does not exist or is not accessible`,
-      );
-    }
-    socket = net.createConnection(socketPath);
-  } else {
-    socket = net.createConnection(socketPort, socketHost);
-  }
-
-  return await new B((resolve, reject) => {
-    socket.once('error', reject);
-    socket.once('connect', () => resolve(socket));
-  }).timeout(timeout ?? 5000);
-}
-
-/**
- * Get socket options from USBMUXD_SOCKET_ADDRESS environment variable
- *
- * @returns {Partial<SocketOptions>}
- */
-function getSocketOptionsFromEnv() {
-  let usbmuxdSocketAddress = process.env.USBMUXD_SOCKET_ADDRESS;
-  if (!usbmuxdSocketAddress) {
-    return {};
-  }
-  log.debug(
-    `Using USBMUXD_SOCKET_ADDRESS environment variable as default socket: ${usbmuxdSocketAddress}`,
-  );
-  // "unix:" or "UNIX:" prefix is optional for unix socket paths.
-  usbmuxdSocketAddress = usbmuxdSocketAddress.replace(/^(unix):/i, '');
-  const [ip, port] = usbmuxdSocketAddress.split(':');
-  if (ip && port) {
-    return {
-      socketHost: ip,
-      socketPort: parseInt(port, 10),
-    };
-  }
-  return {
-    socketPath: usbmuxdSocketAddress,
-  };
-}
-
-class Usbmux extends BaseServiceSocket {
+export class Usbmux extends BaseServiceSocket {
   constructor(socketClient) {
     super(socketClient);
 
@@ -344,5 +234,114 @@ class Usbmux extends BaseServiceSocket {
   }
 }
 
-export {Usbmux, getDefaultSocket};
+/**
+ * @typedef {Object} SocketOptions
+ * @property {string} [socketPath="/var/run/usbmuxd"] The full path to the usbmuxd Unix socket
+ * @property {number} [socketPort=27015] The port number to connect to
+ * @property {string} [socketHost="127.0.0.1"] The host name to connect to
+ * @property {number} [timeout=5000] The number of milliseconds to wait until
+ * the socket is connected
+ */
+
+/**
+ * Connects a socket to usbmuxd service
+ *
+ * @param {SocketOptions} opts
+ * @throws {Error} If there was an error while accessing the socket or
+ * a connection error happened
+ * @throws {B.TimeoutError} if connection timeout happened
+ * @returns {Promise<NodeJS.Socket>} Connected socket instance
+ */
+export async function getDefaultSocket(opts = {}) {
+  const defaults = {
+    socketPath: DEFAULT_USBMUXD_SOCKET,
+    socketPort: DEFAULT_USBMUXD_PORT,
+    socketHost: DEFAULT_USBMUXD_HOST,
+    timeout: 5000,
+  };
+
+  const hasOpts = Object.values(opts).some((v) => !_.isNil(v));
+  const envOpts = hasOpts ? {} : getSocketOptionsFromEnv();
+
+  /**
+   * Retrieves the first non-nullable value of a socket option based on the provided key.
+   * The value is resolved in the following order of precedence:
+   * 1. The value from the `opts` parameter
+   * 2. The value from `USBMUXD_SOCKET_ADDRESS` environment variable
+   * 3. The default value from `defaults` object
+   *
+   * @template {keyof SocketOptions} K
+   * @param {K} key
+   * @returns {NonNullable<SocketOptions[K]>}
+   */
+  const getOption = (key) => opts[key] ?? envOpts[key] ?? defaults[key];
+
+  const socketPath = getOption('socketPath');
+  const socketPort = getOption('socketPort');
+  const socketHost = getOption('socketHost');
+  const timeout = opts.timeout ?? defaults.timeout;
+
+  const hasExplicitPath = !!(opts.socketPath || envOpts.socketPath);
+  const hasExplicitHostPort = !!(
+    opts.socketHost ||
+    opts.socketPort ||
+    envOpts.socketHost ||
+    envOpts.socketPort
+  );
+  const isWinOrWsl =
+    process.platform === 'win32' ||
+    (process.platform === 'linux' && /microsoft/i.test(os.release()));
+  const preferPath = hasExplicitPath || !(hasExplicitHostPort || isWinOrWsl);
+
+  let socket;
+
+  if (preferPath) {
+    const pathExists = await fs.exists(socketPath);
+    if (!pathExists) {
+      throw new Error(
+        `The usbmuxd socket path '${socketPath}' does not exist or is not accessible`,
+      );
+    }
+    socket = net.createConnection(socketPath);
+  } else {
+    socket = net.createConnection(socketPort, socketHost);
+  }
+
+  return await new B((resolve, reject) => {
+    socket.once('error', reject);
+    socket.once('connect', () => resolve(socket));
+  }).timeout(timeout ?? 5000);
+}
+
+function swap16(val) {
+  return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
+}
+
+/**
+ * Get socket options from USBMUXD_SOCKET_ADDRESS environment variable
+ *
+ * @returns {Partial<SocketOptions>}
+ */
+function getSocketOptionsFromEnv() {
+  let usbmuxdSocketAddress = process.env.USBMUXD_SOCKET_ADDRESS;
+  if (!usbmuxdSocketAddress) {
+    return {};
+  }
+  log.debug(
+    `Using USBMUXD_SOCKET_ADDRESS environment variable as default socket: ${usbmuxdSocketAddress}`,
+  );
+  // "unix:" or "UNIX:" prefix is optional for unix socket paths.
+  usbmuxdSocketAddress = usbmuxdSocketAddress.replace(/^(unix):/i, '');
+  const [ip, port] = usbmuxdSocketAddress.split(':');
+  if (ip && port) {
+    return {
+      socketHost: ip,
+      socketPort: parseInt(port, 10),
+    };
+  }
+  return {
+    socketPath: usbmuxdSocketAddress,
+  };
+}
+
 export default Usbmux;

package/lib/usbmux/transformer/usbmux-decoder.js

@@ -3,7 +3,7 @@ import {plist} from '@appium/support';
 
 const HEADER_LENGTH = 16;
 
-class UsbmuxDecoder extends Stream.Transform {
+export class UsbmuxDecoder extends Stream.Transform {
   constructor() {
     super({objectMode: true});
   }
@@ -26,5 +26,4 @@ class UsbmuxDecoder extends Stream.Transform {
   }
 }
 
-export {UsbmuxDecoder};
 export default UsbmuxDecoder;

package/lib/usbmux/transformer/usbmux-encoder.js

@@ -5,7 +5,7 @@ const HEADER_LENGTH = 16;
 const VERSION = 1;
 const TYPE = 8;
 
-class UsbmuxEncoder extends Stream.Transform {
+export class UsbmuxEncoder extends Stream.Transform {
   constructor() {
     super({objectMode: true});
   }
@@ -38,5 +38,4 @@ class UsbmuxEncoder extends Stream.Transform {
   }
 }
 
-export {UsbmuxEncoder};
 export default UsbmuxEncoder;

package/lib/util/uuid/parse.ts

@@ -23,6 +23,11 @@ OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 import {validate} from './validate';
 
+/**
+ * Parses a UUID string into its 16-byte representation.
+ * @param {string} uuid
+ * @returns {Uint8Array}
+ */
 export function parse(uuid: string): Uint8Array {
   if (!validate(uuid)) {
     throw TypeError('Invalid UUID');

package/lib/util/uuid/stringify.ts

@@ -30,6 +30,27 @@ import _ from 'lodash';
  */
 const byteToHex: string[] = _.range(256).map((i) => (i + 0x100).toString(16).slice(1));
 
+/**
+ * Converts a 16-byte UUID array into canonical string form.
+ * @param {Uint8Array} arr
+ * @param {number} [offset=0]
+ * @returns {string}
+ */
+export function stringify(arr: Uint8Array, offset: number = 0): string {
+  const uuid = unsafeStringify(arr, offset);
+
+  // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
 function unsafeStringify(arr: Uint8Array, offset: number = 0): string {
   return (
     byteToHex[arr[offset + 0]] +
@@ -54,18 +75,3 @@ function unsafeStringify(arr: Uint8Array, offset: number = 0): string {
     byteToHex[arr[offset + 15]]
   ).toLowerCase();
 }
-
-export function stringify(arr: Uint8Array, offset: number = 0): string {
-  const uuid = unsafeStringify(arr, offset);
-
-  // Consistency check for valid UUID.  If this throws, it's likely due to one
-  // of the following:
-  // - One or more input array values don't map to a hex octet (leading to
-  // "undefined" in the uuid)
-  // - Invalid input values for the RFC `version` or `variant` fields
-  if (!validate(uuid)) {
-    throw TypeError('Stringified UUID is invalid');
-  }
-
-  return uuid;
-}

package/lib/util/uuid/validate.ts

@@ -24,6 +24,11 @@ OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 const REGEX =
   /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
 
+/**
+ * Checks whether a value is a supported UUID string.
+ * @param {unknown} uuid
+ * @returns {boolean}
+ */
 export function validate(uuid: unknown): boolean {
   return typeof uuid === 'string' && REGEX.test(uuid);
 }

package/lib/utilities.js

@@ -20,7 +20,7 @@ const LOCKDOWN_REQUEST = {
  * @returns {Promise<string[]>} The list of device serial numbers (udid) or
  * an empty list if no devices are connected
  */
-async function getConnectedDevices(socket = null) {
+export async function getConnectedDevices(socket = null) {
   let usbmux;
   try {
     usbmux = new Usbmux(socket || (await getDefaultSocket()));
@@ -44,7 +44,7 @@ async function getConnectedDevices(socket = null) {
  * @param {import('net').Socket?} socket the socket of usbmuxd. It will default to /var/run/usbmuxd if it is not passed
  * @returns {Promise<string>}
  */
-async function getOSVersion(udid, socket = null) {
+export async function getOSVersion(udid, socket = null) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     // lockdown doesn't need to be closed since it uses the same socket usbmux uses
@@ -62,7 +62,7 @@ async function getOSVersion(udid, socket = null) {
  * @param {import('net').Socket?} socket the socket of usbmuxd. It will default to /var/run/usbmuxd if it is not passed
  * @returns {Promise<string>}
  */
-async function getDeviceName(udid, socket = null) {
+export async function getDeviceName(udid, socket = null) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     // lockdown doesn't need to be closed since it uses the same socket usbmux uses
@@ -112,7 +112,7 @@ async function getDeviceName(udid, socket = null) {
  *   "WiFiAddress"=>"00:00:00:00:00:00"
  * }
  */
-async function getDeviceInfo(udid, socket = null) {
+export async function getDeviceInfo(udid, socket = null) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     const lockdown = await usbmux.connectLockdown(udid);
@@ -138,7 +138,7 @@ async function getDeviceInfo(udid, socket = null) {
  * @param {import('net').Socket?} socket the socket of usbmuxd. It will default to /var/run/usbmuxd if it is not passed
  * @returns {Promise<DeviceTime>}
  */
-async function getDeviceTime(udid, socket = null) {
+export async function getDeviceTime(udid, socket = null) {
   const lockdown = await startLockdownSession(udid, socket);
   try {
     return {
@@ -159,7 +159,7 @@ async function getDeviceTime(udid, socket = null) {
  * @param {import('net').Socket?} socket the socket of usbmuxd. It will default to /var/run/usbmuxd if it is not passed
  * @returns {Promise<import('./lockdown').Lockdown>}
  */
-async function startLockdownSession(udid, socket = null) {
+export async function startLockdownSession(udid, socket = null) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     const pairRecord = await usbmux.readPairRecord(udid);
@@ -188,7 +188,7 @@ async function startLockdownSession(udid, socket = null) {
  * @param {boolean} handshakeOnly only handshake and return the initial socket
  * @returns {Promise<import('tls').TLSSocket|Object>} The socket or the object returned in the callback if the callback function exists
  */
-async function connectPortSSL(udid, port, socket = null, handshakeOnly = false) {
+export async function connectPortSSL(udid, port, socket = null, handshakeOnly = false) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     const device = await usbmux.findDevice(udid);
@@ -219,7 +219,7 @@ async function connectPortSSL(udid, port, socket = null, handshakeOnly = false)
  * @param {import('net').Socket?} socket the socket of usbmuxd. It will default to /var/run/usbmuxd if it is not passed
  * @returns {Promise<NodeJS.Socket|Object>} The socket or the object returned in the callback if the callback function exists
  */
-async function connectPort(udid, port, socket = null) {
+export async function connectPort(udid, port, socket = null) {
   const usbmux = new Usbmux(socket || (await getDefaultSocket()));
   try {
     const device = await usbmux.findDevice(udid);
@@ -247,7 +247,7 @@ async function connectPort(udid, port, socket = null) {
  * @returns {Promise<import('./imagemounter/utils/list_developer_image').ImagePath>}
  * @throws If opts error or failed on searching image
  */
-async function fetchImageFromGithubRepo(udid, opts) {
+export async function fetchImageFromGithubRepo(udid, opts) {
   const osVersion = await getOSVersion(udid);
   if (!opts.githubRepo) {
     throw new TypeError(
@@ -262,7 +262,7 @@ async function fetchImageFromGithubRepo(udid, opts) {
  * @param {number} defaultSize - Default frame size in bytes
  * @returns {number} Configured frame size in bytes
  */
-function getMaxFrameLength(defaultSize) {
+export function getMaxFrameLength(defaultSize) {
   const envValue = process.env.APPIUM_IOS_MAX_FRAME_SIZE;
   if (envValue) {
     const parsed = _.parseInt(envValue, 10);
@@ -272,16 +272,3 @@ function getMaxFrameLength(defaultSize) {
   }
   return defaultSize;
 }
-
-export {
-  getConnectedDevices,
-  getOSVersion,
-  getDeviceName,
-  getDeviceTime,
-  startLockdownSession,
-  connectPort,
-  connectPortSSL,
-  getDeviceInfo,
-  fetchImageFromGithubRepo,
-  getMaxFrameLength,
-};

package/lib/webinspector/index.js

@@ -11,52 +11,12 @@ import {log} from '../logger';
 import {BaseServiceSocket} from '../base-service';
 import {getMaxFrameLength} from '../utilities';
 
-const WEB_INSPECTOR_SERVICE_NAME = 'com.apple.webinspector';
+export const WEB_INSPECTOR_SERVICE_NAME = 'com.apple.webinspector';
 const MAX_FRAME_SIZE = 20 * MB;
 
 const PARTIAL_MESSAGE_SUPPORT_DEPRECATION_VERSION = 11;
 
-function cleanupRpcObject(obj) {
-  const isArray = _.isArray(obj);
-  if (!_.isPlainObject(obj) && !isArray) {
-    return obj;
-  }
-
-  if (isArray) {
-    return _.filter(obj, _.negate(_.isNil));
-  }
-
-  return _.reduce(
-    obj,
-    (result, value, key) => {
-      if (!_.isNil(value)) {
-        result[key] = cleanupRpcObject(value);
-      }
-      return result;
-    },
-    {},
-  );
-}
-
-/**
- * @typedef {Object} WebInspectorServiceOptions
- *
- * @property {number} majorOsVersion The major version of the os version
- * @property {boolean} isSimulator Whether the device is a simulator
- * @property {number?} socketChunkSize Size, in bytes of the chunks to send to
- *                                     real device (only iOS 11+). Defaults to
- *                                     16384 bytes (the TLSSocket max).
- * @property {boolean} verbose Turn on logging of each message sent or received.
- *                             Defaults to false
- * @property {boolean} verboseHexDump Turn on logging of _all_ communication as
- *                                    hex dump. Defaults to false
- * @property {*} socketClient The socket client where the communication will happen
- * @property {number} maxFrameLength [20 * 1024 * 1024] - The maximum size
- *                                   in bytes of a single data frame
- *                                   in the device communication protocol
- */
-
-class WebInspectorService extends BaseServiceSocket {
+export class WebInspectorService extends BaseServiceSocket {
   /** @type {number|undefined} */
   _majorOsVersion;
 
@@ -244,5 +204,49 @@ class WebInspectorService extends BaseServiceSocket {
   }
 }
 
-export {WebInspectorService, WEB_INSPECTOR_SERVICE_NAME, cleanupRpcObject};
+/**
+ * @typedef {Object} WebInspectorServiceOptions
+ *
+ * @property {number} majorOsVersion The major version of the os version
+ * @property {boolean} isSimulator Whether the device is a simulator
+ * @property {number?} socketChunkSize Size, in bytes of the chunks to send to
+ *                                     real device (only iOS 11+). Defaults to
+ *                                     16384 bytes (the TLSSocket max).
+ * @property {boolean} verbose Turn on logging of each message sent or received.
+ *                             Defaults to false
+ * @property {boolean} verboseHexDump Turn on logging of _all_ communication as
+ *                                    hex dump. Defaults to false
+ * @property {*} socketClient The socket client where the communication will happen
+ * @property {number} maxFrameLength [20 * 1024 * 1024] - The maximum size
+ *                                   in bytes of a single data frame
+ *                                   in the device communication protocol
+ */
+
+/**
+ * Removes nullish values recursively from RPC payloads.
+ * @param {any} obj
+ * @returns {any}
+ */
+export function cleanupRpcObject(obj) {
+  const isArray = _.isArray(obj);
+  if (!_.isPlainObject(obj) && !isArray) {
+    return obj;
+  }
+
+  if (isArray) {
+    return _.filter(obj, _.negate(_.isNil));
+  }
+
+  return _.reduce(
+    obj,
+    (result, value, key) => {
+      if (!_.isNil(value)) {
+        result[key] = cleanupRpcObject(value);
+      }
+      return result;
+    },
+    {},
+  );
+}
+
 export default WebInspectorService;

package/lib/webinspector/transformer/webinspector-decoder.js

@@ -1,7 +1,7 @@
 import Stream from 'node:stream';
 import {plist} from '@appium/support';
 
-class WebInspectorDecoder extends Stream.Transform {
+export class WebInspectorDecoder extends Stream.Transform {
   constructor(maxLength) {
     super({objectMode: true});
     this._frameBufferIndex = 0;
@@ -49,5 +49,4 @@ class WebInspectorDecoder extends Stream.Transform {
   }
 }
 
-export {WebInspectorDecoder};
 export default WebInspectorDecoder;

package/lib/webinspector/transformer/webinspector-encoder.js

@@ -3,7 +3,7 @@ import {plist} from '@appium/support';
 
 const WEBINSPECTOR_PARTIAL_PACKET_CHUNK_SIZE = 8096;
 
-class WebInspectorEncoder extends Stream.Transform {
+export class WebInspectorEncoder extends Stream.Transform {
   constructor() {
     super({objectMode: true});
   }
@@ -25,5 +25,4 @@ class WebInspectorEncoder extends Stream.Transform {
   }
 }
 
-export {WebInspectorEncoder};
 export default WebInspectorEncoder;