jagproject 5.7.9 → 5.8.2

package/README.MD

@@ -488,31 +488,30 @@ Jika teks dan media digabung, hanya satu yang akan dikirim tergantung prioritas
 
 ### Kirim teks ke status WhatsApp
 ```javascript
-await conn.upswgc("status@broadcast", {
-    text: "Halo dunia! ini teks status 📢"
-})
+await conn.upswgc(m.chat, { text: "Halo dari upswgc versi final!" })
 ```
 
 ### Kirim gambar ke status WhatsApp
 ```javascript
-await conn.upswgc("status@broadcast", {
-    image: { url: "https://example.com/image.jpg" },
-    caption: "Testing gambar status!"
-})
+await conn.upswgc(m.chat, {
+        image: { url: "https://m.media-amazon.com/images/S/pv-target-images/f75db71efd62ea2eff81bd7cc01c44a9344b4ac18615ab71a80f58459ddf8791.jpg" },
+        caption : "apasi"
+      });
+
 ```
 ### Kirim video ke status WhatsApp
 ```javascript
-await conn.upswgc("status@broadcast", {
-    video: { url: "https://example.com/video.mp4" },
-    caption: "Testing video status!"
-})
+await conn.upswgc(m.chat, {
+        video: { url: "https://m.media-amazon.com/images/S/pv-target-images/f75db71efd62ea2eff81bd7cc01c44a9344b4ac18615ab71a80f58459ddf8791.jpg" },
+        caption : "apasi"
+      });
 ```
 ### Kirim audio (voice note) ke status WhatsApp
 ```javascript
-await conn.upswgc("status@broadcast", {
-    audio: { url: "https://example.com/audio.mp3" },
-    mimetype: "audio/mp4"
-})
+await conn.upswgc(m.chat, {
+        audio: { url: "https://cdn.yupra.my.id/yp/xkv99g06.opus" },
+        caption : "apasi"
+      });
 ```
 
 `[!TIP]

package/lib/Utils/messages-media.js

@@ -365,48 +365,126 @@ async function getAudioDuration(buffer) {
     }
     return metadata.format.duration;
 }
+// Ganti / tempelkan seluruh function getAudioWaveform berikut
 async function getAudioWaveform(buffer, logger) {
     try {
-        const { default: decoder } = await eval('import(\'audio-decode\')');
+        // prefer ffmpeg-based robust extraction (supports opus/ogg/mp3/m4a etc.)
+        const { PassThrough } = require('stream');
+        const ffmpeg = require('fluent-ffmpeg');
+        // try to use ffmpeg-static if available (bundled binary)
+        try {
+            const ffmpegPath = require('ffmpeg-static');
+            if (ffmpegPath) {
+                ffmpeg.setFfmpegPath(ffmpegPath);
+            }
+        } catch (e) {
+            // ffmpeg-static not installed — hope system ffmpeg exists in PATH
+            logger?.debug?.('ffmpeg-static not available, relying on system ffmpeg');
+        }
+
+        // normalize input to Buffer
         let audioData;
         if (Buffer.isBuffer(buffer)) {
             audioData = buffer;
+        } else if (typeof buffer === 'string') {
+            // path given
+            const fs = require('fs');
+            audioData = await (async () => {
+                if (fs.existsSync(buffer)) return fs.readFileSync(buffer);
+                // otherwise try to read as URL/stream via toBuffer helper if available
+                return await exports.toBuffer(buffer);
+            })();
+        } else {
+            audioData = await exports.toBuffer(buffer);
         }
-        else if (typeof buffer === 'string') {
-            const rStream = (0, fs_1.createReadStream)(buffer);
-            audioData = await (0, exports.toBuffer)(rStream);
-        }
-        else {
-            audioData = await (0, exports.toBuffer)(buffer);
-        }
-        const audioBuffer = await decoder(audioData);
-        const rawData = audioBuffer.getChannelData(0);
-        const samples = 64;
-        const blockSize = Math.floor(rawData.length / samples);
-        const filteredData = [];
+
+        // convert to raw PCM 16-bit signed little endian mono using ffmpeg in-memory
+        return await new Promise((resolve, reject) => {
+            try {
+                const chunks = [];
+                const inputStream = new PassThrough();
+                inputStream.end(audioData);
+
+                // pipe ffmpeg -> raw PCM signed 16 bit LE, mono, 16000/44100 sample rate doesn't matter much
+                ffmpeg(inputStream)
+                    .format('s16le')
+                    .audioChannels(1)
+                    .audioFrequency(16000)
+                    .noVideo()
+                    .on('error', (err) => {
+                        logger?.debug?.('ffmpeg waveform error', err?.message || err);
+                        // fallback: try a simpler approach using audio-decode if available
+                        try {
+                            (async () => {
+                                const { default: decoder } = await eval('import("audio-decode")');
+                                const audioBuf = await exports.toBuffer(audioData);
+                                const audioDecoded = await decoder(audioBuf);
+                                const raw = audioDecoded.getChannelData(0);
+                                const result = normalizeToUint8(raw);
+                                resolve(result);
+                            })();
+                        } catch (e) {
+                            reject(err);
+                        }
+                    })
+                    .on('end', () => {
+                        try {
+                            const buffer = Buffer.concat(chunks);
+                            // buffer contains 16-bit signed PCM little endian
+                            // convert to Float32 array (-1..1) first
+                            const samples = new Int16Array(buffer.buffer, buffer.byteOffset, Math.floor(buffer.length / 2));
+                            const floatSamples = new Float32Array(samples.length);
+                            for (let i = 0; i < samples.length; i++) {
+                                floatSamples[i] = samples[i] / 32768; // normalize int16 to [-1,1]
+                            }
+                            const result = normalizeToUint8(floatSamples);
+                            resolve(result);
+                        } catch (e) {
+                            reject(e);
+                        }
+                    })
+                    .pipe()
+                    .on('data', (c) => chunks.push(c));
+            } catch (e) {
+                reject(e);
+            }
+        });
+    } catch (e) {
+        logger?.debug?.(e);
+        return undefined;
+    }
+}
+
+// helper: normalize float array (-1..1) into Uint8Array (0..100 per bar)
+function normalizeToUint8(data, samples = 64) {
+    try {
+        const blockSize = Math.floor(data.length / samples) || 1;
+        const filtered = [];
         for (let i = 0; i < samples; i++) {
-            const blockStart = blockSize * i;
+            let blockStart = i * blockSize;
             let sum = 0;
-            for (let j = 0; j < blockSize; j++) {
-                sum = sum + Math.abs(rawData[blockStart + j]);
+            for (let j = 0; j < blockSize && (blockStart + j) < data.length; j++) {
+                sum += Math.abs(data[blockStart + j]);
             }
-            filteredData.push(sum / blockSize);
+            filtered.push(sum / blockSize);
         }
-        const multiplier = Math.pow(Math.max(...filteredData), -1);
-        const normalizedData = filteredData.map((n) => n * multiplier);
-        const waveform = new Uint8Array(normalizedData.map((n) => Math.floor(100 * n)));
-        return waveform;
-    }
-    catch (e) {
-        logger === null || logger === void 0 ? void 0 : logger.debug('Failed to generate waveform: ' + e);
+        const max = Math.max(...filtered) || 1;
+        const normalized = filtered.map(v => Math.floor((v / max) * 100));
+        return new Uint8Array(normalized);
+    } catch (e) {
+        return undefined;
     }
 }
+
 const toReadable = (buffer) => {
     const readable = new stream_1.Readable({ read: () => { } });
     readable.push(buffer);
     readable.push(null);
     return readable;
 };
+// ================================================================
+// Tambahan utilitas media (opsional, jika Wileyss punya bawaan sendiri biarkan bagian bawah tetap ada)
+// ================================================================
 exports.toReadable = toReadable;
 const toBuffer = async (stream) => {
     const chunks = [];
@@ -876,4 +954,5 @@ const MEDIA_RETRY_STATUS_MAP = {
 };
 function __importStar(arg0) {
     throw new Error('Function not implemented.');
-}
+}
+

package/lib/index.js

@@ -1,20 +1,23 @@
+////
 "use strict";
 
 const chalk = require("chalk");
-const gradient = require("gradient-string");
 
-console.log();
+console.log(chalk.yellow("⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘"));
+console.log(chalk.magentaBright.bold("꧁⎝ 𓆩༺ Baileys Jagoan project ༻𓆪 ⎠꧂\n"));
 console.log(
-  chalk.bold.blue('Wil') + chalk.bold.green('eys')
+  chalk.whiteBright(
+    chalk.bgBlue("Ingin beli Script atau panel premium? ke 6282252509320.")
+  )
 );
-
-console.log();
 console.log(
-  chalk.bold(
-    gradient(['magenta', 'cyan'])('> you can get hosting panel pterodactyl yupra.my.id <')
+  chalk.black(
+    chalk.bgMagenta("Update permanen.. gak usah pusing error..!!! 😱\n")
   )
 );
-console.log();
+console.log(chalk.red("Youtube: ") + chalk.greenBright("@jagoanproject"));
+console.log(chalk.yellow("⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘⫘\n"));
+
 
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jagproject",
-  "version": "5.7.9",
+  "version": "5.8.2",
   "description": "WhatsApp Web API Library",
   "keywords": [
     "jagoan",