@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/cjs/lib/common/event.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDisposer = exports.Event = void 0;
+/**
+ * The subscribers of an event in their order. Unsubscribing marks a subscriber removed, in constant time; the list
+ * drops the removed ones once they outnumber the others, a copy left to the iterations going on
+ */
+class Subscribers {
+    constructor() {
+        this.list = [];
+        this.size = 0;
+        this.#removed = 0;
+    }
+    #removed;
+    add(subscriber) {
+        this.list.push(subscriber);
+        this.size++;
+    }
+    /**
+     * Remove a subscriber
+     * @param subscriber
+     * @returns Whether it was there
+     */
+    remove(subscriber) {
+        if (subscriber.removed)
+            return false;
+        subscriber.removed = true;
+        this.size--;
+        if (++this.#removed > 16 && this.#removed > this.size) {
+            this.list = this.list.filter((each) => !each.removed);
+            this.#removed = 0;
+        }
+        return true;
+    }
+    /**
+     * Remove them all: the iterations going on skip the ones they have not reached
+     */
+    clear() {
+        for (const subscriber of this.list)
+            subscriber.removed = true;
+        this.list = [];
+        this.size = 0;
+        this.#removed = 0;
+    }
+}
+class Event {
+    constructor() {
+        this.subscribers = new Subscribers();
+        this.queued = new Subscribers();
+        this.ended = false;
+        this.onerror = (_error) => { };
+        this.execute = (...args) => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (!item.removed)
+                    item.execute(...args);
+            }
+            //The queued subscribers run one after the other; without them, no promise is made
+            if (this.queued.size === 0)
+                return;
+            (async () => {
+                for (const item of this.queued.list) {
+                    if (!item.removed)
+                        await item.execute(...args);
+                }
+            })().catch((e) => {
+                this.onerror(e);
+            });
+        };
+        this.complete = () => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (item.complete && !item.removed) {
+                    item.complete();
+                }
+            }
+            this.allUnsubscribe();
+            this.ended = true;
+            if (this.onended) {
+                this.onended();
+                this.onended = undefined;
+            }
+        };
+        this.error = (e) => {
+            if (this.ended) {
+                return;
+            }
+            for (const item of this.subscribers.list) {
+                if (item.error && !item.removed) {
+                    item.error(e);
+                }
+            }
+            this.allUnsubscribe();
+        };
+        this.allUnsubscribe = () => {
+            // complete() 後の再呼び出しを許容し、close 経路での二重クリーンアップを安全にする
+            if (this.ended) {
+                return;
+            }
+            this.subscribers.clear();
+            this.queued.clear();
+            this.onsubscriberschange?.();
+        };
+        this.subscribe = (execute, complete, error) => {
+            const subscriber = { execute, complete, error };
+            const subscribers = this.subscribers;
+            subscribers.add(subscriber);
+            this.onsubscriberschange?.();
+            const unSubscribe = () => {
+                if (subscribers.remove(subscriber))
+                    this.onsubscriberschange?.();
+            };
+            const disposer = (disposer) => {
+                disposer.push(unSubscribe);
+            };
+            return { unSubscribe, disposer };
+        };
+        this.queuingSubscribe = (execute, complete, error) => {
+            if (this.ended)
+                throw new Error('event completed');
+            const subscriber = { execute, complete, error };
+            const queued = this.queued;
+            queued.add(subscriber);
+            const unSubscribe = () => {
+                queued.remove(subscriber);
+            };
+            const disposer = (disposer) => {
+                disposer.push(unSubscribe);
+            };
+            return { unSubscribe, disposer };
+        };
+        this.once = (execute, complete, error) => {
+            const off = this.subscribe((...args) => {
+                off.unSubscribe();
+                execute(...args);
+            }, complete, error);
+        };
+        this.watch = (cb, timeLimit) => new Promise((resolve, reject) => {
+            const timeout = timeLimit &&
+                setTimeout(() => {
+                    reject('Event watch timeout');
+                }, timeLimit);
+            const { unSubscribe } = this.subscribe((...args) => {
+                const done = cb(...args);
+                if (done) {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    unSubscribe();
+                    resolve(args);
+                }
+            });
+        });
+        this.asPromise = (timeLimit) => new Promise((resolve, reject) => {
+            const timeout = timeLimit &&
+                setTimeout(() => {
+                    reject('Event asPromise timeout');
+                }, timeLimit);
+            this.once((...args) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve(args);
+            }, () => {
+                if (timeout)
+                    clearTimeout(timeout);
+                resolve([]);
+            }, (err) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    pipe(e) {
+        this.subscribe((...args) => {
+            e.execute(...args);
+        });
+    }
+    get returnTrigger() {
+        const { execute, error, complete } = this;
+        return { execute, error, complete };
+    }
+    get returnListener() {
+        const { subscribe, once, asPromise } = this;
+        return { subscribe, once, asPromise };
+    }
+    get length() {
+        return this.subscribers.size;
+    }
+}
+exports.Event = Event;
+class EventDisposer {
+    constructor() {
+        this._disposer = [];
+    }
+    push(disposer) {
+        this._disposer.push(disposer);
+    }
+    dispose() {
+        this._disposer.forEach((d) => d());
+        this._disposer = [];
+    }
+}
+exports.EventDisposer = EventDisposer;

package/dist/cjs/lib/common/index.d.ts

@@ -0,0 +1,11 @@
+export * from './binary.js';
+export * from './crc.js';
+export * from './number.js';
+export * from './promise.js';
+export * from './network.js';
+export * from './type.js';
+export * from './log.js';
+export * from './event.js';
+export * from './transport.js';
+export * as binaryData from './binaryData.js';
+export * from './deque.js';

package/dist/cjs/lib/common/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryData = void 0;
+__exportStar(require("./binary.js"), exports);
+__exportStar(require("./crc.js"), exports);
+__exportStar(require("./number.js"), exports);
+__exportStar(require("./promise.js"), exports);
+__exportStar(require("./network.js"), exports);
+__exportStar(require("./type.js"), exports);
+__exportStar(require("./log.js"), exports);
+__exportStar(require("./event.js"), exports);
+__exportStar(require("./transport.js"), exports);
+exports.binaryData = __importStar(require("./binaryData.js"));
+__exportStar(require("./deque.js"), exports);

package/dist/cjs/lib/common/log.d.ts

@@ -0,0 +1,47 @@
+export declare class WeriftError extends Error {
+    message: string;
+    payload?: object;
+    path?: string;
+    constructor(props: Pick<WeriftError, 'message' | 'payload' | 'path'>);
+    toJSON(): {
+        message: string;
+        payload: any;
+        path: string | undefined;
+    };
+}
+/**
+ * Receives the debug messages of the WebRTC implementation: the namespace of the module (`webrtc/ice/ice`,
+ * `webrtc/sctp/sctp`…), then the arguments given to the logging function (a format string first, as with
+ * `util.format`). The messages of the worker threads of a media server or of a TURN server (`SFU` or `TURNServer` with
+ * `workers`) come already formatted, as one string starting with the number of the thread (`[thread 0] …`).
+ */
+export type DebugHandler = (namespace: string, args: unknown[]) => void;
+/**
+ * Told when a handler is set or removed (the worker threads of the media server and of the TURN server send their
+ * messages to the handler of the main thread while there is one)
+ */
+export declare const debugHandlerWatchers: Set<(set: boolean) => void>;
+/**
+ * Whether a handler is set
+ */
+export declare function hasDebugHandler(): boolean;
+/**
+ * Send the debug messages of the WebRTC implementation (ICE, DTLS, SCTP, TURN), including those of the worker threads of
+ * a media server or of a TURN server, to a handler, to find out why a connection fails; they are dropped by default.
+ * @param handler The handler, or undefined to drop them again.
+ * @example
+ * ```typescript
+ * import {format} from 'node:util'
+ * import {setDebugHandler} from '@lakutata/webrtc'
+ *
+ * //The messages of ICE only
+ * setDebugHandler((namespace: string, args: unknown[]): void => {
+ *     if (namespace.startsWith('webrtc/ice')) console.debug(namespace, format(...args))
+ * })
+ * ```
+ */
+export declare function setDebugHandler(handler: DebugHandler | undefined): void;
+/**
+ * The logging function of a module: it does nothing while no handler is set
+ */
+export declare function debug(namespace: string): (...args: unknown[]) => void;

package/dist/cjs/lib/common/log.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugHandlerWatchers = exports.WeriftError = void 0;
+exports.hasDebugHandler = hasDebugHandler;
+exports.setDebugHandler = setDebugHandler;
+exports.debug = debug;
+class WeriftError extends Error {
+    constructor(props) {
+        super(props.message);
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            payload: JSON.parse(JSON.stringify(this.payload)),
+            path: this.path
+        };
+    }
+}
+exports.WeriftError = WeriftError;
+let debugHandler;
+/**
+ * Told when a handler is set or removed (the worker threads of the media server and of the TURN server send their
+ * messages to the handler of the main thread while there is one)
+ */
+exports.debugHandlerWatchers = new Set();
+/**
+ * Whether a handler is set
+ */
+function hasDebugHandler() {
+    return !!debugHandler;
+}
+/**
+ * Send the debug messages of the WebRTC implementation (ICE, DTLS, SCTP, TURN), including those of the worker threads of
+ * a media server or of a TURN server, to a handler, to find out why a connection fails; they are dropped by default.
+ * @param handler The handler, or undefined to drop them again.
+ * @example
+ * ```typescript
+ * import {format} from 'node:util'
+ * import {setDebugHandler} from '@lakutata/webrtc'
+ *
+ * //The messages of ICE only
+ * setDebugHandler((namespace: string, args: unknown[]): void => {
+ *     if (namespace.startsWith('webrtc/ice')) console.debug(namespace, format(...args))
+ * })
+ * ```
+ */
+function setDebugHandler(handler) {
+    const changed = !!debugHandler !== !!handler;
+    debugHandler = handler;
+    if (changed)
+        for (const watcher of exports.debugHandlerWatchers)
+            watcher(!!handler);
+}
+/**
+ * The logging function of a module: it does nothing while no handler is set
+ */
+function debug(namespace) {
+    return (...args) => {
+        if (debugHandler)
+            debugHandler(namespace, args);
+    };
+}

package/dist/cjs/lib/common/network.d.ts

@@ -0,0 +1,10 @@
+import { type SocketType } from 'node:dgram';
+export type InterfaceAddresses = {
+    [K in SocketType]?: string;
+};
+export declare const interfaceAddress: (type: SocketType, interfaceAddresses: InterfaceAddresses | undefined) => string | undefined;
+export declare function randomPort(protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number>;
+export declare function randomPorts(num: number, protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number[]>;
+export declare function findPort(min: number, max: number, protocol?: SocketType, interfaceAddresses?: InterfaceAddresses): Promise<number>;
+export type Address = Readonly<[string, number]>;
+export declare function normalizeFamilyNodeV18(family: string | number): 4 | 6;

package/dist/cjs/lib/common/network.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interfaceAddress = void 0;
+exports.randomPort = randomPort;
+exports.randomPorts = randomPorts;
+exports.findPort = findPort;
+exports.normalizeFamilyNodeV18 = normalizeFamilyNodeV18;
+const node_dgram_1 = require("node:dgram");
+const interfaceAddress = (type, interfaceAddresses) => (interfaceAddresses ? interfaceAddresses[type] : undefined);
+exports.interfaceAddress = interfaceAddress;
+async function randomPort(protocol = 'udp4', interfaceAddresses) {
+    const socket = (0, node_dgram_1.createSocket)(protocol);
+    setImmediate(() => socket.bind({
+        port: 0,
+        address: (0, exports.interfaceAddress)(protocol, interfaceAddresses)
+    }));
+    await new Promise((r) => {
+        socket.once('error', r);
+        socket.once('listening', r);
+    });
+    const port = socket.address()?.port;
+    await new Promise((r) => socket.close(() => r()));
+    return port;
+}
+async function randomPorts(num, protocol = 'udp4', interfaceAddresses) {
+    return Promise.all([...Array(num)].map(() => randomPort(protocol, interfaceAddresses)));
+}
+async function findPort(min, max, protocol = 'udp4', interfaceAddresses) {
+    let port;
+    for (let i = min; i <= max; i++) {
+        const socket = (0, node_dgram_1.createSocket)(protocol);
+        setImmediate(() => socket.bind({
+            port: i,
+            address: (0, exports.interfaceAddress)(protocol, interfaceAddresses)
+        }));
+        const err = await new Promise((r) => {
+            socket.once('error', (e) => r(e));
+            socket.once('listening', () => r());
+        });
+        if (err) {
+            await new Promise((r) => socket.close(() => r()));
+            continue;
+        }
+        port = socket.address()?.port;
+        await new Promise((r) => socket.close(() => r()));
+        if (min <= port && port <= max) {
+            break;
+        }
+    }
+    if (!port)
+        throw new Error('port not found');
+    return port;
+}
+function normalizeFamilyNodeV18(family) {
+    if (family === 'IPv4')
+        return 4;
+    if (family === 'IPv6')
+        return 6;
+    return family;
+}

package/dist/cjs/lib/common/number.d.ts

@@ -0,0 +1,13 @@
+export declare function uint8Add(a: number, b: number): number;
+export declare function uint16Add(a: number, b: number): number;
+export declare function uint32Add(a: number, b: number): number;
+export declare function uint24(v: number): number;
+/**Return a > b */
+export declare function uint16Gt(a: number, b: number): boolean;
+/**Return a >= b */
+export declare function uint16Gte(a: number, b: number): boolean;
+/**Return a > b */
+export declare function uint32Gt(a: number, b: number): boolean;
+/**Return a >= b */
+export declare function uint32Gte(a: number, b: number): boolean;
+export declare const int: (n: number) => number;

package/dist/cjs/lib/common/number.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.int = void 0;
+exports.uint8Add = uint8Add;
+exports.uint16Add = uint16Add;
+exports.uint32Add = uint32Add;
+exports.uint24 = uint24;
+exports.uint16Gt = uint16Gt;
+exports.uint16Gte = uint16Gte;
+exports.uint32Gt = uint32Gt;
+exports.uint32Gte = uint32Gte;
+function uint8Add(a, b) {
+    return (a + b) & 0xff;
+}
+function uint16Add(a, b) {
+    return (a + b) & 0xffff;
+}
+function uint32Add(a, b) {
+    return Number((BigInt(a) + BigInt(b)) & 0xffffffffn);
+}
+function uint24(v) {
+    return v & 0xffffff;
+}
+/**Return a > b */
+function uint16Gt(a, b) {
+    const halfMod = 0x8000;
+    return (a < b && b - a > halfMod) || (a > b && a - b < halfMod);
+}
+/**Return a >= b */
+function uint16Gte(a, b) {
+    return a === b || uint16Gt(a, b);
+}
+/**Return a > b */
+function uint32Gt(a, b) {
+    const halfMod = 0x80000000;
+    return (a < b && b - a > halfMod) || (a > b && a - b < halfMod);
+}
+/**Return a >= b */
+function uint32Gte(a, b) {
+    return a === b || uint32Gt(a, b);
+}
+const int = (n) => Number.parseInt(n, 10);
+exports.int = int;

package/dist/cjs/lib/common/promise.d.ts

@@ -0,0 +1,21 @@
+export declare class PromiseQueue {
+    queue: {
+        promise: () => Promise<unknown>;
+        done: (...args: any[]) => void;
+        failed: (...args: any[]) => void;
+    }[];
+    running: boolean;
+    push: <T>(promise: () => Promise<T>) => Promise<T>;
+    private run;
+    cancel(): void;
+}
+/**
+ * Runs a function that may return a promise without waiting for it: a failure, thrown or rejected, goes to onError.
+ * For the callbacks of the applications and the tasks started in the background, whose failures must not become
+ * unhandled rejections
+ */
+export declare function runDetached(fn: () => unknown, onError: (error: unknown) => void): void;
+/**
+ * A function for an event or a timer: it runs fn without waiting for it, a failure going to onError
+ */
+export declare function detached<A extends unknown[]>(fn: (...args: A) => unknown, onError: (error: unknown) => void): (...args: A) => void;

package/dist/cjs/lib/common/promise.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseQueue = void 0;
+exports.runDetached = runDetached;
+exports.detached = detached;
+class PromiseQueue {
+    constructor() {
+        this.queue = [];
+        this.running = false;
+        this.push = (promise) => new Promise((r, f) => {
+            this.queue.push({ promise, done: r, failed: f });
+            if (!this.running) {
+                //run() catches the failures of the tasks
+                void this.run();
+            }
+        });
+    }
+    async run() {
+        const task = this.queue.shift();
+        if (task) {
+            this.running = true;
+            try {
+                const res = await task.promise();
+                task.done(res);
+            }
+            catch (error) {
+                task.failed(error);
+            }
+            void this.run();
+        }
+        else {
+            this.running = false;
+        }
+    }
+    cancel() {
+        this.queue = [];
+    }
+}
+exports.PromiseQueue = PromiseQueue;
+/**
+ * Runs a function that may return a promise without waiting for it: a failure, thrown or rejected, goes to onError.
+ * For the callbacks of the applications and the tasks started in the background, whose failures must not become
+ * unhandled rejections
+ */
+function runDetached(fn, onError) {
+    try {
+        const result = fn();
+        if (result instanceof Promise)
+            result.catch(onError);
+    }
+    catch (error) {
+        onError(error);
+    }
+}
+/**
+ * A function for an event or a timer: it runs fn without waiting for it, a failure going to onError
+ */
+function detached(fn, onError) {
+    //As runDetached, without a closure for each call (an event of each packet)
+    return (...args) => {
+        try {
+            const result = fn(...args);
+            if (result instanceof Promise)
+                result.catch(onError);
+        }
+        catch (error) {
+            onError(error);
+        }
+    };
+}