@peteanderson/ansi 1.0.0 → 2.0.0

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/index.ts

@@ -1 +1 @@
-export * from "./color";
+export * from "./color";

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

@@ -1,7 +1,10 @@
 export function rgbToX256(r: number, g: number, b: number): number {
-	if (r === g && g === b)
+	if (r === g && g === b) {
+		// grayscale
 		return 232 + Math.floor(r * 24 / 256);
+	}
 
+	// 6x6x6 color cube
 	return (
 		16 +
 		Math.floor(r * 6 / 256) * 36 +
@@ -12,6 +15,7 @@ export function rgbToX256(r: number, g: number, b: number): number {
 
 export function x256ToRgb(code: number): [number, number, number] {
 	if (code >= 232) {
+		// grayscale
 		const gray = Math.round((code - 232) * 255 / 24);
 		return [gray, gray, gray];
 	}
@@ -24,16 +28,21 @@ 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));
 
+	// Which channels are "on" determines the hue (ANSI color index 0–7).
 	const index = (r ? 1 : 0) | (g ? 2 : 0) | (b ? 4 : 0);
 
+	// The bright bit is derived from the max channel level across all three.
 	const twos   = (r === 2 ? 1 : 0) + (g === 2 ? 1 : 0) + (b === 2 ? 1 : 0);
 	const ones   = (r === 1 ? 1 : 0) + (g === 1 ? 1 : 0) + (b === 1 ? 1 : 0);
 	const bright = twos > 0 && twos >= ones;
 
+	// Return value uses the SGR offset scheme: 0–7 for normal, 60–67 for bright.
 	return index + (bright ? 60 : 0);
 }
 
@@ -48,9 +57,9 @@ 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] {
-	return args.length === 1
-		? Math.max(0, Math.min(255, Math.floor(args[0])))
-		: [
+	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/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,68 +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 rtn = Array.isArray(code) ? [...code] : [code];
+const allKeys: ReadonlySet<ChainKey> = new Set(TypedObject.keys(keyMap));
 
-	for (const c of codes) {
-		if (Array.isArray(c))
-			rtn.push(...c);
-		else
-			rtn.push(c);
-	}
-
-	return rtn;
-}
+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),
+		});
+	}
 
-let disabledSGR = null as unknown as SGR;
-disabledSGR = 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 = (): SGR => disabledSGR;
+	cache[cacheKey] = rtn;
 
-export const makeSGR = (enabled = true): typeof sgr => enabled ? sgr : disabled;
+	return rtn;
+}

package/src/sgr/style.ts

@@ -1,21 +1,38 @@
-import {makeSGR} from "./sgr";
+import {TypedObject} from "../typed-object";
+import {lazy}        from "./lazy";
 
-export function makeStyle(enabled = true) {
-	const sgr = makeSGR(enabled);
+import type {ChainKey, FormatBuilder, Style} from "./types";
 
-	return {
-		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),
-	};
-}
+const propParams = TypedObject.entries<Record<keyof Style, SkipFirst<Parameters<FormatBuilder>>>>({
+	bold            : [ 1, 22, true],
+	dim             : [ 2, 22, true],
+	italic          : [ 3, 23],
+	underline       : [ 4, 24],
+	inverse         : [ 7, 27],
+	hidden          : [ 8, 28],
+	strikethrough   : [ 9, 29],
+	doubleUnderline : [21, 24],
+	frame           : [51, 54],
+	encircle        : [52, 54],
+	overline        : [53, 55],
+});
 
-export type Style = ReturnType<typeof makeStyle>;
+export function makeStyle(
+	keys          : ReadonlySet<ChainKey>,
+	makeFormatter : FormatBuilder,
+	enabled       : boolean,
+): Style<any> {
+	const rtn = {} as Style<any>;
+
+	for (const [key, args] of propParams) {
+		if (keys.has(key)) {
+			lazy.add(rtn, key, () => {
+				const newKeys = new Set(keys);
+				newKeys.delete(key);
+				return enabled ? makeFormatter(newKeys, ...args) : makeFormatter(newKeys, 0, 0);
+			});
+		}
+	}
+
+	return rtn;
+}