simple-ascii-chart-cli 1.0.0 → 1.1.0

package/dist/cli.js

@@ -38,89 +38,129 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// Import necessary modules and types
 var yargs = __importStar(require("yargs"));
-var index_1 = __importDefault(require("./index"));
+var simple_ascii_chart_1 = __importDefault(require("simple-ascii-chart"));
+var validators_1 = require("./validators");
+// Define command-line arguments with yargs
 var argv = yargs
     .option('input', {
     alias: 'i',
     type: 'string',
     demandOption: true,
+    description: 'Data to be plotted (in JSON format)',
 })
     .option('options', {
     alias: 'o',
     type: 'string',
-    description: 'plot settings',
+    description: 'Plot settings (in JSON format)',
 })
     .option('height', {
     alias: 'h',
     type: 'number',
-    description: 'plot height',
+    description: 'Height of the plot',
 })
     .option('hideXAxis', {
     type: 'boolean',
-    description: 'hide x axis',
+    description: 'Hide the x-axis if set to true',
 })
     .option('hideYAxis', {
     type: 'boolean',
-    description: 'hide Y axis',
+    description: 'Hide the y-axis if set to true',
 })
     .option('fillArea', {
     type: 'boolean',
-    description: 'fill plot area',
+    description: 'Fill the plot area if set to true',
 })
     .option('width', {
     alias: 'w',
     type: 'number',
-    description: 'plot width',
+    description: 'Width of the plot',
 })
     .option('title', {
     alias: 't',
     type: 'string',
-    description: 'plot title',
+    description: 'Title for the plot',
 })
     .option('xLabel', {
     type: 'string',
-    description: 'x axis label',
+    description: 'Label for the x-axis',
+})
+    .option('yLabel', {
+    type: 'string',
+    description: 'Label for the y-axis',
 })
     .option('color', {
     alias: 'c',
     type: 'array',
-    description: 'plot colors',
+    description: 'Array of colors for plot elements',
 })
     .option('axisCenter', {
     type: 'array',
-    description: 'plot center coordinates',
+    description: 'Center coordinates for axis alignment',
 })
-    .option('yLabel', {
+    .option('yRange', {
+    type: 'array',
+    description: 'Range for the y-axis, formatted as [min, max]',
+})
+    .option('showTickLabel', {
+    type: 'boolean',
+    description: 'Show tick labels on the axis if set to true',
+})
+    .option('thresholds', {
+    type: 'array',
+    description: 'Array of threshold points or lines with optional color',
+})
+    .option('legend', {
+    type: 'string',
+    description: 'Legend settings (position and series labels)',
+})
+    .option('formatter', {
+    type: 'string',
+    description: 'Custom formatter for axis values, as a JavaScript function',
+})
+    .option('lineFormatter', {
+    type: 'string',
+    description: 'Formatter for customizing line appearance, as a JavaScript function',
+})
+    .option('symbols', {
     type: 'string',
-    description: 'y axis label',
+    description: 'Custom symbols for axis, chart, and background',
 }).argv;
+// Helper function to execute code with error handling
 var withError = function (cb) {
     try {
         cb();
     }
     catch (error) {
+        // Display an error message and exit the process with a failure code
         process.stderr.write('Oops! Something went wrong!\n');
         process.exit(1);
     }
 };
+// Main function to execute the plot based on input and options
 var execute = function (_a) {
     var input = _a.input, options = _a.options;
     withError(function () {
-        var output = (0, index_1.default)(input, options);
+        // Generate the ASCII plot based on provided input and settings
+        var output = (0, simple_ascii_chart_1.default)(input, options);
+        // Output the result to the console
         process.stdout.write(output);
-        process.exit(0);
+        process.exit(0); // Exit successfully after outputting the plot
     });
 };
 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 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, yRange = _a.yRange, showTickLabel = _a.showTickLabel, thresholds = _a.thresholds, legend = _a.legend, formatter = _a.formatter, lineFormatter = _a.lineFormatter, symbols = _a.symbols;
     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 }),
+        options: __assign(__assign({}, currentOptions), { width: width, height: height, hideYAxis: hideYAxis, hideXAxis: hideXAxis, title: title, xLabel: xLabel, yLabel: yLabel, fillArea: fillArea, color: color ? (0, validators_1.validateColors)(color) : undefined, axisCenter: (0, validators_1.validateAxisCenter)(axisCenter), yRange: (0, validators_1.validateYRange)(yRange), // Validate and format yRange
+            showTickLabel: showTickLabel, thresholds: (0, validators_1.validateThresholds)(thresholds), legend: (0, validators_1.validateLegend)(legend), formatter: (0, validators_1.validateFormatter)(formatter), lineFormatter: (0, validators_1.validateLineFormatter)(lineFormatter), symbols: (0, validators_1.validateSymbols)(symbols) }),
     };
 };
+// Check if argv is a Promise to handle async parsing in yargs
 if (argv instanceof Promise) {
+    // If async, wait for arguments and execute the plotting
     argv.then(function (parameters) {
         withError(function () {
             execute(prepareParams(parameters));
@@ -128,6 +168,7 @@ if (argv instanceof Promise) {
     });
 }
 else {
+    // Synchronously prepare parameters and execute the plot
     withError(function () {
         execute(prepareParams(argv));
     });

package/dist/tests/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cli.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var child_process_1 = require("child_process");
+describe('plotter script', function () {
+    // @ts-expect-error tests
+    var execPlotterScript = function (args, callback) {
+        (0, child_process_1.exec)("node dist/cli.js ".concat(args), callback);
+    };
+    it('should require the --input option', function (done) {
+        // @ts-expect-error tests
+        execPlotterScript('', function (error, stdout, stderr) {
+            expect(stderr).toContain('Missing required argument: input');
+            done();
+        });
+    });
+    it('should output a plot when given valid input', function (done) {
+        var validInput = JSON.stringify([
+            [1, 1],
+            [2, 2],
+            [3, 3],
+        ]);
+        // @ts-expect-error tests
+        execPlotterScript("--input '".concat(validInput, "'"), function (error, stdout, stderr) {
+            expect(error).toBeNull();
+            expect(stderr).toBe('');
+            expect(stdout).toContain("\n \u25B2    \n3\u2524 \u250F\u2501 \n2\u2524\u250F\u251B  \n1\u2524\u251B   \n \u2514\u252C\u252C\u252C\u25B6\n  123 \n");
+            done();
+        });
+    });
+    it('should handle invalid JSON input gracefully', function (done) {
+        var invalidInput = '[ invalid json';
+        // @ts-expect-error tests
+        execPlotterScript("--input '".concat(invalidInput, "'"), function (error, stdout, stderr) {
+            expect(stderr).toContain('Oops! Something went wrong!');
+            done();
+        });
+    });
+});

package/dist/tests/validators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/validators.test.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var validators_1 = require("../validators");
+describe('Utility Functions Tests', function () {
+    describe('validateAxisCenter', function () {
+        it('returns valid MaybePoint when given two numbers', function () {
+            expect((0, validators_1.validateAxisCenter)([1, 2])).toEqual([1, 2]);
+        });
+        it('returns undefined for invalid input', function () {
+            expect((0, validators_1.validateAxisCenter)([1])).toBeUndefined();
+            expect((0, validators_1.validateAxisCenter)(['a', 'b'])).toBeUndefined();
+        });
+    });
+    describe('validateColors', function () {
+        it('filters valid ANSI colors from an array', function () {
+            expect((0, validators_1.validateColors)(['ansiRed', 'ansiGreen', 'ansiBlue'])).toEqual([
+                'ansiRed',
+                'ansiGreen',
+                'ansiBlue',
+            ]);
+        });
+        it('returns undefined for unsupported color strings', function () {
+            expect((0, validators_1.validateColors)(['red', 'green'])).toBeUndefined();
+        });
+        it('returns a single ANSI color if input is a valid ANSI color string', function () {
+            expect((0, validators_1.validateColors)('ansiRed')).toEqual('ansiRed');
+        });
+    });
+    describe('validateYRange', function () {
+        it('returns a valid [number, number] tuple for valid input', function () {
+            expect((0, validators_1.validateYRange)([10, 20])).toEqual([10, 20]);
+        });
+        it('returns undefined for invalid ranges', function () {
+            expect((0, validators_1.validateYRange)([10])).toBeUndefined();
+            expect((0, validators_1.validateYRange)(['a', 'b'])).toBeUndefined();
+        });
+    });
+    describe('validateThresholds', function () {
+        it('returns a valid array of Thresholds when given correct input', function () {
+            expect((0, validators_1.validateThresholds)([{ x: 10, y: 20, color: 'ansiRed' }])).toEqual([
+                { x: 10, y: 20, color: 'ansiRed' },
+            ]);
+        });
+        it('ignores invalid items in the array', function () {
+            expect((0, validators_1.validateThresholds)([
+                { x: 10, y: 20, color: 'ansiRed' },
+                { x: 'a', y: 'b' },
+            ])).toEqual([{ x: 10, y: 20, color: 'ansiRed' }]);
+        });
+    });
+    describe('validateLegend', function () {
+        it('returns a valid Legend object for correct JSON string input', function () {
+            var legend = { position: 'top', series: ['series1'] };
+            expect((0, validators_1.validateLegend)(JSON.stringify(legend))).toEqual(legend);
+        });
+        it('returns undefined for invalid JSON or unsupported structure', function () {
+            expect((0, validators_1.validateLegend)('{"position": "middle"}')).toBeUndefined();
+        });
+    });
+    describe('validateFormatter', function () {
+        it('returns a valid Formatter function for correct string input', function () {
+            var formatterStr = '(value) => value.toFixed(2)';
+            var formatter = (0, validators_1.validateFormatter)(formatterStr);
+            expect(formatter(10.1234, {})).toBe('10.12');
+        });
+        it('returns undefined for invalid formatter strings', function () {
+            expect((0, validators_1.validateFormatter)('invalid code')).toBeUndefined();
+        });
+    });
+    describe('validateLineFormatter', function () {
+        it('returns a valid LineFormatter function for correct string input', function () {
+            var lineFormatterStr = '(args) => ({ x: args.x, y: args.y, symbol: "*" })';
+            var lineFormatter = (0, validators_1.validateLineFormatter)(lineFormatterStr);
+            expect(lineFormatter({ x: 1, y: 2, plotX: 1, plotY: 2, input: [], index: 0 })).toEqual({
+                x: 1,
+                y: 2,
+                symbol: '*',
+            });
+        });
+        it('returns undefined for invalid lineFormatter strings', function () {
+            expect((0, validators_1.validateLineFormatter)('invalid code')).toBeUndefined();
+        });
+    });
+    describe('validateSymbols', function () {
+        it('returns valid Symbols object for correct JSON string input', function () {
+            var symbols = { axis: { x: '-', y: '|' }, empty: ' ' };
+            expect((0, validators_1.validateSymbols)(JSON.stringify(symbols))).toEqual(symbols);
+        });
+        it('returns undefined for invalid JSON or unsupported structure', function () {
+            expect((0, validators_1.validateSymbols)('{"invalidKey": "-"}')).toBeUndefined();
+        });
+    });
+});

package/dist/validators.d.ts

@@ -0,0 +1,9 @@
+import { Colors, CustomSymbol, Formatter, Legend, LineFormatterArgs, MaybePoint, Symbols, Threshold } from 'simple-ascii-chart/dist/types';
+export declare const validateAxisCenter: (axisCenter: (string | number)[] | undefined) => MaybePoint;
+export declare const validateColors: (colors: (string | number)[] | string | undefined) => Colors | undefined;
+export declare const validateYRange: (yRange: (string | number)[] | undefined) => [number, number] | undefined;
+export declare const validateThresholds: (thresholds: any[] | undefined) => Threshold[] | undefined;
+export declare const validateLegend: (legend: string | undefined) => Legend | undefined;
+export declare const validateFormatter: (formatter: string | undefined) => Formatter | undefined;
+export declare const validateLineFormatter: (lineFormatter: string | undefined) => ((args: LineFormatterArgs) => CustomSymbol | CustomSymbol[]) | undefined;
+export declare const validateSymbols: (symbols: string | undefined) => Symbols | undefined;

package/dist/validators.js

@@ -0,0 +1,157 @@
+"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.validateSymbols = exports.validateLineFormatter = exports.validateFormatter = exports.validateLegend = exports.validateThresholds = exports.validateYRange = exports.validateColors = exports.validateAxisCenter = void 0;
+// Prepares parameters by parsing JSON inputs and merging with optional settings
+// Define ANSI color types for validation
+var ANSI_COLORS = new Set([
+    'ansiRed',
+    'ansiGreen',
+    'ansiBlack',
+    'ansiYellow',
+    'ansiBlue',
+    'ansiMagenta',
+    'ansiCyan',
+    'ansiWhite',
+]);
+// Type guard to check if a value is a valid ANSI color
+var isAnsiColor = function (value) { return ANSI_COLORS.has(value); };
+// Helper function to validate and format axisCenter as MaybePoint
+var validateAxisCenter = function (axisCenter) {
+    if (!axisCenter || axisCenter.length !== 2)
+        return undefined;
+    var _a = __read(axisCenter, 2), x = _a[0], y = _a[1];
+    return typeof x === 'number' && typeof y === 'number' ? [x, y] : undefined;
+};
+exports.validateAxisCenter = validateAxisCenter;
+// Helper function to validate and map colors to the Colors type
+var validateColors = function (colors) {
+    if (Array.isArray(colors)) {
+        var filteredColors = colors.filter(isAnsiColor);
+        return filteredColors.length > 0 ? filteredColors : undefined;
+    }
+    else if (typeof colors === 'string' && isAnsiColor(colors)) {
+        return colors;
+    }
+    return undefined;
+};
+exports.validateColors = validateColors;
+// Updated prepareParams function with validated colors and axisCenter handling
+// Helper function to validate and format yRange as [number, number]
+var validateYRange = function (yRange) {
+    if (Array.isArray(yRange) && yRange.length === 2) {
+        var _a = __read(yRange, 2), min = _a[0], max = _a[1];
+        // Ensure both elements are numbers
+        if (typeof min === 'number' && typeof max === 'number') {
+            return [min, max];
+        }
+    }
+    return undefined; // Return undefined if the format is incorrect
+};
+exports.validateYRange = validateYRange;
+// Helper function to validate and format thresholds as Threshold[]
+var validateThresholds = function (thresholds) {
+    if (!Array.isArray(thresholds))
+        return undefined;
+    return thresholds
+        .map(function (item) {
+        if (typeof item === 'object' && item !== null) {
+            var threshold = item;
+            var x = typeof threshold.x === 'number' ? threshold.x : undefined;
+            var y = typeof threshold.y === 'number' ? threshold.y : undefined;
+            var color = typeof threshold.color === 'string' ? threshold.color : undefined;
+            return x !== undefined || y !== undefined ? { x: x, y: y, color: color } : undefined;
+        }
+        return undefined;
+    })
+        .filter(function (threshold) { return threshold !== undefined; });
+};
+exports.validateThresholds = validateThresholds;
+// Helper function to validate and parse legend as Legend
+var validateLegend = function (legend) {
+    if (!legend)
+        return undefined;
+    try {
+        // Attempt to parse the legend string as JSON
+        var parsedLegend = JSON.parse(legend);
+        // Check if parsed legend has the correct structure for the Legend type
+        if ((typeof parsedLegend.position === 'string' &&
+            ['left', 'right', 'top', 'bottom'].includes(parsedLegend.position)) ||
+            parsedLegend.series instanceof Array) {
+            return parsedLegend;
+        }
+    }
+    catch (_a) {
+        // Ignore JSON parsing errors and return undefined
+    }
+    return undefined;
+};
+exports.validateLegend = validateLegend;
+// Helper function to parse a formatter string into a function of type Formatter
+var validateFormatter = function (formatter) {
+    if (!formatter)
+        return undefined;
+    try {
+        // Create a function from the formatter string; it should accept (value, helpers) parameters
+        // Using `new Function` to construct a function from the string (in the form "value => { ... }")
+        return new Function('value', 'helpers', "return (".concat(formatter, ")(value, helpers);"));
+    }
+    catch (_a) {
+        // Return undefined if the formatter string cannot be parsed as a function
+        return undefined;
+    }
+};
+exports.validateFormatter = validateFormatter;
+// Helper function to parse lineFormatter string into a function of type (args: LineFormatterArgs) => CustomSymbol | CustomSymbol[]
+var validateLineFormatter = function (lineFormatter) {
+    if (!lineFormatter)
+        return undefined;
+    try {
+        // Using `new Function` to construct a function from the lineFormatter string
+        return new Function('args', "return (".concat(lineFormatter, ")(args);"));
+    }
+    catch (_a) {
+        // Return undefined if the lineFormatter string cannot be parsed as a function
+        return undefined;
+    }
+};
+exports.validateLineFormatter = validateLineFormatter;
+// Helper function to parse and validate symbols as Symbols type
+var validateSymbols = function (symbols) {
+    if (!symbols)
+        return undefined;
+    try {
+        // Parse the symbols JSON string
+        var parsedSymbols = JSON.parse(symbols);
+        // Check if parsedSymbols has the correct structure
+        if (typeof parsedSymbols === 'object' &&
+            (parsedSymbols.axis ||
+                parsedSymbols.chart ||
+                parsedSymbols.empty ||
+                parsedSymbols.background ||
+                parsedSymbols.border)) {
+            return parsedSymbols;
+        }
+    }
+    catch (_a) {
+        // Return undefined if symbols string cannot be parsed
+        return undefined;
+    }
+    return undefined;
+};
+exports.validateSymbols = validateSymbols;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "simple-ascii-chart-cli",
-  "version": "1.0.0",
-  "description": "Simple ascii chart generator",
+  "version": "1.1.0",
+  "description": "Simple ascii chart generator CLI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -9,61 +9,50 @@
   },
   "scripts": {
     "start": "tsc-watch -p tsconfig.json --preserveWatchOutput -w --onSuccess 'node ./dist/index.js'",
-    "lint": "eslint . --ext .ts,.js",
-    "lint:fix": "eslint . --ext .ts,.js --fix",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "test": "jest --coverage",
     "test:watch": "jest --watch",
     "build": "tsc -p tsconfig.build.json",
     "build:watch": "tsc -p tsconfig.build.json -w",
-    "prepare": "husky install",
-    "prepublishOnly": "npm test && npm run lint",
-    "preversion": "npm run lint",
-    "version": "npm run lint && git add -A src",
-    "postversion": "git push && git push --tags"
+    "prepare": "npm test && npm run lint && npm run build"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.5",
-    "@types/node": "^20.6.4",
-    "@typescript-eslint/eslint-plugin": "^6.7.2",
-    "@typescript-eslint/parser": "^6.7.2",
-    "codecov": "^3.8.3",
-    "eslint": "^8.50.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.28.1",
-    "husky": "^8.0.3",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.8.0",
+    "@typescript-eslint/eslint-plugin": "^8.11.0",
+    "@typescript-eslint/parser": "^8.11.0",
+    "eslint": "^9.13.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-import": "^2.31.0",
     "jest": "^29.7.0",
-    "lint-staged": "^14.0.1",
-    "prettier": "^3.0.3",
-    "ts-jest": "^29.1.1",
-    "tsc-watch": "^6.0.4",
-    "typescript": "^5.2.2"
-  },
-  "lint-staged": {
-    "*.ts": "eslint . --ext .ts,.js --fix",
-    "*.{ts,md}": "prettier --write --ignore-unknown"
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "tsc-watch": "^6.2.0",
+    "typescript": "^5.6.3"
   },
   "keywords": [
     "ascii",
     "js",
     "ts",
+    "cli",
     "chart"
   ],
   "author": "gtktsc",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gtktsc/ascii-chart.git"
+    "url": "git+https://github.com/gtktsc/simple-ascii-chart-cli.git"
   },
   "bugs": {
-    "url": "https://github.com/gtktsc/ascii-chart/issues"
+    "url": "https://github.com/gtktsc/simple-ascii-chart-cli/issues"
   },
-  "homepage": "https://github.com/gtktsc/ascii-chart#readme",
+  "homepage": "https://github.com/gtktsc/simple-ascii-chart-cli#readme",
   "files": [
     "dist/**/*"
   ],
   "dependencies": {
-    "simple-ascii-chart": "^4.0.6",
+    "simple-ascii-chart": "^4.1.1",
     "yargs": "^17.7.2"
   }
 }

package/dist/constants/index.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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

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

package/dist/index.js

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