@technoculture/data-bridge 0.1.0

package/dist/index.js

@@ -0,0 +1,314 @@
+"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: () => DataBridge,
+  ResilientDataBridge: () => ResilientDataBridge,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_events2 = require("events");
+var import_path = __toESM(require("path"));
+
+// lib/resilient.ts
+var import_events = require("events");
+var ResilientDataBridge = class _ResilientDataBridge extends import_events.EventEmitter {
+  bridge = null;
+  port;
+  options;
+  messageQueue = [];
+  isConnected = false;
+  isReconnecting = false;
+  shouldReconnect = true;
+  reconnectAttempt = 0;
+  reconnectTimeout = null;
+  constructor(port, options) {
+    super();
+    this.port = port;
+    this.options = {
+      baudRate: options.baudRate ?? 115200,
+      reconnect: options.reconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4,
+      maxQueueSize: options.maxQueueSize ?? 1e3
+    };
+  }
+  /**
+   * 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.connect();
+    return instance;
+  }
+  async connect() {
+    try {
+      this.bridge = await DataBridge.open(this.port, {
+        baudRate: this.options.baudRate
+      });
+      this.isConnected = true;
+      this.reconnectAttempt = 0;
+      this.bridge.on("data", (data) => {
+        this.emit("data", data);
+      });
+      this.bridge.on("error", (err) => {
+        this.emit("error", err);
+        this.handleDisconnect();
+      });
+      if (this.isReconnecting) {
+        this.isReconnecting = false;
+        this.emit("reconnected");
+        await this.flushQueue();
+      }
+    } catch (err) {
+      this.isConnected = false;
+      if (this.shouldReconnect && this.options.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        throw err;
+      }
+    }
+  }
+  handleDisconnect() {
+    if (!this.isConnected) return;
+    this.isConnected = false;
+    this.bridge = null;
+    this.emit("disconnect");
+    if (this.shouldReconnect && this.options.reconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout) return;
+    this.isReconnecting = true;
+    this.reconnectAttempt++;
+    const baseDelay = this.options.reconnectDelay;
+    const maxDelay = this.options.maxReconnectDelay;
+    const delay = Math.min(
+      baseDelay * Math.pow(2, this.reconnectAttempt - 1) + Math.random() * 1e3,
+      maxDelay
+    );
+    this.emit("reconnecting", this.reconnectAttempt, delay);
+    this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  /**
+   * Send data with guaranteed delivery.
+   * 
+   * If disconnected, the message is queued and will be sent
+   * automatically when the connection is restored.
+   * 
+   * @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;
+    if (this.isConnected && this.bridge) {
+      try {
+        await this.bridge.send(buffer);
+      } catch (err) {
+        return this.queueMessage(buffer);
+      }
+    } else {
+      return this.queueMessage(buffer);
+    }
+  }
+  queueMessage(data) {
+    return new Promise((resolve, reject) => {
+      while (this.messageQueue.length >= this.options.maxQueueSize) {
+        const dropped = this.messageQueue.shift();
+        dropped?.reject(new Error("Message dropped: queue overflow"));
+      }
+      this.messageQueue.push({
+        data,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      });
+    });
+  }
+  async flushQueue() {
+    while (this.messageQueue.length > 0 && this.isConnected && this.bridge) {
+      const msg = this.messageQueue.shift();
+      try {
+        await this.bridge.send(msg.data);
+        msg.resolve();
+      } catch (err) {
+        this.messageQueue.unshift(msg);
+        break;
+      }
+    }
+  }
+  /**
+   * Close the connection permanently.
+   * Rejects all pending queued messages.
+   */
+  async close() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    for (const msg of this.messageQueue) {
+      msg.reject(new Error("Connection closed"));
+    }
+    this.messageQueue = [];
+    if (this.bridge) {
+      await this.bridge.close();
+      this.bridge = null;
+    }
+    this.isConnected = false;
+    this.emit("close");
+  }
+  /** Current connection state */
+  get connected() {
+    return this.isConnected;
+  }
+  /** Number of messages waiting in queue */
+  get queueLength() {
+    return this.messageQueue.length;
+  }
+  // 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);
+  }
+};
+
+// lib/index.ts
+var addon;
+function loadAddon() {
+  const possiblePaths = [
+    // Prebuilt binaries
+    `../prebuilds/${process.platform}-${process.arch}/data_bridge_node.node`,
+    // Local build
+    "../build/Release/data_bridge_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.");
+}
+addon = loadAddon();
+var DataBridge = class _DataBridge extends import_events2.EventEmitter {
+  native;
+  _isOpen = false;
+  constructor() {
+    super();
+    this.native = new addon.DataBridge();
+  }
+  /**
+   * Open a serial port with guaranteed reliable communication.
+   * 
+   * @param port - Serial port path (e.g., '/dev/ttyUSB0' or 'COM3')
+   * @param options - Configuration options
+   * @returns Promise resolving to a DataBridge instance
+   */
+  static async open(port, options = {}) {
+    const instance = new _DataBridge();
+    const baud = options.baudRate ?? 115200;
+    const onData = (data) => {
+      instance.emit("data", data);
+    };
+    try {
+      await instance.native.open(port, baud, onData);
+      instance._isOpen = true;
+      return instance;
+    } catch (err) {
+      throw new Error(`Failed to open ${port}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  /**
+   * Send data with guaranteed delivery.
+   * 
+   * The data will be fragmented if necessary, checksummed, and
+   * retransmitted until acknowledged by the receiver.
+   * 
+   * @param data - Data to send (Buffer or string)
+   * @returns Promise resolving when data is acknowledged
+   */
+  async send(data) {
+    if (!this._isOpen) {
+      throw new Error("Port not open");
+    }
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    await this.native.send(buffer);
+  }
+  /**
+   * Close the serial port.
+   */
+  async close() {
+    if (this._isOpen) {
+      this.native.close();
+      this._isOpen = false;
+      this.emit("close");
+    }
+  }
+  /**
+   * Check if the port is currently open.
+   */
+  get isOpen() {
+    return this._isOpen && this.native.isOpen();
+  }
+  // Type-safe event emitter methods
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+var index_default = DataBridge;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataBridge,
+  ResilientDataBridge
+});

package/dist/index.mjs

@@ -0,0 +1,285 @@
+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/index.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import path from "path";
+
+// lib/resilient.ts
+import { EventEmitter } from "events";
+var ResilientDataBridge = class _ResilientDataBridge extends EventEmitter {
+  bridge = null;
+  port;
+  options;
+  messageQueue = [];
+  isConnected = false;
+  isReconnecting = false;
+  shouldReconnect = true;
+  reconnectAttempt = 0;
+  reconnectTimeout = null;
+  constructor(port, options) {
+    super();
+    this.port = port;
+    this.options = {
+      baudRate: options.baudRate ?? 115200,
+      reconnect: options.reconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4,
+      maxQueueSize: options.maxQueueSize ?? 1e3
+    };
+  }
+  /**
+   * 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.connect();
+    return instance;
+  }
+  async connect() {
+    try {
+      this.bridge = await DataBridge.open(this.port, {
+        baudRate: this.options.baudRate
+      });
+      this.isConnected = true;
+      this.reconnectAttempt = 0;
+      this.bridge.on("data", (data) => {
+        this.emit("data", data);
+      });
+      this.bridge.on("error", (err) => {
+        this.emit("error", err);
+        this.handleDisconnect();
+      });
+      if (this.isReconnecting) {
+        this.isReconnecting = false;
+        this.emit("reconnected");
+        await this.flushQueue();
+      }
+    } catch (err) {
+      this.isConnected = false;
+      if (this.shouldReconnect && this.options.reconnect) {
+        this.scheduleReconnect();
+      } else {
+        throw err;
+      }
+    }
+  }
+  handleDisconnect() {
+    if (!this.isConnected) return;
+    this.isConnected = false;
+    this.bridge = null;
+    this.emit("disconnect");
+    if (this.shouldReconnect && this.options.reconnect) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimeout) return;
+    this.isReconnecting = true;
+    this.reconnectAttempt++;
+    const baseDelay = this.options.reconnectDelay;
+    const maxDelay = this.options.maxReconnectDelay;
+    const delay = Math.min(
+      baseDelay * Math.pow(2, this.reconnectAttempt - 1) + Math.random() * 1e3,
+      maxDelay
+    );
+    this.emit("reconnecting", this.reconnectAttempt, delay);
+    this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  /**
+   * Send data with guaranteed delivery.
+   * 
+   * If disconnected, the message is queued and will be sent
+   * automatically when the connection is restored.
+   * 
+   * @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;
+    if (this.isConnected && this.bridge) {
+      try {
+        await this.bridge.send(buffer);
+      } catch (err) {
+        return this.queueMessage(buffer);
+      }
+    } else {
+      return this.queueMessage(buffer);
+    }
+  }
+  queueMessage(data) {
+    return new Promise((resolve, reject) => {
+      while (this.messageQueue.length >= this.options.maxQueueSize) {
+        const dropped = this.messageQueue.shift();
+        dropped?.reject(new Error("Message dropped: queue overflow"));
+      }
+      this.messageQueue.push({
+        data,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      });
+    });
+  }
+  async flushQueue() {
+    while (this.messageQueue.length > 0 && this.isConnected && this.bridge) {
+      const msg = this.messageQueue.shift();
+      try {
+        await this.bridge.send(msg.data);
+        msg.resolve();
+      } catch (err) {
+        this.messageQueue.unshift(msg);
+        break;
+      }
+    }
+  }
+  /**
+   * Close the connection permanently.
+   * Rejects all pending queued messages.
+   */
+  async close() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    for (const msg of this.messageQueue) {
+      msg.reject(new Error("Connection closed"));
+    }
+    this.messageQueue = [];
+    if (this.bridge) {
+      await this.bridge.close();
+      this.bridge = null;
+    }
+    this.isConnected = false;
+    this.emit("close");
+  }
+  /** Current connection state */
+  get connected() {
+    return this.isConnected;
+  }
+  /** Number of messages waiting in queue */
+  get queueLength() {
+    return this.messageQueue.length;
+  }
+  // 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);
+  }
+};
+
+// lib/index.ts
+var addon;
+function loadAddon() {
+  const possiblePaths = [
+    // Prebuilt binaries
+    `../prebuilds/${process.platform}-${process.arch}/data_bridge_node.node`,
+    // Local build
+    "../build/Release/data_bridge_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.");
+}
+addon = loadAddon();
+var DataBridge = class _DataBridge extends EventEmitter2 {
+  native;
+  _isOpen = false;
+  constructor() {
+    super();
+    this.native = new addon.DataBridge();
+  }
+  /**
+   * Open a serial port with guaranteed reliable communication.
+   * 
+   * @param port - Serial port path (e.g., '/dev/ttyUSB0' or 'COM3')
+   * @param options - Configuration options
+   * @returns Promise resolving to a DataBridge instance
+   */
+  static async open(port, options = {}) {
+    const instance = new _DataBridge();
+    const baud = options.baudRate ?? 115200;
+    const onData = (data) => {
+      instance.emit("data", data);
+    };
+    try {
+      await instance.native.open(port, baud, onData);
+      instance._isOpen = true;
+      return instance;
+    } catch (err) {
+      throw new Error(`Failed to open ${port}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  /**
+   * Send data with guaranteed delivery.
+   * 
+   * The data will be fragmented if necessary, checksummed, and
+   * retransmitted until acknowledged by the receiver.
+   * 
+   * @param data - Data to send (Buffer or string)
+   * @returns Promise resolving when data is acknowledged
+   */
+  async send(data) {
+    if (!this._isOpen) {
+      throw new Error("Port not open");
+    }
+    const buffer = typeof data === "string" ? Buffer.from(data) : data;
+    await this.native.send(buffer);
+  }
+  /**
+   * Close the serial port.
+   */
+  async close() {
+    if (this._isOpen) {
+      this.native.close();
+      this._isOpen = false;
+      this.emit("close");
+    }
+  }
+  /**
+   * Check if the port is currently open.
+   */
+  get isOpen() {
+    return this._isOpen && this.native.isOpen();
+  }
+  // Type-safe event emitter methods
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+var index_default = DataBridge;
+export {
+  DataBridge,
+  ResilientDataBridge,
+  index_default as default
+};