🎯 MapView v2.0 - Global Deployment Ready

✨ MAJOR FEATURES:
• Auto-zoom intelligence với smart bounds fitting
• Enhanced 3D GPS markers với pulsing effects
• Professional route display với 6-layer rendering
• Status-based parking icons với availability indicators
• Production-ready build optimizations

🗺️ AUTO-ZOOM FEATURES:
• Smart bounds fitting cho GPS + selected parking
• Adaptive padding (50px) cho visual balance
• Max zoom control (level 16) để tránh quá gần
• Dynamic centering khi không có selection

🎨 ENHANCED VISUALS:
• 3D GPS marker với multi-layer pulse effects
• Advanced parking icons với status colors
• Selection highlighting với animation
• Dimming system cho non-selected items

🛣️ ROUTE SYSTEM:
• OpenRouteService API integration
• Multi-layer route rendering (glow, shadow, main, animated)
• Real-time distance & duration calculation
• Visual route info trong popup

📱 PRODUCTION READY:
• SSR safe với dynamic imports
• Build errors resolved
• Global deployment via Vercel
• Optimized performance

🌍 DEPLOYMENT:
• Vercel: https://whatever-ctk2auuxr-phong12hexdockworks-projects.vercel.app
• Bundle size: 22.8 kB optimized
• Global CDN distribution
• HTTPS enabled

💾 VERSION CONTROL:
• MapView-v2.0.tsx backup created
• MAPVIEW_VERSIONS.md documentation
• Full version history tracking

backend/node_modules/@nestjs/common/services/console-logger.service.d.ts

@@ -0,0 +1,86 @@
+import { LoggerService, LogLevel } from './logger.service';
+export interface ConsoleLoggerOptions {
+    /**
+     * Enabled log levels.
+     */
+    logLevels?: LogLevel[];
+    /**
+     * If enabled, will print timestamp (time difference) between current and previous log message.
+     */
+    timestamp?: boolean;
+}
+export declare class ConsoleLogger implements LoggerService {
+    protected context?: string;
+    protected options: ConsoleLoggerOptions;
+    private static lastTimestampAt?;
+    private originalContext?;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options: ConsoleLoggerOptions);
+    /**
+     * Write a 'log' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log, if the configured level allows for it.
+     * Prints to `stderr` with newline.
+     */
+    error(message: any, stackOrContext?: string): void;
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'warn' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels: LogLevel[]): void;
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context: string): void;
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext(): void;
+    isLevelEnabled(level: LogLevel): boolean;
+    protected getTimestamp(): string;
+    protected printMessages(messages: unknown[], context?: string, logLevel?: LogLevel, writeStreamType?: 'stdout' | 'stderr'): void;
+    protected formatPid(pid: number): string;
+    protected formatContext(context: string): string;
+    protected formatMessage(logLevel: LogLevel, message: unknown, pidMessage: string, formattedLogLevel: string, contextMessage: string, timestampDiff: string): string;
+    protected stringifyMessage(message: unknown, logLevel: LogLevel): any;
+    protected colorize(message: string, logLevel: LogLevel): string;
+    protected printStackTrace(stack: string): void;
+    protected updateAndGetTimestampDiff(): string;
+    protected formatTimestampDiff(timestampDiff: number): string;
+    private getContextAndMessagesToPrint;
+    private getContextAndStackAndMessagesToPrint;
+    private isStackFormat;
+    private getColorByLogLevel;
+}

backend/node_modules/@nestjs/common/services/console-logger.service.js

@@ -0,0 +1,255 @@
+"use strict";
+var ConsoleLogger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogger = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("../decorators/core");
+const cli_colors_util_1 = require("../utils/cli-colors.util");
+const shared_utils_1 = require("../utils/shared.utils");
+const utils_1 = require("./utils");
+const DEFAULT_LOG_LEVELS = [
+    'log',
+    'error',
+    'warn',
+    'debug',
+    'verbose',
+    'fatal',
+];
+const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+    year: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+    day: '2-digit',
+    month: '2-digit',
+});
+let ConsoleLogger = ConsoleLogger_1 = class ConsoleLogger {
+    constructor(context, options = {}) {
+        this.context = context;
+        this.options = options;
+        if (!options.logLevels) {
+            options.logLevels = DEFAULT_LOG_LEVELS;
+        }
+        if (context) {
+            this.originalContext = context;
+        }
+    }
+    log(message, ...optionalParams) {
+        if (!this.isLevelEnabled('log')) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        this.printMessages(messages, context, 'log');
+    }
+    error(message, ...optionalParams) {
+        if (!this.isLevelEnabled('error')) {
+            return;
+        }
+        const { messages, context, stack } = this.getContextAndStackAndMessagesToPrint([message, ...optionalParams]);
+        this.printMessages(messages, context, 'error', 'stderr');
+        this.printStackTrace(stack);
+    }
+    warn(message, ...optionalParams) {
+        if (!this.isLevelEnabled('warn')) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        this.printMessages(messages, context, 'warn');
+    }
+    debug(message, ...optionalParams) {
+        if (!this.isLevelEnabled('debug')) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        this.printMessages(messages, context, 'debug');
+    }
+    verbose(message, ...optionalParams) {
+        if (!this.isLevelEnabled('verbose')) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        this.printMessages(messages, context, 'verbose');
+    }
+    fatal(message, ...optionalParams) {
+        if (!this.isLevelEnabled('fatal')) {
+            return;
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint([
+            message,
+            ...optionalParams,
+        ]);
+        this.printMessages(messages, context, 'fatal');
+    }
+    /**
+     * Set log levels
+     * @param levels log levels
+     */
+    setLogLevels(levels) {
+        if (!this.options) {
+            this.options = {};
+        }
+        this.options.logLevels = levels;
+    }
+    /**
+     * Set logger context
+     * @param context context
+     */
+    setContext(context) {
+        this.context = context;
+    }
+    /**
+     * Resets the logger context to the value that was passed in the constructor.
+     */
+    resetContext() {
+        this.context = this.originalContext;
+    }
+    isLevelEnabled(level) {
+        const logLevels = this.options?.logLevels;
+        return (0, utils_1.isLogLevelEnabled)(level, logLevels);
+    }
+    getTimestamp() {
+        return dateTimeFormatter.format(Date.now());
+    }
+    printMessages(messages, context = '', logLevel = 'log', writeStreamType) {
+        messages.forEach(message => {
+            const pidMessage = this.formatPid(process.pid);
+            const contextMessage = this.formatContext(context);
+            const timestampDiff = this.updateAndGetTimestampDiff();
+            const formattedLogLevel = logLevel.toUpperCase().padStart(7, ' ');
+            const formattedMessage = this.formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff);
+            process[writeStreamType ?? 'stdout'].write(formattedMessage);
+        });
+    }
+    formatPid(pid) {
+        return `[Nest] ${pid}  - `;
+    }
+    formatContext(context) {
+        return context ? (0, cli_colors_util_1.yellow)(`[${context}] `) : '';
+    }
+    formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+        const output = this.stringifyMessage(message, logLevel);
+        pidMessage = this.colorize(pidMessage, logLevel);
+        formattedLogLevel = this.colorize(formattedLogLevel, logLevel);
+        return `${pidMessage}${this.getTimestamp()} ${formattedLogLevel} ${contextMessage}${output}${timestampDiff}\n`;
+    }
+    stringifyMessage(message, logLevel) {
+        if ((0, shared_utils_1.isFunction)(message)) {
+            const messageAsStr = Function.prototype.toString.call(message);
+            const isClass = messageAsStr.startsWith('class ');
+            if (isClass) {
+                // If the message is a class, we will display the class name.
+                return this.stringifyMessage(message.name, logLevel);
+            }
+            // If the message is a non-class function, call it and re-resolve its value.
+            return this.stringifyMessage(message(), logLevel);
+        }
+        return (0, shared_utils_1.isPlainObject)(message) || Array.isArray(message)
+            ? `${this.colorize('Object:', logLevel)}\n${JSON.stringify(message, (key, value) => typeof value === 'bigint' ? value.toString() : value, 2)}\n`
+            : this.colorize(message, logLevel);
+    }
+    colorize(message, logLevel) {
+        const color = this.getColorByLogLevel(logLevel);
+        return color(message);
+    }
+    printStackTrace(stack) {
+        if (!stack) {
+            return;
+        }
+        process.stderr.write(`${stack}\n`);
+    }
+    updateAndGetTimestampDiff() {
+        const includeTimestamp = ConsoleLogger_1.lastTimestampAt && this.options?.timestamp;
+        const result = includeTimestamp
+            ? this.formatTimestampDiff(Date.now() - ConsoleLogger_1.lastTimestampAt)
+            : '';
+        ConsoleLogger_1.lastTimestampAt = Date.now();
+        return result;
+    }
+    formatTimestampDiff(timestampDiff) {
+        return (0, cli_colors_util_1.yellow)(` +${timestampDiff}ms`);
+    }
+    getContextAndMessagesToPrint(args) {
+        if (args?.length <= 1) {
+            return { messages: args, context: this.context };
+        }
+        const lastElement = args[args.length - 1];
+        const isContext = (0, shared_utils_1.isString)(lastElement);
+        if (!isContext) {
+            return { messages: args, context: this.context };
+        }
+        return {
+            context: lastElement,
+            messages: args.slice(0, args.length - 1),
+        };
+    }
+    getContextAndStackAndMessagesToPrint(args) {
+        if (args.length === 2) {
+            return this.isStackFormat(args[1])
+                ? {
+                    messages: [args[0]],
+                    stack: args[1],
+                    context: this.context,
+                }
+                : {
+                    messages: [args[0]],
+                    context: args[1],
+                };
+        }
+        const { messages, context } = this.getContextAndMessagesToPrint(args);
+        if (messages?.length <= 1) {
+            return { messages, context };
+        }
+        const lastElement = messages[messages.length - 1];
+        const isStack = (0, shared_utils_1.isString)(lastElement);
+        // https://github.com/nestjs/nest/issues/11074#issuecomment-1421680060
+        if (!isStack && !(0, shared_utils_1.isUndefined)(lastElement)) {
+            return { messages, context };
+        }
+        return {
+            stack: lastElement,
+            messages: messages.slice(0, messages.length - 1),
+            context,
+        };
+    }
+    isStackFormat(stack) {
+        if (!(0, shared_utils_1.isString)(stack) && !(0, shared_utils_1.isUndefined)(stack)) {
+            return false;
+        }
+        return /^(.)+\n\s+at .+:\d+:\d+/.test(stack);
+    }
+    getColorByLogLevel(level) {
+        switch (level) {
+            case 'debug':
+                return cli_colors_util_1.clc.magentaBright;
+            case 'warn':
+                return cli_colors_util_1.clc.yellow;
+            case 'error':
+                return cli_colors_util_1.clc.red;
+            case 'verbose':
+                return cli_colors_util_1.clc.cyanBright;
+            case 'fatal':
+                return cli_colors_util_1.clc.bold;
+            default:
+                return cli_colors_util_1.clc.green;
+        }
+    }
+};
+exports.ConsoleLogger = ConsoleLogger;
+exports.ConsoleLogger = ConsoleLogger = ConsoleLogger_1 = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, core_1.Optional)()),
+    tslib_1.__param(1, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [String, Object])
+], ConsoleLogger);

backend/node_modules/@nestjs/common/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from './console-logger.service';
+export * from './logger.service';

backend/node_modules/@nestjs/common/services/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./console-logger.service"), exports);
+tslib_1.__exportStar(require("./logger.service"), exports);

backend/node_modules/@nestjs/common/services/logger.service.d.ts

@@ -0,0 +1,151 @@
+/**
+ * @publicApi
+ */
+export type LogLevel = 'log' | 'error' | 'warn' | 'debug' | 'verbose' | 'fatal';
+/**
+ * @publicApi
+ */
+export interface LoggerService {
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal?(message: any, ...optionalParams: any[]): any;
+    /**
+     * Set log levels.
+     * @param levels log levels
+     */
+    setLogLevels?(levels: LogLevel[]): any;
+}
+interface LogBufferRecord {
+    /**
+     * Method to execute.
+     */
+    methodRef: Function;
+    /**
+     * Arguments to pass to the method.
+     */
+    arguments: unknown[];
+}
+/**
+ * @publicApi
+ */
+export declare class Logger implements LoggerService {
+    protected context?: string;
+    protected options: {
+        timestamp?: boolean;
+    };
+    protected static logBuffer: LogBufferRecord[];
+    protected static staticInstanceRef?: LoggerService;
+    protected static logLevels?: LogLevel[];
+    private static isBufferAttached;
+    protected localInstanceRef?: LoggerService;
+    private static WrapBuffer;
+    constructor();
+    constructor(context: string);
+    constructor(context: string, options?: {
+        timestamp?: boolean;
+    });
+    get localInstance(): LoggerService;
+    /**
+     * Write an 'error' level log.
+     */
+    error(message: any, stack?: string, context?: string): void;
+    error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    log(message: any, context?: string): void;
+    log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    warn(message: any, context?: string): void;
+    warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log.
+     */
+    debug(message: any, context?: string): void;
+    debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    verbose(message: any, context?: string): void;
+    verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    fatal(message: any, context?: string): void;
+    fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write an 'error' level log.
+     */
+    static error(message: any, stackOrContext?: string): void;
+    static error(message: any, context?: string): void;
+    static error(message: any, stack?: string, context?: string): void;
+    static error(message: any, ...optionalParams: [...any, string?, string?]): void;
+    /**
+     * Write a 'log' level log.
+     */
+    static log(message: any, context?: string): void;
+    static log(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'warn' level log.
+     */
+    static warn(message: any, context?: string): void;
+    static warn(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'debug' level log, if the configured level allows for it.
+     * Prints to `stdout` with newline.
+     */
+    static debug(message: any, context?: string): void;
+    static debug(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'verbose' level log.
+     */
+    static verbose(message: any, context?: string): void;
+    static verbose(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Write a 'fatal' level log.
+     */
+    static fatal(message: any, context?: string): void;
+    static fatal(message: any, ...optionalParams: [...any, string?]): void;
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush(): void;
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer(): void;
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer(): void;
+    static getTimestamp(): string;
+    static overrideLogger(logger: LoggerService | LogLevel[] | boolean): any;
+    static isLevelEnabled(level: LogLevel): boolean;
+    private registerLocalInstanceRef;
+}
+export {};

backend/node_modules/@nestjs/common/services/logger.service.js

@@ -0,0 +1,243 @@
+"use strict";
+var Logger_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("../decorators/core");
+const shared_utils_1 = require("../utils/shared.utils");
+const console_logger_service_1 = require("./console-logger.service");
+const utils_1 = require("./utils");
+const DEFAULT_LOGGER = new console_logger_service_1.ConsoleLogger();
+const dateTimeFormatter = new Intl.DateTimeFormat(undefined, {
+    year: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric',
+    day: '2-digit',
+    month: '2-digit',
+});
+/**
+ * @publicApi
+ */
+let Logger = Logger_1 = class Logger {
+    constructor(context, options = {}) {
+        this.context = context;
+        this.options = options;
+    }
+    get localInstance() {
+        if (Logger_1.staticInstanceRef === DEFAULT_LOGGER) {
+            return this.registerLocalInstanceRef();
+        }
+        else if (Logger_1.staticInstanceRef instanceof Logger_1) {
+            const prototype = Object.getPrototypeOf(Logger_1.staticInstanceRef);
+            if (prototype.constructor === Logger_1) {
+                return this.registerLocalInstanceRef();
+            }
+        }
+        return Logger_1.staticInstanceRef;
+    }
+    error(message, ...optionalParams) {
+        optionalParams = this.context
+            ? (optionalParams.length ? optionalParams : [undefined]).concat(this.context)
+            : optionalParams;
+        this.localInstance?.error(message, ...optionalParams);
+    }
+    log(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.log(message, ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.warn(message, ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.debug?.(message, ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.verbose?.(message, ...optionalParams);
+    }
+    fatal(message, ...optionalParams) {
+        optionalParams = this.context
+            ? optionalParams.concat(this.context)
+            : optionalParams;
+        this.localInstance?.fatal?.(message, ...optionalParams);
+    }
+    static error(message, ...optionalParams) {
+        this.staticInstanceRef?.error(message, ...optionalParams);
+    }
+    static log(message, ...optionalParams) {
+        this.staticInstanceRef?.log(message, ...optionalParams);
+    }
+    static warn(message, ...optionalParams) {
+        this.staticInstanceRef?.warn(message, ...optionalParams);
+    }
+    static debug(message, ...optionalParams) {
+        this.staticInstanceRef?.debug?.(message, ...optionalParams);
+    }
+    static verbose(message, ...optionalParams) {
+        this.staticInstanceRef?.verbose?.(message, ...optionalParams);
+    }
+    static fatal(message, ...optionalParams) {
+        this.staticInstanceRef?.fatal?.(message, ...optionalParams);
+    }
+    /**
+     * Print buffered logs and detach buffer.
+     */
+    static flush() {
+        this.isBufferAttached = false;
+        this.logBuffer.forEach(item => item.methodRef(...item.arguments));
+        this.logBuffer = [];
+    }
+    /**
+     * Attach buffer.
+     * Turns on initialization logs buffering.
+     */
+    static attachBuffer() {
+        this.isBufferAttached = true;
+    }
+    /**
+     * Detach buffer.
+     * Turns off initialization logs buffering.
+     */
+    static detachBuffer() {
+        this.isBufferAttached = false;
+    }
+    static getTimestamp() {
+        return dateTimeFormatter.format(Date.now());
+    }
+    static overrideLogger(logger) {
+        if (Array.isArray(logger)) {
+            Logger_1.logLevels = logger;
+            return this.staticInstanceRef?.setLogLevels(logger);
+        }
+        if ((0, shared_utils_1.isObject)(logger)) {
+            if (logger instanceof Logger_1 && logger.constructor !== Logger_1) {
+                const errorMessage = `Using the "extends Logger" instruction is not allowed in Nest v9. Please, use "extends ConsoleLogger" instead.`;
+                this.staticInstanceRef.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.staticInstanceRef = logger;
+        }
+        else {
+            this.staticInstanceRef = undefined;
+        }
+    }
+    static isLevelEnabled(level) {
+        const logLevels = Logger_1.logLevels;
+        return (0, utils_1.isLogLevelEnabled)(level, logLevels);
+    }
+    registerLocalInstanceRef() {
+        if (this.localInstanceRef) {
+            return this.localInstanceRef;
+        }
+        this.localInstanceRef = new console_logger_service_1.ConsoleLogger(this.context, {
+            timestamp: this.options?.timestamp,
+            logLevels: Logger_1.logLevels,
+        });
+        return this.localInstanceRef;
+    }
+};
+exports.Logger = Logger;
+Logger.logBuffer = new Array();
+Logger.staticInstanceRef = DEFAULT_LOGGER;
+Logger.WrapBuffer = (target, propertyKey, descriptor) => {
+    const originalFn = descriptor.value;
+    descriptor.value = function (...args) {
+        if (Logger_1.isBufferAttached) {
+            Logger_1.logBuffer.push({
+                methodRef: originalFn.bind(this),
+                arguments: args,
+            });
+            return;
+        }
+        return originalFn.call(this, ...args);
+    };
+};
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "error", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "log", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "warn", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "debug", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "verbose", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger.prototype, "fatal", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "error", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "log", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "warn", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "debug", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "verbose", null);
+tslib_1.__decorate([
+    Logger.WrapBuffer,
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Object, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], Logger, "fatal", null);
+exports.Logger = Logger = Logger_1 = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, core_1.Optional)()),
+    tslib_1.__param(1, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [String, Object])
+], Logger);

backend/node_modules/@nestjs/common/services/utils/filter-log-levels.util.d.ts

@@ -0,0 +1,5 @@
+import { LogLevel } from '../logger.service';
+/**
+ * @publicApi
+ */
+export declare function filterLogLevels(parseableString?: string): LogLevel[];

backend/node_modules/@nestjs/common/services/utils/filter-log-levels.util.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterLogLevels = filterLogLevels;
+const logger_service_1 = require("../logger.service");
+const is_log_level_util_1 = require("./is-log-level.util");
+/**
+ * @publicApi
+ */
+function filterLogLevels(parseableString = '') {
+    const sanitizedSring = parseableString.replaceAll(' ', '').toLowerCase();
+    if (sanitizedSring[0] === '>') {
+        const orEqual = sanitizedSring[1] === '=';
+        const logLevelIndex = logger_service_1.LOG_LEVELS.indexOf(sanitizedSring.substring(orEqual ? 2 : 1));
+        if (logLevelIndex === -1) {
+            throw new Error(`parse error (unknown log level): ${sanitizedSring}`);
+        }
+        return logger_service_1.LOG_LEVELS.slice(orEqual ? logLevelIndex : logLevelIndex + 1);
+    }
+    else if (sanitizedSring.includes(',')) {
+        return sanitizedSring.split(',').filter(is_log_level_util_1.isLogLevel);
+    }
+    return (0, is_log_level_util_1.isLogLevel)(sanitizedSring) ? [sanitizedSring] : logger_service_1.LOG_LEVELS;
+}

backend/node_modules/@nestjs/common/services/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './is-log-level-enabled.util';

backend/node_modules/@nestjs/common/services/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./is-log-level-enabled.util"), exports);

backend/node_modules/@nestjs/common/services/utils/is-log-level-enabled.util.d.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from '../logger.service';
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+export declare function isLogLevelEnabled(targetLevel: LogLevel, logLevels: LogLevel[] | undefined): boolean;

backend/node_modules/@nestjs/common/services/utils/is-log-level-enabled.util.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLogLevelEnabled = isLogLevelEnabled;
+const LOG_LEVEL_VALUES = {
+    verbose: 0,
+    debug: 1,
+    log: 2,
+    warn: 3,
+    error: 4,
+    fatal: 5,
+};
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+function isLogLevelEnabled(targetLevel, logLevels) {
+    if (!logLevels || (Array.isArray(logLevels) && logLevels?.length === 0)) {
+        return false;
+    }
+    if (logLevels.includes(targetLevel)) {
+        return true;
+    }
+    const highestLogLevelValue = logLevels
+        .map(level => LOG_LEVEL_VALUES[level])
+        .sort((a, b) => b - a)?.[0];
+    const targetLevelValue = LOG_LEVEL_VALUES[targetLevel];
+    return targetLevelValue >= highestLogLevelValue;
+}

backend/node_modules/@nestjs/common/services/utils/is-log-level.util.d.ts

@@ -0,0 +1,5 @@
+import { LogLevel } from '../logger.service';
+/**
+ * @publicApi
+ */
+export declare function isLogLevel(maybeLogLevel: any): maybeLogLevel is LogLevel;

backend/node_modules/@nestjs/common/services/utils/is-log-level.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLogLevel = isLogLevel;
+const logger_service_1 = require("../logger.service");
+/**
+ * @publicApi
+ */
+function isLogLevel(maybeLogLevel) {
+    return logger_service_1.LOG_LEVELS.includes(maybeLogLevel);
+}