@figliolia/chalk-animation 1.0.0

package/README.md

@@ -0,0 +1,146 @@
+# chalk-animation
+
+[![Build Status](https://flat.badgen.net/github/checks/bokub/chalk-animation?label=tests)](https://github.com/bokub/chalk-animation/actions/workflows/run.yml)
+[![Version](https://runkit.io/bokub/npm-version/branches/master/chalk-animation?style=flat)](https://www.npmjs.com/package/chalk-animation)
+[![Codecov](https://flat.badgen.net/codecov/c/github/bokub/chalk-animation)](https://codecov.io/gh/bokub/chalk-animation)
+[![Downloads](https://flat.badgen.net/npm/dm/chalk-animation?color=FF9800)](https://www.npmjs.com/package/chalk-animation)
+[![XO code style](https://flat.badgen.net/badge/code%20style/XO/5ed9c7)](https://github.com/sindresorhus/xo)
+
+> Colorful animations in terminal output
+
+
+## Available animations
+
+|   Name    |                   Preview                  |
+|:---------:|:------------------------------------------:|
+|  rainbow  | ![rainbow](http://i.imgur.com/napdxdn.gif) |
+|   pulse   | ![pulse](http://i.imgur.com/xdaETwr.gif)   |
+|   glitch  | ![glitch](http://i.imgur.com/834FJU1.gif)  |
+|   radar   | ![radar](http://i.imgur.com/3bFrtRc.gif)   |
+|    neon   | ![neon](http://i.imgur.com/YdAAroI.gif)    |
+|  karaoke  | ![karaoke](https://i.imgur.com/lG7EF1t.gif)|
+
+
+## Install
+
+```bash
+$ npm i chalk-animation
+```
+
+
+## Usage
+
+```javascript
+import chalkAnimation from 'chalk-animation';
+
+chalkAnimation.rainbow('Lorem ipsum dolor sit amet');
+```
+
+#### Start and stop
+
+You can stop and resume an animation with `stop()` and `start()`.
+
+When created, the instance of chalkAnimation **starts automatically**.
+
+```javascript
+const rainbow = chalkAnimation.rainbow('Lorem ipsum'); // Animation starts
+
+setTimeout(() => {
+    rainbow.stop(); // Animation stops
+}, 1000);
+
+setTimeout(() => {
+    rainbow.start(); // Animation resumes
+}, 2000);
+
+```
+
+#### Automatic stop
+
+Anything printed to the console will stop the previous animation automatically
+
+```javascript
+chalkAnimation.rainbow('Lorem ipsum');
+setTimeout(() => {
+    // Stop the 'Lorem ipsum' animation, then write on a new line.
+    console.log('dolor sit amet');
+}, 1000);
+```
+
+#### Changing speed
+
+Change the animation speed using a second parameter. Should be greater than 0, default is 1.
+
+```javascript
+chalkAnimation.rainbow('Lorem ipsum', 2); // Two times faster than default
+```
+
+#### Changing text
+
+Change the animated text seamlessly with `replace()`
+
+```javascript
+let str = 'Loading...';
+const rainbow = chalkAnimation.rainbow(str);
+
+// Add a new dot every second
+setInterval(() => {
+	rainbow.replace(str += '.');
+}, 1000);
+```
+
+#### Manual rendering
+
+Manually render frames with `render()`, or get the content of the next frame with `frame()`
+
+```javascript
+const rainbow = chalkAnimation.rainbow('Lorem ipsum').stop(); // Don't start the animation
+
+rainbow.render(); // Display the first frame
+
+const frame = rainbow.frame(); // Get the second frame
+console.log(frame);
+```
+
+
+## CLI mode
+
+```bash
+# Install package globally
+$ npm install --global chalk-animation
+```
+
+```
+$ chalk-animation --help
+
+  Colorful animations in terminal output
+
+  Usage
+    $ chalk-animation <name> [options] [text...]
+
+  Options
+    --duration  Duration of the animation in ms, defaults to Infinity
+    --speed  Animation speed as number > 0, defaults to 1
+
+  Available animations
+    rainbow
+    pulse
+    glitch
+    radar
+    neon
+    karaoke
+
+  Example
+    $ chalk-animation rainbow Hello world!
+```
+
+
+## Related
+
+- [gradient-string](https://github.com/bokub/gradient-string) - Output gradients to terminal
+- [chalk](https://github.com/chalk/chalk) - Output colored text to terminal
+
+
+## License
+
+MIT © [Boris K](https://github.com/bokub)

package/dist/cjs/Animation.d.ts

@@ -0,0 +1,20 @@
+import type { AnimationFN } from "./types";
+import { InstanceTracker } from "./InstanceTracker";
+export declare class Animation extends InstanceTracker {
+    effect: any;
+    lines: number;
+    speed: number;
+    delay: number;
+    text: string[];
+    stopped: boolean;
+    currentFrame: number;
+    initialized: boolean;
+    controller: ReturnType<typeof setTimeout> | null;
+    constructor(effect: AnimationFN, str: string, delay?: number, speed?: number);
+    render(): void;
+    frame(): string;
+    replace(str: string): this;
+    stop(): this;
+    start(): this;
+    private clearFrames;
+}

package/dist/cjs/Animation.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animation = void 0;
+const InstanceTracker_1 = require("./InstanceTracker");
+class Animation extends InstanceTracker_1.InstanceTracker {
+    constructor(effect, str, delay = 0, speed = 0) {
+        super();
+        this.stopped = false;
+        this.currentFrame = 0;
+        this.initialized = false;
+        this.controller = null;
+        this.effect = effect;
+        this.speed = speed;
+        this.delay = delay;
+        this.text = str.split(/\r\n|\r|\n/);
+        this.lines = this.text.length;
+    }
+    render() {
+        if (!this.initialized) {
+            Animation.LOG("\n".repeat(this.lines - 1));
+            this.initialized = true;
+        }
+        Animation.LOG(this.frame());
+        this.controller = setTimeout(() => {
+            if (!this.stopped) {
+                this.render();
+            }
+        }, this.delay / this.speed);
+    }
+    frame() {
+        this.currentFrame++;
+        return ("\u001B[" +
+            `${this.lines}` +
+            "F\u001B[G\u001B[2K" +
+            this.text.map((str) => this.effect(str, this.currentFrame)).join("\n"));
+    }
+    replace(str) {
+        this.text = str.split(/\r\n|\r|\n/);
+        this.lines = this.text.length;
+        return this;
+    }
+    stop() {
+        this.clearFrames();
+        this.stopped = true;
+        return this;
+    }
+    start() {
+        this.clearFrames();
+        this.stopped = false;
+        this.render();
+        return this;
+    }
+    clearFrames() {
+        if (this.controller) {
+            clearTimeout(this.controller);
+            this.controller = null;
+        }
+    }
+}
+exports.Animation = Animation;

package/dist/cjs/ChalkAnimation.d.ts

@@ -0,0 +1,10 @@
+import { Animation } from "./Animation";
+export declare class ChalkAnimation {
+    static rainbow(str: string, speed?: number): Animation;
+    static pulse(str: string, speed?: number): Animation;
+    static glitch(str: string, speed?: number): Animation;
+    static radar(str: string, speed?: number): Animation;
+    static neon(str: string, speed?: number): Animation;
+    static karaoke(str: string, speed?: number): Animation;
+    static clearAllAnimations(): void;
+}

package/dist/cjs/ChalkAnimation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChalkAnimation = void 0;
+const Effects_1 = require("./Effects");
+const Animation_1 = require("./Animation");
+const animateString_1 = require("./animateString");
+class ChalkAnimation {
+    static rainbow(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.rainbow, str, 15, speed);
+    }
+    static pulse(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.pulse, str, 16, speed);
+    }
+    static glitch(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.glitch, str, 55, speed);
+    }
+    static radar(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.radar, str, 50, speed);
+    }
+    static neon(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.neon, str, 500, speed);
+    }
+    static karaoke(str, speed = 1) {
+        return (0, animateString_1.animateString)(Effects_1.Effects.karaoke, str, 50, speed);
+    }
+    static clearAllAnimations() {
+        return Animation_1.Animation.clearAll();
+    }
+}
+exports.ChalkAnimation = ChalkAnimation;

package/dist/cjs/Effects.d.ts

@@ -0,0 +1,13 @@
+export declare class Effects {
+    static longHsv: {
+        interpolation: string;
+        hsvSpin: string;
+    };
+    static glitchChars: string;
+    static rainbow(str: string, frame: number): string;
+    static pulse(str: string, frame: number): string;
+    static glitch(str: string, frame: number): string;
+    static radar(str: string, frame: number): string;
+    static neon(str: string, frame: number): string;
+    static karaoke(str: string, frame: number): string;
+}

package/dist/cjs/Effects.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Effects = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+class Effects {
+    static rainbow(str, frame) {
+        const hue = 5 * frame;
+        const leftColor = { h: hue % 360, s: 1, v: 1 };
+        const rightColor = { h: (hue + 1) % 360, s: 1, v: 1 };
+        return (0, gradient_string_1.default)(leftColor, rightColor)(str, Effects.longHsv);
+    }
+    static pulse(str, frame) {
+        frame = (frame % 120) + 1;
+        const transition = 6;
+        const duration = 10;
+        const on = "#ff1010";
+        const off = "#e6e6e6";
+        if (frame >= 2 * transition + duration) {
+            return chalk_1.default.hex(off)(str); // All white
+        }
+        if (frame >= transition && frame <= transition + duration) {
+            return chalk_1.default.hex(on)(str); // All red
+        }
+        frame =
+            frame >= transition + duration
+                ? 2 * transition + duration - frame
+                : frame; // Revert animation
+        const g = frame <= transition / 2
+            ? (0, gradient_string_1.default)([
+                { color: off, pos: 0.5 - frame / transition },
+                { color: on, pos: 0.5 },
+                { color: off, pos: 0.5 + frame / transition },
+            ])
+            : (0, gradient_string_1.default)([
+                { color: off, pos: 0 },
+                { color: on, pos: 1 - frame / transition },
+                { color: on, pos: frame / transition },
+                { color: off, pos: 1 },
+            ]);
+        return g(str);
+    }
+    static glitch(str, frame) {
+        if ((frame % 2) + (frame % 3) + (frame % 11) + (frame % 29) + (frame % 37) >
+            52) {
+            return str.replace(/[^\r\n]/g, " ");
+        }
+        const chunkSize = Math.max(3, Math.round(str.length * 0.02));
+        const chunks = [];
+        for (let i = 0, length = str.length; i < length; i++) {
+            const skip = Math.round(Math.max(0, (Math.random() - 0.8) * chunkSize));
+            chunks.push(str.substring(i, i + skip).replace(/[^\r\n]/g, " "));
+            i += skip;
+            if (str[i]) {
+                if (str[i] !== "\n" && str[i] !== "\r" && Math.random() > 0.995) {
+                    chunks.push(Effects.glitchChars[Math.floor(Math.random() * Effects.glitchChars.length)]);
+                }
+                else if (Math.random() > 0.005) {
+                    chunks.push(str[i]);
+                }
+            }
+        }
+        let result = chunks.join("");
+        if (Math.random() > 0.99) {
+            result = result.toUpperCase();
+        }
+        else if (Math.random() < 0.01) {
+            result = result.toLowerCase();
+        }
+        return result;
+    }
+    static radar(str, frame) {
+        const depth = Math.floor(Math.min(str.length, str.length * 0.2));
+        const step = Math.floor(255 / depth);
+        const globalPos = frame % (str.length + depth);
+        const chars = [];
+        for (let i = 0, length = str.length; i < length; i++) {
+            const pos = -(i - globalPos);
+            if (pos > 0 && pos <= depth - 1) {
+                const shade = (depth - pos) * step;
+                chars.push(chalk_1.default.rgb(shade, shade, shade)(str[i]));
+            }
+            else {
+                chars.push(" ");
+            }
+        }
+        return chars.join("");
+    }
+    static neon(str, frame) {
+        const color = frame % 2 === 0
+            ? chalk_1.default.dim.rgb(88, 80, 85)
+            : chalk_1.default.bold.rgb(213, 70, 242);
+        return color(str);
+    }
+    static karaoke(str, frame) {
+        const chars = (frame % (str.length + 20)) - 10;
+        if (chars < 0) {
+            return chalk_1.default.white(str);
+        }
+        return (chalk_1.default.rgb(255, 187, 0).bold(str.substr(0, chars)) +
+            chalk_1.default.white(str.substr(chars)));
+    }
+}
+exports.Effects = Effects;
+Effects.longHsv = { interpolation: "hsv", hsvSpin: "long" };
+Effects.glitchChars = "x*0987654321[]0-~@#(____!!!!\\|?????....0000\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";

package/dist/cjs/InstanceTracker.d.ts

@@ -0,0 +1,14 @@
+import { AutoIncrementingID } from "@figliolia/event-emitter";
+import type { Animation } from "./Animation";
+export declare class InstanceTracker {
+    ID: string;
+    static readonly LOG: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static IDs: AutoIncrementingID;
+    static bucket: Map<string, Animation>;
+    constructor();
+    get instance(): Animation;
+    static clearAll(): void;
+}

package/dist/cjs/InstanceTracker.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceTracker = void 0;
+const event_emitter_1 = require("@figliolia/event-emitter");
+class InstanceTracker {
+    constructor() {
+        InstanceTracker.clearAll();
+        this.ID = InstanceTracker.IDs.get();
+        InstanceTracker.bucket.set(this.ID, this.instance);
+    }
+    get instance() {
+        return this;
+    }
+    static clearAll() {
+        for (const [, animation] of InstanceTracker.bucket) {
+            animation.stop();
+        }
+        InstanceTracker.bucket.clear();
+    }
+}
+exports.InstanceTracker = InstanceTracker;
+InstanceTracker.LOG = console.log;
+InstanceTracker.IDs = new event_emitter_1.AutoIncrementingID();
+InstanceTracker.bucket = new Map();
+(() => {
+    const methods = ["log", "warn", "info", "error"];
+    methods.forEach((method) => {
+        const original = console[method];
+        console[method] = function (...args) {
+            InstanceTracker.clearAll();
+            return original.apply(console, args);
+        };
+    });
+})();

package/dist/cjs/animateString.d.ts

@@ -0,0 +1,2 @@
+import { Animation } from "./Animation";
+export declare function animateString(effect: any, str: string, delay?: number, speed?: number): Animation;

package/dist/cjs/animateString.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.animateString = void 0;
+const Animation_1 = require("./Animation");
+function animateString(effect, str, delay = 0, speed = 0) {
+    if (!speed || speed <= 0) {
+        throw new Error("Expected `speed` to be an number greater than 0");
+    }
+    const animation = new Animation_1.Animation(effect, str, delay, speed);
+    // setTimeout(() => {
+    //   if (!animation.stopped) {
+    //     animation.start();
+    //   }
+    // }, delay / speed);
+    animation.start();
+    return animation;
+}
+exports.animateString = animateString;

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { ChalkAnimation } from "./ChalkAnimation";
+export type { Animation } from "./Animation";
+export type { InstanceTracker } from "./InstanceTracker";
+export * from "./types";

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChalkAnimation = void 0;
+var ChalkAnimation_1 = require("./ChalkAnimation");
+Object.defineProperty(exports, "ChalkAnimation", { enumerable: true, get: function () { return ChalkAnimation_1.ChalkAnimation; } });
+__exportStar(require("./types"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1 @@
+export type AnimationFN = (str: string, frame: number) => string;

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mjs/Animation.d.ts

@@ -0,0 +1,20 @@
+import type { AnimationFN } from "./types";
+import { InstanceTracker } from "./InstanceTracker";
+export declare class Animation extends InstanceTracker {
+    effect: any;
+    lines: number;
+    speed: number;
+    delay: number;
+    text: string[];
+    stopped: boolean;
+    currentFrame: number;
+    initialized: boolean;
+    controller: ReturnType<typeof setTimeout> | null;
+    constructor(effect: AnimationFN, str: string, delay?: number, speed?: number);
+    render(): void;
+    frame(): string;
+    replace(str: string): this;
+    stop(): this;
+    start(): this;
+    private clearFrames;
+}

package/dist/mjs/Animation.js

@@ -0,0 +1,61 @@
+import { InstanceTracker } from "./InstanceTracker";
+export class Animation extends InstanceTracker {
+    effect;
+    lines;
+    speed;
+    delay;
+    text;
+    stopped = false;
+    currentFrame = 0;
+    initialized = false;
+    controller = null;
+    constructor(effect, str, delay = 0, speed = 0) {
+        super();
+        this.effect = effect;
+        this.speed = speed;
+        this.delay = delay;
+        this.text = str.split(/\r\n|\r|\n/);
+        this.lines = this.text.length;
+    }
+    render() {
+        if (!this.initialized) {
+            Animation.LOG("\n".repeat(this.lines - 1));
+            this.initialized = true;
+        }
+        Animation.LOG(this.frame());
+        this.controller = setTimeout(() => {
+            if (!this.stopped) {
+                this.render();
+            }
+        }, this.delay / this.speed);
+    }
+    frame() {
+        this.currentFrame++;
+        return ("\u001B[" +
+            `${this.lines}` +
+            "F\u001B[G\u001B[2K" +
+            this.text.map((str) => this.effect(str, this.currentFrame)).join("\n"));
+    }
+    replace(str) {
+        this.text = str.split(/\r\n|\r|\n/);
+        this.lines = this.text.length;
+        return this;
+    }
+    stop() {
+        this.clearFrames();
+        this.stopped = true;
+        return this;
+    }
+    start() {
+        this.clearFrames();
+        this.stopped = false;
+        this.render();
+        return this;
+    }
+    clearFrames() {
+        if (this.controller) {
+            clearTimeout(this.controller);
+            this.controller = null;
+        }
+    }
+}

package/dist/mjs/ChalkAnimation.d.ts

@@ -0,0 +1,10 @@
+import { Animation } from "./Animation";
+export declare class ChalkAnimation {
+    static rainbow(str: string, speed?: number): Animation;
+    static pulse(str: string, speed?: number): Animation;
+    static glitch(str: string, speed?: number): Animation;
+    static radar(str: string, speed?: number): Animation;
+    static neon(str: string, speed?: number): Animation;
+    static karaoke(str: string, speed?: number): Animation;
+    static clearAllAnimations(): void;
+}

package/dist/mjs/ChalkAnimation.js

@@ -0,0 +1,26 @@
+import { Effects } from "./Effects";
+import { Animation } from "./Animation";
+import { animateString } from "./animateString";
+export class ChalkAnimation {
+    static rainbow(str, speed = 1) {
+        return animateString(Effects.rainbow, str, 15, speed);
+    }
+    static pulse(str, speed = 1) {
+        return animateString(Effects.pulse, str, 16, speed);
+    }
+    static glitch(str, speed = 1) {
+        return animateString(Effects.glitch, str, 55, speed);
+    }
+    static radar(str, speed = 1) {
+        return animateString(Effects.radar, str, 50, speed);
+    }
+    static neon(str, speed = 1) {
+        return animateString(Effects.neon, str, 500, speed);
+    }
+    static karaoke(str, speed = 1) {
+        return animateString(Effects.karaoke, str, 50, speed);
+    }
+    static clearAllAnimations() {
+        return Animation.clearAll();
+    }
+}

package/dist/mjs/Effects.d.ts

@@ -0,0 +1,13 @@
+export declare class Effects {
+    static longHsv: {
+        interpolation: string;
+        hsvSpin: string;
+    };
+    static glitchChars: string;
+    static rainbow(str: string, frame: number): string;
+    static pulse(str: string, frame: number): string;
+    static glitch(str: string, frame: number): string;
+    static radar(str: string, frame: number): string;
+    static neon(str: string, frame: number): string;
+    static karaoke(str: string, frame: number): string;
+}

package/dist/mjs/Effects.js

@@ -0,0 +1,102 @@
+import chalk from "chalk";
+import gradient from "gradient-string";
+export class Effects {
+    static longHsv = { interpolation: "hsv", hsvSpin: "long" };
+    static glitchChars = "x*0987654321[]0-~@#(____!!!!\\|?????....0000\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+    static rainbow(str, frame) {
+        const hue = 5 * frame;
+        const leftColor = { h: hue % 360, s: 1, v: 1 };
+        const rightColor = { h: (hue + 1) % 360, s: 1, v: 1 };
+        return gradient(leftColor, rightColor)(str, Effects.longHsv);
+    }
+    static pulse(str, frame) {
+        frame = (frame % 120) + 1;
+        const transition = 6;
+        const duration = 10;
+        const on = "#ff1010";
+        const off = "#e6e6e6";
+        if (frame >= 2 * transition + duration) {
+            return chalk.hex(off)(str); // All white
+        }
+        if (frame >= transition && frame <= transition + duration) {
+            return chalk.hex(on)(str); // All red
+        }
+        frame =
+            frame >= transition + duration
+                ? 2 * transition + duration - frame
+                : frame; // Revert animation
+        const g = frame <= transition / 2
+            ? gradient([
+                { color: off, pos: 0.5 - frame / transition },
+                { color: on, pos: 0.5 },
+                { color: off, pos: 0.5 + frame / transition },
+            ])
+            : gradient([
+                { color: off, pos: 0 },
+                { color: on, pos: 1 - frame / transition },
+                { color: on, pos: frame / transition },
+                { color: off, pos: 1 },
+            ]);
+        return g(str);
+    }
+    static glitch(str, frame) {
+        if ((frame % 2) + (frame % 3) + (frame % 11) + (frame % 29) + (frame % 37) >
+            52) {
+            return str.replace(/[^\r\n]/g, " ");
+        }
+        const chunkSize = Math.max(3, Math.round(str.length * 0.02));
+        const chunks = [];
+        for (let i = 0, length = str.length; i < length; i++) {
+            const skip = Math.round(Math.max(0, (Math.random() - 0.8) * chunkSize));
+            chunks.push(str.substring(i, i + skip).replace(/[^\r\n]/g, " "));
+            i += skip;
+            if (str[i]) {
+                if (str[i] !== "\n" && str[i] !== "\r" && Math.random() > 0.995) {
+                    chunks.push(Effects.glitchChars[Math.floor(Math.random() * Effects.glitchChars.length)]);
+                }
+                else if (Math.random() > 0.005) {
+                    chunks.push(str[i]);
+                }
+            }
+        }
+        let result = chunks.join("");
+        if (Math.random() > 0.99) {
+            result = result.toUpperCase();
+        }
+        else if (Math.random() < 0.01) {
+            result = result.toLowerCase();
+        }
+        return result;
+    }
+    static radar(str, frame) {
+        const depth = Math.floor(Math.min(str.length, str.length * 0.2));
+        const step = Math.floor(255 / depth);
+        const globalPos = frame % (str.length + depth);
+        const chars = [];
+        for (let i = 0, length = str.length; i < length; i++) {
+            const pos = -(i - globalPos);
+            if (pos > 0 && pos <= depth - 1) {
+                const shade = (depth - pos) * step;
+                chars.push(chalk.rgb(shade, shade, shade)(str[i]));
+            }
+            else {
+                chars.push(" ");
+            }
+        }
+        return chars.join("");
+    }
+    static neon(str, frame) {
+        const color = frame % 2 === 0
+            ? chalk.dim.rgb(88, 80, 85)
+            : chalk.bold.rgb(213, 70, 242);
+        return color(str);
+    }
+    static karaoke(str, frame) {
+        const chars = (frame % (str.length + 20)) - 10;
+        if (chars < 0) {
+            return chalk.white(str);
+        }
+        return (chalk.rgb(255, 187, 0).bold(str.substr(0, chars)) +
+            chalk.white(str.substr(chars)));
+    }
+}

package/dist/mjs/InstanceTracker.d.ts

@@ -0,0 +1,14 @@
+import { AutoIncrementingID } from "@figliolia/event-emitter";
+import type { Animation } from "./Animation";
+export declare class InstanceTracker {
+    ID: string;
+    static readonly LOG: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    };
+    static IDs: AutoIncrementingID;
+    static bucket: Map<string, Animation>;
+    constructor();
+    get instance(): Animation;
+    static clearAll(): void;
+}

package/dist/mjs/InstanceTracker.js

@@ -0,0 +1,31 @@
+import { AutoIncrementingID } from "@figliolia/event-emitter";
+export class InstanceTracker {
+    ID;
+    static LOG = console.log;
+    static IDs = new AutoIncrementingID();
+    static bucket = new Map();
+    constructor() {
+        InstanceTracker.clearAll();
+        this.ID = InstanceTracker.IDs.get();
+        InstanceTracker.bucket.set(this.ID, this.instance);
+    }
+    static {
+        const methods = ["log", "warn", "info", "error"];
+        methods.forEach((method) => {
+            const original = console[method];
+            console[method] = function (...args) {
+                InstanceTracker.clearAll();
+                return original.apply(console, args);
+            };
+        });
+    }
+    get instance() {
+        return this;
+    }
+    static clearAll() {
+        for (const [, animation] of InstanceTracker.bucket) {
+            animation.stop();
+        }
+        InstanceTracker.bucket.clear();
+    }
+}

package/dist/mjs/animateString.d.ts

@@ -0,0 +1,2 @@
+import { Animation } from "./Animation";
+export declare function animateString(effect: any, str: string, delay?: number, speed?: number): Animation;

package/dist/mjs/animateString.js

@@ -0,0 +1,14 @@
+import { Animation } from "./Animation";
+export function animateString(effect, str, delay = 0, speed = 0) {
+    if (!speed || speed <= 0) {
+        throw new Error("Expected `speed` to be an number greater than 0");
+    }
+    const animation = new Animation(effect, str, delay, speed);
+    // setTimeout(() => {
+    //   if (!animation.stopped) {
+    //     animation.start();
+    //   }
+    // }, delay / speed);
+    animation.start();
+    return animation;
+}

package/dist/mjs/index.d.ts

@@ -0,0 +1,4 @@
+export { ChalkAnimation } from "./ChalkAnimation";
+export type { Animation } from "./Animation";
+export type { InstanceTracker } from "./InstanceTracker";
+export * from "./types";

package/dist/mjs/index.js

@@ -0,0 +1,2 @@
+export { ChalkAnimation } from "./ChalkAnimation";
+export * from "./types";

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/mjs/types.d.ts

@@ -0,0 +1 @@
+export type AnimationFN = (str: string, frame: number) => string;

package/dist/mjs/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@figliolia/chalk-animation",
+  "version": "1.0.0",
+  "description": "An ESM/Common.js compatible typescript port of the popular 'chalk-animation' library",
+  "keywords": [
+    "animation",
+    "chalk",
+    "cli",
+    "color",
+    "colors",
+    "colour",
+    "command-line",
+    "console",
+    "formatting",
+    "gradient",
+    "log",
+    "logging",
+    "rainbow",
+    "shell",
+    "string",
+    "style",
+    "styles",
+    "terminal"
+  ],
+  "homepage": "https://github.com/alexfigliolia/chalk-animation",
+  "bugs": "https://github.com/alexfigliolia/chalk-animation/issues",
+  "repository": "alexfigliolia/chalk-animation",
+  "license": "MIT",
+  "author": "Alex Figliolia",
+  "exports": {
+    ".": {
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/mjs/index.js",
+  "types": "dist/mjs/index.d.ts",
+  "bin": "./cli.js",
+  "files": [
+    "dist",
+    "src/*"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && yarn build-esm && yarn build-cjs && yarn package-targets",
+    "build-cjs": "tsc -p cd/tsconfig.cjs.json",
+    "build-esm": "tsc -p cd/tsconfig.mjs.json",
+    "lint": "tsc --noemit && eslint ./ --fix",
+    "package-targets": "cd/package.sh",
+    "test": "jest"
+  },
+  "dependencies": {
+    "@figliolia/event-emitter": "^1.1.1",
+    "chalk": "^4.1.2",
+    "gradient-string": "^2.0.2"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.3.99",
+    "@types/gradient-string": "^1.1.5",
+    "@types/jest": "^29.5.10",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "eslint": "^8.39.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-airbnb-typescript": "^17.0.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-json-format": "^2.0.1",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^2.8.8",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.4.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Animation.ts

@@ -0,0 +1,71 @@
+import type { AnimationFN } from "./types";
+import { InstanceTracker } from "./InstanceTracker";
+
+export class Animation extends InstanceTracker {
+  effect: any;
+  lines: number;
+  speed: number;
+  delay: number;
+  text: string[];
+  stopped = false;
+  currentFrame = 0;
+  initialized = false;
+  controller: ReturnType<typeof setTimeout> | null = null;
+  constructor(effect: AnimationFN, str: string, delay = 0, speed = 0) {
+    super();
+    this.effect = effect;
+    this.speed = speed;
+    this.delay = delay;
+    this.text = str.split(/\r\n|\r|\n/);
+    this.lines = this.text.length;
+  }
+
+  public render() {
+    if (!this.initialized) {
+      Animation.LOG("\n".repeat(this.lines - 1));
+      this.initialized = true;
+    }
+    Animation.LOG(this.frame());
+    this.controller = setTimeout(() => {
+      if (!this.stopped) {
+        this.render();
+      }
+    }, this.delay / this.speed);
+  }
+
+  public frame() {
+    this.currentFrame++;
+    return (
+      "\u001B[" +
+      `${this.lines}` +
+      "F\u001B[G\u001B[2K" +
+      this.text.map((str) => this.effect(str, this.currentFrame)).join("\n")
+    );
+  }
+
+  public replace(str: string) {
+    this.text = str.split(/\r\n|\r|\n/);
+    this.lines = this.text.length;
+    return this;
+  }
+
+  public stop() {
+    this.clearFrames();
+    this.stopped = true;
+    return this;
+  }
+
+  public start() {
+    this.clearFrames();
+    this.stopped = false;
+    this.render();
+    return this;
+  }
+
+  private clearFrames() {
+    if (this.controller) {
+      clearTimeout(this.controller);
+      this.controller = null;
+    }
+  }
+}

package/src/ChalkAnimation.ts

@@ -0,0 +1,33 @@
+import { Effects } from "./Effects";
+import { Animation } from "./Animation";
+import { animateString } from "./animateString";
+
+export class ChalkAnimation {
+  public static rainbow(str: string, speed = 1) {
+    return animateString(Effects.rainbow, str, 15, speed);
+  }
+
+  public static pulse(str: string, speed = 1) {
+    return animateString(Effects.pulse, str, 16, speed);
+  }
+
+  public static glitch(str: string, speed = 1) {
+    return animateString(Effects.glitch, str, 55, speed);
+  }
+
+  public static radar(str: string, speed = 1) {
+    return animateString(Effects.radar, str, 50, speed);
+  }
+
+  public static neon(str: string, speed = 1) {
+    return animateString(Effects.neon, str, 500, speed);
+  }
+
+  public static karaoke(str: string, speed = 1) {
+    return animateString(Effects.karaoke, str, 50, speed);
+  }
+
+  public static clearAllAnimations() {
+    return Animation.clearAll();
+  }
+}

package/src/Effects.ts

@@ -0,0 +1,127 @@
+import chalk from "chalk";
+import gradient from "gradient-string";
+
+export class Effects {
+  public static longHsv = { interpolation: "hsv", hsvSpin: "long" };
+  public static glitchChars =
+    "x*0987654321[]0-~@#(____!!!!\\|?????....0000\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+  public static rainbow(str: string, frame: number) {
+    const hue = 5 * frame;
+    const leftColor = { h: hue % 360, s: 1, v: 1 };
+    const rightColor = { h: (hue + 1) % 360, s: 1, v: 1 };
+    return gradient(leftColor, rightColor)(str, Effects.longHsv);
+  }
+
+  public static pulse(str: string, frame: number) {
+    frame = (frame % 120) + 1;
+    const transition = 6;
+    const duration = 10;
+    const on = "#ff1010";
+    const off = "#e6e6e6";
+
+    if (frame >= 2 * transition + duration) {
+      return chalk.hex(off)(str); // All white
+    }
+    if (frame >= transition && frame <= transition + duration) {
+      return chalk.hex(on)(str); // All red
+    }
+
+    frame =
+      frame >= transition + duration
+        ? 2 * transition + duration - frame
+        : frame; // Revert animation
+
+    const g =
+      frame <= transition / 2
+        ? gradient([
+            { color: off, pos: 0.5 - frame / transition },
+            { color: on, pos: 0.5 },
+            { color: off, pos: 0.5 + frame / transition },
+          ])
+        : gradient([
+            { color: off, pos: 0 },
+            { color: on, pos: 1 - frame / transition },
+            { color: on, pos: frame / transition },
+            { color: off, pos: 1 },
+          ]);
+
+    return g(str);
+  }
+
+  public static glitch(str: string, frame: number) {
+    if (
+      (frame % 2) + (frame % 3) + (frame % 11) + (frame % 29) + (frame % 37) >
+      52
+    ) {
+      return str.replace(/[^\r\n]/g, " ");
+    }
+
+    const chunkSize = Math.max(3, Math.round(str.length * 0.02));
+    const chunks = [];
+
+    for (let i = 0, length = str.length; i < length; i++) {
+      const skip = Math.round(Math.max(0, (Math.random() - 0.8) * chunkSize));
+      chunks.push(str.substring(i, i + skip).replace(/[^\r\n]/g, " "));
+      i += skip;
+      if (str[i]) {
+        if (str[i] !== "\n" && str[i] !== "\r" && Math.random() > 0.995) {
+          chunks.push(
+            Effects.glitchChars[
+              Math.floor(Math.random() * Effects.glitchChars.length)
+            ]
+          );
+        } else if (Math.random() > 0.005) {
+          chunks.push(str[i]);
+        }
+      }
+    }
+
+    let result = chunks.join("");
+    if (Math.random() > 0.99) {
+      result = result.toUpperCase();
+    } else if (Math.random() < 0.01) {
+      result = result.toLowerCase();
+    }
+
+    return result;
+  }
+
+  public static radar(str: string, frame: number) {
+    const depth = Math.floor(Math.min(str.length, str.length * 0.2));
+    const step = Math.floor(255 / depth);
+
+    const globalPos = frame % (str.length + depth);
+
+    const chars = [];
+    for (let i = 0, length = str.length; i < length; i++) {
+      const pos = -(i - globalPos);
+      if (pos > 0 && pos <= depth - 1) {
+        const shade = (depth - pos) * step;
+        chars.push(chalk.rgb(shade, shade, shade)(str[i]));
+      } else {
+        chars.push(" ");
+      }
+    }
+
+    return chars.join("");
+  }
+
+  public static neon(str: string, frame: number) {
+    const color =
+      frame % 2 === 0
+        ? chalk.dim.rgb(88, 80, 85)
+        : chalk.bold.rgb(213, 70, 242);
+    return color(str);
+  }
+
+  public static karaoke(str: string, frame: number) {
+    const chars = (frame % (str.length + 20)) - 10;
+    if (chars < 0) {
+      return chalk.white(str);
+    }
+    return (
+      chalk.rgb(255, 187, 0).bold(str.substr(0, chars)) +
+      chalk.white(str.substr(chars))
+    );
+  }
+}

package/src/InstanceTracker.ts

@@ -0,0 +1,36 @@
+import { AutoIncrementingID } from "@figliolia/event-emitter";
+import type { Animation } from "./Animation";
+
+export class InstanceTracker {
+  ID: string;
+  static readonly LOG = console.log;
+  static IDs = new AutoIncrementingID();
+  static bucket = new Map<string, Animation>();
+  constructor() {
+    InstanceTracker.clearAll();
+    this.ID = InstanceTracker.IDs.get();
+    InstanceTracker.bucket.set(this.ID, this.instance);
+  }
+
+  static {
+    const methods = ["log", "warn", "info", "error"] as const;
+    methods.forEach((method) => {
+      const original = console[method];
+      console[method] = function (...args: Parameters<typeof console.log>) {
+        InstanceTracker.clearAll();
+        return original.apply(console, args);
+      };
+    });
+  }
+
+  public get instance() {
+    return this as unknown as Animation;
+  }
+
+  public static clearAll() {
+    for (const [, animation] of InstanceTracker.bucket) {
+      animation.stop();
+    }
+    InstanceTracker.bucket.clear();
+  }
+}

package/src/animateString.ts

@@ -0,0 +1,15 @@
+import { Animation } from "./Animation";
+
+export function animateString(effect: any, str: string, delay = 0, speed = 0) {
+  if (!speed || speed <= 0) {
+    throw new Error("Expected `speed` to be an number greater than 0");
+  }
+  const animation = new Animation(effect, str, delay, speed);
+  // setTimeout(() => {
+  //   if (!animation.stopped) {
+  //     animation.start();
+  //   }
+  // }, delay / speed);
+  animation.start();
+  return animation;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { ChalkAnimation } from "./ChalkAnimation";
+export type { Animation } from "./Animation";
+export type { InstanceTracker } from "./InstanceTracker";
+export * from "./types";

package/src/types.ts

@@ -0,0 +1 @@
+export type AnimationFN = (str: string, frame: number) => string;