ngwr 13.0.1 → 14.0.0

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

@@ -1,83 +1,6 @@
 import { WrCalendarDayHarness } from 'ngwr/calendar/testing';
 export { WrCalendarDayHarness as WrDatePickerDayHarness } from 'ngwr/calendar/testing';
-import { BaseHarnessFilters, ComponentHarness, TestElement, HarnessLoader, HarnessPredicate } from '@angular/cdk/testing';
-
-/**
- * @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
- */
-
-/** Narrows which `<wr-date-picker>` a harness query matches. */
-interface WrDatePickerHarnessFilters extends BaseHarnessFilters {
-    /**
-     * Match the text the field is showing — the formatted value, or `''` when the
-     * picker is empty and the placeholder is up. A string is an exact match, a
-     * RegExp is tested.
-     */
-    readonly text?: string | RegExp;
-    /** Match the field's placeholder — a string is an exact match, a RegExp is tested. */
-    readonly placeholder?: string | RegExp;
-    /** Match one mode only. */
-    readonly mode?: 'date' | 'time' | 'datetime';
-    /** Match only enabled (`false`) or only disabled (`true`) pickers. */
-    readonly disabled?: boolean;
-    /** Match only pickers whose popup is up (`true`) or down (`false`). */
-    readonly open?: boolean;
-}
-/** Narrows which `<wr-date-range-picker>` a harness query matches. */
-interface WrDateRangePickerHarnessFilters extends BaseHarnessFilters {
-    /** Match the text in the START field. A string is an exact match, a RegExp is tested. */
-    readonly startText?: string | RegExp;
-    /** Match the text in the END field. A string is an exact match, a RegExp is tested. */
-    readonly endText?: string | RegExp;
-    /** Match one mode only. The range picker has no `time` mode. */
-    readonly mode?: 'date' | 'datetime';
-    /** Match only enabled (`false`) or only disabled (`true`) pickers. */
-    readonly disabled?: boolean;
-    /** Match only pickers whose popup is up (`true`) or down (`false`). */
-    readonly open?: boolean;
-}
-/** Narrows which day cell inside a picker's calendar a harness query matches. */
-interface WrDatePickerDayHarnessFilters extends BaseHarnessFilters {
-    /**
-     * Match the cell's day number as rendered (`'1'` … `'31'`). A string is an
-     * exact match, a RegExp is tested — note the grid spills into the neighbouring
-     * months, so a number appears twice on most months.
-     */
-    readonly text?: string | RegExp;
-    /** Match only selected (`true`) or only unselected (`false`) cells. */
-    readonly selected?: boolean;
-    /** Match only enabled (`false`) or only disabled (`true`) cells. */
-    readonly disabled?: boolean;
-    /**
-     * Match cells strictly BETWEEN the two ends of a picked range — the ends
-     * themselves are `selected`, not `inRange`. Always `false` for
-     * `<wr-date-picker>`, whose calendar has a single value.
-     */
-    readonly inRange?: boolean;
-}
-
-/**
- * @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
- */
-/**
- * Which boxes of a time stepper to type into. Omitted fields are left alone, so
- * `{ minutes: 45 }` changes the minutes and nothing else.
- *
- * Hours are given the way the stepper SHOWS them: 0-23 for a 24-hour panel,
- * 1-12 for a 12-hour one (where AM/PM stays where it was — flip it with
- * `toggleMeridiem()`).
- */
-interface WrDatePickerTimeFields {
-    readonly hours?: number;
-    readonly minutes?: number;
-    readonly seconds?: number;
-}
+import { ComponentHarness, TestElement, HarnessLoader, HarnessPredicate, BaseHarnessFilters } from '@angular/cdk/testing';
 
 /**
  * @license
@@ -155,8 +78,16 @@ declare class WrTimePanelHarness extends ComponentHarness {
  * their popup's id through the trigger's `aria-controls`, so the scoping story is
  * shared too.
  *
- * Not exported from the entry point — a consumer works with one of the two
- * concrete harnesses.
+ * **Deliberately not exported, and `WrAnyDatePickerHarness` is what replaces it.**
+ * The reason a consumer wanted this name was to write a helper taking "either
+ * picker", which the union in `interfaces/` says directly and without publishing
+ * anything else. Exporting the class instead would publish the `protected` members
+ * below as a subclassing contract — including `timePanels()`, which hands back the
+ * harness for `<wr-time-panel>`, a component this package does not ship as public
+ * API. A type-only re-export is not the middle ground it looks like: the base is a
+ * value in two `extends` clauses, so d.ts flattening promotes `export type` back to
+ * a value export while the FESM bundle exports nothing — an import that type-checks
+ * and is `undefined` at runtime.
  *
  * @internal
  */
@@ -258,6 +189,200 @@ declare abstract class WrDatePickerHarnessBase extends ComponentHarness {
     private noCalendar;
 }
 
+/**
+ * @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
+ */
+
+/**
+ * Test harness for `<wr-date-range-picker>` — two text fields over one range
+ * calendar.
+ *
+ * A separate harness rather than a mode of {@link WrDatePickerHarness}, because
+ * the DOM a spec has to reach is genuinely different: two fields with a separator
+ * between them, and in `datetime` mode two time steppers instead of one. Every
+ * call that could mean either field takes an explicit `'start'` / `'end'` — the
+ * component's own bugs were nearly all "which end did that belong to", and a
+ * harness that guessed would reproduce them.
+ *
+ * The popup, the calendar and the scoping work exactly as they do for the single
+ * picker: a pane in the overlay container, addressed by the id the trigger
+ * publishes as `aria-controls`.
+ *
+ * @example
+ * ```ts
+ * const period = await loader.getHarness(WrDateRangePickerHarness);
+ *
+ * await period.open();
+ * await period.selectDay(14);
+ * await period.selectDay(20);
+ *
+ * expect([await period.getStartText(), await period.getEndText()]).toEqual(['14.01.2025', '20.01.2025']);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDateRangePickerHarness extends WrDatePickerHarnessBase {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrDateRangePickerHarnessFilters): HarnessPredicate<WrDateRangePickerHarness>;
+    protected readonly harnessName = "WrDateRangePickerHarness";
+    /** Which mode the picker is in, read from the `wr-date-range-picker--*` modifier. */
+    getMode(): Promise<'date' | 'datetime'>;
+    /** What the start field is showing — `''` while that end is unpicked. */
+    getStartText(): Promise<string>;
+    /** What the end field is showing — `''` while that end is unpicked. */
+    getEndText(): Promise<string>;
+    /** The glyph rendered between the two fields (`[separator]`, `'–'` by default). */
+    getSeparator(): Promise<string>;
+    /** The placeholder of one field. */
+    getPlaceholder(end: WrDateRangePickerEnd): Promise<string>;
+    /**
+     * Type a date into the start field, replacing whatever is there.
+     *
+     * Ends typed out of order are NOT swapped here — the component settles the
+     * ordering when the interaction is over, so call {@link blur} (or close the
+     * popup) to see a normalised range.
+     */
+    setStartText(text: string): Promise<void>;
+    /** Type a date into the end field — see {@link setStartText} on ordering. */
+    setEndText(text: string): Promise<void>;
+    /** Empty both fields, which clears the range. Neither end has a clear button. */
+    clear(): Promise<void>;
+    /** Whether the picker refuses interaction. */
+    isDisabled(): Promise<boolean>;
+    /**
+     * Whether the fields refuse typing. Stricter than `<wr-date-picker>`: a
+     * read-only range picker also refuses to open, since two fields over one
+     * calendar leaves no reading of "untypeable" that still lets the grid rewrite
+     * both ends.
+     */
+    isReadonly(): Promise<boolean>;
+    /** Move focus to one field. */
+    focus(end: WrDateRangePickerEnd): Promise<void>;
+    /**
+     * Blur one field. This is the moment an out-of-order range is put back in
+     * order, and — when focus leaves the control rather than hopping to the other
+     * end — the moment `touch` is emitted.
+     */
+    blur(end: WrDateRangePickerEnd): Promise<void>;
+    /** Whether one field currently has focus. */
+    isFocused(end: WrDateRangePickerEnd): Promise<boolean>;
+    /**
+     * One end's time stepper as `HH:MM`, plus `:SS` when `showSeconds` is on and
+     * ` AM`/` PM` in 12-hour mode. `datetime` mode only.
+     */
+    getTime(end: WrDateRangePickerEnd): Promise<string>;
+    /** Type into one end's time stepper. Omitted fields are left alone. */
+    setTime(end: WrDateRangePickerEnd, fields: WrDatePickerTimeFields): Promise<void>;
+    /** Click one of an end's ▲ / ▼ buttons. Minutes and seconds move by `step`. */
+    stepTime(end: WrDateRangePickerEnd, unit: 'hours' | 'minutes' | 'seconds', direction: 1 | -1): Promise<void>;
+    /** Flip one end between AM and PM. Throws in 24-hour mode, which has no such control. */
+    toggleMeridiem(end: WrDateRangePickerEnd): Promise<void>;
+    private type;
+    /** The two fields are addressed by position, which is the order they render in. */
+    private field;
+    /**
+     * One end's stepper. Both are mounted together in `datetime` mode, start first —
+     * the group labels are localized, so position is the addressable thing.
+     */
+    private timePanel;
+}
+
+/**
+ * @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
+ */
+
+/**
+ * Either picker harness, for a consumer's own helper that does not care which —
+ * `async function pickToday(picker: WrAnyDatePickerHarness)`. Both classes extend
+ * one abstract base, but that base is not exported and is not going to be: it
+ * would publish its `protected` plumbing, and a `<wr-time-panel>` harness for a
+ * component this package keeps internal, as a subclassing contract. A union says
+ * the only part anyone asked for.
+ */
+type WrAnyDatePickerHarness = WrDatePickerHarness | WrDateRangePickerHarness;
+/**
+ * Which end of a range a `WrDateRangePickerHarness` call applies to. Every call
+ * that could mean either field takes one, and it is exported so a consumer's own
+ * helper can forward it rather than re-declaring the union.
+ */
+type WrDateRangePickerEnd = 'start' | 'end';
+/** Narrows which `<wr-date-picker>` a harness query matches. */
+interface WrDatePickerHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the text the field is showing — the formatted value, or `''` when the
+     * picker is empty and the placeholder is up. A string is an exact match, a
+     * RegExp is tested.
+     */
+    readonly text?: string | RegExp;
+    /** Match the field's placeholder — a string is an exact match, a RegExp is tested. */
+    readonly placeholder?: string | RegExp;
+    /** Match one mode only. */
+    readonly mode?: 'date' | 'time' | 'datetime';
+    /** Match only enabled (`false`) or only disabled (`true`) pickers. */
+    readonly disabled?: boolean;
+    /** Match only pickers whose popup is up (`true`) or down (`false`). */
+    readonly open?: boolean;
+}
+/** Narrows which `<wr-date-range-picker>` a harness query matches. */
+interface WrDateRangePickerHarnessFilters extends BaseHarnessFilters {
+    /** Match the text in the START field. A string is an exact match, a RegExp is tested. */
+    readonly startText?: string | RegExp;
+    /** Match the text in the END field. A string is an exact match, a RegExp is tested. */
+    readonly endText?: string | RegExp;
+    /** Match one mode only. The range picker has no `time` mode. */
+    readonly mode?: 'date' | 'datetime';
+    /** Match only enabled (`false`) or only disabled (`true`) pickers. */
+    readonly disabled?: boolean;
+    /** Match only pickers whose popup is up (`true`) or down (`false`). */
+    readonly open?: boolean;
+}
+/** Narrows which day cell inside a picker's calendar a harness query matches. */
+interface WrDatePickerDayHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the cell's day number as rendered (`'1'` … `'31'`). A string is an
+     * exact match, a RegExp is tested — note the grid spills into the neighbouring
+     * months, so a number appears twice on most months.
+     */
+    readonly text?: string | RegExp;
+    /** Match only selected (`true`) or only unselected (`false`) cells. */
+    readonly selected?: boolean;
+    /** Match only enabled (`false`) or only disabled (`true`) cells. */
+    readonly disabled?: boolean;
+    /**
+     * Match cells strictly BETWEEN the two ends of a picked range — the ends
+     * themselves are `selected`, not `inRange`. Always `false` for
+     * `<wr-date-picker>`, whose calendar has a single value.
+     */
+    readonly inRange?: boolean;
+}
+
+/**
+ * @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
+ */
+/**
+ * Which boxes of a time stepper to type into. Omitted fields are left alone, so
+ * `{ minutes: 45 }` changes the minutes and nothing else.
+ *
+ * Hours are given the way the stepper SHOWS them: 0-23 for a 24-hour panel,
+ * 1-12 for a 12-hour one (where AM/PM stays where it was — flip it with
+ * `toggleMeridiem()`).
+ */
+interface WrDatePickerTimeFields {
+    readonly hours?: number;
+    readonly minutes?: number;
+    readonly seconds?: number;
+}
+
 /**
  * @license
  *
@@ -355,109 +480,5 @@ declare class WrDatePickerHarness extends WrDatePickerHarnessBase {
     private timePanel;
 }
 
-/**
- * @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
- */
-
-/** Which end of the range a call applies to. */
-type End = 'start' | 'end';
-/**
- * Test harness for `<wr-date-range-picker>` — two text fields over one range
- * calendar.
- *
- * A separate harness rather than a mode of {@link WrDatePickerHarness}, because
- * the DOM a spec has to reach is genuinely different: two fields with a separator
- * between them, and in `datetime` mode two time steppers instead of one. Every
- * call that could mean either field takes an explicit `'start'` / `'end'` — the
- * component's own bugs were nearly all "which end did that belong to", and a
- * harness that guessed would reproduce them.
- *
- * The popup, the calendar and the scoping work exactly as they do for the single
- * picker: a pane in the overlay container, addressed by the id the trigger
- * publishes as `aria-controls`.
- *
- * @example
- * ```ts
- * const period = await loader.getHarness(WrDateRangePickerHarness);
- *
- * await period.open();
- * await period.selectDay(14);
- * await period.selectDay(20);
- *
- * expect([await period.getStartText(), await period.getEndText()]).toEqual(['14.01.2025', '20.01.2025']);
- * ```
- *
- * @see https://ngwr.dev/guides/testing
- */
-declare class WrDateRangePickerHarness extends WrDatePickerHarnessBase {
-    static hostSelector: string;
-    /** Build a predicate that narrows the query. */
-    static with(options?: WrDateRangePickerHarnessFilters): HarnessPredicate<WrDateRangePickerHarness>;
-    protected readonly harnessName = "WrDateRangePickerHarness";
-    /** Which mode the picker is in, read from the `wr-date-range-picker--*` modifier. */
-    getMode(): Promise<'date' | 'datetime'>;
-    /** What the start field is showing — `''` while that end is unpicked. */
-    getStartText(): Promise<string>;
-    /** What the end field is showing — `''` while that end is unpicked. */
-    getEndText(): Promise<string>;
-    /** The glyph rendered between the two fields (`[separator]`, `'–'` by default). */
-    getSeparator(): Promise<string>;
-    /** The placeholder of one field. */
-    getPlaceholder(end: End): Promise<string>;
-    /**
-     * Type a date into the start field, replacing whatever is there.
-     *
-     * Ends typed out of order are NOT swapped here — the component settles the
-     * ordering when the interaction is over, so call {@link blur} (or close the
-     * popup) to see a normalised range.
-     */
-    setStartText(text: string): Promise<void>;
-    /** Type a date into the end field — see {@link setStartText} on ordering. */
-    setEndText(text: string): Promise<void>;
-    /** Empty both fields, which clears the range. Neither end has a clear button. */
-    clear(): Promise<void>;
-    /** Whether the picker refuses interaction. */
-    isDisabled(): Promise<boolean>;
-    /**
-     * Whether the fields refuse typing. Stricter than `<wr-date-picker>`: a
-     * read-only range picker also refuses to open, since two fields over one
-     * calendar leaves no reading of "untypeable" that still lets the grid rewrite
-     * both ends.
-     */
-    isReadonly(): Promise<boolean>;
-    /** Move focus to one field. */
-    focus(end: End): Promise<void>;
-    /**
-     * Blur one field. This is the moment an out-of-order range is put back in
-     * order, and — when focus leaves the control rather than hopping to the other
-     * end — the moment `touch` is emitted.
-     */
-    blur(end: End): Promise<void>;
-    /** Whether one field currently has focus. */
-    isFocused(end: End): Promise<boolean>;
-    /**
-     * One end's time stepper as `HH:MM`, plus `:SS` when `showSeconds` is on and
-     * ` AM`/` PM` in 12-hour mode. `datetime` mode only.
-     */
-    getTime(end: End): Promise<string>;
-    /** Type into one end's time stepper. Omitted fields are left alone. */
-    setTime(end: End, fields: WrDatePickerTimeFields): Promise<void>;
-    /** Click one of an end's ▲ / ▼ buttons. Minutes and seconds move by `step`. */
-    stepTime(end: End, unit: 'hours' | 'minutes' | 'seconds', direction: 1 | -1): Promise<void>;
-    /** Flip one end between AM and PM. Throws in 24-hour mode, which has no such control. */
-    toggleMeridiem(end: End): Promise<void>;
-    private type;
-    /** The two fields are addressed by position, which is the order they render in. */
-    private field;
-    /**
-     * One end's stepper. Both are mounted together in `datetime` mode, start first —
-     * the group labels are localized, so position is the addressable thing.
-     */
-    private timePanel;
-}
-
 export { WrDatePickerHarness, WrDateRangePickerHarness };
-export type { WrDatePickerDayHarnessFilters, WrDatePickerHarnessFilters, WrDatePickerTimeFields, WrDateRangePickerHarnessFilters };
+export type { WrAnyDatePickerHarness, WrDatePickerDayHarnessFilters, WrDatePickerHarnessFilters, WrDatePickerTimeFields, WrDateRangePickerEnd, WrDateRangePickerHarnessFilters };

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

@@ -149,6 +149,13 @@ declare class WrDatePicker implements FormValueControl<Date | null> {
     private lastFormat;
     constructor();
     protected onInput(event: Event): void;
+    /**
+     * In `time` mode the typed string carries no date, so the adapter fills one in — and
+     * the date already in the model is the better answer than whatever default it picks.
+     * The time PANEL has always worked this way (it keeps a `basis` date across edits);
+     * the text field silently moved the value to another day.
+     */
+    private withKeptDate;
     protected onBlur(): void;
     /** Called by the input's click — opens the overlay if it isn't open already. */
     protected openOnInput(): void;

package/types/ngwr-date.d.ts

@@ -97,12 +97,24 @@ declare abstract class WrDateAdapter<TDate = Date> {
      * 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).
+     * `dd`, `d`, `HH`, `H`, `hh`, `h`, `mm`, `ss`, `a` (the locale's day-period
+     * marker — `PM`, `م`, `午後`).
+     *
+     * `MMMM` / `MMM` take the form the language uses in the position the pattern
+     * puts them: beside a day token a case language declines the month (ru writes
+     * `15 марта`, not `15 март`), and on their own they stay nominative, which is
+     * what a calendar heading wants.
      */
     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}.
+     *
+     * **The round trip is a contract, not an aspiration**: whatever {@link format}
+     * writes for a given key, `parse` reads back to the same date. A caller relies
+     * on it every keystroke — the picker re-parses what it printed — and returning
+     * `null` is how an adapter refuses, which leaves the caller's committed value
+     * exactly as it was.
      */
     abstract parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): TDate | null;
     /** `0` Sunday, `1` Monday — locale-dependent. */
@@ -143,6 +155,22 @@ declare class WrNativeDateAdapter extends WrDateAdapter<Date> {
     isSameMonth(a: Date, b: Date): boolean;
     compareDate(a: Date, b: Date): number;
     format(date: Date, formatKeyOrString: WrDateFormat | (string & {})): string;
+    /**
+     * Read back what {@link format} wrote.
+     *
+     * A named format used to delegate to `new Date(raw)`, which understands only
+     * Anglo-American forms — so the field could not read its own output anywhere else.
+     * `new Date('15.3.2026')` and `new Date('14:30')` are both `Invalid Date`, while
+     * `new Date('1')` is 1 January 2001: retyping a de-DE date committed the year 2001 on
+     * the first keystroke and then refused every one after it, and `mode="time"` collapsed
+     * to midnight in EVERY locale, en-US included. The named branch now builds its parser
+     * from the SAME `Intl.DateTimeFormat` that printed the string, so the round trip holds
+     * by construction rather than by luck.
+     *
+     * Returns `null` rather than a guess whenever the string does not match — the caller's
+     * committed value is then left exactly as it was, which is the contract
+     * `wr-input-number` follows for unparseable text.
+     */
     parse(value: string, formatKeyOrString: WrDateFormat | (string & {})): Date | null;
     getFirstDayOfWeek(): number;
     /**
@@ -156,11 +184,93 @@ declare class WrNativeDateAdapter extends WrDateAdapter<Date> {
      * can be this simple.
      */
     private readonly formatters;
+    /**
+     * Every `Intl` call this adapter makes pins `calendar: 'gregory'`, and that is a
+     * correctness fix rather than a preference.
+     *
+     * The value type is a JS `Date`, every accessor on this class (`getYear`,
+     * `getMonth`, `getDate`) is Gregorian, `createDate` builds a Gregorian date and the
+     * calendar grid draws Gregorian months. A locale whose DEFAULT calendar is something
+     * else — `fa-IR` resolves to `persian`, `th-TH` to `buddhist`, `ar-SA` to
+     * `islamic-umalqura` in several engines — printed a field the grid beside it could
+     * never agree with (`۱۴۰۴/۱۲/۲۴` over a grid headed 2026), and no parser can turn
+     * that back into the `Date` it came from. Pinning the calendar makes format and parse
+     * describe the same one.
+     */
+    private intlOptions;
     private intl;
     getDayOfWeekNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    /**
+     * Month names in the STANDALONE (nominative) form — what a calendar heading wants.
+     * Inside a date the same name often declines; {@link monthNames} serves that form to
+     * the token formatter, and this method deliberately keeps the heading one.
+     */
     getMonthNames(style: 'narrow' | 'short' | 'long'): readonly string[];
+    private numeralsCache;
+    /** The locale's own ten digits, cached — empty when its system is algorithmic. */
+    private localeNumerals;
+    private dayPeriodCache;
+    /**
+     * `[am, pm]` as the LOCALE writes them — `PM`, `م`, `午後`.
+     *
+     * The `a` token used to return a hard-coded lowercase `pm`, byte for byte identical in
+     * every locale, which made it the one token in the pattern language that could not be
+     * localised at all. `Intl` is the source rather than the i18n catalog because
+     * `ngwr/date` deliberately depends on nothing: the panel next to it reads
+     * `datePicker.am` / `datePicker.pm`, so an app that wants its own wording overrides it
+     * there and passes a 24-hour pattern here.
+     */
+    private dayPeriods;
+    private readonly monthNameCache;
+    /**
+     * `context: 'format'` asks `Intl` for the month name as it appears BESIDE A DAY, which
+     * is where a case language stops using the nominative: ru writes `15 марта`, not
+     * `15 март`, and fi writes `maaliskuuta`, not `maaliskuu`. The name comes out of a
+     * `{ day, month }` formatter's parts, because a `{ month }` formatter alone can only
+     * ever answer with the standalone form.
+     *
+     * Some locales write the month NUMERICALLY in that position — fi abbreviates `15.3.`,
+     * ja writes `3` with `月` as a separate literal — and there the standalone name is the
+     * only name there is, so a purely numeric answer falls back to it. Without that guard
+     * `dd MMMM yyyy` would render `15 3 2026` in Japanese.
+     */
+    private monthNames;
+    /** Whether a token pattern also writes the day, which decides the month's form. */
+    private hasDayToken;
     private formatWithTokens;
     private parseWithTokens;
+    /**
+     * Build the parser for one named format out of the very formatter that prints it.
+     *
+     * `formatToParts` is the only honest source for a locale's field ORDER and its
+     * literals — ru writes `dd.MM.y` with a two-digit month while its own
+     * `{ month: 'numeric' }` request says one digit, ja puts the year first, and ar-SA
+     * separates fields with U+200F. Names (a month, AM/PM) become an alternation of the
+     * real strings; numbers accept the locale's digits AND ASCII, because a physical
+     * keyboard produces the latter whatever the display shows.
+     *
+     * Returns `null` — meaning "this format cannot be read back" — rather than guessing,
+     * for a field type nothing here asks for (an era, a weekday) or a numbering system
+     * with no digit-by-digit reading (roman numerals). `parse` then refuses, which leaves
+     * the caller's committed value untouched.
+     */
+    private buildNamedParser;
+    /** The twelve month strings THIS formatter writes, in its own style and context. */
+    private namedMonthNames;
+    /** `[am, pm]` as THIS formatter writes them — `ص` / `م` in Arabic, not AM / PM. */
+    private dayPeriodNames;
+    private readonly namedParsers;
+    private parseNamed;
+    /**
+     * Assemble whatever was read into a `Date`, or refuse.
+     *
+     * `new Date(2025, 12, 45)` does not fail — it rolls forward into the next year — and
+     * `isValid` is happy with the result, so a text field used to turn nonsense into a
+     * confident wrong answer. The clock parts are range-checked directly; the month and the
+     * day are checked by comparing what came back, which catches every rollover including a
+     * month of 12 or -1.
+     */
+    private compose;
     static ɵfac: i0.ɵɵFactoryDeclaration<WrNativeDateAdapter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<WrNativeDateAdapter>;
 }
@@ -176,12 +286,16 @@ declare class WrNativeDateAdapter extends WrDateAdapter<Date> {
  * Register the date adapter and locale used by the calendar / date picker /
  * time picker. Call once at bootstrap.
  *
+ * Omit `locale` and dates follow Angular's `LOCALE_ID`, which is what the app
+ * already says it is. Pass one only to pin dates to something else — see
+ * {@link WR_DATE_LOCALE}, and `WrI18n` for how the three locale inputs rank.
+ *
  * @example
  * ```ts
  * bootstrapApplication(AppComponent, {
  *   providers: [
- *     provideWrDateAdapter(),                 // native, browser locale
- *     // provideWrDateAdapter({ locale: 'ru-RU' }),
+ *     provideWrDateAdapter(),                 // native adapter, LOCALE_ID
+ *     // provideWrDateAdapter({ locale: 'ru-RU' }),        // pin the dates
  *     // provideWrDateAdapter({ adapter: MyDateFnsAdapter, locale: 'fr' }),
  *   ],
  * });
@@ -198,18 +312,34 @@ declare function provideWrDateAdapter(options?: WrDateAdapterOptions): Environme
 
 /**
  * BCP 47 locale tag the {@link WrDateAdapter} implementations read. Defaults to
- * `navigator.language` in the browser and `'en-US'` on the server; override via
- * {@link provideWrDateAdapter}'s `locale` option.
+ * Angular's `LOCALE_ID`; override via {@link provideWrDateAdapter}'s `locale`
+ * option.
+ *
+ * **It used to default to `navigator.language`, and that was wrong in the
+ * documented case.** The provider's own first example is the no-argument call,
+ * so the path a reader copies was the broken one: an app that set
+ * `LOCALE_ID: 'ru-RU'` and translated every string still rendered `March 2026`,
+ * `SUN MON TUE …` and a week starting on Sunday, because the calendar was
+ * asking the browser rather than the application. `navigator.language` is the
+ * user's browser preference; `LOCALE_ID` is what the app says it is, and only
+ * the app can be right about that. Reading the browser also made a prerendered
+ * page and its hydrated self disagree — the server has no `navigator.language`
+ * to match. An app that genuinely wants the browser's tag can still say so:
+ * `provideWrDateAdapter({ locale: navigator.language })`.
+ *
+ * The token is a plain string, resolved once. It is therefore the *pinned* date
+ * locale, not a live one — `WrI18n.use()` moves catalog text and cannot move
+ * this. `WrI18n`'s class docs carry the full precedence and `use()` warns about
+ * the gap in dev mode.
  *
  * **How far it reaches depends on the adapter, and the difference matters.**
- * The luxon adapter threads it through everything — every `DateTime` is
- * constructed with it, and `format` / `parse` call `setLocale`. The date-fns
- * adapter reads it only for locale-DERIVED defaults (first day of week); its
- * `format` and `parse` pass no locale to date-fns, so they stay on that
- * library's module default. Setting this token and expecting French month names
- * out of `WrDateFnsAdapter` gets English ones, and the parse side of that
- * mismatch is silent rather than loud — see the adapter's own class docs for the
- * lever (`setDefaultOptions`).
+ * The native and luxon adapters thread it through everything. The date-fns
+ * adapter cannot: date-fns resolves its patterns against a `Locale` OBJECT, not
+ * a tag, so this token drives only the parts that go through `Intl` (the month
+ * and weekday names) and the OBJECT drives `format` / `parse`. Pass it as
+ * `provideWrDateFnsAdapter({ dateFnsLocale: ru })` — with only a tag the calendar
+ * headings localize and the field does not, which the adapter warns about once
+ * in dev mode.
  */
 declare const WR_DATE_LOCALE: InjectionToken<string>;
 

package/types/ngwr-drag-drop.d.ts

@@ -30,6 +30,10 @@ interface WrSortableReorderEvent<T> {
  * handling of its own, so without this the component's only function was
  * unreachable from a keyboard.
  *
+ * Reading direction: a `horizontal` list follows the VISUAL order, so under
+ * `dir="rtl"` ArrowLeft moves the held row toward the higher index — the same
+ * rule `wr-slider` applies to its track. A vertical list never mirrors.
+ *
  * What that does NOT answer is WCAG 2.5.7, which asks for a POINTER alternative
  * to the drag. Click-to-pick-up is the obvious candidate and is not safe here:
  * the CDK's drag-drop bundle installs no click suppressor of any kind, so the
@@ -78,6 +82,21 @@ declare class WrSortableList<T = unknown> {
     readonly reorder: _angular_core.OutputEmitterRef<WrSortableReorderEvent<T>>;
     protected readonly rowTemplate: _angular_core.Signal<TemplateRef<any>>;
     private readonly injector;
+    /**
+     * Ambient reading direction, for the horizontal keyboard path only.
+     *
+     * Optional so a bare `TestBed` — or any consumer that never set a direction —
+     * needs no provider; `Directionality` is root-provided, so `null` only ever
+     * means "nobody asked", which is LTR. Nothing caches a direction-derived
+     * value: `isRtl()` is read inside the key handler, so a runtime flip needs no
+     * subscription to `Directionality.change`.
+     *
+     * The POINTER path already mirrors without this — `cdkDropList` injects
+     * `Directionality` itself and feeds it to `DropListRef.withDirection`, so a
+     * horizontal drag has always followed the visual order. The keyboard path was
+     * the half that did not, which is why the two disagreed.
+     */
+    private readonly dir;
     private readonly rowEls;
     /** Index of the row the keyboard is holding, or `null` when nothing is held. */
     protected readonly grabbedIndex: _angular_core.WritableSignal<number | null>;