ngwr 6.0.0 → 7.0.0

package/types/ngwr-slider.d.ts

@@ -0,0 +1,86 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Value type accepted by `<wr-slider>`:
+ * - `number` for single-thumb sliders (`range="false"`, the default)
+ * - `[number, number]` (`[low, high]`) for range sliders (`range="true"`)
+ *
+ * The component reads `range` at runtime and writes back the matching shape
+ * through `ControlValueAccessor`.
+ */
+type WrSliderValue = number | readonly [number, number];
+
+/** Trim float drift from step calculations. */
+/**
+ * Numeric slider with optional dual-thumb range mode.
+ *
+ * Implements `ControlValueAccessor` — works with `[(ngModel)]`,
+ * `formControl`, `formControlName`. The value shape depends on `range`:
+ * `number` (default) or `[number, number]` when `range="true"`.
+ *
+ * Keyboard: ← / → adjust by `step`; ↑ / ↓ same; Shift+arrow by `step × 10`;
+ * Home / End jump to min / max; PageUp / PageDown by `step × 10`.
+ *
+ * @example
+ * ```html
+ * <wr-slider [(ngModel)]="volume" min="0" max="100" step="5" />
+ * <wr-slider [(ngModel)]="range" range min="0" max="1000" step="10" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/slider
+ */
+declare class WrSlider implements ControlValueAccessor {
+    /** Lower bound. @default 0 */
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Upper bound. @default 100 */
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Step size for keyboard and drag. @default 1 */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Render two thumbs and emit `[low, high]`. @default false */
+    readonly range: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Disable interaction. @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Render the current value below the track. @default true */
+    readonly showLabel: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly low: _angular_core.WritableSignal<number>;
+    protected readonly high: _angular_core.WritableSignal<number>;
+    private readonly disabledFromCva;
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    protected readonly track: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly lowPercent: _angular_core.Signal<number>;
+    protected readonly highPercent: _angular_core.Signal<number>;
+    protected readonly fillLeft: _angular_core.Signal<number>;
+    protected readonly fillWidth: _angular_core.Signal<number>;
+    protected readonly label: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    writeValue(v: WrSliderValue | null): void;
+    registerOnChange(fn: (v: WrSliderValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onPointerDown(event: PointerEvent, thumb: 'low' | 'high'): void;
+    protected onTrackPointerDown(event: PointerEvent): void;
+    protected onKey(event: KeyboardEvent, thumb: 'low' | 'high'): void;
+    private updateFromEvent;
+    private nearestThumb;
+    private focusThumb;
+    private setThumb;
+    private snap;
+    private clampToBounds;
+    private percentOf;
+    private emitChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSlider, "wr-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showLabel": { "alias": "showLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrSlider };
+export type { WrSliderValue };

package/types/ngwr-sparkline.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Tiny inline trend line. SVG path drawn from `[data]: number[]` — no
+ * axes, no labels, just the shape. Optional area fill + tip dot.
+ *
+ * @example
+ * ```html
+ * <wr-sparkline [data]="[12, 14, 9, 17, 21, 18, 23]" />
+ * <wr-sparkline [data]="prices" [showArea]="true" color="var(--wr-color-success)" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/sparkline
+ */
+declare class WrSparkline {
+    readonly data: _angular_core.InputSignal<readonly number[]>;
+    /** Stroke colour. @default `var(--wr-color-primary)` */
+    readonly color: _angular_core.InputSignal<string>;
+    /** Stroke width in viewBox units. @default 1.5 */
+    readonly strokeWidth: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Fill the area below the line. @default false */
+    readonly showArea: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Show a dot at the last data point. @default true */
+    readonly showTip: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** CSS width. @default '8rem' */
+    readonly width: _angular_core.InputSignal<string>;
+    /** CSS height. @default '2rem' */
+    readonly height: _angular_core.InputSignal<string>;
+    private readonly vbW;
+    private readonly vbH;
+    private readonly padding;
+    /** Mapped `{ x, y }` points for the path. */
+    protected readonly points: _angular_core.Signal<readonly {
+        x: number;
+        y: number;
+    }[]>;
+    protected readonly linePath: _angular_core.Signal<string>;
+    protected readonly areaPath: _angular_core.Signal<string>;
+    protected readonly tipPoint: _angular_core.Signal<{
+        x: number;
+        y: number;
+    } | null>;
+    protected readonly viewBox: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSparkline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSparkline, "wr-sparkline", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; "showArea": { "alias": "showArea"; "required": false; "isSignal": true; }; "showTip": { "alias": "showTip"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrSparkline };

package/types/ngwr-speed-dial.d.ts

@@ -0,0 +1,51 @@
+import * as _angular_core from '@angular/core';
+import { WrIconName } from 'ngwr/icon';
+
+/** Per-button action shown when the dial expands. */
+interface WrSpeedDialAction {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: WrIconName;
+}
+/** Direction the action buttons fan out. */
+type WrSpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+
+/**
+ * Floating action button that expands into a fan of secondary actions on
+ * click / hover. Place inside a positioned container or near `position: fixed`
+ * — the component itself doesn't pin to the viewport.
+ *
+ * @example
+ * ```html
+ * <wr-speed-dial
+ *   [actions]="[
+ *     { id: 'new', label: 'New', icon: 'add' },
+ *     { id: 'edit', label: 'Edit', icon: 'cog' }
+ *   ]"
+ *   (pick)="onPick($event)"
+ * />
+ * ```
+ *
+ * @see https://ngwr.dev/components/speed-dial
+ */
+declare class WrSpeedDial {
+    readonly actions: _angular_core.InputSignal<readonly WrSpeedDialAction[]>;
+    /** Direction the actions fan out. @default 'up' */
+    readonly direction: _angular_core.InputSignal<WrSpeedDialDirection>;
+    /** Two-way bindable open state. @default false */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** Icon for the main trigger button. @default 'add' */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Disable interaction. @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Fires when the user picks one of the actions. */
+    readonly pick: _angular_core.OutputEmitterRef<WrSpeedDialAction>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected onTrigger(): void;
+    protected onPick(action: WrSpeedDialAction): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpeedDial, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpeedDial, "wr-speed-dial", never, { "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "pick": "pick"; }, never, never, true, never>;
+}
+
+export { WrSpeedDial };
+export type { WrSpeedDialAction, WrSpeedDialDirection };

package/types/ngwr-spinner.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ */
+/**
+ * Spinner size variant. Spinner sizing is em-based so the spinner scales
+ * with the current font-size when set to `'inherit'`-ish contexts.
+ */
+type WrSpinnerSize = 'sm' | 'md' | 'lg';
+
+/**
+ * Inline loading indicator.
+ *
+ * Inherits color from the surrounding text (uses `currentColor`).
+ *
+ * @example
+ * ```html
+ * <wr-spinner />
+ * <wr-spinner size="lg" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/spinner
+ */
+declare class WrSpinner {
+    /**
+     * Size variant. Em-based — scales with surrounding font-size.
+     *
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignal<WrSpinnerSize>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpinner, "wr-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrSpinner };
+export type { WrSpinnerSize };

package/types/ngwr-splash-cursor.d.ts

@@ -0,0 +1,94 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Splash cursor — a WebGL fluid simulation that splashes colourful dye
+ * wherever the pointer moves or clicks. Renders as a fixed, full-viewport,
+ * click-through overlay; mount it once on a page (it follows the pointer
+ * everywhere) and it tears down with the component.
+ *
+ * Renders nothing under `prefers-reduced-motion` or when WebGL is
+ * unavailable.
+ *
+ * @example
+ * ```html
+ * <wr-splash-cursor />
+ * <wr-splash-cursor [rainbow]="false" color="#5227ff" />
+ * ```
+ *
+ * @see https://ngwr.dev/animations/splash-cursor
+ */
+declare class WrSplashCursor {
+    /**
+     * `true` overlays the whole viewport (reactbits behaviour); `false`
+     * fills the nearest positioned ancestor instead — handy for demo boxes,
+     * and the dye collides with the box walls. @default true
+     */
+    readonly fullscreen: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Velocity / pressure grid resolution. @default 128 */
+    readonly simResolution: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Dye texture resolution — the visible detail. @default 1440 */
+    readonly dyeResolution: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** How fast the dye fades, higher = shorter trails. @default 3.5 */
+    readonly densityDissipation: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** How fast motion settles. @default 2 */
+    readonly velocityDissipation: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Pressure retained between frames, 0..1. @default 0.1 */
+    readonly pressure: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Jacobi iterations for the pressure solve. @default 20 */
+    readonly pressureIterations: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Vorticity confinement — swirliness. @default 3 */
+    readonly curl: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Splat size. @default 0.2 */
+    readonly splatRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Velocity a pointer move injects. @default 6000 */
+    readonly splatForce: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Pseudo-3D shading on the dye. @default true */
+    readonly shading: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** How fast the splat colour cycles. @default 10 */
+    readonly colorUpdateSpeed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Cycle splat colours through the rainbow. @default true */
+    readonly rainbow: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Fixed splat colour when `rainbow` is off. @default '#ff0000' */
+    readonly color: _angular_core.InputSignal<string>;
+    private readonly canvasRef;
+    private readonly zone;
+    private readonly platform;
+    private readonly isBrowser;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSplashCursor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSplashCursor, "wr-splash-cursor", never, { "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; "simResolution": { "alias": "simResolution"; "required": false; "isSignal": true; }; "dyeResolution": { "alias": "dyeResolution"; "required": false; "isSignal": true; }; "densityDissipation": { "alias": "densityDissipation"; "required": false; "isSignal": true; }; "velocityDissipation": { "alias": "velocityDissipation"; "required": false; "isSignal": true; }; "pressure": { "alias": "pressure"; "required": false; "isSignal": true; }; "pressureIterations": { "alias": "pressureIterations"; "required": false; "isSignal": true; }; "curl": { "alias": "curl"; "required": false; "isSignal": true; }; "splatRadius": { "alias": "splatRadius"; "required": false; "isSignal": true; }; "splatForce": { "alias": "splatForce"; "required": false; "isSignal": true; }; "shading": { "alias": "shading"; "required": false; "isSignal": true; }; "colorUpdateSpeed": { "alias": "colorUpdateSpeed"; "required": false; "isSignal": true; }; "rainbow": { "alias": "rainbow"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * @license
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://github.com/thekhegay/ngwr/blob/main/LICENSE
+ *
+ * WebGL fluid simulation behind `<wr-splash-cursor>`. Port of the engine
+ * used by reactbits.dev's SplashCursor (itself based on Pavel Dobryakov's
+ * WebGL-Fluid-Simulation, MIT).
+ *
+ * Framework-free on purpose: `createFluidSimulation(canvas, config)` boots
+ * the sim and returns a teardown, or `null` when WebGL isn't available.
+ */
+interface WrFluidConfig {
+    readonly simResolution: number;
+    readonly dyeResolution: number;
+    readonly densityDissipation: number;
+    readonly velocityDissipation: number;
+    readonly pressure: number;
+    readonly pressureIterations: number;
+    readonly curl: number;
+    readonly splatRadius: number;
+    readonly splatForce: number;
+    readonly shading: boolean;
+    readonly colorUpdateSpeed: number;
+    /** Cycle splat colours through the rainbow; `false` uses `color`. */
+    readonly rainbow: boolean;
+    /** Fixed splat colour (hex) when `rainbow` is off. */
+    readonly color: string;
+}
+
+export { WrSplashCursor };
+export type { WrFluidConfig };

package/types/ngwr-split-text.d.ts

@@ -0,0 +1,83 @@
+import * as _angular_core from '@angular/core';
+
+/** Granularity of the split. `lines` is not yet supported in this port. */
+type WrSplitTextUnit = 'chars' | 'words';
+/**
+ * One end of the animation. Properties not listed default to the steady
+ * state (opacity 1, no transform). `x` / `y` are pixels, `scale` is a
+ * unitless factor, `rotate` is degrees.
+ */
+interface WrSplitTextMotion {
+    readonly opacity?: number;
+    readonly x?: number;
+    readonly y?: number;
+    readonly scale?: number;
+    readonly rotate?: number;
+}
+
+type Piece = {
+    readonly kind: 'piece';
+    readonly text: string;
+} | {
+    readonly kind: 'space';
+    readonly text: string;
+};
+/**
+ * Animated text reveal — splits the input string into chars or words and
+ * staggers each piece in from a `from` motion state to a `to` motion
+ * state when the host scrolls into view. Whitespace is preserved.
+ *
+ * @example
+ * ```html
+ * <wr-split-text
+ *   text="Hello, ngwr!"
+ *   splitType="chars"
+ *   [delay]="40"
+ *   [duration]="1.2"
+ *   [from]="{ opacity: 0, y: 40 }"
+ *   [to]="{ opacity: 1, y: 0 }"
+ *   (animationComplete)="onDone()"
+ * />
+ * ```
+ *
+ * @see https://www.reactbits.dev/text-animations/split-text
+ */
+declare class WrSplitText {
+    /** Text to animate. Required. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Split granularity. @default 'chars' */
+    readonly splitType: _angular_core.InputSignal<WrSplitTextUnit>;
+    /** Stagger delay between pieces in ms. @default 50 */
+    readonly delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Animation duration in seconds (matches reactbits' API). @default 1.25 */
+    readonly duration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** CSS easing function. @default 'cubic-bezier(0.16, 1, 0.3, 1)' (~power3.out) */
+    readonly easing: _angular_core.InputSignal<string>;
+    /** Start state for each piece. @default { opacity: 0, y: 40 } */
+    readonly from: _angular_core.InputSignal<WrSplitTextMotion>;
+    /** End state for each piece. @default { opacity: 1, y: 0 } */
+    readonly to: _angular_core.InputSignal<WrSplitTextMotion>;
+    /** `IntersectionObserver.threshold` — 0..1. @default 0.1 */
+    readonly threshold: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** `IntersectionObserver.rootMargin`. @default '-100px' */
+    readonly rootMargin: _angular_core.InputSignal<string>;
+    /** Text alignment of the host. @default 'center' */
+    readonly textAlign: _angular_core.InputSignal<"left" | "center" | "right" | "justify">;
+    /** Emitted once all pieces finish animating. */
+    readonly animationComplete: _angular_core.OutputEmitterRef<void>;
+    /** Pieces to render. Each piece is `{ kind: 'piece', text }` or `{ kind: 'space' }`. */
+    protected readonly pieces: _angular_core.Signal<readonly Piece[]>;
+    private readonly host;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private readonly platform;
+    private hasAnimated;
+    constructor();
+    private startObserver;
+    private animate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSplitText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSplitText, "wr-split-text", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "splitType": { "alias": "splitType"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "easing": { "alias": "easing"; "required": false; "isSignal": true; }; "from": { "alias": "from"; "required": false; "isSignal": true; }; "to": { "alias": "to"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "rootMargin": { "alias": "rootMargin"; "required": false; "isSignal": true; }; "textAlign": { "alias": "textAlign"; "required": false; "isSignal": true; }; }, { "animationComplete": "animationComplete"; }, never, never, true, never>;
+}
+
+export { WrSplitText };
+export type { WrSplitTextMotion, WrSplitTextUnit };

package/types/ngwr-splitter.d.ts

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Resizable two-pane splitter. Project two pieces of content via
+ * `[wrSplitterStart]` and `[wrSplitterEnd]`; the user drags the divider
+ * to reallocate space between them.
+ *
+ * @example
+ * ```html
+ * <wr-splitter [(position)]="pos">
+ *   <div wrSplitterStart>Files</div>
+ *   <div wrSplitterEnd>Editor</div>
+ * </wr-splitter>
+ *
+ * <wr-splitter orientation="vertical" [minPosition]="20" [maxPosition]="80">
+ *   <div wrSplitterStart>Preview</div>
+ *   <div wrSplitterEnd>Logs</div>
+ * </wr-splitter>
+ * ```
+ *
+ * @see https://ngwr.dev/components/splitter
+ */
+declare class WrSplitter {
+    /** Position of the divider as a percentage (0–100). Two-way bindable. @default 50 */
+    readonly position: _angular_core.ModelSignal<number>;
+    /**
+     * Divider direction:
+     * - `'horizontal'` — vertical divider, drags L/R (panes side by side).
+     * - `'vertical'`   — horizontal divider, drags U/D (panes stacked).
+     * @default 'horizontal'
+     */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** Minimum allowed position. @default 0 */
+    readonly minPosition: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Maximum allowed position. @default 100 */
+    readonly maxPosition: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable dragging. @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    private readonly host;
+    private dragging;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly startStyle: _angular_core.Signal<string>;
+    protected readonly endStyle: _angular_core.Signal<string>;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSplitter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSplitter, "wr-splitter", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "minPosition": { "alias": "minPosition"; "required": false; "isSignal": true; }; "maxPosition": { "alias": "maxPosition"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "position": "positionChange"; }, never, ["[wrSplitterStart]", "[wrSplitterEnd]"], true, never>;
+}
+
+export { WrSplitter };

package/types/ngwr-spotlight-card.d.ts

@@ -0,0 +1,71 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Cursor-tracked spotlight card. A soft radial highlight follows the
+ * pointer inside the card; fades in on hover, out on leave.
+ *
+ * Project any content as children — the spotlight overlay sits behind
+ * the projected DOM (via a `::before` pseudo with `pointer-events: none`)
+ * so clicks pass through naturally.
+ *
+ * @example
+ * ```html
+ * <wr-spotlight-card spotlightColor="rgba(120, 180, 255, 0.25)">
+ *   <h3>Hover me</h3>
+ * </wr-spotlight-card>
+ * ```
+ *
+ * @see https://www.reactbits.dev/components/spotlight-card
+ */
+declare class WrSpotlightCard {
+    /**
+     * Highlight colour (any CSS colour). When unset, the theme decides:
+     * a soft dark tint on light surfaces, white-alpha on dark.
+     */
+    readonly spotlightColor: _angular_core.InputSignal<string | null>;
+    /** Where the spotlight fades out, as a percentage of the gradient. @default 80 */
+    readonly radius: _angular_core.InputSignalWithTransform<number, unknown>;
+    private readonly el;
+    protected onMouseMove(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpotlightCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSpotlightCard, "wr-spotlight-card", never, { "spotlightColor": { "alias": "spotlightColor"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Cursor-follow radial spotlight. Sets the `--wr-spotlight-x` and
+ * `--wr-spotlight-y` CSS custom properties on the host based on the
+ * pointer position so a `radial-gradient` (or `mask`) in your CSS can
+ * follow the cursor.
+ *
+ * @example
+ * ```html
+ * <div class="card" wrSpotlight>…</div>
+ * ```
+ *
+ * ```scss
+ * .card {
+ *   background: radial-gradient(
+ *     400px circle at var(--wr-spotlight-x, 50%) var(--wr-spotlight-y, 50%),
+ *     rgba(var(--wr-color-primary-rgb), 0.15),
+ *     transparent 60%
+ *   );
+ * }
+ * ```
+ */
+declare class WrSpotlight {
+    /** Optional default coordinates when no pointer is over the host. */
+    readonly resetX: _angular_core.InputSignal<string>;
+    readonly resetY: _angular_core.InputSignal<string>;
+    private readonly el;
+    private readonly zone;
+    private readonly destroyRef;
+    constructor();
+    /** @internal */
+    protected onMove(event: PointerEvent): void;
+    /** @internal */
+    protected onLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSpotlight, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrSpotlight, "[wrSpotlight]", never, { "resetX": { "alias": "resetX"; "required": false; "isSignal": true; }; "resetY": { "alias": "resetY"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrSpotlight, WrSpotlightCard };