@peteanderson/ansi 1.0.1 → 2.0.0

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;
+}

package/src/sgr/types.ts

@@ -0,0 +1,91 @@
+export type ColorKey = "fg" | "bg";
+
+export type StyleKey =
+	| "bold"
+	| "dim"
+	| "italic"
+	| "underline"
+	| "inverse"
+	| "hidden"
+	| "strikethrough"
+	| "doubleUnderline"
+	| "frame"
+	| "encircle"
+	| "overline";
+
+export type ChainKey = ColorKey | StyleKey;
+
+export type Chain<Keys extends ChainKey> = Color<Keys> & Style<Keys>;
+
+export type ChainBuilder = <Keys extends ChainKey>(
+	keys       : ReadonlySet<Keys>,
+	baseFormat : FormatBase,
+) => Chain<Keys>;
+
+export type Code = number | number[];
+
+export interface FormatBase {
+	(text: string): string;
+
+	open  : string;
+	close : string;
+	codes : {open: Code, close: Code};
+}
+
+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 type FormatBuilder = <Keys extends ChainKey = ChainKey>(
+	keys   : ReadonlySet<Keys>,
+	open   : Code,
+	close  : Code,
+	reset? : boolean,
+) => Format<Keys>;
+
+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,
+}
+
+export type Color<Keys extends ChainKey = ChainKey> = {
+	[K in Extract<ColorKey, Keys>]: Channel<Exclude<Keys, K>>;
+};
+
+export type Style<Keys extends ChainKey = ChainKey> = {
+	[K in Extract<StyleKey, Keys>]: Format<Exclude<Keys, K>>;
+};
+
+export interface SGR {
+	fg    : Channel<Exclude<ChainKey, "fg">>;
+	bg    : Channel<Exclude<ChainKey, "bg">>;
+	style : Style;
+	reset : string;
+}

package/src/simplify/simplify.ts

@@ -24,4 +24,6 @@ export function simplify(text: string): string {
 	}
 
 	return result;
-}
+}
+
+export type Simplify = typeof simplify;

package/src/slice.ts

@@ -83,4 +83,6 @@ export function slice(text: string, start: number, end: number): string {
 	const trailingSequences = skippedSequences(text, endIndex);
 
 	return leadingSequences + text.slice(startIndex, endIndex) + trailingSequences;
-}
+}
+
+export type Slice = typeof slice;

package/src/strip.ts

@@ -7,4 +7,8 @@ export const strip         = (text: string): string => text.replace(new RegExp(r
 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), "");
+export const sanitize      = (text: string): string => text.replace(new RegExp(rxUnsafe), "");
+
+export type Strip         = typeof strip;
+export type VisibleLength = typeof visibleLength;
+export type Sanitize      = typeof sanitize;

package/src/typed-object.ts

@@ -0,0 +1,85 @@
+export type TypedPropertyDescriptorMap<T> = {
+	[K in keyof T]: TypedPropertyDescriptor<T[K]>;
+};
+
+export interface TypedObject {
+	getOwnPropertyNames<T>(o: T): KeyOf<T>[];
+
+	keys<T>   (o: T): KeyOf<T>[];
+	values<T> (o: T): ValuesOf<T>;
+	entries<T>(o: T): EntriesOf<T>;
+	fromEntries<K extends keyof any, V>(entries: Iterable<readonly [K, V]>): Record<K, V>;
+
+	create<T>(prototype: object, properties: TypedPropertyDescriptorMap<T>): T;
+
+	recreate<T, U>(
+		o  : T,
+		fn : <K extends keyof T>(
+			key      : K,
+			property : TypedPropertyDescriptor<T[K]>
+		) => [K, TypedPropertyDescriptor<U>]
+	): Record<keyof T, U>;
+
+	transform<T, K extends keyof any, V>(
+		o  : T,
+		fn : (key: KeyOf<T>, value: T[keyof T]) => readonly [K, V]
+	): Record<K, V>;
+
+	toMap<T extends {}, K = KeyOf<T>, V = T[keyof T]>(
+		o          : T,
+		transform? : (key: KeyOf<T>, value: T[keyof T]) => readonly [K, V]
+	): Map<K, V>;
+}
+export const TypedObject = Object.freeze({
+	getOwnPropertyNames : Object.getOwnPropertyNames,
+	keys                : Object.keys,
+	values              : Object.values,
+	entries             : Object.entries,
+	fromEntries         : Object.fromEntries,
+	create              : Object.create,
+
+	recreate: <T, U>(
+		o  : T,
+		fn : <K extends keyof T>(
+			key      : K,
+			property : TypedPropertyDescriptor<T[K]>
+		) => [K, TypedPropertyDescriptor<U>]
+	): Record<keyof T, U> => Object.create(
+		Object.getPrototypeOf(o),
+		TypedObject.transform(Object.getOwnPropertyDescriptors(o), fn as any),
+	),
+
+	transform: <T, K extends keyof any, V>(
+		o  : T,
+		fn : (key: KeyOf<T>, value: T[keyof T]) => readonly [K, V],
+	): Record<K, V> => TypedObject.fromEntries(
+		TypedObject.entries(o).map(([key, value]) => fn(key as any, value)),
+	),
+
+	/**
+	@type {
+		<T extends {}, K = KeyOf<T>, V = T[keyof T]>(
+			o          : T,
+			transform? : (key: KeyOf<T>, value: T[keyof T]) => readonly [K, V]
+		) => Map<K, V>
+	}
+	*/
+	toMap<T extends {}, K = KeyOf<T>, V = T[keyof T]>(
+		o          : T,
+		transform? : (key: KeyOf<T>, value: T[keyof T]) => readonly [K, V],
+	): Map<K, V> {
+		const map = new Map<K, V>();
+
+		if (transform) {
+			for (const [key, value] of TypedObject.entries(o)) {
+				const [newKey, newValue] = transform(key as any, value);
+				map.set(newKey, newValue);
+			}
+		} else {
+			for (const [key, value] of TypedObject.entries(o))
+				map.set(key as any, value as any);
+		}
+
+		return map;
+	},
+}) as TypedObject;

package/src/types.ts

@@ -0,0 +1,28 @@
+import type {Caret}                          from "./caret";
+import type {Erase}                          from "./erase";
+import type {Features}                       from "./features";
+import type {PadEnd, PadStart}               from "./pad";
+import type {Scroll}                         from "./scroll";
+import type {SGR}                            from "./sgr";
+import type {Simplify}                       from "./simplify";
+import type {Slice}                          from "./slice";
+import type {Sanitize, Strip, VisibleLength} from "./strip";
+import type {Terminal}                       from "./terminal";
+
+export type Ansi = SGR & {
+	caret    : Caret;
+	erase    : Erase;
+	scroll   : Scroll;
+	terminal : Terminal;
+
+	padEnd   : PadEnd;
+	padStart : PadStart;
+
+	strip         : Strip;
+	visibleLength : VisibleLength;
+	sanitize      : Sanitize;
+	slice         : Slice;
+	simplify      : Simplify;
+
+	features : Features;
+};

package/src/utility-types.d.ts

@@ -0,0 +1,18 @@
+// https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type
+type UnionToIntersection<U> =
+	(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+
+type StringKey<T> = T extends number ? `${T}` : T extends string ? T : never;
+type KeyOf<T>     = StringKey<keyof T>;
+
+type ValueOf<T, K extends keyof T = keyof T> = Required<T>[K];
+type ValuesOf<T, K extends [...(keyof T)[]] = (keyof T)[]> = {
+	[P in keyof K]: K[P] extends keyof T ? ValueOf<T, K[P]> : never;
+};
+
+type EntryOf<T, K extends keyof T = keyof T> = [K, ValueOf<T, K>];
+type EntriesOf<T, K extends [...(keyof T)[]] = (keyof T)[]> = {
+	[P in keyof K]: K[P] extends keyof T ? EntryOf<T, K[P]> : never;
+};
+
+type SkipFirst<T> = T extends [infer First, ...infer Rest] ? Rest : [];

package/dist/sgr/color/types.d.ts

@@ -1,30 +0,0 @@
-import type { SGR } from "../sgr";
-export interface Channel {
-    black: SGR;
-    red: SGR;
-    green: SGR;
-    yellow: SGR;
-    blue: SGR;
-    magenta: SGR;
-    cyan: SGR;
-    white: SGR;
-    brightBlack: SGR;
-    brightRed: SGR;
-    brightGreen: SGR;
-    brightYellow: SGR;
-    brightBlue: SGR;
-    brightMagenta: SGR;
-    brightCyan: SGR;
-    brightWhite: SGR;
-    rgb: (r: number, g: number, b: number) => SGR;
-    x256: {
-        (code: number): SGR;
-        (r: number, g: number, b: number): SGR;
-    };
-    default: string;
-}
-export type Color = {
-    fg: Channel;
-    bg: Channel;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/sgr/color/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sgr/color/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,QAAQ,CAAC;AAEhC,MAAM,WAAW,OAAO;IACvB,KAAK,EAAK,GAAG,CAAC;IACd,GAAG,EAAO,GAAG,CAAC;IACd,KAAK,EAAK,GAAG,CAAC;IACd,MAAM,EAAI,GAAG,CAAC;IACd,IAAI,EAAM,GAAG,CAAC;IACd,OAAO,EAAG,GAAG,CAAC;IACd,IAAI,EAAM,GAAG,CAAC;IACd,KAAK,EAAK,GAAG,CAAC;IAEd,WAAW,EAAK,GAAG,CAAC;IACpB,SAAS,EAAO,GAAG,CAAC;IACpB,WAAW,EAAK,GAAG,CAAC;IACpB,YAAY,EAAI,GAAG,CAAC;IACpB,UAAU,EAAM,GAAG,CAAC;IACpB,aAAa,EAAG,GAAG,CAAC;IACpB,UAAU,EAAM,GAAG,CAAC;IACpB,WAAW,EAAK,GAAG,CAAC;IAEpB,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,GAAG,CAAC;IAE9C,IAAI,EAAE;QACL,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC;QACpB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;KACvC,CAAC;IAEF,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,KAAK,GAAG;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAC,CAAC"}

package/dist/sgr/utils.d.ts

@@ -1,3 +0,0 @@
-import type { Code } from "./sgr";
-export declare function combine(code: Code, codes: Code[]): Code;
-//# sourceMappingURL=utils.d.ts.map

package/dist/sgr/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/sgr/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,OAAO,CAAC;AAEhC,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,CAcvD"}

package/dist/sgr/utils.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.combine = combine;
-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;
-}
-//# sourceMappingURL=utils.js.map

package/dist/sgr/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/sgr/utils.ts"],"names":[],"mappings":";;AAEA,0BAcC;AAdD,SAAgB,OAAO,CAAC,IAAU,EAAE,KAAa;IAChD,IAAI,CAAC,KAAK,CAAC,MAAM;QAChB,OAAO,IAAI,CAAC;IAEb,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAErD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACvB,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;YACnB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;;YAEf,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACd,CAAC;IAED,OAAO,GAAG,CAAC;AACZ,CAAC"}

package/src/sgr/color/types.ts

@@ -1,32 +0,0 @@
-import type {SGR} from "../sgr";
-
-export interface Channel {
-	black   : SGR;
-	red     : SGR;
-	green   : SGR;
-	yellow  : SGR;
-	blue    : SGR;
-	magenta : SGR;
-	cyan    : SGR;
-	white   : SGR;
-
-	brightBlack   : SGR;
-	brightRed     : SGR;
-	brightGreen   : SGR;
-	brightYellow  : SGR;
-	brightBlue    : SGR;
-	brightMagenta : SGR;
-	brightCyan    : SGR;
-	brightWhite   : SGR;
-
-	rgb: (r: number, g: number, b: number) => SGR;
-
-	x256: {
-		(code: number): SGR;
-		(r: number, g: number, b: number): SGR;
-	};
-
-	default: string;
-}
-
-export type Color = {fg: Channel; bg: Channel};

package/src/sgr/utils.ts

@@ -1,17 +0,0 @@
-import type {Code} from "./sgr";
-
-export function combine(code: Code, codes: Code[]): Code {
-	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;
-}