ngwr 6.1.1 → 7.0.0

package/types/ngwr-calendar.d.ts

@@ -0,0 +1,116 @@
+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
+ */
+/**
+ * Selection mode for `<wr-calendar>`:
+ *
+ * - `single` — one date at a time, bound via `[(date)]`
+ * - `range` — start + end dates, bound via `[(range)]`
+ */
+type WrCalendarMode = 'single' | 'range';
+
+/**
+ * @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
+ */
+/**
+ * `[start, end]` tuple used by `<wr-calendar>` in `range` mode. Either side
+ * may be `null` while the user is mid-selection (start picked, end pending).
+ */
+type WrCalendarRange = readonly [Date | null, Date | null];
+
+/**
+ * Month-view calendar. Supports single-date selection (`mode="single"`) or
+ * date-range selection (`mode="range"`). Reusable on its own; consumed by
+ * `<wr-date-picker>` inside an overlay.
+ *
+ * Uses {@link WrDateAdapter} for all date math and formatting — register
+ * one via {@link provideWrDateAdapter} at bootstrap.
+ *
+ * @example
+ * ```html
+ * <wr-calendar [(date)]="picked" [min]="minDate" />
+ *
+ * <wr-calendar mode="range" [(range)]="[start, end]" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/calendar
+ */
+declare class WrCalendar {
+    /** Selection mode. @default 'single' */
+    readonly mode: _angular_core.InputSignal<WrCalendarMode>;
+    /** Two-way bindable single value (used when `mode === 'single'`). */
+    readonly date: _angular_core.ModelSignal<Date | null>;
+    /** Two-way bindable `[start, end]` (used when `mode === 'range'`). */
+    readonly range: _angular_core.ModelSignal<WrCalendarRange>;
+    /** Min selectable date (inclusive). */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Max selectable date (inclusive). */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Predicate — return `false` to disable specific dates (e.g. weekends only). */
+    readonly dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** Disable interaction entirely. @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    private readonly adapter;
+    private readonly host;
+    /** Currently displayed month (any date inside it). */
+    protected readonly viewDate: _angular_core.WritableSignal<Date>;
+    /** Date currently focused by keyboard (single roving tabindex). */
+    protected readonly focusedDate: _angular_core.WritableSignal<Date>;
+    /** Hovered date during range-mode end-pick — drives the preview highlight. */
+    protected readonly hoverDate: _angular_core.WritableSignal<Date | null>;
+    /** Which sub-view is currently shown. Cycles `day → month → year` on header click. */
+    protected readonly viewMode: _angular_core.WritableSignal<"day" | "month" | "year">;
+    protected readonly today: _angular_core.Signal<Date>;
+    protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
+    protected readonly monthsView: _angular_core.Signal<readonly string[]>;
+    /** 12-year window centered on the floor-aligned decade containing `viewDate`. */
+    protected readonly yearsView: _angular_core.Signal<readonly number[]>;
+    protected readonly headerLabel: _angular_core.Signal<string>;
+    /** 6×7 day grid covering the current month plus spillover. */
+    protected readonly weeks: _angular_core.Signal<readonly (readonly Date[])[]>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    /** Header `‹` button — steps by month / year / decade based on the active view. */
+    protected prev(): void;
+    /** Header `›` button — steps by month / year / decade based on the active view. */
+    protected next(): void;
+    /** Header label click — zooms out (`day → month → year`). No-op at year view. */
+    protected onLabelClick(): void;
+    protected onMonthSelect(monthIdx: number): void;
+    protected onYearSelect(year: number): void;
+    private stepViewDate;
+    protected isToday(date: Date): boolean;
+    protected isOutOfMonth(date: Date): boolean;
+    protected isSelected(date: Date): boolean;
+    protected isInRange(date: Date): boolean;
+    protected isInRangePreview(date: Date): boolean;
+    protected isFocused(date: Date): boolean;
+    protected isDisabled(date: Date): boolean;
+    protected isMonthCurrent(monthIdx: number): boolean;
+    protected isMonthSelected(monthIdx: number): boolean;
+    protected isMonthDisabled(monthIdx: number): boolean;
+    protected isYearCurrent(year: number): boolean;
+    protected isYearSelected(year: number): boolean;
+    protected isYearDisabled(year: number): boolean;
+    protected onCellClick(date: Date): void;
+    protected onCellEnter(date: Date): void;
+    protected onCellLeave(): void;
+    private applyRangeClick;
+    protected onKeyDown(event: KeyboardEvent): void;
+    private focusActiveCell;
+    /** Used by the template's `track` expression. */
+    protected trackByTime(_: number, date: Date): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCalendar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCalendar, "wr-calendar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "range": { "alias": "range"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "date": "dateChange"; "range": "rangeChange"; }, never, never, true, never>;
+}
+
+export { WrCalendar };
+export type { WrCalendarMode, WrCalendarRange };

package/types/ngwr-card.d.ts

@@ -0,0 +1,50 @@
+import * as i0 from '@angular/core';
+
+/**
+ * Surface container with optional header, body, and footer slots.
+ *
+ * Compose with `<wr-card-header>`, the projected body content, and
+ * `<wr-card-footer>`. Each slot is a tiny component that just projects
+ * its content under the matching BEM class — consumers keep full control
+ * of the markup inside.
+ *
+ * @example Basic
+ * ```html
+ * <wr-card>
+ *   <wr-card-header>
+ *     <h3>Settings</h3>
+ *   </wr-card-header>
+ *   <p>Body content.</p>
+ *   <wr-card-footer>
+ *     <button wr-btn>Save</button>
+ *   </wr-card-footer>
+ * </wr-card>
+ * ```
+ *
+ * @see https://ngwr.dev/components/card
+ */
+declare class WrCard {
+    /** Render a 1px border around the surface. @default true */
+    readonly bordered: i0.InputSignalWithTransform<boolean, any>;
+    /** Lift / shadow the card on hover. @default false */
+    readonly hoverable: i0.InputSignalWithTransform<boolean, any>;
+    /** Overlay with a centred spinner — for in-place data loads. @default false */
+    readonly loading: i0.InputSignalWithTransform<boolean, any>;
+    /** Compact paddings — half the default vertical / horizontal spacing. @default false */
+    readonly compact: i0.InputSignalWithTransform<boolean, any>;
+    protected readonly classes: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrCard, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrCard, "wr-card", never, { "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, never, ["wr-card-header", "*", "wr-card-footer"], true, never>;
+}
+/** Header slot — projects content under `.wr-card__header`. */
+declare class WrCardHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrCardHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrCardHeader, "wr-card-header", never, {}, {}, never, ["*"], true, never>;
+}
+/** Footer slot — projects content under `.wr-card__footer`. */
+declare class WrCardFooter {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrCardFooter, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrCardFooter, "wr-card-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+export { WrCard, WrCardFooter, WrCardHeader };

package/types/ngwr-carousel.d.ts

@@ -0,0 +1,57 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * One slide in a {@link WrCarousel}. Holds whatever content you
+ * project — image, card, video, anything.
+ */
+declare class WrCarouselSlide {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCarouselSlide, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarouselSlide, "wr-carousel-slide", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Slide carousel. Project `<wr-carousel-slide>` children — the carousel
+ * snaps between them with prev/next buttons and optional dots / autoplay.
+ *
+ * @example
+ * ```html
+ * <wr-carousel [(active)]="i" autoplay>
+ *   <wr-carousel-slide><img src="a.jpg" /></wr-carousel-slide>
+ *   <wr-carousel-slide><img src="b.jpg" /></wr-carousel-slide>
+ *   <wr-carousel-slide><img src="c.jpg" /></wr-carousel-slide>
+ * </wr-carousel>
+ * ```
+ *
+ * @see https://ngwr.dev/components/carousel
+ */
+declare class WrCarousel {
+    /** Active slide index. Two-way bindable. @default 0 */
+    readonly active: _angular_core.ModelSignal<number>;
+    /** Show prev / next arrow buttons. @default true */
+    readonly showArrows: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Show dot indicators below the slides. @default true */
+    readonly showDots: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Auto-advance slides. @default false */
+    readonly autoplay: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Autoplay interval (ms). @default 4000 */
+    readonly intervalMs: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Wrap around at the ends. @default true */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly slides: _angular_core.Signal<readonly WrCarouselSlide[]>;
+    protected readonly count: _angular_core.Signal<number>;
+    /** CSS transform for the track. */
+    protected readonly trackStyle: _angular_core.Signal<string>;
+    private timer;
+    private readonly paused;
+    private readonly destroyRef;
+    constructor();
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    goTo(index: number): void;
+    next(): void;
+    prev(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCarousel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCarousel, "wr-carousel", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "showArrows": { "alias": "showArrows"; "required": false; "isSignal": true; }; "showDots": { "alias": "showDots"; "required": false; "isSignal": true; }; "autoplay": { "alias": "autoplay"; "required": false; "isSignal": true; }; "intervalMs": { "alias": "intervalMs"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["slides"], ["*"], true, never>;
+}
+
+export { WrCarousel, WrCarouselSlide };

package/types/ngwr-cascader.d.ts

@@ -0,0 +1,107 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** One node in the cascader tree. */
+interface WrCascaderOption<T = string> {
+    /** Value contributed when this node is part of the selection path. */
+    readonly value: T;
+    /** Display label for this node. */
+    readonly label: string;
+    /** Disable interaction for this node. @default false */
+    readonly disabled?: boolean;
+    /** Children. Absence (or empty array) marks this as a leaf. */
+    readonly children?: readonly WrCascaderOption<T>[];
+}
+
+/**
+ * Multi-level select — drills down through hierarchical categories
+ * (e.g. country → state → city). Each level renders as a column; clicks
+ * advance to the next column. Selecting a leaf (no children) commits
+ * the full path.
+ *
+ * Implements `ControlValueAccessor` — value is the path through the
+ * tree as a `readonly T[]`.
+ *
+ * @example
+ * ```html
+ * <wr-cascader [options]="locations" [(ngModel)]="path" placeholder="Pick a location" />
+ * ```
+ *
+ * ```ts
+ * locations: WrCascaderOption[] = [
+ *   {
+ *     value: 'us', label: 'United States', children: [
+ *       { value: 'ny', label: 'New York', children: [
+ *         { value: 'nyc', label: 'NYC' },
+ *         { value: 'buf', label: 'Buffalo' },
+ *       ] },
+ *     ],
+ *   },
+ * ];
+ * ```
+ *
+ * @see https://ngwr.dev/components/cascader
+ */
+declare class WrCascader<T = string> implements ControlValueAccessor {
+    /** Root-level options. Each may have `children` for deeper levels. */
+    readonly options: _angular_core.InputSignal<readonly WrCascaderOption<T>[]>;
+    /** Placeholder shown when no path is selected. @default '' */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Disable the cascader. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Show a clear-all (×) button on the trigger when a path is selected. @default true */
+    readonly clearable: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Allow selecting non-leaf (parent) nodes. When `false`, only leaves
+     * (nodes without children) commit a selection. @default false
+     */
+    readonly changeOnSelect: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Separator between labels in the trigger display. @default '/' */
+    readonly separator: _angular_core.InputSignal<string>;
+    /** Committed selection path (full T[] from root to leaf). @internal */
+    protected readonly path: _angular_core.WritableSignal<readonly T[]>;
+    /** Currently-expanded column path — drives which columns the panel shows. @internal */
+    protected readonly activePath: _angular_core.WritableSignal<readonly T[]>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    /** Panel id used by the trigger's `aria-controls`. */
+    protected readonly panelId: string;
+    private readonly disabledFromCva;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    /**
+     * Columns visible in the panel. Each column shows the children of the
+     * preceding activePath entry. Column 0 = root options. The last
+     * column is whatever the deepest active node's children resolve to —
+     * we only render a column when there are children to show.
+     */
+    protected readonly columns: _angular_core.Signal<readonly (readonly WrCascaderOption<T>[])[]>;
+    /** Label trail joined by `separator()` — what the trigger shows. */
+    protected readonly displayLabel: _angular_core.Signal<string | null>;
+    protected readonly hasSelection: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    protected readonly panelTpl: _angular_core.Signal<TemplateRef<any>>;
+    private readonly host;
+    private readonly overlay;
+    private readonly vcr;
+    private readonly scrollStrategies;
+    private readonly destroyRef;
+    private overlayRef;
+    private onChange;
+    protected onTouched: () => void;
+    constructor();
+    protected onTriggerClick(): void;
+    protected onOptionClick(colIndex: number, opt: WrCascaderOption<T>, event: Event): void;
+    protected clearSelection(event: Event): void;
+    protected isActiveAt(colIndex: number, value: T): boolean;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: readonly T[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private openOverlay;
+    private closeOverlay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCascader<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCascader<any>, "wr-cascader", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "changeOnSelect": { "alias": "changeOnSelect"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrCascader };
+export type { WrCascaderOption };

package/types/ngwr-checkbox.d.ts

@@ -0,0 +1,139 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * Two-state checkbox.
+ *
+ * **Standalone mode** — boolean value, works as a `ControlValueAccessor`:
+ *
+ * @example
+ * ```html
+ * <wr-checkbox [(ngModel)]="agree">I agree</wr-checkbox>
+ * ```
+ *
+ * **Inside `<wr-checkbox-group>`** — the checkbox's `value` is added to
+ * or removed from the group's array. The standalone CVA is ignored.
+ *
+ * @example
+ * ```html
+ * <wr-checkbox-group [(ngModel)]="features">
+ *   <wr-checkbox value="autosave">Autosave</wr-checkbox>
+ *   <wr-checkbox value="notifications">Notifications</wr-checkbox>
+ * </wr-checkbox-group>
+ * ```
+ *
+ * @see https://ngwr.dev/components/checkbox
+ */
+declare class WrCheckbox implements ControlValueAccessor {
+    /**
+     * Stable id used to associate the native input with its label.
+     *
+     * @default Randomly generated
+     */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Per-checkbox value used only when inside a `<wr-checkbox-group>`.
+     * Ignored in standalone mode.
+     */
+    readonly value: _angular_core.InputSignal<unknown>;
+    /**
+     * Disable the checkbox. Also set automatically by Angular forms.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Optional icon name rendered inside the box when checked, in place of the
+     * default checkmark. Use any registered NGWR icon.
+     */
+    readonly icon: _angular_core.InputSignal<string | null>;
+    private readonly group;
+    protected readonly standaloneChecked: _angular_core.WritableSignal<boolean>;
+    protected readonly standaloneDisabledFromCva: _angular_core.WritableSignal<boolean>;
+    /** Derived "is checked". Reads from group when grouped, else local state. */
+    protected readonly checked: _angular_core.Signal<boolean>;
+    /** Effective disabled — input wins, then group, then CVA. */
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private onChange;
+    private onTouched;
+    writeValue(value: boolean | null): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInputChange(event: Event): void;
+    protected onInputBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCheckbox, "wr-checkbox", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, 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
+ */
+
+/**
+ * Contract a checkbox uses to talk to its parent `<wr-checkbox-group>`.
+ *
+ * @internal
+ */
+interface WrCheckboxGroupContext {
+    /** Is the given value currently selected? */
+    isSelected(value: unknown): boolean;
+    /** Toggle the given value in the group. */
+    toggle(value: unknown): void;
+    /** Whether the entire group is disabled. */
+    readonly isDisabled: Signal<boolean>;
+}
+/**
+ * Token a `<wr-checkbox>` injects to read selection state from — and
+ * toggle values in — its parent `<wr-checkbox-group>` (when present).
+ *
+ * @internal
+ */
+declare const WR_CHECKBOX_GROUP: InjectionToken<WrCheckboxGroupContext>;
+
+/**
+ * Manages a group of `<wr-checkbox>` children as a single form value
+ * (an array of the checked items' `value` inputs).
+ *
+ * @example
+ * ```html
+ * <wr-checkbox-group [(ngModel)]="features">
+ *   <wr-checkbox value="autosave">Autosave</wr-checkbox>
+ *   <wr-checkbox value="notifications">Notifications</wr-checkbox>
+ *   <wr-checkbox value="darkmode">Dark mode</wr-checkbox>
+ * </wr-checkbox-group>
+ * ```
+ *
+ * @see https://ngwr.dev/components/checkbox
+ */
+declare class WrCheckboxGroup implements ControlValueAccessor, WrCheckboxGroupContext {
+    /**
+     * Disable every child checkbox. Also set by Angular forms via
+     * `setDisabledState`.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    private readonly selected;
+    private readonly disabledFromCva;
+    /** Effective disabled state — input wins, CVA second. */
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    private onChange;
+    private onTouched;
+    isSelected(value: unknown): boolean;
+    toggle(value: unknown): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCheckboxGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCheckboxGroup, "wr-checkbox-group", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WR_CHECKBOX_GROUP, WrCheckbox, WrCheckboxGroup };
+export type { WrCheckboxGroupContext };

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

@@ -0,0 +1,49 @@
+import * as _angular_core from '@angular/core';
+
+type WrCircularTextHover = 'speedUp' | 'slowDown' | 'pause' | 'goBonkers' | null;
+
+interface Char {
+    readonly ch: string;
+    readonly transform: string;
+}
+/**
+ * Text laid out around a circle, with the whole circle spinning. Hover
+ * behaviour swaps the spin rate (or pauses it) — the current rotation
+ * angle is preserved across the swap so there's no visible jump.
+ *
+ * @example
+ * ```html
+ * <wr-circular-text text="HELLO * NGWR * " />
+ * <wr-circular-text text="GO BONKERS" onHover="goBonkers" [spinDuration]="12" />
+ * ```
+ *
+ * @see https://www.reactbits.dev/text-animations/circular-text
+ */
+declare class WrCircularText {
+    /** Text to lay out around the circle. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Seconds per full revolution at rest. @default 20 */
+    readonly spinDuration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Hover behaviour. `null` disables hover reactivity. @default 'speedUp' */
+    readonly onHover: _angular_core.InputSignal<WrCircularTextHover>;
+    protected readonly chars: _angular_core.Signal<readonly Char[]>;
+    private readonly spinEl;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private readonly platform;
+    private rotation;
+    private hovered;
+    /** Active spin duration in seconds — base, or hover-modified. */
+    private effectiveDuration;
+    constructor();
+    /**
+     * Start the rotation, or swap its duration while preserving the
+     * current angle. If the new mode is `pause`, just pause the animation.
+     */
+    private startOrSwap;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrCircularText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrCircularText, "wr-circular-text", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "spinDuration": { "alias": "spinDuration"; "required": false; "isSignal": true; }; "onHover": { "alias": "onHover"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrCircularText };
+export type { WrCircularTextHover };

package/types/ngwr-click-spark.d.ts

@@ -0,0 +1,52 @@
+import * as _angular_core from '@angular/core';
+
+type WrClickSparkEasing = 'linear' | 'ease-in' | 'ease-in-out' | 'ease-out';
+
+/**
+ * Click ripple — bursts a ring of short line sparks from the click point
+ * across any projected content. Wraps children in a positioned container
+ * with a `pointer-events: none` canvas overlay, so projected DOM stays
+ * fully interactive.
+ *
+ * @example
+ * ```html
+ * <wr-click-spark>
+ *   <h1>Click anywhere</h1>
+ *   <button>Buttons still work</button>
+ * </wr-click-spark>
+ * ```
+ *
+ * @see https://www.reactbits.dev/animations/click-spark
+ */
+declare class WrClickSpark {
+    /** Spark line colour. @default '#fff' */
+    readonly sparkColor: _angular_core.InputSignal<string>;
+    /** Length of each spark line in pixels (at t=0; tapers to 0 at t=1). @default 10 */
+    readonly sparkSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Distance each spark travels from origin in pixels. @default 15 */
+    readonly sparkRadius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Number of sparks per click (evenly distributed around the circle). @default 8 */
+    readonly sparkCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Animation duration in ms. @default 400 */
+    readonly duration: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Easing function applied to the travel distance. @default 'ease-out' */
+    readonly easing: _angular_core.InputSignal<WrClickSparkEasing>;
+    /** Multiplier on the travel distance — bumps the radius without changing `sparkRadius`. @default 1 */
+    readonly extraScale: _angular_core.InputSignalWithTransform<number, unknown>;
+    private readonly canvasRef;
+    private readonly host;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private readonly platform;
+    private sparks;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    private syncCanvasSize;
+    private watchResize;
+    private startLoop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrClickSpark, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrClickSpark, "wr-click-spark", never, { "sparkColor": { "alias": "sparkColor"; "required": false; "isSignal": true; }; "sparkSize": { "alias": "sparkSize"; "required": false; "isSignal": true; }; "sparkRadius": { "alias": "sparkRadius"; "required": false; "isSignal": true; }; "sparkCount": { "alias": "sparkCount"; "required": false; "isSignal": true; }; "duration": { "alias": "duration"; "required": false; "isSignal": true; }; "easing": { "alias": "easing"; "required": false; "isSignal": true; }; "extraScale": { "alias": "extraScale"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WrClickSpark };
+export type { WrClickSparkEasing };

package/types/ngwr-clipboard.d.ts

@@ -0,0 +1,53 @@
+import * as i0 from '@angular/core';
+
+/** Outcome of a clipboard read or permission probe. */
+type WrClipboardPermission = 'granted' | 'denied' | 'prompt' | 'unsupported';
+
+/**
+ * Programmatic clipboard read / write.
+ *
+ * - **Write** uses `navigator.clipboard.writeText` with a hidden
+ *   `<textarea>` + `execCommand('copy')` fallback for non-secure contexts.
+ * - **Read** uses `navigator.clipboard.readText` (no fallback — older
+ *   browsers expose no equivalent).
+ * - **Available** / **permission** check what the current browser allows
+ *   so UI can disable the action when it would silently no-op.
+ *
+ * SSR-safe: every method short-circuits when there's no `document.defaultView`.
+ *
+ * @example
+ * ```ts
+ * const clip = inject(WrClipboard);
+ *
+ * await clip.write('Hello');           // resolves to true on success
+ * const text = await clip.read();      // string | null
+ * clip.available();                    // boolean
+ * await clip.permission('write');      // 'granted' | 'denied' | 'prompt' | 'unsupported'
+ * ```
+ *
+ * @see https://ngwr.dev/services/clipboard
+ */
+declare class WrClipboard {
+    private readonly doc;
+    /** Is any clipboard write path available (async API or `execCommand`)? */
+    available(): boolean;
+    /**
+     * Write text. Resolves to `true` on success, `false` on failure (denied
+     * permission, no clipboard, etc).
+     */
+    write(text: string): Promise<boolean>;
+    /**
+     * Read text from the clipboard. Returns `null` when unsupported or
+     * when the user denied the permission prompt.
+     */
+    read(): Promise<string | null>;
+    /** Probe the Permissions API for `clipboard-read` / `clipboard-write`. */
+    permission(name: 'read' | 'write'): Promise<WrClipboardPermission>;
+    /** Hidden-textarea + `execCommand('copy')` write. Synchronous, no permissions. */
+    private legacyWrite;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrClipboard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrClipboard>;
+}
+
+export { WrClipboard };
+export type { WrClipboardPermission };