@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/Utils/modern-messages.js

@@ -0,0 +1,496 @@
+import { proto } from '../../WAProto/index.js'
+
+const requireObject = (value, name) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError(`${name} must be an object`)
+    }
+    return value
+}
+
+const requireKey = (value, name = 'key') => {
+    requireObject(value, name)
+    if (!value.id) {
+        throw new TypeError(`${name}.id is required`)
+    }
+    return value
+}
+
+const enumValue = (enumObject, value, fallback) => {
+    if (typeof value === 'number') return value
+    if (typeof value === 'string') {
+        const key = value.trim().toUpperCase()
+        if (key in enumObject) return enumObject[key]
+    }
+    return fallback
+}
+
+export const STATUS_NOTIFICATION_TYPES = Object.freeze({
+    ...proto.Message.StatusNotificationMessage.StatusNotificationType,
+    STATUS_GROUP_STATUS_REPLY: 4
+})
+
+const toSeconds = value => value instanceof Date ? Math.floor(value.getTime() / 1000) : value
+const toMilliseconds = value => value instanceof Date ? value.getTime() : value
+
+const makeInnerCommentMessage = content => {
+    const data = requireObject(content, 'comment.content')
+    if (data.raw && typeof data.raw === 'object') return data.raw
+    if (typeof data.text === 'string') {
+        return {
+            extendedTextMessage: proto.Message.ExtendedTextMessage.create({
+                text: data.text,
+                contextInfo: data.contextInfo
+            })
+        }
+    }
+    const keys = Object.keys(data)
+    if (keys.some(key => key.endsWith('Message'))) return data
+    throw new TypeError('comment.content supports text, raw, or protobuf message fields')
+}
+
+export const makeQuestionMessage = input => {
+    const data = requireObject(input, 'question')
+    if (typeof data.text !== 'string' || !data.text.length) {
+        throw new TypeError('question.text is required')
+    }
+    return {
+        questionMessage: proto.Message.FutureProofMessage.create({
+            message: {
+                extendedTextMessage: proto.Message.ExtendedTextMessage.create({
+                    text: data.text,
+                    contextInfo: {
+                        ...(data.contextInfo || {}),
+                        isQuestion: true
+                    }
+                })
+            }
+        })
+    }
+}
+
+export const makeQuestionResponseMessage = input => {
+    const data = requireObject(input, 'questionResponse')
+    requireKey(data.key, 'questionResponse.key')
+    return {
+        questionResponseMessage: proto.Message.QuestionResponseMessage.create({
+            key: data.key,
+            text: data.text ?? ''
+        })
+    }
+}
+
+export const makeQuestionReplyMessage = input => {
+    const data = requireObject(input, 'questionReply')
+    if (typeof data.text !== 'string' || !data.text.length) {
+        throw new TypeError('questionReply.text is required')
+    }
+    if (data.serverQuestionId === undefined || data.serverQuestionId === null) {
+        throw new TypeError('questionReply.serverQuestionId is required')
+    }
+    const quoted = {
+        serverQuestionId: Number(data.serverQuestionId)
+    }
+    if (data.quotedQuestion) quoted.quotedQuestion = data.quotedQuestion
+    if (data.quotedResponse) quoted.quotedResponse = data.quotedResponse
+    return {
+        questionReplyMessage: proto.Message.FutureProofMessage.create({
+            message: {
+                extendedTextMessage: proto.Message.ExtendedTextMessage.create({
+                    text: data.text,
+                    contextInfo: {
+                        ...(data.contextInfo || {}),
+                        questionReplyQuotedMessage: quoted
+                    }
+                })
+            }
+        })
+    }
+}
+
+export const makeStatusQuestionAnswerMessage = input => {
+    const data = requireObject(input, 'statusQuestionAnswer')
+    requireKey(data.key, 'statusQuestionAnswer.key')
+    return {
+        statusQuestionAnswerMessage: proto.Message.StatusQuestionAnswerMessage.create({
+            key: data.key,
+            text: data.text ?? ''
+        })
+    }
+}
+
+export const makeStatusQuotedMessage = input => {
+    const data = requireObject(input, 'statusQuoted')
+    requireKey(data.originalStatusId, 'statusQuoted.originalStatusId')
+    const type = enumValue(
+        proto.Message.StatusQuotedMessage.StatusQuotedMessageType,
+        data.type,
+        proto.Message.StatusQuotedMessage.StatusQuotedMessageType.QUESTION_ANSWER
+    )
+    return {
+        statusQuotedMessage: proto.Message.StatusQuotedMessage.create({
+            type,
+            text: data.text,
+            thumbnail: data.thumbnail,
+            originalStatusId: data.originalStatusId
+        })
+    }
+}
+
+export const makeStatusStickerInteractionMessage = input => {
+    const data = requireObject(input, 'statusStickerInteraction')
+    requireKey(data.key, 'statusStickerInteraction.key')
+    if (!data.stickerKey) {
+        throw new TypeError('statusStickerInteraction.stickerKey is required')
+    }
+    const type = enumValue(
+        proto.Message.StatusStickerInteractionMessage.StatusStickerType,
+        data.type,
+        proto.Message.StatusStickerInteractionMessage.StatusStickerType.REACTION
+    )
+    return {
+        statusStickerInteractionMessage: proto.Message.StatusStickerInteractionMessage.create({
+            key: data.key,
+            stickerKey: data.stickerKey,
+            type
+        })
+    }
+}
+
+export const makeStatusNotificationMessage = input => {
+    const data = requireObject(input, 'statusNotification')
+    requireKey(data.responseMessageKey, 'statusNotification.responseMessageKey')
+    requireKey(data.originalMessageKey, 'statusNotification.originalMessageKey')
+    const type = enumValue(
+        STATUS_NOTIFICATION_TYPES,
+        data.type,
+        STATUS_NOTIFICATION_TYPES.UNKNOWN
+    )
+    return {
+        statusNotificationMessage: proto.Message.StatusNotificationMessage.create({
+            responseMessageKey: data.responseMessageKey,
+            originalMessageKey: data.originalMessageKey,
+            type
+        })
+    }
+}
+
+export const makeNewsletterAdminInviteMessage = input => {
+    const data = requireObject(input, 'newsletterAdminInvite')
+    if (!data.newsletterJid) {
+        throw new TypeError('newsletterAdminInvite.newsletterJid is required')
+    }
+    return {
+        newsletterAdminInviteMessage: proto.Message.NewsletterAdminInviteMessage.create({
+            newsletterJid: data.newsletterJid,
+            newsletterName: data.newsletterName,
+            jpegThumbnail: data.jpegThumbnail,
+            caption: data.caption,
+            inviteExpiration: data.inviteExpiration,
+            contextInfo: data.contextInfo
+        })
+    }
+}
+
+export const makeNewsletterFollowerInviteMessage = input => {
+    const data = requireObject(input, 'newsletterFollowerInvite')
+    if (!data.newsletterJid) {
+        throw new TypeError('newsletterFollowerInvite.newsletterJid is required')
+    }
+    return {
+        newsletterFollowerInviteMessageV2: proto.Message.NewsletterFollowerInviteMessage.create({
+            newsletterJid: data.newsletterJid,
+            newsletterName: data.newsletterName,
+            jpegThumbnail: data.jpegThumbnail,
+            caption: data.caption,
+            contextInfo: data.contextInfo
+        })
+    }
+}
+
+export const makePollAddOptionMessage = input => {
+    const data = requireObject(input, 'pollAddOption')
+    requireKey(data.pollCreationMessageKey, 'pollAddOption.pollCreationMessageKey')
+    const addOption = typeof data.option === 'string'
+        ? { optionName: data.option }
+        : data.addOption || data.option
+    if (!addOption?.optionName) {
+        throw new TypeError('pollAddOption.option is required')
+    }
+    return {
+        pollAddOptionMessage: proto.Message.PollAddOptionMessage.create({
+            pollCreationMessageKey: data.pollCreationMessageKey,
+            addOption,
+            metadata: data.metadata
+        })
+    }
+}
+
+export const makeCommentMessage = input => {
+    const data = requireObject(input, 'comment')
+    requireKey(data.targetMessageKey, 'comment.targetMessageKey')
+    const message = data.message || (data.content ? makeInnerCommentMessage(data.content) : null)
+    requireObject(message, 'comment.message')
+    return {
+        commentMessage: proto.Message.CommentMessage.create({
+            message,
+            targetMessageKey: data.targetMessageKey
+        })
+    }
+}
+
+export const makeEventInviteMessage = input => {
+    const data = requireObject(input, 'eventInvite')
+    if (!data.eventId) {
+        throw new TypeError('eventInvite.eventId is required')
+    }
+    return {
+        eventInviteMessage: proto.Message.EventInviteMessage.create({
+            contextInfo: data.contextInfo,
+            eventId: data.eventId,
+            eventTitle: data.eventTitle,
+            jpegThumbnail: data.jpegThumbnail,
+            startTime: toSeconds(data.startTime),
+            caption: data.caption,
+            isCanceled: data.isCanceled,
+            endTime: toSeconds(data.endTime),
+            callLink: data.callLink
+        })
+    }
+}
+
+export const makeScheduledCallCreationMessage = input => {
+    const data = requireObject(input, 'scheduledCall')
+    if (!data.scheduledTimestampMs) {
+        throw new TypeError('scheduledCall.scheduledTimestampMs is required')
+    }
+    const callType = enumValue(
+        proto.Message.ScheduledCallCreationMessage.CallType,
+        data.callType,
+        proto.Message.ScheduledCallCreationMessage.CallType.UNKNOWN
+    )
+    return {
+        scheduledCallCreationMessage: proto.Message.ScheduledCallCreationMessage.create({
+            scheduledTimestampMs: toMilliseconds(data.scheduledTimestampMs),
+            callType,
+            title: data.title
+        })
+    }
+}
+
+export const makeScheduledCallEditMessage = input => {
+    const data = requireObject(input, 'scheduledCallEdit')
+    requireKey(data.key, 'scheduledCallEdit.key')
+    const editType = enumValue(
+        proto.Message.ScheduledCallEditMessage.EditType,
+        data.editType,
+        proto.Message.ScheduledCallEditMessage.EditType.CANCEL
+    )
+    return {
+        scheduledCallEditMessage: proto.Message.ScheduledCallEditMessage.create({
+            key: data.key,
+            editType
+        })
+    }
+}
+
+export const makeGroupStatusReactionMessage = input => {
+    const data = requireObject(input, 'groupStatusReaction')
+    requireKey(data.key, 'groupStatusReaction.key')
+    return {
+        groupStatusMessageV2: proto.Message.FutureProofMessage.create({
+            message: {
+                reactionMessage: proto.Message.ReactionMessage.create({
+                    key: data.key,
+                    text: data.text ?? '',
+                    groupingKey: data.groupingKey,
+                    senderTimestampMs: data.senderTimestampMs || Date.now()
+                })
+            }
+        })
+    }
+}
+
+export const makeNewsletterStatusAttribution = input => {
+    const data = requireObject(input, 'newsletterStatus')
+    if (!data.newsletterJid) {
+        throw new TypeError('newsletterStatus.newsletterJid is required')
+    }
+    if (data.messageId === undefined || data.messageId === null) {
+        throw new TypeError('newsletterStatus.messageId is required')
+    }
+    return proto.StatusAttribution.create({
+        type: proto.StatusAttribution.Type.NEWSLETTER_STATUS,
+        actionUrl: data.actionUrl,
+        statusReshare: {
+            source: proto.StatusAttribution.StatusReshare.Source.CHANNEL_RESHARE,
+            metadata: {
+                duration: data.duration,
+                channelJid: data.newsletterJid,
+                channelMessageId: Number(data.messageId),
+                hasMultipleReshares: data.hasMultipleReshares ?? false
+            }
+        }
+    })
+}
+
+export const makeGroupStatusAttribution = input => {
+    const data = requireObject(input, 'groupStatusAttribution')
+    if (!data.authorJid) {
+        throw new TypeError('groupStatusAttribution.authorJid is required')
+    }
+    return proto.StatusAttribution.create({
+        type: proto.StatusAttribution.Type.GROUP_STATUS,
+        actionUrl: data.actionUrl,
+        groupStatus: {
+            authorJid: data.authorJid
+        }
+    })
+}
+
+export const STATUS_AUDIENCE_DEFAULT_LIST_NAME = 'Close friends'
+export const STATUS_AUDIENCE_DEFAULT_EMOJI = '⭐'
+
+export const makeStatusAudienceMetadata = input => {
+    const data = typeof input === 'string' ? { listName: input } : requireObject(input, 'statusAudience')
+    const audienceType = enumValue(
+        proto.ContextInfo.StatusAudienceMetadata.AudienceType,
+        data.audienceType,
+        proto.ContextInfo.StatusAudienceMetadata.AudienceType.CLOSE_FRIENDS
+    )
+    const listName = data.listName === undefined ? STATUS_AUDIENCE_DEFAULT_LIST_NAME : String(data.listName)
+    const listEmoji = data.listEmoji === undefined ? STATUS_AUDIENCE_DEFAULT_EMOJI : String(data.listEmoji)
+    return proto.ContextInfo.StatusAudienceMetadata.create({
+        audienceType,
+        listName,
+        listEmoji
+    })
+}
+
+export const makeMessageAssociation = input => {
+    const data = requireObject(input, 'messageAssociation')
+    const parentMessageKey = data.parentMessageKey ?? data.key
+    requireKey(parentMessageKey, 'messageAssociation.parentMessageKey')
+    const associationType = enumValue(
+        proto.MessageAssociation.AssociationType,
+        data.associationType ?? data.type,
+        proto.MessageAssociation.AssociationType.UNKNOWN
+    )
+    return proto.MessageAssociation.create({
+        associationType,
+        parentMessageKey,
+        messageIndex: data.messageIndex
+    })
+}
+
+export const makeStatusAddYoursAssociation = input => {
+    const data = input && typeof input === 'object' && !Array.isArray(input) && input.id
+        ? { key: input }
+        : requireObject(input, 'addYours')
+    const parentMessageKey = data.key ?? data.parentMessageKey
+    requireKey(parentMessageKey, 'addYours.key')
+    const associationType = enumValue(
+        proto.MessageAssociation.AssociationType,
+        data.type ?? data.associationType,
+        proto.MessageAssociation.AssociationType.STATUS_ADD_YOURS
+    )
+    return proto.MessageAssociation.create({
+        associationType,
+        parentMessageKey,
+        messageIndex: data.messageIndex
+    })
+}
+
+export const makeStatusMentionMessage = input => {
+    const data = requireObject(input, 'statusMention')
+    requireKey(data.key, 'statusMention.key')
+    const field = data.group ? 'groupStatusMentionMessage' : 'statusMentionMessage'
+    return {
+        [field]: proto.Message.FutureProofMessage.create({
+            message: {
+                protocolMessage: proto.Message.ProtocolMessage.create({
+                    key: data.key,
+                    type: proto.Message.ProtocolMessage.Type.STATUS_MENTION_MESSAGE
+                })
+            }
+        })
+    }
+}
+
+const modernBuilders = [
+    ['question', makeQuestionMessage],
+    ['questionReply', makeQuestionReplyMessage],
+    ['questionResponse', makeQuestionResponseMessage],
+    ['statusQuestionAnswer', makeStatusQuestionAnswerMessage],
+    ['statusQuoted', makeStatusQuotedMessage],
+    ['statusStickerInteraction', makeStatusStickerInteractionMessage],
+    ['statusNotification', makeStatusNotificationMessage],
+    ['newsletterAdminInvite', makeNewsletterAdminInviteMessage],
+    ['newsletterFollowerInvite', makeNewsletterFollowerInviteMessage],
+    ['pollAddOption', makePollAddOptionMessage],
+    ['comment', makeCommentMessage],
+    ['eventInvite', makeEventInviteMessage],
+    ['scheduledCall', makeScheduledCallCreationMessage],
+    ['scheduledCallEdit', makeScheduledCallEditMessage],
+    ['groupStatusReaction', makeGroupStatusReactionMessage],
+    ['statusMention', makeStatusMentionMessage]
+]
+
+export const prepareModernMessageContent = content => {
+    if (!content || typeof content !== 'object' || Array.isArray(content)) return content
+    let output = { ...content }
+    const attributions = Array.isArray(output.contextInfo?.statusAttributions)
+        ? [...output.contextInfo.statusAttributions]
+        : []
+    if (output.newsletterStatus) {
+        attributions.push(makeNewsletterStatusAttribution(output.newsletterStatus))
+        delete output.newsletterStatus
+    }
+    if (output.groupStatusAttribution) {
+        attributions.push(makeGroupStatusAttribution(output.groupStatusAttribution))
+        delete output.groupStatusAttribution
+    }
+    if (Array.isArray(output.statusAttributions)) {
+        attributions.push(...output.statusAttributions)
+        delete output.statusAttributions
+    }
+    const carried = []
+    const audience = output.statusAudience
+    if (audience !== undefined && audience !== null) {
+        carried.push('statusAudience')
+        output.contextInfo = {
+            ...(output.contextInfo || {}),
+            statusAudienceMetadata: makeStatusAudienceMetadata(audience)
+        }
+        delete output.statusAudience
+    }
+    if (attributions.length) {
+        output.contextInfo = {
+            ...(output.contextInfo || {}),
+            statusAttributions: attributions
+        }
+    }
+    if (output.addYours !== undefined && output.addYours !== null) {
+        carried.push('addYours')
+        output.messageAssociation = makeStatusAddYoursAssociation(output.addYours)
+        delete output.addYours
+    }
+    else if (output.messageAssociation !== undefined && output.messageAssociation !== null) {
+        carried.push('messageAssociation')
+        output.messageAssociation = makeMessageAssociation(output.messageAssociation)
+    }
+    for (const [key, builder] of modernBuilders) {
+        if (output[key] !== undefined && output[key] !== null) {
+            if (carried.length) {
+                throw new TypeError(
+                    `${carried.join(' and ')} cannot be combined with ${key}: ${key} builds its own message and keeps no room for them. `
+                    + 'Build it with the low-level makers and generateWAMessageFromContent instead.'
+                )
+            }
+            return {
+                raw: true,
+                ...builder(output[key])
+            }
+        }
+    }
+    return output
+}

package/src/Utils/native-flow.d.ts

@@ -0,0 +1,11 @@
+export declare const NATIVE_FLOW_NAMES: readonly string[]
+export declare const WEB_SUPPORTED_INTERACTIVE_FLOWS: readonly string[]
+export declare const NATIVE_FLOW_BUTTON_LIMIT: Readonly<{ quickReply: number; other: number }>
+export declare function getNativeFlowNameByButtonName(name: string): string | undefined
+export declare function isWebSupportedButtonName(name: string): boolean
+export declare function checkNativeFlowButtons(buttons: ({ name?: string } | string)[]): {
+    ok: boolean
+    limit: number
+    problems: string[]
+    unsupported: string[]
+}

package/src/Utils/native-flow.js

@@ -0,0 +1,115 @@
+export const NATIVE_FLOW_NAMES = Object.freeze([
+    'booking_confirmation',
+    'order_details',
+    'order_status',
+    'payment_status',
+    'payment_method',
+    'payment_reminder',
+    'message_with_link',
+    'message_with_link_status',
+    'quick_reply',
+    'cta_call',
+    'cta_url',
+    'cta_catalog',
+    'catalog_message',
+    'payment_info',
+    'cta_copy',
+    'mixed',
+    'galaxy_message',
+    'cta_app',
+    'call_permission_request',
+    'payment_request',
+    'api_signup',
+    'inapp_signup',
+    'form_message',
+    'menu_options',
+    'a2ui_reply_action',
+    'address_message',
+    'mpm'
+])
+
+const BUTTON_NAME_TO_FLOW = Object.freeze({
+    review_and_pay: 'order_details',
+    payment_info: 'payment_info',
+    review_order: 'order_status',
+    order_status: 'order_status',
+    payment_status: 'payment_status',
+    payment_method: 'payment_method',
+    open_webview: 'message_with_link',
+    message_with_link_status: 'message_with_link_status',
+    cta_url: 'cta_url',
+    cta_call: 'cta_call',
+    quick_reply: 'quick_reply',
+    catalog_message: 'catalog_message',
+    cta_catalog: 'cta_catalog',
+    cta_copy: 'cta_copy',
+    galaxy_message: 'galaxy_message',
+    payment_reminder: 'payment_reminder',
+    booking_confirmation: 'booking_confirmation',
+    call_permission_request: 'call_permission_request',
+    payment_request: 'payment_request',
+    api_signup: 'api_signup',
+    inapp_signup: 'inapp_signup',
+    cta_app: 'cta_app',
+    form_message: 'form_message',
+    address_message: 'address_message',
+    mpm: 'mpm'
+})
+
+export const WEB_SUPPORTED_INTERACTIVE_FLOWS = Object.freeze([
+    'quick_reply',
+    'cta_call',
+    'cta_url',
+    'cta_catalog',
+    'catalog_message',
+    'cta_copy',
+    'galaxy_message',
+    'order_status',
+    'payment_reminder',
+    'booking_confirmation',
+    'payment_request',
+    'api_signup',
+    'inapp_signup',
+    'cta_app',
+    'form_message'
+])
+
+export const NATIVE_FLOW_BUTTON_LIMIT = Object.freeze({
+    quickReply: 10,
+    other: 3
+})
+
+export const getNativeFlowNameByButtonName = (name) => BUTTON_NAME_TO_FLOW[name]
+
+export const isWebSupportedButtonName = (name) => {
+    const flow = getNativeFlowNameByButtonName(name)
+    return flow !== undefined && WEB_SUPPORTED_INTERACTIVE_FLOWS.includes(flow)
+}
+
+export const checkNativeFlowButtons = (buttons) => {
+    const list = (Array.isArray(buttons) ? buttons : []).map(button => (typeof button === 'string' ? { name: button } : button))
+    const problems = []
+
+    if (!list.length) {
+        return { ok: true, limit: NATIVE_FLOW_BUTTON_LIMIT.other, problems, unsupported: [] }
+    }
+
+    const firstIsQuickReply = list[0]?.name === 'quick_reply'
+    const limit = firstIsQuickReply ? NATIVE_FLOW_BUTTON_LIMIT.quickReply : NATIVE_FLOW_BUTTON_LIMIT.other
+
+    if (list.length > limit) {
+        problems.push(`WhatsApp Web renders at most ${limit} buttons when the first one is ${firstIsQuickReply ? 'quick_reply' : 'not quick_reply'}, got ${list.length}`)
+    }
+
+    const unsupported = [...new Set(list.map(button => button?.name).filter(name => !isWebSupportedButtonName(name)))]
+    for (const name of unsupported) {
+        problems.push(`"${name}" is not a native flow WhatsApp Web or iOS can render, only Android shows it`)
+    }
+
+    const mixesKinds = list.slice(1).some(button => (button?.name === 'quick_reply') !== firstIsQuickReply)
+    if (mixesKinds) {
+        problems.push('quick_reply buttons cannot be mixed with other button types in one message')
+    }
+
+    return { ok: problems.length === 0, limit, problems, unsupported }
+}