simple-ascii-chart-cli 2.2.0 → 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { default as plot } from 'simple-ascii-chart';
+export * from 'simple-ascii-chart';

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plot = void 0;
+var simple_ascii_chart_1 = require("simple-ascii-chart");
+Object.defineProperty(exports, "plot", { enumerable: true, get: function () { return __importDefault(simple_ascii_chart_1).default; } });
+__exportStar(require("simple-ascii-chart"), exports);

package/dist/options.d.ts

@@ -0,0 +1,28 @@
+import { Settings } from 'simple-ascii-chart';
+export declare const GRAPH_MODES: readonly ["line", "point", "bar", "horizontalBar"];
+export type CliGraphMode = (typeof GRAPH_MODES)[number];
+export type CliSettingsInput = {
+    options?: string;
+    title?: string;
+    xLabel?: string;
+    yLabel?: string;
+    width?: number;
+    height?: number;
+    fillArea?: boolean;
+    hideYAxis?: boolean;
+    hideXAxis?: boolean;
+    color?: (string | number)[] | string;
+    axisCenter?: (string | number)[];
+    yRange?: (string | number)[];
+    showTickLabel?: boolean;
+    thresholds?: unknown;
+    points?: unknown;
+    legend?: string;
+    formatter?: string;
+    lineFormatter?: string;
+    symbols?: string;
+    mode?: CliGraphMode;
+    debugMode?: boolean;
+    onWarning?: (message: string) => void;
+};
+export declare const preparePlotOptions: ({ options, width, height, hideYAxis, hideXAxis, fillArea, title, xLabel, yLabel, color, axisCenter, yRange, showTickLabel, thresholds, points, legend, formatter, lineFormatter, symbols, mode, debugMode, onWarning, }: CliSettingsInput) => Settings;

package/dist/options.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePlotOptions = exports.GRAPH_MODES = void 0;
+const validators_1 = require("./validators");
+exports.GRAPH_MODES = ['line', 'point', 'bar', 'horizontalBar'];
+const preparePlotOptions = ({ options, width, height, hideYAxis, hideXAxis, fillArea, title, xLabel, yLabel, color, axisCenter, yRange, showTickLabel, thresholds, points, legend, formatter, lineFormatter, symbols, mode, debugMode, onWarning, }) => {
+    let currentOptions = {};
+    if (options) {
+        try {
+            currentOptions = JSON.parse(options);
+        }
+        catch (error) {
+            const details = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid --options JSON: ${details}`);
+        }
+    }
+    const mergedOptions = {
+        ...currentOptions,
+    };
+    const assignIfDefined = (key, value) => {
+        if (value !== undefined) {
+            mergedOptions[key] = value;
+        }
+    };
+    assignIfDefined('width', width);
+    assignIfDefined('height', height);
+    assignIfDefined('hideYAxis', hideYAxis);
+    assignIfDefined('hideXAxis', hideXAxis);
+    assignIfDefined('title', title);
+    assignIfDefined('xLabel', xLabel);
+    assignIfDefined('yLabel', yLabel);
+    assignIfDefined('fillArea', fillArea);
+    assignIfDefined('mode', mode);
+    assignIfDefined('debugMode', debugMode);
+    assignIfDefined('color', color ? (0, validators_1.validateColors)(color) : undefined);
+    assignIfDefined('axisCenter', (0, validators_1.validateAxisCenter)(axisCenter));
+    assignIfDefined('yRange', (0, validators_1.validateYRange)(yRange));
+    assignIfDefined('showTickLabel', showTickLabel);
+    const parsedThresholds = (0, validators_1.validateThresholds)(thresholds);
+    if (thresholds !== undefined && parsedThresholds === undefined && onWarning) {
+        onWarning('Ignoring invalid --thresholds payload. Use JSON object/array (e.g. {"y":2} or [{"y":2}]).');
+    }
+    assignIfDefined('thresholds', parsedThresholds);
+    const parsedPoints = (0, validators_1.validatePoints)(points);
+    if (points !== undefined && parsedPoints === undefined && onWarning) {
+        onWarning('Ignoring invalid --points payload. Use JSON object/array (e.g. {"x":1,"y":2} or [{"x":1,"y":2}]).');
+    }
+    assignIfDefined('points', parsedPoints);
+    const parsedLegend = (0, validators_1.validateLegend)(legend);
+    if (legend !== undefined && parsedLegend === undefined) {
+        throw new Error('Invalid --legend JSON: expected an object with optional position (left|right|top|bottom) and string/string[] labels for series/points/thresholds');
+    }
+    assignIfDefined('legend', parsedLegend);
+    assignIfDefined('formatter', (0, validators_1.validateFormatter)(formatter));
+    assignIfDefined('lineFormatter', (0, validators_1.validateLineFormatter)(lineFormatter));
+    assignIfDefined('symbols', (0, validators_1.validateSymbols)(symbols));
+    return mergedOptions;
+};
+exports.preparePlotOptions = preparePlotOptions;

package/dist/validators.d.ts

@@ -2,8 +2,8 @@ import { Colors, CustomSymbol, Formatter, GraphPoint, Legend, LineFormatterArgs,
 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 validatePoints: (points: any[] | undefined) => GraphPoint[] | undefined;
+export declare const validateThresholds: (thresholds: unknown) => Threshold[] | undefined;
+export declare const validatePoints: (points: unknown) => GraphPoint[] | 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;

package/dist/validators.js

@@ -1,25 +1,9 @@
 "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.validatePoints = 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([
+const ANSI_COLORS = new Set([
     'ansiRed',
     'ansiGreen',
     'ansiBlack',
@@ -29,20 +13,60 @@ var ANSI_COLORS = new Set([
     'ansiCyan',
     'ansiWhite',
 ]);
+const LEGEND_POSITIONS = new Set(['left', 'right', 'top', 'bottom']);
 // Type guard to check if a value is a valid ANSI color
-var isAnsiColor = function (value) { return ANSI_COLORS.has(value); };
+const isAnsiColor = (value) => ANSI_COLORS.has(value);
+const toFiniteNumber = (value) => {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value.trim());
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+};
+const parseJsonFragment = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isStringOrStringArray = (value) => {
+    return typeof value === 'string' || (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+};
+const collectObjectCandidates = (value) => {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectObjectCandidates(item));
+    }
+    if (typeof value === 'string') {
+        const parsed = parseJsonFragment(value.trim());
+        return parsed === undefined ? [] : collectObjectCandidates(parsed);
+    }
+    if (typeof value === 'object') {
+        return [value];
+    }
+    return [];
+};
 // Helper function to validate and format axisCenter as MaybePoint
-var validateAxisCenter = function (axisCenter) {
+const validateAxisCenter = (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;
+    const [x, y] = axisCenter;
+    const xNumber = toFiniteNumber(x);
+    const yNumber = toFiniteNumber(y);
+    return xNumber !== undefined && yNumber !== undefined ? [xNumber, yNumber] : undefined;
 };
 exports.validateAxisCenter = validateAxisCenter;
 // Helper function to validate and map colors to the Colors type
-var validateColors = function (colors) {
+const validateColors = (colors) => {
     if (Array.isArray(colors)) {
-        var filteredColors = colors.filter(isAnsiColor);
+        const filteredColors = colors.filter(isAnsiColor);
         return filteredColors.length > 0 ? filteredColors : undefined;
     }
     else if (typeof colors === 'string' && isAnsiColor(colors)) {
@@ -53,123 +77,179 @@ var validateColors = function (colors) {
 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) {
+const validateYRange = (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];
+        const [min, max] = yRange;
+        const minNumber = toFiniteNumber(min);
+        const maxNumber = toFiniteNumber(max);
+        if (minNumber !== undefined && maxNumber !== undefined) {
+            return [minNumber, maxNumber];
         }
     }
     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;
+const validateThresholds = (thresholds) => {
+    const candidates = collectObjectCandidates(thresholds);
+    const validated = candidates
+        .map((item) => {
+        const threshold = item;
+        const x = toFiniteNumber(threshold.x);
+        const y = toFiniteNumber(threshold.y);
+        const color = typeof threshold.color === 'string' ? threshold.color : undefined;
+        return x !== undefined || y !== undefined ? { x, y, color } : undefined;
     })
-        .filter(function (threshold) { return threshold !== undefined; });
+        .filter((threshold) => threshold !== undefined);
+    return validated.length > 0 ? validated : undefined;
 };
 exports.validateThresholds = validateThresholds;
 // Helper function to validate and format thresholds as Threshold[]
-var validatePoints = function (points) {
-    if (!Array.isArray(points))
-        return undefined;
-    return points
-        .map(function (item) {
-        if (typeof item === 'object' && item !== null) {
-            var point = item;
-            var x = point.x;
-            var y = point.y;
-            var color = typeof point.color === 'string' ? point.color : undefined;
-            return x !== undefined && y !== undefined ? { x: x, y: y, color: color } : undefined;
-        }
-        return undefined;
+const validatePoints = (points) => {
+    const candidates = collectObjectCandidates(points);
+    const validated = candidates
+        .map((item) => {
+        const point = item;
+        const x = toFiniteNumber(point.x);
+        const y = toFiniteNumber(point.y);
+        const color = typeof point.color === 'string' ? point.color : undefined;
+        return x !== undefined && y !== undefined ? { x, y, color } : undefined;
     })
-        .filter(function (point) { return point !== undefined; });
+        .filter((point) => point !== undefined);
+    return validated.length > 0 ? validated : undefined;
 };
 exports.validatePoints = validatePoints;
 // Helper function to validate and parse legend as Legend
-var validateLegend = function (legend) {
+const validateLegend = (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;
+        const parsedLegend = JSON.parse(legend);
+        if (typeof parsedLegend !== 'object' || parsedLegend === null || Array.isArray(parsedLegend)) {
+            return undefined;
+        }
+        const candidate = parsedLegend;
+        const normalized = {};
+        if (candidate.position !== undefined) {
+            if (typeof candidate.position !== 'string' || !LEGEND_POSITIONS.has(candidate.position)) {
+                return undefined;
+            }
+            normalized.position = candidate.position;
+        }
+        if (candidate.series !== undefined) {
+            if (!isStringOrStringArray(candidate.series)) {
+                return undefined;
+            }
+            normalized.series = candidate.series;
+        }
+        if (candidate.points !== undefined) {
+            if (!isStringOrStringArray(candidate.points)) {
+                return undefined;
+            }
+            normalized.points = candidate.points;
         }
+        if (candidate.thresholds !== undefined) {
+            if (!isStringOrStringArray(candidate.thresholds)) {
+                return undefined;
+            }
+            normalized.thresholds = candidate.thresholds;
+        }
+        return Object.keys(normalized).length > 0 ? normalized : undefined;
     }
-    catch (_a) {
+    catch {
         // 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) {
+const validateFormatter = (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);"));
+        return new Function('value', 'helpers', `return (${formatter})(value, helpers);`);
     }
-    catch (_a) {
+    catch {
         // 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) {
+const validateLineFormatter = (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);"));
+        return new Function('args', `return (${lineFormatter})(args);`);
     }
-    catch (_a) {
+    catch {
         // 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) {
+const validateSymbols = (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;
+        const parsedSymbols = JSON.parse(symbols);
+        if (typeof parsedSymbols !== 'object' || parsedSymbols === null || Array.isArray(parsedSymbols)) {
+            return undefined;
+        }
+        const candidate = parsedSymbols;
+        const normalized = {};
+        const isObjectCandidate = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+        if (candidate.axis !== undefined) {
+            if (!isObjectCandidate(candidate.axis)) {
+                return undefined;
+            }
+            normalized.axis = candidate.axis;
+        }
+        if (candidate.chart !== undefined) {
+            if (!isObjectCandidate(candidate.chart)) {
+                return undefined;
+            }
+            normalized.chart = candidate.chart;
+        }
+        if (candidate.thresholds !== undefined) {
+            if (!isObjectCandidate(candidate.thresholds)) {
+                return undefined;
+            }
+            normalized.thresholds = candidate.thresholds;
+        }
+        if (candidate.empty !== undefined) {
+            if (typeof candidate.empty !== 'string') {
+                return undefined;
+            }
+            normalized.empty = candidate.empty;
         }
+        if (candidate.background !== undefined) {
+            if (typeof candidate.background !== 'string') {
+                return undefined;
+            }
+            normalized.background = candidate.background;
+        }
+        if (candidate.border !== undefined) {
+            if (typeof candidate.border !== 'string') {
+                return undefined;
+            }
+            normalized.border = candidate.border;
+        }
+        if (candidate.point !== undefined) {
+            if (typeof candidate.point !== 'string') {
+                return undefined;
+            }
+            normalized.point = candidate.point;
+        }
+        return Object.keys(normalized).length > 0 ? normalized : undefined;
     }
-    catch (_a) {
+    catch {
         // Return undefined if symbols string cannot be parsed
         return undefined;
     }
-    return undefined;
 };
 exports.validateSymbols = validateSymbols;

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "simple-ascii-chart-cli",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Simple ascii chart generator CLI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "simple-ascii-chart": "dist/cli.js"
+    "simple-ascii-chart": "dist/cli.js",
+    "simple-ascii-chart-cli": "dist/cli.js"
   },
   "scripts": {
-    "start": "tsc-watch -p tsconfig.json --preserveWatchOutput -w --onSuccess 'node ./dist/index.js'",
+    "start": "tsc-watch -p tsconfig.json --preserveWatchOutput -w --onSuccess 'node ./dist/cli.js --help'",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "test": "jest --coverage",
     "test:watch": "jest --watch",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
     "build:watch": "tsc -p tsconfig.build.json -w",
     "prepare": "npm run lint && npm run build && npm test"
   },

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

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

package/dist/tests/cli.test.js

@@ -1,39 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var child_process_1 = require("child_process");
-var path_1 = __importDefault(require("path"));
-var cliPath = path_1.default.resolve(__dirname, '../../dist/cli.js'); // <-- LOCAL build output
-function execPlotterScript(args, callback) {
-    (0, child_process_1.exec)("node ".concat(cliPath, " ").concat(args), callback);
-}
-describe('plotter script', function () {
-    it('should require the --input option', function (done) {
-        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],
-        ]);
-        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';
-        execPlotterScript("--input '".concat(invalidInput, "'"), function (error, stdout, stderr) {
-            expect(stderr).toContain('Oops! Something went wrong!');
-            done();
-        });
-    });
-});

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

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

package/dist/tests/validators.test.js

@@ -1,105 +0,0 @@
-"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,
-                minX: 0,
-                minY: 0,
-                expansionX: [0, 0],
-                expansionY: [0, 0],
-                toPlotCoordinates: function () { return [0, 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();
-        });
-    });
-});