Merge branch 'main' of https://github.com/pedroslopez/whatsapp-web.js

Author: Eonus

index.d.ts

@@ -882,13 +882,17 @@ declare namespace WAWebJS {
         AUTHENTICATED = 'authenticated',
         AUTHENTICATION_FAILURE = 'auth_failure',
         READY = 'ready',
+        CHAT_REMOVED = 'chat_removed',
+        CHAT_ARCHIVED = 'chat_archived',
         MESSAGE_RECEIVED = 'message',
         MESSAGE_CIPHERTEXT = 'message_ciphertext',
         MESSAGE_CREATE = 'message_create',
         MESSAGE_REVOKED_EVERYONE = 'message_revoke_everyone',
         MESSAGE_REVOKED_ME = 'message_revoke_me',
         MESSAGE_ACK = 'message_ack',
         MESSAGE_EDIT = 'message_edit',
+        UNREAD_COUNT = 'unread_count',
+        MESSAGE_REACTION = 'message_reaction',
         MEDIA_UPLOADED = 'media_uploaded',
         CONTACT_CHANGED = 'contact_changed',
         GROUP_JOIN = 'group_join',
@@ -900,6 +904,7 @@ declare namespace WAWebJS {
         CODE_RECEIVED = 'code',
         CODE_FAILED = 'code_failed',
         LOADING_SCREEN = 'loading_screen',
+        CALL = 'call',
         DISCONNECTED = 'disconnected',
         STATE_CHANGED = 'change_state',
         BATTERY_CHANGED = 'change_battery',
@@ -1719,6 +1724,8 @@ declare namespace WAWebJS {
         lastMessage: Message,
         /** Indicates if the Chat is pinned */
         pinned: boolean,
+        /** Indicates if the Chat is locked */
+        isLocked: boolean,
 
         /** Archives this chat */
         archive: () => Promise<void>,

src/Client.js

@@ -317,12 +317,15 @@ class Client extends EventEmitter {
         await this.pupPage.evaluate(() => {
             window.AuthStore.AppState.on('change:state', (_AppState, state) => { window.onAuthAppStateChangedEvent(state); });
             window.AuthStore.AppState.on('change:hasSynced', () => { window.onAppStateHasSyncedEvent(); });
-            window.AuthStore.Cmd.on('offline_progress_update', () => {
+            window.AuthStore.Cmd.on('offline_progress_update_from_bridge', () => {
                 window.onOfflineProgressUpdateEvent(window.AuthStore.OfflineMessageHandler.getOfflineDeliveryProgress());
             });
             window.AuthStore.Cmd.on('logout', async () => {
                 await window.onLogoutEvent();
             });
+            window.AuthStore.Cmd.on('logout_from_bridge', async () => {
+                await window.onLogoutEvent();
+            });
         });
     }
 
@@ -1151,6 +1154,7 @@ class Client extends EventEmitter {
             sendMediaAsDocument: options.sendMediaAsDocument,
             sendMediaAsHd: options.sendMediaAsHd,
             caption: options.caption,
+            isCaptionByUser: options.caption ? true : false,
             quotedMessageId: options.quotedMessageId,
             parseVCards: options.parseVCards !== false,
             mentionedJidList: options.mentions || [],
@@ -2124,7 +2128,7 @@ class Client extends EventEmitter {
      * @returns {Promise<boolean>} Returns true if the operation completed successfully, false otherwise
      */
     async deleteChannel(channelId) {
-        return await this.client.pupPage.evaluate(async (channelId) => {
+        return await this.pupPage.evaluate(async (channelId) => {
             const channel = await window.WWebJS.getChat(channelId, { getAsModel: false });
             if (!channel) return false;
             try {

src/authStrategies/RemoteAuth.js

@@ -102,18 +102,28 @@ class RemoteAuth extends BaseAuthStrategy {
     }
 
     async storeRemoteSession(options) {
-        /* Compress & Store Session */
         const pathExists = await this.isValidPath(this.userDataDir);
-        if (pathExists) {
-            await this.compressSession();
-            await this.store.save({session: path.join(this.dataPath, this.sessionName)});
-            await fs.promises.unlink(path.join(this.dataPath, `${this.sessionName}.zip`));
-            await fs.promises.rm(`${this.tempDir}`, {
-                recursive: true,
-                force: true,
-                maxRetries: this.rmMaxRetries,
-            }).catch(() => {});
+        if (!pathExists) return;
+
+        let compressedSessionPath;
+        try {
+            compressedSessionPath = await this.compressSession();
+            await this.store.save({ session: path.join(this.dataPath, this.sessionName) });
             if(options && options.emit) this.client.emit(Events.REMOTE_SESSION_SAVED);
+        } finally {
+            const paths = [
+                this.tempDir,
+                ...(compressedSessionPath ? [compressedSessionPath] : [])
+            ];
+            await Promise.allSettled(
+                paths.map((p) =>
+                    fs.promises.rm(p, {
+                        recursive: true,
+                        force: true,
+                        maxRetries: this.rmMaxRetries,
+                    })
+                )
+            );
         }
     }
 
@@ -142,20 +152,26 @@ class RemoteAuth extends BaseAuthStrategy {
     }
 
     async compressSession() {
-        const archive = archiver('zip');
-        const stream = fs.createWriteStream(path.join(this.dataPath, `${this.sessionName}.zip`));
+        const stageDefaultPath = path.join(this.tempDir, 'Default');
+        const userDataDefaultPath = path.join(this.userDataDir, 'Default');
 
-        await fs.copy(this.userDataDir, this.tempDir).catch(() => {});
-        await this.deleteMetadata();
-        return new Promise((resolve, reject) => {
-            archive
-                .directory(this.tempDir, false)
-                .on('error', err => reject(err))
-                .pipe(stream);
+        await fs.emptyDir(stageDefaultPath);
+        await this.copyByRequiredDirs(userDataDefaultPath, stageDefaultPath);
 
-            stream.on('close', () => resolve());
+        const archive = archiver('zip');
+        const outPath = path.join(this.dataPath, `${this.sessionName}.zip`);
+        const out = fs.createWriteStream(outPath);
+
+        await new Promise((resolve, reject) => {
+            out.once('close', resolve);
+            out.once('error', reject);
+            archive.once('error', reject);
+        
+            archive.pipe(out);
+            archive.directory(this.tempDir, false);
             archive.finalize();
         });
+        return outPath;
     }
 
     async unCompressSession(compressedSessionPath) {
@@ -171,25 +187,16 @@ class RemoteAuth extends BaseAuthStrategy {
         await fs.promises.unlink(compressedSessionPath);
     }
 
-    async deleteMetadata() {
-        const sessionDirs = [this.tempDir, path.join(this.tempDir, 'Default')];
-        for (const dir of sessionDirs) {
-            const sessionFiles = await fs.promises.readdir(dir);
-            for (const element of sessionFiles) {
-                if (!this.requiredDirs.includes(element)) {
-                    const dirElement = path.join(dir, element);
-                    const stats = await fs.promises.lstat(dirElement);
-    
-                    if (stats.isDirectory()) {
-                        await fs.promises.rm(dirElement, {
-                            recursive: true,
-                            force: true,
-                            maxRetries: this.rmMaxRetries,
-                        }).catch(() => {});
-                    } else {
-                        await fs.promises.unlink(dirElement).catch(() => {});
-                    }
-                }
+    async copyByRequiredDirs(from, to) {
+        for (const d of this.requiredDirs) {
+            const src = path.join(from, d);
+            if (await this.isValidPath(src)) {
+                const dest = path.join(to, path.basename(src));
+                await fs.promises.cp(src, dest, {
+                    recursive: true,
+                    force: true,
+                    errorOnExist: false
+                });
             }
         }
     }

src/structures/Chat.js

@@ -63,6 +63,12 @@ class Chat extends Base {
          */
         this.pinned = !!data.pin;
 
+        /**
+         * Indicates if the Chat is locked
+         * @type {boolean}
+         */
+        this.isLocked = data.isLocked;
+
         /**
          * Indicates if the chat is muted or not
          * @type {boolean}

src/structures/GroupChat.js

@@ -274,7 +274,8 @@ class GroupChat extends Chat {
     async setDescription(description) {
         const success = await this.client.pupPage.evaluate(async (chatId, description) => {
             const chatWid = window.Store.WidFactory.createWid(chatId);
-            let descId = window.Store.GroupMetadata.get(chatWid).descId;
+            const chat = await window.WWebJS.getChat(chatId, { getAsModel: false });
+            let descId = chat.groupMetadata.descId;
             let newId = await window.Store.MsgKey.newId();
             try {
                 await window.Store.GroupUtils.setGroupDescription(chatWid, description, newId, descId);

src/util/Injected/Store.js

@@ -123,7 +123,8 @@ exports.ExposeStore = () => {
 
     window.Store.NumberInfo = {
         ...window.require('WAPhoneUtils'),
-        ...window.require('WAPhoneFindCC')
+        ...window.require('WAPhoneFindCC'),
+        ...window.require('WAWebPhoneUtils')
     };
     window.Store.ForwardUtils = {
         ...window.require('WAWebChatForwardMessage')

src/util/Injected/Utils.js

@@ -573,10 +573,10 @@ exports.LoadUtils = () => {
 
         if (isChannel) {
             try {
-                chat = window.Store.WAWebNewsletterMetadataCollection.get(chatId);
+                chat = window.Store.WAWebNewsletterCollection.get(chatId);
                 if (!chat) {
                     await window.Store.ChannelUtils.loadNewsletterPreviewChat(chatId);
-                    chat = await window.Store.WAWebNewsletterMetadataCollection.find(chatWid);
+                    chat = await window.Store.WAWebNewsletterCollection.find(chatWid);
                 }
             } catch (err) {
                 chat = null;
@@ -639,7 +639,7 @@ exports.LoadUtils = () => {
     };
 
     window.WWebJS.getChannels = async () => {
-        const channels = window.Store.WAWebNewsletterMetadataCollection.getModelsArray();
+        const channels = window.Store.WAWebNewsletterCollection.getModelsArray();
         const channelPromises = channels?.map((channel) => window.WWebJS.getChatModel(channel, { isChannel: true }));
         return await Promise.all(channelPromises);
     };