alemonjs 2.1.48 → 2.1.49

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

@@ -0,0 +1,142 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+import { Format } from '../message-format.js';
+
+const useMessage = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const resolveFormat = (params) => {
+        if (params.format instanceof Format) {
+            return params.format.value;
+        }
+        return params.format;
+    };
+    const sendRaw = async (val, replyId) => {
+        if (!val || val.length === 0) {
+            return [createResult(ResultCode.FailParams, 'Invalid val: val must be a non-empty array', null)];
+        }
+        const result = await sendAction({
+            action: 'message.send',
+            payload: {
+                event: valueEvent,
+                params: {
+                    format: val,
+                    replyId
+                }
+            }
+        });
+        return Array.isArray(result) ? result : [result];
+    };
+    const lightweight = {
+        send(params) {
+            if (Array.isArray(params)) {
+                return sendRaw(params.length > 0 ? params : []);
+            }
+            return sendRaw(resolveFormat(params), params?.replyId ?? valueEvent.MessageId);
+        },
+        async delete(params) {
+            const targetId = params?.messageId || valueEvent.MessageId;
+            if (!targetId) {
+                return createResult(ResultCode.FailParams, 'Missing MessageId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'message.delete',
+                    payload: { MessageId: targetId, ChannelId: valueEvent.ChannelId, event: valueEvent }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Delete not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to delete message', null);
+            }
+        },
+        async edit(params) {
+            const targetId = params.messageId || valueEvent.MessageId;
+            const channelId = valueEvent.ChannelId;
+            if (!targetId || !channelId) {
+                return createResult(ResultCode.FailParams, 'Missing MessageId or ChannelId', null);
+            }
+            try {
+                const val = params.format instanceof Format ? params.format.value : params.format;
+                const results = await sendAction({
+                    action: 'message.edit',
+                    payload: { ChannelId: channelId, MessageId: targetId, params: { format: val }, event: valueEvent }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Edit not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to edit message', null);
+            }
+        },
+        async pin(params) {
+            const targetId = params?.messageId || valueEvent.MessageId;
+            const channelId = valueEvent.ChannelId;
+            if (!targetId || !channelId) {
+                return createResult(ResultCode.FailParams, 'Missing MessageId or ChannelId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'message.pin',
+                    payload: { ChannelId: channelId, MessageId: targetId }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Pin not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to pin message', null);
+            }
+        },
+        async unpin(params) {
+            const targetId = params?.messageId || valueEvent.MessageId;
+            const channelId = valueEvent.ChannelId;
+            if (!targetId || !channelId) {
+                return createResult(ResultCode.FailParams, 'Missing MessageId or ChannelId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'message.unpin',
+                    payload: { ChannelId: channelId, MessageId: targetId }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Unpin not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to unpin message', null);
+            }
+        },
+        async get(params) {
+            const targetId = params?.messageId || valueEvent.MessageId;
+            if (!targetId) {
+                return createResult(ResultCode.FailParams, 'Missing MessageId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'message.get',
+                    payload: { MessageId: targetId }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Get message not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to get message', null);
+            }
+        }
+    };
+    return [lightweight];
+};
+const useSend = (event) => {
+    const [message] = useMessage(event);
+    const send = (...val) => {
+        return message.send(val);
+    };
+    return send;
+};
+const useSends = (event) => {
+    const [message] = useMessage(event);
+    return [message.send];
+};
+
+export { useMessage, useSend, useSends };

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

@@ -0,0 +1,13 @@
+import { EventKeys, Events, Result } from './common';
+export declare const usePermission: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    get: (params: {
+        userId: string;
+        channelId?: string;
+    }) => Promise<Result>;
+    set: (params: {
+        userId: string;
+        allow?: string;
+        deny?: string;
+        channelId?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,49 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const usePermission = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const get = async (params) => {
+        const cid = params.channelId || valueEvent.ChannelId;
+        if (!cid || !params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId or UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'permission.get',
+                payload: { ChannelId: cid, UserId: params.userId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Permission get not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get permission', null);
+        }
+    };
+    const set = async (params) => {
+        const cid = params.channelId || valueEvent.ChannelId;
+        if (!cid || !params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId or UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'permission.set',
+                payload: { ChannelId: cid, UserId: params.userId, params: { allow: params.allow, deny: params.deny } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Permission set not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to set permission', null);
+        }
+    };
+    const permission = {
+        get,
+        set
+    };
+    return [permission];
+};
+
+export { usePermission };

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

@@ -0,0 +1,16 @@
+import { EventKeys, Events, Result } from './common';
+export declare const useReaction: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    add: (params: {
+        emojiId: string;
+        messageId?: string;
+    }) => Promise<Result>;
+    remove: (params: {
+        emojiId: string;
+        messageId?: string;
+    }) => Promise<Result>;
+    list: (params: {
+        emojiId: string;
+        messageId?: string;
+        limit?: number;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,70 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useReaction = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const add = async (params) => {
+        const mid = params.messageId || valueEvent.MessageId;
+        const cid = valueEvent.ChannelId;
+        if (!mid || !cid || !params.emojiId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId, MessageId or EmojiId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'reaction.add',
+                payload: { ChannelId: cid, MessageId: mid, EmojiId: params.emojiId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Reaction add not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to add reaction', null);
+        }
+    };
+    const remove = async (params) => {
+        const mid = params.messageId || valueEvent.MessageId;
+        const cid = valueEvent.ChannelId;
+        if (!mid || !cid || !params.emojiId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId, MessageId or EmojiId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'reaction.remove',
+                payload: { ChannelId: cid, MessageId: mid, EmojiId: params.emojiId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Reaction remove not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to remove reaction', null);
+        }
+    };
+    const list = async (params) => {
+        const mid = params.messageId || valueEvent.MessageId;
+        const cid = valueEvent.ChannelId;
+        if (!mid || !cid || !params.emojiId) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId, MessageId or EmojiId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'reaction.list',
+                payload: { ChannelId: cid, MessageId: mid, EmojiId: params.emojiId, params: { limit: params.limit } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Reaction list not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to list reactions', null);
+        }
+    };
+    const reaction = {
+        add,
+        remove,
+        list
+    };
+    return [reaction];
+};
+
+export { useReaction };

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

@@ -0,0 +1,14 @@
+import { Result } from './common';
+export declare const useRequest: () => readonly [{
+    friend: (params: {
+        flag: string;
+        approve: boolean;
+        remark?: string;
+    }) => Promise<Result>;
+    guild: (params: {
+        flag: string;
+        subType: string;
+        approve: boolean;
+        reason?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,53 @@
+import { ResultCode } from '../../core/variable.js';
+import '../store.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../cbp/processor/config.js';
+import 'flatted';
+import '../message-format-old.js';
+import '../hook-event-context.js';
+
+const useRequest = () => {
+    const friend = async (params) => {
+        if (!params.flag) {
+            return createResult(ResultCode.FailParams, 'Missing flag', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'request.friend',
+                payload: { params: { flag: params.flag, approve: params.approve, remark: params.remark } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Friend request handling not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to handle friend request', null);
+        }
+    };
+    const guild = async (params) => {
+        if (!params.flag || !params.subType) {
+            return createResult(ResultCode.FailParams, 'Missing flag or subType', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'request.guild',
+                payload: { params: { flag: params.flag, subType: params.subType, approve: params.approve, reason: params.reason } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Guild request handling not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to handle guild request', null);
+        }
+    };
+    const request = {
+        friend,
+        guild
+    };
+    return [request];
+};
+
+export { useRequest };

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

@@ -0,0 +1,33 @@
+import { EventKeys, Events, Result, RoleInfo } from './common';
+export declare const useRole: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    list: (params?: {
+        guildId?: string;
+    }) => Promise<Result<RoleInfo[]>>;
+    create: (params: {
+        name: string;
+        color?: number;
+        permissions?: string;
+        guildId?: string;
+    }) => Promise<Result<RoleInfo | null>>;
+    update: (params: {
+        roleId: string;
+        name?: string;
+        color?: number;
+        permissions?: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    delete: (params: {
+        roleId: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    assign: (params: {
+        userId: string;
+        roleId: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    remove: (params: {
+        userId: string;
+        roleId: string;
+        guildId?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,125 @@
+import { getEventOrThrow } from './common.js';
+import { createResult } from '../../core/utils.js';
+import { ResultCode } from '../../core/variable.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useRole = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const getGuildId = (guildId) => guildId || valueEvent.GuildId;
+    const list = async (params) => {
+        const gid = getGuildId(params?.guildId);
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', []);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.list',
+                payload: { GuildId: gid }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved role list', result.data ?? []);
+            }
+            return createResult(ResultCode.Warn, 'No role list found', []);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get role list', []);
+        }
+    };
+    const create = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.create',
+                payload: { GuildId: gid, params: { name: params.name, color: params.color, permissions: params.permissions } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result ? createResult(ResultCode.Ok, 'Role created', result.data ?? null) : createResult(ResultCode.Warn, 'Create not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to create role', null);
+        }
+    };
+    const update = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.roleId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or RoleId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.update',
+                payload: { GuildId: gid, RoleId: params.roleId, params: { name: params.name, color: params.color, permissions: params.permissions } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Update not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to update role', null);
+        }
+    };
+    const remove = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.roleId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or RoleId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.delete',
+                payload: { GuildId: gid, RoleId: params.roleId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Delete not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to delete role', null);
+        }
+    };
+    const assign = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.userId || !params.roleId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId, UserId or RoleId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.assign',
+                payload: { GuildId: gid, UserId: params.userId, RoleId: params.roleId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Assign not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to assign role', null);
+        }
+    };
+    const revoke = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.userId || !params.roleId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId, UserId or RoleId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'role.remove',
+                payload: { GuildId: gid, UserId: params.userId, RoleId: params.roleId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Remove not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to remove role', null);
+        }
+    };
+    const role = {
+        list,
+        create,
+        update,
+        delete: remove,
+        assign,
+        remove: revoke
+    };
+    return [role];
+};
+
+export { useRole };

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

@@ -0,0 +1,6 @@
+import { Result, User } from './common';
+export declare const useUser: () => readonly [{
+    info: (params: {
+        userId: string;
+    }) => Promise<Result<User | null>>;
+}];

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

@@ -0,0 +1,39 @@
+import { ResultCode } from '../../core/variable.js';
+import '../store.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../cbp/processor/config.js';
+import 'flatted';
+import '../message-format-old.js';
+import '../hook-event-context.js';
+
+const useUser = () => {
+    const info = async (params) => {
+        if (!params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'user.info',
+                payload: { UserId: params.userId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved user info', result.data ?? null);
+            }
+            return createResult(ResultCode.Warn, 'No user info found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get user info', null);
+        }
+    };
+    const user = {
+        info
+    };
+    return [user];
+};
+
+export { useUser };

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

@@ -16,7 +16,7 @@ export declare const useMention: <T extends EventKeys>(event: Events[T]) => [{
         count: number;
     }>;
 }];
-export declare const useMessage: <T extends EventKeys>(event: Events[T]) => readonly [{
+export declare const useMessage: <T extends EventKeys>(event?: Events[T]) => readonly [{
     send(params?: {
         format: Format | DataEnums[];
         replyId?: string;
@@ -114,8 +114,8 @@ export declare const useChannel: <T extends EventKeys>(event: Events[T]) => read
         channelId: string;
     }) => Promise<Result>;
 }];
-export declare const useSend: <T extends EventKeys>(event: Events[T]) => (...val: DataEnums[]) => Promise<Result[]>;
-export declare const useSends: <T extends EventKeys>(event: Events[T]) => readonly [(params?: DataEnums[] | {
+export declare const useSend: <T extends EventKeys>(event?: Events[T]) => (...val: DataEnums[]) => Promise<Result[]>;
+export declare const useSends: <T extends EventKeys>(event?: Events[T]) => readonly [(params?: DataEnums[] | {
     format: Format | DataEnums[];
     replyId?: string;
 }) => Promise<Result[]>];