@akala/core/dist/esm/network/udp.js

import { EventEmitter } from "../events/event-emitter.js";
import { IsomorphicBuffer } from "../helpers.js";
import { StatefulSubscription } from "../teardown-manager.js";
import os from 'os';
export class UdpSocketAdapter extends EventEmitter {
    socket;
    constructor(socket) {
        super();
        this.socket = socket;
    }
    pipe(socket) {
        this.on('message', (message) => socket.send(message));
        this.on('close', () => socket.close());
    }
    /**
         * Tells the kernel to join a multicast group at the given `multicastAddress` and `multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the `multicastInterface` argument is not
         * specified, the operating system will choose
         * one interface and will add membership to it. To add membership to every
         * available interface, call `addMembership` multiple times, once per interface.
         *
         * When called on an unbound socket, this method will implicitly bind to a random
         * port, listening on all interfaces.
         *
         **/
    addMembership(address, interfaceAddress) {
        if (!interfaceAddress) {
            for (const netifs of Object.values(os.networkInterfaces())) {
                const netif = netifs.find(netif => netif.family == 'IPv4');
                if (!netif)
                    continue;
                this.socket.addMembership(address, netif.address);
            }
        }
        else
            this.socket.addMembership(address, interfaceAddress);
    }
    bind(port, address) {
        this.teardown(() => { const wasOpen = this.open; this.socket.close(); return wasOpen; });
        return new Promise(resolve => this.socket.bind(port, address, resolve));
    }
    closed;
    get open() {
        return !this.closed;
    }
    close() {
        return new Promise(resolve => this.socket.close(() => {
            this.closed = true;
            resolve();
        }));
    }
    send(data) {
        if (data.remote?.port)
            if (data.remote?.address)
                return new Promise((resolve, reject) => this.socket.send(data.message.toArray(), data.remote.port, data.remote.address, err => err ? reject(err) : resolve()));
            else
                return new Promise((resolve, reject) => this.socket.send(data.message.toArray(), data.remote.port, err => err ? reject(err) : resolve()));
        else
            return new Promise((resolve, reject) => this.socket.send(data.message.toArray(), err => err ? reject(err) : resolve()));
    }
    messageListeners = [];
    off(event, handler) {
        switch (event) {
            case 'message':
                {
                    let listeners = this.messageListeners;
                    if (handler)
                        listeners = listeners.filter(f => f[0] == handler);
                    var result = false;
                    for (const listener of listeners) {
                        this.socket.off('message', listener[1]);
                        result = !!this.messageListeners.splice(this.messageListeners.indexOf(listener), 1)?.length || result;
                    }
                }
                break;
            case 'close':
            case 'error':
            case 'open':
                //eslint-disable-next-line @typescript-eslint/no-explicit-any
                this.socket.off(event, handler);
                break;
            default:
                throw new Error(`Unsupported event ${String(event)}`);
        }
        return true;
    }
    on(event, handler, options) {
        switch (event) {
            case 'message':
                {
                    const x = function (data, remote) {
                        return handler.call(this, { message: IsomorphicBuffer.fromBuffer(data), remote });
                    };
                    this.messageListeners.push([handler, x]);
                    if (options?.once)
                        this.socket.once('message', x);
                    else
                        this.socket.on('message', x);
                    return new StatefulSubscription(() => {
                        this.messageListeners.splice(this.messageListeners.findIndex(x => x[0] === handler), 1);
                        this.socket.off('message', x);
                    }).unsubscribe;
                }
            case 'close':
            case 'error':
            case 'open':
                //eslint-disable-next-line @typescript-eslint/no-explicit-any
                if (options?.once)
                    this.socket.once(event, handler);
                else
                    this.socket.on(event, handler);
                return new StatefulSubscription(() => {
                    this.socket.off(event, handler);
                }).unsubscribe;
            case Symbol.dispose:
                return super.on(event, handler, options);
            default:
                throw new Error(`Unsupported event ${String(event)}`);
        }
    }
    once(event, handler) {
        switch (event) {
            case 'message':
                return this.on(event, handler, { once: true });
            case 'close':
            case 'error':
            case 'open':
            case Symbol.dispose:
                return this.on(event, handler, { once: true });
            default:
                let x = event;
                throw new Error(`Unsupported event ${x}`);
        }
    }
}
//# sourceMappingURL=udp.js.map