@arox/framework 0.1.0-alpha.2 → 0.1.0

package/dist/utils/logger/ILogger.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The logger levels for the {@link ILogger}.
+ */
+export declare enum LogLevel {
+    /**
+     * The lowest log level, used when calling {@link ILogger.trace}.
+     */
+    Trace = 10,
+    /**
+     * The debug level, used when calling {@link ILogger.debug}.
+     */
+    Debug = 20,
+    /**
+     * The info level, used when calling {@link ILogger.info}.
+     */
+    Info = 30,
+    /**
+     * The warning level, used when calling {@link ILogger.warn}.
+     */
+    Warn = 40,
+    /**
+     * The error level, used when calling {@link ILogger.error}.
+     */
+    Error = 50,
+    /**
+     * The critical level, used when calling {@link ILogger.fatal}.
+     */
+    Fatal = 60,
+    /**
+     * An unknown or uncategorized level.
+     */
+    None = 100
+}
+export interface ILogger {
+    /**
+     * Checks whether a level is supported.
+     * @param level The level to check.
+     */
+    has(level: LogLevel): boolean;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Trace} as level.
+     * @param values The values to log.
+     */
+    trace(...values: readonly unknown[]): void;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Debug} as level.
+     * @param values The values to log.
+     */
+    debug(...values: readonly unknown[]): void;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Info} as level.
+     * @param values The values to log.
+     */
+    info(...values: readonly unknown[]): void;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Warn} as level.
+     * @param values The values to log.
+     */
+    warn(...values: readonly unknown[]): void;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Error} as level.
+     * @param values The values to log.
+     */
+    error(...values: readonly unknown[]): void;
+    /**
+     * Alias of {@link ILogger.write} with {@link LogLevel.Fatal} as level.
+     * @param values The values to log.
+     */
+    fatal(...values: readonly unknown[]): void;
+    /**
+     * Writes the log message given a level and the value(s).
+     * @param level The log level.
+     * @param values The values to log.
+     */
+    write(level: LogLevel, ...values: readonly unknown[]): void;
+}

package/dist/utils/logger/ILogger.js

@@ -0,0 +1,37 @@
+//https://github.com/sapphiredev/framework/tree/main/src/lib/utils/logger
+/**
+ * The logger levels for the {@link ILogger}.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LogLevel", {
+    enumerable: true,
+    get: function() {
+        return LogLevel;
+    }
+});
+var LogLevel = /*#__PURE__*/ function(LogLevel) {
+    /**
+	 * The lowest log level, used when calling {@link ILogger.trace}.
+	 */ LogLevel[LogLevel["Trace"] = 10] = "Trace";
+    /**
+	 * The debug level, used when calling {@link ILogger.debug}.
+	 */ LogLevel[LogLevel["Debug"] = 20] = "Debug";
+    /**
+	 * The info level, used when calling {@link ILogger.info}.
+	 */ LogLevel[LogLevel["Info"] = 30] = "Info";
+    /**
+	 * The warning level, used when calling {@link ILogger.warn}.
+	 */ LogLevel[LogLevel["Warn"] = 40] = "Warn";
+    /**
+	 * The error level, used when calling {@link ILogger.error}.
+	 */ LogLevel[LogLevel["Error"] = 50] = "Error";
+    /**
+	 * The critical level, used when calling {@link ILogger.fatal}.
+	 */ LogLevel[LogLevel["Fatal"] = 60] = "Fatal";
+    /**
+	 * An unknown or uncategorized level.
+	 */ LogLevel[LogLevel["None"] = 100] = "None";
+    return LogLevel;
+}({});

package/dist/utils/logger/Logger.d.ts

@@ -0,0 +1,142 @@
+import { Console } from "console";
+import type { Color } from "colorette";
+import { Timestamp } from "@sapphire/timestamp";
+import type { ILogger } from "./ILogger";
+import { LogLevel } from "./ILogger";
+export declare class Logger implements ILogger {
+    level: LogLevel;
+    readonly formats: Map<LogLevel, LoggerLevel>;
+    readonly join: string;
+    readonly depth: number;
+    readonly console: Console;
+    private static instance;
+    private static readonly LOG_METHODS;
+    private static readonly DEFAULT_COLORS;
+    private static readonly DEFAULT_NAMES;
+    constructor(options?: LoggerOptions);
+    static getInstance(): Logger;
+    static get stylize(): boolean;
+    setLevel(level: LogLevel): void;
+    has(level: LogLevel): boolean;
+    trace(...values: readonly unknown[]): void;
+    debug(...values: readonly unknown[]): void;
+    info(...values: readonly unknown[]): void;
+    log(...values: readonly unknown[]): void;
+    warn(...values: readonly unknown[]): void;
+    error(...values: readonly unknown[]): void;
+    fatal(...values: readonly unknown[]): void;
+    write(level: LogLevel, ...values: readonly unknown[]): void;
+    protected preprocess(values: readonly unknown[]): string;
+    private createFormatMap;
+    private createDefaultLevel;
+    private getLevelKey;
+}
+export declare class LoggerStyle {
+    readonly style: Color;
+    constructor(resolvable?: LoggerStyleResolvable);
+    run(value: string | number): string;
+    private buildStyleArray;
+    private combineStyles;
+}
+export declare class LoggerTimestamp {
+    timestamp: Timestamp;
+    utc: boolean;
+    color: LoggerStyle | null;
+    formatter: LoggerTimestampFormatter;
+    constructor(options?: LoggerTimestampOptions);
+    run(): string;
+}
+export declare class LoggerLevel {
+    timestamp: LoggerTimestamp | null;
+    infix: string;
+    message: LoggerStyle | null;
+    constructor(options?: LoggerLevelOptions);
+    run(content: string): string;
+}
+declare const _default: Logger;
+export default _default;
+export interface LoggerOptions {
+    stdout?: NodeJS.WritableStream;
+    stderr?: NodeJS.WritableStream;
+    defaultFormat?: LoggerLevelOptions;
+    format?: LoggerFormatOptions;
+    level?: LogLevel;
+    join?: string;
+    depth?: number;
+}
+export interface LoggerFormatOptions {
+    trace?: LoggerLevelOptions;
+    debug?: LoggerLevelOptions;
+    info?: LoggerLevelOptions;
+    warn?: LoggerLevelOptions;
+    error?: LoggerLevelOptions;
+    fatal?: LoggerLevelOptions;
+    none?: LoggerLevelOptions;
+}
+export interface LoggerLevelOptions {
+    timestamp?: LoggerTimestampOptions | null;
+    infix?: string;
+    message?: LoggerStyleResolvable | null;
+}
+export interface LoggerTimestampOptions {
+    pattern?: string;
+    utc?: boolean;
+    color?: LoggerStyleResolvable | null;
+    formatter?: LoggerTimestampFormatter;
+}
+export interface LoggerTimestampFormatter {
+    (timestamp: string): string;
+}
+export interface LoggerStyleOptions {
+    effects?: LoggerStyleEffect[];
+    text?: LoggerStyleText;
+    background?: LoggerStyleBackground;
+}
+export type LoggerStyleResolvable = Color | LoggerStyleOptions;
+export declare enum LoggerStyleEffect {
+    Reset = "reset",
+    Bold = "bold",
+    Dim = "dim",
+    Italic = "italic",
+    Underline = "underline",
+    Inverse = "inverse",
+    Hidden = "hidden",
+    Strikethrough = "strikethrough"
+}
+export declare enum LoggerStyleText {
+    Black = "black",
+    Red = "red",
+    Green = "green",
+    Yellow = "yellow",
+    Blue = "blue",
+    Magenta = "magenta",
+    Cyan = "cyan",
+    White = "white",
+    Gray = "gray",
+    BlackBright = "blackBright",
+    RedBright = "redBright",
+    GreenBright = "greenBright",
+    YellowBright = "yellowBright",
+    BlueBright = "blueBright",
+    MagentaBright = "magentaBright",
+    CyanBright = "cyanBright",
+    WhiteBright = "whiteBright"
+}
+export declare enum LoggerStyleBackground {
+    Black = "bgBlack",
+    Red = "bgRed",
+    Green = "bgGreen",
+    Yellow = "bgYellow",
+    Blue = "bgBlue",
+    Magenta = "bgMagenta",
+    Cyan = "bgCyan",
+    White = "bgWhite",
+    BlackBright = "bgBlackBright",
+    RedBright = "bgRedBright",
+    GreenBright = "bgGreenBright",
+    YellowBright = "bgYellowBright",
+    BlueBright = "bgBlueBright",
+    MagentaBright = "bgMagentaBright",
+    CyanBright = "bgCyanBright",
+    WhiteBright = "bgWhiteBright"
+}

package/dist/utils/logger/Logger.js

@@ -0,0 +1,361 @@
+//https://github.com/sapphiredev/plugins/tree/main/packages/logger
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Logger () {
+        return Logger;
+    },
+    get LoggerLevel () {
+        return LoggerLevel;
+    },
+    get LoggerStyle () {
+        return LoggerStyle;
+    },
+    get LoggerStyleBackground () {
+        return LoggerStyleBackground;
+    },
+    get LoggerStyleEffect () {
+        return LoggerStyleEffect;
+    },
+    get LoggerStyleText () {
+        return LoggerStyleText;
+    },
+    get LoggerTimestamp () {
+        return LoggerTimestamp;
+    },
+    get default () {
+        return _default;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _console = require("console");
+const _util = require("util");
+const _colorette = /*#__PURE__*/ _interop_require_wildcard._(require("colorette"));
+const _timestamp = require("@sapphire/timestamp");
+const _ILogger = require("./ILogger");
+class Logger {
+    level;
+    formats;
+    join;
+    depth;
+    console;
+    static instance = null;
+    static LOG_METHODS = new Map([
+        [
+            _ILogger.LogLevel.Trace,
+            "trace"
+        ],
+        [
+            _ILogger.LogLevel.Debug,
+            "debug"
+        ],
+        [
+            _ILogger.LogLevel.Info,
+            "info"
+        ],
+        [
+            _ILogger.LogLevel.Warn,
+            "warn"
+        ],
+        [
+            _ILogger.LogLevel.Error,
+            "error"
+        ],
+        [
+            _ILogger.LogLevel.Fatal,
+            "error"
+        ]
+    ]);
+    static DEFAULT_COLORS = new Map([
+        [
+            _ILogger.LogLevel.Trace,
+            _colorette.gray
+        ],
+        [
+            _ILogger.LogLevel.Debug,
+            _colorette.magenta
+        ],
+        [
+            _ILogger.LogLevel.Info,
+            _colorette.cyan
+        ],
+        [
+            _ILogger.LogLevel.Warn,
+            _colorette.yellow
+        ],
+        [
+            _ILogger.LogLevel.Error,
+            _colorette.red
+        ],
+        [
+            _ILogger.LogLevel.Fatal,
+            _colorette.bgRed
+        ],
+        [
+            _ILogger.LogLevel.None,
+            _colorette.white
+        ]
+    ]);
+    static DEFAULT_NAMES = new Map([
+        [
+            _ILogger.LogLevel.Trace,
+            "TRACE"
+        ],
+        [
+            _ILogger.LogLevel.Debug,
+            "DEBUG"
+        ],
+        [
+            _ILogger.LogLevel.Info,
+            "INFO"
+        ],
+        [
+            _ILogger.LogLevel.Warn,
+            "WARN"
+        ],
+        [
+            _ILogger.LogLevel.Error,
+            "ERROR"
+        ],
+        [
+            _ILogger.LogLevel.Fatal,
+            "FATAL"
+        ],
+        [
+            _ILogger.LogLevel.None,
+            ""
+        ]
+    ]);
+    constructor(options = {}){
+        this.level = options.level ?? _ILogger.LogLevel.Info;
+        this.console = new _console.Console(options.stdout ?? process.stdout, options.stderr ?? process.stderr);
+        this.formats = this.createFormatMap(options.format, options.defaultFormat ?? options.format?.none ?? {});
+        this.join = options.join ?? " ";
+        this.depth = options.depth ?? 2;
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new Logger();
+        }
+        return this.instance;
+    }
+    static get stylize() {
+        return _colorette.isColorSupported;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    has(level) {
+        return level >= this.level;
+    }
+    trace(...values) {
+        this.write(_ILogger.LogLevel.Trace, ...values);
+    }
+    debug(...values) {
+        this.write(_ILogger.LogLevel.Debug, ...values);
+    }
+    info(...values) {
+        this.write(_ILogger.LogLevel.Info, ...values);
+    }
+    log(...values) {
+        this.write(_ILogger.LogLevel.Info, ...values);
+    }
+    warn(...values) {
+        this.write(_ILogger.LogLevel.Warn, ...values);
+    }
+    error(...values) {
+        this.write(_ILogger.LogLevel.Error, ...values);
+    }
+    fatal(...values) {
+        this.write(_ILogger.LogLevel.Fatal, ...values);
+    }
+    write(level, ...values) {
+        if (level < this.level) return;
+        const method = Logger.LOG_METHODS.get(level);
+        const formatter = this.formats.get(level) ?? this.formats.get(_ILogger.LogLevel.None);
+        const message = formatter.run(this.preprocess(values));
+        switch(method){
+            case "trace":
+                this.console.trace(message);
+                break;
+            case "debug":
+                this.console.debug(message);
+                break;
+            case "info":
+                this.console.info(message);
+                break;
+            case "warn":
+                this.console.warn(message);
+                break;
+            case "error":
+                this.console.error(message);
+                break;
+            default:
+                this.console.log(message);
+        }
+    }
+    preprocess(values) {
+        const inspectOptions = {
+            colors: _colorette.isColorSupported,
+            depth: this.depth
+        };
+        return values.map((value)=>typeof value === "string" ? value : (0, _util.inspect)(value, inspectOptions)).join(this.join);
+    }
+    createFormatMap(options = {}, defaults) {
+        const map = new Map();
+        for (const [level, color] of Logger.DEFAULT_COLORS){
+            const name = Logger.DEFAULT_NAMES.get(level);
+            const levelOptions = options[this.getLevelKey(level)] ?? this.createDefaultLevel(defaults, color, name ?? "");
+            map.set(level, levelOptions instanceof LoggerLevel ? levelOptions : new LoggerLevel(levelOptions));
+        }
+        return map;
+    }
+    createDefaultLevel(defaults, color, name) {
+        return new LoggerLevel({
+            ...defaults,
+            timestamp: defaults.timestamp === null ? null : {
+                ...defaults.timestamp,
+                color
+            },
+            infix: name.length ? `${color(name.padEnd(5, " "))} ` : ""
+        });
+    }
+    getLevelKey(level) {
+        const keys = {
+            [_ILogger.LogLevel.Trace]: "trace",
+            [_ILogger.LogLevel.Debug]: "debug",
+            [_ILogger.LogLevel.Info]: "info",
+            [_ILogger.LogLevel.Warn]: "warn",
+            [_ILogger.LogLevel.Error]: "error",
+            [_ILogger.LogLevel.Fatal]: "fatal",
+            [_ILogger.LogLevel.None]: "none"
+        };
+        return keys[level];
+    }
+}
+class LoggerStyle {
+    style;
+    constructor(resolvable = {}){
+        if (typeof resolvable === "function") {
+            this.style = resolvable;
+        } else {
+            const styles = this.buildStyleArray(resolvable);
+            this.style = this.combineStyles(styles);
+        }
+    }
+    run(value) {
+        return this.style(String(value));
+    }
+    buildStyleArray(options) {
+        const styles = [];
+        if (options.effects) {
+            styles.push(...options.effects.map((effect)=>_colorette[effect]));
+        }
+        if (options.text) {
+            styles.push(_colorette[options.text]);
+        }
+        if (options.background) {
+            styles.push(_colorette[options.background]);
+        }
+        return styles;
+    }
+    combineStyles(styles) {
+        if (styles.length === 0) return _colorette.reset;
+        if (styles.length === 1) return styles[0];
+        return (text)=>styles.reduce((result, style)=>style(result), text);
+    }
+}
+class LoggerTimestamp {
+    timestamp;
+    utc;
+    color;
+    formatter;
+    constructor(options = {}){
+        this.timestamp = new _timestamp.Timestamp(options.pattern ?? "YYYY-MM-DD HH:mm:ss");
+        this.utc = options.utc ?? false;
+        this.color = options.color === null ? null : new LoggerStyle(options.color);
+        this.formatter = options.formatter ?? ((timestamp)=>`${timestamp} `);
+    }
+    run() {
+        const date = new Date();
+        const result = this.utc ? this.timestamp.displayUTC(date) : this.timestamp.display(date);
+        return this.formatter(this.color ? this.color.run(result) : result);
+    }
+}
+class LoggerLevel {
+    timestamp;
+    infix;
+    message;
+    constructor(options = {}){
+        this.timestamp = options.timestamp === null ? null : new LoggerTimestamp(options.timestamp);
+        this.infix = options.infix ?? "";
+        this.message = options.message === null ? null : new LoggerStyle(options.message);
+    }
+    run(content) {
+        const prefix = (this.timestamp?.run() ?? "") + this.infix;
+        if (prefix.length) {
+            const formatter = this.message ? (line)=>prefix + this.message?.run(line) : (line)=>prefix + line;
+            return content.split("\n").map(formatter).join("\n");
+        }
+        return this.message ? this.message.run(content) : content;
+    }
+}
+const _default = Logger.getInstance();
+var LoggerStyleEffect = /*#__PURE__*/ function(LoggerStyleEffect) {
+    LoggerStyleEffect["Reset"] = "reset";
+    LoggerStyleEffect["Bold"] = "bold";
+    LoggerStyleEffect["Dim"] = "dim";
+    LoggerStyleEffect["Italic"] = "italic";
+    LoggerStyleEffect["Underline"] = "underline";
+    LoggerStyleEffect["Inverse"] = "inverse";
+    LoggerStyleEffect["Hidden"] = "hidden";
+    LoggerStyleEffect["Strikethrough"] = "strikethrough";
+    return LoggerStyleEffect;
+}({});
+var LoggerStyleText = /*#__PURE__*/ function(LoggerStyleText) {
+    LoggerStyleText["Black"] = "black";
+    LoggerStyleText["Red"] = "red";
+    LoggerStyleText["Green"] = "green";
+    LoggerStyleText["Yellow"] = "yellow";
+    LoggerStyleText["Blue"] = "blue";
+    LoggerStyleText["Magenta"] = "magenta";
+    LoggerStyleText["Cyan"] = "cyan";
+    LoggerStyleText["White"] = "white";
+    LoggerStyleText["Gray"] = "gray";
+    LoggerStyleText["BlackBright"] = "blackBright";
+    LoggerStyleText["RedBright"] = "redBright";
+    LoggerStyleText["GreenBright"] = "greenBright";
+    LoggerStyleText["YellowBright"] = "yellowBright";
+    LoggerStyleText["BlueBright"] = "blueBright";
+    LoggerStyleText["MagentaBright"] = "magentaBright";
+    LoggerStyleText["CyanBright"] = "cyanBright";
+    LoggerStyleText["WhiteBright"] = "whiteBright";
+    return LoggerStyleText;
+}({});
+var LoggerStyleBackground = /*#__PURE__*/ function(LoggerStyleBackground) {
+    LoggerStyleBackground["Black"] = "bgBlack";
+    LoggerStyleBackground["Red"] = "bgRed";
+    LoggerStyleBackground["Green"] = "bgGreen";
+    LoggerStyleBackground["Yellow"] = "bgYellow";
+    LoggerStyleBackground["Blue"] = "bgBlue";
+    LoggerStyleBackground["Magenta"] = "bgMagenta";
+    LoggerStyleBackground["Cyan"] = "bgCyan";
+    LoggerStyleBackground["White"] = "bgWhite";
+    LoggerStyleBackground["BlackBright"] = "bgBlackBright";
+    LoggerStyleBackground["RedBright"] = "bgRedBright";
+    LoggerStyleBackground["GreenBright"] = "bgGreenBright";
+    LoggerStyleBackground["YellowBright"] = "bgYellowBright";
+    LoggerStyleBackground["BlueBright"] = "bgBlueBright";
+    LoggerStyleBackground["MagentaBright"] = "bgMagentaBright";
+    LoggerStyleBackground["CyanBright"] = "bgCyanBright";
+    LoggerStyleBackground["WhiteBright"] = "bgWhiteBright";
+    return LoggerStyleBackground;
+}({});

package/dist/utils/util.d.ts

@@ -0,0 +1,4 @@
+import { PrefixOptions } from "#types/client.js";
+import { InteractionResponse, Message } from "discord.js";
+export declare function deleteMessage(message: Message | InteractionResponse, time?: number): Promise<void>;
+export declare function getPrefix(opts: PrefixOptions): string | false;

package/dist/utils/util.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get deleteMessage () {
+        return deleteMessage;
+    },
+    get getPrefix () {
+        return getPrefix;
+    }
+});
+function deleteMessage(message, time = 15_000) {
+    return new Promise((r)=>{
+        setTimeout(()=>{
+            message.delete().catch(()=>{});
+            r();
+        }, time);
+    });
+}
+function getPrefix(opts) {
+    if (typeof opts === "string") {
+        return opts;
+    }
+    if (opts.enabled && opts.prefix) {
+        return opts.prefix;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arox/framework",
-  "version": "0.1.0-alpha.2",
+  "version": "0.1.0",
   "description": "",
   "keywords": [
     "discord.js",
@@ -19,6 +19,9 @@
   "type": "commonjs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "imports": {
+    "#types/*": "./types/*"
+  },
   "scripts": {
     "prepare": "node scripts/prepareHusky.js",
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -30,8 +33,16 @@
     "release:git": "node scripts/actions/github.js",
     "release:npm": "node scripts/actions/npm.js"
   },
+  "dependencies": {
+    "@sapphire/timestamp": "^1.0.5",
+    "@swc/helpers": "^0.5.18",
+    "colorette": "^2.0.20",
+    "fast-glob": "^3.3.3",
+    "lodash": "^4.17.21"
+  },
   "devDependencies": {
     "@swc/cli": "^0.7.10",
+    "@types/lodash": "^4.17.23",
     "@types/node": "^25.0.8",
     "husky": "^9.1.7",
     "libnpmpack": "^9.0.12",
@@ -39,5 +50,8 @@
     "oxlint": "^1.39.0",
     "oxlint-tsgolint": "^0.11.0",
     "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "discord.js": ">=14.25.1"
   }
 }