@noxfly/noxus 3.0.0-dev.0 → 3.0.0-dev.10

package/src/utils/logger.ts

@@ -1,430 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * Logger is a utility class for logging messages to the console.
- */
-export type LogLevel =
-    | 'debug'
-    | 'comment'
-    | 'log'
-    | 'info'
-    | 'warn'
-    | 'error'
-    | 'critical'
-;
-
-interface FileLogState {
-    queue: string[];
-    isWriting: boolean;
-}
-
-
-
-/**
- * Returns a formatted timestamp for logging.
- */
-function getPrettyTimestamp(): string {
-    const now = new Date();
-    return `${now.getDate().toString().padStart(2, '0')}/${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getFullYear()}`
-        + ` ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
-}
-
-/**
- * Generates a log prefix for the console output.
- * @param callee - The name of the function or class that is logging the message.
- * @param messageType - The type of message being logged (e.g., 'log', 'info', 'warn', 'error', 'debug').
- * @param color - The color to use for the log message.
- * @returns A formatted string that includes the timestamp, process ID, message type, and callee name.
- */
-function getLogPrefix(callee: string, messageType: string, color?: string): string {
-    const timestamp = getPrettyTimestamp();
-
-    const spaces = " ".repeat(10 - messageType.length);
-
-    let colReset = Logger.colors.initial;
-    let colCallee = Logger.colors.yellow;
-
-    if(color === undefined) {
-        color = "";
-        colReset = "";
-        colCallee = "";
-    }
-
-    return `${color}[APP] ${process.pid} - ${colReset}`
-        + `${timestamp}${spaces}`
-        + `${color}${messageType.toUpperCase()}${colReset} `
-        + `${colCallee}[${callee}]${colReset}`;
-}
-
-/**
- * Formats an object into a string representation for logging.
- * It converts the object to JSON and adds indentation for readability.
- * @param prefix - The prefix to use for the formatted object.
- * @param arg - The object to format.
- * @returns A formatted string representation of the object, with each line prefixed by the specified prefix.
- */
-function formatObject(prefix: string, arg: object, enableColor: boolean = true): string {
-    const json = JSON.stringify(arg, null, 2);
-
-    let colStart = "";
-    let colLine = "";
-    let colReset = "";
-
-    if(enableColor) {
-        colStart = Logger.colors.darkGrey;
-        colLine = Logger.colors.grey;
-        colReset = Logger.colors.initial;
-    }
-
-    const prefixedJson = json
-        .split('\n')
-        .map((line, idx) => idx === 0 ? `${colStart}${line}` : `${prefix} ${colLine}${line}`)
-        .join('\n') + colReset;
-
-    return prefixedJson;
-}
-
-/**
- * Formats the arguments for logging.
- * It colors strings and formats objects with indentation.
- * This function is used to prepare the arguments for console output.
- * @param prefix - The prefix to use for the formatted arguments.
- * @param args - The arguments to format.
- * @param color - The color to use for the formatted arguments.
- * @returns An array of formatted arguments, where strings are colored and objects are formatted with indentation.
- */
-function formattedArgs(prefix: string, args: any[], color?: string): any[] {
-    let colReset = Logger.colors.initial;
-
-    if(color === undefined) {
-        color = "";
-        colReset = "";
-    }
-
-    return args.map(arg => {
-        if(typeof arg === "string") {
-            return `${color}${arg}${colReset}`;
-        }
-
-        else if(typeof arg === "object") {
-            return formatObject(prefix, arg, color !== "");
-        }
-
-        return arg;
-    });
-}
-
-/**
- * Gets the name of the caller function or class from the stack trace.
- * This function is used to determine the context of the log message.
- * @returns The name of the caller function or class.
- */
-function getCallee(): string {
-    const stack = new Error().stack?.split('\n') ?? [];
-    const caller = stack[3]
-        ?.trim()
-        .match(/at (.+?)(?:\..+)? .+$/)
-        ?.[1]
-        ?.replace("Object", "")
-        .replace(/^_/, "")
-        || "App";
-    return caller;
-}
-
-/**
- * Checks if the current log level allows logging the specified level.
- * This function compares the current log level with the specified level to determine if logging should occur.
- * @param level - The log level to check.
- * @returns A boolean indicating whether the log level is enabled.
- */
-function canLog(level: LogLevel): boolean {
-    return logLevels.has(level);
-}
-
-/**
- * Writes a log message to a file asynchronously to avoid blocking the event loop.
- * It batches messages if writing is already in progress.
- * @param filepath - The path to the log file.
- */
-function processLogQueue(filepath: string): void {
-    const state = fileStates.get(filepath);
-
-    if(!state || state.isWriting || state.queue.length === 0) {
-        return;
-    }
-
-    state.isWriting = true;
-
-    // Optimization: Grab all pending messages to write in one go
-    const messagesToWrite = state.queue.join('\n') + '\n';
-    state.queue = []; // Clear the queue immediately
-
-    const dir = path.dirname(filepath);
-
-    // Using async IO to allow other operations
-    fs.mkdir(dir, { recursive: true }, (err) => {
-        if(err) {
-            console.error(`[Logger] Failed to create directory ${dir}`, err);
-            state.isWriting = false;
-            return;
-        }
-
-        fs.appendFile(filepath, messagesToWrite, { encoding: "utf-8" }, (err) => {
-            state.isWriting = false;
-
-            if(err) {
-                console.error(`[Logger] Failed to write log to ${filepath}`, err);
-            }
-
-            // If new messages arrived while we were writing, process them now
-            if(state.queue.length > 0) {
-                processLogQueue(filepath);
-            }
-        });
-    });
-}
-
-/**
- * Adds a message to the file queue and triggers processing.
- */
-function enqueue(filepath: string, message: string): void {
-    if(!fileStates.has(filepath)) {
-        fileStates.set(filepath, { queue: [], isWriting: false });
-    }
-
-    const state = fileStates.get(filepath)!;
-    state.queue.push(message);
-
-    processLogQueue(filepath);
-}
-
-/**
- *
- */
-function output(level: LogLevel, args: any[]): void {
-    if(!canLog(level)) {
-        return;
-    }
-
-    const callee = getCallee();
-
-    {
-        const prefix = getLogPrefix(callee, level, logLevelColors[level]);
-        const data = formattedArgs(prefix, args, logLevelColors[level]);
-
-        logLevelChannel[level](prefix, ...data);
-    }
-
-    {
-        const prefix = getLogPrefix(callee, level);
-        const data = formattedArgs(prefix, args);
-
-        const filepath = fileSettings.get(level)?.filepath;
-
-        if(filepath) {
-            const message = prefix + " " + data.join(" ").replace(/\x1b\[[0-9;]*m/g, ''); // Remove ANSI codes
-            enqueue(filepath, message);
-        }
-    }
-}
-
-
-
-export namespace Logger {
-
-    /**
-     * Sets the log level for the logger.
-     * This function allows you to change the log level dynamically at runtime.
-     * This won't affect the startup logs.
-     *
-     * If the parameter is a single LogLevel, all log levels with equal or higher severity will be enabled.
-
-    * If the parameter is an array of LogLevels, only the specified levels will be enabled.
-     *
-     * @param level Sets the log level for the logger.
-     */
-    export function setLogLevel(level: LogLevel | LogLevel[]): void {
-        logLevels.clear();
-
-        if(Array.isArray(level)) {
-            for(const lvl of level) {
-                logLevels.add(lvl);
-            }
-        }
-        else {
-            const targetRank = logLevelRank[level];
-
-            for(const [lvl, rank] of Object.entries(logLevelRank) as [LogLevel, number][]) {
-                if(rank >= targetRank) {
-                    logLevels.add(lvl);
-                }
-            }
-        }
-    }
-
-    /**
-     * Logs a message to the console with log level LOG.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function log(...args: any[]): void {
-        output("log", args);
-    }
-
-    /**
-     * Logs a message to the console with log level INFO.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function info(...args: any[]): void {
-        output("info", args);
-    }
-
-    /**
-     * Logs a message to the console with log level WARN.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function warn(...args: any[]): void {
-        output("warn", args);
-    }
-
-    /**
-     * Logs a message to the console with log level ERROR.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function error(...args: any[]): void {
-        output("error", args);
-    }
-
-    /**
-     * Logs a message to the console with log level ERROR and a grey color scheme.
-     */
-    export function errorStack(...args: any[]): void {
-        output("error", args);
-    }
-
-    /**
-     * Logs a message to the console with log level DEBUG.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function debug(...args: any[]): void {
-        output("debug", args);
-    }
-
-    /**
-     * Logs a message to the console with log level COMMENT.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function comment(...args: any[]): void {
-        output("comment", args);
-    }
-
-    /**
-     * Logs a message to the console with log level CRITICAL.
-     * This function formats the message with a timestamp, process ID, and the name of the caller function or class.
-     * It uses different colors for different log levels to enhance readability.
-     * @param args The arguments to log.
-     */
-    export function critical(...args: any[]): void {
-        output("critical", args);
-    }
-
-    /**
-     * Enables logging to a file output for the specified log levels.
-     * @param filepath The path to the log file.
-     * @param levels The log levels to enable file logging for. Defaults to all levels.
-     */
-    export function enableFileLogging(filepath: string, levels: LogLevel[] = ["debug", "comment", "log", "info", "warn", "error", "critical"]): void {
-        for(const level of levels) {
-            fileSettings.set(level, { filepath });
-        }
-    }
-
-    /**
-     * Disables logging to a file output for the specified log levels.
-     * @param levels The log levels to disable file logging for. Defaults to all levels.
-     */
-    export function disableFileLogging(levels: LogLevel[] = ["debug", "comment", "log", "info", "warn", "error", "critical"]): void {
-        for(const level of levels) {
-            fileSettings.delete(level);
-        }
-    }
-
-
-    export const colors = {
-        black: "\x1b[0;30m",
-        grey: "\x1b[0;37m",
-        red: "\x1b[0;31m",
-        green: "\x1b[0;32m",
-        brown: "\x1b[0;33m",
-        blue: "\x1b[0;34m",
-        purple: "\x1b[0;35m",
-
-        darkGrey: "\x1b[1;30m",
-        lightRed: "\x1b[1;31m",
-        lightGreen: "\x1b[1;32m",
-        yellow: "\x1b[1;33m",
-        lightBlue: "\x1b[1;34m",
-        magenta: "\x1b[1;35m",
-        cyan: "\x1b[1;36m",
-        white: "\x1b[1;37m",
-
-        initial: "\x1b[0m"
-    };
-}
-
-
-const fileSettings: Map<LogLevel, { filepath: string }> = new Map();
-const fileStates: Map<string, FileLogState> = new Map(); // filepath -> state
-
-const logLevels: Set<LogLevel> = new Set();
-
-const logLevelRank: Record<LogLevel, number> = {
-    debug: 0,
-    comment: 1,
-    log: 2,
-    info: 3,
-    warn: 4,
-    error: 5,
-    critical: 6,
-};
-
-const logLevelColors: Record<LogLevel, string> = {
-    debug: Logger.colors.purple,
-    comment: Logger.colors.grey,
-    log: Logger.colors.green,
-    info: Logger.colors.blue,
-    warn: Logger.colors.brown,
-    error: Logger.colors.red,
-    critical: Logger.colors.lightRed,
-};
-
-const logLevelChannel: Record<LogLevel, (message?: any, ...optionalParams: any[]) => void> = {
-    debug: console.debug,
-    comment: console.debug,
-    log: console.log,
-    info: console.info,
-    warn: console.warn,
-    error: console.error,
-    critical: console.error,
-};
-
-
-Logger.setLogLevel("debug");

package/src/utils/radix-tree.ts

@@ -1,210 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-/**
- *
- */
-type Params = Record<string, string>;
-
-/**
- * Represents a search result in the Radix Tree.
- */
-interface ISearchResult<T> {
-    node: RadixNode<T>;
-    params: Params;
-}
-
-/**
- * Represents a node in the Radix Tree.
- * The represents a path segment
- */
-class RadixNode<T> {
-    public segment: string;
-    public children: RadixNode<T>[] = [];
-    public value?: T;
-    public isParam: boolean;
-    public paramName?: string;
-
-    /**
-     * Creates a new RadixNode.
-     * @param segment - The segment of the path this node represents.
-     */
-    constructor(segment: string) {
-        this.segment = segment;
-        this.isParam = segment.startsWith(":");
-
-        if(this.isParam) {
-            this.paramName = segment.slice(1);
-        }
-    }
-
-    /**
-     * Matches a child node against a given segment.
-     * This method checks if the segment matches any of the children nodes.
-     * @param segment - The segment to match against the children of this node.
-     * @returns A child node that matches the segment, or undefined if no match is found.
-     */
-    public matchChild(segment: string): RadixNode<T> | undefined {
-        for(const child of this.children) {
-            if(child.isParam || segment.startsWith(child.segment))
-                return child; // param match
-        }
-
-        return undefined;
-    }
-
-    /**
-     * Finds a child node that matches the segment exactly.
-     * This method checks if there is a child node that matches the segment exactly.
-     * @param segment - The segment to find an exact match for among the children of this node.
-     * @returns A child node that matches the segment exactly, or undefined if no match is found.
-     */
-    public findExactChild(segment: string): RadixNode<T> | undefined {
-        return this.children.find(c => c.segment === segment);
-    }
-
-    /**
-     * Adds a child node to this node's children.
-     * This method adds a new child node to the list of children for this node.
-     * @param node - The child node to add to this node's children.
-     */
-    public addChild(node: RadixNode<T>): void {
-        this.children.push(node);
-    }
-}
-
-/**
- *
- */
-export class RadixTree<T> {
-    private readonly root = new RadixNode<T>("");
-
-    /**
-     * Inserts a path and its associated value into the Radix Tree.
-     * This method normalizes the path and inserts it into the tree, associating it with
-     * @param path - The path to insert into the tree.
-     * @param value - The value to associate with the path.
-     */
-    public insert(path: string, value: T): void {
-        const segments = this.normalize(path);
-        this.insertRecursive(this.root, segments, value);
-    }
-
-    /**
-     * Recursively inserts a path into the Radix Tree.
-     * This method traverses the tree and inserts the segments of the path, creating new nodes
-     * @param node - The node to start inserting from.
-     * @param segments - The segments of the path to insert.
-     * @param value - The value to associate with the path.
-     */
-    private insertRecursive(node: RadixNode<T>, segments: string[], value: T): void {
-        if(segments.length === 0) {
-            node.value = value;
-            return;
-        }
-
-        const segment = segments[0] ?? "";
-
-        let child = node.children.find(c =>
-            c.isParam === segment.startsWith(":") &&
-            (c.isParam || c.segment === segment)
-        );
-
-        if(!child) {
-            child = new RadixNode<T>(segment);
-            node.addChild(child);
-        }
-
-        this.insertRecursive(child, segments.slice(1), value);
-    }
-
-    /**
-     * Searches for a path in the Radix Tree.
-     * This method normalizes the path and searches for it in the tree, returning the node
-     * @param path - The path to search for in the Radix Tree.
-     * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-     */
-    public search(path: string): ISearchResult<T> | undefined {
-        const segments = this.normalize(path);
-        return this.searchRecursive(this.root, segments, {});
-    }
-
-    /**
-     * Recursively searches for a path in the Radix Tree.
-     * This method traverses the tree and searches for the segments of the path, collecting parameters
-     * @param node - The node to start searching from.
-     * @param segments - The segments of the path to search for.
-     * @param params - The parameters collected during the search.
-     * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-     */
-    private searchRecursive(node: RadixNode<T>, segments: string[], params: Params): ISearchResult<T> | undefined {
-        if(segments.length === 0) {
-            if(node.value !== undefined) {
-                return {
-                    node: node,
-                    params
-                };
-            }
-
-            return undefined;
-        }
-
-        const [segment, ...rest] = segments;
-
-        for(const child of node.children) {
-            if(child.isParam) {
-                const paramName = child.paramName!;
-
-                const childParams: Params = {
-                    ...params,
-                    [paramName]: segment ?? "",
-                };
-
-                if(rest.length === 0) {
-                    return {
-                        node: child,
-                        params: childParams
-                    };
-                }
-
-                const result = this.searchRecursive(child, rest, childParams);
-
-                if(result)
-                    return result;
-            }
-            else if(segment === child.segment) {
-                if(rest.length === 0) {
-                    return {
-                        node: child,
-                        params
-                    };
-                }
-
-                const result = this.searchRecursive(child, rest, params);
-
-                if(result)
-                    return result;
-            }
-        }
-
-        return undefined;
-    }
-
-    /**
-     * Normalizes a path into an array of segments.
-     * This method removes leading and trailing slashes, splits the path by slashes, and
-     * @param path - The path to normalize.
-     * @returns An array of normalized path segments.
-     */
-    private normalize(path: string): string[] {
-        const segments = path
-            .replace(/^\/+|\/+$/g, "")
-            .split("/")
-            .filter(Boolean);
-
-        return ['', ...segments];
-    }
-}

package/src/utils/types.ts

@@ -1,21 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-
-/**
- * Represents a generic type that can be either a class or a function.
- * This is used to define types that can be instantiated or called.
- */
-declare const Type: FunctionConstructor;
-export interface Type<T> extends Function {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    new (...args: any[]): T;
-}
-
-/**
- * Represents a generic type that can be either a value or a promise resolving to that value.
- */
-export type MaybeAsync<T> = T | Promise<T>;