@guildai/cli 0.10.0 → 0.12.0

package/dist/lib/spinners.js

@@ -1,770 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Animated Spinners - Real-time animated spinners using braille canvas
- *
- * Spinners can be simple (frame-based) or complex (particle simulations).
- * All spinners expose a tick() method for real-time rendering.
- *
- * Color schemes are decoupled from patterns:
- * - GUILD_SPINNER_THEME controls the pattern (classic, wave, rain, etc.)
- * - GUILD_SPINNER_COLOR controls the color (guild, white, cyan, rainbow)
- */
-import chalk from 'chalk';
-import { BrailleCanvas } from './braille-canvas.js';
-/**
- * Guild brand colors - rust orange to warm grey palette
- */
-const GUILD_COLORS = [
-    '#d4522a', // bright saturated orange
-    '#c45c3e', // rust orange
-    '#b34a2d', // deeper rust
-    '#a84832', // darker rust
-    '#8b5a3c', // warm brown
-    '#6b4d3a', // dark brown
-    '#5c4a42', // grey-brown
-    '#4a4544', // warm grey
-    '#3a3838', // darker grey
-];
-/**
- * Cyan gradient - bright cyan to dark cyan (matrix-style)
- */
-const CYAN_COLORS = [
-    '#00ffff', // bright cyan
-    '#00e6e6', // lighter cyan
-    '#00cccc', // light cyan
-    '#00b3b3', // medium-light cyan
-    '#009999', // medium cyan
-    '#008080', // teal
-    '#006666', // darker teal
-    '#004d4d', // dark teal
-    '#003333', // very dark teal
-];
-/**
- * Get the active color scheme from environment
- * Falls back to the spinner's default color if not explicitly set
- */
-function getColorScheme(defaultColor) {
-    const envColor = process.env.GUILD_SPINNER_COLOR?.toLowerCase();
-    // Explicit color overrides (not 'random')
-    if (envColor === 'white' ||
-        envColor === 'cyan' ||
-        envColor === 'rainbow' ||
-        envColor === 'guild') {
-        return envColor;
-    }
-    // Use spinner's default color
-    return defaultColor;
-}
-/**
- * Apply color scheme to a canvas
- */
-function applyColorScheme(canvas, tick, defaultColor) {
-    const colorScheme = getColorScheme(defaultColor);
-    const charWidth = canvas.getCharWidth();
-    switch (colorScheme) {
-        case 'white':
-            for (let cx = 0; cx < charWidth; cx++) {
-                canvas.setCellColor(cx, 0, { fg: '#ffffff' });
-            }
-            break;
-        case 'cyan':
-            // Slow color cycling through cyan gradient - change every 4 ticks
-            for (let cx = 0; cx < charWidth; cx++) {
-                const colorIndex = (Math.floor(tick / 4) + cx) % CYAN_COLORS.length;
-                canvas.setCellColor(cx, 0, { fg: CYAN_COLORS[colorIndex] });
-            }
-            break;
-        case 'rainbow':
-            for (let cx = 0; cx < charWidth; cx++) {
-                const hue = (tick * 3 + cx * 40) % 360;
-                canvas.setCellColor(cx, 0, { fg: hslToHex(hue, 0.9, 0.5) });
-            }
-            break;
-        case 'guild':
-        default:
-            // Slow color cycling - change every 4 ticks
-            for (let cx = 0; cx < charWidth; cx++) {
-                const colorIndex = (Math.floor(tick / 4) + cx) % GUILD_COLORS.length;
-                canvas.setCellColor(cx, 0, { fg: GUILD_COLORS[colorIndex] });
-            }
-            break;
-    }
-}
-/**
- * Get list of available spinner themes
- */
-export function getSpinnerThemeList() {
-    return [
-        { name: 'wave', description: 'Flowing wave (default)' },
-        { name: 'classic', description: 'Classic braille spinner' },
-        { name: 'random', description: 'Random spinner, changes periodically' },
-        { name: 'snow', description: 'Gentle snowfall animation' },
-        { name: 'wave2', description: 'Dual waves with sweeping rainbow' },
-        { name: 'orbit', description: 'Dots circling around center' },
-        { name: 'fireworks', description: 'Exploding particle bursts' },
-        { name: 'confetti', description: 'Colorful particles drifting' },
-        { name: 'pulse', description: 'Breathing pulsing shape' },
-        { name: 'radar', description: 'Rotating radar sweep' },
-        { name: 'spiral', description: 'Rotating spiral pattern' },
-        { name: 'guild', description: 'Rotating pinwheel logo' },
-        { name: 'rain', description: 'Digital rain falling' },
-    ];
-}
-/**
- * Spinner themes for random selection (3-char wide spinners only)
- */
-const SPINNER_THEMES = [
-    'snow',
-    'wave',
-    'wave2',
-    'orbit',
-    'fireworks',
-    'confetti',
-    'pulse',
-    'radar',
-    'spiral',
-    'guild',
-    'rain',
-];
-/**
- * Create a spinner instance for the active theme
- * If GUILD_SPINNER_THEME env var is set, uses that theme.
- * Otherwise, defaults to wave spinner with guild colors.
- */
-export function createSpinner() {
-    const envTheme = process.env.GUILD_SPINNER_THEME;
-    if (envTheme) {
-        return createSpinnerByName(envTheme);
-    }
-    return createWaveSpinner();
-}
-/**
- * Create a random spinner from the available themes
- */
-export function createRandomSpinner() {
-    const randomTheme = SPINNER_THEMES[Math.floor(Math.random() * SPINNER_THEMES.length)];
-    return createSpinnerByName(randomTheme);
-}
-/**
- * Create a spinner by theme name
- */
-export function createSpinnerByName(name) {
-    switch (name) {
-        case 'random':
-            return createRandomSpinner();
-        case 'snow':
-            return createSnowSpinner();
-        case 'wave':
-            return createWaveSpinner();
-        case 'wave2':
-            return createWave2Spinner();
-        case 'orbit':
-            return createOrbitSpinner();
-        case 'fireworks':
-            return createFireworksSpinner();
-        case 'confetti':
-            return createConfettiSpinner();
-        case 'pulse':
-            return createPulseSpinner();
-        case 'radar':
-            return createRadarSpinner();
-        case 'spiral':
-            return createSpiralSpinner();
-        case 'guild':
-            return createGuildSpinner();
-        case 'rain':
-            return createRainSpinner();
-        case 'classic':
-        default:
-            return createClassicSpinner();
-    }
-}
-// =============================================================================
-// SPINNERS
-// =============================================================================
-/**
- * Get color for a single-character spinner based on color scheme
- */
-function getSpinnerColor(tick, defaultColor) {
-    const colorScheme = getColorScheme(defaultColor);
-    switch (colorScheme) {
-        case 'white':
-            return '#ffffff';
-        case 'cyan': {
-            // Slow color cycling through cyan gradient - change every 3 frames
-            const colorIndex = Math.floor(tick / 3) % CYAN_COLORS.length;
-            return CYAN_COLORS[colorIndex];
-        }
-        case 'rainbow': {
-            const hue = (tick * 15) % 360;
-            return hslToHex(hue, 0.9, 0.5);
-        }
-        case 'guild':
-        default: {
-            // Slow color cycling - change every 3 frames
-            const colorIndex = Math.floor(tick / 3) % GUILD_COLORS.length;
-            return GUILD_COLORS[colorIndex];
-        }
-    }
-}
-/**
- * Classic braille spinner
- */
-function createClassicSpinner() {
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let frameIndex = 0;
-    return {
-        name: 'classic',
-        defaultColor: 'rainbow',
-        frameInterval: 80,
-        tick() {
-            const color = getSpinnerColor(frameIndex, 'rainbow');
-            const frame = chalk.hex(color)(frames[frameIndex]);
-            frameIndex = (frameIndex + 1) % frames.length;
-            return frame;
-        },
-    };
-}
-/**
- * Convert HSL to hex color
- */
-function hslToHex(h, s, l) {
-    const c = (1 - Math.abs(2 * l - 1)) * s;
-    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-    const m = l - c / 2;
-    let r = 0, g = 0, b = 0;
-    if (h < 60) {
-        r = c;
-        g = x;
-    }
-    else if (h < 120) {
-        r = x;
-        g = c;
-    }
-    else if (h < 180) {
-        g = c;
-        b = x;
-    }
-    else if (h < 240) {
-        g = x;
-        b = c;
-    }
-    else if (h < 300) {
-        r = x;
-        b = c;
-    }
-    else {
-        r = c;
-        b = x;
-    }
-    const toHex = (n) => Math.round((n + m) * 255)
-        .toString(16)
-        .padStart(2, '0');
-    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-/**
- * Wave spinner - animated sine wave with thick stroke
- */
-function createWaveSpinner() {
-    const width = 6; // 3 braille chars
-    let tick = 0;
-    return {
-        name: 'wave',
-        defaultColor: 'guild',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, 4);
-            // Draw thick sine wave (2 pixels tall)
-            for (let x = 0; x < width; x++) {
-                const phase = (tick * 0.3 + x * 0.5) % (Math.PI * 2);
-                const y = 1.5 + Math.sin(phase) * 1.2;
-                const y1 = Math.floor(y);
-                const y2 = Math.ceil(y);
-                canvas.setPixel(x, y1, true);
-                if (y2 !== y1) {
-                    canvas.setPixel(x, y2, true);
-                }
-            }
-            applyColorScheme(canvas, tick, 'guild');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Wave2 spinner - dual sine waves with sweeping rainbow gradient
- */
-function createWave2Spinner() {
-    const width = 6; // 3 braille chars
-    let tick = 0;
-    return {
-        name: 'wave2',
-        defaultColor: 'rainbow',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, 4);
-            // Draw two overlapping sine waves at different frequencies
-            for (let x = 0; x < width; x++) {
-                // Primary wave
-                const phase1 = (tick * 0.6 + x * 0.5) % (Math.PI * 2);
-                const y1 = Math.floor(1.5 + Math.sin(phase1) * 1.3);
-                canvas.setPixel(x, y1, true);
-                // Secondary wave (slightly different frequency)
-                const phase2 = (tick * 0.48 + x * 0.65) % (Math.PI * 2);
-                const y2 = Math.floor(1.5 + Math.sin(phase2) * 1.3);
-                canvas.setPixel(x, y2, true);
-            }
-            applyColorScheme(canvas, tick, 'rainbow');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Snow spinner - dense blizzard simulation
- */
-function createSnowSpinner() {
-    const width = 6; // 3 braille chars = 6 pixels
-    const height = 4; // 4 pixels tall
-    let tick = 0;
-    const flakes = [];
-    let wind = 0;
-    let windTarget = 0;
-    // Spawn a new snowflake
-    function spawnFlake() {
-        flakes.push({
-            x: Math.random() * width,
-            y: -0.5,
-            speed: 0.15 + Math.random() * 0.25, // gentle: 0.15 to 0.4
-            drift: (Math.random() - 0.5) * 0.15,
-        });
-    }
-    // Initialize with some flakes
-    for (let i = 0; i < 5; i++) {
-        flakes.push({
-            x: Math.random() * width,
-            y: Math.random() * height,
-            speed: 0.15 + Math.random() * 0.25,
-            drift: (Math.random() - 0.5) * 0.15,
-        });
-    }
-    return {
-        name: 'snow',
-        defaultColor: 'white',
-        frameInterval: 60,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            // Gentle wind
-            if (Math.random() < 0.08) {
-                windTarget = (Math.random() - 0.5) * 0.3;
-            }
-            wind += (windTarget - wind) * 0.1;
-            windTarget *= 0.97;
-            // Maintain moderate density
-            while (flakes.length < 6) {
-                spawnFlake();
-            }
-            // Update and draw flakes
-            for (let i = flakes.length - 1; i >= 0; i--) {
-                const f = flakes[i];
-                f.y += f.speed;
-                f.x += f.drift + wind;
-                // Wrap horizontally for continuous blizzard
-                if (f.x < 0)
-                    f.x += width;
-                if (f.x >= width)
-                    f.x -= width;
-                // Remove only if off bottom
-                if (f.y >= height) {
-                    flakes.splice(i, 1);
-                    continue;
-                }
-                const px = Math.floor(f.x);
-                const py = Math.floor(f.y);
-                if (py >= 0 && px >= 0 && px < width) {
-                    canvas.setPixel(px, py, true);
-                }
-            }
-            applyColorScheme(canvas, tick, 'white');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Draw a 2x2 block at the given position (for thicker strokes)
- */
-function drawBlock(canvas, x, y, width, height) {
-    const px = Math.floor(x);
-    const py = Math.floor(y);
-    // Draw 2x2 block
-    for (let dy = 0; dy < 2; dy++) {
-        for (let dx = 0; dx < 2; dx++) {
-            const bx = px + dx;
-            const by = py + dy;
-            if (bx >= 0 && bx < width && by >= 0 && by < height) {
-                canvas.setPixel(bx, by, true);
-            }
-        }
-    }
-}
-/**
- * Orbit spinner - dots circling around center
- */
-function createOrbitSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    return {
-        name: 'orbit',
-        defaultColor: 'guild',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            const centerX = width / 2;
-            const centerY = height / 2;
-            // Two dots orbiting opposite each other (2x2 blocks)
-            for (let i = 0; i < 2; i++) {
-                const angle = (tick * 0.2 + i * Math.PI) % (Math.PI * 2);
-                const radius = 1.3;
-                const x = centerX + Math.cos(angle) * radius * 1.4 - 0.5;
-                const y = centerY + Math.sin(angle) * radius - 0.5;
-                drawBlock(canvas, x, y, width, height);
-            }
-            applyColorScheme(canvas, tick, 'guild');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Fireworks spinner - particles exploding outward
- */
-function createFireworksSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    let particles = [];
-    let cooldown = 0;
-    return {
-        name: 'fireworks',
-        defaultColor: 'rainbow',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            // Spawn new explosion
-            cooldown--;
-            if (cooldown <= 0 && particles.length < 8) {
-                const cx = 1 + Math.random() * (width - 2);
-                const cy = 1 + Math.random() * (height - 2);
-                for (let i = 0; i < 6; i++) {
-                    const angle = (i / 6) * Math.PI * 2;
-                    particles.push({
-                        x: cx,
-                        y: cy,
-                        vx: Math.cos(angle) * 0.5,
-                        vy: Math.sin(angle) * 0.4,
-                        life: 6 + Math.floor(Math.random() * 4),
-                    });
-                }
-                cooldown = 10;
-            }
-            // Update particles
-            for (let i = particles.length - 1; i >= 0; i--) {
-                const p = particles[i];
-                p.x += p.vx;
-                p.y += p.vy;
-                p.vy += 0.05; // gravity
-                p.life--;
-                if (p.life <= 0) {
-                    particles.splice(i, 1);
-                    continue;
-                }
-                // Draw 2x2 block for each particle
-                drawBlock(canvas, p.x, p.y, width, height);
-            }
-            applyColorScheme(canvas, tick, 'rainbow');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Confetti spinner - colorful particles drifting down
- */
-function createConfettiSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    const pieces = [];
-    for (let i = 0; i < 4; i++) {
-        pieces.push({
-            x: Math.random() * width,
-            y: Math.random() * height,
-            vx: (Math.random() - 0.5) * 0.3,
-            speed: 0.1 + Math.random() * 0.2,
-        });
-    }
-    return {
-        name: 'confetti',
-        defaultColor: 'rainbow',
-        frameInterval: 70,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            // Spawn new pieces
-            if (Math.random() < 0.3 && pieces.length < 6) {
-                pieces.push({
-                    x: Math.random() * width,
-                    y: -0.5,
-                    vx: (Math.random() - 0.5) * 0.3,
-                    speed: 0.1 + Math.random() * 0.2,
-                });
-            }
-            // Update pieces
-            for (let i = pieces.length - 1; i >= 0; i--) {
-                const p = pieces[i];
-                p.y += p.speed;
-                p.x += p.vx + Math.sin(p.y * 2) * 0.1; // wobble
-                if (p.y >= height) {
-                    pieces.splice(i, 1);
-                    continue;
-                }
-                // Draw 2x2 block for each piece
-                drawBlock(canvas, p.x, p.y, width, height);
-            }
-            applyColorScheme(canvas, tick, 'rainbow');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Pulse spinner - concentric rings that pulse outward
- */
-function createPulseSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    return {
-        name: 'pulse',
-        defaultColor: 'rainbow',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            const centerX = (width - 1) / 2;
-            const centerY = (height - 1) / 2;
-            // Draw expanding ring
-            const phase = (tick * 0.12) % (Math.PI * 2);
-            const ringRadius = 0.5 + (Math.sin(phase) + 1) * 1.2;
-            for (let y = 0; y < height; y++) {
-                for (let x = 0; x < width; x++) {
-                    const dx = (x - centerX) * 0.7;
-                    const dy = y - centerY;
-                    const dist = Math.sqrt(dx * dx + dy * dy);
-                    // Draw ring (not filled circle)
-                    if (Math.abs(dist - ringRadius) < 0.6) {
-                        canvas.setPixel(x, y, true);
-                    }
-                    // Draw center dot
-                    if (dist < 0.5) {
-                        canvas.setPixel(x, y, true);
-                    }
-                }
-            }
-            applyColorScheme(canvas, tick, 'rainbow');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Radar spinner - rotating sweep line
- */
-function createRadarSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    return {
-        name: 'radar',
-        defaultColor: 'cyan',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            const centerX = width / 2;
-            const centerY = height / 2;
-            const angle = tick * 0.12;
-            // Draw sweep line
-            for (let r = 0; r < 3; r++) {
-                const x = Math.floor(centerX + Math.cos(angle) * r * 1.2);
-                const y = Math.floor(centerY + Math.sin(angle) * r * 0.8);
-                if (x >= 0 && x < width && y >= 0 && y < height) {
-                    canvas.setPixel(x, y, true);
-                }
-            }
-            // Draw fading trail
-            for (let i = 1; i < 3; i++) {
-                const trailAngle = angle - i * 0.3;
-                const x = Math.floor(centerX + Math.cos(trailAngle) * 2);
-                const y = Math.floor(centerY + Math.sin(trailAngle) * 1.2);
-                if (x >= 0 && x < width && y >= 0 && y < height) {
-                    canvas.setPixel(x, y, true);
-                }
-            }
-            applyColorScheme(canvas, tick, 'cyan');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Spiral spinner - rotating spiral pattern
- */
-function createSpiralSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    return {
-        name: 'spiral',
-        defaultColor: 'rainbow',
-        frameInterval: 50,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            const centerX = width / 2;
-            const centerY = height / 2;
-            // Draw spiral arms
-            for (let arm = 0; arm < 2; arm++) {
-                for (let r = 0.5; r < 2.5; r += 0.5) {
-                    const angle = tick * 0.15 + r * 1.2 + arm * Math.PI;
-                    const x = Math.floor(centerX + Math.cos(angle) * r * 1.2);
-                    const y = Math.floor(centerY + Math.sin(angle) * r * 0.7);
-                    if (x >= 0 && x < width && y >= 0 && y < height) {
-                        canvas.setPixel(x, y, true);
-                    }
-                }
-            }
-            applyColorScheme(canvas, tick, 'rainbow');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Guild spinner - rotating pinwheel logo
- */
-function createGuildSpinner() {
-    const width = 6;
-    const height = 4;
-    let tick = 0;
-    return {
-        name: 'guild',
-        defaultColor: 'guild',
-        frameInterval: 60,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            const centerX = width / 2;
-            const centerY = height / 2;
-            const angle = tick * 0.2;
-            // Four arms of the pinwheel, each offset by 90 degrees
-            for (let arm = 0; arm < 4; arm++) {
-                const armAngle = angle + (arm * Math.PI) / 2;
-                // Swirl effect: arm curves outward
-                const innerR = 0.8;
-                const outerR = 1.8;
-                // Draw 2 pixels per arm to show the curve
-                for (let i = 0; i < 2; i++) {
-                    const r = innerR + i * (outerR - innerR);
-                    // Add swirl offset that increases with radius
-                    const swirl = i * 0.4;
-                    const px = Math.floor(centerX + Math.cos(armAngle + swirl) * r * 1.3);
-                    const py = Math.floor(centerY + Math.sin(armAngle + swirl) * r * 0.9);
-                    if (px >= 0 && px < width && py >= 0 && py < height) {
-                        canvas.setPixel(px, py, true);
-                    }
-                }
-            }
-            applyColorScheme(canvas, tick, 'guild');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * Rain spinner - dots raining down
- */
-function createRainSpinner() {
-    const width = 6;
-    const height = 4;
-    const drops = Array(width).fill(-1);
-    let tick = 0;
-    return {
-        name: 'rain',
-        defaultColor: 'cyan',
-        frameInterval: 70,
-        tick() {
-            const canvas = new BrailleCanvas(width, height);
-            for (let x = 0; x < width; x++) {
-                // Random new drops
-                if (drops[x] < 0 && Math.random() < 0.15) {
-                    drops[x] = 0;
-                }
-                if (drops[x] >= 0) {
-                    // Draw drop and trail
-                    for (let t = 0; t < 3; t++) {
-                        const y = Math.floor(drops[x]) - t;
-                        if (y >= 0 && y < height) {
-                            canvas.setPixel(x, y, true);
-                        }
-                    }
-                    drops[x] += 0.4;
-                    if (drops[x] > height + 2) {
-                        drops[x] = -1 - Math.random() * 3;
-                    }
-                }
-            }
-            applyColorScheme(canvas, tick, 'cyan');
-            tick++;
-            return canvas.renderLine();
-        },
-    };
-}
-/**
- * @deprecated Use createSpinner() instead
- */
-export function getSpinnerThemes() {
-    const themes = new Map();
-    // Only classic works well with legacy interface
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    themes.set('classic', {
-        name: 'classic',
-        description: 'Classic braille spinner',
-        frameCount: frames.length,
-        frameInterval: 80,
-        generateFrame: (index) => {
-            const color = getSpinnerColor(index, 'rainbow');
-            return chalk.hex(color)(frames[index]);
-        },
-    });
-    return themes;
-}
-/**
- * @deprecated Use createSpinner() instead
- */
-export function getActiveTheme() {
-    const theme = getSpinnerThemes().get('classic');
-    if (!theme)
-        throw new Error('Missing classic spinner theme');
-    return theme;
-}
-/**
- * @deprecated Use createSpinner() instead
- */
-export function generateSpinnerFrames() {
-    const theme = getActiveTheme();
-    const frames = [];
-    for (let i = 0; i < theme.frameCount; i++) {
-        frames.push(theme.generateFrame(i));
-    }
-    return frames;
-}
-//# sourceMappingURL=spinners.js.map