own-the-canvas 2.0.0 → 2.0.2

package/lib/components/Jellyfish/Jellyfish.d.ts

@@ -0,0 +1,37 @@
+import { BaseCanvasProps } from '../../types';
+
+type JellyfishPreset = "default" | "sea-nettle" | "crystal" | "lions-mane" | "ghost" | "monochrome";
+interface JellyfishPresetValues {
+    bellColor?: string;
+    glowColor?: string;
+    backgroundColor?: string;
+    tentacleLength?: number;
+    count?: number;
+}
+export declare const PRESETS: Record<JellyfishPreset, JellyfishPresetValues>;
+export interface JellyfishProps extends BaseCanvasProps {
+    /** Number of jellyfish (default: 4) */
+    count?: number;
+    /** Bell and oral-arm tint (default: "#c9a7e8") */
+    bellColor?: string;
+    /** Rim light, tentacles and flash color (default: "#8fd8ff") */
+    glowColor?: string;
+    /** Water color; "transparent" drops the scene (default: "#04122a") */
+    backgroundColor?: string;
+    /** Tentacle length multiplier (default: 1) */
+    tentacleLength?: number;
+    /** Bell pulse speed multiplier (default: 1) */
+    pulseRate?: number;
+    /** Jellies turn away from the cursor, which stirs the water; taps make them flash (default: true) */
+    interactive?: boolean;
+    /** Fixed full-viewport, click-through layer over the page (default: false) */
+    overlay?: boolean;
+    /** Nudge off elements marked `data-otc-solid` (default: false) */
+    collide?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "sea-nettle" | "crystal" | "lions-mane" | "ghost" | "monochrome" */
+    preset?: JellyfishPreset | string;
+}
+export declare const Jellyfish: import('react').ForwardRefExoticComponent<JellyfishProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Jellyfish/index.d.ts

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

package/lib/components/Jellyfish/useJellyfish.d.ts

@@ -0,0 +1,20 @@
+export interface UseJellyfishOptions {
+    count: number;
+    bellColor: string;
+    glowColor: string;
+    backgroundColor: string;
+    tentacleLength: number;
+    pulseRate: number;
+    interactive: boolean;
+    overlay: boolean;
+    collide: boolean;
+}
+/** Bell contraction 0..1 over one pulse cycle: a quick squeeze, then a slow relax. */
+export declare function pulse(phase: number): number;
+/**
+ * Moon jellies in open water. Each bell pulses by jet propulsion (a quick squeeze that drives it
+ * forward, a slow relax), steering gently back upward, with verlet tentacles and frilled oral arms
+ * that trail and swirl in the wake. The cursor stirs the water and they turn away from it; a tap
+ * makes nearby bells flash. With `collide` they nudge off `data-otc-solid` elements.
+ */
+export declare function useJellyfish(options: UseJellyfishOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/KoiPond/KoiPond.d.ts

@@ -6,7 +6,7 @@ export interface KoiPondProps extends BaseCanvasProps {
     fishCount?: number;
     /** Primary fish body color (default: "#ff6030") */
     fishColor?: string;
-    /** Scale accent color (default: "#ffffff") */
+    /** Patch color of the markings; every third koi swaps body and patch (default: "#ffffff") */
     scaleColor?: string;
     /** Water background color (default: "#0a1520") */
     waterColor?: string;
@@ -16,7 +16,7 @@ export interface KoiPondProps extends BaseCanvasProps {
     lilyColor?: string;
     /** Fish movement speed multiplier (default: 1) */
     speed?: number;
-    /** Cursor causes ripples (default: true) */
+    /** Cursor leaves ripples; tap to drop food the koi swim up to eat (default: true) */
     interactive?: boolean;
     /** Show lily pads (default: true) */
     showLilies?: boolean;

package/lib/components/KoiPond/useKoiPond.d.ts

@@ -1,5 +1,3 @@
-import { RefObject } from 'react';
-
 export interface UseKoiPondOptions {
     fishCount: number;
     fishColor: string;
@@ -12,4 +10,13 @@ export interface UseKoiPondOptions {
     showLilies: boolean;
     caustics: boolean;
 }
-export declare function useKoiPond(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseKoiPondOptions): void;
+/** Koi body half-width at u (0 = nose, 1 = tail root), as a fraction of body length. */
+export declare function koiWidth(u: number): number;
+/**
+ * A koi pond from above. Koi swim on a flexible 12-point spine with a full silhouette, painted
+ * patches, flapping pectoral fins and a trailing butterfly tail, each casting a soft shadow on the
+ * pond floor below. Sunlight caustics wash over the bottom, lily pads (some flowering) float
+ * above the fish and drift on the ripples. The cursor leaves ripples; tap to drop a food pellet
+ * and the koi race up to eat it.
+ */
+export declare function useKoiPond(options: UseKoiPondOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/Komorebi/Komorebi.d.ts

@@ -0,0 +1,34 @@
+import { BaseCanvasProps } from '../../types';
+
+type KomorebiPreset = "default" | "morning" | "forest" | "golden-hour" | "moonlight" | "monochrome";
+interface KomorebiPresetValues {
+    lightColor?: string;
+    shadowColor?: string;
+    backgroundColor?: string;
+    sunHeight?: number;
+}
+export declare const PRESETS: Record<KomorebiPreset, KomorebiPresetValues>;
+export interface KomorebiProps extends BaseCanvasProps {
+    /** Sunlight color (default: "#ffd9a0") */
+    lightColor?: string;
+    /** Leaf shade tint (default: "#3a4a3a") */
+    shadowColor?: string;
+    /** The wall the light falls on; "transparent" drops it (default: "#c9b49a") */
+    backgroundColor?: string;
+    /** Light spot density multiplier (default: 1) */
+    density?: number;
+    /** Canopy sway strength (default: 1) */
+    wind?: number;
+    /** Sun height 0..1: lower suns stretch the spots into ovals (default: 0.7) */
+    sunHeight?: number;
+    /** The cursor is a breeze that stirs the leaves; a tap sends a gust rippling out (default: true) */
+    interactive?: boolean;
+    /** Fixed full-viewport, click-through layer that dapples the page (default: false) */
+    overlay?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "morning" | "forest" | "golden-hour" | "moonlight" | "monochrome" */
+    preset?: KomorebiPreset | string;
+}
+export declare const Komorebi: import('react').ForwardRefExoticComponent<KomorebiProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Komorebi/index.d.ts

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

package/lib/components/Komorebi/useKomorebi.d.ts

@@ -0,0 +1,22 @@
+export interface UseKomorebiOptions {
+    lightColor: string;
+    shadowColor: string;
+    backgroundColor: string;
+    density: number;
+    wind: number;
+    sunHeight: number;
+    interactive: boolean;
+    overlay: boolean;
+}
+/**
+ * Shape of each light spot: every gap in the canopy is a pinhole camera projecting the sun, so
+ * spots are discs stretched along the light direction as the sun gets lower.
+ */
+export declare function spotStretch(sunHeight: number): number;
+/**
+ * Komorebi: sunlight filtering through leaves onto a wall. Light spots (pinhole images of the
+ * sun, stretched as it gets lower) open, close and drift as the unseen canopy sways, under the
+ * soft moving shadows of nearer leaves. Your cursor is a breeze that stirs the leaves around it;
+ * a tap sends a gust rippling outward. As an overlay it dapples the whole page.
+ */
+export declare function useKomorebi(options: UseKomorebiOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/Lightning/Lightning.d.ts

@@ -27,7 +27,7 @@ export interface LightningProps extends BaseCanvasProps {
     branchChance?: number;
     /** Energy multiplier for sub-branches. (default: 0.6) */
     branchDecay?: number;
-    /** Number of rapid flicker strikes per event. (default: 3) */
+    /** Return strokes per strike: the same channel relights this many times. (default: 3) */
     flickerCount?: number;
     /** Glow shadow blur radius. (default: 20) */
     glowBlur?: number;

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

@@ -16,4 +16,11 @@ export interface UseLightningOptions {
     startY: number;
     endY: number;
 }
+/**
+ * A night thunderstorm. A low cloud deck drifts over dark hills; each strike starts as a
+ * faint stepped leader crawling down from the cloud base, then the return stroke slams the
+ * channel white-hot and lights the clouds from inside. The same channel restrikes a few
+ * times (flickerCount) before fading, while its forks die after the first stroke. Between
+ * strikes, sheet lightning glows inside the clouds. Click to strike at the cursor.
+ */
 export declare function useLightning(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseLightningOptions): void;

package/lib/components/Octopus/Octopus.d.ts

@@ -0,0 +1,44 @@
+import { BaseCanvasProps } from '../../types';
+
+type OctopusPreset = "default" | "blue-ringed" | "ghost" | "abyss" | "sand" | "monochrome";
+interface OctopusPresetValues {
+    skinColor?: string;
+    spotColor?: string;
+    suckerColor?: string;
+    eyeColor?: string;
+    inkColor?: string;
+    backgroundColor?: string;
+}
+export declare const PRESETS: Record<OctopusPreset, OctopusPresetValues>;
+export interface OctopusProps extends BaseCanvasProps {
+    /** Skin color; it deepens when excited and blanches when startled (default: "#c4553a") */
+    skinColor?: string;
+    /** Chromatophore ring color; rings flare when excited (default: "#7a2a1c") */
+    spotColor?: string;
+    /** Sucker color (default: "#f2c4a8") */
+    suckerColor?: string;
+    /** Eye color (default: "#e8c25a") */
+    eyeColor?: string;
+    /** Ink cloud color (default: "#140b12") */
+    inkColor?: string;
+    /** Water color; "transparent" drops the scene (default: "#04131c") */
+    backgroundColor?: string;
+    /** Octopus scale (default: 1) */
+    size?: number;
+    /** Arm length multiplier (default: 1) */
+    tentacleLength?: number;
+    /** Swim toward the cursor and coil the nearest arms around it (default: true) */
+    followCursor?: boolean;
+    /** Tap to make it squirt ink and jet away (default: true) */
+    interactive?: boolean;
+    /** Fixed full-viewport, click-through layer over the page (default: false) */
+    overlay?: boolean;
+    /** Arms grab the edges of elements marked `data-otc-solid` (default: false) */
+    collide?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "blue-ringed" | "ghost" | "abyss" | "sand" | "monochrome" */
+    preset?: OctopusPreset | string;
+}
+export declare const Octopus: import('react').ForwardRefExoticComponent<OctopusProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Octopus/index.d.ts

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

package/lib/components/Octopus/useOctopus.d.ts

@@ -0,0 +1,35 @@
+import { Solid } from '../../runtime/physics';
+
+export interface UseOctopusOptions {
+    skinColor: string;
+    spotColor: string;
+    suckerColor: string;
+    eyeColor: string;
+    inkColor: string;
+    backgroundColor: string;
+    size: number;
+    tentacleLength: number;
+    followCursor: boolean;
+    interactive: boolean;
+    overlay: boolean;
+    collide: boolean;
+}
+interface Pt {
+    x: number;
+    y: number;
+}
+/** FABRIK: bends a chain of `seg`-long links rooted at `root` so its tip reaches toward `target`. */
+export declare function fabrik(P: Pt[], root: Pt, target: Pt, seg: number, iterations?: number): void;
+/** Closest point on a solid's outline to `p`. */
+export declare function edgePoint(s: Solid, p: Pt): Pt;
+/**
+ * An octopus drifting in deep water. Eight tapered arms, webbed at the base, ripple and
+ * coil and uncoil on their own, now and then one wandering off to explore; the nearest
+ * ones reach out and wrap the cursor, and with `collide` arm tips latch onto the edges of
+ * `data-otc-solid` elements and pull the body along. It breathes through its siphon and
+ * swims in jet pulses, mantle first. Its pupils stay level whichever way it turns, dark
+ * "passing cloud" waves ripple over its skin when it is excited, and a tap makes it blanch,
+ * shoot a stream of ink from the siphon and jet away.
+ */
+export declare function useOctopus(options: UseOctopusOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;
+export {};

package/lib/components/Owl/Owl.d.ts

@@ -0,0 +1,48 @@
+import { BaseCanvasProps } from '../../types';
+
+type OwlPreset = "default" | "tawny" | "snowy" | "barn" | "spirit" | "monochrome";
+interface OwlPresetValues {
+    featherColor?: string;
+    bellyColor?: string;
+    faceColor?: string;
+    eyeColor?: string;
+    beakColor?: string;
+    branchColor?: string;
+    backgroundColor?: string;
+    earTufts?: boolean;
+}
+export declare const PRESETS: Record<OwlPreset, OwlPresetValues>;
+export interface OwlProps extends BaseCanvasProps {
+    /** Back, wing and head feathers (default: "#6b4a33") */
+    featherColor?: string;
+    /** Barred chest feathers (default: "#d9bf9a") */
+    bellyColor?: string;
+    /** Facial disc (default: "#c48a52") */
+    faceColor?: string;
+    /** Iris color (default: "#f2a516") */
+    eyeColor?: string;
+    /** Beak color; talons are a tint of it (default: "#3a3330") */
+    beakColor?: string;
+    /** Branch color (default: "#3b2a1e") */
+    branchColor?: string;
+    /** Night sky color; "transparent" drops the scene (default: "#070a12") */
+    backgroundColor?: string;
+    /** Feather "horns" on the head (default: true) */
+    earTufts?: boolean;
+    /** Owl scale (default: 1) */
+    size?: number;
+    /** The head turns to follow the cursor; off = it looks around by itself (default: true) */
+    followCursor?: boolean;
+    /** Average ms between blinks; 0 = never (default: 5000) */
+    blinkInterval?: number;
+    /** Fixed full-viewport, click-through layer over the page (default: false) */
+    overlay?: boolean;
+    /** Perch on top of an element marked `data-otc-solid` instead of a branch (default: false) */
+    collide?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "tawny" | "snowy" | "barn" | "spirit" | "monochrome" */
+    preset?: OwlPreset | string;
+}
+export declare const Owl: import('react').ForwardRefExoticComponent<OwlProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Owl/index.d.ts

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

package/lib/components/Owl/useOwl.d.ts

@@ -0,0 +1,29 @@
+import { Solid } from '../../runtime/physics';
+
+export interface UseOwlOptions {
+    featherColor: string;
+    bellyColor: string;
+    faceColor: string;
+    eyeColor: string;
+    beakColor: string;
+    branchColor: string;
+    backgroundColor: string;
+    earTufts: boolean;
+    size: number;
+    followCursor: boolean;
+    blinkInterval: number;
+    overlay: boolean;
+    collide: boolean;
+}
+/** Owl blink closure 0..1, `s` seconds in: slower and heavier-lidded than a human blink. */
+export declare function owlBlink(s: number): number;
+/** The solid an owl of height `need` can perch on: top edge inside the canvas, nearest the middle. */
+export declare function pickPerch(solids: readonly Solid[], w: number, h: number, need: number): Solid | null;
+/**
+ * An owl on its perch. Owls can't move their eyes, so the whole head snaps to follow the
+ * cursor (a held fixation, then a quick turn); it cocks its head when the cursor goes still,
+ * bobs to judge distance when something moves fast nearby, blinks slowly, grows drowsy when
+ * ignored and fluffs up when tapped. Pupils narrow as the cursor comes close. With `collide`
+ * it perches on top of a `data-otc-solid` element instead of a branch.
+ */
+export declare function useOwl(options: UseOwlOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/Rain/Rain.d.ts

@@ -38,6 +38,8 @@ export interface RainProps extends BaseCanvasProps {
     showSplashes?: boolean;
     /** Canvas background color. (default: "#0b1424") */
     backgroundColor?: string;
+    /** Draw the night-street scene (sky, city, lamps, wet ground). false = rain only, over a plain backgroundColor fill ("transparent" to overlay). (default: true) */
+    showBackground?: boolean;
     /** Number of background stars (default: 0) */
     starCount?: number;
     /** Star color (default: "#ffffff") */

package/lib/components/Rain/useRain.d.ts

@@ -12,6 +12,7 @@ export interface UseRainOptions {
     splashColor: string;
     showSplashes: boolean;
     backgroundColor: string;
+    showBackground: boolean;
     starCount: number;
     starColor: string;
     glowingStars: boolean;

package/lib/components/ReactionDiffusion/ReactionDiffusion.d.ts

@@ -20,7 +20,7 @@ export interface ReactionDiffusionProps extends BaseCanvasProps {
     colorB?: string;
     /** Canvas background color (default: "#04121f") */
     backgroundColor?: string;
-    /** Mouse disturbs the field (default: true) */
+    /** Hovering seeds a trail of chemical (thicker while pressed), taps drop a blob (default: true) */
     interactive?: boolean;
     /** Named preset */
     preset?: ReactionDiffusionPreset | string;

package/lib/components/ReactionDiffusion/useReactionDiffusion.d.ts

@@ -1,5 +1,3 @@
-import { RefObject } from 'react';
-
 export interface UseReactionDiffusionOptions {
     feedRate: number;
     killRate: number;
@@ -12,4 +10,12 @@ export interface UseReactionDiffusionOptions {
     backgroundColor: string;
     interactive: boolean;
 }
-export declare function useReactionDiffusion(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseReactionDiffusionOptions): void;
+/** Seed a soft disc of V (the autocatalyst) at grid cell (cx, cy), wrapping at the edges. */
+export declare function seedDisc(u: Float32Array, v: Float32Array, gw: number, gh: number, cx: number, cy: number, r: number): void;
+/**
+ * Gray-Scott reaction-diffusion, lit like a wet relief. Feed and kill rates drift slowly across
+ * the canvas around the chosen values, so spots, stripes and mazes meet and keep morphing into
+ * each other instead of freezing. Hovering seeds a trail of chemical, taps drop a blob, and an
+ * exhausted field reseeds itself.
+ */
+export declare function useReactionDiffusion(options: UseReactionDiffusionOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/Snail/Snail.d.ts

@@ -0,0 +1,38 @@
+import { BaseCanvasProps } from '../../types';
+
+type SnailPreset = "default" | "amber" | "forest" | "candy" | "nocturne" | "monochrome";
+interface SnailPresetValues {
+    shellColor?: string;
+    bodyColor?: string;
+    trailColor?: string;
+    backgroundColor?: string;
+}
+export declare const PRESETS: Record<SnailPreset, SnailPresetValues>;
+export interface SnailProps extends BaseCanvasProps {
+    /** Shell color (default: "#b5773f") */
+    shellColor?: string;
+    /** Body (foot, head and stalks) color (default: "#a8988a") */
+    bodyColor?: string;
+    /** Slime trail glint (default: "#cfe6ff") */
+    trailColor?: string;
+    /** Garden color; "transparent" drops the scene (default: "#0f1a12") */
+    backgroundColor?: string;
+    /** Snail scale (default: 1) */
+    size?: number;
+    /** Crawl speed multiplier (default: 1) */
+    speed?: number;
+    /** Leave a slime trail that slowly dries (default: true) */
+    trail?: boolean;
+    /** Eye stalks follow the cursor; poke them, move fast or tap and it hides in its shell (default: true) */
+    interactive?: boolean;
+    /** Fixed full-viewport, click-through layer over the page (default: false) */
+    overlay?: boolean;
+    /** Crawl along the top of an element marked `data-otc-solid` (default: false) */
+    collide?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "amber" | "forest" | "candy" | "nocturne" | "monochrome" */
+    preset?: SnailPreset | string;
+}
+export declare const Snail: import('react').ForwardRefExoticComponent<SnailProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Snail/index.d.ts

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

package/lib/components/Snail/useSnail.d.ts

@@ -0,0 +1,21 @@
+export interface UseSnailOptions {
+    shellColor: string;
+    bodyColor: string;
+    trailColor: string;
+    backgroundColor: string;
+    size: number;
+    speed: number;
+    trail: boolean;
+    interactive: boolean;
+    overlay: boolean;
+    collide: boolean;
+}
+/** Direction after a step: turns around at either end of the surface [lo, hi]. */
+export declare function turnAt(x: number, dir: number, lo: number, hi: number): number;
+/**
+ * A garden snail gliding along the ground (or the top of a `data-otc-solid` element with
+ * `collide`) on rippling pedal waves, leaving a glistening slime trail that slowly dries. Its eye
+ * stalks lean toward the cursor out of curiosity; poke an eye, move fast nearby or tap it and it
+ * pulls everything into its shell, then cautiously comes back out.
+ */
+export declare function useSnail(options: UseSnailOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/SpiderWeb/SpiderWeb.d.ts

@@ -31,6 +31,10 @@ export interface SpiderWebProps extends BaseCanvasProps {
     interactive?: boolean;
     /** Show spider (default: true) */
     showSpider?: boolean;
+    /** Show the moon and its halo in the sky (default: true) */
+    showMoon?: boolean;
+    /** Moon color; also tints its halo (default: a pale tint of glowColor) */
+    moonColor?: string;
     /** Named preset */
     preset?: SpiderWebPreset | string;
 }

package/lib/components/SpiderWeb/useSpiderWeb.d.ts

@@ -12,6 +12,9 @@ export interface UseSpiderWebOptions {
     disturbRadius: number;
     interactive: boolean;
     showSpider: boolean;
+    showMoon: boolean;
+    /** "" = derive a pale tint from glowColor */
+    moonColor: string;
 }
 /**
  * An orb weaver's web at night. Irregular frame silk is bridged to the edges, radii run

package/lib/components/Starfield/useStarfield.d.ts

@@ -1,5 +1,3 @@
-import { RefObject } from 'react';
-
 export type StarfieldPerspective = "2D" | "3D";
 export interface UseStarfieldOptions {
     starCount: number;
@@ -19,4 +17,13 @@ export interface UseStarfieldOptions {
     shootingStarLength: number;
     shootingStarLifetime: number;
 }
-export declare function useStarfield(canvasRef: RefObject<HTMLCanvasElement | null>, options: UseStarfieldOptions): void;
+/** Pick a temperature tint 0..4: mostly sun-like, a few hot blue and cool orange stars. */
+export declare function starTint(r: number): number;
+/**
+ * A deep-sky vista. In 2D: a Milky Way band with glowing star clouds, dark dust lanes and faint
+ * nebulae (painted once into a cached layer), under three parallax layers of temperature-tinted
+ * stars that drift slowly and shift as the cursor looks around; the brightest carry diffraction
+ * spikes, small ones scintillate, and tapered meteors streak across now and then. In 3D: a warp
+ * tunnel with motion-streaked stars that the cursor steers.
+ */
+export declare function useStarfield(options: UseStarfieldOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/Sunflowers/Sunflowers.d.ts

@@ -0,0 +1,36 @@
+import { BaseCanvasProps } from '../../types';
+
+type SunflowersPreset = "default" | "dawn" | "dusk" | "velvet" | "moonlight" | "monochrome";
+interface SunflowersPresetValues {
+    petalColor?: string;
+    centerColor?: string;
+    stemColor?: string;
+    backgroundColor?: string;
+}
+export declare const PRESETS: Record<SunflowersPreset, SunflowersPresetValues>;
+export interface SunflowersProps extends BaseCanvasProps {
+    /** Number of sunflowers (default: 5) */
+    count?: number;
+    /** Petal color (default: "#f6b51e") */
+    petalColor?: string;
+    /** Seed disc color (default: "#4a2a12") */
+    centerColor?: string;
+    /** Stems and leaves (default: "#4f7a2a") */
+    stemColor?: string;
+    /** Sky color at the sun's height; "transparent" drops the scene (default: "#f0a868") */
+    backgroundColor?: string;
+    /** Wind strength (default: 1) */
+    wind?: number;
+    /** Your cursor is the sun and the heads turn to face it; off = the sun crosses the sky by itself (default: true) */
+    followCursor?: boolean;
+    /** The cursor's wake pushes stems; tap a head to shake petals loose (default: true) */
+    interactive?: boolean;
+    /** Fixed full-viewport, click-through layer over the page (default: false) */
+    overlay?: boolean;
+    /** Overlay z-index (default: 10) */
+    zIndex?: number;
+    /** Named preset: "default" | "dawn" | "dusk" | "velvet" | "moonlight" | "monochrome" */
+    preset?: SunflowersPreset | string;
+}
+export declare const Sunflowers: import('react').ForwardRefExoticComponent<SunflowersProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/Sunflowers/index.d.ts

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

package/lib/components/Sunflowers/useSunflowers.d.ts

@@ -0,0 +1,23 @@
+export interface UseSunflowersOptions {
+    count: number;
+    petalColor: string;
+    centerColor: string;
+    stemColor: string;
+    backgroundColor: string;
+    wind: number;
+    followCursor: boolean;
+    interactive: boolean;
+    overlay: boolean;
+}
+/** Head orientation that faces a sun at (sx, sy) from a head at (hx, hy): yaw right +, pitch down +. */
+export declare function faceToward(hx: number, hy: number, sx: number, sy: number, w: number, h: number): {
+    yaw: number;
+    pitch: number;
+};
+/**
+ * A row of sunflowers at golden hour. Each heavy head turns to face the sun (your cursor, or
+ * the sun arcing across the sky on its own) with a lagging, springy follow, foreshortened in
+ * 3D, seeds packed in a golden-angle Fibonacci spiral. Stems sway in gusts and in the cursor's
+ * wake; tap a head to shake loose a few petals.
+ */
+export declare function useSunflowers(options: UseSunflowersOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;

package/lib/components/TidePool/TidePool.d.ts

@@ -0,0 +1,32 @@
+import { BaseCanvasProps } from '../../types';
+
+type TidePoolPreset = "default" | "tropical" | "kelp-coast" | "sunset" | "night" | "monochrome";
+interface TidePoolPresetValues {
+    waterColor?: string;
+    rockColor?: string;
+    anemoneColor?: string;
+    starfishColor?: string;
+}
+export declare const PRESETS: Record<TidePoolPreset, TidePoolPresetValues>;
+export interface TidePoolProps extends BaseCanvasProps {
+    /** Water tint (default: "#2a8a8f") */
+    waterColor?: string;
+    /** Rocks and sand on the pool floor (default: "#6e6457") */
+    rockColor?: string;
+    /** Sea anemone color (default: "#5fbf7a") */
+    anemoneColor?: string;
+    /** Starfish color (default: "#e0702e") */
+    starfishColor?: string;
+    /** Number of small fish (default: 7) */
+    fishCount?: number;
+    /** Number of sea anemones (default: 5) */
+    anemoneCount?: number;
+    /** Sunlight caustics strength, 0..2 (default: 1) */
+    causticIntensity?: number;
+    /** Anemones close and fish flee from the cursor; moving it ripples the water, taps splash (default: true) */
+    interactive?: boolean;
+    /** Named preset: "default" | "tropical" | "kelp-coast" | "sunset" | "night" | "monochrome" */
+    preset?: TidePoolPreset | string;
+}
+export declare const TidePool: import('react').ForwardRefExoticComponent<TidePoolProps & import('react').RefAttributes<HTMLCanvasElement>>;
+export {};

package/lib/components/TidePool/index.d.ts

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

package/lib/components/TidePool/useTidePool.d.ts

@@ -0,0 +1,21 @@
+export interface UseTidePoolOptions {
+    waterColor: string;
+    rockColor: string;
+    anemoneColor: string;
+    starfishColor: string;
+    fishCount: number;
+    anemoneCount: number;
+    causticIntensity: number;
+    interactive: boolean;
+}
+/**
+ * Anemone hysteresis: shut when something comes within 1.4 radii, reopen only once it is
+ * past 2.2 radii, so a cursor resting on the edge doesn't make it flutter.
+ */
+export declare function anemoneShut(d: number, r: number, shut: boolean): boolean;
+/**
+ * A rock pool seen from above: sunlight caustics ripple over pebbles, sea anemones sway their
+ * tentacles and snap shut when the cursor comes close, starfish slowly curl their arms and
+ * little fish dart away from your hand. Moving the cursor stirs ripples; tapping splashes.
+ */
+export declare function useTidePool(options: UseTidePoolOptions): import('../../hooks/useCanvasSetup').CanvasSetupResult;