saxi/dist/server/serialport-serialport.js

Drive the AxiDraw pen plotter

import { EventEmitter } from "node:events";
import { SerialPort as NodeSerialPort } from "serialport";
function readableStreamFromAsyncIterable(iterable) {
    const it = iterable[Symbol.asyncIterator]();
    return new ReadableStream({
        async pull(controller) {
            const { done, value } = await it.next();
            if (done) {
                controller.close();
            }
            else {
                controller.enqueue(value);
            }
        },
        async cancel(reason) {
            await it.throw(reason);
        },
    }, { highWaterMark: 0 });
}
export class SerialPortSerialPort extends EventEmitter {
    _path;
    _port;
    constructor(path) {
        super();
        this._path = path;
    }
    onconnect;
    ondisconnect;
    readable;
    writable;
    connected;
    forget() {
        return Promise.resolve();
    }
    open(options) {
        const opts = {
            baudRate: options.baudRate,
            path: this._path,
        };
        if (options.dataBits != null)
            opts.dataBits = options.dataBits;
        if (options.stopBits != null)
            opts.stopBits = options.stopBits;
        if (options.parity != null)
            opts.parity = options.parity;
        return new Promise((resolve, reject) => {
            this._port = new NodeSerialPort(opts, (closeErr) => {
                this._port.once("close", () => this.emit("disconnect"));
                if (closeErr)
                    reject(closeErr);
                else {
                    // Flush RX buffer before considering the port "ready"
                    this._port.flush((flushErr) => {
                        if (flushErr)
                            reject(flushErr);
                        else {
                            this.connected = true;
                            resolve();
                        }
                    });
                }
            });
            this.readable = readableStreamFromAsyncIterable(this._port);
            this.writable = new WritableStream({
                write: (chunk) => {
                    return new Promise((resolve, reject) => {
                        this._port.write(Buffer.from(chunk), (writeErr) => {
                            if (writeErr)
                                reject(writeErr);
                            else
                                resolve();
                            // TODO: check bytesWritten?
                        });
                    });
                },
            });
        });
    }
    setSignals(signals) {
        return new Promise((resolve, reject) => {
            this._port.set({
                dtr: signals.dataTerminalReady,
                rts: signals.requestToSend,
                brk: signals.break,
            }, (err) => {
                if (err)
                    reject(err);
                else
                    resolve();
            });
        });
    }
    getSignals() {
        throw new Error("Method not implemented.");
    }
    getInfo() {
        throw new Error("Method not implemented.");
    }
    close() {
        return new Promise((resolve, reject) => {
            this._port.close((err) => {
                if (err)
                    reject(err);
                else
                    resolve();
                this.connected = false;
            });
        });
    }
    // biome-ignore lint/suspicious/noExplicitAny: match EventEmitter
    addEventListener(type, listener, options) {
        if (typeof options === "object" && options.once) {
            this.once(type, listener);
        }
        else {
            this.on(type, listener);
        }
    }
    // biome-ignore lint/suspicious/noExplicitAny: match EventEmitter
    removeEventListener(type, callback, _options) {
        this.off(type, callback);
    }
    dispatchEvent(event) {
        return this.emit(event.type);
    }
}
//# sourceMappingURL=serialport-serialport.js.map