@neodx/log/_internal/create-logger-factory-LGNVkcG-.cjs

A lightweight universal logging framework

'use strict';

var readArguments = require('./read-arguments-BBlq0hOP.cjs');

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: readArguments$1 }) {
  function createLogger(userParams) {
    const params = {
      ...defaultParams,
      ...userParams
    };
    const { meta, target, level: rootLevel, name = '', levels } = params;
    const transform = readArguments.toArray(params.transform);
    const targets = readArguments
      .toArray(target)
      .filter(readArguments.isTruthy)
      .map(target =>
        readArguments.isTypeOfFunction(target)
          ? {
              target
            }
          : target
      )
      .map(({ target, level }) => ({
        level: level && getOriginalLevelName(level, levels),
        target: readArguments.toArray(target).filter(readArguments.isTruthy)
      }))
      .filter(it => !readArguments.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$1(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: readArguments.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(
      readArguments.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 = readArguments.is(LOGGER_SILENT_LEVEL);
const getOriginalLevelName = (level, levels) => {
  const value = levels[level];
  return readArguments.isTypeOfString(value) ? getOriginalLevelName(value, levels) : level;
};

exports.DEFAULT_LOGGER_LEVELS = DEFAULT_LOGGER_LEVELS;
exports.DEFAULT_LOGGER_PARAMS = DEFAULT_LOGGER_PARAMS;
exports.LOGGER_SILENT_LEVEL = LOGGER_SILENT_LEVEL;
exports.createLoggerFactory = createLoggerFactory;
//# sourceMappingURL=create-logger-factory-LGNVkcG-.cjs.map