whatsauto.js/dist/Utils/helper.js

Easy WhatsApp Automation with Session

import { proto } from "@whiskeysockets/baileys";
import { ValidationError } from "../Error/index.js";
import * as fs from "fs";
import path from "path";
import { CREDENTIALS } from "../Defaults/index.js";
import axios from "axios";
export const getMediaMimeType = (msg) => {
    if (!msg?.message)
        return "";
    if (msg.message?.documentWithCaptionMessage)
        msg = { ...msg, message: msg.message.documentWithCaptionMessage.message };
    else if (msg.message?.ephemeralMessage)
        msg = { ...msg, message: msg.message.ephemeralMessage.message };
    const { imageMessage, stickerMessage, videoMessage, documentMessage, audioMessage, documentWithCaptionMessage, } = msg?.message;
    return to.string(imageMessage?.mimetype ??
        stickerMessage?.mimetype ??
        audioMessage?.mimetype ??
        videoMessage?.mimetype ??
        documentMessage?.mimetype ??
        documentWithCaptionMessage?.message?.documentMessage?.mimetype);
};
export const parseMessageStatusCodeToReadable = (code) => {
    switch (code) {
        case proto.WebMessageInfo.Status.PENDING:
            return "pending";
        case proto.WebMessageInfo.Status.SERVER_ACK:
            return "server";
        case proto.WebMessageInfo.Status.DELIVERY_ACK:
            return "delivered";
        case proto.WebMessageInfo.Status.READ:
            return "read";
        case proto.WebMessageInfo.Status.PLAYED:
            return "played";
        default:
            return "error";
    }
};
export const phoneToJid = ({ from, isGroup = false, reverse = false, }) => {
    if (!from)
        throw new ValidationError('"from" parameter is required!');
    const number = from.toString();
    if (number.includes("@broadcast"))
        return number;
    let formatted = number.replace(/:\d+/, "");
    formatted = formatted.replace(/\D/g, "");
    if (isGroup || number.includes("@g.us")) {
        if (!reverse)
            formatted += "@g.us";
    }
    else {
        if (!reverse)
            formatted += "@s.whatsapp.net";
    }
    return formatted;
};
export const createDelay = async (duration = 1000) => {
    return await new Promise((resolve) => setTimeout(() => {
        resolve(true);
    }, duration));
};
export const is = {
    array: (array) => {
        return typeof array === "object" && array != null && array.length > 0;
    },
    undefined: (elem) => {
        return typeof elem === "undefined";
    },
    file: (file) => {
        return file instanceof File;
    },
    object: (object) => {
        return typeof object === "object" && object != null && Object.keys(object).length > 0;
    },
    string: (str) => {
        return typeof str === "string";
    },
};
export const to = {
    string: (str) => {
        if (typeof str === "string")
            return str;
        return "";
    },
    undefined: (str, defaultValue = undefined) => {
        if ((typeof str === "string" || typeof str === "number") && str !== "")
            return str;
        return defaultValue;
    },
};
export const isSessionExist = function (sessionId) {
    if (fs.existsSync(path.resolve(CREDENTIALS.DIR_NAME)) &&
        fs.existsSync(path.resolve(CREDENTIALS.DIR_NAME, sessionId + CREDENTIALS.PREFIX)) &&
        fs.readdirSync(path.resolve(CREDENTIALS.DIR_NAME, sessionId + CREDENTIALS.PREFIX)).length) {
        return true;
    }
    return false;
};
export const setCredentialsDir = (dirname) => {
    if (typeof dirname !== "string") {
        throw new ValidationError("Parameter dirname must be a string!");
    }
    else if (dirname === "") {
        throw new ValidationError("Parameter dirname must not be empty!");
    }
    CREDENTIALS.DIR_NAME = dirname;
};
export const getBuffer = async (url) => {
    try {
        const response = await axios.get(url, {
            responseType: "arraybuffer",
        });
        return Buffer.from(response.data);
    }
    catch (error) { }
    return null;
};
export function getRandomFromArrays(...arrays) {
    return arrays.map((arr) => {
        const randomIndex = Math.floor(Math.random() * arr.length);
        return arr[randomIndex];
    });
}
export function getContextInfo(msg) {
    let m = msg.message;
    if (!m)
        return null;
    // unwrap ephemeral / viewOnce
    if (m.ephemeralMessage)
        m = m.ephemeralMessage.message;
    if (m.viewOnceMessage)
        m = m.viewOnceMessage.message;
    const type = Object.keys(m)[0];
    return m[type]?.contextInfo || null;
}