ngwr 6.0.0 → 7.0.0

package/types/ngwr-date-adapter.d.ts

@@ -0,0 +1,198 @@
+import * as i0 from '@angular/core';
+import { Type, EnvironmentProviders, InjectionToken } 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
+ */
+/**
+ * Named format keys recognised by every {@link WrDateAdapter}. Adapters map
+ * each key to their preferred locale-aware implementation (the native adapter
+ * uses `Intl.DateTimeFormat`; a `date-fns` adapter would use its own tokens).
+ *
+ * `format()` / `parse()` also accept raw format strings — see the adapter's
+ * implementation for the supported tokens (`yyyy`, `MM`, `dd`, `HH`, …).
+ */
+type WrDateFormat = 'shortDate' | 'mediumDate' | 'longDate' | 'time' | 'shortDateTime' | 'mediumDateTime';
+
+/**
+ * Options for {@link provideWrDateAdapter}.
+ */
+interface WrDateAdapterOptions {
+    /**
+     * Adapter class. Default: {@link WrNativeDateAdapter}.
+     *
+     * Pass a custom subclass to swap implementations (`WrDateFnsAdapter`,
+     * `WrLuxonAdapter`, …).
+     */
+    readonly adapter?: Type<WrDateAdapter<unknown>>;
+    /**
+     * BCP 47 locale tag (`'en-US'`, `'ru-RU'`, …). Default: `navigator.language`
+     * in the browser, `'en-US'` on the server.
+     */
+    readonly locale?: string;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Abstraction over a date object so the calendar, date picker and time picker
+ * can work with `Date`, `date-fns`, `luxon`, or any other library a consumer
+ * prefers — without changing component code.
+ *
+ * Default implementation: {@link WrNativeDateAdapter} (native `Date`,
+ * `Intl.DateTimeFormat`). Register a different adapter via
+ * `provideWrDateAdapter({ adapter: MyAdapter })`.
+ *
+ * Used as both the type and the DI token — `inject(WrDateAdapter)` works
+ * directly thanks to Angular's class-as-token resolution.
+ *
+ * Every "mutating" method (`addX`, `setTime`) returns a **new** value;
+ * adapters never mutate in place so consumers can pass dates around safely.
+ */
+declare abstract class WrDateAdapter<TDate = Date> {
+    /** Current moment. */
+    abstract today(): TDate;
+    /** Defensive clone — must return an independent value, never the same reference. */
+    abstract clone(date: TDate): TDate;
+    /** Build a date from year / month (0-based) / day. */
+    abstract createDate(year: number, month: number, day: number): TDate;
+    /** `false` for `NaN` / invalid input. */
+    abstract isValid(date: TDate): boolean;
+    abstract getYear(date: TDate): number;
+    /** `0` (January) – `11` (December). */
+    abstract getMonth(date: TDate): number;
+    /** Day of the month, `1`-`31`. */
+    abstract getDate(date: TDate): number;
+    /** `0` (Sunday) – `6` (Saturday). */
+    abstract getDayOfWeek(date: TDate): number;
+    abstract getDaysInMonth(date: TDate): number;
+    abstract getHours(date: TDate): number;
+    abstract getMinutes(date: TDate): number;
+    abstract getSeconds(date: TDate): number;
+    abstract addYears(date: TDate, amount: number): TDate;
+    abstract addMonths(date: TDate, amount: number): TDate;
+    abstract addDays(date: TDate, amount: number): TDate;
+    /** Returns a new date with the time portion replaced. */
+    abstract setTime(date: TDate, hours: number, minutes: number, seconds: number): TDate;
+    abstract isSameDay(a: TDate, b: TDate): boolean;
+    abstract isSameMonth(a: TDate, b: TDate): boolean;
+    /** Negative if `a < b`, positive if `a > b`, zero if equal (compared at day precision). */
+    abstract compareDate(a: TDate, b: TDate): number;
+    /**
+     * Convenience used by the calendar's range UI. Inclusive on both ends.
+     * Implementation can stay on the base class because it delegates to
+     * `compareDate`.
+     */
+    isWithinRange(date: TDate, start: TDate, end: TDate): boolean;
+    /**
+     * Format a date. Accepts either a named {@link WrDateFormat} key (which the
+     * adapter resolves locale-aware) or a raw format string (`'dd.MM.yyyy'`).
+     *
+     * Supported tokens for raw strings: `yyyy`, `yy`, `MMMM`, `MMM`, `MM`, `M`,
+     * `dd`, `d`, `HH`, `H`, `hh`, `h`, `mm`, `ss`, `a` (am / pm).
+     */
+    abstract format(date: TDate, formatKeyOrString: WrDateFormat | (string & {})): string;
+    /**
+     * Parse a string into a date. Returns `null` when parsing fails. Accepts
+     * the same `formatKeyOrString` set as {@link format}.
+     */
+    abstract parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): TDate | null;
+    /** `0` Sunday, `1` Monday — locale-dependent. */
+    abstract getFirstDayOfWeek(): number;
+    /** Names ordered from `getFirstDayOfWeek()` onwards. Length 7. */
+    abstract getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    /** Names from January (index `0`) to December (`11`). Length 12. */
+    abstract getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+}
+
+/** Whether `value` is one of the shared named format keys. */
+declare function isNamedFormat(value: string): value is WrDateFormat;
+/**
+ * Reference {@link WrDateAdapter} implementation backed by the native `Date`
+ * object and `Intl.DateTimeFormat`. Zero external dependencies. Suitable for
+ * most apps — swap to a `date-fns` / `luxon` adapter only when you need
+ * timezone-aware math or richer parsing.
+ */
+declare class WrNativeDateAdapter extends WrDateAdapter<Date> {
+    private readonly locale;
+    today(): Date;
+    clone(date: Date): Date;
+    createDate(year: number, month: number, day: number): Date;
+    isValid(date: Date): boolean;
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    getDaysInMonth(date: Date): number;
+    getHours(date: Date): number;
+    getMinutes(date: Date): number;
+    getSeconds(date: Date): number;
+    addYears(date: Date, amount: number): Date;
+    addMonths(date: Date, amount: number): Date;
+    addDays(date: Date, amount: number): Date;
+    setTime(date: Date, hours: number, minutes: number, seconds: number): Date;
+    isSameDay(a: Date, b: Date): boolean;
+    isSameMonth(a: Date, b: Date): boolean;
+    compareDate(a: Date, b: Date): number;
+    format(date: Date, formatKeyOrString: WrDateFormat | (string & {})): string;
+    parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): Date | null;
+    getFirstDayOfWeek(): number;
+    getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    private formatWithTokens;
+    private parseWithTokens;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrNativeDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrNativeDateAdapter>;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Register the date adapter and locale used by the calendar / date picker /
+ * time picker. Call once at bootstrap.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideWrDateAdapter(),                 // native, browser locale
+ *     // provideWrDateAdapter({ locale: 'ru-RU' }),
+ *     // provideWrDateAdapter({ adapter: MyDateFnsAdapter, locale: 'fr' }),
+ *   ],
+ * });
+ * ```
+ */
+declare function provideWrDateAdapter(options?: WrDateAdapterOptions): EnvironmentProviders;
+
+/**
+ * @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
+ */
+
+/**
+ * BCP 47 locale tag used by {@link WrDateAdapter} implementations for
+ * formatting, parsing, and locale-derived defaults (first day of week,
+ * month / day names). Defaults to `navigator.language` in the browser and
+ * `'en-US'` on the server.
+ *
+ * Override via {@link provideWrDateAdapter}'s `locale` option.
+ */
+declare const WR_DATE_LOCALE: InjectionToken<string>;
+
+export { WR_DATE_LOCALE, WrDateAdapter, WrNativeDateAdapter, isNamedFormat, provideWrDateAdapter };
+export type { WrDateAdapterOptions, WrDateFormat };

package/types/ngwr-date-picker.d.ts

@@ -0,0 +1,117 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { WrDateFormat } from 'ngwr/date-adapter';
+
+/**
+ * Unified date / time / date-time picker. Same `<input>` + popover skeleton
+ * for every mode — the overlay content swaps based on `[mode]`:
+ *
+ * - `'date'` (default) — popover renders a calendar. Picking a date closes
+ *   the overlay.
+ * - `'time'` — popover renders an `HH:MM[:SS]` stepper with optional AM/PM.
+ *   Stays open while editing; close with outside-click or Escape.
+ * - `'datetime'` — popover stacks calendar + time stepper. Picking a date
+ *   does NOT close (the user typically wants to set the time next).
+ *
+ * Implements `ControlValueAccessor` — bind via `[(ngModel)]`, `[formControl]`,
+ * or `formControlName`. Value type is `Date | null` for every mode.
+ *
+ * Parses the input on every keystroke (silently — only emits when valid) and
+ * re-formats canonical on blur. Format is driven by {@link WrDateAdapter}: it
+ * accepts both named keys (`'shortDate'`, `'mediumDateTime'`, …) and raw
+ * token strings (`'dd.MM.yyyy'`, `'HH:mm'`). When `format` is left at the
+ * default (`null`), the picker derives the right named key from `mode`:
+ * `'date'` → `'shortDate'`, `'time'` → `'shortTime'`, `'datetime'` →
+ * `'shortDateTime'`.
+ *
+ * @example
+ * ```html
+ * <!-- Date only -->
+ * <wr-date-picker [(ngModel)]="picked" format="dd.MM.yyyy" [min]="minDate" />
+ *
+ * <!-- Time only -->
+ * <wr-date-picker mode="time" [(ngModel)]="picked" timeFormat="24h" />
+ *
+ * <!-- Date + time -->
+ * <wr-date-picker mode="datetime" [(ngModel)]="when" [showSeconds]="true" [step]="5" />
+ * ```
+ *
+ * @see https://ngwr.dev/components/date-picker
+ */
+declare class WrDatePicker implements ControlValueAccessor {
+    /** Picker behavior — see class doc. @default 'date' */
+    readonly mode: _angular_core.InputSignal<"time" | "date" | "datetime">;
+    /**
+     * Format used for both display and parsing. When `null` (default), the
+     * format is derived from `mode` (`shortDate` / `shortTime` /
+     * `shortDateTime`). Pass a named key or raw token string to override.
+     */
+    readonly format: _angular_core.InputSignal<WrDateFormat | (string & {}) | null>;
+    /** Placeholder shown when the input is empty. */
+    readonly placeholder: _angular_core.InputSignal<string>;
+    /** Min selectable date (forwarded to the calendar). Ignored in `time` mode. */
+    readonly min: _angular_core.InputSignal<Date | null>;
+    /** Max selectable date (forwarded to the calendar). Ignored in `time` mode. */
+    readonly max: _angular_core.InputSignal<Date | null>;
+    /** Predicate to disable specific dates (forwarded to the calendar). Ignored in `time` mode. */
+    readonly dateFilter: _angular_core.InputSignal<((date: Date) => boolean) | null>;
+    /** Time-panel 12 / 24-hour format. Applies in `time` + `datetime` modes. @default 'auto' */
+    readonly timeFormat: _angular_core.InputSignal<"auto" | "12h" | "24h">;
+    /** Render the seconds column. Applies in `time` + `datetime` modes. @default false */
+    readonly showSeconds: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Minute / second step for the time panel. @default 1 */
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Disable interaction. @default false */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Read-only — input not typeable, but the trigger icon still opens the overlay. @default false */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, any>;
+    private readonly adapter;
+    private readonly overlay;
+    private readonly scrollStrategies;
+    private readonly host;
+    private readonly destroyRef;
+    protected readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement>>;
+    /** The picked Date. Mirrored from the CVA. */
+    protected readonly value: _angular_core.WritableSignal<Date | null>;
+    /** Text currently in the input (may be partial / invalid mid-type). */
+    protected readonly text: _angular_core.WritableSignal<string>;
+    private readonly disabledFromCva;
+    protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    /** Whether the popover is currently open. */
+    protected readonly overlayOpen: _angular_core.WritableSignal<boolean>;
+    /** Resolved format — falls back to a mode-appropriate default. */
+    protected readonly resolvedFormat: _angular_core.Signal<string>;
+    protected readonly isTime: _angular_core.Signal<boolean>;
+    protected readonly isDateTime: _angular_core.Signal<boolean>;
+    private readonly labelDate;
+    private readonly labelTime;
+    private readonly labelDateTime;
+    protected readonly triggerLabel: _angular_core.Signal<string>;
+    protected readonly classes: _angular_core.Signal<string>;
+    private overlayRef;
+    constructor();
+    private onChange;
+    private onTouched;
+    writeValue(value: Date | null): void;
+    registerOnChange(fn: (value: Date | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onInput(event: Event): void;
+    protected onBlur(): void;
+    /** Called by the input's click — opens the overlay if it isn't open already. */
+    protected openOnInput(): void;
+    protected toggleOverlay(): void;
+    private openOverlay;
+    private attachDate;
+    private attachTime;
+    private attachDateTime;
+    private commit;
+    private closeOverlay;
+    private dispose;
+    private isOutOfBounds;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDatePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDatePicker, "wr-date-picker", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "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; }; "timeFormat": { "alias": "timeFormat"; "required": false; "isSignal": true; }; "showSeconds": { "alias": "showSeconds"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrDatePicker };

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

@@ -0,0 +1,85 @@
+import * as _angular_core from '@angular/core';
+
+type WrDecryptTextAnimateOn = 'hover' | 'click' | 'view' | 'inViewHover';
+type WrDecryptTextRevealDirection = 'start' | 'end' | 'center';
+type WrDecryptTextClickMode = 'once' | 'toggle';
+
+/**
+ * Reveals a string by scrambling characters and progressively replacing
+ * scramble glyphs with the originals. Supports sequential reveal in
+ * three directions, or non-sequential "settle" after N iterations, and
+ * four trigger modes (hover, click, view, in-view + hover).
+ *
+ * @example
+ * ```html
+ * <wr-decrypt-text text="Hello, ngwr!" animateOn="hover" />
+ * <wr-decrypt-text
+ *   text="Reveal from the center"
+ *   [sequential]="true"
+ *   revealDirection="center"
+ *   animateOn="view"
+ * />
+ * ```
+ *
+ * @see https://www.reactbits.dev/text-animations/decrypted-text
+ */
+declare class WrDecryptText {
+    /** Text to reveal. Required. */
+    readonly text: _angular_core.InputSignal<string>;
+    /** Tick interval in ms. @default 50 */
+    readonly speed: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Non-sequential mode only — total scramble ticks before snapping to plain. @default 10 */
+    readonly maxIterations: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Reveal one char per tick instead of scrambling all of them. @default false */
+    readonly sequential: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Order in which chars are revealed in sequential mode. @default 'start' */
+    readonly revealDirection: _angular_core.InputSignal<WrDecryptTextRevealDirection>;
+    /** Scramble using only the glyphs present in `text` (minus spaces). @default false */
+    readonly useOriginalCharsOnly: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Pool of glyphs to scramble through (used when `useOriginalCharsOnly` is false). */
+    readonly characters: _angular_core.InputSignal<string>;
+    /** When to start the animation. @default 'hover' */
+    readonly animateOn: _angular_core.InputSignal<WrDecryptTextAnimateOn>;
+    /** Click behaviour. `'once'` decrypts then stops; `'toggle'` flips state on each click. @default 'once' */
+    readonly clickMode: _angular_core.InputSignal<WrDecryptTextClickMode>;
+    private readonly displayText;
+    private readonly revealedIndices;
+    private readonly isAnimating;
+    private readonly isDecrypted;
+    private readonly direction;
+    /** Per-char render data. */
+    protected readonly chars: _angular_core.Signal<{
+        ch: string;
+        revealed: boolean;
+    }[]>;
+    /** Sequential reverse order — captured when reverse starts. */
+    private reverseOrder;
+    private reversePointer;
+    private iterationCount;
+    private intervalId;
+    private hasAnimatedOnce;
+    private readonly host;
+    private readonly destroyRef;
+    private readonly isBrowser;
+    private readonly platform;
+    constructor();
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    protected onClick(): void;
+    private setupIntersectionObserver;
+    private triggerHoverDecrypt;
+    private resetToPlain;
+    private triggerDecrypt;
+    private triggerReverse;
+    private encryptInstantly;
+    private startInterval;
+    private stopInterval;
+    private tick;
+    private nextSequentialIndex;
+    private shuffle;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDecryptText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDecryptText, "wr-decrypt-text", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "speed": { "alias": "speed"; "required": false; "isSignal": true; }; "maxIterations": { "alias": "maxIterations"; "required": false; "isSignal": true; }; "sequential": { "alias": "sequential"; "required": false; "isSignal": true; }; "revealDirection": { "alias": "revealDirection"; "required": false; "isSignal": true; }; "useOriginalCharsOnly": { "alias": "useOriginalCharsOnly"; "required": false; "isSignal": true; }; "characters": { "alias": "characters"; "required": false; "isSignal": true; }; "animateOn": { "alias": "animateOn"; "required": false; "isSignal": true; }; "clickMode": { "alias": "clickMode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { WrDecryptText };
+export type { WrDecryptTextAnimateOn, WrDecryptTextClickMode, WrDecryptTextRevealDirection };

package/types/ngwr-density.d.ts

@@ -0,0 +1,97 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Signal, EnvironmentProviders } from '@angular/core';
+
+/** Density scale. Components multiply their paddings by the matching multiplier. */
+type WrDensityValue = 'compact' | 'default' | 'comfortable';
+/** Configuration for {@link WrDensityValueService}. */
+interface WrDensityConfig {
+    /** Initial density used when no persisted value is present. @default 'default' */
+    readonly defaultDensity: WrDensityValue;
+    /** Storage key for persistence (via `WrStorage`). Set to `null` to disable. @default 'wr-density' */
+    readonly storageKey: string | null;
+    /** Attribute written to `<html>` to expose the active density. @default 'data-wr-density' */
+    readonly attribute: string;
+}
+
+/**
+ * @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
+ */
+
+declare const DEFAULT_WR_DENSITY_CONFIG: WrDensityConfig;
+declare const WR_DENSITY_CONFIG: InjectionToken<WrDensityConfig>;
+
+/**
+ * Global density scale. Writes `[data-wr-density]` on `<html>` so the
+ * stylesheet's density-scoped CSS-variable rules apply, then components
+ * pick up the new multipliers without re-rendering.
+ *
+ * - **Per-subtree override** — drop `[wrDensity]` on any element; its
+ *   descendants read the override instead of the global value.
+ * - **Persisted** via {@link WrStorage} (swap the engine globally if you
+ *   need a different store).
+ *
+ * @example
+ * ```ts
+ * const density = inject(WrDensity);
+ * density.set('compact');
+ * density.current();   // 'compact'
+ * ```
+ *
+ * @see https://ngwr.dev/services/density
+ */
+declare class WrDensity {
+    private readonly doc;
+    private readonly storage;
+    private readonly config;
+    /** Active density. */
+    readonly current: Signal<WrDensityValue>;
+    private readonly _current;
+    constructor();
+    /** Switch the active density. Ignores unknown values. */
+    set(density: WrDensityValue): void;
+    /** Cycle compact → default → comfortable → compact … */
+    cycle(): void;
+    private readPersisted;
+    private persist;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDensity, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrDensity>;
+}
+
+/**
+ * Scope a density override to a subtree. Writes the same `data-*`
+ * attribute the global service writes — but on the host instead of
+ * `<html>` — so the CSS-variable scope rules cascade only to descendants.
+ *
+ * @example
+ * ```html
+ * <!-- The whole sidebar is compact, the rest of the app keeps its global density. -->
+ * <aside wrDensity="compact">
+ *   <wr-list ...></wr-list>
+ * </aside>
+ * ```
+ */
+declare class WrDensityDirective {
+    /** Density to apply to this subtree. */
+    readonly wrDensity: i0.InputSignal<WrDensityValue>;
+    private readonly host;
+    private readonly config;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDensityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDensityDirective, "[wrDensity]", never, { "wrDensity": { "alias": "wrDensity"; "required": true; "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
+ */
+
+/** Configure {@link WrDensity}. All fields optional — merged with defaults. */
+declare function provideWrDensity(config?: Partial<WrDensityConfig>): EnvironmentProviders;
+
+export { DEFAULT_WR_DENSITY_CONFIG, WR_DENSITY_CONFIG, WrDensity, WrDensityDirective, provideWrDensity };
+export type { WrDensityConfig, WrDensityValue };

package/types/ngwr-descriptions.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Read-only labeled key / value list. Project `<wr-description-item>`
+ * children. `title` is optional. Default layout stacks vertically; set
+ * `[inline]="true"` for label-left / value-right rows.
+ *
+ * @example
+ * ```html
+ * <wr-descriptions title="Account" inline>
+ *   <wr-description-item label="Name">Ada Lovelace</wr-description-item>
+ *   <wr-description-item label="Email">ada@example.com</wr-description-item>
+ *   <wr-description-item label="Joined">2024-03-12</wr-description-item>
+ * </wr-descriptions>
+ * ```
+ *
+ * @see https://ngwr.dev/components/descriptions
+ */
+declare class WrDescriptions {
+    /** Optional title shown above the list. */
+    readonly title: _angular_core.InputSignal<string>;
+    /** Two-column rows (label left, value right) instead of stacked. @default false */
+    readonly inline: _angular_core.InputSignalWithTransform<boolean, any>;
+    /** Add visible borders around each row. @default false */
+    readonly bordered: _angular_core.InputSignalWithTransform<boolean, any>;
+    protected readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDescriptions, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDescriptions, "wr-descriptions", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "inline": { "alias": "inline"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * One row in a {@link WrDescriptions}. The label comes from the
+ * `label` input; the value is the projected content.
+ */
+declare class WrDescriptionItem {
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrDescriptionItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrDescriptionItem, "wr-description-item", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { WrDescriptionItem, WrDescriptions };