alemonjs 2.1.22 → 2.1.24

package/lib/app/hook-use-api.d.ts

@@ -25,7 +25,7 @@ export declare const useMessage: <T extends EventKeys>(event: Events[T]) => read
     addLink(val: string, options?: {
         style?: "none" | "bold" | "block" | "strikethrough" | "boldItalic" | "italic";
     }): any;
-    addImage(val: Buffer<ArrayBufferLike>): any;
+    addImage(val: string | Buffer<ArrayBufferLike>): any;
     addImageFile(val: string): any;
     addImageURL(val: string): any;
     addMention(UserId?: string, options?: {

package/lib/app/index.js

@@ -19,4 +19,4 @@ export { onState, unState, useState } from './hook-use-state.js';
 export { useObserver, useSubscribe } from './hook-use-subscribe.js';
 export { createDataFormat, createEventValue, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
 export { Format, createEvent } from './message-format.js';
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text } from './message-format-old.js';
+export { Ark, Attachment, Audio, BT, Custom, Image, ImageFile, ImageURL, Link, MD, Markdown, Mention, Text, Video } from './message-format-old.js';

package/lib/app/message-format-old.d.ts

@@ -1,10 +1,11 @@
-import { DataMention, DataImage, DataText, DataImageURL, DataImageFile, ButtonRow, DataButtonGroup, DataButton, DataArkList, DataArkListTip, DataArkListContent, DataArkListItem, DataArkCard, DataArkBigCard, DataMarkdownTemplate, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownBold, DataMarkdownItalic, DataMarkdownItalicStar, DataMarkdownStrikethrough, DataMarkdownLink, DataMarkdownImage, DataMarkdownList, DataMarkdownListItem, DataMarkdownBlockquote, DataMarkdownDivider, DataMarkdownNewline, DataLink, DataMarkdownText, DataButtonTemplate, DataMarkdownCode } from '../types';
+import { DataMention, DataImage, DataText, DataImageURL, DataImageFile, ButtonRow, DataButtonGroup, DataButton, DataArkList, DataArkListTip, DataArkListContent, DataArkListItem, DataArkCard, DataArkBigCard, DataMarkdownTemplate, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownBold, DataMarkdownItalic, DataMarkdownItalicStar, DataMarkdownStrikethrough, DataMarkdownLink, DataMarkdownImage, DataMarkdownList, DataMarkdownListItem, DataMarkdownBlockquote, DataMarkdownDivider, DataMarkdownNewline, DataLink, DataMarkdownText, DataButtonTemplate, DataMarkdownCode, DataCustom, DataMarkdownOriginal, DataAttachment, DataAudio, DataVideo } from '../types';
+export declare const Custom: (value: DataCustom["value"], options?: DataCustom["options"], type?: DataCustom["type"]) => DataCustom;
 export declare const Text: (val: DataText["value"], options?: DataText["options"]) => DataText;
 export declare const Link: (val: DataLink["value"], options?: DataText["options"]) => DataText;
 export declare const ImageURL: (val: DataImageURL["value"]) => DataImageURL;
 export declare const ImageFile: (val: DataImageFile["value"]) => DataImageFile;
 declare const Image: {
-    (val: Buffer): DataImage;
+    (val: Buffer | string): DataImage;
     url: (val: DataImageURL["value"]) => DataImageURL;
     file: (val: DataImageFile["value"]) => DataImageFile;
 };
@@ -48,3 +49,7 @@ declare const MD: {
     code(value: DataMarkdownCode["value"], options?: DataMarkdownCode["options"]): DataMarkdownCode;
 };
 export { MD };
+export declare const Markdown: (val: string) => DataMarkdownOriginal;
+export declare const Attachment: (val: string, options?: DataAttachment["options"]) => DataAttachment;
+export declare const Audio: (val: string) => DataAudio;
+export declare const Video: (val: string) => DataVideo;

package/lib/app/message-format-old.js

@@ -1,3 +1,10 @@
+const Custom = (value, options, type) => {
+    return {
+        type: type,
+        value,
+        options
+    };
+};
 const Text = (val, options) => {
     return {
         type: 'Text',
@@ -27,7 +34,7 @@ const ImageFile = (val) => {
 const Image = (val) => {
     return {
         type: 'Image',
-        value: val.toString('base64')
+        value: typeof val === 'string' ? val : `base64://${val.toString('base64')}`
     };
 };
 Image.url = ImageURL;
@@ -213,5 +220,30 @@ MD.code = (value, options) => {
         options: options
     };
 };
+const Markdown = (val) => {
+    return {
+        type: 'MarkdownOriginal',
+        value: val
+    };
+};
+const Attachment = (val, options) => {
+    return {
+        type: 'Attachment',
+        value: val,
+        options
+    };
+};
+const Audio = (val) => {
+    return {
+        type: 'Audio',
+        value: val
+    };
+};
+const Video = (val) => {
+    return {
+        type: 'Video',
+        value: val
+    };
+};
 
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text };
+export { Ark, Attachment, Audio, BT, Custom, Image, ImageFile, ImageURL, Link, MD, Markdown, Mention, Text, Video };

package/lib/app/message-format.d.ts

@@ -1,5 +1,5 @@
 import { DataButtonGroup, DataMarkDown, DataEnums, EventKeys, Events } from '../types';
-import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD } from './message-format-old.js';
+import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD, Markdown, Attachment, Audio, Video, Custom } from './message-format-old.js';
 export * from './message-format-old.js';
 declare class FormatButtonGroup {
     #private;
@@ -45,6 +45,11 @@ export declare class Format {
     addButtonGroup(...args: Parameters<typeof BT.group>): this;
     addMarkdown(md: FormatMarkDown): this;
     addMarkdown(...args: Parameters<typeof MD>): this;
+    addMarkdownOriginal(...args: Parameters<typeof Markdown>): this;
+    addAttachment(...args: Parameters<typeof Attachment>): this;
+    addAudio(...args: Parameters<typeof Audio>): this;
+    addVideo(...args: Parameters<typeof Video>): this;
+    addCustom(...args: Parameters<typeof Custom>): this;
     clear(): this;
 }
 export declare function createEvent<T extends EventKeys>(options: {

package/lib/app/message-format.js

@@ -1,4 +1,4 @@
-import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD } from './message-format-old.js';
+import { Text, Link, Image, ImageFile, ImageURL, Mention, BT, MD, Markdown, Attachment, Audio, Video, Custom } from './message-format-old.js';
 export { Ark } from './message-format-old.js';
 
 class FormatButtonGroup {
@@ -162,6 +162,26 @@ class Format {
         }
         return this;
     }
+    addMarkdownOriginal(...args) {
+        this.#data.push(Markdown(...args));
+        return this;
+    }
+    addAttachment(...args) {
+        this.#data.push(Attachment(...args));
+        return this;
+    }
+    addAudio(...args) {
+        this.#data.push(Audio(...args));
+        return this;
+    }
+    addVideo(...args) {
+        this.#data.push(Video(...args));
+        return this;
+    }
+    addCustom(...args) {
+        this.#data.push(Custom(...args));
+        return this;
+    }
     clear() {
         this.#data = [];
         return this;
@@ -192,4 +212,4 @@ function createEvent(options) {
     return { ...event, ...o };
 }
 
-export { BT, Format, Image, ImageFile, ImageURL, Link, MD, Mention, Text, createEvent };
+export { Attachment, Audio, BT, Custom, Format, Image, ImageFile, ImageURL, Link, MD, Markdown, Mention, Text, Video, createEvent };

package/lib/core/config.d.ts

@@ -1,19 +1,21 @@
 import type { Package } from '../types';
-export declare class ConfigCore {
+type ConfigValue = {
+    [key: string]: any;
+};
+type ConfigListener<T extends ConfigValue = ConfigValue> = (value: T) => void;
+declare class ConfigCore<T extends ConfigValue = ConfigValue> {
     #private;
     constructor(dir: string);
-    get value(): null | {
-        [key: string]: any;
-    };
-    saveValue(value: {
-        [key: string]: any;
-    }): void;
-    get package(): null | Package;
+    get value(): T | null;
+    saveValue(value: T): void;
+    onWatch(listener: ConfigListener<T>): () => void;
+    dispose(): void;
+    get package(): Package | null;
     get argv(): {
         [key: string]: string;
     };
 }
-export declare const getConfig: () => typeof ConfigCore.prototype;
-export declare const getConfigValue: () => {
-    [key: string]: any;
-};
+export declare const getConfig: <T extends ConfigValue = ConfigValue>() => ConfigCore<T>;
+export declare const getConfigValue: <T extends ConfigValue = ConfigValue>() => T;
+export declare const onWatchConfigValue: <T extends ConfigValue = ConfigValue>(callback: ConfigListener<T>) => (() => void);
+export {};

package/lib/core/config.js

@@ -1,38 +1,31 @@
-import { existsSync, readFileSync, watch, mkdirSync, writeFileSync } from 'fs';
+import { readFileSync, existsSync, watch, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import YAML from 'yaml';
 import { ResultCode } from './variable.js';
 
 class ConfigCore {
-    #dir = null;
     #value = null;
     #mergedValue = null;
     #watcher = null;
-    #initValue = {
-        gui: {
-            port: 17127
-        }
-    };
+    #listeners = new Set();
+    #debounceTimer = null;
+    #debounceDelay = 100;
+    #argvProxy = null;
+    #resolvedDir = null;
+    #initValue = {};
     constructor(dir) {
-        this.#dir = dir;
+        this.#resolvedDir = join(process.cwd(), dir);
     }
     #invalidateMergedCache() {
         this.#mergedValue = null;
     }
-    #update() {
-        if (!this.#dir) {
-            return this.#value;
-        }
-        const dir = join(process.cwd(), this.#dir);
-        if (!existsSync(dir)) {
-            this.saveValue(this.#initValue);
-            return this.#value;
+    #readConfig() {
+        if (!this.#resolvedDir) {
+            return null;
         }
         try {
-            const data = readFileSync(dir, 'utf-8');
-            const d = YAML.parse(data);
-            this.#value = d;
-            this.#invalidateMergedCache();
+            const data = readFileSync(this.#resolvedDir, 'utf-8');
+            return YAML.parse(data);
         }
         catch (err) {
             logger.error({
@@ -40,31 +33,69 @@ class ConfigCore {
                 message: 'Config file parse error',
                 data: err
             });
+            return null;
         }
-        if (this.#watcher) {
-            this.#watcher.close();
-            this.#watcher = null;
+    }
+    #applyValue(newValue) {
+        if (newValue === null) {
+            return;
+        }
+        this.#value = newValue;
+        this.#invalidateMergedCache();
+    }
+    #notifyListeners() {
+        if (this.#debounceTimer) {
+            clearTimeout(this.#debounceTimer);
         }
-        this.#watcher = watch(dir, () => {
-            try {
-                const data = readFileSync(dir, 'utf-8');
-                const d = YAML.parse(data);
-                this.#value = d;
-                this.#invalidateMergedCache();
+        this.#debounceTimer = setTimeout(() => {
+            this.#debounceTimer = null;
+            const val = this.value;
+            if (!val) {
+                return;
+            }
+            for (const listener of this.#listeners) {
+                try {
+                    listener(val);
+                }
+                catch (err) {
+                    logger.error({
+                        code: ResultCode.FailInternal,
+                        message: 'Config listener error',
+                        data: err
+                    });
+                }
             }
-            catch (err) {
-                logger.error({
-                    code: ResultCode.FailInternal,
-                    message: 'Config file parse error',
-                    data: err
-                });
+        }, this.#debounceDelay);
+    }
+    #ensureWatcher() {
+        if (this.#watcher || !this.#resolvedDir) {
+            return;
+        }
+        if (!existsSync(this.#resolvedDir)) {
+            return;
+        }
+        this.#watcher = watch(this.#resolvedDir, () => {
+            const newValue = this.#readConfig();
+            if (newValue !== null) {
+                this.#applyValue(newValue);
+                this.#notifyListeners();
             }
         });
-        return this.#value;
+    }
+    #init() {
+        if (!this.#resolvedDir) {
+            return;
+        }
+        if (!existsSync(this.#resolvedDir)) {
+            this.saveValue(this.#initValue);
+            return;
+        }
+        this.#applyValue(this.#readConfig());
+        this.#ensureWatcher();
     }
     get value() {
         if (!this.#value) {
-            this.#update();
+            this.#init();
         }
         if (this.#mergedValue) {
             return this.#mergedValue;
@@ -76,15 +107,40 @@ class ConfigCore {
         return this.#mergedValue;
     }
     saveValue(value) {
-        if (!this.#dir) {
+        if (!this.#resolvedDir) {
             return;
         }
-        const dir = join(process.cwd(), this.#dir);
-        if (!existsSync(dir)) {
-            mkdirSync(dirname(dir), { recursive: true });
+        const dirPath = dirname(this.#resolvedDir);
+        if (!existsSync(this.#resolvedDir)) {
+            mkdirSync(dirPath, { recursive: true });
         }
         const data = YAML.stringify(value);
-        writeFileSync(dir, data, 'utf-8');
+        writeFileSync(this.#resolvedDir, data, 'utf-8');
+        this.#applyValue(value);
+        this.#ensureWatcher();
+    }
+    onWatch(listener) {
+        this.#listeners.add(listener);
+        if (!this.#value) {
+            this.#init();
+        }
+        else {
+            this.#ensureWatcher();
+        }
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    dispose() {
+        if (this.#watcher) {
+            this.#watcher.close();
+            this.#watcher = null;
+        }
+        if (this.#debounceTimer) {
+            clearTimeout(this.#debounceTimer);
+            this.#debounceTimer = null;
+        }
+        this.#listeners.clear();
     }
     #package = null;
     get package() {
@@ -100,8 +156,8 @@ class ConfigCore {
             });
             return null;
         }
-        const data = readFileSync(dir, 'utf-8');
         try {
+            const data = readFileSync(dir, 'utf-8');
             this.#package = JSON.parse(data);
         }
         catch (err) {
@@ -115,8 +171,10 @@ class ConfigCore {
         return this.#package;
     }
     get argv() {
-        const argv = {};
-        return new Proxy(argv, {
+        if (this.#argvProxy) {
+            return this.#argvProxy;
+        }
+        this.#argvProxy = new Proxy({}, {
             get(_target, key) {
                 if (typeof key === 'symbol') {
                     return undefined;
@@ -132,6 +190,7 @@ class ConfigCore {
                 return null;
             }
         });
+        return this.#argvProxy;
     }
 }
 const getConfig = () => {
@@ -142,6 +201,11 @@ const getConfig = () => {
     global.__config = new ConfigCore(configDir);
     return global.__config;
 };
-const getConfigValue = () => getConfig()?.value || {};
+const getConfigValue = () => {
+    return (getConfig()?.value || {});
+};
+const onWatchConfigValue = (callback) => {
+    return getConfig().onWatch(callback);
+};
 
-export { ConfigCore, getConfig, getConfigValue };
+export { getConfig, getConfigValue, onWatchConfigValue };

package/lib/core/index.js

@@ -1,3 +1,3 @@
 export { ResultCode } from './variable.js';
-export { ConfigCore, getConfig, getConfigValue } from './config.js';
+export { getConfig, getConfigValue, onWatchConfigValue } from './config.js';
 export { createEventName, createHash, createResult, getInputExportPath, getRecursiveDirFiles, showErrorModule, stringToNumber, useUserHashKey } from './utils.js';

package/lib/index.js

@@ -1,6 +1,6 @@
 export { ActionsEventEnum } from './types/event/actions.js';
 export { ResultCode } from './core/variable.js';
-export { ConfigCore, getConfig, getConfigValue } from './core/config.js';
+export { getConfig, getConfigValue, onWatchConfigValue } from './core/config.js';
 export { createEventName, createHash, createResult, getInputExportPath, getRecursiveDirFiles, showErrorModule, stringToNumber, useUserHashKey } from './core/utils.js';
 export { cbpClient } from './cbp/connects/client.js';
 export { cbpPlatform } from './cbp/connects/platform.js';
@@ -27,4 +27,4 @@ export { useObserver, useSubscribe } from './app/hook-use-subscribe.js';
 export { createDataFormat, createEventValue, format, getMessageIntent, sendToChannel, sendToUser } from './app/message-api.js';
 export { Format, createEvent } from './app/message-format.js';
 export { start } from './main.js';
-export { Ark, BT, Image, ImageFile, ImageURL, Link, MD, Mention, Text } from './app/message-format-old.js';
+export { Ark, Attachment, Audio, BT, Custom, Image, ImageFile, ImageURL, Link, MD, Markdown, Mention, Text, Video } from './app/message-format-old.js';

package/lib/jsx/index.d.ts

@@ -0,0 +1,105 @@
+import { DataText, DataLink, DataImage, DataImageURL, DataImageFile, DataMention, DataButton, ButtonRow, DataButtonGroup, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownText, DataMarkdownBold, DataMarkdownCode } from '../types/index.js';
+export interface FormatProps {
+    name?: string;
+    children?: any;
+    [key: string]: any;
+}
+export interface TextProps {
+    children?: any;
+    style?: DataText['options']['style'];
+}
+export interface LinkProps {
+    children?: any;
+    link: string;
+}
+export interface ImageProps {
+    children?: Buffer;
+}
+export interface ImageURLProps {
+    children?: string;
+}
+export interface ImageFileProps {
+    children?: string;
+}
+export interface MentionProps {
+    children?: string;
+    belong?: 'user' | 'guild' | 'channel' | 'everyone';
+    payload?: any;
+}
+export interface ButtonProps {
+    children?: any;
+    data?: DataButton['options']['data'];
+    command?: string;
+    toolTip?: string;
+    autoEnter?: boolean;
+    showList?: boolean;
+    type?: 'command' | 'link' | 'call';
+}
+export interface RowProps {
+    children?: any;
+}
+export interface ButtonGroupProps {
+    children?: any;
+}
+export interface MarkdownProps {
+    children?: any;
+}
+export interface MarkdownTitleProps {
+    children?: any;
+}
+export interface MarkdownSubtitleProps {
+    children?: any;
+}
+export interface MarkdownTextProps {
+    children?: any;
+}
+export interface MarkdownBoldProps {
+    children?: any;
+}
+export interface MarkdownCodeProps {
+    children?: any;
+    language?: string;
+}
+export interface CustomProps {
+    name: string;
+    children?: any;
+    [key: string]: any;
+}
+declare function FormatComponent(props: FormatProps): any;
+declare namespace FormatComponent {
+    var Text: typeof FormatText;
+    var Link: typeof FormatLink;
+    var Image: typeof FormatImage;
+    var ImageURL: typeof FormatImageURL;
+    var ImageFile: typeof FormatImageFile;
+    var Mention: typeof FormatMention;
+    var Button: typeof FormatButton;
+    var Row: typeof FormatRow;
+    var ButtonGroup: typeof FormatButtonGroup;
+    var Markdown: typeof FormatMarkdown;
+    var Custom: typeof FormatCustomComponent;
+}
+declare function FormatText(props: TextProps): DataText;
+declare function FormatLink(props: LinkProps): DataLink;
+declare function FormatImage(props: ImageProps): DataImage;
+declare function FormatImageURL(props: ImageURLProps): DataImageURL;
+declare function FormatImageFile(props: ImageFileProps): DataImageFile;
+declare function FormatMention(props: MentionProps): DataMention;
+declare function FormatButton(props: ButtonProps): DataButton;
+declare function FormatRow(props: RowProps): ButtonRow;
+declare function FormatButtonGroup(props: ButtonGroupProps): DataButtonGroup;
+declare function FormatMarkdownTitle(props: MarkdownTitleProps): DataMarkdownTitle;
+declare function FormatMarkdownSubtitle(props: MarkdownSubtitleProps): DataMarkdownSubtitle;
+declare function FormatMarkdownText(props: MarkdownTextProps): DataMarkdownText;
+declare function FormatMarkdownBold(props: MarkdownBoldProps): DataMarkdownBold;
+declare function FormatMarkdownCode(props: MarkdownCodeProps): DataMarkdownCode;
+declare function FormatMarkdown(props: MarkdownProps): DataMarkDown;
+declare namespace FormatMarkdown {
+    var Title: typeof FormatMarkdownTitle;
+    var Subtitle: typeof FormatMarkdownSubtitle;
+    var Text: typeof FormatMarkdownText;
+    var Bold: typeof FormatMarkdownBold;
+    var Code: typeof FormatMarkdownCode;
+}
+declare function FormatCustomComponent(props: CustomProps): any;
+export { FormatComponent as Component, FormatCustomComponent as Custom };

package/lib/jsx/index.js

@@ -0,0 +1,211 @@
+function childrenToString(children) {
+    if (children === null || children === undefined) {
+        return '';
+    }
+    if (typeof children === 'string') {
+        return children;
+    }
+    if (typeof children === 'number' || typeof children === 'boolean') {
+        return String(children);
+    }
+    if (Array.isArray(children)) {
+        return children.map(childrenToString).join('');
+    }
+    return String(children);
+}
+function flattenChildren(children) {
+    if (children === null || children === undefined) {
+        return [];
+    }
+    if (Array.isArray(children)) {
+        const result = [];
+        for (const child of children) {
+            if (Array.isArray(child)) {
+                result.push(...flattenChildren(child));
+            }
+            else if (child !== null && child !== undefined && typeof child === 'object' && 'type' in child) {
+                result.push(child);
+            }
+        }
+        return result;
+    }
+    if (typeof children === 'object' && children !== null && children !== undefined && 'type' in children) {
+        return [children];
+    }
+    return [];
+}
+function collectChildren(children, typeCheck) {
+    const flat = flattenChildren(children);
+    return flat.filter(c => c.type === typeCheck);
+}
+function extractOptions(props, excludeKeys = []) {
+    const exclude = new Set(['children', ...excludeKeys]);
+    const options = {};
+    let hasKeys = false;
+    for (const key of Object.keys(props)) {
+        if (!exclude.has(key)) {
+            options[key] = props[key];
+            hasKeys = true;
+        }
+    }
+    return hasKeys ? options : undefined;
+}
+function FormatComponent(props) {
+    if (props.name !== undefined) {
+        const { name, children, ...rest } = props;
+        const options = Object.keys(rest).length > 0 ? rest : undefined;
+        return {
+            type: name,
+            value: children !== null && children !== undefined ? childrenToString(children) : undefined,
+            options
+        };
+    }
+    return flattenChildren(props.children);
+}
+function FormatText(props) {
+    return {
+        type: 'Text',
+        value: childrenToString(props.children),
+        options: extractOptions(props)
+    };
+}
+function FormatLink(props) {
+    return {
+        type: 'Link',
+        value: childrenToString(props.children),
+        options: extractOptions(props)
+    };
+}
+function FormatImage(props) {
+    const buf = props.children;
+    return {
+        type: 'Image',
+        value: buf instanceof Buffer ? buf.toString('base64') : ''
+    };
+}
+function FormatImageURL(props) {
+    return {
+        type: 'ImageURL',
+        value: childrenToString(props.children)
+    };
+}
+function FormatImageFile(props) {
+    return {
+        type: 'ImageFile',
+        value: childrenToString(props.children)
+    };
+}
+function FormatMention(props) {
+    return {
+        type: 'Mention',
+        value: props.children !== null && props.children !== undefined ? childrenToString(props.children) : undefined,
+        options: extractOptions(props)
+    };
+}
+function FormatButton(props) {
+    const options = {};
+    if (props.command !== undefined) {
+        options.data = props.command;
+        options.type = 'command';
+    }
+    else {
+        if (props.data !== undefined) {
+            options.data = props.data;
+        }
+        if (props.type !== undefined) {
+            options.type = props.type;
+        }
+    }
+    if (props.toolTip !== undefined) {
+        options.toolTip = props.toolTip;
+    }
+    if (props.autoEnter !== undefined) {
+        options.autoEnter = props.autoEnter;
+    }
+    if (props.showList !== undefined) {
+        options.showList = props.showList;
+    }
+    return {
+        type: 'Button',
+        value: childrenToString(props.children),
+        options: Object.keys(options).length > 0 ? options : undefined
+    };
+}
+function FormatRow(props) {
+    return {
+        type: 'BT.row',
+        value: collectChildren(props.children, 'Button')
+    };
+}
+function FormatButtonGroup(props) {
+    return {
+        type: 'BT.group',
+        value: collectChildren(props.children, 'BT.row')
+    };
+}
+function FormatMarkdownTitle(props) {
+    return {
+        type: 'MD.title',
+        value: childrenToString(props.children)
+    };
+}
+function FormatMarkdownSubtitle(props) {
+    return {
+        type: 'MD.subtitle',
+        value: childrenToString(props.children)
+    };
+}
+function FormatMarkdownText(props) {
+    return {
+        type: 'MD.text',
+        value: childrenToString(props.children)
+    };
+}
+function FormatMarkdownBold(props) {
+    return {
+        type: 'MD.bold',
+        value: childrenToString(props.children)
+    };
+}
+function FormatMarkdownCode(props) {
+    return {
+        type: 'MD.code',
+        value: childrenToString(props.children),
+        options: extractOptions(props)
+    };
+}
+function FormatMarkdown(props) {
+    const flat = flattenChildren(props.children);
+    const items = flat.filter(c => typeof c.type === 'string' && c.type.startsWith('MD.'));
+    return {
+        type: 'Markdown',
+        value: items
+    };
+}
+FormatMarkdown.Title = FormatMarkdownTitle;
+FormatMarkdown.Subtitle = FormatMarkdownSubtitle;
+FormatMarkdown.Text = FormatMarkdownText;
+FormatMarkdown.Bold = FormatMarkdownBold;
+FormatMarkdown.Code = FormatMarkdownCode;
+function FormatCustomComponent(props) {
+    const { name, children, ...rest } = props;
+    const options = Object.keys(rest).length > 0 ? rest : undefined;
+    return {
+        type: name,
+        value: children !== null && children !== undefined ? childrenToString(children) : undefined,
+        options
+    };
+}
+FormatComponent.Text = FormatText;
+FormatComponent.Link = FormatLink;
+FormatComponent.Image = FormatImage;
+FormatComponent.ImageURL = FormatImageURL;
+FormatComponent.ImageFile = FormatImageFile;
+FormatComponent.Mention = FormatMention;
+FormatComponent.Button = FormatButton;
+FormatComponent.Row = FormatRow;
+FormatComponent.ButtonGroup = FormatButtonGroup;
+FormatComponent.Markdown = FormatMarkdown;
+FormatComponent.Custom = FormatCustomComponent;
+
+export { FormatComponent as Component, FormatCustomComponent as Custom };

package/lib/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1,2 @@
+export { jsx, jsxs, Fragment } from './jsx-runtime.js';
+export type { JSX } from './jsx-runtime.js';

package/lib/jsx/jsx-dev-runtime.js

@@ -0,0 +1 @@
+export { Fragment, jsx, jsxs } from './jsx-runtime.js';

package/lib/jsx/jsx-runtime.d.ts

@@ -0,0 +1,18 @@
+type JsxChild = any;
+type JsxProps = Record<string, any>;
+type JsxComponent = (props: JsxProps) => any;
+export declare function jsx(type: string | JsxComponent, props: JsxProps, _key?: string): any;
+export declare function jsxs(type: string | JsxComponent, props: JsxProps, _key?: string): any;
+export declare function Fragment(props: {
+    children?: JsxChild;
+}): any[];
+export declare namespace JSX {
+    type Element = any;
+    interface ElementChildrenAttribute {
+        children: object;
+    }
+    interface IntrinsicElements {
+        [elemName: string]: any;
+    }
+}
+export {};

package/lib/jsx/jsx-runtime.js

@@ -0,0 +1,24 @@
+function jsx(type, props, _key) {
+    if (typeof type === 'function') {
+        return type(props);
+    }
+    return { type, props };
+}
+function jsxs(type, props, _key) {
+    if (typeof type === 'function') {
+        return type(props);
+    }
+    return { type, props };
+}
+function Fragment(props) {
+    const { children } = props;
+    if (children === null || children === undefined) {
+        return [];
+    }
+    if (Array.isArray(children)) {
+        return children;
+    }
+    return [children];
+}
+
+export { Fragment, jsx, jsxs };

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

@@ -0,0 +1,7 @@
+export type DataAttachment = {
+    type: 'Attachment';
+    value: string;
+    options?: {
+        filename?: string;
+    };
+};

package/lib/types/message/attachment.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+export type DataAudio = {
+    type: 'Audio';
+    value: string;
+};

package/lib/types/message/audio.js

@@ -0,0 +1 @@
+

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

@@ -1,10 +1,14 @@
 import { DataButtonGroup, DataButtonTemplate } from './button';
 import { DataArkBigCard, DataArkCard, DataArkList } from './ark';
-import { DataMarkDown, DataMarkdownTemplate } from './markdown';
+import { DataMarkDown, DataMarkdownTemplate, DataCustom } from './markdown';
 import { DataImage, DataImageFile, DataImageURL } from './image';
 import { DataText } from './text';
 import { DataMention } from './mention';
 import { DataLink } from './link';
+import { DataAttachment } from './attachment';
+import { DataAudio } from './audio';
+import { DataVideo } from './video';
+import { DataMarkdownOriginal } from './markdown-raw';
 export * from './text';
 export * from './link';
 export * from './mention';
@@ -12,5 +16,9 @@ export * from './image';
 export * from './button';
 export * from './ark';
 export * from './markdown';
-export type DataEnums = DataText | DataLink | DataImage | DataImageURL | DataImageFile | DataMention | DataButtonGroup | DataButtonTemplate | DataArkList | DataArkCard | DataArkBigCard | DataMarkDown | DataMarkdownTemplate;
+export * from './markdown-raw';
+export * from './attachment';
+export * from './audio';
+export * from './video';
+export type DataEnums = DataText | DataLink | DataImage | DataImageURL | DataImageFile | DataMention | DataButtonGroup | DataButtonTemplate | DataArkList | DataArkCard | DataArkBigCard | DataMarkDown | DataMarkdownTemplate | DataMarkdownOriginal | DataAttachment | DataAudio | DataVideo | DataCustom;
 export type MessageDataFormat = DataEnums[];

package/lib/types/message/markdown-raw.d.ts

@@ -0,0 +1,4 @@
+export type DataMarkdownOriginal = {
+    type: 'MarkdownOriginal';
+    value: string;
+};

package/lib/types/message/markdown-raw.js

@@ -0,0 +1 @@
+

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

@@ -79,7 +79,14 @@ export type DataMarkdownCode = {
         language?: string;
     };
 };
-type DataMarkDownBalue = DataMarkdownText | DataMarkdownTitle | DataMarkdownSubtitle | DataMarkdownBold | DataMarkdownItalic | DataMarkdownItalicStar | DataMarkdownStrikethrough | DataMarkdownLink | DataMarkdownImage | DataMarkdownList | DataMarkdownBlockquote | DataMarkdownDivider | DataMarkdownNewline | DataMarkdownCode;
+export type DataCustom = {
+    type: string;
+    value: string;
+    options?: {
+        [key: string]: any;
+    };
+};
+type DataMarkDownBalue = DataMarkdownText | DataMarkdownTitle | DataMarkdownSubtitle | DataMarkdownBold | DataMarkdownItalic | DataMarkdownItalicStar | DataMarkdownStrikethrough | DataMarkdownLink | DataMarkdownImage | DataMarkdownList | DataMarkdownBlockquote | DataMarkdownDivider | DataMarkdownNewline | DataMarkdownCode | DataCustom;
 export type DataMarkDown = {
     type: 'Markdown';
     value: DataMarkDownBalue[];

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

@@ -0,0 +1,4 @@
+export type DataVideo = {
+    type: 'Video';
+    value: string;
+};

package/lib/types/message/video.js

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.22",
+  "version": "2.1.24",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",