alemonjs 2.1.47 → 2.1.49

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

@@ -0,0 +1,15 @@
+export * from './announce';
+export * from './channel';
+export * from './client';
+export * from './guild';
+export * from './history';
+export * from './media';
+export * from './me';
+export * from './member';
+export * from './mention';
+export * from './message';
+export * from './permission';
+export * from './reaction';
+export * from './request';
+export * from './role';
+export * from './user';

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

@@ -0,0 +1,15 @@
+export { useAnnounce } from './announce.js';
+export { useChannel } from './channel.js';
+export { useClient } from './client.js';
+export { useGuild } from './guild.js';
+export { useHistory } from './history.js';
+export { useMedia } from './media.js';
+export { useMe } from './me.js';
+export { useMember } from './member.js';
+export { useMention } from './mention.js';
+export { useMessage, useSend, useSends } from './message.js';
+export { usePermission } from './permission.js';
+export { useReaction } from './reaction.js';
+export { useRequest } from './request.js';
+export { useRole } from './role.js';
+export { useUser } from './user.js';

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

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

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

@@ -0,0 +1,90 @@
+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 useMe = () => {
+    const info = async () => {
+        try {
+            const results = await sendAction({
+                action: 'me.info',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                const data = result?.data ?? null;
+                return createResult(ResultCode.Ok, 'Successfully retrieved bot information', data);
+            }
+            return createResult(ResultCode.Warn, 'No bot information found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', null);
+        }
+    };
+    const guilds = async () => {
+        try {
+            const results = await sendAction({
+                action: 'me.guilds',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved guild list', result.data ?? []);
+            }
+            return createResult(ResultCode.Warn, 'No guild list found', []);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get guild list', []);
+        }
+    };
+    const threads = async () => {
+        try {
+            const results = await sendAction({
+                action: 'me.threads',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                const data = result?.data ?? null;
+                return createResult(ResultCode.Ok, 'Successfully retrieved bot information', data);
+            }
+            return createResult(ResultCode.Warn, 'No bot information found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', null);
+        }
+    };
+    const friends = async () => {
+        try {
+            const results = await sendAction({
+                action: 'me.friends',
+                payload: {}
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                const data = result?.data ?? null;
+                return createResult(ResultCode.Ok, 'Successfully retrieved bot information', data);
+            }
+            return createResult(ResultCode.Warn, 'No bot information found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get bot information', null);
+        }
+    };
+    const control = {
+        info,
+        guilds,
+        threads,
+        friends
+    };
+    return [control];
+};
+
+export { useMe };

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

@@ -0,0 +1,23 @@
+import { EventKeys, Events, Result } from './common';
+export declare const useMedia: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    upload: (params: {
+        type: "image" | "audio" | "video" | "file";
+        url?: string;
+        data?: string;
+        name?: string;
+    }) => Promise<Result>;
+    sendChannel: (params: {
+        type: "image" | "audio" | "video" | "file";
+        url?: string;
+        data?: string;
+        name?: string;
+        channelId?: string;
+    }) => Promise<Result>;
+    sendUser: (params: {
+        userId: string;
+        type: "image" | "audio" | "video" | "file";
+        url?: string;
+        data?: string;
+        name?: string;
+    }) => Promise<Result>;
+}];

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

@@ -0,0 +1,62 @@
+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 useMedia = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const upload = async (params) => {
+        try {
+            const results = await sendAction({
+                action: 'media.upload',
+                payload: { params }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Media upload not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to upload media', null);
+        }
+    };
+    const sendChannel = async (params) => {
+        const cid = params.channelId || valueEvent.ChannelId;
+        if (!cid) {
+            return createResult(ResultCode.FailParams, 'Missing ChannelId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'media.send.channel',
+                payload: { ChannelId: cid, params: { type: params.type, url: params.url, data: params.data, name: params.name } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Media send not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to send media to channel', null);
+        }
+    };
+    const sendUser = async (params) => {
+        if (!params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'media.send.user',
+                payload: { UserId: params.userId, params: { type: params.type, url: params.url, data: params.data, name: params.name } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Media send not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to send media to user', null);
+        }
+    };
+    const media = {
+        upload,
+        sendChannel,
+        sendUser
+    };
+    return [media];
+};
+
+export { useMedia };

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

@@ -0,0 +1,54 @@
+import { EventKeys, Events, MemberInfo, PaginationParams, PaginatedResult, Result } from './common';
+export declare const useMember: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    info: (params: {
+        userId: string;
+        guildId?: string;
+    }) => Promise<Result<MemberInfo | null>>;
+    information: (params: {
+        userId: string;
+    }) => Promise<Result<MemberInfo>>;
+    list: (params?: {
+        guildId?: string;
+        pagination?: PaginationParams;
+    }) => Promise<Result<PaginatedResult<MemberInfo>>>;
+    kick: (params: {
+        userId: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    ban: (params: {
+        userId: string;
+        guildId?: string;
+        reason?: string;
+        duration?: number;
+    }) => Promise<Result>;
+    unban: (params: {
+        userId: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    search: (params: {
+        keyword: string;
+        guildId?: string;
+        limit?: number;
+    }) => Promise<Result>;
+    mute(params: {
+        userId: string;
+        duration: number;
+        guildId?: string;
+    }): Promise<Result>;
+    admin(params: {
+        userId: string;
+        enable: boolean;
+        guildId?: string;
+    }): Promise<Result>;
+    card(params: {
+        userId: string;
+        card: string;
+        guildId?: string;
+    }): Promise<Result>;
+    title(params: {
+        userId: string;
+        title: string;
+        guildId?: string;
+        duration?: number;
+    }): Promise<Result>;
+}];

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

@@ -0,0 +1,200 @@
+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 useMember = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    const getGuildId = (guildId) => guildId || valueEvent.GuildId;
+    const info = async (params) => {
+        try {
+            const results = await sendAction({
+                action: 'member.info',
+                payload: {
+                    event: valueEvent,
+                    params: {
+                        userId: params.userId,
+                        guildId: getGuildId(params.guildId)
+                    }
+                }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved member information', result.data ?? null);
+            }
+            return createResult(ResultCode.Warn, 'No member information found', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get member information', null);
+        }
+    };
+    const list = async (params) => {
+        const guildId = getGuildId(params?.guildId);
+        if (!guildId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId', { Items: [] });
+        }
+        try {
+            const results = await sendAction({
+                action: 'member.list',
+                payload: { GuildId: guildId, params: params?.pagination }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            if (result) {
+                return createResult(ResultCode.Ok, 'Successfully retrieved member list', result.data ?? { Items: [] });
+            }
+            return createResult(ResultCode.Warn, 'No member list found', { Items: [] });
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to get member list', { Items: [] });
+        }
+    };
+    const kick = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'member.kick',
+                payload: { GuildId: gid, UserId: params.userId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Kick not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to kick member', null);
+        }
+    };
+    const ban = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'member.ban',
+                payload: { GuildId: gid, UserId: params.userId, params: { reason: params.reason, duration: params.duration } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Ban not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to ban member', null);
+        }
+    };
+    const unban = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.userId) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'member.unban',
+                payload: { GuildId: gid, UserId: params.userId }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Unban not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to unban member', null);
+        }
+    };
+    const information = (params) => info(params);
+    const search = async (params) => {
+        const gid = getGuildId(params.guildId);
+        if (!gid || !params.keyword) {
+            return createResult(ResultCode.FailParams, 'Missing GuildId or keyword', null);
+        }
+        try {
+            const results = await sendAction({
+                action: 'member.search',
+                payload: { GuildId: gid, params: { keyword: params.keyword, limit: params.limit } }
+            });
+            const result = results.find(item => item.code === ResultCode.Ok);
+            return result || createResult(ResultCode.Warn, 'Member search not supported or failed', null);
+        }
+        catch {
+            return createResult(ResultCode.Fail, 'Failed to search members', null);
+        }
+    };
+    const member = {
+        info,
+        information,
+        list,
+        kick,
+        ban,
+        unban,
+        search,
+        async mute(params) {
+            const gid = getGuildId(params.guildId);
+            if (!gid || !params.userId) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'member.mute',
+                    payload: { GuildId: gid, UserId: params.userId, params: { duration: params.duration } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Mute not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to mute member', null);
+            }
+        },
+        async admin(params) {
+            const gid = getGuildId(params.guildId);
+            if (!gid || !params.userId) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'member.admin',
+                    payload: { GuildId: gid, UserId: params.userId, params: { enable: params.enable } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Admin set not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to set admin', null);
+            }
+        },
+        async card(params) {
+            const gid = getGuildId(params.guildId);
+            if (!gid || !params.userId) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'member.card',
+                    payload: { GuildId: gid, UserId: params.userId, params: { card: params.card } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Card set not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to set member card', null);
+            }
+        },
+        async title(params) {
+            const gid = getGuildId(params.guildId);
+            if (!gid || !params.userId) {
+                return createResult(ResultCode.FailParams, 'Missing GuildId or UserId', null);
+            }
+            try {
+                const results = await sendAction({
+                    action: 'member.title',
+                    payload: { GuildId: gid, UserId: params.userId, params: { title: params.title, duration: params.duration ?? -1 } }
+                });
+                const result = results.find(item => item.code === ResultCode.Ok);
+                return result || createResult(ResultCode.Warn, 'Title set not supported or failed', null);
+            }
+            catch {
+                return createResult(ResultCode.Fail, 'Failed to set member title', null);
+            }
+        }
+    };
+    return [member];
+};
+
+export { useMember };

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

@@ -0,0 +1,9 @@
+import { EventKeys, Events, Options, Result, User } from './common';
+export declare const useMention: <T extends EventKeys>(event?: Events[T]) => [{
+    find: (options?: Options) => Promise<Result<User[]> & {
+        count: number;
+    }>;
+    findOne: (options?: Options) => Promise<Result<User | null> & {
+        count: number;
+    }>;
+}];

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

@@ -0,0 +1,88 @@
+import { getEventOrThrow } from './common.js';
+import { ResultCode } from '../../core/variable.js';
+import { createResult } from '../../core/utils.js';
+import { sendAction } from '../../cbp/processor/actions.js';
+
+const useMention = (event) => {
+    const valueEvent = getEventOrThrow(event);
+    let res = null;
+    const load = async () => {
+        if (res) {
+            return;
+        }
+        const results = await sendAction({
+            action: 'mention.get',
+            payload: { event: valueEvent }
+        });
+        const result = results.find(item => item.code === ResultCode.Ok);
+        if (result) {
+            res = result.data;
+        }
+    };
+    const match = (item, options) => {
+        if (options.UserId !== undefined && item.UserId !== options.UserId) {
+            return false;
+        }
+        if (options.UserKey !== undefined && item.UserKey !== options.UserKey) {
+            return false;
+        }
+        if (options.UserName !== undefined && item.UserName !== options.UserName) {
+            return false;
+        }
+        if (options.IsMaster !== undefined && item.IsMaster !== options.IsMaster) {
+            return false;
+        }
+        if (options.IsBot !== undefined && item.IsBot !== options.IsBot) {
+            return false;
+        }
+        if (options.IsBot === undefined && item.IsBot) {
+            return false;
+        }
+        return true;
+    };
+    const mention = {
+        find: async (options = {}) => {
+            try {
+                await load();
+            }
+            catch (err) {
+                const result = createResult(ResultCode.Fail, err?.message || 'Failed to get mention data', null);
+                return {
+                    ...result,
+                    count: 0
+                };
+            }
+            if (!Array.isArray(res)) {
+                return {
+                    ...createResult(ResultCode.Warn, 'No mention data found', null),
+                    count: 0
+                };
+            }
+            const data = res.filter(item => match(item, options));
+            const result = createResult(ResultCode.Ok, 'Successfully retrieved mention data', data);
+            return {
+                ...result,
+                count: data.length || 0
+            };
+        },
+        findOne: async (options = {}) => {
+            const results = await mention.find(options);
+            if (results.code !== ResultCode.Ok || !results.data?.length) {
+                const result = createResult(results.code, results.message, null);
+                return {
+                    ...result,
+                    count: 0
+                };
+            }
+            const data = results?.data[0];
+            const result = createResult(ResultCode.Ok, results.message, data);
+            return {
+                ...result,
+                count: results.data?.length || 0
+            };
+        }
+    };
+    return [mention];
+};
+
+export { useMention };

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

@@ -0,0 +1,28 @@
+import { DataEnums, EventKeys, Events, Format, Result } from './common';
+export declare const useMessage: <T extends EventKeys>(event?: Events[T]) => readonly [{
+    send(params?: {
+        format: Format | DataEnums[];
+        replyId?: string;
+    } | DataEnums[]): Promise<Result[]>;
+    delete(params?: {
+        messageId?: string;
+    }): Promise<Result>;
+    edit(params: {
+        format: Format | DataEnums[];
+        messageId?: string;
+    }): Promise<Result>;
+    pin(params?: {
+        messageId?: string;
+    }): Promise<Result>;
+    unpin(params?: {
+        messageId?: string;
+    }): Promise<Result>;
+    get(params?: {
+        messageId?: 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[] | {
+    format: Format | DataEnums[];
+    replyId?: string;
+}) => Promise<Result[]>];