seyfert 0.1.0 → 1.0.0

package/lib/client/onmessagecreate.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onMessageCreate = void 0;
+const v10_1 = require("discord-api-types/v10");
+const __1 = require("..");
+const structures_1 = require("../structures");
+function getCommandFromContent(commandRaw, self) {
+    const parentName = commandRaw[0];
+    const groupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
+    const subcommandName = groupName ? commandRaw[2] : commandRaw[1];
+    const parent = self.commands.values.find(x => x.name === parentName);
+    const fullCommandName = `${parentName}${groupName ? ` ${groupName} ${subcommandName}` : ` ${subcommandName ?? ''}`}`;
+    if (!(parent instanceof __1.Command))
+        return { fullCommandName };
+    if (groupName && !parent.groups?.[groupName])
+        return getCommandFromContent([parentName, subcommandName], self);
+    if (subcommandName && !parent.options?.some(x => x instanceof __1.SubCommand && x.name === subcommandName))
+        return getCommandFromContent([parentName], self);
+    const command = groupName || subcommandName
+        ? parent.options?.find(opt => {
+            if (opt instanceof __1.SubCommand) {
+                if (groupName) {
+                    if (opt.group !== groupName)
+                        return false;
+                }
+                if (opt.group && !groupName)
+                    return false;
+                return subcommandName === opt.name;
+            }
+            return false;
+        })
+        : parent;
+    return {
+        command,
+        fullCommandName,
+        parent,
+    };
+}
+async function onMessageCreate(self, rawMessage, shardId) {
+    if (!self.options?.commands)
+        return;
+    const message = new structures_1.Message(self, rawMessage);
+    const prefixes = ((await self.options.commands.prefix?.(message)) ?? []).sort((a, b) => b.length - a.length);
+    const prefix = prefixes.find(x => message.content.startsWith(x));
+    if (!prefix || !message.content.startsWith(prefix))
+        return;
+    const content = message.content.slice(prefix.length).trimStart();
+    const { fullCommandName, command, parent } = getCommandFromContent(content.split(' ').filter(x => x), self);
+    if (!command)
+        return;
+    if (!command.run)
+        return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
+    if (command.dm && !message.guildId)
+        return;
+    if (command.guild_id && !command.guild_id?.includes(message.guildId))
+        return;
+    const resolved = {
+        channels: {},
+        roles: {},
+        users: {},
+        members: {},
+        attachments: {},
+    };
+    const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(content, command);
+    const { options, errors } = await parseOptions(self, command, rawMessage, args, resolved);
+    const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
+    const context = new __1.CommandContext(self, message, optionsResolver, shardId);
+    try {
+        if (command.botPermissions && message.guildId) {
+            const meMember = await self.cache.members?.get(self.botId, message.guildId);
+            if (!meMember)
+                return; //enable member cache and "Guilds" intent, lol
+            const appPermissions = await meMember.fetchPermissions();
+            const permissions = appPermissions.missings(...appPermissions.values(command.botPermissions));
+            if (permissions.length) {
+                return command.onPermissionsFail?.(context, appPermissions.keys(permissions));
+            }
+        }
+        if (errors.length) {
+            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                return [
+                    x.name,
+                    {
+                        failed: true,
+                        value: x.error,
+                    },
+                ];
+            })));
+        }
+        const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
+        if (erroredOptions) {
+            return command.onOptionsError?.(context, result);
+        }
+        const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
+        if (resultRunGlobalMiddlewares.pass) {
+            return;
+        }
+        if ('error' in resultRunGlobalMiddlewares) {
+            return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
+        }
+        const resultRunMiddlewares = await command.__runMiddlewares(context);
+        if (resultRunMiddlewares.pass) {
+            return;
+        }
+        if ('error' in resultRunMiddlewares) {
+            return command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
+        }
+        try {
+            await command.run?.(context);
+            await command.onAfterRun?.(context, undefined);
+        }
+        catch (error) {
+            await command.onRunError?.(context, error);
+            await command.onAfterRun?.(context, error);
+        }
+    }
+    catch (error) {
+        try {
+            await command.onInternalError?.(self, error);
+        }
+        catch {
+            // supress error
+        }
+    }
+}
+exports.onMessageCreate = onMessageCreate;
+async function parseOptions(self, command, message, args, resolved) {
+    const options = [];
+    const errors = [];
+    for (const i of (command.options ?? [])) {
+        let value;
+        let indexAttachment = -1;
+        switch (i.type) {
+            case v10_1.ApplicationCommandOptionType.Attachment:
+                if (message.attachments[++indexAttachment]) {
+                    value = message.attachments[indexAttachment].id;
+                    resolved.attachments[value] = message.attachments[indexAttachment];
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Boolean:
+                if (args[i.name]) {
+                    value = ['yes', 'y', 'true', 'treu'].includes(args[i.name].toLowerCase());
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Channel:
+                {
+                    const rawId = message.content.match(/(?<=<#)[0-9]{17,19}(?=>)/g)?.find(x => args[i.name]?.includes(x));
+                    if (rawId) {
+                        const channel = i.required ? await self.channels.fetch(rawId) : await self.cache.channels?.get(rawId);
+                        if (channel) {
+                            if ('channel_types' in i) {
+                                if (!i.channel_types.includes(channel.type)) {
+                                    errors.push({
+                                        name: i.name,
+                                        error: `The entered channel type is not one of ${i
+                                            .channel_types.map(t => v10_1.ChannelType[t])
+                                            .join(', ')}`,
+                                    });
+                                    break;
+                                }
+                            }
+                            value = rawId;
+                            //@ts-expect-error
+                            resolved.channels[rawId] = channel;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Mentionable:
+                {
+                    const matches = message.content.match(/<@[0-9]{17,19}(?=>)|<@&[0-9]{17,19}(?=>)/g) ?? [];
+                    for (const match of matches) {
+                        if (match.includes('&')) {
+                            const rawId = match.slice(3);
+                            if (rawId) {
+                                const role = i.required
+                                    ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId)
+                                    : await self.cache.roles?.get(rawId);
+                                if (role) {
+                                    value = rawId;
+                                    //@ts-expect-error
+                                    resolved.roles[rawId] = role;
+                                    break;
+                                }
+                            }
+                        }
+                        else {
+                            const rawId = match.slice(2);
+                            const raw = message.mentions.find(x => rawId === x.id);
+                            if (raw) {
+                                value = raw.id;
+                                resolved.users[raw.id] = raw;
+                                break;
+                            }
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Role:
+                {
+                    const rawId = message.mention_roles.find(x => args[i.name]?.includes(x));
+                    if (rawId) {
+                        const role = i.required
+                            ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) //why, discord, why
+                            : await self.cache.roles?.get(rawId);
+                        if (role) {
+                            value = rawId;
+                            //@ts-expect-error
+                            resolved.roles[rawId] = role;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.User:
+                {
+                    const raw = message.mentions.find(x => args[i.name]?.includes(x.id));
+                    if (raw) {
+                        value = raw.id;
+                        resolved.users[raw.id] = raw;
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.String:
+                {
+                    value = args[i.name];
+                    const option = i;
+                    if (value) {
+                        if (option.min_length) {
+                            if (value.length < option.min_length) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                });
+                                break;
+                            }
+                        }
+                        if (option.max_length) {
+                            if (value.length > option.max_length) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                });
+                                break;
+                            }
+                        }
+                        if (option.choices?.length) {
+                            if (!option.choices.some(x => x.name === value)) {
+                                value = undefined;
+                                errors.push({
+                                    name: i.name,
+                                    error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                        .map(x => x.name)
+                                        .join(', ')}.`,
+                                });
+                                break;
+                            }
+                            value = option.choices.find(x => x.name === value).value;
+                        }
+                    }
+                }
+                break;
+            case v10_1.ApplicationCommandOptionType.Number:
+            case v10_1.ApplicationCommandOptionType.Integer:
+                {
+                    value = Number(args[i.name]);
+                    if (args[i.name] === undefined) {
+                        value = undefined;
+                        break;
+                    }
+                    if (Number.isNaN(value)) {
+                        value = undefined;
+                        errors.push({
+                            name: i.name,
+                            error: 'The entered choice is an invalid number.',
+                        });
+                        break;
+                    }
+                    const option = i;
+                    if (option.min_value) {
+                        if (value < option.min_value) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                            });
+                            break;
+                        }
+                    }
+                    if (option.max_value) {
+                        if (value > option.max_value) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                            });
+                            break;
+                        }
+                    }
+                    if (option.choices?.length) {
+                        if (!option.choices.some(x => x.name === value)) {
+                            value = undefined;
+                            errors.push({
+                                name: i.name,
+                                error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
+                                    .map(x => x.name)
+                                    .join(', ')}.`,
+                            });
+                            break;
+                        }
+                        value = option.choices.find(x => x.name === value).value;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        if (value !== undefined) {
+            options.push({
+                name: i.name,
+                type: i.type,
+                value,
+            });
+        }
+    }
+    return { errors, options };
+}
+function defaultArgsParser(content) {
+    const args = {};
+    for (const i of content.match(/-(.*?)(?=\s-|$)/gs) ?? []) {
+        args[i.slice(1).split(' ')[0]] = i.split(' ').slice(1).join(' ');
+    }
+    return args;
+}
+//-(.*?)(?=\s-|$)/gs
+//-(?<text>[^-]*)/gm

package/lib/client/workerclient.d.ts

@@ -3,12 +3,14 @@ import type { GatewayDispatchPayload, When } from '../common';
 import { Logger, type DeepPartial } from '../common';
 import { EventHandler } from '../events';
 import { ClientUser } from '../structures';
-import { Shard } from '../websocket';
+import { Shard, type ShardManagerOptions } from '../websocket';
 import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
+import type { Client } from './client';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
+    private __handleGuilds?;
     logger: Logger;
     events: EventHandler;
     me: When<Ready, ClientUser>;
@@ -24,5 +26,7 @@ export declare class WorkerClient<Ready extends boolean = boolean> extends BaseC
 export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
 interface WorkerClientOptions extends BaseClientOptions {
     disabledCache: Cache['disabledCache'];
+    commands?: NonNullable<Client['options']>['commands'];
+    handlePayload?: ShardManagerOptions['handlePayload'];
 }
 export {};

package/lib/client/workerclient.js

@@ -8,9 +8,11 @@ const events_1 = require("../events");
 const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const base_1 = require("./base");
-const oninteraction_1 = require("./oninteraction");
+const oninteractioncreate_1 = require("./oninteractioncreate");
+const onmessagecreate_1 = require("./onmessagecreate");
 const workerData = node_worker_threads_1.workerData;
 class WorkerClient extends base_1.BaseClient {
+    __handleGuilds;
     logger = new common_1.Logger({
         name: `[Worker #${workerData.workerId}]`,
     });
@@ -19,6 +21,7 @@ class WorkerClient extends base_1.BaseClient {
     shards = new Map();
     constructor(options) {
         super(options);
+        this.__handleGuilds = new Set();
         if (!node_worker_threads_1.parentPort) {
             throw new Error('WorkerClient cannot spawn without manager');
         }
@@ -54,8 +57,10 @@ class WorkerClient extends base_1.BaseClient {
     async handleManagerMessages(data) {
         switch (data.type) {
             case 'CACHE_RESULT':
-                if (this.cache.adapter.promises.has(data.nonce)) {
-                    this.cache.adapter.promises.get(data.nonce)?.(data.result);
+                if (this.cache.adapter instanceof cache_1.WorkerAdapter && this.cache.adapter.promises.has(data.nonce)) {
+                    const cacheData = this.cache.adapter.promises.get(data.nonce);
+                    clearTimeout(cacheData.timeout);
+                    cacheData.resolve(data.result);
                     this.cache.adapter.promises.delete(data.nonce);
                 }
                 break;
@@ -90,6 +95,7 @@ class WorkerClient extends base_1.BaseClient {
                 {
                     const cache = this.cache;
                     const onPacket = this.onPacket.bind(this);
+                    const handlePayload = this.options?.handlePayload?.bind(this);
                     for (const id of workerData.shards) {
                         let shard = this.shards.get(id);
                         if (!shard) {
@@ -100,6 +106,7 @@ class WorkerClient extends base_1.BaseClient {
                                 compress: data.compress,
                                 debugger: this.debugger,
                                 async handlePayload(shardId, payload) {
+                                    await handlePayload?.(shardId, payload);
                                     await cache.onPacket(payload);
                                     await onPacket?.(payload, shardId);
                                     node_worker_threads_1.parentPort.postMessage({
@@ -147,58 +154,74 @@ class WorkerClient extends base_1.BaseClient {
             case 'BOT_READY':
                 if (this.events.values.BOT_READY &&
                     (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                    this.events.values.BOT_READY.fired = true;
-                    await this.events.values.BOT_READY.run(this.me, this, -1);
+                    await this.events.runEvent('BOT_READY', this, this.me, -1);
                 }
                 break;
         }
     }
     async onPacket(packet, shardId) {
+        await this.events.execute('RAW', packet, this, shardId);
         switch (packet.t) {
-            case 'READY':
-                for (const g of packet.d.guilds) {
-                    this.__handleGuilds.add(g.id);
-                }
-                this.botId = packet.d.user.id;
-                this.applicationId = packet.d.application.id;
-                this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                if (!this.__handleGuilds.size) {
-                    if ([...this.shards.values()].every(shard => shard.data.session_id) &&
-                        this.events.values.WORKER_READY &&
-                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                        node_worker_threads_1.parentPort.postMessage({
-                            type: 'WORKER_READY',
-                            workerId: this.workerId,
-                        });
-                        this.events.values.WORKER_READY.fired = true;
-                        await this.events.values.WORKER_READY.run(this.me, this, -1);
-                    }
-                }
-                this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
+            case 'GUILD_MEMBER_UPDATE':
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
                 break;
-            case 'INTERACTION_CREATE': {
-                await (0, oninteraction_1.onInteraction)(shardId, packet.d, this);
+            case 'PRESENCE_UPDATE':
+                await this.events.execute(packet.t, packet, this, shardId);
+                await this.cache.onPacket(packet);
                 break;
-            }
-            case 'GUILD_CREATE': {
-                if (this.__handleGuilds.has(packet.d.id)) {
-                    this.__handleGuilds.delete(packet.d.id);
-                    if (!this.__handleGuilds.size &&
-                        [...this.shards.values()].every(shard => shard.data.session_id) &&
-                        this.events.values.WORKER_READY &&
-                        (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
-                        node_worker_threads_1.parentPort.postMessage({
-                            type: 'WORKER_READY',
-                            workerId: this.workerId,
-                        });
-                        this.events.values.WORKER_READY.fired = true;
-                        await this.events.values.WORKER_READY.run(this.me, this, -1);
+            //rest of the events
+            default:
+                {
+                    switch (packet.t) {
+                        case 'READY':
+                            for (const g of packet.d.guilds) {
+                                this.__handleGuilds?.add(g.id);
+                            }
+                            this.botId = packet.d.user.id;
+                            this.applicationId = packet.d.application.id;
+                            this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
+                            if (!this.__handleGuilds?.size) {
+                                if ([...this.shards.values()].every(shard => shard.data.session_id) &&
+                                    this.events.values.WORKER_READY &&
+                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                                    node_worker_threads_1.parentPort.postMessage({
+                                        type: 'WORKER_READY',
+                                        workerId: this.workerId,
+                                    });
+                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                    delete this.__handleGuilds;
+                                }
+                            }
+                            this.debugger?.debug(`#${shardId} [${packet.d.user.username}](${this.botId}) is online...`);
+                            break;
+                        case 'INTERACTION_CREATE':
+                            await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
+                            break;
+                        case 'MESSAGE_CREATE':
+                            await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
+                            break;
+                        case 'GUILD_CREATE': {
+                            if (this.__handleGuilds?.has(packet.d.id)) {
+                                this.__handleGuilds.delete(packet.d.id);
+                                if (!this.__handleGuilds.size &&
+                                    [...this.shards.values()].every(shard => shard.data.session_id) &&
+                                    this.events.values.WORKER_READY &&
+                                    (this.events.values.WORKER_READY.fired ? !this.events.values.WORKER_READY.data.once : true)) {
+                                    node_worker_threads_1.parentPort.postMessage({
+                                        type: 'WORKER_READY',
+                                        workerId: this.workerId,
+                                    });
+                                    await this.events.runEvent('WORKER_READY', this, this.me, -1);
+                                }
+                                return;
+                            }
+                        }
                     }
-                    return;
+                    await this.events.execute(packet.t, packet, this, shardId);
                 }
-            }
+                break;
         }
-        await this.events.execute(packet.t, packet, this, shardId);
     }
 }
 exports.WorkerClient = WorkerClient;

package/lib/collection.d.ts

@@ -142,7 +142,7 @@ export declare class LimitedCollection<K, V> {
     private readonly data;
     private readonly options;
     private timeout;
-    constructor(options: Partial<LimitedCollectionOptions>);
+    constructor(options?: Partial<LimitedCollectionOptions>);
     /**
      * Adds an element to the limited collection.
      * @param key The key of the element.

package/lib/collection.js

@@ -203,7 +203,7 @@ class LimitedCollection {
     data = new Map();
     options;
     timeout = undefined;
-    constructor(options) {
+    constructor(options = {}) {
         this.options = (0, common_1.MergeOptions)(LimitedCollection.default, options);
     }
     /**
@@ -233,7 +233,7 @@ class LimitedCollection {
                 this.delete(iter.next().value);
             }
         }
-        if (this.closer.expireOn >= expireOn) {
+        if (this.closer.expireOn === expireOn) {
             this.resetTimeout();
         }
     }
@@ -263,10 +263,11 @@ class LimitedCollection {
     get(key) {
         const data = this.data.get(key);
         if (this.options.resetOnDemand && data && data.expire !== -1) {
-            if (this.closer?.expireOn === data.expireOn) {
-                setImmediate(() => this.resetTimeout());
-            }
+            const oldExpireOn = data.expireOn;
             data.expireOn = Date.now() + data.expire;
+            if (this.closer.expireOn === oldExpireOn) {
+                this.resetTimeout();
+            }
         }
         return data?.value;
     }
@@ -294,7 +295,9 @@ class LimitedCollection {
      * console.log(collection.delete(2)); // Output: false
      */
     delete(key) {
-        setImmediate(() => this.resetTimeout());
+        const value = this.raw(key);
+        if (value && value.expireOn === this.closer.expireOn)
+            setImmediate(() => this.resetTimeout());
         return this.data.delete(key);
     }
     /**