own-the-canvas 1.0.0

package/dist/components/Confetti/useConfetti.d.ts

@@ -0,0 +1,25 @@
+import { RefObject } from 'react';
+
+export type ConfettiShape = "square" | "circle" | "triangle" | "strip";
+export interface UseConfettiOptions {
+    trigger: boolean;
+    particleCount: number;
+    spread: number;
+    gravity: number;
+    colors: string[];
+    shapes: ConfettiShape[];
+    duration: number;
+    continuous: boolean;
+    wind: number;
+    spawnX: number;
+    spawnY: number;
+    spawnSpread: number;
+    speedMin: number;
+    speedMax: number;
+    sizeMin: number;
+    sizeMax: number;
+    angularVelocity: number;
+    emissionRate: number;
+    onComplete?: () => void;
+}
+export declare function useConfetti(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseConfettiOptions): void;

package/dist/components/ConstellationMap/ConstellationMap.d.ts

@@ -0,0 +1,42 @@
+import { BaseCanvasProps } from '../../types';
+import { ConstellationLineStyle } from './useConstellationMap';
+
+type ConstellationPreset = "default" | "cosmos" | "minimal" | "aurora" | "gold";
+export interface ConstellationMapProps extends BaseCanvasProps {
+    /** Number of stars (default: 80) */
+    starCount?: number;
+    /** Star color (default: "#ffffff") */
+    starColor?: string;
+    /** Connection line color (default: "#8888ff") */
+    lineColor?: string;
+    /** Background color (default: "#050510") */
+    backgroundColor?: string;
+    /** Star drift speed (default: 0.3) */
+    speed?: number;
+    /** Enable drag-to-move stars (default: true) */
+    interactive?: boolean;
+    /** Line style (default: "solid") */
+    lineStyle?: ConstellationLineStyle;
+    /** Glow effect on stars (default: true) */
+    glowStars?: boolean;
+    /** Max distance for drawing lines (default: 100) */
+    connectionDistance?: number;
+    /** Velocity multiplier for initial star speed (default: 0.3) */
+    velocityMultiplier?: number;
+    /** Drag detection radius in px (default: 20) */
+    dragRadius?: number;
+    /** Twinkle animation speed (default: 0.03) */
+    twinkleSpeed?: number;
+    /** Max line opacity (default: 0.5) */
+    lineAlpha?: number;
+    /** Connection line width (default: 0.8) */
+    lineWidth?: number;
+    /** Glow blur as multiple of star size (default: 4) */
+    glowMultiplier?: number;
+    /** Twinkle opacity amplitude 0–1 (default: 0.4) */
+    twinkleAmplitude?: number;
+    /** Named preset: "default" | "cosmos" | "minimal" | "aurora" | "gold" */
+    preset?: ConstellationPreset | string;
+}
+export declare const ConstellationMap: import('react').ForwardRefExoticComponent<ConstellationMapProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/ConstellationMap/ConstellationMap.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { ConstellationMap } from './ConstellationMap';
+
+declare const meta: Meta<typeof ConstellationMap>;
+export default meta;
+type Story = StoryObj<typeof ConstellationMap>;
+export declare const Default: Story;
+export declare const Dashed: Story;
+export declare const Dense: Story;

package/dist/components/ConstellationMap/index.d.ts

@@ -0,0 +1,3 @@
+export { ConstellationMap } from './ConstellationMap';
+export type { ConstellationMapProps } from './ConstellationMap';
+export type { ConstellationLineStyle } from './useConstellationMap';

package/dist/components/ConstellationMap/useConstellationMap.d.ts

@@ -0,0 +1,22 @@
+import { RefObject } from 'react';
+
+export type ConstellationLineStyle = "solid" | "dashed";
+export interface UseConstellationMapOptions {
+    starCount: number;
+    starColor: string;
+    lineColor: string;
+    backgroundColor: string;
+    speed: number;
+    interactive: boolean;
+    lineStyle: ConstellationLineStyle;
+    glowStars: boolean;
+    connectionDistance: number;
+    velocityMultiplier: number;
+    dragRadius: number;
+    twinkleSpeed: number;
+    lineAlpha: number;
+    lineWidth: number;
+    glowMultiplier: number;
+    twinkleAmplitude: number;
+}
+export declare function useConstellationMap(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseConstellationMapOptions): void;

package/dist/components/FireEffect/FireEffect.d.ts

@@ -0,0 +1,28 @@
+import { BaseCanvasProps } from '../../types';
+import { FirePalette } from './useFireEffect';
+
+type FirePreset = "default" | "inferno" | "toxic" | "ice" | "plasma";
+export interface FireEffectProps extends BaseCanvasProps {
+    /** Color theme (default: "smoke") */
+    palette?: FirePalette;
+    /** Flame intensity 0–1 (default: 0.95) */
+    intensity?: number;
+    /** Wind horizontal strength -1 to 1 (default: 0.3) */
+    windStrength?: number;
+    /** Wind direction: 1 = right, -1 = left (default: 1) */
+    windDirection?: number;
+    /** Flame spread 0–1 (default: 0.7) */
+    spread?: number;
+    /** Cooling rate 0–1 — higher = shorter flames (default: 0.3) */
+    cooling?: number;
+    /** Bottom-row seed noise magnitude (default: 60) */
+    noiseStrength?: number;
+    /** Cooling amount scaling factor (default: 5) */
+    coolingScale?: number;
+    /** Fire buffer resolution relative to canvas — 0.5 = half size for perf (default: 1) */
+    resolution?: number;
+    /** Named preset: "default" | "inferno" | "toxic" | "ice" | "plasma" */
+    preset?: FirePreset | string;
+}
+export declare const FireEffect: import('react').ForwardRefExoticComponent<FireEffectProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/FireEffect/FireEffect.stories.d.ts

@@ -0,0 +1,10 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { FireEffect } from './FireEffect';
+
+declare const meta: Meta<typeof FireEffect>;
+export default meta;
+type Story = StoryObj<typeof FireEffect>;
+export declare const Inferno: Story;
+export declare const Toxic: Story;
+export declare const Ice: Story;
+export declare const Plasma: Story;

package/dist/components/FireEffect/index.d.ts

@@ -0,0 +1,3 @@
+export { FireEffect } from './FireEffect';
+export type { FireEffectProps } from './FireEffect';
+export type { FirePalette } from './useFireEffect';

package/dist/components/FireEffect/useFireEffect.d.ts

@@ -0,0 +1,15 @@
+import { RefObject } from 'react';
+
+export type FirePalette = "inferno" | "toxic" | "ice" | "plasma" | "smoke";
+export interface UseFireEffectOptions {
+    palette: FirePalette;
+    intensity: number;
+    windStrength: number;
+    windDirection: number;
+    spread: number;
+    cooling: number;
+    noiseStrength: number;
+    coolingScale: number;
+    resolution: number;
+}
+export declare function useFireEffect(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseFireEffectOptions): void;

package/dist/components/Fireworks/Fireworks.d.ts

@@ -0,0 +1,37 @@
+import { BaseCanvasProps } from '../../types';
+
+type FireworksPreset = "default" | "celebration" | "subtle" | "neon" | "golden";
+export interface FireworksProps extends BaseCanvasProps {
+    /** Particle burst colors (default: multi-color) */
+    colors?: string[];
+    /** Particles per explosion (default: 80) */
+    particleCount?: number;
+    /** Gravity pull per frame (default: 0.08) */
+    gravity?: number;
+    /** Velocity friction 0–1 (default: 0.97) */
+    friction?: number;
+    /** Alpha fade per frame (default: 0.015) */
+    fadeSpeed?: number;
+    /** Particle base size in px (default: 2) */
+    particleSize?: number;
+    /** Trail history length (default: 6) */
+    trailLength?: number;
+    /** Explosion spread speed (default: 5) */
+    spread?: number;
+    /** Auto-launch shells (default: true) */
+    autoLaunch?: boolean;
+    /** Average ms between auto-launches (default: 1800) */
+    autoInterval?: number;
+    /** Glow on particles (default: true) */
+    glowEffect?: boolean;
+    /** Shadow blur for glow (default: 8) */
+    glowBlur?: number;
+    /** Canvas background (default: "#050010") */
+    backgroundColor?: string;
+    /** Shell upward speed (default: 12) */
+    shellSpeed?: number;
+    /** Named preset */
+    preset?: FireworksPreset | string;
+}
+export declare const Fireworks: import('react').ForwardRefExoticComponent<FireworksProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/Fireworks/index.d.ts

@@ -0,0 +1,2 @@
+export { Fireworks } from './Fireworks';
+export type { FireworksProps } from './Fireworks';

package/dist/components/Fireworks/useFireworks.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+
+export interface UseFireworksOptions {
+    colors: string[];
+    particleCount: number;
+    gravity: number;
+    friction: number;
+    fadeSpeed: number;
+    particleSize: number;
+    trailLength: number;
+    spread: number;
+    autoLaunch: boolean;
+    autoInterval: number;
+    glowEffect: boolean;
+    glowBlur: number;
+    backgroundColor: string;
+    shellSpeed: number;
+}
+export declare function useFireworks(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseFireworksOptions): {
+    launch: (x?: number) => void;
+};

package/dist/components/FlowField/FlowField.d.ts

@@ -0,0 +1,31 @@
+import { BaseCanvasProps } from '../../types';
+
+type FlowFieldPreset = "default" | "neon" | "ocean" | "lava" | "forest" | "monochrome";
+export interface FlowFieldProps extends BaseCanvasProps {
+    /** Number of flow particles (default: 800) */
+    particleCount?: number;
+    /** Particle stroke colors — one is picked per particle (default: multi-color) */
+    colors?: string[];
+    /** Flow speed multiplier (default: 1) */
+    speed?: number;
+    /** Noise sampling scale — lower = larger flow structures (default: 0.004) */
+    noiseScale?: number;
+    /** Particle trail fade length — lower = longer trails (default: 0.04) */
+    trailLength?: number;
+    /** Background fade opacity per frame (default: 0.04) */
+    fadeStrength?: number;
+    /** Stroke line width (default: 1) */
+    lineWidth?: number;
+    /** Canvas background color (default: "#050010") */
+    backgroundColor?: string;
+    /** Enable animation (default: true) */
+    animated?: boolean;
+    /** How fast the noise field evolves (default: 1) */
+    timeSpeed?: number;
+    /** Add curl noise component for more swirling flow (default: false) */
+    curl?: boolean;
+    /** Named preset: "default" | "neon" | "ocean" | "lava" | "forest" | "monochrome" */
+    preset?: FlowFieldPreset | string;
+}
+export declare const FlowField: import('react').ForwardRefExoticComponent<FlowFieldProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/FlowField/index.d.ts

@@ -0,0 +1,2 @@
+export { FlowField } from './FlowField';
+export type { FlowFieldProps } from './FlowField';

package/dist/components/FlowField/useFlowField.d.ts

@@ -0,0 +1,16 @@
+import { RefObject } from 'react';
+
+export interface UseFlowFieldOptions {
+    particleCount: number;
+    colors: string[];
+    speed: number;
+    noiseScale: number;
+    trailLength: number;
+    fadeStrength: number;
+    lineWidth: number;
+    backgroundColor: string;
+    animated: boolean;
+    timeSpeed: number;
+    curl: boolean;
+}
+export declare function useFlowField(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseFlowFieldOptions): void;

package/dist/components/FluidSimulation/FluidSimulation.d.ts

@@ -0,0 +1,33 @@
+import { BaseCanvasProps } from '../../types';
+
+type FluidPreset = "default" | "ink" | "neon" | "lava" | "ocean" | "smoke";
+export interface FluidSimulationProps extends BaseCanvasProps {
+    /** Grid resolution (32–128) — lower is faster (default: 80) */
+    resolution?: number;
+    /** Fluid viscosity — resistance to flow (default: 0.0001) */
+    viscosity?: number;
+    /** Ink diffusion rate (default: 0.0001) */
+    diffusion?: number;
+    /** Density fade per frame 0–1 (default: 0.995) */
+    dissipation?: number;
+    /** Ink colors painted by mouse and auto-ink (default: multi-color) */
+    inkColors?: string[];
+    /** Glow on ink (default: true) */
+    glowEffect?: boolean;
+    /** Shadow blur for glow (default: 0 — handled by blending) */
+    glowBlur?: number;
+    /** Canvas background color (default: "#050010") */
+    backgroundColor?: string;
+    /** Auto-inject ink bursts without mouse (default: true) */
+    autoInk?: boolean;
+    /** Interval between auto-ink bursts in ms (default: 1500) */
+    autoInkInterval?: number;
+    /** Mouse velocity → velocity force multiplier (default: 5) */
+    mouseForce?: number;
+    /** Ink splat radius in grid cells (default: 4) */
+    inkRadius?: number;
+    /** Named preset */
+    preset?: FluidPreset | string;
+}
+export declare const FluidSimulation: import('react').ForwardRefExoticComponent<FluidSimulationProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/FluidSimulation/index.d.ts

@@ -0,0 +1,2 @@
+export { FluidSimulation } from './FluidSimulation';
+export type { FluidSimulationProps } from './FluidSimulation';

package/dist/components/FluidSimulation/useFluidSimulation.d.ts

@@ -0,0 +1,17 @@
+import { RefObject } from 'react';
+
+export interface UseFluidSimulationOptions {
+    resolution: number;
+    viscosity: number;
+    diffusion: number;
+    dissipation: number;
+    inkColors: string[];
+    glowEffect: boolean;
+    glowBlur: number;
+    backgroundColor: string;
+    autoInk: boolean;
+    autoInkInterval: number;
+    mouseForce: number;
+    inkRadius: number;
+}
+export declare function useFluidSimulation(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseFluidSimulationOptions): void;

package/dist/components/GameOfLife/GameOfLife.d.ts

@@ -0,0 +1,30 @@
+import { BaseCanvasProps } from '../../types';
+import { GameOfLifeHandle } from './useGameOfLife';
+
+export type { GameOfLifeHandle };
+type GameOfLifePreset = "default" | "neon" | "matrix" | "minimal" | "fire";
+export interface GameOfLifeProps extends BaseCanvasProps {
+    /** Cell size in px. (default: 8) */
+    cellSize?: number;
+    /** Simulation updates per second. (default: 10) */
+    speed?: number;
+    /** Initial alive cell density 0–1. (default: 0.3) */
+    initialDensity?: number;
+    /** Color of newly born cells. (default: "#7C3AED") */
+    aliveColor?: string;
+    /** Color of old cells. (default: "#0891B2") */
+    oldColor?: string;
+    /** Color of dead cells / background. (default: "#050010") */
+    deadColor?: string;
+    /** Color cells by generation age. (default: true) */
+    showAge?: boolean;
+    /** Wrap cells at canvas edges. (default: true) */
+    wrapEdges?: boolean;
+    /** Click to toggle cells. (default: true) */
+    interactive?: boolean;
+    /** Canvas background color. (default: "#050010") */
+    backgroundColor?: string;
+    /** Named preset. */
+    preset?: GameOfLifePreset | string;
+}
+export declare const GameOfLife: import('react').ForwardRefExoticComponent<GameOfLifeProps & import('react').RefAttributes<GameOfLifeHandle>>;

package/dist/components/GameOfLife/index.d.ts

@@ -0,0 +1,2 @@
+export { GameOfLife } from './GameOfLife';
+export type { GameOfLifeProps, GameOfLifeHandle } from './GameOfLife';

package/dist/components/GameOfLife/useGameOfLife.d.ts

@@ -0,0 +1,21 @@
+import { RefObject } from 'react';
+
+export interface GameOfLifeHandle {
+    randomize: () => void;
+    clear: () => void;
+    pause: () => void;
+    resume: () => void;
+}
+export interface UseGameOfLifeOptions {
+    cellSize: number;
+    speed: number;
+    initialDensity: number;
+    aliveColor: string;
+    oldColor: string;
+    deadColor: string;
+    showAge: boolean;
+    wrapEdges: boolean;
+    interactive: boolean;
+    backgroundColor: string;
+}
+export declare function useGameOfLife(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseGameOfLifeOptions, handleRef: RefObject<GameOfLifeHandle | null>): void;

package/dist/components/GlitchOverlay/GlitchOverlay.d.ts

@@ -0,0 +1,35 @@
+import { BaseCanvasProps } from '../../types';
+
+type GlitchPreset = "default" | "crt" | "cyberpunk" | "subtle" | "corrupt";
+export interface GlitchOverlayProps extends BaseCanvasProps {
+    /** Glitch probability 0–1 (default: 0.6) */
+    intensity?: number;
+    /** Animation speed multiplier (default: 1) */
+    speed?: number;
+    /** RGB color shift amount in px (default: 8) */
+    rgbShift?: number;
+    /** Show CRT scanlines (default: true) */
+    scanlines?: boolean;
+    /** Scanline opacity (default: 0.08) */
+    scanlineOpacity?: number;
+    /** Px between scanlines (default: 2) */
+    scanlineSpacing?: number;
+    /** Enable block-slice glitch (default: true) */
+    blockGlitch?: boolean;
+    /** Number of glitch blocks (default: 4) */
+    blockCount?: number;
+    /** Film noise opacity (default: 0.02) */
+    noiseOpacity?: number;
+    /** Screen flicker rate 0–1 (default: 0.02) */
+    flickerRate?: number;
+    /** Glitch bar color (default: "#7C3AED") */
+    color?: string;
+    /** Enable animation (default: true) */
+    animated?: boolean;
+    /** Canvas background (default: "transparent") */
+    backgroundColor?: string;
+    /** Named preset */
+    preset?: GlitchPreset | string;
+}
+export declare const GlitchOverlay: import('react').ForwardRefExoticComponent<GlitchOverlayProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/GlitchOverlay/index.d.ts

@@ -0,0 +1,2 @@
+export { GlitchOverlay } from './GlitchOverlay';
+export type { GlitchOverlayProps } from './GlitchOverlay';

package/dist/components/GlitchOverlay/useGlitchOverlay.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+
+export interface UseGlitchOverlayOptions {
+    intensity: number;
+    speed: number;
+    rgbShift: number;
+    scanlines: boolean;
+    scanlineOpacity: number;
+    scanlineSpacing: number;
+    blockGlitch: boolean;
+    blockCount: number;
+    noiseOpacity: number;
+    flickerRate: number;
+    color: string;
+    animated: boolean;
+    backgroundColor: string;
+}
+export declare function useGlitchOverlay(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseGlitchOverlayOptions): void;

package/dist/components/Lightning/Lightning.d.ts

@@ -0,0 +1,37 @@
+import { BaseCanvasProps } from '../../types';
+
+type LightningPreset = "default" | "neon" | "storm" | "plasma" | "subtle";
+export interface LightningProps extends BaseCanvasProps {
+    /** Recursion depth for bolt segments. (default: 8) */
+    segments?: number;
+    /** Midpoint displacement roughness 0–1. (default: 0.5) */
+    roughness?: number;
+    /** Probability of spawning a branch at each segment. (default: 0.3) */
+    branchChance?: number;
+    /** Energy multiplier for sub-branches. (default: 0.6) */
+    branchDecay?: number;
+    /** Number of rapid flicker strikes per event. (default: 3) */
+    flickerCount?: number;
+    /** Glow shadow blur radius. (default: 20) */
+    glowBlur?: number;
+    /** Bolt glow color. (default: "#7C3AED") */
+    color?: string;
+    /** Inner core color. (default: "#ffffff") */
+    coreColor?: string;
+    /** Canvas background color. (default: "#050010") */
+    backgroundColor?: string;
+    /** Ms between auto strikes. (default: 2000) */
+    autoInterval?: number;
+    /** Click to trigger strike at cursor. (default: true) */
+    interactive?: boolean;
+    /** Strike origin X as fraction of width. (default: 0.5) */
+    startX?: number;
+    /** Strike origin Y as fraction of height. (default: 0) */
+    startY?: number;
+    /** Strike end Y as fraction of height. (default: 1) */
+    endY?: number;
+    /** Named preset. */
+    preset?: LightningPreset | string;
+}
+export declare const Lightning: import('react').ForwardRefExoticComponent<LightningProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/Lightning/index.d.ts

@@ -0,0 +1,2 @@
+export { Lightning } from './Lightning';
+export type { LightningProps } from './Lightning';

package/dist/components/Lightning/useLightning.d.ts

@@ -0,0 +1,19 @@
+import { RefObject } from 'react';
+
+export interface UseLightningOptions {
+    segments: number;
+    roughness: number;
+    branchChance: number;
+    branchDecay: number;
+    flickerCount: number;
+    glowBlur: number;
+    color: string;
+    coreColor: string;
+    backgroundColor: string;
+    autoInterval: number;
+    interactive: boolean;
+    startX: number;
+    startY: number;
+    endY: number;
+}
+export declare function useLightning(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseLightningOptions): void;

package/dist/components/LiveChart/LiveChart.d.ts

@@ -0,0 +1,46 @@
+import { BaseCanvasProps } from '../../types';
+import { LiveChartSeries } from './useLiveChart';
+
+export type { LiveChartSeries } from './useLiveChart';
+type LiveChartPreset = "default" | "neon" | "minimal" | "ocean" | "fire";
+export interface LiveChartProps extends BaseCanvasProps {
+    /** Data series to render */
+    series?: LiveChartSeries[];
+    /** Max data points kept per series (default: 100) */
+    maxPoints?: number;
+    /** Enable animation loop (default: true) */
+    animated?: boolean;
+    /** Line stroke width (default: 2) */
+    lineWidth?: number;
+    /** Show horizontal grid lines (default: true) */
+    showGrid?: boolean;
+    /** Grid line color (default: "#ffffff") */
+    gridColor?: string;
+    /** Grid opacity (default: 0.08) */
+    gridOpacity?: number;
+    /** Show data point dots (default: false) */
+    showDots?: boolean;
+    /** Dot radius when shown (default: 3) */
+    dotRadius?: number;
+    /** Fill area opacity multiplier (default: 1) */
+    fillOpacity?: number;
+    /** Canvas background color (default: "#050010") */
+    backgroundColor?: string;
+    /** Inner padding px (default: 20) */
+    padding?: number;
+    /** Fixed y minimum */
+    yMin?: number;
+    /** Fixed y maximum */
+    yMax?: number;
+    /** Smooth curves with quadratic bezier (default: true) */
+    smooth?: boolean;
+    /** Line glow effect (default: true) */
+    glowEffect?: boolean;
+    /** Shadow blur for glow (default: 8) */
+    glowBlur?: number;
+    /** Scroll animation speed (default: 1) */
+    scrollSpeed?: number;
+    /** Named preset */
+    preset?: LiveChartPreset | string;
+}
+export declare const LiveChart: import('react').ForwardRefExoticComponent<LiveChartProps & import('react').RefAttributes<HTMLCanvasElement>>;

package/dist/components/LiveChart/index.d.ts

@@ -0,0 +1,2 @@
+export { LiveChart } from './LiveChart';
+export type { LiveChartProps, LiveChartSeries } from './LiveChart';

package/dist/components/LiveChart/useLiveChart.d.ts

@@ -0,0 +1,31 @@
+import { RefObject } from 'react';
+
+export interface LiveChartSeries {
+    data: number[];
+    color: string;
+    label?: string;
+    filled?: boolean;
+}
+export interface UseLiveChartOptions {
+    series: LiveChartSeries[];
+    maxPoints: number;
+    animated: boolean;
+    lineWidth: number;
+    showGrid: boolean;
+    gridColor: string;
+    gridOpacity: number;
+    showDots: boolean;
+    dotRadius: number;
+    fillOpacity: number;
+    backgroundColor: string;
+    padding: number;
+    yMin?: number;
+    yMax?: number;
+    smooth: boolean;
+    glowEffect: boolean;
+    glowBlur: number;
+    scrollSpeed: number;
+}
+export declare function useLiveChart(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseLiveChartOptions): {
+    push: (values: number | number[]) => void;
+};

package/dist/components/MagneticBlob/MagneticBlob.d.ts

@@ -0,0 +1,35 @@
+import { BaseCanvasProps } from '../../types';
+
+type MagneticBlobPreset = "default" | "neon" | "plasma" | "ocean" | "lava" | "minimal";
+export interface MagneticBlobProps extends BaseCanvasProps {
+    /** Number of blobs (default: 5) */
+    count?: number;
+    /** Blob colors (default: purple/cyan/green) */
+    colors?: string[];
+    /** Base blob radius in px (default: 80) */
+    radius?: number;
+    /** Wander animation speed (default: 1) */
+    speed?: number;
+    /** Mouse attraction force (default: 0.08) */
+    magnetStrength?: number;
+    /** Mouse influence radius in px (default: 150) */
+    magnetRadius?: number;
+    /** Metaball merge threshold — higher = earlier merge (default: 1.8) */
+    threshold?: number;
+    /** Glow effect (default: true) */
+    glowEffect?: boolean;
+    /** Shadow blur for glow (default: 20) */
+    glowBlur?: number;
+    /** Canvas background (default: "#050010") */
+    backgroundColor?: string;
+    /** Enable animation (default: true) */
+    animated?: boolean;
+    /** Blobs follow cursor (default: true) */
+    followMouse?: boolean;
+    /** Organic wander amplitude 0–1 (default: 0.4) */
+    wanderStrength?: number;
+    /** Named preset */
+    preset?: MagneticBlobPreset | string;
+}
+export declare const MagneticBlob: import('react').ForwardRefExoticComponent<MagneticBlobProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/dist/components/MagneticBlob/index.d.ts

@@ -0,0 +1,2 @@
+export { MagneticBlob } from './MagneticBlob';
+export type { MagneticBlobProps } from './MagneticBlob';