@kya-os/cli 0.1.0-beta.8 → 1.0.0-beta-0.1

package/dist/effects/implementations/test.d.ts

@@ -1,113 +0,0 @@
-/**
- * Blackhole Effect with ASCII Art Center
- * Characters are consumed by a black hole with custom ASCII art and explode outwards
- */
-import { BaseEffect } from "../types.js";
-/**
- * Configuration options for the Blackhole effect
- */
-export interface BlackholeEffectOptions {
-    /** Duration in milliseconds */
-    duration?: number;
-    /** Color for the blackhole border stars */
-    blackholeColor?: string;
-    /** Colors for stars during explosion */
-    starColors?: string[];
-    /** Final color for characters */
-    finalColor?: string;
-    /** Use gradient for final color */
-    useGradient?: boolean;
-    /** Gradient direction */
-    gradientDirection?: "vertical" | "horizontal" | "diagonal";
-    /** Size of the blackhole relative to canvas (0.1 - 0.5) */
-    blackholeSize?: number;
-    /** ASCII art to display at the center */
-    centerAsciiArt?: string[];
-    /** Color for the center ASCII art */
-    centerArtColor?: string;
-    /** Whether to animate the center art */
-    animateCenterArt?: boolean;
-}
-/**
- * Blackhole effect implementation
- */
-export declare class TestBlackholeEffect extends BaseEffect {
-    readonly name = "Blackhole";
-    readonly description = "Characters are consumed by a black hole with ASCII art center and explode outwards";
-    private options;
-    private characterStates;
-    private animationFrameCount;
-    private totalFrames;
-    private _isEffectComplete;
-    private currentPhase;
-    private blackholeCenter;
-    private blackholeRadius;
-    private blackholeChars;
-    private centerArtChars;
-    private centerArtBounds;
-    private readonly starSymbols;
-    private readonly starfieldColors;
-    private readonly defaultPiArt;
-    constructor(options?: BlackholeEffectOptions);
-    /**
-     * Parse ASCII art into character positions
-     */
-    private parseAsciiArt;
-    /**
-     * Initialize the effect
-     */
-    protected onInitialize(): void;
-    /**
-     * Calculate gradient colors
-     */
-    private calculateGradientColors;
-    /**
-     * Get gradient key based on direction
-     */
-    private getGradientKey;
-    /**
-     * Render the next frame
-     */
-    render(): Promise<string[]>;
-    /**
-     * Render center ASCII art
-     */
-    private renderCenterArt;
-    /**
-     * Update animation state for all characters
-     */
-    private updateAnimationState;
-    /**
-     * Update individual character position
-     */
-    private updateCharacterPosition;
-    /**
-     * Create visual representation of a character
-     */
-    private createCharacterVisual;
-    /**
-     * Calculate distance between two coordinates
-     */
-    private calculateDistance;
-    /**
-     * Get ANSI color code for a color
-     */
-    private getColorCode;
-    /**
-     * Interpolate between two colors
-     */
-    private interpolateColor;
-    /**
-     * Render fallback for when effects are disabled
-     */
-    renderFallback(): string[];
-    /**
-     * Check if effect is complete
-     */
-    isComplete(): boolean;
-    /**
-     * Reset the effect
-     */
-    protected onReset(): void;
-}
-//# sourceMappingURL=test.d.ts.map

package/dist/effects/implementations/test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/effects/implementations/test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,UAAU,EAMX,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,yBAAyB;IACzB,iBAAiB,CAAC,EAAE,UAAU,GAAG,YAAY,GAAG,UAAU,CAAC;IAC3D,2DAA2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,qCAAqC;IACrC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAkCD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,WAAW,wFACmE;IAEvF,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,eAAe,CAAmD;IAC1E,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,iBAAiB,CAAkB;IAG3C,OAAO,CAAC,YAAY,CAKO;IAG3B,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,cAAc,CAAyB;IAG/C,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,eAAe,CAA2B;IAGlD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiD;IAC7E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAO9B;IAGF,OAAO,CAAC,QAAQ,CAAC,YAAY,CA+B3B;gBAEU,OAAO,GAAE,sBAA2B;IAiBhD;;OAEG;IACH,OAAO,CAAC,aAAa;IAuBrB;;OAEG;IACH,SAAS,CAAC,YAAY,IAAI,IAAI;IA8F9B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAwC/B;;OAEG;IACH,OAAO,CAAC,cAAc;IAatB;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IA8CjC;;OAEG;IACH,OAAO,CAAC,eAAe;IA2FvB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAwI/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAkE7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAiBpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;IAI1B;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,SAAS,CAAC,OAAO,IAAI,IAAI;CAS1B"}

package/dist/effects/implementations/test.js

@@ -1,552 +0,0 @@
-/**
- * Blackhole Effect with ASCII Art Center
- * Characters are consumed by a black hole with custom ASCII art and explode outwards
- */
-import { BaseEffect, } from "../types.js";
-import { ANSI } from "../utils.js";
-/**
- * Blackhole effect implementation
- */
-export class TestBlackholeEffect extends BaseEffect {
-    constructor(options = {}) {
-        super();
-        this.name = "Blackhole";
-        this.description = "Characters are consumed by a black hole with ASCII art center and explode outwards";
-        this.characterStates = new Map();
-        this.animationFrameCount = 0;
-        this.totalFrames = 0;
-        this._isEffectComplete = false;
-        // Animation phase tracking
-        this.currentPhase = "forming";
-        // Blackhole properties
-        this.blackholeCenter = { x: 0, y: 0 };
-        this.blackholeRadius = 0;
-        this.blackholeChars = [];
-        // ASCII art properties
-        this.centerArtChars = [];
-        this.centerArtBounds = { width: 0, height: 0 };
-        // Star symbols
-        this.starSymbols = ["*", "'", "`", "¤", "•", "°", "·", "✦", "✧"];
-        this.starfieldColors = [
-            "4a4a4d",
-            "808080",
-            "a0a0a0",
-            "c0c0c0",
-            "e0e0e0",
-            "ffffff",
-        ];
-        // Default Pi ASCII art
-        this.defaultPiArt = [
-            "              πππππππππππππππππππππ             ",
-            "           ππππππππππππππππππππππππππ           ",
-            "         πππππππππππππππππππππππππππππ          ",
-            "       ππππππππππππππππππππππππππππππππ         ",
-            "      πππππππππππππππππππππππππππ               ",
-            "     ππππππππππππππππππππππππππ                 ",
-            "     ππππππππ      πππππππππ        ππππππ      ",
-            "    ππππππππ       ππππππππ      πππππππππ      ",
-            "    ππππππππ       πππππππ     πππππππππππ      ",
-            "    πππππππππππ πππππππππ     ππππππππππππ      ",
-            "     πππππππππππππππππππ     πππππππππππππ      ",
-            "      πππππππππππππππππ     πππππππππππππππ     ",
-            "        πππππππππππππππ     πππππππππππππππ     ",
-            "           ππππππππππππ     ππππππππππππππππ    ",
-            "   ππ        ππππππππππ     πππππππππππππππππ   ",
-            "  ππππππ       πππππππππ     πππππππππππππππππ  ",
-            " ππππππππππ      πππππππ     πππππππππππππππππππ",
-            "ππππππππππππ      πππππππ      πππππππππππππππππ",
-            "ππππππππππππππ     πππππππ      ππππππππππππππππ",
-            "ππππππππππππππ      ππππππππ        ππππππππ    ",
-            "   ππππππππππππ     ππππππππππ       ππππππππ   ",
-            "   ππππππππππππ      ππππππππππππ    ππππππππ   ",
-            "   πππππππππππππ     πππππππππππππππππππππππ    ",
-            "    ππππππππππππ     πππππππππππππππππππππππ    ",
-            "    ππππππππππππ     πππππππππππππππππππππ      ",
-            "     πππππππππππ     πππππππππππππππππππππ      ",
-            "     ππππππππππ       ππππππππππππππππππππ      ",
-            "     ππππππππππ        πππππππππππππππππππ      ",
-            "      ππππππππ           ππππππππππππππππ       ",
-            "       πππππππ              πππππππππππ         ",
-        ];
-        this.options = {
-            duration: 6000,
-            blackholeColor: "ffffff",
-            starColors: ["ffcc0d", "ff7326", "ff194d", "bf2669", "702a8c", "049dbf"],
-            finalColor: "ffffff",
-            useGradient: true,
-            gradientDirection: "diagonal",
-            blackholeSize: 0.3,
-            centerAsciiArt: this.defaultPiArt,
-            centerArtColor: "9945ff",
-            animateCenterArt: true,
-            ...options,
-        };
-    }
-    /**
-     * Parse ASCII art into character positions
-     */
-    parseAsciiArt(art) {
-        this.centerArtChars = [];
-        let maxX = 0;
-        let maxY = art.length;
-        for (let y = 0; y < art.length; y++) {
-            const line = art[y];
-            maxX = Math.max(maxX, line.length);
-            for (let x = 0; x < line.length; x++) {
-                const char = line[x];
-                if (char && char !== " ") {
-                    this.centerArtChars.push({
-                        symbol: char,
-                        relativePos: { x, y },
-                    });
-                }
-            }
-        }
-        this.centerArtBounds = { width: maxX, height: maxY };
-    }
-    /**
-     * Initialize the effect
-     */
-    onInitialize() {
-        this.totalFrames = Math.floor((this.options.duration / 1000) * this.config.frameRate);
-        const dimensions = this.getCanvasDimensions();
-        this.blackholeCenter = {
-            x: Math.floor(dimensions.width / 2),
-            y: Math.floor(dimensions.height / 2),
-        };
-        // Parse ASCII art
-        this.parseAsciiArt(this.options.centerAsciiArt);
-        // Calculate radius to accommodate ASCII art
-        const artRadius = Math.max(Math.ceil(this.centerArtBounds.width / 2), Math.ceil(this.centerArtBounds.height / 2));
-        this.blackholeRadius = Math.max(artRadius + 5, // Add padding around ASCII art
-        Math.floor(Math.min(dimensions.width * this.options.blackholeSize, dimensions.height * this.options.blackholeSize)));
-        // Initialize character states
-        this.characterStates.clear();
-        this.blackholeChars = [];
-        // Calculate final colors for gradient
-        const gradientColors = this.calculateGradientColors(dimensions);
-        // Select characters for blackhole ring
-        const blackholeCharCount = Math.min(Math.floor(this.blackholeRadius * 3), Math.floor(this.characters.length * 0.3));
-        const shuffledChars = [...this.characters].sort(() => Math.random() - 0.5);
-        this.blackholeChars = shuffledChars.slice(0, blackholeCharCount);
-        // Initialize all character states
-        for (const char of this.characters) {
-            const key = `${char.originalPosition.x},${char.originalPosition.y}`;
-            const isBlackholeChar = this.blackholeChars.includes(char);
-            let finalColor = this.options.finalColor;
-            if (this.options.useGradient) {
-                const gradientKey = this.getGradientKey(char.originalPosition, dimensions);
-                finalColor = gradientColors[gradientKey] || this.options.finalColor;
-            }
-            // Random starfield position
-            const starfieldPos = {
-                x: Math.floor(Math.random() * dimensions.width),
-                y: Math.floor(Math.random() * dimensions.height),
-            };
-            this.characterStates.set(key, {
-                phase: "starfield",
-                isBlackholeRing: isBlackholeChar,
-                isCenterArt: false,
-                starSymbol: this.starSymbols[Math.floor(Math.random() * this.starSymbols.length)],
-                starColor: this.starfieldColors[Math.floor(Math.random() * this.starfieldColors.length)],
-                position: { ...starfieldPos },
-                targetPosition: { ...char.originalPosition },
-                spiralAngle: Math.random() * Math.PI * 2,
-                spiralRadius: this.calculateDistance(starfieldPos, this.blackholeCenter),
-                explosionVector: { x: 0, y: 0 },
-                settlingProgress: 0,
-                finalColor,
-            });
-        }
-        this.currentPhase = "forming";
-        this.animationFrameCount = 0;
-        this._isEffectComplete = false;
-    }
-    /**
-     * Calculate gradient colors
-     */
-    calculateGradientColors(dimensions) {
-        const gradientMap = {};
-        if (this.options.gradientDirection === "diagonal") {
-            const maxDist = Math.sqrt(dimensions.width ** 2 + dimensions.height ** 2);
-            for (let y = 0; y < dimensions.height; y++) {
-                for (let x = 0; x < dimensions.width; x++) {
-                    const dist = Math.sqrt(x ** 2 + y ** 2);
-                    const factor = dist / maxDist;
-                    const key = `${x},${y}`;
-                    gradientMap[key] = this.interpolateColor(this.options.starColors[this.options.starColors.length - 1], this.options.finalColor, factor);
-                }
-            }
-        }
-        else {
-            const size = this.options.gradientDirection === "vertical"
-                ? dimensions.height
-                : dimensions.width;
-            const startColor = this.options.starColors[this.options.starColors.length - 1];
-            for (let i = 0; i < size; i++) {
-                const factor = i / (size - 1);
-                gradientMap[i] = this.interpolateColor(startColor, this.options.finalColor, factor);
-            }
-        }
-        return gradientMap;
-    }
-    /**
-     * Get gradient key based on direction
-     */
-    getGradientKey(pos, _dimensions) {
-        if (this.options.gradientDirection === "diagonal") {
-            return `${pos.x},${pos.y}`;
-        }
-        else if (this.options.gradientDirection === "vertical") {
-            return pos.y;
-        }
-        else {
-            return pos.x;
-        }
-    }
-    /**
-     * Render the next frame
-     */
-    async render() {
-        if (!this.isInitialized) {
-            throw new Error("Effect not initialized");
-        }
-        // Update animation state
-        this.updateAnimationState();
-        // Create the frame
-        const dimensions = this.getCanvasDimensions();
-        const frame = Array(dimensions.height)
-            .fill("")
-            .map(() => Array(dimensions.width).fill(" "));
-        // Render center ASCII art first (so it appears behind other elements)
-        if (this.currentPhase !== "forming") {
-            this.renderCenterArt(frame, dimensions);
-        }
-        // Render characters
-        for (const char of this.characters) {
-            const key = `${char.originalPosition.x},${char.originalPosition.y}`;
-            const state = this.characterStates.get(key);
-            if (state && !state.isCenterArt) {
-                const visual = this.createCharacterVisual(char, state);
-                char.visual = visual;
-                const x = Math.round(state.position.x);
-                const y = Math.round(state.position.y);
-                if (y >= 0 && y < dimensions.height && x >= 0 && x < dimensions.width) {
-                    // Apply ANSI color codes
-                    const colorCode = this.getColorCode(visual.colors.fg);
-                    const resetCode = ANSI.reset;
-                    frame[y][x] = colorCode + visual.symbol + resetCode;
-                }
-            }
-        }
-        this.animationFrameCount++;
-        // Convert frame to strings
-        return frame.map((row) => row.join(""));
-    }
-    /**
-     * Render center ASCII art
-     */
-    renderCenterArt(frame, dimensions) {
-        const artOffsetX = Math.floor(this.blackholeCenter.x - this.centerArtBounds.width / 2);
-        const artOffsetY = Math.floor(this.blackholeCenter.y - this.centerArtBounds.height / 2);
-        // Calculate art properties based on phase
-        let opacity = 1;
-        let rotation = 0;
-        let scale = 1;
-        if (this.options.animateCenterArt) {
-            const frameProgress = this.animationFrameCount / this.totalFrames;
-            switch (this.currentPhase) {
-                case "forming":
-                    opacity = Math.min(frameProgress / 0.15, 1);
-                    scale = 0.5 + opacity * 0.5;
-                    break;
-                case "consuming":
-                    rotation = frameProgress * Math.PI * 2;
-                    opacity = 1;
-                    // Pulsate
-                    scale = 1 + Math.sin(frameProgress * Math.PI * 10) * 0.1;
-                    break;
-                case "collapsing":
-                    const collapseProgress = (frameProgress - 0.5) / 0.1;
-                    scale = 1 - collapseProgress * 0.5;
-                    opacity = 1;
-                    break;
-                case "exploding":
-                    opacity = 0; // Hide during explosion
-                    break;
-            }
-        }
-        // Render each character
-        for (const artChar of this.centerArtChars) {
-            let x = artChar.relativePos.x;
-            let y = artChar.relativePos.y;
-            // Apply rotation if animating
-            if (rotation !== 0 && this.options.animateCenterArt) {
-                const centerX = this.centerArtBounds.width / 2;
-                const centerY = this.centerArtBounds.height / 2;
-                const relX = x - centerX;
-                const relY = y - centerY;
-                x = Math.round(centerX + relX * Math.cos(rotation) - relY * Math.sin(rotation));
-                y = Math.round(centerY + relX * Math.sin(rotation) + relY * Math.cos(rotation));
-            }
-            // Apply scale
-            if (scale !== 1) {
-                const centerX = this.centerArtBounds.width / 2;
-                const centerY = this.centerArtBounds.height / 2;
-                x = Math.round(centerX + (x - centerX) * scale);
-                y = Math.round(centerY + (y - centerY) * scale);
-            }
-            const finalX = artOffsetX + x;
-            const finalY = artOffsetY + y;
-            if (finalY >= 0 &&
-                finalY < dimensions.height &&
-                finalX >= 0 &&
-                finalX < dimensions.width &&
-                opacity > 0.1) {
-                const colorCode = this.getColorCode(this.options.centerArtColor);
-                const resetCode = ANSI.reset;
-                frame[finalY][finalX] = colorCode + artChar.symbol + resetCode;
-            }
-        }
-    }
-    /**
-     * Update animation state for all characters
-     */
-    updateAnimationState() {
-        const progress = this.animationFrameCount / this.totalFrames;
-        // Update phase transitions
-        if (this.currentPhase === "forming" && progress > 0.15) {
-            this.currentPhase = "consuming";
-        }
-        else if (this.currentPhase === "consuming" && progress > 0.5) {
-            this.currentPhase = "collapsing";
-        }
-        else if (this.currentPhase === "collapsing" && progress > 0.6) {
-            this.currentPhase = "exploding";
-        }
-        else if (this.currentPhase === "exploding" && progress > 0.7) {
-            this.currentPhase = "settling";
-        }
-        // Update character positions based on phase
-        for (const [_key, state] of this.characterStates) {
-            if (!state.isCenterArt) {
-                this.updateCharacterPosition(state);
-            }
-        }
-        // Check completion
-        this._isEffectComplete = progress >= 1;
-    }
-    /**
-     * Update individual character position
-     */
-    updateCharacterPosition(state) {
-        const frameProgress = this.animationFrameCount / this.totalFrames;
-        switch (this.currentPhase) {
-            case "forming":
-                if (state.isBlackholeRing) {
-                    // Move to blackhole ring position
-                    const ringProgress = Math.min(frameProgress / 0.15, 1);
-                    const angle = (this.blackholeChars.indexOf(this.characters.find((c) => this.characterStates.get(`${c.originalPosition.x},${c.originalPosition.y}`) === state)) /
-                        this.blackholeChars.length) *
-                        Math.PI *
-                        2;
-                    const targetX = this.blackholeCenter.x + Math.cos(angle) * this.blackholeRadius;
-                    const targetY = this.blackholeCenter.y + Math.sin(angle) * this.blackholeRadius;
-                    state.position.x =
-                        state.position.x +
-                            (targetX - state.position.x) * ringProgress * 0.1;
-                    state.position.y =
-                        state.position.y +
-                            (targetY - state.position.y) * ringProgress * 0.1;
-                    state.phase = "consuming";
-                }
-                break;
-            case "consuming":
-                if (state.isBlackholeRing) {
-                    // Rotate blackhole ring
-                    const angle = (this.blackholeChars.indexOf(this.characters.find((c) => this.characterStates.get(`${c.originalPosition.x},${c.originalPosition.y}`) === state)) /
-                        this.blackholeChars.length) *
-                        Math.PI *
-                        2 +
-                        frameProgress * Math.PI * 2;
-                    state.position.x =
-                        this.blackholeCenter.x + Math.cos(angle) * this.blackholeRadius;
-                    state.position.y =
-                        this.blackholeCenter.y + Math.sin(angle) * this.blackholeRadius;
-                }
-                else {
-                    // Spiral into blackhole
-                    const consumeProgress = (frameProgress - 0.15) / 0.35;
-                    if (consumeProgress > 0) {
-                        state.spiralAngle += 0.2;
-                        state.spiralRadius *= 0.95;
-                        state.position.x =
-                            this.blackholeCenter.x +
-                                Math.cos(state.spiralAngle) * state.spiralRadius;
-                        state.position.y =
-                            this.blackholeCenter.y +
-                                Math.sin(state.spiralAngle) * state.spiralRadius;
-                        if (state.spiralRadius < 2) {
-                            state.phase = "collapsed";
-                            state.position = { ...this.blackholeCenter };
-                        }
-                    }
-                }
-                break;
-            case "collapsing":
-                // All characters move to center
-                const collapseProgress = (frameProgress - 0.5) / 0.1;
-                if (collapseProgress > 0) {
-                    state.position.x += (this.blackholeCenter.x - state.position.x) * 0.2;
-                    state.position.y += (this.blackholeCenter.y - state.position.y) * 0.2;
-                    state.phase = "collapsed";
-                }
-                break;
-            case "exploding":
-                // Calculate explosion vector
-                if (state.explosionVector.x === 0 && state.explosionVector.y === 0) {
-                    const angle = Math.atan2(state.targetPosition.y - this.blackholeCenter.y, state.targetPosition.x - this.blackholeCenter.x);
-                    const distance = this.calculateDistance(state.targetPosition, this.blackholeCenter);
-                    const speed = Math.min(distance * 0.3, 5);
-                    state.explosionVector.x = Math.cos(angle) * speed;
-                    state.explosionVector.y = Math.sin(angle) * speed;
-                    state.phase = "exploding";
-                }
-                // Apply explosion movement
-                state.position.x += state.explosionVector.x;
-                state.position.y += state.explosionVector.y;
-                // Dampen explosion
-                state.explosionVector.x *= 0.9;
-                state.explosionVector.y *= 0.9;
-                break;
-            case "settling":
-                // Settle to final position
-                const settleProgress = (frameProgress - 0.7) / 0.3;
-                if (settleProgress > 0) {
-                    state.position.x += (state.targetPosition.x - state.position.x) * 0.1;
-                    state.position.y += (state.targetPosition.y - state.position.y) * 0.1;
-                    state.settlingProgress = Math.min(settleProgress, 1);
-                    if (Math.abs(state.position.x - state.targetPosition.x) < 0.5 &&
-                        Math.abs(state.position.y - state.targetPosition.y) < 0.5) {
-                        state.position = { ...state.targetPosition };
-                        state.phase = "final";
-                    }
-                }
-                break;
-        }
-    }
-    /**
-     * Create visual representation of a character
-     */
-    createCharacterVisual(char, state) {
-        let symbol = state.starSymbol;
-        let color = state.starColor;
-        switch (state.phase) {
-            case "starfield":
-                // Initial starfield state
-                break;
-            case "consuming":
-                if (state.isBlackholeRing) {
-                    symbol = "*";
-                    color = this.options.blackholeColor;
-                }
-                else {
-                    // Fading as consumed
-                    const fadeColors = ["808080", "606060", "404040", "202020", "000000"];
-                    const fadeIndex = Math.min(Math.floor((1 - state.spiralRadius / 50) * fadeColors.length), fadeColors.length - 1);
-                    color = fadeColors[Math.max(0, fadeIndex)];
-                }
-                break;
-            case "collapsed":
-                symbol = "●";
-                color =
-                    this.options.starColors[Math.floor(Math.random() * this.options.starColors.length)];
-                break;
-            case "exploding":
-                symbol = char.originalSymbol;
-                color =
-                    this.options.starColors[Math.floor(this.animationFrameCount / 2) %
-                        this.options.starColors.length];
-                break;
-            case "settling":
-            case "final":
-                symbol = char.originalSymbol;
-                // Fade from star color to final color
-                const starColor = this.options.starColors[0];
-                color = this.interpolateColor(starColor, state.finalColor, state.settlingProgress);
-                break;
-        }
-        return {
-            symbol,
-            colors: {
-                fg: color,
-                bg: null,
-            },
-        };
-    }
-    /**
-     * Calculate distance between two coordinates
-     */
-    calculateDistance(a, b) {
-        return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
-    }
-    /**
-     * Get ANSI color code for a color
-     */
-    getColorCode(color) {
-        if (!color || this.config.noColor) {
-            return "";
-        }
-        // For RGB colors, convert to ANSI 24-bit color
-        if (typeof color === "string") {
-            const r = parseInt(color.substring(0, 2), 16);
-            const g = parseInt(color.substring(2, 4), 16);
-            const b = parseInt(color.substring(4, 6), 16);
-            return `\x1b[38;2;${r};${g};${b}m`;
-        }
-        // For XTerm colors
-        return `\x1b[38;5;${color}m`;
-    }
-    /**
-     * Interpolate between two colors
-     */
-    interpolateColor(color1, color2, factor) {
-        const r1 = parseInt(color1.substring(0, 2), 16);
-        const g1 = parseInt(color1.substring(2, 4), 16);
-        const b1 = parseInt(color1.substring(4, 6), 16);
-        const r2 = parseInt(color2.substring(0, 2), 16);
-        const g2 = parseInt(color2.substring(2, 4), 16);
-        const b2 = parseInt(color2.substring(4, 6), 16);
-        const r = Math.round(r1 + (r2 - r1) * factor);
-        const g = Math.round(g1 + (g2 - g1) * factor);
-        const b = Math.round(b1 + (b2 - b1) * factor);
-        return [r, g, b]
-            .map((c) => Math.max(0, Math.min(255, c)).toString(16).padStart(2, "0"))
-            .join("");
-    }
-    /**
-     * Render fallback for when effects are disabled
-     */
-    renderFallback() {
-        return this.text.split("\n");
-    }
-    /**
-     * Check if effect is complete
-     */
-    isComplete() {
-        return this._isEffectComplete;
-    }
-    /**
-     * Reset the effect
-     */
-    onReset() {
-        this.characterStates.clear();
-        this.blackholeChars = [];
-        this.centerArtChars = [];
-        this.currentPhase = "forming";
-        this.animationFrameCount = 0;
-        this._isEffectComplete = false;
-        this.onInitialize();
-    }
-}
-//# sourceMappingURL=test.js.map