@ryuu-reinzz/haruka-lib 1.0.15 → 1.2.15

package/main/index.js

@@ -1,52 +1,7 @@
 import addProperty from './socket.js';
 import useSQLiteAuthState from './sqliteAuth.js';
 
-const haruka = {}
- haruka.tutorial = () => {
- console.log(`
-╭──────────────────────────────────────╮
-│     @ryuu-reinzz/haruka-lib          │
-│  Small helper for WhatsApp Baileys   │
-╰──────────────────────────────────────╯
-
-Usage:
-  haruka.extendSocketBot(socket, store, smsg, baileys)
-    → extend socket with helper methods
-
-  haruka.useSQLiteAuthState()
-    → SQLite-based auth state for your bot
-
-Examples:
-  Add socket:
-   import makeWASocket, {
-     proto,
-     generateWAMessageFromContent,
-     jidDecode,
-     downloadContentFromMessage,
-     prepareWAMessageMedia,
-     generateMessageID
-   } from "baileys";
-   const conn = makeWASocket({});
-   const baileys = {
-            proto,
-            generateWAMessageFromContent,
-            jidDecode,
-            downloadContentFromMessage,
-            prepareWAMessageMedia,
-            generateMessageID
-        }
-   import haruka from "@ryuu-reinzz/haruka-lib";
-   haruka.addProperty(conn, store, smsg, baileys);
-  
-  SQLite session:
-    const sessionPath = "./session"
-    if (!fs.existsSync(sessionPath)) fs.mkdirSync(sessionPath, { recursive: true });
-    const useSQLiteAuthState = haruka.useSQLiteAuthState;
-    const { state, saveCreds } = await useSQLiteAuthState(sessionPath + \"auth.db\");
-
-Made by Ryuu
- `)
-}
+const haruka = global.Haruka;
 haruka.useSQLiteAuthState = useSQLiteAuthState;
 haruka.addProperty = addProperty;
 

package/main/socket.js

@@ -14,6 +14,70 @@ const __dirname = dirname(__filename);
  */
 
 export default function addProperty(socket, store, smsg, baileys) {
+const tutor = `
+ Welcome to @ryuu-reinzz/haruka-lib
+  Small helper for WhatsApp Baileys
+
+Usage:
+  haruka.extendSocketBot(socket, store, smsg, baileys)
+    → extend socket with helper methods
+
+  haruka.useSQLiteAuthState()
+    → SQLite-based auth state for your bot
+
+Examples:
+  Add socket:
+   import makeWASocket, {
+     proto,
+     generateWAMessageFromContent,
+     jidDecode,
+     downloadContentFromMessage,
+     prepareWAMessageMedia,
+     generateMessageID
+   } from "baileys";
+   const conn = makeWASocket({});
+   const baileys = {
+            proto,
+            generateWAMessageFromContent,
+            jidDecode,
+            downloadContentFromMessage,
+            prepareWAMessageMedia,
+            generateMessageID
+        }
+   import haruka from "@ryuu-reinzz/haruka-lib";
+   haruka.addProperty(conn, store, smsg, baileys);
+  
+  SQLite session:
+    const sessionPath = "./session"
+    if (!fs.existsSync(sessionPath)) fs.mkdirSync(sessionPath, { recursive: true });
+    const useSQLiteAuthState = haruka.useSQLiteAuthState;
+    const { state, saveCreds } = await useSQLiteAuthState(sessionPath + \"auth.db\");
+
+Made by Ryuu`;
+ global.Haruka = () => {
+ socket.sendMessage(
+      socket.user.jid,
+      {
+        text: tutor,
+        contextInfo: {
+        forwardingScore: 99,
+            isForwarded: true,
+            forwardedNewsletterMessageInfo: {
+                newsletterName: "𝙍͢𝙮𝙪𝙪 𝙍͢𝙚𝙞𝙣𝙯𝙯",
+                newsletterJid: "120363419382206255@newsletter"
+            },
+          externalAdReply: {
+            title: "Haruka Tutorial",
+            body: "How to use",
+            thumbnailUrl: "https://api.ryuu-dev.offc.my.id/src/assest/bot/Haruka.jpg",
+            sourceUrl: `https://whatsapp.com/channel/0029Vb49CCWJ93wO2dLDqx14`,
+            mediaType: 1,
+            renderLargerThumbnail: true,
+          },
+        },
+      }
+     );
+    }
  const {
   proto,
   generateWAMessageFromContent,
@@ -155,350 +219,316 @@ Object.assign(socket, {
     }
 },
   
-    sendButton: async (jid, content = {}, options = {}) => {
-      if (!socket.user?.id) {
-        throw new Error("User not authenticated");
-      }
-
-      const {
-        text = "",
-        caption = "",
-        title = "",
-        footer = "",
-        buttons = [],
-        hasMediaAttachment = false,
-        image = null,
-        video = null,
-        document = null,
-        mimetype = null,
-        jpegThumbnail = null,
-        location = null,
-        product = null,
-        businessOwnerJid = null,
-      } = content;
-
-      if (!Array.isArray(buttons) || buttons.length ===
-        0) {
-        throw new Error(
-          "buttons must be a non-empty array");
-      }
-
-      const interactiveButtons = [];
-
-      for (let i = 0; i < buttons.length; i++) {
-        const btn = buttons[i];
-
-        if (!btn || typeof btn !== "object") {
-          throw new Error(
-            `button[${i}] must be an object`);
-        }
-
-        if (btn.name && btn.buttonParamsJson) {
-          interactiveButtons.push(btn);
-          continue;
-        }
-
-        if (btn.id || btn.text || btn.displayText) {
-          interactiveButtons.push({
-            name: "quick_reply",
-            buttonParamsJson: JSON
-              .stringify({
-                display_text: btn
-                  .text || btn
-                  .displayText ||
-                  `Button ${i + 1}`,
-                id: btn.id ||
-                  `quick_${i + 1}`,
-              }),
-          });
-          continue;
-        }
+    sendButton: 
+            async (jid, content = {}, options = {}) => {
+                if (!socket.user?.id) {
+                    throw new Error("User not authenticated");
+                }
 
-        if (btn.buttonId && btn.buttonText
-          ?.displayText) {
-          interactiveButtons.push({
-            name: "quick_reply",
-            buttonParamsJson: JSON
-              .stringify({
-                display_text: btn
-                  .buttonText
-                  .displayText,
-                id: btn.buttonId,
-              }),
-          });
-          continue;
-        }
+                const {
+                    text = "",
+                    caption = "",
+                    title = "",
+                    footer = "",
+                    buttons = [],
+                    hasMediaAttachment = false,
+                    image = null,
+                    video = null,
+                    document = null,
+                    mimetype = null,
+                    jpegThumbnail = null,
+                    location = null,
+                    product = null,
+                    businessOwnerJid = null,
+                    externalAdReply = null,
+                } = content;
+
+                if (!Array.isArray(buttons) || buttons.length === 0) {
+                    throw new Error("buttons must be a non-empty array");
+                }
 
-        throw new Error(
-          `button[${i}] has invalid shape`);
-      }
+                const processedButtons = [];
+
+                for (let i = 0; i < buttons.length; i++) {
+                    const btn = buttons[i];
+
+                    if (!btn || typeof btn !== "object") {
+                        throw new Error(`interactiveButton[${i}] must be an object`);
+                    }
+
+                    if (btn.name && btn.buttonParamsJson) {
+                        processedButtons.push(btn);
+                        continue;
+                    }
+
+                    if (btn.id || btn.text || btn.displayText) {
+                        processedButtons.push({
+                            name: "quick_reply",
+                            buttonParamsJson: JSON.stringify({
+                                display_text: btn.text || btn.displayText || `Button ${i + 1}`,
+                                id: btn.id || `quick_${i + 1}`,
+                            }),
+                        });
+                        continue;
+                    }
+
+                    if (btn.buttonId && btn.buttonText?.displayText) {
+                        processedButtons.push({
+                            name: "quick_reply",
+                            buttonParamsJson: JSON.stringify({
+                                display_text: btn.buttonText.displayText,
+                                id: btn.buttonId,
+                            }),
+                        });
+                        continue;
+                    }
+
+                    throw new Error(`interactiveButton[${i}] has invalid shape`);
+                }
 
-      let messageContent = {};
-      if (image) {
-        const mediaInput = {};
-        if (Buffer.isBuffer(image)) {
-          mediaInput.image = image;
-        } else if (typeof image === "object" && image
-          .url) {
-          mediaInput.image = {
-            url: image.url
-          };
-        } else if (typeof image === "string") {
-          mediaInput.image = {
-            url: image
-          };
-        }
+                let messageContent = {};
 
-        const preparedMedia =
-          await prepareWAMessageMedia(mediaInput, {
-            upload: socket.waUploadToServer,
-          });
-
-        messageContent.header = {
-          title: title || "",
-          hasMediaAttachment: hasMediaAttachment,
-          imageMessage: preparedMedia
-            .imageMessage,
-        };
-      } else if (video) {
-        const mediaInput = {};
-        if (Buffer.isBuffer(video)) {
-          mediaInput.video = video;
-        } else if (typeof video === "object" && video
-          .url) {
-          mediaInput.video = {
-            url: video.url
-          };
-        } else if (typeof video === "string") {
-          mediaInput.video = {
-            url: video
-          };
-        }
+                if (image) {
+                    const mediaInput = {};
+                    if (Buffer.isBuffer(image)) {
+                        mediaInput.image = image;
+                    } else if (typeof image === "object" && image.url) {
+                        mediaInput.image = { url: image.url };
+                    } else if (typeof image === "string") {
+                        mediaInput.image = { url: image };
+                    }
 
-        const preparedMedia =
-          await prepareWAMessageMedia(mediaInput, {
-            upload: socket.waUploadToServer,
-          });
-
-        messageContent.header = {
-          title: title || "",
-          hasMediaAttachment: hasMediaAttachment,
-          videoMessage: preparedMedia
-            .videoMessage,
-        };
-      } else if (document) {
-        const mediaInput = {
-          document: {}
-        };
-
-        if (Buffer.isBuffer(document)) {
-          mediaInput.document = document;
-        } else if (typeof document === "object" &&
-          document.url) {
-          mediaInput.document = {
-            url: document.url
-          };
-        } else if (typeof document === "string") {
-          mediaInput.document = {
-            url: document
-          };
-        }
+                    const preparedMedia = await prepareWAMessageMedia(mediaInput, {
+                        upload: socket.waUploadToServer,
+                    });
 
-        if (mimetype) {
-          if (typeof mediaInput.document ===
-            "object") {
-            mediaInput.document.mimetype = mimetype;
-          }
-        }
+                    messageContent.header = {
+                        title: title || "",
+                        hasMediaAttachment: hasMediaAttachment || true,
+                        imageMessage: preparedMedia.imageMessage,
+                    };
+                } else if (video) {
+                    const mediaInput = {};
+                    if (Buffer.isBuffer(video)) {
+                        mediaInput.video = video;
+                    } else if (typeof video === "object" && video.url) {
+                        mediaInput.video = { url: video.url };
+                    } else if (typeof video === "string") {
+                        mediaInput.video = { url: video };
+                    }
+
+                    const preparedMedia = await prepareWAMessageMedia(mediaInput, {
+                        upload: socket.waUploadToServer,
+                    });
 
-        if (jpegThumbnail) {
-          if (typeof mediaInput.document ===
-            "object") {
-            if (Buffer.isBuffer(jpegThumbnail)) {
-              mediaInput.document.jpegThumbnail =
-                jpegThumbnail;
-            } else if (typeof jpegThumbnail ===
-              "string") {
-              try {
-                const response = await fetch(
-                  jpegThumbnail);
-                const arrayBuffer =
-                  await response
-                  .arrayBuffer();
-                mediaInput.document
-                  .jpegThumbnail = Buffer
-                  .from(arrayBuffer);
-              } catch {
-              }
-            }
-          }
-        }
+                    messageContent.header = {
+                        title: title || "",
+                        hasMediaAttachment: hasMediaAttachment || true,
+                        videoMessage: preparedMedia.videoMessage,
+                    };
+                } else if (document) {
+                    const mediaInput = { document: {} };
+
+                    if (Buffer.isBuffer(document)) {
+                        mediaInput.document = document;
+                    } else if (typeof document === "object" && document.url) {
+                        mediaInput.document = { url: document.url };
+                    } else if (typeof document === "string") {
+                        mediaInput.document = { url: document };
+                    }
+
+                    if (mimetype) {
+                        if (typeof mediaInput.document === "object") {
+                            mediaInput.document.mimetype = mimetype;
+                        }
+                    }
+
+                    if (jpegThumbnail) {
+                        if (typeof mediaInput.document === "object") {
+                            if (Buffer.isBuffer(jpegThumbnail)) {
+                                mediaInput.document.jpegThumbnail = jpegThumbnail;
+                            } else if (typeof jpegThumbnail === "string") {
+                                try {
+                                    const response = await fetch(jpegThumbnail);
+                                    const arrayBuffer = await response.arrayBuffer();
+                                    mediaInput.document.jpegThumbnail = Buffer.from(arrayBuffer);
+                                } catch {
+                                    //
+                                }
+                            }
+                        }
+                    }
+
+                    const preparedMedia = await prepareWAMessageMedia(mediaInput, {
+                        upload: socket.waUploadToServer,
+                    });
 
-        const preparedMedia =
-          await prepareWAMessageMedia(mediaInput, {
-            upload: socket.waUploadToServer,
-          });
-
-        messageContent.header = {
-          title: title || "",
-          hasMediaAttachment: hasMediaAttachment,
-          documentMessage: preparedMedia
-            .documentMessage,
-        };
-      } else if (location && typeof location ===
-        "object") {
-        messageContent.header = {
-          title: title || location.name ||
-            "Location",
-          hasMediaAttachment: hasMediaAttachment,
-          locationMessage: {
-            degreesLatitude: location
-              .degressLatitude || location
-              .degreesLatitude || 0,
-            degreesLongitude: location
-              .degressLongitude || location
-              .degreesLongitude || 0,
-            name: location.name || "",
-            address: location.address || "",
-          },
-        };
-      } else if (product && typeof product === "object") {
-        let productImageMessage = null;
-        if (product.productImage) {
-          const mediaInput = {};
-          if (Buffer.isBuffer(product.productImage)) {
-            mediaInput.image = product.productImage;
-          } else if (
-            typeof product.productImage ===
-            "object" &&
-            product.productImage.url
-          ) {
-            mediaInput.image = {
-              url: product.productImage.url,
-            };
-          } else if (typeof product.productImage ===
-            "string") {
-            mediaInput.image = {
-              url: product.productImage,
-            };
-          }
+                    messageContent.header = {
+                        title: title || "",
+                        hasMediaAttachment: hasMediaAttachment || true,
+                        documentMessage: preparedMedia.documentMessage,
+                    };
+                } else if (location && typeof location === "object") {
+                    messageContent.header = {
+                        title: title || location.name || "Location",
+                        hasMediaAttachment: hasMediaAttachment || false,
+                        locationMessage: {
+                            degreesLatitude:
+                                location.degressLatitude || location.degreesLatitude || 0,
+                            degreesLongitude:
+                                location.degressLongitude || location.degreesLongitude || 0,
+                            name: location.name || "",
+                            address: location.address || "",
+                        },
+                    };
+                } else if (product && typeof product === "object") {
+                    let productImageMessage = null;
+                    if (product.productImage) {
+                        const mediaInput = {};
+                        if (Buffer.isBuffer(product.productImage)) {
+                            mediaInput.image = product.productImage;
+                        } else if (
+                            typeof product.productImage === "object" &&
+                            product.productImage.url
+                        ) {
+                            mediaInput.image = {
+                                url: product.productImage.url,
+                            };
+                        } else if (typeof product.productImage === "string") {
+                            mediaInput.image = {
+                                url: product.productImage,
+                            };
+                        }
+
+                        const preparedMedia = await prepareWAMessageMedia(mediaInput, {
+                            upload: socket.waUploadToServer,
+                        });
+                        productImageMessage = preparedMedia.imageMessage;
+                    }
+
+                    messageContent.header = {
+                        title: title || product.title || "Product",
+                        hasMediaAttachment: hasMediaAttachment || false,
+                        productMessage: {
+                            product: {
+                                productImage: productImageMessage,
+                                productId: product.productId || "",
+                                title: product.title || "",
+                                description: product.description || "",
+                                currencyCode: product.currencyCode || "USD",
+                                priceAmount1000: parseInt(product.priceAmount1000) || 0,
+                                retailerId: product.retailerId || "",
+                                url: product.url || "",
+                                productImageCount: product.productImageCount || 1,
+                            },
+                            businessOwnerJid:
+                                businessOwnerJid || product.businessOwnerJid || socket.user.id,
+                        },
+                    };
+                } else if (title) {
+                    messageContent.header = {
+                        title: title,
+                        hasMediaAttachment: false,
+                    };
+                }
 
-          const preparedMedia =
-            await prepareWAMessageMedia(
-              mediaInput, {
-                upload: socket.waUploadToServer,
-              });
-          productImageMessage = preparedMedia
-            .imageMessage;
-        }
+                const hasMedia = !!(image || video || document || location || product);
+                const bodyText = hasMedia ? caption : text || caption;
 
-        messageContent.header = {
-          title: title || product.title ||
-            "Product",
-          hasMediaAttachment: hasMediaAttachment,
-          productMessage: {
-            product: {
-              productImage: productImageMessage,
-              productId: product.productId ||
-                "",
-              title: product.title || "",
-              description: product
-                .description || "",
-              currencyCode: product
-                .currencyCode || "USD",
-              priceAmount1000: parseInt(
-                product.priceAmount1000
-              ) || 0,
-              retailerId: product
-                .retailerId || "",
-              url: product.url || "",
-              productImageCount: product
-                .productImageCount || 1,
-            },
-            businessOwnerJid: businessOwnerJid ||
-              product.businessOwnerJid || socket
-              .user.id,
-          },
-        };
-      } else if (title) {
-        messageContent.header = {
-          title: title,
-          hasMediaAttachment: false,
-        };
-      }
+                if (bodyText) {
+                    messageContent.body = { text: bodyText };
+                }
 
-      const hasMedia = !!(image || video || document ||
-        location || product);
-      const bodyText = hasMedia ? caption : text ||
-        caption;
+                if (footer) {
+                    messageContent.footer = { text: footer };
+                }
 
-      if (bodyText) {
-        messageContent.body = {
-          text: bodyText
-        };
-      }
+                messageContent.nativeFlowMessage = {
+                    buttons: processedButtons,
+                };
 
-      if (footer) {
-        messageContent.footer = {
-          text: footer
-        };
-      }
+                if (externalAdReply && typeof externalAdReply === "object") {
+                    messageContent.contextInfo = {
+                        externalAdReply: {
+                            title: externalAdReply.title || "",
+                            body: externalAdReply.body || "",
+                            mediaType: externalAdReply.mediaType || 1,
+                            sourceUrl: externalAdReply.sourceUrl || externalAdReply.url || "",
+                            thumbnailUrl:
+                                externalAdReply.thumbnailUrl || externalAdReply.thumbnail || "",
+                            renderLargerThumbnail: externalAdReply.renderLargerThumbnail || false,
+                            showAdAttribution: externalAdReply.showAdAttribution !== false,
+                            containsAutoReply: externalAdReply.containsAutoReply || false,
+                            ...(externalAdReply.mediaUrl && {
+                                mediaUrl: externalAdReply.mediaUrl,
+                            }),
+                            ...(externalAdReply.thumbnail &&
+                                Buffer.isBuffer(externalAdReply.thumbnail) && {
+                                    thumbnail: externalAdReply.thumbnail,
+                                }),
+                            ...(externalAdReply.jpegThumbnail && {
+                                jpegThumbnail: externalAdReply.jpegThumbnail,
+                            }),
+                        },
+                        ...(options.mentionedJid && {
+                            mentionedJid: options.mentionedJid,
+                        }),
+                    };
+                } else if (options.mentionedJid) {
+                    messageContent.contextInfo = {
+                        mentionedJid: options.mentionedJid,
+                    };
+                }
 
-      messageContent.nativeFlowMessage = {
-        buttons: interactiveButtons,
-      };
+                const payload = proto.Message.InteractiveMessage.create(messageContent);
 
-      const payload = proto.Message.InteractiveMessage
-        .create(messageContent);
+                const msg = generateWAMessageFromContent(
+                    jid,
+                    {
+                        viewOnceMessage: {
+                            message: {
+                                interactiveMessage: payload,
+                            },
+                        },
+                    },
+                    {
+                        userJid: socket.user.id,
+                        quoted: options?.quoted || null,
+                    }
+                );
 
-      const msg = generateWAMessageFromContent(
-        jid, {
-          viewOnceMessage: {
-            message: {
-              interactiveMessage: payload,
-            },
-          },
-        }, {
-          userJid: socket.user.id,
-          quoted: options?.quoted || null,
-        }
-      );
-      const isGroup = jid.endsWith("@g.us");
-      const additionalNodes = [{
-        tag: "biz",
-        attrs: {},
-        content: [{
-          tag: "interactive",
-          attrs: {
-            type: "native_flow",
-            v: "1",
-          },
-          content: [{
-            tag: "native_flow",
-            attrs: {
-              v: "9",
-              name: "mixed",
-            },
-          }, ],
-        }, ],
-      }, ];
-
-      if (!isGroup) {
-        additionalNodes.push({
-          tag: "bot",
-          attrs: {
-            biz_bot: "1"
-          },
-        });
-      }
+                const additionalNodes = [
+                    {
+                        tag: "biz",
+                        attrs: {},
+                        content: [
+                            {
+                                tag: "interactive",
+                                attrs: {
+                                    type: "native_flow",
+                                    v: "1",
+                                },
+                                content: [
+                                    {
+                                        tag: "native_flow",
+                                        attrs: {
+                                            v: "9",
+                                            name: "mixed",
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ];
 
-      await socket.relayMessage(jid, msg.message, {
-        messageId: msg.key.id,
-        additionalNodes,
-      });
+                await socket.relayMessage(jid, msg.message, {
+                    messageId: msg.key.id,
+                    additionalNodes,
+                });
 
-      return msg;
-    },
+                return msg;
+        },
         sendAlbum: async (jid, items = [], options = {}) => {
                 if (!socket.user?.id) {
                     throw new Error("User not authenticated");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuu-reinzz/haruka-lib",
-  "version": "1.0.15",
+  "version": "1.2.15",
   "description": "Library extra for bot WhatsApp",
   "main": "main/index.js",
   "type": "module",
@@ -17,6 +17,6 @@
   "dependencies": {
     "better-sqlite3": "^12.5.0",
     "node-fetch": "^2.6.1",
-    "wa-sticker-formatter": "^4.4.4"
+    "wa-sticker-formatter": "4.4.4"
   }
 }