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

A lightweight universal logging framework

import { t as e, b as t, d as r, e as a, k as l, f as n } from './read-arguments-CPC3VkQ4.mjs';
let s = 'silent',
  o = {
    error: 10,
    warn: 20,
    info: 30,
    done: 40,
    debug: 50,
    success: 'done',
    verbose: 'debug',
    [s]: 1 / 0
  },
  m = { levels: o, level: 'done', name: '', transform: [], target: [], meta: {} };
function f({ defaultParams: n, formatMessage: s, readArguments: o }) {
  return function m(f) {
    let u = { ...n, ...f },
      { meta: L, target: E, level: c, name: d = '', levels: v } = u,
      _ = e(u.transform),
      b = e(E)
        .filter(t)
        .map(e => (r(e) ? { target: e } : e))
        .map(({ target: r, level: a }) => ({ level: a && g(a, v), target: e(r).filter(t) }))
        .filter(e => !a(e.target) && !i(e.level)),
      G = (e, ...t) => {
        let r = g(e, v);
        if (i(c) || (c && v[r] > v[c])) return;
        let [[l = '', ...n], m, f] = o(t),
          u = String(l),
          E = _.reduce((e, t) => t(e), {
            name: d,
            level: r,
            error: f,
            meta: { ...L, ...m },
            date: new Date(),
            msgArgs: n,
            msgTemplate: u,
            msg: a(n) ? u : s(u, n),
            __: { originalLevel: e, levels: v }
          });
        for (let e of b) (e.level && v[e.level] > v[r]) || e.target.forEach(e => e(E));
      };
    return {
      ...Object.fromEntries(l(v).map(e => [e, G.bind(null, e)])),
      get meta() {
        return { ...u.meta };
      },
      fork: e => m({ ...f, ...e }),
      child: (e, t) => m({ ...f, ...t, name: d ? `${d}:${e}` : e })
    };
  };
}
let i = e => e === s,
  g = (e, t) => {
    let r = t[e];
    return n(r) ? g(r, t) : e;
  };
export { m as D, s as L, o as a, f as c };
//# sourceMappingURL=create-logger-factory-BmydF_vP.mjs.map