zigbee-herdsman 6.0.1 → 6.0.3

package/src/adapter/ezsp/driver/uart.ts

@@ -1,460 +0,0 @@
-/* v8 ignore start */
-
-import {EventEmitter} from "node:events";
-import net from "node:net";
-
-import {Queue, Waitress, wait} from "../../../utils";
-import {logger} from "../../../utils/logger";
-import {SerialPort} from "../../serialPort";
-import SocketPortUtils from "../../socketPortUtils";
-import type {SerialPortOptions} from "../../tstype";
-import {FrameType, Frame as NpiFrame} from "./frame";
-import {Parser} from "./parser";
-import {Writer} from "./writer";
-
-const NS = "zh:ezsp:uart";
-
-enum NcpResetCode {
-    RESET_UNKNOWN_REASON = 0x00,
-    RESET_EXTERNAL = 0x01,
-    RESET_POWER_ON = 0x02,
-    RESET_WATCHDOG = 0x03,
-    RESET_ASSERT = 0x06,
-    RESET_BOOTLOADER = 0x09,
-    RESET_SOFTWARE = 0x0b,
-    ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT = 0x51,
-    ERROR_UNKNOWN_EM3XX_ERROR = 0x80,
-}
-
-type EZSPPacket = {
-    sequence: number;
-};
-
-type EZSPPacketMatcher = {
-    sequence: number;
-};
-
-export class SerialDriver extends EventEmitter {
-    private serialPort?: SerialPort;
-    private socketPort?: net.Socket;
-    private writer: Writer;
-    private parser: Parser;
-    private initialized: boolean;
-    private sendSeq = 0; // next frame number to send
-    private recvSeq = 0; // next frame number to receive
-    private ackSeq = 0; // next number after the last accepted frame
-    private rejectCondition = false;
-    private waitress: Waitress<EZSPPacket, EZSPPacketMatcher>;
-    private queue: Queue;
-
-    constructor() {
-        super();
-        this.initialized = false;
-        this.queue = new Queue(1);
-        this.waitress = new Waitress<EZSPPacket, EZSPPacketMatcher>(this.waitressValidator, this.waitressTimeoutFormatter);
-        this.writer = new Writer();
-        this.parser = new Parser();
-    }
-
-    async connect(options: SerialPortOptions): Promise<void> {
-        // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-        if (SocketPortUtils.isTcpPath(options.path!)) {
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            await this.openSocketPort(options.path!);
-        } else {
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            await this.openSerialPort(options.path!, options.baudRate!, options.rtscts!);
-        }
-    }
-
-    private async openSerialPort(path: string, baudRate: number, rtscts: boolean): Promise<void> {
-        const options = {
-            path,
-            baudRate: typeof baudRate === "number" ? baudRate : 115200,
-            rtscts: typeof rtscts === "boolean" ? rtscts : false,
-            autoOpen: false,
-            parity: "none",
-            stopBits: 1,
-            xon: false,
-            xoff: false,
-        };
-
-        // enable software flow control if RTS/CTS not enabled in config
-        if (!options.rtscts) {
-            logger.debug("RTS/CTS config is off, enabling software flow control.", NS);
-            options.xon = true;
-            options.xoff = true;
-        }
-
-        logger.debug(`Opening SerialPort with ${JSON.stringify(options)}`, NS);
-        // @ts-ignore
-        this.serialPort = new SerialPort(options);
-
-        this.writer.pipe(this.serialPort);
-
-        this.serialPort.pipe(this.parser);
-        this.parser.on("parsed", this.onParsed.bind(this));
-
-        try {
-            await this.serialPort.asyncOpen();
-            logger.debug("Serialport opened", NS);
-
-            this.serialPort.once("close", this.onPortClose.bind(this));
-            this.serialPort.on("error", this.onPortError.bind(this));
-
-            // reset
-            await this.reset();
-
-            this.initialized = true;
-        } catch (error) {
-            this.initialized = false;
-
-            if (this.serialPort.isOpen) {
-                this.serialPort.close();
-            }
-
-            throw error;
-        }
-    }
-
-    private async openSocketPort(path: string): Promise<void> {
-        const info = SocketPortUtils.parseTcpPath(path);
-        logger.debug(`Opening TCP socket with ${info.host}:${info.port}`, NS);
-
-        this.socketPort = new net.Socket();
-        this.socketPort.setNoDelay(true);
-        this.socketPort.setKeepAlive(true, 15000);
-
-        this.writer.pipe(this.socketPort);
-
-        this.socketPort.pipe(this.parser);
-        this.parser.on("parsed", this.onParsed.bind(this));
-
-        return await new Promise((resolve, reject): void => {
-            const openError = (err: Error): void => {
-                this.initialized = false;
-
-                reject(err);
-            };
-
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            this.socketPort!.on("connect", () => {
-                logger.debug("Socket connected", NS);
-            });
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            this.socketPort!.on("ready", async (): Promise<void> => {
-                logger.debug("Socket ready", NS);
-                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                this.socketPort!.removeListener("error", openError);
-                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                this.socketPort!.once("close", this.onPortClose.bind(this));
-                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                this.socketPort!.on("error", this.onPortError.bind(this));
-
-                // reset
-                await this.reset();
-
-                this.initialized = true;
-
-                resolve();
-            });
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            this.socketPort!.once("error", openError);
-
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            this.socketPort!.connect(info.port, info.host);
-        });
-    }
-
-    private async onParsed(frame: NpiFrame): Promise<void> {
-        const rejectCondition = this.rejectCondition;
-        try {
-            frame.checkCRC();
-
-            /* Frame receive handler */
-            switch (frame.type) {
-                case FrameType.DATA:
-                    this.handleDATA(frame);
-                    break;
-                case FrameType.ACK:
-                    this.handleACK(frame);
-                    break;
-                case FrameType.NAK:
-                    this.handleNAK(frame);
-                    break;
-                case FrameType.RST:
-                    this.handleRST(frame);
-                    break;
-                case FrameType.RSTACK:
-                    this.handleRSTACK(frame);
-                    break;
-                case FrameType.ERROR:
-                    await this.handleError(frame);
-                    break;
-                default:
-                    this.rejectCondition = true;
-                    logger.debug(`UNKNOWN FRAME RECEIVED: ${frame}`, NS);
-            }
-        } catch (error) {
-            this.rejectCondition = true;
-            logger.error(`Error while parsing to NpiFrame '${error}'`, NS);
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            logger.debug((error as Error).stack!, NS);
-        }
-
-        // We send NAK only if the rejectCondition was set in the current processing
-        if (!rejectCondition && this.rejectCondition) {
-            // send NAK
-            this.writer.sendNAK(this.recvSeq);
-        }
-    }
-
-    private handleDATA(frame: NpiFrame): void {
-        /* Data frame receive handler */
-        const frmNum = (frame.control & 0x70) >> 4;
-        const reTx = (frame.control & 0x08) >> 3;
-
-        logger.debug(`<-- DATA (${frmNum},${frame.control & 0x07},${reTx}): ${frame}`, NS);
-
-        // Expected package {recvSeq}, but received {frmNum}
-        // This happens when the chip sends us a reTx packet, but we are waiting for the next one
-        if (this.recvSeq !== frmNum) {
-            if (reTx) {
-                // if the reTx flag is set, then this is a packet replay
-                logger.debug(`Unexpected DATA packet sequence ${frmNum} | ${this.recvSeq}: packet replay`, NS);
-            } else {
-                // otherwise, the sequence of packets is out of order - skip or send NAK is needed
-                logger.debug(`Unexpected DATA packet sequence ${frmNum} | ${this.recvSeq}: reject condition`, NS);
-                this.rejectCondition = true;
-                return;
-            }
-        }
-
-        this.rejectCondition = false;
-
-        this.recvSeq = (frmNum + 1) & 7; // next
-
-        logger.debug(`--> ACK  (${this.recvSeq})`, NS);
-
-        this.writer.sendACK(this.recvSeq);
-
-        const handled = this.handleACK(frame);
-
-        if (reTx && !handled) {
-            // if the package is resent and did not expect it,
-            // then will skip it - already processed it earlier
-            logger.debug(`Skipping the packet as repeated (${this.recvSeq})`, NS);
-
-            return;
-        }
-
-        const data = frame.buffer.subarray(1, -3);
-
-        this.emit("received", NpiFrame.makeRandomizedBuffer(data));
-    }
-
-    private handleACK(frame: NpiFrame): boolean {
-        /* Handle an acknowledgement frame */
-        // next number after the last accepted frame
-        this.ackSeq = frame.control & 0x07;
-
-        logger.debug(`<-- ACK (${this.ackSeq}): ${frame}`, NS);
-
-        const handled = this.waitress.resolve({sequence: this.ackSeq});
-
-        if (!handled && this.sendSeq !== this.ackSeq) {
-            // Packet confirmation received for {ackSeq}, but was expected {sendSeq}
-            // This happens when the chip has not yet received of the packet {sendSeq} from us,
-            // but has already sent us the next one.
-            logger.debug(`Unexpected packet sequence ${this.ackSeq} | ${this.sendSeq}`, NS);
-        }
-
-        return handled;
-    }
-
-    private handleNAK(frame: NpiFrame): void {
-        /* Handle negative acknowledgment frame */
-        const nakNum = frame.control & 0x07;
-
-        logger.debug(`<-- NAK (${nakNum}): ${frame}`, NS);
-
-        const handled = this.waitress.reject({sequence: nakNum}, "Recv NAK frame");
-
-        if (!handled) {
-            // send NAK
-            logger.debug(`NAK Unexpected packet sequence ${nakNum}`, NS);
-        } else {
-            logger.debug(`NAK Expected packet sequence ${nakNum}`, NS);
-        }
-    }
-
-    private handleRST(frame: NpiFrame): void {
-        logger.debug(`<-- RST:  ${frame}`, NS);
-    }
-
-    private handleRSTACK(frame: NpiFrame): void {
-        /* Reset acknowledgement frame receive handler */
-        let code: string | number;
-        this.rejectCondition = false;
-
-        logger.debug(`<-- RSTACK ${frame}`, NS);
-
-        try {
-            code = NcpResetCode[frame.buffer[2]];
-        } catch {
-            code = NcpResetCode.ERROR_UNKNOWN_EM3XX_ERROR;
-        }
-
-        logger.debug(`RSTACK Version: ${frame.buffer[1]} Reason: ${code.toString()} frame: ${frame}`, NS);
-
-        if (NcpResetCode[<number>code].toString() !== NcpResetCode.RESET_SOFTWARE.toString()) {
-            return;
-        }
-
-        this.waitress.resolve({sequence: -1});
-    }
-
-    private async handleError(frame: NpiFrame): Promise<void> {
-        logger.debug(`<-- Error ${frame}`, NS);
-
-        try {
-            // send reset
-            await this.reset();
-        } catch (error) {
-            logger.error(`Failed to reset on Error Frame: ${error}`, NS);
-        }
-    }
-
-    async reset(): Promise<void> {
-        logger.debug("Uart reseting", NS);
-        this.parser.reset();
-        this.queue.clear();
-        this.sendSeq = 0;
-        this.recvSeq = 0;
-
-        return await this.queue.execute<void>(async (): Promise<void> => {
-            try {
-                logger.debug("--> Write reset", NS);
-                const waiter = this.waitFor(-1, 10000);
-                this.rejectCondition = false;
-
-                this.writer.sendReset();
-                logger.debug("-?- waiting reset", NS);
-                await waiter.start().promise;
-                logger.debug("-+- waiting reset success", NS);
-
-                await wait(2000);
-            } catch (e) {
-                logger.error(`--> Error: ${e}`, NS);
-
-                this.emit("reset");
-
-                throw new Error(`Reset error: ${e}`);
-            }
-        });
-    }
-
-    public async close(emitClose: boolean): Promise<void> {
-        logger.debug("Closing UART", NS);
-        this.queue.clear();
-
-        if (this.initialized) {
-            this.initialized = false;
-
-            if (this.serialPort) {
-                try {
-                    await this.serialPort.asyncFlushAndClose();
-                } catch (error) {
-                    if (emitClose) {
-                        this.emit("close");
-                    }
-
-                    throw error;
-                }
-            } else {
-                // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-                this.socketPort!.destroy();
-            }
-        }
-
-        if (emitClose) {
-            this.emit("close");
-        }
-    }
-
-    private onPortError(error: Error): void {
-        logger.error(`Port error: ${error}`, NS);
-    }
-
-    private onPortClose(err: boolean | Error): void {
-        logger.debug(`Port closed. Error? ${err}`, NS);
-
-        // on error: serialport passes an Error object (in case of disconnect)
-        //           net.Socket passes a boolean (in case of a transmission error)
-        // try to reset instead of failing immediately
-        if (err != null && err !== false) {
-            this.emit("reset");
-        } else {
-            this.initialized = false;
-            this.emit("close");
-        }
-    }
-
-    public isInitialized(): boolean {
-        return this.initialized;
-    }
-
-    public async sendDATA(data: Buffer): Promise<void> {
-        const seq = this.sendSeq;
-        this.sendSeq = (seq + 1) % 8; // next
-        const nextSeq = this.sendSeq;
-        const ackSeq = this.recvSeq;
-
-        return await this.queue.execute<void>(async (): Promise<void> => {
-            const randData = NpiFrame.makeRandomizedBuffer(data);
-
-            try {
-                const waiter = this.waitFor(nextSeq);
-                logger.debug(`--> DATA (${seq},${ackSeq},0): ${data.toString("hex")}`, NS);
-                this.writer.sendData(randData, seq, 0, ackSeq);
-                logger.debug(`-?- waiting (${nextSeq})`, NS);
-                await waiter.start().promise;
-                logger.debug(`-+- waiting (${nextSeq}) success`, NS);
-            } catch (e1) {
-                logger.error(`--> Error: ${e1}`, NS);
-                logger.error(`-!- break waiting (${nextSeq})`, NS);
-                logger.error(`Can't send DATA frame (${seq},${ackSeq},0): ${data.toString("hex")}`, NS);
-
-                try {
-                    await wait(500);
-                    const waiter = this.waitFor(nextSeq);
-                    logger.debug(`->> DATA (${seq},${ackSeq},1): ${data.toString("hex")}`, NS);
-                    this.writer.sendData(randData, seq, 1, ackSeq);
-                    logger.debug(`-?- rewaiting (${nextSeq})`, NS);
-                    await waiter.start().promise;
-                    logger.debug(`-+- rewaiting (${nextSeq}) success`, NS);
-                } catch (e2) {
-                    logger.error(`--> Error: ${e2}`, NS);
-                    logger.error(`-!- break rewaiting (${nextSeq})`, NS);
-                    logger.error(`Can't resend DATA frame (${seq},${ackSeq},1): ${data.toString("hex")}`, NS);
-                    if (this.initialized) {
-                        this.emit("reset");
-                    }
-                    throw new Error(`sendDATA error: try 1: ${e1}, try 2: ${e2}`);
-                }
-            }
-        });
-    }
-
-    public waitFor(sequence: number, timeout = 4000): {start: () => {promise: Promise<EZSPPacket>; ID: number}; ID: number} {
-        return this.waitress.waitFor({sequence}, timeout);
-    }
-
-    private waitressTimeoutFormatter(matcher: EZSPPacketMatcher, timeout: number): string {
-        return `${JSON.stringify(matcher)} after ${timeout}ms`;
-    }
-
-    private waitressValidator(payload: EZSPPacket, matcher: EZSPPacketMatcher): boolean {
-        return payload.sequence === matcher.sequence;
-    }
-}

package/src/adapter/ezsp/driver/utils/crc16ccitt.ts

@@ -1,44 +0,0 @@
-/* v8 ignore start */
-
-import type {Buffer} from "node:buffer";
-
-type CalcFn = (buf: Buffer | number[], previous: number) => number;
-
-function defineCrc(model: string, calc: CalcFn): CalcFn {
-    const fn = (buf: Buffer | number[], previous: number): number => calc(buf, previous) >>> 0;
-    fn.signed = calc;
-    fn.unsigned = fn;
-    fn.model = model;
-
-    return fn;
-}
-
-// Generated by `./pycrc.py --algorithm=table-driven --model=ccitt --generate=c`
-const TABLE: number[] = [
-    0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210,
-    0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401,
-    0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6,
-    0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-    0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc,
-    0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd,
-    0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a,
-    0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-    0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb,
-    0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8,
-    0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9,
-    0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-    0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07,
-    0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74,
-    0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
-];
-
-const crc16ccitt = defineCrc("ccitt", (buf: Buffer | number[], previous: number): number => {
-    let crc = ~~previous;
-    for (const byte of buf) {
-        crc = (TABLE[((crc >> 8) ^ byte) & 0xff] ^ (crc << 8)) & 0xffff;
-    }
-
-    return crc;
-});
-
-export default crc16ccitt;

package/src/adapter/ezsp/driver/utils/index.ts

@@ -1,32 +0,0 @@
-/* v8 ignore start */
-
-import {randomBytes} from "node:crypto";
-
-import {EmberEUI64, EmberInitialSecurityBitmask} from "../types/named";
-import {EmberInitialSecurityState, EmberKeyData} from "../types/struct";
-import crc16ccitt from "./crc16ccitt";
-
-if (!Symbol.asyncIterator) {
-    // biome-ignore lint/suspicious/noExplicitAny: API
-    (<any>Symbol).asyncIterator = Symbol.for("Symbol.asyncIterator");
-}
-
-function emberSecurity(networkKey: Buffer): EmberInitialSecurityState {
-    const isc: EmberInitialSecurityState = new EmberInitialSecurityState();
-    isc.bitmask =
-        EmberInitialSecurityBitmask.HAVE_PRECONFIGURED_KEY |
-        EmberInitialSecurityBitmask.TRUST_CENTER_GLOBAL_LINK_KEY |
-        EmberInitialSecurityBitmask.HAVE_NETWORK_KEY |
-        //EmberInitialSecurityBitmask.PRECONFIGURED_NETWORK_KEY_MODE |
-        EmberInitialSecurityBitmask.REQUIRE_ENCRYPTED_KEY |
-        EmberInitialSecurityBitmask.TRUST_CENTER_USES_HASHED_LINK_KEY;
-    isc.preconfiguredKey = new EmberKeyData();
-    isc.preconfiguredKey.contents = randomBytes(16);
-    isc.networkKey = new EmberKeyData();
-    isc.networkKey.contents = networkKey;
-    isc.networkKeySequenceNumber = 0;
-    isc.preconfiguredTrustCenterEui64 = new EmberEUI64([0, 0, 0, 0, 0, 0, 0, 0]);
-    return isc;
-}
-
-export {crc16ccitt, emberSecurity};

package/src/adapter/ezsp/driver/writer.ts

@@ -1,64 +0,0 @@
-/* v8 ignore start */
-
-import * as stream from "node:stream";
-
-import {logger} from "../../../utils/logger";
-import * as consts from "./consts";
-import {crc16ccitt} from "./utils";
-
-const NS = "zh:ezsp:uart";
-
-export class Writer extends stream.Readable {
-    public writeBuffer(buffer: Buffer): void {
-        logger.debug(`--> [${buffer.toString("hex")}]`, NS);
-        this.push(buffer);
-    }
-
-    public override _read(): void {}
-
-    public sendACK(ackNum: number): void {
-        /* Construct a acknowledgement frame */
-        const ackFrame = this.makeFrame(0b10000000 | ackNum);
-        this.writeBuffer(ackFrame);
-    }
-
-    public sendNAK(ackNum: number): void {
-        /* Construct a negative acknowledgement frame */
-        const nakFrame = this.makeFrame(0b10100000 | ackNum);
-        this.writeBuffer(nakFrame);
-    }
-
-    public sendReset(): void {
-        /* Construct a reset frame */
-        const rstFrame = Buffer.concat([Buffer.from([consts.CANCEL]), this.makeFrame(0xc0)]);
-        this.writeBuffer(rstFrame);
-    }
-
-    public sendData(data: Buffer, seq: number, rxmit: number, ackSeq: number): void {
-        /* Construct a data frame */
-        const control = (seq << 4) | (rxmit << 3) | ackSeq;
-        const dataFrame = this.makeFrame(control, data);
-        this.writeBuffer(dataFrame);
-    }
-
-    private *stuff(buffer: number[]): Generator<number> {
-        /* Byte stuff (escape) a string for transmission */
-        for (const byte of buffer) {
-            if (consts.RESERVED.includes(byte)) {
-                yield consts.ESCAPE;
-                yield byte ^ consts.STUFF;
-            } else {
-                yield byte;
-            }
-        }
-    }
-
-    private makeFrame(control: number, data?: Buffer): Buffer {
-        /* Construct a frame */
-        const frm = [control, ...(data || [])];
-        const crc = crc16ccitt(frm, 65535);
-        frm.push(crc >> 8);
-        frm.push(crc % 256);
-        return Buffer.from([...this.stuff(frm), consts.FLAG]);
-    }
-}

package/src/adapter/index.ts

@@ -1,3 +0,0 @@
-export {Adapter} from "./adapter";
-export * as Events from "./events";
-export * as TsType from "./tstype";

package/src/adapter/serialPort.ts

@@ -1,58 +0,0 @@
-/* v8 ignore start */
-
-import {type AutoDetectTypes, autoDetect, type OpenOptionsFromBinding, type SetOptions} from "@serialport/bindings-cpp";
-// This file was copied from https://github.com/serialport/node-serialport/blob/master/packages/serialport/lib/serialport.ts.
-import {type ErrorCallback, type OpenOptions, SerialPortStream, type StreamOptions} from "@serialport/stream";
-
-const DetectedBinding = autoDetect();
-
-export type SerialPortOpenOptions<T extends AutoDetectTypes> = Omit<StreamOptions<T>, "binding"> & OpenOptionsFromBinding<T>;
-
-export class SerialPort<T extends AutoDetectTypes = AutoDetectTypes> extends SerialPortStream<T> {
-    static list = DetectedBinding.list;
-    static readonly binding = DetectedBinding;
-
-    constructor(options: SerialPortOpenOptions<T>, openCallback?: ErrorCallback) {
-        const opts: OpenOptions<T> = {
-            binding: DetectedBinding as T,
-            ...options,
-        };
-        super(opts, openCallback);
-    }
-
-    public async asyncOpen(): Promise<void> {
-        return await new Promise((resolve, reject): void => {
-            this.open((err) => (err ? reject(err) : resolve()));
-        });
-    }
-
-    public async asyncClose(): Promise<void> {
-        return await new Promise((resolve, reject): void => {
-            this.close((err) => (err ? reject(err) : resolve()));
-        });
-    }
-
-    public async asyncFlush(): Promise<void> {
-        return await new Promise((resolve, reject): void => {
-            this.flush((err) => (err ? reject(err) : resolve()));
-        });
-    }
-
-    public async asyncFlushAndClose(): Promise<void> {
-        await this.asyncFlush();
-        await this.asyncClose();
-    }
-
-    public async asyncGet(): Promise<{cts: boolean; dsr: boolean; dcd: boolean}> {
-        return await new Promise((resolve, reject): void => {
-            // biome-ignore lint/style/noNonNullAssertion: ignored using `--suppress`
-            this.get((err, options?) => (err ? reject(err) : resolve(options!)));
-        });
-    }
-
-    public async asyncSet(options: SetOptions): Promise<void> {
-        return await new Promise((resolve, reject): void => {
-            this.set(options, (err) => (err ? reject(err) : resolve()));
-        });
-    }
-}

package/src/adapter/socketPortUtils.ts

@@ -1,16 +0,0 @@
-export function isTcpPath(path: string): boolean {
-    // tcp path must be:
-    // tcp://<host>:<port>
-    const regex = /^(?:tcp:\/\/)[\w.-]+[:][\d]+$/gm;
-    return regex.test(path);
-}
-
-export function parseTcpPath(path: string): {host: string; port: number} {
-    const str = path.replace("tcp://", "");
-    return {
-        host: str.substring(0, str.indexOf(":")),
-        port: Number(str.substring(str.indexOf(":") + 1)),
-    };
-}
-
-export default {isTcpPath, parseTcpPath};