@figliolia/chalk-animation 1.0.0 → 1.0.2

package/README.md

@@ -1,12 +1,6 @@
 # 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
+Colorful animations in terminal output
 
 
 ## Available animations
@@ -24,26 +18,26 @@
 ## Install
 
 ```bash
-$ npm i chalk-animation
+$ npm i @figliolia/chalk-animation
 ```
 
 
 ## Usage
 
 ```javascript
-import chalkAnimation from 'chalk-animation';
+import { ChalkAnimation } from '@figliolia/chalk-animation';
 
-chalkAnimation.rainbow('Lorem ipsum dolor sit amet');
+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**.
+When created, the instance of ChalkAnimation **starts automatically**.
 
 ```javascript
-const rainbow = chalkAnimation.rainbow('Lorem ipsum'); // Animation starts
+const rainbow = ChalkAnimation.rainbow('Lorem ipsum'); // Animation starts
 
 setTimeout(() => {
     rainbow.stop(); // Animation stops
@@ -60,7 +54,7 @@ setTimeout(() => {
 Anything printed to the console will stop the previous animation automatically
 
 ```javascript
-chalkAnimation.rainbow('Lorem ipsum');
+ChalkAnimation.rainbow('Lorem ipsum');
 setTimeout(() => {
     // Stop the 'Lorem ipsum' animation, then write on a new line.
     console.log('dolor sit amet');
@@ -72,7 +66,7 @@ setTimeout(() => {
 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
+ChalkAnimation.rainbow('Lorem ipsum', 2); // Two times faster than default
 ```
 
 #### Changing text
@@ -81,7 +75,7 @@ Change the animated text seamlessly with `replace()`
 
 ```javascript
 let str = 'Loading...';
-const rainbow = chalkAnimation.rainbow(str);
+const rainbow = ChalkAnimation.rainbow(str);
 
 // Add a new dot every second
 setInterval(() => {
@@ -94,7 +88,7 @@ setInterval(() => {
 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
+const rainbow = ChalkAnimation.rainbow('Lorem ipsum').stop(); // Don't start the animation
 
 rainbow.render(); // Display the first frame
 
@@ -102,45 +96,6 @@ 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)
+MIT © [Alex Figliolia](https://github.com/alexfigliolia)

package/dist/cjs/Animation.d.ts

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

package/dist/cjs/Animation.js

@@ -1,18 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Animation = void 0;
-const InstanceTracker_1 = require("./InstanceTracker");
-class Animation extends InstanceTracker_1.InstanceTracker {
+const FrameRate_1 = require("./FrameRate");
+const Decor_1 = require("./Decor");
+class Animation extends FrameRate_1.FrameRate {
     constructor(effect, str, delay = 0, speed = 0) {
-        super();
+        super(delay, speed);
         this.stopped = false;
-        this.currentFrame = 0;
         this.initialized = false;
-        this.controller = null;
+        this.replace = Decor_1.Decor.chainable(this, (str) => {
+            this.text = str.split(Animation.LINE_BREAKS);
+            this.lines = this.text.length;
+        });
+        this.stop = Decor_1.Decor.chainable(this, () => {
+            this.clearFrames();
+            this.stopped = true;
+        });
+        this.start = Decor_1.Decor.chainable(this, () => {
+            this.clearFrames();
+            this.stopped = false;
+            this.render();
+        });
         this.effect = effect;
-        this.speed = speed;
-        this.delay = delay;
-        this.text = str.split(/\r\n|\r|\n/);
+        this.text = str.split(Animation.LINE_BREAKS);
         this.lines = this.text.length;
     }
     render() {
@@ -20,41 +30,20 @@ class Animation extends InstanceTracker_1.InstanceTracker {
             Animation.LOG("\n".repeat(this.lines - 1));
             this.initialized = true;
         }
-        Animation.LOG(this.frame());
-        this.controller = setTimeout(() => {
+        Animation.LOG(this.nextFrame());
+        this.schedule(() => {
             if (!this.stopped) {
                 this.render();
             }
-        }, this.delay / this.speed);
+        });
     }
-    frame() {
-        this.currentFrame++;
+    nextFrame() {
+        this.increment();
         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;
-        }
+            this.text.map(str => this.effect(str, this.current)).join("\n"));
     }
 }
 exports.Animation = Animation;
+Animation.LINE_BREAKS = /\r\n|\r|\n/;

package/dist/cjs/ChalkAnimation.d.ts

@@ -1,10 +1,21 @@
 import { Animation } from "./Animation";
+/**
+ * Chalk Animation
+ *
+ * Console animations for your CLI tools
+ *
+ * ```typescript
+ * const animation = ChalkAnimation.rainbow("hello!");
+ * animation.stop();
+ * animation.start();
+ * ```
+ */
 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;
+    static readonly neon: (str: string, speed?: number) => Animation;
+    static readonly radar: (str: string, speed?: number) => Animation;
+    static readonly pulse: (str: string, speed?: number) => Animation;
+    static readonly glitch: (str: string, speed?: number) => Animation;
+    static readonly rainbow: (str: string, speed?: number) => Animation;
+    static readonly karaoke: (str: string, speed?: number) => Animation;
+    private static configure;
 }

package/dist/cjs/ChalkAnimation.js

@@ -1,30 +1,35 @@
 "use strict";
+var _a;
 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");
+/**
+ * Chalk Animation
+ *
+ * Console animations for your CLI tools
+ *
+ * ```typescript
+ * const animation = ChalkAnimation.rainbow("hello!");
+ * animation.stop();
+ * animation.start();
+ * ```
+ */
 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();
+    static configure(effect, delay) {
+        return (str, speed = 1) => {
+            if (!speed || speed <= 0) {
+                throw new Error("Expected `speed` to be an number greater than 0");
+            }
+            return new Animation_1.Animation(Effects_1.Effects[effect], str, delay, speed).start();
+        };
     }
 }
 exports.ChalkAnimation = ChalkAnimation;
+_a = ChalkAnimation;
+ChalkAnimation.neon = _a.configure("neon", 500);
+ChalkAnimation.radar = _a.configure("radar", 50);
+ChalkAnimation.pulse = _a.configure("pulse", 16);
+ChalkAnimation.glitch = _a.configure("glitch", 55);
+ChalkAnimation.rainbow = _a.configure("rainbow", 15);
+ChalkAnimation.karaoke = _a.configure("karaoke", 50);

package/dist/cjs/Decor.d.ts

@@ -0,0 +1,5 @@
+import type { MethodKeys, MethodLike } from "./types";
+export declare class Decor {
+    static bound<T, K extends MethodKeys<T>>(target: T, _propertyKey: K, descriptor: TypedPropertyDescriptor<MethodLike>): void;
+    static chainable<I, F extends (...args: any[]) => any>(instance: I, func: F): (...params: Parameters<F>) => I;
+}

package/dist/cjs/Decor.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decor = void 0;
+class Decor {
+    static bound(target, _propertyKey, descriptor) {
+        const operation = descriptor.value;
+        if (operation) {
+            descriptor.value = operation.bind(target);
+        }
+    }
+    static chainable(instance, func) {
+        return (...params) => {
+            func(...params);
+            return instance;
+        };
+    }
+}
+exports.Decor = Decor;

package/dist/cjs/Effects.d.ts

@@ -1,9 +1,9 @@
 export declare class Effects {
-    static longHsv: {
+    static readonly longHsv: {
         interpolation: string;
         hsvSpin: string;
     };
-    static glitchChars: string;
+    static readonly glitchChars = "x*0987654321[]0-~@#(____!!!!\\|?????....0000\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
     static rainbow(str: string, frame: number): string;
     static pulse(str: string, frame: number): string;
     static glitch(str: string, frame: number): string;

package/dist/cjs/Effects.js

@@ -1,4 +1,10 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,12 +12,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Effects = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const gradient_string_1 = __importDefault(require("gradient-string"));
+const Decor_1 = require("./Decor");
 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);
+        return (0, gradient_string_1.default)(leftColor, rightColor)(str, this.longHsv);
     }
     static pulse(str, frame) {
         frame = (frame % 120) + 1;
@@ -56,7 +63,7 @@ class Effects {
             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)]);
+                    chunks.push(this.glitchChars[Math.floor(Math.random() * this.glitchChars.length)]);
                 }
                 else if (Math.random() > 0.005) {
                     chunks.push(str[i]);
@@ -104,6 +111,24 @@ class Effects {
             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";
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "rainbow", null);
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "pulse", null);
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "glitch", null);
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "radar", null);
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "neon", null);
+__decorate([
+    Decor_1.Decor.bound
+], Effects, "karaoke", null);
+exports.Effects = Effects;

package/dist/cjs/FrameRate.d.ts

@@ -0,0 +1,11 @@
+import { InstanceTracker } from "./InstanceTracker";
+export declare class FrameRate extends InstanceTracker {
+    current: number;
+    speed: number;
+    delay: number;
+    controller: ReturnType<typeof setTimeout> | null;
+    constructor(delay: number, speed: number);
+    schedule<F extends () => any>(func: F): void;
+    increment(): void;
+    clearFrames(): void;
+}

package/dist/cjs/FrameRate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameRate = void 0;
+const InstanceTracker_1 = require("./InstanceTracker");
+class FrameRate extends InstanceTracker_1.InstanceTracker {
+    constructor(delay, speed) {
+        super();
+        this.current = 0;
+        this.controller = null;
+        this.delay = delay;
+        this.speed = speed;
+    }
+    schedule(func) {
+        this.controller = setTimeout(func, this.delay / this.speed);
+    }
+    increment() {
+        this.current++;
+    }
+    clearFrames() {
+        if (this.controller) {
+            clearTimeout(this.controller);
+            this.controller = null;
+        }
+    }
+}
+exports.FrameRate = FrameRate;

package/dist/cjs/InstanceTracker.d.ts

@@ -8,6 +8,7 @@ export declare class InstanceTracker {
     };
     static IDs: AutoIncrementingID;
     static bucket: Map<string, Animation>;
+    static loggers: readonly ["log", "warn", "info", "error"];
     constructor();
     get instance(): Animation;
     static clearAll(): void;

package/dist/cjs/InstanceTracker.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InstanceTracker = void 0;
 const event_emitter_1 = require("@figliolia/event-emitter");
@@ -19,12 +20,13 @@ class InstanceTracker {
     }
 }
 exports.InstanceTracker = InstanceTracker;
+_a = InstanceTracker;
 InstanceTracker.LOG = console.log;
 InstanceTracker.IDs = new event_emitter_1.AutoIncrementingID();
 InstanceTracker.bucket = new Map();
+InstanceTracker.loggers = ["log", "warn", "info", "error"];
 (() => {
-    const methods = ["log", "warn", "info", "error"];
-    methods.forEach((method) => {
+    _a.loggers.forEach(method => {
         const original = console[method];
         console[method] = function (...args) {
             InstanceTracker.clearAll();

package/dist/cjs/index.d.ts

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

package/dist/cjs/types.d.ts

@@ -1 +1,6 @@
 export type AnimationFN = (str: string, frame: number) => string;
+export type AnimationName = "rainbow" | "pulse" | "glitch" | "radar" | "neon" | "karaoke";
+export type MethodLike<T = any> = (...args: any[]) => T;
+export type MethodKeys<T, R = any> = keyof {
+    [K in keyof T as Required<T>[K] extends MethodLike<R> ? K : never]: T[K];
+};

package/dist/mjs/Animation.d.ts

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

package/dist/mjs/Animation.js

@@ -1,20 +1,16 @@
-import { InstanceTracker } from "./InstanceTracker";
-export class Animation extends InstanceTracker {
-    effect;
+import { FrameRate } from "./FrameRate";
+import { Decor } from "./Decor";
+export class Animation extends FrameRate {
     lines;
-    speed;
-    delay;
     text;
     stopped = false;
-    currentFrame = 0;
     initialized = false;
-    controller = null;
+    effect;
+    static LINE_BREAKS = /\r\n|\r|\n/;
     constructor(effect, str, delay = 0, speed = 0) {
-        super();
+        super(delay, speed);
         this.effect = effect;
-        this.speed = speed;
-        this.delay = delay;
-        this.text = str.split(/\r\n|\r|\n/);
+        this.text = str.split(Animation.LINE_BREAKS);
         this.lines = this.text.length;
     }
     render() {
@@ -22,40 +18,31 @@ export class Animation extends InstanceTracker {
             Animation.LOG("\n".repeat(this.lines - 1));
             this.initialized = true;
         }
-        Animation.LOG(this.frame());
-        this.controller = setTimeout(() => {
+        Animation.LOG(this.nextFrame());
+        this.schedule(() => {
             if (!this.stopped) {
                 this.render();
             }
-        }, this.delay / this.speed);
+        });
     }
-    frame() {
-        this.currentFrame++;
+    nextFrame() {
+        this.increment();
         return ("\u001B[" +
             `${this.lines}` +
             "F\u001B[G\u001B[2K" +
-            this.text.map((str) => this.effect(str, this.currentFrame)).join("\n"));
+            this.text.map(str => this.effect(str, this.current)).join("\n"));
     }
-    replace(str) {
-        this.text = str.split(/\r\n|\r|\n/);
+    replace = Decor.chainable(this, (str) => {
+        this.text = str.split(Animation.LINE_BREAKS);
         this.lines = this.text.length;
-        return this;
-    }
-    stop() {
+    });
+    stop = Decor.chainable(this, () => {
         this.clearFrames();
         this.stopped = true;
-        return this;
-    }
-    start() {
+    });
+    start = Decor.chainable(this, () => {
         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

@@ -1,10 +1,21 @@
 import { Animation } from "./Animation";
+/**
+ * Chalk Animation
+ *
+ * Console animations for your CLI tools
+ *
+ * ```typescript
+ * const animation = ChalkAnimation.rainbow("hello!");
+ * animation.stop();
+ * animation.start();
+ * ```
+ */
 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;
+    static readonly neon: (str: string, speed?: number) => Animation;
+    static readonly radar: (str: string, speed?: number) => Animation;
+    static readonly pulse: (str: string, speed?: number) => Animation;
+    static readonly glitch: (str: string, speed?: number) => Animation;
+    static readonly rainbow: (str: string, speed?: number) => Animation;
+    static readonly karaoke: (str: string, speed?: number) => Animation;
+    private static configure;
 }