seyfert 0.1.0

package/lib/commands/optionresolver.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionResolver = void 0;
+const common_1 = require("../common");
+const structures_1 = require("../structures");
+const channels_1 = __importDefault(require("../structures/channels"));
+class OptionResolver {
+    client;
+    parent;
+    guildId;
+    resolved;
+    options;
+    hoistedOptions;
+    subCommand = null;
+    group = null;
+    constructor(client, options, parent, guildId, resolved) {
+        this.client = client;
+        this.parent = parent;
+        this.guildId = guildId;
+        this.resolved = resolved;
+        this.hoistedOptions = this.options = options.map(option => this.transformOption(option, resolved));
+        if (this.hoistedOptions[0]?.type === common_1.ApplicationCommandOptionType.Subcommand) {
+            this.subCommand = this.hoistedOptions[0].name;
+            this.hoistedOptions = this.hoistedOptions[0].options ?? [];
+        }
+        if (this.hoistedOptions[0]?.type === common_1.ApplicationCommandOptionType.SubcommandGroup) {
+            this.group = this.hoistedOptions[0].name;
+            this.subCommand = this.hoistedOptions[0].options[0].name;
+            this.hoistedOptions = this.hoistedOptions[0].options[0].options ?? [];
+        }
+    }
+    get fullCommandName() {
+        return `${this.parent?.name}${this.group ? ` ${this.group} ${this.subCommand}` : this.subCommand ? ` ${this.subCommand}` : ''}`;
+    }
+    getCommand() {
+        if (this.subCommand) {
+            return (this.parent?.options).find(x => (this.group ? x.group === this.group : true) && x.name === this.subCommand);
+        }
+        return this.parent;
+    }
+    getAutocompleteValue() {
+        return this.hoistedOptions.find(option => option.focused)?.value;
+    }
+    getAutocomplete() {
+        return (this.getCommand()?.options).find(option => option.name === this.hoistedOptions.find(x => x.focused)?.name);
+    }
+    getParent() {
+        return this.parent?.name;
+    }
+    getSubCommand() {
+        return this.subCommand;
+    }
+    getGroup() {
+        return this.group;
+    }
+    get(name) {
+        return this.options.find(opt => opt.name === name);
+    }
+    getHoisted(name) {
+        return this.hoistedOptions.find(x => x.name === name);
+    }
+    getValue(name) {
+        const option = this.getHoisted(name);
+        if (!option) {
+            return;
+        }
+        switch (option.type) {
+            case common_1.ApplicationCommandOptionType.Attachment:
+                return option.attachment;
+            case common_1.ApplicationCommandOptionType.Boolean:
+                return option.value;
+            case common_1.ApplicationCommandOptionType.Channel:
+                return option.channel;
+            case common_1.ApplicationCommandOptionType.Integer:
+            case common_1.ApplicationCommandOptionType.Number:
+                return option.value;
+            case common_1.ApplicationCommandOptionType.Role:
+                return option.role;
+            case common_1.ApplicationCommandOptionType.String:
+                return option.value;
+            case common_1.ApplicationCommandOptionType.User:
+                return option.member ?? option.user;
+            case common_1.ApplicationCommandOptionType.Mentionable:
+                return option.member ?? option.user ?? option.channel ?? option.role;
+            default:
+                return;
+        }
+    }
+    getTypedOption(name, allow) {
+        const option = this.getHoisted(name);
+        if (!option) {
+            throw new Error('Bad Option');
+        }
+        if (!allow.includes(option.type)) {
+            throw new Error('Bad Option');
+        }
+        return option;
+    }
+    getChannel(name) {
+        const option = this.getTypedOption(name, [common_1.ApplicationCommandOptionType.Channel]);
+        return option.channel;
+    }
+    getString(name) {
+        const option = this.getTypedOption(name, [common_1.ApplicationCommandOptionType.String]);
+        return option.value;
+    }
+    transformOption(option, resolved) {
+        const resolve = {
+            ...option,
+        };
+        if ('value' in option) {
+            resolve.value = option.value;
+        }
+        if ('options' in option) {
+            resolve.options = option.options?.map(x => this.transformOption(x, resolved));
+        }
+        if (resolved) {
+            const value = resolve.value;
+            const user = resolved.users?.[value];
+            if (user) {
+                resolve.user = new structures_1.User(this.client, user);
+            }
+            const member = resolved.members?.[value];
+            if (member) {
+                resolve.member = new structures_1.InteractionGuildMember(this.client, member, user, this.guildId);
+            }
+            const channel = resolved.channels?.[value];
+            if (channel) {
+                resolve.channel = (0, channels_1.default)(channel, this.client);
+            }
+            const role = resolved.roles?.[value];
+            if (role) {
+                resolve.role = new structures_1.GuildRole(this.client, role, this.guildId);
+            }
+            const attachment = resolved.attachments?.[value];
+            if (attachment) {
+                resolve.attachment = attachment;
+            }
+        }
+        return resolve;
+    }
+}
+exports.OptionResolver = OptionResolver;

package/lib/common/bot/watcher.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import type { GatewayDispatchPayload, GatewaySendPayload } from 'discord-api-types/v10';
+import { Worker } from 'node:worker_threads';
+import { REST } from '../../api';
+import { ShardManager, type ShardManagerOptions } from '../../websocket';
+import { Logger } from '../it/logger';
+import type { MakeRequired } from '../types/util';
+/**
+ * Represents a watcher class that extends the ShardManager.
+ */
+export declare class Watcher extends ShardManager {
+    worker?: Worker;
+    logger: Logger;
+    rest?: REST;
+    options: MakeRequired<WatcherOptions, 'intents' | 'token' | 'handlePayload' | 'info'>;
+    /**
+     * Initializes a new instance of the Watcher class.
+     * @param options The options for the watcher.
+     */
+    constructor(options: WatcherOptions);
+    /**
+     * Resets the worker instance.
+     */
+    resetWorker(): void;
+    /**
+     * Spawns shards for the watcher.
+     */
+    spawnShards(): Promise<void>;
+    /**
+     * Builds the watcher.
+     */
+    protected build(): void;
+}
+export interface WatcherOptions extends Omit<ShardManagerOptions, 'debug' | 'handlePayload' | 'info' | 'token' | 'intents'> {
+    filePath: string;
+    transpileCommand: string;
+    srcPath: string;
+    argv?: string[];
+    handlePayload?: ShardManagerOptions['handlePayload'];
+    info?: ShardManagerOptions['info'];
+    token?: ShardManagerOptions['token'];
+    intents?: ShardManagerOptions['intents'];
+}
+export interface WatcherPayload {
+    type: 'PAYLOAD';
+    shardId: number;
+    payload: GatewayDispatchPayload;
+}
+export interface WatcherSendToShard {
+    type: 'SEND_TO_SHARD';
+    shardId: number;
+    payload: GatewaySendPayload;
+}

package/lib/common/bot/watcher.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watcher = void 0;
+const chokidar_1 = require("chokidar");
+const node_child_process_1 = require("node:child_process");
+const node_worker_threads_1 = require("node:worker_threads");
+const api_1 = require("../../api");
+const base_1 = require("../../client/base");
+const websocket_1 = require("../../websocket");
+const logger_1 = require("../it/logger");
+/**
+ * Represents a watcher class that extends the ShardManager.
+ */
+class Watcher extends websocket_1.ShardManager {
+    worker;
+    logger = new logger_1.Logger({
+        name: '[Watcher]',
+    });
+    rest;
+    /**
+     * Initializes a new instance of the Watcher class.
+     * @param options The options for the watcher.
+     */
+    constructor(options) {
+        super({
+            handlePayload() { },
+            token: '',
+            intents: 0,
+            info: {
+                url: 'wss://gateway.discord.gg',
+                session_start_limit: {
+                    max_concurrency: -1,
+                    remaining: -1,
+                    reset_after: -1,
+                    total: -1,
+                },
+                shards: -1,
+            },
+            ...options,
+        });
+    }
+    /**
+     * Resets the worker instance.
+     */
+    resetWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+        }
+        this.build();
+        this.worker = new node_worker_threads_1.Worker(this.options.filePath, {
+            argv: this.options.argv,
+            workerData: {
+                __USING_WATCHER__: true,
+            },
+        });
+        this.worker.on('message', (data) => {
+            switch (data.type) {
+                case 'SEND_TO_SHARD':
+                    this.send(data.shardId, data.payload);
+                    break;
+            }
+        });
+    }
+    /**
+     * Spawns shards for the watcher.
+     */
+    async spawnShards() {
+        const RC = await base_1.BaseClient.prototype.getRC();
+        this.options.token = RC.token;
+        this.rest ??= new api_1.REST({
+            token: this.options.token,
+        });
+        this.options.intents = RC.intents;
+        this.options.info = await new api_1.Router(this.rest).createProxy().gateway.bot.get();
+        this.options.totalShards = this.options.info.shards;
+        this.resetWorker();
+        const oldFn = this.options.handlePayload;
+        this.options.handlePayload = (shardId, payload) => {
+            this.worker?.postMessage({
+                type: 'PAYLOAD',
+                shardId,
+                payload,
+            });
+            return oldFn?.(shardId, payload);
+        };
+        this.connectQueue.concurrency = this.options.info.session_start_limit.max_concurrency;
+        await super.spawnShards();
+        const watcher = (0, chokidar_1.watch)(this.options.srcPath).on('ready', () => {
+            this.logger.debug(`Watching ${this.options.srcPath}`);
+            watcher.on('all', event => {
+                this.logger.debug(`${event} event detected, building`);
+                this.resetWorker();
+            });
+        });
+    }
+    /**
+     * Builds the watcher.
+     */
+    build() {
+        (0, node_child_process_1.execSync)(`cd ${process.cwd()} && ${this.options.transpileCommand}`);
+        this.logger.info('Builded');
+    }
+}
+exports.Watcher = Watcher;

package/lib/common/index.d.ts

@@ -0,0 +1,13 @@
+export * from './it/constants';
+export * from './it/utils';
+export * from 'discord-api-types/v10';
+export * from './bot/watcher';
+export * from './it/colors';
+export * from './it/logger';
+export * from './shorters/channels';
+export * from './shorters/guilds';
+export * from './shorters/users';
+export * from './types/options';
+export * from './types/resolvables';
+export * from './types/util';
+export * from './types/write';

package/lib/common/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./it/constants"), exports);
+__exportStar(require("./it/utils"), exports);
+//
+__exportStar(require("discord-api-types/v10"), exports);
+__exportStar(require("./bot/watcher"), exports);
+__exportStar(require("./it/colors"), exports);
+__exportStar(require("./it/logger"), exports);
+__exportStar(require("./shorters/channels"), exports);
+__exportStar(require("./shorters/guilds"), exports);
+__exportStar(require("./shorters/users"), exports);
+__exportStar(require("./types/options"), exports);
+__exportStar(require("./types/resolvables"), exports);
+__exportStar(require("./types/util"), exports);
+__exportStar(require("./types/write"), exports);

package/lib/common/it/colors.d.ts

@@ -0,0 +1,274 @@
+export interface Code {
+    open: string;
+    close: string;
+    regexp: RegExp;
+}
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+export declare function rgb8(str: string, color: number): string;
+/**
+ * Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+export declare function bgRgb8(str: string, color: number): string;
+/**
+ * Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { rgb24 } from "./colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/**
+ * Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "./colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;