@yamato-daiwa/es-extensions-nodejs 0.0.2 → 0.10.0-alpha.0

package/Distributable/ConsoleApplicationLogger.d.ts

@@ -0,0 +1,68 @@
+import { type ILogger, type Logger, type ErrorLog, type ThrownErrorLog, type InfoLog, type SuccessLog, type WarningLog, type Log } from "@yamato-daiwa/es-extensions";
+declare abstract class ConsoleApplicationLogger {
+    protected static localization: Logger.Localization;
+    static setLocalization(localization: Logger.Localization): typeof ConsoleApplicationLogger;
+    static throwErrorWithFormattedMessage<CustomError extends Error>(thrownErrorLog: ThrownErrorLog<CustomError>, options?: ILogger.ThrowingErrorWithFormattedMessage.Options): never;
+    static logError(polymorphicPayload: ErrorLog | string): void;
+    static logErrorLikeMessage(polymorphicPayload: Log | string): void;
+    static logWarning(polymorphicPayload: WarningLog | string): void;
+    static logInfo(polymorphicPayload: InfoLog | string): void;
+    static logSuccess(polymorphicPayload: SuccessLog | string): void;
+    static logDebug(polymorphicPayload: Log | string | number | bigint | boolean | null | undefined): void;
+    static logGeneric(polymorphicPayload: Log | string | number | bigint | boolean | null | undefined): void;
+    static highlightText(targetString: string): string;
+    static generateFormattedErrorFromThrownErrorLog(thrownErrorLog: ThrownErrorLog, stringifiedInnerError?: string): string;
+    static formatErrorLog(errorLog: ErrorLog): Array<string>;
+    static formatGenericLog({ genericLog, badgeContentAndFormatting, mainColor, titleColor }: Readonly<{
+        genericLog: Log;
+        badgeContentAndFormatting: Readonly<{
+            defaultText: string;
+            foregroundColor: ConsoleApplicationLogger.RedGreenBlue;
+            backgroundColor: ConsoleApplicationLogger.RedGreenBlue;
+        }>;
+        mainColor: ConsoleApplicationLogger.RedGreenBlue;
+        titleColor: ConsoleApplicationLogger.RedGreenBlue;
+    }>): Array<string>;
+    static generateBadgeIfMust(badge: Readonly<{
+        customText: string;
+    }> | false | undefined, { defaultText, foregroundColor, backgroundColor }: Readonly<{
+        defaultText: string;
+        foregroundColor: ConsoleApplicationLogger.RedGreenBlue;
+        backgroundColor: ConsoleApplicationLogger.RedGreenBlue;
+    }>): [string | null, ConsoleApplicationLogger.Formatting];
+    static generateConsoleMethodParametersForFormattedOutput(formattedOutputData: ConsoleApplicationLogger.FormattedOutputData): Array<string>;
+    static generateRedGreenBlueForegroundColorControlSequence(colorDefinition: ConsoleApplicationLogger.RedGreenBlue): string;
+    static generateRedGreenBlueBackgroundColorControlSequence(colorDefinition: ConsoleApplicationLogger.RedGreenBlue): string;
+}
+declare namespace ConsoleApplicationLogger {
+    type FormattedOutputData = Array<[string | null, Formatting]>;
+    type Formatting = {
+        foregroundColor?: FourBitColours | RedGreenBlue;
+        bold?: boolean;
+        bright?: boolean;
+        dim?: boolean;
+        underscore?: boolean;
+        blink?: boolean;
+        reverse?: boolean;
+        hidden?: boolean;
+        underlined?: boolean;
+        backgroundColor?: FourBitColours | RedGreenBlue;
+    };
+    enum FourBitColours {
+        black = "BLACK",
+        white = "WHITE",
+        red = "RED",
+        green = "GREEN",
+        blue = "BLUE",
+        yellow = "YELLOW",
+        magenta = "MAGENTA",
+        cyan = "CYAN"
+    }
+    type RedGreenBlue = {
+        red: number;
+        green: number;
+        blue: number;
+    };
+    function isRegGreenBlue(rawValue: unknown): rawValue is RedGreenBlue;
+}
+export default ConsoleApplicationLogger;

package/Distributable/ConsoleApplicationLogger.js

@@ -0,0 +1,435 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const es_extensions_1 = require("@yamato-daiwa/es-extensions");
+class ConsoleApplicationLogger {
+    static localization = es_extensions_1.loggerLocalization__english;
+    static setLocalization(localization) {
+        ConsoleApplicationLogger.localization = localization;
+        return ConsoleApplicationLogger;
+    }
+    static throwErrorWithFormattedMessage(thrownErrorLog, options = {}) {
+        let stringifiedInnerError;
+        if ((0, es_extensions_1.isNotUndefined)(thrownErrorLog.innerError)) {
+            stringifiedInnerError = (0, es_extensions_1.stringifyAndFormatArbitraryValue)(thrownErrorLog.innerError);
+            if (thrownErrorLog.innerError instanceof Error && (0, es_extensions_1.isNonEmptyString)(thrownErrorLog.innerError.stack)) {
+                stringifiedInnerError = thrownErrorLog.innerError.stack.includes(stringifiedInnerError) ?
+                    thrownErrorLog.innerError.stack :
+                    `${stringifiedInnerError}\n${thrownErrorLog.innerError.stack}`;
+            }
+        }
+        const errorMessage = ConsoleApplicationLogger.
+            generateFormattedErrorFromThrownErrorLog(thrownErrorLog, stringifiedInnerError);
+        if ("errorInstance" in thrownErrorLog) {
+            thrownErrorLog.errorInstance.message = errorMessage;
+            throw thrownErrorLog.errorInstance;
+        }
+        const errorWillBeThrown = new Error(errorMessage);
+        errorWillBeThrown.name = thrownErrorLog.errorType;
+        if (options.mustLogErrorBeforeThrowing === true) {
+            ConsoleApplicationLogger.logErrorLikeMessage({
+                title: errorWillBeThrown.name,
+                description: errorWillBeThrown.message
+            });
+        }
+        throw errorWillBeThrown;
+    }
+    static logError(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload)) {
+            console.error(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.error(...ConsoleApplicationLogger.formatErrorLog(polymorphicPayload));
+    }
+    static logErrorLikeMessage(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload)) {
+            console.error(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.error(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.error,
+                foregroundColor: { red: 255, green: 255, blue: 255 },
+                backgroundColor: { red: 192, green: 57, blue: 43 }
+            },
+            mainColor: { red: 231, green: 76, blue: 60 },
+            titleColor: { red: 192, green: 57, blue: 43 }
+        }));
+    }
+    static logWarning(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload)) {
+            console.error(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.warn(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.warning,
+                foregroundColor: { red: 255, green: 255, blue: 255 },
+                backgroundColor: { red: 211, green: 84, blue: 0 }
+            },
+            mainColor: { red: 230, green: 126, blue: 34 },
+            titleColor: { red: 211, green: 84, blue: 0 }
+        }));
+    }
+    static logInfo(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload)) {
+            console.error(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.log(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.info,
+                foregroundColor: { red: 255, green: 255, blue: 255 },
+                backgroundColor: { red: 41, green: 128, blue: 185 }
+            },
+            mainColor: { red: 52, green: 152, blue: 219 },
+            titleColor: { red: 41, green: 128, blue: 185 }
+        }));
+    }
+    static logSuccess(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload)) {
+            console.error(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.log(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.success,
+                foregroundColor: { red: 255, green: 255, blue: 255 },
+                backgroundColor: { red: 39, green: 174, blue: 96 }
+            },
+            mainColor: { red: 46, green: 204, blue: 113 },
+            titleColor: { red: 39, green: 174, blue: 96 }
+        }));
+    }
+    static logDebug(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload) ||
+            (0, es_extensions_1.isNumber)(polymorphicPayload, { mustConsiderNaN_AsNumber: true }) ||
+            (0, es_extensions_1.isBigInt)(polymorphicPayload) ||
+            (0, es_extensions_1.isBoolean)(polymorphicPayload) ||
+            (0, es_extensions_1.isNull)(polymorphicPayload) ||
+            (0, es_extensions_1.isUndefined)(polymorphicPayload)) {
+            console.debug(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.debug(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.debug,
+                foregroundColor: { red: 0, green: 0, blue: 0 },
+                backgroundColor: { red: 255, green: 255, blue: 255 }
+            },
+            mainColor: { red: 255, green: 255, blue: 255 },
+            titleColor: { red: 255, green: 255, blue: 255 }
+        }));
+    }
+    static logGeneric(polymorphicPayload) {
+        if ((0, es_extensions_1.isString)(polymorphicPayload) ||
+            (0, es_extensions_1.isNumber)(polymorphicPayload, { mustConsiderNaN_AsNumber: true }) ||
+            (0, es_extensions_1.isBigInt)(polymorphicPayload) ||
+            (0, es_extensions_1.isBoolean)(polymorphicPayload) ||
+            (0, es_extensions_1.isNull)(polymorphicPayload) ||
+            (0, es_extensions_1.isUndefined)(polymorphicPayload)) {
+            console.log(polymorphicPayload);
+            return;
+        }
+        if (polymorphicPayload.mustOutputIf === false) {
+            return;
+        }
+        console.log(...ConsoleApplicationLogger.formatGenericLog({
+            genericLog: polymorphicPayload,
+            badgeContentAndFormatting: {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.generic,
+                foregroundColor: { red: 0, green: 0, blue: 0 },
+                backgroundColor: { red: 255, green: 255, blue: 255 }
+            },
+            mainColor: { red: 255, green: 255, blue: 255 },
+            titleColor: { red: 255, green: 255, blue: 255 }
+        }));
+    }
+    static highlightText(targetString) {
+        return `\x1b[43m${targetString}\x1b[49m`;
+    }
+    static generateFormattedErrorFromThrownErrorLog(thrownErrorLog, stringifiedInnerError) {
+        return [
+            ConsoleApplicationLogger.generateRedGreenBlueForegroundColorControlSequence({ red: 231, green: 76, blue: 60 }),
+            "\x1b[1m",
+            thrownErrorLog.title,
+            "\x1b[22m",
+            ...thrownErrorLog.compactLayout === true ? [" "] : ["\n"],
+            ..."errorInstance" in thrownErrorLog ?
+                [thrownErrorLog.errorInstance.message] :
+                [thrownErrorLog.description],
+            `\n\n${ConsoleApplicationLogger.localization.occurrenceLocation}: ${thrownErrorLog.occurrenceLocation}`,
+            ...(0, es_extensions_1.isNotUndefined)(stringifiedInnerError) ?
+                [`\n\n${ConsoleApplicationLogger.localization.innerError}:\n${stringifiedInnerError}`] : [],
+            ...(0, es_extensions_1.isNotUndefined)(thrownErrorLog.additionalData) ?
+                [
+                    `\n\n${ConsoleApplicationLogger.localization.appendedData}:` +
+                        `\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(thrownErrorLog.additionalData)}`
+                ] :
+                [],
+            "\x1b[0m",
+            "\n"
+        ].join("");
+    }
+    static formatErrorLog(errorLog) {
+        return ConsoleApplicationLogger.generateConsoleMethodParametersForFormattedOutput([
+            ConsoleApplicationLogger.generateBadgeIfMust(errorLog.badge, {
+                defaultText: ConsoleApplicationLogger.localization.badgesDefaultTitles.error,
+                foregroundColor: { red: 255, green: 255, blue: 255 },
+                backgroundColor: { red: 192, green: 57, blue: 43 }
+            }),
+            [
+                `${(0, es_extensions_1.insertSubstringIf)(" ", errorLog.badge !== false)}${errorLog.title}`,
+                { bold: true, foregroundColor: { red: 192, green: 57, blue: 43 } }
+            ],
+            [
+                `${errorLog.compactLayout === true ? " " : "\n"}${errorLog.description}`,
+                { foregroundColor: { red: 231, green: 76, blue: 60 } }
+            ],
+            [
+                `\n\n${ConsoleApplicationLogger.localization.errorType}: `,
+                { bold: true, foregroundColor: { red: 231, green: 76, blue: 60 } }
+            ],
+            [
+                errorLog.errorType,
+                { foregroundColor: { red: 231, green: 76, blue: 60 } }
+            ],
+            [
+                `\n${ConsoleApplicationLogger.localization.occurrenceLocation}: `,
+                { bold: true, foregroundColor: { red: 231, green: 76, blue: 60 } }
+            ],
+            [
+                errorLog.occurrenceLocation,
+                { foregroundColor: { red: 231, green: 76, blue: 60 } }
+            ],
+            ...("caughtError" in errorLog ? [
+                [
+                    `\n\n${ConsoleApplicationLogger.localization.caughtError}:`,
+                    { bold: true, foregroundColor: { red: 231, green: 76, blue: 60 } }
+                ],
+                [
+                    (() => {
+                        let stringifiedInnerError = (0, es_extensions_1.stringifyAndFormatArbitraryValue)(errorLog.caughtError);
+                        if (errorLog.caughtError instanceof Error && (0, es_extensions_1.isNotUndefined)(errorLog.caughtError.stack)) {
+                            stringifiedInnerError = errorLog.caughtError.stack.includes(stringifiedInnerError) ?
+                                errorLog.caughtError.stack :
+                                `${stringifiedInnerError}\n${errorLog.caughtError.stack}`;
+                        }
+                        return `\n${stringifiedInnerError}`;
+                    })(),
+                    { foregroundColor: { red: 231, green: 76, blue: 60 } }
+                ]
+            ] : []),
+            ...("additionalData" in errorLog ? [
+                [
+                    `\n\n${ConsoleApplicationLogger.localization.appendedData}:`,
+                    {
+                        bold: true,
+                        foregroundColor: { red: 231, green: 76, blue: 60 }
+                    }
+                ],
+                [
+                    `\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(errorLog.additionalData)}`,
+                    {
+                        foregroundColor: { red: 231, green: 76, blue: 60 }
+                    }
+                ]
+            ] : [])
+        ]);
+    }
+    static formatGenericLog({ genericLog, badgeContentAndFormatting, mainColor, titleColor }) {
+        return ConsoleApplicationLogger.generateConsoleMethodParametersForFormattedOutput([
+            ConsoleApplicationLogger.generateBadgeIfMust(genericLog.badge, badgeContentAndFormatting),
+            [
+                `${(0, es_extensions_1.insertSubstringIf)(" ", genericLog.badge !== false)}${genericLog.title}`,
+                { foregroundColor: titleColor, bold: true }
+            ],
+            [
+                `${genericLog.compactLayout === true ? " " : "\n"}${genericLog.description}`,
+                { foregroundColor: mainColor }
+            ],
+            ...("additionalData" in genericLog ? [
+                [
+                    `\n\n${ConsoleApplicationLogger.localization.appendedData}:`,
+                    { bold: true, foregroundColor: mainColor }
+                ],
+                [
+                    `\n${(0, es_extensions_1.stringifyAndFormatArbitraryValue)(genericLog.additionalData)}`,
+                    { foregroundColor: mainColor }
+                ]
+            ] : [])
+        ]);
+    }
+    static generateBadgeIfMust(badge, { defaultText, foregroundColor, backgroundColor }) {
+        return [
+            badge === false ? null : ` ${badge?.customText ?? defaultText} `,
+            {
+                bold: true,
+                foregroundColor,
+                backgroundColor
+            }
+        ];
+    }
+    static generateConsoleMethodParametersForFormattedOutput(formattedOutputData) {
+        const logsTextings = [];
+        const templatesWithFormattings = [];
+        for (const singleFormattedOutputData of formattedOutputData) {
+            if ((0, es_extensions_1.isNull)(singleFormattedOutputData[0])) {
+                continue;
+            }
+            let templateWithFormatting = "";
+            const formatting = singleFormattedOutputData[1];
+            switch (formatting.foregroundColor) {
+                case ConsoleApplicationLogger.FourBitColours.black: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[30m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.red: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[31m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.green: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[32m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.yellow: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[33m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.blue: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[34m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.magenta: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[35m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.cyan: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[36m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.white: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[37m`;
+                    break;
+                }
+                default: {
+                    if (ConsoleApplicationLogger.isRegGreenBlue(formatting.foregroundColor)) {
+                        templateWithFormatting = `${templateWithFormatting}${ConsoleApplicationLogger.generateRedGreenBlueForegroundColorControlSequence(formatting.foregroundColor)}`;
+                    }
+                }
+            }
+            switch (formatting.backgroundColor) {
+                case ConsoleApplicationLogger.FourBitColours.black: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[40m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.red: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[41m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.green: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[42m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.yellow: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[43m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.blue: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[44m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.magenta: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[45m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.cyan: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[46m`;
+                    break;
+                }
+                case ConsoleApplicationLogger.FourBitColours.white: {
+                    templateWithFormatting = `${templateWithFormatting}\x1b[47m`;
+                    break;
+                }
+                default: {
+                    if (ConsoleApplicationLogger.isRegGreenBlue(formatting.backgroundColor)) {
+                        templateWithFormatting = `${templateWithFormatting}${ConsoleApplicationLogger.generateRedGreenBlueBackgroundColorControlSequence(formatting.backgroundColor)}`;
+                    }
+                }
+            }
+            if (formatting.bold === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[1m`;
+            }
+            if (formatting.underlined === true || formatting.underscore === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[4m`;
+            }
+            if (formatting.bright === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[1m`;
+            }
+            if (formatting.dim === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[2m`;
+            }
+            if (formatting.blink === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[5m`;
+            }
+            if (formatting.reverse === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[7m`;
+            }
+            if (formatting.hidden === true) {
+                templateWithFormatting = `${templateWithFormatting}\x1b[8m`;
+            }
+            logsTextings.push(singleFormattedOutputData[0]);
+            templatesWithFormattings.push(templateWithFormatting);
+        }
+        return [`${templatesWithFormattings.join("%s\x1b[0m")}%s\x1b[0m`].concat(logsTextings);
+    }
+    static generateRedGreenBlueForegroundColorControlSequence(colorDefinition) {
+        return `\x1b[38;2;${colorDefinition.red};${colorDefinition.green};${colorDefinition.blue}m`;
+    }
+    static generateRedGreenBlueBackgroundColorControlSequence(colorDefinition) {
+        return `\x1b[48;2;${colorDefinition.red};${colorDefinition.green};${colorDefinition.blue}m`;
+    }
+}
+(function (ConsoleApplicationLogger) {
+    let FourBitColours;
+    (function (FourBitColours) {
+        FourBitColours["black"] = "BLACK";
+        FourBitColours["white"] = "WHITE";
+        FourBitColours["red"] = "RED";
+        FourBitColours["green"] = "GREEN";
+        FourBitColours["blue"] = "BLUE";
+        FourBitColours["yellow"] = "YELLOW";
+        FourBitColours["magenta"] = "MAGENTA";
+        FourBitColours["cyan"] = "CYAN";
+    })(FourBitColours = ConsoleApplicationLogger.FourBitColours || (ConsoleApplicationLogger.FourBitColours = {}));
+    function isRegGreenBlue(rawValue) {
+        return (0, es_extensions_1.isArbitraryObject)(rawValue) &&
+            (0, es_extensions_1.isNaturalNumberOrZero)(rawValue.red) &&
+            (0, es_extensions_1.isNaturalNumberOrZero)(rawValue.green) &&
+            (0, es_extensions_1.isNaturalNumberOrZero)(rawValue.blue);
+    }
+    ConsoleApplicationLogger.isRegGreenBlue = isRegGreenBlue;
+})(ConsoleApplicationLogger || (ConsoleApplicationLogger = {}));
+exports.default = ConsoleApplicationLogger;