@satorijs/adapter-lark 3.6.1 → 3.6.2

package/lib/types/message/content.d.ts

@@ -112,9 +112,10 @@ export declare namespace MessageContent {
         type Paragraph = InlineElement[] | [BlockElement];
     }
     interface Card {
-        config: Card.Config;
+        config?: Card.Config;
         card_link?: Card.URLs;
-        elements?: Card.Element[];
+        header?: Card.Header;
+        elements: Card.Element[];
     }
     namespace Card {
         /** @see https://open.larksuite.com/document/common-capabilities/message-card/getting-started/card-structure/card-configuration */
@@ -174,16 +175,25 @@ export declare namespace MessageContent {
         namespace TextTagElement {
             type Color = 'neutral' | 'blue' | 'torqoise' | 'lime' | 'orange' | 'violet' | 'indigo' | 'wathet' | 'green' | 'yellow' | 'red' | 'purple' | 'carmine';
         }
-        interface ImageElement extends BaseElement<'image'> {
+        interface BaseImageElement extends BaseElement<'image'> {
             img_key: string;
             alt?: PlainTextElement;
+        }
+        interface ImageElement extends BaseImageElement {
             title?: PlainTextElement;
+            transparent?: string;
+            preview?: boolean;
+            corner_radius?: string;
+            scale_type?: 'crop_center' | 'fit_horizontal' | 'crop_top';
+            size?: 'large' | 'medium' | 'small' | 'tiny' | 'stretch_without_padding' | 'stretch' | string;
+            /** @deprecated */
             custom_width?: number;
+            /** @deprecated */
             compact_width?: boolean;
+            /** @deprecated */
             mode?: 'crop_center' | 'fit_horizontal' | 'large' | 'medium' | 'small' | 'tiny';
-            preview?: boolean;
         }
-        interface HorizontalRuleElement extends BaseElement<'hr'> {
+        interface HRElement extends BaseElement<'hr'> {
         }
         interface DivElement extends BaseElement<'div'> {
             text?: DivPlainTextElement;
@@ -194,13 +204,70 @@ export declare namespace MessageContent {
             text_align?: TextAlign;
             href?: Record<string, URLs>;
         }
-        interface HorizontalRuleElement extends BaseElement<'hr'> {
-        }
-        interface ActionModule extends BaseElement<'action'> {
-            actions: ActionElement[];
+        interface PersonElement extends BaseElement<'person'> {
+            user_id: string;
+            size?: 'large' | 'medium' | 'small' | 'extra_small';
+        }
+        interface PersonListElement extends BaseElement<'person_list'> {
+            persons: {
+                id: string;
+            }[];
+            size?: 'large' | 'medium' | 'small' | 'extra_small';
+            show_name?: boolean;
+            show_avatar?: boolean;
+        }
+        interface ChartElement extends BaseElement<'chart'> {
+            chart_spec: {};
+            aspect_ratio?: '1:1' | '2:1' | '4:3' | '16:9';
+            color_theme?: 'brand' | 'rainbow' | 'complementary' | 'converse' | 'primary';
+            preview?: boolean;
+            height?: 'auto' | string;
+        }
+        interface TableElement extends BaseElement<'table'> {
+            page_size?: number;
+            row_height?: 'low' | 'medium' | 'high' | string;
+            header_style?: TableElement.HeaderStyle;
+            columns: TableElement.Column[];
+            rows: object[];
+        }
+        namespace TableElement {
+            interface HeaderStyle {
+                text_align?: TextAlign;
+                text_size?: TextSize;
+                background_style?: 'grey' | 'none';
+                text_color?: 'default' | 'grey';
+                bold?: boolean;
+                lines?: number;
+            }
+            interface Column {
+                name: string;
+                display_name?: string;
+                width?: 'auto' | string;
+                horizontal_align?: 'left' | 'center' | 'right';
+                data_type?: 'text' | 'lark_md' | 'options' | 'number' | 'persons' | 'date' | 'markdown';
+                format?: {
+                    percision?: number;
+                    symbol?: string;
+                    separator?: string;
+                };
+                date_format?: string;
+            }
+        }
+        interface NoteElement extends BaseElement<'note'> {
+            elements: NoteElement.InnerElement[];
+        }
+        namespace NoteElement {
+            type InnerElement = IconElement | PlainTextElement | BaseImageElement;
+        }
+        interface FormElement extends BaseElement<'form'> {
+            name: string;
+            elements: Element[];
+            confirm?: ConfirmElement;
+        }
+        interface ActionElement extends BaseElement<'action'> {
+            actions: Element[];
             layout?: 'bisected' | 'trisection' | 'flow';
         }
-        type ActionElement = ButtonElement;
         type ActionBehavior = OpenURLBehavior | CallbackBehavior;
         interface OpenURLBehavior {
             type: 'open_url';
@@ -213,30 +280,148 @@ export declare namespace MessageContent {
             type: 'callback';
             value: Record<string, string>;
         }
-        interface ButtonElement extends BaseElement<'button'> {
+        interface BaseButtonElement extends BaseElement<'button'> {
             text: PlainTextElement;
-            type?: ButtonElement.Type;
             size?: ButtonElement.Size;
-            width?: ButtonElement.Width;
             icon?: IconElement;
-            hover_tips?: PlainTextElement;
             disabled?: boolean;
+            behaviors?: ActionBehavior[];
+        }
+        interface ButtonElement extends BaseButtonElement {
+            type?: ButtonElement.Type;
+            width?: ButtonElement.Width;
+            hover_tips?: PlainTextElement;
             disabled_tips?: PlainTextElement;
             confirm?: {
                 title: PlainTextElement;
                 text: PlainTextElement;
             };
-            behaviors?: ActionBehavior[];
             name?: string;
             required?: boolean;
             action_type?: 'link' | 'request' | 'multi' | 'form_submit' | 'form_reset';
         }
+        interface ConfirmElement {
+            title: PlainTextElement;
+            text: PlainTextElement;
+        }
+        interface InputElement extends BaseElement<'input'> {
+            name: string;
+            required?: boolean;
+            placeholder?: PlainTextElement;
+            default_value?: string;
+            disabled?: boolean;
+            width?: 'default' | 'fill' | string;
+            max_length?: number;
+            input_type?: 'text' | 'multiline_text' | 'password';
+            show_icon?: boolean;
+            rows?: number;
+            auto_resize?: boolean;
+            max_rows?: number;
+            label?: PlainTextElement;
+            label_position?: 'top' | 'left';
+            value?: string | object;
+            behaviors?: ActionBehavior[];
+            confirm?: ConfirmElement;
+            fallback?: {
+                tag?: string;
+                text?: PlainTextElement;
+            };
+        }
+        interface OverflowElement extends BaseElement<'overflow'> {
+            width?: 'default' | 'fill' | string;
+            options: OverflowElement.Option[];
+            value?: object;
+            confirm?: ConfirmElement;
+        }
+        namespace OverflowElement {
+            interface Option {
+                text?: PlainTextElement;
+                multi_url?: URLs;
+                value?: string;
+            }
+        }
+        interface BaseSelectElement<T extends string = string> extends BaseElement<T> {
+            type?: 'default' | 'text';
+            name?: string;
+            required?: boolean;
+            disabled?: boolean;
+            placeholder?: PlainTextElement;
+            width?: 'default' | 'fill' | string;
+            confirm?: ConfirmElement;
+        }
+        interface OptionElement {
+            text: PlainTextElement;
+            icon?: IconElement;
+            value: string;
+        }
+        interface SelectElement extends BaseSelectElement<'select_static'> {
+            options: OptionElement[];
+            initial_option?: string;
+        }
+        interface MultiSelectElement extends BaseSelectElement<'multi_select_static'> {
+            options: OptionElement[];
+            selected_values?: string[];
+        }
+        interface SelectPersonElement extends BaseSelectElement<'select_person'> {
+            options?: {
+                value: string;
+            }[];
+        }
+        interface MultiSelectPersonElement extends BaseSelectElement<'multi_select_person'> {
+            options?: {
+                value: string;
+            }[];
+            selected_values?: string[];
+        }
+        interface DatePickerElement extends BaseSelectElement<'date_picker'> {
+            initial_date?: string;
+            value?: object;
+        }
+        interface TimePickerElement extends BaseSelectElement<'picker_time'> {
+            initial_time?: string;
+            value?: object;
+        }
+        interface DateTimePickerElement extends BaseSelectElement<'picker_datetime'> {
+            initial_datetime?: string;
+            value?: object;
+        }
+        interface CheckerElement extends BaseElement<'checker'> {
+            name?: string;
+            checked?: boolean;
+            disabled?: boolean;
+            text?: CheckerElement.TextElement;
+            overall_checkable?: boolean;
+            button_area?: {
+                pc_display_rule?: 'always' | 'on_hover';
+                buttons?: CheckerElement.ButtonElement[];
+            };
+            checked_style?: {
+                show_strikethrough?: boolean;
+                opacity?: number;
+            };
+            margin?: string;
+            padding?: string;
+            confirm?: ConfirmElement;
+            behaviors?: ActionBehavior[];
+            hover_tips?: PlainTextElement;
+            disable_tips?: PlainTextElement;
+        }
+        namespace CheckerElement {
+            interface TextElement extends PlainTextElement {
+                text_size?: 'normal' | 'heading' | 'notation';
+                text_color?: string;
+                text_align?: TextAlign;
+            }
+            interface ButtonElement extends BaseButtonElement {
+                type: 'text' | 'primary_text' | 'danger_text';
+            }
+        }
         namespace ButtonElement {
             type Size = 'tiny' | 'small' | 'medium' | 'large';
             type Width = 'default' | 'fill' | string;
             type Type = 'default' | 'primary' | 'danger' | 'text' | 'primary_text' | 'danger_text' | 'primary_filled' | 'danger_filled' | 'laser';
         }
-        type Element = DivElement | MarkdownElement | HorizontalRuleElement | ActionModule;
+        type Element = DivElement | MarkdownElement | HRElement | ActionElement | NoteElement | ChartElement | TableElement | ImageElement | FormElement | InputElement | ButtonElement;
     }
     interface Template {
         type: 'template';

package/lib/types/message/index.d.ts

@@ -74,5 +74,21 @@ declare module '../event' {
                 open_chat_id: string;
             };
         };
+        /**
+         * 机器人自定义菜单事件
+         * @see https://open.feishu.cn/document/client-docs/bot-v3/events/menu
+         */
+        'application.bot.menu_v6': {
+            operator: {
+                operator_name: string;
+                operator_id: {
+                    union_id: string;
+                    user_id: string;
+                    open_id: string;
+                };
+            };
+            event_key: string;
+            timestamp: number;
+        };
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@satorijs/adapter-lark",
   "description": "Lark (飞书) Adapter for Satorijs",
-  "version": "3.6.1",
+  "version": "3.6.2",
   "type": "module",
   "main": "lib/index.cjs",
   "types": "lib/index.d.ts",
@@ -35,10 +35,10 @@
   ],
   "devDependencies": {
     "@cordisjs/plugin-server": "^0.2.4",
-    "@satorijs/core": "^4.2.9",
+    "@satorijs/core": "^4.2.10",
     "cordis": "^3.18.1"
   },
   "peerDependencies": {
-    "@satorijs/core": "^4.2.9"
+    "@satorijs/core": "^4.2.10"
   }
 }

package/src/message.ts

@@ -1,23 +1,27 @@
-import { Context, h, MessageEncoder } from '@satorijs/core'
+import { Context, Dict, h, MessageEncoder } from '@satorijs/core'
 import { LarkBot } from './bot'
 import { BaseResponse, Lark, MessageContent } from './types'
 import { extractIdType } from './utils'
 
 export class LarkMessageEncoder<C extends Context = Context> extends MessageEncoder<C, LarkBot<C>> {
-  private quote: string | undefined
+  private quote: Dict | undefined
   private textContent = ''
   private richContent: MessageContent.RichText.Paragraph[] = []
-  private cardElements: MessageContent.Card.Element[] | undefined
-  private actionElements: MessageContent.Card.ButtonElement[] = []
+  private card: MessageContent.Card | undefined
+  private noteElements: MessageContent.Card.NoteElement.InnerElement[] | undefined
+  private actionElements: MessageContent.Card.Element[] = []
 
   async post(data?: any) {
     try {
       let resp: BaseResponse & { data?: Lark.Message }
-      if (this.quote) {
-        resp = await this.bot.internal.replyImMessage(this.quote, data)
+      if (this.quote?.id) {
+        resp = await this.bot.internal.replyImMessage(this.quote.id, {
+          ...data,
+          reply_in_thread: this.quote.replyInThread,
+        })
       } else {
         data.receive_id = this.channelId
-        resp = await this.bot.internal?.createImMessage(data, {
+        resp = await this.bot.internal.createImMessage(data, {
           receive_id_type: extractIdType(this.channelId),
         })
       }
@@ -41,27 +45,32 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     }
   }
 
-  private flushText(flushAction = false) {
-    if ((this.textContent || flushAction) && this.actionElements.length) {
-      this.cardElements?.push({ tag: 'action', actions: this.actionElements })
+  private flushText(button = false) {
+    if ((this.textContent || !button) && this.actionElements.length) {
+      this.card!.elements.push({ tag: 'action', actions: this.actionElements, layout: 'flow' })
       this.actionElements = []
     }
     if (this.textContent) {
       this.richContent.push([{ tag: 'md', text: this.textContent }])
-      this.cardElements?.push({ tag: 'markdown', content: this.textContent })
+      if (this.noteElements) {
+        this.noteElements.push({ tag: 'plain_text', content: this.textContent })
+      } else if (this.card) {
+        this.card.elements.push({ tag: 'markdown', content: this.textContent })
+      }
       this.textContent = ''
     }
   }
 
   async flush() {
     this.flushText()
-    if (!this.cardElements && !this.richContent.length) return
+    if (!this.card && !this.richContent.length) return
 
-    if (this.cardElements) {
+    if (this.card) {
+      this.bot.logger.debug('card', JSON.stringify(this.card.elements))
       await this.post({
         msg_type: 'interactive',
         content: JSON.stringify({
-          elements: this.cardElements,
+          elements: this.card.elements,
         }),
       })
     } else {
@@ -79,7 +88,7 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     this.quote = undefined
     this.textContent = ''
     this.richContent = []
-    this.cardElements = undefined
+    this.card = undefined
   }
 
   async createImage(url: string) {
@@ -124,6 +133,27 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     })
   }
 
+  private createBehavior(attrs: Dict) {
+    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
+    }
+    return behaviors.length ? behaviors : undefined
+  }
+
   async visit(element: h) {
     const { type, attrs, children } = element
     if (type === 'text') {
@@ -147,7 +177,7 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
       // platform does not support sharp
     } else if (type === 'quote') {
       await this.flush()
-      this.quote = attrs.id
+      this.quote = attrs
     } else if (type === 'img' || type === 'image') {
       const image_key = await this.createImage(attrs.src || attrs.url)
       this.textContent += `![${attrs.alt ?? '图片'}](${image_key})`
@@ -162,26 +192,41 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
     } else if (type === 'hr') {
       this.flushText()
       this.richContent.push([{ tag: 'hr' }])
-      this.cardElements?.push({ tag: 'hr' })
-    } else if (type === 'button') {
+      this.card?.elements.push({ tag: 'hr' })
+    } else if (type === 'form') {
       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,
-          },
+      const length = this.card?.elements.length
+      await this.render(children)
+      if (this.card?.elements.length > length) {
+        const elements = this.card?.elements.slice(length)
+        this.card.elements.push({
+          tag: 'form',
+          name: attrs.name || 'Form',
+          elements,
         })
-      } else if (attrs.type === 'action') {
-        // TODO
       }
+    } else if (type === 'input') {
+      this.flushText()
+      this.card?.elements.push({
+        tag: 'action',
+        actions: [{
+          tag: 'input',
+          name: attrs.name,
+          width: attrs.width,
+          label: attrs.label && {
+            tag: 'plain_text',
+            content: attrs.label,
+          },
+          placeholder: attrs.placeholder && {
+            tag: 'plain_text',
+            content: attrs.placeholder,
+          },
+          behaviors: this.createBehavior(attrs),
+        }],
+      })
+    } else if (type === 'button') {
+      this.card ??= { elements: [] }
+      this.flushText(true)
       await this.render(children)
       this.actionElements.push({
         tag: 'button',
@@ -189,13 +234,14 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
           tag: 'plain_text',
           content: this.textContent,
         },
-        behaviors,
+        disabled: attrs.disabled,
+        behaviors: this.createBehavior(attrs),
       })
       this.textContent = ''
     } else if (type === 'button-group') {
-      this.flushText(true)
+      this.flushText()
       await this.render(children)
-      this.flushText(true)
+      this.flushText()
     } else if (type.startsWith('lark:') || type.startsWith('feishu:')) {
       const tag = type.slice(type.split(':', 1)[0].length + 1)
       if (tag === 'share-chat') {
@@ -224,18 +270,51 @@ export class LarkMessageEncoder<C extends Context = Context> extends MessageEnco
         this.textContent = ''
       } else if (tag === 'card') {
         await this.flush()
-        this.cardElements = []
+        this.card = {
+          elements: [],
+          header: attrs.title && {
+            template: attrs.color,
+            ud_icon: attrs.icon && {
+              tag: 'standard_icon',
+              token: attrs.icon,
+            },
+            title: {
+              tag: 'plain_text',
+              content: attrs.title,
+            },
+            subtitle: attrs.subtitle && {
+              tag: 'plain_text',
+              content: attrs.subtitle,
+            },
+          },
+        }
         await this.render(children, true)
       } else if (tag === 'div') {
         this.flushText()
         await this.render(children)
-        this.cardElements?.push({
+        this.card?.elements.push({
           tag: 'markdown',
           text_align: attrs.align,
           text_size: attrs.size,
           content: this.textContent,
         })
         this.textContent = ''
+      } else if (tag === 'note') {
+        this.flushText()
+        this.noteElements = []
+        await this.render(children)
+        this.flushText()
+        this.card?.elements.push({
+          tag: 'note',
+          elements: this.noteElements,
+        })
+        this.noteElements = undefined
+      } else if (tag === 'icon') {
+        this.flushText()
+        this.noteElements?.push({
+          tag: 'standard_icon',
+          token: attrs.token,
+        })
       }
     } else {
       await this.render(children)

package/src/types/api.ts

@@ -16681,6 +16681,8 @@ export interface ReplyImMessageRequest {
   content: string
   /** 消息类型，包括：text、post、image、file、audio、media、sticker、interactive、share_card、share_user */
   msg_type: string
+  /** 是否以话题形式回复。取值为 true 时将以话题形式回复。注意：如果要回复的消息已经是话题形式的消息，则默认以话题形式进行回复。 */
+  reply_in_thread?: boolean
   /** 由开发者生成的唯一字符串序列，用于回复消息请求去重；持有相同uuid的请求1小时内至多成功执行一次 */
   uuid?: string
 }