@peteanderson/ansi 0.1.0 → 0.1.2

package/dist/sgr.d.ts

@@ -0,0 +1,205 @@
+export const reset: "\u001B[0m";
+export namespace style {
+    let bold: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let dim: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let italic: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let underline: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let inverse: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let hidden: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let strikethrough: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let doubleUnderline: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let frame: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let encircle: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let overline: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+}
+export namespace fg {
+    export let black: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let red: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let green: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let yellow: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let blue: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let magenta: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let cyan: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let white: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightBlack: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightRed: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightGreen: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightYellow: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightBlue: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightMagenta: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightCyan: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export let brightWhite: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    let _default: string;
+    export { _default as default };
+    export let rgb: (r: number, g: number, b: number) => (text: string) => string;
+    export let x256: (r: number, g: number, b: number) => (text: string) => string;
+}
+export namespace bg {
+    let black_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { black_1 as black };
+    let red_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { red_1 as red };
+    let green_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { green_1 as green };
+    let yellow_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { yellow_1 as yellow };
+    let blue_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { blue_1 as blue };
+    let magenta_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { magenta_1 as magenta };
+    let cyan_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { cyan_1 as cyan };
+    let white_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { white_1 as white };
+    let brightBlack_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightBlack_1 as brightBlack };
+    let brightRed_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightRed_1 as brightRed };
+    let brightGreen_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightGreen_1 as brightGreen };
+    let brightYellow_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightYellow_1 as brightYellow };
+    let brightBlue_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightBlue_1 as brightBlue };
+    let brightMagenta_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightMagenta_1 as brightMagenta };
+    let brightCyan_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightCyan_1 as brightCyan };
+    let brightWhite_1: ((s: string) => string) & {
+        open: string;
+        close: string;
+    };
+    export { brightWhite_1 as brightWhite };
+    let _default_1: string;
+    export { _default_1 as default };
+    let rgb_1: (r: number, g: number, b: number) => (text: string) => string;
+    export { rgb_1 as rgb };
+    let x256_1: (r: number, g: number, b: number) => (text: string) => string;
+    export { x256_1 as x256 };
+}

package/dist/sgr.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * @param {number | string} open
+ * @param {number | string} close
+ */
+function sgr(open, close) {
+    const openSequence = `\x1b[${open}m`;
+    const closeSequence = `\x1b[${close}m`;
+    return Object.assign(
+    /** @type {(text: string) => string} */
+    s => openSequence +
+        s.replaceAll(openSequence, '').replaceAll(closeSequence, openSequence) +
+        closeSequence, { open: openSequence, close: closeSequence });
+}
+/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
+const rgb = (r, g, b, open, close) => sgr(`${open};2;${r};${g};${b}`, close);
+/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
+function x256(r, g, b, open, close) {
+    if (r === g && g === b) {
+        // grayscale
+        return sgr(`${open};5;${232 + Math.floor(r * 24 / 256)}`, close);
+    }
+    // 6x6x6 color cube
+    return sgr(`${open};5;${16 +
+        Math.floor(r * 6 / 256) * 36 +
+        Math.floor(g * 6 / 256) * 6 +
+        Math.floor(b * 6 / 256)}`, close);
+}
+const reset = "\x1b[0m";
+const style = {
+    bold: sgr(1, 22),
+    dim: sgr(2, 22),
+    italic: sgr(3, 23),
+    underline: sgr(4, 24),
+    inverse: sgr(7, 27),
+    hidden: sgr(8, 28),
+    strikethrough: sgr(9, 29),
+    doubleUnderline: sgr(21, 24),
+    frame: sgr(51, 54),
+    encircle: sgr(52, 54),
+    overline: sgr(53, 55),
+};
+const fg = {
+    black: sgr(30, 39),
+    red: sgr(31, 39),
+    green: sgr(32, 39),
+    yellow: sgr(33, 39),
+    blue: sgr(34, 39),
+    magenta: sgr(35, 39),
+    cyan: sgr(36, 39),
+    white: sgr(37, 39),
+    brightBlack: sgr(90, 39),
+    brightRed: sgr(91, 39),
+    brightGreen: sgr(92, 39),
+    brightYellow: sgr(93, 39),
+    brightBlue: sgr(94, 39),
+    brightMagenta: sgr(95, 39),
+    brightCyan: sgr(96, 39),
+    brightWhite: sgr(97, 39),
+    default: "\x1b[39m",
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    rgb: (r, g, b) => rgb(r, g, b, 38, 39),
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    x256: (r, g, b) => x256(r, g, b, 38, 39),
+};
+const bg = {
+    black: sgr(40, 49),
+    red: sgr(41, 49),
+    green: sgr(42, 49),
+    yellow: sgr(43, 49),
+    blue: sgr(44, 49),
+    magenta: sgr(45, 49),
+    cyan: sgr(46, 49),
+    white: sgr(47, 49),
+    brightBlack: sgr(100, 49),
+    brightRed: sgr(101, 49),
+    brightGreen: sgr(102, 49),
+    brightYellow: sgr(103, 49),
+    brightBlue: sgr(104, 49),
+    brightMagenta: sgr(105, 49),
+    brightCyan: sgr(106, 49),
+    brightWhite: sgr(107, 49),
+    default: "\x1b[49m",
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    rgb: (r, g, b) => rgb(r, g, b, 48, 49),
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    x256: (r, g, b) => x256(r, g, b, 48, 49),
+};
+module.exports = { reset, style, fg, bg };

package/dist/strip.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Remove all ANSI escape codes from the given text.
+ * @type {(text: string) => string}
+ */
+export const strip: (text: string) => string;
+/**
+ * Remove all ANSI escape codes except SGR (m) codes, which are used for color and styling.
+ * @type {(text: string) => string}
+ */
+export const sanitize: (text: string) => string;
+export function slice(text: string, start: number, end: number): string;

package/dist/strip.js

@@ -0,0 +1,58 @@
+"use strict";
+const { reset } = require("./sgr");
+const rxCSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) codes.
+/**
+ * Remove all ANSI escape codes from the given text.
+ * @type {(text: string) => string}
+ */
+const strip = text => text.replace(rxCSI, '');
+/**
+ * Remove all ANSI escape codes except SGR (m) codes, which are used for color and styling.
+ * @type {(text: string) => string}
+ */
+const sanitize = text => text.replace(rxUnsafe, '');
+/** @type {(text: string, start: number, end: number) => string} */
+function slice(text, start, end) {
+    if (start < 0 || end < 0) {
+        const visibleLength = strip(text).length;
+        if (start < 0)
+            start = Math.max(0, visibleLength + start);
+        if (end < 0)
+            end = Math.max(0, visibleLength + end);
+    }
+    if (start > end)
+        return "";
+    let visibleIndex = 0;
+    let startIndex = 0;
+    while (startIndex < text.length && visibleIndex < start) {
+        if (text[startIndex] === "\x1b") {
+            rxCSI.lastIndex = startIndex;
+            const match = rxCSI.exec(text);
+            if (match?.index === startIndex) {
+                startIndex += match[0].length;
+                continue;
+            }
+        }
+        startIndex++;
+        visibleIndex++;
+    }
+    let endIndex = startIndex;
+    let hasAnsi = false;
+    while (endIndex < text.length && visibleIndex < end) {
+        if (text[endIndex] === "\x1b") {
+            rxCSI.lastIndex = endIndex;
+            const match = rxCSI.exec(text);
+            if (match?.index === endIndex) {
+                endIndex += match[0].length;
+                hasAnsi = true;
+                continue;
+            }
+        }
+        endIndex++;
+        visibleIndex++;
+    }
+    return text.slice(startIndex, endIndex) + (hasAnsi ? reset : "");
+}
+;
+module.exports = { strip, sanitize, slice };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name"            : "@peteanderson/ansi",
-	"version"         : "0.1.0",
+	"version"         : "0.1.2",
 	"description"     : "ANSI escape sequence generation with automatic feature detection",
 	"author"          : {
 		"name"  : "Pete Anderson",

package/src/ansi.js

@@ -1,89 +1,28 @@
 "use strict";
 
-/** @type {(r: number, g: number, b: number, code: number) => string} */
-function rgb(r, g, b, code) {
-	if (r === g && g === b) {
-		// Grayscale range.
-		if (r >= 232 && r <= 255)
-			return `\x1b[${code};5;${r}m`;
-	} else if (r >= 0 && r <= 5 && g >= 0 && g <= 5 && b >= 0 && b <= 5) {
-		// 6x6x6 color cube.
-		const code = 16 + r * 36 + g * 6 + b;
-		return `\x1b[${code};5;${code}m`;
-	}
-
-	return `\x1b[${code};2;${r};${g};${b}m`;
-}
+const {colorDepth, enabled}    = require("./caps");
+const caret                    = require("./caret");
+const erase                    = require("./erase");
+const scroll                   = require("./scroll");
+const {bg, fg, reset, style}   = require("./sgr");
+const {sanitize, slice, strip} = require("./strip");
 
 const ansi = {
-	reset     : "\x1b[0m",
-	underline : "\x1b[4m",
-	reverse   : "\x1b[7m",
-
-	fg: {
-		black   : "\x1b[30m",
-		red     : "\x1b[31m",
-		green   : "\x1b[32m",
-		yellow  : "\x1b[33m",
-		blue    : "\x1b[34m",
-		magenta : "\x1b[35m",
-		cyan    : "\x1b[36m",
-		white   : "\x1b[37m",
-
-		default : "\x1b[39m",
-
-		/** @type {(r: number, g: number, b: number) => string} */
-		rgb: (r, g, b) => rgb(r, g, b, 38),
-	},
-
-	bg: {
-		black   : "\x1b[40m",
-		red     : "\x1b[41m",
-		green   : "\x1b[42m",
-		yellow  : "\x1b[43m",
-		blue    : "\x1b[44m",
-		magenta : "\x1b[45m",
-		cyan    : "\x1b[46m",
-		white   : "\x1b[47m",
-
-		default : "\x1b[49m",
-
-		/** @type {(r: number, g: number, b: number) => string} */
-		rgb: (r, g, b) => rgb(r, g, b, 48),
-	},
-
-	erase: {
-		toLineStart : "\x1b[1K",
-		toLineEnd   : "\x1b[0K",
-		line        : "\x1b[2K",
-		screen      : "\x1b[2J",
-	},
-
-	caret: {
-		hide : "\x1b[?25l",
-		show : "\x1b[?25h",
+	colorDepth,
+	enabled,
 
-		position: {
-			get: "\x1b[6n",
-			/** @type {(x: number, y: number) => string} */
-			set: (x, y) => `\x1b[${y + 1};${x + 1}H`,
-		},
+	caret,
+	erase,
+	scroll,
 
-		shape: {
-			steadyBlock       : "\x1b[2 q",
-			steadyBar         : "\x1b[6 q",
-			steadyUnderline   : "\x1b[4 q",
-			blinkingBlock     : "\x1b[1 q",
-			blinkingBar       : "\x1b[5 q",
-			blinkingUnderline : "\x1b[3 q",
-			default           : "\x1b[0 q",
-		},
-	},
+	reset,
+	style,
+	fg,
+	bg,
 
-	/** @type {(lines: number) => string} */
-	scrollUp   : lines => `\x1b[${lines}S`,
-	/** @type {(lines: number) => string} */
-	scrollDown : lines => `\x1b[${lines}T`,
+	strip,
+	sanitize,
+	slice,
 };
 
 module.exports = ansi;

package/src/caps.js

@@ -0,0 +1,27 @@
+"use strict";
+
+/** @type {(stream: NodeJS.WriteStream) => number} */
+const getColorDepth = (stream) =>
+	stream.isTTY ?
+		stream.getColorDepth() :
+	process.env.FORCE_COLOR !== undefined ?
+		["1", "true", ""].includes(process.env.FORCE_COLOR) ?
+			4 :
+		process.env.FORCE_COLOR === "2" ?
+			8 :
+		process.env.FORCE_COLOR === "3" ?
+			24 :
+		1 :
+	1;
+
+const colorDepth = {
+	stdout: getColorDepth(process.stdout),
+	stderr: getColorDepth(process.stderr),
+};
+
+const enabled = {
+	stdout: colorDepth.stdout > 1,
+	stderr: colorDepth.stderr > 1,
+};
+
+module.exports = {colorDepth, enabled};

package/src/caret.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/** @type {(code: string) => (count?: number) => string} */
+const move = code =>
+	count => `\x1b[${count === undefined ? "" : count ? count : "?"}${code}`;
+
+const caret = {
+	up       : move("A"),
+	down     : move("B"),
+	forward  : move("C"),
+	backward : move("D"),
+	nextLine : move("E"),
+	prevLine : move("F"),
+
+	/** @type {(x: number) => string} */
+	x: x => `\x1b[${x}G`,
+
+	// These are the old VT100 codes, but they're widely supported by old and new terminals. The
+	// newer VT220 codes are standardized by ECMA and ISO, and are also widely supported, but might
+	// not work in some older terminals. The VT220 codes are:
+	//
+	// ```
+	// save    : "\x1b[s",
+	// restore : "\x1b[u",
+	// ```
+	save    : "\x1b7",
+	restore : "\x1b8",
+
+	hide : "\x1b[?25l",
+	show : "\x1b[?25h",
+
+	position: {
+		get: "\x1b[6n",
+		/** @type {(x: number, y: number) => string} */
+		set: (x, y) => `\x1b[${y};${x}H`,
+	},
+
+	shape: {
+		steadyBlock       : "\x1b[2 q",
+		steadyBar         : "\x1b[6 q",
+		steadyUnderline   : "\x1b[4 q",
+		blinkingBlock     : "\x1b[1 q",
+		blinkingBar       : "\x1b[5 q",
+		blinkingUnderline : "\x1b[3 q",
+		default           : "\x1b[0 q",
+	},
+};
+
+module.exports = caret;

package/src/erase.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const erase = {
+	line: {
+		toStart: "\x1b[1K",
+		toEnd  : "\x1b[0K",
+		full   : "\x1b[2K",
+	},
+	screen: {
+		toStart    : "\x1b[1J",
+		toEnd      : "\x1b[0J",
+		full       : "\x1b[2J",
+		scrollback : "\x1b[3J",
+	},
+};
+
+module.exports = erase;

package/src/index.js

@@ -0,0 +1 @@
+module.exports = require("./ansi");

package/src/scroll.js

@@ -0,0 +1,10 @@
+"use strict";
+
+const scroll = {
+	/** @type {(lines?: number) => string} */
+	up   : lines => `\x1b[${lines ?? 1}S`,
+	/** @type {(lines?: number) => string} */
+	down : lines => `\x1b[${lines ?? 1}T`,
+};
+
+module.exports = scroll;