simple-ascii-chart-cli 1.0.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var yargs = __importStar(require("yargs"));
+var index_1 = __importDefault(require("./index"));
+var argv = yargs
+    .option('input', {
+    alias: 'i',
+    type: 'string',
+    demandOption: true,
+})
+    .option('options', {
+    alias: 'o',
+    type: 'string',
+    description: 'plot settings',
+})
+    .option('height', {
+    alias: 'h',
+    type: 'number',
+    description: 'plot height',
+})
+    .option('hideXAxis', {
+    type: 'boolean',
+    description: 'hide x axis',
+})
+    .option('hideYAxis', {
+    type: 'boolean',
+    description: 'hide Y axis',
+})
+    .option('fillArea', {
+    type: 'boolean',
+    description: 'fill plot area',
+})
+    .option('width', {
+    alias: 'w',
+    type: 'number',
+    description: 'plot width',
+})
+    .option('title', {
+    alias: 't',
+    type: 'string',
+    description: 'plot title',
+})
+    .option('xLabel', {
+    type: 'string',
+    description: 'x axis label',
+})
+    .option('color', {
+    alias: 'c',
+    type: 'array',
+    description: 'plot colors',
+})
+    .option('axisCenter', {
+    type: 'array',
+    description: 'plot center coordinates',
+})
+    .option('yLabel', {
+    type: 'string',
+    description: 'y axis label',
+}).argv;
+var withError = function (cb) {
+    try {
+        cb();
+    }
+    catch (error) {
+        process.stderr.write('Oops! Something went wrong!\n');
+        process.exit(1);
+    }
+};
+var execute = function (_a) {
+    var input = _a.input, options = _a.options;
+    withError(function () {
+        var output = (0, index_1.default)(input, options);
+        process.stdout.write(output);
+        process.exit(0);
+    });
+};
+var prepareParams = function (_a) {
+    var input = _a.input, options = _a.options, width = _a.width, height = _a.height, hideYAxis = _a.hideYAxis, hideXAxis = _a.hideXAxis, fillArea = _a.fillArea, title = _a.title, xLabel = _a.xLabel, yLabel = _a.yLabel, color = _a.color, axisCenter = _a.axisCenter;
+    var currentOptions = options ? JSON.parse(options) : {};
+    return {
+        input: JSON.parse(input),
+        options: __assign(__assign({}, currentOptions), { width: width, height: height, hideYAxis: hideYAxis, hideXAxis: hideXAxis, title: title, xLabel: xLabel, yLabel: yLabel, fillArea: fillArea, color: color, axisCenter: axisCenter }),
+    };
+};
+if (argv instanceof Promise) {
+    argv.then(function (parameters) {
+        withError(function () {
+            execute(prepareParams(parameters));
+        });
+    });
+}
+else {
+    withError(function () {
+        execute(prepareParams(argv));
+    });
+}

package/dist/constants/index.d.ts

@@ -0,0 +1,19 @@
+export declare const AXIS: {
+    n: string;
+    ns: string;
+    y: string;
+    nse: string;
+    x: string;
+    we: string;
+    e: string;
+};
+export declare const CHART: {
+    we: string;
+    wns: string;
+    ns: string;
+    nse: string;
+    wsn: string;
+    sne: string;
+    area: string;
+};
+export declare const EMPTY = " ";

package/dist/constants/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMPTY = exports.CHART = exports.AXIS = void 0;
+exports.AXIS = {
+    n: '▲',
+    ns: '│',
+    y: '┤',
+    nse: '└',
+    x: '┬',
+    we: '─',
+    e: '▶',
+};
+exports.CHART = {
+    we: '━',
+    wns: '┓',
+    ns: '┃',
+    nse: '┗',
+    wsn: '┛',
+    sne: '┏',
+    area: '█',
+};
+exports.EMPTY = ' ';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { plot } from './services/plot';
+export default plot;

package/dist/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var plot_1 = require("./services/plot");
+exports.default = plot_1.plot;

package/dist/services/coords.d.ts

@@ -0,0 +1,113 @@
+import { SingleLine, Point, MultiLine } from '../types/index';
+/**
+ * Creates an array filled with empty strings.
+ * @param {number} size - The size of the array.
+ * @param {string} empty - The value to fill the array with (default: EMPTY).
+ * @returns {string[]} - An array of empty strings.
+ */
+export declare const toEmpty: (size: number, empty?: string) => string[];
+/**
+ * Converts a number or string to an array of its characters.
+ * @param {number | string} input - The input to convert.
+ * @returns {string[]} - An array of characters.
+ */
+export declare const toArray: (input: number | string) => string[];
+/**
+ * Removes duplicate values from an array.
+ * @param {number[]} array - The input array.
+ * @returns {number[]} - An array with unique values.
+ */
+export declare const toUnique: (array: number[]) => number[];
+/**
+ * Calculates the distance between two points.
+ * @param {number} x - The x-coordinate of the first point.
+ * @param {number} y - The y-coordinate of the second point.
+ * @returns {number} - The distance between the points.
+ */
+export declare const distance: (x: number, y: number) => number;
+/**
+ * Flattens a multi-line array into a single array of points.
+ * @param {MultiLine} array - The multi-line array.
+ * @returns {Point[]} - A flat array of points.
+ */
+export declare const toFlat: (array: MultiLine) => Point[];
+/**
+ * Converts a multi-line array into arrays of unique x and y values.
+ * @param {MultiLine} array - The multi-line array.
+ * @returns {[number[], number[]]} - Arrays of unique x and y values.
+ */
+export declare const toArrays: (array: MultiLine) => [number[], number[]];
+/**
+ * Sorts a single-line array of points in ascending order by the first value of each point.
+ * @param {SingleLine} array - The single-line array to sort.
+ * @returns {SingleLine} - The sorted array.
+ */
+export declare const toSorted: (array: SingleLine) => SingleLine;
+/**
+ * Converts a coordinate (x, y) to plot coordinates in the specified plot dimensions.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @returns {function} - A function that takes (x, y) and returns plot coordinates [scaledX, scaledY].
+ */
+export declare const toPlot: (plotWidth: number, plotHeight: number) => (x: number, y: number) => number[];
+/**
+ * Finds the maximum or minimum value in a single-line array of points.
+ * @param {SingleLine} arr - The single-line array to find extrema in.
+ * @param {string} type - 'max' for maximum, 'min' for minimum (default is 'max').
+ * @param {number} position - The position of the value within each point (default is 1).
+ * @returns {number} - The maximum or minimum value found in the array.
+ */
+export declare const getExtrema: (arr: SingleLine, type?: 'max' | 'min', position?: number) => number;
+/**
+ * Finds the maximum value in an array of numbers.
+ * @param {number[]} arr - The array of numbers to find the maximum in.
+ * @returns {number} - The maximum value in the array.
+ */
+export declare const getMax: (arr: number[]) => number;
+/**
+ * Finds the minimum value in an array of numbers.
+ * @param {number[]} arr - The array of numbers to find the minimum in.
+ * @returns {number} - The minimum value in the array.
+ */
+export declare const getMin: (arr: number[]) => number;
+/**
+ * Returns a function that scales coordinates to fit within a plot.
+ * @param {[number, number]} domain - The domain range (min and max values).
+ * @param {[number, number]} range - The range within which to scale.
+ * @returns {(value: number) => number} - A function for scaling coordinates.
+ */
+export declare const scaler: ([domainMin, domainMax]: number[], [rangeMin, rangeMax]: number[]) => (domainValue: number) => number;
+/**
+ * Scales a point's coordinates to fit within a plot.
+ * @param {Point} point - The point to scale.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} rangeX - The range of x values.
+ * @param {number[]} rangeY - The range of y values.
+ * @returns {Point} - The scaled point.
+ */
+export declare const toCoordinates: (point: Point, plotWidth: number, plotHeight: number, rangeX: number[], rangeY: number[]) => Point;
+/**
+ * Scales a list of coordinates to fit within a plot.
+ * @param {SingleLine} coordinates - The list of coordinates to scale.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} [rangeX] - The range of x values (defaults to min and max from coordinates).
+ * @param {number[]} [rangeY] - The range of y values (defaults to min and max from coordinates).
+ * @returns {SingleLine} - The scaled list of coordinates.
+ */
+export declare const getPlotCoords: (coordinates: SingleLine, plotWidth: number, plotHeight: number, rangeX?: number[], rangeY?: number[]) => SingleLine;
+/**
+ * Gets the center point for an axis.
+ * @param {Point | void} axisCenter - The center point of the axis (optional).
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} rangeX - The range of x values.
+ * @param {number[]} rangeY - The range of y values.
+ * @param {number[]} initialValue - The initial value for the axis.
+ * @returns {Point} - The center point of the axis.
+ */
+export declare const getAxisCenter: (axisCenter: Point | void, plotWidth: number, plotHeight: number, rangeX: number[], rangeY: number[], initialValue: number[]) => {
+    x: number;
+    y: number;
+};

package/dist/services/coords.js

@@ -0,0 +1,228 @@
+"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.getAxisCenter = exports.getPlotCoords = exports.toCoordinates = exports.scaler = exports.getMin = exports.getMax = exports.getExtrema = exports.toPlot = exports.toSorted = exports.toArrays = exports.toFlat = exports.distance = exports.toUnique = exports.toArray = exports.toEmpty = void 0;
+var index_1 = require("../constants/index");
+/**
+ * Creates an array filled with empty strings.
+ * @param {number} size - The size of the array.
+ * @param {string} empty - The value to fill the array with (default: EMPTY).
+ * @returns {string[]} - An array of empty strings.
+ */
+var toEmpty = function (size, empty) {
+    if (empty === void 0) { empty = index_1.EMPTY; }
+    return Array(size >= 0 ? size : 0).fill(empty);
+};
+exports.toEmpty = toEmpty;
+/**
+ * Converts a number or string to an array of its characters.
+ * @param {number | string} input - The input to convert.
+ * @returns {string[]} - An array of characters.
+ */
+var toArray = function (input) { return input.toString().split(''); };
+exports.toArray = toArray;
+/**
+ * Removes duplicate values from an array.
+ * @param {number[]} array - The input array.
+ * @returns {number[]} - An array with unique values.
+ */
+var toUnique = function (array) { return __spreadArray([], __read(new Set(array)), false); };
+exports.toUnique = toUnique;
+/**
+ * Calculates the distance between two points.
+ * @param {number} x - The x-coordinate of the first point.
+ * @param {number} y - The y-coordinate of the second point.
+ * @returns {number} - The distance between the points.
+ */
+var distance = function (x, y) { return Math.abs(Math.round(x) - Math.round(y)); };
+exports.distance = distance;
+/**
+ * Flattens a multi-line array into a single array of points.
+ * @param {MultiLine} array - The multi-line array.
+ * @returns {Point[]} - A flat array of points.
+ */
+var toFlat = function (array) {
+    var _a;
+    return (_a = []).concat.apply(_a, __spreadArray([], __read(array), false));
+};
+exports.toFlat = toFlat;
+/**
+ * Converts a multi-line array into arrays of unique x and y values.
+ * @param {MultiLine} array - The multi-line array.
+ * @returns {[number[], number[]]} - Arrays of unique x and y values.
+ */
+var toArrays = function (array) {
+    var rangeX = [];
+    var rangeY = [];
+    (0, exports.toFlat)(array).forEach(function (_a) {
+        var _b = __read(_a, 2), x = _b[0], y = _b[1];
+        rangeX.push(x);
+        rangeY.push(y);
+    });
+    return [(0, exports.toUnique)(rangeX), (0, exports.toUnique)(rangeY)];
+};
+exports.toArrays = toArrays;
+/**
+ * Sorts a single-line array of points in ascending order by the first value of each point.
+ * @param {SingleLine} array - The single-line array to sort.
+ * @returns {SingleLine} - The sorted array.
+ */
+var toSorted = function (array) {
+    return array.sort(function (_a, _b) {
+        var _c = __read(_a, 1), x1 = _c[0];
+        var _d = __read(_b, 1), x2 = _d[0];
+        if (x1 < x2) {
+            return -1;
+        }
+        if (x1 > x2) {
+            return 1;
+        }
+        return 0;
+    });
+};
+exports.toSorted = toSorted;
+/**
+ * Converts a coordinate (x, y) to plot coordinates in the specified plot dimensions.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @returns {function} - A function that takes (x, y) and returns plot coordinates [scaledX, scaledY].
+ */
+var toPlot = function (plotWidth, plotHeight) { return function (x, y) { return [
+    Math.round((x / plotWidth) * plotWidth),
+    plotHeight - 1 - Math.round((y / plotHeight) * plotHeight),
+]; }; };
+exports.toPlot = toPlot;
+/**
+ * Finds the maximum or minimum value in a single-line array of points.
+ * @param {SingleLine} arr - The single-line array to find extrema in.
+ * @param {string} type - 'max' for maximum, 'min' for minimum (default is 'max').
+ * @param {number} position - The position of the value within each point (default is 1).
+ * @returns {number} - The maximum or minimum value found in the array.
+ */
+var getExtrema = function (arr, type, position) {
+    if (type === void 0) { type = 'max'; }
+    if (position === void 0) { position = 1; }
+    return arr.reduce(function (previous, curr) { return Math[type](previous, curr[position]); }, type === 'max' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY);
+};
+exports.getExtrema = getExtrema;
+/**
+ * Finds the maximum value in an array of numbers.
+ * @param {number[]} arr - The array of numbers to find the maximum in.
+ * @returns {number} - The maximum value in the array.
+ */
+var getMax = function (arr) {
+    return arr.reduce(function (previous, curr) { return Math.max(previous, curr); }, Number.NEGATIVE_INFINITY);
+};
+exports.getMax = getMax;
+/**
+ * Finds the minimum value in an array of numbers.
+ * @param {number[]} arr - The array of numbers to find the minimum in.
+ * @returns {number} - The minimum value in the array.
+ */
+var getMin = function (arr) {
+    return arr.reduce(function (previous, curr) { return Math.min(previous, curr); }, Number.POSITIVE_INFINITY);
+};
+exports.getMin = getMin;
+/**
+ * Returns a function that scales coordinates to fit within a plot.
+ * @param {[number, number]} domain - The domain range (min and max values).
+ * @param {[number, number]} range - The range within which to scale.
+ * @returns {(value: number) => number} - A function for scaling coordinates.
+ */
+var scaler = function (_a, _b) {
+    var _c = __read(_a, 2), domainMin = _c[0], domainMax = _c[1];
+    var _d = __read(_b, 2), rangeMin = _d[0], rangeMax = _d[1];
+    var domainLength = Math.sqrt(Math.abs(Math.pow((domainMax - domainMin), 2))) || 1;
+    var rangeLength = Math.sqrt(Math.pow((rangeMax - rangeMin), 2));
+    return function (domainValue) {
+        return rangeMin + (rangeLength * (domainValue - domainMin)) / domainLength;
+    };
+};
+exports.scaler = scaler;
+/**
+ * Scales a point's coordinates to fit within a plot.
+ * @param {Point} point - The point to scale.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} rangeX - The range of x values.
+ * @param {number[]} rangeY - The range of y values.
+ * @returns {Point} - The scaled point.
+ */
+var toCoordinates = function (point, plotWidth, plotHeight, rangeX, rangeY) {
+    var getXCoord = (0, exports.scaler)(rangeX, [0, plotWidth - 1]);
+    var getYCoord = (0, exports.scaler)(rangeY, [0, plotHeight - 1]);
+    var toScale = function (_a) {
+        var _b = __read(_a, 2), x = _b[0], y = _b[1];
+        return [getXCoord(x), getYCoord(y)];
+    };
+    return toScale(point);
+};
+exports.toCoordinates = toCoordinates;
+/**
+ * Scales a list of coordinates to fit within a plot.
+ * @param {SingleLine} coordinates - The list of coordinates to scale.
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} [rangeX] - The range of x values (defaults to min and max from coordinates).
+ * @param {number[]} [rangeY] - The range of y values (defaults to min and max from coordinates).
+ * @returns {SingleLine} - The scaled list of coordinates.
+ */
+var getPlotCoords = function (coordinates, plotWidth, plotHeight, rangeX, rangeY) {
+    var getXCoord = (0, exports.scaler)(rangeX || [(0, exports.getExtrema)(coordinates, 'min', 0), (0, exports.getExtrema)(coordinates, 'max', 0)], [0, plotWidth - 1]);
+    var getYCoord = (0, exports.scaler)(rangeY || [(0, exports.getExtrema)(coordinates, 'min'), (0, exports.getExtrema)(coordinates)], [
+        0,
+        plotHeight - 1,
+    ]);
+    var toScale = function (_a) {
+        var _b = __read(_a, 2), x = _b[0], y = _b[1];
+        return [getXCoord(x), getYCoord(y)];
+    };
+    return coordinates.map(toScale);
+};
+exports.getPlotCoords = getPlotCoords;
+/**
+ * Gets the center point for an axis.
+ * @param {Point | void} axisCenter - The center point of the axis (optional).
+ * @param {number} plotWidth - The width of the plot.
+ * @param {number} plotHeight - The height of the plot.
+ * @param {number[]} rangeX - The range of x values.
+ * @param {number[]} rangeY - The range of y values.
+ * @param {number[]} initialValue - The initial value for the axis.
+ * @returns {Point} - The center point of the axis.
+ */
+var getAxisCenter = function (axisCenter, plotWidth, plotHeight, rangeX, rangeY, initialValue) {
+    var axis = { x: initialValue[0], y: initialValue[1] };
+    // calculate axis position
+    if (axisCenter) {
+        var _a = __read((0, exports.toCoordinates)(axisCenter, plotWidth, plotHeight, rangeX, rangeY), 2), centerX = _a[0], centerY = _a[1];
+        var _b = __read((0, exports.toPlot)(plotWidth, plotHeight)(centerX, centerY), 2), plotCenterX = _b[0], plotCenterY = _b[1];
+        axis.x = plotCenterX;
+        axis.y = plotCenterY + 1;
+    }
+    return axis;
+};
+exports.getAxisCenter = getAxisCenter;

package/dist/services/defaults.d.ts

@@ -0,0 +1,41 @@
+import { Symbols, MultiLine, Formatter, Coordinates } from '../types';
+export declare const getSymbols: ({ symbols }: {
+    symbols?: Symbols | undefined;
+}) => {
+    axisSymbols: {
+        n: string;
+        ns: string;
+        y: string;
+        nse: string;
+        x: string;
+        we: string;
+        e: string;
+    };
+    emptySymbol: string;
+    backgroundSymbol: string;
+    borderSymbol: string | undefined;
+};
+export declare const getChartSize: ({ input, width, height, }: {
+    input: MultiLine;
+    width?: number | undefined;
+    height?: number | undefined;
+}) => {
+    minX: number;
+    plotWidth: number;
+    plotHeight: number;
+    expansionX: number[];
+    expansionY: number[];
+};
+export declare const getLabelShift: ({ input, transformLabel, expansionX, expansionY, minX, }: {
+    input: MultiLine;
+    transformLabel: Formatter;
+    expansionX: number[];
+    expansionY: number[];
+    minX: number;
+}) => {
+    xShift: number;
+    yShift: number;
+};
+export declare const getInput: ({ rawInput }: {
+    rawInput: Coordinates;
+}) => MultiLine;