@satorijs/adapter-lark 3.6.0 → 3.6.1

package/src/message.ts

@@ -1,19 +1,14 @@
 import { Context, h, MessageEncoder } from '@satorijs/core'
 import { LarkBot } from './bot'
-import { BaseResponse, Lark, MessageContent, MessageType } from './types'
+import { BaseResponse, Lark, MessageContent } from './types'
 import { extractIdType } from './utils'
 
-export interface Addition {
-  file: MessageContent.MediaContents
-  type: MessageType
-}
-
 export class LarkMessageEncoder<C extends Context = Context> extends MessageEncoder<C, LarkBot<C>> {
   private quote: string | undefined
-  private content = ''
-  private addition: Addition
-  // TODO: currently not used, would be supported in the future
-  private richText: MessageContent.RichText[string]
+  private textContent = ''
+  private richContent: MessageContent.RichText.Paragraph[] = []
+  private cardElements: MessageContent.Card.Element[] | undefined
+  private actionElements: MessageContent.Card.ButtonElement[] = []
 
   async post(data?: any) {
     try {
@@ -46,131 +41,204 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     }
   }
 
-  async flush() {
-    if (this.content === '' && !this.addition && !this.richText) return
-
-    let message: MessageContent.Contents
-    if (this.addition) {
-      message = {
-        ...message,
-        ...this.addition.file,
-      }
+  private flushText(flushAction = false) {
+    if ((this.textContent || flushAction) && this.actionElements.length) {
+      this.cardElements?.push({ tag: 'action', actions: this.actionElements })
+      this.actionElements = []
     }
-    if (this.richText) {
-      message = { zh_cn: this.richText }
+    if (this.textContent) {
+      this.richContent.push([{ tag: 'md', text: this.textContent }])
+      this.cardElements?.push({ tag: 'markdown', content: this.textContent })
+      this.textContent = ''
     }
-    if (this.content) {
-      message = { text: this.content }
+  }
+
+  async flush() {
+    this.flushText()
+    if (!this.cardElements && !this.richContent.length) return
+
+    if (this.cardElements) {
+      await this.post({
+        msg_type: 'interactive',
+        content: JSON.stringify({
+          elements: this.cardElements,
+        }),
+      })
+    } else {
+      await this.post({
+        msg_type: 'post',
+        content: JSON.stringify({
+          zh_cn: {
+            content: this.richContent,
+          },
+        }),
+      })
     }
-    await this.post({
-      msg_type: this.richText ? 'post' : this.addition ? this.addition.type : 'text',
-      content: JSON.stringify(message),
-    })
 
     // reset cached content
     this.quote = undefined
-    this.content = ''
-    this.addition = undefined
-    this.richText = undefined
+    this.textContent = ''
+    this.richContent = []
+    this.cardElements = undefined
   }
 
-  async sendFile(type: 'img' | 'image' | 'video' | 'audio' | 'file', url: string): Promise<Addition> {
+  async createImage(url: string) {
+    const { filename, type, data } = await this.bot.assetsQuester.file(url)
     const payload = new FormData()
+    payload.append('image', new Blob([data], { type }), filename)
+    payload.append('image_type', 'message')
+    const { data: { image_key } } = await this.bot.internal.createImImage(payload)
+    return image_key
+  }
 
-    const assetKey = type === 'img' || type === 'image' ? 'image' : 'file'
-    const { filename, mime, data } = await this.bot.assetsQuester.file(url)
-    payload.append(assetKey, new Blob([data], { type: mime }), filename)
+  async sendFile(_type: 'video' | 'audio' | 'file', attrs: any) {
+    const url = attrs.src || attrs.url
+    const payload = new FormData()
+    const { filename, type, data } = await this.bot.assetsQuester.file(url)
+    payload.append('file', new Blob([data], { type }), filename)
+    payload.append('file_name', filename)
 
-    if (type === 'img' || type === 'image') {
-      payload.append('image_type', 'message')
-      const { data } = await this.bot.internal.createImImage(payload)
-      return {
-        type: 'image',
-        file: {
-          image_key: data.image_key,
-        },
-      }
+    if (attrs.duration) {
+      payload.append('duration', attrs.duration)
+    }
+
+    if (_type === 'audio') {
+      // FIXME: only support opus
+      payload.append('file_type', 'opus')
+    } else if (_type === 'video') {
+      // FIXME: only support mp4
+      payload.append('file_type', 'mp4')
     } else {
-      let msgType: MessageType = 'file'
-      if (type === 'audio') {
-        // FIXME: only support opus
-        payload.append('file_type', 'opus')
-        msgType = 'audio'
-      } else if (type === 'video') {
-        // FIXME: only support mp4
-        payload.append('file_type', 'mp4')
-        msgType = 'media'
+      const ext = filename.split('.').pop()
+      if (['doc', 'xls', 'ppt', 'pdf'].includes(ext)) {
+        payload.append('file_type', ext)
       } else {
-        const ext = filename.split('.').pop()
-        if (['xls', 'ppt', 'pdf'].includes(ext)) {
-          payload.append('file_type', ext)
-        } else {
-          payload.append('file_type', 'stream')
-        }
-      }
-      payload.append('file_name', filename)
-      const { data } = await this.bot.internal.createImFile(payload)
-      return {
-        type: msgType,
-        file: {
-          file_key: data.file_key,
-        },
+        payload.append('file_type', 'stream')
       }
     }
+
+    const { data: { file_key } } = await this.bot.internal.createImFile(payload)
+    await this.post({
+      msg_type: _type === 'video' ? 'media' : _type,
+      content: JSON.stringify({ file_key }),
+    })
   }
 
   async visit(element: h) {
     const { type, attrs, children } = element
-
-    switch (type) {
-      case 'text':
-        this.content += attrs.content
-        break
-      case 'at': {
-        if (attrs.type === 'all') {
-          this.content += `<at user_id="all">${attrs.name ?? '所有人'}</at>`
-        } else {
-          this.content += `<at user_id="${attrs.id}">${attrs.name}</at>`
-        }
-        break
+    if (type === 'text') {
+      this.textContent += attrs.content
+    } else if (type === 'at') {
+      if (attrs.type === 'all') {
+        this.textContent += `<at user_id="all">${attrs.name ?? '所有人'}</at>`
+      } else {
+        this.textContent += `<at user_id="${attrs.id}">${attrs.name}</at>`
       }
-      case 'a':
-        await this.render(children)
-        if (attrs.href) this.content += ` (${attrs.href})`
-        break
-      case 'p':
-        if (!this.content.endsWith('\n')) this.content += '\n'
-        await this.render(children)
-        if (!this.content.endsWith('\n')) this.content += '\n'
-        break
-      case 'br':
-        this.content += '\n'
-        break
-      case 'sharp':
-        // platform does not support sharp
-        break
-      case 'quote':
+    } else if (type === 'a') {
+      await this.render(children)
+      if (attrs.href) this.textContent += ` (${attrs.href})`
+    } else if (type === 'p') {
+      if (!this.textContent.endsWith('\n')) this.textContent += '\n'
+      await this.render(children)
+      if (!this.textContent.endsWith('\n')) this.textContent += '\n'
+    } else if (type === 'br') {
+      this.textContent += '\n'
+    } else if (type === 'sharp') {
+      // platform does not support sharp
+    } else if (type === 'quote') {
+      await this.flush()
+      this.quote = attrs.id
+    } else if (type === 'img' || type === 'image') {
+      const image_key = await this.createImage(attrs.src || attrs.url)
+      this.textContent += `![${attrs.alt ?? '图片'}](${image_key})`
+      this.flushText()
+      this.richContent.push([{ tag: 'img', image_key }])
+    } else if (['video', 'audio', 'file'].includes(type)) {
+      await this.flush()
+      await this.sendFile(type as any, attrs)
+    } else if (type === 'figure' || type === 'message') {
+      await this.flush()
+      await this.render(children, true)
+    } else if (type === 'hr') {
+      this.flushText()
+      this.richContent.push([{ tag: 'hr' }])
+      this.cardElements?.push({ tag: 'hr' })
+    } else if (type === 'button') {
+      this.flushText()
+      const behaviors: MessageContent.Card.ActionBehavior[] = []
+      if (attrs.type === 'link') {
+        behaviors.push({
+          type: 'open_url',
+          default_url: attrs.href,
+        })
+      } else if (attrs.type === 'input') {
+        behaviors.push({
+          type: 'callback',
+          value: {
+            _satori_type: 'command',
+            content: attrs.text,
+          },
+        })
+      } else if (attrs.type === 'action') {
+        // TODO
+      }
+      await this.render(children)
+      this.actionElements.push({
+        tag: 'button',
+        text: {
+          tag: 'plain_text',
+          content: this.textContent,
+        },
+        behaviors,
+      })
+      this.textContent = ''
+    } else if (type === 'button-group') {
+      this.flushText(true)
+      await this.render(children)
+      this.flushText(true)
+    } else if (type.startsWith('lark:') || type.startsWith('feishu:')) {
+      const tag = type.slice(type.split(':', 1)[0].length + 1)
+      if (tag === 'share-chat') {
         await this.flush()
-        this.quote = attrs.id
-        break
-      case 'img':
-      case 'image':
-      case 'video':
-      case 'audio':
-      case 'file':
-        if (attrs.src || attrs.url) {
-          await this.flush()
-          this.addition = await this.sendFile(type, attrs.src || attrs.url)
-          await this.flush()
-        }
-        break
-      case 'figure': // FIXME: treat as message element for now
-      case 'message':
+        await this.post({
+          msg_type: 'share_chat',
+          content: JSON.stringify({ chat_id: attrs.chatId }),
+        })
+      } else if (tag === 'share-user') {
+        await this.flush()
+        await this.post({
+          msg_type: 'share_user',
+          content: JSON.stringify({ user_id: attrs.userId }),
+        })
+      } else if (tag === 'system') {
+        await this.flush()
+        await this.render(children)
+        await this.post({
+          msg_type: 'system',
+          content: JSON.stringify({
+            type: 'divider',
+            params: { divider_text: { text: this.textContent } },
+            options: { need_rollup: attrs.needRollup },
+          }),
+        })
+        this.textContent = ''
+      } else if (tag === 'card') {
         await this.flush()
+        this.cardElements = []
         await this.render(children, true)
-        break
-      default:
+      } else if (tag === 'div') {
+        this.flushText()
         await this.render(children)
+        this.cardElements?.push({
+          tag: 'markdown',
+          text_align: attrs.align,
+          text_size: attrs.size,
+          content: this.textContent,
+        })
+        this.textContent = ''
+      }
+    } else {
+      await this.render(children)
     }
   }
 }

package/src/types/message/content.ts

@@ -1,23 +1,35 @@
-// https://open.larksuite.com/document/uAjLw4CM/ukTMukTMukTM/im-v1/message/create_json
+// https://open.larksuite.com/document/server-docs/im-v1/message-content-description/create_json
 
-export namespace MessageContent {
-  export type Contents =
-    | Text
-    | Image
-    | ShareChat
-    | ShareUser
-    | Audio
-    | Media
-    | File
-    | Sticker
-    | RichText
-
-  export type MediaContents =
-    | Image
-    | Audio
-    | Media
-    | File
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      'lark:share-chat': {
+        'chat-id': string
+      }
+      'lark:share-user': {
+        'user-id': string
+      }
+      'lark:system': {
+        'need-rollup'?: boolean
+      }
+    }
+  }
+}
+
+export interface MessageContent {
+  text: MessageContent.Text
+  post: MessageContent.RichText
+  image: MessageContent.Image
+  file: MessageContent.File
+  audio: MessageContent.Audio
+  media: MessageContent.Media
+  sticker: MessageContent.Sticker
+  share_chat: MessageContent.ShareChat
+  share_user: MessageContent.ShareUser
+  system: MessageContent.System
+}
 
+export namespace MessageContent {
   export interface Text {
     text: string
   }
@@ -40,7 +52,7 @@ export namespace MessageContent {
 
   export interface Media {
     file_key: string
-    image_key: string
+    image_key?: string
   }
 
   export interface File {
@@ -51,52 +63,264 @@ export namespace MessageContent {
     file_key: string
   }
 
+  export interface System {
+    type: 'divider'
+    params: {
+      divider_text: {
+        text: string
+        i18n_text?: Record<string, string>
+      }
+    }
+    options?: {
+      need_rollup?: boolean
+    }
+  }
+
   export interface RichText {
     [locale: string]: {
-      title: string
+      title?: string
       content: RichText.Paragraph[]
     }
   }
 
   export namespace RichText {
-    export interface Paragraph extends Array<RichText.Content> {}
+    export type Style = 'bold' | 'italic' | 'underline' | 'lineThrough'
 
-    export interface BaseContent {
-      tag: string
+    export interface BaseElement<T extends string = string> {
+      tag: T
     }
 
-    export interface TextContent extends BaseContent {
-      tag: 'text'
+    export interface TextElement extends BaseElement<'text'> {
       text: string
       un_escape?: boolean
+      style?: Style[]
     }
-    export interface LinkContent extends BaseContent {
-      tag: 'a'
+
+    export interface LinkElement extends BaseElement<'a'> {
       text: string
       href: string
+      style?: Style[]
     }
-    export interface AtContent extends BaseContent {
-      tag: 'at'
+
+    export interface AtElement extends BaseElement<'at'> {
       user_id: string
-      user_name?: string
+      style?: Style[]
+      // user_name?: string
     }
-    export interface ImageContent extends BaseContent {
-      tag: 'img'
+
+    export interface ImageElement extends BaseElement<'img'> {
       image_key: string
-      height?: number
-      width?: number
+      // height?: number
+      // width?: number
     }
-    export interface MediaContent extends BaseContent {
-      tag: 'media'
+
+    export interface MediaElement extends BaseElement<'media'> {
       file_key: string
       image_key?: string
     }
 
-    export type Content =
-      | RichText.TextContent
-      | RichText.LinkContent
-      | RichText.AtContent
-      | RichText.ImageContent
-      | RichText.MediaContent
+    export interface EmotionElement extends BaseElement<'emoji'> {
+      emoji_type: string
+    }
+
+    export interface CodeBlockElement extends BaseElement<'code_block'> {
+      language?: string
+      text: string
+    }
+
+    export interface HRElement extends BaseElement<'hr'> {}
+
+    export interface MarkdownElement extends BaseElement<'md'> {
+      text: string
+    }
+
+    export type InlineElement =
+      | TextElement
+      | LinkElement
+      | AtElement
+      | EmotionElement
+      | MarkdownElement
+
+    export type BlockElement =
+      | ImageElement
+      | MediaElement
+      | CodeBlockElement
+      | HRElement
+
+    export type Paragraph =
+      | InlineElement[]
+      | [BlockElement]
+  }
+
+  export interface Card {
+    config: Card.Config
+    card_link?: Card.URLs
+    elements?: Card.Element[]
+  }
+
+  export namespace Card {
+    /** @see https://open.larksuite.com/document/common-capabilities/message-card/getting-started/card-structure/card-configuration */
+    export interface Config {
+      enable_forward?: boolean
+      update_multi?: boolean
+    }
+
+    export interface URLs {
+      url: string
+      pc_url?: string
+      ios_url?: string
+      android_url?: string
+    }
+
+    /** @see https://open.larksuite.com/document/common-capabilities/message-card/message-cards-content/card-header */
+    export interface Header {
+      title: I18nPlainTextElement
+      subtitle?: I18nPlainTextElement
+      template?: Header.Template
+      icon?: CustomIconElement
+      ud_icon?: StandardIconElement
+      text_tag_list?: TextTagElement[]
+      i18n_text_tag_list?: Record<string, TextTagElement[]>
+    }
+
+    export namespace Header {
+      export type Template = 'blue' | 'wathet' | 'turquoise' | 'green' | 'yellow' | 'orange' | 'red' | 'carmine' | 'violet' | 'purple' | 'indigo' | 'grey' | 'default'
+    }
+
+    export interface BaseElement<T extends string = string> {
+      tag: T
+    }
+
+    export type TextSize =
+      | 'heading-0' | 'heading-1' | 'heading-2' | 'heading-3' | 'heading-4' | 'heading'
+      | 'normal' | 'notation' | 'xxxx-large' | 'xxx-large' | 'xx-large' | 'x-large' | 'large' | 'medium' | 'small' | 'x-small'
+
+    export type TextAlign = 'left' | 'center' | 'right'
+
+    export interface PlainTextElement extends BaseElement<'plain_text'> {
+      content: string
+    }
+
+    export interface I18nPlainTextElement extends PlainTextElement {
+      i18n?: Record<string, string>
+    }
+
+    export interface DivPlainTextElement extends PlainTextElement {
+      text_size?: TextSize
+      text_color?: string
+      text_align?: TextAlign
+      lines?: number
+      icon?: IconElement
+    }
+
+    export type IconElement = StandardIconElement | CustomIconElement
+
+    export interface CustomIconElement extends BaseElement<'custom_icon'> {
+      img_key: string
+    }
+
+    export interface StandardIconElement extends BaseElement<'standard_icon'> {
+      token: string
+      color?: string
+    }
+
+    export interface TextTagElement extends BaseElement<'text_tag'> {
+      text: PlainTextElement
+      color: TextTagElement.Color
+    }
+
+    export namespace TextTagElement {
+      export type Color = 'neutral' | 'blue' | 'torqoise' | 'lime' | 'orange' | 'violet' | 'indigo' | 'wathet' | 'green' | 'yellow' | 'red' | 'purple' | 'carmine'
+    }
+
+    export interface ImageElement extends BaseElement<'image'> {
+      img_key: string
+      alt?: PlainTextElement
+      title?: PlainTextElement
+      custom_width?: number
+      compact_width?: boolean
+      mode?: 'crop_center' | 'fit_horizontal' | 'large' | 'medium' | 'small' | 'tiny'
+      preview?: boolean
+    }
+
+    export interface HorizontalRuleElement extends BaseElement<'hr'> {}
+
+    export interface DivElement extends BaseElement<'div'> {
+      text?: DivPlainTextElement
+    }
+
+    export interface MarkdownElement extends BaseElement<'markdown'> {
+      content: string
+      text_size?: TextSize
+      text_align?: TextAlign
+      href?: Record<string, URLs>
+    }
+
+    export interface HorizontalRuleElement extends BaseElement<'hr'> {}
+
+    export interface ActionModule extends BaseElement<'action'> {
+      actions: ActionElement[]
+      layout?: 'bisected' | 'trisection' | 'flow'
+    }
+
+    export type ActionElement =
+      | ButtonElement
+
+    export type ActionBehavior =
+      | OpenURLBehavior
+      | CallbackBehavior
+
+    export interface OpenURLBehavior {
+      type: 'open_url'
+      default_url: string
+      pc_url?: string
+      ios_url?: string
+      android_url?: string
+    }
+
+    export interface CallbackBehavior {
+      type: 'callback'
+      value: Record<string, string>
+    }
+
+    export interface ButtonElement extends BaseElement<'button'> {
+      text: PlainTextElement
+      type?: ButtonElement.Type
+      size?: ButtonElement.Size
+      width?: ButtonElement.Width
+      icon?: IconElement
+      hover_tips?: PlainTextElement
+      disabled?: boolean
+      disabled_tips?: PlainTextElement
+      confirm?: {
+        title: PlainTextElement
+        text: PlainTextElement
+      }
+      behaviors?: ActionBehavior[]
+      // form-related fields
+      name?: string
+      required?: boolean
+      action_type?: 'link' | 'request' | 'multi' | 'form_submit' | 'form_reset'
+    }
+
+    export namespace ButtonElement {
+      export type Size = 'tiny' | 'small' | 'medium' | 'large'
+      export type Width = 'default' | 'fill' | string
+      export type Type = 'default' | 'primary' | 'danger' | 'text' | 'primary_text' | 'danger_text' | 'primary_filled' | 'danger_filled' | 'laser'
+    }
+
+    export type Element =
+      | DivElement
+      | MarkdownElement
+      | HorizontalRuleElement
+      | ActionModule
+  }
+
+  export interface Template {
+    type: 'template'
+    data: {
+      template_id: string
+      template_variable: object
+    }
   }
 }