simple-ascii-chart-cli 2.1.0 → 3.0.0

package/dist/cli.js

@@ -1,16 +1,5 @@
 #!/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);
@@ -48,22 +37,583 @@ 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 simple_ascii_chart_1 = __importDefault(require("simple-ascii-chart"));
-var validators_1 = require("./validators");
-// Define command-line arguments with yargs
-var argv = yargs
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const readline = __importStar(require("node:readline"));
+const yargs = __importStar(require("yargs"));
+const simple_ascii_chart_1 = __importDefault(require("simple-ascii-chart"));
+const options_1 = require("./options");
+const clearScreen = '\x1b[2J\x1b[H';
+class CliError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'CliError';
+    }
+}
+const fail = (message, cause) => {
+    throw new CliError(message, cause);
+};
+const parseNumber = (value) => {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+};
+const formatElapsedAxisTick = (elapsedMilliseconds) => {
+    const elapsedSeconds = Math.max(0, Math.round(elapsedMilliseconds / 1000));
+    if (elapsedSeconds < 60) {
+        return `+${elapsedSeconds}s`;
+    }
+    const minutes = Math.floor(elapsedSeconds / 60);
+    const seconds = elapsedSeconds % 60;
+    if (minutes < 60) {
+        return `+${minutes}m${seconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `+${hours}h${remainingMinutes}m`;
+};
+const inferFormatFromFilePath = (inputFile) => {
+    const extension = path.extname(inputFile).toLowerCase();
+    if (extension === '.csv')
+        return 'csv';
+    if (extension === '.tsv' || extension === '.tab')
+        return 'tsv';
+    if (extension === '.space' || extension === '.dat' || extension === '.txt')
+        return 'space';
+    return 'json';
+};
+const inferFormatFromRawInput = (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return 'json';
+    }
+    if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+        return 'json';
+    }
+    const firstLine = trimmed.split(/\r?\n/, 1)[0];
+    if (firstLine.includes('\t')) {
+        return 'tsv';
+    }
+    if (firstLine.includes(',')) {
+        return 'csv';
+    }
+    return 'space';
+};
+const getInputFormat = ({ explicit, inputFile, raw, }) => {
+    if (explicit) {
+        return explicit;
+    }
+    if (inputFile) {
+        return inferFormatFromFilePath(inputFile);
+    }
+    return inferFormatFromRawInput(raw);
+};
+const isPoint = (value) => {
+    return (Array.isArray(value) &&
+        value.length === 2 &&
+        typeof value[0] === 'number' &&
+        Number.isFinite(value[0]) &&
+        typeof value[1] === 'number' &&
+        Number.isFinite(value[1]));
+};
+const parseJsonCoordinates = (raw, sourceLabel) => {
+    let parsedUnknown;
+    try {
+        parsedUnknown = JSON.parse(raw);
+    }
+    catch (error) {
+        const details = error instanceof Error ? error.message : String(error);
+        return fail(`Invalid ${sourceLabel} JSON: ${details}`);
+    }
+    if (!Array.isArray(parsedUnknown)) {
+        fail(`Invalid ${sourceLabel}: expected an array`);
+    }
+    const parsed = parsedUnknown;
+    if (parsed.length === 0) {
+        return [];
+    }
+    if (parsed.every((item) => isPoint(item))) {
+        return parsed;
+    }
+    if (parsed.every((series) => Array.isArray(series) && series.every((item) => isPoint(item)))) {
+        return parsed;
+    }
+    return fail(`Invalid ${sourceLabel}: expected [[x,y], ...] or [[[x,y], ...], ...]`);
+};
+const splitDelimitedLine = (line, format, delimiter) => {
+    if (delimiter !== undefined) {
+        return line.split(delimiter);
+    }
+    if (format === 'csv') {
+        return line.split(',');
+    }
+    if (format === 'tsv') {
+        return line.split('\t');
+    }
+    return line.trim().split(/\s+/);
+};
+const resolveColumnIndex = ({ column, defaultIndex, axis, headerColumns, }) => {
+    if (column === undefined) {
+        return defaultIndex;
+    }
+    if (/^\d+$/.test(column)) {
+        const index = Number(column) - 1;
+        if (index < 0) {
+            fail(`--${axis}-col must be a positive 1-based index`);
+        }
+        return index;
+    }
+    if (!headerColumns) {
+        return fail(`--${axis}-col="${column}" requires --header or a numeric column index`);
+    }
+    const index = headerColumns.indexOf(column);
+    if (index === -1) {
+        fail(`--${axis}-col="${column}" was not found in the header row`);
+    }
+    return index;
+};
+const parseDelimitedCoordinates = ({ raw, format, delimiter, header, xCol, yCol, sourceLabel, }) => {
+    const lines = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        fail(`No data found in ${sourceLabel}`);
+    }
+    const rows = lines.map((line) => splitDelimitedLine(line, format, delimiter));
+    let startIndex = 0;
+    let headerColumns;
+    if (header) {
+        headerColumns = rows[0].map((column) => column.trim());
+        startIndex = 1;
+    }
+    const xIndex = resolveColumnIndex({
+        column: xCol,
+        defaultIndex: 0,
+        axis: 'x',
+        headerColumns,
+    });
+    const yIndex = resolveColumnIndex({
+        column: yCol,
+        defaultIndex: 1,
+        axis: 'y',
+        headerColumns,
+    });
+    const points = [];
+    for (let index = startIndex; index < rows.length; index += 1) {
+        const row = rows[index];
+        const x = parseNumber(row[xIndex] ?? '');
+        const y = parseNumber(row[yIndex] ?? '');
+        if (x !== undefined && y !== undefined) {
+            points.push([x, y]);
+        }
+    }
+    if (points.length === 0) {
+        fail(`No valid numeric points could be parsed from ${sourceLabel}`);
+    }
+    return points;
+};
+const parseCoordinatesFromRaw = ({ raw, args, sourceLabel, inputFile, }) => {
+    const format = getInputFormat({
+        explicit: args.format,
+        inputFile,
+        raw,
+    });
+    if (format === 'json') {
+        return parseJsonCoordinates(raw, sourceLabel);
+    }
+    return parseDelimitedCoordinates({
+        raw,
+        format,
+        delimiter: args.delimiter,
+        header: args.header,
+        xCol: args.xCol,
+        yCol: args.yCol,
+        sourceLabel,
+    });
+};
+const readStdinText = async () => {
+    return new Promise((resolve, reject) => {
+        let output = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            output += chunk;
+        });
+        process.stdin.on('error', reject);
+        process.stdin.on('end', () => resolve(output));
+    });
+};
+const getStaticInput = async (args) => {
+    if (args.input !== undefined) {
+        if (!args.input.trim()) {
+            fail('`--input` was provided but empty. Pass coordinate data or use --input-file/stdin.');
+        }
+        return parseCoordinatesFromRaw({
+            raw: args.input,
+            args,
+            sourceLabel: '--input',
+        });
+    }
+    if (args.inputFile) {
+        try {
+            const content = await fs.readFile(args.inputFile, 'utf8');
+            return parseCoordinatesFromRaw({
+                raw: content,
+                args,
+                sourceLabel: `file ${args.inputFile}`,
+                inputFile: args.inputFile,
+            });
+        }
+        catch (error) {
+            const details = error instanceof Error ? error.message : String(error);
+            fail(`Unable to read --input-file "${args.inputFile}": ${details}`);
+        }
+    }
+    if (!process.stdin.isTTY) {
+        const stdinContent = await readStdinText();
+        if (!stdinContent.trim()) {
+            fail('Stdin is empty. Pipe data or provide --input/--input-file.');
+        }
+        return parseCoordinatesFromRaw({
+            raw: stdinContent,
+            args,
+            sourceLabel: 'stdin',
+        });
+    }
+    return fail('Missing input. Provide --input, --input-file, or pipe data via stdin.');
+};
+const parseStreamSample = ({ line, lastAutoX, seriesCount, }) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return { nextAutoX: lastAutoX };
+    }
+    const tokens = trimmed.split(/[,\s]+/).filter(Boolean);
+    const withAutoX = seriesCount;
+    const withExplicitX = seriesCount + 1;
+    const parseValues = (startIndex) => {
+        const values = tokens
+            .slice(startIndex)
+            .map((token) => parseNumber(token))
+            .filter((value) => value !== undefined);
+        if (values.length !== seriesCount) {
+            return undefined;
+        }
+        return values;
+    };
+    const sampleMs = Date.now();
+    if (tokens.length === withAutoX) {
+        const values = parseValues(0);
+        if (!values) {
+            return { nextAutoX: lastAutoX };
+        }
+        const x = sampleMs > lastAutoX ? sampleMs : lastAutoX + 1;
+        return {
+            x,
+            values,
+            sampleMs,
+            nextAutoX: x,
+        };
+    }
+    if (tokens.length === withExplicitX) {
+        const x = parseNumber(tokens[0]);
+        const values = parseValues(1);
+        if (x === undefined || !values) {
+            return { nextAutoX: lastAutoX };
+        }
+        return {
+            x,
+            values,
+            sampleMs,
+            nextAutoX: x > lastAutoX ? x : lastAutoX,
+        };
+    }
+    return { nextAutoX: lastAutoX };
+};
+const executeStatic = ({ input, options, plotOutput, }) => {
+    const output = (0, simple_ascii_chart_1.default)(input, options);
+    const stream = plotOutput === 'stderr' ? process.stderr : process.stdout;
+    stream.write(output);
+};
+const executeStream = ({ options, plotOutput, refreshMs, seriesCount, rateEnabled, window, passthrough, }) => {
+    const plotStream = plotOutput === 'stderr' ? process.stderr : process.stdout;
+    const seriesPoints = Array.from({ length: seriesCount }, () => []);
+    let nextAutoX = Date.now();
+    let streamStartX;
+    let previousRateSample;
+    let lastRenderAt = 0;
+    let hasPendingRender = false;
+    let renderTimer;
+    let isFinished = false;
+    const streamOptions = {
+        ...(options ?? {}),
+    };
+    if (seriesCount === 2 && streamOptions.color === undefined) {
+        streamOptions.color = ['ansiCyan', 'ansiYellow'];
+    }
+    if (!streamOptions.formatter) {
+        streamOptions.formatter = (value, helpers) => {
+            if (helpers.axis === 'x') {
+                const startX = streamStartX ?? value;
+                return formatElapsedAxisTick(value - startX);
+            }
+            return value;
+        };
+    }
+    const render = () => {
+        if (seriesPoints[0].length === 0) {
+            return;
+        }
+        const renderOptions = {
+            ...streamOptions,
+        };
+        if (options?.width === undefined) {
+            const columns = plotStream.columns ?? process.stdout.columns ?? 80;
+            renderOptions.width = Math.max(10, columns - 8);
+        }
+        const coordinates = (seriesCount === 1 ? seriesPoints[0] : seriesPoints);
+        const output = (0, simple_ascii_chart_1.default)(coordinates, renderOptions);
+        plotStream.write(`${clearScreen}${output}`);
+        lastRenderAt = Date.now();
+    };
+    const scheduleRender = (force = false) => {
+        if (force) {
+            if (renderTimer) {
+                clearTimeout(renderTimer);
+                renderTimer = undefined;
+            }
+            hasPendingRender = false;
+            render();
+            return;
+        }
+        if (refreshMs <= 0) {
+            render();
+            return;
+        }
+        const now = Date.now();
+        const elapsed = now - lastRenderAt;
+        if (elapsed >= refreshMs) {
+            render();
+            return;
+        }
+        hasPendingRender = true;
+        if (!renderTimer) {
+            renderTimer = setTimeout(() => {
+                renderTimer = undefined;
+                if (hasPendingRender) {
+                    hasPendingRender = false;
+                    render();
+                }
+            }, refreshMs - elapsed);
+        }
+    };
+    const addSample = (sample) => {
+        if (streamStartX === undefined) {
+            streamStartX = sample.x;
+        }
+        let values = sample.values;
+        if (rateEnabled) {
+            if (!previousRateSample) {
+                previousRateSample = {
+                    sampleMs: sample.sampleMs,
+                    values: sample.values,
+                };
+                return;
+            }
+            const deltaSeconds = (sample.sampleMs - previousRateSample.sampleMs) / 1000;
+            const previousValues = previousRateSample.values;
+            previousRateSample = {
+                sampleMs: sample.sampleMs,
+                values: sample.values,
+            };
+            if (deltaSeconds <= 0) {
+                return;
+            }
+            values = sample.values.map((value, index) => (value - previousValues[index]) / deltaSeconds);
+        }
+        for (let index = 0; index < seriesCount; index += 1) {
+            seriesPoints[index].push([sample.x, values[index]]);
+            if (seriesPoints[index].length > window) {
+                seriesPoints[index].splice(0, seriesPoints[index].length - window);
+            }
+        }
+        scheduleRender(false);
+    };
+    const finish = () => {
+        if (isFinished) {
+            return;
+        }
+        isFinished = true;
+        if (renderTimer) {
+            clearTimeout(renderTimer);
+            renderTimer = undefined;
+        }
+        process.off('SIGWINCH', onResize);
+        process.off('SIGINT', onSigInt);
+        if (hasPendingRender || seriesPoints[0].length > 0) {
+            scheduleRender(true);
+        }
+        plotStream.write('\n');
+        process.exit(0);
+    };
+    const onResize = () => {
+        scheduleRender(true);
+    };
+    const stream = readline.createInterface({
+        input: process.stdin,
+        crlfDelay: Infinity,
+        terminal: false,
+    });
+    const onSigInt = () => {
+        stream.close();
+        finish();
+    };
+    process.on('SIGWINCH', onResize);
+    process.on('SIGINT', onSigInt);
+    stream.on('line', (line) => {
+        if (passthrough) {
+            process.stdout.write(`${line}\n`);
+        }
+        const parsed = parseStreamSample({
+            line,
+            lastAutoX: nextAutoX,
+            seriesCount,
+        });
+        nextAutoX = parsed.nextAutoX;
+        if ('x' in parsed) {
+            addSample(parsed);
+        }
+    });
+    stream.on('close', finish);
+};
+const reportError = (error, verbose) => {
+    const primaryMessage = error instanceof CliError
+        ? error.message
+        : error instanceof Error
+            ? error.message
+            : `Unexpected error: ${String(error)}`;
+    process.stderr.write(`${primaryMessage}\n`);
+    if (verbose) {
+        if (error instanceof CliError && error.cause instanceof Error && error.cause.stack) {
+            process.stderr.write(`${error.cause.stack}\n`);
+        }
+        else if (error instanceof Error && error.stack) {
+            process.stderr.write(`${error.stack}\n`);
+        }
+    }
+    process.exit(1);
+};
+const run = async (argumentsInput) => {
+    if (argumentsInput.passthrough && !argumentsInput.stream) {
+        fail('--passthrough is only supported with --stream mode');
+    }
+    if (argumentsInput.rate && !argumentsInput.stream) {
+        fail('--rate is only supported with --stream mode');
+    }
+    const warnings = [];
+    const parsedOptions = (0, options_1.preparePlotOptions)({
+        ...argumentsInput,
+        mode: argumentsInput.mode,
+        onWarning: (message) => warnings.push(message),
+    });
+    warnings.forEach((message) => {
+        process.stderr.write(`Warning: ${message}\n`);
+    });
+    const plotOutput = (argumentsInput.plotOutput ??
+        (argumentsInput.passthrough ? 'stderr' : 'stdout'));
+    if (argumentsInput.stream) {
+        executeStream({
+            options: parsedOptions,
+            plotOutput,
+            refreshMs: argumentsInput.refreshMs ?? 200,
+            seriesCount: argumentsInput.series ?? 1,
+            rateEnabled: argumentsInput.rate ?? false,
+            window: argumentsInput.window ?? 60,
+            passthrough: argumentsInput.passthrough ?? false,
+        });
+        return;
+    }
+    const input = await getStaticInput(argumentsInput);
+    executeStatic({
+        input,
+        options: parsedOptions,
+        plotOutput,
+    });
+};
+const { argv } = yargs
     .option('input', {
     alias: 'i',
     type: 'string',
-    demandOption: true,
-    description: 'Data to be plotted (in JSON format)',
+    description: 'Inline data payload. Usually JSON coordinates (for example [[1,2],[2,3]])',
+})
+    .option('inputFile', {
+    alias: ['input-file'],
+    type: 'string',
+    description: 'Read input data from a file path',
+})
+    .option('format', {
+    choices: ['json', 'csv', 'tsv', 'space'],
+    description: 'Input format for --input-file or stdin. Auto-detected when omitted',
+})
+    .option('delimiter', {
+    type: 'string',
+    description: 'Custom delimiter for delimited formats',
+})
+    .option('header', {
+    type: 'boolean',
+    default: false,
+    description: 'Treat the first row in delimited input as a header row',
+})
+    .option('xCol', {
+    alias: ['x-col'],
+    type: 'string',
+    description: 'X column selector for delimited input (1-based index or header name)',
+})
+    .option('yCol', {
+    alias: ['y-col'],
+    type: 'string',
+    description: 'Y column selector for delimited input (1-based index or header name)',
+})
+    .option('stream', {
+    type: 'boolean',
+    default: false,
+    description: 'Enable streaming mode and read newline-delimited samples from stdin',
+})
+    .option('window', {
+    type: 'number',
+    default: 60,
+    description: 'Maximum number of recent samples to keep in stream mode',
+})
+    .option('refreshMs', {
+    alias: ['refresh-ms'],
+    type: 'number',
+    default: 200,
+    description: 'Minimum render interval in milliseconds for stream mode',
+})
+    .option('rate', {
+    type: 'boolean',
+    default: false,
+    description: 'Treat stream values as counters and plot per-second rates',
+})
+    .option('series', {
+    choices: [1, 2],
+    default: 1,
+    description: 'Number of stream series to parse per line',
+})
+    .option('passthrough', {
+    type: 'boolean',
+    default: false,
+    description: 'Forward incoming stream lines to stdout while plotting',
+})
+    .option('plotOutput', {
+    alias: ['plot-output'],
+    choices: ['stdout', 'stderr'],
+    description: 'Output stream used for chart rendering',
 })
     .option('options', {
     alias: 'o',
     type: 'string',
-    description: 'Plot settings (in JSON format)',
+    description: 'Plot settings (JSON object)',
 })
     .option('height', {
     alias: 'h',
@@ -74,13 +624,14 @@ var argv = yargs
     type: 'boolean',
     description: 'Hide the x-axis if set to true',
 })
-    .option('barChart', {
-    type: 'boolean',
-    description: 'Draw bar chart if set to true',
+    .option('mode', {
+    choices: options_1.GRAPH_MODES,
+    description: 'Plot mode',
 })
-    .option('horizontalBarChart', {
+    .option('debugMode', {
+    alias: ['debug-mode'],
     type: 'boolean',
-    description: 'Draw horizontal bar chart if set to true',
+    description: 'Enable debug mode in the chart engine',
 })
     .option('hideYAxis', {
     type: 'boolean',
@@ -111,7 +662,7 @@ var argv = yargs
     .option('color', {
     alias: 'c',
     type: 'array',
-    description: 'Array of colors for plot elements',
+    description: 'Array of ANSI colors for plot elements',
 })
     .option('axisCenter', {
     type: 'array',
@@ -127,11 +678,11 @@ var argv = yargs
 })
     .option('thresholds', {
     type: 'array',
-    description: 'Array of threshold lines with optional color',
+    description: 'Threshold markers: JSON object/array string (for example \'{"y":2}\' or \'[{"y":2}]\') or tokenized JSON objects',
 })
     .option('points', {
     type: 'array',
-    description: 'Array of points with optional color',
+    description: 'Point markers: JSON object/array string (for example \'{"x":1,"y":2}\' or \'[{"x":1,"y":2}]\') or tokenized JSON objects',
 })
     .option('legend', {
     type: 'string',
@@ -148,50 +699,53 @@ var argv = yargs
     .option('symbols', {
     type: 'string',
     description: 'Custom symbols for axis, chart, and background',
-}).argv;
-// Helper function to execute code with error handling
-var withError = function (cb) {
+})
+    .option('verbose', {
+    type: 'boolean',
+    default: false,
+    description: 'Print verbose errors',
+})
+    .check((argumentsInput) => {
+    if (argumentsInput.window !== undefined &&
+        (typeof argumentsInput.window !== 'number' ||
+            !Number.isFinite(argumentsInput.window) ||
+            argumentsInput.window <= 0)) {
+        throw new Error('window must be a positive number');
+    }
+    if (argumentsInput.refreshMs !== undefined &&
+        (typeof argumentsInput.refreshMs !== 'number' ||
+            !Number.isFinite(argumentsInput.refreshMs) ||
+            argumentsInput.refreshMs < 0)) {
+        throw new Error('refreshMs must be a non-negative number');
+    }
+    if (argumentsInput.width !== undefined &&
+        (typeof argumentsInput.width !== 'number' ||
+            !Number.isFinite(argumentsInput.width) ||
+            argumentsInput.width <= 0)) {
+        throw new Error('width must be a positive number');
+    }
+    if (argumentsInput.height !== undefined &&
+        (typeof argumentsInput.height !== 'number' ||
+            !Number.isFinite(argumentsInput.height) ||
+            argumentsInput.height <= 0)) {
+        throw new Error('height must be a positive number');
+    }
+    return true;
+});
+const runMain = async (parsedArguments) => {
+    const args = parsedArguments;
     try {
-        cb();
+        await run(args);
     }
     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 () {
-        // 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); // 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, yRange = _a.yRange, showTickLabel = _a.showTickLabel, thresholds = _a.thresholds, points = _a.points, legend = _a.legend, formatter = _a.formatter, lineFormatter = _a.lineFormatter, symbols = _a.symbols, barChart = _a.barChart, horizontalBarChart = _a.horizontalBarChart;
-    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, barChart: barChart, horizontalBarChart: horizontalBarChart, 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), points: (0, validators_1.validatePoints)(points), legend: (0, validators_1.validateLegend)(legend), formatter: (0, validators_1.validateFormatter)(formatter), lineFormatter: (0, validators_1.validateLineFormatter)(lineFormatter), symbols: (0, validators_1.validateSymbols)(symbols) }),
-    };
+        reportError(error, args.verbose ?? false);
+    }
 };
-// 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));
-        });
+    argv.then((parsedArguments) => {
+        runMain(parsedArguments);
     });
 }
 else {
-    // Synchronously prepare parameters and execute the plot
-    withError(function () {
-        execute(prepareParams(argv));
-    });
+    runMain(argv);
 }