zapo-js 0.1.0

package/dist/esm/util/bytes.js

@@ -0,0 +1,275 @@
+import { timingSafeEqual } from 'node:crypto';
+export const TEXT_ENCODER = new TextEncoder();
+export const TEXT_DECODER = new TextDecoder();
+export const EMPTY_BYTES = Object.freeze(new Uint8Array(0));
+const HEX_CHARS = '0123456789abcdef';
+const HEX_TABLE = /* @__PURE__ */ (() => {
+    const table = new Array(256);
+    for (let i = 0; i < 256; i += 1) {
+        table[i] = HEX_CHARS[i >> 4] + HEX_CHARS[i & 0x0f];
+    }
+    return table;
+})();
+const HEX_LOOKUP = /* @__PURE__ */ (() => {
+    const table = new Int8Array(128).fill(-1);
+    for (let i = 0x30; i <= 0x39; i += 1)
+        table[i] = i - 0x30;
+    for (let i = 0x41; i <= 0x46; i += 1)
+        table[i] = i - 0x41 + 10;
+    for (let i = 0x61; i <= 0x66; i += 1)
+        table[i] = i - 0x61 + 10;
+    return table;
+})();
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const BASE64URL_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const BASE64_LOOKUP = /* @__PURE__ */ (() => {
+    const table = new Uint8Array(128).fill(0xff);
+    for (let i = 0; i < BASE64_CHARS.length; i += 1) {
+        table[BASE64_CHARS.charCodeAt(i)] = i;
+    }
+    table[0x3d] = 0; // '='
+    return table;
+})();
+/**
+ * Encodes a Uint8Array to a hex string
+ */
+export function bytesToHex(value) {
+    let out = '';
+    for (let i = 0; i < value.length; i += 1) {
+        out += HEX_TABLE[value[i]];
+    }
+    return out;
+}
+/**
+ * Decodes a hex string to a Uint8Array
+ */
+export function hexToBytes(value) {
+    const len = value.length;
+    if (len & 1) {
+        throw new Error('hex string must have even length');
+    }
+    const out = new Uint8Array(len >> 1);
+    for (let i = 0; i < len; i += 2) {
+        const hiCode = value.charCodeAt(i);
+        const loCode = value.charCodeAt(i + 1);
+        const hi = hiCode < 128 ? HEX_LOOKUP[hiCode] : -1;
+        const lo = loCode < 128 ? HEX_LOOKUP[loCode] : -1;
+        if ((hi | lo) < 0) {
+            throw new Error('invalid hex character');
+        }
+        out[i >> 1] = (hi << 4) | lo;
+    }
+    return out;
+}
+export function bytesToBase64(value) {
+    return encodeBase64(value, BASE64_CHARS, true);
+}
+export function base64ToBytes(value) {
+    const len = value.length;
+    if (len === 0)
+        return EMPTY_BYTES;
+    if ((len & 3) !== 0) {
+        throw new Error('base64 string length must be multiple of 4');
+    }
+    let padding = 0;
+    if (value.charCodeAt(len - 1) === 0x3d)
+        padding += 1;
+    if (value.charCodeAt(len - 2) === 0x3d)
+        padding += 1;
+    const outLen = ((len * 3) >> 2) - padding;
+    const out = new Uint8Array(outLen);
+    let j = 0;
+    const mainLen = len - 4;
+    let i = 0;
+    for (; i < mainLen; i += 4) {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        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 (padding === 0) {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        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;
+    }
+    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);
+    }
+    else {
+        const a = lookupBase64(value.charCodeAt(i));
+        const b = lookupBase64(value.charCodeAt(i + 1));
+        out[j++] = (a << 2) | (b >> 4);
+    }
+    return out;
+}
+function lookupBase64(code) {
+    if (code > 127) {
+        throw new Error('invalid base64 character');
+    }
+    const v = BASE64_LOOKUP[code];
+    if (v === 0xff) {
+        throw new Error('invalid base64 character');
+    }
+    return v;
+}
+/**
+ * Encodes a Uint8Array to a base64url string (URL-safe, no padding)
+ */
+export function bytesToBase64UrlSafe(value) {
+    return encodeBase64(value, BASE64URL_CHARS, false);
+}
+function encodeBase64(value, alphabet, pad) {
+    const len = value.length;
+    if (len === 0)
+        return '';
+    const remainder = len % 3;
+    const mainLen = len - remainder;
+    const chunks = Math.ceil(len / 3);
+    const out = new Array(pad ? chunks * 4 : Math.ceil((len * 4) / 3));
+    let k = 0;
+    for (let i = 0; i < mainLen; i += 3) {
+        const a = value[i];
+        const b = value[i + 1];
+        const c = value[i + 2];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+        out[k++] = alphabet[((b & 0x0f) << 2) | (c >> 6)];
+        out[k++] = alphabet[c & 0x3f];
+    }
+    if (remainder === 1) {
+        const a = value[mainLen];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[(a & 0x03) << 4];
+        if (pad) {
+            out[k++] = '=';
+            out[k++] = '=';
+        }
+    }
+    else if (remainder === 2) {
+        const a = value[mainLen];
+        const b = value[mainLen + 1];
+        out[k++] = alphabet[a >> 2];
+        out[k++] = alphabet[((a & 0x03) << 4) | (b >> 4)];
+        out[k++] = alphabet[(b & 0x0f) << 2];
+        if (pad) {
+            out[k++] = '=';
+        }
+    }
+    return out.join('');
+}
+export function concatBytes(parts) {
+    const total = parts.reduce((sum, current) => sum + current.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+export function toBytesView(value) {
+    if (value instanceof Uint8Array) {
+        if (value.constructor === Uint8Array) {
+            return value;
+        }
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return new Uint8Array(value);
+}
+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);
+    }
+    throw new Error(`unsupported stream chunk type: ${typeof chunk}`);
+}
+export function uint8TimingSafeEqual(left, right) {
+    if (left.byteLength !== right.byteLength) {
+        return false;
+    }
+    return timingSafeEqual(left, right);
+}
+export function uint8Equal(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    let diff = 0;
+    for (let i = 0; i < a.length; i += 1) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff === 0;
+}
+export function removeAt(items, index) {
+    const out = [];
+    for (let i = 0; i < items.length; i += 1) {
+        if (i !== index) {
+            out.push(items[i]);
+        }
+    }
+    return out;
+}
+export function intToBytes(byteLength, value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`invalid integer value: ${value}`);
+    }
+    const out = new Uint8Array(byteLength);
+    let current = value;
+    for (let i = byteLength - 1; i >= 0; i -= 1) {
+        out[i] = current & 0xff;
+        current = Math.floor(current / 256);
+    }
+    return out;
+}
+export async function readAllBytes(stream, options = {}) {
+    const maxBytes = options.maxBytes;
+    if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes < 0)) {
+        throw new Error(`invalid max bytes limit: ${maxBytes}`);
+    }
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream) {
+        const bytes = toChunkBytes(chunk);
+        chunks.push(bytes);
+        total += bytes.byteLength;
+        if (maxBytes !== undefined && total > maxBytes) {
+            const error = new Error(`stream exceeded max bytes limit (${maxBytes})`);
+            stream.destroy(error);
+            throw error;
+        }
+    }
+    if (total === 0) {
+        return EMPTY_BYTES;
+    }
+    if (chunks.length === 1) {
+        return chunks[0];
+    }
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        merged.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return merged;
+}

package/dist/esm/util/coercion.js

@@ -0,0 +1,56 @@
+import { toBytesView } from './bytes.js';
+import { toSafeNumber } from './primitives.js';
+export function asNumber(value, field) {
+    if (typeof value === 'bigint') {
+        return toSafeNumber(Number(value), field);
+    }
+    if (typeof value === 'number') {
+        return toSafeNumber(value, field);
+    }
+    throw new Error(`invalid number value for ${field}`);
+}
+export function asOptionalNumber(value, field = 'optional number') {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return asNumber(value, field);
+}
+export function asString(value, field) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    throw new Error(`invalid string value for ${field}`);
+}
+export function asOptionalString(value, field = 'optional string') {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    return asString(value, field);
+}
+export function asBytes(value, field) {
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+        return toBytesView(value);
+    }
+    throw new Error(`invalid bytes value for ${field}`);
+}
+export function asOptionalBytes(value, field = 'optional bytes') {
+    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);
+}
+export function resolvePositive(value, fallback, name) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (Number.isSafeInteger(value) && value > 0) {
+        return value;
+    }
+    throw new Error(`${name} must be a positive safe integer`);
+}

package/dist/esm/util/collections.js

@@ -0,0 +1,27 @@
+export function resolveCleanupIntervalMs(ttlMs, maxIntervalMs = 60000) {
+    if (ttlMs <= 1000) {
+        return ttlMs;
+    }
+    return Math.min(maxIntervalMs, Math.floor(ttlMs / 2));
+}
+export function normalizeQueryLimit(limit, defaultLimit) {
+    if (limit === undefined) {
+        return defaultLimit;
+    }
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new Error(`invalid query limit: ${limit}`);
+    }
+    return limit;
+}
+export function setBoundedMapEntry(map, key, value, maxEntries, onEvict) {
+    map.delete(key);
+    map.set(key, value);
+    while (map.size > maxEntries) {
+        const oldest = map.entries().next().value;
+        if (!oldest) {
+            break;
+        }
+        map.delete(oldest[0]);
+        onEvict?.(oldest[0], oldest[1]);
+    }
+}

package/dist/esm/util/primitives.js

@@ -0,0 +1,32 @@
+export function toError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return new Error(value);
+    }
+    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;
+}
+export function toSafeNumber(value, field) {
+    if (value === null || value === undefined) {
+        throw new Error(`missing ${field}`);
+    }
+    const numeric = typeof value === 'number' ? value : value.toNumber?.();
+    if (typeof numeric !== 'number') {
+        throw new Error(`invalid ${field}`);
+    }
+    return assertSafeInteger(numeric, field, 'throw');
+}
+export function longToNumber(value) {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    return assertSafeInteger(typeof value === 'number' ? value : value.toNumber(), '', 'zero');
+}

package/dist/esm/util/runtime.js

@@ -0,0 +1,15 @@
+export function getRuntimeOsDisplayName() {
+    switch (process.platform) {
+        case 'win32':
+            return 'Windows';
+        case 'darwin':
+            return 'Mac OS';
+        case 'linux':
+            return 'Linux';
+        default:
+            return process.platform;
+    }
+}
+export function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}

package/dist/esm/util/signal-address.js

@@ -0,0 +1,5 @@
+import { WA_DEFAULTS } from '../protocol/constants.js';
+export function signalAddressKey(address) {
+    const server = address.server ?? WA_DEFAULTS.HOST_DOMAIN;
+    return `${address.user}|${server}|${address.device}`;
+}

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proto = exports.WA_XMLNS = exports.WA_SUPPORTED_DIRTY_TYPES = exports.WA_STREAM_SIGNALING = exports.WA_SIGNALING = exports.WA_RETRYABLE_ACK_CODES = exports.WA_READY_STATES = exports.WA_PREVIEW_MEDIA_HKDF_INFO = exports.WA_PAIRING_KDF_INFO = exports.WA_NODE_TAGS = exports.WA_MEDIA_HKDF_INFO = exports.WA_MESSAGE_TYPES = exports.WA_MESSAGE_TAGS = exports.WA_LOGOUT_REASONS = exports.WA_IQ_TYPES = exports.WA_DISCONNECT_REASONS = exports.WA_DIRTY_TYPES = exports.WA_DIRTY_PROTOCOLS = exports.WA_DEFAULTS = exports.WA_COMPANION_PLATFORM_IDS = exports.WA_BROWSERS = exports.WA_APP_STATE_SYNC_DATA_TYPE = exports.WA_APP_STATE_KEY_TYPES = exports.WA_APP_STATE_KDF_INFO = exports.WA_APP_STATE_ERROR_CODES = exports.WA_APP_STATE_COLLECTION_STATES = exports.WA_APP_STATE_COLLECTIONS = exports.WA_ACCOUNT_SYNC_PROTOCOLS = exports.toUserJid = exports.splitJid = exports.parseSignalAddressFromJid = exports.parsePhoneJid = exports.normalizeRecipientJid = exports.normalizeDeviceJid = exports.isGroupJid = exports.getWaMediaHkdfInfo = exports.getWaCompanionPlatformId = exports.getLoginIdentity = exports.createStore = exports.createPinoLogger = exports.PinoLogger = exports.ConsoleLogger = exports.WaClient = void 0;
+var _client_1 = require("./client/index.js");
+Object.defineProperty(exports, "WaClient", { enumerable: true, get: function () { return _client_1.WaClient; } });
+var ConsoleLogger_1 = require("./infra/log/ConsoleLogger");
+Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return ConsoleLogger_1.ConsoleLogger; } });
+var PinoLogger_1 = require("./infra/log/PinoLogger");
+Object.defineProperty(exports, "PinoLogger", { enumerable: true, get: function () { return PinoLogger_1.PinoLogger; } });
+Object.defineProperty(exports, "createPinoLogger", { enumerable: true, get: function () { return PinoLogger_1.createPinoLogger; } });
+var _store_1 = require("./store/index.js");
+Object.defineProperty(exports, "createStore", { enumerable: true, get: function () { return _store_1.createStore; } });
+var _protocol_1 = require("./protocol/index.js");
+Object.defineProperty(exports, "getLoginIdentity", { enumerable: true, get: function () { return _protocol_1.getLoginIdentity; } });
+Object.defineProperty(exports, "getWaCompanionPlatformId", { enumerable: true, get: function () { return _protocol_1.getWaCompanionPlatformId; } });
+Object.defineProperty(exports, "getWaMediaHkdfInfo", { enumerable: true, get: function () { return _protocol_1.getWaMediaHkdfInfo; } });
+Object.defineProperty(exports, "isGroupJid", { enumerable: true, get: function () { return _protocol_1.isGroupJid; } });
+Object.defineProperty(exports, "normalizeDeviceJid", { enumerable: true, get: function () { return _protocol_1.normalizeDeviceJid; } });
+Object.defineProperty(exports, "normalizeRecipientJid", { enumerable: true, get: function () { return _protocol_1.normalizeRecipientJid; } });
+Object.defineProperty(exports, "parsePhoneJid", { enumerable: true, get: function () { return _protocol_1.parsePhoneJid; } });
+Object.defineProperty(exports, "parseSignalAddressFromJid", { enumerable: true, get: function () { return _protocol_1.parseSignalAddressFromJid; } });
+Object.defineProperty(exports, "splitJid", { enumerable: true, get: function () { return _protocol_1.splitJid; } });
+Object.defineProperty(exports, "toUserJid", { enumerable: true, get: function () { return _protocol_1.toUserJid; } });
+Object.defineProperty(exports, "WA_ACCOUNT_SYNC_PROTOCOLS", { enumerable: true, get: function () { return _protocol_1.WA_ACCOUNT_SYNC_PROTOCOLS; } });
+Object.defineProperty(exports, "WA_APP_STATE_COLLECTIONS", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_COLLECTIONS; } });
+Object.defineProperty(exports, "WA_APP_STATE_COLLECTION_STATES", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_COLLECTION_STATES; } });
+Object.defineProperty(exports, "WA_APP_STATE_ERROR_CODES", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_ERROR_CODES; } });
+Object.defineProperty(exports, "WA_APP_STATE_KDF_INFO", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_KDF_INFO; } });
+Object.defineProperty(exports, "WA_APP_STATE_KEY_TYPES", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_KEY_TYPES; } });
+Object.defineProperty(exports, "WA_APP_STATE_SYNC_DATA_TYPE", { enumerable: true, get: function () { return _protocol_1.WA_APP_STATE_SYNC_DATA_TYPE; } });
+Object.defineProperty(exports, "WA_BROWSERS", { enumerable: true, get: function () { return _protocol_1.WA_BROWSERS; } });
+Object.defineProperty(exports, "WA_COMPANION_PLATFORM_IDS", { enumerable: true, get: function () { return _protocol_1.WA_COMPANION_PLATFORM_IDS; } });
+Object.defineProperty(exports, "WA_DEFAULTS", { enumerable: true, get: function () { return _protocol_1.WA_DEFAULTS; } });
+Object.defineProperty(exports, "WA_DIRTY_PROTOCOLS", { enumerable: true, get: function () { return _protocol_1.WA_DIRTY_PROTOCOLS; } });
+Object.defineProperty(exports, "WA_DIRTY_TYPES", { enumerable: true, get: function () { return _protocol_1.WA_DIRTY_TYPES; } });
+Object.defineProperty(exports, "WA_DISCONNECT_REASONS", { enumerable: true, get: function () { return _protocol_1.WA_DISCONNECT_REASONS; } });
+Object.defineProperty(exports, "WA_IQ_TYPES", { enumerable: true, get: function () { return _protocol_1.WA_IQ_TYPES; } });
+Object.defineProperty(exports, "WA_LOGOUT_REASONS", { enumerable: true, get: function () { return _protocol_1.WA_LOGOUT_REASONS; } });
+Object.defineProperty(exports, "WA_MESSAGE_TAGS", { enumerable: true, get: function () { return _protocol_1.WA_MESSAGE_TAGS; } });
+Object.defineProperty(exports, "WA_MESSAGE_TYPES", { enumerable: true, get: function () { return _protocol_1.WA_MESSAGE_TYPES; } });
+Object.defineProperty(exports, "WA_MEDIA_HKDF_INFO", { enumerable: true, get: function () { return _protocol_1.WA_MEDIA_HKDF_INFO; } });
+Object.defineProperty(exports, "WA_NODE_TAGS", { enumerable: true, get: function () { return _protocol_1.WA_NODE_TAGS; } });
+Object.defineProperty(exports, "WA_PAIRING_KDF_INFO", { enumerable: true, get: function () { return _protocol_1.WA_PAIRING_KDF_INFO; } });
+Object.defineProperty(exports, "WA_PREVIEW_MEDIA_HKDF_INFO", { enumerable: true, get: function () { return _protocol_1.WA_PREVIEW_MEDIA_HKDF_INFO; } });
+Object.defineProperty(exports, "WA_READY_STATES", { enumerable: true, get: function () { return _protocol_1.WA_READY_STATES; } });
+Object.defineProperty(exports, "WA_RETRYABLE_ACK_CODES", { enumerable: true, get: function () { return _protocol_1.WA_RETRYABLE_ACK_CODES; } });
+Object.defineProperty(exports, "WA_SIGNALING", { enumerable: true, get: function () { return _protocol_1.WA_SIGNALING; } });
+Object.defineProperty(exports, "WA_STREAM_SIGNALING", { enumerable: true, get: function () { return _protocol_1.WA_STREAM_SIGNALING; } });
+Object.defineProperty(exports, "WA_SUPPORTED_DIRTY_TYPES", { enumerable: true, get: function () { return _protocol_1.WA_SUPPORTED_DIRTY_TYPES; } });
+Object.defineProperty(exports, "WA_XMLNS", { enumerable: true, get: function () { return _protocol_1.WA_XMLNS; } });
+var _proto_1 = require("./proto.js");
+Object.defineProperty(exports, "proto", { enumerable: true, get: function () { return _proto_1.proto; } });

package/dist/infra/log/ConsoleLogger.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const LOG_LEVEL_PRIORITY = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50
+};
+class ConsoleLogger {
+    constructor(level = 'info') {
+        this.level = level;
+    }
+    trace(message, context) {
+        if (this.canLog('trace')) {
+            console.debug(message, context);
+        }
+    }
+    debug(message, context) {
+        if (this.canLog('debug')) {
+            console.debug(message, context);
+        }
+    }
+    info(message, context) {
+        if (this.canLog('info')) {
+            console.info(message, context);
+        }
+    }
+    warn(message, context) {
+        if (this.canLog('warn')) {
+            console.warn(message, context);
+        }
+    }
+    error(message, context) {
+        if (this.canLog('error')) {
+            console.error(message, context);
+        }
+    }
+    canLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.level];
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;

package/dist/infra/log/PinoLogger.js

@@ -0,0 +1,111 @@
+"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 __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.PinoLogger = void 0;
+exports.createPinoLogger = createPinoLogger;
+const PINO_MODULE = 'pino';
+const PINO_PRETTY_MODULE = 'pino-pretty';
+async function loadPinoFactory() {
+    try {
+        const loaded = await Promise.resolve(`${PINO_MODULE}`).then(s => __importStar(require(s)));
+        if (typeof loaded === 'function') {
+            return loaded;
+        }
+        const candidate = loaded && typeof loaded === 'object' ? loaded.default : undefined;
+        if (typeof candidate === 'function') {
+            return candidate;
+        }
+        throw new Error('invalid pino module export');
+    }
+    catch {
+        throw new Error('optional dependency "pino" is not installed. Install with: npm i pino');
+    }
+}
+class PinoLogger {
+    constructor(logger, level = 'info') {
+        this.logger = logger;
+        this.level = level;
+        this.logger.level = level;
+    }
+    trace(message, context) {
+        this.writeLog('trace', message, context);
+    }
+    debug(message, context) {
+        this.writeLog('debug', message, context);
+    }
+    info(message, context) {
+        this.writeLog('info', message, context);
+    }
+    warn(message, context) {
+        this.writeLog('warn', message, context);
+    }
+    error(message, context) {
+        this.writeLog('error', message, context);
+    }
+    writeLog(method, message, context) {
+        if (!context || Object.keys(context).length === 0) {
+            this.logger[method](message);
+            return;
+        }
+        this.logger[method](context, message);
+    }
+}
+exports.PinoLogger = PinoLogger;
+async function createPinoLogger(options = {}) {
+    const level = options.level ?? 'info';
+    const pino = await loadPinoFactory();
+    const pinoOptions = {
+        ...(options.pinoOptions ?? {}),
+        level
+    };
+    if (options.name) {
+        pinoOptions.name = options.name;
+    }
+    if (options.base !== undefined) {
+        pinoOptions.base = options.base;
+    }
+    if (options.pretty) {
+        pinoOptions.transport = options.prettyOptions
+            ? {
+                target: PINO_PRETTY_MODULE,
+                options: options.prettyOptions
+            }
+            : {
+                target: PINO_PRETTY_MODULE
+            };
+    }
+    const pinoLogger = pino(pinoOptions);
+    return new PinoLogger(pinoLogger, level);
+}

package/dist/infra/log/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });