@hansaka02/baileys 7.3.4 → 7.3.6

package/lib/WAM/encode.js

@@ -17,20 +17,23 @@ const encodeWAM = (binaryInfo) => {
     binaryInfo.buffer = []
     encodeWAMHeader(binaryInfo)
     encodeEvents(binaryInfo)
-    const totalSize = binaryInfo.buffer
-        .map((a) => a.length)
-        .reduce((a, b) => a + b)
+    
+    const totalSize = binaryInfo.buffer.map(a => a.length).reduce((a, b) => a + b)
     const buffer = Buffer.alloc(totalSize)
+    
     let offset = 0
+    
     for (const buffer_ of binaryInfo.buffer) {
         buffer_.copy(buffer, offset)
         offset += buffer_.length
     }
+    
     return buffer
 }
 
 function encodeWAMHeader(binaryInfo) {
     const headerBuffer = Buffer.alloc(8) // starting buffer
+    
     headerBuffer.write('WAM', 0, 'utf8')
     headerBuffer.writeUInt8(binaryInfo.protocolVersion, 3)
     headerBuffer.writeUInt8(1, 4) //random flag
@@ -41,35 +44,49 @@ function encodeWAMHeader(binaryInfo) {
 
 function encodeGlobalAttributes(binaryInfo, globals) {
     for (const [key, _value] of Object.entries(globals)) {
-        const id = WEB_GLOBALS.find(a => a?.name === key)?.id
+        const id = WEB_GLOBALS.find(a => a?.name === key).id
+        
         let value = _value
+        
         if (typeof value === 'boolean') {
             value = value ? 1 : 0
         }
+        
         binaryInfo.buffer.push(serializeData(id, value, FLAG_GLOBAL))
     }
 }
 
 function encodeEvents(binaryInfo) {
-    for (const [name, { props, globals },] of binaryInfo.events.map((a) => Object.entries(a)[0])) {
+    for (const [name, { props, globals }] of binaryInfo.events.map(a => Object.entries(a)[0])) {
         encodeGlobalAttributes(binaryInfo, globals)
-        const event = WEB_EVENTS.find((a) => a.name === name)
+        
+        const event = WEB_EVENTS.find(a => a.name === name)
         const props_ = Object.entries(props)
+        
         let extended = false
+        
         for (const [, value] of props_) {
             extended || (extended = value !== null)
         }
+        
         const eventFlag = extended ? FLAG_EVENT : FLAG_EVENT | FLAG_EXTENDED
+        
         binaryInfo.buffer.push(serializeData(event.id, -event.weight, eventFlag))
+        
         for (let i = 0; i < props_.length; i++) {
             const [key, _value] = props_[i]
-            const id = (event.props)[key][0]
-            extended = i < (props_.length - 1)
+            const id = event.props[key]?.[0]
+            
+            extended = i < props_.length - 1
+            
             let value = _value
+            
             if (typeof value === 'boolean') {
                 value = value ? 1 : 0
             }
+            
             const fieldFlag = extended ? FLAG_EVENT : FLAG_FIELD | FLAG_EXTENDED
+            
             binaryInfo.buffer.push(serializeData(id, value, fieldFlag))
         }
     }
@@ -77,77 +94,107 @@ function encodeEvents(binaryInfo) {
 
 function serializeData(key, value, flag) {
     const bufferLength = getHeaderBitLength(key)
+    
     let buffer
     let offset = 0
+    
     if (value === null) {
         if (flag === FLAG_GLOBAL) {
             buffer = Buffer.alloc(bufferLength)
             offset = serializeHeader(buffer, offset, key, flag)
+            
             return buffer
         }
     }
+    
     else if (typeof value === 'number' && Number.isInteger(value)) {
         // is number
         if (value === 0 || value === 1) {
             buffer = Buffer.alloc(bufferLength)
             offset = serializeHeader(buffer, offset, key, flag | ((value + 1) << 4))
+            
             return buffer
         }
+        
         else if (-128 <= value && value < 128) {
             buffer = Buffer.alloc(bufferLength + 1)
             offset = serializeHeader(buffer, offset, key, flag | (3 << 4))
+            
             buffer.writeInt8(value, offset)
+            
             return buffer
         }
+        
         else if (-32768 <= value && value < 32768) {
             buffer = Buffer.alloc(bufferLength + 2)
             offset = serializeHeader(buffer, offset, key, flag | (4 << 4))
+            
             buffer.writeInt16LE(value, offset)
+            
             return buffer
         }
+        
         else if (-2147483648 <= value && value < 2147483648) {
             buffer = Buffer.alloc(bufferLength + 4)
             offset = serializeHeader(buffer, offset, key, flag | (5 << 4))
+            
             buffer.writeInt32LE(value, offset)
+            
             return buffer
         }
+        
         else {
             buffer = Buffer.alloc(bufferLength + 8)
             offset = serializeHeader(buffer, offset, key, flag | (7 << 4))
+            
             buffer.writeDoubleLE(value, offset)
+            
             return buffer
         }
     }
+    
     else if (typeof value === 'number') {
         // is float
         buffer = Buffer.alloc(bufferLength + 8)
         offset = serializeHeader(buffer, offset, key, flag | (7 << 4))
+        
         buffer.writeDoubleLE(value, offset)
+        
         return buffer
     }
+    
     else if (typeof value === 'string') {
         // is string
         const utf8Bytes = Buffer.byteLength(value, 'utf8')
+        
         if (utf8Bytes < 256) {
             buffer = Buffer.alloc(bufferLength + 1 + utf8Bytes)
             offset = serializeHeader(buffer, offset, key, flag | (8 << 4))
+            
             buffer.writeUint8(utf8Bytes, offset++)
         }
+        
         else if (utf8Bytes < 65536) {
             buffer = Buffer.alloc(bufferLength + 2 + utf8Bytes)
             offset = serializeHeader(buffer, offset, key, flag | (9 << 4))
+            
             buffer.writeUInt16LE(utf8Bytes, offset)
             offset += 2
         }
+        
         else {
             buffer = Buffer.alloc(bufferLength + 4 + utf8Bytes)
             offset = serializeHeader(buffer, offset, key, flag | (10 << 4))
+            
             buffer.writeUInt32LE(utf8Bytes, offset)
             offset += 4
         }
+        
         buffer.write(value, offset, 'utf8')
+        
         return buffer
     }
+    
     throw 'missing'
 }
 
@@ -158,12 +205,14 @@ function serializeHeader(buffer, offset, key, flag) {
         buffer.writeUInt8(key, offset)
         offset += 1
     }
+    
     else {
         buffer.writeUInt8(flag | FLAG_BYTE, offset)
         offset += 1
         buffer.writeUInt16LE(key, offset)
         offset += 2
     }
+    
     return offset
 }
 

package/lib/WAUSync/USyncQuery.js

@@ -32,38 +32,54 @@ class USyncQuery {
         return this
     }
     parseUSyncQueryResult(result) {
-        if (result.attrs.type !== 'result') {
+        if (!result || result.attrs.type !== 'result') {
             return
         }
-        const protocolMap = Object.fromEntries(this.protocols.map((protocol) => {
+        
+        const protocolMap = Object.fromEntries(this.protocols.map(protocol => {
             return [protocol.name, protocol.parser]
         }))
+        
         const queryResult = {
             // TODO: implement errors etc.
             list: [],
-            sideList: [],
+            sideList: []
         }
+        
         const usyncNode = getBinaryNodeChild(result, 'usync')
+        
         //TODO: implement error backoff, refresh etc.
         //TODO: see if there are any errors in the result node
         //const resultNode = getBinaryNodeChild(usyncNode, 'result')
-        const listNode = getBinaryNodeChild(usyncNode, 'list')
-        if (Array.isArray(listNode?.content) && typeof listNode !== 'undefined') {
-            queryResult.list = listNode.content.map((node) => {
-                const id = node?.attrs?.jid
-                const data = Array.isArray(node?.content) ? Object.fromEntries(node.content.map((content) => {
-                    const protocol = content.tag
-                    const parser = protocolMap[protocol]
-                    if (parser) {
-                        return [protocol, parser(content)]
-                    }
-                    else {
-                        return [protocol, null]
-                    }
-                }).filter(([, b]) => b !== null)) : {}
-                return { ...data, id }
-            })
+        const listNode = usyncNode ? getBinaryNodeChild(usyncNode, 'list') : undefined
+        
+        if (listNode?.content && Array.isArray(listNode.content)) {
+            queryResult.list = listNode.content.reduce((acc, node) => {
+                const id = node?.attrs.jid
+                
+                if (id) {
+                    const data = Array.isArray(node?.content)
+                        ? Object.fromEntries(node.content
+                            .map(content => {
+                            const protocol = content.tag
+                            const parser = protocolMap[protocol]
+                            
+                            if (parser) {
+                                return [protocol, parser(content)]
+                            }
+                            
+                            else {
+                                return [protocol, null]
+                            }
+                        }).filter(([, b]) => b !== null))
+                        : {};
+                    acc.push({ ...data, id })
+                }
+                
+                return acc
+            }, [])
         }
+        
         //TODO: implement side list
         //const sideListNode = getBinaryNodeChild(usyncNode, 'side_list')
         return queryResult

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hansaka02/baileys",
-  "version": "7.3.4",
+  "version": "7.3.6",
   "description": "WhatsApp API Modification By hansaka",
   "keywords": [
     "whatsapp",
@@ -15,7 +15,7 @@
   "homepage": "https://github.com/hansaka02/Baileys",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/Itsukichann/Baileys.git"
+    "url": "git+ssh://git@github.com/hansaka02/baileys.git"
   },
   "license": "MIT",
   "author": "hansaka02",
@@ -39,18 +39,17 @@
     "@hapi/boom": "^9.1.3",
     "@adiwajshing/keyed-db": "^0.2.4",
     "@cacheable/node-cache": "1.5.3",
-    "@itsukichan/eslint-config": "^1.0.0",
     "@itsukichan/libsignal-node": "^1.0.1",
     "async-mutex": "^0.5.0",
-    "axios": "^1.12.1",
     "audio-decode": "^2.2.2",
     "cache-manager": "^5.7.6",
     "fflate": "^0.8.2",
     "lodash": "^4.17.21",
-    "link-preview-js": "^3.0.14",
+    "unfurl.js": "^6.4.0",
     "lru-cache": "^11.1.0",
     "music-metadata": "^7.12.3",
     "pino": "^9.6",
+    "p-queue": "^9.0.0",
     "protobufjs": "^7.2.4",
     "qrcode-terminal": "^0.12.0",
     "ws": "^8.13.0"
@@ -59,12 +58,13 @@
     "@types/jest": "^29.5.14",
     "@types/node": "^16.0.0",
     "@types/ws": "^8.0.0",
+    "@itsukichan/eslint-config": "^1.0.0",
     "conventional-changelog-cli": "^2.2.2",
     "eslint": "^8.0.0",
     "jest": "^30.1.1",
     "jimp": "^0.22.12",
     "json": "^11.0.0",
-    "link-preview-js": "^3.0.5",
+    "unfurl.js": "^6.4.0",
     "open": "^8.4.2",
     "release-it": "^15.10.3",
     "ts-jest": "^29.4.1",
@@ -74,7 +74,8 @@
     "typescript": "^5.8.2"
   },
   "peerDependencies": {
-    "jimp": "^0.22.12"
+    "jimp": "^0.22.12",
+    "sharp": "*"
   },
   "peerDependenciesMeta": {
     "jimp": {
@@ -89,6 +90,6 @@
     "lib": "lib"
   },
   "bugs": {
-    "url": "https://github.com/hansaka02Baileys/issues"
+    "url": "https://github.com/hansaka02/baileys/issues"
   }
 }

package/lib/Socket/usync.js

@@ -1,83 +0,0 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const { Boom } = require("@hapi/boom")
-const { S_WHATSAPP_NET } = require("../WABinary")
-const { makeSocket } = require("./socket")
-
-const makeUSyncSocket = (config) => {
-    const suki = makeSocket(config)
-    const { generateMessageTag, query, } = suki
-    
-    const executeUSyncQuery = async (usyncQuery) => {
-        if (usyncQuery.protocols.length === 0) {
-            throw new Boom('USyncQuery must have at least one protocol')
-        }
-        
-        // todo: validate users, throw WARNING on no valid users
-        // variable below has only validated users
-        const validUsers = usyncQuery.users
-        
-        const userNodes = validUsers.map((user) => {
-            return {
-                tag: 'user',
-                attrs: {
-                    jid: !user.phone ? user.id : undefined,
-                },
-                content: usyncQuery.protocols
-                    .map((a) => a.getUserElement(user))
-                    .filter(a => a !== null)
-            }
-        })
-        
-        const listNode = {
-            tag: 'list',
-            attrs: {},
-            content: userNodes
-        }
-        
-        const queryNode = {
-            tag: 'query',
-            attrs: {},
-            content: usyncQuery.protocols.map((a) => a.getQueryElement())
-        }
-        
-        const iq = {
-            tag: 'iq',
-            attrs: {
-                to: S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync',
-            },
-            content: [
-                {
-                    tag: 'usync',
-                    attrs: {
-                        context: usyncQuery.context,
-                        mode: usyncQuery.mode,
-                        sid: generateMessageTag(),
-                        last: 'true',
-                        index: '0',
-                    },
-                    content: [
-                        queryNode,
-                        listNode
-                    ]
-                }
-            ],
-        }
-        
-        const result = await query(iq)
-        
-        return usyncQuery.parseUSyncQueryResult(result)
-    }
-    return {
-        ...suki,
-        executeUSyncQuery
-    }
-}
-
-module.exports = {
-  makeUSyncSocket
-}