ngwr 10.2.1 → 11.0.0

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

@@ -0,0 +1,196 @@
+import { BaseHarnessFilters, ContentContainerComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { WrDrawerPosition } from 'ngwr/drawer';
+
+/**
+ * @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 open drawer a harness query matches. */
+interface WrDrawerHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the `[wrDrawerTitle]` text — a string is an exact match, a RegExp is
+     * tested. A drawer with no title never matches.
+     */
+    readonly title?: string | RegExp;
+    /**
+     * Match the `[wrDrawerContent]` text. A drawer whose content is not wrapped in
+     * that directive never matches.
+     */
+    readonly content?: string | RegExp;
+    /** Match the edge the drawer slid in from: `left`, `right`, `top` or `bottom`. */
+    readonly position?: WrDrawerPosition;
+}
+
+/**
+ * @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 an open drawer — both flavours.
+ *
+ * A drawer ships as an element (`<wr-drawer [(open)]="…">`) AND as a service call
+ * (`WrDrawerManager.open(Cmp)`), but neither puts the panel where a consumer's
+ * spec can see it: both render into the NGWR overlay container, a sibling of the
+ * whole app. So this is loaded from `TestbedHarnessEnvironment.documentRootLoader()`
+ * in BOTH cases — a fixture-scoped loader finds nothing, including for the element
+ * form, whose `<wr-drawer>` host is `display: none` and holds no content.
+ *
+ * The harness is anchored on the overlay pane, which is the one element the two
+ * flavours share: for `<wr-drawer>` it wraps the panel div, for the manager it IS
+ * the panel (the caller's component is attached straight into it). It is also the
+ * only per-instance anchor there is — `<wr-drawer>` publishes no `aria-controls` /
+ * `aria-owns` link to the overlay it opened — which is why every query here starts
+ * from the pane rather than from a class in the shared container.
+ *
+ * The harness is a CONTENT CONTAINER: the fields and buttons in the panel are the
+ * consumer's own components, so `drawer.getHarness(WrButtonHarness…)` reads them
+ * without the spec ever touching the overlay.
+ *
+ * @example
+ * ```ts
+ * const rootLoader = TestbedHarnessEnvironment.documentRootLoader(fixture);
+ * const drawer = await rootLoader.getHarness(WrDrawerHarness.with({ title: 'Filters' }));
+ *
+ * expect(await drawer.getPosition()).toBe('bottom');
+ * expect(await drawer.isSheet()).toBe(true);
+ * await drawer.close();
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDrawerHarness extends ContentContainerComponentHarness {
+    /** The overlay pane both flavours create. A closed drawer has none. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query — drawers can be stacked. */
+    static with(options?: WrDrawerHarnessFilters): HarnessPredicate<WrDrawerHarness>;
+    /**
+     * Whether this drawer is still open.
+     *
+     * A harness can only be obtained while a drawer is open — closing disposes the
+     * overlay, panel and all — so this is the answer for a harness you are already
+     * HOLDING: it flips to `false` after a dismissal, where a fresh
+     * `getHarnessOrNull()` comes back `null`.
+     *
+     * Attachment is the test, not a class: disposal takes the pane out of the
+     * document along with its wrapper, so the `body` ancestor in the selector is what
+     * distinguishes a live panel from the detached element a stale harness holds.
+     */
+    isOpen(): Promise<boolean>;
+    /** The `[wrDrawerTitle]` text, or `null` when the drawer has no title. */
+    getTitleText(): Promise<string | null>;
+    /** The `[wrDrawerContent]` text, or `null` when the body is not wrapped in it. */
+    getContentText(): Promise<string | null>;
+    /**
+     * The edge the drawer is attached to.
+     *
+     * Read from the overlay's own side modifier, which both flavours set and consumer
+     * CSS targets. It is a real mode axis rather than a style flag: left/right size
+     * themselves from `width` and stretch full-height, top/bottom span the viewport
+     * and size themselves from `height` / `maxHeight`.
+     */
+    getPosition(): Promise<WrDrawerPosition>;
+    /**
+     * Whether the drawer presents as a SHEET rather than a side panel — the top and
+     * bottom edges, where it spans the full viewport width and takes its size from
+     * `height` / `maxHeight`.
+     *
+     * This answers the axis only. The bottom-sheet look is that plus `rounded` and
+     * `showHandle`, which {@link isRounded} and {@link hasHandle} answer separately.
+     */
+    isSheet(): Promise<boolean>;
+    /** Whether the leading corners are rounded (`rounded`). */
+    isRounded(): Promise<boolean>;
+    /** Whether the trailing edge is padded for the device's safe area (`safeArea`). */
+    hasSafeArea(): Promise<boolean>;
+    /**
+     * Whether the drawer draws a grab handle (`showHandle`), which is also what
+     * enables swipe-to-dismiss.
+     *
+     * Always `false` for a `WrDrawerManager.open()` drawer, and not a defect: the
+     * handle lives in the component's own wrapper markup, which the service path
+     * replaces with the caller's component.
+     */
+    hasHandle(): Promise<boolean>;
+    /**
+     * The role the drawer announces.
+     *
+     * Worth asserting rather than assuming: both flavours write it onto the OVERLAY
+     * element, not onto the markup the consumer wrote, so a spec looking for it on
+     * its own host would not find it.
+     */
+    getRole(): Promise<string | null>;
+    /** Whether the drawer is marked `aria-modal` — the promise the backdrop and focus trap make. */
+    isModal(): Promise<boolean>;
+    /**
+     * Whether the panel takes its accessible name from the drawer's own title.
+     *
+     * Both flavours point `aria-labelledby` at `[wrDrawerTitle]`'s generated id, but
+     * only once the content is in the DOM — deferred either way — so a spec has to
+     * let the fixture settle (`await fixture.whenStable()`) before asking.
+     */
+    isLabelledByTitle(): Promise<boolean>;
+    /** Whether the built-in dismiss (✕) button is present (`closable`, the default). */
+    isClosable(): Promise<boolean>;
+    /** The dismiss button's accessible name — the string a screen reader reads out. */
+    getCloseLabel(): Promise<string | null>;
+    /**
+     * Click the built-in dismiss button.
+     *
+     * Throws on a drawer opened `closable: false`. That is a deliberate shape — the
+     * projected content owns the close affordance, typically a `[wrDrawerClose]`
+     * button — and a quiet no-op here would read as "closed" three assertions later.
+     */
+    close(): Promise<void>;
+    /**
+     * Press Escape. A drawer opened `closeOnEscape: false` ignores it — assert, do
+     * not assume.
+     *
+     * The key reaches a drawer through the CDK's keyboard dispatcher, which hands it
+     * to the TOP-MOST listening overlay, so with drawers stacked this dismisses the
+     * top one whichever harness it is called on.
+     */
+    sendEscape(): Promise<void>;
+    /** Whether the drawer dims the page behind it (`hasBackdrop`, the default). */
+    hasBackdrop(): Promise<boolean>;
+    /**
+     * Click the backdrop — the third way a drawer is dismissed, next to the dismiss
+     * button and Escape, and the one a `closeOnBackdropClick: false` drawer is meant
+     * to survive.
+     */
+    clickBackdrop(): Promise<void>;
+    /** Whether focus is currently inside the drawer, where the trap should hold it. */
+    isFocusTrapped(): Promise<boolean>;
+    /**
+     * The element carrying the `.wr-drawer__panel` classes.
+     *
+     * `WrDrawerManager` flattens the panel onto the overlay pane itself, while
+     * `<wr-drawer>` renders it as a div inside the pane — same classes, one level
+     * apart, so the modifiers have to be read from whichever element has them.
+     */
+    private panel;
+    /**
+     * THIS drawer's backdrop, or `null` when it has none.
+     *
+     * Scoped by the overlay pane's own id, not by a bare `.wr-drawer-backdrop` query:
+     * the container is shared, so a class query answers with whichever drawer opened
+     * first — and two drawers open at once can disagree about `hasBackdrop`.
+     *
+     * Two queries, because the CDK puts the backdrop in one of two places. With the
+     * popover API — its default wherever `showPopover` exists, so in every real
+     * browser — the backdrop is PREPENDED INSIDE the host, next to the pane, which is
+     * what the first query's `+` pins down. Without it (jsdom, or `usePopover: false`)
+     * it goes immediately BEFORE the host wrapper that holds the pane, which is what
+     * the second query matches — so under vitest the second one does the work and the
+     * first is the production path.
+     */
+    private backdrop;
+}
+
+export { WrDrawerHarness };
+export type { WrDrawerHarnessFilters };

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

@@ -0,0 +1,202 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate, ContentContainerComponentHarness, HarnessLoader } 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 `[wrDropdown]` trigger a harness query matches. */
+interface WrDropdownHarnessFilters extends BaseHarnessFilters {
+    /**
+     * Match the trigger's visible text — the label of whatever element the
+     * consumer put `[wrDropdown]` on. A string is an exact match, a RegExp is
+     * tested.
+     */
+    readonly text?: string | RegExp;
+    /** Match only open (`true`) or only closed (`false`) dropdowns. */
+    readonly open?: boolean;
+}
+/** Narrows which item inside a dropdown's menu a harness query matches. */
+interface WrDropdownItemHarnessFilters extends BaseHarnessFilters {
+    /** Match the item's label — a string is an exact match, a RegExp is tested. */
+    readonly text?: string | RegExp;
+    /** Match only enabled (`false`) or only disabled (`true`) items. */
+    readonly disabled?: 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 `<wr-dropdown-item>` inside a dropdown menu.
+ *
+ * The selector is the CLASS rather than the element: `.wr-dropdown-item` is what
+ * the directive's own keyboard navigation queries, so it is the contract both
+ * sides already rely on. Only the class, though — the directive narrows its query
+ * to `:not(.wr-dropdown-item--disabled)` because it is looking for focus stops,
+ * while a spec still has to be able to see a disabled item and assert that it is
+ * one.
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDropdownItemHarness extends ComponentHarness {
+    /** The class the item paints on its host, and the one arrow-key navigation looks for. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrDropdownItemHarnessFilters): HarnessPredicate<WrDropdownItemHarness>;
+    /** The item's label, trimmed. A leading icon is not part of it. */
+    getText(): Promise<string>;
+    /** The role the item announces — `menuitem`. */
+    getRole(): Promise<string | null>;
+    /** Whether the item refuses activation. */
+    isDisabled(): Promise<boolean>;
+    /** Whether the item shows a leading icon. */
+    hasIcon(): Promise<boolean>;
+    /** The leading icon's registered name, or `null` when the item has no icon. */
+    getIconName(): Promise<string | null>;
+    /** Whether the item holds the menu's roving focus. */
+    isFocused(): Promise<boolean>;
+    /**
+     * Click the item. A disabled item throws instead.
+     *
+     * Refusing is the only honest answer: the item's own `disabled` guards the
+     * KEYBOARD path only, and a pointer is stopped by `pointer-events: none` in the
+     * stylesheet. jsdom loads no stylesheets, so a click dispatched here would land
+     * on the host — exactly where the consumer bound `(click)` — and the spec would
+     * record an activation that cannot happen in a browser. Assert `isDisabled()`
+     * instead.
+     */
+    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
+ */
+
+/**
+ * Test harness for `[wrDropdown]` — the trigger, and the menu it opens.
+ *
+ * The harness matches the TRIGGER, because that is the only part of the dropdown
+ * in the fixture: `<wr-dropdown-menu>` renders nothing of its own (it hands over
+ * an `<ng-template>`), and the menu is portalled into the overlay container, a
+ * sibling of the whole app. So every item is read through the document root,
+ * scoped by the `aria-controls` id the trigger publishes while it is open — which
+ * is what keeps two dropdowns on one page from answering with each other's items.
+ *
+ * That scoped loader is also this harness's CONTENT loader, so
+ * `dropdown.getHarness(…)` resolves inside THIS dropdown's menu: the consumer's
+ * own components in the menu are reachable without the spec ever touching the
+ * overlay, and so is a nested `[wrDropdown]`, which is how a submenu is built
+ * here (the component ships no submenu API of its own).
+ *
+ * @example
+ * ```ts
+ * const dropdown = await loader.getHarness(WrDropdownHarness.with({ text: 'Actions' }));
+ *
+ * await dropdown.open();
+ * expect(await dropdown.getItemTexts()).toEqual(['Copy', 'Delete']);
+ *
+ * await dropdown.clickItem({ text: 'Copy' });
+ * ```
+ *
+ * @see https://ngwr.dev/guides/testing
+ */
+declare class WrDropdownHarness extends ContentContainerComponentHarness {
+    /** The directive's host — whatever element the consumer put `[wrDropdown]` on. */
+    static hostSelector: string;
+    /** Build a predicate that narrows the query. */
+    static with(options?: WrDropdownHarnessFilters): HarnessPredicate<WrDropdownHarness>;
+    /** The trigger's visible text. */
+    getTriggerText(): Promise<string>;
+    /** Whether the menu is showing. */
+    isOpen(): Promise<boolean>;
+    /** The role the menu announces — `menu`. Throws while the menu is closed. */
+    getMenuRole(): Promise<string | null>;
+    /**
+     * Whether the menu takes its accessible name from this trigger.
+     *
+     * The menu carries no label of its own, so that reference IS its name — and the
+     * id it points at is generated unless the consumer named the trigger
+     * themselves, which is why a spec cannot simply hard-code one.
+     */
+    isMenuLabelledByTrigger(): Promise<boolean>;
+    /**
+     * Open the menu, whichever gesture this dropdown listens for.
+     *
+     * `trigger` is not reflected in the DOM, so the harness cannot ask which mode it
+     * is in: it moves the pointer on first and falls back to a click. Hover leads
+     * because a click is an outside pointer event for every OTHER open overlay — so
+     * leading with it would shut someone else's menu on the way to opening this one
+     * — and a `trigger="click"` dropdown ignores the hover outright.
+     */
+    open(): Promise<void>;
+    /**
+     * Open the menu from the keyboard — ArrowDown on the trigger, the APG
+     * menu-button path (ArrowUp / Enter / Space do the same).
+     *
+     * Worth its own method rather than an argument to `open()`: it is the only way
+     * to get TWO dropdowns open at once, because clicking a second trigger is an
+     * outside pointer event for the first and closes it.
+     */
+    openByKeyboard(): Promise<void>;
+    /** Close the menu. A closed dropdown is left alone. */
+    close(): Promise<void>;
+    /** Click the trigger. A `trigger="hover"` dropdown deliberately ignores this. */
+    clickTrigger(): Promise<void>;
+    /** Move the pointer onto the trigger. Opens a `trigger="hover"` dropdown. */
+    hoverTrigger(): Promise<void>;
+    /** Move the pointer off the trigger. Closes a `trigger="hover"` dropdown. */
+    mouseAwayFromTrigger(): Promise<void>;
+    /**
+     * The items in this dropdown's menu, in DOM order.
+     *
+     * Throws while the menu is closed: the items do not exist anywhere until the
+     * portal is attached, and an empty array reads like a menu that rendered
+     * nothing — a failure three lines later instead of here.
+     */
+    getItems(filters?: WrDropdownItemHarnessFilters): Promise<WrDropdownItemHarness[]>;
+    /** The labels of the items in this dropdown's menu, in DOM order. */
+    getItemTexts(): Promise<string[]>;
+    /**
+     * Open the menu if it is closed, then click the first item matching the filters.
+     *
+     * Picking does NOT close the menu — there is no close-on-select in the item or
+     * the menu, so a consumer who wants one calls `close()` themselves.
+     */
+    clickItem(filters: WrDropdownItemHarnessFilters): Promise<void>;
+    /**
+     * The label of the item that currently holds focus, or `null` when focus is
+     * elsewhere.
+     *
+     * The menu roves focus rather than moving a visual cursor — it lands on the
+     * first ENABLED item as the menu renders, and the arrow keys walk it from there
+     * over the enabled items only (a disabled one is not a stop) — so this is the
+     * only way to ask where the keyboard is.
+     */
+    getFocusedItemText(): Promise<string | null>;
+    /**
+     * A loader scoped to THIS dropdown's menu — the content loader every
+     * `HarnessLoader` method on this class runs through, `getItems()` included.
+     *
+     * Scoped by the published id rather than by `.wr-dropdown-menu`: the overlay
+     * container is shared, so a bare class query would answer with whichever
+     * dropdown happened to open first.
+     */
+    protected getRootHarnessLoader(): Promise<HarnessLoader>;
+    /** This dropdown's menu element in the overlay. */
+    private menu;
+    /** The id the trigger publishes as `aria-controls`, which its menu carries. */
+    private menuId;
+}
+
+export { WrDropdownHarness, WrDropdownItemHarness };
+export type { WrDropdownHarnessFilters, WrDropdownItemHarnessFilters };

package/types/ngwr-dropdown.d.ts

@@ -80,7 +80,13 @@ declare class WrDropdown {
     private readonly destroyRef;
     /** @internal Public so host bindings can read it. */
     readonly isOpen: _angular_core.WritableSignal<boolean>;
-    /** Auto-generated id for `aria-labelledby` wiring on the menu. */
+    /**
+     * Id the menu names itself after. The trigger is the CONSUMER's own element, so
+     * an `id` they already put there wins: overwriting it broke `<label for>`,
+     * `document.getElementById` and any `aria-labelledby` aimed at that button from
+     * elsewhere in their app. The generated one is only a fallback so the menu has
+     * something to reference.
+     */
     protected readonly triggerId: string;
     private overlayRef;
     constructor();

package/types/ngwr-empty.d.ts

@@ -15,7 +15,7 @@ import * as _angular_core from '@angular/core';
  *
  * @example
  * ```html
- * <wr-empty icon="search" title="No results">
+ * <wr-empty iconName="search" title="No results">
  *   Try a different query or clear filters.
  *   <ng-container wrEmptyActions>
  *     <wr-btn (click)="reset()">Reset filters</wr-btn>
@@ -26,13 +26,28 @@ import * as _angular_core from '@angular/core';
  * @see https://ngwr.dev/reference/components/empty
  */
 declare class WrEmpty {
-    /** Icon name shown above the title. @default 'folder' */
-    readonly icon: _angular_core.InputSignal<string | null>;
+    /**
+     * Render the built-in folder glyph. Pass `false` to show no icon at all.
+     * Ignored when `iconName` is set — the same contract as `<wr-alert>`.
+     *
+     * This used to be typed as an icon NAME, which it never was: whatever name
+     * you passed, the template drew the folder. Any truthy value still shows it,
+     * so nothing that compiled before behaves differently.
+     *
+     * @default true
+     */
+    readonly icon: _angular_core.InputSignalWithTransform<boolean, any>;
+    /**
+     * Show any registered ngwr icon instead of the built-in glyph.
+     *
+     * @default null
+     */
+    readonly iconName: _angular_core.InputSignal<string | null>;
     /** Headline. Falls back to `empty.noData` from WrI18n, then `'No data'`. */
     readonly title: _angular_core.InputSignal<string | null>;
     protected readonly resolvedTitle: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrEmpty, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEmpty, "wr-empty", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[wrEmptyActions]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEmpty, "wr-empty", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconName": { "alias": "iconName"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[wrEmptyActions]"], true, never>;
 }
 
 export { WrEmpty };

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

@@ -218,6 +218,7 @@ declare class WrEventCalendar {
     readonly eventChange: _angular_core.OutputEmitterRef<WrCalendarEventChange>;
     private readonly adapter;
     private readonly document;
+    private readonly dir;
     private readonly chipTpl;
     protected readonly todayLabel: string;
     protected readonly previousLabel: string;
@@ -254,7 +255,13 @@ declare class WrEventCalendar {
     /** Only what overlaps the window — everything downstream works off this. */
     private readonly visible;
     protected readonly title: _angular_core.Signal<string>;
-    protected readonly weekdayNames: _angular_core.Signal<string[]>;
+    /**
+     * The adapter contract is "names ordered from `getFirstDayOfWeek()` onwards",
+     * so the list is ALREADY rotated. Rotating it again here put every column one
+     * day out for every locale whose week does not start on Sunday — invisible in
+     * en-US, wrong everywhere else. `wr-calendar` consumes the same call directly.
+     */
+    protected readonly weekdayNames: _angular_core.Signal<readonly string[]>;
     protected readonly switcher: _angular_core.Signal<{
         view: WrCalendarView;
         label: string;
@@ -282,6 +289,15 @@ declare class WrEventCalendar {
     protected onCellClick(date: Date, minutes: number): void;
     protected onChipKeyDown(event: KeyboardEvent, chipEvent: WrCalendarEvent): void;
     protected onGridKeyDown(event: KeyboardEvent): void;
+    /**
+     * Keep the roving cursor on the cell that actually has focus.
+     *
+     * The cursor was only ever written by an arrow key, while focus moves for three
+     * other reasons — a click, a Tab onto a chip, Escape out of one — so the next
+     * arrow read a coordinate nobody was standing on and threw focus back to it,
+     * usually the top-left of the grid.
+     */
+    protected onCellFocus(day: number, minutes: number): void;
     protected isCursor(day: number, minutes: number): boolean;
     /**
      * Greedy lane packing for day-spanning chips. Sorted by start then by length,
@@ -323,6 +339,15 @@ declare class WrEventCalendar {
     private spansWholeDay;
     private clock;
     private iso;
+    /**
+     * The key as the grid SEES it.
+     *
+     * A day step follows visual order, so under `dir="rtl"` ArrowRight goes back a
+     * day. Up/Down move by week or by row and never flip; Home/End are semantic.
+     * Both key handlers route through here — the grid nav and the `Alt`+arrow drag,
+     * which moves an event and would otherwise reschedule it the wrong way.
+     */
+    private inlineKey;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<WrEventCalendar, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<WrEventCalendar, "wr-event-calendar", never, { "events": { "alias": "events"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "date": { "alias": "date"; "required": false; "isSignal": true; }; "views": { "alias": "views"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "slotMinutes": { "alias": "slotMinutes"; "required": false; "isSignal": true; }; "dayStartHour": { "alias": "dayStartHour"; "required": false; "isSignal": true; }; "dayEndHour": { "alias": "dayEndHour"; "required": false; "isSignal": true; }; "maxLanes": { "alias": "maxLanes"; "required": false; "isSignal": true; }; "hideHeader": { "alias": "hideHeader"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "view": "viewChange"; "date": "dateChange"; "eventClick": "eventClick"; "slotClick": "slotClick"; "eventChange": "eventChange"; }, ["chipTpl"], never, true, never>;
 }