saxi/dist/server/serialport-serialport.js

Drive the AxiDraw pen plotter

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SerialPortSerialPort = void 0;
const node_events_1 = require("node:events");
const serialport_1 = require("serialport");
function readableStreamFromAsyncIterable(iterable) {
    const it = iterable[Symbol.asyncIterator]();
    return new ReadableStream({
        pull(controller) {
            return __awaiter(this, void 0, void 0, function* () {
                const { done, value } = yield it.next();
                if (done) {
                    controller.close();
                }
                else {
                    controller.enqueue(value);
                }
            });
        },
        cancel(reason) {
            return __awaiter(this, void 0, void 0, function* () {
                yield it.throw(reason);
            });
        }
    }, { highWaterMark: 0 });
}
class SerialPortSerialPort extends node_events_1.EventEmitter {
    constructor(path) {
        super();
        this._path = path;
    }
    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;
        /*
          TODO:
          bufferSize?: number | undefined;
          flowControl?: FlowControlType | undefined;
          */
        return new Promise((resolve, reject) => {
            this._port = new serialport_1.SerialPort(opts, (err) => {
                this._port.once('close', () => this.emit('disconnect'));
                if (err)
                    reject(err);
                else {
                    // Drain the port
                    while (this._port.read() != null) { /* do nothing */ }
                    resolve();
                }
            });
            this.readable = readableStreamFromAsyncIterable(this._port);
            this.writable = new WritableStream({
                write: (chunk) => {
                    return new Promise((resolve, reject) => {
                        this._port.write(Buffer.from(chunk), (err) => {
                            if (err)
                                reject(err);
                            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();
            });
        });
    }
    addEventListener(type, listener, options) {
        if (typeof options === 'object' && options.once) {
            this.once(type, listener);
        }
        else {
            this.on(type, listener);
        }
    }
    removeEventListener(type, callback, options) {
        if (typeof options === 'object' && options.once) {
            this.off(type, callback);
        }
        else {
            this.off(type, callback);
        }
    }
    dispatchEvent(event) {
        return this.emit(event.type);
    }
}
exports.SerialPortSerialPort = SerialPortSerialPort;
//# sourceMappingURL=serialport-serialport.js.map