zapo-js 0.1.0 → 0.1.2

package/dist/esm/transport/proxy.js

@@ -0,0 +1,27 @@
+export function isProxyDispatcher(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'dispatch' in value &&
+        typeof value.dispatch === 'function');
+}
+export function isProxyAgent(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'addRequest' in value &&
+        typeof value.addRequest === 'function');
+}
+export function isProxyTransport(value) {
+    return isProxyDispatcher(value) || isProxyAgent(value);
+}
+export function toProxyDispatcher(proxy) {
+    if (!proxy || !isProxyDispatcher(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}
+export function toProxyAgent(proxy) {
+    if (!proxy || !isProxyAgent(proxy)) {
+        return undefined;
+    }
+    return proxy;
+}

package/dist/esm/transport/stream/parse.js

@@ -1,74 +1,39 @@
 import { WA_STREAM_SIGNALING } from '../../protocol/constants.js';
 import { findNodeChild, hasNodeChild } from '../node/helpers.js';
-import { base64ToBytes } from '../../util/base64.js';
-function parseStrictUnsignedInt(value) {
-    if (!/^\d+$/.test(value)) {
-        return undefined;
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed)) {
-        return undefined;
-    }
-    return parsed;
-}
+import { base64ToBytesChecked } from '../../util/bytes.js';
+import { parseOptionalInt, parseStrictUnsignedInt } from '../../util/primitives.js';
 export function parseStreamControlNode(node) {
     if (node.tag === WA_STREAM_SIGNALING.XML_STREAM_END_TAG) {
-        return {
-            kind: 'xmlstreamend'
-        };
+        return { kind: 'xmlstreamend' };
     }
     if (node.tag !== WA_STREAM_SIGNALING.STREAM_ERROR_TAG) {
         return null;
     }
     const conflictNode = findNodeChild(node, WA_STREAM_SIGNALING.CONFLICT_TAG);
     if (conflictNode) {
-        if (conflictNode.attrs.type === WA_STREAM_SIGNALING.REPLACED_TYPE) {
-            return {
-                kind: 'stream_error_replaced'
-            };
-        }
-        return {
-            kind: 'stream_error_device_removed'
-        };
+        return conflictNode.attrs.type === WA_STREAM_SIGNALING.REPLACED_TYPE
+            ? { kind: 'stream_error_replaced' }
+            : { kind: 'stream_error_device_removed' };
     }
-    const codeRaw = node.attrs.code;
-    if (codeRaw) {
-        const code = parseStrictUnsignedInt(codeRaw);
-        if (code !== undefined) {
-            return {
-                kind: 'stream_error_code',
-                code
-            };
-        }
+    const code = node.attrs.code ? parseStrictUnsignedInt(node.attrs.code) : undefined;
+    if (code !== undefined) {
+        return { kind: 'stream_error_code', code };
     }
     const ackNode = findNodeChild(node, WA_STREAM_SIGNALING.ACK_TAG);
     if (ackNode) {
-        return {
-            kind: 'stream_error_ack',
-            id: ackNode.attrs.id
-        };
+        return { kind: 'stream_error_ack', id: ackNode.attrs.id };
     }
     if (hasNodeChild(node, WA_STREAM_SIGNALING.XML_NOT_WELL_FORMED_TAG)) {
-        return {
-            kind: 'stream_error_xml_not_well_formed'
-        };
-    }
-    return {
-        kind: 'stream_error_other'
-    };
-}
-export function parseOptionalInt(value) {
-    if (!value) {
-        return undefined;
+        return { kind: 'stream_error_xml_not_well_formed' };
     }
-    return parseStrictUnsignedInt(value);
+    return { kind: 'stream_error_other' };
 }
 export function parseCompanionEncStatic(value, onError) {
     if (!value) {
         return undefined;
     }
     try {
-        return base64ToBytes(value, 'success.companion_enc_static');
+        return base64ToBytesChecked(value, 'success.companion_enc_static');
     }
     catch (error) {
         if (error instanceof Error) {

package/dist/esm/util/bytes.js

@@ -1,6 +1,7 @@
 import { timingSafeEqual } from 'node:crypto';
 export const TEXT_ENCODER = new TextEncoder();
 export const TEXT_DECODER = new TextDecoder();
+export const ZERO_BYTES = new Uint8Array([0]);
 export const EMPTY_BYTES = Object.freeze(new Uint8Array(0));
 const HEX_CHARS = '0123456789abcdef';
 const HEX_TABLE = /* @__PURE__ */ (() => {
@@ -90,28 +91,52 @@ export function base64ToBytes(value) {
         out[j++] = ((b & 0x0f) << 4) | (c >> 2);
         out[j++] = ((c & 0x03) << 6) | d;
     }
-    if (padding === 0) {
-        const a = lookupBase64(value.charCodeAt(i));
-        const b = lookupBase64(value.charCodeAt(i + 1));
+    const a = lookupBase64(value.charCodeAt(i));
+    const b = lookupBase64(value.charCodeAt(i + 1));
+    out[j++] = (a << 2) | (b >> 4);
+    if (j < outLen) {
         const c = lookupBase64(value.charCodeAt(i + 2));
-        const d = lookupBase64(value.charCodeAt(i + 3));
-        out[j++] = (a << 2) | (b >> 4);
         out[j++] = ((b & 0x0f) << 4) | (c >> 2);
-        out[j++] = ((c & 0x03) << 6) | d;
+        if (j < outLen) {
+            const d = lookupBase64(value.charCodeAt(i + 3));
+            out[j++] = ((c & 0x03) << 6) | d;
+        }
     }
-    else if (padding === 1) {
-        const a = lookupBase64(value.charCodeAt(i));
-        const b = lookupBase64(value.charCodeAt(i + 1));
-        const c = lookupBase64(value.charCodeAt(i + 2));
-        out[j++] = (a << 2) | (b >> 4);
-        out[j++] = ((b & 0x0f) << 4) | (c >> 2);
+    return out;
+}
+export function base64ToBytesChecked(value, field, requireNonEmpty = true) {
+    if (requireNonEmpty && value.length === 0) {
+        throw new Error(`invalid base64 payload for ${field}`);
     }
-    else {
-        const a = lookupBase64(value.charCodeAt(i));
-        const b = lookupBase64(value.charCodeAt(i + 1));
-        out[j++] = (a << 2) | (b >> 4);
+    return base64ToBytes(value);
+}
+export function decodeBase64Url(value, field) {
+    if (!value) {
+        throw new Error(`missing ${field}`);
+    }
+    const padded = value
+        .replace(/-/g, '+')
+        .replace(/_/g, '/')
+        .padEnd(Math.ceil(value.length / 4) * 4, '=');
+    return base64ToBytesChecked(padded, field);
+}
+export function assertByteLength(value, expectedLength, errorMessage, throwOnMismatch = true) {
+    if (value.length !== expectedLength) {
+        if (!throwOnMismatch) {
+            return false;
+        }
+        throw new Error(errorMessage);
     }
-    return out;
+    return true;
+}
+export function decodeProtoBytes(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing protobuf bytes field ${field}`);
+    }
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    return base64ToBytes(value);
 }
 function lookupBase64(code) {
     if (code > 127) {
@@ -180,28 +205,21 @@ export function concatBytes(parts) {
 }
 export function toBytesView(value) {
     if (value instanceof Uint8Array) {
-        if (value.constructor === Uint8Array) {
-            return value;
-        }
-        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+        return value.constructor === Uint8Array
+            ? value
+            : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
     }
-    if (ArrayBuffer.isView(value)) {
-        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
     }
-    return new Uint8Array(value);
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
 }
 export function toChunkBytes(chunk) {
-    if (chunk instanceof Uint8Array) {
-        return chunk;
-    }
-    if (chunk instanceof ArrayBuffer) {
-        return new Uint8Array(chunk);
-    }
     if (typeof chunk === 'string') {
         return TEXT_ENCODER.encode(chunk);
     }
-    if (ArrayBuffer.isView(chunk)) {
-        return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+    if (chunk instanceof Uint8Array || chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk)) {
+        return toBytesView(chunk);
     }
     throw new Error(`unsupported stream chunk type: ${typeof chunk}`);
 }

package/dist/esm/util/coercion.js

@@ -10,9 +10,8 @@ export function asNumber(value, field) {
     throw new Error(`invalid number value for ${field}`);
 }
 export function asOptionalNumber(value, field = 'optional number') {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         return undefined;
-    }
     return asNumber(value, field);
 }
 export function asString(value, field) {
@@ -22,9 +21,8 @@ export function asString(value, field) {
     throw new Error(`invalid string value for ${field}`);
 }
 export function asOptionalString(value, field = 'optional string') {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         return undefined;
-    }
     return asString(value, field);
 }
 export function asBytes(value, field) {
@@ -34,23 +32,17 @@ export function asBytes(value, field) {
     throw new Error(`invalid bytes value for ${field}`);
 }
 export function asOptionalBytes(value, field = 'optional bytes') {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         return undefined;
-    }
     return asBytes(value, field);
 }
 export function toBoolOrUndef(value) {
-    if (value === null || value === undefined) {
-        return undefined;
-    }
-    return Boolean(value);
+    return value === null || value === undefined ? undefined : Boolean(value);
 }
 export function resolvePositive(value, fallback, name) {
-    if (value === undefined) {
+    if (value === undefined)
         return fallback;
-    }
-    if (Number.isSafeInteger(value) && value > 0) {
+    if (Number.isSafeInteger(value) && value > 0)
         return value;
-    }
     throw new Error(`${name} must be a positive safe integer`);
 }

package/dist/esm/util/primitives.js

@@ -1,32 +1,57 @@
 export function toError(value) {
-    if (value instanceof Error) {
+    if (value instanceof Error)
         return value;
-    }
-    if (typeof value === 'string') {
+    if (typeof value === 'string')
         return new Error(value);
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return new Error(String(value));
+    }
+    if (value && typeof value === 'object') {
+        const message = value.message;
+        if (typeof message === 'string' && message.length > 0) {
+            return new Error(message);
+        }
+        const code = value.code;
+        if (typeof code === 'string' || typeof code === 'number') {
+            return new Error(`unknown error (${code})`);
+        }
     }
     return new Error('unknown error');
 }
 function assertSafeInteger(value, field, nullishBehavior) {
-    if (!Number.isFinite(value) || !Number.isSafeInteger(value)) {
-        const prefix = nullishBehavior === 'throw' ? `invalid ${field}` : 'invalid long numeric value';
-        throw new Error(`${prefix}: ${value}`);
-    }
-    return value;
+    if (Number.isFinite(value) && Number.isSafeInteger(value))
+        return value;
+    const prefix = nullishBehavior === 'throw' ? `invalid ${field}` : 'invalid long numeric value';
+    throw new Error(`${prefix}: ${value}`);
 }
 export function toSafeNumber(value, field) {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         throw new Error(`missing ${field}`);
-    }
     const numeric = typeof value === 'number' ? value : value.toNumber?.();
-    if (typeof numeric !== 'number') {
+    if (typeof numeric !== 'number')
         throw new Error(`invalid ${field}`);
-    }
     return assertSafeInteger(numeric, field, 'throw');
 }
 export function longToNumber(value) {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         return 0;
-    }
     return assertSafeInteger(typeof value === 'number' ? value : value.toNumber(), '', 'zero');
 }
+export function normalizeNonNegativeInteger(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return fallback;
+    return Math.max(0, Math.trunc(value));
+}
+export function parseStrictUnsignedInt(value) {
+    if (!/^\d+$/.test(value))
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed))
+        return undefined;
+    return parsed;
+}
+export function parseOptionalInt(value) {
+    if (!value)
+        return undefined;
+    return parseStrictUnsignedInt(value);
+}

package/dist/infra/log/ConsoleLogger.js

@@ -8,37 +8,38 @@ const LOG_LEVEL_PRIORITY = {
     warn: 40,
     error: 50
 };
+const CONSOLE_WRITERS = {
+    trace: console.debug,
+    debug: console.debug,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+};
 class ConsoleLogger {
     constructor(level = 'info') {
         this.level = level;
+        this.minLevelPriority = LOG_LEVEL_PRIORITY[level];
     }
     trace(message, context) {
-        if (this.canLog('trace')) {
-            console.debug(message, context);
-        }
+        this.write('trace', message, context);
     }
     debug(message, context) {
-        if (this.canLog('debug')) {
-            console.debug(message, context);
-        }
+        this.write('debug', message, context);
     }
     info(message, context) {
-        if (this.canLog('info')) {
-            console.info(message, context);
-        }
+        this.write('info', message, context);
     }
     warn(message, context) {
-        if (this.canLog('warn')) {
-            console.warn(message, context);
-        }
+        this.write('warn', message, context);
     }
     error(message, context) {
-        if (this.canLog('error')) {
-            console.error(message, context);
-        }
+        this.write('error', message, context);
     }
-    canLog(level) {
-        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+    write(level, message, context) {
+        if (LOG_LEVEL_PRIORITY[level] < this.minLevelPriority) {
+            return;
+        }
+        CONSOLE_WRITERS[level](message, context);
     }
 }
 exports.ConsoleLogger = ConsoleLogger;

package/dist/infra/log/PinoLogger.js

@@ -60,26 +60,32 @@ class PinoLogger {
         this.logger.level = level;
     }
     trace(message, context) {
-        this.writeLog('trace', message, context);
+        this.write('trace', message, context);
     }
     debug(message, context) {
-        this.writeLog('debug', message, context);
+        this.write('debug', message, context);
     }
     info(message, context) {
-        this.writeLog('info', message, context);
+        this.write('info', message, context);
     }
     warn(message, context) {
-        this.writeLog('warn', message, context);
+        this.write('warn', message, context);
     }
     error(message, context) {
-        this.writeLog('error', message, context);
+        this.write('error', message, context);
     }
-    writeLog(method, message, context) {
-        if (!context || Object.keys(context).length === 0) {
-            this.logger[method](message);
+    write(level, message, context) {
+        if (context === null || context === undefined) {
+            this.logger[level](message);
             return;
         }
-        this.logger[method](context, message);
+        for (const key in context) {
+            if (Object.prototype.hasOwnProperty.call(context, key)) {
+                this.logger[level](context, message);
+                return;
+            }
+        }
+        this.logger[level](message);
     }
 }
 exports.PinoLogger = PinoLogger;

package/dist/infra/log/types.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoopLogger = createNoopLogger;
+function noop() { }
+function createNoopLogger(level = 'trace') {
+    return {
+        level,
+        trace: noop,
+        debug: noop,
+        info: noop,
+        warn: noop,
+        error: noop
+    };
+}

package/dist/infra/perf/BoundedTaskQueue.js

@@ -11,6 +11,16 @@ class BoundedTaskQueueFullError extends Error {
 exports.BoundedTaskQueueFullError = BoundedTaskQueueFullError;
 class BoundedTaskQueue {
     constructor(maxQueueSize = 256, maxConcurrency = 1) {
+        this.settleTask = () => {
+            this.running--;
+            if (this.head >= 1024 && this.head * 2 >= this.queue.length) {
+                const remaining = this.queue.length - this.head;
+                this.queue.copyWithin(0, this.head);
+                this.queue.length = remaining;
+                this.head = 0;
+            }
+            this.drain();
+        };
         if (maxQueueSize <= 0) {
             throw new Error('maxQueueSize must be > 0');
         }
@@ -29,8 +39,8 @@ class BoundedTaskQueue {
         }
         return new Promise((resolve, reject) => {
             this.queue.push({
-                task,
-                resolve: (value) => resolve(value),
+                task: task,
+                resolve: resolve,
                 reject
             });
             this.drain();
@@ -46,22 +56,8 @@ class BoundedTaskQueue {
         while (this.running < this.maxConcurrency && this.head < this.queue.length) {
             const item = this.queue[this.head++];
             this.running++;
-            item.task()
-                .then(item.resolve)
-                .catch(item.reject)
-                .finally(() => {
-                this.running--;
-                this.compactIfNeeded();
-                this.drain();
-            });
+            void item.task().then(item.resolve, item.reject).finally(this.settleTask);
         }
     }
-    compactIfNeeded() {
-        if (this.head < 1024 || this.head * 2 < this.queue.length) {
-            return;
-        }
-        this.queue.splice(0, this.head);
-        this.head = 0;
-    }
 }
 exports.BoundedTaskQueue = BoundedTaskQueue;

package/dist/media/WaMediaCrypto.js

@@ -16,9 +16,7 @@ class WaMediaCrypto {
         return (0, random_1.randomBytesAsync)(32);
     }
     static async deriveKeys(mediaType, mediaKey) {
-        if (mediaKey.byteLength !== 32) {
-            throw new Error(`invalid media key length ${mediaKey.byteLength}, expected 32`);
-        }
+        (0, bytes_1.assertByteLength)(mediaKey, 32, `invalid media key length ${mediaKey.byteLength}, expected 32`);
         const info = mediaTypeToHkdfInfo(mediaType);
         const expanded = await (0, hkdf_1.hkdf)(mediaKey, null, info, constants_1.MEDIA_HKDF_SIZE);
         return {