@peteanderson/ansi 0.3.3 → 1.0.1

package/src/sgr/color/{utils.js → utils.ts}

@@ -1,7 +1,4 @@
-/** @typedef {import("../sgr").Code} Code */
-
-/** @type {(r: number, g: number, b: number) => number} */
-function rgbToX256(r, g, b) {
+export function rgbToX256(r: number, g: number, b: number): number {
 	if (r === g && g === b) {
 		// grayscale
 		return 232 + Math.floor(r * 24 / 256);
@@ -16,8 +13,7 @@ function rgbToX256(r, g, b) {
 	);
 }
 
-/** @type {(code: number) => [number, number, number]} */
-function x256ToRgb(code) {
+export function x256ToRgb(code: number): [number, number, number] {
 	if (code >= 232) {
 		// grayscale
 		const gray = Math.round((code - 232) * 255 / 24);
@@ -31,10 +27,8 @@ function x256ToRgb(code) {
 	return [r, g, b];
 }
 
-/** @type {(r: number, g: number, b: number) => number} */
-function rgbToX16(r, g, b) {
+export function rgbToX16(r: number, g: number, b: number): number {
 	// First calculate it as a 4x4x4 cube.
-
 	r = Math.min(2, Math.floor(r / 85));
 	g = Math.min(2, Math.floor(g / 85));
 	b = Math.min(2, Math.floor(b / 85));
@@ -51,8 +45,7 @@ function rgbToX16(r, g, b) {
 	return index + (bright ? 60 : 0);
 }
 
-/** @type {(r: number, g: number, b: number) => number} */
-function rgbToX8(r, g, b) {
+export function rgbToX8(r: number, g: number, b: number): number {
 	r = r >= 128 ? 1 : 0;
 	g = g >= 128 ? 1 : 0;
 	b = b >= 128 ? 1 : 0;
@@ -60,22 +53,16 @@ function rgbToX8(r, g, b) {
 	return (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
 }
 
-/**
- * @overload
- * @param   {number} x
- * @returns {number}
- * @overload
- * @param   {number} r
- * @param   {number} g
- * @param   {number} b
- * @returns {[number, number, number]}
- *//** @param {[number] | [number, number, number]} args */
-const clip = (...args) => args.length === 1 ?
-	Math.max(0, Math.min(255, Math.floor(args[0]))) :
-	[
-		Math.max(0, Math.min(255, Math.floor(args[0]))),
-		Math.max(0, Math.min(255, Math.floor(args[1]))),
-		Math.max(0, Math.min(255, Math.floor(args[2]))),
-	];
-
-module.exports = {rgbToX256, x256ToRgb, rgbToX16, rgbToX8, clip};
+export function clip(x: number): number;
+export function clip(r: number, g: number, b: number): [number, number, number];
+export function clip(
+	...args: [number] | [number, number, number]
+): number | [number, number, number] {
+	return args.length === 1 ?
+		Math.max(0, Math.min(255, Math.floor(args[0]))) :
+		[
+			Math.max(0, Math.min(255, Math.floor(args[0]))),
+			Math.max(0, Math.min(255, Math.floor(args[1]))),
+			Math.max(0, Math.min(255, Math.floor(args[2]))),
+		];
+}

package/src/sgr/index.ts

@@ -0,0 +1,3 @@
+export * from "./reset";
+export * from "./style";
+export * from "./color";

package/src/sgr/reset.ts

@@ -0,0 +1 @@
+export const makeReset = (enabled = true): string => enabled ? "\x1b[0m" : "";

package/src/sgr/sgr.ts

@@ -0,0 +1,65 @@
+export type Code = number | number[];
+
+export interface SGR {
+	(text: string): string;
+	open    : string;
+	close   : string;
+	codes   : {open: Code; close: Code};
+	combine : (...styles: SGR[]) => SGR;
+}
+
+function combine(code: Code, codes: Code[]): Code {
+	if (!codes.length)
+		return code;
+
+	const set = new Set(Array.isArray(code) ? [...code] : [code]);
+
+	for (const c of codes) {
+		if (Array.isArray(c)) {
+			for (const code of c)
+				set.add(code);
+		} else
+			set.add(c);
+	}
+
+	return Array.from(set);
+}
+
+const codeSequence = (code: Code): string | number => Array.isArray(code) ? code.join(";") : code;
+
+function sgr(open: Code, close: Code, reset = false): SGR {
+	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>`;
+
+	const func = (s: string) => s ? openSequence + s.replace(rxClose, replace) + closeSequence : s;
+
+	return Object.assign(func, {
+		codes   : {open, close},
+		open    : openSequence,
+		close   : closeSequence,
+		combine : (...styles: SGR[]) => sgr(
+			combine(open, styles.map(s => s.codes.open)),
+			combine(close, styles.map(s => s.codes.close)),
+		),
+	});
+}
+
+const disabledSGR: SGR = Object.assign((s: string) => s, {
+	codes   : {open: 0, close: 0},
+	open    : "",
+	close   : "",
+	combine : (): SGR => disabledSGR,
+});
+
+const disabled: typeof sgr = () => disabledSGR;
+
+export const makeSGR = (enabled = true): typeof sgr => enabled ? sgr : disabled;

package/src/sgr/{style.js → style.ts}

@@ -1,8 +1,6 @@
-"use strict";
+import {makeSGR} from "./sgr";
 
-const {makeSGR} = require("./sgr");
-
-function makeStyle(enabled = true) {
+export function makeStyle(enabled = true) {
 	const sgr = makeSGR(enabled);
 
 	return {
@@ -20,4 +18,4 @@ function makeStyle(enabled = true) {
 	};
 }
 
-module.exports = {makeStyle};
+export type Style = ReturnType<typeof makeStyle>;

package/src/sgr/{utils.js → utils.ts}

@@ -1,7 +1,6 @@
-/** @typedef {number | number[]} Code */
+import type {Code} from "./sgr";
 
-/** @type {(code: Code, codes: Code[]) => Code} */
-function combine(code, codes, ) {
+export function combine(code: Code, codes: Code[]): Code {
 	if (!codes.length)
 		return code;
 
@@ -15,6 +14,4 @@ function combine(code, codes, ) {
 	}
 
 	return rtn;
-}
-
-module.exports = {combine};
+}

package/src/simplify/{atom.js → atom.ts}

@@ -1,9 +1,6 @@
-"use strict";
+import type {BuildAtom} from "./types";
 
-/** @typedef {import("./types").BuildAtom} BuildAtom */
-
-/** @type {BuildAtom} */
-function buildExtendedColorAtom(attribute, codes, index) {
+export const buildExtendedColorAtom: BuildAtom = (attribute, codes, index) => {
 	switch (codes[index + 1]) {
 		case 2:
 			if (index + 5 >= codes.length)
@@ -16,10 +13,9 @@ function buildExtendedColorAtom(attribute, codes, index) {
 		default:
 			return {attribute, code: codes.slice(index, index + 2), skip: 1};
 	}
-}
+};
 
-/** @type {BuildAtom} */
-function buildIntensityAtom(attribute, codes, index, state) {
+export const buildIntensityAtom: BuildAtom = (attribute, codes, index, state) => {
 	const code = codes[index];
 	if (code === 22)
 		return {attribute, code: [code]};
@@ -39,6 +35,4 @@ function buildIntensityAtom(attribute, codes, index, state) {
 
 	// Otherwise, we need to set both intensity codes.
 	return {attribute, code: [1, 2]};
-}
-
-module.exports = {buildExtendedColorAtom, buildIntensityAtom};
+};

package/src/simplify/index.ts

@@ -0,0 +1 @@
+export * from "./simplify";

package/src/simplify/{lookup.js → lookup.ts}

@@ -1,14 +1,8 @@
-"use strict";
+import {buildExtendedColorAtom, buildIntensityAtom} from "./atom";
 
-const {buildExtendedColorAtom, buildIntensityAtom} = require("./atom");
+import type {Atom, Attribute, AttributeMap, BuildAtom} from "./types";
 
-/** @typedef {import("./types").Atom}         Atom */
-/** @typedef {import("./types").Attribute}    Attribute */
-/** @typedef {import("./types").AttributeMap} AttributeMap */
-/** @typedef {import("./types").BuildAtom}    BuildAtom */
-
-/** @type {Record<number, [attribute: Attribute, buildAtom?: BuildAtom]>} */
-const codeMap = {
+const codeMap: Record<number, [attribute: Attribute, buildAtom?: BuildAtom]> = {
 	0   : ["reset"],
 	1   : ["intensity", buildIntensityAtom],
 	2   : ["intensity", buildIntensityAtom],
@@ -67,8 +61,7 @@ const codeMap = {
 	107 : ["bg"],
 };
 
-/** @type {(codes: number[], index: number, state: AttributeMap) => Atom} */
-function lookUpAtom(codes, index, state) {
+export function lookUpAtom(codes: number[], index: number, state: AttributeMap): Atom {
 	const code  = codes[index];
 	const entry = codeMap[code];
 
@@ -81,6 +74,4 @@ function lookUpAtom(codes, index, state) {
 		return buildAtom(attribute, codes, index, state);
 
 	return {attribute, code: [code]};
-}
-
-module.exports = {lookUpAtom};
+}

package/src/simplify/{simplify.js → simplify.ts}

@@ -1,10 +1,7 @@
-"use strict";
+import {rxSGR} from "../patterns";
+import {State} from "./state";
 
-const {rxSGR} = require("../patterns");
-const {State} = require("./state");
-
-/** @type {(text: string) => string} */
-function simplify(text) {
+export function simplify(text: string): string {
 	// `.split` doesn't modify `lastIndex`, so no clone is necessary here.
 	const parts = text.split(rxSGR);
 
@@ -16,7 +13,6 @@ function simplify(text) {
 		let chunk = parts[i++];
 
 		while (!chunk && i < parts.length) {
-			// Merge consecutive SGR sequences.
 			codes.push(...parts[i++].split(";").map(Number));
 			chunk = parts[i++];
 		}
@@ -28,6 +24,4 @@ function simplify(text) {
 	}
 
 	return result;
-}
-
-module.exports = {simplify};
+}

package/src/simplify/state.ts

@@ -0,0 +1,63 @@
+import {lookUpAtom}                       from "./lookup";
+import {arraysEqual, transitionIntensity} from "./utils";
+
+import type {Attribute, AttributeMap} from "./types";
+
+const defaultCodes: Map<Attribute, number[]> = new Map([
+	["intensity",     [22]],
+	["italic",        [23]],
+	["underline",     [24]],
+	["inverse",       [27]],
+	["hidden",        [28]],
+	["strikethrough", [29]],
+	["fg",            [39]],
+	["bg",            [49]],
+	["frame",         [54]],
+	["overline",      [55]],
+]);
+
+export class State extends Map<Attribute, number[]> implements AttributeMap {
+	update(codes: number[]): number[] {
+		let snapshot: AttributeMap = new Map(this);
+
+		const attributes = new Set<Attribute>();
+
+		for (let i = 0; i < codes.length; i++) {
+			const {attribute, code, skip} = lookUpAtom(codes, i, this);
+
+			if (attribute === "reset") {
+				attributes.clear();
+				this.clear();
+				attributes.add("reset");
+				for (const [attr, defaultCode] of defaultCodes)
+					this.set(attr, defaultCode);
+
+				snapshot = new Map(this);
+				continue;
+			}
+
+			attributes.add(attribute);
+			this.set(attribute, code);
+
+			if (skip)
+				i += skip;
+		}
+
+		return Array.from(attributes).flatMap(attribute => {
+			if (attribute === "reset")
+				return [0];
+
+			const code = this.get(attribute)!;
+
+			if (arraysEqual(code, snapshot.get(attribute)))
+				return [];
+
+			if (attribute === "intensity") {
+				const previous = snapshot.get(attribute);
+				return transitionIntensity(previous, code);
+			}
+
+			return code;
+		});
+	}
+}

package/src/simplify/{types.d.ts → types.ts}

@@ -12,7 +12,7 @@ export type Attribute =
 	| "reset"
 	| number;
 
-type AttributeMap = Map<Attribute, number[]>;
+export type AttributeMap = Map<Attribute, number[]>;
 
 export interface Atom {
 	attribute : Attribute;
@@ -21,8 +21,8 @@ export interface Atom {
 }
 
 export type BuildAtom = (
-	attribute: Attribute,
-	codes    : number[],
-	index    : number,
-	state    : AttributeMap,
+	attribute : Attribute,
+	codes     : number[],
+	index     : number,
+	state     : AttributeMap,
 ) => Atom;

package/src/simplify/{utils.js → utils.ts}

@@ -1,7 +1,4 @@
-"use strict";
-
-/** @type {<T>(a: T[] | undefined, b: T[] | undefined) => boolean} */
-function arraysEqual(a, b) {
+export function arraysEqual<T>(a: T[] | undefined, b: T[] | undefined): boolean {
 	if (a === b)
 		return true;
 
@@ -16,8 +13,7 @@ function arraysEqual(a, b) {
 	return true;
 }
 
-/** @type {(previous: number[] | undefined, current: number[]) => number[]} */
-function transitionIntensity(previous, current) {
+export function transitionIntensity(previous: number[] | undefined, current: number[]): number[] {
 	if (!previous || previous[0] === 22 || current[0] === 22)
 		return current;
 
@@ -26,7 +22,7 @@ function transitionIntensity(previous, current) {
 	const oldDim  = previous[previous.length - 1] === 2;
 	const newDim  = current[current.length - 1] === 2;
 
-	const result = [];
+	const result: number[] = [];
 
 	if (oldBold && !newBold || oldDim && !newDim)
 		result.push(22);
@@ -36,6 +32,4 @@ function transitionIntensity(previous, current) {
 		result.push(2);
 
 	return result;
-}
-
-module.exports = {arraysEqual, transitionIntensity};
+}

package/src/{slice.js → slice.ts}

@@ -1,19 +1,12 @@
-"use strict";
+import {rxCSI, rxSGR}  from "./patterns";
+import {simplify}      from "./simplify";
+import {visibleLength} from "./strip";
 
-const {rxCSI, rxSGR}  = require("./patterns");
-const {simplify}      = require("./simplify");
-const {visibleLength} = require("./strip");
-
-/**
-@type {
-	(
-		text            : string,
-		fromStringIndex : number,
-		visibleCount    : number,
-	) => {index: number, length: number}
-}
-*/
-function scanCSI(text, fromStringIndex, visibleCount) {
+function scanCSI(
+	text            : string,
+	fromStringIndex : number,
+	visibleCount    : number,
+): {index: number; length: number} {
 	// We intentionally mutate `lastIndex` here, so we need a clone.
 	const rx = new RegExp(rxCSI);
 
@@ -37,8 +30,7 @@ function scanCSI(text, fromStringIndex, visibleCount) {
 	return {index, length};
 }
 
-/** @type {(text: string, start: number, end?: number) => string} */
-function skippedSequences(text, start, end) {
+function skippedSequences(text: string, start: number, end?: number): string {
 	const sequences = text.slice(start, end).match(new RegExp(rxSGR));
 	return sequences ? simplify(sequences.join("")) : "";
 }
@@ -61,12 +53,9 @@ function skippedSequences(text, start, end) {
  * length of the slice, and that the terminal state may not be exactly the same at the start and end
  * of the slice as it would be if the whole string were printed. This function is intended mostly
  * for text that contains SGR codes, but no other ANSI codes or control characters.
- *
- * @type {(text: string, start: number, end: number) => string}
  */
-function slice(text, start, end) {
-	/** @type {number | undefined} */
-	let textVisibleLength;
+export function slice(text: string, start: number, end: number): string {
+	let textVisibleLength: number | undefined;
 	const getVisibleLength = () => textVisibleLength ??= visibleLength(text);
 
 	if (start < 0 || end < 0) {
@@ -94,6 +83,4 @@ function slice(text, start, end) {
 	const trailingSequences = skippedSequences(text, endIndex);
 
 	return leadingSequences + text.slice(startIndex, endIndex) + trailingSequences;
-}
-
-module.exports = {slice};
+}

package/src/strip.ts

@@ -0,0 +1,10 @@
+import {rxCSI, rxUnsafe} from "./patterns";
+
+/** Remove all ANSI escape codes from the given text. */
+export const strip         = (text: string): string => text.replace(new RegExp(rxCSI), "");
+
+/** Calculate the visible length of a string with ANSI escape codes stripped. */
+export const visibleLength = (text: string): number => strip(text).length;
+
+/** Remove all ANSI escape codes except SGR codes (m), which are used for color and styling. */
+export const sanitize      = (text: string): string => text.replace(new RegExp(rxUnsafe), "");

package/src/{terminal.js → terminal.ts}

@@ -1,5 +1,3 @@
-"use strict";
-
 const terminal = {
 	focusReporting: {
 		enable  : "\x1b[?1004h",
@@ -26,8 +24,9 @@ const terminal = {
 	},
 };
 
-/** @type {typeof terminal} */
-const disabled = {
+export type Terminal = typeof terminal;
+
+const disabled: Terminal = {
 	focusReporting: {
 		enable  : "",
 		disable : "",
@@ -53,6 +52,4 @@ const disabled = {
 	},
 };
 
-const makeTerminal = (enabled = true) => enabled ? terminal : disabled;
-
-module.exports = {makeTerminal};
+export const makeTerminal = (enabled = true): Terminal => enabled ? terminal : disabled;

package/src/ansi.js

@@ -1,70 +0,0 @@
-"use strict";
-
-const {makeCaret}                       = require("./caret");
-const {makeErase}                       = require("./erase");
-const {getFeatures}                     = require("./features");
-const {padEnd, padStart}                = require("./pad");
-const {makeScroll}                      = require("./scroll");
-const {makeColor, makeReset, makeStyle} = require("./sgr");
-const {simplify}                        = require("./simplify");
-const {slice}                           = require("./slice");
-const {sanitize, strip, visibleLength}  = require("./strip");
-const {makeTerminal}                    = require("./terminal");
-
-/**
-@typedef {import("./features/features").Args} Args
-
-@typedef {ReturnType<typeof makeColor> & {
-	caret  : ReturnType<typeof makeCaret>;
-	erase  : ReturnType<typeof makeErase>;
-	scroll : ReturnType<typeof makeScroll>;
-
-	reset : string;
-	style : ReturnType<typeof makeStyle>;
-
-	terminal : ReturnType<typeof makeTerminal>;
-
-	padEnd   : typeof padEnd;
-	padStart : typeof padStart;
-
-	strip         : typeof strip;
-	visibleLength : typeof visibleLength;
-	sanitize      : typeof sanitize;
-	slice         : typeof slice;
-	simplify      : typeof simplify;
-
-	features : ReturnType<typeof getFeatures>;
-}} Ansi
-*/
-
-/** @type {(...args: Args) => Ansi}*/
-function makeAnsi(...args) {
-	const features = getFeatures(...args);
-
-	return {
-		caret  : makeCaret(features.caret),
-		erase  : makeErase(features.erase),
-		scroll : makeScroll(features.scroll),
-
-		reset : makeReset(features.colorDepth > 1),
-		style : makeStyle(features.style),
-		...makeColor(features.colorDepth),
-
-		terminal: makeTerminal(features.terminal),
-
-		padEnd,
-		padStart,
-
-		strip,
-		visibleLength,
-		sanitize,
-		slice,
-		simplify,
-
-		features,
-	};
-}
-
-const ansi = Object.assign(makeAnsi, makeAnsi());
-
-module.exports = ansi;

package/src/features/build.js

@@ -1,68 +0,0 @@
-"use strict";
-
-const {getColorDepth, detectFeatureSupport} = require("./detect");
-
-/** @typedef {import("./types").ColorDepth} ColorDepth */
-/** @typedef {import("./types").Features}   Features */
-
-/** @type {(colorDepth: number) => ColorDepth} */
-function normalizeColorDepth(colorDepth) {
-	colorDepth = Math.floor(colorDepth);
-	if (colorDepth >= 24)
-		return 24;
-	if (colorDepth >= 8)
-		return 8;
-	if (colorDepth >= 4)
-		return 4;
-	if (colorDepth === 3)
-		return 3;
-	return 1;
-}
-
-/**
-@type {
-	(
-		isTTY      : boolean,
-		colorDepth : ColorDepth,
-		style?     : boolean,
-		caret?     : boolean,
-		erase?     : boolean,
-		scroll?    : boolean,
-		terminal?  : boolean,
-	) => Features
-}
-*/
-function build(isTTY, colorDepth, style, caret, erase, scroll, terminal) {
-	if (
-		style    !== undefined &&
-		caret    !== undefined &&
-		erase    !== undefined &&
-		scroll   !== undefined &&
-		terminal !== undefined
-	)
-		return {colorDepth: normalizeColorDepth(colorDepth), style, caret, erase, scroll, terminal};
-
-	const support = detectFeatureSupport(isTTY, colorDepth);
-	return {
-		colorDepth : normalizeColorDepth(colorDepth),
-		style      : style    ?? support.style,
-		caret      : caret    ?? support.caret,
-		erase      : erase    ?? support.erase,
-		scroll     : scroll   ?? support.scroll,
-		terminal   : terminal ?? support.terminal,
-	};
-}
-
-/** @type {(isTTY: boolean, enabled: boolean) => Features} */
-const boolean = (isTTY, enabled) => build(isTTY, enabled ? 4 : 1);
-
-/** @type {(isTTY: boolean, colorDepth: ColorDepth) => Features} */
-const number = (isTTY, colorDepth) => build(isTTY, colorDepth);
-
-/** @type {(stream: NodeJS.WriteStream) => Features} */
-const tty = stream => build(true, getColorDepth(stream));
-
-/** @type {() => Features} */
-const pipe = () => build(false, getColorDepth());
-
-module.exports = {build, boolean, number, tty, pipe};