zapo-js 0.1.2 → 0.3.0

package/dist/store/providers/memory/pre-key.store.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaPreKeyMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_PRE_KEYS = 4096;
+class WaPreKeyMemoryStore {
+    constructor(options = {}) {
+        this.preKeys = new Map();
+        this.uploadedPreKeys = new Set();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+        this.maxPreKeys = (0, coercion_1.resolvePositive)(options.maxPreKeys, DEFAULT_MAX_PRE_KEYS, 'WaPreKeyMemoryStoreOptions.maxPreKeys');
+    }
+    async putPreKey(record) {
+        (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+            this.uploadedPreKeys.delete(keyId);
+        });
+        if (record.keyId >= this.nextPreKeyId) {
+            this.nextPreKeyId = record.keyId + 1;
+        }
+    }
+    async getOrGenPreKeys(count, generator) {
+        if (!Number.isSafeInteger(count) || count <= 0) {
+            throw new Error(`invalid prekey count: ${count}`);
+        }
+        const available = [];
+        const availableKeyIds = [];
+        for (const keyId of this.preKeys.keys()) {
+            if (!this.uploadedPreKeys.has(keyId)) {
+                availableKeyIds.push(keyId);
+            }
+        }
+        availableKeyIds.sort((left, right) => left - right);
+        for (let index = 0; index < availableKeyIds.length; index += 1) {
+            const keyId = availableKeyIds[index];
+            const record = this.preKeys.get(keyId);
+            if (!record) {
+                continue;
+            }
+            available.push(record);
+            if (available.length >= count) {
+                return available;
+            }
+        }
+        while (available.length < count) {
+            const record = await generator(this.nextPreKeyId++);
+            (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
+                this.uploadedPreKeys.delete(keyId);
+            });
+            available.push(record);
+        }
+        return available;
+    }
+    async getPreKeyById(keyId) {
+        return this.preKeys.get(keyId) ?? null;
+    }
+    async getPreKeysById(keyIds) {
+        const result = new Array(keyIds.length);
+        for (let i = 0; i < keyIds.length; i += 1) {
+            result[i] = this.preKeys.get(keyIds[i]) ?? null;
+        }
+        return result;
+    }
+    async consumePreKeyById(keyId) {
+        const record = this.preKeys.get(keyId) ?? null;
+        if (!record) {
+            return null;
+        }
+        this.preKeys.delete(keyId);
+        this.uploadedPreKeys.delete(keyId);
+        return record;
+    }
+    async getOrGenSinglePreKey(generator) {
+        const preKeys = await this.getOrGenPreKeys(1, generator);
+        return preKeys[0];
+    }
+    async markKeyAsUploaded(keyId) {
+        if (keyId < 0 || keyId >= this.nextPreKeyId) {
+            throw new Error(`prekey ${keyId} is out of boundary`);
+        }
+        for (const candidate of this.preKeys.keys()) {
+            if (candidate <= keyId) {
+                this.uploadedPreKeys.add(candidate);
+            }
+        }
+    }
+    async setServerHasPreKeys(value) {
+        this.serverHasPreKeys = value;
+    }
+    async getServerHasPreKeys() {
+        return this.serverHasPreKeys;
+    }
+    async clear() {
+        this.preKeys.clear();
+        this.uploadedPreKeys.clear();
+        this.serverHasPreKeys = false;
+        this.nextPreKeyId = 1;
+    }
+}
+exports.WaPreKeyMemoryStore = WaPreKeyMemoryStore;

package/dist/store/providers/memory/privacy-token.store.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaPrivacyTokenMemoryStore = void 0;
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_ENTRIES = 10000;
+class WaPrivacyTokenMemoryStore {
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        this.records = new Map();
+        this.maxEntries = maxEntries;
+    }
+    async upsert(record) {
+        const existing = this.records.get(record.jid);
+        const merged = existing ? this.mergeRecord(existing, record) : record;
+        (0, collections_1.setBoundedMapEntry)(this.records, record.jid, merged, this.maxEntries);
+    }
+    async upsertBatch(records) {
+        for (let i = 0; i < records.length; i += 1) {
+            const record = records[i];
+            const existing = this.records.get(record.jid);
+            const merged = existing ? this.mergeRecord(existing, record) : record;
+            (0, collections_1.setBoundedMapEntry)(this.records, record.jid, merged, this.maxEntries);
+        }
+    }
+    async getByJid(jid) {
+        return this.records.get(jid) ?? null;
+    }
+    async deleteByJid(jid) {
+        return this.records.delete(jid) ? 1 : 0;
+    }
+    async clear() {
+        this.records.clear();
+    }
+    async destroy() {
+        this.records.clear();
+    }
+    mergeRecord(existing, incoming) {
+        return {
+            jid: incoming.jid,
+            tcToken: incoming.tcToken ?? existing.tcToken,
+            tcTokenTimestamp: incoming.tcTokenTimestamp ?? existing.tcTokenTimestamp,
+            tcTokenSenderTimestamp: incoming.tcTokenSenderTimestamp ?? existing.tcTokenSenderTimestamp,
+            nctSalt: incoming.nctSalt ?? existing.nctSalt,
+            updatedAtMs: incoming.updatedAtMs
+        };
+    }
+}
+exports.WaPrivacyTokenMemoryStore = WaPrivacyTokenMemoryStore;

package/dist/store/providers/memory/retry.store.js

@@ -1,23 +1,95 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaRetryMemoryStore = void 0;
+const coercion_1 = require("../../../util/coercion");
 const collections_1 = require("../../../util/collections");
-const DEFAULT_RETRY_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULTS = Object.freeze({
+    ttlMs: 60 * 1000,
+    maxOutboundMessages: 10000,
+    maxInboundCounters: 20000
+});
 class WaRetryMemoryStore {
-    constructor(ttlMs = DEFAULT_RETRY_TTL_MS) {
+    constructor(ttlMs = DEFAULTS.ttlMs, options = {}) {
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new Error('retry ttlMs must be a positive finite number');
+        }
         this.outboundMessages = new Map();
+        this.eligibleSets = new Map();
         this.inboundCounters = new Map();
         this.ttlMs = ttlMs;
+        this.maxOutboundMessages = (0, coercion_1.resolvePositive)(options.maxOutboundMessages, DEFAULTS.maxOutboundMessages, 'WaRetryMemoryStoreOptions.maxOutboundMessages');
+        this.maxInboundCounters = (0, coercion_1.resolvePositive)(options.maxInboundCounters, DEFAULTS.maxInboundCounters, 'WaRetryMemoryStoreOptions.maxInboundCounters');
         this.cleanupTimer = setInterval(() => {
             void this.cleanupExpired(Date.now());
-        }, (0, collections_1.resolveCleanupIntervalMs)(ttlMs));
+        }, (0, collections_1.resolveCleanupIntervalMs)(this.ttlMs));
         this.cleanupTimer.unref();
     }
     getTtlMs() {
         return this.ttlMs;
     }
+    supportsRawReplayPayload() {
+        return true;
+    }
+    async getOutboundRequesterStatus(messageId, requesterDeviceJid) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return null;
+        }
+        const eligible = current.eligibleRequesterDeviceJids;
+        if (!eligible || eligible.length === 0) {
+            return null;
+        }
+        const eligibleSet = this.eligibleSets.get(current.messageId);
+        let isEligible = false;
+        if (eligibleSet) {
+            isEligible = eligibleSet.has(requesterDeviceJid);
+        }
+        else {
+            for (let index = 0; index < eligible.length; index += 1) {
+                if (eligible[index] === requesterDeviceJid) {
+                    isEligible = true;
+                    break;
+                }
+            }
+        }
+        if (!isEligible) {
+            return { eligible: false, delivered: false };
+        }
+        const delivered = current.deliveredRequesterDeviceJids;
+        if (!delivered || delivered.length === 0) {
+            return { eligible: true, delivered: false };
+        }
+        for (let index = 0; index < delivered.length; index += 1) {
+            if (delivered[index] === requesterDeviceJid) {
+                return { eligible: true, delivered: true };
+            }
+        }
+        return { eligible: true, delivered: false };
+    }
     async upsertOutboundMessage(record) {
-        this.outboundMessages.set(record.messageId, record);
+        const storedRecord = {
+            ...record,
+            eligibleRequesterDeviceJids: record.eligibleRequesterDeviceJids
+                ? [...record.eligibleRequesterDeviceJids]
+                : undefined,
+            deliveredRequesterDeviceJids: record.deliveredRequesterDeviceJids
+                ? [...record.deliveredRequesterDeviceJids]
+                : undefined
+        };
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, record.messageId, storedRecord, this.maxOutboundMessages, (messageId) => {
+            this.eligibleSets.delete(messageId);
+        });
+        if (record.eligibleRequesterDeviceJids && record.eligibleRequesterDeviceJids.length > 0) {
+            this.eligibleSets.set(record.messageId, new Set(record.eligibleRequesterDeviceJids));
+        }
+        else {
+            this.eligibleSets.delete(record.messageId);
+        }
+    }
+    async deleteOutboundMessage(messageId) {
+        const existed = this.outboundMessages.delete(messageId);
+        this.eligibleSets.delete(messageId);
+        return existed ? 1 : 0;
     }
     async getOutboundMessage(messageId) {
         return this.outboundMessages.get(messageId) ?? null;
@@ -27,21 +99,36 @@ class WaRetryMemoryStore {
         if (!current) {
             return;
         }
-        this.outboundMessages.set(messageId, {
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, messageId, {
             ...current,
             state,
             updatedAtMs,
             expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
+        });
+    }
+    async markOutboundRequesterDelivered(messageId, requesterDeviceJid, updatedAtMs, expiresAtMs) {
+        const current = this.outboundMessages.get(messageId);
+        if (!current) {
+            return;
+        }
+        const delivered = new Set(current.deliveredRequesterDeviceJids ?? []);
+        delivered.add(requesterDeviceJid);
+        (0, collections_1.setBoundedMapEntry)(this.outboundMessages, messageId, {
+            ...current,
+            deliveredRequesterDeviceJids: Array.from(delivered),
+            updatedAtMs,
+            expiresAtMs
+        }, this.maxOutboundMessages, (evictedMessageId) => {
+            this.eligibleSets.delete(evictedMessageId);
         });
     }
     async incrementInboundCounter(messageId, requesterJid, _updatedAtMs, expiresAtMs) {
         const key = this.counterKey(messageId, requesterJid);
         const current = this.inboundCounters.get(key);
         const count = current ? current.count + 1 : 1;
-        this.inboundCounters.set(key, {
-            count,
-            expiresAtMs
-        });
+        (0, collections_1.setBoundedMapEntry)(this.inboundCounters, key, { count, expiresAtMs }, this.maxInboundCounters);
         return count;
     }
     async cleanupExpired(nowMs) {
@@ -50,6 +137,7 @@ class WaRetryMemoryStore {
             if (record.expiresAtMs > nowMs)
                 continue;
             this.outboundMessages.delete(messageId);
+            this.eligibleSets.delete(messageId);
             removed += 1;
         }
         for (const [key, record] of this.inboundCounters) {
@@ -62,6 +150,7 @@ class WaRetryMemoryStore {
     }
     async clear() {
         this.outboundMessages.clear();
+        this.eligibleSets.clear();
         this.inboundCounters.clear();
     }
     async destroy() {

package/dist/store/providers/memory/sender-key.store.js

@@ -49,7 +49,12 @@ class SenderKeyMemoryStore {
         return record ?? null;
     }
     async getDeviceSenderKeyDistributions(groupId, senders) {
-        return senders.map((sender) => this.senderDistributions.get(this.makeKey(groupId, sender)) ?? null);
+        const records = new Array(senders.length);
+        for (let index = 0; index < senders.length; index += 1) {
+            records[index] =
+                this.senderDistributions.get(this.makeKey(groupId, senders[index])) ?? null;
+        }
+        return records;
     }
     async deleteDeviceSenderKey(target, groupId) {
         let deleted = 0;

package/dist/store/providers/memory/session.store.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaSessionMemoryStore = void 0;
+const jid_1 = require("../../../protocol/jid");
+const coercion_1 = require("../../../util/coercion");
+const collections_1 = require("../../../util/collections");
+const DEFAULT_MAX_SESSIONS = 8192;
+class WaSessionMemoryStore {
+    constructor(options = {}) {
+        this.signalSessions = new Map();
+        this.maxSessions = (0, coercion_1.resolvePositive)(options.maxSessions, DEFAULT_MAX_SESSIONS, 'WaSessionMemoryStoreOptions.maxSessions');
+    }
+    async hasSession(address) {
+        return this.signalSessions.has((0, jid_1.signalAddressKey)(address));
+    }
+    async hasSessions(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.has((0, jid_1.signalAddressKey)(addresses[i]));
+        }
+        return result;
+    }
+    async getSession(address) {
+        return this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null;
+    }
+    async getSessionsBatch(addresses) {
+        const result = new Array(addresses.length);
+        for (let i = 0; i < addresses.length; i += 1) {
+            result[i] = this.signalSessions.get((0, jid_1.signalAddressKey)(addresses[i])) ?? null;
+        }
+        return result;
+    }
+    async setSession(address, session) {
+        (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(address), session, this.maxSessions);
+    }
+    async setSessionsBatch(entries) {
+        for (let index = 0; index < entries.length; index += 1) {
+            const entry = entries[index];
+            (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(entry.address), entry.session, this.maxSessions);
+        }
+    }
+    async deleteSession(address) {
+        this.signalSessions.delete((0, jid_1.signalAddressKey)(address));
+    }
+    async clear() {
+        this.signalSessions.clear();
+    }
+}
+exports.WaSessionMemoryStore = WaSessionMemoryStore;

package/dist/store/providers/memory/signal.store.js

@@ -1,28 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WaSignalMemoryStore = void 0;
-const jid_1 = require("../../../protocol/jid");
-const coercion_1 = require("../../../util/coercion");
-const collections_1 = require("../../../util/collections");
-const DEFAULT_SIGNAL_STORE_LIMITS = Object.freeze({
-    preKeys: 4096,
-    sessions: 8192,
-    remoteIdentities: 8192
-});
 class WaSignalMemoryStore {
-    constructor(options = {}) {
+    constructor() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys = new Map();
-        this.uploadedPreKeys = new Set();
-        this.serverHasPreKeys = false;
-        this.signalSessions = new Map();
-        this.remoteIdentities = new Map();
-        this.nextPreKeyId = 1;
-        this.maxPreKeys = (0, coercion_1.resolvePositive)(options.maxPreKeys, DEFAULT_SIGNAL_STORE_LIMITS.preKeys, 'WaSignalMemoryStoreOptions.maxPreKeys');
-        this.maxSessions = (0, coercion_1.resolvePositive)(options.maxSessions, DEFAULT_SIGNAL_STORE_LIMITS.sessions, 'WaSignalMemoryStoreOptions.maxSessions');
-        this.maxRemoteIdentities = (0, coercion_1.resolvePositive)(options.maxRemoteIdentities, DEFAULT_SIGNAL_STORE_LIMITS.remoteIdentities, 'WaSignalMemoryStoreOptions.maxRemoteIdentities');
     }
     async getRegistrationInfo() {
         return this.registrationInfo;
@@ -48,139 +31,10 @@ class WaSignalMemoryStore {
     async getSignedPreKeyRotationTs() {
         return this.signedPreKeyRotationTs;
     }
-    async putPreKey(record) {
-        (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-            this.uploadedPreKeys.delete(keyId);
-        });
-        if (record.keyId >= this.nextPreKeyId) {
-            this.nextPreKeyId = record.keyId + 1;
-        }
-    }
-    async getOrGenPreKeys(count, generator) {
-        if (!Number.isSafeInteger(count) || count <= 0) {
-            throw new Error(`invalid prekey count: ${count}`);
-        }
-        const available = [];
-        const sortedIds = [...this.preKeys.keys()].sort((left, right) => left - right);
-        for (let index = 0; index < sortedIds.length; index += 1) {
-            const keyId = sortedIds[index];
-            if (this.uploadedPreKeys.has(keyId)) {
-                continue;
-            }
-            const record = this.preKeys.get(keyId);
-            if (!record) {
-                continue;
-            }
-            available.push(record);
-            if (available.length >= count) {
-                return available;
-            }
-        }
-        while (available.length < count) {
-            const record = await generator(this.nextPreKeyId++);
-            (0, collections_1.setBoundedMapEntry)(this.preKeys, record.keyId, record, this.maxPreKeys, (keyId) => {
-                this.uploadedPreKeys.delete(keyId);
-            });
-            available.push(record);
-        }
-        return available;
-    }
-    async getPreKeyById(keyId) {
-        return this.preKeys.get(keyId) ?? null;
-    }
-    async getPreKeysById(keyIds) {
-        return keyIds.map((keyId) => this.preKeys.get(keyId) ?? null);
-    }
-    async consumePreKeyById(keyId) {
-        const record = this.preKeys.get(keyId) ?? null;
-        if (!record) {
-            return null;
-        }
-        this.preKeys.delete(keyId);
-        this.uploadedPreKeys.delete(keyId);
-        return record;
-    }
-    async getOrGenSinglePreKey(generator) {
-        const preKeys = await this.getOrGenPreKeys(1, generator);
-        return preKeys[0];
-    }
-    async markKeyAsUploaded(keyId) {
-        if (keyId < 0 || keyId >= this.nextPreKeyId) {
-            throw new Error(`prekey ${keyId} is out of boundary`);
-        }
-        for (const candidate of this.preKeys.keys()) {
-            if (candidate <= keyId) {
-                this.addUploadedPreKey(candidate);
-            }
-        }
-    }
-    async setServerHasPreKeys(value) {
-        this.serverHasPreKeys = value;
-    }
-    async getServerHasPreKeys() {
-        return this.serverHasPreKeys;
-    }
-    async hasSession(address) {
-        return this.signalSessions.has((0, jid_1.signalAddressKey)(address));
-    }
-    async hasSessions(addresses) {
-        return addresses.map((address) => this.signalSessions.has((0, jid_1.signalAddressKey)(address)));
-    }
-    async getSession(address) {
-        return this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null;
-    }
-    async getSessionsBatch(addresses) {
-        return addresses.map((address) => this.signalSessions.get((0, jid_1.signalAddressKey)(address)) ?? null);
-    }
-    async setSession(address, session) {
-        (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(address), session, this.maxSessions);
-    }
-    async setSessionsBatch(entries) {
-        for (let index = 0; index < entries.length; index += 1) {
-            const entry = entries[index];
-            (0, collections_1.setBoundedMapEntry)(this.signalSessions, (0, jid_1.signalAddressKey)(entry.address), entry.session, this.maxSessions);
-        }
-    }
-    async deleteSession(address) {
-        this.signalSessions.delete((0, jid_1.signalAddressKey)(address));
-    }
-    async getRemoteIdentity(address) {
-        return this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null;
-    }
-    async getRemoteIdentities(addresses) {
-        return addresses.map((address) => this.remoteIdentities.get((0, jid_1.signalAddressKey)(address)) ?? null);
-    }
-    async setRemoteIdentity(address, identityKey) {
-        (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(address), identityKey, this.maxRemoteIdentities);
-    }
-    async setRemoteIdentities(entries) {
-        for (const entry of entries) {
-            (0, collections_1.setBoundedMapEntry)(this.remoteIdentities, (0, jid_1.signalAddressKey)(entry.address), entry.identityKey, this.maxRemoteIdentities);
-        }
-    }
     async clear() {
         this.registrationInfo = null;
         this.signedPreKey = null;
         this.signedPreKeyRotationTs = null;
-        this.preKeys.clear();
-        this.uploadedPreKeys.clear();
-        this.serverHasPreKeys = false;
-        this.signalSessions.clear();
-        this.remoteIdentities.clear();
-        this.nextPreKeyId = 1;
-    }
-    addUploadedPreKey(keyId) {
-        if (this.uploadedPreKeys.has(keyId)) {
-            this.uploadedPreKeys.delete(keyId);
-        }
-        this.uploadedPreKeys.add(keyId);
-        while (this.uploadedPreKeys.size > this.maxPreKeys) {
-            const oldest = this.uploadedPreKeys.values().next().value;
-            if (oldest === undefined) {
-                break;
-            }
-            this.uploadedPreKeys.delete(oldest);
-        }
     }
 }
 exports.WaSignalMemoryStore = WaSignalMemoryStore;

package/dist/transport/WaComms.js

@@ -7,7 +7,6 @@ const constants_1 = require("../protocol/constants");
 const WaNoiseSession_1 = require("./noise/WaNoiseSession");
 const WaWebSocket_1 = require("./WaWebSocket");
 const bytes_1 = require("../util/bytes");
-const bytes_2 = require("../util/bytes");
 const primitives_1 = require("../util/primitives");
 const WA_FRAME_HANDLER_QUEUE_MAX_SIZE = 4096;
 const WA_FRAME_HANDLER_MAX_CONCURRENCY = 8;
@@ -32,7 +31,9 @@ class WaComms {
             protocols: this.config.protocols,
             dispatcher: this.config.dispatcher,
             agent: this.config.agent,
-            timeoutIntervalMs: this.config.timeoutIntervalMs
+            headers: this.config.headers,
+            timeoutIntervalMs: this.config.timeoutIntervalMs,
+            rawWebSocketConstructor: this.config.rawWebSocketConstructor
         }, logger);
         this.socket.setHandlers({
             onOpen: async () => {
@@ -340,7 +341,7 @@ class WaComms {
             this.noiseSession = null;
             throw error;
         }
-        const buffered = await session.pushWireChunk(bytes_2.EMPTY_BYTES);
+        const buffered = await session.pushWireChunk(bytes_1.EMPTY_BYTES);
         this.routeDecodedFrames(buffered);
         this.resumeHandshakeFailures = 0;
         this.lastServerStaticKey = session.getServerStaticKey();
@@ -402,7 +403,9 @@ class WaComms {
             this.schedulePendingFramesOverflowClose();
             return false;
         }
-        this.pendingFrames.push(...frames);
+        for (let i = 0; i < frames.length; i += 1) {
+            this.pendingFrames.push(frames[i]);
+        }
         this.pendingFramesByteLength = nextBytes;
         return true;
     }

package/dist/transport/WaWebSocket.js

@@ -111,7 +111,8 @@ class WaWebSocket {
         });
         this.socketUrls = resolveSocketUrls(config);
         this.logger = logger;
-        this.webSocketCtor = resolveWebSocketConstructor();
+        this.webSocketCtor = config.rawWebSocketConstructor ?? resolveWebSocketConstructor();
+        this.customWebSocketCtor = Boolean(config.rawWebSocketConstructor);
         this.socketRuntime = resolveSocketRuntime();
         this.connectingSockets = new Set();
         this.handlers = {};
@@ -129,12 +130,6 @@ class WaWebSocket {
         return (this.socket?.readyState === constants_1.WA_READY_STATES.CONNECTING ||
             this.connectingSockets.size > 0);
     }
-    getReadyState() {
-        if (this.connectingSockets.size > 0) {
-            return constants_1.WA_READY_STATES.CONNECTING;
-        }
-        return this.socket?.readyState ?? constants_1.WA_READY_STATES.CLOSED;
-    }
     async open() {
         if (this.isOpen()) {
             this.logger.trace('socket open skipped: already open');
@@ -453,6 +448,13 @@ class WaWebSocket {
         const headers = this.config.headers;
         const dispatcher = this.config.dispatcher;
         const agent = this.config.agent;
+        if (this.customWebSocketCtor) {
+            return new this.webSocketCtor(url, this.config.protocols, {
+                headers,
+                dispatcher,
+                agent
+            });
+        }
         let hasHeaders = false;
         if (headers) {
             for (const key in headers) {

package/dist/transport/binary/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WAP_DECODE_CONSTANTS = exports.WAP_ENCODE_CONSTANTS = exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
+exports.DICTIONARY_TOKEN_MAPS = exports.SINGLE_BYTE_TOKEN_MAP = exports.HEX_ALPHABET = exports.NIBBLE_ALPHABET = exports.NIBBLE_8 = exports.BINARY_32 = exports.BINARY_20 = exports.BINARY_8 = exports.HEX_8 = exports.JID_PAIR = exports.LIST_16 = exports.LIST_8 = exports.JID_U = exports.JID_FB = exports.JID_INTEROP = exports.DICTIONARY_3 = exports.DICTIONARY_0 = exports.STREAM_END = exports.LIST_EMPTY = void 0;
 const tokens_1 = require("../binary/tokens");
 exports.LIST_EMPTY = 0;
 exports.STREAM_END = 2;
@@ -67,33 +67,3 @@ exports.DICTIONARY_TOKEN_MAPS = tokens_1.DICTIONARIES.map((dictionary) => {
     }
     return map;
 });
-exports.WAP_ENCODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY: exports.LIST_EMPTY,
-    LIST_8: exports.LIST_8,
-    LIST_16: exports.LIST_16,
-    JID_PAIR: exports.JID_PAIR,
-    HEX_8: exports.HEX_8,
-    BINARY_8: exports.BINARY_8,
-    BINARY_20: exports.BINARY_20,
-    BINARY_32: exports.BINARY_32,
-    NIBBLE_8: exports.NIBBLE_8,
-    DICTIONARY_0: exports.DICTIONARY_0,
-    DICTIONARY_3: exports.DICTIONARY_3
-});
-exports.WAP_DECODE_CONSTANTS = Object.freeze({
-    LIST_EMPTY: exports.LIST_EMPTY,
-    LIST_8: exports.LIST_8,
-    LIST_16: exports.LIST_16,
-    JID_PAIR: exports.JID_PAIR,
-    JID_FB: exports.JID_FB,
-    JID_INTEROP: exports.JID_INTEROP,
-    JID_U: exports.JID_U,
-    HEX_8: exports.HEX_8,
-    BINARY_8: exports.BINARY_8,
-    BINARY_20: exports.BINARY_20,
-    BINARY_32: exports.BINARY_32,
-    NIBBLE_8: exports.NIBBLE_8,
-    DICTIONARY_0: exports.DICTIONARY_0,
-    DICTIONARY_3: exports.DICTIONARY_3,
-    STREAM_END: exports.STREAM_END
-});

package/dist/transport/binary/decoder.js

@@ -63,22 +63,22 @@ function parsePacked(reader, alphabet) {
     const odd = (lengthByte & 0x80) !== 0;
     const byteCount = lengthByte & 0x7f;
     const outLength = byteCount * 2 - (odd ? 1 : 0);
-    const chars = new Array(outLength);
+    const buf = new Uint8Array(outLength);
     let outIndex = 0;
     for (let i = 0; i < byteCount; i += 1) {
         const packed = reader.readUint8();
         const high = (packed >>> 4) & 0x0f;
         const low = packed & 0x0f;
         if (outIndex < outLength) {
-            chars[outIndex] = alphabet[high];
+            buf[outIndex] = alphabet[high].charCodeAt(0);
             outIndex += 1;
         }
         if (outIndex < outLength) {
-            chars[outIndex] = alphabet[low];
+            buf[outIndex] = alphabet[low].charCodeAt(0);
             outIndex += 1;
         }
     }
-    return chars.join('');
+    return bytes_1.TEXT_DECODER.decode(buf);
 }
 function readBinary(reader, token) {
     if (token === constants_2.BINARY_8) {