@angular/cdk 19.2.3 → 20.0.0-next.1

package/tree-key-manager-strategy.d-603161dd.d.ts

@@ -0,0 +1,116 @@
+import { QueryList } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+
+/** Represents an item within a tree that can be passed to a TreeKeyManager. */
+interface TreeKeyManagerItem {
+    /** Whether the item is disabled. */
+    isDisabled?: (() => boolean) | boolean;
+    /** The user-facing label for this item. */
+    getLabel?(): string;
+    /** Perform the main action (i.e. selection) for this item. */
+    activate(): void;
+    /** Retrieves the parent for this item. This is `null` if there is no parent. */
+    getParent(): TreeKeyManagerItem | null;
+    /** Retrieves the children for this item. */
+    getChildren(): TreeKeyManagerItem[] | Observable<TreeKeyManagerItem[]>;
+    /** Determines if the item is currently expanded. */
+    isExpanded: (() => boolean) | boolean;
+    /** Collapses the item, hiding its children. */
+    collapse(): void;
+    /** Expands the item, showing its children. */
+    expand(): void;
+    /**
+     * Focuses the item. This should provide some indication to the user that this item is focused.
+     */
+    focus(): void;
+    /**
+     * Unfocus the item. This should remove the focus state.
+     */
+    unfocus(): void;
+    /**
+     * Sets the item to be focusable without actually focusing it.
+     */
+    makeFocusable?(): void;
+}
+/**
+ * Configuration for the TreeKeyManager.
+ */
+interface TreeKeyManagerOptions<T extends TreeKeyManagerItem> {
+    /**
+     * If true, then the key manager will call `activate` in addition to calling `focus` when a
+     * particular item is focused.
+     */
+    shouldActivationFollowFocus?: boolean;
+    /**
+     * The direction in which the tree items are laid out horizontally. This influences which key
+     * will be interpreted as expand or collapse.
+     */
+    horizontalOrientation?: 'rtl' | 'ltr';
+    /**
+     * If provided, navigation "skips" over items that pass the given predicate.
+     *
+     * If the item is to be skipped, predicate function should return false.
+     */
+    skipPredicate?: (item: T) => boolean;
+    /**
+     * If provided, determines how the key manager determines if two items are equivalent.
+     *
+     * It should provide a unique key for each unique tree item. If two tree items are equivalent,
+     * then this function should return the same value.
+     */
+    trackBy?: (treeItem: T) => unknown;
+    /**
+     * If a value is provided, enables typeahead mode, which allows users to set the active item
+     * by typing the visible label of the item.
+     *
+     * If a number is provided, this will be the time to wait after the last keystroke before
+     * setting the active item. If `true` is provided, the default interval of 200ms will be used.
+     */
+    typeAheadDebounceInterval?: true | number;
+}
+interface TreeKeyManagerStrategy<T extends TreeKeyManagerItem> {
+    /** Stream that emits any time the focused item changes. */
+    readonly change: Subject<T | null>;
+    /**
+     * Cleans up the key manager.
+     */
+    destroy(): void;
+    /**
+     * Handles a keyboard event on the tree.
+     *
+     * @param event Keyboard event that represents the user interaction with the tree.
+     */
+    onKeydown(event: KeyboardEvent): void;
+    /** Index of the currently active item. */
+    getActiveItemIndex(): number | null;
+    /** The currently active item. */
+    getActiveItem(): T | null;
+    /**
+     * Focus the provided item by index.
+     *
+     * Updates the state of the currently active item. Emits to `change` stream if active item
+     * Changes.
+     * @param index The index of the item to focus.
+     * @param options Additional focusing options.
+     */
+    focusItem(index: number, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+    /**
+     * Focus the provided item.
+     *
+     * Updates the state of the currently active item. Emits to `change` stream if active item
+     * Changes.
+     * @param item The item to focus. Equality is determined via the trackBy function.
+     * @param options Additional focusing options.
+     */
+    focusItem(item: T, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+    focusItem(itemOrIndex: number | T, options?: {
+        emitChangeEvent?: boolean;
+    }): void;
+}
+type TreeKeyManagerFactory<T extends TreeKeyManagerItem> = (items: Observable<T[]> | QueryList<T> | T[], options: TreeKeyManagerOptions<T>) => TreeKeyManagerStrategy<T>;
+
+export type { TreeKeyManagerItem as T, TreeKeyManagerStrategy as a, TreeKeyManagerFactory as b, TreeKeyManagerOptions as c };

package/unique-selection-dispatcher.d-7993b9f5.d.ts

@@ -0,0 +1,32 @@
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+type UniqueSelectionDispatcherListener = (id: string, name: string) => void;
+/**
+ * Class to coordinate unique selection based on name.
+ * Intended to be consumed as an Angular service.
+ * This service is needed because native radio change events are only fired on the item currently
+ * being selected, and we still need to uncheck the previous selection.
+ *
+ * This service does not *store* any IDs and names because they may change at any time, so it is
+ * less error-prone if they are simply passed through when the events occur.
+ */
+declare class UniqueSelectionDispatcher implements OnDestroy {
+    private _listeners;
+    /**
+     * Notify other items that selection for the given name has been set.
+     * @param id ID of the item.
+     * @param name Name of the item.
+     */
+    notify(id: string, name: string): void;
+    /**
+     * Listen for future changes to item selection.
+     * @return Function used to deregister listener
+     */
+    listen(listener: UniqueSelectionDispatcherListener): () => void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniqueSelectionDispatcher, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UniqueSelectionDispatcher>;
+}
+
+export { UniqueSelectionDispatcher as U, type UniqueSelectionDispatcherListener as a };

package/view-repeater.d-79039e1f.d.ts

@@ -0,0 +1,88 @@
+import { TemplateRef, IterableChangeRecord, IterableChanges, ViewContainerRef, InjectionToken } from '@angular/core';
+
+/**
+ * The context for an embedded view in the repeater's view container.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ */
+interface _ViewRepeaterItemContext<T> {
+    $implicit?: T;
+}
+/**
+ * The arguments needed to construct an embedded view for an item in a view
+ * container.
+ *
+ * @template C The type for the context passed to each embedded view.
+ */
+interface _ViewRepeaterItemInsertArgs<C> {
+    templateRef: TemplateRef<C>;
+    context?: C;
+    index?: number;
+}
+/**
+ * A factory that derives the embedded view context for an item in a view
+ * container.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+type _ViewRepeaterItemContextFactory<T, R, C extends _ViewRepeaterItemContext<T>> = (record: IterableChangeRecord<R>, adjustedPreviousIndex: number | null, currentIndex: number | null) => _ViewRepeaterItemInsertArgs<C>;
+/**
+ * Extracts the value of an item from an {@link IterableChangeRecord}.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ */
+type _ViewRepeaterItemValueResolver<T, R> = (record: IterableChangeRecord<R>) => T;
+/** Indicates how a view was changed by a {@link _ViewRepeater}. */
+declare enum _ViewRepeaterOperation {
+    /** The content of an existing view was replaced with another item. */
+    REPLACED = 0,
+    /** A new view was created with `createEmbeddedView`. */
+    INSERTED = 1,
+    /** The position of a view changed, but the content remains the same. */
+    MOVED = 2,
+    /** A view was detached from the view container. */
+    REMOVED = 3
+}
+/**
+ * Meta data describing the state of a view after it was updated by a
+ * {@link _ViewRepeater}.
+ *
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+interface _ViewRepeaterItemChange<R, C> {
+    /** The view's context after it was changed. */
+    context?: C;
+    /** Indicates how the view was changed. */
+    operation: _ViewRepeaterOperation;
+    /** The view's corresponding change record. */
+    record: IterableChangeRecord<R>;
+}
+/**
+ * Type for a callback to be executed after a view has changed.
+ *
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+type _ViewRepeaterItemChanged<R, C> = (change: _ViewRepeaterItemChange<R, C>) => void;
+/**
+ * Describes a strategy for rendering items in a {@link ViewContainerRef}.
+ *
+ * @template T The type for the embedded view's $implicit property.
+ * @template R The type for the item in each IterableDiffer change record.
+ * @template C The type for the context passed to each embedded view.
+ */
+interface _ViewRepeater<T, R, C extends _ViewRepeaterItemContext<T>> {
+    applyChanges(changes: IterableChanges<R>, viewContainerRef: ViewContainerRef, itemContextFactory: _ViewRepeaterItemContextFactory<T, R, C>, itemValueResolver: _ViewRepeaterItemValueResolver<T, R>, itemViewChanged?: _ViewRepeaterItemChanged<R, C>): void;
+    detach(): void;
+}
+/**
+ * Injection token for {@link _ViewRepeater}. This token is for use by Angular Material only.
+ * @docs-private
+ */
+declare const _VIEW_REPEATER_STRATEGY: InjectionToken<_ViewRepeater<unknown, unknown, _ViewRepeaterItemContext<unknown>>>;
+
+export { type _ViewRepeaterItemContext as _, type _ViewRepeater as a, type _ViewRepeaterItemContextFactory as b, type _ViewRepeaterItemValueResolver as c, type _ViewRepeaterItemChanged as d, type _ViewRepeaterItemInsertArgs as e, _ViewRepeaterOperation as f, type _ViewRepeaterItemChange as g, _VIEW_REPEATER_STRATEGY as h };

package/viewport-ruler.d-f3d3e82f.d.ts

@@ -0,0 +1,57 @@
+import * as i0 from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+
+/** Time in ms to throttle the resize events by default. */
+declare const DEFAULT_RESIZE_TIME = 20;
+/** Object that holds the scroll position of the viewport in each direction. */
+interface ViewportScrollPosition {
+    top: number;
+    left: number;
+}
+/**
+ * Simple utility for getting the bounds of the browser viewport.
+ * @docs-private
+ */
+declare class ViewportRuler implements OnDestroy {
+    private _platform;
+    private _listeners;
+    /** Cached viewport dimensions. */
+    private _viewportSize;
+    /** Stream of viewport change events. */
+    private readonly _change;
+    /** Used to reference correct document/window */
+    protected _document: Document;
+    constructor(...args: unknown[]);
+    ngOnDestroy(): void;
+    /** Returns the viewport's width and height. */
+    getViewportSize(): Readonly<{
+        width: number;
+        height: number;
+    }>;
+    /** Gets a DOMRect for the viewport's bounds. */
+    getViewportRect(): {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+        height: number;
+        width: number;
+    };
+    /** Gets the (top, left) scroll position of the viewport. */
+    getViewportScrollPosition(): ViewportScrollPosition;
+    /**
+     * Returns a stream that emits whenever the size of the viewport changes.
+     * This stream emits outside of the Angular zone.
+     * @param throttleTime Time in milliseconds to throttle the stream.
+     */
+    change(throttleTime?: number): Observable<Event>;
+    /** Use defaultView of injected document if available or fallback to global window reference */
+    private _getWindow;
+    /** Updates the cached viewport size. */
+    private _updateViewportSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportRuler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportRuler>;
+}
+
+export { DEFAULT_RESIZE_TIME as D, ViewportRuler as V, type ViewportScrollPosition as a };