@peteanderson/ansi 0.3.3 → 1.0.0

package/src/sgr/reset.js

@@ -1,3 +0,0 @@
-const makeReset = (enabled = true) => enabled ? "\x1b[0m" : "";
-
-module.exports = {makeReset};

package/src/sgr/sgr.js

@@ -1,77 +0,0 @@
-"use strict";
-
-/**
-@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 => s ? openSequence + s.replace(rxClose, replace) + closeSequence : s;
-
-	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)),
-		),
-	});
-};
-
-/** @type {SGR} */
-const disabledSGR = Object.assign(/** @type {(text: string) => string} */ s => s, {
-	codes   : {open: 0, close: 0},
-	open    : "",
-	close   : "",
-	combine : () => disabledSGR,
-});
-
-/** @type {typeof sgr} */
-const disabled = () => disabledSGR;
-
-const makeSGR = (enabled = true) => enabled ? sgr : disabled;
-
-module.exports = {makeSGR};

package/src/simplify/atom.js

@@ -1,44 +0,0 @@
-"use strict";
-
-/** @typedef {import("./types").BuildAtom} BuildAtom */
-
-/** @type {BuildAtom} */
-function buildExtendedColorAtom(attribute, codes, index) {
-	switch (codes[index + 1]) {
-		case 2:
-			if (index + 5 >= codes.length)
-				return {attribute, code: codes.slice(index), skip: codes.length - index - 1};
-			return {attribute, code: codes.slice(index, index + 5), skip: 4};
-		case 5:
-			if (index + 3 >= codes.length)
-				return {attribute, code: codes.slice(index), skip: codes.length - index - 1};
-			return {attribute, code: codes.slice(index, index + 3), skip: 2};
-		default:
-			return {attribute, code: codes.slice(index, index + 2), skip: 1};
-	}
-}
-
-/** @type {BuildAtom} */
-function buildIntensityAtom(attribute, codes, index, state) {
-	const code = codes[index];
-	if (code === 22)
-		return {attribute, code: [code]};
-
-	const current = state.get("intensity");
-	if (
-		// If there is no intensity currently in the state, then we can just set the new state.
-		!current ||
-		// If the current intensity is normal (22), then we can just set the new state.
-		// Note that while the ultimate transition may return a code sequence of `[22, 1]` or
-		// `[22, 2]`, in our state representation, the only two-code intensity is `[1, 2]`.
-		current[0] === 22 ||
-		// If the current intensity is equal to the new intensity, then return the same state.
-		current.length === 1 && current[0] === code
-	)
-		return {attribute, code: [code]};
-
-	// Otherwise, we need to set both intensity codes.
-	return {attribute, code: [1, 2]};
-}
-
-module.exports = {buildExtendedColorAtom, buildIntensityAtom};

package/src/simplify/index.js

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

package/src/simplify/state.js

@@ -1,73 +0,0 @@
-"use strict";
-
-const {lookUpAtom}                       = require("./lookup");
-const {arraysEqual, transitionIntensity} = require("./utils");
-
-/** @typedef {import("./types").Attribute}    Attribute */
-/** @typedef {import("./types").AttributeMap} AttributeMap */
-
-/** @type {Map<Attribute, number[]>} */
-const defaultCodes = new Map([
-	["intensity",    [22]],
-	["italic",       [23]],
-	["underline",    [24]],
-	["inverse",      [27]],
-	["hidden",       [28]],
-	["strikethrough",[29]],
-	["fg",           [39]],
-	["bg",           [49]],
-	["frame",        [54]],
-	["overline",     [55]],
-]);
-
-/** @type {AttributeMap} */
-class State extends Map {
-	/** @type {(codes: number[]) => number[]} */
-	update(codes) {
-		/** @type {AttributeMap} */
-		let snapshot = new Map(this);
-
-		/** @type {Set<Attribute>} */
-		const attributes = new Set();
-
-		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;
-		});
-	}
-}
-
-module.exports = {State};

package/src/strip.js

@@ -1,23 +0,0 @@
-"use strict";
-
-const {rxCSI, rxUnsafe} = require("./patterns");
-
-/**
- * Remove all ANSI escape codes from the given text.
- * @type {(text: string) => string}
- */
-const strip = text => text.replace(new RegExp(rxCSI), "");
-
-/**
- * Calculate the visible length of a string with ANSI escape codes stripped.
- * @type {(text: string) => number}
- */
-const visibleLength = text => strip(text).length;
-
-/**
- * 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(new RegExp(rxUnsafe), "");
-
-module.exports = {strip, visibleLength, sanitize};