@neelegirl/wa-api 1.6.9 → 1.7.0

package/dist/Defaults/index.d.ts

@@ -8,12 +8,11 @@ export declare enum CALLBACK_KEY {
     ON_CONNECTED = "on-connected",
     ON_DISCONNECTED = "on-disconnected",
     ON_CONNECTING = "on-connecting",
-    ON_MESSAGE_UPDATED = "on-message-updated",
-    ON_PAIRING_CODE = "on-pairing-code"
+    ON_MESSAGE_UPDATED = "on-message-updated"
 }
 export declare abstract class Messages {
     static sessionAlreadyExist: (sessionId: string) => string;
     static sessionNotFound: (sessionId: string) => string;
     static paremetersRequired: (props: string[] | string) => string;
 }
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/Messaging/index.d.ts

@@ -1,4 +1,4 @@
-
+
 
 /**
  * Send a message to target
@@ -11,9 +11,14 @@
 export declare function sendMessage(
     sessionId: string,
     jid: string,
-    content: import("@neelegirl/baileys/lib").AnyMessageContent,
-    options?: import("@neelegirl/baileys/lib").MiscMessageGenerationOptions
-  ): Promise<import("@neelegirl/baileys/lib").proto.WebMessageInfo>;
+    content: import("@neelegirl/baileys").AnyMessageContent,
+    options?: import("@neelegirl/baileys").MiscMessageGenerationOptions
+  ): Promise<import("@neelegirl/baileys").proto.WebMessageInfo>;
+export declare function sendStatusMentions(
+  sessionId: string,
+  content: import("@neelegirl/baileys").AnyMessageContent,
+  targets?: string[]
+): Promise<string>;
     /**
  * Sendet einen rohen WAMessage-Stanza an WhatsApp.
  *
@@ -40,5 +45,5 @@ export declare function relayMessage(
   sessionId: string,
   jid: string,
   content: any,
-  options?: import('@neelegirl/baileys/lib').MiscMessageGenerationOptions
+  options?: import('@neelegirl/baileys').MiscMessageGenerationOptions
 ): Promise<string>;

package/dist/Messaging/index.js

@@ -1,61 +1,124 @@
-"use strict";
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.relayMessage = exports.sendStatusMentions = exports.sendMessage = void 0;
-
+exports.relayMessage = exports.sendMessage = void 0;
 const Defaults_1 = require("../Defaults");
 const Socket_1 = require("../Socket");
 const Utils_1 = require("../Utils");
+const create_delay_1 = require("../Utils/create-delay");
+const is_exist_1 = require("../Utils/is-exist");
+const mime_1 = __importDefault(require("mime"));
 const Error_1 = require("../Error");
 
 const sessionCache = new Map();
 
 function getCachedSession(sessionId) {
-    let session = sessionCache.get(sessionId);
-    if (!session) {
-        session = (0, Socket_1.getSession)(sessionId);
-        if (!session) {
-            throw new Error_1.WhatsappError(Defaults_1.Messages.sessionNotFound(sessionId));
-        }
-        sessionCache.set(sessionId, session);
-    }
-    return session;
-}
-
-function resolveJid(jid) {
-    return jid.includes("@") ? jid : (0, Utils_1.phoneToJid)({ to: jid });
+  let session = sessionCache.get(sessionId);
+  if (!session) {
+    session = Socket_1.getSession(sessionId);
+    if (!session) throw new Error_1.WhatsappError(Defaults_1.Messages.sessionNotFound(sessionId));
+    sessionCache.set(sessionId, session);
+  }
+  return session;
 }
 
+/**
+ * Universal sendMessage wrapper for all Baileys message types in JavaScript.
+ *
+ * @param {string} sessionId   Your multi-session identifier
+ * @param {string} jid         Destination JID (user or group) or phone number
+ * @param {object} content     AnyMessageContent payload
+ * @param {object} [options]   MiscMessageGenerationOptions (quoted, mentions, etc.)
+ * @returns {Promise<any>}
+ */
 async function sendMessage(sessionId, jid, content, options) {
-    const session = getCachedSession(sessionId);
-    const destJid = resolveJid(jid);
-    try {
-        return await session.sendMessage(destJid, content, options || {});
-    }
-    catch (err) {
-        throw new Error_1.WhatsappError(`Failed to send message to ${destJid}: ${err.message}`, { cause: err });
-    }
+  const session = getCachedSession(sessionId);
+  const target = String(jid);
+
+  // Convert phone number to JID if needed
+  const destJid = target.includes("@") ? target : Utils_1.phoneToJid({ to: target });
+
+  try {
+    return await session.sendMessage(destJid, content, options || {});
+  } catch (err) {
+    // Wrap Baileys errors into WhatsappError for consistency
+    throw new Error_1.WhatsappError(
+      `Failed to send message to ${destJid}: ${err.message}`,
+      { cause: err }
+    );
+  }
 }
+
 exports.sendMessage = sendMessage;
+/**
+ * Universal sendMessage wrapper for all Baileys message types in JavaScript.
+ *
+ * @param {string} sessionId   Your multi-session identifier
+ * @param {string} jid         Destination JID (user or group) or phone number
+ * @param {object} content     AnyMessageContent payload
+ * @param {object} [options]   MiscMessageGenerationOptions (quoted, mentions, etc.)
+ * @returns {Promise<any>}
+ */
+async function sendStatusMentions(sessionId, content, targets = []) {
+  const session = getCachedSession(sessionId);
 
-async function sendStatusMentions(sessionId, content, options) {
-    const session = getCachedSession(sessionId);
-    try {
-        return await session.sendStatusMentions(content, options || {});
-    }
-    catch (err) {
-        throw new Error_1.WhatsappError(`Failed to send status mention: ${err.message}`, { cause: err });
-    }
+  try {
+    return await session.sendStatusMentions(content, targets || []);
+  } catch (err) {
+    // Wrap Baileys errors into WhatsappError for consistency
+    throw new Error_1.WhatsappError(
+      `Failed to send message: ${err.message}`,
+      { cause: err }
+    );
+  }
 }
-exports.sendStatusMentions = sendStatusMentions;
 
+exports.sendStatusMentions = sendStatusMentions;
+/**
+ * Low-level relayMessage-Wrapper für Baileys.
+ *
+ * @param {string} sessionId - Deine Session-ID
+ * @param {string} jid       - Ziel-JID oder Telefonnummer
+ * @param {object} content   - das rohe Message-Node-Objekt
+ * @param {object} options   - zusätzliche Relay-Optionen wie messageId, participant, additionalNodes, etc.
+ *
+ * @returns {Promise<string>} die gesendete Nachricht-ID
+ */
 async function relayMessage(sessionId, jid, content, options = {}) {
-    const session = getCachedSession(sessionId);
-    const destJid = resolveJid(jid);
-    try {
-        return await session.relayMessage(destJid, content, options);
-    }
-    catch (err) {
-        throw new Error_1.WhatsappError(`Relay to ${destJid} failed: ${err.message}`, { cause: err });
-    }
+  const session = getCachedSession(sessionId);
+  if (!session) {
+    throw new Error_1.WhatsappError(`Session ${sessionId} nicht gefunden`);
+  }
+
+  const target = String(jid);
+  const destJid = target.includes("@") ? target : Utils_1.phoneToJid({ to: target });
+  try {
+    // Baileys-intern sendet hier direkt das XML-Stanza
+    return await session.relayMessage(destJid, content, options);
+  } catch (err) {
+    throw new Error_1.WhatsappError(`Relay an ${destJid} fehlgeschlagen: ${err.message}`, { cause: err });
+  }
 }
-exports.relayMessage = relayMessage;
+exports.relayMessage = relayMessage;

package/dist/Socket/index.d.ts

@@ -1,15 +1,18 @@
-import { WASocket } from "@neelegirl/baileys/lib";
+import { WASocket } from "@neelegirl/baileys";
 import type { MessageReceived, MessageUpdated, StartSessionParams } from "../Types";
 export declare const startSession: (sessionId?: string, options?: StartSessionParams) => Promise<WASocket>;
 /**
  * @deprecated Use startSession method instead
  */
 export declare const startWhatsapp: (sessionId?: string, options?: StartSessionParams) => Promise<WASocket>;
-export declare const startSessionWithPairingCode: (sessionId?: string, options?: {phoneNumber}) => Promise<WASocket>;
+export declare const startSessionWithPairingCode: (sessionId?: string, options?: {
+    phoneNumber: string;
+}, customPairingCode?: string) => Promise<WASocket>;
 export declare const deleteSession: (sessionId: string) => Promise<void>;
 export declare const getAllSession: () => string[];
 export declare const getSession: (key: string) => WASocket | undefined;
-export declare const loadSessionsFromStorage: () => void;
+export declare const getAllSessionData: () => Record<string, WASocket | undefined>;
+export declare const loadSessionsFromStorage: () => Promise<string[]>;
 export declare const onMessageReceived: (listener: (msg: MessageReceived) => any) => void;
 export declare const onQRUpdated: (listener: ({ sessionId, qr }: {
     sessionId: string;
@@ -19,4 +22,6 @@ export declare const onConnected: (listener: (sessionId: string) => any) => void
 export declare const onDisconnected: (listener: (sessionId: string) => any) => void;
 export declare const onConnecting: (listener: (sessionId: string) => any) => void;
 export declare const onMessageUpdate: (listener: (data: MessageUpdated) => any) => void;
-//# sourceMappingURL=index.d.ts.map
+export declare const onPairingCode: (listener: (sessionId: string, code: string) => any) => void;
+export declare const sock: (sessionId: string) => WASocket | undefined;
+//# sourceMappingURL=index.d.ts.map