alemonjs 2.1.43 → 2.1.45

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIdED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/bin/updateConfig.js

@@ -61,7 +61,9 @@ export function updateConfig(action, key, value = []) {
       }
       current = current[currentKey];
     }
-    delete current[keys[keys.length - 1]];
+    const delKey = keys[keys.length - 1];
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete current[delKey];
   } else if (action === 'get') {
     for (let i = 0; i < keys.length; i++) {
       const currentKey = keys[i];

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

@@ -1,4 +1,4 @@
-import { DataEnums, EventKeys, Events, User } from '../types';
+import { DataEnums, EventKeys, Events, User, GuildInfo, ChannelInfo, MemberInfo, RoleInfo, PaginationParams, PaginatedResult } from '../types';
 import { Result } from '../core/utils';
 import { Format } from './message-format';
 type Options = {
@@ -21,13 +21,99 @@ export declare const useMessage: <T extends EventKeys>(event: Events[T]) => read
         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 useMember: <T extends EventKeys>(event: Events[T]) => readonly [{
+    info: (params: {
+        userId: string;
+        guildId?: string;
+    }) => Promise<Result<MemberInfo | null>>;
     information: (params: {
         userId: string;
-    }) => Promise<Result<any>>;
+    }) => 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>;
+}];
+export declare const useChannel: <T extends EventKeys>(event: Events[T]) => readonly [{
+    info: (params?: {
+        channelId?: string;
+    }) => Promise<Result<ChannelInfo | null>>;
+    list: (params?: {
+        guildId?: string;
+    }) => Promise<Result<ChannelInfo[]>>;
+    create: (params: {
+        name: string;
+        type?: string;
+        parentId?: string;
+        guildId?: string;
+    }) => Promise<Result<ChannelInfo | null>>;
+    update: (params: {
+        channelId: string;
+        name?: string;
+        topic?: string;
+        position?: number;
+    }) => Promise<Result>;
+    delete: (params: {
+        channelId: string;
+    }) => Promise<Result>;
 }];
-export declare const useChannel: <T extends EventKeys>(event: Events[T]) => readonly [{}];
 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[];
@@ -37,10 +123,146 @@ export declare const unChildren: (name?: string) => void;
 export declare const onSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
 export declare const createSelects: <T extends EventKeys[] | EventKeys>(values: T) => T;
 export declare const useClient: <T extends object>(event: any, _ApiClass: new (...args: any[]) => T) => readonly [T];
+export declare const useGuild: <T extends EventKeys>(event: Events[T]) => readonly [{
+    info: (params?: {
+        guildId?: string;
+    }) => Promise<Result<GuildInfo | null>>;
+    list: () => Promise<Result<GuildInfo[]>>;
+    update(params: {
+        name?: string;
+        guildId?: string;
+    }): Promise<Result>;
+    leave(params?: {
+        guildId?: string;
+        isDismiss?: boolean;
+    }): Promise<Result>;
+    mute(params: {
+        enable: boolean;
+        guildId?: string;
+    }): Promise<Result>;
+}];
+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>;
+}];
+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>;
+}];
 export declare const useMe: () => readonly [{
     info: () => Promise<Result<User | null>>;
-    guilds: () => Promise<Result<User | null>>;
+    guilds: () => Promise<Result<GuildInfo[]>>;
     threads: () => Promise<Result<User | null>>;
     friends: () => Promise<Result<User | null>>;
 }];
+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>;
+}];
+export declare const useUser: () => readonly [{
+    info: (params: {
+        userId: string;
+    }) => Promise<Result<User | null>>;
+}];
+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>;
+}];
+export declare const useHistory: <T extends EventKeys>(event: Events[T]) => readonly [{
+    list: (params?: {
+        channelId?: string;
+        limit?: number;
+        before?: string;
+        after?: string;
+    }) => Promise<Result>;
+}];
+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>;
+}];
+export declare const useAnnounce: <T extends EventKeys>(event: Events[T]) => readonly [{
+    set: (params: {
+        messageId: string;
+        channelId?: string;
+        guildId?: string;
+    }) => Promise<Result>;
+    remove: (params?: {
+        messageId?: string;
+        guildId?: string;
+    }) => Promise<Result>;
+}];
 export {};