@japofc/baileys 2.1.0

package/lib/Utils/chat-control.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Chat Control Utilities
+ *
+ * Part of @japofc/baileys chat utilities.
+ * Rewritten as clean TypeScript with full types and JSDoc.
+ *
+ * Three components:
+ *  - TypingIndicator  — composing / recording presence helpers
+ *  - PinnedMessagesManager — client-side pin tracking
+ *  - ReadReceiptController — configurable automatic read receipts
+ */
+/**
+ * Standard disappearing-message duration constants (in seconds).
+ * Pass to `sock.sendMessage(jid, { disappearingMessagesInChat: DISAPPEARING_DURATIONS.DAYS_7 })`.
+ */
+export declare const DISAPPEARING_DURATIONS: {
+    /** Disable disappearing messages */
+    readonly OFF: 0;
+    /** 24 hours */
+    readonly HOURS_24: 86400;
+    /** 7 days */
+    readonly DAYS_7: 604800;
+    /** 90 days */
+    readonly DAYS_90: 7776000;
+};
+export type DisappearingDuration = (typeof DISAPPEARING_DURATIONS)[keyof typeof DISAPPEARING_DURATIONS];
+type PresenceType = 'composing' | 'recording' | 'paused' | 'available' | 'unavailable';
+type SendPresence = (jid: string, presence: PresenceType) => Promise<void>;
+type TypingOptions = {
+    /** Auto-stop after this many ms (default: no auto-stop) */
+    duration?: number;
+    /** Whether to auto-pause on timeout — default `true` */
+    autoPause?: boolean;
+};
+/**
+ * Manages composing ("typing...") and recording ("recording...") presence
+ * indicators with per-JID timer tracking.
+ *
+ * @example
+ * const typing = createTypingIndicator(
+ *     (jid, presence) => sock.sendPresenceUpdate(presence, jid)
+ * )
+ *
+ * // Simulate typing then send a message
+ * const result = await typing.simulateTyping(jid, 1500, () =>
+ *     sock.sendMessage(jid, { text: 'Hello!' })
+ * )
+ */
+export declare class TypingIndicator {
+    private readonly sendPresence;
+    private readonly timers;
+    constructor(sendPresence: SendPresence);
+    /** Show the "typing..." (composing) indicator for a JID. */
+    startTyping(jid: string, options?: TypingOptions): Promise<void>;
+    /** Show the "recording..." (audio/video) indicator for a JID. */
+    startRecording(jid: string, options?: TypingOptions): Promise<void>;
+    /** Stop any active composing/recording indicator for a JID. */
+    stopTyping(jid: string): Promise<void>;
+    /** Stop all active indicators. */
+    stopAll(): Promise<void>;
+    /**
+     * Show typing for `durationMs`, run `callback`, then stop the indicator.
+     *
+     * @template T
+     * @returns The return value of `callback`
+     *
+     * @example
+     * await typing.simulateTyping(jid, 2000, async () => {
+     *     await sock.sendMessage(jid, { text: 'Here is your answer' })
+     * })
+     */
+    simulateTyping<T>(jid: string, durationMs: number, callback: () => Promise<T> | T): Promise<T>;
+    private clearTimer;
+}
+/** Factory — create a TypingIndicator. */
+export declare const createTypingIndicator: (sendPresence: SendPresence) => TypingIndicator;
+export type PinnedMessage = {
+    messageId: string;
+    jid: string;
+    pinnedAt: Date;
+    pinnedBy?: string;
+    expiresAt?: Date;
+};
+/**
+ * Client-side tracker for pinned messages.
+ * Listen to `messages.update` for `pinInChatMessage` protocol messages and call
+ * `manager.pin(jid, msgId, pinnedBy)` / `manager.unpin(jid, msgId)` accordingly.
+ */
+export declare class PinnedMessagesManager {
+    private readonly store;
+    /**
+     * Record a newly pinned message.
+     * @returns The created pin entry
+     */
+    pin(jid: string, messageId: string, pinnedBy?: string, expiresAt?: Date): PinnedMessage;
+    /**
+     * Remove a pinned message.
+     * @returns `true` if the pin was found and removed, `false` otherwise
+     */
+    unpin(jid: string, messageId: string): boolean;
+    /** Get all pinned messages for a chat. */
+    getPinned(jid: string): PinnedMessage[];
+    /** Check if a message is pinned in a chat. */
+    isPinned(jid: string, messageId: string): boolean;
+    /** Remove all pins for a chat. */
+    clearPins(jid: string): void;
+    /**
+     * Evict pins whose `expiresAt` is in the past.
+     * @returns Number of expired pins removed
+     */
+    clearExpired(): number;
+    /** Total pin count across all chats. */
+    get totalPins(): number;
+}
+/** Factory — create a PinnedMessagesManager. */
+export declare const createPinnedMessagesManager: () => PinnedMessagesManager;
+export type ReadReceiptConfig = {
+    /** Whether to send read receipts at all (default: `true`) */
+    enabled?: boolean;
+    /** JIDs to never send receipts for */
+    excludeJids?: string[];
+    /** Delay before marking as read in ms (default: `0`) */
+    readDelay?: number;
+};
+export type ReadReceiptController = {
+    setConfig(config: Partial<ReadReceiptConfig>): void;
+    getConfig(): Required<ReadReceiptConfig>;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    /**
+     * Mark messages as read, respecting the current config.
+     * No-op if disabled or JID is excluded.
+     */
+    markRead(jid: string, participant: string | null | undefined, messageIds: string[]): Promise<void>;
+    /** Mark messages as read regardless of config. */
+    forceMarkRead(jid: string, participant: string | null | undefined, messageIds: string[]): Promise<void>;
+};
+type SendReadReceipt = (jid: string, participant: string | null | undefined, messageIds: string[]) => Promise<void>;
+/**
+ * Create a read-receipt controller with optional auto-delay and per-JID exclusions.
+ *
+ * @example
+ * const readCtrl = createReadReceiptController(
+ *     (jid, participant, ids) => sock.readMessages(ids.map(id => ({ remoteJid: jid, id, participant }))),
+ *     { enabled: true, readDelay: 500, excludeJids: [spamJid] }
+ * )
+ *
+ * sock.ev.on('messages.upsert', ({ messages }) => {
+ *     for (const msg of messages) {
+ *         const { key } = msg
+ *         if (!key.fromMe)
+ *             readCtrl.markRead(key.remoteJid!, key.participant, [key.id!])
+ *     }
+ * })
+ */
+export declare const createReadReceiptController: (sendReadReceipt: SendReadReceipt, config?: ReadReceiptConfig) => ReadReceiptController;
+export {};
+//# sourceMappingURL=chat-control.d.ts.map

package/lib/Utils/chat-control.js

@@ -0,0 +1,230 @@
+/**
+ * Chat Control Utilities
+ *
+ * Part of @japofc/baileys chat utilities.
+ *
+ * Three components:
+ *  - TypingIndicator  — composing / recording presence helpers
+ *  - PinnedMessagesManager — client-side pin tracking
+ *  - ReadReceiptController — configurable automatic read receipts
+ */
+// ─── Constants ─────────────────────────────────────────────────────────────────
+/**
+ * Standard disappearing-message duration constants (in seconds).
+ * Pass to `sock.sendMessage(jid, { disappearingMessagesInChat: DISAPPEARING_DURATIONS.DAYS_7 })`.
+ */
+export const DISAPPEARING_DURATIONS = {
+    /** Disable disappearing messages */
+    OFF: 0,
+    /** 24 hours */
+    HOURS_24: 86400,
+    /** 7 days */
+    DAYS_7: 604800,
+    /** 90 days */
+    DAYS_90: 7776000
+};
+/**
+ * Manages composing ("typing...") and recording ("recording...") presence
+ * indicators with per-JID timer tracking.
+ *
+ * @example
+ * const typing = createTypingIndicator(
+ *     (jid, presence) => sock.sendPresenceUpdate(presence, jid)
+ * )
+ *
+ * // Simulate typing then send a message
+ * const result = await typing.simulateTyping(jid, 1500, () =>
+ *     sock.sendMessage(jid, { text: 'Hello!' })
+ * )
+ */
+export class TypingIndicator {
+    constructor(sendPresence) {
+        this.sendPresence = sendPresence;
+        this.timers = new Map();
+    }
+    /** Show the "typing..." (composing) indicator for a JID. */
+    async startTyping(jid, options = {}) {
+        this.clearTimer(jid);
+        await this.sendPresence(jid, 'composing');
+        if (options.autoPause !== false && options.duration) {
+            const t = setTimeout(() => void this.stopTyping(jid), options.duration);
+            this.timers.set(jid, t);
+        }
+    }
+    /** Show the "recording..." (audio/video) indicator for a JID. */
+    async startRecording(jid, options = {}) {
+        this.clearTimer(jid);
+        await this.sendPresence(jid, 'recording');
+        if (options.autoPause !== false && options.duration) {
+            const t = setTimeout(() => void this.stopTyping(jid), options.duration);
+            this.timers.set(jid, t);
+        }
+    }
+    /** Stop any active composing/recording indicator for a JID. */
+    async stopTyping(jid) {
+        this.clearTimer(jid);
+        try {
+            await this.sendPresence(jid, 'paused');
+        }
+        catch {
+            // Ignore errors when stopping presence (connection may be closed)
+        }
+    }
+    /** Stop all active indicators. */
+    async stopAll() {
+        const jids = Array.from(this.timers.keys());
+        await Promise.all(jids.map(jid => this.stopTyping(jid)));
+    }
+    /**
+     * Show typing for `durationMs`, run `callback`, then stop the indicator.
+     *
+     * @template T
+     * @returns The return value of `callback`
+     *
+     * @example
+     * await typing.simulateTyping(jid, 2000, async () => {
+     *     await sock.sendMessage(jid, { text: 'Here is your answer' })
+     * })
+     */
+    async simulateTyping(jid, durationMs, callback) {
+        await this.startTyping(jid);
+        await new Promise(resolve => setTimeout(resolve, durationMs));
+        await this.stopTyping(jid);
+        return callback();
+    }
+    clearTimer(jid) {
+        const existing = this.timers.get(jid);
+        if (existing) {
+            clearTimeout(existing);
+            this.timers.delete(jid);
+        }
+    }
+}
+/** Factory — create a TypingIndicator. */
+export const createTypingIndicator = (sendPresence) => new TypingIndicator(sendPresence);
+/**
+ * Client-side tracker for pinned messages.
+ * Listen to `messages.update` for `pinInChatMessage` protocol messages and call
+ * `manager.pin(jid, msgId, pinnedBy)` / `manager.unpin(jid, msgId)` accordingly.
+ */
+export class PinnedMessagesManager {
+    constructor() {
+        this.store = new Map();
+    }
+    /**
+     * Record a newly pinned message.
+     * @returns The created pin entry
+     */
+    pin(jid, messageId, pinnedBy, expiresAt) {
+        const entry = { messageId, jid, pinnedAt: new Date(), pinnedBy, expiresAt };
+        const existing = this.store.get(jid) ?? [];
+        // Remove any previous pin with the same message ID before re-adding
+        const filtered = existing.filter(p => p.messageId !== messageId);
+        filtered.push(entry);
+        this.store.set(jid, filtered);
+        return entry;
+    }
+    /**
+     * Remove a pinned message.
+     * @returns `true` if the pin was found and removed, `false` otherwise
+     */
+    unpin(jid, messageId) {
+        const existing = this.store.get(jid);
+        if (!existing)
+            return false;
+        const filtered = existing.filter(p => p.messageId !== messageId);
+        if (filtered.length === existing.length)
+            return false;
+        this.store.set(jid, filtered);
+        return true;
+    }
+    /** Get all pinned messages for a chat. */
+    getPinned(jid) {
+        return this.store.get(jid) ?? [];
+    }
+    /** Check if a message is pinned in a chat. */
+    isPinned(jid, messageId) {
+        return (this.store.get(jid) ?? []).some(p => p.messageId === messageId);
+    }
+    /** Remove all pins for a chat. */
+    clearPins(jid) {
+        this.store.delete(jid);
+    }
+    /**
+     * Evict pins whose `expiresAt` is in the past.
+     * @returns Number of expired pins removed
+     */
+    clearExpired() {
+        let cleared = 0;
+        const now = Date.now();
+        for (const [jid, pins] of this.store) {
+            const valid = pins.filter(p => !p.expiresAt || p.expiresAt.getTime() > now);
+            cleared += pins.length - valid.length;
+            this.store.set(jid, valid);
+        }
+        return cleared;
+    }
+    /** Total pin count across all chats. */
+    get totalPins() {
+        let total = 0;
+        for (const pins of this.store.values())
+            total += pins.length;
+        return total;
+    }
+}
+/** Factory — create a PinnedMessagesManager. */
+export const createPinnedMessagesManager = () => new PinnedMessagesManager();
+/**
+ * Create a read-receipt controller with optional auto-delay and per-JID exclusions.
+ *
+ * @example
+ * const readCtrl = createReadReceiptController(
+ *     (jid, participant, ids) => sock.readMessages(ids.map(id => ({ remoteJid: jid, id, participant }))),
+ *     { enabled: true, readDelay: 500, excludeJids: [spamJid] }
+ * )
+ *
+ * sock.ev.on('messages.upsert', ({ messages }) => {
+ *     for (const msg of messages) {
+ *         const { key } = msg
+ *         if (!key.fromMe)
+ *             readCtrl.markRead(key.remoteJid!, key.participant, [key.id!])
+ *     }
+ * })
+ */
+export const createReadReceiptController = (sendReadReceipt, config = {}) => {
+    let currentConfig = {
+        enabled: config.enabled ?? true,
+        excludeJids: config.excludeJids ?? [],
+        readDelay: config.readDelay ?? 0
+    };
+    return {
+        setConfig(newConfig) {
+            currentConfig = { ...currentConfig, ...newConfig };
+        },
+        getConfig() {
+            return { ...currentConfig };
+        },
+        enable() {
+            currentConfig.enabled = true;
+        },
+        disable() {
+            currentConfig.enabled = false;
+        },
+        isEnabled() {
+            return currentConfig.enabled;
+        },
+        async markRead(jid, participant, messageIds) {
+            if (!currentConfig.enabled)
+                return;
+            if (currentConfig.excludeJids.includes(jid))
+                return;
+            if (currentConfig.readDelay > 0) {
+                await new Promise(r => setTimeout(r, currentConfig.readDelay));
+            }
+            await sendReadReceipt(jid, participant, messageIds);
+        },
+        async forceMarkRead(jid, participant, messageIds) {
+            await sendReadReceipt(jid, participant, messageIds);
+        }
+    };
+};

package/lib/Utils/chat-history-helpers.d.ts

@@ -0,0 +1,21 @@
+import type { WAMessage } from '../Types/index.js';
+import type { AnyMediaMessageContent, WAMediaUploadFunction } from '../Types/Message.js';
+import type { ILogger } from './logger.js';
+import type { MediaType } from '../Defaults/index.js';
+/** The object returned by `makeInMemoryStore()` (see lib/Store/make-in-memory-store.js). */
+export interface InMemoryStoreLike {
+    messages?: Record<string, {
+        array: WAMessage[];
+    } | undefined>;
+}
+export declare const getLastMessageInChat: (store: InMemoryStoreLike, jid: string) => WAMessage | undefined;
+export declare const getOldestMessageInChat: (store: InMemoryStoreLike, jid: string) => WAMessage | undefined;
+export declare const copyNForward: (sock: {
+    sendMessage: (jid: string, content: unknown) => Promise<WAMessage | undefined>;
+}, jid: string, message: WAMessage, forceForward?: boolean) => Promise<WAMessage | undefined>;
+export declare const uploadMediaToWhatsApp: (sock: {
+    waUploadToServer: WAMediaUploadFunction;
+}, message: AnyMediaMessageContent, opts?: {
+    logger?: ILogger;
+    mediaTypeOverride?: MediaType;
+}) => Promise<any>;

package/lib/Utils/chat-history-helpers.js

@@ -0,0 +1,70 @@
+/**
+ * JAP@Add --- part of the @japofc/baileys utils (chat-history-helpers.ts.)
+ *
+ * NOTE: this was written against this package's own
+ * `in-memory-store.ts` addon (a plain `Map<jid, WAMessage[]>`), which this fork
+ * does not have. `@japofc/baileys` already ships a full `makeInMemoryStore`
+ * (see lib/Store/make-in-memory-store.js), whose `store.messages[jid]` is a
+ * KeyedDB-backed ordered dictionary exposing `.array` — NOT a plain array or
+ * Map. getLastMessageInChat / getOldestMessageInChat below are rewritten
+ * against that shape so they work with this fork's real store out of the box.
+ * copyNForward and uploadMediaToWhatsApp are store-independent and ported as-is.
+ */
+import { generateForwardMessageContent, prepareWAMessageMedia } from './messages.js';
+/**
+ * Get the most recently stored message in a chat.
+ * `store` is the object returned by `makeInMemoryStore()`, kept in sync via
+ * `store.bind(sock.ev)`.
+ */
+export const getLastMessageInChat = (store, jid) => {
+    const list = store.messages?.[jid];
+    const arr = list?.array;
+    if (!arr || arr.length === 0)
+        return undefined;
+    return arr[arr.length - 1];
+};
+/**
+ * Get the oldest stored message in a chat (useful as the `oldestMsgKey`
+ * cursor for `sock.fetchMessageHistory(...)`, which pages backwards from it).
+ */
+export const getOldestMessageInChat = (store, jid) => {
+    const list = store.messages?.[jid];
+    const arr = list?.array;
+    if (!arr || arr.length === 0)
+        return undefined;
+    return arr[0];
+};
+/**
+ * Re-send ("copy-forward") an existing message to a (possibly different) jid.
+ * Thin wrapper around generateForwardMessageContent + sock.sendMessage —
+ * strips the original sender's quoting/context the same way WhatsApp's own
+ * "Forward" action does, and marks the copy as forwarded.
+ *
+ * Usage: await copyNForward(sock, targetJid, originalMessage)
+ */
+export const copyNForward = async (sock, jid, message, forceForward = false) => {
+    const content = generateForwardMessageContent(message, forceForward);
+    return sock.sendMessage(jid, content);
+};
+/**
+ * Upload media directly to WhatsApp's own encrypted media CDN and get back
+ * a ready-to-send message-content object (with mediaKey, url/directPath,
+ * fileEncSha256, etc).
+ *
+ * IMPORTANT: WhatsApp clients only accept media that lives on WhatsApp's own
+ * CDN, encrypted with a mediaKey the recipient can derive — there is no way
+ * to point a WAMessage at an arbitrary third-party URL and have it render.
+ * This wrapper does the real, official upload (same path prepareWAMessageMedia
+ * / sock.waUploadToServer use internally) — it does not accept or return an
+ * arbitrary external URL.
+ *
+ * Usage: const media = await uploadMediaToWhatsApp(sock, { image: buffer })
+ *        await sock.sendMessage(jid, media)
+ */
+export const uploadMediaToWhatsApp = async (sock, message, opts) => {
+    return prepareWAMessageMedia(message, {
+        upload: sock.waUploadToServer,
+        logger: opts?.logger,
+        mediaTypeOverride: opts?.mediaTypeOverride
+    });
+};