zapo-js 0.1.0

package/dist/esm/transport/WaWebSocket.js

@@ -0,0 +1,361 @@
+import { ConsoleLogger } from '../infra/log/ConsoleLogger.js';
+import { WA_DEFAULTS, WA_READY_STATES } from '../protocol/constants.js';
+import { TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+import { toError } from '../util/primitives.js';
+function resolveWebSocketConstructor() {
+    const ctor = globalThis
+        .WebSocket;
+    if (!ctor) {
+        throw new Error('global WebSocket is not available in this runtime');
+    }
+    return ctor;
+}
+function resolveSocketUrls(config) {
+    const preferredUrls = config.urls;
+    if (preferredUrls && preferredUrls.length > 0) {
+        return Object.freeze(Array.from(new Set(preferredUrls)));
+    }
+    if (config.url) {
+        return Object.freeze([config.url]);
+    }
+    return WA_DEFAULTS.CHAT_SOCKET_URLS;
+}
+function resolveSocketRuntime() {
+    const maybeNodeProcess = globalThis.process;
+    if (typeof maybeNodeProcess?.versions?.node === 'string') {
+        return 'node';
+    }
+    return 'browser';
+}
+export class WaWebSocket {
+    constructor(config, logger = new ConsoleLogger('info')) {
+        this.config = Object.freeze({
+            ...config,
+            timeoutIntervalMs: config.timeoutIntervalMs ?? 10000
+        });
+        this.socketUrls = resolveSocketUrls(config);
+        this.logger = logger;
+        this.webSocketCtor = resolveWebSocketConstructor();
+        this.socketRuntime = resolveSocketRuntime();
+        this.connectingSockets = new Set();
+        this.handlers = {};
+        this.socket = null;
+        this.closeWaiter = null;
+    }
+    setHandlers(handlers) {
+        this.handlers = handlers;
+    }
+    isOpen() {
+        return this.socket?.readyState === WA_READY_STATES.OPEN;
+    }
+    isConnecting() {
+        return (this.socket?.readyState === WA_READY_STATES.CONNECTING ||
+            this.connectingSockets.size > 0);
+    }
+    getReadyState() {
+        if (this.connectingSockets.size > 0) {
+            return WA_READY_STATES.CONNECTING;
+        }
+        return this.socket?.readyState ?? WA_READY_STATES.CLOSED;
+    }
+    async open() {
+        if (this.isOpen()) {
+            this.logger.trace('socket open skipped: already open');
+            return { openedAt: Date.now() };
+        }
+        if (this.isConnecting()) {
+            throw new Error('websocket is already connecting');
+        }
+        this.logger.info('socket open start', { urls: this.socketUrls.length });
+        if (this.socketUrls.length === 1) {
+            return this.openSingle(this.socketUrls[0]);
+        }
+        return this.openConcurrently(this.socketUrls);
+    }
+    async close(code = 1000, reason = '') {
+        this.logger.debug('socket close requested', { code, reason });
+        const socket = this.socket;
+        if (!socket) {
+            if (this.connectingSockets.size > 0) {
+                for (const connectingSocket of this.connectingSockets) {
+                    this.closeSocketSafe(connectingSocket, code, reason);
+                }
+                this.connectingSockets.clear();
+                return {
+                    code,
+                    reason,
+                    wasClean: true
+                };
+            }
+            return null;
+        }
+        if (socket.readyState === WA_READY_STATES.CLOSED) {
+            this.socket = null;
+            return {
+                code,
+                reason,
+                wasClean: true
+            };
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.closeWaiter) {
+                    this.closeWaiter = null;
+                    if (this.socket === socket) {
+                        this.socket = null;
+                    }
+                    resolve({
+                        code,
+                        reason,
+                        wasClean: false
+                    });
+                }
+            }, this.config.timeoutIntervalMs);
+            this.closeWaiter = (info) => {
+                clearTimeout(timer);
+                if (this.socket === socket) {
+                    this.socket = null;
+                }
+                resolve(info);
+            };
+            try {
+                socket.close(code, reason);
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.closeWaiter = null;
+                if (this.socket === socket) {
+                    this.socket = null;
+                }
+                resolve({
+                    code,
+                    reason,
+                    wasClean: false
+                });
+                void this.handlers.onError?.(toError(error));
+            }
+        });
+    }
+    async send(data) {
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WA_READY_STATES.OPEN) {
+            throw new Error('websocket is not connected');
+        }
+        socket.send(data);
+    }
+    async openSingle(url) {
+        const pending = this.createPendingSocket(url);
+        return new Promise((resolve, reject) => {
+            this.bindPendingSocket(pending, {
+                onOpen: () => {
+                    if (!this.settlePendingSocket(pending)) {
+                        return;
+                    }
+                    resolve(this.activatePendingSocket(pending, 'socket open success'));
+                },
+                onFail: (error) => {
+                    if (!this.settlePendingSocket(pending)) {
+                        return;
+                    }
+                    if (this.socket === pending.socket) {
+                        this.socket = null;
+                    }
+                    reject(error);
+                }
+            });
+        });
+    }
+    async openConcurrently(urls) {
+        const pendingSockets = urls.map((url) => this.createPendingSocket(url));
+        return new Promise((resolve, reject) => {
+            let done = false;
+            let failedCount = 0;
+            let lastError = null;
+            const fail = (entry, error) => {
+                if (done || !this.settlePendingSocket(entry)) {
+                    return;
+                }
+                failedCount += 1;
+                lastError = error;
+                if (failedCount === pendingSockets.length) {
+                    done = true;
+                    reject(lastError ?? new Error('websocket connect error'));
+                }
+            };
+            const win = (entry) => {
+                if (!this.settlePendingSocket(entry)) {
+                    return;
+                }
+                if (done) {
+                    this.closeSocketSafe(entry.socket, 1000, 'loser_socket');
+                    return;
+                }
+                done = true;
+                for (const other of pendingSockets) {
+                    if (other.socket === entry.socket) {
+                        continue;
+                    }
+                    if (!this.settlePendingSocket(other)) {
+                        continue;
+                    }
+                    this.closeSocketSafe(other.socket, 1000, 'loser_socket');
+                }
+                resolve(this.activatePendingSocket(entry, 'socket open success (race winner)'));
+            };
+            for (const entry of pendingSockets) {
+                this.bindPendingSocket(entry, {
+                    onOpen: () => win(entry),
+                    onFail: (error) => fail(entry, error)
+                });
+            }
+        });
+    }
+    bindRuntimeHandlers(socket) {
+        socket.onmessage = (event) => {
+            void this.handleMessage(event.data);
+        };
+        socket.onerror = (event) => {
+            this.handleRuntimeError(event);
+        };
+        socket.onclose = (event) => {
+            this.handleRuntimeClose(socket, event);
+        };
+    }
+    async handleMessage(data) {
+        try {
+            const payload = await this.normalizePayload(data);
+            if (!payload) {
+                this.logger.trace('socket message ignored: unsupported payload shape');
+                return;
+            }
+            await this.handlers.onMessage?.(payload);
+        }
+        catch (error) {
+            this.logger.error('socket message handling failed', {
+                message: toError(error).message
+            });
+            void this.handlers.onError?.(toError(error));
+        }
+    }
+    async normalizePayload(data) {
+        if (data instanceof Uint8Array) {
+            return data;
+        }
+        if (data instanceof ArrayBuffer) {
+            return toBytesView(data);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return toBytesView(data);
+        }
+        if (typeof data === 'string') {
+            return TEXT_ENCODER.encode(data);
+        }
+        if (data && typeof data === 'object' && 'arrayBuffer' in data) {
+            const maybeBlob = data;
+            const buffer = await maybeBlob.arrayBuffer();
+            return toBytesView(buffer);
+        }
+        return null;
+    }
+    createPendingSocket(url) {
+        const socket = this.createRawSocket(url);
+        socket.binaryType = 'arraybuffer';
+        this.connectingSockets.add(socket);
+        return {
+            url,
+            socket,
+            timer: null,
+            settled: false
+        };
+    }
+    bindPendingSocket(entry, handlers) {
+        entry.timer = setTimeout(() => {
+            this.logger.warn('socket connect timeout', { url: entry.url });
+            this.closeSocketSafe(entry.socket, 4000, 'connect_timeout');
+            handlers.onFail(new Error(`websocket connect timeout for ${entry.url}`));
+        }, this.config.timeoutIntervalMs);
+        entry.socket.onopen = () => {
+            handlers.onOpen();
+        };
+        entry.socket.onerror = () => {
+            this.logger.warn('socket open error', { url: entry.url });
+            handlers.onFail(new Error(`websocket connect error for ${entry.url}`));
+        };
+        entry.socket.onclose = (event) => {
+            const info = this.toCloseInfo(event);
+            this.logger.warn('socket closed before open', {
+                url: entry.url,
+                code: info.code,
+                reason: info.reason
+            });
+            handlers.onFail(new Error(`websocket closed before open (${info.code}:${info.reason}) for ${entry.url}`));
+        };
+    }
+    settlePendingSocket(entry) {
+        if (entry.settled) {
+            return false;
+        }
+        entry.settled = true;
+        this.releasePendingSocket(entry);
+        return true;
+    }
+    releasePendingSocket(entry) {
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+            entry.timer = null;
+        }
+        this.connectingSockets.delete(entry.socket);
+    }
+    activatePendingSocket(entry, message) {
+        const info = { openedAt: Date.now() };
+        this.socket = entry.socket;
+        this.bindRuntimeHandlers(entry.socket);
+        this.logger.info(message, { url: entry.url });
+        void this.handlers.onOpen?.(info);
+        return info;
+    }
+    toCloseInfo(event) {
+        return {
+            code: typeof event.code === 'number' ? event.code : 1000,
+            reason: typeof event.reason === 'string' ? event.reason : '',
+            wasClean: event.wasClean === true
+        };
+    }
+    handleRuntimeError(event) {
+        void event;
+        this.logger.warn('socket runtime error event');
+        void this.handlers.onError?.(new Error('websocket runtime error'));
+    }
+    handleRuntimeClose(socket, event) {
+        const info = this.toCloseInfo(event);
+        this.logger.info('socket runtime closed', {
+            code: info.code,
+            reason: info.reason,
+            wasClean: info.wasClean
+        });
+        if (this.socket === socket) {
+            this.socket = null;
+        }
+        const waiter = this.closeWaiter;
+        this.closeWaiter = null;
+        if (waiter) {
+            waiter(info);
+        }
+        void this.handlers.onClose?.(info);
+    }
+    closeSocketSafe(socket, code, reason) {
+        try {
+            socket.close(code, reason);
+        }
+        catch {
+            // no-op
+        }
+    }
+    createRawSocket(url) {
+        const headers = this.config.headers;
+        if (this.socketRuntime === 'node' && headers && Object.keys(headers).length > 0) {
+            return new this.webSocketCtor(url, this.config.protocols, { headers });
+        }
+        return new this.webSocketCtor(url, this.config.protocols);
+    }
+}

package/dist/esm/transport/binary/constants.js

@@ -0,0 +1,96 @@
+import { DICTIONARIES, SINGLE_BYTE_TOKENS } from '../binary/tokens.js';
+export const LIST_EMPTY = 0;
+export const STREAM_END = 2;
+export const DICTIONARY_0 = 236;
+export const DICTIONARY_3 = 239;
+export const JID_INTEROP = 245;
+export const JID_FB = 246;
+export const JID_U = 247;
+export const LIST_8 = 248;
+export const LIST_16 = 249;
+export const JID_PAIR = 250;
+export const HEX_8 = 251;
+export const BINARY_8 = 252;
+export const BINARY_20 = 253;
+export const BINARY_32 = 254;
+export const NIBBLE_8 = 255;
+export const NIBBLE_ALPHABET = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '-',
+    '.',
+    '\uFFFD',
+    '\uFFFD',
+    '\uFFFD',
+    '\uFFFD'
+];
+export const HEX_ALPHABET = [
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F'
+];
+export const SINGLE_BYTE_TOKEN_MAP = (() => {
+    const map = new Map();
+    for (let i = 0; i < SINGLE_BYTE_TOKENS.length; i += 1) {
+        map.set(SINGLE_BYTE_TOKENS[i], i + 1);
+    }
+    return map;
+})();
+export const DICTIONARY_TOKEN_MAPS = DICTIONARIES.map((dictionary) => {
+    const map = new Map();
+    for (let i = 0; i < dictionary.length; i += 1) {
+        map.set(dictionary[i], i);
+    }
+    return map;
+});
+export const WAP_ENCODE_CONSTANTS = Object.freeze({
+    LIST_EMPTY,
+    LIST_8,
+    LIST_16,
+    JID_PAIR,
+    HEX_8,
+    BINARY_8,
+    BINARY_20,
+    BINARY_32,
+    NIBBLE_8,
+    DICTIONARY_0,
+    DICTIONARY_3
+});
+export const WAP_DECODE_CONSTANTS = Object.freeze({
+    LIST_EMPTY,
+    LIST_8,
+    LIST_16,
+    JID_PAIR,
+    JID_FB,
+    JID_INTEROP,
+    JID_U,
+    HEX_8,
+    BINARY_8,
+    BINARY_20,
+    BINARY_32,
+    NIBBLE_8,
+    DICTIONARY_0,
+    DICTIONARY_3,
+    STREAM_END
+});