@pontalabs/baileys 1.0.10 → 1.1.0

package/lib/WAM/encode.js

@@ -1,164 +1,148 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const constants_1 = require("./constants")
-const getHeaderBitLength = (key) => (key < 256 ? 2 : 3)
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    FLAG_BYTE: FLAG_BYTE,
+    FLAG_EVENT: FLAG_EVENT,
+    FLAG_EXTENDED: FLAG_EXTENDED,
+    FLAG_FIELD: FLAG_FIELD,
+    FLAG_GLOBAL: FLAG_GLOBAL,
+    WEB_EVENTS: WEB_EVENTS,
+    WEB_GLOBALS: WEB_GLOBALS,
+} = require("./constants");
+const getHeaderBitLength = (key) => (key < 256 ? 2 : 3);
 const encodeWAM = (binaryInfo) => {
-    binaryInfo.buffer = []
-    encodeWAMHeader(binaryInfo)
-    encodeEvents(binaryInfo)
-    const totalSize = binaryInfo.buffer
-        .map((a) => a.length)
-        .reduce((a, b) => a + b)
-    const buffer = Buffer.alloc(totalSize)
-    let offset = 0
+    binaryInfo.buffer = [];
+    encodeWAMHeader(binaryInfo);
+    encodeEvents(binaryInfo);
+    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
+        buffer_.copy(buffer, offset);
+        offset += buffer_.length;
     }
-    return buffer
-}
-
+    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
-    headerBuffer.writeUInt16BE(binaryInfo.sequence, 5)
-    headerBuffer.writeUInt8(0, 7) // regular channel
-    binaryInfo.buffer.push(headerBuffer)
+    const headerBuffer = Buffer.alloc(8);
+    headerBuffer.write("WAM", 0, "utf8");
+    headerBuffer.writeUInt8(binaryInfo.protocolVersion, 3);
+    headerBuffer.writeUInt8(1, 4);
+    headerBuffer.writeUInt16BE(binaryInfo.sequence, 5);
+    headerBuffer.writeUInt8(0, 7);
+    binaryInfo.buffer.push(headerBuffer);
 }
-
 function encodeGlobalAttributes(binaryInfo, globals) {
     for (const [key, _value] of Object.entries(globals)) {
-        const id = constants_1.WEB_GLOBALS.find(a => a?.name === key)?.id
-        let value = _value
-        if (typeof value === 'boolean') {
-            value = value ? 1 : 0
+        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, constants_1.FLAG_GLOBAL))
+        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])) {
-        encodeGlobalAttributes(binaryInfo, globals)
-        const event = constants_1.WEB_EVENTS.find((a) => a.name === name)
-        const props_ = Object.entries(props)
-        let extended = false
+    for (const [name, { props: props, globals: globals }] of binaryInfo.events.map(
+        (a) => Object.entries(a)[0]
+    )) {
+        encodeGlobalAttributes(binaryInfo, globals);
+        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)
+            extended || (extended = value !== null);
         }
-        const eventFlag = extended ? constants_1.FLAG_EVENT : constants_1.FLAG_EVENT | constants_1.FLAG_EXTENDED
-        binaryInfo.buffer.push(serializeData(event.id, -event.weight, eventFlag))
+        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)
-            let value = _value
-            if (typeof value === 'boolean') {
-                value = value ? 1 : 0
+            const [key, _value] = props_[i];
+            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 ? constants_1.FLAG_EVENT : constants_1.FLAG_FIELD | constants_1.FLAG_EXTENDED
-            binaryInfo.buffer.push(serializeData(id, value, fieldFlag))
+            const fieldFlag = extended ? FLAG_EVENT : FLAG_FIELD | FLAG_EXTENDED;
+            binaryInfo.buffer.push(serializeData(id, value, fieldFlag));
         }
     }
 }
-
 function serializeData(key, value, flag) {
-    const bufferLength = getHeaderBitLength(key)
-    let buffer
-    let offset = 0
+    const bufferLength = getHeaderBitLength(key);
+    let buffer;
+    let offset = 0;
     if (value === null) {
-        if (flag === constants_1.FLAG_GLOBAL) {
-            buffer = Buffer.alloc(bufferLength)
-            offset = serializeHeader(buffer, offset, key, flag)
-            return buffer
+        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
+    } else if (typeof value === "number" && Number.isInteger(value)) {
         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
+            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')
+    } else if (typeof value === "number") {
+        buffer = Buffer.alloc(bufferLength + 8);
+        offset = serializeHeader(buffer, offset, key, flag | (7 << 4));
+        buffer.writeDoubleLE(value, offset);
+        return buffer;
+    } else if (typeof value === "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
+            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;
         }
-        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
+        buffer.write(value, offset, "utf8");
+        return buffer;
     }
-    throw 'missing'
+    throw "missing";
 }
-
 function serializeHeader(buffer, offset, key, flag) {
     if (key < 256) {
-        buffer.writeUInt8(flag, offset)
-        offset += 1
-        buffer.writeUInt8(key, offset)
-        offset += 1
-    }
-    else {
-        buffer.writeUInt8(flag | constants_1.FLAG_BYTE, offset)
-        offset += 1
-        buffer.writeUInt16LE(key, offset)
-        offset += 2
+        buffer.writeUInt8(flag, offset);
+        offset += 1;
+        buffer.writeUInt8(key, offset);
+        offset += 1;
+    } else {
+        buffer.writeUInt8(flag | FLAG_BYTE, offset);
+        offset += 1;
+        buffer.writeUInt16LE(key, offset);
+        offset += 2;
     }
-    return offset
+    return offset;
 }
-
-module.exports = {
-  encodeWAM
-}
+module.exports = { encodeWAM: encodeWAM };

package/lib/WAM/index.js

@@ -1,23 +1,34 @@
-"use strict"
-
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    var desc = Object.getOwnPropertyDescriptor(m, k)
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k] } }
-    }
-    Object.defineProperty(o, k2, desc)
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k
-    o[k2] = m[k]
-}))
-
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
-}
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-__exportStar(require("./constants"), exports)
-__exportStar(require("./encode"), exports)
-__exportStar(require("./BinaryInfo"), exports)
+"use strict";
+const __createBinding =
+    (this && this.__createBinding) ||
+    (Object.create
+        ? function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              let desc = Object.getOwnPropertyDescriptor(m, k);
+              if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+                  desc = {
+                      enumerable: true,
+                      get: function () {
+                          return m[k];
+                      },
+                  };
+              }
+              Object.defineProperty(o, k2, desc);
+          }
+        : function (o, m, k, k2) {
+              if (k2 === undefined) k2 = k;
+              o[k2] = m[k];
+          });
+const __exportStar =
+    (this && this.__exportStar) ||
+    function (m, exports) {
+        for (var p in m) {
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) {
+                __createBinding(exports, m, p);
+            }
+        }
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./encode"), exports);
+__exportStar(require("./BinaryInfo"), exports);

package/lib/WAUSync/Protocols/USyncBotProfileProtocol.js

@@ -1,69 +1,62 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const WABinary_1 = require("../../WABinary")
-
-class USyncBotProfileProtocol {
-    constructor() {
-        this.name = 'bot'
-    }
-    getQueryElement() {
-        return {
-            tag: 'bot',
-            attrs: {},
-            content: [{ tag: 'profile', attrs: { v: '1' } }]
-        }
-    }
-    getUserElement(user) {
-        return {
-            tag: 'bot',
-            attrs: {},
-            content: [{ tag: 'profile', attrs: { 'persona_id': user.personaId } }]
-        }
-    }
-    parser(node) {
-        const botNode = WABinary_1.getBinaryNodeChild(node, 'bot')
-        const profile = WABinary_1.getBinaryNodeChild(botNode, 'profile')
-
-        const commandsNode = WABinary_1.getBinaryNodeChild(profile, 'commands')
-        const promptsNode = WABinary_1.getBinaryNodeChild(profile, 'prompts')
-
-        const commands = []
-        const prompts = []
-
-        if (commandsNode) {
-            for (const command of WABinary_1.getBinaryNodeChildren(commandsNode, 'command')) {
-                commands.push({
-                    name: WABinary_1.getBinaryNodeChildString(command, 'name') || '',
-                    description: WABinary_1.getBinaryNodeChildString(command, 'description') || ''
-                })
-            }
-        }
-
-        if (promptsNode) {
-            for (const prompt of WABinary_1.getBinaryNodeChildren(promptsNode, 'prompt')) {
-                prompts.push(
-                    `${WABinary_1.getBinaryNodeChildString(prompt, 'emoji') || ''} ${WABinary_1.getBinaryNodeChildString(prompt, 'text') || ''}`
-                )
-            }
-        }
-
-        return {
-            isDefault: !!WABinary_1.getBinaryNodeChild(profile, 'default'),
-            jid: node.attrs.jid,
-            name: WABinary_1.getBinaryNodeChildString(profile, 'name') || '',
-            attributes: WABinary_1.getBinaryNodeChildString(profile, 'attributes') || '',
-            description: WABinary_1.getBinaryNodeChildString(profile, 'description') || '',
-            category: WABinary_1.getBinaryNodeChildString(profile, 'category') || '',
-            personaId: profile.attrs['persona_id'] || '',
-            commandsDescription: WABinary_1.getBinaryNodeChildString(commandsNode, 'description') || '',
-            commands,
-            prompts
-        }
-    }
-}
-
-module.exports = {
-  USyncBotProfileProtocol
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    getBinaryNodeChild: getBinaryNodeChild,
+    getBinaryNodeChildren: getBinaryNodeChildren,
+    getBinaryNodeChildString: getBinaryNodeChildString,
+} = require("../../WABinary");
+class USyncBotProfileProtocol {
+    constructor() {
+        this.name = "bot";
+    }
+    getQueryElement() {
+        return {
+            tag: "bot",
+            attrs: {},
+            content: [{ tag: "profile", attrs: { v: "1" } }],
+        };
+    }
+    getUserElement(user) {
+        return {
+            tag: "bot",
+            attrs: {},
+            content: [{ tag: "profile", attrs: { persona_id: user.personaId } }],
+        };
+    }
+    parser(node) {
+        const botNode = getBinaryNodeChild(node, "bot");
+        const profile = getBinaryNodeChild(botNode, "profile");
+        const commandsNode = getBinaryNodeChild(profile, "commands");
+        const promptsNode = getBinaryNodeChild(profile, "prompts");
+        const commands = [];
+        const prompts = [];
+        if (commandsNode) {
+            for (const command of getBinaryNodeChildren(commandsNode, "command")) {
+                commands.push({
+                    name: getBinaryNodeChildString(command, "name") || "",
+                    description: getBinaryNodeChildString(command, "description") || "",
+                });
+            }
+        }
+        if (promptsNode) {
+            for (const prompt of getBinaryNodeChildren(promptsNode, "prompt")) {
+                prompts.push(
+                    `${getBinaryNodeChildString(prompt, "emoji") || ""} ${getBinaryNodeChildString(prompt, "text") || ""}`
+                );
+            }
+        }
+        return {
+            isDefault: !!getBinaryNodeChild(profile, "default"),
+            jid: node.attrs.jid,
+            name: getBinaryNodeChildString(profile, "name") || "",
+            attributes: getBinaryNodeChildString(profile, "attributes") || "",
+            description: getBinaryNodeChildString(profile, "description") || "",
+            category: getBinaryNodeChildString(profile, "category") || "",
+            personaId: profile.attrs["persona_id"] || "",
+            commandsDescription: getBinaryNodeChildString(commandsNode, "description") || "",
+            commands: commands,
+            prompts: prompts,
+        };
+    }
+}
+module.exports = { USyncBotProfileProtocol: USyncBotProfileProtocol };

package/lib/WAUSync/Protocols/USyncContactProtocol.js

@@ -1,36 +1,22 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const WABinary_1 = require("../../WABinary")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { assertNodeErrorFree: assertNodeErrorFree } = require("../../WABinary");
 class USyncContactProtocol {
     constructor() {
-        this.name = 'contact'
+        this.name = "contact";
     }
     getQueryElement() {
-        return {
-            tag: 'contact',
-            attrs: {},
-        }
+        return { tag: "contact", attrs: {} };
     }
     getUserElement(user) {
-        //TODO: Implement type / username fields (not yet supported)
-        return {
-            tag: 'contact',
-            attrs: {},
-            content: user.phone,
-        }
+        return { tag: "contact", attrs: {}, content: user.phone };
     }
     parser(node) {
-        if (node.tag === 'contact') {
-            WABinary_1.assertNodeErrorFree(node)
-            return node?.attrs?.type === 'in'
+        if (node.tag === "contact") {
+            assertNodeErrorFree(node);
+            return node?.attrs?.type === "in";
         }
-        return false
+        return false;
     }
 }
-
-module.exports = {
-  USyncContactProtocol
-}
+module.exports = { USyncContactProtocol: USyncContactProtocol };

package/lib/WAUSync/Protocols/USyncDeviceProtocol.js

@@ -1,62 +1,50 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const WABinary_1 = require("../../WABinary")
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    getBinaryNodeChild: getBinaryNodeChild,
+    assertNodeErrorFree: assertNodeErrorFree,
+} = require("../../WABinary");
 class USyncDeviceProtocol {
     constructor() {
-        this.name = 'devices'
+        this.name = "devices";
     }
     getQueryElement() {
-        return {
-            tag: 'devices',
-            attrs: {
-                version: '2',
-            },
-        }
+        return { tag: "devices", attrs: { version: "2" } };
     }
-    getUserElement( /* user: USyncUser */) {
-        //TODO: Implement device phashing, ts and expectedTs
-        //TODO: if all are not present, return null <- current behavior
-        //TODO: otherwise return a node w tag 'devices' w those as attrs
-        return null
+    getUserElement() {
+        return null;
     }
     parser(node) {
-        const deviceList = []
-        let keyIndex = undefined
-        if (node.tag === 'devices') {
-            WABinary_1.assertNodeErrorFree(node)
-            const deviceListNode = WABinary_1.getBinaryNodeChild(node, 'device-list')
-            const keyIndexNode = WABinary_1.getBinaryNodeChild(node, 'key-index-list')
+        const deviceList = [];
+        let keyIndex = undefined;
+        if (node.tag === "devices") {
+            assertNodeErrorFree(node);
+            const deviceListNode = getBinaryNodeChild(node, "device-list");
+            const keyIndexNode = getBinaryNodeChild(node, "key-index-list");
             if (Array.isArray(deviceListNode?.content)) {
-                for (const { tag, attrs } of deviceListNode.content) {
-                    const id = +attrs.id
-                    const keyIndex = +attrs['key-index']
-                    if (tag === 'device') {
+                for (const { tag: tag, attrs: attrs } of deviceListNode.content) {
+                    const id = +attrs.id;
+                    const keyIndex = +attrs["key-index"];
+                    if (tag === "device") {
                         deviceList.push({
-                            id,
-                            keyIndex,
-                            isHosted: !!(attrs['is_hosted'] && attrs['is_hosted'] === 'true')
-                        })
+                            id: id,
+                            keyIndex: keyIndex,
+                            isHosted: !!(attrs["is_hosted"] && attrs["is_hosted"] === "true"),
+                        });
                     }
                 }
             }
-            if (keyIndexNode?.tag === 'key-index-list') {
+            if (keyIndexNode?.tag === "key-index-list") {
                 keyIndex = {
-                    timestamp: +keyIndexNode.attrs['ts'],
+                    timestamp: +keyIndexNode.attrs["ts"],
                     signedKeyIndex: keyIndexNode?.content,
-                    expectedTimestamp: keyIndexNode.attrs['expected_ts'] ? +keyIndexNode.attrs['expected_ts'] : undefined
-                }
+                    expectedTimestamp: keyIndexNode.attrs["expected_ts"]
+                        ? +keyIndexNode.attrs["expected_ts"]
+                        : undefined,
+                };
             }
         }
-        return {
-            deviceList,
-            keyIndex
-        }
+        return { deviceList: deviceList, keyIndex: keyIndex };
     }
 }
-
-module.exports = {
-  USyncDeviceProtocol
-}
+module.exports = { USyncDeviceProtocol: USyncDeviceProtocol };