@peteanderson/ansi 3.7.1 → 3.8.0

package/src/sgr/chain/build.ts

@@ -0,0 +1,25 @@
+import {makeColor}    from "../color";
+import {combineCodes} from "../combine";
+import {makeStyle}    from "../style";
+
+import type {Color}         from "../color";
+import type {FormatContext} from "../context";
+import type {FormatBase}    from "../format";
+import type {Style}         from "../style";
+import type {ChainKey}      from "./keys";
+
+export type Chain<Keys extends ChainKey> = Color<Keys> & Style<Keys>;
+
+export function makeChain<Keys extends ChainKey>(
+	context    : FormatContext<Keys>,
+	baseFormat : FormatBase,
+): Chain<Keys> {
+	const parentCodes = context.parentCodes ? {
+		open  : combineCodes(context.parentCodes.open, baseFormat.codes.open),
+		close : combineCodes(baseFormat.codes.close, context.parentCodes.close),
+	} : baseFormat.codes;
+
+	const chainedContext: FormatContext<Keys> = {...context, parentCodes};
+
+	return {...makeColor(chainedContext), ...makeStyle(chainedContext)};
+}

package/src/sgr/chain/chain.ts

@@ -0,0 +1,60 @@
+import {define, ownProperties} from "@peteanderson/props";
+import {getContext}            from "../context";
+import {attachChain}           from "./attach";
+import {allKeys}               from "./keys";
+
+import type {Features}           from "#features";
+import type {Format, FormatBase} from "../format";
+import type {ChainKey}           from "./keys";
+
+function cloneFormatBase(baseFormat: FormatBase): FormatBase {
+	const clone       = (text: string) => baseFormat(text);
+	const descriptors = ownProperties(baseFormat);
+
+	delete descriptors.and;
+
+	return define(clone, descriptors);
+}
+
+function keysMatch(a: ReadonlySet<ChainKey>, b: ReadonlySet<ChainKey>): boolean {
+	if (a.size !== b.size)
+		return false;
+
+	for (const key of a)
+		if (!b.has(key))
+			return false;
+
+	return true;
+}
+
+type ChainArgs<Keys extends ChainKey> = [
+	keys       : ReadonlySet<Keys>,
+	baseFormat : FormatBase,
+	features?  : Features,
+];
+
+type OverloadedArgs<Keys extends ChainKey> = [FormatBase, Features?] | ChainArgs<Keys>;
+
+const resolveArgs = <Keys extends ChainKey>(args: OverloadedArgs<Keys>): ChainArgs<Keys> =>
+	args.length === 1 ?
+		[allKeys as ReadonlySet<Keys>, args[0], undefined] :
+	args.length === 2 ?
+		typeof args[0] === "function"
+			? [allKeys as ReadonlySet<Keys>, ...args as [FormatBase]]
+			: args as ChainArgs<Keys> :
+	args as ChainArgs<Keys>;
+
+export function chain(baseFormat: FormatBase, features?: Features): Format<ChainKey>;
+export function chain<Keys extends ChainKey = ChainKey>(...args: ChainArgs<Keys>): Format<Keys>;
+
+export function chain<Keys extends ChainKey>(...args: OverloadedArgs<Keys>): Format<Keys> {
+	const [keys, baseFormat, features] = resolveArgs(args);
+
+	let context = getContext(baseFormat, features);
+	if (!keysMatch(context.keys, keys))
+		context = {...context, keys};
+
+	return attachChain(context, cloneFormatBase(baseFormat));
+}
+
+export type AddChain = typeof chain;

package/src/sgr/chain/index.ts

@@ -0,0 +1,5 @@
+export * from "./attach";
+export * from "./chain";
+export * from "./keys";
+
+export type {Chain} from "./build";

package/src/sgr/chain/keys.ts

@@ -0,0 +1,8 @@
+import {channels}  from "../color";
+import {styleKeys} from "../style";
+
+const chainKeys = [...channels, ...styleKeys] as const;
+
+export type ChainKey = typeof chainKeys[number];
+
+export const allKeys: ReadonlySet<ChainKey> = new Set(chainKeys);

package/src/sgr/color/channel.ts

@@ -1,10 +1,41 @@
-import {csi}               from "../../utils";
-import {lazy}              from "../lazy";
-import {buildContext}      from "./context";
-import {makeRGB, makeX256} from "./rgb";
+import {csi}                 from "#utils";
+import {lazy}                from "../lazy";
+import {buildChannelContext} from "./context";
+import {makeRGB, makeX256}   from "./rgb";
 
-import type {ColorDepth}                                        from "../../features";
-import type {ChainKey, Channel, ColorKey, FormatBuilder, Style} from "../types";
+import type {ChainKey}      from "../chain";
+import type {FormatContext} from "../context";
+import type {Format}        from "../format";
+import type {ColorKey}      from "./color";
+
+export interface Channel<Keys extends ChainKey = ChainKey> {
+	black   : Format<Keys>;
+	red     : Format<Keys>;
+	green   : Format<Keys>;
+	yellow  : Format<Keys>;
+	blue    : Format<Keys>;
+	magenta : Format<Keys>;
+	cyan    : Format<Keys>;
+	white   : Format<Keys>;
+
+	brightBlack   : Format<Keys>;
+	brightRed     : Format<Keys>;
+	brightGreen   : Format<Keys>;
+	brightYellow  : Format<Keys>;
+	brightBlue    : Format<Keys>;
+	brightMagenta : Format<Keys>;
+	brightCyan    : Format<Keys>;
+	brightWhite   : Format<Keys>;
+
+	rgb: (r: number, g: number, b: number) => Format<Keys>;
+
+	x256: {
+		(code: number): Format<Keys>;
+		(r: number, g: number, b: number): Format<Keys>;
+	};
+
+	default: string,
+}
 
 const colors = [
 	"black",
@@ -17,27 +48,24 @@ const colors = [
 	"white",
 ] as const;
 
-export function makeChannel(
-	keys          : ReadonlySet<ChainKey>,
-	makeFormatter : FormatBuilder,
-	style         : Style,
-	colorDepth    : ColorDepth,
+export function makeChannel<Keys extends ChainKey>(
+	formatContext : FormatContext<Keys>,
 	channel       : ColorKey,
-): Channel {
-	const ctx = buildContext(keys, makeFormatter, style, colorDepth, channel);
-	const {build, bright, open, close} = ctx;
+): Channel<Keys> {
+	const channelContext                 = buildChannelContext(formatContext, channel);
+	const {build, bright, close, offset} = channelContext;
 
 	const rtn = {
-		rgb     : makeRGB(ctx),
-		x256    : makeX256(ctx),
-		default : colorDepth > 1 ? csi(close, "m") : "",
-	} as Channel;
+		rgb     : makeRGB(channelContext),
+		x256    : makeX256(channelContext),
+		default : csi(close, "m"),
+	} as unknown as Channel<Keys>;
 
 	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, color,       () => build(offset(i)));
 		lazy.add(rtn, brightColor, () => bright(i));
 	}
 

package/src/sgr/color/color.ts

@@ -1,29 +1,24 @@
-"use strict";
-
 import {lazy}        from "../lazy";
 import {makeChannel} from "./channel";
 
-import type {ColorDepth}                            from "../../features";
-import type {ChainKey, Color, FormatBuilder, Style} from "../types";
+import type {ChainKey}      from "../chain";
+import type {FormatContext} from "../context";
+import type {Channel}       from "./channel";
+
+export const channels = ["fg", "bg"] as const;
+
+export type ColorKey = typeof channels[number];
 
-const channels = ["fg", "bg"] as const;
+export type Color<Keys extends ChainKey = ChainKey> = {
+	[K in Extract<ColorKey, Keys>]: Channel<Exclude<Keys, K>>;
+};
 
-export function makeColor(
-	keys          : ReadonlySet<ChainKey>,
-	makeFormatter : FormatBuilder,
-	style         : Style,
-	colorDepth    : ColorDepth,
-): Color<any> {
-	const rtn = {} as Color<any>;
+export function makeColor<Keys extends ChainKey>(context: FormatContext<Keys>): Color<Keys> {
+	const rtn = {} as Color<Keys>;
 
 	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);
-			});
-		}
+		if (context.keys.has(channel as Keys))
+			lazy.add(rtn, channel, () => makeChannel(context.removeKey(channel as Keys), channel));
 	}
 
 	return rtn;

package/src/sgr/color/context.ts

@@ -1,46 +1,52 @@
+import {Code}         from "#code";
 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},
+import {makeFormat}   from "../format";
+
+import type {FormatContext}      from "../context";
+import type {Format, FormatBase} from "../format";
+import type {ColorKey}           from "./color";
+
+const codes = (open: number) => ({
+	open     : open as Code,
+	close    : open + 9 as Code,
+	offset   : (delta: number): Code => open + delta,
+	extended : (...args: number[]): Code => [open + 8, ...args],
+});
+
+const baseCodes = {fg: codes(30), bg: codes(40)};
+
+const disabledCodes: ReturnType<typeof codes> = {
+	open     : Code.disabled,
+	close    : Code.disabled,
+	offset   : () => Code.disabled,
+	extended : () => Code.disabled,
 };
 
-export function buildContext(
-	keys          : ReadonlySet<ChainKey>,
-	makeFormatter : FormatBuilder,
-	style         : Style,
-	colorDepth    : ColorDepth,
-	channel       : ColorKey
-) {
-	const {open, close} = baseCodes[channel];
-
-	const build = colorDepth > 1
-		? (open: Code): Format => makeFormatter(keys, open, close)
-		: () => makeFormatter(keys, [], []);
-
-	const combine = (base: FormatBase, style: FormatBase): Format => makeFormatter(
-		keys,
+export function buildChannelContext(formatContext: FormatContext, channel: ColorKey) {
+	const {colorDepth}                    = formatContext.features;
+	const {open, close, extended, offset} = colorDepth > 1 ? baseCodes[channel] : disabledCodes;
+
+	const build   = (open: Code): Format => makeFormat(formatContext, open, close);
+	const combine = (base: FormatBase, style: FormatBase): Format => makeFormat(
+		formatContext,
 		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 >= 4 ? index => build(offset(60 + index)) :
 		colorDepth === 3 ?
 			channel === "fg" ?
-				index => combine(style.bold, build(open + index)) :
-				index => build(open + index) :
-		() => build([]);
+				index => combine(formatContext.style.bold, build(offset(index))) :
+				index => build(offset(index)) :
+		() => build(Code.disabled);
 
 	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);
+		channel === "fg"
+			? code => code >= 60 ? bright(code - 60) : build(offset(code))
+			: code => build(offset(code % 60));
 
-	return {colorDepth, channel, open, close, build, bright, x16ToX8};
+	return {colorDepth, channel, open, close, offset, extended, build, bright, x16ToX8};
 }
 
-export type Context = ReturnType<typeof buildContext>;
+export type ChannelContext = ReturnType<typeof buildChannelContext>;

package/src/sgr/color/rgb.ts

@@ -1,35 +1,38 @@
+import {Code}                                          from "#code";
 import {clip, rgbToX256, rgbToX16, rgbToX8, x256ToRgb} from "./utils";
 
-import type {Channel, Format} from "../types";
-import type {Context}         from "./context";
+import type {Format}         from "../format";
+import type {Channel}        from "./channel";
+import type {ChannelContext} from "./context";
 
-export function makeRGB(ctx: Context): Channel["rgb"] {
-	const {colorDepth, channel, build, open, x16ToX8} = ctx;
+export function makeRGB(ctx: ChannelContext): Channel["rgb"] {
+	const {colorDepth, channel, build, offset, extended, 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 >= 24 ? (r, g, b) => build(extended(2, ...clip(r, g, b))) :
+		colorDepth >=  8 ? (r, g, b) => build(extended(5, rgbToX256(...clip(r, g, b)))) :
+		colorDepth >=  4 ? (r, g, b) => build(offset(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([])
+				(r, g, b) => build(offset(rgbToX8(...clip(r, g, b)))) :
+		() => build(Code.disabled)
 	);
 }
 
-export function makeX256(ctx: Context): (...args: [number] | [number, number, number]) => Format {
-	const {colorDepth, channel, build, open, x16ToX8} = ctx;
+type X256 = (...args: [number] | [number, number, number]) => Format;
+
+export function makeX256(ctx: ChannelContext): X256 {
+	const {colorDepth, channel, build, offset, extended, x16ToX8} = ctx;
 
 	return (
 		colorDepth >= 8 ?
 			(...args) => build(
-				[open + 8, 5, args.length === 3 ? rgbToX256(...clip(...args)) : clip(args[0])],
+				extended(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])))),
+				offset(rgbToX16(...(args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0]))))),
 			) :
 		colorDepth === 3 ?
 			channel === "fg" ?
@@ -38,11 +41,9 @@ export function makeX256(ctx: Context): (...args: [number] | [number, number, nu
 						rgbToX16(...clip(...args)) :
 						rgbToX16(...x256ToRgb(clip(args[0]))),
 				) :
-				(...args) => build(
-					open + rgbToX8(
-						...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])),
-					),
-				) :
-		() => build([])
+				(...args) => build(offset(rgbToX8(
+					...args.length === 3 ? clip(...args) : x256ToRgb(clip(args[0])),
+				))) :
+		() => build(Code.disabled)
 	);
 }

package/src/sgr/combine.ts

@@ -1,6 +1,6 @@
 import {State} from "../simplify/state";
 
-import type {Code} from "./types";
+import type {Code} from "#code";
 
 export const combineCodes = (base: Code, ...codes: Code[]): Code =>
 	new State().update([base, ...codes].flat());

package/src/sgr/context.ts

@@ -0,0 +1,68 @@
+import {getFeatures} from "#features";
+import {allKeys}     from "./chain";
+import {makeStyle}   from "./style";
+
+import type {Codes}      from "#code";
+import type {Features}   from "#features";
+import type {ChainKey}   from "./chain";
+import type {FormatBase} from "./format";
+import type {Style}      from "./style";
+
+export interface FormatContext<Keys extends ChainKey = ChainKey> {
+	features       : Features;
+	keys           : ReadonlySet<Keys>;
+	parentCodes?   : Codes;
+	style          : Style;
+	removeKey      : <Key extends Keys>(key: Key) => FormatContext<Exclude<Keys, Key>>;
+	registerFormat : (format: FormatBase) => void;
+}
+
+function removeKey<Keys extends ChainKey, Key extends Keys>(
+	context : FormatContext<Keys>,
+	key     : Key,
+): FormatContext<Exclude<Keys, Key>> {
+	const keys = new Set(context.keys);
+	keys.delete(key);
+	return {...context, keys: keys as unknown as ReadonlySet<Exclude<Keys, Key>>};
+}
+
+const cache = new WeakMap<FormatBase, FormatContext<any>>();
+
+export function getContext(format: FormatBase, features?: Features): FormatContext<any> {
+	let context = cache.get(format);
+	if (context)
+		return context;
+
+	features ??= getFeatures(format.open ? 24 : 1);
+
+	context = {
+		features,
+		keys           : allKeys,
+		parentCodes    : format.codes,
+		style          : undefined as unknown as Style,
+		removeKey      : key => removeKey(context!, key),
+		registerFormat : (format: FormatBase) => void cache.set(format, context!),
+	};
+	context.style = makeStyle(context);
+
+	cache.set(format, context);
+	return context;
+}
+
+export function createContext<Keys extends ChainKey = ChainKey>(
+	features     : Features,
+	parentCodes? : Codes,
+	keys?        : ReadonlySet<Keys>,
+): FormatContext<Keys> {
+	const context: FormatContext<Keys> = {
+		features,
+		keys           : keys ?? allKeys as ReadonlySet<Keys>,
+		parentCodes,
+		style          : undefined as unknown as Style,
+		removeKey      : key => removeKey(context, key),
+		registerFormat : format => void cache.set(format, context),
+	};
+	context.style = makeStyle(keys ? {...context, keys: allKeys} : context);
+
+	return context;
+}

package/src/sgr/format.ts

@@ -0,0 +1,72 @@
+import {Code}              from "#code";
+import {codeSequence, csi} from "#utils";
+import {define}            from "@peteanderson/props";
+import {attachChain}       from "./chain";
+import {combineCodes}      from "./combine";
+
+import type {Codes}           from "#code";
+import type {Chain, ChainKey} from "./chain";
+import type {FormatContext}   from "./context";
+
+export interface FormatBase {
+	(text: string): string;
+
+	open    : string;
+	close   : string;
+	codes   : Codes;
+	combine : (...formats: [FormatBase, ...FormatBase[]]) => FormatBase;
+}
+
+export interface ChainedFormat<Keys extends ChainKey = ChainKey> extends FormatBase {
+	and: Chain<Keys>;
+}
+
+export type Format<Keys extends ChainKey = ChainKey> =
+	[Keys] extends [never] ? FormatBase : ChainedFormat<Keys>;
+
+export function makeFormat<Keys extends ChainKey = ChainKey>(
+	context : FormatContext<Keys>,
+	open    : Code,
+	close   : Code,
+	reset?  : boolean,
+): Format<Keys> {
+	if (context.parentCodes) {
+		open  = combineCodes(context.parentCodes.open, open);
+		close = combineCodes(close, context.parentCodes.close);
+	}
+
+	const openCode      = codeSequence(open);
+	const closeCode     = codeSequence(close);
+	const openSequence  = csi(open, "m");
+	const closeSequence = csi(close, "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 format = attachChain(context, define(
+		openSequence
+			? (s: string) => s ? openSequence + s.replace(rxClose, replace) + closeSequence : s
+			: (s: string) => s,
+		{
+			open    : {value: openSequence,  enumerable: true},
+			close   : {value: closeSequence, enumerable: true},
+			codes   : {value: {open, close}, enumerable: true},
+			combine : {
+				value: (...formats: [FormatBase, ...FormatBase[]]) => makeFormat(
+					context,
+					combineCodes(open,  ...formats.map(f => f.codes.open)),
+					combineCodes(close, ...formats.map(f => f.codes.close)),
+					reset,
+				),
+				enumerable: true,
+			},
+		},
+	));
+
+	context.registerFormat(format);
+	return format;
+};

package/src/sgr/index.ts

@@ -1,3 +1,5 @@
-export * from "./sgr";
+export {chain} from "./chain"; // This export must come first to avoid circular dependency issues.
+export *       from "./sgr";
 
-export {SGR} from "./types";
+export type {AddChain, ChainKey} from "./chain";
+export type {Format, FormatBase} from "./format";

package/src/sgr/reset.ts

@@ -1,3 +1,3 @@
-import {csi} from "../utils";
+import {csi} from "#utils";
 
 export const makeReset = (enabled = true): string => enabled ? csi("m") : "";

package/src/sgr/sgr.ts

@@ -1,30 +1,20 @@
-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";
-
-import type {ColorDepth, Features}                            from "../features";
-import type {Chain, ChainKey, FormatBase, FormatBuilder, SGR} from "./types";
-
-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 allKeys: ReadonlySet<ChainKey> = new Set(TypedObject.keys(keyMap));
+import {Code}          from "#code";
+import {makeColor}     from "./color";
+import {createContext} from "./context";
+import {makeFormat}    from "./format";
+import {makeReset}     from "./reset";
+
+import type {ColorDepth, Features} from "#features";
+import type {ChainKey}             from "./chain";
+import type {Color}                from "./color";
+import type {Format}               from "./format";
+import type {Style}                from "./style";
+
+export interface SGR extends Color<ChainKey> {
+	style : Style;
+	plain : Format<ChainKey>;
+	reset : string;
+}
 
 const cache: Partial<Record<`${ColorDepth}.${boolean}`, SGR>> = {};
 
@@ -33,30 +23,12 @@ export function makeSGR(features: Features): SGR {
 	if (cache[cacheKey])
 		return cache[cacheKey];
 
-	const makeFormat = makeFormatBuilder(makeChain);
-	const style      = makeStyle(allKeys, makeFormat, features.style);
-
-	function makeChain<Keys extends ChainKey>(
-		keys       : ReadonlySet<Keys>,
-		baseFormat : FormatBase,
-	): Chain<Keys> {
-		const makeChainedFormat: FormatBuilder = (keys, open, close, reset) => makeFormat(
-			keys,
-			combineCodes(baseFormat.codes.open, open),
-			combineCodes(baseFormat.codes.close, close),
-			reset,
-		);
-
-		return {
-			...makeColor(keys, makeChainedFormat, style, features.colorDepth),
-			...makeStyle(keys, makeChainedFormat, features.style),
-		};
-	}
+	const context = createContext(features);
 
 	const rtn: SGR = {
-		...makeColor(allKeys, makeFormat, style, features.colorDepth),
-		style,
-		plain : makeFormat(allKeys, [], []),
+		...makeColor(context),
+		style : context.style,
+		plain : makeFormat(context, Code.disabled, Code.disabled),
 		reset : makeReset(features.colorDepth > 1 || features.style),
 	};