pipechart 1.0.0

package/lib/render/spark.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// Sparkline renderer — single-line inline chart using Unicode block chars
+
+var ansi = require('../ansi');
+var scale = require('../scale');
+
+// Unicode block elements from lowest to highest
+var SPARKS = [
+  '\u2581', // ▁  1/8
+  '\u2582', // ▂  2/8
+  '\u2583', // ▃  3/8
+  '\u2584', // ▄  4/8
+  '\u2585', // ▅  5/8
+  '\u2586', // ▆  6/8
+  '\u2587', // ▇  7/8
+  '\u2588'  // █  8/8
+];
+
+/**
+ * Convert a single normalized value [0,1] to a spark character.
+ * @param {number} normalized — value in [0, 1]
+ * @returns {string}
+ */
+function toSparkChar(normalized) {
+  var idx = Math.round(normalized * (SPARKS.length - 1));
+  if (idx < 0) idx = 0;
+  if (idx >= SPARKS.length) idx = SPARKS.length - 1;
+  return SPARKS[idx];
+}
+
+/**
+ * Render a sparkline.
+ *
+ * @param {object} opts
+ * @param {number[]}  opts.values   — data values
+ * @param {number}    opts.width    — max terminal width (chars)
+ * @param {string}    [opts.color]  — ANSI color name
+ * @param {string}    [opts.title]  — optional title prefix
+ * @returns {string}  — single line (or title + line)
+ */
+function render(opts) {
+  var values = opts.values || [];
+  var width  = opts.width  || 80;
+  var color  = opts.color  || 'green';
+  var title  = opts.title  || null;
+
+  if (values.length === 0) {
+    return ansi.colorize('(no data)', 'dim');
+  }
+
+  var minVal = scale.min(values);
+  var maxVal = scale.max(values);
+
+  // If we have more values than width, downsample by averaging buckets
+  var displayValues = values;
+  if (values.length > width) {
+    displayValues = downsample(values, width);
+  }
+
+  var spark = '';
+  for (var i = 0; i < displayValues.length; i++) {
+    var norm = scale.normalize(displayValues[i], minVal, maxVal);
+    spark += toSparkChar(norm);
+  }
+
+  var colored = ansi.colorize(spark, color);
+
+  var minStr = ansi.dim(scale.formatNum(minVal));
+  var maxStr = ansi.dim(scale.formatNum(maxVal));
+
+  var lines = [];
+  if (title) {
+    lines.push(ansi.bold(ansi.colorize(title, color)));
+  }
+  lines.push(colored + '  ' + minStr + ' \u2013 ' + maxStr);
+
+  return lines.join('\n');
+}
+
+/**
+ * Downsample an array to targetLen by averaging buckets.
+ * @param {number[]} values
+ * @param {number} targetLen
+ * @returns {number[]}
+ */
+function downsample(values, targetLen) {
+  var result = [];
+  var bucketSize = values.length / targetLen;
+  for (var i = 0; i < targetLen; i++) {
+    var start = Math.floor(i * bucketSize);
+    var end   = Math.floor((i + 1) * bucketSize);
+    if (end > values.length) end = values.length;
+    var sum = 0;
+    for (var j = start; j < end; j++) sum += values[j];
+    result.push(sum / (end - start));
+  }
+  return result;
+}
+
+module.exports = { render: render, toSparkChar: toSparkChar, downsample: downsample };

package/lib/scale.js

@@ -0,0 +1,185 @@
+'use strict';
+
+// Normalization and scaling math helpers
+
+/**
+ * Find the minimum value in an array of numbers.
+ * @param {number[]} values
+ * @returns {number}
+ */
+function min(values) {
+  var m = Infinity;
+  for (var i = 0; i < values.length; i++) {
+    if (values[i] < m) m = values[i];
+  }
+  return m;
+}
+
+/**
+ * Find the maximum value in an array of numbers.
+ * @param {number[]} values
+ * @returns {number}
+ */
+function max(values) {
+  var m = -Infinity;
+  for (var i = 0; i < values.length; i++) {
+    if (values[i] > m) m = values[i];
+  }
+  return m;
+}
+
+/**
+ * Normalize a value from [minVal, maxVal] to [0, 1].
+ * Returns 0 if minVal === maxVal (flat line).
+ * @param {number} value
+ * @param {number} minVal
+ * @param {number} maxVal
+ * @returns {number}
+ */
+function normalize(value, minVal, maxVal) {
+  if (maxVal === minVal) return 0;
+  return (value - minVal) / (maxVal - minVal);
+}
+
+/**
+ * Scale a normalized value [0,1] to [0, range].
+ * @param {number} normalized  — value in [0, 1]
+ * @param {number} range       — target integer range (e.g. terminal width)
+ * @returns {number}           — integer in [0, range]
+ */
+function scaleToRange(normalized, range) {
+  return Math.round(normalized * range);
+}
+
+/**
+ * Map a value from [minVal, maxVal] directly to [0, range].
+ * @param {number} value
+ * @param {number} minVal
+ * @param {number} maxVal
+ * @param {number} range
+ * @returns {number}
+ */
+function mapToRange(value, minVal, maxVal, range) {
+  return scaleToRange(normalize(value, minVal, maxVal), range);
+}
+
+/**
+ * Compute a "nice" tick step for axis labels.
+ * @param {number} range   — the data range (max - min)
+ * @param {number} ticks   — desired number of ticks
+ * @returns {number}
+ */
+function niceStep(range, ticks) {
+  if (range === 0) return 1;
+  var rawStep = range / ticks;
+  var magnitude = Math.pow(10, Math.floor(Math.log(rawStep) / Math.LN10));
+  var normalized = rawStep / magnitude;
+  var nice;
+  if (normalized < 1.5) nice = 1;
+  else if (normalized < 3) nice = 2;
+  else if (normalized < 7) nice = 5;
+  else nice = 10;
+  return nice * magnitude;
+}
+
+/**
+ * Format a number for axis display — trim unnecessary decimals.
+ * @param {number} value
+ * @param {number} [decimals=2]
+ * @returns {string}
+ */
+function formatNum(value, decimals) {
+  if (decimals === undefined) decimals = 2;
+  if (Number.isInteger(value)) return String(value);
+  var s = value.toFixed(decimals);
+  // Remove trailing zeros after decimal point
+  s = s.replace(/\.?0+$/, '');
+  return s;
+}
+
+/**
+ * Auto-bin an array of numbers into `binCount` histogram bins.
+ * Returns an array of { min, max, count } objects.
+ * @param {number[]} values
+ * @param {number} binCount
+ * @returns {Array<{min: number, max: number, count: number}>}
+ */
+function autoBin(values, binCount) {
+  if (!values || values.length === 0) return [];
+  var minVal = min(values);
+  var maxVal = max(values);
+  if (minVal === maxVal) {
+    return [{ min: minVal, max: maxVal, count: values.length }];
+  }
+  var binWidth = (maxVal - minVal) / binCount;
+  var bins = [];
+  for (var i = 0; i < binCount; i++) {
+    bins.push({
+      min: minVal + i * binWidth,
+      max: minVal + (i + 1) * binWidth,
+      count: 0
+    });
+  }
+  for (var j = 0; j < values.length; j++) {
+    var v = values[j];
+    var idx = Math.floor((v - minVal) / binWidth);
+    // Clamp last value into last bin
+    if (idx >= binCount) idx = binCount - 1;
+    bins[idx].count++;
+  }
+  return bins;
+}
+
+/**
+ * Pad a string on the left to a given width.
+ * @param {string} s
+ * @param {number} width
+ * @param {string} [char=' ']
+ * @returns {string}
+ */
+function padLeft(s, width, char) {
+  if (char === undefined) char = ' ';
+  s = String(s);
+  while (s.length < width) s = char + s;
+  return s;
+}
+
+/**
+ * Pad a string on the right to a given width.
+ * @param {string} s
+ * @param {number} width
+ * @param {string} [char=' ']
+ * @returns {string}
+ */
+function padRight(s, width, char) {
+  if (char === undefined) char = ' ';
+  s = String(s);
+  while (s.length < width) s = s + char;
+  return s;
+}
+
+/**
+ * Truncate a string to maxLen, appending '…' if truncated.
+ * @param {string} s
+ * @param {number} maxLen
+ * @returns {string}
+ */
+function truncate(s, maxLen) {
+  s = String(s);
+  if (s.length <= maxLen) return s;
+  return s.slice(0, maxLen - 1) + '\u2026';
+}
+
+module.exports = {
+  min: min,
+  max: max,
+  normalize: normalize,
+  scaleToRange: scaleToRange,
+  mapToRange: mapToRange,
+  niceStep: niceStep,
+  formatNum: formatNum,
+  autoBin: autoBin,
+  padLeft: padLeft,
+  padRight: padRight,
+  truncate: truncate
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "pipechart",
+  "version": "1.0.0",
+  "description": "Zero-dependency CLI tool that pipes JSON to real-time ASCII charts in the terminal",
+  "main": "bin/pipechart.js",
+  "bin": {
+    "pipechart": "./bin/pipechart.js"
+  },
+  "scripts": {
+    "start": "node bin/termviz.js"
+  },
+  "keywords": [
+    "cli",
+    "chart",
+    "ascii",
+    "terminal",
+    "json",
+    "visualization",
+    "sparkline",
+    "histogram",
+    "bar-chart",
+    "line-chart",
+    "ansi"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {},
+  "engines": {
+    "node": ">=12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/pipechart.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/pipechart/issues"
+  },
+  "homepage": "https://github.com/yourusername/pipechart#readme"
+}