@syntrologie/adapt-overlays 2.15.0 → 2.17.0

package/dist/cdn.js

@@ -1,39 +0,0 @@
-/**
- * CDN Entry Point for Adaptive Overlays
- *
- * This module is bundled for CDN delivery and self-registers with the global
- * SynOS app registry when loaded dynamically via the AppLoader.
- */
-import { editor } from './editor';
-import { executors, runtime } from './runtime';
-/**
- * App manifest for registry registration.
- * Follows the AppManifest interface expected by AppLoader/AppRegistry.
- */
-export const manifest = {
-    id: runtime.id,
-    version: runtime.version,
-    name: runtime.name,
-    description: runtime.description,
-    runtime: {
-        actions: executors.map(({ kind, executor }) => ({
-            kind,
-            executor,
-        })),
-    },
-    editor,
-    metadata: {
-        isBuiltIn: true,
-    },
-};
-/**
- * Self-register with global registry if available.
- * This happens when loaded via script tag (UMD).
- */
-if (typeof window !== 'undefined') {
-    const registry = window.SynOS?.appRegistry;
-    if (registry && typeof registry.register === 'function') {
-        registry.register(manifest);
-    }
-}
-export default manifest;

package/dist/celebrations/__tests__/engine.test.js

@@ -1,130 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-/** Stub CanvasRenderingContext2D for jsdom (which lacks canvas support) */
-function stubCanvasContext() {
-    const ctx = {
-        scale: vi.fn(),
-        clearRect: vi.fn(),
-        save: vi.fn(),
-        restore: vi.fn(),
-        translate: vi.fn(),
-        rotate: vi.fn(),
-        fillRect: vi.fn(),
-        beginPath: vi.fn(),
-        arc: vi.fn(),
-        fill: vi.fn(),
-        fillText: vi.fn(),
-        globalAlpha: 1,
-        fillStyle: '',
-        font: '',
-        shadowBlur: 0,
-        shadowColor: '',
-    };
-    vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(ctx);
-    return ctx;
-}
-function mockEffect() {
-    return {
-        init: vi.fn(() => [
-            {
-                x: 100,
-                y: 0,
-                vx: 0,
-                vy: 1,
-                rotation: 0,
-                rotationSpeed: 0,
-                size: 5,
-                color: '#ff0000',
-                opacity: 1,
-            },
-        ]),
-        update: vi.fn(() => true),
-        render: vi.fn(),
-    };
-}
-const defaultConfig = {
-    duration: 3000,
-    intensity: 'medium',
-    colors: ['#ff0000', '#00ff00'],
-};
-describe('CelebrationEngine', () => {
-    let container;
-    beforeEach(() => {
-        container = document.createElement('div');
-        document.body.appendChild(container);
-        stubCanvasContext();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-        container.remove();
-    });
-    it('creates a canvas element when started', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        const canvas = container.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).not.toBeNull();
-        expect(canvas?.style.position).toBe('fixed');
-        expect(canvas?.style.pointerEvents).toBe('none');
-        engine.stop();
-    });
-    it('removes canvas when stopped', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        expect(container.querySelector('canvas[data-syntro-celebrate]')).not.toBeNull();
-        engine.stop();
-        expect(container.querySelector('canvas[data-syntro-celebrate]')).toBeNull();
-    });
-    it('calls effect.init with canvas dimensions', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        expect(effect.init).toHaveBeenCalledWith(expect.any(Number), expect.any(Number), defaultConfig);
-        engine.stop();
-    });
-    it('calls effect.update and effect.render on animation frame', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        // Trigger an animation frame
-        vi.advanceTimersByTime(16);
-        expect(effect.update).toHaveBeenCalled();
-        expect(effect.render).toHaveBeenCalled();
-        engine.stop();
-    });
-    it('auto-stops after duration expires', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, { ...defaultConfig, duration: 1000 });
-        // Advance past duration
-        vi.advanceTimersByTime(1100);
-        expect(container.querySelector('canvas[data-syntro-celebrate]')).toBeNull();
-    });
-    it('auto-stops when effect.update returns false', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        // After first frame, update returns false (all particles done)
-        effect.update.mockReturnValue(false);
-        engine.start(container, effect, defaultConfig);
-        // Trigger animation frame
-        vi.advanceTimersByTime(16);
-        expect(container.querySelector('canvas[data-syntro-celebrate]')).toBeNull();
-    });
-    it('stop() is safe to call multiple times', async () => {
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        engine.stop();
-        engine.stop(); // should not throw
-        expect(container.querySelector('canvas[data-syntro-celebrate]')).toBeNull();
-    });
-});

package/dist/celebrations/__tests__/executor.test.js

@@ -1,102 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-/** Stub CanvasRenderingContext2D for jsdom */
-function stubCanvasContext() {
-    const ctx = {
-        scale: vi.fn(),
-        clearRect: vi.fn(),
-        save: vi.fn(),
-        restore: vi.fn(),
-        translate: vi.fn(),
-        rotate: vi.fn(),
-        fillRect: vi.fn(),
-        beginPath: vi.fn(),
-        arc: vi.fn(),
-        fill: vi.fn(),
-        fillText: vi.fn(),
-        moveTo: vi.fn(),
-        lineTo: vi.fn(),
-        closePath: vi.fn(),
-        globalAlpha: 1,
-        fillStyle: '',
-        font: '',
-        shadowBlur: 0,
-        shadowColor: '',
-        textAlign: 'center',
-        textBaseline: 'middle',
-    };
-    vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(ctx);
-    return ctx;
-}
-function mockContext() {
-    const overlayRoot = document.createElement('div');
-    document.body.appendChild(overlayRoot);
-    return {
-        overlayRoot,
-        resolveAnchor: vi.fn(() => null),
-        generateId: vi.fn(() => 'test-id'),
-        publishEvent: vi.fn(),
-    };
-}
-describe('executeCelebrate', () => {
-    let context;
-    beforeEach(() => {
-        context = mockContext();
-        stubCanvasContext();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-        context.overlayRoot.remove();
-    });
-    it('creates engine and starts confetti effect', async () => {
-        const { executeCelebrate } = await import('../index');
-        const result = await executeCelebrate({ kind: 'overlays:celebrate', effect: 'confetti' }, context);
-        const canvas = context.overlayRoot.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).not.toBeNull();
-        result.cleanup();
-    });
-    it('returns cleanup that stops the engine', async () => {
-        const { executeCelebrate } = await import('../index');
-        const result = await executeCelebrate({ kind: 'overlays:celebrate', effect: 'confetti' }, context);
-        result.cleanup();
-        const canvas = context.overlayRoot.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).toBeNull();
-    });
-    it('handles unknown effect name gracefully', async () => {
-        const { executeCelebrate } = await import('../index');
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const result = await executeCelebrate({ kind: 'overlays:celebrate', effect: 'unknown-effect' }, context);
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('unknown-effect'));
-        // Should still return a valid cleanup
-        expect(typeof result.cleanup).toBe('function');
-        result.cleanup();
-        warnSpy.mockRestore();
-    });
-    it('publishes action.applied event', async () => {
-        const { executeCelebrate } = await import('../index');
-        await executeCelebrate({ kind: 'overlays:celebrate', effect: 'confetti' }, context);
-        expect(context.publishEvent).toHaveBeenCalledWith('action.applied', expect.objectContaining({ kind: 'overlays:celebrate', effect: 'confetti' }));
-        // Cleanup
-        const canvas = context.overlayRoot.querySelector('canvas[data-syntro-celebrate]');
-        canvas?.remove();
-    });
-    it('uses default config values when not specified', async () => {
-        const { executeCelebrate } = await import('../index');
-        const result = await executeCelebrate({ kind: 'overlays:celebrate', effect: 'fireworks' }, context);
-        // Should not throw — defaults are applied
-        const canvas = context.overlayRoot.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).not.toBeNull();
-        result.cleanup();
-    });
-    it('supports all registered effect names', async () => {
-        const { executeCelebrate } = await import('../index');
-        const effectNames = ['confetti', 'fireworks', 'sparkles', 'emoji-rain'];
-        for (const effect of effectNames) {
-            const result = await executeCelebrate({ kind: 'overlays:celebrate', effect }, context);
-            const canvas = context.overlayRoot.querySelector('canvas[data-syntro-celebrate]');
-            expect(canvas).not.toBeNull();
-            result.cleanup();
-        }
-    });
-});

package/dist/celebrations/__tests__/reduced-motion.test.js

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-/** Stub CanvasRenderingContext2D for jsdom (which lacks canvas support) */
-function stubCanvasContext() {
-    const ctx = {
-        scale: vi.fn(),
-        clearRect: vi.fn(),
-        save: vi.fn(),
-        restore: vi.fn(),
-        translate: vi.fn(),
-        rotate: vi.fn(),
-        fillRect: vi.fn(),
-        beginPath: vi.fn(),
-        arc: vi.fn(),
-        fill: vi.fn(),
-        fillText: vi.fn(),
-        globalAlpha: 1,
-        fillStyle: '',
-        font: '',
-        shadowBlur: 0,
-        shadowColor: '',
-    };
-    vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue(ctx);
-    return ctx;
-}
-function mockEffect() {
-    return {
-        init: vi.fn(() => [
-            {
-                x: 100,
-                y: 0,
-                vx: 0,
-                vy: 1,
-                rotation: 0,
-                rotationSpeed: 0,
-                size: 5,
-                color: '#ff0000',
-                opacity: 1,
-            },
-        ]),
-        update: vi.fn(() => true),
-        render: vi.fn(),
-    };
-}
-const defaultConfig = {
-    duration: 3000,
-    intensity: 'medium',
-    colors: ['#ff0000', '#00ff00'],
-};
-describe('CelebrationEngine prefers-reduced-motion', () => {
-    let container;
-    beforeEach(() => {
-        container = document.createElement('div');
-        document.body.appendChild(container);
-        stubCanvasContext();
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.restoreAllMocks();
-        container.remove();
-    });
-    it('should skip animation when prefers-reduced-motion is "reduce"', async () => {
-        window.matchMedia = vi.fn().mockReturnValue({ matches: true });
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        // Effect should never be initialized or rendered
-        expect(effect.init).not.toHaveBeenCalled();
-        expect(effect.render).not.toHaveBeenCalled();
-        // matchMedia should have been queried with the right media query
-        expect(window.matchMedia).toHaveBeenCalledWith('(prefers-reduced-motion: reduce)');
-    });
-    it('should run animation when prefers-reduced-motion is not set', async () => {
-        window.matchMedia = vi.fn().mockReturnValue({ matches: false });
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        // Effect should be initialized normally
-        expect(effect.init).toHaveBeenCalled();
-        // Canvas should be created
-        const canvas = container.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).not.toBeNull();
-        engine.stop();
-    });
-    it('should not create canvas element when motion is reduced', async () => {
-        window.matchMedia = vi.fn().mockReturnValue({ matches: true });
-        const { CelebrationEngine } = await import('../engine');
-        const engine = new CelebrationEngine();
-        const effect = mockEffect();
-        engine.start(container, effect, defaultConfig);
-        // No canvas should exist in the container
-        const canvas = container.querySelector('canvas[data-syntro-celebrate]');
-        expect(canvas).toBeNull();
-    });
-});

package/dist/celebrations/effects/__tests__/confetti.test.js

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-const defaultConfig = {
-    duration: 3000,
-    intensity: 'medium',
-    colors: ['#ff0000', '#00ff00', '#0000ff'],
-};
-describe('confetti effect', () => {
-    describe('init', () => {
-        it('creates correct particle count for light intensity', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, { ...defaultConfig, intensity: 'light' });
-            expect(particles).toHaveLength(50);
-        });
-        it('creates correct particle count for medium intensity', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, { ...defaultConfig, intensity: 'medium' });
-            expect(particles).toHaveLength(100);
-        });
-        it('creates correct particle count for heavy intensity', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, { ...defaultConfig, intensity: 'heavy' });
-            expect(particles).toHaveLength(200);
-        });
-        it('uses colors from config', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            const usedColors = new Set(particles.map((p) => p.color));
-            // All particle colors should be from the provided palette
-            for (const color of usedColors) {
-                expect(defaultConfig.colors).toContain(color);
-            }
-        });
-        it('creates particles with rect or circle shapes', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            const shapes = new Set(particles.map((p) => p.shape));
-            expect(shapes.size).toBeGreaterThanOrEqual(1);
-            for (const shape of shapes) {
-                expect(['rect', 'circle']).toContain(shape);
-            }
-        });
-    });
-    describe('update', () => {
-        it('applies gravity (vy increases each frame)', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            const initialVy = particles[0].vy;
-            confettiEffect.update(particles, 16, 16);
-            expect(particles[0].vy).toBeGreaterThan(initialVy);
-        });
-        it('returns true while particles are still visible', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            const alive = confettiEffect.update(particles, 16, 16);
-            expect(alive).toBe(true);
-        });
-        it('returns false when all particles have faded', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            // Force all particles to be fully faded
-            for (const p of particles) {
-                p.opacity = 0;
-            }
-            const alive = confettiEffect.update(particles, 16, 5000);
-            expect(alive).toBe(false);
-        });
-    });
-    describe('render', () => {
-        it('draws to canvas context', async () => {
-            const { confettiEffect } = await import('../confetti');
-            const particles = confettiEffect.init(800, 600, defaultConfig);
-            const ctx = {
-                save: vi.fn(),
-                restore: vi.fn(),
-                translate: vi.fn(),
-                rotate: vi.fn(),
-                fillRect: vi.fn(),
-                beginPath: vi.fn(),
-                arc: vi.fn(),
-                fill: vi.fn(),
-                globalAlpha: 1,
-                fillStyle: '',
-            };
-            confettiEffect.render(ctx, particles);
-            expect(ctx.save).toHaveBeenCalled();
-            expect(ctx.restore).toHaveBeenCalled();
-        });
-    });
-});

package/dist/celebrations/effects/__tests__/emoji-rain.test.js

@@ -1,88 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-const defaultConfig = {
-    duration: 3000,
-    intensity: 'medium',
-    colors: ['#000000'],
-};
-describe('emoji-rain effect', () => {
-    describe('init', () => {
-        it('creates emoji particles across the top of the screen', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            expect(particles.length).toBeGreaterThan(0);
-            for (const p of particles) {
-                expect(p.shape).toBe('emoji');
-            }
-        });
-        it('uses default emoji when none specified in props', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            for (const p of particles) {
-                expect(p.emoji).toBeDefined();
-            }
-        });
-        it('uses emoji from config.props when provided', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, {
-                ...defaultConfig,
-                props: { emoji: '🔥' },
-            });
-            for (const p of particles) {
-                expect(p.emoji).toBe('🔥');
-            }
-        });
-        it('scales count with intensity', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const light = emojiRainEffect.init(800, 600, { ...defaultConfig, intensity: 'light' });
-            const heavy = emojiRainEffect.init(800, 600, { ...defaultConfig, intensity: 'heavy' });
-            expect(heavy.length).toBeGreaterThan(light.length);
-        });
-    });
-    describe('update', () => {
-        it('moves particles downward (vy is positive)', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            const initialY = particles[0].y;
-            emojiRainEffect.update(particles, 16, 16);
-            expect(particles[0].y).toBeGreaterThan(initialY);
-        });
-        it('applies horizontal wobble', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            const initialX = particles[0].x;
-            // Run several frames to see wobble effect
-            for (let i = 0; i < 10; i++) {
-                emojiRainEffect.update(particles, 16, i * 16);
-            }
-            // X should have changed due to wobble
-            expect(particles[0].x).not.toBe(initialX);
-        });
-        it('returns false when all particles have faded', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            for (const p of particles) {
-                p.opacity = 0;
-            }
-            expect(emojiRainEffect.update(particles, 16, 5000)).toBe(false);
-        });
-    });
-    describe('render', () => {
-        it('renders emoji via fillText', async () => {
-            const { emojiRainEffect } = await import('../emoji-rain');
-            const particles = emojiRainEffect.init(800, 600, defaultConfig);
-            const ctx = {
-                save: vi.fn(),
-                restore: vi.fn(),
-                fillText: vi.fn(),
-                globalAlpha: 1,
-                font: '',
-                textAlign: 'center',
-                textBaseline: 'middle',
-            };
-            emojiRainEffect.render(ctx, particles);
-            expect(ctx.fillText).toHaveBeenCalled();
-            expect(ctx.save).toHaveBeenCalled();
-            expect(ctx.restore).toHaveBeenCalled();
-        });
-    });
-});

package/dist/celebrations/effects/__tests__/fireworks.test.js

@@ -1,87 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-const defaultConfig = {
-    duration: 3000,
-    intensity: 'medium',
-    colors: ['#ff0000', '#00ff00', '#0000ff'],
-};
-describe('fireworks effect', () => {
-    describe('init', () => {
-        it('creates burst groups with particles radiating outward', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            // Medium intensity: 3-5 bursts × 40 particles each = 120-200
-            expect(particles.length).toBeGreaterThanOrEqual(60);
-            expect(particles.length).toBeLessThanOrEqual(400);
-        });
-        it('scales particle count with intensity', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const light = fireworksEffect.init(800, 600, { ...defaultConfig, intensity: 'light' });
-            const heavy = fireworksEffect.init(800, 600, { ...defaultConfig, intensity: 'heavy' });
-            expect(heavy.length).toBeGreaterThan(light.length);
-        });
-        it('positions bursts in upper 60% of screen', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const height = 600;
-            const particles = fireworksEffect.init(800, height, defaultConfig);
-            // Burst centers (stored in data.centerY) should be in upper 60%
-            for (const p of particles) {
-                if (p.data?.centerY !== undefined) {
-                    expect(p.data.centerY).toBeLessThanOrEqual(height * 0.6);
-                }
-            }
-        });
-        it('uses colors from config', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            const usedColors = new Set(particles.map((p) => p.color));
-            for (const color of usedColors) {
-                expect(defaultConfig.colors).toContain(color);
-            }
-        });
-    });
-    describe('update', () => {
-        it('applies deceleration (velocity decreases each frame)', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            const initialSpeed = Math.sqrt(particles[0].vx ** 2 + particles[0].vy ** 2);
-            fireworksEffect.update(particles, 16, 16);
-            const newSpeed = Math.sqrt(particles[0].vx ** 2 + particles[0].vy ** 2);
-            expect(newSpeed).toBeLessThan(initialSpeed);
-        });
-        it('returns true while particles are visible', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            expect(fireworksEffect.update(particles, 16, 16)).toBe(true);
-        });
-        it('returns false when all particles have faded', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            for (const p of particles) {
-                p.opacity = 0;
-            }
-            expect(fireworksEffect.update(particles, 16, 5000)).toBe(false);
-        });
-    });
-    describe('render', () => {
-        it('draws circles with glow effect', async () => {
-            const { fireworksEffect } = await import('../fireworks');
-            const particles = fireworksEffect.init(800, 600, defaultConfig);
-            const ctx = {
-                save: vi.fn(),
-                restore: vi.fn(),
-                beginPath: vi.fn(),
-                arc: vi.fn(),
-                fill: vi.fn(),
-                globalAlpha: 1,
-                fillStyle: '',
-                shadowBlur: 0,
-                shadowColor: '',
-            };
-            fireworksEffect.render(ctx, particles);
-            expect(ctx.save).toHaveBeenCalled();
-            expect(ctx.beginPath).toHaveBeenCalled();
-            expect(ctx.arc).toHaveBeenCalled();
-            expect(ctx.restore).toHaveBeenCalled();
-        });
-    });
-});