react-native-web-serial-api 0.1.0 → 0.2.0

package/src/websocket/bridge.ts

@@ -0,0 +1,299 @@
+/**
+ * Server-side core of the WebSocket serial bridge — deliberately free of any
+ * `serialport`/`ws`/Node imports so it is unit-testable with fakes. The thin
+ * `bin/expose-serial.js` wrapper supplies the real `serialport` port and `ws`
+ * socket objects and calls {@link attachBridge} for each connection.
+ */
+import {
+  type ControlMessage,
+  type PortInfo,
+  parseControlMessage,
+} from './protocol';
+
+/** The subset of a `serialport` SerialPort that the bridge uses (callback API). */
+export interface SerialLike {
+  write(data: Uint8Array, cb?: (err?: Error | null) => void): void;
+  set(
+    opts: {dtr?: boolean; rts?: boolean; brk?: boolean},
+    cb?: (err?: Error | null) => void,
+  ): void;
+  get(
+    cb: (
+      err: Error | null,
+      signals?: {cts?: boolean; dsr?: boolean; dcd?: boolean; ri?: boolean},
+    ) => void,
+  ): void;
+  update(opts: {baudRate: number}, cb?: (err?: Error | null) => void): void;
+  flush(cb?: (err?: Error | null) => void): void;
+  drain(cb?: (err?: Error | null) => void): void;
+  close(cb?: (err?: Error | null) => void): void;
+  on(event: 'data', listener: (data: Uint8Array) => void): void;
+  on(event: 'error', listener: (err: Error) => void): void;
+  on(event: 'open' | 'close', listener: () => void): void;
+  removeListener(event: string, listener: (...args: never[]) => void): void;
+}
+
+/** The subset of a `ws` WebSocket that the bridge uses. */
+export interface WsLike {
+  send(data: string | Uint8Array): void;
+  on(
+    event: 'message',
+    listener: (data: unknown, isBinary: boolean) => void,
+  ): void;
+  on(event: 'close', listener: () => void): void;
+  on(event: 'error', listener: (err: Error) => void): void;
+}
+
+export type BridgeOptions = {
+  /** Whether the port forwards serial→client data before `startReading`. */
+  readingByDefault?: boolean;
+  /** Optional logger for diagnostics. */
+  log?: (message: string) => void;
+  /** Optional static metadata or callback exposed via `getPortInfo`. */
+  portInfo?: PortInfo | (() => PortInfo | null | undefined);
+};
+
+/** Normalise any binary payload (Buffer/ArrayBuffer/typed array) to bytes. */
+function toBytes(data: unknown): Uint8Array {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (Array.isArray(data)) {
+    return Uint8Array.from(data as number[]);
+  }
+  return new Uint8Array(0);
+}
+
+const errMessage = (e: unknown): string =>
+  e instanceof Error ? e.message : String(e);
+
+/**
+ * Wire a single WebSocket connection to a single serial port: binary frames are
+ * piped both ways, JSON control frames invoke the corresponding serial method
+ * and get a response, and the port's data/error/close are surfaced as frames.
+ * Returns a teardown function that detaches the serial listeners.
+ */
+export function attachBridge(
+  serial: SerialLike,
+  ws: WsLike,
+  options: BridgeOptions = {},
+): () => void {
+  let reading = options.readingByDefault ?? true;
+
+  const onData = (data: Uint8Array): void => {
+    if (reading) {
+      ws.send(toBytes(data));
+    }
+  };
+  const sendEvent = (event: 'open' | 'close' | 'error', error?: string): void =>
+    ws.send(JSON.stringify({type: 'event', event, ...(error ? {error} : {})}));
+  const onError = (err: Error): void => sendEvent('error', err.message);
+  const onOpen = (): void => sendEvent('open');
+  const onClose = (): void => sendEvent('close');
+
+  serial.on('data', onData);
+  serial.on('error', onError);
+  serial.on('open', onOpen);
+  serial.on('close', onClose);
+
+  const reply = (id: number, error: unknown, result: unknown = null): void =>
+    ws.send(
+      JSON.stringify({
+        type: 'response',
+        id,
+        error: error ? errMessage(error) : null,
+        result,
+      }),
+    );
+
+  const handleCommand = (msg: Extract<ControlMessage, {type: 'command'}>) => {
+    const {id, command} = msg;
+    const args = (msg.args ?? {}) as Record<string, number | boolean>;
+    switch (command) {
+      // Note: serialport can change the baud rate live; data-bits/parity/stop-bits
+      // are fixed at the rate the bridge process was started with.
+      case 'setLineCoding':
+      case 'setBaudRate':
+        serial.update({baudRate: Number(args.baudRate)}, e => reply(id, e));
+        break;
+      case 'setSignals': {
+        const set: {dtr?: boolean; rts?: boolean; brk?: boolean} = {};
+        if (typeof args.dtr === 'boolean') set.dtr = args.dtr;
+        if (typeof args.rts === 'boolean') set.rts = args.rts;
+        if (typeof args.brk === 'boolean') set.brk = args.brk;
+        serial.set(set, e => reply(id, e));
+        break;
+      }
+      case 'getSignals':
+        serial.get((e, s) =>
+          reply(
+            id,
+            e,
+            s
+              ? {cts: !!s.cts, dsr: !!s.dsr, dcd: !!s.dcd, ri: !!s.ri}
+              : {cts: false, dsr: false, dcd: false, ri: false},
+          ),
+        );
+        break;
+      case 'getPortInfo': {
+        const info =
+          typeof options.portInfo === 'function'
+            ? options.portInfo()
+            : options.portInfo;
+        reply(
+          id,
+          null,
+          info
+            ? {
+                usbVendorId: info.usbVendorId,
+                usbProductId: info.usbProductId,
+                serialNumber: info.serialNumber,
+              }
+            : null,
+        );
+        break;
+      }
+      case 'startReading':
+        reading = true;
+        reply(id, null);
+        break;
+      case 'stopReading':
+        reading = false;
+        reply(id, null);
+        break;
+      case 'flush':
+        serial.flush(e => reply(id, e));
+        break;
+      case 'drain':
+        serial.drain(e => reply(id, e));
+        break;
+      case 'break':
+        serial.set({brk: true}, () =>
+          setTimeout(
+            () => serial.set({brk: false}, e => reply(id, e)),
+            Number(args.duration ?? 100),
+          ),
+        );
+        break;
+      case 'close':
+        serial.close(e => reply(id, e));
+        break;
+      default:
+        reply(id, new Error(`unknown command: ${command}`));
+    }
+  };
+
+  ws.on('message', (data, isBinary) => {
+    if (isBinary) {
+      serial.write(toBytes(data), err => {
+        if (err) {
+          options.log?.(`serial write failed: ${errMessage(err)}`);
+        }
+      });
+      return;
+    }
+    const text =
+      typeof data === 'string' ? data : new TextDecoder().decode(toBytes(data));
+    const msg = parseControlMessage(text);
+    if (msg?.type === 'command') {
+      handleCommand(msg);
+    }
+  });
+
+  const teardown = (): void => {
+    serial.removeListener('data', onData as (...a: never[]) => void);
+    serial.removeListener('error', onError as (...a: never[]) => void);
+    serial.removeListener('open', onOpen as (...a: never[]) => void);
+    serial.removeListener('close', onClose as (...a: never[]) => void);
+  };
+  ws.on('close', teardown);
+  ws.on('error', err => options.log?.(`ws error: ${errMessage(err)}`));
+
+  return teardown;
+}
+
+// ── CLI argument parsing (pure, testable) ────────────────────────────────────
+
+export type BridgeArgs = {
+  port?: string;
+  baudRate: number;
+  wsPort: number;
+  host: string;
+  allowRemote: boolean;
+  help: boolean;
+};
+
+/** Parse `expose-serial` CLI args + env into a normalised options object. */
+export function parseBridgeArgs(
+  argv: readonly string[],
+  env: Record<string, string | undefined> = {},
+): BridgeArgs {
+  const args: Record<string, string | boolean> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const take = () => argv[++i];
+    switch (a) {
+      case '-p':
+      case '--port':
+        args.port = take();
+        break;
+      case '-b':
+      case '--baudrate':
+        args.baudRate = take();
+        break;
+      case '-w':
+      case '--ws-port':
+        args.wsPort = take();
+        break;
+      case '--host':
+        args.host = take();
+        break;
+      case '--allow-remote':
+        args.allowRemote = true;
+        break;
+      case '-h':
+      case '--help':
+        args.help = true;
+        break;
+    }
+  }
+
+  const allowRemote = args.allowRemote === true;
+  const host =
+    (args.host as string) ??
+    env.HOST ??
+    (allowRemote ? '0.0.0.0' : '127.0.0.1');
+
+  return {
+    port: (args.port as string) ?? env.SERIAL_PORT,
+    baudRate: Number(args.baudRate ?? env.BAUD_RATE ?? 115200),
+    wsPort: Number(args.wsPort ?? env.WS_PORT ?? 8080),
+    host,
+    allowRemote,
+    help: args.help === true,
+  };
+}
+
+export const USAGE = `expose-serial-websocket — bridge a serial port to a WebSocket
+
+Usage:
+  expose-serial-websocket --port <path> [--baudrate 115200] [--ws-port 8080]
+                          [--host 127.0.0.1] [--allow-remote]
+
+Options:
+  -p, --port <path>       Serial device (e.g. /dev/ttyUSB0, COM3)   [env SERIAL_PORT]
+  -b, --baudrate <n>      Baud rate (default 115200)                [env BAUD_RATE]
+  -w, --ws-port <n>       WebSocket port (default 8080)             [env WS_PORT]
+      --host <addr>       Listen address (default 127.0.0.1)        [env HOST]
+      --allow-remote      Bind 0.0.0.0 (exposes the port to the network!)
+  -h, --help              Show this help
+
+Connect from the app with:
+  new Serial(new WebSocketSerialTransport('ws://localhost:8080'))
+`;

package/src/websocket/index.ts

@@ -0,0 +1,38 @@
+/**
+ * Remote-serial-over-WebSocket entry point.
+ *
+ *   import {WebSocketSerialTransport}
+ *     from 'react-native-web-serial-api/websocket';
+ *
+ * Client side: `WebSocketSerialTransport` connects an app to a remote serial
+ * port. Server side: {@link attachBridge} pipes a WebSocket to a serial port,
+ * and {@link SimulatedDeviceToSerialLike} lets that "serial port" be an in-memory
+ * {@link SimulatedDevice} simulator (used by `testing/exposeSimulatedDevice`). The
+ * wire protocol is in {@link ./protocol}; the bridge core in {@link ./bridge}.
+ */
+
+// The bridge core + the in-memory device adapter, so a test can expose a
+// SimulatedDevice simulator over a WebSocket (see testing/exposeSimulatedDevice).
+export type {BridgeOptions, SerialLike, WsLike} from './bridge';
+export {attachBridge} from './bridge';
+export type {
+  CommandMessage,
+  CommandName,
+  ControlMessage,
+  EventMessage,
+  InputSignals,
+  LineCoding,
+  Parity,
+  PortInfo,
+  ResponseMessage,
+} from './protocol';
+export {
+  portInfoFromDevice,
+  SimulatedDeviceToSerialLike,
+} from './serial-device-bridge';
+export type {
+  WebSocketCtor,
+  WebSocketLike,
+  WebSocketSerialOptions,
+} from './WebSocketSerialTransport';
+export {WebSocketSerialTransport} from './WebSocketSerialTransport';

package/src/websocket/protocol.ts

@@ -0,0 +1,101 @@
+/**
+ * Wire protocol shared by the WebSocket serial bridge (Node, see
+ * {@link ./bridge}) and the client transport ({@link ./WebSocketSerialTransport}).
+ *
+ * A single WebSocket carries two kinds of frame:
+ *   - **binary** frames are raw serial bytes (client→bridge = data to write to the
+ *     port; bridge→client = data read from the port), and
+ *   - **text** frames are JSON control messages (this module).
+ *
+ * Control flow is request/response: the client tags each {@link CommandMessage}
+ * with an incrementing `id` and the bridge replies with a {@link ResponseMessage}
+ * carrying the same `id`. The bridge may also push unsolicited
+ * {@link EventMessage}s (port open/close/error).
+ */
+
+import type {Parity} from '../WebSerial';
+
+export type {Parity} from '../WebSerial';
+
+/** Connection parameters for `setLineCoding`. */
+export type LineCoding = {
+  baudRate: number;
+  dataBits?: number;
+  stopBits?: number;
+  parity?: Parity;
+};
+
+/** Input control-signal state returned by `getSignals`. */
+export type InputSignals = {
+  cts: boolean;
+  dsr: boolean;
+  dcd: boolean;
+  ri: boolean;
+};
+
+/** Optional serial-port metadata returned by `getPortInfo`. */
+export type PortInfo = {
+  usbVendorId?: number;
+  usbProductId?: number;
+  serialNumber?: string;
+};
+
+/** Every control command the bridge understands. */
+export type CommandName =
+  | 'setLineCoding'
+  | 'setBaudRate'
+  | 'setSignals'
+  | 'getSignals'
+  | 'getPortInfo'
+  | 'startReading'
+  | 'stopReading'
+  | 'flush'
+  | 'drain'
+  | 'break'
+  | 'close';
+
+/** client → bridge */
+export type CommandMessage = {
+  type: 'command';
+  id: number;
+  command: CommandName;
+  args?: Record<string, unknown>;
+};
+
+/** bridge → client, answering a {@link CommandMessage} with the same `id`. */
+export type ResponseMessage = {
+  type: 'response';
+  id: number;
+  error: string | null;
+  result?: unknown;
+};
+
+/** An unsolicited port lifecycle event the bridge emits to the client. */
+export type BridgeEventName = 'open' | 'close' | 'error';
+
+/** bridge → client */
+export type EventMessage = {
+  type: 'event';
+  event: BridgeEventName;
+  error?: string;
+};
+
+export type ControlMessage = CommandMessage | ResponseMessage | EventMessage;
+
+/** Parse a text frame into a {@link ControlMessage}, or null if it isn't one. */
+export function parseControlMessage(text: string): ControlMessage | null {
+  let value: unknown;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof value !== 'object' || value === null) {
+    return null;
+  }
+  const type = (value as {type?: unknown}).type;
+  if (type === 'command' || type === 'response' || type === 'event') {
+    return value as ControlMessage;
+  }
+  return null;
+}

package/src/websocket/serial-device-bridge.ts

@@ -0,0 +1,160 @@
+/**
+ * Adapt an in-memory {@link DeviceHandle} simulator to the
+ * `serialport`-style {@link SerialLike} that {@link attachBridge} consumes, so a
+ * test can expose a *simulated* device over a WebSocket and have a real app
+ * connect to it with `new WebSocketSerialTransport(url)`. This is what makes the
+ * *same* device-driving test run in Jest (in-memory) and on a device/emulator
+ * (over the socket).
+ *
+ * Pure — no `ws`/`serialport`/Node imports — so it unit-tests with the same
+ * `FakeWs` + `attachBridge` fakes the bridge core uses. The lazy-`ws` server
+ * wrapper lives in `react-native-web-serial-api/testing` (`exposeSimulatedDevice`).
+ *
+ * Mapping (host app ⇄ simulator):
+ *   - client binary frame → `write` → `device.onData`,
+ *   - `setLineCoding`/`setBaudRate` → `update` → opens the sim + starts reading,
+ *   - `setSignals` → `set` → `device.onHostSignals`,
+ *   - `getSignals` → `get` → the device's asserted input signals,
+ *   - `device.send(...)` → `'data'` → client binary frame,
+ *   - `getPortInfo` → {@link portInfoFromDevice}.
+ */
+
+import type {
+  DeviceHandle,
+  InMemorySerialTransport,
+} from '../testing/in-memory-serial-transport';
+import type {DataEvent, ErrorEvent} from '../transport';
+import type {SerialLike} from './bridge';
+import type {PortInfo} from './protocol';
+
+/** The bridge's `getPortInfo` metadata, taken from the device's USB identity. */
+export function portInfoFromDevice(device: DeviceHandle): PortInfo {
+  return {
+    usbVendorId: device.usbVendorId,
+    usbProductId: device.usbProductId,
+    serialNumber: device.serialNumber,
+  };
+}
+
+/**
+ * Build a {@link SerialLike} backed by `device` (already registered on
+ * `transport` via `addDevice`). One adapter per WebSocket connection; its
+ * transport subscriptions are released when the bridge tears down its listeners.
+ */
+export function SimulatedDeviceToSerialLike(
+  transport: InMemorySerialTransport,
+  device: DeviceHandle,
+): SerialLike {
+  const dataListeners = new Set<(data: Uint8Array) => void>();
+  const errorListeners = new Set<(err: Error) => void>();
+  const openListeners = new Set<() => void>();
+  const closeListeners = new Set<() => void>();
+
+  // The device's `send(...)` surfaces here as a transport data event; forward
+  // the bytes of *this* device to the bridge's 'data' listener.
+  const dataSub = transport.onData((e: DataEvent) => {
+    if (e.deviceId !== device.deviceId) return;
+    const bytes = Uint8Array.from(e.data);
+    for (const l of dataListeners) l(bytes);
+  });
+  const errorSub = transport.onError((e: ErrorEvent) => {
+    if (e.deviceId !== device.deviceId) return;
+    const err = new Error(e.error);
+    err.name = e.errorName ?? err.name;
+    for (const l of errorListeners) l(err);
+  });
+
+  const id = () => device.deviceId;
+  const port = () => device.portNumber;
+
+  /** Open the sim on first use (the app's open handshake), else just re-baud. */
+  const ensureOpen = async (baudRate: number): Promise<void> => {
+    if (device.isOpen) {
+      await transport.setParameters(id(), port(), {baudRate});
+      return;
+    }
+    await transport.open(id(), port(), {baudRate});
+    // The device only forwards `send(...)` while "reading"; the bridge's own
+    // startReading toggles client forwarding, not the device, so enable it here.
+    await transport.startReading(id(), port());
+    for (const l of openListeners) l();
+  };
+
+  const cleanupIfIdle = (): void => {
+    if (dataListeners.size === 0 && errorListeners.size === 0) {
+      dataSub.remove();
+      errorSub.remove();
+    }
+  };
+
+  return {
+    write(data, cb) {
+      transport.write(id(), port(), Array.from(data)).then(
+        () => cb?.(null),
+        err => cb?.(err as Error),
+      );
+    },
+    set(opts, cb) {
+      const ops: Array<Promise<void>> = [];
+      if (opts.dtr !== undefined)
+        ops.push(transport.setDTR(id(), port(), opts.dtr));
+      if (opts.rts !== undefined)
+        ops.push(transport.setRTS(id(), port(), opts.rts));
+      if (opts.brk !== undefined)
+        ops.push(transport.setBreak(id(), port(), opts.brk));
+      Promise.all(ops).then(
+        () => cb?.(null),
+        err => cb?.(err as Error),
+      );
+    },
+    get(cb) {
+      Promise.all([
+        transport.getCTS(id(), port()),
+        transport.getDSR(id(), port()),
+        transport.getCD(id(), port()),
+        transport.getRI(id(), port()),
+      ]).then(
+        ([cts, dsr, dcd, ri]) => cb(null, {cts, dsr, dcd, ri}),
+        err => cb(err as Error),
+      );
+    },
+    update(opts, cb) {
+      ensureOpen(opts.baudRate).then(
+        () => cb?.(null),
+        err => cb?.(err as Error),
+      );
+    },
+    flush(cb) {
+      cb?.(null);
+    },
+    drain(cb) {
+      cb?.(null);
+    },
+    close(cb) {
+      transport.close(id(), port()).then(
+        () => {
+          for (const l of closeListeners) l();
+          cb?.(null);
+        },
+        err => cb?.(err as Error),
+      );
+    },
+    on(event: string, listener: (...args: never[]) => void) {
+      if (event === 'data')
+        dataListeners.add(listener as (d: Uint8Array) => void);
+      else if (event === 'error')
+        errorListeners.add(listener as (e: Error) => void);
+      else if (event === 'open') openListeners.add(listener as () => void);
+      else if (event === 'close') closeListeners.add(listener as () => void);
+    },
+    removeListener(event: string, listener: (...args: never[]) => void) {
+      if (event === 'data')
+        dataListeners.delete(listener as (d: Uint8Array) => void);
+      else if (event === 'error')
+        errorListeners.delete(listener as (e: Error) => void);
+      else if (event === 'open') openListeners.delete(listener as () => void);
+      else if (event === 'close') closeListeners.delete(listener as () => void);
+      cleanupIfIdle();
+    },
+  };
+}

package/lib/commonjs/testing/install.js

@@ -1,54 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.installSerialMock = installSerialMock;
-var _UsbSerial = require("../UsbSerial");
-var _serialDevice = require("./serial-device");
-var _virtualSerial = require("./virtual-serial");
-/**
- * installSerialMock — point the library at a virtual device set in one call.
- *
- * Built for E2E: call it once at app startup, behind your own env/build flag, to
- * make `navigator.serial` / this library's `serial` talk to simulated
- * {@link SerialDevice}s instead of real USB hardware while a test driver
- * (Maestro, Detox, …) exercises the app on a device/emulator.
- *
- * @example
- * // index.js (debug/E2E build only)
- * import {installSerialMock, EchoDevice} from 'react-native-web-serial-api/testing';
- * installSerialMock({
- *   enabled: process.env.RNWS_SERIAL_MOCK === '1',
- *   devices: [new EchoDevice(), new MyThermometer()],
- * });
- */
-
-/** A device to register: a SerialDevice, optionally with transport options. */
-
-/**
- * Build a {@link VirtualSerialTransport} from `devices` and install it globally
- * via {@link setUsbSerial}. SerialDevices default to granted USB permission (so
- * they show up immediately); pass the `{device, options}` form to override.
- * Returns the transport (handy for driving devices in-test), or `null` when
- * disabled.
- */
-function installSerialMock(options) {
-  if (options.enabled === false) return null;
-  const transport = new _virtualSerial.VirtualSerialTransport(options.transport);
-  for (const entry of options.devices) {
-    if (entry instanceof _serialDevice.SerialDevice) {
-      transport.addDevice(entry, {
-        hasPermission: true
-      });
-    } else {
-      transport.addDevice(entry.device, {
-        hasPermission: true,
-        ...entry.options
-      });
-    }
-  }
-  (0, _UsbSerial.setUsbSerial)(transport);
-  return transport;
-}
-//# sourceMappingURL=install.js.map

package/lib/commonjs/testing/install.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_UsbSerial","require","_serialDevice","_virtualSerial","installSerialMock","options","enabled","transport","VirtualSerialTransport","entry","devices","SerialDevice","addDevice","hasPermission","device","setUsbSerial"],"sourceRoot":"../../../src","sources":["testing/install.ts"],"mappings":";;;;;;AAgBA,IAAAA,UAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AAKA,IAAAE,cAAA,GAAAF,OAAA;AAtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;;AAcA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,iBAAiBA,CAC/BC,OAAiC,EACF;EAC/B,IAAIA,OAAO,CAACC,OAAO,KAAK,KAAK,EAAE,OAAO,IAAI;EAE1C,MAAMC,SAAS,GAAG,IAAIC,qCAAsB,CAACH,OAAO,CAACE,SAAS,CAAC;EAC/D,KAAK,MAAME,KAAK,IAAIJ,OAAO,CAACK,OAAO,EAAE;IACnC,IAAID,KAAK,YAAYE,0BAAY,EAAE;MACjCJ,SAAS,CAACK,SAAS,CAACH,KAAK,EAAE;QAACI,aAAa,EAAE;MAAI,CAAC,CAAC;IACnD,CAAC,MAAM;MACLN,SAAS,CAACK,SAAS,CAACH,KAAK,CAACK,MAAM,EAAE;QAChCD,aAAa,EAAE,IAAI;QACnB,GAAGJ,KAAK,CAACJ;MACX,CAAC,CAAC;IACJ;EACF;EAEA,IAAAU,uBAAY,EAACR,SAAS,CAAC;EACvB,OAAOA,SAAS;AAClB","ignoreList":[]}

package/lib/commonjs/testing/serial-device.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["toBytes","data","Array","from","c","charCodeAt","Uint8Array","map","n","SerialDevice","host","_bind","send","raiseError","message","name","setSignals","signals","openOptions","deviceId","portNumber","onOpen","_options","onData","_data","onHostSignals","_signals","onClose","exports","EchoDevice","constructor","identity","usbVendorId","usbProductId","serialNumber","LineDevice","buffer","i","length","String","fromCharCode","nl","indexOf","line","slice","replace","onLine","SilentDevice"],"sourceRoot":"../../../src","sources":["testing/serial-device.ts"],"mappings":"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","ignoreList":[]}