@basmilius/sparkle 2.1.0 → 2.3.0

package/src/waves/layer.ts

@@ -1,30 +1,38 @@
-import { SimulationLayer } from '../layer';
+import { hexToRGB } from '@basmilius/utils';
+import { Effect } from '../effect';
 import { MULBERRY } from './consts';
-import type { WaveSimulationConfig } from './simulation';
 import type { Wave } from './types';
 
 const DEFAULT_COLORS = ['#0a3d6b', '#0e5a8a', '#1a7ab5', '#3399cc', '#66c2e0'];
 
-export class WaveLayer extends SimulationLayer {
-    readonly #speed: number;
-    readonly #foamColor: string;
-    readonly #foamAmount: number;
-    readonly #scale: number;
-    #time: number = 0;
+export interface WavesConfig {
+    readonly layers?: number;
+    readonly speed?: number;
+    readonly colors?: string[];
+    readonly foamColor?: string;
+    readonly foamAmount?: number;
+    readonly scale?: number;
+}
+
+export class Waves extends Effect<WavesConfig> {
+    #speed: number;
+    #foamAmount: number;
+    #scale: number;
+    readonly #foamRGB: [number, number, number];
     #waves: Wave[] = [];
-    #foamParticles: {x: number; y: number; alpha: number; size: number}[] = [];
+    #foamParticles: { x: number; y: number; alpha: number; size: number }[] = [];
     #maxFoamParticles: number;
 
-    constructor(config: WaveSimulationConfig = {}) {
+    constructor(config: WavesConfig = {}) {
         super();
 
         const layers = config.layers ?? 5;
         const colors = config.colors ?? DEFAULT_COLORS;
         this.#speed = config.speed ?? 1;
-        this.#foamColor = config.foamColor ?? '#ffffff';
         this.#foamAmount = config.foamAmount ?? 0.4;
         this.#scale = config.scale ?? 1;
         this.#maxFoamParticles = 120;
+        this.#foamRGB = hexToRGB(config.foamColor ?? '#ffffff');
 
         if (innerWidth < 991) {
             this.#maxFoamParticles = Math.floor(this.#maxFoamParticles / 2);
@@ -37,20 +45,31 @@ export class WaveLayer extends SimulationLayer {
             this.#waves.push({
                 amplitude: (20 + MULBERRY.next() * 30) * (1 - depth * 0.4),
                 frequency: 0.005 + MULBERRY.next() * 0.008 + depth * 0.002,
-                speed: (0.4 + MULBERRY.next() * 0.6 + depth * 0.3) * this.#speed,
+                speed: 0.4 + MULBERRY.next() * 0.6 + depth * 0.3,
                 phase: MULBERRY.next() * Math.PI * 2,
                 baseY: 0.35 + depth * 0.13,
                 color,
-                foamThreshold: 0.6 + MULBERRY.next() * 0.3
+                foamThreshold: 0.6 + MULBERRY.next() * 0.3,
+                rgb: hexToRGB(color)
             });
         }
     }
 
-    tick(dt: number, width: number, height: number): void {
-        this.#time += 0.02 * dt * this.#speed;
+    configure(config: Partial<WavesConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+        if (config.foamAmount !== undefined) {
+            this.#foamAmount = config.foamAmount;
+        }
+        if (config.scale !== undefined) {
+            this.#scale = config.scale;
+        }
+    }
 
+    tick(dt: number, width: number, height: number): void {
         for (const wave of this.#waves) {
-            wave.phase += 0.015 * wave.speed * dt;
+            wave.phase += 0.015 * wave.speed * this.#speed * dt;
         }
 
         let aliveFoam = 0;
@@ -100,6 +119,7 @@ export class WaveLayer extends SimulationLayer {
 
         for (let wi = 0; wi < this.#waves.length; wi++) {
             const wave = this.#waves[wi];
+            const [wr, wg, wb] = wave.rgb;
             const centerY = wave.baseY * height;
 
             ctx.beginPath();
@@ -118,15 +138,17 @@ export class WaveLayer extends SimulationLayer {
             ctx.closePath();
 
             const gradient = ctx.createLinearGradient(0, centerY - wave.amplitude * this.#scale, 0, height);
-            gradient.addColorStop(0, this.#adjustAlpha(wave.color, 0.85));
-            gradient.addColorStop(0.4, wave.color);
-            gradient.addColorStop(1, this.#darkenColor(wave.color, 0.6));
+            gradient.addColorStop(0, `rgba(${wr}, ${wg}, ${wb}, 0.85)`);
+            gradient.addColorStop(0.4, `rgb(${wr}, ${wg}, ${wb})`);
+            gradient.addColorStop(1, `rgb(${Math.floor(wr * 0.6)}, ${Math.floor(wg * 0.6)}, ${Math.floor(wb * 0.6)})`);
 
             ctx.fillStyle = gradient;
             ctx.fill();
         }
 
         if (this.#foamAmount > 0) {
+            const [fr, fg, fb] = this.#foamRGB;
+
             for (const foam of this.#foamParticles) {
                 if (foam.alpha <= 0) {
                     continue;
@@ -134,34 +156,9 @@ export class WaveLayer extends SimulationLayer {
 
                 ctx.beginPath();
                 ctx.arc(foam.x, foam.y, foam.size * this.#scale, 0, Math.PI * 2);
-                ctx.fillStyle = this.#adjustAlpha(this.#foamColor, foam.alpha * this.#foamAmount);
+                ctx.fillStyle = `rgba(${fr}, ${fg}, ${fb}, ${foam.alpha * this.#foamAmount})`;
                 ctx.fill();
             }
         }
     }
-
-    #adjustAlpha(color: string, alpha: number): string {
-        const canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        const ctx = canvas.getContext('2d')!;
-        ctx.fillStyle = color;
-        ctx.fillRect(0, 0, 1, 1);
-        const data = ctx.getImageData(0, 0, 1, 1).data;
-        return `rgba(${data[0]}, ${data[1]}, ${data[2]}, ${alpha})`;
-    }
-
-    #darkenColor(color: string, factor: number): string {
-        const canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        const ctx = canvas.getContext('2d')!;
-        ctx.fillStyle = color;
-        ctx.fillRect(0, 0, 1, 1);
-        const data = ctx.getImageData(0, 0, 1, 1).data;
-        const r = Math.floor(data[0] * factor);
-        const g = Math.floor(data[1] * factor);
-        const b = Math.floor(data[2] * factor);
-        return `rgb(${r}, ${g}, ${b})`;
-    }
 }

package/src/waves/types.ts

@@ -6,4 +6,5 @@ export type Wave = {
     baseY: number;
     color: string;
     foamThreshold: number;
+    rgb: [number, number, number];
 };

package/src/wormhole/index.ts

@@ -1,4 +1,10 @@
-export { WormholeLayer } from './layer';
-export { WormholeSimulation } from './simulation';
-export type { WormholeSimulationConfig } from './simulation';
+import { Wormhole } from './layer';
+import type { WormholeConfig } from './layer';
+import type { Effect } from '../effect';
+
+export function createWormhole(config?: WormholeConfig): Effect<WormholeConfig> {
+    return new Wormhole(config);
+}
+
+export type { WormholeConfig };
 export type { WormholeDirection, WormholeParticle } from './types';

package/src/wormhole/layer.ts

@@ -1,21 +1,28 @@
 import { hexToRGB } from '@basmilius/utils';
-import { SimulationLayer } from '../layer';
+import { Effect } from '../effect';
 import { MULBERRY } from './consts';
-import type { WormholeSimulationConfig } from './simulation';
 import type { WormholeDirection, WormholeParticle } from './types';
 
-export class WormholeLayer extends SimulationLayer {
-    readonly #speed: number;
+export interface WormholeConfig {
+    readonly count?: number;
+    readonly speed?: number;
+    readonly color?: string;
+    readonly direction?: WormholeDirection;
+    readonly scale?: number;
+}
+
+export class Wormhole extends Effect<WormholeConfig> {
+    #speed: number;
     readonly #colorRGB: [number, number, number];
     readonly #direction: WormholeDirection;
-    readonly #scale: number;
+    #scale: number;
     #count: number;
     #particles: WormholeParticle[] = [];
     #width: number = 960;
     #height: number = 540;
     #initialized: boolean = false;
 
-    constructor(config: WormholeSimulationConfig = {}) {
+    constructor(config: WormholeConfig = {}) {
         super();
 
         let count = config.count ?? 200;
@@ -46,6 +53,15 @@ export class WormholeLayer extends SimulationLayer {
         }
     }
 
+    configure(config: Partial<WormholeConfig>): void {
+        if (config.speed !== undefined) {
+            this.#speed = config.speed;
+        }
+        if (config.scale !== undefined) {
+            this.#scale = config.scale;
+        }
+    }
+
     tick(dt: number, width: number, height: number): void {
         this.#width = width;
         this.#height = height;

package/src/aurora/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { AuroraLayer } from './layer';
-
-export interface AuroraSimulationConfig {
-    readonly bands?: number;
-    readonly colors?: string[];
-    readonly speed?: number;
-    readonly intensity?: number;
-    readonly waveAmplitude?: number;
-    readonly verticalPosition?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class AuroraSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: AuroraSimulationConfig = {}) {
-        super(canvas, new AuroraLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/balloons/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { BalloonLayer } from './layer';
-
-export interface BalloonSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly sizeRange?: [number, number];
-    readonly speed?: number;
-    readonly driftAmount?: number;
-    readonly stringLength?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class BalloonSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: BalloonSimulationConfig = {}) {
-        super(canvas, new BalloonLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/bubbles/simulation.ts

@@ -1,20 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { BubbleLayer } from './layer';
-
-export interface BubbleSimulationConfig {
-    readonly count?: number;
-    readonly sizeRange?: [number, number];
-    readonly speed?: number;
-    readonly popOnClick?: boolean;
-    readonly popRadius?: number;
-    readonly colors?: string[];
-    readonly wobbleAmount?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class BubbleSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: BubbleSimulationConfig = {}) {
-        super(canvas, new BubbleLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/confetti/simulation.ts

@@ -1,27 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { ConfettiLayer } from './layer';
-import type { Config } from './types';
-
-export interface ConfettiSimulationConfig {
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class ConfettiSimulation extends SimulationCanvas {
-    readonly #layer: ConfettiLayer;
-
-    constructor(canvas: HTMLCanvasElement, config: ConfettiSimulationConfig = {}) {
-        const layer = new ConfettiLayer(config);
-        super(canvas, layer, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-        this.#layer = layer;
-    }
-
-    fire(config: Partial<Config>): void {
-        this.onResize();
-        this.#layer.fire(config);
-
-        if (!this.isTicking) {
-            this.start();
-        }
-    }
-}

package/src/donuts/simulation.ts

@@ -1,25 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { DonutLayer } from './layer';
-
-export interface DonutSimulationConfig {
-    readonly background?: string;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-    readonly collisionPadding?: number;
-    readonly colors?: string[];
-    readonly count?: number;
-    readonly mouseAvoidance?: boolean;
-    readonly mouseAvoidanceRadius?: number;
-    readonly mouseAvoidanceStrength?: number;
-    readonly radiusRange?: [number, number];
-    readonly repulsionStrength?: number;
-    readonly rotationSpeedRange?: [number, number];
-    readonly scale?: number;
-    readonly speedRange?: [number, number];
-    readonly thickness?: number;
-}
-
-export class DonutSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: DonutSimulationConfig = {}) {
-        super(canvas, new DonutLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/fireflies/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FireflyLayer } from './layer';
-
-export interface FireflySimulationConfig {
-    readonly count?: number;
-    readonly color?: string;
-    readonly size?: number;
-    readonly speed?: number;
-    readonly glowSpeed?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class FireflySimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: FireflySimulationConfig = {}) {
-        super(canvas, new FireflyLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/firepit/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FirepitLayer } from './layer';
-
-export interface FirepitSimulationConfig {
-    readonly embers?: number;
-    readonly flameWidth?: number;
-    readonly flameHeight?: number;
-    readonly intensity?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class FirepitSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: FirepitSimulationConfig = {}) {
-        super(canvas, new FirepitLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/fireworks/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { FireworkLayer } from './layer';
-import type { Point } from '../point';
-import type { FireworkSimulationConfig, FireworkVariant } from './types';
-
-export class FireworkSimulation extends SimulationCanvas {
-    readonly #layer: FireworkLayer;
-
-    constructor(canvas: HTMLCanvasElement, config: FireworkSimulationConfig = {}) {
-        const layer = new FireworkLayer(config);
-        super(canvas, layer, 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-        this.#layer = layer;
-    }
-
-    fireExplosion(variant: FireworkVariant, position?: Point): void {
-        this.#layer.fireExplosion(variant, position);
-    }
-}

package/src/glitter/simulation.ts

@@ -1,19 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { GlitterLayer } from './layer';
-
-export interface GlitterSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly groundLevel?: number;
-    readonly maxSettled?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class GlitterSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: GlitterSimulationConfig = {}) {
-        super(canvas, new GlitterLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/lanterns/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LanternLayer } from './layer';
-
-export interface LanternSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LanternSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LanternSimulationConfig = {}) {
-        super(canvas, new LanternLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/layered.ts

@@ -1,185 +0,0 @@
-import { LimitedFrameRateCanvas } from './canvas';
-import type { EdgeFade, EdgeFadeSide, SimulationLayer } from './layer';
-
-function parseSide(side: EdgeFadeSide): [number, number] {
-    return typeof side === 'number' ? [0, side] : side;
-}
-
-
-function applyEdgeFade(ctx: CanvasRenderingContext2D, width: number, height: number, fade: EdgeFade): void {
-    ctx.globalCompositeOperation = 'destination-out';
-
-    if (fade.top !== undefined) {
-        const [near, far] = parseSide(fade.top);
-        const nearPx = near * height;
-        const farPx = far * height;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, 0, width, nearPx);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(0, nearPx, 0, farPx);
-            gradient.addColorStop(0, 'rgba(0,0,0,1)');
-            gradient.addColorStop(1, 'rgba(0,0,0,0)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(0, nearPx, width, farPx - nearPx);
-        }
-    }
-
-    if (fade.bottom !== undefined) {
-        const [near, far] = parseSide(fade.bottom);
-        const nearPx = near * height;
-        const farPx = far * height;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, height - nearPx, width, nearPx);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(0, height - farPx, 0, height - nearPx);
-            gradient.addColorStop(0, 'rgba(0,0,0,0)');
-            gradient.addColorStop(1, 'rgba(0,0,0,1)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(0, height - farPx, width, farPx - nearPx);
-        }
-    }
-
-    if (fade.left !== undefined) {
-        const [near, far] = parseSide(fade.left);
-        const nearPx = near * width;
-        const farPx = far * width;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(0, 0, nearPx, height);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(nearPx, 0, farPx, 0);
-            gradient.addColorStop(0, 'rgba(0,0,0,1)');
-            gradient.addColorStop(1, 'rgba(0,0,0,0)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(nearPx, 0, farPx - nearPx, height);
-        }
-    }
-
-    if (fade.right !== undefined) {
-        const [near, far] = parseSide(fade.right);
-        const nearPx = near * width;
-        const farPx = far * width;
-
-        if (nearPx > 0) {
-            ctx.fillStyle = 'rgba(0,0,0,1)';
-            ctx.fillRect(width - nearPx, 0, nearPx, height);
-        }
-
-        if (farPx > nearPx) {
-            const gradient = ctx.createLinearGradient(width - farPx, 0, width - nearPx, 0);
-            gradient.addColorStop(0, 'rgba(0,0,0,0)');
-            gradient.addColorStop(1, 'rgba(0,0,0,1)');
-            ctx.fillStyle = gradient;
-            ctx.fillRect(width - farPx, 0, farPx - nearPx, height);
-        }
-    }
-
-    ctx.globalCompositeOperation = 'source-over';
-}
-
-export class LayeredSimulation extends LimitedFrameRateCanvas {
-    readonly #layers: SimulationLayer[] = [];
-    readonly #contextOptions: CanvasRenderingContext2DSettings;
-    #offscreen: HTMLCanvasElement | null = null;
-    #offscreenCtx: CanvasRenderingContext2D | null = null;
-
-    constructor(canvas: HTMLCanvasElement, frameRate: number = 60, options: CanvasRenderingContext2DSettings = {colorSpace: 'display-p3'}) {
-        super(canvas, frameRate, options);
-        this.#contextOptions = options;
-
-        canvas.style.position = 'absolute';
-        canvas.style.top = '0';
-        canvas.style.left = '0';
-        canvas.style.height = '100%';
-        canvas.style.width = '100%';
-    }
-
-    add(layer: SimulationLayer): this {
-        this.#layers.push(layer);
-
-        if (this.isTicking) {
-            layer.onMount(this.canvas);
-        }
-
-        return this;
-    }
-
-    start(): void {
-        for (const layer of this.#layers) {
-            layer.onMount(this.canvas);
-        }
-        super.start();
-    }
-
-    destroy(): void {
-        for (const layer of this.#layers) {
-            layer.onUnmount(this.canvas);
-        }
-        super.destroy();
-    }
-
-    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 layer of this.#layers) {
-            if (layer.fade) {
-                const offCtx = this.#getOffscreenCtx(this.width, this.height);
-                offCtx.clearRect(0, 0, this.width, this.height);
-                layer.draw(offCtx, this.width, this.height);
-                applyEdgeFade(offCtx, this.width, this.height, layer.fade);
-                ctx.drawImage(this.#offscreen!, 0, 0);
-            } else {
-                ctx.save();
-                layer.draw(ctx, this.width, this.height);
-                ctx.restore();
-            }
-        }
-    }
-
-    tick(): void {
-        const dt = (this.delta > 0 && this.delta < 200 ? this.delta / (1000 / 60) : 1) * this.speed * LimitedFrameRateCanvas.globalSpeed;
-
-        for (const layer of this.#layers) {
-            layer.tick(dt, this.width, this.height);
-        }
-    }
-
-    onResize(): void {
-        super.onResize();
-
-        if (this.#offscreen) {
-            this.#offscreen.width = this.width;
-            this.#offscreen.height = this.height;
-        }
-
-        for (const layer of this.#layers) {
-            layer.onResize(this.width, this.height);
-        }
-    }
-
-    #getOffscreenCtx(width: number, height: number): CanvasRenderingContext2D {
-        if (!this.#offscreen) {
-            this.#offscreen = document.createElement('canvas');
-            this.#offscreen.width = width;
-            this.#offscreen.height = height;
-            this.#offscreenCtx = this.#offscreen.getContext('2d', this.#contextOptions)!;
-        }
-
-        return this.#offscreenCtx!;
-    }
-}

package/src/leaves/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LeafLayer } from './layer';
-
-export interface LeafSimulationConfig {
-    readonly count?: number;
-    readonly colors?: string[];
-    readonly size?: number;
-    readonly speed?: number;
-    readonly wind?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LeafSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LeafSimulationConfig = {}) {
-        super(canvas, new LeafLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/lightning/simulation.ts

@@ -1,17 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { LightningLayer } from './layer';
-
-export interface LightningSimulationConfig {
-    readonly frequency?: number;
-    readonly color?: string;
-    readonly branches?: boolean;
-    readonly flash?: boolean;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class LightningSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: LightningSimulationConfig = {}) {
-        super(canvas, new LightningLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}

package/src/matrix/simulation.ts

@@ -1,18 +0,0 @@
-import { SimulationCanvas } from '../simulation-canvas';
-import { MatrixLayer } from './layer';
-
-export interface MatrixSimulationConfig {
-    readonly columns?: number;
-    readonly speed?: number;
-    readonly color?: string;
-    readonly fontSize?: number;
-    readonly trailLength?: number;
-    readonly scale?: number;
-    readonly canvasOptions?: CanvasRenderingContext2DSettings;
-}
-
-export class MatrixSimulation extends SimulationCanvas {
-    constructor(canvas: HTMLCanvasElement, config: MatrixSimulationConfig = {}) {
-        super(canvas, new MatrixLayer(config), 60, config.canvasOptions ?? {colorSpace: 'display-p3'});
-    }
-}