@satorijs/adapter-lark 3.6.0 → 3.6.1

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,198 @@ 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;
+        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 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;
+        }
+        interface HorizontalRuleElement 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 HorizontalRuleElement extends BaseElement<'hr'> {
+        }
+        interface ActionModule extends BaseElement<'action'> {
+            actions: ActionElement[];
+            layout?: 'bisected' | 'trisection' | 'flow';
+        }
+        type ActionElement = ButtonElement;
+        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 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[];
+            name?: string;
+            required?: boolean;
+            action_type?: 'link' | 'request' | 'multi' | 'form_submit' | 'form_reset';
+        }
+        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;
+    }
+    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;

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.1",
   "type": "module",
   "main": "lib/index.cjs",
   "types": "lib/index.d.ts",

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
     })