ngwr 6.0.0 → 7.0.0

package/types/ngwr-squircle.d.ts

@@ -0,0 +1,132 @@
+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
+ *
+ * Squircle path computation — port of the algorithm from `figma-squircle`
+ * (https://github.com/phamfoo/figma-squircle, MIT). Generates an SVG `d`
+ * string for a smooth-corner rectangle.
+ */
+/** Per-corner radii for the squircle. */
+interface WrSquircleCorners {
+    readonly topLeft: number;
+    readonly topRight: number;
+    readonly bottomRight: number;
+    readonly bottomLeft: number;
+}
+/**
+ * Generate an SVG `d` string for a squircle (smooth-corner rectangle).
+ *
+ * @param width Box width in user units.
+ * @param height Box height in user units.
+ * @param radius Either a single number applied to all four corners or a
+ *               `WrSquircleCorners` object with per-corner radii.
+ * @param smoothing 0–1. `0` = standard rounded rectangle; `1` = full
+ *                  iOS-style smooth corner. @default 1
+ */
+declare function squirclePath(width: number, height: number, radius: number | WrSquircleCorners, smoothing?: number): string;
+
+/**
+ * Which corners to squircle. `'all'` = standard four-corner squircle;
+ * the side-named values squircle the two corners on that side and leave
+ * the other two at 90°. Useful for tab-/segment-style controls where
+ * only outer corners need smoothing.
+ */
+type WrSquircleCornerMask = 'all' | 'left' | 'right' | 'top' | 'bottom' | 'none';
+
+/**
+ * Apply a Figma-style smooth-corner ("squircle") `clip-path` to the host
+ * element. Re-computes the path whenever the element resizes.
+ *
+ * Borders: pass `[borderWidth]` (px) + `[borderColor]` and the directive
+ * paints a `::before` pseudo with an *inset* squircle path on top of the
+ * host. The visible border is the host's own background colour, so set
+ * `background: <border-color>` on the host (or use the convenience
+ * `[borderColor]` input which writes the host background for you).
+ *
+ * @example
+ * ```html
+ * <button wrButton wrSquircle [radius]="16">Save</button>
+ * <wr-tag wrSquircle>v2.0</wr-tag>
+ * <div wrSquircle [radius]="32" [smoothing]="0.8">…</div>
+ * <div wrSquircle [borderWidth]="2" borderColor="var(--wr-color-primary)">…</div>
+ * ```
+ */
+declare class WrSquircle {
+    /** Corner radius in CSS pixels. Falls back to `--wr-border-radius-base` × 16. @default 12 */
+    readonly radius: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Smoothing factor — `0` = plain rounded rect; `1` = full smooth iOS corner. @default 1 */
+    readonly smoothing: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Whether the squircle clip-path is applied. When `false`, the directive
+     * stays inert (clip-path cleared).
+     *
+     * Modelled as `model()` so a parent component composing this directive
+     * (`inject(WrSquircle, { self: true }).enabled.set(...)`) can flip the
+     * state from outside without exposing an `enabled` input on its own API.
+     *
+     * @default true
+     */
+    readonly enabled: _angular_core.ModelSignal<boolean>;
+    /**
+     * Border thickness in CSS pixels. `0` disables the border ring entirely.
+     * Modelled (not `input()`) so parent components composing this directive
+     * can flip it imperatively — e.g. `WrButton` turning on a 1px ring when
+     * `shape="squircle" outlined` is active.
+     * @default 0
+     */
+    readonly borderWidth: _angular_core.ModelSignal<number>;
+    /**
+     * Border colour — any CSS colour. Applied to the host's background so the
+     * outer squircle reveals it. Defaults to `currentColor` so the consuming
+     * element's text colour drives the ring.
+     * @default 'currentColor'
+     */
+    readonly borderColor: _angular_core.ModelSignal<string>;
+    /**
+     * Which corners to squircle. `'all'` (default) is the standard four-
+     * corner shape; `'left'` / `'right'` / `'top'` / `'bottom'` squircle
+     * only the two corners on the named side and leave the other two at
+     * 90°. `'none'` is equivalent to disabling the directive.
+     *
+     * Modelled so parent components composing the directive can flip the
+     * value imperatively — used by `WrButtonGroup` to squircle only the
+     * outer corners of the first / last child.
+     *
+     * @default 'all'
+     */
+    readonly corners: _angular_core.ModelSignal<WrSquircleCornerMask>;
+    private readonly el;
+    private readonly isBrowser;
+    private readonly destroyRef;
+    private observer;
+    constructor();
+    private apply;
+    private clear;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSquircle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<WrSquircle, "[wrSquircle]", never, { "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "smoothing": { "alias": "smoothing"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "borderWidth": { "alias": "borderWidth"; "required": false; "isSignal": true; }; "borderColor": { "alias": "borderColor"; "required": false; "isSignal": true; }; "corners": { "alias": "corners"; "required": false; "isSignal": true; }; }, { "enabled": "enabledChange"; "borderWidth": "borderWidthChange"; "borderColor": "borderColorChange"; "corners": "cornersChange"; }, never, never, true, never>;
+}
+
+/**
+ * Standalone squircle container. Equivalent to `<div wrSquircle>` but
+ * named for ergonomics in templates.
+ *
+ * @example
+ * ```html
+ * <wr-squircle [radius]="24" style="width: 160px; height: 160px; background: var(--wr-color-primary)">
+ *   …
+ * </wr-squircle>
+ * ```
+ *
+ * @see https://ngwr.dev/components/squircle
+ */
+declare class WrSquircleHost {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrSquircleHost, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSquircleHost, "wr-squircle", never, {}, {}, never, ["*"], true, [{ directive: typeof WrSquircle; inputs: { "radius": "radius"; "smoothing": "smoothing"; "borderWidth": "borderWidth"; "borderColor": "borderColor"; }; outputs: {}; }]>;
+}
+
+export { WrSquircle, WrSquircleHost, squirclePath };
+export type { WrSquircleCornerMask, WrSquircleCorners };

package/types/ngwr-star-border.d.ts

@@ -0,0 +1,40 @@
+import * as _angular_core from '@angular/core';
+
+/** When the rays animate. */
+type WrStarBorderMode = 'infinite' | 'hover';
+/** Ray layout — both edges (reactbits default) or just the bottom one. */
+type WrStarBorderRays = 'mirror' | 'single';
+
+/**
+ * Star border — radial "comet" rays orbiting the top and bottom edges of
+ * a rounded container. Project any content; it sits on a themed inner
+ * panel above the rays.
+ *
+ * Works as an element or as an attribute on buttons / links.
+ *
+ * @example
+ * ```html
+ * <wr-star-border>Star border</wr-star-border>
+ * <button wr-star-border mode="hover" rays="single">Hover me</button>
+ * ```
+ *
+ * @see https://ngwr.dev/animations/star-border
+ */
+declare class WrStarBorder {
+    /** Ray colour. When unset, the theme decides: primary on light, white on dark. */
+    readonly color: _angular_core.InputSignal<string | null>;
+    /** Seconds per ray sweep. @default 6 */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Vertical bleed of the rays past the inner panel, in px. @default 1 */
+    readonly thickness: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** `'infinite'` animates always; `'hover'` only while hovered. @default 'infinite' */
+    readonly mode: _angular_core.InputSignal<WrStarBorderMode>;
+    /** `'mirror'` runs rays along both edges; `'single'` only the bottom. @default 'mirror' */
+    readonly rays: _angular_core.InputSignal<WrStarBorderRays>;
+    protected readonly classes: () => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrStarBorder, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrStarBorder, "wr-star-border, [wr-star-border]", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "rays": { "alias": "rays"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WrStarBorder };
+export type { WrStarBorderMode, WrStarBorderRays };

package/types/ngwr-statistic.d.ts

@@ -0,0 +1,88 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * KPI card — label + big number + optional prefix/suffix + delta. Pair
+ * with a layout grid for dashboards.
+ *
+ * @example
+ * ```html
+ * <wr-statistic label="Active users" [value]="12345" suffix="users" />
+ * <wr-statistic label="Revenue" [value]="9512" prefix="$" [delta]="12.4" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/statistic
+ */
+declare class WrStatistic {
+    readonly label: _angular_core.InputSignal<string>;
+    /** The number (or string) to display in the main slot. */
+    readonly value: _angular_core.InputSignal<string | number | null>;
+    /** Prefix glyph / symbol (e.g. `'$'`). */
+    readonly prefix: _angular_core.InputSignal<string>;
+    /** Suffix glyph / unit (e.g. `'%'`, `'kg'`). */
+    readonly suffix: _angular_core.InputSignal<string>;
+    /**
+     * Optional delta vs previous period — shown as `+x.x%` (or `-x.x%`).
+     * Use `deltaSuffix` to change the trailing unit.
+     */
+    readonly delta: _angular_core.InputSignalWithTransform<number | null, number | null>;
+    /** Unit appended to the delta value. @default '%' */
+    readonly deltaSuffix: _angular_core.InputSignal<string>;
+    protected readonly hasDelta: _angular_core.Signal<boolean>;
+    protected readonly deltaDirection: _angular_core.Signal<"up" | "down" | "flat">;
+    protected readonly deltaText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrStatistic, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrStatistic, "wr-statistic", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "delta": { "alias": "delta"; "required": false; "isSignal": true; }; "deltaSuffix": { "alias": "deltaSuffix"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Live-counting variant of `<wr-statistic>` that targets a future date
+ * and ticks down to zero. The format string uses Day/Hour/Minute/Second
+ * tokens (`D`, `H`, `m`, `s`, double for zero-padded, plus `SSS` for
+ * milliseconds).
+ *
+ * @example
+ * ```html
+ * <wr-statistic-countdown
+ *   label="Launch in"
+ *   [target]="launchDate"
+ *   format="D days HH:mm:ss"
+ *   (countdownEnd)="onLive()"
+ * />
+ * ```
+ *
+ * @see https://ngwr.dev/components/statistic
+ */
+declare class WrStatisticCountdown {
+    /** Target date / timestamp the countdown is running down to. */
+    readonly target: _angular_core.InputSignal<string | number | Date>;
+    /** Label rendered above the value. */
+    readonly label: _angular_core.InputSignal<string>;
+    /**
+     * Format string. Tokens: `D`/`DD` (days), `H`/`HH` (hours),
+     * `m`/`mm` (minutes), `s`/`ss` (seconds), `SSS` (milliseconds).
+     * Double-letter forms zero-pad to width 2. @default 'HH:mm:ss'
+     */
+    readonly format: _angular_core.InputSignal<string>;
+    /** Optional text shown once the countdown reaches zero. */
+    readonly endText: _angular_core.InputSignal<string | null>;
+    /**
+     * Tick interval in ms. Drop to ~16 for `SSS` (millisecond display).
+     * @default 1000
+     */
+    readonly tickMs: _angular_core.InputSignal<number>;
+    /** Fires once when the countdown crosses zero. */
+    readonly countdownEnd: _angular_core.OutputEmitterRef<void>;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private readonly targetMs;
+    /** Remaining milliseconds (live signal). */
+    protected readonly remaining: _angular_core.WritableSignal<number>;
+    protected readonly finished: _angular_core.WritableSignal<boolean>;
+    protected readonly display: _angular_core.Signal<string>;
+    constructor();
+    private tick;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrStatisticCountdown, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrStatisticCountdown, "wr-statistic-countdown", never, { "target": { "alias": "target"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "endText": { "alias": "endText"; "required": false; "isSignal": true; }; "tickMs": { "alias": "tickMs"; "required": false; "isSignal": true; }; }, { "countdownEnd": "countdownEnd"; }, never, never, true, never>;
+}
+
+export { WrStatistic, WrStatisticCountdown };

package/types/ngwr-stepper.d.ts

@@ -0,0 +1,99 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+
+/**
+ * One step in a {@link WrStepper}. Project as a child:
+ *
+ * ```html
+ * <wr-stepper>
+ *   <wr-step label="Account"> … </wr-step>
+ *   <wr-step label="Profile" description="Optional"> … </wr-step>
+ * </wr-stepper>
+ * ```
+ *
+ * The stepper hides every step except the active one via a host class —
+ * each step still mounts once, so component state survives navigation.
+ *
+ * @see https://ngwr.dev/components/stepper
+ */
+declare class WrStep {
+    /** Header label. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Secondary text shown under the label. */
+    readonly description: _angular_core.InputSignal<string>;
+    /** Marks the step as optional in the header. */
+    readonly optional: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Override completion state. When unset, the stepper auto-derives it
+     * from the active index (any step before `active` is completed).
+     */
+    readonly completed: _angular_core.InputSignal<boolean | null>;
+    /** Disables the header — also blocks header clicks. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Stepper-assigned index. Set by the parent when contentChildren updates. */
+    readonly _index: _angular_core.WritableSignal<number>;
+    private readonly stepper;
+    protected readonly isActive: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrStep, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrStep, "wr-step", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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
+ */
+
+/** Surface a {@link WrStepper} provides for its child `<wr-step>`s. */
+interface WrStepperContext {
+    /** Index of the currently visible step. */
+    readonly active: Signal<number>;
+    /** Linear mode — steps after the latest completed one are locked. */
+    readonly linear: Signal<boolean>;
+}
+declare const WR_STEPPER: InjectionToken<WrStepperContext>;
+
+/**
+ * Multi-step wizard container. Children are `<wr-step>` components — the
+ * stepper renders one numbered header per step (with connectors) and the
+ * body of the currently active one.
+ *
+ * Two-way bind `[(active)]` to the active step index. Set `linear="true"`
+ * to forbid jumping past incomplete steps.
+ *
+ * @example
+ * ```html
+ * <wr-stepper [(active)]="step" linear>
+ *   <wr-step label="Account">…</wr-step>
+ *   <wr-step label="Profile">…</wr-step>
+ *   <wr-step label="Confirm">…</wr-step>
+ * </wr-stepper>
+ * ```
+ *
+ * @see https://ngwr.dev/components/stepper
+ */
+declare class WrStepper implements WrStepperContext {
+    /** Index of the currently visible step. */
+    readonly active: _angular_core.ModelSignal<number>;
+    /** Layout direction. @default 'horizontal' */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /** Lock steps after the latest completed one. @default false */
+    readonly linear: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly steps: _angular_core.Signal<readonly WrStep[]>;
+    protected readonly classes: _angular_core.Signal<string>;
+    constructor();
+    /** Is the step at `index` considered completed? */
+    protected isCompleted(index: number): boolean;
+    /** Is the step at `index` reachable for direct header clicks? */
+    protected isReachable(index: number): boolean;
+    protected onHeaderClick(index: number): void;
+    goTo(index: number): void;
+    next(): void;
+    prev(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrStepper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrStepper, "wr-stepper", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; }, ["steps"], ["*"], true, never>;
+}
+
+export { WR_STEPPER, WrStep, WrStepper };
+export type { WrStepperContext };

package/types/ngwr-storage.d.ts

@@ -0,0 +1,178 @@
+import * as i0 from '@angular/core';
+import { Signal, InjectionToken, EnvironmentProviders } from '@angular/core';
+import * as ngwr_storage from 'ngwr/storage';
+
+/**
+ * Reactive key/value storage on top of any `Storage`-compatible engine.
+ *
+ * - **Swap engines** through {@link WR_STORAGE_ENGINE} or
+ *   {@link provideWrStorage}. Default: `localStorage` with an in-memory
+ *   fallback for SSR / private mode.
+ * - **Namespacing** via `prefix` (config) — every key is transparently
+ *   prefixed on read / write.
+ * - **TTL** per-call or default — values past their expiry are removed
+ *   lazily on the next `get` / `watch` read.
+ * - **Reactive watch** — `watch(key)` returns a `Signal` that updates on
+ *   local writes and cross-tab `storage` events.
+ *
+ * SSR-safe: the default engine factory returns an in-memory shim when
+ * `localStorage` is unavailable, so reads always work.
+ *
+ * @example
+ * ```ts
+ * const store = inject(WrStorage);
+ *
+ * store.set('user', { name: 'Ada' });
+ * store.get<{ name: string }>('user');         // { name: 'Ada' }
+ *
+ * store.set('cart', items, { ttl: 60_000 });   // expires in 60s
+ *
+ * const theme = store.watch<'light' | 'dark'>('theme', 'light');
+ * effect(() => console.log('theme is', theme()));
+ * ```
+ *
+ * @see https://ngwr.dev/services/storage
+ */
+declare class WrStorage {
+    private readonly engine;
+    private readonly config;
+    private readonly isBrowser;
+    /** Per-key watchers. Shared so multiple `watch(k)` calls reuse one signal. */
+    private readonly watchers;
+    private listenerInstalled;
+    /** Is `key` present (regardless of value / expiry)? */
+    has(key: string): boolean;
+    /**
+     * Read `key`. Returns `fallback` (default `null`) when the key is
+     * missing or expired. Expired values are also removed as a side effect.
+     */
+    get<T = unknown>(key: string, fallback?: T | null): T | null;
+    /**
+     * Write `value` at `key`. Per-call `ttl` (ms) overrides the config
+     * default. JSON-serializable values only when `json` is on (the default).
+     */
+    set<T = unknown>(key: string, value: T, opts?: {
+        ttl?: number;
+    }): void;
+    /** Remove `key`. No-op when absent. */
+    remove(key: string): void;
+    /**
+     * Clear every key owned by this prefix. When `prefix` is empty this
+     * defers to `engine.clear()` (clears everything — be careful with
+     * shared storage).
+     */
+    clear(): void;
+    /** All known keys under our prefix, with the prefix stripped. */
+    keys(): readonly string[];
+    /**
+     * Reactive read of `key`. Updates when this instance writes to the key,
+     * when `clear()` runs, and when another tab updates `localStorage`
+     * under the same prefix. Returned signal is shared per key — calling
+     * `watch(k)` twice returns the same signal.
+     */
+    watch<T = unknown>(key: string, fallback?: T | null): Signal<T | null>;
+    private fullKey;
+    private notify;
+    private rawKeys;
+    private installCrossTabListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrStorage, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrStorage>;
+}
+
+/**
+ * Storage backend. Anything implementing the native `Storage` interface
+ * works — `localStorage`, `sessionStorage`, a Map-backed shim, an
+ * IndexedDB sync wrapper, an encrypted wrapper, a worker bridge, …
+ */
+type WrStorageEngine = Storage;
+/** {@link WrStorage} configuration. Pass partial — merged with defaults. */
+interface WrStorageConfig {
+    /**
+     * Prefix prepended to every key on read / write. Keeps your app's keys
+     * from colliding with third-party libs sharing the same storage.
+     * @default ''
+     */
+    readonly prefix?: string;
+    /**
+     * Auto JSON-(de)serialize values. Disable to store / read raw strings
+     * verbatim (useful when interop with non-ngwr code).
+     * @default true
+     */
+    readonly json?: boolean;
+    /**
+     * Default TTL in milliseconds applied to every `set()` without a
+     * per-call override. `0` means no expiry.
+     * @default 0
+     */
+    readonly ttl?: number;
+}
+/** Fully-resolved config (all defaults filled). @internal */
+type WrStorageConfigResolved = Required<WrStorageConfig>;
+
+declare const DEFAULT_WR_STORAGE_CONFIG: WrStorageConfigResolved;
+declare const WR_STORAGE_CONFIG: InjectionToken<Required<ngwr_storage.WrStorageConfig>>;
+
+/**
+ * @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
+ */
+
+/**
+ * In-memory implementation of `Storage`. Used as the SSR / private-mode
+ * fallback. Exported so consumers can opt into it explicitly for tests.
+ */
+declare function createMemoryStorage(): WrStorageEngine;
+/**
+ * Injection token for the active storage engine. Override at any
+ * injector level to swap engines (e.g. a feature module uses
+ * `sessionStorage`; the rest uses `localStorage`):
+ *
+ * ```ts
+ * providers: [{ provide: WR_STORAGE_ENGINE, useValue: sessionStorage }]
+ * ```
+ *
+ * The default factory returns `localStorage` in the browser when it's
+ * actually writable, an in-memory map otherwise.
+ */
+declare const WR_STORAGE_ENGINE: InjectionToken<Storage>;
+
+/**
+ * @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
+ */
+
+/**
+ * Configure {@link WrStorage}. All fields optional — merged with defaults.
+ *
+ * @example Override the engine globally (e.g. session storage)
+ * ```ts
+ * provideWrStorage({ engine: sessionStorage })
+ * ```
+ *
+ * @example Lazy engine factory (e.g. wrap localStorage with encryption)
+ * ```ts
+ * provideWrStorage({ engine: () => new EncryptedStorage(localStorage, key) })
+ * ```
+ *
+ * @example Namespace + auto-expire
+ * ```ts
+ * provideWrStorage({ prefix: 'myapp:', ttl: 24 * 60 * 60 * 1000 })
+ * ```
+ */
+interface ProvideWrStorageOptions extends WrStorageConfig {
+    /**
+     * Storage engine. Either an instance (eager) or a factory (lazy —
+     * called inside the injection context the first time `WR_STORAGE_ENGINE`
+     * is read). Defaults to {@link WR_STORAGE_ENGINE}'s factory
+     * (`localStorage` with in-memory fallback).
+     */
+    readonly engine?: WrStorageEngine | (() => WrStorageEngine);
+}
+declare function provideWrStorage(options?: ProvideWrStorageOptions): EnvironmentProviders;
+
+export { DEFAULT_WR_STORAGE_CONFIG, WR_STORAGE_CONFIG, WR_STORAGE_ENGINE, WrStorage, createMemoryStorage, provideWrStorage };
+export type { ProvideWrStorageOptions, WrStorageConfig, WrStorageConfigResolved, WrStorageEngine };

package/types/ngwr-switch.d.ts

@@ -0,0 +1,39 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+/**
+ * Boolean toggle with an iOS-style slider. Implements `ControlValueAccessor`.
+ *
+ * @example
+ * ```html
+ * <wr-switch [(ngModel)]="enabled">Notifications</wr-switch>
+ * ```
+ *
+ * @see https://ngwr.dev/components/switch
+ */
+declare class WrSwitch implements ControlValueAccessor {
+    /** Stable id used to associate the native input with its label. */
+    readonly id: _angular_core.InputSignal<string>;
+    /**
+     * Disable the switch. Also set by Angular forms via `setDisabledState`.
+     *
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly checked: _angular_core.WritableSignal<boolean>;
+    private readonly disabledFromCva;
+    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<WrSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrSwitch, "wr-switch", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WrSwitch };