xernerx 4.1.0 → 4.2.1

package/dist/mjs/tools/package.d.ts

@@ -0,0 +1,49 @@
+declare const _default: {
+    name: string;
+    version: string;
+    type: string;
+    description: string;
+    main: string;
+    keywords: string[];
+    author: string;
+    license: string;
+    homepage: string;
+    packageManager: string;
+    exports: {
+        import: string;
+        require: string;
+        types: string;
+        node: null;
+        default: null;
+    };
+    scripts: {
+        start: string;
+        patch: string;
+        minor: string;
+        major: string;
+        site: string;
+        commit: string;
+        write: string;
+        build: string;
+    };
+    repository: {
+        type: string;
+        url: string;
+    };
+    bugs: {
+        url: string;
+    };
+    dependencies: {
+        '@sapphire/shapeshift': string;
+        'discord.js': string;
+        dumfunctions: string;
+        'xernerx-extension-builder': string;
+        zod: string;
+    };
+    devDependencies: {
+        prettier: string;
+        tsup: string;
+        typescript: string;
+    };
+};
+export default _default;

package/dist/mjs/tools/package.js

@@ -0,0 +1,48 @@
+export default {
+    name: 'xernerx',
+    version: '3.5.1',
+    type: 'module',
+    description: 'A bot framework for discord.js.',
+    main: 'dist/main.js',
+    keywords: ['discord.js', 'discord', 'framework', 'mjs', 'esm', 'cjs', 'ts'],
+    author: 'Dummi',
+    license: 'MIT',
+    homepage: 'https://xernerx.github.io/xernerx/home.html',
+    packageManager: 'npm@8.5.5',
+    exports: {
+        import: './dist/main.js',
+        require: './dist/main.cjs',
+        types: './types',
+        node: null,
+        default: null,
+    },
+    scripts: {
+        start: 'npm i && npm fund && npm audit fix --force && npm link && tsc -w',
+        patch: 'npm run write && git add . && npm run commit && npm version patch && npm publish && git push',
+        minor: 'npm run write && git add . && npm run commit && npm version minor && npm publish && git push',
+        major: 'npm run write && git add . && npm run commit && npm version major && npm publish && git push',
+        site: 'git add docs && npm run commit && git push',
+        commit: 'node ../.scripts/commit.js',
+        write: 'npm run build && node ../.scripts/rewritePackage.js ',
+        build: 'tsc && npx tsup src/main.ts && npx prettier --write src',
+    },
+    repository: {
+        type: 'git',
+        url: 'git+https://github.com/xernerx/xernerx.git',
+    },
+    bugs: {
+        url: 'https://github.com/xernerx/xernerx/issues',
+    },
+    dependencies: {
+        '@sapphire/shapeshift': '^3.8.1',
+        'discord.js': '^14.7.1',
+        dumfunctions: '^2.1.1',
+        'xernerx-extension-builder': '^0.0.5',
+        zod: '^3.20.6',
+    },
+    devDependencies: {
+        prettier: '^2.8.4',
+        tsup: '^6.6.0',
+        typescript: '^4.9.5',
+    },
+};

package/dist/mjs/types/enums.d.ts

@@ -0,0 +1,44 @@
+import {
+    SlashCommandStringOption,
+    SlashCommandNumberOption,
+    SlashCommandIntegerOption,
+    SlashCommandBooleanOption,
+    SlashCommandUserOption,
+    SlashCommandChannelOption,
+    SlashCommandRoleOption,
+    SlashCommandMentionableOption,
+} from 'discord.js';
+export declare enum InhibitorType {
+    Member = 'Member',
+    User = 'User',
+    Guild = 'Guild',
+    SlashCommand = 'SlashCommand',
+    MessageCommand = 'MessageCommand',
+    ContextCommand = 'ContextCommand',
+    Command = 'Command',
+    Message = 'Message',
+    Interaction = 'Interaction',
+    Channel = 'Channel',
+}
+export declare enum CommandType {
+    Message = 'MessageCommand',
+    Slash = 'SlashCommand',
+    Context = 'ContextCommand',
+    Event = 'Event',
+    Inhibitor = 'Inhibitor',
+    MessageCommand = 'MessageCommand',
+    SlashCommand = 'SlashCommand',
+    ContextCommand = 'ContextCommand',
+}
+export declare enum ContextCommandType {
+    Message = 3,
+    User = 2,
+}
+export declare enum EventEmitterType {
+    Client = 'client',
+    Rest = 'rest',
+    Process = 'process',
+}
+export type SlashCommandOptionChoices = SlashCommandStringOption | SlashCommandNumberOption | SlashCommandIntegerOption;
+export type SlashCommandOption = SlashCommandOptionChoices | SlashCommandBooleanOption | SlashCommandUserOption | SlashCommandChannelOption | SlashCommandRoleOption | SlashCommandMentionableOption;
+export type SlashArgumentTypes = 'String' | 'Number' | 'Boolean' | 'User' | 'Channel' | 'Role' | 'Mentionable' | 'Integer';

package/dist/mjs/types/enums.js

@@ -0,0 +1,35 @@
+export var InhibitorType;
+(function (InhibitorType) {
+    InhibitorType['Member'] = 'Member';
+    InhibitorType['User'] = 'User';
+    InhibitorType['Guild'] = 'Guild';
+    InhibitorType['SlashCommand'] = 'SlashCommand';
+    InhibitorType['MessageCommand'] = 'MessageCommand';
+    InhibitorType['ContextCommand'] = 'ContextCommand';
+    InhibitorType['Command'] = 'Command';
+    InhibitorType['Message'] = 'Message';
+    InhibitorType['Interaction'] = 'Interaction';
+    InhibitorType['Channel'] = 'Channel';
+})((InhibitorType = InhibitorType || (InhibitorType = {})));
+export var CommandType;
+(function (CommandType) {
+    CommandType['Message'] = 'MessageCommand';
+    CommandType['Slash'] = 'SlashCommand';
+    CommandType['Context'] = 'ContextCommand';
+    CommandType['Event'] = 'Event';
+    CommandType['Inhibitor'] = 'Inhibitor';
+    CommandType['MessageCommand'] = 'MessageCommand';
+    CommandType['SlashCommand'] = 'SlashCommand';
+    CommandType['ContextCommand'] = 'ContextCommand';
+})((CommandType = CommandType || (CommandType = {})));
+export var ContextCommandType;
+(function (ContextCommandType) {
+    ContextCommandType[(ContextCommandType['Message'] = 3)] = 'Message';
+    ContextCommandType[(ContextCommandType['User'] = 2)] = 'User';
+})((ContextCommandType = ContextCommandType || (ContextCommandType = {})));
+export var EventEmitterType;
+(function (EventEmitterType) {
+    EventEmitterType['Client'] = 'client';
+    EventEmitterType['Rest'] = 'rest';
+    EventEmitterType['Process'] = 'process';
+})((EventEmitterType = EventEmitterType || (EventEmitterType = {})));

package/dist/mjs/types/interfaces.d.ts

@@ -0,0 +1,25 @@
+import { Collection } from 'discord.js';
+import CommandHandler from '../handlers/CommandHandler.js';
+import EventHandler from '../handlers/EventHandler.js';
+import InhibitorHandler from '../handlers/InhibitorHandler.js';
+import MessageCommandBuilder from '../build/MessageCommandBuilder.js';
+import ContextCommandBuilder from '../build/ContextCommandBuilder.js';
+import SlashCommandBuilder from '../build/SlashCommandBuilder.js';
+export interface ClientCommands {
+    message: Collection<string, MessageCommandBuilder>;
+    slash: Collection<string, SlashCommandBuilder>;
+    context: Collection<string, ContextCommandBuilder>;
+}
+export interface ClientCache {
+    messages: Collection<string, object>;
+    cooldowns: Collection<string, object>;
+    messageCommands: Collection<string, object>;
+    slashCommands: Collection<string, object>;
+    contextCommands: Collection<string, object>;
+    commands: Collection<string, object>;
+}
+export interface ClientModules {
+    commandHandler: CommandHandler;
+    eventHandler: EventHandler;
+    inhibitorHandler: InhibitorHandler;
+}

package/dist/mjs/types/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/types/options.d.ts

@@ -0,0 +1,241 @@
+import { CacheFactory, ChannelType, ContextMenuCommandType, MessageMentionOptions, Partials, PresenceData, RESTOptions, SweeperOptions, WebSocketOptions } from 'discord.js';
+import XernerxExtensionBuilder from 'xernerx-extension-builder';
+import { InhibitorType } from './enums.js';
+import { EventEmitterType, Localizations, MessageCommandArgsTypes } from './types.js';
+export interface DiscordOptions {
+    shards?: number | number[] | 'auto';
+    closeTimeout?: number;
+    shardCount?: number;
+    makeCache?: CacheFactory;
+    allowedMentions?: MessageMentionOptions;
+    partials?: Array<Partials>;
+    failIfNotExists?: boolean;
+    presence?: PresenceData;
+    intents: number[];
+    waitGuildTimeout?: number;
+    sweepers?: SweeperOptions;
+    ws?: WebSocketOptions;
+    rest?: RESTOptions;
+    jsonTransformer?: (obj: unknown) => unknown;
+}
+export interface ClientOptions {
+    ownerId?: string | string[];
+    permissions?: {
+        client?: Array<string>;
+        user?: Array<string>;
+        dm?: boolean;
+    };
+    ignore?: {
+        owner?: boolean;
+        users: Array<string>;
+        channels: Array<string>;
+        guilds: Array<string>;
+    };
+    log?: {
+        ready: boolean;
+        error: boolean;
+    };
+    cooldown?: {
+        command?: number;
+        cache?: number;
+    };
+}
+export interface HandlerOptions {
+    message?: MessageCommandHandlerOptions;
+    slash?: SlashCommandHandlerOptions;
+    context?: ContextCommandHandlerOptions;
+    events?: EventHandlerOptions;
+    inhibitors?: InhibitorHandlerOptions;
+}
+export interface ExtensionOptions {
+    extensions: Array<XernerxExtensionBuilder>;
+    logging?: boolean;
+}
+export interface MessageCommandOptions {
+    name: string;
+    aliases?: Array<string>;
+    separator?: string;
+    description?: string;
+    info?: string;
+    category?: string;
+    prefix?: Array<string> | string;
+    regex?: string;
+    channelType?: Array<number>;
+    cooldown?: number;
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    permissions?: {
+        client?: Array<string>;
+        user?: Array<string>;
+        dm?: boolean;
+    };
+    args?: Array<MessageArgumentOptions>;
+}
+export interface ContextCommandOptions {
+    name: string;
+    type: ContextMenuCommandType;
+    nameLocalizations: Record<Localizations, string>;
+    description?: string;
+    info?: string;
+    category?: string;
+    channelType?: Array<number> | number;
+    cooldown?: number;
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    permissions?: {
+        client?: Array<string>;
+        users?: Array<string>;
+        dm?: boolean;
+    };
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetch?: boolean;
+    };
+}
+export interface MessageArgumentOptions {
+    type: MessageCommandArgsTypes;
+    content?: Array<string>;
+    match?: string;
+    name: string;
+    prompt?: {
+        reply: string;
+        send: string;
+    };
+    default?: string | Function;
+}
+export interface SlashArgumentOptions {
+    type: 'string' | 'number' | 'boolean' | 'user' | 'channel' | 'role' | 'mentionable' | 'integer';
+    name: string;
+    choices: Array<{
+        name: string;
+        value: string;
+    }>;
+    required: boolean;
+    description: string;
+}
+export interface SlashSubcommandOptions {
+    name: string;
+    description: string;
+    args: Array<SlashArgumentOptions>;
+}
+export interface SlashGroupOptions {
+    name: string;
+    description: string;
+    subcommands: Array<SlashSubcommandOptions>;
+}
+export interface SlashCommandOptions {
+    name: string;
+    description: string;
+    info?: string;
+    category?: string;
+    owner?: boolean;
+    channelType?: ChannelType;
+    cooldown?: number;
+    ignore?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    strict?: {
+        owner?: boolean;
+        users?: Array<string>;
+        channels?: Array<string>;
+        guilds?: Array<string>;
+    };
+    permissions: {
+        client?: Array<string>;
+        users?: Array<string>;
+        dm?: boolean;
+    };
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+    args?: Array<SlashArgumentOptions>;
+    subcommands?: Array<SlashSubcommandOptions>;
+    groups?: Array<SlashGroupOptions>;
+}
+export interface MessageCommandHandlerOptions {
+    directory: string;
+    prefix: string[] | string;
+    allowMention?: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    handleEdits?: boolean;
+    handleDeletes?: boolean;
+    handleTyping?: boolean;
+    util?: boolean;
+    logging?: boolean;
+}
+export interface SlashCommandHandlerOptions {
+    directory: string;
+    guildId: string;
+    global: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    util?: boolean;
+    logging?: boolean;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface ContextCommandHandlerOptions {
+    directory: string;
+    guildId: string;
+    global: boolean;
+    cooldown?: number;
+    userPermissions?: bigint[];
+    clientPermissions?: bigint[];
+    util?: boolean;
+    logging?: boolean;
+    defer?: {
+        reply?: boolean;
+        ephemeral?: boolean;
+        fetchReply?: boolean;
+    };
+}
+export interface EventHandlerOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface EventOptions {
+    name: string;
+    emitter?: EventEmitterType | string;
+    type?: 'discord' | string;
+    once?: boolean;
+}
+export interface InhibitorHandlerOptions {
+    directory: string;
+    logging?: boolean;
+}
+export interface InhibitorOptions {
+    name: string;
+    type: InhibitorType;
+}

package/dist/mjs/types/options.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/types/types.d.ts

@@ -0,0 +1,61 @@
+import { TextChannel, Message, User, Guild, GuildMember, Channel, Role, InteractionResponse } from 'discord.js';
+import { InteractionCommandUtil, MessageCommandUtil } from '../utils/CommandUtil.js';
+export interface XernerxMessage extends Message {
+    util?: MessageCommandUtil;
+    response?: string;
+}
+export interface XernerxInteraction extends InteractionResponse {
+    util: InteractionCommandUtil;
+    options?: {
+        _group: string;
+        _subcommand: string;
+        _hoistedOptions: Array<{
+            name: string;
+            channel: Channel;
+            user: XernerxUser;
+            role: XernerxRole;
+            value: string;
+        }>;
+    };
+}
+export interface XernerxUser extends User {
+    isOwner: boolean;
+}
+export interface XernerxRole extends Role {}
+export interface XernerxTextChannel extends TextChannel {}
+export interface XernerxGuild extends Guild {}
+export interface XernerxMember extends GuildMember {}
+export type MessageCommandArgsTypes = 'rest' | 'option' | 'flag' | 'string' | 'number' | 'channel' | 'user' | 'member' | 'boolean' | 'role';
+export type Localizations =
+    | 'id'
+    | 'da'
+    | 'de'
+    | 'en-GB'
+    | 'en-US'
+    | 'es-ES'
+    | 'fr'
+    | 'hr'
+    | 'it'
+    | 'lt'
+    | 'hu'
+    | 'nl'
+    | 'no'
+    | 'pl'
+    | 'pt-BR'
+    | 'ro'
+    | 'fi'
+    | 'sv-SE'
+    | 'vi'
+    | 'tr'
+    | 'cs'
+    | 'el'
+    | 'bg'
+    | 'ru'
+    | 'uk'
+    | 'hi'
+    | 'th'
+    | 'zh-CN'
+    | 'ja'
+    | 'zh-TW'
+    | 'ko';
+export type EventEmitterType = 'client' | 'process';

package/dist/mjs/types/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/utils/ClientUtil.d.ts

@@ -0,0 +1,25 @@
+import { ActivityType, ClientPresenceStatus } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+interface Presence {
+    text?: string;
+    type?: ActivityType.Playing | ActivityType.Streaming | ActivityType.Listening | ActivityType.Watching | ActivityType.Competing;
+    link?: string;
+    status?: ClientPresenceStatus;
+    interval?: number;
+}
+export declare class ClientUtil {
+    client: XernerxClient;
+    constructor(client: XernerxClient);
+    uptime(timestamp: number | null): string;
+    getSubcommands(name: string): object[];
+    isOwner(userId: string): boolean;
+    getAllCommands(): object[];
+    getAllMessageCommands(): object[];
+    getAllSlashCommands(): object[];
+    getAllContextCommands(): object[];
+    setPresence(options: Presence): void;
+    getCooldowns(id: string, command?: string): any;
+    getCooldownTimers(id: string, command?: string): any;
+    defer(time: number): Promise<unknown>;
+}
+export {};