seyfert 0.1.0

package/lib/common/it/logger.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevels = void 0;
+const colors_1 = require("./colors");
+const utils_1 = require("./utils");
+var LogLevels;
+(function (LogLevels) {
+    LogLevels[LogLevels["Debug"] = 0] = "Debug";
+    LogLevels[LogLevels["Info"] = 1] = "Info";
+    LogLevels[LogLevels["Warn"] = 2] = "Warn";
+    LogLevels[LogLevels["Error"] = 3] = "Error";
+    LogLevels[LogLevels["Fatal"] = 4] = "Fatal";
+})(LogLevels || (exports.LogLevels = LogLevels = {}));
+/**
+ * Represents a logger utility for logging messages with various log levels.
+ */
+class Logger {
+    /**
+     * The options for configuring the logger.
+     */
+    options;
+    /**
+     * The custom callback function for logging.
+     */
+    static __callback;
+    /**
+     * Allows customization of the logging behavior by providing a custom callback function.
+     * @param cb The custom callback function for logging.
+     * @example
+     * Logger.customize((logger, level, args) => {
+     *     // Custom logging implementation
+     * });
+     */
+    static customize(cb) {
+        Logger.__callback = cb;
+    }
+    /**
+     * Constructs a new Logger instance with the provided options.
+     * @param options The options for configuring the logger.
+     */
+    constructor(options) {
+        this.options = (0, utils_1.MergeOptions)(Logger.DEFAULT_OPTIONS, options);
+    }
+    /**
+     * Sets the log level of the logger.
+     */
+    set level(level) {
+        this.options.logLevel = level;
+    }
+    /**
+     * Gets the log level of the logger.
+     */
+    get level() {
+        return this.options.logLevel;
+    }
+    /**
+     * Sets whether the logger is active or not.
+     */
+    set active(active) {
+        this.options.active = active;
+    }
+    /**
+     * Gets whether the logger is active or not.
+     */
+    get active() {
+        return this.options.active;
+    }
+    /**
+     * Sets the name of the logger.
+     */
+    set name(name) {
+        this.options.name = name;
+    }
+    /**
+     * Gets the name of the logger.
+     */
+    get name() {
+        return this.options.name;
+    }
+    /**
+     * Logs a message with the specified log level.
+     * @param level The log level.
+     * @param args The arguments to log.
+     * @returns The logged message.
+     */
+    rawLog(level, ...args) {
+        if (!this.active)
+            return;
+        if (level < this.level)
+            return;
+        let log;
+        if (!Logger.__callback) {
+            const color = Logger.colorFunctions.get(level) ?? Logger.noColor;
+            const memoryData = process.memoryUsage();
+            const date = new Date();
+            log = [
+                (0, colors_1.brightBlack)(formatMemoryUsage(memoryData.rss)),
+                (0, colors_1.bgBrightWhite)((0, colors_1.black)(`[${date.toLocaleDateString()} ${date.toLocaleTimeString()}]`)),
+                color(Logger.prefixes.get(level) ?? 'DEBUG'),
+                this.name ? `${this.name} >` : '>',
+                ...args,
+            ];
+        }
+        else {
+            log = Logger.__callback(this, level, args);
+        }
+        return console.log(...log);
+    }
+    /**
+     * Logs a debug message.
+     * @param args The arguments to log.
+     */
+    debug(...args) {
+        this.rawLog(LogLevels.Debug, ...args);
+    }
+    /**
+     * Logs an info message.
+     * @param args The arguments to log.
+     */
+    info(...args) {
+        this.rawLog(LogLevels.Info, ...args);
+    }
+    /**
+     * Logs a warning message.
+     * @param args The arguments to log.
+     */
+    warn(...args) {
+        this.rawLog(LogLevels.Warn, ...args);
+    }
+    /**
+     * Logs an error message.
+     * @param args The arguments to log.
+     */
+    error(...args) {
+        this.rawLog(LogLevels.Error, ...args);
+    }
+    /**
+     * Logs a fatal error message.
+     * @param args The arguments to log.
+     */
+    fatal(...args) {
+        this.rawLog(LogLevels.Fatal, ...args);
+    }
+    /**
+     * The default options for the logger.
+     */
+    static DEFAULT_OPTIONS = {
+        logLevel: LogLevels.Debug,
+        name: 'seyfert',
+        active: true,
+    };
+    /**
+     * A function that returns the input string as is, without any color modification.
+     * @param msg The message to log.
+     * @returns The input message as is.
+     */
+    static noColor(msg) {
+        return msg;
+    }
+    /**
+     * A map containing color functions for different log levels.
+     */
+    static colorFunctions = new Map([
+        [LogLevels.Debug, colors_1.gray],
+        [LogLevels.Info, colors_1.cyan],
+        [LogLevels.Warn, colors_1.yellow],
+        [LogLevels.Error, colors_1.red],
+        [LogLevels.Fatal, (str) => (0, colors_1.red)((0, colors_1.bold)((0, colors_1.italic)(str)))],
+    ]);
+    /**
+     * A map containing prefixes for different log levels.
+     */
+    static prefixes = new Map([
+        [LogLevels.Debug, 'DEBUG'],
+        [LogLevels.Info, 'INFO'],
+        [LogLevels.Warn, 'WARN'],
+        [LogLevels.Error, 'ERROR'],
+        [LogLevels.Fatal, 'FATAL'],
+    ]);
+}
+exports.Logger = Logger;
+/**
+ * Formats memory usage data into a string.
+ * @param data The memory usage data.
+ * @returns The formatted string representing memory usage.
+ */
+function formatMemoryUsage(data) {
+    return `[RAM Usage ${Math.round((data / 1024 / 1024) * 100) / 100} MB]`;
+}

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

@@ -0,0 +1,107 @@
+import { type ColorResolvable, type Logger, type ObjectToLower, type ObjectToSnake } from '..';
+/**
+ * Resolves the color to a numeric representation.
+ * @param color The color to resolve.
+ * @returns The numeric representation of the color.
+ */
+export declare function resolveColor(color: ColorResolvable): number;
+/**
+ * Flattens an array to a certain depth.
+ * @param arr The array to flatten.
+ * @returns The flattened array.
+ */
+export declare function fastFlat<A extends any[]>(arr: A): FlatArray<A, 1>[];
+/**
+ * Creates a new array with the results of calling a provided function on every element in the array.
+ * @param arr The array to iterate over.
+ * @param fn The function that produces an element of the new array.
+ * @returns A new array with the results of calling the provided function on every element in the array.
+ */
+export declare function fastMap<U, T extends any[]>(arr: T, fn: (value: T[number], index: number, array: T) => U): U[];
+/**
+ * Delays the resolution of a Promise by the specified time.
+ * @param time The time in milliseconds to delay the resolution.
+ * @param result The value to resolve with after the delay.
+ * @returns A Promise that resolves after the specified time with the provided result.
+ */
+export declare function delay<T>(time: number, result?: T): Promise<T>;
+/**
+ * Checks if a given value is an object.
+ * @param o The value to check.
+ * @returns `true` if the value is an object, otherwise `false`.
+ */
+export declare function isObject(o: any): boolean;
+/**
+ * Merges multiple options objects together, deeply extending objects.
+ * @param defaults The default options object.
+ * @param options Additional options objects to merge.
+ * @returns The merged options object.
+ */
+export declare function MergeOptions<T>(defaults: any, ...options: any[]): T;
+/**
+ * Splits an array into two arrays based on the result of a predicate function.
+ * @param arr The array to split.
+ * @param func The predicate function used to test elements of the array.
+ * @returns An object containing two arrays: one with elements that passed the test and one with elements that did not.
+ */
+export declare function filterSplit<Element, Predicate extends (value: Element) => boolean>(arr: Element[], func: Predicate): {
+    expect: Element[];
+    never: Element[];
+};
+/**
+ * Represents a base handler class.
+ */
+export declare class BaseHandler {
+    protected logger: Logger;
+    /**
+     * Initializes a new instance of the BaseHandler class.
+     * @param logger The logger instance.
+     */
+    constructor(logger: Logger);
+    /**
+     * Filters a file path.
+     * @param path The path to filter.
+     * @returns `true` if the path passes the filter, otherwise `false`.
+     */
+    protected filter: (path: string) => boolean;
+    /**
+     * Recursively retrieves all files in a directory.
+     * @param dir The directory path.
+     * @returns A Promise that resolves to an array of file paths.
+     */
+    protected getFiles(dir: string): Promise<string[]>;
+    /**
+     * Loads files from given paths.
+     * @param paths The paths of the files to load.
+     * @returns A Promise that resolves to an array of loaded files.
+     */
+    protected loadFiles<T extends NonNullable<unknown>>(paths: string[]): Promise<T[]>;
+    /**
+     * Loads files from given paths along with additional information.
+     * @param paths The paths of the files to load.
+     * @returns A Promise that resolves to an array of objects containing name, file, and path.
+     */
+    protected loadFilesK<T>(paths: string[]): Promise<{
+        name: string;
+        file: T;
+        path: string;
+    }[]>;
+}
+/**
+ * Convert a camelCase object to snake_case.
+ * @param target The object to convert.
+ * @returns The converted object.
+ */
+export declare function toSnakeCase<Obj extends Record<string, any>>(target: Obj): ObjectToSnake<Obj>;
+/**
+ * Convert a snake_case object to camelCase.
+ * @param target The object to convert.
+ * @returns The converted object.
+ */
+export declare function toCamelCase<Obj extends Record<string, any>>(target: Obj): ObjectToLower<Obj>;
+export declare const ReplaceRegex: {
+    camel: (s: string) => string;
+    snake: (s: string) => string;
+};
+export declare function magicImport(path: string): Promise<any>;
+export type OnFailCallback = (error: unknown) => any;

package/lib/common/it/utils.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magicImport = exports.ReplaceRegex = exports.toCamelCase = exports.toSnakeCase = exports.BaseHandler = exports.filterSplit = exports.MergeOptions = exports.isObject = exports.delay = exports.fastMap = exports.fastFlat = exports.resolveColor = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const promises_2 = require("node:timers/promises");
+const __1 = require("..");
+/**
+ * Resolves the color to a numeric representation.
+ * @param color The color to resolve.
+ * @returns The numeric representation of the color.
+ */
+function resolveColor(color) {
+    switch (typeof color) {
+        case 'string':
+            if (color === 'Random')
+                return Math.floor(Math.random() * (0xffffff + 1));
+            if (color.startsWith('#'))
+                return Number.parseInt(color.slice(1), 16);
+            if (color in __1.EmbedColors)
+                return __1.EmbedColors[color];
+            return __1.EmbedColors.Default;
+        case 'number':
+            return color;
+        case 'object':
+            if (Array.isArray(color))
+                return (color[0] << 16) + (color[1] << 8) + color[2];
+            break;
+        default:
+            return color;
+    }
+    return color;
+}
+exports.resolveColor = resolveColor;
+/**
+ * Flattens an array to a certain depth.
+ * @param arr The array to flatten.
+ * @returns The flattened array.
+ */
+function fastFlat(arr) {
+    let newArr = [];
+    for (const element of arr) {
+        newArr = newArr.concat(element);
+    }
+    return newArr;
+}
+exports.fastFlat = fastFlat;
+/**
+ * Creates a new array with the results of calling a provided function on every element in the array.
+ * @param arr The array to iterate over.
+ * @param fn The function that produces an element of the new array.
+ * @returns A new array with the results of calling the provided function on every element in the array.
+ */
+function fastMap(arr, fn) {
+    const newArr = [];
+    let key = 0;
+    for (const value of arr) {
+        newArr.push(fn(value, key, arr));
+        key++;
+    }
+    return newArr;
+}
+exports.fastMap = fastMap;
+/**
+ * Delays the resolution of a Promise by the specified time.
+ * @param time The time in milliseconds to delay the resolution.
+ * @param result The value to resolve with after the delay.
+ * @returns A Promise that resolves after the specified time with the provided result.
+ */
+function delay(time, result) {
+    return (0, promises_2.setTimeout)(time, result);
+}
+exports.delay = delay;
+/**
+ * Checks if a given value is an object.
+ * @param o The value to check.
+ * @returns `true` if the value is an object, otherwise `false`.
+ */
+function isObject(o) {
+    return o && typeof o === 'object' && !Array.isArray(o);
+}
+exports.isObject = isObject;
+/**
+ * Merges multiple options objects together, deeply extending objects.
+ * @param defaults The default options object.
+ * @param options Additional options objects to merge.
+ * @returns The merged options object.
+ */
+function MergeOptions(defaults, ...options) {
+    const option = options.shift();
+    if (!option) {
+        return defaults;
+    }
+    return MergeOptions({
+        ...option,
+        ...Object.fromEntries(Object.entries(defaults).map(([key, value]) => [
+            key,
+            isObject(value) ? MergeOptions(value, option?.[key] || {}) : option?.[key] ?? value,
+        ])),
+    }, ...options);
+}
+exports.MergeOptions = MergeOptions;
+/**
+ * Splits an array into two arrays based on the result of a predicate function.
+ * @param arr The array to split.
+ * @param func The predicate function used to test elements of the array.
+ * @returns An object containing two arrays: one with elements that passed the test and one with elements that did not.
+ */
+function filterSplit(arr, func) {
+    const expect = [];
+    const never = [];
+    for (const element of arr) {
+        const test = func(element);
+        if (test)
+            expect.push(element);
+        else
+            never.push(element);
+    }
+    return { expect, never };
+}
+exports.filterSplit = filterSplit;
+/**
+ * Represents a base handler class.
+ */
+class BaseHandler {
+    logger;
+    /**
+     * Initializes a new instance of the BaseHandler class.
+     * @param logger The logger instance.
+     */
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Filters a file path.
+     * @param path The path to filter.
+     * @returns `true` if the path passes the filter, otherwise `false`.
+     */
+    filter = (path) => !!path;
+    /**
+     * Recursively retrieves all files in a directory.
+     * @param dir The directory path.
+     * @returns A Promise that resolves to an array of file paths.
+     */
+    async getFiles(dir) {
+        const files = [];
+        for (const i of await (0, promises_1.readdir)(dir, { withFileTypes: true })) {
+            if (i.isDirectory()) {
+                files.push(...(await this.getFiles((0, node_path_1.join)(dir, i.name))));
+            }
+            else {
+                if (this.filter((0, node_path_1.join)(dir, i.name))) {
+                    files.push((0, node_path_1.join)(dir, i.name));
+                }
+            }
+        }
+        return files;
+    }
+    /**
+     * Loads files from given paths.
+     * @param paths The paths of the files to load.
+     * @returns A Promise that resolves to an array of loaded files.
+     */
+    async loadFiles(paths) {
+        return Promise.all(paths.map(path => magicImport(path).then(file => file.default ?? file)));
+    }
+    /**
+     * Loads files from given paths along with additional information.
+     * @param paths The paths of the files to load.
+     * @returns A Promise that resolves to an array of objects containing name, file, and path.
+     */
+    async loadFilesK(paths) {
+        return Promise.all(paths.map(path => magicImport(path).then(file => {
+            return {
+                name: (0, node_path_1.basename)(path),
+                file: file.default ?? file,
+                path,
+            };
+        })));
+    }
+}
+exports.BaseHandler = BaseHandler;
+/**
+ * Convert a camelCase object to snake_case.
+ * @param target The object to convert.
+ * @returns The converted object.
+ */
+function toSnakeCase(target) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        switch (typeof value) {
+            case 'string':
+            case 'bigint':
+            case 'boolean':
+            case 'function':
+            case 'number':
+            case 'symbol':
+            case 'undefined':
+                result[exports.ReplaceRegex.snake(key)] = value;
+                break;
+            case 'object':
+                if (Array.isArray(value)) {
+                    result[exports.ReplaceRegex.snake(key)] = value.map(prop => typeof prop === 'object' && prop ? toSnakeCase(prop) : prop);
+                    break;
+                }
+                if (isObject(value)) {
+                    result[exports.ReplaceRegex.snake(key)] = toSnakeCase(value);
+                    break;
+                }
+                if (!Number.isNaN(value)) {
+                    result[exports.ReplaceRegex.snake(key)] = null;
+                    break;
+                }
+                result[exports.ReplaceRegex.snake(key)] = toSnakeCase(value);
+                break;
+        }
+    }
+    return result;
+}
+exports.toSnakeCase = toSnakeCase;
+/**
+ * Convert a snake_case object to camelCase.
+ * @param target The object to convert.
+ * @returns The converted object.
+ */
+function toCamelCase(target) {
+    const result = {};
+    for (const [key, value] of Object.entries(target)) {
+        switch (typeof value) {
+            case 'string':
+            case 'bigint':
+            case 'boolean':
+            case 'function':
+            case 'symbol':
+            case 'number':
+            case 'undefined':
+                result[exports.ReplaceRegex.camel(key)] = value;
+                break;
+            case 'object':
+                if (Array.isArray(value)) {
+                    result[exports.ReplaceRegex.camel(key)] = value.map(prop => typeof prop === 'object' && prop ? toCamelCase(prop) : prop);
+                    break;
+                }
+                if (isObject(value)) {
+                    result[exports.ReplaceRegex.camel(key)] = toCamelCase(value);
+                    break;
+                }
+                if (!Number.isNaN(value)) {
+                    result[exports.ReplaceRegex.camel(key)] = null;
+                    break;
+                }
+                result[exports.ReplaceRegex.camel(key)] = toCamelCase(value);
+                break;
+        }
+    }
+    return result;
+}
+exports.toCamelCase = toCamelCase;
+exports.ReplaceRegex = {
+    camel: (s) => {
+        return s.toLowerCase().replace(/(_\S)/gi, a => a[1].toUpperCase());
+    },
+    snake: (s) => {
+        return s.replace(/[A-Z]/g, a => `_${a.toLowerCase()}`);
+    },
+};
+async function magicImport(path) {
+    try {
+        return require(path);
+    }
+    catch {
+        return eval('((path) => import(`file:///${path}`))')(path.split('\\').join('\\\\'));
+    }
+}
+exports.magicImport = magicImport;

package/lib/common/shorters/base.d.ts

@@ -0,0 +1,5 @@
+import type { UsingClient } from '../../commands';
+export declare class BaseShorter {
+    readonly client: UsingClient;
+    constructor(client: UsingClient);
+}

package/lib/common/shorters/base.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseShorter = void 0;
+class BaseShorter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+}
+exports.BaseShorter = BaseShorter;

package/lib/common/shorters/channels.d.ts

@@ -0,0 +1,90 @@
+import type { RESTPatchAPIChannelJSONBody } from '..';
+import { Message } from '../../structures';
+import { BaseShorter } from './base';
+export declare class ChannelShorter extends BaseShorter {
+    get channels(): {
+        /**
+         * Fetches a channel by its ID.
+         * @param id The ID of the channel to fetch.
+         * @param force Whether to force fetching the channel from the API even if it exists in the cache.
+         * @returns A Promise that resolves to the fetched channel.
+         */
+        fetch: (id: string, force?: boolean) => Promise<import("../../structures").AllChannels>;
+        /**
+         * Deletes a channel by its ID.
+         * @param id The ID of the channel to delete.
+         * @param optional Optional parameters for the deletion.
+         * @returns A Promise that resolves to the deleted channel.
+         */
+        delete: (id: string, optional?: ChannelShorterOptionalParams) => Promise<import("../../structures").AllChannels>;
+        /**
+         * Edits a channel by its ID.
+         * @param id The ID of the channel to edit.
+         * @param body The updated channel data.
+         * @param optional Optional parameters for the editing.
+         * @returns A Promise that resolves to the edited channel.
+         */
+        edit: (id: string, body: RESTPatchAPIChannelJSONBody, optional?: ChannelShorterOptionalParams) => Promise<import("../../structures").AllChannels>;
+        /**
+         * Sends a typing indicator to the channel.
+         * @param id The ID of the channel.
+         * @returns A Promise that resolves when the typing indicator is successfully sent.
+         */
+        typing: (id: string) => Promise<never>;
+        /**
+         * Provides access to pinned messages in the channel.
+         */
+        pins: {
+            /**
+             * Fetches pinned messages in the channel.
+             * @param channelId The ID of the channel.
+             * @returns A Promise that resolves to an array of pinned messages.
+             */
+            fetch: (channelId: string) => Promise<Message[]>;
+            /**
+             * Pins a message in the channel.
+             * @param messageId The ID of the message to pin.
+             * @param channelId The ID of the channel.
+             * @param reason The reason for pinning the message.
+             * @returns A Promise that resolves when the message is successfully pinned.
+             */
+            set: (messageId: string, channelId: string, reason?: string | undefined) => Promise<never>;
+            /**
+             * Unpins a message in the channel.
+             * @param messageId The ID of the message to unpin.
+             * @param channelId The ID of the channel.
+             * @param reason The reason for unpinning the message.
+             * @returns A Promise that resolves when the message is successfully unpinned.
+             */
+            delete: (messageId: string, channelId: string, reason?: string | undefined) => Promise<never>;
+        };
+    };
+    get pins(): {
+        /**
+         * Fetches pinned messages in the channel.
+         * @param channelId The ID of the channel.
+         * @returns A Promise that resolves to an array of pinned messages.
+         */
+        fetch: (channelId: string) => Promise<Message[]>;
+        /**
+         * Pins a message in the channel.
+         * @param messageId The ID of the message to pin.
+         * @param channelId The ID of the channel.
+         * @param reason The reason for pinning the message.
+         * @returns A Promise that resolves when the message is successfully pinned.
+         */
+        set: (messageId: string, channelId: string, reason?: string) => Promise<never>;
+        /**
+         * Unpins a message in the channel.
+         * @param messageId The ID of the message to unpin.
+         * @param channelId The ID of the channel.
+         * @param reason The reason for unpinning the message.
+         * @returns A Promise that resolves when the message is successfully unpinned.
+         */
+        delete: (messageId: string, channelId: string, reason?: string) => Promise<never>;
+    };
+}
+export type ChannelShorterOptionalParams = Partial<{
+    guildId: string;
+    reason: string;
+}>;