@peteanderson/ansi 0.1.2 → 0.2.1

package/README.md

@@ -14,7 +14,7 @@ npm install @peteanderson/ansi
 const ansi = require("@peteanderson/ansi");
 
 console.log(ansi.fg.red("error: something went wrong"));
-console.log(ansi.bg.blue(ansi.fg.white("highlighted")));
+console.log(ansi.bg.blue.combine(ansi.fg.white)("highlighted"));
 console.log(ansi.style.bold("important"));
 console.log(ansi.fg.rgb(5, 2, 0)("custom color"));
 console.log(ansi.strip("styled text")); // remove all ANSI codes
@@ -31,7 +31,7 @@ Functions that wrap text with color codes:
 - Bright colors: `brightBlack` `brightRed` `brightGreen` `brightYellow` `brightBlue` `brightMagenta`
   `brightCyan` `brightWhite`
 - `fg.rgb(r, g, b)(text)` - 24-bit RGB color (r, g, b in 0–5 or grayscale 232–255)
-- `fg.x256(code)(text)` - 256-color palette
+- `fg.x256(code)(text)` or `fg.x256(r, g, b)(text)` - 256-color palette
 
 All return functions with `open` and `close` properties for raw sequences.
 
@@ -43,7 +43,7 @@ Functions that wrap text with color codes:
 - Bright colors: `brightBlack` `brightRed` `brightGreen` `brightYellow` `brightBlue` `brightMagenta`
   `brightCyan` `brightWhite`
 - `bg.rgb(r, g, b)(text)` - 24-bit RGB color
-- `bg.x256(code)(text)` - 256-color palette
+- `bg.x256(code)(text)` or `bg.x256(r, g, b)(text)` - 256-color palette
 
 ### `style`
 
@@ -52,7 +52,8 @@ Functions that wrap text with style codes:
 `bold` `dim` `italic` `underline` `inverse` `hidden` `strikethrough` `doubleUnderline` `framed`
 `encircled` `overline`
 
-All return functions with `open` and `close` properties for raw sequences.
+All return functions with `open` and `close` properties for raw sequences. SGR functions also have a
+`combine()` method for appending additional styles.
 
 ### `caret`
 

package/dist/ansi.d.ts

@@ -1,13 +1,11 @@
-import { colorDepth } from "./caps";
-import { enabled } from "./caps";
 import caret = require("./caret");
 import erase = require("./erase");
 import scroll = require("./scroll");
-import { reset } from "./sgr";
-import { style } from "./sgr";
-import { fg } from "./sgr";
-import { bg } from "./sgr";
+import { reset } from "./sgr/reset";
+import { style } from "./sgr/style";
+import { fg } from "./sgr/color";
+import { bg } from "./sgr/color";
 import { strip } from "./strip";
 import { sanitize } from "./strip";
 import { slice } from "./strip";
-export { colorDepth, enabled, caret, erase, scroll, reset, style, fg, bg, strip, sanitize, slice };
+export { caret, erase, scroll, reset, style, fg, bg, strip, sanitize, slice };

package/dist/ansi.js

@@ -1,13 +1,10 @@
 "use strict";
-const { colorDepth, enabled } = require("./caps");
 const caret = require("./caret");
 const erase = require("./erase");
 const scroll = require("./scroll");
 const { bg, fg, reset, style } = require("./sgr");
 const { sanitize, slice, strip } = require("./strip");
 const ansi = {
-    colorDepth,
-    enabled,
     caret,
     erase,
     scroll,

package/dist/index.d.ts

@@ -1,12 +1,4 @@
 declare const _exports: {
-    colorDepth: {
-        stdout: number;
-        stderr: number;
-    };
-    enabled: {
-        stdout: boolean;
-        stderr: boolean;
-    };
     caret: {
         up: (count?: number) => string;
         down: (count?: number) => string;
@@ -52,188 +44,59 @@ declare const _exports: {
     };
     reset: string;
     style: {
-        bold: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        dim: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        italic: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        underline: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        inverse: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        hidden: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        strikethrough: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        doubleUnderline: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        frame: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        encircle: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        overline: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
+        bold: import("./sgr/sgr").SGR;
+        dim: import("./sgr/sgr").SGR;
+        italic: import("./sgr/sgr").SGR;
+        underline: import("./sgr/sgr").SGR;
+        inverse: import("./sgr/sgr").SGR;
+        hidden: import("./sgr/sgr").SGR;
+        strikethrough: import("./sgr/sgr").SGR;
+        doubleUnderline: import("./sgr/sgr").SGR;
+        frame: import("./sgr/sgr").SGR;
+        encircle: import("./sgr/sgr").SGR;
+        overline: import("./sgr/sgr").SGR;
     };
     fg: {
-        black: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        red: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        green: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        yellow: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        blue: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        magenta: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        cyan: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        white: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightBlack: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightRed: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightGreen: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightYellow: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightBlue: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightMagenta: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightCyan: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightWhite: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
+        black: import("./sgr/sgr").SGR;
+        red: import("./sgr/sgr").SGR;
+        green: import("./sgr/sgr").SGR;
+        yellow: import("./sgr/sgr").SGR;
+        blue: import("./sgr/sgr").SGR;
+        magenta: import("./sgr/sgr").SGR;
+        cyan: import("./sgr/sgr").SGR;
+        white: import("./sgr/sgr").SGR;
+        brightBlack: import("./sgr/sgr").SGR;
+        brightRed: import("./sgr/sgr").SGR;
+        brightGreen: import("./sgr/sgr").SGR;
+        brightYellow: import("./sgr/sgr").SGR;
+        brightBlue: import("./sgr/sgr").SGR;
+        brightMagenta: import("./sgr/sgr").SGR;
+        brightCyan: import("./sgr/sgr").SGR;
+        brightWhite: import("./sgr/sgr").SGR;
         default: string;
         rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
     };
     bg: {
-        black: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        red: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        green: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        yellow: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        blue: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        magenta: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        cyan: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        white: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightBlack: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightRed: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightGreen: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightYellow: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightBlue: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightMagenta: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightCyan: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
-        brightWhite: ((s: string) => string) & {
-            open: string;
-            close: string;
-        };
+        black: import("./sgr/sgr").SGR;
+        red: import("./sgr/sgr").SGR;
+        green: import("./sgr/sgr").SGR;
+        yellow: import("./sgr/sgr").SGR;
+        blue: import("./sgr/sgr").SGR;
+        magenta: import("./sgr/sgr").SGR;
+        cyan: import("./sgr/sgr").SGR;
+        white: import("./sgr/sgr").SGR;
+        brightBlack: import("./sgr/sgr").SGR;
+        brightRed: import("./sgr/sgr").SGR;
+        brightGreen: import("./sgr/sgr").SGR;
+        brightYellow: import("./sgr/sgr").SGR;
+        brightBlue: import("./sgr/sgr").SGR;
+        brightMagenta: import("./sgr/sgr").SGR;
+        brightCyan: import("./sgr/sgr").SGR;
+        brightWhite: import("./sgr/sgr").SGR;
         default: string;
         rgb: (r: number, g: number, b: number) => (text: string) => string;
-        x256: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
     };
     strip: (text: string) => string;
     sanitize: (text: string) => string;

package/dist/sgr/color.d.ts

@@ -0,0 +1,62 @@
+export namespace fg {
+    export let black: import("./sgr").SGR;
+    export let red: import("./sgr").SGR;
+    export let green: import("./sgr").SGR;
+    export let yellow: import("./sgr").SGR;
+    export let blue: import("./sgr").SGR;
+    export let magenta: import("./sgr").SGR;
+    export let cyan: import("./sgr").SGR;
+    export let white: import("./sgr").SGR;
+    export let brightBlack: import("./sgr").SGR;
+    export let brightRed: import("./sgr").SGR;
+    export let brightGreen: import("./sgr").SGR;
+    export let brightYellow: import("./sgr").SGR;
+    export let brightBlue: import("./sgr").SGR;
+    export let brightMagenta: import("./sgr").SGR;
+    export let brightCyan: import("./sgr").SGR;
+    export let brightWhite: import("./sgr").SGR;
+    let _default: string;
+    export { _default as default };
+    export let rgb: (r: number, g: number, b: number) => (text: string) => string;
+    export let x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
+}
+export namespace bg {
+    let black_1: import("./sgr").SGR;
+    export { black_1 as black };
+    let red_1: import("./sgr").SGR;
+    export { red_1 as red };
+    let green_1: import("./sgr").SGR;
+    export { green_1 as green };
+    let yellow_1: import("./sgr").SGR;
+    export { yellow_1 as yellow };
+    let blue_1: import("./sgr").SGR;
+    export { blue_1 as blue };
+    let magenta_1: import("./sgr").SGR;
+    export { magenta_1 as magenta };
+    let cyan_1: import("./sgr").SGR;
+    export { cyan_1 as cyan };
+    let white_1: import("./sgr").SGR;
+    export { white_1 as white };
+    let brightBlack_1: import("./sgr").SGR;
+    export { brightBlack_1 as brightBlack };
+    let brightRed_1: import("./sgr").SGR;
+    export { brightRed_1 as brightRed };
+    let brightGreen_1: import("./sgr").SGR;
+    export { brightGreen_1 as brightGreen };
+    let brightYellow_1: import("./sgr").SGR;
+    export { brightYellow_1 as brightYellow };
+    let brightBlue_1: import("./sgr").SGR;
+    export { brightBlue_1 as brightBlue };
+    let brightMagenta_1: import("./sgr").SGR;
+    export { brightMagenta_1 as brightMagenta };
+    let brightCyan_1: import("./sgr").SGR;
+    export { brightCyan_1 as brightCyan };
+    let brightWhite_1: import("./sgr").SGR;
+    export { brightWhite_1 as brightWhite };
+    let _default_1: string;
+    export { _default_1 as default };
+    let rgb_1: (r: number, g: number, b: number) => (text: string) => string;
+    export { rgb_1 as rgb };
+    let x256_1: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
+    export { x256_1 as x256 };
+}

package/dist/sgr/color.js

@@ -0,0 +1,111 @@
+"use strict";
+const { sgr } = require("./sgr");
+/** @type {(r: number, g: number, b: number, open: number, close: number) => (text: string) => string} */
+const rgb = (r, g, b, open, close) => sgr([open, 2, r, g, b], close);
+/**
+ * @overload
+ * @param {number} code
+ * @param {number} open
+ * @param {number} close
+ * @returns {(text: string) => string}
+ */ /**
+* @overload
+* @param {number} r
+* @param {number} g
+* @param {number} b
+* @param {number} open
+* @param {number} close
+* @returns {(text: string) => string}
+*/ /**
+@type {
+   (
+       ...args: [number, number, number] | [number, number, number, number, number]
+   ) => (text: string) => string}
+*/
+function x256(...args) {
+    if (args.length === 3)
+        return sgr([args[1], 5, args[0]], args[2]);
+    const [r, g, b, open, close] = args;
+    if (r === g && g === b) {
+        // grayscale
+        return sgr([open, 5, 232 + Math.floor(r * 24 / 256)], close);
+    }
+    // 6x6x6 color cube
+    return sgr([
+        open,
+        5,
+        16 +
+            Math.floor(r * 6 / 256) * 36 +
+            Math.floor(g * 6 / 256) * 6 +
+            Math.floor(b * 6 / 256)
+    ], close);
+}
+const fg = {
+    black: sgr(30, 39),
+    red: sgr(31, 39),
+    green: sgr(32, 39),
+    yellow: sgr(33, 39),
+    blue: sgr(34, 39),
+    magenta: sgr(35, 39),
+    cyan: sgr(36, 39),
+    white: sgr(37, 39),
+    brightBlack: sgr(90, 39),
+    brightRed: sgr(91, 39),
+    brightGreen: sgr(92, 39),
+    brightYellow: sgr(93, 39),
+    brightBlue: sgr(94, 39),
+    brightMagenta: sgr(95, 39),
+    brightCyan: sgr(96, 39),
+    brightWhite: sgr(97, 39),
+    default: "\x1b[39m",
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    rgb: (r, g, b) => rgb(r, g, b, 38, 39),
+    /**
+     * @overload
+     * @param {number} code
+     * @returns {(text: string) => string}
+     */ /**
+    * @param {number} r
+    * @param {number} g
+    * @param {number} b
+    * @returns {(text: string) => string}
+    */ /** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+    x256: (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+        ? x256(arg0, 38, 39)
+        : x256(arg0, arg1, arg2, 38, 39),
+};
+const bg = {
+    black: sgr(40, 49),
+    red: sgr(41, 49),
+    green: sgr(42, 49),
+    yellow: sgr(43, 49),
+    blue: sgr(44, 49),
+    magenta: sgr(45, 49),
+    cyan: sgr(46, 49),
+    white: sgr(47, 49),
+    brightBlack: sgr(100, 49),
+    brightRed: sgr(101, 49),
+    brightGreen: sgr(102, 49),
+    brightYellow: sgr(103, 49),
+    brightBlue: sgr(104, 49),
+    brightMagenta: sgr(105, 49),
+    brightCyan: sgr(106, 49),
+    brightWhite: sgr(107, 49),
+    default: "\x1b[49m",
+    /** @type {(r: number, g: number, b: number) => (text: string) => string} */
+    rgb: (r, g, b) => rgb(r, g, b, 48, 49),
+    /**
+     * @overload
+     * @param {number} code
+     * @returns {(text: string) => string}
+     */ /**
+    * @param {number} r
+    * @param {number} g
+    * @param {number} b
+    * @returns {(text: string) => string}
+    */ /** @type {(arg0: number, arg1?: number, arg2?: number) => (text: string) => string} */
+    x256: (arg0, arg1, arg2) => arg1 === undefined || arg2 === undefined
+        ? x256(arg0, 48, 49)
+        : x256(arg0, arg1, arg2, 48, 49),
+};
+module.exports = { fg, bg };

package/dist/sgr/index.d.ts

@@ -0,0 +1,59 @@
+declare const _exports: {
+    fg: {
+        black: import("./sgr").SGR;
+        red: import("./sgr").SGR;
+        green: import("./sgr").SGR;
+        yellow: import("./sgr").SGR;
+        blue: import("./sgr").SGR;
+        magenta: import("./sgr").SGR;
+        cyan: import("./sgr").SGR;
+        white: import("./sgr").SGR;
+        brightBlack: import("./sgr").SGR;
+        brightRed: import("./sgr").SGR;
+        brightGreen: import("./sgr").SGR;
+        brightYellow: import("./sgr").SGR;
+        brightBlue: import("./sgr").SGR;
+        brightMagenta: import("./sgr").SGR;
+        brightCyan: import("./sgr").SGR;
+        brightWhite: import("./sgr").SGR;
+        default: string;
+        rgb: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
+    };
+    bg: {
+        black: import("./sgr").SGR;
+        red: import("./sgr").SGR;
+        green: import("./sgr").SGR;
+        yellow: import("./sgr").SGR;
+        blue: import("./sgr").SGR;
+        magenta: import("./sgr").SGR;
+        cyan: import("./sgr").SGR;
+        white: import("./sgr").SGR;
+        brightBlack: import("./sgr").SGR;
+        brightRed: import("./sgr").SGR;
+        brightGreen: import("./sgr").SGR;
+        brightYellow: import("./sgr").SGR;
+        brightBlue: import("./sgr").SGR;
+        brightMagenta: import("./sgr").SGR;
+        brightCyan: import("./sgr").SGR;
+        brightWhite: import("./sgr").SGR;
+        default: string;
+        rgb: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (arg0: number, arg1?: number, arg2?: number) => (text: string) => string;
+    };
+    style: {
+        bold: import("./sgr").SGR;
+        dim: import("./sgr").SGR;
+        italic: import("./sgr").SGR;
+        underline: import("./sgr").SGR;
+        inverse: import("./sgr").SGR;
+        hidden: import("./sgr").SGR;
+        strikethrough: import("./sgr").SGR;
+        doubleUnderline: import("./sgr").SGR;
+        frame: import("./sgr").SGR;
+        encircle: import("./sgr").SGR;
+        overline: import("./sgr").SGR;
+    };
+    reset: "\u001B[0m";
+};
+export = _exports;

package/dist/sgr/index.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = {
+    ...require("./reset"),
+    ...require("./style"),
+    ...require("./color"),
+};

package/dist/sgr/reset.d.ts

@@ -0,0 +1 @@
+export const reset: "\u001B[0m";

package/dist/sgr/reset.js

@@ -0,0 +1,3 @@
+"use strict";
+const reset = "\x1b[0m";
+module.exports = { reset };

package/dist/sgr/sgr.d.ts

@@ -0,0 +1,14 @@
+export type Code = number | number[];
+export type SGR = {
+    (text: string): string;
+    open: string;
+    close: string;
+    [$codes]: {
+        open: Code;
+        close: Code;
+    };
+    combine: (...styles: SGR[]) => SGR;
+};
+export function sgr(open: Code, close: Code, reset?: boolean): SGR;
+declare const $codes: unique symbol;
+export {};

package/dist/sgr/sgr.js

@@ -0,0 +1,47 @@
+"use strict";
+const $codes = Symbol();
+/**
+@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 => openSequence + s.replace(rxClose, replace) + closeSequence;
+    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))),
+    });
+}
+module.exports = { sgr };

package/dist/sgr/style.d.ts

@@ -0,0 +1,13 @@
+export namespace style {
+    let bold: import("./sgr").SGR;
+    let dim: import("./sgr").SGR;
+    let italic: import("./sgr").SGR;
+    let underline: import("./sgr").SGR;
+    let inverse: import("./sgr").SGR;
+    let hidden: import("./sgr").SGR;
+    let strikethrough: import("./sgr").SGR;
+    let doubleUnderline: import("./sgr").SGR;
+    let frame: import("./sgr").SGR;
+    let encircle: import("./sgr").SGR;
+    let overline: import("./sgr").SGR;
+}

package/dist/sgr/style.js

@@ -0,0 +1,16 @@
+"use strict";
+const { sgr } = require("./sgr");
+const style = {
+    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),
+};
+module.exports = { style };

package/dist/sgr/utils.d.ts

@@ -0,0 +1,2 @@
+export type Code = number | number[];
+export function combine(code: Code, codes: Code[]): Code;