@hansaka02/baileys 7.3.2 → 7.3.6

package/lib/Socket/usync.js

@@ -1,83 +0,0 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const boom_1 = require("@hapi/boom")
-const WABinary_1 = require("../WABinary")
-const socket_1 = require("./socket")
-
-const makeUSyncSocket = (config) => {
-    const suki = socket_1.makeSocket(config)
-    const { generateMessageTag, query, } = suki
-    
-    const executeUSyncQuery = async (usyncQuery) => {
-        if (usyncQuery.protocols.length === 0) {
-            throw new boom_1.Boom('USyncQuery must have at least one protocol')
-        }
-        
-        // todo: validate users, throw WARNING on no valid users
-        // variable below has only validated users
-        const validUsers = usyncQuery.users
-        
-        const userNodes = validUsers.map((user) => {
-            return {
-                tag: 'user',
-                attrs: {
-                    jid: !user.phone ? user.id : undefined,
-                },
-                content: usyncQuery.protocols
-                    .map((a) => a.getUserElement(user))
-                    .filter(a => a !== null)
-            }
-        })
-        
-        const listNode = {
-            tag: 'list',
-            attrs: {},
-            content: userNodes
-        }
-        
-        const queryNode = {
-            tag: 'query',
-            attrs: {},
-            content: usyncQuery.protocols.map((a) => a.getQueryElement())
-        }
-        
-        const iq = {
-            tag: 'iq',
-            attrs: {
-                to: WABinary_1.S_WHATSAPP_NET,
-                type: 'get',
-                xmlns: 'usync',
-            },
-            content: [
-                {
-                    tag: 'usync',
-                    attrs: {
-                        context: usyncQuery.context,
-                        mode: usyncQuery.mode,
-                        sid: generateMessageTag(),
-                        last: 'true',
-                        index: '0',
-                    },
-                    content: [
-                        queryNode,
-                        listNode
-                    ]
-                }
-            ],
-        }
-        
-        const result = await query(iq)
-        
-        return usyncQuery.parseUSyncQueryResult(result)
-    }
-    return {
-        ...suki,
-        executeUSyncQuery
-    }
-}
-
-module.exports = {
-  makeUSyncSocket
-}

package/lib/Store/index.d.ts

@@ -1,4 +0,0 @@
-export * from './make-cache-manager-store'
-export * from './make-in-memory-store'
-export * from './make-ordered-dictionary'
-export * from './object-repository'

package/lib/Store/make-cache-manager-store.d.ts

@@ -1,14 +0,0 @@
-import { Store } from 'cache-manager'
-import { AuthenticationCreds } from '../Types'
-
-export declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
-    clearState: () => Promise<void>
-    saveCreds: () => Promise<void>
-    state: {
-        creds: AuthenticationCreds
-        keys: {
-            get: (type: string, ids: string[]) => Promise<{}>
-            set: (data: any) => Promise<void>
-        }
-    }
-}>

package/lib/Store/make-in-memory-store.d.ts

@@ -1,123 +0,0 @@
-import type KeyedDB from '@adiwajshing/keyed-db'
-import type { Comparable } from '@adiwajshing/keyed-db/lib/Types'
-import type { Logger } from 'pino'
-import { proto } from '../../WAProto'
-import type makeMDSocket from '../Socket'
-import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata, PresenceData, WAMessage, WAMessageCursor, WAMessageKey } from '../Types'
-import { Label } from '../Types/Label'
-import { LabelAssociation } from '../Types/LabelAssociation'
-import { ObjectRepository } from './object-repository'
-
-type WASocket = ReturnType<typeof makeMDSocket>
-
-export declare const waChatKey: (pin: boolean) => {
-    key: (c: Chat) => string
-    compare: (k1: string, k2: string) => number
-}
-
-export declare const waMessageID: (m: WAMessage) => string
-
-export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>
-
-export type BaileysInMemoryStoreConfig = {
-    chatKey?: Comparable<Chat, string>
-    labelAssociationKey?: Comparable<LabelAssociation, string>
-    logger?: Logger
-    socket?: WASocket
-}
-
-export declare const makeInMemoryStore: (config: BaileysInMemoryStoreConfig) => {
-    chats: KeyedDB<Chat, string>
-    contacts: {
-        [_: string]: Contact
-    }
-    messages: {
-        [_: string]: {
-            array: proto.IWebMessageInfo[]
-            get: (id: string) => proto.IWebMessageInfo | undefined
-            upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
-            update: (item: proto.IWebMessageInfo) => boolean
-            remove: (item: proto.IWebMessageInfo) => boolean
-            updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
-            clear: () => void
-            filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
-            toJSON: () => proto.IWebMessageInfo[]
-            fromJSON: (newItems: proto.IWebMessageInfo[]) => void
-        }
-    }
-    groupMetadata: {
-        [_: string]: GroupMetadata
-    }
-    state: ConnectionState
-    presences: {
-        [id: string]: {
-            [participant: string]: PresenceData
-        }
-    }
-    labels: ObjectRepository<Label>
-    labelAssociations: KeyedDB<LabelAssociation, string>
-    bind: (ev: BaileysEventEmitter) => void
-    /** loads messages from the store, if not found -- uses the legacy connection */
-    loadMessages: (jid: string, count: number, cursor: WAMessageCursor) => Promise<proto.IWebMessageInfo[]>
-    /**
-     * Get all available labels for profile
-     *
-     * Keep in mind that the list is formed from predefined tags and tags
-     * that were "caught" during their editing.
-     */
-    getLabels: () => ObjectRepository<Label>
-    /**
-     * Get labels for chat
-     *
-     * @returns Label IDs
-     **/
-    getChatLabels: (chatId: string) => LabelAssociation[]
-    /**
-     * Get labels for message
-     *
-     * @returns Label IDs
-     **/
-    getMessageLabels: (messageId: string) => string[]
-    loadMessage: (jid: string, id: string) => Promise<proto.IWebMessageInfo | undefined>
-    mostRecentMessage: (jid: string) => Promise<proto.IWebMessageInfo>
-    fetchImageUrl: (jid: string, suki: WASocket | undefined) => Promise<string | null | undefined>
-    fetchGroupMetadata: (jid: string, suki: WASocket | undefined) => Promise<GroupMetadata>
-    fetchMessageReceipts: ({ remoteJid, id }: WAMessageKey) => Promise<proto.IUserReceipt[] | null | undefined>
-    toJSON: () => {
-        chats: KeyedDB<Chat, string>
-        contacts: {
-            [_: string]: Contact
-        }
-        messages: {
-            [_: string]: {
-                array: proto.IWebMessageInfo[]
-                get: (id: string) => proto.IWebMessageInfo | undefined
-                upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
-                update: (item: proto.IWebMessageInfo) => boolean
-                remove: (item: proto.IWebMessageInfo) => boolean
-                updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
-                clear: () => void
-                filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
-                toJSON: () => proto.IWebMessageInfo[]
-                fromJSON: (newItems: proto.IWebMessageInfo[]) => void
-            }
-        }
-        labels: ObjectRepository<Label>
-        labelAssociations: KeyedDB<LabelAssociation, string>
-    }
-    fromJSON: (json: {
-        chats: Chat[]
-        contacts: {
-            [id: string]: Contact
-        }
-        messages: {
-            [id: string]: proto.IWebMessageInfo[]
-        }
-        labels: {
-            [labelId: string]: Label
-        }
-        labelAssociations: LabelAssociation[]
-    }) => void
-    writeToFile: (path: string) => void
-    readFromFile: (path: string) => void
-}

package/lib/Store/make-ordered-dictionary.d.ts

@@ -1,12 +0,0 @@
-export declare function makeOrderedDictionary<T>(idGetter: (item: T) => string): {
-    array: T[]
-    get: (id: string) => T | undefined
-    upsert: (item: T, mode: 'append' | 'prepend') => void
-    update: (item: T) => boolean
-    remove: (item: T) => boolean
-    updateAssign: (id: string, update: Partial<T>) => boolean
-    clear: () => void
-    filter: (contain: (item: T) => boolean) => void
-    toJSON: () => T[]
-    fromJSON: (newItems: T[]) => void
-}

package/lib/Store/object-repository.d.ts

@@ -1,10 +0,0 @@
-export declare class ObjectRepository<T extends object> {
-    readonly entityMap: Map<string, T>
-    constructor(entities?: Record<string, T>)
-    findById(id: string): T | undefined
-    findAll(): T[]
-    upsertById(id: string, entity: T): Map<string, T>
-    deleteById(id: string): boolean
-    count(): number
-    toJSON(): T[]
-}

package/lib/Types/Auth.d.ts

@@ -1,121 +0,0 @@
-import type { proto } from '../../WAProto'
-import type { Contact } from './Contact'
-import type { MinimalMessage } from './Message'
-
-export type KeyPair = {
-    public: Uint8Array
-    private: Uint8Array
-}
-
-export type SignedKeyPair = {
-    keyPair: KeyPair
-    signature: Uint8Array
-    keyId: number
-    timestampS?: number
-}
-
-export type ProtocolAddress = {
-    name: string
-    deviceId: number
-}
-
-export type SignalIdentity = {
-    identifier: ProtocolAddress
-    identifierKey: Uint8Array
-}
-
-export type LTHashState = {
-    version: number
-    hash: Buffer
-    indexValueMap: {
-        [indexMacBase64: string]: {
-            valueMac: Uint8Array | Buffer
-        }
-    }
-}
-
-export type SignalCreds = {
-    readonly signedIdentityKey: KeyPair
-    readonly signedPreKey: SignedKeyPair
-    readonly registrationId: number
-}
-
-export type AccountSettings = {
-    /** unarchive chats when a new message is received */
-    unarchiveChats: boolean
-    /** the default mode to start new conversations with */
-    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>
-}
-
-export type AuthenticationCreds = SignalCreds & {
-    readonly noiseKey: KeyPair
-    readonly pairingEphemeralKeyPair: KeyPair
-    advSecretKey: string
-    me?: Contact
-    account?: proto.IADVSignedDeviceIdentity
-    signalIdentities?: SignalIdentity[]
-    myAppStateKeyId?: string
-    firstUnuploadedPreKeyId: number
-    nextPreKeyId: number
-    lastAccountSyncTimestamp?: number
-    platform?: string
-    processedHistoryMessages: MinimalMessage[]
-    /** number of times history & app state has been synced */
-    accountSyncCounter: number
-    accountSettings: AccountSettings
-    registered: boolean
-    pairingCode: string | undefined
-    lastPropHash: string | undefined
-    routingInfo: Buffer | undefined
-}
-
-export type SignalDataTypeMap = {
-    'pre-key': KeyPair
-    'session': Uint8Array
-    'sender-key': Uint8Array
-    'sender-key-memory': {
-        [jid: string]: boolean
-    }
-    'app-state-sync-key': proto.Message.IAppStateSyncKeyData
-    'app-state-sync-version': LTHashState
-    'lid-mapping': string
-}
-
-export type SignalDataSet = {
-    [T in keyof SignalDataTypeMap]?: {
-        [id: string]: SignalDataTypeMap[T] | null
-    }
-}
-
-type Awaitable<T> = T | Promise<T>
-
-export type SignalKeyStore = {
-    get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
-        [id: string]: SignalDataTypeMap[T]
-    }>
-    set(data: SignalDataSet): Awaitable<void>
-    /** clear all the data in the store */
-    clear?(): Awaitable<void>
-}
-
-export type SignalKeyStoreWithTransaction = SignalKeyStore & {
-    isInTransaction: () => boolean
-    transaction<T>(exec: () => Promise<T>, key: string): Promise<T>
-}
-
-export type TransactionCapabilityOptions = {
-    maxCommitRetries: number
-    delayBetweenTriesMs: number
-}
-
-export type SignalAuthState = {
-    creds: SignalCreds
-    keys: SignalKeyStore | SignalKeyStoreWithTransaction
-}
-
-export type AuthenticationState = {
-    creds: AuthenticationCreds
-    keys: SignalKeyStore
-}
-
-export {}

package/lib/Types/Bussiness.d.ts

@@ -1,28 +0,0 @@
-import type { proto } from '../../WAProto'
-
-export type DayOfWeekBussines = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat'
-
-export type HoursDay = {
-    day: DayOfWeekBussines
-    mode: 'specific_hours'
-    openTimeInMinutes: string
-    closeTimeInMinutes: string
-} | {
-    day: DayOfWeekBussines;
-    mode: 'open_24h' | 'appointment_only'
-}
-
-export type UpdateBussinesProfileProps = {
-    address?: string;
-    websites?: string[]
-    email?: string;
-    description?: string
-    hours?: {
-        timezone: string
-        days: HoursDay[]
-    }
-}
-
-export type QuickReplyAction = proto.SyncActionValue.IQuickReplyAction & {
-    timestamp?: string
-}

package/lib/Types/Call.d.ts

@@ -1,14 +0,0 @@
-export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate'
-
-export type WACallEvent = {
-    chatId: string
-    from: string
-    isGroup?: boolean
-    groupJid?: string
-    id: string
-    date: Date
-    isVideo?: boolean
-    status: WACallUpdateType
-    offline: boolean
-    latencyMs?: number
-}

package/lib/Types/Chat.d.ts

@@ -1,143 +0,0 @@
-import type { proto } from '../../WAProto'
-import type { AccountSettings } from './Auth'
-import type { QuickReplyAction } from './Bussines'
-import type { ContactAction } from './Contact'
-import type { BufferedEventData } from './Events'
-import type { LabelActionBody } from './Label'
-import type { ChatLabelAssociationActionBody } from './LabelAssociation'
-import type { MessageLabelAssociationActionBody } from './LabelAssociation'
-import type { MinimalMessage, WAMessageKey } from './Message'
-
-/** privacy settings in WhatsApp Web */
-export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none'
-
-export type WAPrivacyOnlineValue = 'all' | 'match_last_seen'
-
-export type WAPrivacyGroupAddValue = 'all' | 'contacts' | 'contact_blacklist'
-
-export type WAReadReceiptsValue = 'all' | 'none'
-
-export type WAPrivacyCallValue = 'all' | 'known'
-
-export type WAPrivacyMessagesValue = 'all' | 'contacts'
-
-/** set of statuses visible to other people see updatePresence() in WhatsAppWeb.Send */
-export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused'
-
-export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"]
-
-export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number]
-
-export type BotListInfo = {
-    jid: string
-    personaId: string
-}
-
-export interface PresenceData {
-    lastKnownPresence: WAPresence
-    lastSeen?: number
-}
-
-export type ChatMutation = {
-    syncAction: proto.ISyncActionData
-    index: string[]
-}
-
-export type WAPatchCreate = {
-    syncAction: proto.ISyncActionValue
-    index: string[]
-    type: WAPatchName
-    apiVersion: number
-    operation: proto.SyncdMutation.SyncdOperation
-}
-
-export type Chat = proto.IConversation & {
-    /** unix timestamp of when the last message was received in the chat */
-    lastMessageRecvTimestamp?: number
-}
-
-export type ChatUpdate = Partial<Chat & {
-    /**
-     * if specified in the update,
-     * the EV buffer will check if the condition gets fulfilled before applying the update
-     * Right now, used to determine when to release an app state sync event
-     *
-     * @returns true, if the update should be applied
-     * false if it can be discarded
-     * undefined if the condition is not yet fulfilled
-     * */
-    conditional: (bufferedData: BufferedEventData) => boolean | undefined
-    /** last update time */
-    timestamp?: number
-}>
-
-/**
- * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
- * for MD modifications, the last message in the array (i.e. the earlist message) must be the last message recv in the chat
- * */
-export type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange
-
-export type ChatModification = {
-    archive: boolean
-    lastMessages: LastMessageList
-} | {
-    contact: ContactAction | null
-} | {
-    pushNameSetting: string
-} | {
-    pin: boolean
-} | {
-    /** mute for duration, or provide timestamp of mute to remove*/
-    mute: number | null
-} | {
-    clear: boolean
-} | {
-    deleteForMe: {
-        deleteMedia: boolean
-        key: WAMessageKey
-        timestamp: number
-    }
-} | {
-    star: {
-        messages: {
-            id: string
-            fromMe?: boolean
-        }[]
-        star: boolean
-    }
-} | {
-    markRead: boolean
-    lastMessages: LastMessageList
-} | {
-    delete: true
-    lastMessages: LastMessageList
-} | {
-    contact: proto.SyncActionValue.IContactAction | null
-} | {
-    disableLinkPreviews: proto.SyncActionValue.IPrivacySettingDisableLinkPreviewsAction
-} | {
-    addLabel: LabelActionBody
-} | {
-    addChatLabel: ChatLabelAssociationActionBody
-} | {
-    removeChatLabel: ChatLabelAssociationActionBody
-} | {
-    addMessageLabel: MessageLabelAssociationActionBody
-} | {
-    removeMessageLabel: MessageLabelAssociationActionBody
-} | {
-    quickReply: QuickReplyAction
-}
-
-export type InitialReceivedChatsState = {
-    [jid: string]: {
-        /** the last message received from the other party */
-        lastMsgRecvTimestamp?: number
-        /** the absolute last message in the chat */
-        lastMsgTimestamp: number
-    }
-}
-
-export type InitialAppStateSyncOptions = {
-    accountSettings: AccountSettings
-}

package/lib/Types/Contact.d.ts

@@ -1,23 +0,0 @@
-export interface Contact {
-    /** ID either in lid or jid format (preferred) **/
-    id: string
-    /** ID in LID format (@lid) **/
-    lid?: string
-    /** ID in PN format (@s.whatsapp.net)  **/
-    phoneNumber?: string
-    /** name of the contact, you have saved on your WA */
-    name?: string
-    /** name of the contact, the contact has set on their own on WA */
-    notify?: string
-    /** I have no idea */
-    verifiedName?: string
-    /**
-     * Url of the profile picture of the contact
-     *
-     * 'changed' => if the profile picture has changed
-     * null => if the profile picture has not been set (default profile picture)
-     * any other string => url of the profile picture
-     */
-    imgUrl?: string | null
-    status?: string
-}