@technoculture/safeserial 0.1.0

package/deps/src/transport/platform/windows/windows_serial.cpp

@@ -0,0 +1,51 @@
+#include <safeserial/transport/serial_port.hpp>
+#include <windows.h>
+
+struct SerialPort::Impl {
+    HANDLE hSerial = INVALID_HANDLE_VALUE;
+};
+
+SerialPort::SerialPort() : pimpl(std::make_unique<Impl>()) {}
+SerialPort::~SerialPort() { close(); }
+
+bool SerialPort::open(const std::string& port, int baud) {
+    pimpl->hSerial = CreateFileA(port.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+    if (pimpl->hSerial == INVALID_HANDLE_VALUE) return false;
+
+    DCB dcb = {0};
+    dcb.DCBlength = sizeof(dcb);
+    GetCommState(pimpl->hSerial, &dcb);
+    dcb.BaudRate = CBR_115200;
+    dcb.ByteSize = 8;
+    dcb.StopBits = ONESTOPBIT;
+    dcb.Parity   = NOPARITY;
+    SetCommState(pimpl->hSerial, &dcb);
+
+    // TIMEOUTS - Prevents the app from freezing
+    COMMTIMEOUTS timeouts = { 0 };
+    timeouts.ReadIntervalTimeout = 50;
+    timeouts.ReadTotalTimeoutConstant = 50;
+    timeouts.ReadTotalTimeoutMultiplier = 10;
+    SetCommTimeouts(pimpl->hSerial, &timeouts);
+
+    return true;
+}
+
+int SerialPort::write(const std::vector<uint8_t>& data) {
+    DWORD written;
+    WriteFile(pimpl->hSerial, data.data(), (DWORD)data.size(), &written, NULL);
+    return (int)written;
+}
+
+int SerialPort::read(uint8_t* buffer, size_t size) {
+    DWORD read;
+    if (!ReadFile(pimpl->hSerial, buffer, (DWORD)size, &read, NULL)) return -1;
+    return (int)read;
+}
+
+void SerialPort::close() {
+    if (pimpl->hSerial != INVALID_HANDLE_VALUE) {
+        CloseHandle(pimpl->hSerial);
+        pimpl->hSerial = INVALID_HANDLE_VALUE;
+    }
+}

package/dist/index.d.mts

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'events';
+
+interface DataBridgeOptions {
+    baudRate?: number;
+    maxRetries?: number;
+    ackTimeoutMs?: number;
+    fragmentSize?: number;
+}
+/**
+ * ReliableDataBridge
+ *
+ * Thin wrapper around the native C++ DataBridge implementation.
+ */
+declare class ReliableDataBridge extends EventEmitter {
+    private bridge;
+    private isOpen_;
+    private options;
+    constructor(options?: DataBridgeOptions);
+    static open(port: string, baudOrOptions?: number | DataBridgeOptions, cb?: (data: Buffer) => void): Promise<ReliableDataBridge>;
+    open(port: string, baud?: number): Promise<boolean>;
+    close(): Promise<void>;
+    get isOpen(): boolean;
+    send(data: string | Buffer): Promise<void>;
+}
+
+interface SerialPort {
+    open(port: string, baud: number, callback: (data: Buffer) => void): boolean;
+    write(data: Buffer): number;
+    close(): boolean;
+    isOpen(): boolean;
+}
+declare const SerialPort: {
+    new (): SerialPort;
+};
+
+/**
+ * ResilientDataBridge - Connection-resilient wrapper
+ *
+ * Thin wrapper around the native C++ ResilientDataBridge implementation.
+ */
+
+interface ResilientOptions extends DataBridgeOptions {
+    /** Enable auto-reconnection (default: true) */
+    reconnect?: boolean;
+    /** Initial reconnect delay in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Maximum reconnect delay in ms (default: 30000) */
+    maxReconnectDelay?: number;
+    /** Maximum queue size before dropping old messages (default: 1000) */
+    maxQueueSize?: number;
+}
+interface ResilientEvents {
+    data: (data: Buffer) => void;
+    error: (error: Error) => void;
+    close: () => void;
+    disconnect: () => void;
+    reconnecting: (attempt: number, delay: number) => void;
+    reconnected: () => void;
+}
+declare class ResilientDataBridge extends EventEmitter {
+    private bridge;
+    private port;
+    private options;
+    private constructor();
+    /**
+     * Open a resilient serial connection.
+     *
+     * @param port - Serial port path
+     * @param options - Configuration including reconnection settings
+     */
+    static open(port: string, options?: ResilientOptions): Promise<ResilientDataBridge>;
+    open(): Promise<boolean>;
+    /**
+     * Send data with guaranteed delivery.
+     *
+     * @param data - Data to send
+     * @returns Promise that resolves when data is acknowledged
+     */
+    send(data: Buffer | string): Promise<void>;
+    /**
+     * Close the connection permanently.
+     */
+    close(): Promise<void>;
+    /** Current connection state */
+    get connected(): boolean;
+    /** Number of messages waiting in queue */
+    get queueLength(): number;
+    on<K extends keyof ResilientEvents>(event: K, listener: ResilientEvents[K]): this;
+    once<K extends keyof ResilientEvents>(event: K, listener: ResilientEvents[K]): this;
+    emit<K extends keyof ResilientEvents>(event: K, ...args: Parameters<ResilientEvents[K]>): boolean;
+}
+
+export { ReliableDataBridge as DataBridge, type DataBridgeOptions, SerialPort as RawSerialPort, ResilientDataBridge, type ResilientEvents, type ResilientOptions };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+import { EventEmitter } from 'events';
+
+interface DataBridgeOptions {
+    baudRate?: number;
+    maxRetries?: number;
+    ackTimeoutMs?: number;
+    fragmentSize?: number;
+}
+/**
+ * ReliableDataBridge
+ *
+ * Thin wrapper around the native C++ DataBridge implementation.
+ */
+declare class ReliableDataBridge extends EventEmitter {
+    private bridge;
+    private isOpen_;
+    private options;
+    constructor(options?: DataBridgeOptions);
+    static open(port: string, baudOrOptions?: number | DataBridgeOptions, cb?: (data: Buffer) => void): Promise<ReliableDataBridge>;
+    open(port: string, baud?: number): Promise<boolean>;
+    close(): Promise<void>;
+    get isOpen(): boolean;
+    send(data: string | Buffer): Promise<void>;
+}
+
+interface SerialPort {
+    open(port: string, baud: number, callback: (data: Buffer) => void): boolean;
+    write(data: Buffer): number;
+    close(): boolean;
+    isOpen(): boolean;
+}
+declare const SerialPort: {
+    new (): SerialPort;
+};
+
+/**
+ * ResilientDataBridge - Connection-resilient wrapper
+ *
+ * Thin wrapper around the native C++ ResilientDataBridge implementation.
+ */
+
+interface ResilientOptions extends DataBridgeOptions {
+    /** Enable auto-reconnection (default: true) */
+    reconnect?: boolean;
+    /** Initial reconnect delay in ms (default: 1000) */
+    reconnectDelay?: number;
+    /** Maximum reconnect delay in ms (default: 30000) */
+    maxReconnectDelay?: number;
+    /** Maximum queue size before dropping old messages (default: 1000) */
+    maxQueueSize?: number;
+}
+interface ResilientEvents {
+    data: (data: Buffer) => void;
+    error: (error: Error) => void;
+    close: () => void;
+    disconnect: () => void;
+    reconnecting: (attempt: number, delay: number) => void;
+    reconnected: () => void;
+}
+declare class ResilientDataBridge extends EventEmitter {
+    private bridge;
+    private port;
+    private options;
+    private constructor();
+    /**
+     * Open a resilient serial connection.
+     *
+     * @param port - Serial port path
+     * @param options - Configuration including reconnection settings
+     */
+    static open(port: string, options?: ResilientOptions): Promise<ResilientDataBridge>;
+    open(): Promise<boolean>;
+    /**
+     * Send data with guaranteed delivery.
+     *
+     * @param data - Data to send
+     * @returns Promise that resolves when data is acknowledged
+     */
+    send(data: Buffer | string): Promise<void>;
+    /**
+     * Close the connection permanently.
+     */
+    close(): Promise<void>;
+    /** Current connection state */
+    get connected(): boolean;
+    /** Number of messages waiting in queue */
+    get queueLength(): number;
+    on<K extends keyof ResilientEvents>(event: K, listener: ResilientEvents[K]): this;
+    once<K extends keyof ResilientEvents>(event: K, listener: ResilientEvents[K]): this;
+    emit<K extends keyof ResilientEvents>(event: K, ...args: Parameters<ResilientEvents[K]>): boolean;
+}
+
+export { ReliableDataBridge as DataBridge, type DataBridgeOptions, SerialPort as RawSerialPort, ResilientDataBridge, type ResilientEvents, type ResilientOptions };

package/dist/index.js

@@ -0,0 +1,202 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DataBridge: () => ReliableDataBridge,
+  RawSerialPort: () => SerialPort,
+  ResilientDataBridge: () => ResilientDataBridge
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/reliable.ts
+var import_events = require("events");
+
+// lib/native.ts
+var import_path = __toESM(require("path"));
+function loadAddon() {
+  const possiblePaths = [
+    `../prebuilds/${process.platform}-${process.arch}/safeserial_node.node`,
+    "../build/Release/safeserial_node.node"
+  ];
+  for (const p of possiblePaths) {
+    try {
+      return require(import_path.default.join(__dirname, p));
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Failed to load native addon. Run `npm run build` first.");
+}
+var addon = loadAddon();
+var SerialPort = addon.SerialPort;
+var NativeDataBridge = addon.DataBridge;
+var NativeResilientDataBridge = addon.ResilientDataBridge;
+var Packet = addon.Packet;
+var Reassembler = addon.Reassembler;
+
+// lib/reliable.ts
+var ReliableDataBridge = class _ReliableDataBridge extends import_events.EventEmitter {
+  bridge;
+  isOpen_ = false;
+  // Config
+  options;
+  constructor(options = {}) {
+    super();
+    this.bridge = new NativeDataBridge();
+    this.options = {
+      baudRate: options.baudRate ?? 115200,
+      maxRetries: options.maxRetries ?? 10,
+      ackTimeoutMs: options.ackTimeoutMs ?? 500,
+      fragmentSize: options.fragmentSize ?? 200
+    };
+    this.bridge.onData((data) => {
+      this.emit("data", data);
+    });
+  }
+  static async open(port, baudOrOptions, cb) {
+    let opts = {};
+    if (typeof baudOrOptions === "number") {
+      opts.baudRate = baudOrOptions;
+    } else if (baudOrOptions) {
+      opts = baudOrOptions;
+    }
+    const bridge = new _ReliableDataBridge(opts);
+    if (cb) bridge.on("data", cb);
+    await bridge.open(port);
+    return bridge;
+  }
+  async open(port, baud) {
+    if (this.isOpen_) return true;
+    const baudRate = baud ?? this.options.baudRate;
+    const success = this.bridge.open(port, baudRate);
+    if (!success) {
+      throw new Error(`Failed to open ${port}`);
+    }
+    this.isOpen_ = true;
+    return true;
+  }
+  async close() {
+    if (this.isOpen_) {
+      this.bridge.close();
+      this.isOpen_ = false;
+      this.emit("close");
+    }
+  }
+  get isOpen() {
+    return this.isOpen_;
+  }
+  async send(data) {
+    if (!this.isOpen_) throw new Error("Port not open");
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    this.bridge.send(
+      buf,
+      this.options.ackTimeoutMs,
+      this.options.maxRetries,
+      this.options.fragmentSize
+    );
+  }
+};
+
+// lib/resilient.ts
+var import_events2 = require("events");
+var ResilientDataBridge = class _ResilientDataBridge extends import_events2.EventEmitter {
+  bridge;
+  port;
+  options;
+  constructor(port, options) {
+    super();
+    this.port = port;
+    this.options = options;
+    this.bridge = new NativeResilientDataBridge(options);
+    this.bridge.onData((data) => this.emit("data", data));
+    this.bridge.onError((message) => this.emit("error", new Error(message)));
+    this.bridge.onDisconnect(() => this.emit("disconnect"));
+    this.bridge.onReconnecting(
+      (attempt, delay) => this.emit("reconnecting", attempt, delay)
+    );
+    this.bridge.onReconnected(() => this.emit("reconnected"));
+    this.bridge.onClose(() => this.emit("close"));
+  }
+  /**
+   * Open a resilient serial connection.
+   *
+   * @param port - Serial port path
+   * @param options - Configuration including reconnection settings
+   */
+  static async open(port, options = {}) {
+    const instance = new _ResilientDataBridge(port, options);
+    await instance.open();
+    return instance;
+  }
+  async open() {
+    return this.bridge.open(this.port);
+  }
+  /**
+   * Send data with guaranteed delivery.
+   *
+   * @param data - Data to send
+   * @returns Promise that resolves when data is acknowledged
+   */
+  async send(data) {
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    this.bridge.send(buffer);
+  }
+  /**
+   * Close the connection permanently.
+   */
+  async close() {
+    this.bridge.close();
+  }
+  /** Current connection state */
+  get connected() {
+    return this.bridge.isConnected();
+  }
+  /** Number of messages waiting in queue */
+  get queueLength() {
+    return this.bridge.queueLength();
+  }
+  // Type-safe event emitter
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataBridge,
+  RawSerialPort,
+  ResilientDataBridge
+});

package/dist/index.mjs

@@ -0,0 +1,170 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// lib/reliable.ts
+import { EventEmitter } from "events";
+
+// lib/native.ts
+import path from "path";
+function loadAddon() {
+  const possiblePaths = [
+    `../prebuilds/${process.platform}-${process.arch}/safeserial_node.node`,
+    "../build/Release/safeserial_node.node"
+  ];
+  for (const p of possiblePaths) {
+    try {
+      return __require(path.join(__dirname, p));
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Failed to load native addon. Run `npm run build` first.");
+}
+var addon = loadAddon();
+var SerialPort = addon.SerialPort;
+var NativeDataBridge = addon.DataBridge;
+var NativeResilientDataBridge = addon.ResilientDataBridge;
+var Packet = addon.Packet;
+var Reassembler = addon.Reassembler;
+
+// lib/reliable.ts
+var ReliableDataBridge = class _ReliableDataBridge extends EventEmitter {
+  bridge;
+  isOpen_ = false;
+  // Config
+  options;
+  constructor(options = {}) {
+    super();
+    this.bridge = new NativeDataBridge();
+    this.options = {
+      baudRate: options.baudRate ?? 115200,
+      maxRetries: options.maxRetries ?? 10,
+      ackTimeoutMs: options.ackTimeoutMs ?? 500,
+      fragmentSize: options.fragmentSize ?? 200
+    };
+    this.bridge.onData((data) => {
+      this.emit("data", data);
+    });
+  }
+  static async open(port, baudOrOptions, cb) {
+    let opts = {};
+    if (typeof baudOrOptions === "number") {
+      opts.baudRate = baudOrOptions;
+    } else if (baudOrOptions) {
+      opts = baudOrOptions;
+    }
+    const bridge = new _ReliableDataBridge(opts);
+    if (cb) bridge.on("data", cb);
+    await bridge.open(port);
+    return bridge;
+  }
+  async open(port, baud) {
+    if (this.isOpen_) return true;
+    const baudRate = baud ?? this.options.baudRate;
+    const success = this.bridge.open(port, baudRate);
+    if (!success) {
+      throw new Error(`Failed to open ${port}`);
+    }
+    this.isOpen_ = true;
+    return true;
+  }
+  async close() {
+    if (this.isOpen_) {
+      this.bridge.close();
+      this.isOpen_ = false;
+      this.emit("close");
+    }
+  }
+  get isOpen() {
+    return this.isOpen_;
+  }
+  async send(data) {
+    if (!this.isOpen_) throw new Error("Port not open");
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    this.bridge.send(
+      buf,
+      this.options.ackTimeoutMs,
+      this.options.maxRetries,
+      this.options.fragmentSize
+    );
+  }
+};
+
+// lib/resilient.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter2 {
+  bridge;
+  port;
+  options;
+  constructor(port, options) {
+    super();
+    this.port = port;
+    this.options = options;
+    this.bridge = new NativeResilientDataBridge(options);
+    this.bridge.onData((data) => this.emit("data", data));
+    this.bridge.onError((message) => this.emit("error", new Error(message)));
+    this.bridge.onDisconnect(() => this.emit("disconnect"));
+    this.bridge.onReconnecting(
+      (attempt, delay) => this.emit("reconnecting", attempt, delay)
+    );
+    this.bridge.onReconnected(() => this.emit("reconnected"));
+    this.bridge.onClose(() => this.emit("close"));
+  }
+  /**
+   * Open a resilient serial connection.
+   *
+   * @param port - Serial port path
+   * @param options - Configuration including reconnection settings
+   */
+  static async open(port, options = {}) {
+    const instance = new _ResilientDataBridge(port, options);
+    await instance.open();
+    return instance;
+  }
+  async open() {
+    return this.bridge.open(this.port);
+  }
+  /**
+   * Send data with guaranteed delivery.
+   *
+   * @param data - Data to send
+   * @returns Promise that resolves when data is acknowledged
+   */
+  async send(data) {
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    this.bridge.send(buffer);
+  }
+  /**
+   * Close the connection permanently.
+   */
+  async close() {
+    this.bridge.close();
+  }
+  /** Current connection state */
+  get connected() {
+    return this.bridge.isConnected();
+  }
+  /** Number of messages waiting in queue */
+  get queueLength() {
+    return this.bridge.queueLength();
+  }
+  // Type-safe event emitter
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+export {
+  ReliableDataBridge as DataBridge,
+  SerialPort as RawSerialPort,
+  ResilientDataBridge
+};

package/lib/index.ts

@@ -0,0 +1,23 @@
+
+/**
+ * SafeSerial - Guaranteed Reliable Serial Communication
+ * 
+ * TypeScript wrapper for the native Node-API addon.
+ * Provides a clean, async-friendly API for Electron applications.
+ */
+
+import { ReliableDataBridge, DataBridgeOptions } from './reliable';
+import { SerialPort } from './native';
+
+// Export the Reliable implementation as the default DataBridge
+export { ReliableDataBridge as DataBridge };
+export { DataBridgeOptions };
+
+// Export Raw SerialPort for advanced users
+export { SerialPort as RawSerialPort };
+
+// Export Resilient wrapper (connection resilience)
+// Note: ResilientDataBridge wraps DataBridge. 
+// If DataBridge is now Reliable, ResilientDataBridge will hold a ReliableDataBridge.
+// This gives us Connection Resilience + Data Reliability.
+export { ResilientDataBridge, ResilientOptions, ResilientEvents } from './resilient';