@figliolia/chalk-animation 1.0.2 → 1.0.4

package/dist/cjs/Animation.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Animation = void 0;
-const FrameRate_1 = require("./FrameRate");
 const Decor_1 = require("./Decor");
+const FrameRate_1 = require("./FrameRate");
 class Animation extends FrameRate_1.FrameRate {
     constructor(effect, str, delay = 0, speed = 0) {
         super(delay, speed);

package/dist/cjs/ChalkAnimation.js

@@ -2,8 +2,8 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChalkAnimation = void 0;
-const Effects_1 = require("./Effects");
 const Animation_1 = require("./Animation");
+const Effects_1 = require("./Effects");
 /**
  * Chalk Animation
  *

package/dist/cjs/Effects.js

@@ -111,6 +111,7 @@ 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([
@@ -131,4 +132,3 @@ __decorate([
 __decorate([
     Decor_1.Decor.bound
 ], Effects, "karaoke", null);
-exports.Effects = Effects;

package/dist/cjs/InstanceTracker.js

@@ -5,18 +5,18 @@ 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);
+        _a.clearAll();
+        this.ID = _a.IDs.get();
+        _a.bucket.set(this.ID, this.instance);
     }
     get instance() {
         return this;
     }
     static clearAll() {
-        for (const [, animation] of InstanceTracker.bucket) {
+        for (const [, animation] of _a.bucket) {
             animation.stop();
         }
-        InstanceTracker.bucket.clear();
+        _a.bucket.clear();
     }
 }
 exports.InstanceTracker = InstanceTracker;
@@ -29,7 +29,7 @@ InstanceTracker.loggers = ["log", "warn", "info", "error"];
     _a.loggers.forEach(method => {
         const original = console[method];
         console[method] = function (...args) {
-            InstanceTracker.clearAll();
+            _a.clearAll();
             return original.apply(console, args);
         };
     });

package/dist/cjs/__tests__/ChalkAnimation.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ChalkAnimation_1 = require("../ChalkAnimation");
+const Effects_1 = require("../Effects");
+const InstanceTracker_1 = require("../InstanceTracker");
+const animations = [
+    "rainbow",
+    "pulse",
+    "glitch",
+    "radar",
+    "neon",
+    "karaoke",
+];
+describe("Chalk Animation", () => {
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe("Spawn", () => {
+        beforeAll(() => {
+            jest.spyOn(InstanceTracker_1.InstanceTracker, "LOG").mockImplementation(() => { });
+        });
+        afterEach(() => {
+            InstanceTracker_1.InstanceTracker.clearAll();
+            InstanceTracker_1.InstanceTracker.IDs.reset();
+        });
+        animations.forEach(name => {
+            it(`ChalkAnimation.${name} - returns an initialized animation instance`, () => {
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("hello");
+                expect(animation.effect).toEqual(Effects_1.Effects[name]);
+                expect(typeof animation.ID).toEqual("string");
+                expect(animation.text).toEqual(["hello"]);
+                expect(animation.lines).toEqual(1);
+                expect(animation.speed).toEqual(1);
+                expect(animation.current).toEqual(1);
+                expect(animation.initialized).toEqual(true);
+                expect(animation.stopped).toEqual(false);
+                expect(animation.controller).not.toEqual(null);
+                expect(InstanceTracker_1.InstanceTracker.bucket.size).toEqual(1);
+                animation.stop();
+                expect(animation.stopped).toEqual(true);
+                expect(animation.controller).toEqual(null);
+            });
+            InstanceTracker_1.InstanceTracker.loggers.forEach(method => {
+                it(`ChalkAnimation.${name} - subsequent console.${method} stop the animation`, () => {
+                    const animation = ChalkAnimation_1.ChalkAnimation[name]("hello");
+                    expect(animation.stopped).toEqual(false);
+                    console[method]("");
+                    expect(animation.stopped).toEqual(true);
+                });
+            });
+            it(`ChalkAnimation.${name} - can be stopped and restarted`, () => {
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("hello");
+                animation.stop();
+                expect(animation.stopped).toEqual(true);
+                animation.start();
+                expect(animation.current).toEqual(2);
+            });
+            it(`ChalkAnimation.${name} - can be manually rendered at a desired frame rate`, () => {
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("hello").stop();
+                expect(animation.current).toEqual(1);
+                animation.render();
+                expect(animation.current).toEqual(2);
+                animation.render();
+                expect(animation.current).toEqual(3);
+            });
+            it(`ChalkAnimation.${name} - text can be replaced`, () => {
+                if (name === "radar") {
+                    return;
+                }
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("Y Y Y").stop();
+                const f1 = animation.nextFrame();
+                animation.replace("Z Z Z");
+                const f2 = animation.nextFrame();
+                expect(f1.includes("Y")).toEqual(true);
+                expect(f1.includes("Z")).toEqual(false);
+                expect(f2.includes("Y")).toEqual(false);
+                expect(f2.includes("Z")).toEqual(true);
+            });
+            it(`ChalkAnimation.${name} - supports multiline strings`, () => {
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("Lorem\nipsum\ndolor\nsit\namet").stop();
+                const frame = animation.nextFrame();
+                expect(animation.lines).toEqual(5);
+                expect(frame.split("\n")).toHaveLength(5);
+            });
+            it(`ChalkAnimation.${name} - supports 5K+ frames`, () => {
+                const animation = ChalkAnimation_1.ChalkAnimation[name]("Lorem\nipsum\ndolor\nsit\namet").stop();
+                for (let i = 0; i < 5000; i++) {
+                    expect(() => {
+                        animation.nextFrame();
+                    }).not.toThrow();
+                }
+            });
+        });
+    });
+});

package/dist/cjs/package.json

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

package/dist/mjs/Animation.js

@@ -1,5 +1,5 @@
-import { FrameRate } from "./FrameRate";
-import { Decor } from "./Decor";
+import { Decor } from "./Decor.js";
+import { FrameRate } from "./FrameRate.js";
 export class Animation extends FrameRate {
     lines;
     text;

package/dist/mjs/ChalkAnimation.js

@@ -1,5 +1,5 @@
-import { Effects } from "./Effects";
-import { Animation } from "./Animation";
+import { Animation } from "./Animation.js";
+import { Effects } from "./Effects.js";
 /**
  * Chalk Animation
  *

package/dist/mjs/Effects.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import chalk from "chalk";
 import gradient from "gradient-string";
-import { Decor } from "./Decor";
+import { Decor } from "./Decor.js";
 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";

package/dist/mjs/FrameRate.js

@@ -1,4 +1,4 @@
-import { InstanceTracker } from "./InstanceTracker";
+import { InstanceTracker } from "./InstanceTracker.js";
 export class FrameRate extends InstanceTracker {
     current = 0;
     speed;

package/dist/mjs/__tests__/ChalkAnimation.test.js

@@ -0,0 +1,93 @@
+import { ChalkAnimation } from "../ChalkAnimation.js";
+import { Effects } from "../Effects.js";
+import { InstanceTracker } from "../InstanceTracker.js";
+const animations = [
+    "rainbow",
+    "pulse",
+    "glitch",
+    "radar",
+    "neon",
+    "karaoke",
+];
+describe("Chalk Animation", () => {
+    afterAll(() => {
+        jest.restoreAllMocks();
+    });
+    describe("Spawn", () => {
+        beforeAll(() => {
+            jest.spyOn(InstanceTracker, "LOG").mockImplementation(() => { });
+        });
+        afterEach(() => {
+            InstanceTracker.clearAll();
+            InstanceTracker.IDs.reset();
+        });
+        animations.forEach(name => {
+            it(`ChalkAnimation.${name} - returns an initialized animation instance`, () => {
+                const animation = ChalkAnimation[name]("hello");
+                expect(animation.effect).toEqual(Effects[name]);
+                expect(typeof animation.ID).toEqual("string");
+                expect(animation.text).toEqual(["hello"]);
+                expect(animation.lines).toEqual(1);
+                expect(animation.speed).toEqual(1);
+                expect(animation.current).toEqual(1);
+                expect(animation.initialized).toEqual(true);
+                expect(animation.stopped).toEqual(false);
+                expect(animation.controller).not.toEqual(null);
+                expect(InstanceTracker.bucket.size).toEqual(1);
+                animation.stop();
+                expect(animation.stopped).toEqual(true);
+                expect(animation.controller).toEqual(null);
+            });
+            InstanceTracker.loggers.forEach(method => {
+                it(`ChalkAnimation.${name} - subsequent console.${method} stop the animation`, () => {
+                    const animation = ChalkAnimation[name]("hello");
+                    expect(animation.stopped).toEqual(false);
+                    console[method]("");
+                    expect(animation.stopped).toEqual(true);
+                });
+            });
+            it(`ChalkAnimation.${name} - can be stopped and restarted`, () => {
+                const animation = ChalkAnimation[name]("hello");
+                animation.stop();
+                expect(animation.stopped).toEqual(true);
+                animation.start();
+                expect(animation.current).toEqual(2);
+            });
+            it(`ChalkAnimation.${name} - can be manually rendered at a desired frame rate`, () => {
+                const animation = ChalkAnimation[name]("hello").stop();
+                expect(animation.current).toEqual(1);
+                animation.render();
+                expect(animation.current).toEqual(2);
+                animation.render();
+                expect(animation.current).toEqual(3);
+            });
+            it(`ChalkAnimation.${name} - text can be replaced`, () => {
+                if (name === "radar") {
+                    return;
+                }
+                const animation = ChalkAnimation[name]("Y Y Y").stop();
+                const f1 = animation.nextFrame();
+                animation.replace("Z Z Z");
+                const f2 = animation.nextFrame();
+                expect(f1.includes("Y")).toEqual(true);
+                expect(f1.includes("Z")).toEqual(false);
+                expect(f2.includes("Y")).toEqual(false);
+                expect(f2.includes("Z")).toEqual(true);
+            });
+            it(`ChalkAnimation.${name} - supports multiline strings`, () => {
+                const animation = ChalkAnimation[name]("Lorem\nipsum\ndolor\nsit\namet").stop();
+                const frame = animation.nextFrame();
+                expect(animation.lines).toEqual(5);
+                expect(frame.split("\n")).toHaveLength(5);
+            });
+            it(`ChalkAnimation.${name} - supports 5K+ frames`, () => {
+                const animation = ChalkAnimation[name]("Lorem\nipsum\ndolor\nsit\namet").stop();
+                for (let i = 0; i < 5000; i++) {
+                    expect(() => {
+                        animation.nextFrame();
+                    }).not.toThrow();
+                }
+            });
+        });
+    });
+});

package/dist/mjs/index.js

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

package/dist/mjs/package.json

@@ -1,3 +1,4 @@
 {
-    "type": "module"
-}
+  "type": "module",
+  "exports": "./index.js"
+}

package/dist/types/__tests__/ChalkAnimation.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@figliolia/chalk-animation",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "An ESM/Common.js compatible typescript port of the popular 'chalk-animation' library",
   "keywords": [
     "animation",
@@ -30,24 +30,22 @@
   "exports": {
     ".": {
       "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js"
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
     }
   },
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
-  "types": "dist/mjs/index.d.ts",
+  "types": "dist/types/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"
+    "build": "ts-packager -e src",
+    "lint": "tsx ci/commands/Lint.ts",
+    "test": "tsx ci/commands/Test.ts"
   },
   "dependencies": {
     "@figliolia/event-emitter": "^1.1.1",
@@ -55,9 +53,11 @@
     "gradient-string": "^2.0.2"
   },
   "devDependencies": {
-    "@swc/core": "^1.3.99",
-    "@types/gradient-string": "^1.1.5",
-    "@types/jest": "^29.5.10",
+    "@figliolia/child-process": "^1.0.1",
+    "@figliolia/ts-packager": "^1.1.0",
+    "@types/gradient-string": "^1.1.6",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.19",
     "@typescript-eslint/eslint-plugin": "^5.59.1",
     "@typescript-eslint/parser": "^5.59.1",
     "eslint": "^8.39.0",
@@ -67,13 +67,16 @@
     "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-prettier": "^5.1.3",
     "eslint-plugin-simple-import-sort": "^10.0.0",
+    "eslint-plugin-unused-imports": "3",
     "jest": "^29.7.0",
-    "prettier": "^2.8.8",
-    "ts-jest": "^29.1.1",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.4.2"
+    "prettier": "^3.2.4",
+    "ts-jest": "^29.2.4",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.8",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3"
   },
   "engines": {
     "node": ">=16"
@@ -81,4 +84,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/Animation.ts

@@ -1,6 +1,6 @@
-import type { AnimationFN } from "./types";
-import { FrameRate } from "./FrameRate";
 import { Decor } from "./Decor";
+import { FrameRate } from "./FrameRate";
+import type { AnimationFN } from "./types";
 
 export class Animation extends FrameRate {
   lines: number;

package/src/ChalkAnimation.ts

@@ -1,5 +1,5 @@
-import { Effects } from "./Effects";
 import { Animation } from "./Animation";
+import { Effects } from "./Effects";
 import type { AnimationName } from "./types";
 
 /**

package/dist/mjs/Animation.d.ts

@@ -1,16 +0,0 @@
-import type { AnimationFN } from "./types";
-import { FrameRate } from "./FrameRate";
-export declare class Animation extends FrameRate {
-    lines: number;
-    text: string[];
-    stopped: boolean;
-    initialized: boolean;
-    effect: AnimationFN;
-    static readonly LINE_BREAKS: RegExp;
-    constructor(effect: AnimationFN, str: string, delay?: number, speed?: number);
-    render(): void;
-    nextFrame(): string;
-    readonly replace: (str: string) => this;
-    readonly stop: () => this;
-    readonly start: () => this;
-}

package/dist/mjs/ChalkAnimation.d.ts

@@ -1,21 +0,0 @@
-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 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/mjs/Decor.d.ts

@@ -1,5 +0,0 @@
-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/mjs/Effects.d.ts

@@ -1,13 +0,0 @@
-export declare class Effects {
-    static readonly longHsv: {
-        interpolation: string;
-        hsvSpin: 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;
-    static radar(str: string, frame: number): string;
-    static neon(str: string, frame: number): string;
-    static karaoke(str: string, frame: number): string;
-}

package/dist/mjs/FrameRate.d.ts

@@ -1,11 +0,0 @@
-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/mjs/InstanceTracker.d.ts

@@ -1,15 +0,0 @@
-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>;
-    static loggers: readonly ["log", "warn", "info", "error"];
-    constructor();
-    get instance(): Animation;
-    static clearAll(): void;
-}

package/dist/mjs/index.d.ts

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

package/dist/mjs/types.d.ts

@@ -1,6 +0,0 @@
-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/{cjs → types}/Animation.d.ts

@@ -1,5 +1,5 @@
-import type { AnimationFN } from "./types";
 import { FrameRate } from "./FrameRate";
+import type { AnimationFN } from "./types";
 export declare class Animation extends FrameRate {
     lines: number;
     text: string[];