KnodesCommunity/typedoc-plugins

import { isString } from 'lodash';
import { LogLevel, Logger } from 'typedoc';

import type { ABasePlugin } from './base-plugin';

export class PluginLogger extends Logger {
    public constructor( private readonly _parent: Logger, private readonly _plugin: ABasePlugin, private readonly _context?: string ){
        super();
        this.level = this._parent.level;
    }

    /**
     * Create a new {@link PluginLogger} for the given context.
     *
     * @param context - The new logger context.
     * @returns the new logger.
     */
    public makeChildLogger( context?: string ){
        const newLogger = new PluginLogger( this._parent, this._plugin, context );
        newLogger.level = this.level;
        return newLogger;
    }

    /**
     * Log the given verbose message.
     *
     * @param text  - The message that should be logged.
     */
    public verbose( text: string | ( () => string ) ): void {
        this.log( text, LogLevel.Verbose );
    }

    /**
     * Log the given info message.
     *
     * @param text  - The message that should be logged.
     */
    public info( text: string | ( () => string ) ): void {
        this.log( text, LogLevel.Info );
    }

    /**
     * Log the given warning message.
     *
     * @param text  - The warning that should be logged.
     */
    public warn( text: string | ( () => string ) ): void {
        this.log( text, LogLevel.Warn );
    }

    /**
     * Log the given deprecation message.
     *
     * @param text  - The message that should be logged.
     * @param addStack - TODO: Not sure why ?
     */
    public deprecated( text: string | ( () => string ), addStack?: boolean ): void {
        if ( addStack ) {
            const stack = new Error().stack?.split( '\n' );
            if ( stack && stack.length >= 4 ) {
                text = () => `${text}\n${stack[3]}`;
            }
        }
        this.warn( text );
    }

    /**
     * Log the given error message.
     *
     * @param text  - The error that should be logged.
     */
    public error( text: string | ( () => string ) ): void {
        this.log( text, LogLevel.Error );
    }

    /**
     * Print a log message.
     *
     * @param message  - The message itself.
     * @param level  - The urgency of the log message.
     */
    public log( message: string | ( () => string ), level: LogLevel ): void {
        if( level < this.level ){
            return;
        }
        this._logThroughParent( message, level );
    }

    /**
     * Pass a log message to the parent.
     *
     * @param message  - The message itself.
     * @param level  - The urgency of the log message.
     */
    private _logThroughParent( message: string | ( () => string ), level: LogLevel ){
        if( this._parent instanceof PluginLogger ){
            this._parent._logThroughParent( message, level );
        } else {
            const loggerMethodMapper = {
                [LogLevel.Error]: 'error',
                [LogLevel.Warn]: 'warn',
                [LogLevel.Info]: 'info',
                [LogLevel.Verbose]: 'verbose',
            } as const;
            const parentMethod = loggerMethodMapper[level];
            const orignalLevel = this._parent.level;
            this._parent.level = LogLevel.Verbose;
            this._parent[parentMethod]( this._formatMessage( isString( message ) ? message : message() ) );
            this._parent.level = orignalLevel;
        }
    }

    /**
     * Format the given message.
     *
     * @param message - The message to format.
     * @returns the formatted message;
     */
    private _formatMessage( message: string ){
        let fullMessage = `[${this._plugin.package.name}]`;
        if( this._context ){
            fullMessage += ': ';
            fullMessage += this._context;
        }
        fullMessage += ' ⇒ ';
        fullMessage += message;
        return fullMessage;
    }
}