@foxford/logger 1.0.0-beta-6f7848f0-20250318

package/browser.cjs.js

@@ -0,0 +1,456 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var log = require('loglevel');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var log__default = /*#__PURE__*/_interopDefaultLegacy(log);
+
+/**
+ * Генерирует hex-код цвета на основе строки, избегая оттенков красного
+ * @param {string} str - Строка, для которой нужно сгенерировать цвет
+ * @returns {string} - Hex-код цвета
+ */
+function generateHexByString(str) {
+    // Генерируем новый цвет
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    // Используем HSL для контроля оттенка
+    const hue = Math.abs(hash) % 300; // Расширяем диапазон, исключая только часть красного (300-360)
+    const saturation = 60 + (Math.abs(hash) % 40); // От 60% до 100%
+    const lightness = 30 + (Math.abs(hash) % 40); // От 30% до 70%
+    // Конвертируем HSL в RGB
+    const chroma = ((1 - Math.abs((2 * lightness) / 100 - 1)) * saturation) / 100;
+    const huePrime = hue / 60;
+    const x = chroma * (1 - Math.abs((huePrime % 2) - 1));
+    let r1 = 0, g1 = 0, b1 = 0;
+    if (huePrime >= 0 && huePrime < 1) {
+        [r1, g1, b1] = [chroma, x, 0];
+    }
+    else if (huePrime >= 1 && huePrime < 2) {
+        [r1, g1, b1] = [x, chroma, 0];
+    }
+    else if (huePrime >= 2 && huePrime < 3) {
+        [r1, g1, b1] = [0, chroma, x];
+    }
+    else if (huePrime >= 3 && huePrime < 4) {
+        [r1, g1, b1] = [0, x, chroma];
+    }
+    else if (huePrime >= 4 && huePrime < 5) {
+        [r1, g1, b1] = [x, 0, chroma];
+    }
+    else {
+        [r1, g1, b1] = [chroma, 0, x];
+    }
+    const m = lightness / 100 - chroma / 2;
+    const [r, g, b] = [r1, g1, b1].map((v) => Math.round((v + m) * 255));
+    // Добавляем проверку и значения по умолчанию
+    const rValue = r !== null && r !== void 0 ? r : 0;
+    const gValue = g !== null && g !== void 0 ? g : 0;
+    const bValue = b !== null && b !== void 0 ? b : 0;
+    const color = `#${((rValue << 16) | (gValue << 8) | bValue).toString(16).padStart(6, '0')}`;
+    return color;
+}
+
+/** Ключ для хранения значения debug в localStorage */
+const DEBUG_LC_KEY = 'debug';
+/**
+ * Кеш для хранения сгенерированных цветов
+ * могут быть заранее предустановлены по имени логгера
+ **/
+const colorCache = {};
+/** Цвета для различных уровней логирования */
+const levelColors = {
+    TRACE: '#6C757D', // Серый
+    LOG: '#17A2B8', // Голубой
+    DEBUG: '#17A2B8', // Голубой
+    INFO: '#28A745', // Зеленый
+    WARN: '#FFC107', // Желтый
+    ERROR: '#DC3545', // Красный
+};
+/**
+ * Генерирует hex-код цвета на основе строки, избегая оттенков красного
+ * @param {string} str - Строка, для которой нужно сгенерировать цвет
+ * @returns {string} - Hex-код цвета
+ */
+function stringToColorCode(str) {
+    var _a;
+    // Если цвет уже есть в кеше, возвращаем его
+    if (str in colorCache) {
+        return (_a = colorCache[str]) !== null && _a !== void 0 ? _a : 'inherit';
+    }
+    const color = generateHexByString(str);
+    // Сохраняем цвет в кеш
+    colorCache[str] = color;
+    return color;
+}
+/**
+ * Получает значение debug из localStorage
+ * @returns {string | undefined} Значение debug или undefined, если его нет
+ */
+function getDebugValue() {
+    try {
+        return localStorage.getItem(DEBUG_LC_KEY) || undefined;
+    }
+    catch (error) {
+        console.warn('Failed to get `debug` value from localStorage:', error);
+        return undefined;
+    }
+}
+/**
+ * Устанавливает значение debug в localStorage
+ * @param {string | null} value - Значение для установки
+ */
+function setDebugValue(value) {
+    try {
+        if (value === null || value === undefined) {
+            localStorage.removeItem(DEBUG_LC_KEY);
+        }
+        else {
+            localStorage.setItem(DEBUG_LC_KEY, value);
+        }
+    }
+    catch (error) {
+        console.warn('Failed to set `debug` value in localStorage:', error);
+    }
+}
+/**
+ * Форматирует сообщение лога
+ * @param {string} level - Уровень логирования
+ * @param {string} name - Имя логгера
+ * @param {Date} timestamp - Временная метка
+ * @returns {Array} Массив с отформатированной строкой и стилями
+ */
+function formatter(level, name, timestamp) {
+    const baseStyle = 'font-weight: bold;';
+    const date = `${timestamp.toLocaleDateString()} ${timestamp.toLocaleTimeString()}`;
+    let dateStyle;
+    let levelStyle;
+    let nameStyle;
+    switch (name) {
+        // предустановленнный цветовой шаблон по имени логгера
+        case 'critical':
+            dateStyle = `color: ${levelColors.ERROR};`;
+            levelStyle = `color: ${levelColors.ERROR};`;
+            nameStyle = `color: ${levelColors.ERROR};`;
+            break;
+        default:
+            dateStyle = `color: #6C757D;`;
+            levelStyle = `color: ${levelColors[level]};`;
+            nameStyle = `color: ${stringToColorCode(name)};`;
+            break;
+    }
+    return [
+        `%c[${date}] %c[${level}] %c[${name}] %c•`,
+        `${baseStyle} ${dateStyle}`,
+        `${baseStyle} ${levelStyle}`,
+        `${baseStyle} ${nameStyle}`,
+        `color: white`,
+    ];
+}
+/**
+ * Объект с методами для работы с окружением браузера
+ */
+const environment = {
+    getDebugValue,
+    setDebugValue,
+    formatter,
+    /**
+     * Устанавливает обработчик изменения значения debug
+     * @param {function} callback - Функция обратного вызова
+     * @returns {function} Функция для удаления обработчика
+     */
+    onDebugValueChange: (callback) => {
+        function changeValue(event) {
+            if (event.key === DEBUG_LC_KEY) {
+                callback(event.newValue);
+            }
+        }
+        window.addEventListener('storage', changeValue);
+        return () => {
+            window.removeEventListener('storage', changeValue);
+        };
+    },
+};
+
+/**
+ * Генерирует UUID версии 4.
+ * @returns {string} Строка, представляющая UUID версии 4.
+ */
+function generateUUIDv4() {
+    return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (char) => (parseInt(char, 10) ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (parseInt(char, 10) / 4)))).toString(16));
+}
+
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+const loggerCache = new Map();
+const previousLevels = new Map();
+let isInitialized = false;
+/**
+ * Создает экземпляр HierarchicalLogger
+ * @param fullName Имя логгера
+ * @param parent Родительский логгер (если есть)
+ */
+function createHierarchicalLogger(originalGetLogger, fullName, parent) {
+    const loggerId = generateUUIDv4();
+    const baseLogger = originalGetLogger(fullName);
+    const name = parent ? fullName.slice(parent.getFullName().length + 1) : fullName;
+    const hierarchicalLogger = Object.assign(Object.assign({}, baseLogger), { id: loggerId, parent: parent !== null && parent !== void 0 ? parent : null, children: new Set(), name: name, debugEnabled: false, isDebugEnabled() {
+            return this.debugEnabled;
+        },
+        getDebugPattern() {
+            var _a;
+            return (_a = environment.getDebugValue()) !== null && _a !== void 0 ? _a : null;
+        },
+        // Добавим вспомогательный метод для получения полного имени логгера
+        getFullName() {
+            if (!this.parent) {
+                return this.name;
+            }
+            const parentFullName = this.parent.getFullName();
+            return parentFullName ? `${parentFullName}:${this.name}` : this.name;
+        },
+        setDebug(enabled) {
+            this.debugEnabled = enabled;
+            const parentLevel = this.parent ? this.parent.getLevel() : undefined;
+            const currentPatterns = (environment.getDebugValue() || '').split(',').filter(Boolean);
+            const fullName = this.getFullName();
+            if (enabled) {
+                if (!previousLevels.has(this.id)) {
+                    previousLevels.set(this.id, baseLogger.getLevel());
+                }
+                baseLogger.setLevel(log__default["default"].levels.TRACE, false);
+                // Если включаем отладку
+                if (!currentPatterns.some((pattern) => fullName === pattern || `${fullName}:*` === pattern)) {
+                    // Удаляем все дочерние паттерны, если они есть
+                    const childrenPatterns = currentPatterns.filter((pattern) => pattern.startsWith(`${fullName}:`));
+                    childrenPatterns.forEach((pattern) => {
+                        const index = currentPatterns.indexOf(pattern);
+                        if (index !== -1) {
+                            currentPatterns.splice(index, 1);
+                        }
+                    });
+                    // Добавляем новый паттерн без ':*'
+                    currentPatterns.push(fullName);
+                }
+            }
+            else {
+                let newLevel;
+                if (parentLevel !== undefined) {
+                    // Используем уровень родительского логгера, если он существует
+                    newLevel = parentLevel;
+                }
+                else {
+                    // Если родительского логгера нет, используем предыдущий сохраненный уровень или уровень по умолчанию
+                    newLevel = previousLevels.get(this.id) || log__default["default"].levels.WARN;
+                }
+                baseLogger.setLevel(newLevel, false);
+                previousLevels.delete(this.id);
+                // Если выключаем отладку
+                const index = currentPatterns.findIndex((pattern) => pattern === fullName || pattern === `${fullName}:*`);
+                if (index !== -1) {
+                    currentPatterns.splice(index, 1);
+                }
+            }
+            // Оптимизируем паттерны
+            const optimizedPatterns = optimizePatterns(currentPatterns);
+            // Сохраняем оптимизированные паттерны
+            environment.setDebugValue(optimizedPatterns.join(',') || null);
+        },
+        getLogger(name) {
+            const childLogger = createHierarchicalLogger(originalGetLogger, `${fullName}:${name}`, this);
+            this.children.add(childLogger);
+            return childLogger;
+        },
+        setLevel(level) {
+            baseLogger.setLevel(level, false);
+            // Обновляем уровень для всех дочерних логгеров
+            this.children.forEach((child) => child.setLevel(level, false));
+            // Если логгер в режиме отладки, сохраняем новый уровень
+            if (this.isDebugEnabled()) {
+                previousLevels.set(loggerId, level);
+            }
+        } });
+    const originalFactory = baseLogger.methodFactory;
+    // Переопределяем методы логирования для учета режима отладки
+    const logMethods = ['trace', 'debug', 'info', 'warn', 'error', 'log'];
+    logMethods.forEach((method) => {
+        const originalMethod = originalFactory(method, baseLogger.getLevel(), fullName);
+        hierarchicalLogger[method] = function (...args) {
+            var _a;
+            const debugEnabled = this.isDebugEnabled();
+            const messageLevel = (_a = log__default["default"].levels[method.toUpperCase()]) !== null && _a !== void 0 ? _a : 0;
+            const currentLevel = baseLogger.getLevel();
+            if (debugEnabled || messageLevel >= currentLevel) {
+                return originalMethod.apply(baseLogger, args);
+            }
+        };
+    });
+    loggerCache.set(loggerId, hierarchicalLogger);
+    if (!isInitialized) {
+        isInitialized = true;
+        initializeDebugPatterns();
+    }
+    else {
+        const debugPattern = environment.getDebugValue() || '';
+        const patterns = debugPattern
+            .split(',')
+            .map((p) => p.trim())
+            .filter(Boolean);
+        configureLogger(hierarchicalLogger, patterns);
+    }
+    return hierarchicalLogger;
+}
+/**
+ * Оптимизирует паттерны отладки
+ * @param patterns Массив паттернов отладки
+ * @returns Оптимизированный массив паттернов
+ */
+function optimizePatterns(patterns) {
+    const optimized = new Set();
+    // Сортируем паттерны от более общих к более конкретным
+    patterns.sort((a, b) => a.split(':').length - b.split(':').length);
+    for (const pattern of patterns) {
+        let isRedundant = false;
+        for (const existingPattern of optimized) {
+            if (pattern === existingPattern || pattern.startsWith(existingPattern + ':')) {
+                isRedundant = true;
+                break;
+            }
+        }
+        if (!isRedundant) {
+            optimized.add(pattern);
+        }
+    }
+    return Array.from(optimized);
+}
+/**
+ * Проверяет, должен ли логгер быть в режиме отладки
+ * @param fullName Полное имя логгера
+ * @param patterns Массив паттернов отладки
+ * @returns true, если логгер должен быть в режиме отладки
+ */
+function shouldEnableDebug(fullName, patterns) {
+    return patterns.some((pattern) => {
+        if (pattern === '*')
+            return true;
+        if (fullName === pattern)
+            return true;
+        if (pattern.endsWith(':*')) {
+            const patternPrefix = pattern.slice(0, -2);
+            return fullName.startsWith(patternPrefix + ':');
+        }
+        return false;
+    });
+}
+/**
+ * Настраивает логгер в соответствии с текущими паттернами отладки
+ * @param logger Логгер для настройки
+ * @param patterns Массив паттернов отладки
+ */
+function configureLogger(logger, patterns) {
+    const fullName = logger.getFullName();
+    const debugEnabled = shouldEnableDebug(fullName, patterns);
+    logger.debugEnabled = debugEnabled;
+    if (debugEnabled) {
+        logger.setLevel(previousLevels.get(logger.id) || log__default["default"].levels.TRACE);
+    }
+    else {
+        logger.setLevel(previousLevels.get(logger.id) || log__default["default"].levels.WARN);
+    }
+}
+/**
+ * Инициализирует паттерны отладки из environment
+ */
+function initializeDebugPatterns() {
+    const debugPattern = environment.getDebugValue() || '';
+    const patterns = debugPattern
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    // Создаем Set для отслеживания уже обработанных логгеров
+    const processedLoggers = new Set();
+    function processLogger(logger) {
+        if (processedLoggers.has(logger.id))
+            return;
+        processedLoggers.add(logger.id);
+        configureLogger(logger, patterns);
+        // Обрабатываем дочерние логгеры
+        logger.children.forEach(processLogger);
+    }
+    // Обрабатываем все существующие логгеры
+    loggerCache.forEach(processLogger);
+    // Обрабатываем все существующие логгеры
+    Array.from(loggerCache).forEach(([, logger]) => {
+        processLogger(logger);
+    });
+}
+/**
+ * Плагин иерархического логгера для loglevel
+ */
+const hierarchicalPlugin = {
+    apply(rootLogger) {
+        // Переопределяем метод getLogger корневого логгера
+        const originalGetLogger = rootLogger.getLogger.bind(rootLogger);
+        rootLogger.getLogger = (name) => {
+            return createHierarchicalLogger(originalGetLogger, name);
+        };
+        // Отслеживаем изменения в environment
+        environment.onDebugValueChange(() => {
+            initializeDebugPatterns();
+        });
+    },
+};
+
+const defaultOptions = {
+    format: (level, name, timestamp) => `[${timestamp.toISOString()}] [${level}] [${name}]`,
+};
+/**
+ * Плагин для добавления префикса к логам
+ * @param logger Инстанс логгера
+ * @param options Опции плагина
+ */
+function prefix(logger, options = {}) {
+    const mergedOptions = Object.assign(Object.assign({}, defaultOptions), options);
+    const originalFactory = logger.methodFactory;
+    logger.methodFactory = function (methodName, logLevel, loggerName) {
+        const rawMethod = originalFactory(methodName, logLevel, loggerName);
+        return function (...args) {
+            const level = methodName.toUpperCase();
+            const timestamp = new Date();
+            const prefix = mergedOptions.format(level, typeof loggerName === 'string' ? loggerName : '', timestamp);
+            if (Array.isArray(prefix)) {
+                rawMethod.apply(this, [...prefix, ...args]);
+            }
+            else {
+                rawMethod.apply(this, [prefix, ...args]);
+            }
+        };
+    };
+    return logger;
+}
+const prefixPlugin = {
+    apply(rootLogger, options = {}) {
+        prefix(rootLogger, options);
+    },
+};
+
+// Применяем плагины
+hierarchicalPlugin.apply(log__default["default"]);
+prefixPlugin.apply(log__default["default"], {
+    format: (level, name, timestamp) => {
+        return environment.formatter(level, name, timestamp);
+    },
+});
+// сброс левела чтобы игнорировать запись в сторадже в браузерной имплементации
+log__default["default"].resetLevel();
+// Пересоздаем методы логгера
+log__default["default"].rebuild();
+const extendedLog = Object.assign(log__default["default"], {});
+
+exports.hierarchicalPlugin = hierarchicalPlugin;
+exports.log = extendedLog;
+exports.prefixPlugin = prefixPlugin;