@peteanderson/ansi 1.0.1 → 2.0.1

package/src/ansi.ts

@@ -3,54 +3,25 @@ import {makeErase}                       from "./erase";
 import {getFeatures}                     from "./features";
 import {padEnd, padStart}                from "./pad";
 import {makeScroll}                      from "./scroll";
-import {makeColor, makeReset, makeStyle} from "./sgr";
+import {makeSGR}                         from "./sgr";
 import {simplify}                        from "./simplify";
 import {slice}                           from "./slice";
 import {sanitize, strip, visibleLength}  from "./strip";
 import {makeTerminal}                    from "./terminal";
 
-import type {Args}         from "./features/features";
-import type {Caret}        from "./caret";
-import type {Erase}        from "./erase";
-import type {Features}     from "./features/types";
-import type {Scroll}       from "./scroll";
-import type {Color, Style} from "./sgr";
-import type {Terminal}     from "./terminal";
+import type {Args} from "./features";
+import type {Ansi} from "./types";
 
-export type Ansi = Color & {
-	caret  : Caret;
-	erase  : Erase;
-	scroll : Scroll;
-
-	reset : string;
-	style : Style;
-
-	terminal : Terminal;
-
-	padEnd   : typeof padEnd;
-	padStart : typeof padStart;
-
-	strip         : typeof strip;
-	visibleLength : typeof visibleLength;
-	sanitize      : typeof sanitize;
-	slice         : typeof slice;
-	simplify      : typeof simplify;
-
-	features : Features;
-};
-
-export function makeAnsi(...args: Args): Ansi {
+function makeAnsi(...args: Args): Ansi {
 	const features = getFeatures(...args);
 
 	return {
+		...makeSGR(features),
+
 		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,
@@ -66,6 +37,10 @@ export function makeAnsi(...args: Args): Ansi {
 	};
 }
 
-const ansi = Object.assign(makeAnsi, makeAnsi());
+export const ansi = Object.assign(makeAnsi, makeAnsi());
+
+export const {fg, bg, style, reset, caret, erase, scroll, terminal} = ansi;
+
+export {padEnd, padStart, strip, visibleLength}
 
 export default ansi;

package/src/features/features.ts

@@ -3,14 +3,7 @@ import {WriteStream}                       from "node:tty";
 import {boolean, build, number, pipe, tty} from "./build";
 import {getColorDepth}                     from "./detect";
 
-import type {ColorDepth, Features} from "./types";
-
-export type Args =
-	| [enabled    : boolean,           stream?: NodeJS.WriteStream]
-	| [colorDepth : ColorDepth,        stream?: NodeJS.WriteStream]
-	| [features   : Partial<Features>, stream?: NodeJS.WriteStream]
-	| [socket     : Socket]
-	| [stream?    : NodeJS.WriteStream];
+import type {Args, Features} from "./types";
 
 export function getFeatures(...args: Args): Features {
 	let [features, stream] = args;
@@ -35,7 +28,7 @@ export function getFeatures(...args: Args): Features {
 	stream ??= process.stdout;
 
 	if (colorDepth)
-		build(stream.isTTY, colorDepth, style, caret, erase, scroll, terminal);
+		return build(stream.isTTY, colorDepth, style, caret, erase, scroll, terminal);
 
 	if (stream.isTTY)
 		return build(true, getColorDepth(stream), style, caret, erase, scroll, terminal);

package/src/features/index.ts

@@ -1 +1,3 @@
-export * from "./features";
+export * from "./features";
+
+export type * from "./types";

package/src/features/types.ts

@@ -1,3 +1,5 @@
+import type {Socket} from "node:net";
+
 export type ColorDepth = 1 | 3 | 4 | 8 | 24;
 
 export interface Features {
@@ -7,4 +9,11 @@ export interface Features {
 	erase      : boolean;
 	scroll     : boolean;
 	terminal   : boolean;
-}
+}
+
+export type Args =
+	| [enabled    : boolean,           stream?: NodeJS.WriteStream]
+	| [colorDepth : ColorDepth,        stream?: NodeJS.WriteStream]
+	| [features   : Partial<Features>, stream?: NodeJS.WriteStream]
+	| [socket     : Socket]
+	| [stream?    : NodeJS.WriteStream];

package/src/pad.ts

@@ -12,4 +12,7 @@ export const padEnd = (text: string, targetLength: number, fillString = " "): st
  * without counting ANSI escape codes.
  */
 export const padStart = (text: string, targetLength: number, fillString = " "): string =>
-	fillString.repeat(Math.max(0, targetLength - visibleLength(text)) / fillString.length) + text;
+	fillString.repeat(Math.max(0, targetLength - visibleLength(text)) / fillString.length) + text;
+
+export type PadEnd   = typeof padEnd;
+export type PadStart = typeof padStart;

package/src/sgr/color/channel.ts

@@ -0,0 +1,44 @@
+import {lazy}              from "../lazy";
+import {buildContext}      from "./context";
+import {makeRGB, makeX256} from "./rgb";
+
+import type {ColorDepth}                                        from "../../features";
+import type {ChainKey, Channel, ColorKey, FormatBuilder, Style} from "../types";
+
+const colors = [
+	"black",
+	"red",
+	"green",
+	"yellow",
+	"blue",
+	"magenta",
+	"cyan",
+	"white",
+] as const;
+
+export function makeChannel(
+	keys          : ReadonlySet<ChainKey>,
+	makeFormatter : FormatBuilder,
+	style         : Style,
+	colorDepth    : ColorDepth,
+	channel       : ColorKey,
+): Channel {
+	const ctx = buildContext(keys, makeFormatter, style, colorDepth, channel);
+	const {build, bright, open, close} = ctx;
+
+	const rtn = {
+		rgb     : makeRGB(ctx),
+		x256    : makeX256(ctx),
+		default : colorDepth > 1 ? `\x1b[${close}m` : "",
+	} as Channel;
+
+	for (let i = 0; i < colors.length; i++) {
+		const color       = colors[i];
+		const brightColor = `bright${color[0].toUpperCase()}${color.slice(1)}`;
+
+		lazy.add(rtn, color,       () => build(open + i));
+		lazy.add(rtn, brightColor, () => bright(i));
+	}
+
+	return rtn;
+}

package/src/sgr/color/color.ts

@@ -1,95 +1,30 @@
-import {makeSGR}                                       from "../sgr";
-import {makeStyle}                                     from "../style";
-import {clip, rgbToX16, rgbToX256, rgbToX8, x256ToRgb} from "./utils";
-
-import type {ColorDepth}     from "../../features/types";
-import type {SGR}            from "../sgr";
-import type {Channel, Color} from "./types";
-
-export type {Color} from "./types";
-
-const fgOpen = 30, fgClose = 39;
-const bgOpen = 40, bgClose = 49;
-
-function makeChannel(colorDepth: ColorDepth, open: number, close: number): Channel {
-	const sgrBase = makeSGR(colorDepth > 1);
-	const style   = makeStyle(colorDepth > 1);
-
-	const sgr = (code: number | number[]): SGR => sgrBase(code, close);
-
-	const bright: (index: number) => SGR =
-		colorDepth >= 4 ? index => sgr(open + 60 + index) :
-		colorDepth === 3 ?
-			open === fgOpen ?
-				index => style.bold.combine(sgr(open + index)) :
-				index => sgr(open + index) :
-		() => sgr(0);
-
-	const x16ToX8: (code: number) => SGR =
-		open === fgOpen ?
-			code => code >= 60 ? style.bold.combine(sgr(open + code - 60)) : sgr(open + code) :
-			code => code >= 60 ? sgr(open + code - 60)                     : sgr(open + code);
-
-	return {
-		black   : sgr(open + 0),
-		red     : sgr(open + 1),
-		green   : sgr(open + 2),
-		yellow  : sgr(open + 3),
-		blue    : sgr(open + 4),
-		magenta : sgr(open + 5),
-		cyan    : sgr(open + 6),
-		white   : sgr(open + 7),
-
-		brightBlack   : bright(0),
-		brightRed     : bright(1),
-		brightGreen   : bright(2),
-		brightYellow  : bright(3),
-		brightBlue    : bright(4),
-		brightMagenta : bright(5),
-		brightCyan    : bright(6),
-		brightWhite   : bright(7),
-
-		rgb:
-			colorDepth >= 24 ? (r, g, b) => sgr([open + 8, 2, ...clip(r, g, b)]) :
-			colorDepth >=  8 ? (r, g, b) => sgr([open + 8, 5, rgbToX256(...clip(r, g, b))]) :
-			colorDepth >=  4 ? (r, g, b) => sgr(open + rgbToX16(...clip(r, g, b))) :
-			colorDepth === 3 ?
-				open === fgOpen ?
-					(r, g, b) => x16ToX8(rgbToX16(...clip(r, g, b))) :
-					(r, g, b) => sgr(open + rgbToX8(...clip(r, g, b))) :
-			() => sgr(0),
-
-		x256:
-			colorDepth >= 8 ?
-				(...args: [number] | [number, number, number]): SGR => sgr(
-					[open + 8, 5, args.length === 3 ? rgbToX256(...clip(...args)) : clip(args[0])],
-				) :
-			colorDepth >= 4 ?
-				(...args: [number] | [number, number, number]): SGR => sgr(
-					open +
-					rgbToX16(...(args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])))),
-				) :
-			colorDepth === 3 ?
-				open === fgOpen ?
-					(...args: [number] | [number, number, number]): SGR => x16ToX8(
-						args.length === 3
-							? rgbToX16(...clip(...args))
-							: rgbToX16(...x256ToRgb(clip(args[0]))),
-					) :
-					(...args: [number] | [number, number, number]): SGR => sgr(
-						open +
-						rgbToX8(...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0]))),
-					) :
-			(): SGR => sgr(0),
-
-		default: colorDepth > 1 ? `\x1b[${close}m` : "",
-	};
-}
-
-const cache: Partial<Record<ColorDepth, Color>> = {};
-
-export const makeColor = (colorDepth: ColorDepth = 4): Color =>
-	cache[colorDepth] ?? (cache[colorDepth] = {
-		fg : makeChannel(colorDepth, fgOpen, fgClose),
-		bg : makeChannel(colorDepth, bgOpen, bgClose),
-	});
+"use strict";
+
+import {lazy}        from "../lazy";
+import {makeChannel} from "./channel";
+
+import type {ColorDepth}                            from "../../features";
+import type {ChainKey, Color, FormatBuilder, Style} from "../types";
+
+const channels = ["fg", "bg"] as const;
+
+export function makeColor(
+	keys          : ReadonlySet<ChainKey>,
+	makeFormatter : FormatBuilder,
+	style         : Style,
+	colorDepth    : ColorDepth,
+): Color<any> {
+	const rtn = {} as Color<any>;
+
+	for (const channel of channels) {
+		if (keys.has(channel)) {
+			lazy.add(rtn, channel, () => {
+				const newKeys = new Set(keys);
+				newKeys.delete(channel);
+				return makeChannel(newKeys, makeFormatter, style, colorDepth, channel);
+			});
+		}
+	}
+
+	return rtn;
+}

package/src/sgr/color/context.ts

@@ -0,0 +1,44 @@
+import {combineCodes} from "../combine";
+
+import type {ColorDepth} from "../../features";
+import type {ChainKey, Code, ColorKey, Format, FormatBase, FormatBuilder, Style} from "../types";
+
+const baseCodes = {
+	fg: {open: 30, close: 39},
+	bg: {open: 40, close: 49},
+};
+
+export function buildContext(
+	keys          : ReadonlySet<ChainKey>,
+	makeFormatter : FormatBuilder,
+	style         : Style,
+	colorDepth    : ColorDepth,
+	channel       : ColorKey
+) {
+	const {open, close} = baseCodes[channel];
+
+	const build = (open: Code): Format => makeFormatter(keys, open, close);
+
+	const combine = (base: FormatBase, style: FormatBase): Format => makeFormatter(
+		keys,
+		combineCodes(base.codes.open,  style.codes.open),
+		combineCodes(base.codes.close, style.codes.close),
+	);
+
+	const bright: (index: number) => Format =
+		colorDepth >= 4 ? index => build(open + 60 + index) :
+		colorDepth === 3 ?
+			channel === "fg" ?
+				index => combine(style.bold, build(open + index)) :
+				index => build(open + index) :
+		() => build(0);
+
+	const x16ToX8: (code: number) => Format =
+		channel === "fg" ?
+			code => code >= 60 ? combine(style.bold, build(open + code - 60)) : build(open + code) :
+			code => code >= 60 ? build(open + code - 60) : build(open + code);
+
+	return {colorDepth, channel, open, close, build, bright, x16ToX8};
+}
+
+export type Context = ReturnType<typeof buildContext>;

package/src/sgr/color/rgb.ts

@@ -0,0 +1,48 @@
+import {clip, rgbToX256, rgbToX16, rgbToX8, x256ToRgb} from "./utils";
+
+import type {Channel, Format} from "../types";
+import type {Context}         from "./context";
+
+export function makeRGB(ctx: Context): Channel["rgb"] {
+	const {colorDepth, channel, build, open, x16ToX8} = ctx;
+
+	return (
+		colorDepth >= 24 ? (r, g, b) => build([open + 8, 2, ...clip(r, g, b)]) :
+		colorDepth >=  8 ? (r, g, b) => build([open + 8, 5, rgbToX256(...clip(r, g, b))]) :
+		colorDepth >=  4 ? (r, g, b) => build(open + rgbToX16(...clip(r, g, b))) :
+		colorDepth === 3 ?
+			channel === "fg" ?
+				(r, g, b) => x16ToX8(rgbToX16(...clip(r, g, b))) :
+				(r, g, b) => build(open + rgbToX8(...clip(r, g, b))) :
+		() => build(0)
+	);
+}
+
+export function makeX256(ctx: Context): (...args: [number] | [number, number, number]) => Format {
+	const {colorDepth, channel, build, open, x16ToX8} = ctx;
+
+	return (
+		colorDepth >= 8 ?
+			(...args) => build(
+				[open + 8, 5, args.length === 3 ? rgbToX256(...clip(...args)) : clip(args[0])],
+			) :
+		colorDepth >= 4 ?
+			(...args) => build(
+				open +
+				rgbToX16(...(args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])))),
+			) :
+		colorDepth === 3 ?
+			channel === "fg" ?
+				(...args) => x16ToX8(
+					args.length === 3 ?
+						rgbToX16(...clip(...args)) :
+						rgbToX16(...x256ToRgb(clip(args[0]))),
+				) :
+				(...args) => build(
+					open + rgbToX8(
+						...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])),
+					),
+				) :
+		() => build(0)
+	);
+}

package/src/sgr/color/utils.ts

@@ -29,6 +29,7 @@ export function x256ToRgb(code: number): [number, number, number] {
 
 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));
@@ -55,9 +56,7 @@ export function rgbToX8(r: number, g: number, b: number): number {
 
 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] {
+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]))) :
 		[

package/src/sgr/combine.ts

@@ -0,0 +1,13 @@
+import type {Code} from "./types";
+
+export function combineCodes(base: Code, code: Code): Code {
+	const set = new Set(Array.isArray(base) ? [...base] : [base]);
+
+	if (Array.isArray(code)) {
+		for (const c of code)
+			set.add(c);
+	} else
+		set.add(code);
+
+	return [...set];
+}

package/src/sgr/format-builder.ts

@@ -0,0 +1,47 @@
+import {define} from "@peteanderson/props";
+import {lazy}   from "./lazy";
+
+import type {ChainBuilder, ChainKey, Code, Format, FormatBase, FormatBuilder} from "./types";
+
+const codeSequence = (code: Code): string | number => Array.isArray(code) ? code.join(';') : code;
+
+const chain = <Keys extends ChainKey>(
+	makeChain  : ChainBuilder,
+	keys       : ReadonlySet<Keys>,
+	baseFormat : FormatBase,
+): Format<Keys> => !keys.size
+	? baseFormat as Format<Keys>
+	: lazy.add(baseFormat, "and", () => makeChain(keys, baseFormat));
+
+export function makeFormatBuilder(makeChain: ChainBuilder, enabled = true): FormatBuilder {
+	if (enabled) {
+		return (keys, open, close, reset) => {
+			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>`;
+
+			return chain(makeChain, keys, define(
+				(s: string) => s ? openSequence + s.replace(rxClose, replace) + closeSequence : s,
+				{
+					open  : {value: openSequence,  enumerable: true},
+					close : {value: closeSequence, enumerable: true},
+					codes : {value: {open, close}, enumerable: true},
+				},
+			));
+		};
+	}
+
+	return keys => chain(makeChain, keys, define((s: string) => s, {
+		open  : {value: "", enumerable: true},
+		close : {value: "", enumerable: true},
+		codes : {value: {open: [], close: []}, enumerable: true},
+	}));
+}

package/src/sgr/index.ts

@@ -1,3 +1,3 @@
-export * from "./reset";
-export * from "./style";
-export * from "./color";
+export * from "./sgr";
+
+export {SGR} from "./types";

package/src/sgr/lazy.ts

@@ -0,0 +1,21 @@
+import {define} from "@peteanderson/props";
+
+import type {GetterProperty} from "@peteanderson/props";
+
+export function lazy<K extends keyof any, V>(key: K, get: () => V): GetterProperty<V> {
+	return {
+		get() {
+			const value = get();
+			define(this, key, {value, enumerable: true});
+			return value;
+		},
+		enumerable   : true,
+		configurable : true,
+	};
+}
+
+lazy.add = <T extends object, K extends keyof any, V>(
+	obj : T,
+	key : K,
+	get : () => V,
+): T & {[k in K]: V} => define(obj, key, lazy(key, get));

package/src/sgr/sgr.ts

@@ -1,65 +1,72 @@
-export type Code = number | number[];
+import {TypedObject}       from "../typed-object";
+import {makeColor}         from "./color";
+import {combineCodes}      from "./combine";
+import {makeFormatBuilder} from "./format-builder";
+import {makeReset}         from "./reset";
+import {makeStyle}         from "./style";
 
-export interface SGR {
-	(text: string): string;
-	open    : string;
-	close   : string;
-	codes   : {open: Code; close: Code};
-	combine : (...styles: SGR[]) => SGR;
-}
+import type {ColorDepth, Features}                            from "../features";
+import type {Chain, ChainKey, FormatBase, FormatBuilder, SGR} from "./types";
 
-function combine(code: Code, codes: Code[]): Code {
-	if (!codes.length)
-		return code;
+const keyMap: Record<ChainKey, undefined> = {
+	fg              : undefined,
+	bg              : undefined,
+	bold            : undefined,
+	dim             : undefined,
+	italic          : undefined,
+	underline       : undefined,
+	inverse         : undefined,
+	hidden          : undefined,
+	strikethrough   : undefined,
+	doubleUnderline : undefined,
+	frame           : undefined,
+	encircle        : undefined,
+	overline        : undefined,
+};
 
-	const set = new Set(Array.isArray(code) ? [...code] : [code]);
+const allKeys: ReadonlySet<ChainKey> = new Set(TypedObject.keys(keyMap));
 
-	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 cache: Partial<Record<`${ColorDepth}.${boolean}`, SGR>> = {};
 
-const codeSequence = (code: Code): string | number => Array.isArray(code) ? code.join(";") : code;
+export function makeSGR(features: Features): SGR {
+	const cacheKey = `${features.colorDepth}.${features.style}` as const;
+	if (cache[cacheKey])
+		return cache[cacheKey];
 
-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 colorFormat = makeFormatBuilder(makeChain, features.colorDepth > 1);
+	const styleFormat = makeFormatBuilder(makeChain, features.style);
+	const style       = makeStyle(allKeys, styleFormat, features.style);
 
-	const rxClose = new RegExp(
-		`(?<start>\\x1b\\[(?:\\d+;)*)${closeCode}(?<end>(?:;\\d+)*m)`,
-		"g"
-	);
-	const replace = `$<start>${reopenCode}$<end>`;
+	function makeChain<Keys extends ChainKey>(
+		keys       : ReadonlySet<Keys>,
+		baseFormat : FormatBase,
+	): Chain<Keys> {
+		const chainedColorFormat: FormatBuilder = (keys, open, close, reset) => colorFormat(
+			keys,
+			combineCodes(baseFormat.codes.open, open),
+			combineCodes(baseFormat.codes.close, close),
+			reset,
+		);
+		const chainedStyleFormat: FormatBuilder = (keys, open, close, reset) => styleFormat(
+			keys,
+			combineCodes(baseFormat.codes.open, open),
+			combineCodes(baseFormat.codes.close, close),
+			reset,
+		);
 
-	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)),
-		),
-	});
-}
+		return /** @type {Chain<any>} */({
+			...makeColor(keys, chainedColorFormat, style, features.colorDepth),
+			...makeStyle(keys, chainedStyleFormat, features.style),
+		});
+	}
 
-const disabledSGR: SGR = Object.assign((s: string) => s, {
-	codes   : {open: 0, close: 0},
-	open    : "",
-	close   : "",
-	combine : (): SGR => disabledSGR,
-});
+	const rtn: SGR = {
+		...makeColor(allKeys, colorFormat, style, features.colorDepth),
+		style,
+		reset: makeReset(features.colorDepth > 1 || features.style),
+	};
 
-const disabled: typeof sgr = () => disabledSGR;
+	cache[cacheKey] = rtn;
 
-export const makeSGR = (enabled = true): typeof sgr => enabled ? sgr : disabled;
+	return rtn;
+}