alemonjs 2.1.56 → 2.1.58

package/lib/app/api/schedule.d.ts

@@ -0,0 +1,17 @@
+import { ScheduleCallback, CronExpression } from '../../types/schedule';
+export declare const setInterval: (callback: ScheduleCallback, ms: number) => string;
+export declare const setTimeout: (callback: ScheduleCallback, ms: number) => string;
+export declare const setCron: (expression: CronExpression, callback: ScheduleCallback) => string;
+export declare const clearInterval: (id: import("../..").ScheduleId) => boolean;
+export declare const clearTimeout: (id: import("../..").ScheduleId) => boolean;
+export declare const pauseSchedule: (id: import("../..").ScheduleId) => boolean;
+export declare const resumeSchedule: (id: import("../..").ScheduleId) => boolean;
+export declare const listSchedule: (appName?: string) => Array<{
+    id: import("../..").ScheduleId;
+    type: import("../..").ScheduleItem["type"];
+    status: import("../..").ScheduleStatus;
+    ms?: number;
+    cron?: string;
+    appName?: string;
+    createdAt: number;
+}>;

package/lib/app/api/schedule.js

@@ -0,0 +1,12 @@
+import { scheduleCancel, scheduleList, schedulePause, scheduleResume, scheduleCron, scheduleInterval, scheduleTimeout } from '../schedule-store.js';
+
+const setInterval = (callback, ms) => scheduleInterval(callback, ms);
+const setTimeout = (callback, ms) => scheduleTimeout(callback, ms);
+const setCron = (expression, callback) => scheduleCron(expression, callback);
+const clearInterval = scheduleCancel;
+const clearTimeout = scheduleCancel;
+const pauseSchedule = schedulePause;
+const resumeSchedule = scheduleResume;
+const listSchedule = scheduleList;
+
+export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout };

package/lib/app/hook-use/client.js

@@ -7,7 +7,6 @@ import 'path';
 import 'yaml';
 import '../../cbp/processor/config.js';
 import { sendAPI } from '../../cbp/processor/api.js';
-import '../message-format-old.js';
 import { getCurrentEvent } from '../hook-event-context.js';
 
 const createDeepProxy = (event, path = []) => {

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

@@ -1,6 +1,7 @@
 import { GuildInfo, Result, User } from './common';
 export declare const useMe: () => readonly [{
     info: () => Promise<Result<User | null>>;
+    isMentionMe: () => Result<boolean>;
     guilds: () => Promise<Result<GuildInfo[]>>;
     threads: () => Promise<Result<User | null>>;
     friends: () => Promise<Result<User | null>>;

package/lib/app/hook-use/me.js

@@ -7,7 +7,6 @@ import 'path';
 import 'yaml';
 import '../../cbp/processor/config.js';
 import 'flatted';
-import '../message-format-old.js';
 import '../hook-event-context.js';
 
 const useMe = () => {
@@ -28,6 +27,14 @@ const useMe = () => {
             return createResult(ResultCode.Fail, 'Failed to get bot information', null);
         }
     };
+    const isMentionMe = () => {
+        try {
+            return createResult(ResultCode.Warn, 'No bot information found', false);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', false);
+        }
+    };
     const guilds = async () => {
         try {
             const results = await sendAction({
@@ -80,6 +87,7 @@ const useMe = () => {
     };
     const control = {
         info,
+        isMentionMe,
         guilds,
         threads,
         friends

package/lib/app/hook-use/request.js

@@ -7,7 +7,6 @@ import 'path';
 import 'yaml';
 import '../../cbp/processor/config.js';
 import 'flatted';
-import '../message-format-old.js';
 import '../hook-event-context.js';
 
 const useRequest = () => {

package/lib/app/hook-use/user.js

@@ -7,7 +7,6 @@ import 'path';
 import 'yaml';
 import '../../cbp/processor/config.js';
 import 'flatted';
-import '../message-format-old.js';
 import '../hook-event-context.js';
 
 const useUser = () => {

package/lib/app/index.d.ts

@@ -16,7 +16,9 @@ export * from './event-processor-event.js';
 export * from './event-processor-middleware.js';
 export * from './event-processor-subscribe.js';
 export * from './hook-use/index.js';
+export * from './api/schedule.js';
 export * from './hook-event-context.js';
+export * from './schedule-store.js';
 export * from './event-utils.js';
 export * from './message-api.js';
 export * from './message-format.js';

package/lib/app/index.js

@@ -33,8 +33,9 @@ export { useRole } from './hook-use/role.js';
 export { useUser } from './hook-use/user.js';
 export { useObserver, useSubscribe } from './hook-use/subscribe.js';
 export { createEvent, useEvent } from './hook-use/event.js';
+export { clearInterval, clearTimeout, listSchedule, pauseSchedule, resumeSchedule, setCron, setInterval, setTimeout } from './api/schedule.js';
 export { getCurrentEvent, getCurrentNext, withEventContext } from './hook-event-context.js';
+export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir } from './schedule-store.js';
 export { createEventValue, createSelects, onSelects, onState, unChildren, unState, useState } from './event-utils.js';
 export { MessageDirect, createDataFormat, format, getMessageIntent, sendToChannel, sendToUser } from './message-api.js';
-export { Format, FormatButtonGroup, FormatMarkDown } from './message-format.js';
-export { Attachment, Audio, BT, Button, Image, ImageFile, ImageURL, Link, MD, Markdown, MarkdownOriginal, Mention, Text, Video } from './message-format-old.js';
+export { Format, FormatButtonGroup, FormatMarkDown, FormatModal, FormatSelect } from './message-format.js';

package/lib/app/load_modules/loadChild.js

@@ -4,6 +4,7 @@ import { showErrorModule, getRecursiveDirFiles, createEventName } from '../../co
 import { ChildrenApp } from '../store.js';
 import { registerExpose } from '../expose.js';
 import { ResultCode, fileSuffixMiddleware } from '../../core/variable.js';
+import { registerAppDir, scheduleCancelByApp, unregisterAppDir } from '../schedule-store.js';
 import module$1 from 'module';
 
 const initRequire = () => { };
@@ -20,6 +21,7 @@ const loadChildren = async (mainPath, appName) => {
     }
     const mainDir = dirname(mainPath);
     const App = new ChildrenApp(appName);
+    registerAppDir(appName, mainDir);
     try {
         const moduleApp = await import(`file://${mainPath}`);
         if (!moduleApp?.default) {
@@ -44,6 +46,8 @@ const loadChildren = async (mainPath, appName) => {
         App.pushCycle(app);
         const unMounted = async (e) => {
             showErrorModule(e);
+            scheduleCancelByApp(appName);
+            unregisterAppDir(appName);
             App.un();
             try {
                 if (app?.unMounted) {

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

@@ -1,4 +1,5 @@
 import { DataMention, DataImage, DataText, DataImageURL, DataImageFile, DataButtonRow, DataButtonGroup, DataButton, DataMarkDown, DataMarkdownTitle, DataMarkdownSubtitle, DataMarkdownBold, DataMarkdownItalic, DataMarkdownItalicStar, DataMarkdownStrikethrough, DataMarkdownLink, DataMarkdownImage, DataMarkdownList, DataMarkdownListItem, DataMarkdownBlockquote, DataMarkdownDivider, DataMarkdownNewline, DataLink, DataMarkdownText, DataMarkdownCode, DataMarkdownOriginal, DataAttachment, DataAudio, DataVideo, DataMarkdownMention, DataMarkdownContent, DataMarkdownButton } from '../types';
+import { Format, FormatMarkDown, FormatButtonGroup } from './message-format.js';
 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;
@@ -73,3 +74,4 @@ export declare const MarkdownOriginal: (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;
+export { Format, FormatMarkDown, FormatButtonGroup };

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

@@ -1,61 +1,32 @@
+import { Format } from './message-format.js';
+export { FormatButtonGroup, FormatMarkDown } from './message-format.js';
+
 const Text = (val, options) => {
-    return {
-        type: 'Text',
-        value: val,
-        options
-    };
+    return Format.create().addText(val, options).value[0];
 };
 const Link = (val, options) => {
-    return {
-        type: 'Text',
-        value: val,
-        options
-    };
+    return Format.create().addLink(val, options).value[0];
 };
 const ImageURL = (val) => {
-    return {
-        type: 'ImageURL',
-        value: val
-    };
+    return Format.create().addImageURL(val).value[0];
 };
 const ImageFile = (val) => {
-    return {
-        type: 'ImageFile',
-        value: val
-    };
+    return Format.create().addImageFile(val).value[0];
 };
 const Image = (val) => {
-    return {
-        type: 'Image',
-        value: typeof val === 'string' ? val : `base64://${val.toString('base64')}`
-    };
+    return Format.create().addImage(val).value[0];
 };
 Image.url = ImageURL;
 Image.file = ImageFile;
 const Mention = (UserId, options) => {
-    return {
-        type: 'Mention',
-        value: UserId,
-        options: options ?? {
-            belong: 'user'
-        }
-    };
+    return Format.create().addMention(UserId, options).value[0];
 };
 const Button = (title, data, options) => {
-    return {
-        type: 'Button',
-        value: title,
-        options: {
-            data,
-            ...options
-        }
-    };
+    const group = Format.createButtonGroup().addButton(title, data, options).value;
+    return group.value[0].value[0];
 };
 const ButtonGroup = (...rows) => {
-    return {
-        type: 'BT.group',
-        value: rows
-    };
+    return Format.create().addButtonGroup(...rows).value[0];
 };
 const ButtonRow = (...buttons) => {
     return {
@@ -67,93 +38,46 @@ Button.group = ButtonGroup;
 Button.row = ButtonRow;
 const BT = Button;
 const Markdown = (...values) => {
-    return {
-        type: 'Markdown',
-        value: values
-    };
+    return Format.create().addMarkdown(...values).value[0];
 };
 Markdown.text = (text) => {
-    return {
-        type: 'MD.text',
-        value: text
-    };
+    return Format.createMarkdown().addText(text).value.value[0];
 };
 Markdown.mention = (uid, options) => {
-    return {
-        type: 'MD.mention',
-        value: uid || 'everyone',
-        options: options ?? {
-            belong: 'user'
-        }
-    };
+    return Format.createMarkdown().addMention(uid, options).value.value[0];
 };
 Markdown.button = (title, data) => {
-    return {
-        type: 'MD.button',
-        value: title,
-        options: data
-    };
+    return Format.createMarkdown().addButton(title, data).value.value[0];
 };
 Markdown.content = (text) => {
-    return {
-        type: 'MD.content',
-        value: text
-    };
+    return Format.createMarkdown().addContent(text).value.value[0];
 };
 Markdown.title = (text) => {
-    return {
-        type: 'MD.title',
-        value: text
-    };
+    return Format.createMarkdown().addTitle(text).value.value[0];
 };
 Markdown.subtitle = (text) => {
-    return {
-        type: 'MD.subtitle',
-        value: text
-    };
+    return Format.createMarkdown().addSubtitle(text).value.value[0];
 };
 Markdown.bold = (text) => {
-    return {
-        type: 'MD.bold',
-        value: text
-    };
+    return Format.createMarkdown().addBold(text).value.value[0];
 };
 Markdown.italic = (text) => {
-    return {
-        type: 'MD.italic',
-        value: text
-    };
+    return Format.createMarkdown().addItalic(text).value.value[0];
 };
 Markdown.italicStar = (text) => {
-    return {
-        type: 'MD.italicStar',
-        value: text
-    };
+    return Format.createMarkdown().addItalicStar(text).value.value[0];
 };
 Markdown.strikethrough = (text) => {
-    return {
-        type: 'MD.strikethrough',
-        value: text
-    };
+    return Format.createMarkdown().addStrikethrough(text).value.value[0];
 };
 Markdown.link = (text, url) => {
-    return {
-        type: 'MD.link',
-        value: { text, url }
-    };
+    return Format.createMarkdown().addLink(text, url).value.value[0];
 };
 Markdown.image = (url, options) => {
-    return {
-        type: 'MD.image',
-        value: url,
-        options
-    };
+    return Format.createMarkdown().addImage(url, options).value.value[0];
 };
 Markdown.list = (...items) => {
-    return {
-        type: 'MD.list',
-        value: items
-    };
+    return Format.createMarkdown().addList(...items).value.value[0];
 };
 Markdown.listItem = (indexOrText, text) => {
     return {
@@ -162,54 +86,29 @@ Markdown.listItem = (indexOrText, text) => {
     };
 };
 Markdown.blockquote = (text) => {
-    return {
-        type: 'MD.blockquote',
-        value: text
-    };
+    return Format.createMarkdown().addBlockquote(text).value.value[0];
 };
 Markdown.divider = () => {
-    return {
-        type: 'MD.divider'
-    };
+    return Format.createMarkdown().addDivider().value.value[0];
 };
 Markdown.newline = (value = false) => {
-    return {
-        type: 'MD.newline',
-        value: value
-    };
+    return Format.createMarkdown().addNewline(value).value.value[0];
 };
 Markdown.code = (value, options) => {
-    return {
-        type: 'MD.code',
-        value: value,
-        options: options
-    };
+    return Format.createMarkdown().addCode(value, options).value.value[0];
 };
 const MD = Markdown;
 const MarkdownOriginal = (val) => {
-    return {
-        type: 'MarkdownOriginal',
-        value: val
-    };
+    return Format.create().addMarkdownOriginal(val).value[0];
 };
 const Attachment = (val, options) => {
-    return {
-        type: 'Attachment',
-        value: val,
-        options
-    };
+    return Format.create().addAttachment(val, options).value[0];
 };
 const Audio = (val) => {
-    return {
-        type: 'Audio',
-        value: val
-    };
+    return Format.create().addAudio(val).value[0];
 };
 const Video = (val) => {
-    return {
-        type: 'Video',
-        value: val
-    };
+    return Format.create().addVideo(val).value[0];
 };
 
-export { Attachment, Audio, BT, Button, Image, ImageFile, ImageURL, Link, MD, Markdown, MarkdownOriginal, Mention, Text, Video };
+export { Attachment, Audio, BT, Button, Format, Image, ImageFile, ImageURL, Link, MD, Markdown, MarkdownOriginal, Mention, Text, Video };

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

@@ -1,36 +1,56 @@
-import { DataButtonGroup, DataMarkDown, DataEnums } from '../types';
-import { Text, Image, Link, ImageFile, ImageURL, Mention, BT, MD, MarkdownOriginal, Attachment, Audio, Video } from './message-format-old.js';
-export * from './message-format-old.js';
+import { DataMention, DataText, DataImageURL, DataImageFile, DataButtonRow, DataButtonGroup, DataButton, DataMarkDown, DataLink, DataMarkdownCode, DataAttachment, DataMarkdownMention, DataMarkdownButton, DataEnums, DataSelect, DataSelectOption, DataModal, DataTextInput, DataEmbed } from '../types';
 export declare class FormatButtonGroup {
     #private;
     get value(): DataButtonGroup;
     absorb(group: FormatButtonGroup): this;
     addRow(): this;
-    addButton(...args: Parameters<typeof BT>): this;
+    addButton(title: string, data: DataButton['options']['data'], options?: Omit<DataButton['options'], 'data'>): this;
     clear(): this;
 }
 export declare class FormatMarkDown {
     #private;
     get value(): DataMarkDown;
     absorb(md: FormatMarkDown): this;
-    addContent(...args: Parameters<typeof MD.content>): this;
-    addText(...args: Parameters<typeof MD.text>): this;
-    addTitle(...args: Parameters<typeof MD.title>): this;
-    addSubtitle(...args: Parameters<typeof MD.subtitle>): this;
-    addBold(...args: Parameters<typeof MD.bold>): this;
-    addItalic(...args: Parameters<typeof MD.italic>): this;
-    addItalicStar(...args: Parameters<typeof MD.italicStar>): this;
-    addStrikethrough(...args: Parameters<typeof MD.strikethrough>): this;
-    addLink(...args: Parameters<typeof MD.link>): this;
-    addImage(...args: Parameters<typeof MD.image>): this;
-    addList(...args: Parameters<typeof MD.list>): this;
-    addBlockquote(...args: Parameters<typeof MD.blockquote>): this;
+    addContent(text: string): this;
+    addText(text: string): this;
+    addTitle(text: string): this;
+    addSubtitle(text: string): this;
+    addBold(text: string): this;
+    addItalic(text: string): this;
+    addItalicStar(text: string): this;
+    addStrikethrough(text: string): this;
+    addLink(text: string, url?: string): this;
+    addImage(url: string, options?: {
+        width?: number;
+        height?: number;
+    }): this;
+    addList(...items: any[]): this;
+    addBlockquote(text: string): this;
     addDivider(): this;
-    addNewline(...args: Parameters<typeof MD.newline>): this;
-    addCode(...args: Parameters<typeof MD.code>): this;
+    addNewline(value?: boolean): this;
+    addCode(value: DataMarkdownCode['value'], options?: DataMarkdownCode['options']): this;
     addBreak(): this;
-    addMention(...args: Parameters<typeof MD.mention>): this;
-    addButton(...args: Parameters<typeof MD.button>): this;
+    addMention(uid?: string, options?: DataMarkdownMention['options']): this;
+    addButton(title: string, data: DataMarkdownButton['options']): this;
+    clear(): this;
+}
+export declare class FormatSelect {
+    #private;
+    get value(): DataSelect;
+    setCustomId(customId: string): this;
+    setPlaceholder(placeholder: string): this;
+    setRange(min?: number, max?: number): this;
+    setKind(kind: DataSelect['options']['kind']): this;
+    setDisabled(disabled?: boolean): this;
+    addOption(label: string, value: string, extra?: Omit<DataSelectOption, 'label' | 'value'>): this;
+    clear(): this;
+}
+export declare class FormatModal {
+    #private;
+    get value(): DataModal;
+    setCustomId(customId: string): this;
+    setTitle(title: string): this;
+    addInput(label: string, options: DataTextInput['options']): this;
     clear(): this;
 }
 export declare class Format {
@@ -38,21 +58,28 @@ export declare class Format {
     static create(): Format;
     static createMarkdown(): FormatMarkDown;
     static createButtonGroup(): FormatButtonGroup;
+    static createSelect(): FormatSelect;
+    static createModal(): FormatModal;
     get value(): DataEnums[];
     absorb(format: Format): this;
-    addText(...args: Parameters<typeof Text>): this;
-    addImage(...args: Parameters<typeof Image>): this;
-    addMention(...args: Parameters<typeof Mention>): this;
+    addText(val: DataText['value'], options?: DataText['options']): this;
+    addImage(val: Buffer | string): this;
+    addMention(UserId?: DataMention['value'], options?: DataMention['options']): this;
     addButtonGroup(bt: FormatButtonGroup): this;
-    addButtonGroup(...args: Parameters<typeof BT.group>): this;
+    addButtonGroup(...rows: DataButtonRow[]): this;
     addMarkdown(md: FormatMarkDown): this;
-    addMarkdown(...args: Parameters<typeof MD>): this;
-    addMarkdownOriginal(...args: Parameters<typeof MarkdownOriginal>): this;
-    addAttachment(...args: Parameters<typeof Attachment>): this;
-    addAudio(...args: Parameters<typeof Audio>): this;
-    addVideo(...args: Parameters<typeof Video>): this;
-    addLink(...args: Parameters<typeof Link>): this;
-    addImageFile(...args: Parameters<typeof ImageFile>): this;
-    addImageURL(...args: Parameters<typeof ImageURL>): this;
+    addMarkdown(...values: DataMarkDown['value']): this;
+    addMarkdownOriginal(val: string): this;
+    addAttachment(val: string, options?: DataAttachment['options']): this;
+    addAudio(val: string): this;
+    addVideo(val: string): this;
+    addLink(val: DataLink['value'], options?: DataText['options']): this;
+    addImageFile(val: DataImageFile['value']): this;
+    addImageURL(val: DataImageURL['value']): this;
+    addSelect(select: FormatSelect): this;
+    addSelect(options: DataSelectOption[], meta?: DataSelect['options']): this;
+    addModal(modal: FormatModal): this;
+    addModal(inputs: DataTextInput[], meta: DataModal['options']): this;
+    addEmbed(embed: DataEmbed['value']): this;
     clear(): this;
 }