njs-modbus 3.0.2 → 3.1.0

package/dist/index.d.ts

@@ -113,6 +113,8 @@ declare enum ConformityLevel {
     REGULAR = 130,
     EXTENDED = 131
 }
+/** Shared empty Buffer to avoid repeated allocations. */
+declare const EMPTY_BUFFER: Buffer<ArrayBuffer>;
 /** Modbus V1.1b3 PDU quantity limits. */
 declare const LIMITS: {
     readonly READ_COILS_MIN: 1;
@@ -180,17 +182,16 @@ declare class SerialPhysicalLayer extends AbstractPhysicalLayer {
     private _serialportOpts;
     private _path;
     private _baudRate;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get serialport(): SerialPort | null;
     get path(): string;
     get baudRate(): number;
     constructor(options: SerialPhysicalLayerOptions);
-    open(): Promise<void>;
-    close(): Promise<void>;
+    open(cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }
 
 declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
@@ -199,15 +200,14 @@ declare class TcpClientPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _socketOpts?;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket | null;
     constructor(options?: SocketConstructorOpts);
-    open(options?: SocketConnectOpts): Promise<void>;
-    close(): Promise<void>;
+    open(options?: SocketConnectOpts | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }
 
 interface TcpServerPhysicalLayerOptions {
@@ -226,15 +226,14 @@ declare class TcpServerPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _server;
     private _opts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get server(): Server | null;
     constructor(options?: TcpServerPhysicalLayerOptions);
-    open(options?: ListenOptions): Promise<void>;
-    close(): Promise<void>;
+    open(options?: ListenOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }
 
 declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
@@ -243,9 +242,8 @@ declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _socketOpts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket$1 | null;
@@ -253,8 +251,8 @@ declare class UdpClientPhysicalLayer extends AbstractPhysicalLayer {
     open(remote?: {
         port?: number;
         address?: string;
-    }): Promise<void>;
-    close(): Promise<void>;
+    } | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }
 
 interface UdpServerPhysicalLayerOptions {
@@ -273,9 +271,8 @@ declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
     private _connections;
     private _socket;
     private _opts;
-    private _openPromise;
-    private _closePromise;
-    private _resolveClose;
+    private _pendingOpenCbs;
+    private _pendingCloseCbs;
     private _cleanupFns;
     get state(): PhysicalState;
     get socket(): Socket$1 | null;
@@ -284,13 +281,10 @@ declare class UdpServerPhysicalLayer extends AbstractPhysicalLayer {
      * Bind the UDP socket and start accepting datagrams.
      *
      * @param options Bind options (port, address, etc.). Defaults to port 502.
-     * @param [idleTimeout=30000] Maximum idle time in milliseconds before an
-     * inactive client connection is evicted. Pass `0` to disable eviction
-     * (connections never time out). Disabling eviction may cause unbounded
-     * memory growth if the server sees many unique clients.
+     * @param cb Callback invoked when binding completes or fails.
      */
-    open(options?: BindOptions): Promise<void>;
-    close(): Promise<void>;
+    open(options?: BindOptions | ((err?: Error | null) => void), cb?: (err?: Error | null) => void): void;
+    close(cb?: (err?: Error | null) => void): void;
 }
 
 interface AbstractPhysicalConnectionEvents {
@@ -306,8 +300,8 @@ interface AbstractPhysicalConnectionEvents {
 declare abstract class AbstractPhysicalConnection extends EventEmitter<AbstractPhysicalConnectionEvents> {
     abstract readonly state: PhysicalConnectionState;
     abstract readonly physicalLayer: AbstractPhysicalLayer;
-    abstract write(data: Buffer): Promise<void>;
-    abstract destroy(): Promise<void>;
+    abstract write(data: Buffer, cb?: (err?: Error | null) => void): void;
+    abstract destroy(cb?: (err?: Error | null) => void): void;
 }
 interface AbstractPhysicalLayerEvents {
     open: [];
@@ -331,8 +325,9 @@ declare abstract class AbstractPhysicalLayer extends EventEmitter<AbstractPhysic
     is(type: 'UDP_CLIENT'): this is UdpClientPhysicalLayer;
     is(type: 'UDP_SERVER'): this is UdpServerPhysicalLayer;
     abstract readonly state: PhysicalState;
-    abstract open(...args: any[]): Promise<void>;
-    abstract close(): Promise<void>;
+    /** Last argument is the callback: `(err?: Error | null) => void`. Callback is optional. */
+    abstract open(...args: any[]): void;
+    abstract close(cb?: (err?: Error | null) => void): void;
 }
 
 type PhysicalConfig = {
@@ -387,7 +382,7 @@ declare abstract class AbstractApplicationLayer extends EventEmitter<AbstractApp
     flush(): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;
     removeCustomFunctionCode(fc: number): void;
-    abstract encode(data: ApplicationDataUnit): Buffer;
+    abstract encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }
 
 interface AsciiApplicationLayerOptions {
@@ -409,7 +404,7 @@ declare class AsciiApplicationLayer extends AbstractApplicationLayer {
     constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: AsciiApplicationLayerOptions);
     private framing;
     flush(): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }
 
 interface RtuApplicationLayerOptions {
@@ -438,14 +433,10 @@ declare class RtuApplicationLayer extends AbstractApplicationLayer {
     constructor(role: 'MASTER' | 'SLAVE', connection: AbstractPhysicalConnection, options?: RtuApplicationLayerOptions);
     private clearStateTimers;
     private flushBuffer;
-    private deliverFrame;
-    private tryExtract;
-    private checkExpected;
-    private crcMatches;
     flush(): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;
     removeCustomFunctionCode(fc: number): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }
 
 declare class TcpApplicationLayer extends AbstractApplicationLayer {
@@ -460,35 +451,49 @@ declare class TcpApplicationLayer extends AbstractApplicationLayer {
     private tryExtract;
     private processFrame;
     flush(): void;
-    encode(data: ApplicationDataUnit): Buffer;
+    encode(unit: number, fc: number, data: Buffer, transaction?: number): Buffer;
 }
 
+/**
+ * RTU timing parameter — accepts either:
+ * - a bare `number` in milliseconds (`0` to disable the timer entirely)
+ * - `{ unit: 'ms', value: N }` — explicit milliseconds (equivalent to bare `N`)
+ * - `{ unit: 'bit', value: N }` — bit-time approximation, derived from `baudRate`
+ *
+ * The bare-number form is the recommended default; the object form exists for
+ * specs that quote bit-time. Pass `0` (or `{ unit: 'ms', value: 0 }`) to disable
+ * the timer; either form short-circuits the baudRate-derived fallback.
+ */
+type RtuTimingValue = number | {
+    unit: 'bit' | 'ms';
+    value: number;
+};
 /** User-facing RTU protocol options (supports both bit and ms units). */
 interface RtuProtocolOptions {
     /**
      * Inter-frame silence (Modbus RTU t3.5).
+     *
+     * - `20` or `{ unit: 'ms', value: 20 }` — 20 ms
      * - `{ unit: 'bit', value: 38.5 }` — spec bit-time approximation (default when `baudRate` is provided)
-     * - `{ unit: 'ms', value: 20 }` — explicit milliseconds
+     * - `0` — disable t3.5 timing (immediate parse on every chunk; useful for
+     *   lossless transports such as RTU-over-TCP or PTY-based tests where the
+     *   wire's silence semantics do not apply)
      *
      * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 1.75 ms is used
      * regardless of the bit value.
      */
-    intervalBetweenFrames?: {
-        unit: 'bit' | 'ms';
-        value: number;
-    };
+    intervalBetweenFrames?: RtuTimingValue;
     /**
      * Inter-character timeout (Modbus RTU t1.5). Opt-in; **disabled** by default.
+     *
+     * - `1` or `{ unit: 'ms', value: 1 }` — 1 ms
      * - `{ unit: 'bit', value: 21 }` — bit-time approximation (~1.5 char times)
-     * - `{ unit: 'ms', value: 1 }` — explicit milliseconds
+     * - `0` — disable explicitly
      *
      * Per Modbus V1.02 §2.5.1.1, at baud rates > 19200 a fixed 0.75 ms is used
      * regardless of the bit value.
      */
-    interCharTimeout?: {
-        unit: 'bit' | 'ms';
-        value: number;
-    };
+    interCharTimeout?: RtuTimingValue;
     /**
      * Buffer pool size per connection (bytes). Defaults to `MAX_FRAME_LENGTH * 2`
      * (512 bytes). Increase this if you expect frames larger than 256 bytes or
@@ -532,7 +537,15 @@ declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions>
     private _protocol;
     private _appLayer?;
     private _customFunctionCodes;
-    private _queue;
+    private _queueUnits;
+    private _queueFcs;
+    private _queueDatas;
+    private _queueTimeouts;
+    private _queueBroadcasts;
+    private _queueResolves;
+    private _queueRejects;
+    private _queueHead;
+    private _queueLen;
     private _draining;
     private _nextTid;
     private _cleanupFns;
@@ -543,6 +556,7 @@ declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions>
     private _createAppLayer;
     private send;
     private _drain;
+    private _processNext;
     private _exchange;
     private writeFC1Or2;
     writeFC1: this['readCoils'];
@@ -601,7 +615,6 @@ declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions>
     removeCustomFunctionCode(fc: number): void;
     sendCustomFC(unit: 0, fc: number, data: Buffer | number[], timeout?: number): Promise<void>;
     sendCustomFC(unit: number, fc: number, data: Buffer | number[], timeout?: number): Promise<Buffer>;
-    private _clean;
     /**
      * Open the underlying physical layer and begin accepting connections.
      *
@@ -626,17 +639,17 @@ declare class ModbusMaster<T extends ModbusMasterOptions = ModbusMasterOptions>
 type Frame = ApplicationDataUnit & {
     buffer: Buffer;
 };
-type PreCheck = (frame: Frame) => boolean | number | undefined;
 type Callback = (error: Error | null, frame?: Frame) => void;
 declare class MasterSession {
     private _waiters;
-    start(key: string | number, preCheck: PreCheck[], callback: Callback): void;
+    /** Register a callback for `key`. No timer — timeout is managed by the caller. */
+    start(key: string | number, callback: Callback): void;
+    /** Cancel a pending waiter without firing its callback. */
     stop(key: string | number): void;
     stopAll(error: Error): void;
     has(key: string | number): boolean;
     handleFrame(frame: Frame): void;
     handleError(error: Error): void;
-    private runPreChecks;
 }
 
 interface ModbusSlaveModel {
@@ -727,6 +740,7 @@ declare class ModbusSlave<T extends ModbusSlaveOptions = ModbusSlaveOptions> ext
     private _intercept;
     private _withAddressLock;
     private _handleFC;
+    private _handleCustomFC;
     add(model: ModbusSlaveModel): void;
     remove(unit: number): void;
     addCustomFunctionCode(cfc: CustomFunctionCode): void;
@@ -752,5 +766,5 @@ declare class ModbusSlave<T extends ModbusSlaveOptions = ModbusSlaveOptions> ext
     close(): Promise<void>;
 }
 
-export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };
+export { AbstractApplicationLayer, AbstractPhysicalConnection, AbstractPhysicalLayer, AsciiApplicationLayer, COIL_OFF, COIL_ON, ConformityLevel, EMPTY_BUFFER, EXCEPTION_OFFSET, ErrorCode, FunctionCode, LIMITS, MEI_READ_DEVICE_ID, MasterSession, ModbusError, ModbusMaster, ModbusSlave, PhysicalConnectionState, PhysicalState, ReadDeviceIDCode, RtuApplicationLayer, SerialPhysicalLayer, TcpApplicationLayer, TcpClientPhysicalLayer, TcpServerPhysicalLayer, UdpClientPhysicalLayer, UdpServerPhysicalLayer, createPhysicalLayer, getCodeByError, getErrorByCode };
 export type { AbstractPhysicalLayerEvents, ApplicationDataUnit, AsciiApplicationLayerOptions, Callback$1 as Callback, CustomFunctionCode, DeviceIdentification, MaybeAsyncFunction, ModbusMasterOptions, ModbusSlaveModel, ModbusSlaveOptions, OpenArgs, PhysicalConfig, RtuApplicationLayerOptions, ServerId, TcpServerPhysicalLayerOptions, UdpServerPhysicalLayerOptions };