@mmutils/logger 0.0.0-stage → 0.1.1

package/dist/esm/plugins/graph.js

@@ -0,0 +1,572 @@
+import { formatHighResTime } from '@mmutils/time';
+import { joinedOutput } from '../outputs.js';
+import { createSanitizer, resolveOutputLimits, describeThrown, stringifyData, scaleArray, safeStringify, truncate, textWidth } from '../utils/text.js';
+import { paint, paintUnrenderable, headerTemplates, mergeStyleSheets, DEFAULT_TEXT_STYLES } from './shared.js';
+
+const SAFE_SANITIZER = createSanitizer('safe');
+/** The unit a formatted time ends with: `ms` in `2s 25ms`. */
+const LAST_UNIT = /(?:[hms]|[mµn]s)$/;
+/**
+ * Formats an axis label. A zero time label takes the smallest unit of the
+ * other label, so both show the same precision: `0` next to `2s 25ms`
+ * reads `0ms`.
+ *
+ * @param label Label to format.
+ * @param axis Axis settings.
+ * @param other The opposite label.
+ */
+const formatAxisLabel = (label, { unit, capTo = 2 }, other) => {
+    if (label === undefined)
+        return '';
+    if (typeof label === 'string')
+        return label;
+    if (unit === undefined)
+        return String(label);
+    if (label === 0 && typeof other === 'number' && other !== 0) {
+        const otherLabel = formatHighResTime(other, capTo, unit);
+        const otherUnit = LAST_UNIT.exec(otherLabel)?.[0];
+        return formatHighResTime(0, otherUnit ?? unit, unit);
+    }
+    return formatHighResTime(label, capTo, unit);
+};
+const DEFAULT_GRAPH_LIMITS = {
+    cols: 500,
+    rows: 50,
+    precision: 20,
+};
+/**
+ * Characters the frame adds to the bars: `│` on each side.
+ */
+const FRAME_WIDTH = 2;
+/**
+ * Size settings with their minimum values.
+ */
+const SIZE_SETTINGS = [
+    ['cols', 1],
+    ['rows', 1],
+    ['precision', 0],
+];
+/**
+ * `toFixed` accepts at most 100 digits.
+ */
+const MAX_PRECISION = 100;
+const isIntegerIn = (value, min, max) => Number.isInteger(value) &&
+    value >= min &&
+    value <= max;
+/**
+ * Validates the limits and the plugin's size settings, which are
+ * configuration: invalid values throw when the plugin is created.
+ */
+const validateLimits = (limits) => {
+    for (const [name, min] of SIZE_SETTINGS) {
+        const limit = limits[name];
+        const maxLimit = name === 'precision' ? MAX_PRECISION : Infinity;
+        if (!isIntegerIn(limit, min, maxLimit))
+            throw new RangeError(`graphPlugin: limits.${name} must be an integer ${maxLimit === Infinity ? `of at least ${String(min)}` : `from ${String(min)} to ${String(maxLimit)}`}, got ${String(limit)}.`);
+    }
+};
+const validateSizes = (defaults, limits) => {
+    for (const [name, min] of SIZE_SETTINGS)
+        if (!isIntegerIn(defaults[name], min, limits[name]))
+            throw new RangeError(`graphPlugin: ${name} must be an integer from ${String(min)} to ${String(limits[name])}, got ${String(defaults[name])}.`);
+};
+/**
+ * Bars of a plugin `width`, validated against `limits.cols` plus the frame.
+ *
+ * @returns `undefined` without `width`.
+ * @throws RangeError if `cols` is set too, or `width` is out of range.
+ */
+const colsOfWidth = ({ cols, width }, limits) => {
+    if (width === undefined)
+        return undefined;
+    if (cols !== undefined)
+        throw new RangeError('graphPlugin: set cols (bars) or width (terminal columns, frame included), not both.');
+    const max = limits.cols + FRAME_WIDTH;
+    if (!isIntegerIn(width, 1 + FRAME_WIDTH, max))
+        throw new RangeError(`graphPlugin: width must be an integer from ${String(1 + FRAME_WIDTH)} to ${String(max)}, got ${String(width)}.`);
+    return width - FRAME_WIDTH;
+};
+const describeSetting = (value) => typeof value === 'number' ? String(value) : safeStringify(value);
+/**
+ * Applies the `width` of a single graph: clamps it to the limits (values
+ * that are not finite numbers fall back to the plugin's width) and sets the
+ * bars. A per-graph `width` wins over a per-graph `cols`.
+ *
+ * @returns A note if the width was changed, e.g. `width 100000 → 502`.
+ */
+const limitWidth = (settings, width, defaults, limits) => {
+    const limited = typeof width === 'number' && Number.isFinite(width) ?
+        Math.min(limits.cols + FRAME_WIDTH, Math.max(1 + FRAME_WIDTH, Math.trunc(width)))
+        : defaults.cols + FRAME_WIDTH;
+    settings.cols = limited - FRAME_WIDTH;
+    return limited === width ? undefined : (`width ${describeSetting(width)} → ${String(limited)}`);
+};
+/**
+ * Clamps the size settings of a single graph to the limits. Values that are
+ * not finite numbers fall back to the plugin's settings.
+ *
+ * @returns Notes on the changed values, e.g. `cols 100000 → 500`.
+ */
+const limitSizes = (settings, defaults, limits) => {
+    const notes = [];
+    for (const [name, min] of SIZE_SETTINGS) {
+        // logged data is not type checked
+        const value = settings[name];
+        if (value === defaults[name])
+            continue;
+        if (value === undefined) {
+            settings[name] = defaults[name];
+            continue;
+        }
+        const limited = typeof value === 'number' && Number.isFinite(value) ?
+            Math.min(limits[name], Math.max(min, Math.trunc(value)))
+            : defaults[name];
+        if (limited === value)
+            continue;
+        settings[name] = limited;
+        notes.push(`${name} ${describeSetting(value)} → ${String(limited)}`);
+    }
+    return notes;
+};
+const isFiniteNumber = (value) => Number.isFinite(value);
+const isBaseline = (value) => value === 'min' || value === 'max' || Number.isFinite(value);
+/**
+ * The first range setting out of order, and the bound it passed: `min`
+ * above a numeric baseline or `max` below it; with `'min'`, `'max'` or the
+ * default baseline, `min` above `max`.
+ */
+const outOfOrder = ({ baseline, min, max, }) => {
+    if (typeof baseline === 'number') {
+        if (min !== undefined && min > baseline)
+            return ['min', baseline, 'baseline'];
+        if (max !== undefined && max < baseline)
+            return ['max', baseline, 'baseline'];
+    }
+    else if (min !== undefined && max !== undefined && min > max)
+        return ['min', max, 'max'];
+    return undefined;
+};
+/**
+ * Validates the plugin's range settings, which are configuration: `min` and
+ * `max` finite numbers, `baseline` a finite number, `'min'` or `'max'`, and
+ * `min ≤ baseline ≤ max` (`min ≤ max` without a numeric baseline).
+ *
+ * @throws RangeError for an invalid setting.
+ */
+const validateRange = (defaults) => {
+    const { baseline, min, max } = defaults;
+    if (baseline !== undefined && !isBaseline(baseline))
+        throw new RangeError(`graphPlugin: baseline must be a finite number, 'min' or 'max', got ${describeSetting(baseline)}.`);
+    for (const [name, value] of [
+        ['min', min],
+        ['max', max],
+    ])
+        if (value !== undefined && !isFiniteNumber(value))
+            throw new RangeError(`graphPlugin: ${name} must be a finite number, got ${describeSetting(value)}.`);
+    const wrong = outOfOrder(defaults);
+    if (wrong) {
+        const [name, bound, boundName] = wrong;
+        throw new RangeError(`graphPlugin: ${name} must not be ${name === 'min' ? 'higher' : 'lower'} than ${boundName} (${String(bound)}), got ${String(defaults[name])}.`);
+    }
+};
+/**
+ * A range setting of a single graph, or the plugin's if it is invalid.
+ *
+ * @param notes Receives a note if an invalid value was replaced, e.g.
+ * `baseline NaN → 0` or `max "x" ignored` (the plugin has none).
+ */
+const rangeSetting = (name, value, isValid, fallback, notes) => {
+    if (isValid(value))
+        return value;
+    if (value !== undefined)
+        notes.push(`${name} ${describeSetting(value)} ${fallback === undefined ? 'ignored' : `→ ${String(fallback)}`}`);
+    return fallback;
+};
+/**
+ * Checks the range settings of a single graph: invalid values fall back to
+ * the plugin's, then settings out of order are moved to the bound they
+ * passed (`min 30 → 20` for a baseline of 20), also when the plugin set
+ * them.
+ *
+ * @param notes Receives notes on the changed values.
+ */
+const limitRange = (settings, defaults, notes) => {
+    // logged data is not type checked
+    const { baseline, min, max } = settings;
+    settings.baseline = rangeSetting('baseline', baseline, isBaseline, defaults.baseline, notes);
+    settings.min = rangeSetting('min', min, isFiniteNumber, defaults.min, notes);
+    settings.max = rangeSetting('max', max, isFiniteNumber, defaults.max, notes);
+    // at most twice: `min` and `max` on the wrong side of the baseline
+    for (let wrong = outOfOrder(settings); wrong; wrong = outOfOrder(settings)) {
+        const [name, bound] = wrong;
+        notes.push(`${name} ${String(settings[name])} → ${String(bound)}`);
+        settings[name] = bound;
+    }
+};
+/**
+ * Text of a per-log label setting, which comes from logged data: strings are
+ * cut to `stringLength` like message text, `null` and `undefined` are empty,
+ * other values are described (`5`, `{"a":1}`) instead of breaking the row
+ * layout.
+ */
+const textSetting = (value, limits) => typeof value === 'string' ? truncate(value, limits.stringLength)
+    : value === null || value === undefined ? ''
+        : safeStringify(value, limits);
+const axisLabel = (value, limits) => value === undefined || typeof value === 'number' ?
+    value
+    : textSetting(value, limits);
+/**
+ * Cuts the title, unit and axis labels of a single graph to the output
+ * limits. A length check for ordinary labels.
+ */
+const limitLabels = (settings, limits) => {
+    settings.title = textSetting(settings.title, limits);
+    settings.unit = textSetting(settings.unit, limits);
+    const { axis } = settings;
+    if (typeof axis !== 'object' || axis === null)
+        return;
+    const start = axisLabel(axis.start, limits);
+    const end = axisLabel(axis.end, limits);
+    settings.axis = {
+        ...axis,
+        ...(start !== undefined && { start }),
+        ...(end !== undefined && { end }),
+    };
+};
+/**
+ * Key of graph data whose settings could not be read; the value is what was
+ * thrown. A symbol: data can't set it by accident.
+ */
+const SETTINGS_ERROR = Symbol('settingsError');
+const paintNote = (note, styles, { label }) => paint(styles['textDim'] ?? '', label(note), styles['reset'] ?? '');
+/**
+ * Eight vertical steps of a single row, from empty to full.
+ */
+const BAR_SYMBOLS = ' ▁▂▃▄▅▆▇█';
+const STEPS = BAR_SYMBOLS.length - 1;
+/**
+ * Eighths of a row filled by `fill` rows: `0` for empty, negative or `NaN`.
+ */
+const eighthsOf = (fill) => fill >= 1 ? STEPS
+    : fill > 0 ? Math.round(fill * STEPS)
+        : 0;
+/**
+ * A row filled from the top by `eighths`, for bars growing down: the
+ * nearest of the upper blocks every terminal draws, `▔` (an eighth) and `▀`
+ * (a half). The other upper eighths (🮂 🮃 🮄 🮅 🮆, Symbols for Legacy
+ * Computing) are missing from many fonts and renderers, and a lower block
+ * in inverse video paints the cell background; so tips below the baseline
+ * are coarser than above it.
+ */
+const upperBlock = (eighths) => eighths === 0 ? ' '
+    : eighths <= 2 ? '▔'
+        : eighths <= 6 ? '▀'
+            : '█';
+const isNumberArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'number');
+const isGraphDataWithSettings = (value) => typeof value === 'object' &&
+    value !== null &&
+    'values' in value &&
+    isNumberArray(value.values);
+/**
+ * Converts values to rows of bar symbols growing up from `min`, top row
+ * first.
+ *
+ * @param max Top of the graph: higher values draw full bars.
+ * @param min Bottom of the graph. Default: `0`.
+ */
+const valuesToBars = (values, rows, max, min = 0) => {
+    const lines = [];
+    const rowValue = (max - min) / rows;
+    for (let row = rows - 1; row >= 0; row--) {
+        let line = '';
+        for (const value of values)
+            line += BAR_SYMBOLS.charAt(eighthsOf(rowValue > 0 ? (value - min) / rowValue - row : 0));
+        lines.push(line);
+    }
+    return lines;
+};
+/**
+ * Value per row of a graph with `below` of its `rows` under the baseline:
+ * the side that needs more per row sets the scale of both.
+ */
+const rowValueOf = (rows, top, bottom, baseline, below) => Math.max(below < rows ? (top - baseline) / (rows - below) : 0, below > 0 ? (baseline - bottom) / below : 0);
+/**
+ * Converts values to rows of bars growing from `baseline`: up to values
+ * above it and down to values below it, top row first.
+ *
+ * The baseline is placed in proportion to `bottom`…`top`, at the row
+ * boundary next to that position that gives the bars more room. Both sides
+ * share the scale of the side that needs more per row, so nothing is cut
+ * and equal distances draw equal bars. A side gets at least one row (if
+ * `rows` allows) when a bar to its end draws at least an eighth of that
+ * row, and none otherwise: a value of -0.001 next to 100 sits on the
+ * baseline instead of taking a row. Bars growing down end in upper blocks
+ * (`upperBlock`).
+ */
+const barsFromBaseline = (values, rows, top, bottom, baseline) => {
+    const span = top - bottom;
+    // nothing to draw: no range, or one that can't be scaled
+    if (!(span > 0 && Number.isFinite(span)))
+        return Array.from({ length: rows }, () => ' '.repeat(values.length));
+    const proportional = ((baseline - bottom) / span) * rows;
+    const least = (bottom < baseline &&
+        eighthsOf((baseline - bottom) / rowValueOf(rows, top, bottom, baseline, 1)) > 0) ?
+        1
+        : 0;
+    const most = (top > baseline &&
+        eighthsOf((top - baseline) / rowValueOf(rows, top, bottom, baseline, rows - 1)) > 0) ?
+        rows - 1
+        : rows;
+    let rowsBelow;
+    if (least > most)
+        // one row for two sides: the larger side gets it
+        rowsBelow = Math.min(rows, Math.max(0, Math.round(proportional)));
+    else {
+        // the row boundary below or above the exact position, whichever gives
+        // the bars more room (a smaller value per row)
+        const lower = Math.min(most, Math.max(least, Math.floor(proportional)));
+        const upper = Math.min(most, Math.max(least, Math.ceil(proportional)));
+        rowsBelow =
+            (rowValueOf(rows, top, bottom, baseline, upper) <
+                rowValueOf(rows, top, bottom, baseline, lower)) ?
+                upper
+                : lower;
+    }
+    const rowsAbove = rows - rowsBelow;
+    const rowValue = rowValueOf(rows, top, bottom, baseline, rowsBelow);
+    const lines = [];
+    for (let row = rowsAbove - 1; row >= 0; row--) {
+        let line = '';
+        for (const value of values)
+            line += BAR_SYMBOLS.charAt(eighthsOf((value - baseline) / rowValue - row));
+        lines.push(line);
+    }
+    for (let row = 0; row < rowsBelow; row++) {
+        let line = '';
+        for (const value of values)
+            line += upperBlock(eighthsOf((baseline - value) / rowValue - row));
+        lines.push(line);
+    }
+    return lines;
+};
+/**
+ * `toFixed` without a sign on zero: `-0.004` with precision 2 is `0.00`,
+ * not `-0.00`.
+ */
+const fixed = (number, precision) => {
+    const text = number.toFixed(precision);
+    return text.startsWith('-') && Number(text) === 0 ? text.slice(1) : text;
+};
+const segmentsLength = (segments) => {
+    let length = 0;
+    for (const [text] of segments)
+        length += textWidth(text);
+    return length;
+};
+const renderSegments = (segments, reset) => {
+    let text = '';
+    for (const [segment, style] of segments)
+        text += paint(style, segment, reset);
+    return text;
+};
+/**
+ * Renders a framed graph with an optional axis row and value statistics:
+ * title, bars, frame and values in `textHighlight`, legend labels in
+ * `textNormal`, axis labels and units in `textDim`. When the baseline splits
+ * the graph, a `baseline` row follows the average.
+ *
+ * Average, min, max and the default top and bottom are computed from the
+ * original values, so peaks blunted by scaling are still reported. Bars are
+ * scaled to `cols` with `settings.aggregate`. The top value is shown on the
+ * title row, the bottom value on the average row.
+ *
+ * Title, unit and axis labels are sanitized as single line `label`s and
+ * measured in terminal columns with `textWidth` (wide characters take two,
+ * as in columns). Default: `'safe'` (see `Sanitize`).
+ */
+const renderGraph = (values, settings, { textNormal = '', textDim = '', textHighlight = '', reset = '', } = {}, { label } = SAFE_SANITIZER) => {
+    const { cols, rows, precision, min: fixedMin, max: fixedMax } = settings;
+    const title = label(settings.title);
+    const unit = label(settings.unit);
+    // statistics, top and bottom describe the data, not the scaled bars
+    let min = Infinity;
+    let max = -Infinity;
+    let sum = 0;
+    for (const value of values) {
+        if (value < min)
+            min = value;
+        if (value > max)
+            max = value;
+        sum += value;
+    }
+    if (!values.length)
+        min = max = 0;
+    const average = values.length ? sum / values.length : 0;
+    // the default baseline, 0, moves inside a fixed range: `min: 480` alone
+    // starts the bars at 480
+    const setting = settings.baseline ??
+        Math.min(Math.max(0, fixedMin ?? -Infinity), fixedMax ?? Infinity);
+    let top;
+    let bottom;
+    let baseline;
+    if (typeof setting === 'number') {
+        // the range holds a numeric baseline, also when `min` or `max` leave it
+        // out (the plugin rejects or moves those); without values it is only
+        // the baseline, so the zeros of the scaled bars draw nothing
+        baseline = setting;
+        top = Math.max(fixedMax ?? (values.length ? max : setting), setting);
+        bottom = Math.min(fixedMin ?? (values.length ? min : setting), setting);
+    }
+    else {
+        bottom = fixedMin ?? (values.length ? min : (fixedMax ?? 0));
+        top = Math.max(fixedMax ?? (values.length ? max : bottom), bottom);
+        baseline = setting === 'min' ? bottom : top;
+    }
+    const scaled = scaleArray(values, cols, settings.aggregate);
+    const width = cols + FRAME_WIDTH;
+    const value = (number) => [
+        [fixed(number, precision), textHighlight],
+        [unit ? ` ${unit}` : '', textDim],
+    ];
+    const legend = (label, number) => [
+        [`${label}: `, textNormal],
+        ...value(number),
+    ];
+    // left and right justified, in terminal columns (wide characters 2); too long rows
+    // break before the right side, unless there is no right side
+    const row = (left, right = []) => {
+        const rightLength = segmentsLength(right);
+        const gap = width - segmentsLength(left) - rightLength;
+        const separator = gap >= 0 ? ' '.repeat(gap)
+            : rightLength ? '\n'
+                : '';
+        return `${renderSegments(left, reset)}${separator}${renderSegments(right, reset)}`;
+    };
+    const lines = [row([[title, textHighlight]], value(top))];
+    // bars growing up from the bottom: the plain path, as before baselines
+    const bars = baseline > bottom ?
+        barsFromBaseline(scaled, rows, top, bottom, baseline)
+        : valuesToBars(scaled, rows, top, bottom);
+    for (const line of bars)
+        lines.push(paint(textHighlight, `│${line}│`, reset));
+    const { axis } = settings;
+    if (axis && (axis.start !== undefined || axis.end !== undefined))
+        lines.push(row([[label(formatAxisLabel(axis.start, axis, axis.end)), textDim]], [[label(formatAxisLabel(axis.end, axis, axis.start)), textDim]]));
+    lines.push(row(settings.showAverage ? legend('average', average) : [], value(bottom)));
+    // a baseline at the top or the bottom is already the value shown there
+    if (bottom < baseline && baseline < top)
+        lines.push(row(legend('baseline', baseline)));
+    if (settings.showMin)
+        lines.push(row(legend('min', min)));
+    if (settings.showMax)
+        lines.push(row(legend('max', max)));
+    return lines.join('\n');
+};
+/**
+ * Renders logs of a given kind as bar graphs. Adds a graph method per log
+ * type to the logger: `infoGraph`, `errorGraph`, etc.
+ *
+ * ```
+ * 2026/03/16 15:35:00 [i]   info
+ * CPU                      82.00 %
+ * │▁▁▁▂▃▃▃▄▄▄▆▆▆▇██▇▆▆▆▄▄▄▃▃▃▂▁▁▁│
+ * average: 41.33 %          0.00 %
+ * ```
+ */
+const graphPlugin = (options = {}) => {
+    const kind = options.kind ?? 'graph';
+    const sanitizer = createSanitizer(options.sanitize);
+    const limits = {
+        cols: options.limits?.cols ?? DEFAULT_GRAPH_LIMITS.cols,
+        rows: options.limits?.rows ?? DEFAULT_GRAPH_LIMITS.rows,
+        precision: options.limits?.precision ?? DEFAULT_GRAPH_LIMITS.precision,
+    };
+    validateLimits(limits);
+    const defaults = {
+        cols: colsOfWidth(options, limits) ?? options.cols ?? 30,
+        rows: options.rows ?? 3,
+        title: options.title ?? '',
+        unit: options.unit ?? '',
+        precision: options.precision ?? 2,
+        showAverage: options.showAverage ?? true,
+        showMin: options.showMin ?? true,
+        showMax: options.showMax ?? true,
+        aggregate: options.aggregate ?? 'average',
+        // no baseline: 0, moved inside `min` and `max` (see `renderGraph`)
+        ...(options.baseline !== undefined && { baseline: options.baseline }),
+        ...(options.max !== undefined && { max: options.max }),
+        ...(options.min !== undefined && { min: options.min }),
+        ...(options.axis !== undefined && { axis: options.axis }),
+    };
+    const outputLimits = resolveOutputLimits(options.limits, 'graphPlugin');
+    validateSizes(defaults, limits);
+    validateRange(defaults);
+    return {
+        name: `graph:${kind}`,
+        styles: mergeStyleSheets(DEFAULT_TEXT_STYLES, options.styles),
+        templateMaps: {
+            [kind]: {
+                ...headerTemplates(options),
+                // never throws: unreadable data or invalid settings give a placeholder
+                data: (value, { styles }) => {
+                    try {
+                        if (isNumberArray(value))
+                            return `\n${renderGraph(value, defaults, styles, sanitizer)}`;
+                        if (isGraphDataWithSettings(value)) {
+                            const { values, width, ...overrides } = value;
+                            const settings = { ...defaults, ...overrides };
+                            const widthNote = width === undefined ? undefined : (limitWidth(settings, width, defaults, limits));
+                            const notes = limitSizes(settings, defaults, limits);
+                            if (widthNote !== undefined)
+                                notes.unshift(widthNote);
+                            limitRange(settings, defaults, notes);
+                            limitLabels(settings, outputLimits);
+                            const graph = renderGraph(values, settings, styles, sanitizer);
+                            const unreadable = value[SETTINGS_ERROR];
+                            if (!notes.length && unreadable === undefined)
+                                return `\n${graph}`;
+                            let text = `\n${graph}`;
+                            if (notes.length)
+                                text += `\n${paintNote(`(limited: ${notes.join(', ')})`, styles, sanitizer)}`;
+                            if (unreadable !== undefined)
+                                text += `\n${paintNote(`(settings unreadable: ${describeThrown(unreadable)})`, styles, sanitizer)}`;
+                            return text;
+                        }
+                        return paint(styles['textNormal'] ?? '', stringifyData(value, sanitizer, outputLimits), styles['reset'] ?? '');
+                    }
+                    catch (thrown) {
+                        return paintUnrenderable(thrown, styles, sanitizer);
+                    }
+                },
+            },
+        },
+        outputs: { [kind]: joinedOutput(options.write) },
+        methods: (logger) => {
+            const graph = (type) => (values, settings) => {
+                let data = values;
+                // settings are data too: unreadable ones (throwing getters,
+                // revoked proxies) give a note, never an exception
+                if (settings)
+                    try {
+                        data = { ...settings, values };
+                    }
+                    catch (thrown) {
+                        data = { values, [SETTINGS_ERROR]: thrown };
+                    }
+                logger.log(type, data, kind);
+            };
+            return {
+                fatalGraph: graph('fatal'),
+                errorGraph: graph('error'),
+                warningGraph: graph('warning'),
+                infoGraph: graph('info'),
+                debugGraph: graph('debug'),
+                traceGraph: graph('trace'),
+                verboseGraph: graph('verbose'),
+            };
+        },
+    };
+};
+
+export { DEFAULT_GRAPH_LIMITS, formatAxisLabel, graphPlugin, renderGraph, valuesToBars };
+//# sourceMappingURL=graph.js.map