@neodx/log/_internal/create-logger-factory-DktgHJZq.mjs

A lightweight universal logging framework

import {
  t as toArray,
  b as isTruthy,
  d as isTypeOfFunction,
  e as isEmpty,
  k as keys,
  f as is,
  g as isTypeOfString
} from './read-arguments-BklHPmep.mjs';

const LOGGER_SILENT_LEVEL = 'silent';
const DEFAULT_LOGGER_LEVELS = {
  error: 10,
  warn: 20,
  info: 30,
  done: 40,
  debug: 50,
  success: 'done',
  verbose: 'debug',
  [LOGGER_SILENT_LEVEL]: Infinity
};
const DEFAULT_LOGGER_PARAMS = {
  levels: DEFAULT_LOGGER_LEVELS,
  level: 'done',
  name: '',
  transform: [],
  target: [],
  meta: {}
};

function createLoggerFactory({ defaultParams, formatMessage, readArguments }) {
  function createLogger(userParams) {
    const params = {
      ...defaultParams,
      ...userParams
    };
    const { meta, target, level: rootLevel, name = '', levels } = params;
    const transform = toArray(params.transform);
    const targets = toArray(target)
      .filter(isTruthy)
      .map(target =>
        isTypeOfFunction(target)
          ? {
              target
            }
          : target
      )
      .map(({ target, level }) => ({
        level: level && getOriginalLevelName(level, levels),
        target: toArray(target).filter(isTruthy)
      }))
      .filter(it => !isEmpty(it.target) && !isSilent(it.level));
    const log = (levelOrAlias, ...args) => {
      const level = getOriginalLevelName(levelOrAlias, levels);
      if (isSilent(rootLevel) || (rootLevel && levels[level] > levels[rootLevel])) return;
      const [[unknownMsgTemplate = '', ...msgArgs], additionalFields, error] = readArguments(args);
      const msgTemplate = String(unknownMsgTemplate);
      const chunk = transform.reduce((chunk, transformer) => transformer(chunk), {
        name,
        level,
        error,
        meta: {
          ...meta,
          ...additionalFields
        },
        date: new Date(),
        msgArgs,
        msgTemplate,
        msg: isEmpty(msgArgs) ? msgTemplate : formatMessage(msgTemplate, msgArgs),
        __: {
          originalLevel: levelOrAlias,
          levels: levels
        }
      });
      for (const handle of targets) {
        if (handle.level && levels[handle.level] > levels[level]) continue;
        handle.target.forEach(fn => fn(chunk));
      }
    };
    const methods = Object.fromEntries(keys(levels).map(level => [level, log.bind(null, level)]));
    return {
      ...methods,
      get meta() {
        return {
          ...params.meta
        };
      },
      fork: params =>
        createLogger({
          ...userParams,
          ...params
        }),
      child: (childName, params) =>
        createLogger({
          ...userParams,
          ...params,
          name: name ? `${name}:${childName}` : childName
        })
    };
  }
  return createLogger;
}
const isSilent = is(LOGGER_SILENT_LEVEL);
const getOriginalLevelName = (level, levels) => {
  const value = levels[level];
  return isTypeOfString(value) ? getOriginalLevelName(value, levels) : level;
};

export {
  DEFAULT_LOGGER_PARAMS as D,
  LOGGER_SILENT_LEVEL as L,
  DEFAULT_LOGGER_LEVELS as a,
  createLoggerFactory as c
};
//# sourceMappingURL=create-logger-factory-DktgHJZq.mjs.map