waengine 1.1.0 → 1.1.2

package/README.md

@@ -137,22 +137,32 @@ quickBot()
     .start();
 ```
 
-### **Action Chaining**
-Chain multiple actions elegantly:
-
+### **🆕 Enhanced Action Chaining v1.1.0**
 ```javascript
-import { createBot } from "waengine";
-
 createBot()
-    .when("important")
-        .react("⚠️")
+    .when("demo")
+        .react("🎬")
         .type(2)
-        .reply("This is important!")
-        .react("✅")
+        .reply("Starting demo...")
+        .wait(1000)
+        .sendImage("demo.jpg", "Demo image")
+        .slowTypeWithMention("Hello @user! This is for you! 🎉")
+        .aiReply("Explain this demo")
+        .saveData("demos", "count", 1)
         .done()
     .start();
 ```
 
+### **🆕 New Mention Actions**
+```javascript
+bot
+    .when("hello").slowTypeWithMention("Hello @user! 👋")
+    .when("quick").quickTypeWithMention("Hey @user! ⚡")
+    .when("normal").normalTypeWithMention("Hi @user! 😊")
+    .when("mention").mentionSender("Thanks @user!")
+    .when("all").mentionAll("Hello everyone! 👥");
+```
+
 ### **EasyBot Features**
 ```javascript
 const bot = createBot()
@@ -449,6 +459,11 @@ await msg.replyWithMention("Hello @user!", userJid)
 // Mention all in group
 await msg.mentionAll("Hello everyone!")
 
+// NEW in v1.1.0: Mention with Typing
+await msg.slowTypeWithMention("Hello @user! How are you?", userJid)
+await msg.quickTypeWithMention("Hey @user! 👋", userJid)  
+await msg.normalTypeWithMention("Hi @user, nice to see you!", userJid)
+
 // Get mentions from message
 const mentions = msg.getMentions()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",
@@ -12,6 +12,9 @@
     "example:easy": "node examples/easy-bot-examples.js vollständig"
   },
   "keywords": [
+    "mention",
+    "waengine",
+    "hidetag",
     "whatsapp",
     "bot",
     "baileys",

package/src/easy-bot.js

@@ -455,21 +455,29 @@ export class EasyBot {
         }
     }
 
-    async sendReply(msg, text) {
+    async sendReply(msg, text, mentions = []) {
         try {
             if (this.isMultiDevice) {
                 const client = this.multiClient.getNextDevice();
                 if (client && client.socket) {
-                    await client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await client.socket.sendMessage(msg.from, messageObj);
                 } else {
                     throw new Error('Kein verfügbarer Multi-Device Client');
                 }
             } else {
                 if (msg.reply && typeof msg.reply === 'function') {
-                    await msg.reply(String(text));
+                    await msg.reply(String(text), mentions);
                 } else {
                     // Fallback: Direct client call
-                    await this.client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await this.client.socket.sendMessage(msg.from, messageObj);
                 }
             }
         } catch (error) {
@@ -477,7 +485,11 @@ export class EasyBot {
             // Fallback attempt
             try {
                 if (this.client && this.client.socket) {
-                    await this.client.socket.sendMessage(msg.from, { text: String(text) });
+                    const messageObj = { text: String(text) };
+                    if (mentions.length > 0) {
+                        messageObj.mentions = mentions;
+                    }
+                    await this.client.socket.sendMessage(msg.from, messageObj);
                 }
             } catch (fallbackError) {
                 console.error("❌ Auch Fallback fehlgeschlagen:", fallbackError.message);
@@ -771,6 +783,22 @@ class EasyRule {
         return this;
     }
 
+    // Neue Mention + Typing Kombinationen
+    slowTypeWithMention(text) {
+        this.actions.push({ type: 'slowTypeWithMention', value: text });
+        return this;
+    }
+
+    quickTypeWithMention(text) {
+        this.actions.push({ type: 'quickTypeWithMention', value: text });
+        return this;
+    }
+
+    normalTypeWithMention(text) {
+        this.actions.push({ type: 'normalTypeWithMention', value: text });
+        return this;
+    }
+
     // Delete actions
     deleteMessage() {
         this.actions.push({ type: 'delete' });
@@ -1046,13 +1074,99 @@ class EasyRule {
                         break;
                         
                     case 'mentionSender':
-                        // Implementierung für mentionSender
-                        await this.bot.sendReply(msg, action.value);
+                        // Verbesserte Implementierung für mentionSender
+                        try {
+                            if (msg.replyWithMention && typeof msg.replyWithMention === 'function') {
+                                await msg.replyWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionSender:', error.message);
+                            await this.bot.sendReply(msg, action.value);
+                        }
                         break;
                         
                     case 'mentionAll':
-                        // Implementierung für mentionAll
-                        await this.bot.sendReply(msg, action.value);
+                        // Verbesserte Implementierung für mentionAll
+                        try {
+                            if (msg.mentionAll && typeof msg.mentionAll === 'function') {
+                                await msg.mentionAll(action.value);
+                            } else {
+                                await this.bot.sendReply(msg, action.value);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionAll:', error.message);
+                            await this.bot.sendReply(msg, action.value);
+                        }
+                        break;
+                        
+                    case 'mentionUser':
+                        // Implementierung für mentionUser
+                        try {
+                            if (msg.replyWithMention && typeof msg.replyWithMention === 'function') {
+                                await msg.replyWithMention(action.value.text, action.value.userJid);
+                            } else {
+                                await this.bot.sendReply(msg, action.value.text);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei mentionUser:', error.message);
+                            await this.bot.sendReply(msg, action.value.text);
+                        }
+                        break;
+                        
+                    case 'slowTypeWithMention':
+                        // Neue Funktion: Slow Type mit Mention
+                        try {
+                            if (msg.slowTypeWithMention && typeof msg.slowTypeWithMention === 'function') {
+                                await msg.slowTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 4000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei slowTypeWithMention:', error.message);
+                        }
+                        break;
+                        
+                    case 'quickTypeWithMention':
+                        // Neue Funktion: Quick Type mit Mention
+                        try {
+                            if (msg.quickTypeWithMention && typeof msg.quickTypeWithMention === 'function') {
+                                await msg.quickTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 1000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei quickTypeWithMention:', error.message);
+                        }
+                        break;
+                        
+                    case 'normalTypeWithMention':
+                        // Neue Funktion: Normal Type mit Mention
+                        try {
+                            if (msg.normalTypeWithMention && typeof msg.normalTypeWithMention === 'function') {
+                                await msg.normalTypeWithMention(action.value, msg.getSender());
+                            } else {
+                                // Fallback
+                                const senderName = msg.getSender().split('@')[0];
+                                const mentionText = action.value.replace('@user', `@${senderName}`);
+                                await this.bot.typeMessage(msg, 2000);
+                                await this.bot.sendReply(msg, mentionText, [msg.getSender()]);
+                            }
+                        } catch (error) {
+                            console.error('❌ Fehler bei normalTypeWithMention:', error.message);
+                        }
                         break;
                         
                     case 'mentionUser':

package/src/message.js

@@ -301,6 +301,25 @@ export class Message {
         return await this.reply(mentionText, allMembers);
     }
 
+    // Mention mit Typing - Neue Funktion für bessere UX
+    async slowTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.slowType(mentionText, [userJid]);
+    }
+
+    async quickTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.quickType(mentionText, [userJid]);
+    }
+
+    async normalTypeWithMention(text, userJid) {
+        const senderName = userJid.split('@')[0];
+        const mentionText = text.replace('@user', `@${senderName}`);
+        return await this.normalType(mentionText, [userJid]);
+    }
+
     // ===== PERMISSION SYSTEM =====
 
     async isAdmin() {