@juzi/wechaty 1.0.0

package/src/sayable/message-to-sayable.ts

@@ -0,0 +1,57 @@
+import * as PUPPET from 'wechaty-puppet'
+import { log } from 'wechaty-puppet'
+
+import type {
+  MessageInterface,
+}                   from '../user-modules/mod.js'
+
+import type { Sayable } from './types.js'
+
+async function messageToSayable (
+  message: MessageInterface,
+): Promise<undefined | Sayable> {
+  log.verbose('Wechaty', 'toSayable(%s)', message)
+
+  const type = message.type()
+
+  switch (type) {
+    case PUPPET.types.Message.Text:
+      return message.text()
+
+    case PUPPET.types.Message.Image:
+    case PUPPET.types.Message.Attachment:
+    case PUPPET.types.Message.Audio:
+    case PUPPET.types.Message.Video:
+    case PUPPET.types.Message.Emoticon:
+      return message.toFileBox()
+
+    case PUPPET.types.Message.Contact:
+      return message.toContact()
+
+    case PUPPET.types.Message.Url:
+      return message.toUrlLink()
+
+    case PUPPET.types.Message.MiniProgram:
+      return message.toMiniProgram()
+
+    case PUPPET.types.Message.Location:
+      return message.toLocation()
+
+    case PUPPET.types.Message.Post:
+      return message.toPost()
+
+    default:
+      log.warn('Wechaty',
+        'toSayable() can not convert not re-sayable type: %s(%s) for %s\n%s',
+        PUPPET.types.Message[type],
+        type,
+        message,
+        new Error().stack,
+      )
+      return undefined
+  }
+}
+
+export {
+  messageToSayable,
+}

package/src/sayable/mod.ts

@@ -0,0 +1,27 @@
+import type {
+  SayableSayer,
+  Sayable,
+}                                     from './types.js'
+import {
+  messageToSayable,
+}                                     from './message-to-sayable.js'
+import {
+  sayableToPayload,
+}                                     from './sayable-to-payload.js'
+import {
+  payloadToSayableWechaty,
+}                                     from './payload-to-sayable.js'
+import {
+  deliverSayableConversationPuppet,
+}                                     from './deliver-sayable.js'
+
+export type {
+  Sayable,
+  SayableSayer,
+}
+export {
+  messageToSayable,
+  sayableToPayload,
+  payloadToSayableWechaty,
+  deliverSayableConversationPuppet,
+}

package/src/sayable/payload-to-sayable.ts

@@ -0,0 +1,51 @@
+import * as PUPPET from 'wechaty-puppet'
+import { log }  from 'wechaty-puppet'
+
+import type { WechatyInterface } from '../wechaty/wechaty-impl.js'
+
+import type {
+  Sayable,
+}                   from './types.js'
+
+const payloadToSayableWechaty: (w: WechatyInterface) => (p: PUPPET.payloads.Sayable) => Promise<undefined | Sayable> = (wechaty: WechatyInterface) => async (
+  sayable: PUPPET.payloads.Sayable,
+) => {
+  log.verbose('Wechaty', 'payloadToSayable({type: %s(%s)})',
+    PUPPET.types.Message[sayable.type],
+    sayable.type,
+  )
+
+  switch (sayable.type) {
+    case PUPPET.types.Sayable.Text:
+      return sayable.payload.text
+
+    case PUPPET.types.Sayable.Emoticon:
+    case PUPPET.types.Sayable.Image:
+    case PUPPET.types.Sayable.Video:
+    case PUPPET.types.Sayable.Audio:
+    case PUPPET.types.Sayable.Attachment:
+      return sayable.payload.filebox
+
+    case PUPPET.types.Sayable.Contact:
+      return wechaty.Contact.find({ id: sayable.payload.contactId })
+
+    case PUPPET.types.Sayable.Location:
+      return new wechaty.Location(sayable.payload)
+
+    case PUPPET.types.Sayable.MiniProgram:
+      return new wechaty.MiniProgram(sayable.payload)
+
+    case PUPPET.types.Sayable.Url:
+      return new wechaty.UrlLink(sayable.payload)
+
+    case PUPPET.types.Sayable.Post:
+      return new wechaty.Post(sayable.payload)
+
+    default:
+      throw new Error('payloadToSayable() not support payload: ' + JSON.stringify(sayable))
+  }
+}
+
+export {
+  payloadToSayableWechaty,
+}

package/src/sayable/sayable-to-payload.ts

@@ -0,0 +1,54 @@
+import * as PUPPET from 'wechaty-puppet'
+import { log }  from 'wechaty-puppet'
+import { FileBox } from 'file-box'
+
+import {
+  DelayImpl,
+  LocationImpl,
+  MessageImpl,
+  MiniProgramImpl,
+  UrlLinkImpl,
+  ContactImpl,
+  PostImpl,
+}                       from '../user-modules/mod.js'
+
+import type {
+  Sayable,
+}                   from './types.js'
+
+async function sayableToPayload (sayable: Sayable): Promise<undefined | PUPPET.payloads.Sayable> {
+  log.verbose('Wechaty', 'sayableToPayload(%s)', sayable)
+
+  if (typeof sayable === 'string') {
+    return PUPPET.payloads.sayable.text(sayable)
+  } else if (typeof sayable === 'number') {
+    return PUPPET.payloads.sayable.text(String(sayable))
+  } else if (ContactImpl.valid(sayable)) {
+    return PUPPET.payloads.sayable.contact(sayable.id)
+  } else if (DelayImpl.validInstance(sayable)) {
+    return undefined
+  } else if (FileBox.valid(sayable)) {
+    return PUPPET.payloads.sayable.attatchment(sayable)
+  } else if (LocationImpl.validInstance(sayable)) {
+    return PUPPET.payloads.sayable.location(sayable.payload)
+  } else if (MessageImpl.valid(sayable)) {
+    const messageSayable = await sayable.toSayable()
+    if (!messageSayable) {
+      return undefined
+    }
+    return sayableToPayload(messageSayable)
+  } else if (MiniProgramImpl.validInstance(sayable)) {
+    return PUPPET.payloads.sayable.miniProgram(sayable.payload)
+  } else if (PostImpl.validInstance(sayable)) {
+    return PUPPET.payloads.sayable.post(sayable.payload)
+  } else if (UrlLinkImpl.validInstance(sayable)) {
+    return PUPPET.payloads.sayable.url(sayable.payload)
+  } else {
+    log.error('Wechaty', 'sayableToPayload() unsupported sayable: %s', sayable)
+    return undefined
+  }
+}
+
+export {
+  sayableToPayload,
+}

package/src/sayable/types.ts

@@ -0,0 +1,62 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import type {
+  FileBoxInterface,
+}                       from 'file-box'
+
+import type {
+  ContactInterface,
+  DelayInterface,
+  LocationInterface,
+  MessageInterface,
+  MiniProgramInterface,
+  PostInterface,
+  UrlLinkInterface,
+}                           from '../user-modules/mod.js'
+
+import type {
+  WechatyInterface,
+}                           from '../wechaty/mod.js'
+
+type Sayable =
+  | ContactInterface
+  | DelayInterface
+  | FileBoxInterface
+  | LocationInterface
+  | MessageInterface
+  | MiniProgramInterface
+  | number
+  | PostInterface
+  | string
+  | UrlLinkInterface
+
+interface SayableSayer {
+  id      : string,
+  wechaty : WechatyInterface,
+  say (
+    sayable  : Sayable,
+    replyTo? : ContactInterface | ContactInterface[]
+  ): Promise<void | MessageInterface>
+}
+
+export type {
+  SayableSayer,
+  Sayable,
+}

package/src/schemas/acceptable.ts

@@ -0,0 +1,30 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import type { WechatyInterface } from '../wechaty/mod.js'
+
+interface Accepter {
+  accept  : () => Promise<void>
+  id      : string,
+  wechaty : WechatyInterface
+}
+
+export type  {
+  Accepter,
+}

package/src/schemas/contact-events.ts

@@ -0,0 +1,29 @@
+import { EventEmitter }   from 'events'
+import type TypedEventEmitter  from 'typed-emitter'
+
+import type {
+  ContactInterface,
+  FriendshipInterface,
+  MessageInterface,
+}                   from '../user-modules/mod.js'
+
+type ContactEventListenerMessage    = (this: ContactInterface, message: MessageInterface, date?: Date)  => void | Promise<void>
+type ContactEventListenerFriendship = (friendship: FriendshipInterface)                                 => void | Promise<void>
+
+interface ContactEventListeners {
+  friendship : ContactEventListenerFriendship,
+  message    : ContactEventListenerMessage,
+}
+
+const ContactEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
+  ContactEventListeners
+>
+
+export type {
+  ContactEventListeners,
+  ContactEventListenerMessage,
+  ContactEventListenerFriendship,
+}
+export {
+  ContactEventEmitter,
+}

package/src/schemas/mod.ts

@@ -0,0 +1,29 @@
+import {
+  ContactEventEmitter,
+  ContactEventListeners,
+}                           from './contact-events.js'
+import {
+  RoomEventEmitter,
+  RoomEventListeners,
+}                           from './room-events.js'
+import {
+  WechatyEventEmitter,
+  WechatyEventListeners,
+  WechatyEventName,
+}                           from './wechaty-events.js'
+import type {
+  Accepter,
+}                           from './acceptable.js'
+
+export type {
+  Accepter,
+  ContactEventListeners,
+  RoomEventListeners,
+  WechatyEventListeners,
+  WechatyEventName,
+}
+export {
+  ContactEventEmitter,
+  RoomEventEmitter,
+  WechatyEventEmitter,
+}

package/src/schemas/room-events.ts

@@ -0,0 +1,128 @@
+import { EventEmitter }   from 'events'
+import type TypedEventEmitter  from 'typed-emitter'
+
+import type {
+  ContactInterface,
+  MessageInterface,
+  RoomInterface,
+  RoomInvitationInterface,
+}                   from '../user-modules/mod.js'
+
+export const ROOM_EVENT_DICT = {
+  invite  : 'tbw',
+  join    : 'tbw',
+  leave   : 'tbw',
+  message : 'message that received in this room',
+  topic   : 'tbw',
+}
+export type RoomEventName = keyof typeof ROOM_EVENT_DICT
+
+/**
+ * @desc       Room Class Event Type
+ * @typedef    RoomEventName
+ * @property   {string}  join  - Emit when anyone join any room.
+ * @property   {string}  topic - Get topic event, emitted when someone change room topic.
+ * @property   {string}  leave - Emit when anyone leave the room.<br>
+ *                               If someone leaves the room by themselves, WeChat will not notice other people in the room, so the bot will never get the "leave" event.
+ */
+
+/**
+ * @desc       Room Class Event Function
+ * @typedef    RoomEventFunction
+ * @property   {Function} room-join       - (this: Room, inviteeList: Contact[] , inviter: Contact)  => void
+ * @property   {Function} room-topic      - (this: Room, topic: string, oldTopic: string, changer: Contact) => void
+ * @property   {Function} room-leave      - (this: Room, leaver: Contact) => void
+ */
+
+/**
+ * @listens Room
+ * @param   {RoomEventName}      event      - Emit WechatyEvent
+ * @param   {RoomEventFunction}  listener   - Depends on the WechatyEvent
+ * @return  {this}                          - this for chain
+ *
+ * @example <caption>Event:join </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('join', (room, inviteeList, inviter) => {
+ *     const nameList = inviteeList.map(c => c.name()).join(',')
+ *     console.log(`Room got new member ${nameList}, invited by ${inviter}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:leave </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('leave', (room, leaverList) => {
+ *     const nameList = leaverList.map(c => c.name()).join(',')
+ *     console.log(`Room lost member ${nameList}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:message </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('message', (message) => {
+ *     console.log(`Room received new message: ${message}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:topic </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('topic', (room, topic, oldTopic, changer) => {
+ *     console.log(`Room topic changed from ${oldTopic} to ${topic} by ${changer.name()}`)
+ *   })
+ * }
+ *
+ * @example <caption>Event:invite </caption>
+ * const bot = new Wechaty()
+ * await bot.start()
+ * // after logged in...
+ * const room = await bot.Room.find({topic: 'topic of your room'}) // change `event-room` to any room topic in your WeChat
+ * if (room) {
+ *   room.on('invite', roomInvitation => roomInvitation.accept())
+ * }
+ *
+ */
+
+type RoomEventListenerInvite  = (this: RoomInterface, inviter: ContactInterface, invitation: RoomInvitationInterface)           => void | Promise<void>
+type RoomEventListenerJoin    = (this: RoomInterface, inviteeList: ContactInterface[], inviter: ContactInterface,  date?: Date) => void | Promise<void>
+type RoomEventListenerLeave   = (this: RoomInterface, leaverList: ContactInterface[], remover?: ContactInterface, date?: Date)  => void | Promise<void>
+type RoomEventListenerMessage = (this: RoomInterface, message: MessageInterface, date?: Date)                                   => void | Promise<void>
+type RoomEventListenerTopic   = (this: RoomInterface, topic: string, oldTopic: string, changer: ContactInterface, date?: Date)  => void | Promise<void>
+
+interface RoomEventListeners {
+  invite  : RoomEventListenerInvite
+  join    : RoomEventListenerJoin
+  leave   : RoomEventListenerLeave
+  message : RoomEventListenerMessage
+  topic   : RoomEventListenerTopic
+}
+
+const RoomEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
+  RoomEventListeners
+>
+
+export type {
+  RoomEventListeners,
+  RoomEventListenerInvite,
+  RoomEventListenerJoin,
+  RoomEventListenerLeave,
+  RoomEventListenerMessage,
+  RoomEventListenerTopic,
+}
+export {
+  RoomEventEmitter,
+}