@syncbridge/serialport 0.4.1

package/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025 Panates (Panates Teknoloji Yatirim A.S.). All rights reserved.
+
+This software and associated documentation files (the "Software") are
+the proprietary property of Panates and are protected by copyright laws
+and international copyright treaties.
+
+Unauthorized copying, distribution, modification, reverse engineering,
+or use of this software, in whole or in part, is strictly prohibited
+without the express written permission of Panates.
+
+This Software is provided solely for use in accordance with the terms
+of a valid license agreement. Any unauthorized use may result in
+civil and/or criminal penalties.
+
+For licensing inquiries, please contact: info@panates.com

package/README.md

@@ -0,0 +1 @@
+# SyncBridge Ngrok Connectors

package/components/serial-client.component.d.ts

@@ -0,0 +1,37 @@
+import { Buffer } from 'node:buffer';
+import type { PortInfo } from '@serialport/bindings-interface';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import reconnectCore from 'reconnect-core';
+import { SerialPort } from 'serialport';
+import { SerialClientReconnectVariables, SerialClientVariables } from './serial-client.variables.js';
+export declare class SerialClientComponent<TEvents extends SerialClientComponent.Events = SerialClientComponent.Events> extends IoClientBaseComponent<TEvents> {
+    readonly protocol: string;
+    protected _connectionManager?: ReturnType<typeof socketReconnect>;
+    protected _serialPort?: SerialPort;
+    protected _stopping?: boolean;
+    values: SerialClientVariables;
+    get connected(): boolean;
+    protected _start(abortSignal: AbortSignal): Promise<void>;
+    protected _stop(): Promise<void>;
+    write(data: string | Buffer): void;
+    list(): Promise<PortInfo[]>;
+}
+declare const socketReconnect: reconnectCore.CustomModule<any, any>;
+/**
+ * @namespace
+ */
+export declare namespace SerialClientComponent {
+    interface Events extends IoClientBaseComponent.Events {
+        connect: [];
+        disconnect: [error: Error | undefined];
+        data: [data: Buffer];
+        reconnecting: [n: number, delay: number];
+        reconnect: [];
+        write: [data: Buffer | string];
+    }
+    const Variables: typeof SerialClientVariables;
+    type Variables = SerialClientVariables;
+    const ReconnectVariables: typeof SerialClientReconnectVariables;
+    type ReconnectVariables = SerialClientReconnectVariables;
+}
+export {};

package/components/serial-client.component.js

@@ -0,0 +1,146 @@
+import { __decorate, __metadata } from "tslib";
+import EventEmitter from 'node:events';
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { Component, ServiceStatus } from '@syncbridge/common';
+import colors from 'ansi-colors';
+import { toIntDef } from 'putil-varhelpers';
+import reconnectCore from 'reconnect-core';
+import { SerialPort } from 'serialport';
+import { noOp } from '../constants.js';
+import { SerialClientReconnectVariables, SerialClientVariables, } from './serial-client.variables.js';
+let SerialClientComponent = class SerialClientComponent extends IoClientBaseComponent {
+    protocol = 'serial';
+    _connectionManager;
+    _serialPort;
+    _stopping;
+    get connected() {
+        return this._connectionManager?.connected ?? false;
+    }
+    async _start(abortSignal) {
+        await super._start(abortSignal);
+        this._stopping = false;
+        let reconnecting = false;
+        this._connectionManager = socketReconnect({
+            ...this.values.reconnect,
+        })
+            .on('error', err => {
+            this.emit('error', err);
+        })
+            .on('connect', (emitter) => {
+            const serialPort = emitter.port;
+            if (this._serialPort !== serialPort) {
+                this._serialPort = serialPort;
+                serialPort.on('data', (chunk) => this.emit('data', chunk));
+            }
+            if (reconnecting)
+                this.emit('reconnect');
+            reconnecting = false;
+            this.emit('connect');
+            this.logger?.info(`Connected to "${colors.cyan(this.values.port)}" serial port`);
+            this.setStatus(ServiceStatus.started);
+        })
+            .on('reconnect', (n, delay) => {
+            if (n === 0 && delay === 0)
+                return;
+            this.logger?.warn(`Connection failed (${colors.cyan(String(n + 1))}). Will be retried after ${colors.cyan(delay + 'ms')}`);
+            this.emit('reconnecting', n, delay);
+        })
+            .on('disconnect', err => {
+            this._serialPort = undefined;
+            if (this._stopping)
+                this.emit('disconnect');
+            else {
+                this.logger?.info(`Serial port "${colors.cyan(this.values.port)}" disconnected`);
+                this.setStatus(ServiceStatus.unhealthy, err.message);
+            }
+        });
+        this.logger?.info(`Connecting to serial port ${colors.cyan(this.values.port)} ...`);
+        this._connectionManager.connect({
+            path: this.values.port,
+            baudRate: this.values.baudRate || 9600,
+            dataBits: toIntDef(this.values.dataBits, 8),
+            stopBits: toIntDef(this.values.dataBits, 1),
+            parity: this.values.parity || 'none',
+            rtscts: this.values.rtscts,
+            xon: this.values.xon,
+            xoff: this.values.xoff,
+            xany: this.values.xany,
+            hupcl: this.values.hupcl,
+        });
+    }
+    async _stop() {
+        if (!this._connectionManager)
+            return;
+        this._stopping = true;
+        const connectionManager = this._connectionManager;
+        this._connectionManager = undefined;
+        /** istanbul ignore else */
+        if (connectionManager.connected) {
+            return new Promise(resolve => {
+                connectionManager.once('disconnect', async () => {
+                    await this.emitAsync('stop').catch(noOp);
+                    resolve();
+                });
+                connectionManager.disconnect();
+                connectionManager.reset();
+            });
+        }
+        else {
+            connectionManager.disconnect();
+            connectionManager.reset();
+        }
+    }
+    write(data) {
+        if (!(this._serialPort && this._connectionManager?.connected)) {
+            throw new Error(`Can't write while serial port is not connected`);
+        }
+        this.emit('transmit', data);
+        this._serialPort.write(data);
+    }
+    async list() {
+        return await SerialPort.list();
+    }
+};
+__decorate([
+    Component.UseVariables(),
+    __metadata("design:type", SerialClientVariables)
+], SerialClientComponent.prototype, "values", void 0);
+SerialClientComponent = __decorate([
+    Component({
+        className: 'SerialPort',
+        displayName: 'Serial Port',
+        description: 'Serial port connection component',
+        tags: ['serial', 'rs232', 'client', 'connection'],
+    })
+], SerialClientComponent);
+export { SerialClientComponent };
+const socketReconnect = reconnectCore(args => {
+    const port = new SerialPort({
+        ...args,
+        autoOpen: false,
+    });
+    const emitter = new EventEmitter();
+    port.on('open', () => {
+        emitter.port = port;
+        emitter.emit('connect', port);
+    });
+    port.on('error', err => {
+        emitter.emit('error', err);
+    });
+    port.on('close', () => {
+        emitter.emit('disconnect');
+    });
+    port.open(err => {
+        if (err) {
+            emitter.emit('error', err);
+        }
+    });
+    return emitter;
+});
+/**
+ * @namespace
+ */
+(function (SerialClientComponent) {
+    SerialClientComponent.Variables = SerialClientVariables;
+    SerialClientComponent.ReconnectVariables = SerialClientReconnectVariables;
+})(SerialClientComponent || (SerialClientComponent = {}));

package/components/serial-client.variables.d.ts

@@ -0,0 +1,25 @@
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+/**
+ * Reconnect variables
+ */
+export declare class SerialClientReconnectVariables {
+    strategy: 'fibonacci' | 'exponential';
+    initialDelay: number;
+    maxDelay: number;
+}
+/**
+ * Variables
+ */
+export declare class SerialClientVariables extends IoClientBaseComponent.Variables {
+    port: string;
+    baudRate: number;
+    dataBits: string;
+    stopBits: string;
+    parity: string;
+    rtscts: boolean;
+    xon: boolean;
+    xoff: boolean;
+    xany: boolean;
+    hupcl: boolean;
+    reconnect: SerialClientReconnectVariables;
+}

package/components/serial-client.variables.js

@@ -0,0 +1,138 @@
+import { __decorate, __metadata } from "tslib";
+import { IoClientBaseComponent } from '@syncbridge/builtins';
+import { DefineVariable, VariableType } from '@syncbridge/common';
+import { SerialPort } from 'serialport';
+/**
+ * Reconnect variables
+ */
+export class SerialClientReconnectVariables {
+}
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        label: 'Reconnection strategy',
+        enumValues: ['fibonacci', 'exponential'],
+        default: 'fibonacci',
+    }),
+    __metadata("design:type", String)
+], SerialClientReconnectVariables.prototype, "strategy", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Initial delay',
+        description: 'Initial delay in milliseconds',
+        default: 2000,
+    }),
+    __metadata("design:type", Number)
+], SerialClientReconnectVariables.prototype, "initialDelay", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Maximum delay',
+        description: 'Maximum delay in milliseconds',
+        default: 10000,
+    }),
+    __metadata("design:type", Number)
+], SerialClientReconnectVariables.prototype, "maxDelay", void 0);
+/**
+ * Variables
+ */
+export class SerialClientVariables extends IoClientBaseComponent.Variables {
+}
+__decorate([
+    DefineVariable({
+        label: 'Port',
+        description: 'The port or the system path of the serial port you want to open. For example, `/dev/tty.XXX` on Mac/Linux, or `COM1` on Windows',
+        required: true,
+        enumValues: SerialPort.list()
+            .then(ports => ports.map(port => port.path))
+            .catch(() => []),
+    }),
+    __metadata("design:type", String)
+], SerialClientVariables.prototype, "port", void 0);
+__decorate([
+    DefineVariable({
+        type: VariableType.Number,
+        label: 'Baud rate',
+        description: 'The baud rate of the port to be opened. This should match one of the commonly available ' +
+            'baud rates, such as 110, 300, 1200, 2400, 4800, 9600, 14400, 19200, 38400, 57600, or 115200. ' +
+            'Custom rates are supported best effort per platform. The device connected to the serial port ' +
+            'is not guaranteed to support the requested baud rate, even if the port itself supports that baud rate.',
+        default: 9600,
+        required: true,
+    }),
+    __metadata("design:type", Number)
+], SerialClientVariables.prototype, "baudRate", void 0);
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        label: 'Data bits',
+        enumValues: ['5', '6', '7', '8', '9'],
+        default: '8',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], SerialClientVariables.prototype, "dataBits", void 0);
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        label: 'Stop bits',
+        enumValues: ['1', '1.5', '2'],
+        default: '1',
+    }),
+    __metadata("design:type", String)
+], SerialClientVariables.prototype, "stopBits", void 0);
+__decorate([
+    DefineVariable({
+        type: VariableType.Enum,
+        label: 'Parity flow control',
+        enumValues: ['none', 'even', 'mark', 'odd', 'space'],
+        default: 'none',
+    }),
+    __metadata("design:type", String)
+], SerialClientVariables.prototype, "parity", void 0);
+__decorate([
+    DefineVariable({
+        label: 'RTS/CTS',
+        description: 'RTS/CTS flow control',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], SerialClientVariables.prototype, "rtscts", void 0);
+__decorate([
+    DefineVariable({
+        label: 'XON',
+        description: 'XON flow control',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], SerialClientVariables.prototype, "xon", void 0);
+__decorate([
+    DefineVariable({
+        label: 'XOFF',
+        description: 'XOFF flow control',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], SerialClientVariables.prototype, "xoff", void 0);
+__decorate([
+    DefineVariable({
+        label: 'XANY',
+        description: 'XANY flow control',
+        default: false,
+    }),
+    __metadata("design:type", Boolean)
+], SerialClientVariables.prototype, "xany", void 0);
+__decorate([
+    DefineVariable({
+        label: 'HUPCL',
+        description: 'Drop DTR on close if enabled',
+        default: true,
+    }),
+    __metadata("design:type", Boolean)
+], SerialClientVariables.prototype, "hupcl", void 0);
+__decorate([
+    DefineVariable({
+        label: 'Reconnect Options',
+        description: 'Connection timeout in milliseconds',
+    }),
+    __metadata("design:type", SerialClientReconnectVariables)
+], SerialClientVariables.prototype, "reconnect", void 0);

package/components.d.ts

@@ -0,0 +1 @@
+export * from './components/serial-client.component.js';

package/components.js

@@ -0,0 +1 @@
+export * from './components/serial-client.component.js';

package/constants.d.ts

@@ -0,0 +1,4 @@
+import { AuthorMetadata } from '@syncbridge/common';
+export declare const version = "1";
+export declare const noOp: () => undefined;
+export declare const panatesAuthor: AuthorMetadata;

package/constants.js

@@ -0,0 +1,7 @@
+export const version = '0.4.1';
+export const noOp = () => undefined;
+export const panatesAuthor = {
+    name: 'Panates Technology AS',
+    email: 'info@panates.com',
+    url: 'https://www.panates.com',
+};

package/index.d.ts

@@ -0,0 +1,5 @@
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+declare const cfg: import("@syncbridge/common").IExtensionPackage;
+export default cfg;

package/index.js

@@ -0,0 +1,9 @@
+import { makeExtensionPackage } from '@syncbridge/common';
+import * as components from './components.js';
+export { components };
+export * from './components.js';
+const cfg = makeExtensionPackage({
+    processors: [],
+    components: Object.values(components),
+});
+export default cfg;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@syncbridge/serialport",
+  "version": "0.4.1",
+  "description": "SyncBridge Serial Port connection component",
+  "author": "Panates Inc",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@serialport/bindings-interface": "^1.2.2",
+    "ansi-colors": "^4.1.3",
+    "fast-tokenizer": "^1.9.0",
+    "node-events-async": "^1.5.0",
+    "reconnect-core": "^1.3.0",
+    "putil-varhelpers": "^1.7.0",
+    "serialport": "^13.0.0"
+  },
+  "peerDependencies": {
+    "@syncbridge/common": "^0.4.1",
+    "@syncbridge/builtins": "^0.4.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}