@cdevhub/ngx-tw 0.4.0 → 0.6.0

package/types/cdevhub-ngx-tw-time-picker.d.ts

@@ -59,6 +59,16 @@ declare class TimePickerIntl {
  *   }),
  * ]
  * ```
+ *
+ * Keys explicitly set to `undefined` are dropped before merging. Root
+ * `tsconfig.json` does not set `exactOptionalPropertyTypes`, so
+ * `provideTimePickerIntl({ hoursLabel: bundle['time.hours'] })` type-checks
+ * even when the lookup misses — and a plain `Object.assign` would then copy
+ * that `undefined` over a field `TimePickerIntl` types as `string`. Because
+ * this is a bootstrap-level provider, one missing key broke *every*
+ * time-picker in the app: `focusedFieldLabel()` calls `.toLowerCase()` on the
+ * field labels to build the stepper aria-labels, so the picker threw on first
+ * render. Filtering here makes a missing key fall back to the English default.
  */
 declare function provideTimePickerIntl(custom: Partial<TimePickerIntl>): Provider;
 
@@ -115,13 +125,13 @@ type TimePickerValidationErrors = Partial<{
     };
 }>;
 declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implements ControlValueAccessor, Validator, OnInit {
-    /** Id on the time-picker's host element. Auto-generated when not provided. Used by the form-field's `<label for>` attribute. */
+    /** Id on the time-picker's host element. Auto-generated when not provided. The accessible name inside a `<tw-form-field>` comes from `aria-labelledby` on the inner `role="group"` wrapper, not from the field's `<label for>` — the host is a custom element, which `for` cannot target. */
     readonly idInput: _angular_core.InputSignal<string | undefined>;
     /** When true, the whole component is disabled and every field sets `aria-disabled="true"`. Defaults to `false`. */
     readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** When true, exposes `aria-required="true"`. Validators.required on a bound NgControl is also honoured. Defaults to `false`. */
     readonly requiredInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** When true, blocks typing, stepping, and the AM/PM toggle — the value is still read-only visible. Defaults to `false`. */
+    /** When true, blocks typing, stepping, and the AM/PM toggle — the value is still read-only visible. Defaults to `false`. Alias: `readonly`. */
     readonly readonlyInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Controls field height, font size, and stepper density. Defaults to `'md'`. */
     readonly size: _angular_core.InputSignal<TwSize>;
@@ -129,7 +139,7 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly color: _angular_core.InputSignal<TwColor>;
     /** Visual style of the chrome. `'default'` draws its own border; `'naked'` strips chrome. Auto-resolves to `'naked'` inside `<tw-form-field>`. */
     readonly variant: _angular_core.InputSignal<TimePickerVariant | undefined>;
-    /** `'12h'` renders 1–12 hours with an AM/PM toggle; `'24h'` renders 00–23. Defaults to `'24h'`. */
+    /** `'12h'` renders 1–12 hours with an AM/PM toggle; `'24h'` renders 00–23. The same axis is spelled `timeFormat` on `tw-date-range-picker` and lives under `timeConfig.format` on `tw-date-picker`, where `format` instead means the display-format descriptor. Defaults to `'24h'`. */
     readonly format: _angular_core.InputSignal<TimePickerFormat>;
     /** When true, renders a seconds field after minutes. Defaults to `false`. */
     readonly showSeconds: _angular_core.InputSignal<boolean>;
@@ -147,21 +157,21 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly referenceDate: _angular_core.InputSignal<D | null>;
     /** Placeholder shown in each field when empty. Defaults to `'--'`. */
     readonly placeholder: _angular_core.InputSignal<string | undefined>;
-    /** Whether to render the up/down stepper column. Defaults to `true`. */
+    /** Whether to render the up/down stepper column. Defaults to `true`. Pointer users expect inline up/down chevrons next to a numeric editor; without them the picker reads as a static display and consumers must rebuild stepping for every instance. Ignored at `size="xs"` on the bordered `default` variant, where the 24px control leaves no room for a stacked pair — use ↑/↓ on a field instead. */
     readonly showSteppers: _angular_core.InputSignal<boolean>;
-    /** Whether to render the clear affordance when a value is set. Defaults to `true`. */
+    /** Whether to render the clear affordance when a value is set. Defaults to `true` — it matches `<tw-date-picker>` and `<tw-input>` clear behaviour; without the inline clear every form has to wire its own reset surface for an obvious affordance. */
     readonly showClear: _angular_core.InputSignal<boolean>;
-    /** Accessible label for the clear button. Defaults to `'Clear time'`. */
+    /** Accessible label for the clear button. Note the name differs in meaning from the date pickers, which spell this `clearAriaLabel` and reserve `clearLabel` for the overlay action bar's visible button text. Defaults to `'Clear time'`. */
     readonly clearLabel: _angular_core.InputSignal<string>;
-    /** Per-instance override of the `ErrorStateMatcher`. */
+    /** Per-instance override of the `ErrorStateMatcher`. Defaults to `undefined`. */
     readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | undefined>;
-    /** Accessible name for the fields group. Required when no visible label is supplied. Alias: `aria-label`. */
+    /** Accessible name for the fields group. Required when no visible label is supplied. Alias: `aria-label`. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
-    /** ID of an external element that labels the group. Alias: `aria-labelledby`. */
+    /** ID of an external element that labels the group. Alias: `aria-labelledby`. Defaults to `undefined`. */
     readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
-    /** Consumer-supplied `aria-describedby` ids. The form-field preserves these when merging hint/error ids. Alias: `aria-describedby`. */
+    /** Consumer-supplied `aria-describedby` ids. The form-field preserves these when merging hint/error ids. Alias: `aria-describedby`. Defaults to `undefined`. */
     readonly userAriaDescribedByInput: _angular_core.InputSignal<string | undefined>;
-    /** Two-way bound current time. `null` when empty. Setting programmatically updates the fields without firing `onChange`. */
+    /** Two-way bound current time. `null` when empty. Setting programmatically updates the fields without firing `onChange`. Defaults to `null`. */
     readonly value: _angular_core.ModelSignal<D | null>;
     /** Fires on every keystroke, stepper press, or AM/PM toggle — before the new value is committed. */
     readonly timeInput: _angular_core.OutputEmitterRef<TimePickerInputEvent<D>>;
@@ -175,9 +185,6 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     private readonly injector;
     private readonly formField;
     private ngControl;
-    private readonly parentForm;
-    private readonly parentFormGroup;
-    private readonly defaultMatcher;
     /** @internal — exposed for the template; consumers configure via `provideTimePickerIntl()`. */
     protected readonly intl: TimePickerIntl;
     private readonly hourInputRef;
@@ -200,9 +207,10 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly internalValue: _angular_core.WritableSignal<D | null>;
     private readonly cvaDisabled;
     private readonly describedByIdsSignal;
+    private readonly labelledByIdsSignal;
     private readonly focusedSignal;
-    private readonly _ngControlRev;
-    private readonly _formSubmitRev;
+    /** @internal Shared `errorState` / `required` / `errors` derivation — see `wireErrorState`. */
+    private readonly errorWiring;
     /** When true, an effect should not rewrite field text from the external value. */
     private editing;
     private onChange;
@@ -213,6 +221,23 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly isEmpty: Signal<boolean>;
     /** @internal Effective variant — auto-naked when wrapped in tw-form-field. */
     readonly resolvedVariant: Signal<TimePickerVariant>;
+    /**
+     * @internal Whether the stepper column actually renders.
+     *
+     * `showSteppers` stays the consumer's switch, but the column is geometrically
+     * impossible at `size="xs"` on the bordered `default` variant: the pinned h-6
+     * root is 24px border-box, leaving a 22px content box, while a stacked pair of
+     * chevron buttons has a 24px min-content height (2 × size-3). Rendering it
+     * anyway would either overflow the shell or squeeze each button to 11px — far
+     * under any usable pointer target. The `naked` variant keeps its steppers: it
+     * draws no border, so in the date-picker / date-range-picker overlay footers a
+     * 24px row leaves a full 24px content box and the pair fits exactly. (Inside
+     * `<tw-form-field>` the row is governed by the field's own padding and its
+     * `min-h-*` floor, which is a minimum — the row grows rather than clipping.)
+     * Stepping stays available everywhere via ↑/↓ on a focused field, so nothing
+     * becomes unreachable.
+     */
+    readonly steppersVisible: Signal<boolean>;
     /** @internal */
     readonly hourMin: Signal<number>;
     /** @internal */
@@ -231,8 +256,23 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     readonly secondValueNow: Signal<number | null>;
     /** @internal */
     readonly secondValueText: Signal<string>;
-    /** @internal */
-    readonly groupAriaLabel: Signal<string>;
+    /**
+     * @internal Merged `aria-labelledby` for the `role="group"` wrapper: the ids a
+     * wrapping `<tw-form-field>` pushes down (its projected `<label twLabel>` plus
+     * anything the consumer supplied) or, standalone, the consumer's own
+     * `aria-labelledby`. The host is `<tw-time-picker>`, a custom element the
+     * field's `<label for>` cannot target, so this attribute is the only route
+     * from the visible label to the composite. Returns `null` when nothing labels
+     * the group by reference.
+     */
+    readonly groupLabelledBy: Signal<string | null>;
+    /**
+     * @internal `aria-label` for the group. An explicit `aria-label` always wins;
+     * otherwise the generic intl fallback is suppressed whenever `groupLabelledBy`
+     * already names the group, so a real label is not shadowed by "Time" in the
+     * accessibility tree inspector.
+     */
+    readonly groupAriaLabel: Signal<string | null>;
     /** @internal Label of the currently focused field, used by stepper aria-labels. */
     readonly focusedFieldLabel: Signal<string>;
     /** @internal */
@@ -254,12 +294,27 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     /** @internal */ readonly focused: Signal<boolean>;
     /** @internal */ readonly empty: Signal<boolean>;
     /** @internal */ readonly disabled: Signal<boolean>;
-    /** @internal */ readonly required: Signal<boolean>;
+    /**
+     * Whether the control is required — the `required` input OR `Validators.required`
+     * on a bound `NgControl`. Bound to `aria-required` on each spinbutton field, not on
+     * the `role="group"` wrapper, which does not permit the attribute.
+     */
+    readonly required: Signal<boolean>;
     /** @internal */
     readonly errorState: Signal<boolean>;
+    /**
+     * @internal Active validation errors map from the bound `NgControl` (or `null` when the
+     * control reports none / is unbound). This is what `[twError match="…"]` filters on inside a
+     * `<tw-form-field>`; without it every `match`-targeted message — including the
+     * `timePickerMin` / `timePickerMax` codes this component's `NG_VALIDATORS` apparatus exists
+     * to produce — stays permanently hidden.
+     */
+    readonly errors: Signal<Record<string, unknown> | null>;
     /** @internal */ readonly controlType = "time-picker";
     /** @internal */
     readonly userAriaDescribedBy: Signal<string | undefined>;
+    /** @internal Consumer-supplied `aria-labelledby`, surfaced so the wrapping form-field merges it into the ids it pushes back rather than replacing it. */
+    readonly userAriaLabelledby: Signal<string | undefined>;
     constructor();
     ngOnInit(): void;
     /** Moves focus to the hours field. */
@@ -318,6 +373,8 @@ declare class TimePickerComponent<D = Date> extends FormFieldControl<D> implemen
     setDisabledState(isDisabled: boolean): void;
     /** @internal */
     setDescribedByIds(ids: string[]): void;
+    /** @internal Receives the merged `aria-labelledby` ids from the wrapping form-field and applies them to the `role="group"` wrapper. Required because the host is a custom element rather than a labelable control, so the field's `<label for>` never reaches it. */
+    setLabelledByIds(ids: string[]): void;
     /** @internal */
     onContainerClick(event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerComponent<any>, never>;

package/types/cdevhub-ngx-tw-timeline.d.ts

@@ -12,19 +12,38 @@ type TimelineAlign = 'left' | 'right' | 'alternate' | 'split';
 type TimelineLineStyle = 'solid' | 'dashed';
 /** Visibility policy for the horizontal-overflow chevron buttons. */
 type TimelineScrollControls = 'auto' | 'always' | 'never';
-/** Localisable labels for the horizontal-overflow chevron buttons on `tw-timeline`. */
+/**
+ * Localisable labels for the horizontal-overflow chevron buttons on
+ * `tw-timeline`.
+ *
+ * Every member is optional. This interface only ever reaches consumers through
+ * `provideTwTimelineScrollLabels(labels: Partial<TwTimelineScrollLabels>)`, and
+ * unset keys fall back to {@link DEFAULT_TW_TIMELINE_SCROLL_LABELS} — so a
+ * consumer who annotates a complete literal must not be forced to restate keys
+ * they do not override, and adding a label in a future minor must not break
+ * them on a non-major release. `scrollRegion` was already optional for exactly
+ * this reason when it was added after the interface shipped; making the other
+ * two optional is the structural version of the same fix, so the next added
+ * label does not reproduce the break.
+ */
 interface TwTimelineScrollLabels {
     /** Accessible label for the previous-scroll chevron. Used as `aria-label`. Defaults to `'Scroll to previous events'`. */
-    scrollPrevious: string;
+    scrollPrevious?: string;
     /** Accessible label for the next-scroll chevron. Used as `aria-label`. Defaults to `'Scroll to next events'`. */
-    scrollNext: string;
+    scrollNext?: string;
+    /** Accessible label for the horizontal scroll viewport, which is a keyboard-focusable scrollable region. Defaults to `'Timeline events'`. */
+    scrollRegion?: string;
 }
-/** Default English labels used when `TW_TIMELINE_SCROLL_LABELS` is not provided. */
-declare const DEFAULT_TW_TIMELINE_SCROLL_LABELS: TwTimelineScrollLabels;
+/**
+ * Default English labels used when `TW_TIMELINE_SCROLL_LABELS` is not provided.
+ * Typed `Required<TwTimelineScrollLabels>` so readers keep a non-optional
+ * `string` for every key even though the interface itself is all-optional.
+ */
+declare const DEFAULT_TW_TIMELINE_SCROLL_LABELS: Required<TwTimelineScrollLabels>;
 /**
  * Injection token carrying localisable `aria-label` strings for the timeline's
- * horizontal-overflow chevron buttons. The container uses these labels exclusively
- * on the prev/next buttons; they do not affect any other rendered text.
+ * horizontal-overflow affordances — the prev/next chevron buttons and the
+ * scrollable viewport between them. They do not affect any other rendered text.
  *
  * Provide via `provideTwTimelineScrollLabels({ ... })` at the root or feature level.
  * If both keys are present they override the English defaults; if only one is present
@@ -129,19 +148,24 @@ declare class TimelineComponent {
     private readonly _directionality;
     private readonly _viewportRef;
     private readonly _scrollLabelsOverride;
-    /** @internal Live `dir` from CDK `Directionality`. */
+    /**
+     * @internal Live `dir` from CDK `Directionality`. Read straight from
+     * `valueSignal` (CDK 22+) so `_isRtl` re-evaluates on a runtime `dir` flip
+     * with no manual subscription mirror.
+     */
     private readonly _cdkDir;
     /** @internal True when the host renders inside a `dir="rtl"` ancestor. */
     readonly _isRtl: _angular_core.Signal<boolean>;
     /**
-     * @internal Defaults to `false` until the first measurement runs in
-     * `afterNextRender`. This avoids a one-frame "enabled-then-disabled" flash
-     * where the buttons appear live before the scroll state has been read.
+     * @internal Defaults to `false` until the first measurement runs in the
+     * `afterRenderEffect` in the constructor. This avoids a one-frame
+     * "enabled-then-disabled" flash where the buttons appear live before the
+     * scroll state has been read.
      */
     readonly _canScrollPrev: _angular_core.WritableSignal<boolean>;
     readonly _canScrollNext: _angular_core.WritableSignal<boolean>;
     /** @internal Resolved label record. Falls back to English defaults for any missing key. */
-    readonly scrollLabels: _angular_core.Signal<TwTimelineScrollLabels>;
+    readonly scrollLabels: _angular_core.Signal<Required<TwTimelineScrollLabels>>;
     /** @internal True when the prev button should be aria-hidden + visually suppressed. */
     readonly _prevButtonHidden: _angular_core.Signal<boolean>;
     /** @internal True when the next button should be aria-hidden + visually suppressed. */

package/types/cdevhub-ngx-tw-toast.d.ts

@@ -88,6 +88,17 @@ declare class ToastRef<C = unknown, R = unknown> {
     private enterTimer;
     private leaveTimer;
     constructor(id: string, content: ToastContent, config: ToastConfig<unknown, R>, dismissCallback: (ref: ToastRef) => void);
+    /**
+     * @internal Start the enter animation clock. Called by the service once the
+     * toast has actually been attached to its container.
+     *
+     * This deliberately does NOT run from the constructor. The renderer is loaded
+     * through a dynamic `import()`, so a ref can exist for an arbitrary stretch
+     * before anything is on screen — starting the clock at construction would let
+     * a toast burn part (or all) of its auto-dismiss duration while still
+     * invisible on a slow connection. Idempotent and safe to call after dismissal.
+     */
+    _startEnterSequence(): void;
     /**
      * Dismiss the toast programmatically. The leave animation plays before the
      * element is removed and subscribers are notified. Safe to call multiple times.
@@ -165,7 +176,16 @@ declare class ToastConfig<D = unknown, _R = unknown> {
     severity?: ToastSeverity;
     /** Screen position of the toast stack. Defaults to `'bottom-right'`. */
     position?: ToastPosition;
-    /** Auto-dismiss duration in ms. `0` disables auto-dismiss. Defaults to `5000`. */
+    /**
+     * Auto-dismiss duration in ms. `0` disables auto-dismiss. Defaults to `5000`.
+     *
+     * The duration alone would fail SC 2.2.1 (Timing Adjustable) — a time limit the
+     * user cannot influence. What makes 5s conformant is `pauseOnInteraction`
+     * (default `true`): the clock stops while the pointer is over the toast or
+     * focus is anywhere inside it, and resumes on leave / blur. Setting
+     * `pauseOnInteraction: false` alongside a non-zero duration re-introduces the
+     * failure, so pair it with `duration: 0`.
+     */
     duration?: number;
     /** When true, renders a close (×) button. Defaults to `true`. */
     dismissible?: boolean;
@@ -190,7 +210,7 @@ declare class ToastConfig<D = unknown, _R = unknown> {
      * primitives for the string-content path.
      */
     icon?: string | false;
-    /** When true, pause the auto-dismiss timer while the toast is hovered or holds focus. Defaults to `true`. */
+    /** When true, pause the auto-dismiss timer while the toast is hovered or holds focus anywhere inside it, resuming on leave / blur. Defaults to `true`. */
     pauseOnInteraction?: boolean;
     /** Enable horizontal swipe-to-dismiss via pointer gestures. Defaults to `true`. */
     swipeToDismiss?: boolean;
@@ -215,6 +235,11 @@ declare const TW_TOAST_DEFAULT_OPTIONS: InjectionToken<Partial<ToastConfig<unkno
 /** Accepted content forms for `ToastService.show()`. */
 type ToastContent = string | TemplateRef<ToastTemplateContext> | Type<unknown>;
 
+/**
+ * The three messages {@link ToastService.promise} shows as a promise settles.
+ * `success` and `error` may be functions, receiving the resolved value or the
+ * rejection reason so the message can quote it.
+ */
 interface PromiseMessages<T> {
     loading: string;
     success: string | ((value: T) => string);
@@ -225,14 +250,22 @@ interface PromiseMessages<T> {
  * created per `ToastPosition` on first use and reused for the lifetime of the
  * service; toasts stack vertically inside their position container.
  *
+ * The rendering layer (CDK overlay + the toast components) is loaded through a
+ * dynamic `import()` on the first `show()` call, so merely registering this
+ * service costs nothing in the initial bundle. Every open method still returns
+ * its {@link ToastRef} synchronously — the toast is attached once the chunk
+ * lands, and `update()` / `dismiss()` called in the meantime are honoured.
+ *
  * Not `providedIn: 'root'` — register via {@link provideToast}.
  */
 declare class ToastService implements OnDestroy {
-    private readonly overlay;
     private readonly injector;
     private readonly defaultOptions;
     private readonly parent;
-    private readonly positionOverlays;
+    /** Cached renderer chunk. Non-null once the first `show()` has kicked off the import. */
+    private rendererPromise;
+    private renderer;
+    private destroyed;
     private readonly activeRefsAtThisLevel;
     private readonly afterOpenedSubject;
     private readonly afterAllDismissedSubject;
@@ -273,14 +306,30 @@ declare class ToastService implements OnDestroy {
     ngOnDestroy(): void;
     private openWithSeverity;
     private openInternal;
+    /**
+     * Attach a toast once the renderer chunk has loaded. The ref was already
+     * returned to the caller, so it may have been dismissed (or the service
+     * destroyed) while the import was in flight — both are checked before
+     * anything is put on screen.
+     */
+    private attachWhenRendererReady;
+    /**
+     * @internal Resolves once the renderer chunk has loaded and pending toasts
+     * have been attached. Exposed for tests, which must await the dynamic import
+     * before asserting on rendered DOM.
+     */
+    _whenRendered(): Promise<void>;
+    /** Load (once) and instantiate the rendering layer. Resolves to `null` if the service was destroyed mid-import. */
+    private loadRenderer;
     private enforceMaxVisible;
     private registerOpen;
     private handleDismissed;
-    private attachToContainer;
-    private announceOpen;
+    /**
+     * Re-announce an updated toast. If the renderer has not landed yet there is
+     * nothing on screen to announce — the announcement that fires on attach
+     * reads the ref's current (already updated) content, so nothing is lost.
+     */
     private announceUpdate;
-    private getContainerForPosition;
-    private buildPositionStrategy;
     private resolveConfig;
     private getAfterAllDismissedSource;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
@@ -341,7 +390,7 @@ declare class ToastActionDirective {
 declare class ToastComponent {
     /** Severity variant. Drives color palette, default icon, and ARIA role / live politeness. Defaults to `'info'`. */
     readonly severity: _angular_core.InputSignal<ToastSeverity>;
-    /** Whether to render the close button. Defaults to `true`. */
+    /** Whether to render the close button. Defaults to `true` — mirroring `ToastConfig.dismissible`, toasts must offer an escape hatch; the special case is an ephemeral progress marker paired with `duration`. */
     readonly dismissible: _angular_core.InputSignal<boolean>;
     /**
      * Icon override. Pass a string to render as text inside the icon slot, or
@@ -351,7 +400,7 @@ declare class ToastComponent {
      * For arbitrary icon markup, project a `[twToastIcon]` child instead.
      */
     readonly icon: _angular_core.InputSignal<string | false | undefined>;
-    /** Explicit aria-label for the toast wrapper. When omitted, text content is used by assistive tech. */
+    /** Explicit aria-label for the toast wrapper. Mirrored to `aria-label`. When omitted, text content is used by assistive tech. Defaults to `undefined`. */
     readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
     /** Fires when the close button is clicked. */
     readonly dismissed: _angular_core.OutputEmitterRef<void>;
@@ -381,8 +430,8 @@ declare class ToastComponent {
     /** @internal */
     protected readonly ariaLiveAttr: _angular_core.Signal<"polite" | "assertive">;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "tw-toast", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; "actionClicked": "actionClicked"; }, ["projectedIcon"], ["[twToastIcon]", "[twToastTitle]", "[twToastDescription]", "*", "[twToastAction]"], true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "tw-toast", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; "actionClicked": "actionClicked"; }, ["projectedIcon"], ["[twToastIcon]", "[twToastTitle]", "[twToastDescription]", "*", "[twToastAction]"], true, never>;
 }
 
 export { TW_TOAST_DATA, TW_TOAST_DEFAULT_OPTIONS, TW_TOAST_REF, ToastActionDirective, ToastComponent, ToastConfig, ToastDescriptionDirective, ToastIconDirective, ToastRef, ToastService, ToastTitleDirective, provideToast };
-export type { ToastAction, ToastContent, ToastDismissReason, ToastDismissal, ToastPosition, ToastSeverity, ToastState, ToastTemplateContext, ToastUpdatePatch };
+export type { PromiseMessages, ToastAction, ToastContent, ToastDismissReason, ToastDismissal, ToastPosition, ToastSeverity, ToastState, ToastTemplateContext, ToastUpdatePatch };

package/types/cdevhub-ngx-tw-tooltip.d.ts

@@ -20,17 +20,19 @@ declare class TooltipDirective {
      */
     readonly twTooltipShowDelay: _angular_core.InputSignal<number>;
     /**
-     * Milliseconds to wait before hiding after trigger ends. Defaults to `0`
-     * (immediate dismiss). The asymmetry with `twTooltipShowDelay` is
-     * intentional — show is gated to filter noise, hide is instant so the
-     * tooltip never lingers over content the user has moved on from.
+     * Milliseconds to wait before hiding after the trigger is left. Defaults to
+     * `150` — a grace period, not a lingering delay: WCAG 2.1 SC 1.4.13 requires
+     * the tooltip to be hoverable, and the panel sits 8px clear of its trigger,
+     * so the pointer needs a window in which to cross that gap. Hovering the
+     * panel itself cancels the pending hide entirely. Set `0` to opt out (the
+     * tooltip is then dismissible by Escape but not reachable by pointer).
      */
     readonly twTooltipHideDelay: _angular_core.InputSignal<number>;
     /** When true, tooltip never shows. Defaults to `false`. */
     readonly twTooltipDisabled: _angular_core.InputSignal<boolean>;
-    /** When true, renders an arrow pointing to the trigger. Defaults to `true`. */
+    /** When true, renders an arrow pointing to the trigger. Defaults to `true` — arrows reinforce the visual association between the floating panel and its trigger and match every other ngx-tw overlay (popover, menu); the special case is a compact iconic context. */
     readonly twTooltipArrow: _angular_core.InputSignal<boolean>;
-    /** Optional class string (space-separated) merged into the panel slot for consumer customization. */
+    /** Optional class string (space-separated) merged into the panel slot for consumer customization. Defaults to an empty string. */
     readonly twTooltipPanelClass: _angular_core.InputSignal<string>;
     /** Fires when the tooltip becomes visible. */
     readonly twTooltipShown: _angular_core.OutputEmitterRef<void>;
@@ -41,9 +43,18 @@ declare class TooltipDirective {
     private readonly destroyRef;
     private readonly ariaDescriber;
     private overlayRef;
+    /**
+     * The live position strategy. Held as a field so every show can re-apply
+     * `twTooltipPosition` onto it — see `applyPositions`.
+     */
+    private positionStrategy;
+    /** The `twTooltipPosition` value currently baked into `positionStrategy`. */
+    private appliedPosition;
     private tooltipInstance;
     private showTimer;
     private hideTimer;
+    /** Removes the panel's hover listeners. Set in `createOverlay`, invoked from `disposeOverlay`. */
+    private overlayHoverCleanup;
     /** Last description string handed to `AriaDescriber.describe` — required so the symmetrical `removeDescription` call passes the same key. */
     private _describedBy;
     /** True when the trigger's `aria-describedby` was set directly to the overlay id (TemplateRef fallback path); used by `removeAriaDescription` to choose the symmetrical teardown. */
@@ -64,6 +75,17 @@ declare class TooltipDirective {
     protected onTouchEnd(): void;
     private createAndShow;
     private createOverlay;
+    /**
+     * Pushes the current `twTooltipPosition` onto the live position strategy.
+     *
+     * Updating the strategy in place rather than disposing the `OverlayRef` on
+     * hide is not just the cheaper option — it is the correct one. `createOverlay`
+     * subscribes to `positionStrategy.positionChanges` exactly once, and that feed
+     * is what drives the arrow direction; `FlexibleConnectedPositionStrategy`
+     * completes that subject in `dispose()`, so a dispose-on-hide would silently
+     * kill arrow placement from the second show onward.
+     */
+    private applyPositions;
     private updateTooltip;
     private detach;
     /**

package/types/cdevhub-ngx-tw-transfer-testing.d.ts

@@ -0,0 +1,152 @@
+import { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+
+/** Filters accepted by `TransferItemHarness.with`. */
+interface TransferItemHarnessFilters extends BaseHarnessFilters {
+    /** Match by the row's visible text. */
+    text?: string | RegExp;
+    /** Match ticked / unticked rows. */
+    checked?: boolean;
+    /** Match disabled / enabled rows. */
+    disabled?: boolean;
+}
+/**
+ * Harness for a single row inside one of a `tw-transfer`'s two panels.
+ *
+ * Rows are `CdkOption`s, so the harness reads ARIA that CDK owns rather than
+ * anything ngx-tw renders: `aria-selected` for the ticked state and
+ * `aria-disabled` for the per-item disable predicate.
+ *
+ * "Checked" here is the *ephemeral pending-move* state — which rows the next
+ * move button press will shuttle — not membership of a side. Membership is the
+ * component's value; read it by asking {@link TransferHarness} which panel a
+ * row is in.
+ *
+ * Reach these through {@link TransferHarness.getItems}: located from a document
+ * root the selector would match every listbox option on the page.
+ */
+declare class TransferItemHarness extends ComponentHarness {
+    static hostSelector: string;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: TransferItemHarnessFilters): HarnessPredicate<TransferItemHarness>;
+    /**
+     * The row's rendered text, trimmed. With the default row rendering this is
+     * `labelFn(item)`; a projected `*twTransferItem` template makes it whatever
+     * that template renders.
+     */
+    getText(): Promise<string>;
+    /** Whether the row is ticked for the next move, from `aria-selected`. */
+    isChecked(): Promise<boolean>;
+    /** Whether the row reports `aria-disabled="true"` (`behavior.disabledItem`). */
+    isDisabled(): Promise<boolean>;
+    /** Ticks the row for the next move. No-op when already ticked. */
+    check(): Promise<void>;
+    /** Unticks the row. No-op when already unticked. */
+    uncheck(): Promise<void>;
+}
+
+/**
+ * Which panel of a `tw-transfer` a call addresses. Structurally identical to
+ * the component's own `TwTransferSide`, redeclared here so the testing entry
+ * point stays free of any import from the component entry point.
+ */
+type TransferHarnessSide = 'source' | 'target';
+/** Filters accepted by `TransferHarness.with`. */
+interface TransferHarnessFilters extends BaseHarnessFilters {
+    /** Match by the control's accessible name (its `aria-label`). */
+    label?: string | RegExp;
+    /** Match disabled / enabled controls. */
+    disabled?: boolean;
+}
+/**
+ * Harness for `tw-transfer`.
+ *
+ * ## How the two panels are told apart
+ *
+ * The panels are one `ng-template` instantiated twice, and neither the panel
+ * element nor its list carries a side marker. The only per-side hook the
+ * component renders is the auto-generated panel-title id — `…-source-title` /
+ * `…-target-title` — which the listbox references through `aria-labelledby`
+ * and which the component's own `focusDestination()` already matches on for
+ * the same reason. This harness scopes every per-side query with a suffix
+ * match on that id.
+ *
+ * Two consequences worth knowing:
+ *
+ * - Ordering is never assumed, so a panel that has emptied (its listbox is
+ *   removed entirely — an empty `role="listbox"` violates
+ *   `aria-required-children`) does not shift the other panel's identity.
+ *   {@link getItems} simply returns `[]` for the empty side.
+ * - The hook is a derived id, not a declared contract. If the panels ever gain
+ *   a real marker attribute, this is the code that should move onto it.
+ *
+ * The whole control lives inside the `tw-transfer` host — there is no CDK
+ * overlay — so the ordinary fixture loader is enough.
+ */
+declare class TransferHarness extends ComponentHarness {
+    static hostSelector: string;
+    /**
+     * The move buttons, in DOM order: `[0]` shuttles source → target and `[1]`
+     * target → source (absent under `behavior.oneWay`).
+     *
+     * The `:not()` excludes buttons a consumer projected into a
+     * `*twTransferItem` template, which would otherwise be picked up ahead of
+     * the real controls — rows render before the button column.
+     */
+    private readonly moveButtons;
+    /** Predicate for `locatorFor` / `locatorForAll`. */
+    static with(options?: TransferHarnessFilters): HarnessPredicate<TransferHarness>;
+    /** The control's accessible name, from `aria-label` when one is set. */
+    getLabel(): Promise<string | null>;
+    /** Whether the control reports `aria-disabled="true"`. */
+    isDisabled(): Promise<boolean>;
+    /** The title rendered in a panel's header. */
+    getTitle(side: TransferHarnessSide): Promise<string>;
+    /**
+     * Every visible row in a panel, in render order. Returns `[]` for a panel
+     * with nothing in it — including one hidden behind a search query, since
+     * filtering removes rows from the DOM rather than hiding them.
+     *
+     * `filters.ancestor` is ignored: picking the side *is* the ancestor.
+     */
+    getItems(side: TransferHarnessSide, filters?: TransferItemHarnessFilters): Promise<TransferItemHarness[]>;
+    /** The visible text of every row in a panel, in render order. */
+    getItemTexts(side: TransferHarnessSide): Promise<string[]>;
+    /**
+     * How many rows a panel is showing. This is the number the panel header's
+     * count also reports, so it tracks the search query rather than total
+     * membership.
+     */
+    getItemCount(side: TransferHarnessSide): Promise<number>;
+    /**
+     * Ticks the first row in a panel whose text matches, staging it for the next
+     * move. Throws when nothing matches, rather than failing silently.
+     */
+    checkItem(side: TransferHarnessSide, text: string | RegExp): Promise<void>;
+    /**
+     * Drives a panel's header select-all checkbox to `checked`, ticking or
+     * clearing every enabled visible row in one gesture. This is how "move
+     * everything" is expressed: `setAllChecked('source', true)` then
+     * {@link moveToTarget}.
+     *
+     * The checkbox is tri-state. From `mixed` a single click resolves to
+     * *checked*, the way a native indeterminate checkbox does, so clearing from
+     * a partial selection takes two clicks — which is what a user does too, and
+     * what this method issues. Everything is ticked in between.
+     *
+     * Throws when the checkbox is not rendered (`display.showSelectAll: false`).
+     */
+    setAllChecked(side: TransferHarnessSide, checked: boolean): Promise<void>;
+    /**
+     * Presses the → button, shuttling the source panel's ticked rows to the
+     * target. Rows that are disabled are skipped by the component.
+     */
+    moveToTarget(): Promise<void>;
+    /**
+     * Presses the ← button, shuttling the target panel's ticked rows back to the
+     * source. Throws under `behavior.oneWay`, where that button is not rendered.
+     */
+    moveToSource(): Promise<void>;
+}
+
+export { TransferHarness, TransferItemHarness };
+export type { TransferHarnessFilters, TransferHarnessSide, TransferItemHarnessFilters };