@basmilius/sparkle 2.0.0 → 2.2.0

package/src/snow/{simulation.ts → layer.ts}

@@ -1,49 +1,44 @@
-import { LimitedFrameRateCanvas } from '../canvas';
+import { parseColor } from '../color';
+import { Effect } from '../effect';
 import { MULBERRY } from './consts';
 import type { Snowflake } from './snowflake';
 
-export interface SnowSimulationConfig {
+export interface SnowConfig {
     readonly fillStyle?: string;
     readonly particles?: number;
     readonly scale?: number;
     readonly size?: number;
     readonly speed?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
 }
 
 const SPRITE_SIZE = 64;
 const SPRITE_CENTER = SPRITE_SIZE / 2;
 const SPRITE_RADIUS = SPRITE_SIZE / 2;
 
-export class SnowSimulation extends LimitedFrameRateCanvas {
+export class Snow extends Effect<SnowConfig> {
     readonly #scale: number;
     readonly #size: number;
-    readonly #speed: number;
+    #speed: number;
     readonly #baseOpacity: number;
     #maxParticles: number;
     #time: number = 0;
     #ratio: number = 1;
     #snowflakes: Snowflake[] = [];
     #sprites: HTMLCanvasElement[] = [];
+    #height: number = 540;
 
-    constructor(canvas: HTMLCanvasElement, config: SnowSimulationConfig = {}) {
-        super(canvas, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
+    constructor(config: SnowConfig = {}) {
+        super();
 
         this.#scale = config.scale ?? 1;
         this.#maxParticles = config.particles ?? 200;
         this.#size = (config.size ?? 9) * this.#scale;
         this.#speed = config.speed ?? 2;
 
-        const {r, g, b, a} = this.#parseColor(config.fillStyle ?? 'rgb(255 255 255 / .75)');
+        const {r, g, b, a} = parseColor(config.fillStyle ?? 'rgb(255 255 255 / .75)');
         this.#baseOpacity = a;
 
-        this.canvas.style.position = 'absolute';
-        this.canvas.style.top = '0';
-        this.canvas.style.left = '0';
-        this.canvas.style.height = '100%';
-        this.canvas.style.width = '100%';
-
-        if (this.isSmall) {
+        if (innerWidth < 991) {
             this.#maxParticles = Math.floor(this.#maxParticles / 2);
         }
 
@@ -54,77 +49,37 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
         }
     }
 
-    draw(): void {
-        this.canvas.height = this.height;
-        this.canvas.width = this.width;
-
-        const ctx = this.context;
-        ctx.clearRect(0, 0, this.width, this.height);
-
-        for (const snowflake of this.#snowflakes) {
-            const px = snowflake.x * this.width;
-            const py = snowflake.y * this.height;
-            const displayRadius = snowflake.radius * snowflake.depth * this.#ratio;
-            const displaySize = displayRadius * 2;
-
-            if (displaySize < 0.5) {
-                continue;
-            }
-
-            ctx.globalAlpha = this.#baseOpacity * (0.15 + snowflake.depth * 0.85);
-
-            if (snowflake.spriteIndex === 3) {
-                ctx.save();
-                ctx.translate(px, py);
-                ctx.rotate(snowflake.rotation);
-                ctx.drawImage(
-                    this.#sprites[snowflake.spriteIndex],
-                    -displayRadius,
-                    -displayRadius,
-                    displaySize,
-                    displaySize
-                );
-                ctx.restore();
-            } else {
-                ctx.drawImage(
-                    this.#sprites[snowflake.spriteIndex],
-                    px - displayRadius,
-                    py - displayRadius,
-                    displaySize,
-                    displaySize
-                );
-            }
+    configure(config: Partial<SnowConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
         }
+    }
 
-        ctx.globalAlpha = 1;
+    onResize(_width: number, height: number): void {
+        this.#height = height;
     }
 
-    tick(): void {
-        const speedFactor = (this.height / (420 * this.#ratio) / this.#speed) * this.deltaFactor;
+    tick(dt: number, _width: number, height: number): void {
+        this.#height = height;
 
-        this.#time += 0.015 * speedFactor;
+        const speedFactor = height / (420 * this.#ratio) / this.#speed;
+
+        this.#time += 0.015 * speedFactor * dt;
 
-        // Multi-frequency wind for organic movement
         const wind = Math.sin(this.#time * 0.7) * 0.5
-                   + Math.sin(this.#time * 1.9 + 3) * 0.25
-                   + Math.sin(this.#time * 4.3 + 1) * 0.1;
+            + Math.sin(this.#time * 1.9 + 3) * 0.25
+            + Math.sin(this.#time * 4.3 + 1) * 0.1;
 
         for (let index = 0; index < this.#snowflakes.length; index++) {
             const snowflake = this.#snowflakes[index];
 
-            // Individual swing oscillation
             const swing = Math.sin(this.#time * snowflake.swingFrequency + snowflake.swingOffset) * snowflake.swingAmplitude;
 
-            // Horizontal: personal swing + global wind (deeper = more wind influence)
-            snowflake.x += (swing + wind * snowflake.depth * 2) / (4000 * speedFactor);
-
-            // Vertical: individual speed + depth + size influence
-            snowflake.y += (snowflake.fallSpeed * 2 + snowflake.depth + snowflake.radius * 0.15) / (700 * speedFactor);
+            snowflake.x += (swing + wind * snowflake.depth * 2) * dt / (4000 * speedFactor);
+            snowflake.y += (snowflake.fallSpeed * 2 + snowflake.depth + snowflake.radius * 0.15) * dt / (700 * speedFactor);
 
-            // Rotation (only visually relevant for crystal sprites)
-            snowflake.rotation += snowflake.rotationSpeed / speedFactor;
+            snowflake.rotation += snowflake.rotationSpeed * dt / speedFactor;
 
-            // Recycle out-of-bounds particles
             if (snowflake.x > 1.15 || snowflake.x < -0.15 || snowflake.y > 1.05) {
                 const recycled = this.#createSnowflake(false);
 
@@ -147,26 +102,52 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
         }
     }
 
-    #parseColor(fillStyle: string): {r: number; g: number; b: number; a: number} {
-        const canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        const ctx = canvas.getContext('2d')!;
-        ctx.fillStyle = fillStyle;
-        ctx.fillRect(0, 0, 1, 1);
-        const data = ctx.getImageData(0, 0, 1, 1).data;
-        return {r: data[0], g: data[1], b: data[2], a: data[3] / 255};
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+
+        for (const snowflake of this.#snowflakes) {
+            const px = snowflake.x * width;
+            const py = snowflake.y * height;
+            const displayRadius = snowflake.radius * snowflake.depth * this.#ratio;
+            const displaySize = displayRadius * 2;
+
+            if (displaySize < 0.5) {
+                continue;
+            }
+
+            ctx.globalAlpha = this.#baseOpacity * (0.15 + snowflake.depth * 0.85);
+
+            if (snowflake.spriteIndex === 3) {
+                const cos = Math.cos(snowflake.rotation);
+                const sin = Math.sin(snowflake.rotation);
+                ctx.setTransform(cos, sin, -sin, cos, px, py);
+                ctx.drawImage(
+                    this.#sprites[snowflake.spriteIndex],
+                    -displayRadius,
+                    -displayRadius,
+                    displaySize,
+                    displaySize
+                );
+                ctx.resetTransform();
+            } else {
+                ctx.drawImage(
+                    this.#sprites[snowflake.spriteIndex],
+                    px - displayRadius,
+                    py - displayRadius,
+                    displaySize,
+                    displaySize
+                );
+            }
+        }
+
+        ctx.globalAlpha = 1;
     }
 
     #createSprites(r: number, g: number, b: number): HTMLCanvasElement[] {
         const sprites: HTMLCanvasElement[] = [];
 
         const gradientProfiles: [number, number][][] = [
-            // 0: Soft glow
             [[0, 0.8], [0.3, 0.4], [0.7, 0.1], [1, 0]],
-            // 1: Bright center
             [[0, 1], [0.15, 0.7], [0.5, 0.2], [1, 0]],
-            // 2: Compact dot
             [[0, 0.9], [0.25, 0.5], [0.5, 0.1], [1, 0]]
         ];
 
@@ -193,7 +174,6 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
             sprites.push(canvas);
         }
 
-        // 3: Crystal snowflake
         sprites.push(this.#createCrystalSprite(r, g, b));
 
         return sprites;
@@ -205,7 +185,6 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
         canvas.height = SPRITE_SIZE;
         const ctx = canvas.getContext('2d')!;
 
-        // Soft glow base
         const glow = ctx.createRadialGradient(
             SPRITE_CENTER, SPRITE_CENTER, 0,
             SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS
@@ -219,7 +198,6 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
         ctx.arc(SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS, 0, Math.PI * 2);
         ctx.fill();
 
-        // Crystal arms
         ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, 0.7)`;
         ctx.lineWidth = 1.5;
         ctx.lineCap = 'round';
@@ -231,13 +209,11 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
             const tipX = SPRITE_CENTER + Math.cos(angle) * armLength;
             const tipY = SPRITE_CENTER + Math.sin(angle) * armLength;
 
-            // Main arm
             ctx.beginPath();
             ctx.moveTo(SPRITE_CENTER, SPRITE_CENTER);
             ctx.lineTo(tipX, tipY);
             ctx.stroke();
 
-            // Side branches at 40% and 65% along the arm
             for (const position of [0.4, 0.65]) {
                 const branchX = SPRITE_CENTER + Math.cos(angle) * armLength * position;
                 const branchY = SPRITE_CENTER + Math.sin(angle) * armLength * position;
@@ -256,7 +232,6 @@ export class SnowSimulation extends LimitedFrameRateCanvas {
             }
         }
 
-        // Center dot
         const centerGlow = ctx.createRadialGradient(
             SPRITE_CENTER, SPRITE_CENTER, 0,
             SPRITE_CENTER, SPRITE_CENTER, SPRITE_RADIUS * 0.12

package/src/sparklers/consts.ts

@@ -0,0 +1,3 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);

package/src/sparklers/index.ts

@@ -0,0 +1,16 @@
+import { Sparklers } from './layer';
+import type { SparklersConfig } from './layer';
+import type { Effect } from '../effect';
+
+export interface SparklersInstance extends Effect<SparklersConfig> {
+    moveTo(x: number, y: number): void;
+}
+
+export function createSparklers(config?: SparklersConfig): SparklersInstance {
+    return new Sparklers(config) as SparklersInstance;
+}
+
+export { SparklerParticle } from './particle';
+export type { SparklersConfig };
+export type { SparklerParticleConfig } from './particle';
+export type { SparklerSpark } from './types';

package/src/sparklers/layer.ts

@@ -0,0 +1,220 @@
+import { hexToRGB } from '@basmilius/utils';
+import { Effect } from '../effect';
+import { MULBERRY } from './consts';
+import type { SparklerSpark } from './types';
+
+export interface SparklersConfig {
+    readonly emitRate?: number;
+    readonly maxSparks?: number;
+    readonly colors?: string[];
+    readonly speed?: [number, number];
+    readonly friction?: number;
+    readonly gravity?: number;
+    readonly decay?: [number, number];
+    readonly trailLength?: number;
+    readonly hoverMode?: boolean;
+    readonly scale?: number;
+}
+
+const DEFAULT_COLORS = ['#ffcc33', '#ff9900', '#ffffff', '#ffee88'];
+
+export class Sparklers extends Effect<SparklersConfig> {
+    #scale: number;
+    #emitRate: number;
+    readonly #maxSparks: number;
+    readonly #colorRGBs: [number, number, number][];
+    readonly #speedRange: [number, number];
+    #friction: number;
+    #gravity: number;
+    readonly #decayRange: [number, number];
+    #trailLength: number;
+    #hoverMode: boolean;
+    readonly #onMouseMoveBound: (evt: MouseEvent) => void;
+    readonly #onMouseLeaveBound: () => void;
+    #emitX: number = 0.5;
+    #emitY: number = 0.5;
+    #mouseOnCanvas: boolean = false;
+    #sparks: SparklerSpark[] = [];
+    #mountedCanvas: HTMLCanvasElement | null = null;
+    #cachedRect: DOMRect | null = null;
+
+    constructor(config: SparklersConfig = {}) {
+        super();
+
+        this.#scale = config.scale ?? 1;
+        this.#emitRate = config.emitRate ?? 8;
+        this.#maxSparks = config.maxSparks ?? 300;
+        this.#speedRange = config.speed ?? [2, 8];
+        this.#friction = config.friction ?? 0.96;
+        this.#gravity = config.gravity ?? 0.8;
+        this.#decayRange = config.decay ?? [0.02, 0.05];
+        this.#trailLength = config.trailLength ?? 3;
+        this.#hoverMode = config.hoverMode ?? false;
+
+        const colors = config.colors ?? DEFAULT_COLORS;
+        this.#colorRGBs = colors.map(c => hexToRGB(c));
+
+        this.#onMouseMoveBound = this.#onMouseMove.bind(this);
+        this.#onMouseLeaveBound = this.#onMouseLeave.bind(this);
+    }
+
+    moveTo(x: number, y: number): void {
+        this.#emitX = x;
+        this.#emitY = y;
+    }
+
+    onMount(canvas: HTMLCanvasElement): void {
+        this.#mountedCanvas = canvas;
+        this.#cachedRect = canvas.getBoundingClientRect();
+
+        if (this.#hoverMode) {
+            canvas.addEventListener('mousemove', this.#onMouseMoveBound, {passive: true});
+            canvas.addEventListener('mouseleave', this.#onMouseLeaveBound, {passive: true});
+        }
+    }
+
+    onUnmount(canvas: HTMLCanvasElement): void {
+        canvas.removeEventListener('mousemove', this.#onMouseMoveBound);
+        canvas.removeEventListener('mouseleave', this.#onMouseLeaveBound);
+        this.#mountedCanvas = null;
+        this.#cachedRect = null;
+    }
+
+    onResize(): void {
+        if (this.#mountedCanvas) {
+            this.#cachedRect = this.#mountedCanvas.getBoundingClientRect();
+        }
+    }
+
+    configure(config: Partial<SparklersConfig>): void {
+        if (config.scale !== undefined) {
+            this.#scale = config.scale;
+        }
+        if (config.emitRate !== undefined) {
+            this.#emitRate = config.emitRate;
+        }
+        if (config.friction !== undefined) {
+            this.#friction = config.friction;
+        }
+        if (config.gravity !== undefined) {
+            this.#gravity = config.gravity;
+        }
+        if (config.trailLength !== undefined) {
+            this.#trailLength = config.trailLength;
+        }
+        if (config.hoverMode !== undefined) {
+            this.#hoverMode = config.hoverMode;
+        }
+    }
+
+    tick(dt: number, width: number, height: number): void {
+        if (!this.#hoverMode || this.#mouseOnCanvas) {
+            const emitCount = Math.min(this.#emitRate, this.#maxSparks - this.#sparks.length);
+
+            for (let i = 0; i < emitCount; i++) {
+                this.#sparks.push(this.#createSpark(width, height));
+            }
+        }
+
+        const frictionFactor = Math.pow(this.#friction, dt);
+        let alive = 0;
+
+        for (let i = 0; i < this.#sparks.length; i++) {
+            const spark = this.#sparks[i];
+
+            spark.trail.push({x: spark.x, y: spark.y});
+
+            if (spark.trail.length > this.#trailLength) {
+                spark.trail.shift();
+            }
+
+            spark.vx *= frictionFactor;
+            spark.vy *= frictionFactor;
+            spark.vy += this.#gravity * this.#scale * dt;
+
+            spark.x += spark.vx * dt;
+            spark.y += spark.vy * dt;
+
+            spark.alpha -= spark.decay * dt;
+
+            if (spark.alpha > 0) {
+                this.#sparks[alive++] = spark;
+            }
+        }
+
+        this.#sparks.length = alive;
+    }
+
+    draw(ctx: CanvasRenderingContext2D, width: number, height: number): void {
+        ctx.globalCompositeOperation = 'lighter';
+
+        if (!this.#hoverMode || this.#mouseOnCanvas) {
+            const cx = this.#emitX * width;
+            const cy = this.#emitY * height;
+            const glowRadius = 15 * this.#scale;
+            const glow = ctx.createRadialGradient(cx, cy, 0, cx, cy, glowRadius);
+            glow.addColorStop(0, 'rgba(255, 220, 100, 0.8)');
+            glow.addColorStop(0.3, 'rgba(255, 180, 50, 0.3)');
+            glow.addColorStop(1, 'rgba(255, 150, 0, 0)');
+            ctx.fillStyle = glow;
+            ctx.beginPath();
+            ctx.arc(cx, cy, glowRadius, 0, Math.PI * 2);
+            ctx.fill();
+        }
+
+        for (const spark of this.#sparks) {
+            const [r, g, b] = spark.color;
+
+            for (let t = 0; t < spark.trail.length; t++) {
+                const trailAlpha = spark.alpha * (t / spark.trail.length) * 0.5;
+
+                if (trailAlpha < 0.01) {
+                    continue;
+                }
+
+                const trailSize = spark.size * (t / spark.trail.length) * this.#scale;
+
+                ctx.beginPath();
+                ctx.arc(spark.trail[t].x, spark.trail[t].y, trailSize, 0, Math.PI * 2);
+                ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${trailAlpha})`;
+                ctx.fill();
+            }
+
+            ctx.beginPath();
+            ctx.arc(spark.x, spark.y, spark.size * this.#scale, 0, Math.PI * 2);
+            ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${spark.alpha})`;
+            ctx.fill();
+        }
+
+        ctx.globalCompositeOperation = 'source-over';
+    }
+
+    #onMouseMove(evt: MouseEvent): void {
+        const rect = this.#cachedRect ?? (evt.currentTarget as HTMLCanvasElement).getBoundingClientRect();
+        this.#emitX = (evt.clientX - rect.left) / rect.width;
+        this.#emitY = (evt.clientY - rect.top) / rect.height;
+        this.#mouseOnCanvas = true;
+    }
+
+    #onMouseLeave(): void {
+        this.#mouseOnCanvas = false;
+    }
+
+    #createSpark(width: number, height: number): SparklerSpark {
+        const angle = MULBERRY.next() * Math.PI * 2;
+        const speed = this.#speedRange[0] + MULBERRY.next() * (this.#speedRange[1] - this.#speedRange[0]);
+        const colorIndex = Math.floor(MULBERRY.next() * this.#colorRGBs.length);
+
+        return {
+            x: this.#emitX * width,
+            y: this.#emitY * height,
+            vx: Math.cos(angle) * speed * this.#scale,
+            vy: Math.sin(angle) * speed * this.#scale,
+            alpha: 0.8 + MULBERRY.next() * 0.2,
+            color: this.#colorRGBs[colorIndex],
+            size: 1 + MULBERRY.next() * 2,
+            decay: this.#decayRange[0] + MULBERRY.next() * (this.#decayRange[1] - this.#decayRange[0]),
+            trail: []
+        };
+    }
+}

package/src/sparklers/particle.ts

@@ -0,0 +1,89 @@
+import type { Point } from '../point';
+
+export interface SparklerParticleConfig {
+    readonly decay?: number;
+    readonly friction?: number;
+    readonly gravity?: number;
+    readonly scale?: number;
+    readonly size?: number;
+    readonly trailLength?: number;
+}
+
+export class SparklerParticle {
+    readonly #color: [number, number, number];
+    readonly #decay: number;
+    readonly #friction: number;
+    readonly #gravity: number;
+    readonly #scale: number;
+    readonly #size: number;
+    readonly #trailLength: number;
+    readonly #trail: Point[] = [];
+    #x: number;
+    #y: number;
+    #vx: number;
+    #vy: number;
+    #alpha: number = 1;
+
+    get isDead(): boolean {
+        return this.#alpha <= 0;
+    }
+
+    get position(): Point {
+        return {x: this.#x, y: this.#y};
+    }
+
+    constructor(position: Point, velocity: Point, color: [number, number, number], config: SparklerParticleConfig = {}) {
+        this.#x = position.x;
+        this.#y = position.y;
+        this.#vx = velocity.x;
+        this.#vy = velocity.y;
+        this.#color = color;
+        this.#decay = config.decay ?? (0.02 + Math.random() * 0.03);
+        this.#friction = config.friction ?? 0.96;
+        this.#gravity = config.gravity ?? 0.8;
+        this.#scale = config.scale ?? 1;
+        this.#size = config.size ?? (1 + Math.random() * 2);
+        this.#trailLength = config.trailLength ?? 3;
+    }
+
+    draw(ctx: CanvasRenderingContext2D): void {
+        const [r, g, b] = this.#color;
+
+        for (let t = 0; t < this.#trail.length; t++) {
+            const trailAlpha = this.#alpha * (t / this.#trail.length) * 0.5;
+
+            if (trailAlpha < 0.01) {
+                continue;
+            }
+
+            const trailSize = this.#size * (t / this.#trail.length) * this.#scale;
+
+            ctx.beginPath();
+            ctx.arc(this.#trail[t].x, this.#trail[t].y, trailSize, 0, Math.PI * 2);
+            ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${trailAlpha})`;
+            ctx.fill();
+        }
+
+        ctx.beginPath();
+        ctx.arc(this.#x, this.#y, this.#size * this.#scale, 0, Math.PI * 2);
+        ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${this.#alpha})`;
+        ctx.fill();
+    }
+
+    tick(dt: number = 1): void {
+        this.#trail.push({x: this.#x, y: this.#y});
+
+        if (this.#trail.length > this.#trailLength) {
+            this.#trail.shift();
+        }
+
+        this.#vx *= Math.pow(this.#friction, dt);
+        this.#vy *= Math.pow(this.#friction, dt);
+        this.#vy += this.#gravity * this.#scale * dt;
+
+        this.#x += this.#vx * dt;
+        this.#y += this.#vy * dt;
+
+        this.#alpha -= this.#decay * dt;
+    }
+}

package/src/sparklers/types.ts

@@ -0,0 +1,13 @@
+import type { Point } from '../point';
+
+export type SparklerSpark = {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    alpha: number;
+    color: [number, number, number];
+    size: number;
+    decay: number;
+    trail: Point[];
+};

package/src/stars/consts.ts

@@ -0,0 +1,3 @@
+import { type Mulberry32, mulberry32 } from '@basmilius/utils';
+
+export const MULBERRY: Mulberry32 = mulberry32(13);

package/src/stars/index.ts

@@ -0,0 +1,10 @@
+import { Stars } from './layer';
+import type { StarsConfig } from './layer';
+import type { Effect } from '../effect';
+
+export function createStars(config?: StarsConfig): Effect<StarsConfig> {
+    return new Stars(config);
+}
+
+export type { StarsConfig };
+export type { Star, StarMode, ShootingStar } from './types';