seyfert 1.4.0 → 2.0.0

package/lib/client/onmessagecreate.js

@@ -1,395 +0,0 @@
-"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 rawParentName = commandRaw[0];
-    const rawGroupName = commandRaw.length === 3 ? commandRaw[1] : undefined;
-    const rawSubcommandName = rawGroupName ? commandRaw[2] : commandRaw[1];
-    const parent = self.commands.values.find(x => (!('ignore' in x) || x.ignore !== __1.IgnoreCommand.Message) &&
-        (x.name === rawParentName || ('aliases' in x ? x.aliases?.includes(rawParentName) : false)));
-    const fullCommandName = `${rawParentName}${rawGroupName ? ` ${rawGroupName} ${rawSubcommandName}` : `${rawSubcommandName ? ` ${rawSubcommandName}` : ''}`}`;
-    if (!(parent instanceof __1.Command))
-        return { fullCommandName };
-    if (rawGroupName && !parent.groups?.[rawGroupName] && !parent.groupsAliases?.[rawGroupName])
-        return getCommandFromContent([rawParentName, rawGroupName], self);
-    if (rawSubcommandName &&
-        !parent.options?.some(x => x instanceof __1.SubCommand && (x.name === rawSubcommandName || x.aliases?.includes(rawSubcommandName))))
-        return getCommandFromContent([rawParentName], self);
-    const groupName = rawGroupName ? parent.groupsAliases?.[rawGroupName] || rawGroupName : undefined;
-    const command = groupName || rawSubcommandName
-        ? parent.options?.find(opt => {
-            if (opt instanceof __1.SubCommand) {
-                if (groupName) {
-                    if (opt.group !== groupName)
-                        return false;
-                }
-                if (opt.group && !groupName)
-                    return false;
-                return rawSubcommandName === opt.name || opt.aliases?.includes(rawSubcommandName);
-            }
-            return false;
-        })
-        : parent;
-    return {
-        command,
-        fullCommandName,
-        parent,
-    };
-}
-async function onMessageCreate(self, rawMessage, shardId) {
-    if (!self.options?.commands?.prefix)
-        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)
-        .slice(0, 3), self);
-    if (!command)
-        return;
-    if (!command.run)
-        return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
-    if (!command.contexts?.includes(__1.InteractionContextTypes.BOT_DM) && !message.guildId)
-        return;
-    if (command.guildId && !command.guildId?.includes(message.guildId))
-        return;
-    const resolved = {
-        channels: {},
-        roles: {},
-        users: {},
-        members: {},
-        attachments: {},
-    };
-    let newContent = content;
-    for (const i of fullCommandName.split(' ')) {
-        newContent = newContent.slice(newContent.indexOf(i) + i.length);
-    }
-    const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(newContent.slice(1), command, message);
-    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, command);
-    //@ts-expect-error
-    const extendContext = self.options?.context?.(message) ?? {};
-    Object.assign(context, extendContext);
-    try {
-        if (command.defaultMemberPermissions && message.guildId) {
-            const memberPermissions = await self.members.permissions(message.guildId, message.author.id);
-            const permissions = memberPermissions.missings(...memberPermissions.values([command.defaultMemberPermissions]));
-            if (!memberPermissions.has('Administrator') &&
-                permissions.length &&
-                (await message.guild()).ownerId !== message.author.id) {
-                return command.onPermissionsFail?.(context, memberPermissions.keys(permissions));
-            }
-        }
-        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 (!appPermissions.has('Administrator') && permissions.length) {
-                return command.onBotPermissionsFail?.(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, context.command, 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 ?? [])) {
-        try {
-            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)) ||
-                            args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const channel = (await self.cache.channels?.get(rawId)) ?? (i.required ? await self.channels.fetch(rawId) : undefined);
-                            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;
-                                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 = (await self.cache.roles?.get(rawId)) ??
-                                        (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
-                                    if (role) {
-                                        value = rawId;
-                                        resolved.roles[rawId] = role;
-                                        break;
-                                    }
-                                }
-                            }
-                            else {
-                                const rawId = match.slice(2);
-                                const raw = message.mentions.find(x => rawId === x.id);
-                                if (raw) {
-                                    const { member, ...user } = raw;
-                                    value = raw.id;
-                                    resolved.users[raw.id] = user;
-                                    if (member)
-                                        resolved.members[raw.id] = member;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Role:
-                    {
-                        const rawId = message.mention_roles.find(x => args[i.name]?.includes(x)) || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const role = (await self.cache.roles?.get(rawId)) ??
-                                (i.required ? (await self.roles.list(message.guild_id)).find(x => x.id === rawId) : undefined);
-                            if (role) {
-                                value = rawId;
-                                resolved.roles[rawId] = role;
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.User:
-                    {
-                        const rawId = message.mentions.find(x => args[i.name]?.includes(x.id))?.id || args[i.name]?.match(/[0-9]{17,19}/g)?.[0];
-                        if (rawId) {
-                            const raw = message.mentions.find(x => args[i.name]?.includes(x.id)) ??
-                                (await self.cache.users?.get(rawId)) ??
-                                (i.required ? await self.users.fetch(rawId) : undefined);
-                            if (raw) {
-                                value = raw.id;
-                                if (raw instanceof __1.User) {
-                                    resolved.users[raw.id] = raw;
-                                    if (message.guild_id) {
-                                        const member = message.mentions.find(x => args[i.name]?.includes(x.id))?.member ??
-                                            (await self.cache.members?.get(rawId, message.guild_id)) ??
-                                            (i.required ? await self.members.fetch(rawId, message.guild_id) : undefined);
-                                        if (member)
-                                            resolved.members[raw.id] = member;
-                                    }
-                                }
-                                else {
-                                    const { member, ...user } = raw;
-                                    resolved.users[user.id] = user;
-                                    if (member)
-                                        resolved.members[user.id] = member;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.String:
-                    {
-                        value = args[i.name];
-                        const option = i;
-                        if (!value)
-                            break;
-                        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) {
-                            const choice = option.choices.find(x => x.name === value);
-                            if (!choice) {
-                                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 = choice.value;
-                        }
-                    }
-                    break;
-                case v10_1.ApplicationCommandOptionType.Number:
-                case v10_1.ApplicationCommandOptionType.Integer:
-                    {
-                        const option = i;
-                        if (!option.choices?.length) {
-                            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;
-                            }
-                            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;
-                                }
-                            }
-                            break;
-                        }
-                        const choice = option.choices.find(x => x.name === args[i.name]);
-                        if (!choice) {
-                            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 = choice.value;
-                    }
-                    break;
-                default:
-                    break;
-            }
-            if (value !== undefined) {
-                options.push({
-                    name: i.name,
-                    type: i.type,
-                    value,
-                });
-            }
-            else if (i.required)
-                if (!errors.some(x => x.name === i.name))
-                    errors.push({
-                        error: 'Option is required but returned undefined',
-                        name: i.name,
-                    });
-        }
-        catch (e) {
-            errors.push({
-                error: e && typeof e === 'object' && 'message' in e ? e.message : `${e}`,
-                name: i.name,
-            });
-        }
-    }
-    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/structures/extra/functions.d.ts

@@ -1,12 +0,0 @@
-import type { APIPartialEmoji } from 'discord-api-types/v10';
-import type { Cache } from '../../cache';
-import type { TypeArray } from '../../common';
-import type { EmojiResolvable } from '../../common/types/resolvables';
-/** * Convert a timestamp to a snowflake. * @param timestamp The timestamp to convert. * @returns The snowflake. */
-export declare function snowflakeToTimestamp(id: string): bigint;
-export declare function channelLink(channelId: string, guildId?: string): string;
-export declare function messageLink(channelId: string, messageId: string, guildId?: string): string;
-export declare function resolvePartialEmoji(emoji: EmojiResolvable): APIPartialEmoji | undefined;
-export declare function resolveEmoji(emoji: EmojiResolvable, cache: Cache): Promise<APIPartialEmoji | undefined>;
-export declare function encodeEmoji(rawEmoji: APIPartialEmoji): string;
-export declare function hasProps<T extends Record<any, any>>(target: T, props: TypeArray<keyof T>): boolean;

package/lib/structures/extra/functions.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasProps = exports.encodeEmoji = exports.resolveEmoji = exports.resolvePartialEmoji = exports.messageLink = exports.channelLink = exports.snowflakeToTimestamp = void 0;
-const globals_1 = require("discord-api-types/globals");
-const common_1 = require("../../common");
-/** * Convert a timestamp to a snowflake. * @param timestamp The timestamp to convert. * @returns The snowflake. */
-function snowflakeToTimestamp(id) {
-    return (BigInt(id) >> 22n) + common_1.DiscordEpoch;
-}
-exports.snowflakeToTimestamp = snowflakeToTimestamp;
-function channelLink(channelId, guildId) {
-    return `https://discord.com/channels/${guildId ?? '@me'}/${channelId}`;
-}
-exports.channelLink = channelLink;
-function messageLink(channelId, messageId, guildId) {
-    return `${channelLink(channelId, guildId)}/${messageId}`;
-}
-exports.messageLink = messageLink;
-function resolvePartialEmoji(emoji) {
-    if (typeof emoji === 'string') {
-        const groups = emoji.match(globals_1.FormattingPatterns.Emoji)?.groups;
-        if (groups) {
-            return { animated: !!groups.animated, name: groups.name, id: groups.id };
-        }
-        if (emoji.includes('%')) {
-            emoji = encodeURIComponent(emoji);
-        }
-        if (!emoji.includes(':') && !emoji.match(/\d{17,20}/g)) {
-            return { name: emoji, id: null };
-        }
-        return;
-    }
-    if (!(emoji.id && emoji.name))
-        return;
-    return { id: emoji.id, name: emoji.name, animated: !!emoji.animated };
-}
-exports.resolvePartialEmoji = resolvePartialEmoji;
-async function resolveEmoji(emoji, cache) {
-    const partial = resolvePartialEmoji(emoji);
-    if (partial)
-        return partial;
-    if (typeof emoji === 'string') {
-        if (!emoji.match(/\d{17,20}/g))
-            return;
-        const fromCache = await cache.emojis?.get(emoji);
-        return fromCache && { animated: fromCache.animated, id: fromCache.id, name: fromCache.name };
-    }
-    const fromCache = await cache.emojis?.get(emoji.id);
-    if (fromCache)
-        return { animated: fromCache.animated, id: fromCache.id, name: fromCache.name };
-    return;
-}
-exports.resolveEmoji = resolveEmoji;
-function encodeEmoji(rawEmoji) {
-    return rawEmoji.id ? `${rawEmoji.name}:${rawEmoji.id}` : `${rawEmoji.name}`;
-}
-exports.encodeEmoji = encodeEmoji;
-function hasProps(target, props) {
-    if (Array.isArray(props)) {
-        return props.every(x => hasProps(target, x));
-    }
-    if (!(props in target)) {
-        return false;
-    }
-    if (typeof target[props] === 'string' && !target[props].length) {
-        return false;
-    }
-    return true;
-}
-exports.hasProps = hasProps;