@angular/material 22.0.0-next.2 → 22.0.0-next.4

package/types/tabs.d.ts

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { InjectionToken, TemplateRef, OnInit, OnChanges, OnDestroy, SimpleChanges, QueryList, ElementRef, AfterContentChecked, AfterContentInit, AfterViewInit, ChangeDetectorRef, EventEmitter } from '@angular/core';
 import { CdkPortal, TemplatePortal, CdkPortalOutlet } from '@angular/cdk/portal';
 import { Subject, BehaviorSubject } from 'rxjs';
-import { FocusKeyManager, FocusableOption, FocusOrigin } from '@angular/cdk/a11y';
+import { FocusableOption, FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y';
 import * as i2 from '@angular/cdk/bidi';
 import { Direction } from '@angular/cdk/bidi';
 import { ThemePalette } from './_palette-chunk.js';
@@ -18,7 +18,6 @@ declare const MAT_TAB_CONTENT: InjectionToken<MatTabContent>;
 /** Decorates the `ng-template` tags and reads out the template from it. */
 declare class MatTabContent {
     template: TemplateRef<any>;
-    constructor(...args: unknown[]);
     static ɵfac: i0.ɵɵFactoryDeclaration<MatTabContent, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<MatTabContent, "[matTabContent]", never, {}, {}, never, never, true, never>;
 }
@@ -99,7 +98,7 @@ declare class MatTab implements OnInit, OnChanges, OnDestroy {
      * Whether the tab is currently active.
      */
     isActive: boolean;
-    constructor(...args: unknown[]);
+    constructor();
     ngOnChanges(changes: SimpleChanges<this>): void;
     ngOnDestroy(): void;
     ngOnInit(): void;
@@ -270,7 +269,7 @@ declare abstract class MatPaginatedTabHeader implements AfterContentChecked, Aft
     readonly selectFocusedIndex: EventEmitter<number>;
     /** Event emitted when a label is focused. */
     readonly indexFocused: EventEmitter<number>;
-    constructor(...args: unknown[]);
+    constructor();
     /** Called when the user has selected an item via the keyboard. */
     protected abstract _itemSelected(event: KeyboardEvent): void;
     ngAfterViewInit(): void;
@@ -423,7 +422,6 @@ declare class MatTabBodyPortal extends CdkPortalOutlet implements OnInit, OnDest
     private _centeringSub;
     /** Subscription to events for when the tab body finishes leaving from center position. */
     private _leavingSub;
-    constructor(...args: unknown[]);
     /** Set initial visibility or set up subscription for changing visibility. */
     ngOnInit(): void;
     /** Clean up centering subscription. */
@@ -497,7 +495,7 @@ declare class MatTabBody implements OnInit, OnDestroy {
     preserveContent: boolean;
     /** The shifted index position of the tab body, where zero represents the active center tab. */
     set position(position: number);
-    constructor(...args: unknown[]);
+    constructor();
     ngOnInit(): void;
     ngOnDestroy(): void;
     /** Sets up the transition events. */
@@ -644,7 +642,7 @@ declare class MatTabGroup implements AfterViewInit, AfterContentInit, AfterConte
     private _groupId;
     /** Whether the tab group is rendered on the server. */
     protected _isServer: boolean;
-    constructor(...args: unknown[]);
+    constructor();
     /**
      * After the content is checked, this component knows what tabs have been defined
      * and what the selected index should be. This is where we can know exactly what position
@@ -776,7 +774,7 @@ declare class MatTabNav extends MatPaginatedTabHeader implements AfterContentIni
     _nextPaginator: ElementRef<HTMLElement>;
     _previousPaginator: ElementRef<HTMLElement>;
     _inkBar: MatInkBar;
-    constructor(...args: unknown[]);
+    constructor();
     protected _itemSelected(): void;
     ngAfterContentInit(): void;
     ngAfterViewInit(): void;
@@ -825,7 +823,7 @@ declare class MatTabLink extends InkBarItem implements AfterViewInit, OnDestroy,
     get rippleDisabled(): boolean;
     /** Unique id for the tab. */
     id: string;
-    constructor(...args: unknown[]);
+    constructor();
     /** Focuses the tab link. */
     focus(): void;
     ngAfterViewInit(): void;

package/types/timepicker.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Signal, ElementRef, OnDestroy, TemplateRef, InputSignalWithTransform, InputSignal, OutputEmitterRef, ModelSignal } from '@angular/core';
+import { InjectionToken, OnDestroy, Signal, TemplateRef, InputSignalWithTransform, InputSignal, OutputEmitterRef, ElementRef, ModelSignal } from '@angular/core';
 import { MatOption } from './_option-chunk.js';
 import { MatOptionParentComponent } from './_option-parent-chunk.js';
 import { ScrollStrategy } from '@angular/cdk/overlay';

package/types/toolbar.d.ts

@@ -20,7 +20,6 @@ declare class MatToolbar implements AfterViewInit {
     color?: string | null;
     /** Reference to all toolbar row elements that have been projected. */
     _toolbarRows: QueryList<MatToolbarRow>;
-    constructor(...args: unknown[]);
     ngAfterViewInit(): void;
     /**
      * Throws an exception when developers are attempting to combine the different toolbar row modes.

package/types/tooltip.d.ts

@@ -1,12 +1,321 @@
-import { MatTooltip, TooltipComponent } from './_tooltip-chunk.js';
-export { MAT_TOOLTIP_DEFAULT_OPTIONS, MAT_TOOLTIP_SCROLL_STRATEGY, MatTooltipDefaultOptions, SCROLL_THROTTLE_MS, TOOLTIP_PANEL_CLASS, TooltipPosition, TooltipTouchGestures, TooltipVisibility, getMatTooltipInvalidPositionError } from './_tooltip-chunk.js';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
 import * as i0 from '@angular/core';
-import * as i1 from '@angular/cdk/a11y';
-import * as i2 from '@angular/cdk/overlay';
+import { OnDestroy, AfterViewInit, ElementRef, InjectionToken } from '@angular/core';
 import * as i2$1 from '@angular/cdk/bidi';
+import { Directionality } from '@angular/cdk/bidi';
+import * as i2 from '@angular/cdk/overlay';
+import { OverlayRef, ConnectedPosition, OriginConnectionPosition, OverlayConnectionPosition, ScrollStrategy } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
+import * as i1 from '@angular/cdk/a11y';
 import * as i1$1 from '@angular/cdk/scrolling';
-import '@angular/cdk/coercion';
-import 'rxjs';
+
+/** Possible positions for a tooltip. */
+type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+/**
+ * Options for how the tooltip trigger should handle touch gestures.
+ * See `MatTooltip.touchGestures` for more information.
+ */
+type TooltipTouchGestures = 'auto' | 'on' | 'off';
+/** Possible visibility states of a tooltip. */
+type TooltipVisibility = 'initial' | 'visible' | 'hidden';
+/** Time in ms to throttle repositioning after scroll events. */
+declare const SCROLL_THROTTLE_MS = 20;
+/**
+ * Creates an error to be thrown if the user supplied an invalid tooltip position.
+ * @docs-private
+ */
+declare function getMatTooltipInvalidPositionError(position: string): Error;
+/** Injection token that determines the scroll handling while a tooltip is visible. */
+declare const MAT_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+/** Injection token to be used to override the default options for `matTooltip`. */
+declare const MAT_TOOLTIP_DEFAULT_OPTIONS: InjectionToken<MatTooltipDefaultOptions>;
+/** Default `matTooltip` options that can be overridden. */
+interface MatTooltipDefaultOptions {
+    /** Default delay when the tooltip is shown. */
+    showDelay: number;
+    /** Default delay when the tooltip is hidden. */
+    hideDelay: number;
+    /** Default delay when hiding the tooltip on a touch device. */
+    touchendHideDelay: number;
+    /** Time between the user putting the pointer on a tooltip trigger and the long press event being fired on a touch device. */
+    touchLongPressShowDelay?: number;
+    /** Default touch gesture handling for tooltips. */
+    touchGestures?: TooltipTouchGestures;
+    /** Default position for tooltips. */
+    position?: TooltipPosition;
+    /**
+     * Default value for whether tooltips should be positioned near the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    positionAtOrigin?: boolean;
+    /** Disables the ability for the user to interact with the tooltip element. */
+    disableTooltipInteractivity?: boolean;
+    /**
+     * Default classes to be applied to the tooltip. These default classes will not be applied if
+     * `tooltipClass` is defined directly on the tooltip element, as it will override the default.
+     */
+    tooltipClass?: string | string[];
+    /**
+     * By default the tooltip attempts to detect whether the user's device is able to hover by
+     * consulting the `Platform` provider that was created a long time ago and is based on
+     * some data points that may not be entirely accurate anymore (e.g. user agent string and
+     * Android/iOS-specific APIs), however changing them will break existing users. You can use this
+     * config property to opt into a more modern detection mechanism.
+     *
+     * The supported values include:
+     *
+     * - `false` - Default value. Detection is based on the `Platform` provider.
+     * - `true` - The tooltip will use the `any-hover` media query for more accurate detection.
+     * Note that this may break existing unit tests running in a headless browser.
+     * - `() => boolean` - If the automatic detection doesn't work properly in your case (e.g. the
+     * `any-hover` media query isn't supported) and you're able to detect more accurately, you can
+     * pass in a function that will be used for detection instead. It should return `true` if the
+     * device **has the ability to hover**, or `false` if it cannot.
+     */
+    detectHoverCapability?: boolean | (() => boolean);
+}
+/**
+ * CSS class that will be attached to the overlay panel.
+ * @deprecated
+ * @breaking-change 13.0.0 remove this variable
+ */
+declare const TOOLTIP_PANEL_CLASS = "mat-mdc-tooltip-panel";
+/**
+ * Directive that attaches a material design tooltip to the host element. Animates the showing and
+ * hiding of a tooltip provided position (defaults to below the element).
+ *
+ * https://material.io/design/components/tooltips.html
+ */
+declare class MatTooltip implements OnDestroy, AfterViewInit {
+    private _elementRef;
+    private _ngZone;
+    private _platform;
+    private _ariaDescriber;
+    private _focusMonitor;
+    protected _dir: Directionality;
+    private _injector;
+    private _viewContainerRef;
+    private _mediaMatcher;
+    private _document;
+    private _renderer;
+    private _animationsDisabled;
+    private _defaultOptions;
+    _overlayRef: OverlayRef | null;
+    _tooltipInstance: TooltipComponent | null;
+    _overlayPanelClass: string[] | undefined;
+    private _portal;
+    private _position;
+    private _positionAtOrigin;
+    private _disabled;
+    private _tooltipClass;
+    private _viewInitialized;
+    private _pointerExitEventsInitialized;
+    private readonly _tooltipComponent;
+    private _viewportMargin;
+    private _currentPosition;
+    private readonly _cssClassPrefix;
+    private _ariaDescriptionPending;
+    private _dirSubscribed;
+    /** Allows the user to define the position of the tooltip relative to the parent element */
+    get position(): TooltipPosition;
+    set position(value: TooltipPosition);
+    /**
+     * Whether tooltip should be relative to the click or touch origin
+     * instead of outside the element bounding box.
+     */
+    get positionAtOrigin(): boolean;
+    set positionAtOrigin(value: BooleanInput);
+    /** Disables the display of the tooltip. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    /** The default delay in ms before showing the tooltip after show is called */
+    get showDelay(): number;
+    set showDelay(value: NumberInput);
+    private _showDelay;
+    /** The default delay in ms before hiding the tooltip after hide is called */
+    get hideDelay(): number;
+    set hideDelay(value: NumberInput);
+    private _hideDelay;
+    /**
+     * How touch gestures should be handled by the tooltip. On touch devices the tooltip directive
+     * uses a long press gesture to show and hide, however it can conflict with the native browser
+     * gestures. To work around the conflict, Angular Material disables native gestures on the
+     * trigger, but that might not be desirable on particular elements (e.g. inputs and draggable
+     * elements). The different values for this option configure the touch event handling as follows:
+     * - `auto` - Enables touch gestures for all elements, but tries to avoid conflicts with native
+     *   browser gestures on particular elements. In particular, it allows text selection on inputs
+     *   and textareas, and preserves the native browser dragging on elements marked as `draggable`.
+     * - `on` - Enables touch gestures for all elements and disables native
+     *   browser gestures with no exceptions.
+     * - `off` - Disables touch gestures. Note that this will prevent the tooltip from
+     *   showing on touch devices.
+     */
+    touchGestures: TooltipTouchGestures;
+    /** The message to be displayed in the tooltip */
+    get message(): string;
+    set message(value: string | number | null | undefined);
+    private _message;
+    /** Classes to be passed to the tooltip. Supports the same syntax as `ngClass`. */
+    get tooltipClass(): string | string[] | Set<string> | {
+        [key: string]: unknown;
+    };
+    set tooltipClass(value: string | string[] | Set<string> | {
+        [key: string]: unknown;
+    });
+    /** Manually-bound passive event listeners. */
+    private readonly _eventCleanups;
+    /** Timer started at the last `touchstart` event. */
+    private _touchstartTimeout;
+    /** Emits when the component is destroyed. */
+    private readonly _destroyed;
+    /** Whether ngOnDestroyed has been called. */
+    private _isDestroyed;
+    constructor();
+    ngAfterViewInit(): void;
+    /**
+     * Dispose the tooltip when destroyed.
+     */
+    ngOnDestroy(): void;
+    /** Shows the tooltip after the delay in ms, defaults to tooltip-delay-show or 0ms if no input */
+    show(delay?: number, origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Hides the tooltip after the delay in ms, defaults to tooltip-delay-hide or 0ms if no input */
+    hide(delay?: number): void;
+    /** Shows/hides the tooltip */
+    toggle(origin?: {
+        x: number;
+        y: number;
+    }): void;
+    /** Returns true if the tooltip is currently visible to the user */
+    _isTooltipVisible(): boolean;
+    /** Create the overlay config and position strategy */
+    private _createOverlay;
+    /** Detaches the currently-attached tooltip. */
+    private _detach;
+    /** Updates the position of the current tooltip. */
+    private _updatePosition;
+    /** Adds the configured offset to a position. Used as a hook for child classes. */
+    protected _addOffset(position: ConnectedPosition): ConnectedPosition;
+    /**
+     * Returns the origin position and a fallback position based on the user's position preference.
+     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
+     */
+    _getOrigin(): {
+        main: OriginConnectionPosition;
+        fallback: OriginConnectionPosition;
+    };
+    /** Returns the overlay position and a fallback position based on the user's preference */
+    _getOverlayPosition(): {
+        main: OverlayConnectionPosition;
+        fallback: OverlayConnectionPosition;
+    };
+    /** Updates the tooltip message and repositions the overlay according to the new message length */
+    private _updateTooltipMessage;
+    /** Updates the tooltip class */
+    private _setTooltipClass;
+    /** Inverts an overlay position. */
+    private _invertPosition;
+    /** Updates the class on the overlay panel based on the current position of the tooltip. */
+    private _updateCurrentPositionClass;
+    /** Binds the pointer events to the tooltip trigger. */
+    private _setupPointerEnterEventsIfNeeded;
+    private _setupPointerExitEventsIfNeeded;
+    private _addListener;
+    private _isTouchPlatform;
+    /** Disables the native browser gestures, based on how the tooltip has been configured. */
+    private _disableNativeGesturesIfNecessary;
+    /** Updates the tooltip's ARIA description based on it current state. */
+    private _syncAriaDescription;
+    /** Determines which events should be routed to the tooltip overlay. */
+    private _overlayEventPredicate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTooltip, "[matTooltip]", ["matTooltip"], { "position": { "alias": "matTooltipPosition"; "required": false; }; "positionAtOrigin": { "alias": "matTooltipPositionAtOrigin"; "required": false; }; "disabled": { "alias": "matTooltipDisabled"; "required": false; }; "showDelay": { "alias": "matTooltipShowDelay"; "required": false; }; "hideDelay": { "alias": "matTooltipHideDelay"; "required": false; }; "touchGestures": { "alias": "matTooltipTouchGestures"; "required": false; }; "message": { "alias": "matTooltip"; "required": false; }; "tooltipClass": { "alias": "matTooltipClass"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * Internal component that wraps the tooltip's content.
+ * @docs-private
+ */
+declare class TooltipComponent implements OnDestroy {
+    private _changeDetectorRef;
+    protected _elementRef: ElementRef<HTMLElement>;
+    _isMultiline: boolean;
+    /** Message to display in the tooltip */
+    message: string;
+    /** Classes to be added to the tooltip. */
+    tooltipClass: string | string[] | {
+        [key: string]: unknown;
+    };
+    /** The timeout ID of any current timer set to show the tooltip */
+    private _showTimeoutId;
+    /** The timeout ID of any current timer set to hide the tooltip */
+    private _hideTimeoutId;
+    /** Element that caused the tooltip to open. */
+    _triggerElement: HTMLElement;
+    /** Amount of milliseconds to delay the closing sequence. */
+    _mouseLeaveHideDelay: number;
+    /** Whether animations are currently disabled. */
+    private _animationsDisabled;
+    /** Reference to the internal tooltip element. */
+    _tooltip: ElementRef<HTMLElement>;
+    /** Whether interactions on the page should close the tooltip */
+    private _closeOnInteraction;
+    /** Whether the tooltip is currently visible. */
+    private _isVisible;
+    /** Subject for notifying that the tooltip has been hidden from the view */
+    private readonly _onHide;
+    /** Name of the show animation and the class that toggles it. */
+    private readonly _showAnimation;
+    /** Name of the hide animation and the class that toggles it. */
+    private readonly _hideAnimation;
+    /**
+     * Shows the tooltip with an animation originating from the provided origin
+     * @param delay Amount of milliseconds to the delay showing the tooltip.
+     */
+    show(delay: number): void;
+    /**
+     * Begins the animation to hide the tooltip after the provided delay in ms.
+     * @param delay Amount of milliseconds to delay showing the tooltip.
+     */
+    hide(delay: number): void;
+    /** Returns an observable that notifies when the tooltip has been hidden from view. */
+    afterHidden(): Observable<void>;
+    /** Whether the tooltip is being displayed. */
+    isVisible(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Interactions on the HTML body should close the tooltip immediately as defined in the
+     * material design spec.
+     * https://material.io/design/components/tooltips.html#behavior
+     */
+    _handleBodyInteraction(): void;
+    /**
+     * Marks that the tooltip needs to be checked in the next change detection run.
+     * Mainly used for rendering the initial text before positioning a tooltip, which
+     * can be problematic in components with OnPush change detection.
+     */
+    _markForCheck(): void;
+    _handleMouseLeave({ relatedTarget }: MouseEvent): void;
+    /**
+     * Callback for when the timeout in this.show() gets completed.
+     * This method is only needed by the mdc-tooltip, and so it is only implemented
+     * in the mdc-tooltip, not here.
+     */
+    protected _onShow(): void;
+    /** Whether the tooltip text has overflown to the next line */
+    private _isTooltipMultiline;
+    /** Event listener dispatched when an animation on the tooltip finishes. */
+    _handleAnimationEnd({ animationName }: AnimationEvent): void;
+    /** Cancels any pending animation sequences. */
+    _cancelPendingAnimations(): void;
+    /** Handles the cleanup after an animation has finished. */
+    private _finalizeAnimation;
+    /** Toggles the visibility of the tooltip element. */
+    private _toggleVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "mat-tooltip-component", never, {}, {}, never, never, true, never>;
+}
 
 declare class MatTooltipModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<MatTooltipModule, never>;
@@ -14,4 +323,5 @@ declare class MatTooltipModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<MatTooltipModule>;
 }
 
-export { MatTooltip, MatTooltipModule, TooltipComponent };
+export { MAT_TOOLTIP_DEFAULT_OPTIONS, MAT_TOOLTIP_SCROLL_STRATEGY, MatTooltip, MatTooltipModule, SCROLL_THROTTLE_MS, TOOLTIP_PANEL_CLASS, TooltipComponent, getMatTooltipInvalidPositionError };
+export type { MatTooltipDefaultOptions, TooltipPosition, TooltipTouchGestures, TooltipVisibility };

package/types/tree.d.ts

@@ -1,7 +1,7 @@
 import * as i1 from '@angular/cdk/tree';
-import { CdkTreeNode, CdkTreeNodeDef, CdkNestedTreeNode, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, TreeControl, FlatTreeControl } from '@angular/cdk/tree';
+import { CdkNestedTreeNode, CdkTreeNodeDef, CdkTreeNode, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, FlatTreeControl, TreeControl } from '@angular/cdk/tree';
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, AfterContentInit, ViewContainerRef } from '@angular/core';
+import { AfterContentInit, OnDestroy, OnInit, ViewContainerRef } from '@angular/core';
 import * as i2 from '@angular/cdk/bidi';
 import { DataSource, CollectionViewer } from '@angular/cdk/collections';
 import { Observable } from 'rxjs';
@@ -39,7 +39,7 @@ declare class MatTreeNode<T, K = T> extends CdkTreeNode<T, K> implements OnInit,
      */
     get disabled(): boolean;
     set disabled(value: boolean);
-    constructor(...args: unknown[]);
+    constructor();
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNode<any, any>, never>;