@peteanderson/ansi 0.1.0 → 0.1.2

package/README.md

@@ -13,38 +13,63 @@ npm install @peteanderson/ansi
 ```js
 const ansi = require("@peteanderson/ansi");
 
-console.log(ansi.fg.red + "error: something went wrong" + ansi.fg.default);
-console.log(ansi.bg.blue + ansi.fg.white + "highlighted" + ansi.fg.default + ansi.bg.default);
-console.log(ansi.erase.screen);
-console.log(ansi.caret.show);
+console.log(ansi.fg.red("error: something went wrong"));
+console.log(ansi.bg.blue(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
+console.log(ansi.slice("styled text", 0, 5)); // slice by visible length
 ```
 
 ## API
 
 ### `fg` — foreground colors
 
-Raw ANSI open sequences: `black` `red` `green` `yellow` `blue` `magenta` `cyan` `white` `default`
+Functions that wrap text with color codes:
+
+- Basic colors: `black` `red` `green` `yellow` `blue` `magenta` `cyan` `white` `default`
+- 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
+
+All return functions with `open` and `close` properties for raw sequences.
 
 ### `bg` — background colors
 
-Raw ANSI open sequences: `black` `red` `green` `yellow` `blue` `magenta` `cyan` `white` `default`
+Functions that wrap text with color codes:
+
+- Basic colors: `black` `red` `green` `yellow` `blue` `magenta` `cyan` `white` `default`
+- 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
 
 ### `style`
 
-`underline` `reverse` (raw sequences)
+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.
 
 ### `caret`
 
-- `show` / `hide` - show or hide the cursor
-- `position.get` - get the current cursor position (terminal sends position to stdin)
-- `position.set(row, col)` - set cursor position (1-based indexing)
-- `shape.block` / `shape.underline` / `shape.bar` - change cursor shape
+- `caret.show` / `caret.hide` - show or hide the cursor
+- `caret.position.get` - get the current cursor position (terminal sends position to stdin)
+- `caret.position.set(row, col)` - set cursor position (1-based indexing)
+- `caret.shape.block` / `caret.shape.underline` / `caret.shape.bar` - change cursor shape
+- `caret.up(n)` / `caret.down(n)` / `caret.forward(n)` / `caret.backward(n)` - move cursor
+- `caret.nextLine(n)` / `caret.prevLine(n)` - move cursor to next/previous line
+- `caret.x(col)` - move cursor to column (1-based)
+- `caret.save` / `caret.restore` - save/restore cursor position (VT100)
 
 ### `erase`
 
-Raw sequences:
-- `erase.line.toStart` / `erase.line.toEnd` / `erase.line.full`
-- `erase.screen`
+- `erase.line.toStart` / `erase.line.toEnd` / `erase.line.full` - erase line
+- `erase.screen.toStart` / `erase.screen.toEnd` / `erase.screen.full` - erase screen
+- `erase.screen.scrollback` - erase screen and scrollback buffer
 
 ### `scroll`
 
@@ -53,7 +78,16 @@ Raw sequences:
 
 ### `strip(text)`
 
-Removes ANSI CSI sequences from a string.
+Removes all ANSI CSI sequences from a string.
+
+### `slice(text, start, end)`
+
+Slices a string by visible characters, ignoring ANSI sequences. Works like `String.prototype.slice`
+but counts only visible characters.
+
+### `sanitize(text)`
+
+Removes "unsafe" CSI sequences (non-SGR), leaving only color and style codes.
 
 ## License
 

package/dist/ansi.d.ts

@@ -1,64 +1,13 @@
-export let reset: string;
-export let underline: string;
-export let reverse: string;
-export namespace fg {
-    export let black: string;
-    export let red: string;
-    export let green: string;
-    export let yellow: string;
-    export let blue: string;
-    export let magenta: string;
-    export let cyan: string;
-    export let white: string;
-    let _default: string;
-    export { _default as default };
-    export let rgb: (r: number, g: number, b: number) => string;
-}
-export namespace bg {
-    let black_1: string;
-    export { black_1 as black };
-    let red_1: string;
-    export { red_1 as red };
-    let green_1: string;
-    export { green_1 as green };
-    let yellow_1: string;
-    export { yellow_1 as yellow };
-    let blue_1: string;
-    export { blue_1 as blue };
-    let magenta_1: string;
-    export { magenta_1 as magenta };
-    let cyan_1: string;
-    export { cyan_1 as cyan };
-    let white_1: string;
-    export { white_1 as white };
-    let _default_1: string;
-    export { _default_1 as default };
-    let rgb_1: (r: number, g: number, b: number) => string;
-    export { rgb_1 as rgb };
-}
-export namespace erase {
-    let toLineStart: string;
-    let toLineEnd: string;
-    let line: string;
-    let screen: string;
-}
-export namespace caret {
-    let hide: string;
-    let show: string;
-    namespace position {
-        let get: string;
-        let set: (x: number, y: number) => string;
-    }
-    namespace shape {
-        export let steadyBlock: string;
-        export let steadyBar: string;
-        export let steadyUnderline: string;
-        export let blinkingBlock: string;
-        export let blinkingBar: string;
-        export let blinkingUnderline: string;
-        let _default_2: string;
-        export { _default_2 as default };
-    }
-}
-export let scrollUp: (lines: number) => string;
-export let scrollDown: (lines: number) => string;
+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 { strip } from "./strip";
+import { sanitize } from "./strip";
+import { slice } from "./strip";
+export { colorDepth, enabled, caret, erase, scroll, reset, style, fg, bg, strip, sanitize, slice };

package/dist/ansi.js

@@ -1,75 +1,22 @@
 "use strict";
-/** @type {(r: number, g: number, b: number, code: number) => string} */
-function rgb(r, g, b, code) {
-    if (r === g && g === b) {
-        // Grayscale range.
-        if (r >= 232 && r <= 255)
-            return `\x1b[${code};5;${r}m`;
-    }
-    else if (r >= 0 && r <= 5 && g >= 0 && g <= 5 && b >= 0 && b <= 5) {
-        // 6x6x6 color cube.
-        const code = 16 + r * 36 + g * 6 + b;
-        return `\x1b[${code};5;${code}m`;
-    }
-    return `\x1b[${code};2;${r};${g};${b}m`;
-}
+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 = {
-    reset: "\x1b[0m",
-    underline: "\x1b[4m",
-    reverse: "\x1b[7m",
-    fg: {
-        black: "\x1b[30m",
-        red: "\x1b[31m",
-        green: "\x1b[32m",
-        yellow: "\x1b[33m",
-        blue: "\x1b[34m",
-        magenta: "\x1b[35m",
-        cyan: "\x1b[36m",
-        white: "\x1b[37m",
-        default: "\x1b[39m",
-        /** @type {(r: number, g: number, b: number) => string} */
-        rgb: (r, g, b) => rgb(r, g, b, 38),
-    },
-    bg: {
-        black: "\x1b[40m",
-        red: "\x1b[41m",
-        green: "\x1b[42m",
-        yellow: "\x1b[43m",
-        blue: "\x1b[44m",
-        magenta: "\x1b[45m",
-        cyan: "\x1b[46m",
-        white: "\x1b[47m",
-        default: "\x1b[49m",
-        /** @type {(r: number, g: number, b: number) => string} */
-        rgb: (r, g, b) => rgb(r, g, b, 48),
-    },
-    erase: {
-        toLineStart: "\x1b[1K",
-        toLineEnd: "\x1b[0K",
-        line: "\x1b[2K",
-        screen: "\x1b[2J",
-    },
-    caret: {
-        hide: "\x1b[?25l",
-        show: "\x1b[?25h",
-        position: {
-            get: "\x1b[6n",
-            /** @type {(x: number, y: number) => string} */
-            set: (x, y) => `\x1b[${y + 1};${x + 1}H`,
-        },
-        shape: {
-            steadyBlock: "\x1b[2 q",
-            steadyBar: "\x1b[6 q",
-            steadyUnderline: "\x1b[4 q",
-            blinkingBlock: "\x1b[1 q",
-            blinkingBar: "\x1b[5 q",
-            blinkingUnderline: "\x1b[3 q",
-            default: "\x1b[0 q",
-        },
-    },
-    /** @type {(lines: number) => string} */
-    scrollUp: lines => `\x1b[${lines}S`,
-    /** @type {(lines: number) => string} */
-    scrollDown: lines => `\x1b[${lines}T`,
+    colorDepth,
+    enabled,
+    caret,
+    erase,
+    scroll,
+    reset,
+    style,
+    fg,
+    bg,
+    strip,
+    sanitize,
+    slice,
 };
 module.exports = ansi;

package/dist/caps.d.ts

@@ -0,0 +1,10 @@
+export namespace colorDepth {
+    let stdout: number;
+    let stderr: number;
+}
+export namespace enabled {
+    let stdout_1: boolean;
+    export { stdout_1 as stdout };
+    let stderr_1: boolean;
+    export { stderr_1 as stderr };
+}

package/dist/caps.js

@@ -0,0 +1,22 @@
+"use strict";
+/** @type {(stream: NodeJS.WriteStream) => number} */
+const getColorDepth = (stream) => stream.isTTY ?
+    stream.getColorDepth() :
+    process.env.FORCE_COLOR !== undefined ?
+        ["1", "true", ""].includes(process.env.FORCE_COLOR) ?
+            4 :
+            process.env.FORCE_COLOR === "2" ?
+                8 :
+                process.env.FORCE_COLOR === "3" ?
+                    24 :
+                    1 :
+        1;
+const colorDepth = {
+    stdout: getColorDepth(process.stdout),
+    stderr: getColorDepth(process.stderr),
+};
+const enabled = {
+    stdout: colorDepth.stdout > 1,
+    stderr: colorDepth.stderr > 1,
+};
+module.exports = { colorDepth, enabled };

package/dist/caret.d.ts

@@ -0,0 +1,25 @@
+export let up: (count?: number) => string;
+export let down: (count?: number) => string;
+export let forward: (count?: number) => string;
+export let backward: (count?: number) => string;
+export let nextLine: (count?: number) => string;
+export let prevLine: (count?: number) => string;
+export let x: (x: number) => string;
+export let save: string;
+export let restore: string;
+export let hide: string;
+export let show: string;
+export namespace position {
+    let get: string;
+    let set: (x: number, y: number) => string;
+}
+export namespace shape {
+    export let steadyBlock: string;
+    export let steadyBar: string;
+    export let steadyUnderline: string;
+    export let blinkingBlock: string;
+    export let blinkingBar: string;
+    export let blinkingUnderline: string;
+    let _default: string;
+    export { _default as default };
+}

package/dist/caret.js

@@ -0,0 +1,40 @@
+"use strict";
+/** @type {(code: string) => (count?: number) => string} */
+const move = code => count => `\x1b[${count === undefined ? "" : count ? count : "?"}${code}`;
+const caret = {
+    up: move("A"),
+    down: move("B"),
+    forward: move("C"),
+    backward: move("D"),
+    nextLine: move("E"),
+    prevLine: move("F"),
+    /** @type {(x: number) => string} */
+    x: x => `\x1b[${x}G`,
+    // These are the old VT100 codes, but they're widely supported by old and new terminals. The
+    // newer VT220 codes are standardized by ECMA and ISO, and are also widely supported, but might
+    // not work in some older terminals. The VT220 codes are:
+    //
+    // ```
+    // save    : "\x1b[s",
+    // restore : "\x1b[u",
+    // ```
+    save: "\x1b7",
+    restore: "\x1b8",
+    hide: "\x1b[?25l",
+    show: "\x1b[?25h",
+    position: {
+        get: "\x1b[6n",
+        /** @type {(x: number, y: number) => string} */
+        set: (x, y) => `\x1b[${y};${x}H`,
+    },
+    shape: {
+        steadyBlock: "\x1b[2 q",
+        steadyBar: "\x1b[6 q",
+        steadyUnderline: "\x1b[4 q",
+        blinkingBlock: "\x1b[1 q",
+        blinkingBar: "\x1b[5 q",
+        blinkingUnderline: "\x1b[3 q",
+        default: "\x1b[0 q",
+    },
+};
+module.exports = caret;

package/dist/erase.d.ts

@@ -0,0 +1,14 @@
+export namespace line {
+    let toStart: string;
+    let toEnd: string;
+    let full: string;
+}
+export namespace screen {
+    let toStart_1: string;
+    export { toStart_1 as toStart };
+    let toEnd_1: string;
+    export { toEnd_1 as toEnd };
+    let full_1: string;
+    export { full_1 as full };
+    export let scrollback: string;
+}

package/dist/erase.js

@@ -0,0 +1,15 @@
+"use strict";
+const erase = {
+    line: {
+        toStart: "\x1b[1K",
+        toEnd: "\x1b[0K",
+        full: "\x1b[2K",
+    },
+    screen: {
+        toStart: "\x1b[1J",
+        toEnd: "\x1b[0J",
+        full: "\x1b[2J",
+        scrollback: "\x1b[3J",
+    },
+};
+module.exports = erase;

package/dist/index.d.ts

@@ -0,0 +1,242 @@
+declare const _exports: {
+    colorDepth: {
+        stdout: number;
+        stderr: number;
+    };
+    enabled: {
+        stdout: boolean;
+        stderr: boolean;
+    };
+    caret: {
+        up: (count?: number) => string;
+        down: (count?: number) => string;
+        forward: (count?: number) => string;
+        backward: (count?: number) => string;
+        nextLine: (count?: number) => string;
+        prevLine: (count?: number) => string;
+        x: (x: number) => string;
+        save: string;
+        restore: string;
+        hide: string;
+        show: string;
+        position: {
+            get: string;
+            set: (x: number, y: number) => string;
+        };
+        shape: {
+            steadyBlock: string;
+            steadyBar: string;
+            steadyUnderline: string;
+            blinkingBlock: string;
+            blinkingBar: string;
+            blinkingUnderline: string;
+            default: string;
+        };
+    };
+    erase: {
+        line: {
+            toStart: string;
+            toEnd: string;
+            full: string;
+        };
+        screen: {
+            toStart: string;
+            toEnd: string;
+            full: string;
+            scrollback: string;
+        };
+    };
+    scroll: {
+        up: (lines?: number) => string;
+        down: (lines?: number) => string;
+    };
+    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;
+        };
+    };
+    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;
+        };
+        default: string;
+        rgb: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (r: number, g: number, b: 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;
+        };
+        default: string;
+        rgb: (r: number, g: number, b: number) => (text: string) => string;
+        x256: (r: number, g: number, b: number) => (text: string) => string;
+    };
+    strip: (text: string) => string;
+    sanitize: (text: string) => string;
+    slice: typeof import("./strip").slice;
+};
+export = _exports;

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./ansi");

package/dist/scroll.d.ts

@@ -0,0 +1,2 @@
+export let up: (lines?: number) => string;
+export let down: (lines?: number) => string;

package/dist/scroll.js

@@ -0,0 +1,8 @@
+"use strict";
+const scroll = {
+    /** @type {(lines?: number) => string} */
+    up: lines => `\x1b[${lines ?? 1}S`,
+    /** @type {(lines?: number) => string} */
+    down: lines => `\x1b[${lines ?? 1}T`,
+};
+module.exports = scroll;