@deffa5556/bail 1.0.6 → 1.0.7

package/cjs/lib/Utils/text-sticker.cjs

@@ -0,0 +1,174 @@
+"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.renderTextSticker = renderTextSticker;
+/**
+ * deffa@Changes --- Text Sticker generator.
+ *
+ * Implements WA's "Text Stickers" feature, announced officially on
+ * blog.whatsapp.com (Jan 7 2026, "Level Up Your WhatsApp Group Chats With
+ * New Member Tags, Text Stickers, and More"):
+ *   "you can now turn any word into a sticker by typing your text into
+ *    Sticker Search."
+ *
+ * IMPORTANT — protocol note: WA's "Sticker Search" is a client-side / app
+ * UI feature (local rendering + Meta's closed sticker search index). There
+ * is no dedicated wire-protocol message type for it — the result a user
+ * sends is just a normal stickerMessage (image/webp), identical to what
+ * Baileys already sends via the sticker pack pipeline in messages.js.
+ *
+ * This util renders the *client-side* part ourselves (text -> styled
+ * image -> webp), so deffa-baileys can produce the same end result
+ * (a valid stickerMessage) without depending on WA's internal sticker
+ * search service, which isn't reachable over the protocol Baileys speaks.
+ *
+ * Output of `renderTextSticker()` is a webp Buffer ready to be passed as
+ * the `sticker` field of `sock.sendMessage(jid, { sticker: buffer })`,
+ * exactly like any other sticker in this library.
+ */
+const boom_1 = require("@hapi/boom");
+const messages_media_js_1 = require("./messages-media.cjs");
+const MAX_TEXT_LENGTH = 60;
+const STICKER_SIZE = 512;
+const DEFAULT_STYLE = {
+    backgroundColor: '#FFFFFF',
+    textColor: '#000000',
+    fontFamily: 'sans-serif',
+    fontWeight: 'bold',
+    padding: 48,
+};
+/**
+ * Renders a single word/phrase into a square WhatsApp-compatible sticker (webp).
+ *
+ * @param {string} text - The text to render (e.g. a word typed into "Sticker Search").
+ * @param {object} [options]
+ * @param {string} [options.backgroundColor='#FFFFFF'] - CSS color for the sticker background.
+ * @param {string} [options.textColor='#000000'] - CSS color for the text.
+ * @param {string} [options.fontFamily='sans-serif'] - Font family available on the system/canvas.
+ * @param {string} [options.fontWeight='bold'] - CSS font-weight.
+ * @returns {Promise<Buffer>} webp-encoded sticker buffer, ready for sock.sendMessage(jid, { sticker: buffer }).
+ */
+async function renderTextSticker(text, options = {}) {
+    if (typeof text !== 'string' || !text.trim()) {
+        throw new boom_1.Boom('text is required to render a text sticker', { statusCode: 400 });
+    }
+    const trimmed = text.trim();
+    if (trimmed.length > MAX_TEXT_LENGTH) {
+        throw new boom_1.Boom(`text exceeds max length of ${MAX_TEXT_LENGTH} characters`, { statusCode: 400 });
+    }
+    const style = { ...DEFAULT_STYLE, ...options };
+    // canvas is an existing dependency of this package (see package.json).
+    let canvasLib;
+    try {
+        canvasLib = await Promise.resolve().then(() => __importStar(require('canvas')));
+    }
+    catch {
+        throw new boom_1.Boom('The "canvas" package is required to render text stickers but is not installed.', { statusCode: 500 });
+    }
+    const { createCanvas } = canvasLib;
+    const canvas = createCanvas(STICKER_SIZE, STICKER_SIZE);
+    const ctx = canvas.getContext('2d');
+    // Background
+    ctx.fillStyle = style.backgroundColor;
+    ctx.fillRect(0, 0, STICKER_SIZE, STICKER_SIZE);
+    // Auto-fit font size so the text (possibly multi-line) fits within the
+    // sticker bounds, shrinking from a large starting size.
+    const maxWidth = STICKER_SIZE - style.padding * 2;
+    const maxHeight = STICKER_SIZE - style.padding * 2;
+    let fontSize = 160;
+    let lines = [trimmed];
+    const wrapText = (size) => {
+        ctx.font = `${style.fontWeight} ${size}px ${style.fontFamily}`;
+        const words = trimmed.split(/\s+/);
+        const wrapped = [];
+        let current = '';
+        for (const word of words) {
+            const test = current ? `${current} ${word}` : word;
+            if (ctx.measureText(test).width <= maxWidth || !current) {
+                current = test;
+            }
+            else {
+                wrapped.push(current);
+                current = word;
+            }
+        }
+        if (current)
+            wrapped.push(current);
+        return wrapped;
+    };
+    while (fontSize > 24) {
+        lines = wrapText(fontSize);
+        const lineHeight = fontSize * 1.15;
+        const totalHeight = lineHeight * lines.length;
+        const widestLine = Math.max(...lines.map(l => ctx.measureText(l).width));
+        if (totalHeight <= maxHeight && widestLine <= maxWidth) {
+            break;
+        }
+        fontSize -= 4;
+    }
+    ctx.font = `${style.fontWeight} ${fontSize}px ${style.fontFamily}`;
+    ctx.fillStyle = style.textColor;
+    ctx.textAlign = 'center';
+    ctx.textBaseline = 'middle';
+    const lineHeight = fontSize * 1.15;
+    const startY = STICKER_SIZE / 2 - (lineHeight * (lines.length - 1)) / 2;
+    lines.forEach((line, i) => {
+        ctx.fillText(line, STICKER_SIZE / 2, startY + i * lineHeight);
+    });
+    const pngBuffer = canvas.toBuffer('image/png');
+    // Convert PNG -> WebP using the same image-processing pipeline the rest
+    // of the library already relies on (sharp / @napi-rs/image), so output
+    // is guaranteed to be a valid WA sticker (webp, <=1MB, 512x512).
+    const lib = await (0, messages_media_js_1.getImageProcessingLibrary)();
+    let webpBuffer;
+    if ('sharp' in lib && lib.sharp?.default) {
+        webpBuffer = await lib.sharp.default(pngBuffer)
+            .resize(STICKER_SIZE, STICKER_SIZE, { fit: 'inside' })
+            .webp({ quality: 90 })
+            .toBuffer();
+    }
+    else if ('image' in lib && lib.image?.Transformer) {
+        webpBuffer = await new lib.image.Transformer(pngBuffer)
+            .resize(STICKER_SIZE, STICKER_SIZE)
+            .webp(90);
+    }
+    else {
+        throw new boom_1.Boom('No image processing library (sharp or @napi-rs/image) available to encode the sticker as WebP.', { statusCode: 500 });
+    }
+    if (webpBuffer.length > 1024 * 1024) {
+        throw new boom_1.Boom('Generated text sticker exceeds the 1MB WhatsApp sticker size limit.', { statusCode: 400 });
+    }
+    return webpBuffer;
+}

package/cjs/lib/Utils/use-multi-file-auth-state.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_mutex_1 = require("async-mutex");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const index_js_1 = require("../../WAProto/index.cjs");
+const auth_utils_js_1 = require("./auth-utils.cjs");
+const generics_js_1 = require("./generics.cjs");
+// We need to lock files due to the fact that we are using async functions to read and write files
+// https://github.com/WhiskeySockets/Baileys/issues/794
+// https://github.com/nodejs/node/issues/26338
+// Use a Map to store mutexes for each file path
+const fileLocks = new Map();
+// Get or create a mutex for a specific file path
+const getFileLock = (path) => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new async_mutex_1.Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+/**
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const writeData = async (data, file) => {
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
+        return mutex.acquire().then(async (release) => {
+            try {
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_js_1.BufferJSON.replacer));
+            }
+            finally {
+                release();
+            }
+        });
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return await mutex.acquire().then(async (release) => {
+                try {
+                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, generics_js_1.BufferJSON.reviver);
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await (0, promises_1.unlink)(filePath);
+                }
+                catch {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch { }
+    };
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        }
+    }
+    else {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+    }
+    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;
+//# sourceMappingURL=use-multi-file-auth-state.js.map

package/cjs/lib/Utils/use-single-file-auth-state.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+const promises_1 = require("fs/promises");
+const index_js_1 = require("../Defaults/index.cjs");
+const index_js_2 = require("../../WAProto/index.cjs");
+const auth_utils_js_1 = require("./auth-utils.cjs");
+const generics_js_1 = require("./generics.cjs");
+const lru_cache_1 = require("lru-cache");
+const async_mutex_1 = require("async-mutex");
+// Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
+const FLUSH_TIMEOUT_MS = 3000;
+// Lia@Changes 22-04-26 --- Enhanced useSingleFileAuthState with LRUCache
+const useSingleFileAuthState = async (fileName) => {
+    const cache = new lru_cache_1.LRUCache({
+        max: 20000,
+        ttl: 1000 * index_js_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        updateAgeOnGet: false,
+        updateAgeOnHas: false,
+        ttlAutopurge: true
+    });
+    // Lia@Changes 26-04-26 --- Add mutex for prevent race condition
+    const mutex = new async_mutex_1.Mutex();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded)
+                return;
+            try {
+                const data = JSON.parse(await (0, promises_1.readFile)(fileName, 'utf-8'), generics_js_1.BufferJSON.reviver);
+                fileData = data || {};
+                for (const [keyName, value] of Object.entries(fileData)) {
+                    cache.set(keyName, value);
+                }
+            }
+            catch {
+                fileData = {};
+            }
+            isLoaded = true;
+        });
+    };
+    const flushKey = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await (0, promises_1.writeFile)(tempFile, JSON.stringify(fileData, generics_js_1.BufferJSON.replacer));
+                    await (0, promises_1.rename)(tempFile, fileName);
+                }
+                catch { }
+            });
+        }, FLUSH_TIMEOUT_MS);
+    };
+    const writeKey = (keyName, value) => {
+        cache.set(keyName, value);
+        fileData[keyName] = value;
+        flushKey();
+    };
+    const removeKey = (keyName) => {
+        cache.delete(keyName);
+        delete fileData[keyName];
+        flushKey();
+    };
+    const fileInfo = await (0, promises_1.stat)(fileName).catch(() => null);
+    if (!fileInfo) {
+        await (0, promises_1.writeFile)(fileName, '{}');
+    }
+    else if (!fileInfo.isFile()) {
+        throw new Error(`found something that is not a file at ${fileName}, either delete it or specify a different location`);
+    }
+    await loadKey();
+    const creds = fileData['creds'] || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const keyName = type + id;
+                        let value = cache.get(keyName);
+                        if (value === undefined && fileData[keyName] !== undefined) {
+                            value = fileData[keyName];
+                            cache.set(keyName, value);
+                        }
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_2.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }
+                    return data;
+                },
+                set: (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const keyName = category + id;
+                            const value = data[category][id];
+                            value ? writeKey(keyName, value) : removeKey(keyName);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: () => writeKey('creds', creds)
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;
+//# sourceMappingURL=use-single-file-auth-state.js.map

package/cjs/lib/Utils/use-sqlite-auth-state.cjs

@@ -0,0 +1,145 @@
+"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.useSqliteAuthState = useSqliteAuthState;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const index_js_1 = require("../../WAProto/index.cjs");
+const auth_utils_js_1 = require("./auth-utils.cjs");
+const generics_js_1 = require("./generics.cjs");
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await Promise.resolve().then(() => __importStar(require('better-sqlite3'))));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+async function useSqliteAuthState(opts) {
+    let db;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+    }
+    // WAL mode allows concurrent reads alongside a single writer; matches
+    // what SQLite recommends for read-heavy workloads with sporadic writes.
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return (0, auth_utils_js_1.initAuthCreds)();
+        return JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, generics_js_1.BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async (data) => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, generics_js_1.BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        }
+    };
+}
+//# sourceMappingURL=use-sqlite-auth-state.js.map