@syntrologie/adapt-overlays 2.4.0 → 2.5.1

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

@@ -0,0 +1,102 @@
+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/effects/__tests__/confetti.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=confetti.test.d.ts.map

package/dist/celebrations/effects/__tests__/confetti.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confetti.test.d.ts","sourceRoot":"","sources":["../../../../src/celebrations/effects/__tests__/confetti.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,89 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=emoji-rain.test.d.ts.map

package/dist/celebrations/effects/__tests__/emoji-rain.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emoji-rain.test.d.ts","sourceRoot":"","sources":["../../../../src/celebrations/effects/__tests__/emoji-rain.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,88 @@
+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.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fireworks.test.d.ts.map

package/dist/celebrations/effects/__tests__/fireworks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fireworks.test.d.ts","sourceRoot":"","sources":["../../../../src/celebrations/effects/__tests__/fireworks.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,87 @@
+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();
+        });
+    });
+});

package/dist/celebrations/effects/__tests__/sparkles.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sparkles.test.d.ts.map

package/dist/celebrations/effects/__tests__/sparkles.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkles.test.d.ts","sourceRoot":"","sources":["../../../../src/celebrations/effects/__tests__/sparkles.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi } from 'vitest';
+const defaultConfig = {
+    duration: 3000,
+    intensity: 'medium',
+    colors: ['#ffd700', '#ffffff', '#fffacd'],
+};
+describe('sparkles effect', () => {
+    describe('init', () => {
+        it('creates particles at random positions across the screen', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            expect(particles.length).toBeGreaterThan(0);
+            // Particles should be spread across the viewport
+            const xs = particles.map((p) => p.x);
+            const minX = Math.min(...xs);
+            const maxX = Math.max(...xs);
+            expect(maxX - minX).toBeGreaterThan(100);
+        });
+        it('scales count with intensity', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const light = sparklesEffect.init(800, 600, { ...defaultConfig, intensity: 'light' });
+            const heavy = sparklesEffect.init(800, 600, { ...defaultConfig, intensity: 'heavy' });
+            expect(heavy.length).toBeGreaterThan(light.length);
+        });
+        it('uses colors from config', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            for (const p of particles) {
+                expect(defaultConfig.colors).toContain(p.color);
+            }
+        });
+    });
+    describe('update', () => {
+        it('moves particles upward (vy is negative)', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            const initialY = particles[0].y;
+            sparklesEffect.update(particles, 16, 16);
+            expect(particles[0].y).toBeLessThan(initialY);
+        });
+        it('returns true while particles are visible', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            expect(sparklesEffect.update(particles, 16, 16)).toBe(true);
+        });
+        it('returns false when all particles have faded', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            for (const p of particles) {
+                p.opacity = 0;
+                if (p.data)
+                    p.data.baseOpacity = 0;
+            }
+            expect(sparklesEffect.update(particles, 16, 5000)).toBe(false);
+        });
+    });
+    describe('render', () => {
+        it('draws to canvas context', async () => {
+            const { sparklesEffect } = await import('../sparkles');
+            const particles = sparklesEffect.init(800, 600, defaultConfig);
+            const ctx = {
+                save: vi.fn(),
+                restore: vi.fn(),
+                translate: vi.fn(),
+                rotate: vi.fn(),
+                beginPath: vi.fn(),
+                moveTo: vi.fn(),
+                lineTo: vi.fn(),
+                closePath: vi.fn(),
+                fill: vi.fn(),
+                globalAlpha: 1,
+                fillStyle: '',
+            };
+            sparklesEffect.render(ctx, particles);
+            expect(ctx.save).toHaveBeenCalled();
+            expect(ctx.restore).toHaveBeenCalled();
+        });
+    });
+});

package/dist/celebrations/effects/confetti.d.ts

@@ -0,0 +1,3 @@
+import type { CelebrationEffect } from '../types';
+export declare const confettiEffect: CelebrationEffect;
+//# sourceMappingURL=confetti.d.ts.map

package/dist/celebrations/effects/confetti.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confetti.d.ts","sourceRoot":"","sources":["../../../src/celebrations/effects/confetti.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,iBAAiB,EAAY,MAAM,UAAU,CAAC;AAe/E,eAAO,MAAM,cAAc,EAAE,iBA2E5B,CAAC"}

package/dist/celebrations/effects/confetti.js

@@ -0,0 +1,80 @@
+const INTENSITY_COUNTS = { light: 50, medium: 100, heavy: 200 };
+const DEFAULT_COLORS = [
+    '#ff0000',
+    '#00ff00',
+    '#0000ff',
+    '#ffff00',
+    '#ff00ff',
+    '#00ffff',
+    '#ff8800',
+    '#8800ff',
+];
+export const confettiEffect = {
+    init(width, height, config) {
+        const count = INTENSITY_COUNTS[config.intensity];
+        const colors = config.colors.length > 0 ? config.colors : DEFAULT_COLORS;
+        const particles = [];
+        for (let i = 0; i < count; i++) {
+            particles.push({
+                x: Math.random() * width,
+                y: Math.random() * -height * 0.3,
+                vx: (Math.random() - 0.5) * 4,
+                vy: Math.random() * 2 + 1,
+                rotation: Math.random() * Math.PI * 2,
+                rotationSpeed: (Math.random() - 0.5) * 0.2,
+                size: Math.random() * 6 + 4,
+                color: colors[Math.floor(Math.random() * colors.length)],
+                opacity: 1,
+                shape: Math.random() > 0.5 ? 'rect' : 'circle',
+            });
+        }
+        return particles;
+    },
+    update(particles, _dt, _elapsed) {
+        let anyVisible = false;
+        for (const p of particles) {
+            // Gravity
+            p.vy += 0.15;
+            // Air resistance
+            p.vx *= 0.99;
+            // Movement
+            p.x += p.vx;
+            p.y += p.vy;
+            // Rotation
+            p.rotation += p.rotationSpeed;
+            // Fade when past 80% of a typical viewport height (use a reasonable default)
+            if (p.y > 0 && p.opacity > 0) {
+                // Gradually fade based on how far the particle has traveled
+                if (p.y > 500) {
+                    p.opacity -= 0.02;
+                    if (p.opacity < 0)
+                        p.opacity = 0;
+                }
+            }
+            if (p.opacity > 0.01) {
+                anyVisible = true;
+            }
+        }
+        return anyVisible;
+    },
+    render(ctx, particles) {
+        for (const p of particles) {
+            if (p.opacity < 0.01)
+                continue;
+            ctx.save();
+            ctx.globalAlpha = p.opacity;
+            ctx.fillStyle = p.color;
+            ctx.translate(p.x, p.y);
+            ctx.rotate(p.rotation);
+            if (p.shape === 'circle') {
+                ctx.beginPath();
+                ctx.arc(0, 0, p.size / 2, 0, Math.PI * 2);
+                ctx.fill();
+            }
+            else {
+                ctx.fillRect(-p.size / 2, -p.size / 2, p.size, p.size * 0.6);
+            }
+            ctx.restore();
+        }
+    },
+};

package/dist/celebrations/effects/emoji-rain.d.ts

@@ -0,0 +1,3 @@
+import type { CelebrationEffect } from '../types';
+export declare const emojiRainEffect: CelebrationEffect;
+//# sourceMappingURL=emoji-rain.d.ts.map

package/dist/celebrations/effects/emoji-rain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emoji-rain.d.ts","sourceRoot":"","sources":["../../../src/celebrations/effects/emoji-rain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,iBAAiB,EAAY,MAAM,UAAU,CAAC;AAK/E,eAAO,MAAM,eAAe,EAAE,iBA8E7B,CAAC"}

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

@@ -0,0 +1,73 @@
+const INTENSITY_COUNTS = { light: 20, medium: 40, heavy: 80 };
+const DEFAULT_EMOJI = '🎉';
+export const emojiRainEffect = {
+    init(width, _height, config) {
+        const count = INTENSITY_COUNTS[config.intensity];
+        const emoji = typeof config.props?.emoji === 'string' ? config.props.emoji : DEFAULT_EMOJI;
+        const particles = [];
+        for (let i = 0; i < count; i++) {
+            particles.push({
+                x: Math.random() * width,
+                y: Math.random() * -200,
+                vx: 0,
+                vy: Math.random() * 1.5 + 1,
+                rotation: 0,
+                rotationSpeed: 0,
+                size: Math.random() * 12 + 16,
+                color: '#000000',
+                opacity: 1,
+                shape: 'emoji',
+                emoji,
+                data: {
+                    /** Phase offset for horizontal wobble */
+                    wobblePhase: Math.random() * Math.PI * 2,
+                    /** Amplitude of horizontal wobble */
+                    wobbleAmp: Math.random() * 1.5 + 0.5,
+                    /** Original x for wobble base */
+                    originX: 0,
+                },
+            });
+        }
+        // Store originX after x is set
+        for (const p of particles) {
+            if (p.data)
+                p.data.originX = p.x;
+        }
+        return particles;
+    },
+    update(particles, _dt, elapsed) {
+        let anyVisible = false;
+        for (const p of particles) {
+            // Fall downward
+            p.y += p.vy;
+            // Horizontal wobble via sine wave
+            const phase = p.data?.wobblePhase ?? 0;
+            const amp = p.data?.wobbleAmp ?? 1;
+            const originX = p.data?.originX ?? p.x;
+            p.x = originX + Math.sin(elapsed * 0.003 + phase) * amp * 20;
+            // Fade when past bottom of viewport
+            if (p.y > 600) {
+                p.opacity -= 0.02;
+                if (p.opacity < 0)
+                    p.opacity = 0;
+            }
+            if (p.opacity > 0.01) {
+                anyVisible = true;
+            }
+        }
+        return anyVisible;
+    },
+    render(ctx, particles) {
+        for (const p of particles) {
+            if (p.opacity < 0.01 || !p.emoji)
+                continue;
+            ctx.save();
+            ctx.globalAlpha = p.opacity;
+            ctx.font = `${p.size}px serif`;
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.fillText(p.emoji, p.x, p.y);
+            ctx.restore();
+        }
+    },
+};

package/dist/celebrations/effects/fireworks.d.ts

@@ -0,0 +1,3 @@
+import type { CelebrationEffect } from '../types';
+export declare const fireworksEffect: CelebrationEffect;
+//# sourceMappingURL=fireworks.d.ts.map

package/dist/celebrations/effects/fireworks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fireworks.d.ts","sourceRoot":"","sources":["../../../src/celebrations/effects/fireworks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,iBAAiB,EAAY,MAAM,UAAU,CAAC;AAK/E,eAAO,MAAM,eAAe,EAAE,iBA4E7B,CAAC"}