@satorijs/adapter-lark 3.6.0 → 3.6.2

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

@@ -1,6 +1,31 @@
+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 declare namespace MessageContent {
-    type Contents = Text | Image | ShareChat | ShareUser | Audio | Media | File | Sticker | RichText;
-    type MediaContents = Image | Audio | Media | File;
     interface Text {
         text: string;
     }
@@ -18,7 +43,7 @@ export declare namespace MessageContent {
     }
     interface Media {
         file_key: string;
-        image_key: string;
+        image_key?: string;
     }
     interface File {
         file_key: string;
@@ -26,44 +51,383 @@ export declare namespace MessageContent {
     interface Sticker {
         file_key: string;
     }
+    interface System {
+        type: 'divider';
+        params: {
+            divider_text: {
+                text: string;
+                i18n_text?: Record<string, string>;
+            };
+        };
+        options?: {
+            need_rollup?: boolean;
+        };
+    }
     interface RichText {
         [locale: string]: {
-            title: string;
+            title?: string;
             content: RichText.Paragraph[];
         };
     }
     namespace RichText {
-        interface Paragraph extends Array<RichText.Content> {
-        }
-        interface BaseContent {
-            tag: string;
+        type Style = 'bold' | 'italic' | 'underline' | 'lineThrough';
+        interface BaseElement<T extends string = string> {
+            tag: T;
         }
-        interface TextContent extends BaseContent {
-            tag: 'text';
+        interface TextElement extends BaseElement<'text'> {
             text: string;
             un_escape?: boolean;
+            style?: Style[];
         }
-        interface LinkContent extends BaseContent {
-            tag: 'a';
+        interface LinkElement extends BaseElement<'a'> {
             text: string;
             href: string;
+            style?: Style[];
         }
-        interface AtContent extends BaseContent {
-            tag: 'at';
+        interface AtElement extends BaseElement<'at'> {
             user_id: string;
-            user_name?: string;
+            style?: Style[];
         }
-        interface ImageContent extends BaseContent {
-            tag: 'img';
+        interface ImageElement extends BaseElement<'img'> {
             image_key: string;
-            height?: number;
-            width?: number;
         }
-        interface MediaContent extends BaseContent {
-            tag: 'media';
+        interface MediaElement extends BaseElement<'media'> {
             file_key: string;
             image_key?: string;
         }
-        type Content = RichText.TextContent | RichText.LinkContent | RichText.AtContent | RichText.ImageContent | RichText.MediaContent;
+        interface EmotionElement extends BaseElement<'emoji'> {
+            emoji_type: string;
+        }
+        interface CodeBlockElement extends BaseElement<'code_block'> {
+            language?: string;
+            text: string;
+        }
+        interface HRElement extends BaseElement<'hr'> {
+        }
+        interface MarkdownElement extends BaseElement<'md'> {
+            text: string;
+        }
+        type InlineElement = TextElement | LinkElement | AtElement | EmotionElement | MarkdownElement;
+        type BlockElement = ImageElement | MediaElement | CodeBlockElement | HRElement;
+        type Paragraph = InlineElement[] | [BlockElement];
+    }
+    interface Card {
+        config?: Card.Config;
+        card_link?: Card.URLs;
+        header?: Card.Header;
+        elements: Card.Element[];
+    }
+    namespace Card {
+        /** @see https://open.larksuite.com/document/common-capabilities/message-card/getting-started/card-structure/card-configuration */
+        interface Config {
+            enable_forward?: boolean;
+            update_multi?: boolean;
+        }
+        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 */
+        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[]>;
+        }
+        namespace Header {
+            type Template = 'blue' | 'wathet' | 'turquoise' | 'green' | 'yellow' | 'orange' | 'red' | 'carmine' | 'violet' | 'purple' | 'indigo' | 'grey' | 'default';
+        }
+        interface BaseElement<T extends string = string> {
+            tag: T;
+        }
+        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';
+        type TextAlign = 'left' | 'center' | 'right';
+        interface PlainTextElement extends BaseElement<'plain_text'> {
+            content: string;
+        }
+        interface I18nPlainTextElement extends PlainTextElement {
+            i18n?: Record<string, string>;
+        }
+        interface DivPlainTextElement extends PlainTextElement {
+            text_size?: TextSize;
+            text_color?: string;
+            text_align?: TextAlign;
+            lines?: number;
+            icon?: IconElement;
+        }
+        type IconElement = StandardIconElement | CustomIconElement;
+        interface CustomIconElement extends BaseElement<'custom_icon'> {
+            img_key: string;
+        }
+        interface StandardIconElement extends BaseElement<'standard_icon'> {
+            token: string;
+            color?: string;
+        }
+        interface TextTagElement extends BaseElement<'text_tag'> {
+            text: PlainTextElement;
+            color: TextTagElement.Color;
+        }
+        namespace TextTagElement {
+            type Color = 'neutral' | 'blue' | 'torqoise' | 'lime' | 'orange' | 'violet' | 'indigo' | 'wathet' | 'green' | 'yellow' | 'red' | 'purple' | 'carmine';
+        }
+        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';
+        }
+        interface HRElement extends BaseElement<'hr'> {
+        }
+        interface DivElement extends BaseElement<'div'> {
+            text?: DivPlainTextElement;
+        }
+        interface MarkdownElement extends BaseElement<'markdown'> {
+            content: string;
+            text_size?: TextSize;
+            text_align?: TextAlign;
+            href?: Record<string, URLs>;
+        }
+        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 ActionBehavior = OpenURLBehavior | CallbackBehavior;
+        interface OpenURLBehavior {
+            type: 'open_url';
+            default_url: string;
+            pc_url?: string;
+            ios_url?: string;
+            android_url?: string;
+        }
+        interface CallbackBehavior {
+            type: 'callback';
+            value: Record<string, string>;
+        }
+        interface BaseButtonElement extends BaseElement<'button'> {
+            text: PlainTextElement;
+            size?: ButtonElement.Size;
+            icon?: IconElement;
+            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;
+            };
+            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 | HRElement | ActionElement | NoteElement | ChartElement | TableElement | ImageElement | FormElement | InputElement | ButtonElement;
+    }
+    interface Template {
+        type: 'template';
+        data: {
+            template_id: string;
+            template_variable: object;
+        };
     }
 }

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

@@ -1,19 +1,5 @@
-import { Lark } from '..';
-import { MessageContent } from './content';
+import { Lark, MessageContent } from '..';
 export * from './content';
-export type MessageType = 'text' | 'post' | 'image' | 'file' | 'audio' | 'media' | 'sticker' | 'interactive' | 'share_chat' | 'share_user';
-export interface MessageContentMap {
-    '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;
-}
-export type MessageContentType<T extends MessageType> = T extends keyof MessageContentMap ? MessageContentMap[T] : any;
 declare module '../event' {
     interface Events {
         /**
@@ -33,7 +19,7 @@ declare module '../event' {
                 create_time: string;
                 chat_id: string;
                 chat_type: string;
-                message_type: MessageType;
+                message_type: keyof MessageContent;
                 content: string;
                 mentions: {
                     key: string;
@@ -88,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/lib/utils.d.ts

@@ -1,5 +1,5 @@
 import { Context, Session, Universal } from '@satorijs/core';
-import { FeishuBot, LarkBot } from './bot';
+import { LarkBot } from './bot';
 import { EventPayload, Events, GetImChatResponse, Lark } from './types';
 export type Sender = {
     sender_id: Lark.UserIds;
@@ -10,8 +10,8 @@ export type Sender = {
     tenant_key: string;
 });
 export declare function adaptSender(sender: Sender, session: Session): Session;
-export declare function adaptMessage(bot: FeishuBot, data: Events['im.message.receive_v1'], session: Session, details?: boolean): Promise<Session>;
-export declare function adaptSession<C extends Context>(bot: FeishuBot<C>, body: EventPayload): Promise<C[typeof import("cordis").Context.session]>;
+export declare function adaptMessage(bot: LarkBot, data: Events['im.message.receive_v1'], session: Session, details?: boolean): Promise<Session>;
+export declare function adaptSession<C extends Context>(bot: LarkBot<C>, body: EventPayload): Promise<C[typeof import("cordis").Context.session]>;
 export declare function decodeMessage(bot: LarkBot, body: Lark.Message, details?: boolean): Promise<Universal.Message>;
 /**
  * Get ID type from id string

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@satorijs/adapter-lark",
   "description": "Lark (飞书) Adapter for Satorijs",
-  "version": "3.6.0",
+  "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/http.ts

@@ -3,29 +3,29 @@ import { ReadableStream } from 'node:stream/web'
 import { Adapter, Context, Logger, Schema } from '@satorijs/core'
 import {} from '@cordisjs/plugin-server'
 
-import { FeishuBot } from './bot'
+import { LarkBot } from './bot'
 import { EventPayload } from './types'
 import { adaptSession, Cipher } from './utils'
 
-export class HttpServer<C extends Context = Context> extends Adapter<C, FeishuBot<C>> {
+export class HttpServer<C extends Context = Context> extends Adapter<C, LarkBot<C>> {
   static inject = ['server']
 
   private logger: Logger
   private ciphers: Record<string, Cipher> = {}
 
-  constructor(ctx: C, bot: FeishuBot<C>) {
+  constructor(ctx: C, bot: LarkBot<C>) {
     super(ctx)
     this.logger = ctx.logger('lark')
   }
 
-  fork(ctx: C, bot: FeishuBot<C>) {
+  fork(ctx: C, bot: LarkBot<C>) {
     super.fork(ctx, bot)
 
     this._refreshCipher()
     return bot.initialize()
   }
 
-  async connect(bot: FeishuBot) {
+  async connect(bot: LarkBot) {
     const { path } = bot.config
     bot.ctx.server.post(path, (ctx) => {
       this._refreshCipher()
@@ -72,10 +72,10 @@ export class HttpServer<C extends Context = Context> extends Adapter<C, FeishuBo
 
       // dispatch message
       bot.logger.debug('received decryped event: %o', body)
-      // @TODO: need await?
       this.dispatchSession(body)
 
       // Lark requires 200 OK response to make sure event is received
+      ctx.body = {}
       return ctx.status = 200
     })