@peteanderson/ansi 0.2.0 → 0.2.1

package/dist/strip.js

@@ -1,14 +1,14 @@
 "use strict";
 const { reset } = require("./sgr");
 const rxCSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) codes.
+const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR codes (m).
 /**
  * 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.
+ * Remove all ANSI escape codes except SGR codes (m), which are used for color and styling.
  * @type {(text: string) => string}
  */
 const sanitize = text => text.replace(rxUnsafe, '');

package/package.json

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

package/src/sgr/color.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const {sgr} = require("./sgr");
+
+/** @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);
+
+/**
+ * @overload
+ * @param {number} code
+ * @param {number} open
+ * @param {number} close
+ * @returns {(text: string) => string}
+ *//**
+ * @overload
+ * @param {number} r
+ * @param {number} g
+ * @param {number} b
+ * @param {number} open
+ * @param {number} close
+ * @returns {(text: string) => string}
+ *//**
+@type {
+	(
+		...args: [number, number, number] | [number, number, number, number, number]
+	) => (text: string) => string}
+*/
+function x256(...args) {
+	if (args.length === 3)
+		return sgr([args[1], 5, args[0]], args[2]);
+
+	const [r, g, b, open, close] = args;
+	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 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),
+
+	/**
+	 * @overload
+	 * @param {number} code
+	 * @returns {(text: string) => string}
+	 *//**
+	 * @param {number} r
+	 * @param {number} g
+	 * @param {number} b
+	 * @returns {(text: string) => string}
+	 *//** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+	x256 : (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+		? x256(arg0 , 38, 39)
+		: x256(arg0, arg1, arg2, 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),
+
+	/**
+	 * @overload
+	 * @param {number} code
+	 * @returns {(text: string) => string}
+	 *//**
+	 * @param {number} r
+	 * @param {number} g
+	 * @param {number} b
+	 * @returns {(text: string) => string}
+	 *//** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+	x256 : (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+		? x256(arg0 , 48, 49)
+		: x256(arg0, arg1, arg2, 48, 49),
+};
+
+module.exports = {fg, bg};

package/src/sgr/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+	...require("./reset"),
+	...require("./style"),
+	...require("./color"),
+};

package/src/sgr/reset.js

@@ -0,0 +1,3 @@
+const reset = "\x1b[0m";
+
+module.exports = {reset};

package/src/sgr/sgr.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const $codes = Symbol();
+
+/**
+@typedef {number | number[]} Code
+@typedef {{
+	(text: string): string;
+	open     : string;
+	close    : string;
+	[$codes] : {open: Code, close: Code};
+	combine  : (...styles: SGR[]) => SGR;
+}} SGR
+*/
+
+/** @type {(code: Code, codes: Code[]) => Code} */
+function combine(code, codes, ) {
+	if (!codes.length)
+		return code;
+
+	const rtn = Array.isArray(code) ? [...code] : [code];
+
+	for (const c of codes) {
+		if (Array.isArray(c))
+			rtn.push(...c);
+		else
+			rtn.push(c);
+	}
+
+	return rtn;
+}
+
+/** @type {(code: Code) => string | number} */
+const codeSequence = code => Array.isArray(code) ? code.join(';') : code;
+
+/** @type {(open: Code, close: Code, reset?: boolean) => SGR} */
+function sgr(open, close, reset = false) {
+	const openCode       = codeSequence(open);
+	const closeCode      = codeSequence(close);
+	const openSequence   = `\x1b[${openCode}m`;
+	const closeSequence  = `\x1b[${closeCode}m`;
+	const reopenCode     = reset ? `${closeCode};${openCode}` : openCode;
+
+	const rxClose = new RegExp(
+		`(?<start>\\x1b\\[(?:\\d+;)*)${closeCode}(?<end>(?:;\\d+)*m)`,
+		"g"
+	);
+	const replace = `$<start>${reopenCode}$<end>`;
+
+	/** @type {(text: string) => string} */
+	const func = s => openSequence + s.replace(rxClose, replace) + closeSequence
+
+	return Object.assign(func, {
+		[$codes] : {open, close},
+		open     : openSequence,
+		close    : closeSequence,
+
+		/** @type {(...styles: SGR[]) => SGR} */
+		combine: (...styles) => sgr(
+			combine(open, styles.map(s => s[$codes].open)),
+			combine(close, styles.map(s => s[$codes].close)),
+		),
+	});
+}
+
+module.exports = {sgr};

package/src/sgr/style.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const {sgr} = require("./sgr");
+
+const style = {
+	bold            : sgr(1, 22, true),
+	dim             : sgr(2, 22, true),
+	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),
+};
+
+module.exports = {style};

package/src/sgr/utils.js

@@ -0,0 +1,20 @@
+/** @typedef {number | number[]} Code */
+
+/** @type {(code: Code, codes: Code[]) => Code} */
+function combine(code, codes, ) {
+	if (!codes.length)
+		return code;
+
+	const rtn = Array.isArray(code) ? [...code] : [code];
+
+	for (const c of codes) {
+		if (Array.isArray(c))
+			rtn.push(...c);
+		else
+			rtn.push(c);
+	}
+
+	return rtn;
+}
+
+module.exports = {combine};

package/src/strip.js

@@ -3,7 +3,7 @@
 const {reset} = require("./sgr");
 
 const rxCSI    = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) codes.
+const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR codes (m).
 
 /**
  * Remove all ANSI escape codes from the given text.
@@ -12,7 +12,7 @@ const rxUnsafe = /\x1b\[[0-?]*[ -/]*[@-ln-~]/g; // Everything except SGR (m) cod
 const strip = text => text.replace(rxCSI, '');
 
 /**
- * Remove all ANSI escape codes except SGR (m) codes, which are used for color and styling.
+ * Remove all ANSI escape codes except SGR codes (m), which are used for color and styling.
  * @type {(text: string) => string}
  */
 const sanitize = text => text.replace(rxUnsafe, '');

package/dist/sgr.d.ts

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

@@ -1,89 +0,0 @@
-"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/src/sgr.js

@@ -1,113 +0,0 @@
-"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};