@foxglove/ros1/dist/nodejs/TcpServerNode.js

Standalone TypeScript implementation of the ROS 1 (Robot Operating System) protocol with a pluggable transport layer

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TcpServerNode = void 0;
const eventemitter3_1 = __importDefault(require("eventemitter3"));
const net_1 = __importDefault(require("net"));
const TcpSocketNode_1 = require("./TcpSocketNode");
class TcpServerNode extends eventemitter3_1.default {
    constructor(server) {
        super();
        this._server = server;
        server.on("close", () => this.emit("close"));
        server.on("connection", (socket) => {
            const host = socket.remoteAddress;
            const port = socket.remotePort;
            if (host != undefined && port != undefined) {
                this.emit("connection", new TcpSocketNode_1.TcpSocketNode(host, port, socket));
            }
        });
        server.on("error", (err) => this.emit("error", err));
    }
    async address() {
        const addr = this._server.address();
        if (addr == undefined || typeof addr === "string") {
            // Address will only be a string for an IPC (named pipe) server, which
            // should never happen in TcpServerNode
            return undefined;
        }
        return addr;
    }
    close() {
        this._server.close();
    }
    static async Listen(options) {
        return await new Promise((resolve, reject) => {
            const server = net_1.default.createServer();
            server.on("error", reject);
            server.listen(options.port, options.host, options.backlog, () => {
                server.removeListener("error", reject);
                resolve(new TcpServerNode(server));
            });
        });
    }
}
exports.TcpServerNode = TcpServerNode;
//# sourceMappingURL=TcpServerNode.js.map