@kyyinfinite/baileys 1.0.0 → 2.1.0

package/lib/Kyyinfinite/Simple/CardBuilder.js

@@ -0,0 +1,179 @@
+import { prepareWAMessageMedia } from '../../Utils/messages.js'
+
+export class CardBuilder {
+  constructor(parent, options = {}) {
+    this.parent = parent
+    this.card = {
+      header: {
+        hasMediaAttachment: false
+      },
+      body: { text: '' },
+      footer: { text: '' },
+      nativeFlowMessage: { buttons: [] }
+    }
+
+    if (options && typeof options === 'object') {
+      if (options.image !== undefined) this.image(options.image, options.imageOptions || {})
+      if (options.video !== undefined) this.video(options.video, options.videoOptions || {})
+      this.payload(options)
+    }
+  }
+
+  title(value) {
+    this.card.header.title = String(value ?? '')
+    return this
+  }
+
+  body(value) {
+    this.card.body.text = String(value ?? '')
+    return this
+  }
+
+  text(value) {
+    return this.body(value)
+  }
+
+  footer(value) {
+    this.card.footer.text = String(value ?? '')
+    return this
+  }
+
+  image(media, options = {}) {
+    this.card._media = { type: 'image', media, options }
+    return this
+  }
+
+  video(media, options = {}) {
+    this.card._media = { type: 'video', media, options }
+    return this
+  }
+
+  media(type, media, options = {}) {
+    if (type !== 'image' && type !== 'video') {
+      throw new TypeError('Carousel card media must be image or video')
+    }
+    return this[type](media, options)
+  }
+
+  button(displayText, id, options = {}) {
+    return this._button('quick_reply', {
+      display_text: displayText,
+      id,
+      ...options
+    })
+  }
+
+  reply(displayText, id, options = {}) {
+    return this.button(displayText, id, options)
+  }
+
+  quickReply(displayText, id, options = {}) {
+    return this.button(displayText, id, options)
+  }
+
+  url(displayText, url, options = {}) {
+    return this._button('cta_url', {
+      display_text: displayText,
+      url,
+      ...options
+    })
+  }
+
+  copy(displayText, copyCode, options = {}) {
+    return this._button('cta_copy', {
+      display_text: displayText,
+      copy_code: copyCode,
+      ...options
+    })
+  }
+
+  coppy(displayText, copyCode, options = {}) {
+    return this.copy(displayText, copyCode, options)
+  }
+
+  call(displayText, phone, options = {}) {
+    return this._button('cta_call', {
+      display_text: displayText,
+      id: phone,
+      ...options
+    })
+  }
+
+  buttons(buttons = []) {
+    if (!Array.isArray(buttons)) {
+      throw new TypeError('Buttons must be an array')
+    }
+
+    this.card.nativeFlowMessage.buttons.push(...buttons)
+    return this
+  }
+
+  rawButton(button) {
+    if (!button || typeof button !== 'object' || Array.isArray(button)) {
+      throw new TypeError('Button must be a plain object')
+    }
+
+    this.card.nativeFlowMessage.buttons.push(button)
+    return this
+  }
+
+  context(value) {
+    this.card.contextInfo = value || {}
+    return this
+  }
+
+  payload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return this
+    }
+
+    const { header, body, footer, nativeFlowMessage, image, video, imageOptions, videoOptions, ...extra } = value
+
+    Object.assign(this.card, extra)
+    if (header) Object.assign(this.card.header, header)
+    if (body) Object.assign(this.card.body, body)
+    if (footer) Object.assign(this.card.footer, footer)
+    if (nativeFlowMessage) Object.assign(this.card.nativeFlowMessage, nativeFlowMessage)
+
+    return this
+  }
+
+  _button(name, params) {
+    this.card.nativeFlowMessage.buttons.push({
+      name,
+      buttonParamsJson: JSON.stringify(params)
+    })
+    return this
+  }
+
+  async build() {
+    const { _media, ...card } = this.card
+
+    if (!_media) {
+      throw new Error('Carousel card requires image() or video()')
+    }
+
+    const media = {
+      [_media.type]: _media.media,
+      ..._media.options
+    }
+
+    const prepared = await prepareWAMessageMedia(media, {
+      upload: this.parent.sock.waUploadToServer
+    })
+
+    card.header.hasMediaAttachment = true
+    card.header[`${_media.type}Message`] = prepared[`${_media.type}Message`]
+
+    return card
+  }
+
+  add() {
+    this.parent._cards.push(this)
+    return this.parent
+  }
+
+  end() {
+    return this.add()
+  }
+}

package/lib/Kyyinfinite/Simple/CarouselBuilder.js

@@ -0,0 +1,97 @@
+import { Carousel } from '../Carousel.js'
+import { CardBuilder } from './CardBuilder.js'
+
+const aliases = {
+  title: 'setTitle',
+  subtitle: 'setSubtitle',
+  body: 'setBody',
+  text: 'setBody',
+  footer: 'setFooter',
+  context: 'setContextInfo',
+  payload: 'addPayload'
+}
+
+export class CarouselBuilder {
+  constructor(sock, ...args) {
+    if (!sock) throw new Error('Socket is required')
+
+    this.sock = sock
+    this.raw = new Carousel(sock, ...args)
+    this._cards = []
+    this._rawCards = []
+  }
+
+  card(options = {}) {
+    return new CardBuilder(this, options)
+  }
+
+  addCard(card) {
+    if (card instanceof CardBuilder) {
+      if (!this._cards.includes(card)) this._cards.push(card)
+      return this
+    }
+
+    this._rawCards.push(card)
+    return this
+  }
+
+  cards(cards = []) {
+    if (!Array.isArray(cards)) {
+      throw new TypeError('Cards must be an array')
+    }
+
+    for (const card of cards) this.addCard(card)
+    return this
+  }
+
+  clear() {
+    this._cards = []
+    this._rawCards = []
+    this.raw._cards = []
+    return this
+  }
+
+  async _prepareCards() {
+    this.raw._cards = []
+
+    for (const card of this._rawCards) {
+      this.raw.addCard(card)
+    }
+
+    for (const card of this._cards) {
+      this.raw.addCard(await card.build())
+    }
+
+    return this.raw
+  }
+
+  async build(jid, options = {}) {
+    await this._prepareCards()
+    return this.raw.build(jid, options)
+  }
+
+  async send(jid, options = {}) {
+    await this._prepareCards()
+    return this.raw.send(jid, options)
+  }
+
+  loadFrom(message) {
+    this.raw.loadFrom(message)
+    this._cards = []
+    this._rawCards = [...this.raw._cards]
+    return this
+  }
+}
+
+for (const [name, method] of Object.entries(aliases)) {
+  CarouselBuilder.prototype[name] = function (...args) {
+    const value = this.raw[method](...args)
+    return value === this.raw ? this : value
+  }
+}
+
+export { Carousel, CardBuilder }
+
+export function createCarouselBuilder(sock, ...args) {
+  return new CarouselBuilder(sock, ...args)
+}

package/lib/Kyyinfinite/Simple/FoadBuilder.js

@@ -0,0 +1,18 @@
+import { Foad } from '../Foad.js'
+import { Foad2 } from '../Foad2.js'
+import { proxyBuilder } from './SimpleBuilder.js'
+
+const foadAliases = {
+  title: 'addTitle',
+  html: 'addHtml'
+}
+
+export function createFoadBuilder(sock, ...args) {
+  return proxyBuilder({ sock, raw: new Foad(sock, ...args) }, foadAliases)
+}
+
+export function createFoad2Builder(sock, ...args) {
+  return proxyBuilder({ sock, raw: new Foad2(sock, ...args) }, foadAliases)
+}
+
+export { Foad, Foad2 }

package/lib/Kyyinfinite/Simple/KyyMessage.js

@@ -0,0 +1,46 @@
+import { downloadMediaMessage } from '../../Utils/messages.js'
+
+export class KyyMessage {
+  constructor(sock, message) {
+    if (!sock) throw new Error('Socket is required')
+    if (!message) throw new TypeError('A WhatsApp message is required')
+    this.sock = sock
+    this.message = message
+    this.key = message.key || message
+  }
+
+  get id() { return this.key?.id }
+  get jid() { return this.key?.remoteJid }
+  get sender() { return this.key?.participant || this.key?.remoteJid }
+  get fromMe() { return Boolean(this.key?.fromMe) }
+
+  reply(content, options = {}) {
+    const message = typeof content === 'string' ? { text: content } : { ...(content || {}) }
+    const sendOptions = { ...(options || {}), quoted: this.message }
+    return this.sock.sendMessage(this.jid, message, sendOptions)
+  }
+
+  react(text = '') {
+    return this.sock.sendMessage(this.jid, { react: { text: String(text), key: this.key } })
+  }
+
+  edit(content, options = {}) {
+    const message = typeof content === 'string' ? { text: content } : { ...(content || {}) }
+    message.edit = this.key
+    return this.sock.sendMessage(this.jid, message, options)
+  }
+
+  delete() {
+    return this.sock.sendMessage(this.jid, { delete: this.key })
+  }
+
+  forward(jid = this.jid, force = false) {
+    return this.sock.sendMessage(jid, { forward: this.message, force })
+  }
+
+  download(type = 'buffer', options = {}, ctx) {
+    return downloadMediaMessage(this.message, type, options, ctx)
+  }
+
+  raw() { return this.message }
+}

package/lib/Kyyinfinite/Simple/MediaBuilder.js

@@ -0,0 +1,41 @@
+import { applyAutoMentions, resolveMedia } from './messageUtils.js'
+
+export class MediaBuilder {
+  constructor(sock, type, media) {
+    this.sock = sock
+    this.type = type
+    this.content = { [type]: resolveMedia(media) }
+    this._autoMentions = true
+    this._sendOptions = {}
+  }
+
+  caption(value) { this.content.caption = String(value ?? ''); return this }
+  fileName(value) { this.content.fileName = String(value ?? ''); return this }
+  mimetype(value) { this.content.mimetype = value; return this }
+  context(value) { this.content.contextInfo = value || {}; return this }
+  mentions(value) { this.content.mentions = Array.isArray(value) ? [...value] : []; return this }
+  autoMentions(value = true) { this._autoMentions = Boolean(value); return this }
+  quoted(message) { this._sendOptions.quoted = message; return this }
+  payload(value) { Object.assign(this.content, value || {}); return this }
+  viewOnce(value = true) { this.content.viewOnce = Boolean(value); return this }
+  ptt(value = true) { this.content.ptt = Boolean(value); return this }
+  voice(value = true) { return this.ptt(value) }
+  ptv(value = true) { this.content.ptv = Boolean(value); return this }
+  videoNote(value = true) { return this.ptv(value) }
+  gif(value = true) { this.content.gifPlayback = Boolean(value); return this }
+  animated(value = true) { this.content.isAnimated = Boolean(value); return this }
+  dimensions(width, height) {
+    if (width != null) this.content.width = Number(width)
+    if (height != null) this.content.height = Number(height)
+    return this
+  }
+  thumbnail(value) { this.content.jpegThumbnail = value; return this }
+
+  build() {
+    return applyAutoMentions({ ...this.content }, this._autoMentions)
+  }
+
+  send(jid, options = {}) {
+    return this.sock.sendMessage(jid, this.build(), { ...this._sendOptions, ...(options || {}) })
+  }
+}

package/lib/Kyyinfinite/Simple/MessageBuilder.js

@@ -0,0 +1,55 @@
+import { applyAutoMentions, resolveMediaContent } from './messageUtils.js'
+
+export class MessageBuilder {
+  constructor(sock, content = {}) {
+    if (!sock) throw new Error('Socket is required')
+    this.sock = sock
+    this.content = { ...content }
+    this._autoMentions = true
+    this._sendOptions = {}
+  }
+
+  payload(value) {
+    if (!value || typeof value !== 'object') return this
+    Object.assign(this.content, value)
+    return this
+  }
+
+  context(value) {
+    this.content.contextInfo = value || {}
+    return this
+  }
+
+  mentions(value) {
+    this.content.mentions = Array.isArray(value) ? [...value] : []
+    return this
+  }
+
+  autoMentions(value = true) {
+    this._autoMentions = Boolean(value)
+    return this
+  }
+
+  quoted(message) {
+    this._sendOptions.quoted = message
+    return this
+  }
+
+  viewOnce(value = true) {
+    this.content.viewOnce = Boolean(value)
+    return this
+  }
+
+  edit(key) {
+    this.content.edit = key
+    return this
+  }
+
+  build() {
+    return applyAutoMentions(resolveMediaContent({ ...this.content }), this._autoMentions)
+  }
+
+  send(jid, options = {}) {
+    return this.sock.sendMessage(jid, this.build(), { ...this._sendOptions, ...(options || {}) })
+  }
+}

package/lib/Kyyinfinite/Simple/MessageTypesBuilder.js

@@ -0,0 +1,3 @@
+import { MessageBuilder } from './MessageBuilder.js'
+
+export class MessageTypesBuilder extends MessageBuilder {}

package/lib/Kyyinfinite/Simple/SimpleBuilder.js

@@ -0,0 +1,28 @@
+export class SimpleBuilder {
+  constructor(client, factory) {
+    if (!client) throw new Error('Socket is required')
+    this.sock = client
+    this._factory = factory
+    this.raw = factory()
+  }
+
+  build(...args) { return this.raw.build(...args) }
+  send(...args) { return this.raw.send(...args) }
+}
+
+export function proxyBuilder(builder, aliases = {}) {
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver)
+      const mapped = aliases[prop] || prop
+      const raw = target.raw
+      if (raw && typeof raw[mapped] === 'function') {
+        return (...args) => {
+          const value = raw[mapped](...args)
+          return value === raw ? receiver : value
+        }
+      }
+      return undefined
+    }
+  })
+}

package/lib/Kyyinfinite/Simple/SimpleClient.js

@@ -0,0 +1,120 @@
+import { TextBuilder } from './TextBuilder.js'
+import { MediaBuilder } from './MediaBuilder.js'
+import { MessageBuilder } from './MessageBuilder.js'
+import { createButtonBuilder, createButtonV2Builder } from './ButtonBuilder.js'
+import { createCarouselBuilder } from './CarouselBuilder.js'
+import { createAIBuilder } from './AIBuilder.js'
+import { createFoadBuilder, createFoad2Builder } from './FoadBuilder.js'
+import { Toolkit, Button, ButtonV2, Carousel, AIRich, Foad, Foad2 } from '../wrapper.js'
+import { KyyMessage } from './KyyMessage.js'
+import { UniversalMediaBuilder } from './UniversalMediaBuilder.js'
+import { parseMessage } from './parseMessage.js'
+import { applyAutoMentions, extractMentions, resolveMedia, resolveMediaContent, quotedOptions } from './messageUtils.js'
+import { parseJid, normalizeJid, jidUser, jidServer, jidDevice, isGroupJid, isPrivateJid, isBroadcastJid, isStatusJid, isNewsletterJid, isLidJid, makeJid } from './jid.js'
+
+export class SimpleClient {
+  constructor(sock) {
+    if (!sock || (typeof sock !== 'object' && typeof sock !== 'function')) {
+      throw new TypeError('A Baileys socket is required')
+    }
+    this.sock = sock
+    this.raw = Object.freeze({ Toolkit, Button, ButtonV2, Carousel, AIRich, Foad, Foad2 })
+    this.wrapper = this.raw
+  }
+
+  text(text = '') { return new TextBuilder(this.sock, text) }
+  media(media) { return new UniversalMediaBuilder(this.sock, media) }
+  wrapMessage(message) { return new KyyMessage(this.sock, message) }
+  parseMessage(message, options = {}) { return parseMessage(message, options) }
+  send(jid, content, options = {}) {
+    const { autoMentions = true, ...sendOptions } = options || {}
+    const message = typeof content === 'string' ? { text: content } : resolveMediaContent({ ...(content || {}) })
+    return this.sock.sendMessage(jid, applyAutoMentions(message, autoMentions !== false), sendOptions)
+  }
+  quoted(message, content, options = {}) {
+    return this.send(this.wrapMessage(message).jid, content, quotedOptions(message, options))
+  }
+  mentions(text) { return extractMentions(text) }
+  resolveMedia(media) { return resolveMedia(media) }
+  resolveMediaContent(content) { return resolveMediaContent(content) }
+  jid(value) { return normalizeJid(value) }
+  parseJid(value) { return parseJid(value) }
+  jidUser(value) { return jidUser(value) }
+  jidServer(value) { return jidServer(value) }
+  jidDevice(value) { return jidDevice(value) }
+  isGroup(value) { return isGroupJid(value) }
+  isPrivate(value) { return isPrivateJid(value) }
+  isBroadcast(value) { return isBroadcastJid(value) }
+  isStatus(value) { return isStatusJid(value) }
+  isNewsletter(value) { return isNewsletterJid(value) }
+  isLid(value) { return isLidJid(value) }
+  makeJid(user, server = 's.whatsapp.net', device = null) { return makeJid(user, server, device) }
+  reply(message, content, options = {}) { return this.wrapMessage(message).reply(content, options) }
+  reactTo(message, text = '') { return this.wrapMessage(message).react(text) }
+  editMessage(message, content, options = {}) { return this.wrapMessage(message).edit(content, options) }
+  deleteMessage(message) { return this.wrapMessage(message).delete() }
+  forwardMessage(message, jid, force = false) { return this.wrapMessage(message).forward(jid, force) }
+  downloadMessage(message, type = 'buffer', options = {}, ctx) { return this.wrapMessage(message).download(type, options, ctx) }
+  image(media) { return new MediaBuilder(this.sock, 'image', media) }
+  video(media) { return new MediaBuilder(this.sock, 'video', media) }
+  audio(media) { return new MediaBuilder(this.sock, 'audio', media) }
+  voice(media) { return new MediaBuilder(this.sock, 'audio', media).ptt(true) }
+  document(media) { return new MediaBuilder(this.sock, 'document', media) }
+  sticker(media) { return new MediaBuilder(this.sock, 'sticker', media) }
+  ptv(media) { return new MediaBuilder(this.sock, 'video', media).ptv(true) }
+  gif(media) { return new MediaBuilder(this.sock, 'video', media).gif(true) }
+
+  message(content = {}) { return new MessageBuilder(this.sock, content) }
+  poll(name, values = [], selectableCount = 1) {
+    return new MessageBuilder(this.sock, {
+      poll: { name, values, selectableCount }
+    })
+  }
+  event(options = {}) { return new MessageBuilder(this.sock, { event: options }) }
+  album(options = {}) { return new MessageBuilder(this.sock, { album: options }) }
+  contacts(displayName, contacts = []) {
+    return new MessageBuilder(this.sock, {
+      contacts: { displayName, contacts }
+    })
+  }
+  location(location = {}) { return new MessageBuilder(this.sock, { location }) }
+  buttonReply(displayText, id, index = 0) {
+    return new MessageBuilder(this.sock, {
+      buttonReply: { displayText, id, index },
+      type: 'plain'
+    })
+  }
+  listReply(reply = {}) { return new MessageBuilder(this.sock, { listReply: reply }) }
+  react(messageKey, text = '') {
+    return new MessageBuilder(this.sock, {
+      react: { key: messageKey, text }
+    })
+  }
+  groupInvite(info = {}) { return new MessageBuilder(this.sock, { groupInvite: info }) }
+  product(product, options = {}) {
+    return new MessageBuilder(this.sock, { product, ...options })
+  }
+  requestPhoneNumber(value = true) {
+    return new MessageBuilder(this.sock, { requestPhoneNumber: Boolean(value) })
+  }
+  sharePhoneNumber(value = true) {
+    return new MessageBuilder(this.sock, { sharePhoneNumber: Boolean(value) })
+  }
+  pin(messageKey, type, time) {
+    const payload = { pin: messageKey, type }
+    if (time != null) payload.time = time
+    return new MessageBuilder(this.sock, payload)
+  }
+  forward(message, force = false) {
+    return new MessageBuilder(this.sock, { forward: message, force })
+  }
+  delete(messageKey) { return new MessageBuilder(this.sock, { delete: messageKey }) }
+  disappearing(value) { return new MessageBuilder(this.sock, { disappearingMessagesInChat: value }) }
+  limitSharing(value = true) { return new MessageBuilder(this.sock, { limitSharing: Boolean(value) }) }
+  button(...args) { return createButtonBuilder(this.sock, ...args) }
+  buttonV2(...args) { return createButtonV2Builder(this.sock, ...args) }
+  carousel(...args) { return createCarouselBuilder(this.sock, ...args) }
+  ai(...args) { return createAIBuilder(this.sock, ...args) }
+  foad(...args) { return createFoadBuilder(this.sock, ...args) }
+  foad2(...args) { return createFoad2Builder(this.sock, ...args) }
+}

package/lib/Kyyinfinite/Simple/TextBuilder.js

@@ -0,0 +1,28 @@
+import { applyAutoMentions } from './messageUtils.js'
+
+export class TextBuilder {
+  constructor(sock, text = '') {
+    this.sock = sock
+    this.content = { text: String(text ?? '') }
+    this._autoMentions = true
+    this._sendOptions = {}
+  }
+
+  text(value) { this.content.text = String(value ?? ''); return this }
+  footer(value) { this.content.footer = String(value ?? ''); return this }
+  context(value) { this.content.contextInfo = value || {}; return this }
+  mentions(value) { this.content.mentions = Array.isArray(value) ? [...value] : []; return this }
+  autoMentions(value = true) { this._autoMentions = Boolean(value); return this }
+  quoted(message) { this._sendOptions.quoted = message; return this }
+  viewOnce(value = true) { this.content.viewOnce = Boolean(value); return this }
+  edit(key) { this.content.edit = key; return this }
+  payload(value) { Object.assign(this.content, value || {}); return this }
+
+  build() {
+    return applyAutoMentions({ ...this.content }, this._autoMentions)
+  }
+
+  send(jid, options = {}) {
+    return this.sock.sendMessage(jid, this.build(), { ...this._sendOptions, ...(options || {}) })
+  }
+}

package/lib/Kyyinfinite/Simple/UniversalMediaBuilder.js

@@ -0,0 +1,21 @@
+import { MediaBuilder } from './MediaBuilder.js'
+
+export class UniversalMediaBuilder extends MediaBuilder {
+  constructor(sock, media) {
+    super(sock, 'image', media)
+  }
+
+  _setType(type) {
+    const current = this.content[this.type]
+    delete this.content[this.type]
+    this.type = type
+    this.content[type] = current
+    return this
+  }
+
+  asImage() { return this._setType('image') }
+  asVideo() { return this._setType('video') }
+  asAudio() { return this._setType('audio') }
+  asDocument() { return this._setType('document') }
+  asSticker() { return this._setType('sticker') }
+}