@alemonjs/discord 2.1.0-alpha.2 → 2.1.0-alpha.20

package/lib/sdk/typings.d.ts

@@ -0,0 +1,190 @@
+type ComponentButton = {
+    type: number;
+    style: 2;
+    label?: string;
+    emoji?: any;
+    custom_id?: string;
+    sku_id?: any;
+    url?: string;
+    disabled?: boolean;
+};
+type ComponentButtons = {
+    type: 1;
+    components: ComponentButton[];
+};
+type ComponentSelectsOption = {
+    label: string;
+    value: string;
+    description?: string;
+    emoji?: {
+        name?: string;
+        id?: string;
+    };
+};
+type ComponentChannelSelect = {
+    type: 8;
+    custom_id: string;
+    placeholder?: string;
+    channel_types?: number[];
+};
+type ComponentMentionSelect = {
+    type: 7;
+    custom_id: string;
+    placeholder?: string;
+};
+type ComponentRuleSelect = {
+    type: 6;
+    custom_id: string;
+    placeholder?: string;
+    max_values?: number;
+    min_values?: number;
+};
+type ComponentUserSelect = {
+    type: 5;
+    custom_id: string;
+    placeholder?: string;
+};
+type ComponentSelect = {
+    type: 3;
+    custom_id: string;
+    max_values?: number;
+    min_values?: number;
+    options: ComponentSelectsOption[];
+};
+type ComponentSelects = {
+    type: 1;
+    components: (ComponentSelect | ComponentUserSelect | ComponentRuleSelect | ComponentMentionSelect | ComponentChannelSelect)[];
+};
+type ComponentInput = {
+    id?: number;
+    type: 4;
+    custom_id: string;
+    label: string;
+    style: number;
+    min_length?: number;
+    max_length?: number;
+    placeholder?: string;
+    required?: boolean;
+};
+type ComponentModal = {
+    title: string;
+    custom_id: string;
+    components: {
+        type: 1;
+        components: ComponentInput[];
+    }[];
+};
+type ComponentText = {
+    type: 10;
+    content: string;
+};
+type ComponentSection = {
+    type: 9;
+    components: ComponentText[];
+    accessory?: {
+        type: 11;
+        media: {
+            url: string;
+        };
+    };
+};
+type ComponentMedia = {
+    type: 12;
+    items: {
+        media: {
+            url: string;
+        };
+        description?: string;
+    }[];
+};
+type ComponentFile = {
+    type: 13;
+    file: {
+        url: string;
+    };
+};
+type ComponentSeparator = {
+    type: 14;
+    divider: boolean;
+    spacing: number;
+};
+type ComponentContainer = {
+    type: 17;
+    accent_color: number;
+    components: (ComponentButtons | ComponentSelects | ComponentMedia | ComponentFile | ComponentText | ComponentSection | ComponentSeparator)[];
+};
+export type MessageData = {
+    content?: string;
+    tts?: boolean;
+    embeds?: {
+        title?: string;
+        type?: string;
+        description?: string;
+        url?: string;
+        timestamp?: string;
+        color?: number;
+        footer?: {
+            text: string;
+            icon_url?: string;
+            proxy_icon_url?: string;
+        };
+        image?: {
+            url: string;
+            proxy_url?: string;
+            height?: number;
+            width?: number;
+        };
+        thumbnail?: {
+            url: string;
+            proxy_url?: string;
+            height?: number;
+            width?: number;
+        };
+        video?: {
+            url: string;
+            proxy_url?: string;
+            height?: number;
+            width?: number;
+        };
+        provider?: {
+            name: string;
+            url: string;
+        };
+        author?: {
+            name: string;
+            url?: string;
+            icon_url?: string;
+            proxy_icon_url?: string;
+        };
+        fields?: {
+            name: string;
+            value: string;
+            inline?: boolean;
+        }[];
+    }[];
+    allowed_mentions?: any;
+    message_reference?: any;
+    components?: (ComponentButtons | ComponentSelects | ComponentModal | ComponentMedia | ComponentFile | ComponentText | ComponentSection | ComponentSeparator | ComponentContainer)[];
+    sticker_ids?: any;
+    files?: any[];
+    payload_json?: string;
+    attachments?: {
+        id: string;
+        filename: string;
+        description?: string;
+        content_type?: string;
+        size: number;
+        url: string;
+        proxy_url?: string;
+        height?: number;
+        width?: number;
+        ephemeral?: boolean;
+        duration_secs?: number;
+        waveform?: string;
+        flags?: number;
+    }[];
+    flags?: number;
+    enforce_nonce?: boolean;
+    poll?: any;
+};
+export {};

package/lib/sdk/typings.js

@@ -0,0 +1 @@
+

package/lib/sdk/wss.d.ts

@@ -1,27 +1,8 @@
-import { DCAPI } from './api.js'
-import { DISOCRDOptions } from './wss.types.js'
-import { DCEventMap } from './message.js'
-
-declare class DCClient extends DCAPI {
-  #private
-  /**
-   * 设置配置
-   * @param opstion
-   */
-  constructor(opstion: DISOCRDOptions)
-  /**
-   * 注册事件处理程序
-   * @param key 事件名称
-   * @param val 事件处理函数
-   */
-  on<T extends keyof DCEventMap>(key: T, val: (event: DCEventMap[T]) => any): this
-  /**
-   * 创建ws监听
-   * @param conversation
-   * @param shard
-   * @returns
-   */
-  connect(gatewayURL?: string): Promise<void>
+import { DCAPI } from './api.js';
+import { DCEventMap } from './message.js';
+export declare class DCClient extends DCAPI {
+    #private;
+    constructor();
+    on<T extends keyof DCEventMap>(key: T, val: (event: DCEventMap[T]) => any): this;
+    connect(): Promise<void>;
 }
-
-export { DCClient }

package/lib/sdk/wss.js

@@ -1,7 +1,10 @@
 import WebSocket from 'ws';
 import { DCAPI } from './api.js';
-import { config } from './config.js';
 import { getIntents } from './intents.js';
+import { getDiscordConfig } from '../config.js';
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import { AvailableIntentsEventsEnum } from './types.js';
+import dayjs from 'dayjs';
 
 class DCClient extends DCAPI {
     #heartbeat_interval = 0;
@@ -10,31 +13,21 @@ class DCClient extends DCAPI {
     #timeout_id = null;
     #seq = null;
     #ws;
-    /**
-     * 设置配置
-     * @param opstion
-     */
-    constructor(opstion) {
+    #count = 0;
+    #events = {};
+    constructor() {
         super();
-        config.set('intent', opstion.intent);
-        config.set('shard', opstion.shard);
-        config.set('token', opstion.token);
-        config.set('gatewayURL', opstion.gatewayURL);
         return this;
     }
-    /**
-     * 连接确认
-     * @returns
-     */
     #aut() {
-        const token = config.get('token');
-        const intent = config.get('intent');
-        const shard = config.get('shard');
+        const value = getDiscordConfig();
+        const token = value.token;
+        const intent = value.intent || AvailableIntentsEventsEnum;
+        const shard = value.shard || [0, 1];
         return {
             op: 2,
             d: {
                 shard: shard,
-                // 验证token
                 token: `Bot ${token}`,
                 intents: getIntents(intent),
                 properties: {
@@ -45,163 +38,117 @@ class DCClient extends DCAPI {
             }
         };
     }
-    /**
-     * 重新确认
-     */
-    // #reAut() {
-    //   const token = config.get('token')
-    //   const c = {
-    //     op: 6,
-    //     d: {
-    //       // 会话token
-    //       token: token,
-    //       session_id: this.#session_id,
-    //       // 收到的最后一个序列号
-    //       seq: this.#seq
-    //     }
-    //   }
-    //   console.log('[ws] c', c)
-    //   return c
-    // }
-    #events = {};
-    /**
-     * 注册事件处理程序
-     * @param key 事件名称
-     * @param val 事件处理函数
-     */
+    #getReConnectTime() {
+        const time = this.#count > 3 ? 1000 * 6 : 1000 * 1;
+        const curTime = this.#count > 6 ? 1000 * this.#count * 2 : time;
+        logger.info(`[ws-discord] 等待 ${dayjs(curTime).format('mm:ss')} 后重新连接`);
+        return curTime;
+    }
     on(key, val) {
         this.#events[key] = val;
         return this;
     }
-    /**
-     * 创建ws监听
-     * @param conversation
-     * @param shard
-     * @returns
-     */
-    async connect(gatewayURL) {
-        // 清除序列号
+    async connect() {
+        this.#count++;
+        const value = getDiscordConfig();
+        const gatewayURL = value.gatewayURL;
         this.#seq = null;
-        // 清除心跳
         clearTimeout(this.#timeout_id);
-        // 获取网关
-        const url = gatewayURL ??
-            (await this.gateway()
+        const gateway = async () => {
+            if (gatewayURL) {
+                return gatewayURL;
+            }
+            const currentGateway = await this.gateway()
                 .then(res => res?.url)
-                .catch(err => {
-                if (this.#events['ERROR'])
-                    this.#events['ERROR'](err?.message ?? err);
-            }));
-        // 没有网关
-        if (!url) {
-            console.error('[ws] 无法获取网关');
-            return;
-        }
-        /**
-         * 心跳恢复
-         */
-        const call = async () => {
-            this.#ws.send(JSON.stringify({
-                op: 1, //  op = 1
-                d: this.#seq // 如果是第一次连接，传null
-            }));
-            // 确保清除
-            clearTimeout(this.#timeout_id);
-            // 开始心跳
-            this.#timeout_id = setTimeout(call, this.#heartbeat_interval);
+                .catch(() => null);
+            return currentGateway;
         };
-        const map = {
-            /**
-             * 事件接收到
-             * @param param0
-             */
-            0: async ({ d, t, s }) => {
-                if (s) {
-                    // 序列号
-                    this.#seq = s;
-                }
-                // 准备
-                if (t == 'READY') {
-                    if (d?.resume_gateway_url) {
-                        this.#gateway_url = d?.resume_gateway_url;
-                        console.log('[ws] gateway_url', this.#gateway_url);
-                    }
-                    if (d?.session_id) {
-                        this.#session_id = d?.session_id;
-                        console.log('[ws] session_id', this.#session_id);
+        try {
+            const url = gatewayURL ?? (await gateway());
+            if (!url) {
+                logger.error('[ws-discord] 获取网关失败～');
+                const curTime = this.#getReConnectTime();
+                setTimeout(() => {
+                    void this.connect();
+                }, curTime);
+                return;
+            }
+            const call = () => {
+                this.#ws.send(JSON.stringify({
+                    op: 1,
+                    d: this.#seq
+                }));
+                clearTimeout(this.#timeout_id);
+                this.#timeout_id = setTimeout(call, this.#heartbeat_interval);
+            };
+            const map = {
+                0: ({ d, t, s }) => {
+                    if (s) {
+                        this.#seq = s;
                     }
-                }
-                // const events = ['PRESENCE_UPDATE','TYPING_START']
-                // if (!events.includes(t)) {
-                //     console.log("t", t)
-                //     console.log("d", d)
-                // }
-                // 事件处理
-                if (this.#events[t]) {
-                    try {
-                        await this.#events[t](d);
+                    if (t === 'READY') {
+                        if (d?.resume_gateway_url) {
+                            this.#gateway_url = d?.resume_gateway_url;
+                            logger.info('[ws-discord] gateway_url', this.#gateway_url);
+                        }
+                        if (d?.session_id) {
+                            this.#session_id = d?.session_id;
+                            logger.info('[ws-discord] session_id', this.#session_id);
+                        }
                     }
-                    catch (err) {
-                        if (this.#events['ERROR'])
-                            this.#events['ERROR'](err);
+                    if (this.#events[t]) {
+                        try {
+                            this.#events[t](d);
+                        }
+                        catch (err) {
+                            logger.error('[ws-discord] 事件处理错误', err);
+                        }
                     }
+                },
+                7: () => {
+                    logger.info('[ws-discord] 重新连接');
+                },
+                9: ({ d }) => {
+                    logger.error('[ws-discord] 无效会话', d);
+                },
+                10: ({ d }) => {
+                    this.#heartbeat_interval = d.heartbeat_interval;
+                    call();
+                    this.#ws.send(JSON.stringify(this.#aut()));
+                },
+                11: () => {
+                    logger.debug('[ws-discord] 心跳确认');
                 }
-                //
-            },
-            /**
-             * 重新连接
-             */
-            7: () => {
-                console.info('[ws] 重新连接');
-                // this.#ws.send(JSON.stringify(this.#reAut()))
-            },
-            /**
-             * 无效会话
-             * @param message
-             */
-            9: ({ d }) => {
-                console.error('[ws] 无效会话 ', d);
-            },
-            /**
-             * 你好
-             * @param param0
-             */
-            10: ({ d }) => {
-                // 得到心跳间隔
-                this.#heartbeat_interval = d.heartbeat_interval;
-                // 开始心跳
-                call();
-                // 开启会话
-                this.#ws.send(JSON.stringify(this.#aut()));
-            },
-            /**
-             * 心跳确认
-             */
-            11: () => {
-                console.info('[ws] 心跳确认');
+            };
+            const ClientOptions = value.websocket_options || {};
+            if (value.websocket_proxy) {
+                ClientOptions.agent = new HttpsProxyAgent(value.websocket_proxy);
             }
-        };
-        this.#ws = new WebSocket(`${url}?v=10&encoding=json`);
-        this.#ws.on('open', async () => {
-            console.info('[ws] open');
-        });
-        // 消息
-        this.#ws.on('message', data => {
-            const message = JSON.parse(data.toString());
-            if (map[message.op])
-                map[message.op](message);
-        });
-        // 关闭
-        this.#ws.on('close', err => {
-            console.error('[ws] 连接已关闭', err);
-            console.log('[ws] 等待重连');
-            this.connect();
-        });
-        // 出错
-        this.#ws.on('error', err => {
-            console.error('[ws] error:', err);
-        });
-        ///
+            this.#ws = new WebSocket(`${url}?v=10&encoding=json`, ClientOptions);
+            this.#ws.on('open', () => {
+                logger.info('[ws-discord] 打开连接');
+                this.#count = 0;
+            });
+            this.#ws.on('message', data => {
+                const message = JSON.parse(data.toString());
+                if (map[message.op]) {
+                    map[message.op](message);
+                }
+            });
+            this.#ws.on('close', err => {
+                logger.info('[ws-discord] 连接关闭', err);
+                const curTime = this.#getReConnectTime();
+                setTimeout(() => {
+                    void this.connect();
+                }, curTime);
+            });
+            this.#ws.on('error', err => {
+                logger.error('[ws-discord] 出错', err?.message || err);
+            });
+        }
+        catch (err) {
+            logger.error('[ws-discord] 内部错误', err);
+        }
     }
 }
 

package/lib/sdk/wss.types.d.ts

@@ -1,30 +1,7 @@
-import { DCIntentsEnum } from './types.js'
-
-/**
- * ****
- * discord
- * ***
- */
-interface DISOCRDOptions {
-  /**
-   * 网关地址
-   */
-  gatewayURL?: string
-  /**
-   * 钥匙
-   */
-  token: string
-  /**
-   * 订阅(有默认值)
-   * ******
-   */
-  intent?: DCIntentsEnum[]
-  /**
-   * 分片(有默认值)
-   * ******
-   * [0, 1]
-   */
-  shard?: number[]
+import { DCIntentsEnum } from './types.js';
+export interface DISOCRDOptions {
+    gatewayURL?: string;
+    token: string;
+    intent?: DCIntentsEnum[];
+    shard?: number[];
 }
-
-export type { DISOCRDOptions }

package/lib/sdk/wss.types.js

@@ -0,0 +1 @@
+

package/lib/send.d.ts

@@ -0,0 +1,11 @@
+import { DataEnums } from 'alemonjs';
+import { DCClient } from './sdk/wss';
+type Client = typeof DCClient.prototype;
+export declare const sendchannel: (client: Client, param: {
+    channel_id: string;
+}, val: DataEnums[]) => Promise<import("alemonjs").Result<any>[]>;
+export declare const senduser: (client: Client, param: {
+    author_id?: string;
+    channel_id?: string;
+}, val: DataEnums[]) => Promise<import("alemonjs").Result<any>[]>;
+export {};