ngwr 11.0.0 → 11.2.0

package/types/ngwr-calendar-testing.d.ts

@@ -0,0 +1,277 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrCalendarMode } from 'ngwr/calendar';
+
+/**
+ * @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 of the three sub-views the calendar is showing. */
+type WrCalendarView = 'day' | 'month' | 'year';
+/** One month or year chip, as the picker views render them. */
+interface WrCalendarChip {
+    /** The label as printed — a short month name, or the year. */
+    readonly label: string;
+    /** Whether it is the current selection. */
+    readonly selected: boolean;
+    /** Whether it is the month / year containing today. */
+    readonly current: boolean;
+    /** Whether `min` / `max` ruled it out. */
+    readonly disabled: boolean;
+}
+/** Narrows which `<wr-calendar>` a harness query matches. */
+interface WrCalendarHarnessFilters extends BaseHarnessFilters {
+    /** Match the header label as printed, e.g. `March 2026`. */
+    readonly headerLabel?: string | RegExp;
+    /** Match single- or range-selection calendars. */
+    readonly mode?: WrCalendarMode;
+    /** Match only enabled (`false`) or only disabled (`true`) calendars. */
+    readonly disabled?: boolean;
+}
+/** Narrows which day cell a harness query matches. */
+interface WrCalendarDayHarnessFilters 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 most numbers appear twice.
+     */
+    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`.
+     */
+    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
+ */
+
+/**
+ * Test harness for one day cell of a `<wr-calendar>` grid.
+ *
+ * The cell belongs to the calendar, and a date-picker's popup is a calendar in an
+ * overlay — so this is the harness for both, re-exported from
+ * `ngwr/date-picker/testing` under the name it shipped as
+ * (`WrDatePickerDayHarness`). Reach it through `WrCalendarHarness.getDays()`, or
+ * through `WrDatePickerHarness.getDay()` / `getDays()`, which scope it to ONE
+ * picker's panel — those cells are in the shared overlay container, so a bare query
+ * would answer with whichever picker opened first.
+ *
+ * State is read the way a screen reader reads it (`role`, `aria-selected`,
+ * `aria-disabled`) with the `.wr-calendar__day--*` modifiers filling in what
+ * ARIA has no word for: today, the spill days of the neighbouring months, and
+ * the interior of a picked range.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCalendarDayHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrCalendarDayHarnessFilters): HarnessPredicate<WrCalendarDayHarness>;
+    /** The day number as rendered. */
+    getText(): Promise<string>;
+    /** The day number as a number, for mapping a list of cells to dates. */
+    getDayOfMonth(): Promise<number>;
+    /** `'gridcell'` — the cell is a button, and the grid semantics are what a spec should assert. */
+    getRole(): Promise<string | null>;
+    /** Whether this day is (one end of) the current selection. */
+    isSelected(): Promise<boolean>;
+    /**
+     * Whether the day refuses selection — `min` / `max` or `dateFilter` ruled it
+     * out, or the whole calendar is disabled.
+     */
+    isDisabled(): Promise<boolean>;
+    /** Whether the cell is today's date. */
+    isToday(): Promise<boolean>;
+    /**
+     * Whether the cell belongs to a neighbouring month. The grid is always 6x7, so
+     * every month is padded with days that are selectable but not "in" the month —
+     * which is why `WrDatePickerHarness.getDay` and {@link WrCalendarHarness.getDay} skip them.
+     */
+    isOutOfMonth(): Promise<boolean>;
+    /** Whether the day lies strictly between the two ends of a picked range. */
+    isInRange(): Promise<boolean>;
+    /**
+     * Whether this is the roving cell — the grid's single tab stop, and where the
+     * arrow keys move from.
+     *
+     * At most ONE cell answers `true`, and it is not always one: the calendar's
+     * roving date does not follow `next()` / `previous()`, so a grid navigated away
+     * from that month has no active cell (and, deliberately or not, no tab stop)
+     * until a cell is clicked or the arrows move it.
+     */
+    isActive(): Promise<boolean>;
+    /** Click the cell. A disabled cell swallows the click — assert, do not assume. */
+    click(): Promise<void>;
+}
+
+/**
+ * @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
+ */
+
+/** The arrow keys, by the direction a user would say out loud. */
+type Arrow = 'left' | 'right' | 'up' | 'down';
+/**
+ * Test harness for `<wr-calendar>` — the standalone month grid, and the one
+ * `<wr-date-picker>` puts in an overlay.
+ *
+ * **It is three views behind one header.** Clicking the header label walks
+ * `day → month → year`, and each view renders something different: a
+ * `role="grid"` of day cells, or a `role="listbox"` of chips. Every day method
+ * throws off the day view rather than answering `[]`, which would read as "this
+ * month has no days".
+ *
+ * **The roving cell is not the selection.** The grid has one tab stop and the
+ * arrows move it; it starts on the selected date, or on today when nothing is
+ * picked. And it does NOT follow {@link next} / {@link previous} — a grid paged
+ * away from the roving month has no active cell at all, and so no tab stop, until
+ * a key or a click puts one back. That is the component's behaviour, and
+ * {@link getActiveDay} is how a spec sees it.
+ *
+ * **Keys go to the host, not to a cell.** The component listens on its own element,
+ * so {@link pressArrow} works whether or not jsdom managed to put real focus
+ * anywhere — which it often does not, since the calendar moves focus in an
+ * `afterNextRender` and a disabled cell cannot take it.
+ *
+ * @example
+ * ```ts
+ * const calendar = await loader.getHarness(WrCalendarHarness);
+ *
+ * expect(await calendar.getHeaderLabel()).toBe('March 2026');
+ * await (await calendar.getDay(14)).click();
+ * expect(await calendar.getSelectedDayNumbers()).toEqual([14]);
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCalendarHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCalendarHarnessFilters): HarnessPredicate<WrCalendarHarness>;
+    private readonly header;
+    private readonly prevButton;
+    private readonly nextButton;
+    /** Which sub-view is showing. */
+    getView(): Promise<WrCalendarView>;
+    /** Single- or range-selection, from the host modifier. */
+    getMode(): Promise<WrCalendarMode>;
+    /** Whether the whole calendar refuses interaction. */
+    isDisabled(): Promise<boolean>;
+    /** The header text — `March 2026`, `2026`, or `2016 – 2027` depending on the view. */
+    getHeaderLabel(): Promise<string>;
+    /**
+     * Click the header — stepping `day → month → year`.
+     *
+     * The year view is the end of the walk: the header is disabled there, so this
+     * throws rather than clicking a button the DOM would ignore.
+     */
+    clickHeader(): Promise<void>;
+    /**
+     * Step back — a month, a year or twelve years, depending on the view.
+     *
+     * The roving day cell does NOT come along: paging is a view change, not a
+     * navigation, and the tab stop stays on the month it was in.
+     */
+    previous(): Promise<void>;
+    /** Step forward — a month, a year or twelve years, depending on the view. */
+    next(): Promise<void>;
+    /**
+     * The back arrow's accessible name, which changes with the view — the arrows are
+     * icon-only, so this is the only name they have.
+     */
+    getPreviousLabel(): Promise<string | null>;
+    /** The forward arrow's accessible name. */
+    getNextLabel(): Promise<string | null>;
+    /** The weekday column headers, in the order the adapter's first day of week puts them. */
+    getWeekdayNames(): Promise<string[]>;
+    /**
+     * Every day cell, in DOM order — 42 of them, since the grid is always six weeks.
+     *
+     * That includes the spill days of the neighbouring months, which are selectable
+     * and not "in" the month; {@link getDay} skips them, and
+     * `WrCalendarDayHarness.isOutOfMonth()` tells them apart.
+     */
+    getDays(filters?: WrCalendarDayHarnessFilters): Promise<WrCalendarDayHarness[]>;
+    /**
+     * The cell for a day of THIS month.
+     *
+     * The number alone is ambiguous — a 42-cell grid shows most numbers twice — so
+     * the spill days are skipped rather than matched, which is what "the 3rd" means
+     * to someone reading the calendar.
+     */
+    getDay(dayOfMonth: number): Promise<WrCalendarDayHarness>;
+    /** The day numbers currently selected — one in single mode, both ends in range mode. */
+    getSelectedDayNumbers(): Promise<number[]>;
+    /** The day numbers strictly inside a picked range — never the ends. */
+    getInRangeDayNumbers(): Promise<number[]>;
+    /**
+     * The day number holding the roving tab stop, or `null` when the grid has none.
+     *
+     * `null` is a real answer, not a failure: paging with {@link next} leaves the
+     * roving date behind in another month, and the grid then has no `tabindex="0"`
+     * at all until a key or a click puts one back.
+     */
+    getActiveDayNumber(): Promise<number | null>;
+    /** The month chips, with their state. Throws off the month view. */
+    getMonths(): Promise<WrCalendarChip[]>;
+    /** The year chips, with their state. Throws off the year view. */
+    getYears(): Promise<WrCalendarChip[]>;
+    /**
+     * Click a month or year chip by its printed label — which drops the calendar back
+     * one view, the way clicking the header climbed up.
+     *
+     * Throws on the day view, where there are no chips, and on a label the view does
+     * not offer, naming what it does.
+     */
+    selectChip(label: string): Promise<void>;
+    /**
+     * Press an arrow key — one day left or right, one WEEK up or down.
+     *
+     * Sent to the host, where the component listens, so this does not depend on jsdom
+     * having managed to focus a cell. Under `dir="rtl"` the horizontal pair mirrors:
+     * ArrowRight goes back a day, because the grid itself is mirrored.
+     */
+    pressArrow(arrow: Arrow): Promise<void>;
+    /** Press Home — the first day of the roving cell's week, not of the month. */
+    pressHome(): Promise<void>;
+    /** Press End — the last day of the roving cell's week. */
+    pressEnd(): Promise<void>;
+    /** Press PageUp — a month back, or a YEAR back with `shift`. */
+    pressPageUp(options?: {
+        shift?: boolean;
+    }): Promise<void>;
+    /** Press PageDown — a month on, or a YEAR on with `shift`. */
+    pressPageDown(options?: {
+        shift?: boolean;
+    }): Promise<void>;
+    /** Press Enter — picking the roving day, exactly as clicking it would. */
+    pressEnter(): Promise<void>;
+    /**
+     * The role of the element that owns the day rows.
+     *
+     * Worth asserting rather than assuming: the grid is NOT the host. The host also
+     * holds the nav header, and a `role="grid"` may only own rows — so the role sits
+     * on the body, and the weekday strip is a row inside it rather than a sibling.
+     */
+    getGridRole(): Promise<string | null>;
+    /** How many week rows the grid renders — always six, which is what keeps it from reflowing. */
+    getWeekCount(): Promise<number>;
+    private readChips;
+    private requireView;
+}
+
+export { WrCalendarDayHarness, WrCalendarHarness };
+export type { WrCalendarChip, WrCalendarDayHarnessFilters, WrCalendarHarnessFilters, WrCalendarView };

package/types/ngwr-calendar.d.ts

@@ -79,6 +79,16 @@ declare class WrCalendar {
     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">;
+    private readonly prevMonthLabel;
+    private readonly nextMonthLabel;
+    private readonly prevYearLabel;
+    private readonly nextYearLabel;
+    private readonly prevYearsLabel;
+    private readonly nextYearsLabel;
+    /** What the ← button does from here — a month, a year, or a 12-year page. */
+    protected readonly prevLabel: _angular_core.Signal<string>;
+    /** What the → button does from here. */
+    protected readonly nextLabel: _angular_core.Signal<string>;
     protected readonly today: _angular_core.Signal<Date>;
     protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
     protected readonly monthsView: _angular_core.Signal<readonly string[]>;

package/types/ngwr-checkbox.d.ts

@@ -120,6 +120,17 @@ interface WrCheckboxGroupContext {
     isSelected(value: unknown): boolean;
     /** Toggle the given value in the group. */
     toggle(value: unknown): void;
+    /**
+     * A child lost focus.
+     *
+     * The group is the control a form binds to, so it is the group that has to
+     * report touched — and a child's own `touch` output goes nowhere, since the
+     * group never listens to it. Without this channel the only way to mark a
+     * group touched was to CHANGE it: tabbing through every box and picking none
+     * left the field pristine, so a `required` group showed no error until the
+     * user toggled something, which is the one thing they had decided not to do.
+     */
+    blurred(): void;
     /** Whether the entire group is disabled. */
     readonly isDisabled: Signal<boolean>;
 }
@@ -167,6 +178,8 @@ declare class WrCheckboxGroup implements FormValueControl<unknown[]>, WrCheckbox
     readonly isDisabled: _angular_core.Signal<boolean>;
     isSelected(value: unknown): boolean;
     toggle(value: unknown): void;
+    /** @internal A child checkbox lost focus — see {@link WrCheckboxGroupContext.blurred}. */
+    blurred(): 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; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, ["*"], true, never>;
 }

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

@@ -0,0 +1,196 @@
+import { BaseHarnessFilters, ComponentHarness, 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-circular-text>` a harness query matches. */
+interface WrCircularTextHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the string the ring announces — the readable copy, not the characters.
+     * A string is an exact match, a RegExp is tested.
+     *
+     * Matched against the accessible copy rather than the host's text because the host
+     * carries both: one readable span AND one span per character, so its text reads back
+     * as the string twice over and a filter written against it would depend on the split.
+     */
+    readonly text?: string | RegExp;
+    /**
+     * Match on how many characters the ring was laid out from — the divisor every angle is
+     * derived from, and the blunt way to address one of two rings without spelling their
+     * strings out.
+     */
+    readonly characterCount?: number;
+}
+
+/**
+ * @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-circular-text>`.
+ *
+ * **The ring's geometry is the component's real output, and it is exact without a
+ * browser.** Each character is placed by an inline `transform` the component computes —
+ * `rotate(360 / N × i deg)` and then a push outward by the orbit radius — so
+ * {@link getCharacterAngles} reads the entire layout back as numbers. A broken circle
+ * shows up as uneven angles, as an offset that varies per character, or as a surrogate
+ * pair torn into two glyphs, and none of those need a single measured pixel.
+ *
+ * **The spin does not exist in the DOM, and every method that would report it is absent
+ * on purpose.** The rotation is one Web Animation on the ring wrapper, advanced by a
+ * compositor, and `spinDuration` reaches nothing but that animation's `duration` option
+ * — so there is no `getSpinDurationSeconds()` (it would report whatever the spec's own
+ * `animate` stub recorded, which is the test reading back its own fixture), no
+ * `isSpinning()` and no `getRotationAngle()` (both live on `Animation.currentTime`, in an
+ * API jsdom does not implement). There is no `hover()` either: hovering swaps that
+ * duration through listeners on the host and changes not one attribute, so a harness
+ * hover would appear to work and assert nothing. `pause()` / `resume()` are missing for
+ * the same reason — the state is the private `Animation` object, never the document.
+ * `respectsReducedMotion()` is the same shape once more: the component honours it by NOT
+ * calling `animate`, which is a spec assertion against a stub rather than something a
+ * harness can read.
+ *
+ * **The radius is exposed as text, not as pixels.** `--wr-circular-text-size` and
+ * `--wr-circular-text-radius` are declared in the stylesheet, so a test running no
+ * stylesheets reads them back empty — hence {@link getOrbitOffsets} hands over the CSS
+ * each character carries verbatim instead of a `getRadiusPx()` nobody could compute, and
+ * there is no `getCharacterPositions()`: every rect in a unit test is 0×0.
+ *
+ * **{@link isBonkers} is the one hover mode with a DOM footprint, and the INPUT sets it,
+ * not the pointer.** `onHover="goBonkers"` puts the modifier on the host at render time;
+ * the scale it enables is a CSS `:hover` rule the harness cannot see. Reading it as "the
+ * pointer is over the ring" is exactly backwards.
+ *
+ * **What is announced and what is drawn are two questions.** The string is carried once
+ * in a visually-hidden span, and the ring as a whole is `aria-hidden` so a screen reader
+ * hears the word rather than spelling it out — {@link getAccessibleText} is the first,
+ * {@link getText} the second, and a spec that read only the second would pass on a
+ * component announcing `N. G. W. R.`
+ *
+ * jsdom implements no Web Animations API and this component animates on mount, so a spec
+ * has to supply one of the two halves before the fixture is created — either the API, or
+ * a reason not to reach for it:
+ *
+ * ```ts
+ * // Either: mount under reduced motion, where the component never animates at all.
+ * // (jsdom has no matchMedia, so WrPlatform must be provided as a value.)
+ * TestBed.configureTestingModule({ providers: [{ provide: WrPlatform, useValue: reducedMotion }] });
+ *
+ * // Or: stub the API. Save the descriptor and put it back by hand in afterEach — this
+ * // is an assignment, not a spy, so it leaks into whichever file vitest runs next.
+ * Reflect.set(Element.prototype, 'animate', () => ({ cancel: () => undefined }));
+ * ```
+ *
+ * @example
+ * ```ts
+ * const ring = await loader.getHarness(WrCircularTextHarness.with({ text: 'NGWR' }));
+ *
+ * expect(await ring.getCharacters()).toEqual(['N', 'G', 'W', 'R']);
+ * expect(await ring.getCharacterAngles()).toEqual([0, 90, 180, 270]);
+ * expect(await ring.getText()).toBe(await ring.getAccessibleText());
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrCircularTextHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — pass to `getHarness` / `getAllHarnesses`. */
+    static with(options?: WrCircularTextHarnessFilters): HarnessPredicate<WrCircularTextHarness>;
+    private readonly chars;
+    /**
+     * The whole string, as the one readable copy holds it.
+     *
+     * All a screen reader gets, the ring itself being out of the tree — lose this span and
+     * the component becomes a nameless pile of hidden letters, with no other symptom
+     * anywhere in the DOM.
+     *
+     * Untrimmed, deliberately: a ring is usually given a separator-padded string like
+     * `'HELLO * NGWR * '`, whose trailing space is a real character that takes a slot on
+     * the circle. {@link getText} is meant to compare equal to this, and a trimmed read on
+     * either side would forgive losing it.
+     */
+    getAccessibleText(): Promise<string>;
+    /**
+     * The characters laid out around the circle, in DOM order.
+     *
+     * Pins the splitting rule — `Array.from(text())`, so a surrogate pair is ONE slot and
+     * not two broken halves, and a space is its own slot rather than being collapsed away.
+     * DOM order is the only order there is: every character is absolutely positioned, so
+     * the sequence here is what the angles below are indexed by.
+     */
+    getCharacters(): Promise<string[]>;
+    /**
+     * Everything the ring draws, put back together in DOM order.
+     *
+     * The assertion this exists for is `getText() === getAccessibleText()`: the split has
+     * to be lossless. Read from the character spans rather than from the host, because the
+     * host also holds the readable copy and would report the string twice over.
+     */
+    getText(): Promise<string>;
+    /** How many slots the circle was divided into — the divisor every angle is derived from. */
+    getCharacterCount(): Promise<number>;
+    /**
+     * Where each character sits on the circle, in degrees, in DOM order.
+     *
+     * The component's whole geometric output, and the one thing that tells a ring from a
+     * crowded arc: the angles must start at 0 and be exactly `360 / N` apart. Empty text
+     * yields an empty array — no characters, no angles.
+     *
+     * Throws for a character carrying no rotation of its own rather than reporting `0` or
+     * `NaN` for it. Both of those describe a ring collapsed onto a single point as though
+     * nothing were wrong, and that is precisely the failure this method exists to catch.
+     */
+    getCharacterAngles(): Promise<number[]>;
+    /**
+     * How far each character is pushed out from the centre, as the CSS the component wrote.
+     *
+     * A string rather than a number, and that is the honest answer: the distance is
+     * `calc(-1 * var(--wr-circular-text-radius))`, a custom property the STYLESHEET
+     * declares, so there is no pixel value to resolve in a test that loads no stylesheet.
+     * What matters is assertable anyway — every character must be pushed out by the SAME
+     * offset, along the same axis. A per-character or axis-mixed one is the classic bug
+     * that turns the ring into a diagonal line, and it survives every other check here
+     * because the angles stay perfect while it happens.
+     *
+     * Throws on the same unplaced character {@link getCharacterAngles} does, for the same
+     * reason.
+     */
+    getOrbitOffsets(): Promise<string[]>;
+    /**
+     * Whether the host carries the `wr-circular-text--bonkers` modifier.
+     *
+     * Set from the `onHover` INPUT being `'goBonkers'` — at render time, before anyone has
+     * hovered anything — which is the one assumption a spec author makes backwards here.
+     * It is also the only one of the four hover modes with any DOM footprint at all; the
+     * other three exist purely as a number handed to a Web Animation.
+     */
+    isBonkers(): Promise<boolean>;
+    /**
+     * Whether the ring is out of the accessibility tree.
+     *
+     * ONE attribute answers this, and that is the contract rather than an approximation:
+     * `aria-hidden` sits on the `__spin` wrapper, so the letters underneath inherit it and
+     * none of them carries the attribute itself — which keeps it off the nodes the rotation
+     * touches. Asserting it per character would fail on a component that is behaving.
+     *
+     * Answers for the wrapper even when the text is empty, and that is deliberate: the
+     * wrapper is always rendered, so there is no vacuous case to guard against — a ring
+     * with nothing in it is still correctly hidden or incorrectly readable.
+     *
+     * Assert it together with {@link getAccessibleText}: hidden letters AND no readable
+     * copy is an element with no accessible name at all, which passes either check alone.
+     */
+    areCharactersHiddenFromAssistiveTech(): Promise<boolean>;
+    /** Each character's placement, parsed once out of the inline transform it carries. */
+    private placements;
+}
+
+export { WrCircularTextHarness };
+export type { WrCircularTextHarnessFilters };