alemonjs 2.1.56 → 2.1.58

package/lib/app/schedule-store.js

@@ -0,0 +1,230 @@
+import { ResultCode } from '../core/variable.js';
+import { CronJob } from 'cron';
+
+const scheduleMap = new Map();
+const appDirMap = new Map();
+const registerAppDir = (appName, mainDir) => {
+    appDirMap.set(appName, mainDir);
+};
+const unregisterAppDir = (appName) => {
+    appDirMap.delete(appName);
+};
+const extractCallerPaths = () => {
+    const stack = new Error().stack;
+    if (!stack) {
+        return [];
+    }
+    const paths = [];
+    const lineRegex = /(?:file:\/\/|\(|\s)(\/[^):]+)/g;
+    let m;
+    while ((m = lineRegex.exec(stack)) !== null) {
+        paths.push(m[1]);
+    }
+    return paths;
+};
+const resolveAppName = () => {
+    const callerPaths = extractCallerPaths();
+    for (const filePath of callerPaths) {
+        for (const [name, dir] of appDirMap) {
+            if (filePath.startsWith(dir)) {
+                return name;
+            }
+        }
+    }
+    return 'main';
+};
+const generateId = () => {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2, 15);
+};
+const safeInvoke = (callback, id, type) => {
+    try {
+        const result = callback();
+        if (result instanceof Promise) {
+            result.catch(err => {
+                logger.error({
+                    code: ResultCode.Fail,
+                    message: `Schedule ${type} error [${id}]: ${err?.message ?? err}`,
+                    data: null
+                });
+            });
+        }
+    }
+    catch (err) {
+        logger.error({
+            code: ResultCode.Fail,
+            message: `Schedule ${type} error [${id}]: ${err?.message ?? err}`,
+            data: null
+        });
+    }
+};
+const scheduleInterval = (callback, ms, appName) => {
+    if (ms <= 0) {
+        throw new Error('Interval ms must be greater than 0');
+    }
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const timer = setInterval(() => {
+        safeInvoke(callback, id, 'interval');
+    }, ms);
+    const item = {
+        id,
+        type: 'interval',
+        status: 'active',
+        callback,
+        ms,
+        _timer: timer,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const scheduleTimeout = (callback, ms, appName) => {
+    if (ms < 0) {
+        throw new Error('Timeout ms must be >= 0');
+    }
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const timer = setTimeout(() => {
+        safeInvoke(callback, id, 'timeout');
+        const item = scheduleMap.get(id);
+        if (item) {
+            item.status = 'stopped';
+            item._timer = null;
+        }
+        scheduleMap.delete(id);
+    }, ms);
+    const item = {
+        id,
+        type: 'timeout',
+        status: 'active',
+        callback,
+        ms,
+        _timer: timer,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const scheduleCron = (expression, callback, appName) => {
+    const resolvedApp = appName ?? resolveAppName();
+    const id = generateId();
+    const job = CronJob.from({
+        cronTime: expression,
+        onTick: () => {
+            safeInvoke(callback, id, 'cron');
+        },
+        start: true
+    });
+    const item = {
+        id,
+        type: 'cron',
+        status: 'active',
+        callback,
+        cron: expression,
+        _timer: job,
+        appName: resolvedApp,
+        createdAt: Date.now()
+    };
+    scheduleMap.set(id, item);
+    return id;
+};
+const clearTimer = (item) => {
+    if (item._timer === null || item._timer === undefined) {
+        return;
+    }
+    if (item.type === 'cron') {
+        void item._timer.stop();
+    }
+    else if (item.type === 'interval') {
+        clearInterval(item._timer);
+    }
+    else {
+        clearTimeout(item._timer);
+    }
+    item._timer = null;
+};
+const schedulePause = (id) => {
+    const item = scheduleMap.get(id);
+    if (item?.status !== 'active') {
+        return false;
+    }
+    clearTimer(item);
+    item.status = 'paused';
+    return true;
+};
+const scheduleResume = (id) => {
+    const item = scheduleMap.get(id);
+    if (item?.status !== 'paused') {
+        return false;
+    }
+    if (item.type === 'interval' && item.ms) {
+        item._timer = setInterval(() => {
+            safeInvoke(item.callback, id, 'interval');
+        }, item.ms);
+        item.status = 'active';
+        return true;
+    }
+    if (item.type === 'cron' && item.cron) {
+        const job = CronJob.from({
+            cronTime: item.cron,
+            onTick: () => {
+                safeInvoke(item.callback, id, 'cron');
+            },
+            start: true
+        });
+        item._timer = job;
+        item.status = 'active';
+        return true;
+    }
+    return false;
+};
+const scheduleCancel = (id) => {
+    const item = scheduleMap.get(id);
+    if (!item) {
+        return false;
+    }
+    clearTimer(item);
+    item.status = 'stopped';
+    scheduleMap.delete(id);
+    return true;
+};
+const scheduleCancelByApp = (appName) => {
+    let count = 0;
+    for (const [id, item] of scheduleMap) {
+        if (item.appName === appName) {
+            scheduleCancel(id);
+            count++;
+        }
+    }
+    return count;
+};
+const scheduleCancelAll = () => {
+    let count = 0;
+    for (const [id] of scheduleMap) {
+        scheduleCancel(id);
+        count++;
+    }
+    return count;
+};
+const scheduleList = (appName) => {
+    const result = [];
+    for (const [, item] of scheduleMap) {
+        if (appName && item.appName !== appName) {
+            continue;
+        }
+        result.push({
+            id: item.id,
+            type: item.type,
+            status: item.status,
+            ms: item.ms,
+            cron: item.cron,
+            appName: item.appName,
+            createdAt: item.createdAt
+        });
+    }
+    return result;
+};
+
+export { registerAppDir, scheduleCancel, scheduleCancelAll, scheduleCancelByApp, scheduleCron, scheduleInterval, scheduleList, schedulePause, scheduleResume, scheduleTimeout, unregisterAppDir };

package/lib/cbp/connects/client.js

@@ -16,7 +16,7 @@ import { createResult } from '../../core/utils.js';
 import '../../app/hook-event-context.js';
 import { apiResolves, apiTimeouts, actionResolves, actionTimeouts, FULL_RECEIVE_HEADER } from '../processor/config.js';
 import { setDirectSend } from '../processor/transport.js';
-import '../../app/message-format-old.js';
+import 'cron';
 import '../../app/event-utils.js';
 import '../../app/message-api.js';
 import { createWSConnector } from './base.js';

package/lib/client.js

@@ -27,7 +27,7 @@ import './app/event-middleware.js';
 import './app/event-processor.js';
 import './app/event-response.js';
 import './app/hook-event-context.js';
-import './app/message-format-old.js';
+import 'cron';
 import './app/event-utils.js';
 import './app/message-api.js';
 import './process/platform.js';

package/lib/index.js

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

package/lib/server/routers/router.js

@@ -5,9 +5,7 @@ import mime from 'mime-types';
 import hello from './hello.html.js';
 import { safePath, getModuelFile, formatPath, isValidPackageName } from './utils.js';
 import { collectMiddlewares, runMiddlewares } from './middleware.js';
-import { ResultCode } from '../../core/variable.js';
-import 'yaml';
-import '../../core/utils.js';
+import { ResultCode } from 'core';
 import module$1 from 'module';
 
 const initRequire = () => { };

package/lib/types/index.d.ts

@@ -25,6 +25,7 @@ export * from './state/index';
 export * from './store/res';
 export * from './expose/index';
 export * from './subscribe';
+export * from './schedule';
 export * from './standard';
 export * from './actions';
 export * from './apis';

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

@@ -0,0 +1,29 @@
+export type DataEmbedField = {
+    name: string;
+    value: string;
+    inline?: boolean;
+};
+export type DataEmbedAuthor = {
+    name: string;
+    url?: string;
+    iconUrl?: string;
+};
+export type DataEmbedFooter = {
+    text: string;
+    iconUrl?: string;
+};
+export type DataEmbed = {
+    type: 'Embed';
+    value: {
+        title?: string;
+        description?: string;
+        url?: string;
+        color?: number;
+        image?: string;
+        thumbnail?: string;
+        author?: DataEmbedAuthor;
+        footer?: DataEmbedFooter;
+        fields?: DataEmbedField[];
+        timestamp?: string | number | Date;
+    };
+};

package/lib/types/message/embed.js

@@ -0,0 +1 @@
+

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

@@ -8,6 +8,9 @@ import { DataAttachment } from './attachment';
 import { DataAudio } from './audio';
 import { DataVideo } from './video';
 import { DataMarkdownOriginal } from './markdown-raw';
+import { DataSelect } from './select';
+import { DataModal, DataTextInput } from './modal';
+import { DataEmbed } from './embed';
 export * from './text';
 export * from './link';
 export * from './mention';
@@ -18,5 +21,8 @@ export * from './markdown-raw';
 export * from './attachment';
 export * from './audio';
 export * from './video';
-export type DataEnums = DataText | DataLink | DataImage | DataImageURL | DataImageFile | DataMention | DataButtonGroup | DataMarkDown | DataMarkdownOriginal | DataAttachment | DataAudio | DataVideo;
+export * from './select';
+export * from './modal';
+export * from './embed';
+export type DataEnums = DataText | DataLink | DataImage | DataImageURL | DataImageFile | DataMention | DataButtonGroup | DataMarkDown | DataMarkdownOriginal | DataAttachment | DataAudio | DataVideo | DataSelect | DataModal | DataTextInput | DataEmbed;
 export type MessageDataFormat = DataEnums[];

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

@@ -0,0 +1,21 @@
+export type DataTextInput = {
+    type: 'TextInput';
+    value: string;
+    options: {
+        customId: string;
+        style?: 'short' | 'paragraph';
+        placeholder?: string;
+        minLength?: number;
+        maxLength?: number;
+        required?: boolean;
+        defaultValue?: string;
+    };
+};
+export type DataModal = {
+    type: 'Modal';
+    value: DataTextInput[];
+    options: {
+        customId: string;
+        title: string;
+    };
+};

package/lib/types/message/modal.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,19 @@
+export type DataSelectOption = {
+    label: string;
+    value: string;
+    description?: string;
+    emoji?: string;
+    default?: boolean;
+};
+export type DataSelect = {
+    type: 'Select';
+    value: DataSelectOption[];
+    options?: {
+        customId?: string;
+        placeholder?: string;
+        minValues?: number;
+        maxValues?: number;
+        kind?: 'string' | 'user' | 'role' | 'channel' | 'mentionable';
+        disabled?: boolean;
+    };
+};

package/lib/types/message/select.js

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,23 @@
+export type ScheduleId = string;
+export type ScheduleType = 'interval' | 'timeout' | 'cron';
+export type ScheduleStatus = 'active' | 'paused' | 'stopped';
+export type CronExpression = string;
+export type ScheduleCallback = () => void | Promise<void>;
+export interface ScheduleItem {
+    id: ScheduleId;
+    type: ScheduleType;
+    status: ScheduleStatus;
+    callback: ScheduleCallback;
+    ms?: number;
+    cron?: CronExpression;
+    _timer?: any;
+    appName?: string;
+    createdAt: number;
+}
+export type ScheduleMap = Map<ScheduleId, ScheduleItem>;
+export interface ScheduleTools {
+    setInterval: (callback: ScheduleCallback, ms: number) => ScheduleId;
+    setTimeout: (callback: ScheduleCallback, ms: number) => ScheduleId;
+    setCron: (expression: CronExpression, callback: ScheduleCallback) => ScheduleId;
+    cancel: (id: ScheduleId) => boolean;
+}

package/lib/types/schedule/index.js

@@ -0,0 +1 @@
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.56",
+  "version": "2.1.58",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "axios": "^1.14.0",
     "chalk": "^5.6.2",
     "commander": "^13.1.0",
+    "cron": "^4.4.0",
     "file-type": "21.0.0",
     "flatted": "^3.3.3",
     "koa": "^3.0.1",