@foxford/logger 1.0.2 → 1.2.0

package/node.js

@@ -1,426 +1,324 @@
-'use strict';
-
-var log = require('loglevel');
-var chalk = require('chalk');
-
-/**
- * Генерирует hex-код цвета на основе строки, избегая оттенков красного
- * @param {string} str - Строка, для которой нужно сгенерировать цвет
- * @returns {string} - Hex-код цвета
- */
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const log = require("loglevel");
+const chalk = require("chalk");
 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;
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash) % 300;
+  const saturation = 60 + Math.abs(hash) % 40;
+  const lightness = 30 + Math.abs(hash) % 40;
+  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 ?? 0;
+  const gValue = g ?? 0;
+  const bValue = b ?? 0;
+  const color = `#${(rValue << 16 | gValue << 8 | bValue).toString(16).padStart(6, "0")}`;
+  return color;
 }
-
-/**
- * Кеш для хранения сгенерированных цветов
- * могут быть заранее предустановлены по имени логгера
- **/
 const colorCache = {};
-/** Цвета для различных уровней логирования */
 const levelColors = {
-    TRACE: chalk.gray,
-    LOG: chalk.cyan,
-    DEBUG: chalk.cyan,
-    INFO: chalk.green,
-    WARN: chalk.yellow,
-    ERROR: chalk.red,
+  DEBUG: chalk.cyan,
+  ERROR: chalk.red,
+  INFO: chalk.green,
+  LOG: chalk.cyan,
+  TRACE: chalk.gray,
+  WARN: chalk.yellow
 };
-// Хранилище для значений debug в памяти
-const debugStorage = new Set();
-/**
- * Генерирует hex-код цвета на основе строки, избегая оттенков красного
- * @param {string} str - Строка, для которой нужно сгенерировать цвет
- * @returns {string} - Hex-код цвета
- */
+const debugStorage = /* @__PURE__ */ new Set();
 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;
+  if (str in colorCache) {
+    return colorCache[str] ?? "inherit";
+  }
+  const color = generateHexByString(str);
+  colorCache[str] = color;
+  return color;
 }
-/**
- * Форматирует сообщение лога
- * @param {string} level - Уровень лога
- * @param {string} name - Имя логгера
- * @param {Date} timestamp - Временная метка
- * @returns {string} Отформатированное сообщение
- */
 function formatter(level, name, timestamp) {
-    const levelColor = levelColors[level.toUpperCase()] || chalk.gray;
-    let date;
-    let nameHex;
-    let loggerName;
-    let loggerLevel;
-    switch (name) {
-        // предустановленнный цветовой шаблон по имени логгера
-        case 'critical':
-            date = chalk.red(`[${timestamp.toISOString()}]`);
-            loggerName = chalk.red(`[${name}]`);
-            loggerLevel = chalk.red(`[${level}]`);
-            break;
-        default:
-            date = chalk.gray(`[${timestamp.toISOString()}]`);
-            nameHex = stringToColorCode(name);
-            loggerName = chalk.hex(nameHex)(`[${name}]`);
-            loggerLevel = levelColor(`[${level}]`);
-            break;
-    }
-    return `${date} ${loggerLevel} ${loggerName} ${chalk.cyan('•')}`;
+  const levelColor = levelColors[level.toUpperCase()] || chalk.gray;
+  let date;
+  let nameHex;
+  let loggerName;
+  let loggerLevel;
+  switch (name) {
+    // предустановленнный цветовой шаблон по имени логгера
+    case "critical":
+      date = chalk.red(`[${timestamp.toISOString()}]`);
+      loggerName = chalk.red(`[${name}]`);
+      loggerLevel = chalk.red(`[${level}]`);
+      break;
+    default:
+      date = chalk.gray(`[${timestamp.toISOString()}]`);
+      nameHex = stringToColorCode(name);
+      loggerName = chalk.hex(nameHex)(`[${name}]`);
+      loggerLevel = levelColor(`[${level}]`);
+      break;
+  }
+  return `${date} ${loggerLevel} ${loggerName} ${chalk.cyan("•")}`;
 }
-/**
- * Получает текущее значение debug
- * @returns {string | undefined} Строка с debug значениями или undefined, если значений нет
- */
 function getDebugValue() {
-    const value = Array.from(debugStorage).join(',');
-    return value.length ? value : undefined;
+  const value = Array.from(debugStorage).join(",");
+  return value.length ? value : void 0;
 }
-/**
- * Устанавливает значение debug
- * @param {string | null} value - Новое значение debug
- */
 function setDebugValue(value) {
-    if (value === null || value === undefined) {
-        debugStorage.clear();
-    }
-    else {
-        debugStorage.add(value.trim());
-    }
+  if (value === null || value === void 0) {
+    debugStorage.clear();
+  } else {
+    debugStorage.add(value.trim());
+  }
 }
-/**
- * Функция для подписки на изменения значения debug
- * @param {function} callback - Функция, вызываемая при изменении значения debug
- * @returns {function} Функция для отписки от изменений
- */
 function onDebugValueChange(_callback) {
-    // TODO: Implement debug value change listener
-    return () => { };
+  return () => {
+  };
 }
 if (process.env.DEBUG) {
-    setDebugValue(process.env.DEBUG);
+  setDebugValue(process.env.DEBUG);
 }
 const environment = {
-    getDebugValue,
-    setDebugValue,
-    formatter,
-    onDebugValueChange,
+  formatter,
+  getDebugValue,
+  onDebugValueChange,
+  setDebugValue
 };
-
-/**
- * Генерирует 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));
+  return "10000000-1000-4000-8000-100000000000".replace(
+    /[018]/g,
+    (char) => (
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      (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();
+const loggerCache = /* @__PURE__ */ new Map();
+const previousLevels = /* @__PURE__ */ 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.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.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.levels[method.toUpperCase()]) !== null && _a !== void 0 ? _a : 0;
-            const currentLevel = baseLogger.getLevel();
-            if (debugEnabled || messageLevel >= currentLevel) {
-                return originalMethod.apply(baseLogger, args);
+  const loggerId = generateUUIDv4();
+  const baseLogger = originalGetLogger(fullName);
+  const name = parent ? fullName.slice(parent.getFullName().length + 1) : fullName;
+  const hierarchicalLogger = {
+    ...baseLogger,
+    children: /* @__PURE__ */ new Set(),
+    debugEnabled: false,
+    getDebugPattern() {
+      return environment.getDebugValue() ?? null;
+    },
+    // Добавим вспомогательный метод для получения полного имени логгера
+    getFullName() {
+      if (!this.parent) {
+        return this.name;
+      }
+      const parentFullName = this.parent.getFullName();
+      return parentFullName ? `${parentFullName}:${this.name}` : this.name;
+    },
+    getLogger(name2) {
+      for (const child of this.children) {
+        if (child.name === name2) {
+          return child;
+        }
+      }
+      const childLogger = createHierarchicalLogger(originalGetLogger, `${fullName}:${name2}`, this);
+      this.children.add(childLogger);
+      return childLogger;
+    },
+    id: loggerId,
+    isDebugEnabled() {
+      return this.debugEnabled;
+    },
+    name,
+    parent: parent ?? null,
+    setDebug(enabled) {
+      this.debugEnabled = enabled;
+      const parentLevel = this.parent ? this.parent.getLevel() : void 0;
+      const currentPatterns = (environment.getDebugValue() || "").split(",").filter(Boolean);
+      const fullName2 = this.getFullName();
+      if (enabled) {
+        if (!previousLevels.has(this.id)) {
+          previousLevels.set(this.id, baseLogger.getLevel());
+        }
+        baseLogger.setLevel(log.levels.TRACE, false);
+        if (!currentPatterns.some((pattern) => fullName2 === pattern || `${fullName2}:*` === pattern)) {
+          const childrenPatterns = currentPatterns.filter((pattern) => pattern.startsWith(`${fullName2}:`));
+          childrenPatterns.forEach((pattern) => {
+            const index = currentPatterns.indexOf(pattern);
+            if (index !== -1) {
+              currentPatterns.splice(index, 1);
             }
-        };
-    });
-    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);
+          });
+          currentPatterns.push(fullName2);
+        }
+      } else {
+        let newLevel;
+        if (parentLevel !== void 0) {
+          newLevel = parentLevel;
+        } else {
+          newLevel = previousLevels.get(this.id) || log.levels.WARN;
+        }
+        baseLogger.setLevel(newLevel, false);
+        previousLevels.delete(this.id);
+        const index = currentPatterns.findIndex((pattern) => pattern === fullName2 || pattern === `${fullName2}:*`);
+        if (index !== -1) {
+          currentPatterns.splice(index, 1);
+        }
+      }
+      const optimizedPatterns = optimizePatterns(currentPatterns);
+      environment.setDebugValue(optimizedPatterns.join(",") || null);
+    },
+    setLevel(level) {
+      baseLogger.setLevel(level, false);
+      this.children.forEach((child) => child.setLevel(level, false));
+      if (this.isDebugEnabled()) {
+        previousLevels.set(loggerId, level);
+      }
     }
-    return hierarchicalLogger;
+  };
+  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) {
+      const debugEnabled = this.isDebugEnabled();
+      const messageLevel = log.levels[method.toUpperCase()] ?? 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);
-        }
+  const optimized = /* @__PURE__ */ 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;
+      }
     }
-    return Array.from(optimized);
+    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;
-    });
+  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.levels.TRACE);
-    }
-    else {
-        logger.setLevel(previousLevels.get(logger.id) || log.levels.WARN);
-    }
+  const fullName = logger.getFullName();
+  const debugEnabled = shouldEnableDebug(fullName, patterns);
+  logger.debugEnabled = debugEnabled;
+  if (debugEnabled) {
+    logger.setLevel(previousLevels.get(logger.id) || log.levels.TRACE);
+  } else {
+    logger.setLevel(previousLevels.get(logger.id) || log.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);
-    });
+  const debugPattern = environment.getDebugValue() || "";
+  const patterns = debugPattern.split(",").map((p) => p.trim()).filter(Boolean);
+  const processedLoggers = /* @__PURE__ */ 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);
-        };
-    },
+  apply(rootLogger) {
+    const originalGetLogger = rootLogger.getLogger.bind(rootLogger);
+    const rootChildren = /* @__PURE__ */ new Map();
+    rootLogger.getLogger = (name) => {
+      let logger = rootChildren.get(name);
+      if (!logger) {
+        logger = createHierarchicalLogger(originalGetLogger, name);
+        rootChildren.set(name, logger);
+      }
+      return logger;
+    };
+  }
 };
-
 const defaultOptions = {
-    format: (level, name, timestamp) => `[${timestamp.toISOString()}] [${level}] [${name}]`,
+  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]);
-            }
-        };
+  const mergedOptions = { ...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 = /* @__PURE__ */ new Date();
+      const prefix2 = mergedOptions.format(level, typeof loggerName === "string" ? loggerName : "", timestamp);
+      if (Array.isArray(prefix2)) {
+        rawMethod.apply(this, [...prefix2, ...args]);
+      } else {
+        rawMethod.apply(this, [prefix2, ...args]);
+      }
     };
-    return logger;
+  };
+  return logger;
 }
 const prefixPlugin = {
-    apply(rootLogger, options = {}) {
-        prefix(rootLogger, options);
-    },
+  apply(rootLogger, options = {}) {
+    prefix(rootLogger, options);
+  }
 };
-
-// Применяем плагины
 hierarchicalPlugin.apply(log);
 prefixPlugin.apply(log, {
-    format: (level, name, timestamp) => {
-        return environment.formatter(level, name, timestamp);
-    },
+  format: (level, name, timestamp) => {
+    return environment.formatter(level, name, timestamp);
+  }
 });
-// сброс левела чтобы игнорировать запись в сторадже в браузерной имплементации
 log.resetLevel();
-// Пересоздаем методы логгера
 log.rebuild();
 const extendedLog = Object.assign(log, {});
-
 exports.hierarchicalPlugin = hierarchicalPlugin;
 exports.log = extendedLog;
 exports.prefixPlugin = prefixPlugin;