simple-ascii-chart-cli 1.0.0

package/dist/services/overrides.js

@@ -0,0 +1,262 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransformLabel = exports.removeEmptyLines = exports.setFillArea = exports.addThresholds = exports.addBackgroundSymbol = exports.addBorder = exports.addLegend = exports.addYLabel = exports.addXLable = exports.setTitle = void 0;
+var constants_1 = require("../constants");
+var coords_1 = require("./coords");
+var settings_1 = require("./settings");
+var setTitle = function (_a) {
+    var title = _a.title, graph = _a.graph, backgroundSymbol = _a.backgroundSymbol, plotWidth = _a.plotWidth, yShift = _a.yShift;
+    // add one line for the title
+    graph.unshift((0, coords_1.toEmpty)(plotWidth + yShift + 2, backgroundSymbol)); // top
+    Array.from(title).forEach(function (letter, index) {
+        graph[0][index] = letter;
+    });
+};
+exports.setTitle = setTitle;
+var addXLable = function (_a) {
+    var graph = _a.graph, plotWidth = _a.plotWidth, yShift = _a.yShift, backgroundSymbol = _a.backgroundSymbol, xLabel = _a.xLabel;
+    var totalWidth = graph[0].length;
+    var labelLength = (0, coords_1.toArray)(xLabel).length;
+    var startingPosition = Math.round((totalWidth - labelLength) / 2);
+    // add one line for the xLabel
+    graph.push((0, coords_1.toEmpty)(plotWidth + yShift + 2, backgroundSymbol)); // bottom
+    Array.from(xLabel).forEach(function (letter, index) {
+        graph[graph.length - 1][startingPosition + index] = letter;
+    });
+};
+exports.addXLable = addXLable;
+var addYLabel = function (_a) {
+    var graph = _a.graph, backgroundSymbol = _a.backgroundSymbol, yLabel = _a.yLabel;
+    var totalHeight = graph.length;
+    var labelLength = (0, coords_1.toArray)(yLabel).length;
+    var startingPosition = Math.round((totalHeight - labelLength) / 2) - 1;
+    var label = Array.from(yLabel);
+    // add one line for the xLabel
+    graph.forEach(function (line, position) {
+        line.unshift(backgroundSymbol); // left
+        if (position > startingPosition && label[position - startingPosition - 1]) {
+            graph[position][0] = label[position - startingPosition - 1];
+        }
+    });
+};
+exports.addYLabel = addYLabel;
+var addLegend = function (_a) {
+    // calculate legend width as the longest label
+    // adds 2 for one space and color indicator
+    var graph = _a.graph, legend = _a.legend, backgroundSymbol = _a.backgroundSymbol, color = _a.color, symbols = _a.symbols, fillArea = _a.fillArea;
+    var series = Array.isArray(legend.series) ? legend.series : [legend.series];
+    var legendWidth = 2 + series.reduce(function (acc, label) { return Math.max(acc, (0, coords_1.toArray)(label).length); }, 0);
+    var _loop_1 = function (i) {
+        graph.forEach(function (line, lineIndex) {
+            if (legend.position === 'left') {
+                line.unshift(backgroundSymbol); // left
+                series.forEach(function (label, index) {
+                    if (lineIndex !== index)
+                        return;
+                    // get chart symbols for series
+                    var chartSymbols = (0, settings_1.getChartSymbols)(color, index, symbols === null || symbols === void 0 ? void 0 : symbols.chart, fillArea);
+                    var reversedLabel = __spreadArray(__spreadArray([
+                        chartSymbols.area,
+                        backgroundSymbol
+                    ], __read(Array.from(label)), false), __read(Array(legendWidth - label.length - 2).fill(backgroundSymbol)), false).reverse();
+                    if (reversedLabel[i]) {
+                        // eslint-disable-next-line no-param-reassign
+                        line[0] = reversedLabel[i];
+                    }
+                });
+            }
+            if (legend.position === 'right') {
+                line.push(backgroundSymbol);
+                series.forEach(function (label, index) {
+                    // get chart symbols for series
+                    var chartSymbols = (0, settings_1.getChartSymbols)(color, index, symbols === null || symbols === void 0 ? void 0 : symbols.chart, fillArea);
+                    var newSymbol = __spreadArray(__spreadArray([
+                        chartSymbols.area,
+                        backgroundSymbol
+                    ], __read(Array.from(label)), false), __read(Array(legendWidth - label.length - 2).fill(backgroundSymbol)), false);
+                    if (lineIndex === index) {
+                        // eslint-disable-next-line no-param-reassign
+                        line[line.length - 1] = newSymbol[i];
+                    }
+                });
+            }
+        });
+    };
+    // prepare space for legend
+    // and then place the legend
+    for (var i = 0; i < legendWidth; i += 1) {
+        _loop_1(i);
+    }
+    if (legend.position === 'top') {
+        series.reverse().forEach(function (label, index) {
+            graph.unshift((0, coords_1.toEmpty)(graph[0].length, backgroundSymbol)); // top
+            // get chart symbols for series
+            var chartSymbols = (0, settings_1.getChartSymbols)(color, index, symbols === null || symbols === void 0 ? void 0 : symbols.chart, fillArea);
+            var newSymbol = __spreadArray([chartSymbols.area, backgroundSymbol], __read(Array.from(label)), false);
+            graph[index].forEach(function (_, symbolIndex) {
+                if (newSymbol[symbolIndex]) {
+                    // eslint-disable-next-line no-param-reassign
+                    graph[0][symbolIndex] = newSymbol[symbolIndex];
+                }
+            });
+        });
+    }
+    if (legend.position === 'bottom') {
+        series.forEach(function (label, index) {
+            graph.push((0, coords_1.toEmpty)(graph[0].length, backgroundSymbol)); // bottom
+            // get chart symbols for series
+            var chartSymbols = (0, settings_1.getChartSymbols)(color, index, symbols === null || symbols === void 0 ? void 0 : symbols.chart, fillArea);
+            var newSymbol = __spreadArray([chartSymbols.area, backgroundSymbol], __read(Array.from(label)), false);
+            graph[index].forEach(function (_, symbolIndex) {
+                if (newSymbol[symbolIndex]) {
+                    // eslint-disable-next-line no-param-reassign
+                    graph[graph.length - 1][symbolIndex] = newSymbol[symbolIndex];
+                }
+            });
+        });
+    }
+};
+exports.addLegend = addLegend;
+var addBorder = function (_a) {
+    var graph = _a.graph, borderSymbol = _a.borderSymbol;
+    graph.forEach(function (line) {
+        line.unshift(borderSymbol); // left
+        line.push(borderSymbol); // right
+    });
+    graph.unshift((0, coords_1.toEmpty)(graph[0].length, borderSymbol)); // top
+    graph.push((0, coords_1.toEmpty)(graph[0].length, borderSymbol)); // bottom
+};
+exports.addBorder = addBorder;
+var addBackgroundSymbol = function (_a) {
+    var graph = _a.graph, backgroundSymbol = _a.backgroundSymbol, emptySymbol = _a.emptySymbol;
+    graph.forEach(function (line) {
+        for (var index = 0; index < line.length; index += 1) {
+            if (line[index] === emptySymbol) {
+                // eslint-disable-next-line
+                line[index] = backgroundSymbol;
+            }
+            else {
+                break;
+            }
+        }
+    });
+};
+exports.addBackgroundSymbol = addBackgroundSymbol;
+var addThresholds = function (_a) {
+    var graph = _a.graph, thresholds = _a.thresholds, axis = _a.axis, plotWidth = _a.plotWidth, plotHeight = _a.plotHeight, expansionX = _a.expansionX, expansionY = _a.expansionY;
+    var mappedThreshold = thresholds.map(function (_a) {
+        var thresholdX = _a.x, thresholdY = _a.y;
+        var x = axis.x, y = axis.y;
+        if (thresholdX) {
+            x = thresholdX;
+        }
+        if (thresholdY) {
+            y = thresholdY;
+        }
+        return [x, y];
+    });
+    // add threshold line
+    (0, coords_1.getPlotCoords)(mappedThreshold, plotWidth, plotHeight, expansionX, expansionY).forEach(function (_a, thresholdNumber) {
+        var _b, _c;
+        var _d = __read(_a, 2), x = _d[0], y = _d[1];
+        var _e = __read((0, coords_1.toPlot)(plotWidth, plotHeight)(x, y), 2), scaledX = _e[0], scaledY = _e[1];
+        // display x threshold only if it's in the graph
+        if (((_b = thresholds[thresholdNumber]) === null || _b === void 0 ? void 0 : _b.x) && graph[0][scaledX]) {
+            graph.forEach(function (_, index) {
+                var _a, _b;
+                if (graph[index][scaledX]) {
+                    graph[index][scaledX] = ((_a = thresholds[thresholdNumber]) === null || _a === void 0 ? void 0 : _a.color)
+                        ? "".concat((0, settings_1.getAnsiColor)(((_b = thresholds[thresholdNumber]) === null || _b === void 0 ? void 0 : _b.color) || 'ansiRed')).concat(constants_1.CHART.ns, "\u001B[0m")
+                        : constants_1.CHART.ns;
+                }
+            });
+        }
+        // display y threshold only if it's in the graph
+        if (((_c = thresholds[thresholdNumber]) === null || _c === void 0 ? void 0 : _c.y) && graph[scaledY]) {
+            graph[scaledY].forEach(function (_, index) {
+                var _a, _b;
+                if (graph[scaledY][index]) {
+                    graph[scaledY][index] = ((_a = thresholds[thresholdNumber]) === null || _a === void 0 ? void 0 : _a.color)
+                        ? "".concat((0, settings_1.getAnsiColor)(((_b = thresholds[thresholdNumber]) === null || _b === void 0 ? void 0 : _b.color) || 'ansiRed')).concat(constants_1.CHART.we, "\u001B[0m")
+                        : constants_1.CHART.we;
+                }
+            });
+        }
+    });
+};
+exports.addThresholds = addThresholds;
+var setFillArea = function (_a) {
+    var graph = _a.graph, chartSymbols = _a.chartSymbols;
+    graph.forEach(function (xValues, yIndex) {
+        xValues.forEach(function (xSymbol, xIndex) {
+            var _a;
+            if (xSymbol === (chartSymbols === null || chartSymbols === void 0 ? void 0 : chartSymbols.nse) ||
+                xSymbol === (chartSymbols === null || chartSymbols === void 0 ? void 0 : chartSymbols.wsn) ||
+                xSymbol === (chartSymbols === null || chartSymbols === void 0 ? void 0 : chartSymbols.we) ||
+                xSymbol === (chartSymbols === null || chartSymbols === void 0 ? void 0 : chartSymbols.area)) {
+                if ((_a = graph[yIndex + 1]) === null || _a === void 0 ? void 0 : _a[xIndex]) {
+                    graph[yIndex + 1][xIndex] = chartSymbols.area || constants_1.CHART.area;
+                }
+            }
+        });
+    });
+};
+exports.setFillArea = setFillArea;
+var removeEmptyLines = function (_a) {
+    var graph = _a.graph, backgroundSymbol = _a.backgroundSymbol;
+    // clean up empty lines after shift
+    // when there are occupied positions and shift is not needed
+    // there might be empty lines at the bottom
+    var elementsToRemove = [];
+    graph.forEach(function (line, position) {
+        if (line.every(function (symbol) { return symbol === backgroundSymbol; })) {
+            // collect empty line positions and remove them later
+            elementsToRemove.push(position);
+        }
+        // remove empty lines from the beginning
+        if (graph.every(function (currentLine) { return currentLine[0] === backgroundSymbol; })) {
+            graph.forEach(function (currentLine) { return currentLine.shift(); });
+        }
+    });
+    // reverse to remove from the end, otherwise positions will be shifted
+    elementsToRemove.reverse().forEach(function (position) {
+        graph.splice(position, 1);
+    });
+};
+exports.removeEmptyLines = removeEmptyLines;
+var getTransformLabel = function (_a) {
+    var formatter = _a.formatter;
+    var transformLabel = function (value, helpers) {
+        if (formatter) {
+            return formatter(value, helpers);
+        }
+        return (0, settings_1.defaultFormatter)(value, helpers);
+    };
+    return transformLabel;
+};
+exports.getTransformLabel = getTransformLabel;

package/dist/services/plot.d.ts

@@ -0,0 +1,3 @@
+import { Plot } from '../types/index';
+export declare const plot: Plot;
+export default plot;

package/dist/services/plot.js

@@ -0,0 +1,213 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plot = void 0;
+var coords_1 = require("./coords");
+var settings_1 = require("./settings");
+var overrides_1 = require("./overrides");
+var defaults_1 = require("./defaults");
+var draw_1 = require("./draw");
+var plot = function (rawInput, _a) {
+    var _b = _a === void 0 ? {} : _a, color = _b.color, width = _b.width, height = _b.height, axisCenter = _b.axisCenter, formatter = _b.formatter, lineFormatter = _b.lineFormatter, symbols = _b.symbols, title = _b.title, fillArea = _b.fillArea, hideXAxis = _b.hideXAxis, hideYAxis = _b.hideYAxis, xLabel = _b.xLabel, yLabel = _b.yLabel, legend = _b.legend, thresholds = _b.thresholds;
+    // Multiline
+    var input = (0, defaults_1.getInput)({ rawInput: rawInput });
+    // Empty input, return early
+    if (input.length === 0) {
+        return '';
+    }
+    var transformLabel = (0, overrides_1.getTransformLabel)({ formatter: formatter });
+    var scaledCoords = [[0, 0]];
+    var _c = (0, defaults_1.getChartSize)({
+        width: width,
+        height: height,
+        input: input,
+    }), minX = _c.minX, plotWidth = _c.plotWidth, plotHeight = _c.plotHeight, expansionX = _c.expansionX, expansionY = _c.expansionY;
+    var _d = (0, defaults_1.getSymbols)({ symbols: symbols }), axisSymbols = _d.axisSymbols, emptySymbol = _d.emptySymbol, backgroundSymbol = _d.backgroundSymbol, borderSymbol = _d.borderSymbol;
+    // create placeholder
+    var graph = (0, draw_1.drawGraph)({ plotWidth: plotWidth, plotHeight: plotHeight, emptySymbol: emptySymbol });
+    var axis = (0, coords_1.getAxisCenter)(axisCenter, plotWidth, plotHeight, expansionX, expansionY, [
+        0,
+        graph.length - 1,
+    ]);
+    // get default chart symbols
+    input.forEach(function (coords, series) {
+        // override default chart symbols with colored ones
+        var chartSymbols = (0, settings_1.getChartSymbols)(color, series, symbols === null || symbols === void 0 ? void 0 : symbols.chart, fillArea);
+        // sort input by the first value
+        var sortedCoords = (0, coords_1.toSorted)(coords);
+        scaledCoords = (0, coords_1.getPlotCoords)(sortedCoords, plotWidth, plotHeight, expansionX, expansionY).map(function (_a, index, arr) {
+            var _b = __read(_a, 2), x = _b[0], y = _b[1];
+            var _c = __read((0, coords_1.toPlot)(plotWidth, plotHeight)(x, y), 2), scaledX = _c[0], scaledY = _c[1];
+            if (!lineFormatter) {
+                (0, draw_1.drawLine)({ index: index, arr: arr, graph: graph, scaledX: scaledX, scaledY: scaledY, plotHeight: plotHeight, emptySymbol: emptySymbol, chartSymbols: chartSymbols });
+                // fill empty area under the line if fill area is true
+                if (fillArea) {
+                    (0, overrides_1.setFillArea)({ graph: graph, chartSymbols: chartSymbols });
+                }
+            }
+            else {
+                (0, draw_1.drawCustomLine)({ sortedCoords: sortedCoords, scaledX: scaledX, scaledY: scaledY, input: input, index: index, lineFormatter: lineFormatter, graph: graph });
+            }
+            return [scaledX, scaledY];
+        });
+    });
+    if (thresholds) {
+        (0, overrides_1.addThresholds)({
+            graph: graph,
+            thresholds: thresholds,
+            axis: axis,
+            plotWidth: plotWidth,
+            plotHeight: plotHeight,
+            expansionX: expansionX,
+            expansionY: expansionY,
+        });
+    }
+    // axis
+    (0, draw_1.drawAxis)({
+        graph: graph,
+        hideXAxis: hideXAxis,
+        hideYAxis: hideYAxis,
+        axisCenter: axisCenter,
+        axisSymbols: axisSymbols,
+        axis: axis,
+    });
+    // labels
+    // takes the longest label that needs to be rendered
+    // on the Y axis and returns it's length
+    var _e = (0, defaults_1.getLabelShift)({ input: input, transformLabel: transformLabel, expansionX: expansionX, expansionY: expansionY, minX: minX }), xShift = _e.xShift, yShift = _e.yShift;
+    // shift graph
+    var hasToBeMoved = (0, draw_1.drawShift)({
+        graph: graph,
+        plotWidth: plotWidth,
+        emptySymbol: emptySymbol,
+        scaledCoords: scaledCoords,
+        xShift: xShift,
+        yShift: yShift,
+    }).hasToBeMoved;
+    // apply background symbol if override
+    if (backgroundSymbol) {
+        (0, overrides_1.addBackgroundSymbol)({ graph: graph, backgroundSymbol: backgroundSymbol, emptySymbol: emptySymbol });
+    }
+    // shift coords
+    input.forEach(function (current) {
+        var coord = (0, coords_1.getPlotCoords)(current, plotWidth, plotHeight, expansionX, expansionY);
+        current.forEach(function (_a, index) {
+            var _b = __read(_a, 2), pointX = _b[0], pointY = _b[1];
+            var _c = __read(coord[index], 2), x = _c[0], y = _c[1];
+            var _d = __read((0, coords_1.toPlot)(plotWidth, plotHeight)(x, y), 2), scaledX = _d[0], scaledY = _d[1];
+            if (!hideYAxis) {
+                (0, draw_1.drawYAxisEnd)({
+                    graph: graph,
+                    scaledY: scaledY,
+                    yShift: yShift,
+                    axis: axis,
+                    pointY: pointY,
+                    transformLabel: transformLabel,
+                    axisSymbols: axisSymbols,
+                    expansionX: expansionX,
+                    expansionY: expansionY,
+                });
+            }
+            if (!hideXAxis) {
+                var pointXShift = (0, coords_1.toArray)(transformLabel(pointX, { axis: 'x', xRange: expansionX, yRange: expansionY }));
+                var yPos_1 = graph.length - 1;
+                var shift_1 = axisCenter ? -1 : 0;
+                // check if place is taken by previous point
+                // take into consideration different axis center,
+                // when axis center is set to true symbol might be '-'
+                var hasPlaceToRender = pointXShift.every(function (_, i) {
+                    return [emptySymbol, axisSymbols.ns].includes(graph[yPos_1 - 1][scaledX + yShift - i + 2 + shift_1]);
+                });
+                for (var i = 0; i < pointXShift.length; i += 1) {
+                    var signShift = -1;
+                    if (hasToBeMoved) {
+                        signShift = -2;
+                    }
+                    var isSymbolOnXAxisOccupied = graph[yPos_1 + signShift][scaledX + yShift + 2 + shift_1] === axisSymbols.x;
+                    // Make sure position is not taken already
+                    if (isSymbolOnXAxisOccupied) {
+                        break;
+                    }
+                    // make sure that shift is applied only when place is taken
+                    if (axisCenter) {
+                        yPos_1 = axis.y + 1;
+                    }
+                    (0, draw_1.drawXAxisEnd)({
+                        hasPlaceToRender: hasPlaceToRender,
+                        axisCenter: axisCenter,
+                        yPos: yPos_1,
+                        graph: graph,
+                        yShift: yShift,
+                        i: i,
+                        scaledX: scaledX,
+                        shift: shift_1,
+                        signShift: signShift,
+                        axisSymbols: axisSymbols,
+                        pointXShift: pointXShift,
+                    });
+                }
+            }
+        });
+    });
+    // Remove empty lines
+    (0, overrides_1.removeEmptyLines)({ graph: graph, backgroundSymbol: backgroundSymbol });
+    // Adds title above the graph
+    if (title) {
+        (0, overrides_1.setTitle)({
+            title: title,
+            graph: graph,
+            backgroundSymbol: backgroundSymbol,
+            plotWidth: plotWidth,
+            yShift: yShift,
+        });
+    }
+    // Adds x axis label below the graph
+    if (xLabel) {
+        (0, overrides_1.addXLable)({
+            xLabel: xLabel,
+            graph: graph,
+            backgroundSymbol: backgroundSymbol,
+            plotWidth: plotWidth,
+            yShift: yShift,
+        });
+    }
+    // Adds x axis label below the graph
+    if (yLabel) {
+        (0, overrides_1.addYLabel)({
+            yLabel: yLabel,
+            graph: graph,
+            backgroundSymbol: backgroundSymbol,
+        });
+    }
+    if (legend) {
+        (0, overrides_1.addLegend)({
+            graph: graph,
+            legend: legend,
+            backgroundSymbol: backgroundSymbol,
+            color: color,
+            symbols: symbols,
+            fillArea: fillArea,
+        });
+    }
+    if (borderSymbol) {
+        (0, overrides_1.addBorder)({ graph: graph, borderSymbol: borderSymbol });
+    }
+    return (0, draw_1.drawChart)({ graph: graph });
+};
+exports.plot = plot;
+exports.default = exports.plot;

package/dist/services/settings.d.ts

@@ -0,0 +1,21 @@
+import { CHART } from '../constants/index';
+import { Color, Formatter } from '../types/index';
+export declare const getAnsiColor: (color: Color) => string;
+export declare const getChartSymbols: (color: Color | Color[] | undefined, series: number, chartSymbols: Partial<typeof CHART> | void, fillArea?: boolean) => {
+    we: string;
+    wns: string;
+    ns: string;
+    nse: string;
+    wsn: string;
+    sne: string;
+    area: string;
+} | {
+    we: string;
+    wns: string;
+    ns: string;
+    nse: string;
+    wsn: string;
+    sne: string;
+    area: string;
+};
+export declare const defaultFormatter: Formatter;

package/dist/services/settings.js

@@ -0,0 +1,67 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFormatter = exports.getChartSymbols = exports.getAnsiColor = void 0;
+var index_1 = require("../constants/index");
+var colorMap = {
+    ansiBlack: '\u001b[30m',
+    ansiRed: '\u001b[31m',
+    ansiGreen: '\u001b[32m',
+    ansiYellow: '\u001b[33m',
+    ansiBlue: '\u001b[34m',
+    ansiMagenta: '\u001b[35m',
+    ansiCyan: '\u001b[36m',
+    ansiWhite: '\u001b[37m',
+};
+var getAnsiColor = function (color) { return colorMap[color] || colorMap.ansiWhite; };
+exports.getAnsiColor = getAnsiColor;
+var getChartSymbols = function (color, series, chartSymbols, fillArea) {
+    var chart = __assign(__assign({}, index_1.CHART), chartSymbols);
+    if (fillArea) {
+        Object.entries(chart).forEach(function (_a) {
+            var _b = __read(_a, 1), key = _b[0];
+            chart[key] = chart.area;
+        });
+    }
+    if (color) {
+        var currentColor_1 = Array.isArray(color) ? color[series] : color;
+        Object.entries(chart).forEach(function (_a) {
+            var _b = __read(_a, 2), key = _b[0], sign = _b[1];
+            chart[key] = "".concat((0, exports.getAnsiColor)(currentColor_1)).concat(sign, "\u001B[0m");
+        });
+    }
+    return chart;
+};
+exports.getChartSymbols = getChartSymbols;
+var defaultFormatter = function (value) {
+    if (Math.abs(value) >= 1000)
+        return "".concat(Number(value.toFixed(3)) / 1000, "k");
+    return Number(value.toFixed(3));
+};
+exports.defaultFormatter = defaultFormatter;

package/dist/types/index.d.ts

@@ -0,0 +1,61 @@
+import { AXIS, CHART } from '../constants';
+export type Point = [x: number, y: number];
+export type SingleLine = Point[];
+export type MultiLine = SingleLine[];
+export type Coordinates = SingleLine | MultiLine;
+export type Color = `ansi${'Red' | 'Green' | 'Black' | 'Yellow' | 'Blue' | 'Magenta' | 'Cyan' | 'White'}`;
+export type LineFormatterArgs = {
+    x: number;
+    y: number;
+    plotX: number;
+    plotY: number;
+    input: SingleLine;
+    index: number;
+};
+export type CustomSymbol = {
+    x: number;
+    y: number;
+    symbol: string;
+};
+export type FormatterHelpers = {
+    axis: 'x' | 'y';
+    xRange: number[];
+    yRange: number[];
+};
+export type Symbols = {
+    axis?: Partial<typeof AXIS>;
+    chart?: Partial<typeof CHART>;
+    empty?: string;
+    background?: string;
+    border?: string;
+};
+export type Formatter = (number: number, helpers: FormatterHelpers) => number | string;
+export type Legend = {
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    series: string | string[];
+};
+export type Threshold = {
+    x?: number;
+    y?: number;
+    color?: Color;
+};
+export type Colors = Color | Color[];
+export type Graph = string[][];
+export type Settings = {
+    color?: Colors;
+    width?: number;
+    height?: number;
+    hideXAxis?: boolean;
+    hideYAxis?: boolean;
+    title?: string;
+    xLabel?: string;
+    yLabel?: string;
+    thresholds?: Threshold[];
+    fillArea?: boolean;
+    legend?: Legend;
+    axisCenter?: Point;
+    formatter?: Formatter;
+    lineFormatter?: (args: LineFormatterArgs) => CustomSymbol | CustomSymbol[];
+    symbols?: Symbols;
+};
+export type Plot = (coordinates: Coordinates, settings?: Settings) => string;

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });