whatsapp-web-jf.js 1.31.0

package/src/util/InterfaceController.js

@@ -0,0 +1,126 @@
+'use strict';
+
+/**
+ * Interface Controller
+ */
+class InterfaceController {
+
+    constructor(props) {
+        this.pupPage = props.pupPage;
+    }
+
+    /**
+     * Opens the Chat Window
+     * @param {string} chatId ID of the chat window that will be opened
+     */
+    async openChatWindow(chatId) {
+        await this.pupPage.evaluate(async (chatId) => {
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+            await window.Store.Cmd.openChatBottom(chat);
+        }, chatId);
+    }
+
+    /**
+     * Opens the Chat Drawer
+     * @param {string} chatId ID of the chat drawer that will be opened
+     */
+    async openChatDrawer(chatId) {
+        await this.pupPage.evaluate(async chatId => {
+            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+            await window.Store.Cmd.openDrawerMid(chat);
+        }, chatId);
+    }
+
+    /**
+     * Opens the Chat Search
+     * @param {string} chatId ID of the chat search that will be opened
+     */
+    async openChatSearch(chatId) {
+        await this.pupPage.evaluate(async chatId => {
+            let chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+            await window.Store.Cmd.chatSearch(chat);
+        }, chatId);
+    }
+
+    /**
+     * Opens or Scrolls the Chat Window to the position of the message
+     * @param {string} msgId ID of the message that will be scrolled to
+     */
+    async openChatWindowAt(msgId) {
+        await this.pupPage.evaluate(async (msgId) => {
+            const msg = window.Store.Msg.get(msgId) || (await window.Store.Msg.getMessagesById([msgId]))?.messages?.[0];
+            const chat = window.Store.Chat.get(msg.id.remote) ?? await window.Store.Chat.find(msg.id.remote);
+            const searchContext = await window.Store.SearchContext.getSearchContext(chat, msg.id);
+            await window.Store.Cmd.openChatAt({ chat: chat, msgContext: searchContext });
+        }, msgId);
+    }
+
+    /**
+     * Opens the Message Drawer
+     * @param {string} msgId ID of the message drawer that will be opened
+     */
+    async openMessageDrawer(msgId) {
+        await this.pupPage.evaluate(async msgId => {
+            const msg = window.Store.Msg.get(msgId) || (await window.Store.Msg.getMessagesById([msgId]))?.messages?.[0];
+            await window.Store.Cmd.msgInfoDrawer(msg);
+        }, msgId);
+    }
+
+    /**
+     * Closes the Right Drawer
+     */
+    async closeRightDrawer() {
+        await this.pupPage.evaluate(async () => {
+            await window.Store.DrawerManager.closeDrawerRight();
+        });
+    }
+
+    /**
+     * Get all Features
+     */
+    async getFeatures() {
+        return await this.pupPage.evaluate(() => {
+            if(!window.Store.Features) throw new Error('This version of Whatsapp Web does not support features');
+            return window.Store.Features.F;
+        });
+    }
+
+    /**
+     * Check if Feature is enabled
+     * @param {string} feature status to check
+     */
+    async checkFeatureStatus(feature) {
+        return await this.pupPage.evaluate((feature) => {
+            if(!window.Store.Features) throw new Error('This version of Whatsapp Web does not support features');
+            return window.Store.Features.supportsFeature(feature);
+        }, feature);
+    }
+
+    /**
+     * Enable Features
+     * @param {string[]} features to be enabled
+     */
+    async enableFeatures(features) {
+        await this.pupPage.evaluate((features) => {
+            if(!window.Store.Features) throw new Error('This version of Whatsapp Web does not support features');
+            for (const feature in features) {
+                window.Store.Features.setFeature(features[feature], true);
+            }
+        }, features);
+    }
+
+    /**
+     * Disable Features
+     * @param {string[]} features to be disabled
+     */
+    async disableFeatures(features) {
+        await this.pupPage.evaluate((features) => {
+            if(!window.Store.Features) throw new Error('This version of Whatsapp Web does not support features');
+            for (const feature in features) {
+                window.Store.Features.setFeature(features[feature], false);
+            }
+        }, features);
+    }
+}
+
+module.exports = InterfaceController;

package/src/util/Puppeteer.js

@@ -0,0 +1,23 @@
+/**
+ * Expose a function to the page if it does not exist
+ *
+ * NOTE:
+ * Rewrite it to 'upsertFunction' after updating Puppeteer to 20.6 or higher
+ * using page.removeExposedFunction
+ * https://pptr.dev/api/puppeteer.page.removeExposedFunction
+ *
+ * @param {import(puppeteer).Page} page
+ * @param {string} name
+ * @param {Function} fn
+ */
+async function exposeFunctionIfAbsent(page, name, fn) {
+    const exist = await page.evaluate((name) => {
+        return !!window[name];
+    }, name);
+    if (exist) {
+        return;
+    }
+    await page.exposeFunction(name, fn);
+}
+
+module.exports = {exposeFunctionIfAbsent};

package/src/util/Util.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const path = require('path');
+const Crypto = require('crypto');
+const { tmpdir } = require('os');
+const ffmpeg = require('fluent-ffmpeg');
+const webp = require('node-webpmux');
+const fs = require('fs').promises;
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+/**
+ * Utility methods
+ */
+class Util {
+    constructor() {
+        throw new Error(`The ${this.constructor.name} class may not be instantiated.`);
+    }
+
+    static generateHash(length) {
+        var result = '';
+        var characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        var charactersLength = characters.length;
+        for (var i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result;
+    }
+
+    /**
+     * Sets default properties on an object that aren't already specified.
+     * @param {Object} def Default properties
+     * @param {Object} given Object to assign defaults to
+     * @returns {Object}
+     * @private
+     */
+    static mergeDefault(def, given) {
+        if (!given) return def;
+        for (const key in def) {
+            if (!has(given, key) || given[key] === undefined) {
+                given[key] = def[key];
+            } else if (given[key] === Object(given[key])) {
+                given[key] = Util.mergeDefault(def[key], given[key]);
+            }
+        }
+
+        return given;
+    }
+
+    /**
+     * Formats a image to webp
+     * @param {MessageMedia} media
+     * 
+     * @returns {Promise<MessageMedia>} media in webp format
+     */
+    static async formatImageToWebpSticker(media, pupPage) {
+        if (!media.mimetype.includes('image'))
+            throw new Error('media is not a image');
+
+        if (media.mimetype.includes('webp')) {
+            return media;
+        }
+
+        return pupPage.evaluate((media) => {
+            return window.WWebJS.toStickerData(media);
+        }, media);
+    }
+
+    /**
+     * Formats a video to webp
+     * @param {MessageMedia} media
+     * 
+     * @returns {Promise<MessageMedia>} media in webp format
+     */
+    static async formatVideoToWebpSticker(media) {
+        if (!media.mimetype.includes('video'))
+            throw new Error('media is not a video');
+
+        const videoType = media.mimetype.split('/')[1];
+
+        const tempFile = path.join(
+            tmpdir(),
+            `${Crypto.randomBytes(6).readUIntLE(0, 6).toString(36)}.webp`
+        );
+
+        const stream = new (require('stream').Readable)();
+        const buffer = Buffer.from(
+            media.data.replace(`data:${media.mimetype};base64,`, ''),
+            'base64'
+        );
+        stream.push(buffer);
+        stream.push(null);
+
+        await new Promise((resolve, reject) => {
+            ffmpeg(stream)
+                .inputFormat(videoType)
+                .on('error', reject)
+                .on('end', () => resolve(true))
+                .addOutputOptions([
+                    '-vcodec',
+                    'libwebp',
+                    '-vf',
+                    // eslint-disable-next-line no-useless-escape
+                    'scale=\'iw*min(300/iw\,300/ih)\':\'ih*min(300/iw\,300/ih)\',format=rgba,pad=300:300:\'(300-iw)/2\':\'(300-ih)/2\':\'#00000000\',setsar=1,fps=10',
+                    '-loop',
+                    '0',
+                    '-ss',
+                    '00:00:00.0',
+                    '-t',
+                    '00:00:05.0',
+                    '-preset',
+                    'default',
+                    '-an',
+                    '-vsync',
+                    '0',
+                    '-s',
+                    '512:512',
+                ])
+                .toFormat('webp')
+                .save(tempFile);
+        });
+
+        const data = await fs.readFile(tempFile, 'base64');
+        await fs.unlink(tempFile);
+
+        return {
+            mimetype: 'image/webp',
+            data: data,
+            filename: media.filename,
+        };
+    }
+
+    /**
+     * Sticker metadata.
+     * @typedef {Object} StickerMetadata
+     * @property {string} [name] 
+     * @property {string} [author] 
+     * @property {string[]} [categories]
+     */
+
+    /**
+     * Formats a media to webp
+     * @param {MessageMedia} media
+     * @param {StickerMetadata} metadata
+     * 
+     * @returns {Promise<MessageMedia>} media in webp format
+     */
+    static async formatToWebpSticker(media, metadata, pupPage) {
+        let webpMedia;
+
+        if (media.mimetype.includes('image'))
+            webpMedia = await this.formatImageToWebpSticker(media, pupPage);
+        else if (media.mimetype.includes('video'))
+            webpMedia = await this.formatVideoToWebpSticker(media);
+        else
+            throw new Error('Invalid media format');
+
+        if (metadata.name || metadata.author) {
+            const img = new webp.Image();
+            const hash = this.generateHash(32);
+            const stickerPackId = hash;
+            const packname = metadata.name;
+            const author = metadata.author;
+            const categories = metadata.categories || [''];
+            const json = { 'sticker-pack-id': stickerPackId, 'sticker-pack-name': packname, 'sticker-pack-publisher': author, 'emojis': categories };
+            let exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
+            let jsonBuffer = Buffer.from(JSON.stringify(json), 'utf8');
+            let exif = Buffer.concat([exifAttr, jsonBuffer]);
+            exif.writeUIntLE(jsonBuffer.length, 14, 4);
+            await img.load(Buffer.from(webpMedia.data, 'base64'));
+            img.exif = exif;
+            webpMedia.data = (await img.save(null)).toString('base64');
+        }
+
+        return webpMedia;
+    }
+
+    /**
+     * Configure ffmpeg path
+     * @param {string} path
+     */
+    static setFfmpegPath(path) {
+        ffmpeg.setFfmpegPath(path);
+    }
+}
+
+module.exports = Util;

package/src/webCache/LocalWebCache.js

@@ -0,0 +1,40 @@
+const path = require('path');
+const fs = require('fs');
+
+const { WebCache, VersionResolveError } = require('./WebCache');
+
+/**
+ * LocalWebCache - Fetches a WhatsApp Web version from a local file store
+ * @param {object} options - options
+ * @param {string} options.path - Path to the directory where cached versions are saved, default is: "./.wwebjs_cache/" 
+ * @param {boolean} options.strict - If true, will throw an error if the requested version can't be fetched. If false, will resolve to the latest version.
+ */
+class LocalWebCache extends WebCache {
+    constructor(options = {}) {
+        super();
+
+        this.path = options.path || './.wwebjs_cache/';
+        this.strict = options.strict || false;
+    }
+
+    async resolve(version) {
+        const filePath = path.join(this.path, `${version}.html`);
+        
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (err) {
+            if (this.strict) throw new VersionResolveError(`Couldn't load version ${version} from the cache`);
+            return null;
+        }
+    }
+
+    async persist(indexHtml, version) {
+        // version = (version+'').replace(/[^0-9.]/g,'');
+        const filePath = path.join(this.path, `${version}.html`);
+        fs.mkdirSync(this.path, { recursive: true });
+        fs.writeFileSync(filePath, indexHtml);
+    }
+}
+
+module.exports = LocalWebCache;

package/src/webCache/RemoteWebCache.js

@@ -0,0 +1,40 @@
+const fetch = require('node-fetch');
+const { WebCache, VersionResolveError } = require('./WebCache');
+
+/**
+ * RemoteWebCache - Fetches a WhatsApp Web version index from a remote server
+ * @param {object} options - options
+ * @param {string} options.remotePath - Endpoint that should be used to fetch the version index. Use {version} as a placeholder for the version number.
+ * @param {boolean} options.strict - If true, will throw an error if the requested version can't be fetched. If false, will resolve to the latest version. Defaults to false.
+ */
+class RemoteWebCache extends WebCache {
+    constructor(options = {}) {
+        super();
+
+        if (!options.remotePath) throw new Error('webVersionCache.remotePath is required when using the remote cache');
+        this.remotePath = options.remotePath;
+        this.strict = options.strict || false;
+    }
+
+    async resolve(version) {
+        const remotePath = this.remotePath.replace('{version}', version);
+
+        try {
+            const cachedRes = await fetch(remotePath);
+            if (cachedRes.ok) {
+                return cachedRes.text();
+            }
+        } catch (err) {
+            console.error(`Error fetching version ${version} from remote`, err);
+        }
+
+        if (this.strict) throw new VersionResolveError(`Couldn't load version ${version} from the archive`);
+        return null;         
+    }
+
+    async persist() {
+        // Nothing to do here
+    }
+}
+
+module.exports = RemoteWebCache;

package/src/webCache/WebCache.js

@@ -0,0 +1,14 @@
+/**
+ * Default implementation of a web version cache that does nothing.
+ */
+class WebCache {
+    async resolve() { return null; }
+    async persist() { }
+}
+
+class VersionResolveError extends Error { }
+
+module.exports = {
+    WebCache,
+    VersionResolveError
+};

package/src/webCache/WebCacheFactory.js

@@ -0,0 +1,20 @@
+const RemoteWebCache = require('./RemoteWebCache');
+const LocalWebCache = require('./LocalWebCache');
+const { WebCache } = require('./WebCache');
+
+const createWebCache = (type, options) => {
+    switch (type) {
+    case 'remote':
+        return new RemoteWebCache(options);
+    case 'local':
+        return new LocalWebCache(options);
+    case 'none':
+        return new WebCache();
+    default:
+        throw new Error(`Invalid WebCache type ${type}`);
+    }
+};
+
+module.exports = {
+    createWebCache,
+};