From 8f2745c2d2a03171be61537cfed3faae6bcd6760 Mon Sep 17 00:00:00 2001 From: Paul Gschwendtner Date: Tue, 13 Nov 2018 21:49:51 +0100 Subject: [PATCH] build: validate CDK public API using ts-api-guardian --- .circleci/config.yml | 2 +- WORKSPACE | 4 +- tools/public_api_guard/BUILD.bazel | 9 + tools/public_api_guard/cdk/a11y.d.ts | 178 +++++++++++ tools/public_api_guard/cdk/accordion.d.ts | 30 ++ tools/public_api_guard/cdk/bidi.d.ts | 22 ++ tools/public_api_guard/cdk/cdk.d.ts | 1 + tools/public_api_guard/cdk/coercion.d.ts | 10 + tools/public_api_guard/cdk/collections.d.ts | 57 ++++ tools/public_api_guard/cdk/drag-drop.d.ts | 183 +++++++++++ tools/public_api_guard/cdk/keycodes.d.ts | 237 ++++++++++++++ tools/public_api_guard/cdk/layout.d.ts | 38 +++ tools/public_api_guard/cdk/observers.d.ts | 22 ++ tools/public_api_guard/cdk/overlay.d.ts | 302 ++++++++++++++++++ tools/public_api_guard/cdk/platform.d.ts | 31 ++ tools/public_api_guard/cdk/scrolling.d.ts | 199 ++++++++++++ tools/public_api_guard/cdk/stepper.d.ts | 99 ++++++ tools/public_api_guard/cdk/table.d.ts | 240 ++++++++++++++ tools/public_api_guard/cdk/text-field.d.ts | 38 +++ tools/public_api_guard/cdk/tree.d.ts | 153 +++++++++ .../public_api_guard/generate-guard-tests.bzl | 34 ++ tsconfig.json | 3 + tslint.json | 2 + 23 files changed, 1891 insertions(+), 3 deletions(-) create mode 100644 tools/public_api_guard/BUILD.bazel create mode 100644 tools/public_api_guard/cdk/a11y.d.ts create mode 100644 tools/public_api_guard/cdk/accordion.d.ts create mode 100644 tools/public_api_guard/cdk/bidi.d.ts create mode 100644 tools/public_api_guard/cdk/cdk.d.ts create mode 100644 tools/public_api_guard/cdk/coercion.d.ts create mode 100644 tools/public_api_guard/cdk/collections.d.ts create mode 100644 tools/public_api_guard/cdk/drag-drop.d.ts create mode 100644 tools/public_api_guard/cdk/keycodes.d.ts create mode 100644 tools/public_api_guard/cdk/layout.d.ts create mode 100644 tools/public_api_guard/cdk/observers.d.ts create mode 100644 tools/public_api_guard/cdk/overlay.d.ts create mode 100644 tools/public_api_guard/cdk/platform.d.ts create mode 100644 tools/public_api_guard/cdk/scrolling.d.ts create mode 100644 tools/public_api_guard/cdk/stepper.d.ts create mode 100644 tools/public_api_guard/cdk/table.d.ts create mode 100644 tools/public_api_guard/cdk/text-field.d.ts create mode 100644 tools/public_api_guard/cdk/tree.d.ts create mode 100644 tools/public_api_guard/generate-guard-tests.bzl diff --git a/.circleci/config.yml b/.circleci/config.yml index 169877199372..f790554cdda1 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -90,7 +90,7 @@ jobs: # TODO(jelbourn): Update this command to run all tests if the Bazel issues have been fixed. - run: bazel build src/... - - run: bazel test src/... + - run: bazel test src/... tools/public_api_guard/... # ------------------------------------------------------------------------------------------ # Job that runs the unit tests on locally installed browsers (Chrome and Firefox headless). diff --git a/WORKSPACE b/WORKSPACE index 2a82660fdcbe..0485e0620d71 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -17,8 +17,8 @@ http_archive( # Add Angular source and Bazel rules. http_archive( name = "angular", - url = "https://github.com/angular/angular/archive/7.0.3.zip", - strip_prefix = "angular-7.0.3", + url = "https://github.com/angular/angular/archive/2ec05415e24137d44f24b07202c34c5054c968ed.zip", + strip_prefix = "angular-2ec05415e24137d44f24b07202c34c5054c968ed", ) # Add RxJS as repository because those are needed in order to build Angular from source. diff --git a/tools/public_api_guard/BUILD.bazel b/tools/public_api_guard/BUILD.bazel new file mode 100644 index 000000000000..e12c9c638ddc --- /dev/null +++ b/tools/public_api_guard/BUILD.bazel @@ -0,0 +1,9 @@ +package(default_visibility=["//visibility:public"]) + +load(":generate-guard-tests.bzl", "generate_test_targets") + +# TODO(devversion): This currently does not include the CDK portal package because +# aliases are not supported by ts-api-guardian. Re-add once we found a solution for that. + +# Generate the API guard test targets for each golden file in the current package. +generate_test_targets(glob(["**/*.d.ts"])) diff --git a/tools/public_api_guard/cdk/a11y.d.ts b/tools/public_api_guard/cdk/a11y.d.ts new file mode 100644 index 000000000000..274a8ae1306d --- /dev/null +++ b/tools/public_api_guard/cdk/a11y.d.ts @@ -0,0 +1,178 @@ +export declare class A11yModule { +} + +export declare class ActiveDescendantKeyManager extends ListKeyManager { + setActiveItem(index: number): void; + setActiveItem(item: T): void; +} + +export declare const ARIA_DESCRIBER_PROVIDER: { + provide: typeof AriaDescriber; + deps: (Optional[] | InjectionToken)[]; + useFactory: typeof ARIA_DESCRIBER_PROVIDER_FACTORY; +}; + +export declare function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher: AriaDescriber, _document: any): AriaDescriber; + +export declare class AriaDescriber implements OnDestroy { + constructor(_document: any); + describe(hostElement: Element, message: string): void; + ngOnDestroy(): void; + removeDescription(hostElement: Element, message: string): void; +} + +export declare type AriaLivePoliteness = 'off' | 'polite' | 'assertive'; + +export declare const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = "cdk-describedby-host"; + +export declare const CDK_DESCRIBEDBY_ID_PREFIX = "cdk-describedby-message"; + +export declare class CdkAriaLive implements OnDestroy { + politeness: AriaLivePoliteness; + constructor(_elementRef: ElementRef, _liveAnnouncer: LiveAnnouncer, _contentObserver: ContentObserver, _ngZone: NgZone); + ngOnDestroy(): void; +} + +export declare class CdkMonitorFocus implements OnDestroy { + cdkFocusChange: EventEmitter; + constructor(_elementRef: ElementRef, _focusMonitor: FocusMonitor); + ngOnDestroy(): void; +} + +export declare class CdkTrapFocus implements OnDestroy, AfterContentInit, DoCheck { + autoCapture: boolean; + enabled: boolean; + focusTrap: FocusTrap; + constructor(_elementRef: ElementRef, _focusTrapFactory: FocusTrapFactory, _document: any); + ngAfterContentInit(): void; + ngDoCheck(): void; + ngOnDestroy(): void; +} + +export declare const FOCUS_MONITOR_PROVIDER: { + provide: typeof FocusMonitor; + deps: (Optional[] | typeof NgZone | typeof Platform)[]; + useFactory: typeof FOCUS_MONITOR_PROVIDER_FACTORY; +}; + +export declare function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher: FocusMonitor, ngZone: NgZone, platform: Platform): FocusMonitor; + +export interface FocusableOption extends ListKeyManagerOption { + focus(origin?: FocusOrigin): void; +} + +export declare class FocusKeyManager extends ListKeyManager { + setActiveItem(index: number): void; + setActiveItem(item: T): void; + setFocusOrigin(origin: FocusOrigin): this; +} + +export declare class FocusMonitor implements OnDestroy { + constructor(_ngZone: NgZone, _platform: Platform); + _onBlur(event: FocusEvent, element: HTMLElement): void; + focusVia(element: ElementRef, origin: FocusOrigin, options?: FocusOptions): void; + focusVia(element: HTMLElement, origin: FocusOrigin, options?: FocusOptions): void; + monitor(element: HTMLElement, checkChildren?: boolean): Observable; + monitor(element: ElementRef, checkChildren?: boolean): Observable; + ngOnDestroy(): void; + stopMonitoring(element: ElementRef): void; + stopMonitoring(element: HTMLElement): void; +} + +export interface FocusOptions { + preventScroll?: boolean; +} + +export declare type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null; + +export declare class FocusTrap { + enabled: boolean; + constructor(_element: HTMLElement, _checker: InteractivityChecker, _ngZone: NgZone, _document: Document, deferAnchors?: boolean); + attachAnchors(): boolean; + destroy(): void; + focusFirstTabbableElement(): boolean; + focusFirstTabbableElementWhenReady(): Promise; + focusInitialElement(): boolean; + focusInitialElementWhenReady(): Promise; + focusLastTabbableElement(): boolean; + focusLastTabbableElementWhenReady(): Promise; + hasAttached(): boolean; +} + +export declare class FocusTrapFactory { + constructor(_checker: InteractivityChecker, _ngZone: NgZone, _document: any); + create(element: HTMLElement, deferCaptureElements?: boolean): FocusTrap; +} + +export interface Highlightable extends ListKeyManagerOption { + setActiveStyles(): void; + setInactiveStyles(): void; +} + +export declare class InteractivityChecker { + constructor(_platform: Platform); + isDisabled(element: HTMLElement): boolean; + isFocusable(element: HTMLElement): boolean; + isTabbable(element: HTMLElement): boolean; + isVisible(element: HTMLElement): boolean; +} + +export declare function isFakeMousedownFromScreenReader(event: MouseEvent): boolean; + +export declare class ListKeyManager { + readonly activeItem: T | null; + readonly activeItemIndex: number | null; + change: Subject; + tabOut: Subject; + constructor(_items: QueryList | T[]); + onKeydown(event: KeyboardEvent): void; + setActiveItem(index: number): void; + setActiveItem(item: T): void; + setFirstItemActive(): void; + setLastItemActive(): void; + setNextItemActive(): void; + setPreviousItemActive(): void; + skipPredicate(predicate: (item: T) => boolean): this; + updateActiveItem(item: T): void; + updateActiveItem(index: number): void; + updateActiveItemIndex(index: number): void; + withAllowedModifierKeys(keys: ListKeyManagerModifierKey[]): this; + withHorizontalOrientation(direction: 'ltr' | 'rtl' | null): this; + withTypeAhead(debounceInterval?: number): this; + withVerticalOrientation(enabled?: boolean): this; + withWrap(shouldWrap?: boolean): this; +} + +export declare type ListKeyManagerModifierKey = 'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'; + +export interface ListKeyManagerOption { + disabled?: boolean; + getLabel?(): string; +} + +export declare const LIVE_ANNOUNCER_ELEMENT_TOKEN: InjectionToken; + +export declare function LIVE_ANNOUNCER_ELEMENT_TOKEN_FACTORY(): null; + +export declare const LIVE_ANNOUNCER_PROVIDER: Provider; + +export declare function LIVE_ANNOUNCER_PROVIDER_FACTORY(parentDispatcher: LiveAnnouncer, liveElement: any, _document: any, ngZone: NgZone): LiveAnnouncer; + +export declare class LiveAnnouncer implements OnDestroy { + constructor(elementToken: any, _ngZone: NgZone, _document: any); + announce(message: string): Promise; + announce(message: string, duration?: number): Promise; + announce(message: string, politeness?: AriaLivePoliteness, duration?: number): Promise; + announce(message: string, politeness?: AriaLivePoliteness): Promise; + clear(): void; + ngOnDestroy(): void; +} + +export declare const MESSAGES_CONTAINER_ID = "cdk-describedby-message-container"; + +export interface RegisteredMessage { + messageElement: Element; + referenceCount: number; +} + +export declare const TOUCH_BUFFER_MS = 650; diff --git a/tools/public_api_guard/cdk/accordion.d.ts b/tools/public_api_guard/cdk/accordion.d.ts new file mode 100644 index 000000000000..fcf505221de2 --- /dev/null +++ b/tools/public_api_guard/cdk/accordion.d.ts @@ -0,0 +1,30 @@ +export declare class CdkAccordion implements OnDestroy, OnChanges { + readonly _openCloseAllActions: Subject; + readonly _stateChanges: Subject; + readonly id: string; + multi: boolean; + closeAll(): void; + ngOnChanges(changes: SimpleChanges): void; + ngOnDestroy(): void; + openAll(): void; +} + +export declare class CdkAccordionItem implements OnDestroy { + protected _expansionDispatcher: UniqueSelectionDispatcher; + accordion: CdkAccordion; + closed: EventEmitter; + destroyed: EventEmitter; + disabled: any; + expanded: any; + expandedChange: EventEmitter; + readonly id: string; + opened: EventEmitter; + constructor(accordion: CdkAccordion, _changeDetectorRef: ChangeDetectorRef, _expansionDispatcher: UniqueSelectionDispatcher); + close(): void; + ngOnDestroy(): void; + open(): void; + toggle(): void; +} + +export declare class CdkAccordionModule { +} diff --git a/tools/public_api_guard/cdk/bidi.d.ts b/tools/public_api_guard/cdk/bidi.d.ts new file mode 100644 index 000000000000..b99832f33f46 --- /dev/null +++ b/tools/public_api_guard/cdk/bidi.d.ts @@ -0,0 +1,22 @@ +export declare class BidiModule { +} + +export declare class Dir implements Directionality, AfterContentInit, OnDestroy { + _rawDir: string; + change: EventEmitter; + dir: Direction; + readonly value: Direction; + ngAfterContentInit(): void; + ngOnDestroy(): void; +} + +export declare const DIR_DOCUMENT: InjectionToken; + +export declare type Direction = 'ltr' | 'rtl'; + +export declare class Directionality implements OnDestroy { + readonly change: EventEmitter; + readonly value: Direction; + constructor(_document?: any); + ngOnDestroy(): void; +} diff --git a/tools/public_api_guard/cdk/cdk.d.ts b/tools/public_api_guard/cdk/cdk.d.ts new file mode 100644 index 000000000000..6e154bba2805 --- /dev/null +++ b/tools/public_api_guard/cdk/cdk.d.ts @@ -0,0 +1 @@ +export declare const VERSION: Version; diff --git a/tools/public_api_guard/cdk/coercion.d.ts b/tools/public_api_guard/cdk/coercion.d.ts new file mode 100644 index 000000000000..44725d0a4e5c --- /dev/null +++ b/tools/public_api_guard/cdk/coercion.d.ts @@ -0,0 +1,10 @@ +export declare function _isNumberValue(value: any): boolean; + +export declare function coerceArray(value: T | T[]): T[]; + +export declare function coerceBooleanProperty(value: any): boolean; + +export declare function coerceCssPixelValue(value: any): string; + +export declare function coerceNumberProperty(value: any): number; +export declare function coerceNumberProperty(value: any, fallback: D): number | D; diff --git a/tools/public_api_guard/cdk/collections.d.ts b/tools/public_api_guard/cdk/collections.d.ts new file mode 100644 index 000000000000..d0e35acad260 --- /dev/null +++ b/tools/public_api_guard/cdk/collections.d.ts @@ -0,0 +1,57 @@ +export declare class ArrayDataSource extends DataSource { + constructor(_data: T[] | ReadonlyArray | Observable>); + connect(): Observable>; + disconnect(): void; +} + +export interface CollectionViewer { + viewChange: Observable; +} + +export declare abstract class DataSource { + abstract connect(collectionViewer: CollectionViewer): Observable>; + abstract disconnect(collectionViewer: CollectionViewer): void; +} + +export declare function getMultipleValuesInSingleSelectionError(): Error; + +export declare type ListRange = { + start: number; + end: number; +}; + +export interface SelectionChange { + added: T[]; + removed: T[]; + source: SelectionModel; +} + +export declare class SelectionModel { + changed: Subject>; + onChange: Subject>; + readonly selected: T[]; + constructor(_multiple?: boolean, initiallySelectedValues?: T[], _emitChanges?: boolean); + clear(): void; + deselect(...values: T[]): void; + hasValue(): boolean; + isEmpty(): boolean; + isMultipleSelection(): boolean; + isSelected(value: T): boolean; + select(...values: T[]): void; + sort(predicate?: (a: T, b: T) => number): void; + toggle(value: T): void; +} + +export interface TreeDataNodeFlattener { + expandFlattenedNodes(nodes: T[], expansionModel: SelectionModel): T[]; + flattenNodes(structuredData: any[]): T[]; + nodeDescendents(node: T, nodes: T[], onlyExpandable: boolean): void; +} + +export declare class UniqueSelectionDispatcher implements OnDestroy { + listen(listener: UniqueSelectionDispatcherListener): () => void; + ngOnDestroy(): void; + notify(id: string, name: string): void; +} + +export declare type UniqueSelectionDispatcherListener = (id: string, name: string) => void; diff --git a/tools/public_api_guard/cdk/drag-drop.d.ts b/tools/public_api_guard/cdk/drag-drop.d.ts new file mode 100644 index 000000000000..36d7bc3f58a0 --- /dev/null +++ b/tools/public_api_guard/cdk/drag-drop.d.ts @@ -0,0 +1,183 @@ +export declare const CDK_DRAG_CONFIG: InjectionToken; + +export declare function CDK_DRAG_CONFIG_FACTORY(): CdkDragConfig; + +export declare const CDK_DROP_LIST_CONTAINER: InjectionToken>; + +export declare class CdkDrag implements AfterViewInit, OnDestroy { + _handles: QueryList; + _hasStartedDragging: boolean; + _placeholderTemplate: CdkDragPlaceholder; + _pointerDown: (event: TouchEvent | MouseEvent) => void; + _previewTemplate: CdkDragPreview; + data: T; + dropContainer: CdkDropListContainer; + dropped: EventEmitter>; + element: ElementRef; + ended: EventEmitter; + entered: EventEmitter>; + exited: EventEmitter>; + lockAxis: 'x' | 'y'; + moved: Observable>; + rootElementSelector: string; + started: EventEmitter; + constructor( + element: ElementRef, + dropContainer: CdkDropListContainer, document: any, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, _viewportRuler: ViewportRuler, _dragDropRegistry: DragDropRegistry, CdkDropListContainer>, _config: CdkDragConfig, _dir: Directionality); + _isDragging(): boolean; + getPlaceholderElement(): HTMLElement; + getRootElement(): HTMLElement; + ngAfterViewInit(): void; + ngOnDestroy(): void; + reset(): void; +} + +export interface CdkDragConfig { + dragStartThreshold: number; + pointerDirectionChangeThreshold: number; +} + +export interface CdkDragDrop { + container: CdkDropListContainer; + currentIndex: number; + item: CdkDrag; + previousContainer: CdkDropListContainer; + previousIndex: number; +} + +export interface CdkDragEnd { + source: CdkDrag; +} + +export interface CdkDragEnter { + container: CdkDropListContainer; + item: CdkDrag; +} + +export interface CdkDragExit { + container: CdkDropListContainer; + item: CdkDrag; +} + +export declare class CdkDragHandle { + _parentDrag: {} | undefined; + element: ElementRef; + constructor(element: ElementRef, parentDrag?: any); +} + +export interface CdkDragMove { + delta: { + x: -1 | 0 | 1; + y: -1 | 0 | 1; + }; + event: MouseEvent | TouchEvent; + pointerPosition: { + x: number; + y: number; + }; + source: CdkDrag; +} + +export declare class CdkDragPlaceholder { + data: T; + templateRef: TemplateRef; + constructor(templateRef: TemplateRef); +} + +export declare class CdkDragPreview { + data: T; + templateRef: TemplateRef; + constructor(templateRef: TemplateRef); +} + +export interface CdkDragSortEvent { + container: CdkDropListContainer; + currentIndex: number; + item: CdkDrag; + previousIndex: number; +} + +export interface CdkDragStart { + source: CdkDrag; +} + +export declare class CdkDropList implements OnInit, OnDestroy { + _draggables: QueryList; + _dragging: boolean; + connectedTo: (CdkDropList | string)[] | CdkDropList | string; + data: T; + dropped: EventEmitter>; + element: ElementRef; + enterPredicate: (drag: CdkDrag, drop: CdkDropList) => boolean; + entered: EventEmitter>; + exited: EventEmitter>; + id: string; + lockAxis: 'x' | 'y'; + orientation: 'horizontal' | 'vertical'; + sorted: EventEmitter>; + constructor(element: ElementRef, _dragDropRegistry: DragDropRegistry>, _changeDetectorRef: ChangeDetectorRef, _dir?: Directionality | undefined, _group?: CdkDropListGroup> | undefined); + _canReturnItem(x: number, y: number): boolean; + _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropList | null; + _sortItem(item: CdkDrag, pointerX: number, pointerY: number, pointerDelta: { + x: number; + y: number; + }): void; + drop(item: CdkDrag, currentIndex: number, previousContainer: CdkDropList): void; + enter(item: CdkDrag, pointerX: number, pointerY: number): void; + exit(item: CdkDrag): void; + getItemIndex(item: CdkDrag): number; + ngOnDestroy(): void; + ngOnInit(): void; + start(): void; +} + +export interface CdkDropListContainer { + _draggables: QueryList; + data: T; + element: ElementRef; + id: string; + lockAxis: 'x' | 'y'; + orientation: 'horizontal' | 'vertical'; + _canReturnItem(x: number, y: number): boolean; + _getSiblingContainerFromPosition(item: CdkDrag, x: number, y: number): CdkDropListContainer | null; + _sortItem(item: CdkDrag, pointerX: number, pointerY: number, delta: { + x: number; + y: number; + }): void; + drop(item: CdkDrag, currentIndex: number, previousContainer?: CdkDropListContainer): void; + enter(item: CdkDrag, pointerX: number, pointerY: number): void; + exit(item: CdkDrag): void; + getItemIndex(item: CdkDrag): number; + start(): void; +} + +export declare class CdkDropListGroup implements OnDestroy { + readonly _items: Set; + ngOnDestroy(): void; +} + +export declare function copyArrayItem(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void; + +export declare class DragDropModule { +} + +export declare class DragDropRegistry implements OnDestroy { + readonly pointerMove: Subject; + readonly pointerUp: Subject; + constructor(_ngZone: NgZone, _document: any); + getDropContainer(id: string): C | undefined; + isDragging(drag: I): boolean; + ngOnDestroy(): void; + registerDragItem(drag: I): void; + registerDropContainer(drop: C): void; + removeDragItem(drag: I): void; + removeDropContainer(drop: C): void; + startDragging(drag: I, event: TouchEvent | MouseEvent): void; + stopDragging(drag: I): void; +} + +export declare function moveItemInArray(array: T[], fromIndex: number, toIndex: number): void; + +export declare function transferArrayItem(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void; diff --git a/tools/public_api_guard/cdk/keycodes.d.ts b/tools/public_api_guard/cdk/keycodes.d.ts new file mode 100644 index 000000000000..46dcf687c5a9 --- /dev/null +++ b/tools/public_api_guard/cdk/keycodes.d.ts @@ -0,0 +1,237 @@ +export declare const A = 65; + +export declare const ALT = 18; + +export declare const APOSTROPHE = 192; + +export declare const AT_SIGN = 64; + +export declare const B = 66; + +export declare const BACKSLASH = 220; + +export declare const BACKSPACE = 8; + +export declare const C = 67; + +export declare const CAPS_LOCK = 20; + +export declare const CLOSE_SQUARE_BRACKET = 221; + +export declare const COMMA = 188; + +export declare const CONTEXT_MENU = 93; + +export declare const CONTROL = 17; + +export declare const D = 68; + +export declare const DASH = 189; + +export declare const DELETE = 46; + +export declare const DOWN_ARROW = 40; + +export declare const E = 69; + +export declare const EIGHT = 56; + +export declare const END = 35; + +export declare const ENTER = 13; + +export declare const EQUALS = 187; + +export declare const ESCAPE = 27; + +export declare const F = 70; + +export declare const F1 = 112; + +export declare const F10 = 121; + +export declare const F11 = 122; + +export declare const F12 = 123; + +export declare const F2 = 113; + +export declare const F3 = 114; + +export declare const F4 = 115; + +export declare const F5 = 116; + +export declare const F6 = 117; + +export declare const F7 = 118; + +export declare const F8 = 119; + +export declare const F9 = 120; + +export declare const FF_EQUALS = 61; + +export declare const FF_MINUS = 173; + +export declare const FF_MUTE = 181; + +export declare const FF_SEMICOLON = 59; + +export declare const FF_VOLUME_DOWN = 182; + +export declare const FF_VOLUME_UP = 183; + +export declare const FIRST_MEDIA = 166; + +export declare const FIVE = 53; + +export declare const FOUR = 52; + +export declare const G = 71; + +export declare const H = 72; + +export declare function hasModifierKey(event: KeyboardEvent, ...modifiers: ModifierKey[]): boolean; + +export declare const HOME = 36; + +export declare const I = 73; + +export declare const INSERT = 45; + +export declare const J = 74; + +export declare const K = 75; + +export declare const L = 76; + +export declare const LAST_MEDIA = 183; + +export declare const LEFT_ARROW = 37; + +export declare const M = 77; + +export declare const MAC_ENTER = 3; + +export declare const MAC_META = 224; + +export declare const MAC_WK_CMD_LEFT = 91; + +export declare const MAC_WK_CMD_RIGHT = 93; + +export declare const META = 91; + +export declare const MUTE = 173; + +export declare const N = 78; + +export declare const NINE = 57; + +export declare const NUM_CENTER = 12; + +export declare const NUM_LOCK = 144; + +export declare const NUMPAD_DIVIDE = 111; + +export declare const NUMPAD_EIGHT = 104; + +export declare const NUMPAD_FIVE = 101; + +export declare const NUMPAD_FOUR = 100; + +export declare const NUMPAD_MINUS = 109; + +export declare const NUMPAD_MULTIPLY = 106; + +export declare const NUMPAD_NINE = 105; + +export declare const NUMPAD_ONE = 97; + +export declare const NUMPAD_PERIOD = 110; + +export declare const NUMPAD_PLUS = 107; + +export declare const NUMPAD_SEVEN = 103; + +export declare const NUMPAD_SIX = 102; + +export declare const NUMPAD_THREE = 99; + +export declare const NUMPAD_TWO = 98; + +export declare const NUMPAD_ZERO = 96; + +export declare const O = 79; + +export declare const ONE = 49; + +export declare const OPEN_SQUARE_BRACKET = 219; + +export declare const P = 80; + +export declare const PAGE_DOWN = 34; + +export declare const PAGE_UP = 33; + +export declare const PAUSE = 19; + +export declare const PLUS_SIGN = 43; + +export declare const PRINT_SCREEN = 44; + +export declare const Q = 81; + +export declare const QUESTION_MARK = 63; + +export declare const R = 82; + +export declare const RIGHT_ARROW = 39; + +export declare const S = 83; + +export declare const SCROLL_LOCK = 145; + +export declare const SEMICOLON = 186; + +export declare const SEVEN = 55; + +export declare const SHIFT = 16; + +export declare const SINGLE_QUOTE = 222; + +export declare const SIX = 54; + +export declare const SLASH = 191; + +export declare const SPACE = 32; + +export declare const T = 84; + +export declare const TAB = 9; + +export declare const THREE = 51; + +export declare const TILDE = 192; + +export declare const TWO = 50; + +export declare const U = 85; + +export declare const UP_ARROW = 38; + +export declare const V = 86; + +export declare const VOLUME_DOWN = 174; + +export declare const VOLUME_UP = 175; + +export declare const W = 87; + +export declare const X = 88; + +export declare const Y = 89; + +export declare const Z = 90; + +export declare const ZERO = 48; diff --git a/tools/public_api_guard/cdk/layout.d.ts b/tools/public_api_guard/cdk/layout.d.ts new file mode 100644 index 000000000000..16c0873b3e34 --- /dev/null +++ b/tools/public_api_guard/cdk/layout.d.ts @@ -0,0 +1,38 @@ +export declare class BreakpointObserver implements OnDestroy { + constructor(mediaMatcher: MediaMatcher, zone: NgZone); + isMatched(value: string | string[]): boolean; + ngOnDestroy(): void; + observe(value: string | string[]): Observable; +} + +export declare const Breakpoints: { + XSmall: string; + Small: string; + Medium: string; + Large: string; + XLarge: string; + Handset: string; + Tablet: string; + Web: string; + HandsetPortrait: string; + TabletPortrait: string; + WebPortrait: string; + HandsetLandscape: string; + TabletLandscape: string; + WebLandscape: string; +}; + +export interface BreakpointState { + breakpoints: { + [key: string]: boolean; + }; + matches: boolean; +} + +export declare class LayoutModule { +} + +export declare class MediaMatcher { + constructor(platform: Platform); + matchMedia(query: string): MediaQueryList; +} diff --git a/tools/public_api_guard/cdk/observers.d.ts b/tools/public_api_guard/cdk/observers.d.ts new file mode 100644 index 000000000000..5a1f4e18f483 --- /dev/null +++ b/tools/public_api_guard/cdk/observers.d.ts @@ -0,0 +1,22 @@ +export declare class CdkObserveContent implements AfterContentInit, OnDestroy { + debounce: number; + disabled: any; + event: EventEmitter; + constructor(_contentObserver: ContentObserver, _elementRef: ElementRef, _ngZone: NgZone); + ngAfterContentInit(): void; + ngOnDestroy(): void; +} + +export declare class ContentObserver implements OnDestroy { + constructor(_mutationObserverFactory: MutationObserverFactory); + ngOnDestroy(): void; + observe(element: Element): Observable; + observe(element: ElementRef): Observable; +} + +export declare class MutationObserverFactory { + create(callback: MutationCallback): MutationObserver | null; +} + +export declare class ObserversModule { +} diff --git a/tools/public_api_guard/cdk/overlay.d.ts b/tools/public_api_guard/cdk/overlay.d.ts new file mode 100644 index 000000000000..fc48e7f2f955 --- /dev/null +++ b/tools/public_api_guard/cdk/overlay.d.ts @@ -0,0 +1,302 @@ +export declare class BlockScrollStrategy implements ScrollStrategy { + constructor(_viewportRuler: ViewportRuler, document: any); + attach(): void; + disable(): void; + enable(): void; +} + +export declare class CdkConnectedOverlay implements OnDestroy, OnChanges { + attach: EventEmitter; + backdropClass: string; + backdropClick: EventEmitter; + detach: EventEmitter; + readonly dir: Direction; + flexibleDimensions: boolean; + growAfterOpen: boolean; + hasBackdrop: any; + height: number | string; + lockPosition: any; + minHeight: number | string; + minWidth: number | string; + offsetX: number; + offsetY: number; + open: boolean; + origin: CdkOverlayOrigin; + overlayKeydown: EventEmitter; + readonly overlayRef: OverlayRef; + panelClass: string | string[]; + positionChange: EventEmitter; + positions: ConnectedPosition[]; + push: boolean; + scrollStrategy: ScrollStrategy; + viewportMargin: number; + width: number | string; + constructor(_overlay: Overlay, templateRef: TemplateRef, viewContainerRef: ViewContainerRef, scrollStrategyFactory: any, _dir: Directionality); + ngOnChanges(changes: SimpleChanges): void; + ngOnDestroy(): void; +} + +export declare class CdkOverlayOrigin { + elementRef: ElementRef; + constructor( + elementRef: ElementRef); +} + +export declare class CloseScrollStrategy implements ScrollStrategy { + constructor(_scrollDispatcher: ScrollDispatcher, _ngZone: NgZone, _viewportRuler: ViewportRuler, _config?: CloseScrollStrategyConfig | undefined); + attach(overlayRef: OverlayReference): void; + disable(): void; + enable(): void; +} + +export declare class ConnectedOverlayPositionChange { + connectionPair: ConnectionPositionPair; + scrollableViewProperties: ScrollingVisibility; + constructor( + connectionPair: ConnectionPositionPair, + scrollableViewProperties: ScrollingVisibility); +} + +export interface ConnectedPosition { + offsetX?: number; + offsetY?: number; + originX: 'start' | 'center' | 'end'; + originY: 'top' | 'center' | 'bottom'; + overlayX: 'start' | 'center' | 'end'; + overlayY: 'top' | 'center' | 'bottom'; + panelClass?: string | string[]; + weight?: number; +} + +export declare class ConnectedPositionStrategy implements PositionStrategy { + readonly _isRtl: boolean; + _positionStrategy: FlexibleConnectedPositionStrategy; + _preferredPositions: ConnectionPositionPair[]; + readonly onPositionChange: Observable; + readonly positions: ConnectionPositionPair[]; + constructor(originPos: OriginConnectionPosition, overlayPos: OverlayConnectionPosition, connectedTo: ElementRef, viewportRuler: ViewportRuler, document: Document, platform?: Platform); + apply(): void; + attach(overlayRef: OverlayReference): void; + detach(): void; + dispose(): void; + recalculateLastPosition(): void; + setOrigin(origin: ElementRef): this; + withDirection(dir: 'ltr' | 'rtl'): this; + withFallbackPosition(originPos: OriginConnectionPosition, overlayPos: OverlayConnectionPosition, offsetX?: number, offsetY?: number): this; + withLockedPosition(isLocked: boolean): this; + withOffsetX(offset: number): this; + withOffsetY(offset: number): this; + withPositions(positions: ConnectionPositionPair[]): this; + withScrollableContainers(scrollables: CdkScrollable[]): void; +} + +export declare class ConnectionPositionPair { + offsetX?: number | undefined; + offsetY?: number | undefined; + originX: HorizontalConnectionPos; + originY: VerticalConnectionPos; + overlayX: HorizontalConnectionPos; + overlayY: VerticalConnectionPos; + panelClass?: string | string[] | undefined; + constructor(origin: OriginConnectionPosition, overlay: OverlayConnectionPosition, + offsetX?: number | undefined, + offsetY?: number | undefined, + panelClass?: string | string[] | undefined); +} + +export declare class FlexibleConnectedPositionStrategy implements PositionStrategy { + _preferredPositions: ConnectionPositionPair[]; + positionChanges: Observable; + readonly positions: ConnectionPositionPair[]; + constructor(connectedTo: ElementRef | HTMLElement, _viewportRuler: ViewportRuler, _document: Document, _platform?: Platform | undefined, _overlayContainer?: OverlayContainer | undefined); + apply(): void; + attach(overlayRef: OverlayReference): void; + detach(): void; + dispose(): void; + reapplyLastPosition(): void; + setOrigin(origin: ElementRef | HTMLElement): this; + withDefaultOffsetX(offset: number): this; + withDefaultOffsetY(offset: number): this; + withFlexibleDimensions(flexibleDimensions?: boolean): this; + withGrowAfterOpen(growAfterOpen?: boolean): this; + withLockedPosition(isLocked?: boolean): this; + withPositions(positions: ConnectedPosition[]): this; + withPush(canPush?: boolean): this; + withScrollableContainers(scrollables: CdkScrollable[]): void; + withTransformOriginOn(selector: string): this; + withViewportMargin(margin: number): this; +} + +export declare class FullscreenOverlayContainer extends OverlayContainer implements OnDestroy { + constructor(_document: any); + protected _createContainer(): void; + getFullscreenElement(): Element; + ngOnDestroy(): void; +} + +export declare class GlobalPositionStrategy implements PositionStrategy { + apply(): void; + attach(overlayRef: OverlayReference): void; + bottom(value?: string): this; + centerHorizontally(offset?: string): this; + centerVertically(offset?: string): this; + dispose(): void; + height(value?: string): this; + left(value?: string): this; + right(value?: string): this; + top(value?: string): this; + width(value?: string): this; +} + +export declare type HorizontalConnectionPos = 'start' | 'center' | 'end'; + +export declare class NoopScrollStrategy implements ScrollStrategy { + attach(): void; + disable(): void; + enable(): void; +} + +export interface OriginConnectionPosition { + originX: HorizontalConnectionPos; + originY: VerticalConnectionPos; +} + +export declare class Overlay { + scrollStrategies: ScrollStrategyOptions; + constructor( + scrollStrategies: ScrollStrategyOptions, _overlayContainer: OverlayContainer, _componentFactoryResolver: ComponentFactoryResolver, _positionBuilder: OverlayPositionBuilder, _keyboardDispatcher: OverlayKeyboardDispatcher, _injector: Injector, _ngZone: NgZone, _document: any, _directionality: Directionality, _location?: Location | undefined); + create(config?: OverlayConfig): OverlayRef; + position(): OverlayPositionBuilder; +} + +export declare const OVERLAY_PROVIDERS: Provider[]; + +export declare class OverlayConfig { + backdropClass?: string | string[]; + direction?: Direction | Directionality; + disposeOnNavigation?: boolean; + hasBackdrop?: boolean; + height?: number | string; + maxHeight?: number | string; + maxWidth?: number | string; + minHeight?: number | string; + minWidth?: number | string; + panelClass?: string | string[]; + positionStrategy?: PositionStrategy; + scrollStrategy?: ScrollStrategy; + width?: number | string; + constructor(config?: OverlayConfig); +} + +export interface OverlayConnectionPosition { + overlayX: HorizontalConnectionPos; + overlayY: VerticalConnectionPos; +} + +export declare class OverlayContainer implements OnDestroy { + protected _containerElement: HTMLElement; + protected _document: any; + constructor(_document: any); + protected _createContainer(): void; + getContainerElement(): HTMLElement; + ngOnDestroy(): void; +} + +export declare class OverlayKeyboardDispatcher implements OnDestroy { + _attachedOverlays: OverlayRef[]; + constructor(document: any); + add(overlayRef: OverlayRef): void; + ngOnDestroy(): void; + remove(overlayRef: OverlayRef): void; +} + +export declare class OverlayModule { +} + +export declare class OverlayPositionBuilder { + constructor(_viewportRuler: ViewportRuler, _document: any, _platform?: Platform | undefined, _overlayContainer?: OverlayContainer | undefined); + connectedTo(elementRef: ElementRef, originPos: OriginConnectionPosition, overlayPos: OverlayConnectionPosition): ConnectedPositionStrategy; + flexibleConnectedTo(elementRef: ElementRef | HTMLElement): FlexibleConnectedPositionStrategy; + global(): GlobalPositionStrategy; +} + +export declare class OverlayRef implements PortalOutlet, OverlayReference { + _keydownEventSubscriptions: number; + _keydownEvents: Subject; + readonly backdropElement: HTMLElement | null; + readonly hostElement: HTMLElement; + readonly overlayElement: HTMLElement; + constructor(_portalOutlet: PortalOutlet, _host: HTMLElement, _pane: HTMLElement, _config: ImmutableObject, _ngZone: NgZone, _keyboardDispatcher: OverlayKeyboardDispatcher, _document: Document, _location?: Location | undefined); + attach(portal: TemplatePortal): EmbeddedViewRef; + attach(portal: any): any; + attach(portal: ComponentPortal): ComponentRef; + attachments(): Observable; + backdropClick(): Observable; + detach(): any; + detachBackdrop(): void; + detachments(): Observable; + dispose(): void; + getConfig(): OverlayConfig; + getDirection(): Direction; + hasAttached(): boolean; + keydownEvents(): Observable; + setDirection(dir: Direction | Directionality): void; + updatePosition(): void; + updatePositionStrategy(strategy: PositionStrategy): void; + updateSize(sizeConfig: OverlaySizeConfig): void; +} + +export interface OverlaySizeConfig { + height?: number | string; + maxHeight?: number | string; + maxWidth?: number | string; + minHeight?: number | string; + minWidth?: number | string; + width?: number | string; +} + +export interface PositionStrategy { + apply(): void; + attach(overlayRef: OverlayReference): void; + detach?(): void; + dispose(): void; +} + +export declare class RepositionScrollStrategy implements ScrollStrategy { + constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, _config?: RepositionScrollStrategyConfig | undefined); + attach(overlayRef: OverlayReference): void; + disable(): void; + enable(): void; +} + +export interface RepositionScrollStrategyConfig { + autoClose?: boolean; + scrollThrottle?: number; +} + +export declare class ScrollingVisibility { + isOriginClipped: boolean; + isOriginOutsideView: boolean; + isOverlayClipped: boolean; + isOverlayOutsideView: boolean; +} + +export interface ScrollStrategy { + attach: (overlayRef: OverlayReference) => void; + disable: () => void; + enable: () => void; +} + +export declare class ScrollStrategyOptions { + block: () => BlockScrollStrategy; + close: (config?: CloseScrollStrategyConfig | undefined) => CloseScrollStrategy; + noop: () => NoopScrollStrategy; + reposition: (config?: RepositionScrollStrategyConfig | undefined) => RepositionScrollStrategy; + constructor(_scrollDispatcher: ScrollDispatcher, _viewportRuler: ViewportRuler, _ngZone: NgZone, document: any); +} + +export declare function validateHorizontalPosition(property: string, value: HorizontalConnectionPos): void; + +export declare function validateVerticalPosition(property: string, value: VerticalConnectionPos): void; + +export declare type VerticalConnectionPos = 'top' | 'center' | 'bottom'; diff --git a/tools/public_api_guard/cdk/platform.d.ts b/tools/public_api_guard/cdk/platform.d.ts new file mode 100644 index 000000000000..dd20d47c69ab --- /dev/null +++ b/tools/public_api_guard/cdk/platform.d.ts @@ -0,0 +1,31 @@ +export declare function getRtlScrollAxisType(): RtlScrollAxisType; + +export declare function getSupportedInputTypes(): Set; + +export declare function normalizePassiveListenerOptions(options: AddEventListenerOptions): AddEventListenerOptions | boolean; + +export declare class Platform { + ANDROID: boolean; + BLINK: boolean; + EDGE: boolean; + FIREFOX: boolean; + IOS: boolean; + SAFARI: boolean; + TRIDENT: boolean; + WEBKIT: boolean; + isBrowser: boolean; + constructor(_platformId?: Object | undefined); +} + +export declare class PlatformModule { +} + +export declare enum RtlScrollAxisType { + NORMAL = 0, + NEGATED = 1, + INVERTED = 2 +} + +export declare function supportsPassiveEventListeners(): boolean; + +export declare function supportsScrollBehavior(): boolean; diff --git a/tools/public_api_guard/cdk/scrolling.d.ts b/tools/public_api_guard/cdk/scrolling.d.ts new file mode 100644 index 000000000000..950c49b0b7da --- /dev/null +++ b/tools/public_api_guard/cdk/scrolling.d.ts @@ -0,0 +1,199 @@ +export declare type _Bottom = { + bottom?: number; +}; + +export declare type _End = { + end?: number; +}; + +export declare function _fixedSizeVirtualScrollStrategyFactory(fixedSizeDir: CdkFixedSizeVirtualScroll): FixedSizeVirtualScrollStrategy; + +export declare type _Left = { + left?: number; +}; + +export declare type _Right = { + right?: number; +}; + +export declare type _Start = { + start?: number; +}; + +export declare type _Top = { + top?: number; +}; + +export declare type _Without = { + [P in keyof T]?: never; +}; + +export declare type _XAxis = _XOR<_XOR<_Left, _Right>, _XOR<_Start, _End>>; + +export declare type _XOR = (_Without & U) | (_Without & T); + +export declare type _YAxis = _XOR<_Top, _Bottom>; + +export declare class CdkFixedSizeVirtualScroll implements OnChanges { + _itemSize: number; + _maxBufferPx: number; + _minBufferPx: number; + _scrollStrategy: FixedSizeVirtualScrollStrategy; + itemSize: number; + maxBufferPx: number; + minBufferPx: number; + ngOnChanges(): void; +} + +export declare class CdkScrollable implements OnInit, OnDestroy { + protected dir?: Directionality | undefined; + protected elementRef: ElementRef; + protected ngZone: NgZone; + protected scrollDispatcher: ScrollDispatcher; + constructor(elementRef: ElementRef, scrollDispatcher: ScrollDispatcher, ngZone: NgZone, dir?: Directionality | undefined); + elementScrolled(): Observable; + getElementRef(): ElementRef; + measureScrollOffset(from: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number; + ngOnDestroy(): void; + ngOnInit(): void; + scrollTo(options: ExtendedScrollToOptions): void; +} + +export declare class CdkVirtualForOf implements CollectionViewer, DoCheck, OnDestroy { + _cdkVirtualForOf: DataSource | Observable | NgIterable; + cdkVirtualForOf: DataSource | Observable | NgIterable; + cdkVirtualForTemplate: TemplateRef>; + cdkVirtualForTemplateCacheSize: number; + cdkVirtualForTrackBy: TrackByFunction | undefined; + dataStream: Observable>; + viewChange: Subject; + constructor( + _viewContainerRef: ViewContainerRef, + _template: TemplateRef>, + _differs: IterableDiffers, + _viewport: CdkVirtualScrollViewport, ngZone: NgZone); + measureRangeSize(range: ListRange, orientation: 'horizontal' | 'vertical'): number; + ngDoCheck(): void; + ngOnDestroy(): void; +} + +export declare type CdkVirtualForOfContext = { + $implicit: T; + cdkVirtualForOf: DataSource | Observable | NgIterable; + index: number; + count: number; + first: boolean; + last: boolean; + even: boolean; + odd: boolean; +}; + +export declare class CdkVirtualScrollViewport extends CdkScrollable implements OnInit, OnDestroy { + _contentWrapper: ElementRef; + _totalContentSizeTransform: string; + elementRef: ElementRef; + orientation: 'horizontal' | 'vertical'; + renderedRangeStream: Observable; + scrolledIndexChange: Observable; + constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, ngZone: NgZone, _scrollStrategy: VirtualScrollStrategy, dir: Directionality, scrollDispatcher: ScrollDispatcher); + attach(forOf: CdkVirtualForOf): void; + checkViewportSize(): void; + detach(): void; + getDataLength(): number; + getOffsetToRenderedContentStart(): number | null; + getRenderedRange(): ListRange; + getViewportSize(): number; + measureRangeSize(range: ListRange): number; + measureRenderedContentSize(): number; + measureScrollOffset(from?: 'top' | 'left' | 'right' | 'bottom' | 'start' | 'end'): number; + ngOnDestroy(): void; + ngOnInit(): void; + scrollToIndex(index: number, behavior?: ScrollBehavior): void; + scrollToOffset(offset: number, behavior?: ScrollBehavior): void; + setRenderedContentOffset(offset: number, to?: 'to-start' | 'to-end'): void; + setRenderedRange(range: ListRange): void; + setTotalContentSize(size: number): void; +} + +export declare const DEFAULT_RESIZE_TIME = 20; + +export declare const DEFAULT_SCROLL_TIME = 20; + +export declare type ExtendedScrollToOptions = _XAxis & _YAxis & ScrollOptions; + +export declare class FixedSizeVirtualScrollStrategy implements VirtualScrollStrategy { + scrolledIndexChange: Observable; + constructor(itemSize: number, minBufferPx: number, maxBufferPx: number); + attach(viewport: CdkVirtualScrollViewport): void; + detach(): void; + onContentRendered(): void; + onContentScrolled(): void; + onDataLengthChanged(): void; + onRenderedOffsetChanged(): void; + scrollToIndex(index: number, behavior: ScrollBehavior): void; + updateItemAndBufferSize(itemSize: number, minBufferPx: number, maxBufferPx: number): void; +} + +export declare const SCROLL_DISPATCHER_PROVIDER: { + provide: typeof ScrollDispatcher; + deps: (Optional[] | typeof NgZone | typeof Platform)[]; + useFactory: typeof SCROLL_DISPATCHER_PROVIDER_FACTORY; +}; + +export declare function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher: ScrollDispatcher, ngZone: NgZone, platform: Platform): ScrollDispatcher; + +export declare class ScrollDispatcher implements OnDestroy { + _globalSubscription: Subscription | null; + scrollContainers: Map; + constructor(_ngZone: NgZone, _platform: Platform); + ancestorScrolled(elementRef: ElementRef, auditTimeInMs?: number): Observable; + deregister(scrollable: CdkScrollable): void; + getAncestorScrollContainers(elementRef: ElementRef): CdkScrollable[]; + ngOnDestroy(): void; + register(scrollable: CdkScrollable): void; + scrolled(auditTimeInMs?: number): Observable; +} + +export declare class ScrollDispatchModule { +} + +export declare class ScrollingModule { +} + +export declare const VIEWPORT_RULER_PROVIDER: { + provide: typeof ViewportRuler; + deps: (Optional[] | typeof NgZone | typeof Platform)[]; + useFactory: typeof VIEWPORT_RULER_PROVIDER_FACTORY; +}; + +export declare function VIEWPORT_RULER_PROVIDER_FACTORY(parentRuler: ViewportRuler, platform: Platform, ngZone: NgZone): ViewportRuler; + +export declare class ViewportRuler implements OnDestroy { + constructor(_platform: Platform, ngZone: NgZone); + change(throttleTime?: number): Observable; + getViewportRect(): ClientRect; + getViewportScrollPosition(): ViewportScrollPosition; + getViewportSize(): Readonly<{ + width: number; + height: number; + }>; + ngOnDestroy(): void; +} + +export interface ViewportScrollPosition { + left: number; + top: number; +} + +export declare const VIRTUAL_SCROLL_STRATEGY: InjectionToken; + +export interface VirtualScrollStrategy { + scrolledIndexChange: Observable; + attach(viewport: CdkVirtualScrollViewport): void; + detach(): void; + onContentRendered(): void; + onContentScrolled(): void; + onDataLengthChanged(): void; + onRenderedOffsetChanged(): void; + scrollToIndex(index: number, behavior: ScrollBehavior): void; +} diff --git a/tools/public_api_guard/cdk/stepper.d.ts b/tools/public_api_guard/cdk/stepper.d.ts new file mode 100644 index 000000000000..7d6448816558 --- /dev/null +++ b/tools/public_api_guard/cdk/stepper.d.ts @@ -0,0 +1,99 @@ +export declare class CdkStep implements OnChanges { + _displayDefaultIndicatorType: boolean; + _showError: boolean; + ariaLabel: string; + ariaLabelledby: string; + completed: boolean; + content: TemplateRef; + editable: boolean; + errorMessage: string; + hasError: boolean; + interacted: boolean; + label: string; + optional: boolean; + state: StepState; + stepControl: AbstractControl; + stepLabel: CdkStepLabel; + constructor(_stepper: CdkStepper, stepperOptions?: StepperOptions); + ngOnChanges(): void; + reset(): void; + select(): void; +} + +export declare class CdkStepHeader implements FocusableOption { + protected _elementRef: ElementRef; + constructor(_elementRef: ElementRef); + focus(): void; +} + +export declare class CdkStepLabel { + template: TemplateRef; + constructor(/** @docs-private */ template: TemplateRef); +} + +export declare class CdkStepper implements AfterViewInit, OnDestroy { + protected _destroyed: Subject; + _groupId: number; + protected _orientation: StepperOrientation; + _stepHeader: QueryList; + _steps: QueryList; + linear: boolean; + selected: CdkStep; + selectedIndex: number; + selectionChange: EventEmitter; + constructor(_dir: Directionality, _changeDetectorRef: ChangeDetectorRef, _elementRef?: ElementRef | undefined, _document?: any); + _getAnimationDirection(index: number): StepContentPositionState; + _getFocusIndex(): number | null; + _getIndicatorType(index: number, state?: StepState): StepState; + _getStepContentId(i: number): string; + _getStepLabelId(i: number): string; + _onKeydown(event: KeyboardEvent): void; + _stateChanged(): void; + next(): void; + ngAfterViewInit(): void; + ngOnDestroy(): void; + previous(): void; + reset(): void; +} + +export declare class CdkStepperModule { +} + +export declare class CdkStepperNext { + _stepper: CdkStepper; + type: string; + constructor(_stepper: CdkStepper); +} + +export declare class CdkStepperPrevious { + _stepper: CdkStepper; + type: string; + constructor(_stepper: CdkStepper); +} + +export declare const MAT_STEPPER_GLOBAL_OPTIONS: InjectionToken; + +export declare const STEP_STATE: { + NUMBER: string; + EDIT: string; + DONE: string; + ERROR: string; +}; + +export declare type StepContentPositionState = 'previous' | 'current' | 'next'; + +export interface StepperOptions { + displayDefaultIndicatorType?: boolean; + showError?: boolean; +} + +export declare type StepperOrientation = 'horizontal' | 'vertical'; + +export declare class StepperSelectionEvent { + previouslySelectedIndex: number; + previouslySelectedStep: CdkStep; + selectedIndex: number; + selectedStep: CdkStep; +} + +export declare type StepState = 'number' | 'edit' | 'done' | 'error' | string; diff --git a/tools/public_api_guard/cdk/table.d.ts b/tools/public_api_guard/cdk/table.d.ts new file mode 100644 index 000000000000..74812cae49f1 --- /dev/null +++ b/tools/public_api_guard/cdk/table.d.ts @@ -0,0 +1,240 @@ +export declare const _CdkColumnDefBase: CanStickCtor & typeof CdkColumnDefBase; + +export declare const _CdkFooterRowDefBase: CanStickCtor & typeof CdkFooterRowDefBase; + +export declare const _CdkHeaderRowDefBase: CanStickCtor & typeof CdkHeaderRowDefBase; + +export declare class BaseCdkCell { + constructor(columnDef: CdkColumnDef, elementRef: ElementRef); +} + +export declare abstract class BaseRowDef implements OnChanges { + protected _columnsDiffer: IterableDiffer; + protected _differs: IterableDiffers; + columns: Iterable; + template: TemplateRef; + constructor(/** @docs-private */ template: TemplateRef, _differs: IterableDiffers); + extractCellTemplate(column: CdkColumnDef): TemplateRef; + getColumnsDiff(): IterableChanges | null; + ngOnChanges(changes: SimpleChanges): void; +} + +export interface CanStick { + _hasStickyChanged: boolean; + sticky: boolean; + hasStickyChanged(): boolean; + resetStickyChanged(): void; +} + +export declare type CanStickCtor = Constructor; + +export declare const CDK_ROW_TEMPLATE = ""; + +export declare const CDK_TABLE_TEMPLATE = "\n \n \n "; + +export declare class CdkCell extends BaseCdkCell { + constructor(columnDef: CdkColumnDef, elementRef: ElementRef); +} + +export declare class CdkCellDef implements CellDef { + template: TemplateRef; + constructor(/** @docs-private */ template: TemplateRef); +} + +export declare class CdkCellOutlet implements OnDestroy { + _viewContainer: ViewContainerRef; + cells: CdkCellDef[]; + context: any; + constructor(_viewContainer: ViewContainerRef); + ngOnDestroy(): void; + static mostRecentCellOutlet: CdkCellOutlet | null; +} + +export interface CdkCellOutletMultiRowContext { + $implicit?: T; + count?: number; + dataIndex?: number; + even?: boolean; + first?: boolean; + last?: boolean; + odd?: boolean; + renderIndex?: number; +} + +export interface CdkCellOutletRowContext { + $implicit?: T; + count?: number; + even?: boolean; + first?: boolean; + index?: number; + last?: boolean; + odd?: boolean; +} + +export declare class CdkColumnDef extends _CdkColumnDefBase implements CanStick { + _name: string; + _stickyEnd: boolean; + cell: CdkCellDef; + cssClassFriendlyName: string; + footerCell: CdkFooterCellDef; + headerCell: CdkHeaderCellDef; + name: string; + stickyEnd: boolean; +} + +export declare class CdkColumnDefBase { +} + +export declare class CdkFooterCell extends BaseCdkCell { + constructor(columnDef: CdkColumnDef, elementRef: ElementRef); +} + +export declare class CdkFooterCellDef implements CellDef { + template: TemplateRef; + constructor(/** @docs-private */ template: TemplateRef); +} + +export declare class CdkFooterRow { +} + +export declare class CdkFooterRowDef extends _CdkFooterRowDefBase implements CanStick, OnChanges { + constructor(template: TemplateRef, _differs: IterableDiffers); + ngOnChanges(changes: SimpleChanges): void; +} + +export declare class CdkFooterRowDefBase extends BaseRowDef { +} + +export declare class CdkHeaderCell extends BaseCdkCell { + constructor(columnDef: CdkColumnDef, elementRef: ElementRef); +} + +export declare class CdkHeaderCellDef implements CellDef { + template: TemplateRef; + constructor(/** @docs-private */ template: TemplateRef); +} + +export declare class CdkHeaderRow { +} + +export declare class CdkHeaderRowDef extends _CdkHeaderRowDefBase implements CanStick, OnChanges { + constructor(template: TemplateRef, _differs: IterableDiffers); + ngOnChanges(changes: SimpleChanges): void; +} + +export declare class CdkHeaderRowDefBase extends BaseRowDef { +} + +export declare class CdkRow { +} + +export declare class CdkRowDef extends BaseRowDef { + when: (index: number, rowData: T) => boolean; + constructor(template: TemplateRef, _differs: IterableDiffers); +} + +export declare class CdkTable implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit { + protected readonly _changeDetectorRef: ChangeDetectorRef; + _contentColumnDefs: QueryList; + _contentFooterRowDefs: QueryList; + _contentHeaderRowDefs: QueryList; + _contentRowDefs: QueryList>; + protected _data: T[] | ReadonlyArray; + protected readonly _differs: IterableDiffers; + protected readonly _dir: Directionality; + protected readonly _elementRef: ElementRef; + _footerRowOutlet: FooterRowOutlet; + _headerRowOutlet: HeaderRowOutlet; + _multiTemplateDataRows: boolean; + _rowOutlet: DataRowOutlet; + dataSource: CdkTableDataSourceInput; + multiTemplateDataRows: boolean; + protected stickyCssClass: string; + trackBy: TrackByFunction; + viewChange: BehaviorSubject<{ + start: number; + end: number; + }>; + constructor(_differs: IterableDiffers, _changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef, role: string, _dir: Directionality, + _document?: any, _platform?: Platform | undefined); + _getRenderedRows(rowOutlet: RowOutlet): HTMLElement[]; + _getRowDefs(data: T, dataIndex: number): CdkRowDef[]; + addColumnDef(columnDef: CdkColumnDef): void; + addFooterRowDef(footerRowDef: CdkFooterRowDef): void; + addHeaderRowDef(headerRowDef: CdkHeaderRowDef): void; + addRowDef(rowDef: CdkRowDef): void; + ngAfterContentChecked(): void; + ngOnDestroy(): void; + ngOnInit(): void; + removeColumnDef(columnDef: CdkColumnDef): void; + removeFooterRowDef(footerRowDef: CdkFooterRowDef): void; + removeHeaderRowDef(headerRowDef: CdkHeaderRowDef): void; + removeRowDef(rowDef: CdkRowDef): void; + renderRows(): void; + setFooterRowDef(footerRowDef: CdkFooterRowDef): void; + setHeaderRowDef(headerRowDef: CdkHeaderRowDef): void; + updateStickyColumnStyles(): void; + updateStickyFooterRowStyles(): void; + updateStickyHeaderRowStyles(): void; +} + +export declare class CdkTableModule { +} + +export interface CellDef { + template: TemplateRef; +} + +export declare type Constructor = new (...args: any[]) => T; + +export declare class DataRowOutlet implements RowOutlet { + elementRef: ElementRef; + viewContainer: ViewContainerRef; + constructor(viewContainer: ViewContainerRef, elementRef: ElementRef); +} + +export declare class FooterRowOutlet implements RowOutlet { + elementRef: ElementRef; + viewContainer: ViewContainerRef; + constructor(viewContainer: ViewContainerRef, elementRef: ElementRef); +} + +export declare class HeaderRowOutlet implements RowOutlet { + elementRef: ElementRef; + viewContainer: ViewContainerRef; + constructor(viewContainer: ViewContainerRef, elementRef: ElementRef); +} + +export declare function mixinHasStickyInput>(base: T): CanStickCtor & T; + +export interface RenderRow { + data: T; + dataIndex: number; + rowDef: CdkRowDef; +} + +export interface RowContext extends CdkCellOutletMultiRowContext, CdkCellOutletRowContext { +} + +export interface RowOutlet { + viewContainer: ViewContainerRef; +} + +export declare const STICKY_DIRECTIONS: StickyDirection[]; + +export declare type StickyDirection = 'top' | 'bottom' | 'left' | 'right'; + +export declare class StickyStyler { + direction: Direction; + constructor(isNativeHtmlTable: boolean, stickCellCss: string, direction: Direction, _isBrowser?: boolean); + _addStickyStyle(element: HTMLElement, dir: StickyDirection, dirValue: number): void; + _getCalculatedZIndex(element: HTMLElement): string; + _getCellWidths(row: HTMLElement): number[]; + _getStickyEndColumnPositions(widths: number[], stickyStates: boolean[]): number[]; + _getStickyStartColumnPositions(widths: number[], stickyStates: boolean[]): number[]; + _removeStickyStyle(element: HTMLElement, stickyDirections: StickyDirection[]): void; + clearStickyPositioning(rows: HTMLElement[], stickyDirections: StickyDirection[]): void; + stickRows(rowsToStick: HTMLElement[], stickyStates: boolean[], position: 'top' | 'bottom'): void; + updateStickyColumns(rows: HTMLElement[], stickyStartStates: boolean[], stickyEndStates: boolean[]): void; + updateStickyFooterContainer(tableElement: Element, stickyStates: boolean[]): void; +} diff --git a/tools/public_api_guard/cdk/text-field.d.ts b/tools/public_api_guard/cdk/text-field.d.ts new file mode 100644 index 000000000000..1961e048752b --- /dev/null +++ b/tools/public_api_guard/cdk/text-field.d.ts @@ -0,0 +1,38 @@ +export declare type AutofillEvent = { + target: Element; + isAutofilled: boolean; +}; + +export declare class AutofillMonitor implements OnDestroy { + constructor(_platform: Platform, _ngZone: NgZone); + monitor(element: Element): Observable; + monitor(element: ElementRef): Observable; + ngOnDestroy(): void; + stopMonitoring(element: Element): void; + stopMonitoring(element: ElementRef): void; +} + +export declare class CdkAutofill implements OnDestroy, OnInit { + cdkAutofill: EventEmitter; + constructor(_elementRef: ElementRef, _autofillMonitor: AutofillMonitor); + ngOnDestroy(): void; + ngOnInit(): void; +} + +export declare class CdkTextareaAutosize implements AfterViewInit, DoCheck, OnDestroy { + enabled: boolean; + maxRows: number; + minRows: number; + constructor(_elementRef: ElementRef, _platform: Platform, _ngZone: NgZone); + _noopInputHandler(): void; + _setMaxHeight(): void; + _setMinHeight(): void; + ngAfterViewInit(): void; + ngDoCheck(): void; + ngOnDestroy(): void; + reset(): void; + resizeToFitContent(force?: boolean): void; +} + +export declare class TextFieldModule { +} diff --git a/tools/public_api_guard/cdk/tree.d.ts b/tools/public_api_guard/cdk/tree.d.ts new file mode 100644 index 000000000000..766379e40d15 --- /dev/null +++ b/tools/public_api_guard/cdk/tree.d.ts @@ -0,0 +1,153 @@ +export declare abstract class BaseTreeControl implements TreeControl { + dataNodes: T[]; + expansionModel: SelectionModel; + getChildren: (dataNode: T) => (Observable | T[]); + getLevel: (dataNode: T) => number; + isExpandable: (dataNode: T) => boolean; + collapse(dataNode: T): void; + collapseAll(): void; + collapseDescendants(dataNode: T): void; + expand(dataNode: T): void; + abstract expandAll(): void; + expandDescendants(dataNode: T): void; + abstract getDescendants(dataNode: T): T[]; + isExpanded(dataNode: T): boolean; + toggle(dataNode: T): void; + toggleDescendants(dataNode: T): void; +} + +export declare class CdkNestedTreeNode extends CdkTreeNode implements AfterContentInit, OnDestroy { + protected _children: T[]; + protected _differs: IterableDiffers; + protected _elementRef: ElementRef; + protected _tree: CdkTree; + nodeOutlet: QueryList; + constructor(_elementRef: ElementRef, _tree: CdkTree, _differs: IterableDiffers); + protected _clear(): void; + ngAfterContentInit(): void; + ngOnDestroy(): void; + protected updateChildrenNodes(children?: T[]): void; +} + +export declare class CdkTree implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit { + _nodeDefs: QueryList>; + _nodeOutlet: CdkTreeNodeOutlet; + dataSource: DataSource | Observable | T[]; + trackBy: TrackByFunction; + treeControl: TreeControl; + viewChange: BehaviorSubject<{ + start: number; + end: number; + }>; + constructor(_differs: IterableDiffers, _changeDetectorRef: ChangeDetectorRef); + _getNodeDef(data: T, i: number): CdkTreeNodeDef; + insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T): void; + ngAfterContentChecked(): void; + ngOnDestroy(): void; + ngOnInit(): void; + renderNodeChanges(data: T[] | ReadonlyArray, dataDiffer?: IterableDiffer, viewContainer?: ViewContainerRef, parentData?: T): void; +} + +export declare class CdkTreeModule { +} + +export declare class CdkTreeNode implements FocusableOption, OnDestroy { + protected _data: T; + protected _destroyed: Subject; + protected _elementRef: ElementRef; + protected _tree: CdkTree; + data: T; + readonly isExpanded: boolean; + readonly level: number; + role: 'treeitem' | 'group'; + constructor(_elementRef: ElementRef, _tree: CdkTree); + protected _setRoleFromChildren(children: T[]): void; + protected _setRoleFromData(): void; + focus(): void; + ngOnDestroy(): void; + static mostRecentTreeNode: CdkTreeNode | null; +} + +export declare class CdkTreeNodeDef { + template: TemplateRef; + when: (index: number, nodeData: T) => boolean; + constructor(template: TemplateRef); +} + +export declare class CdkTreeNodeOutlet { + viewContainer: ViewContainerRef; + constructor(viewContainer: ViewContainerRef); +} + +export declare class CdkTreeNodeOutletContext { + $implicit: T; + count?: number; + index?: number; + level: number; + constructor(data: T); +} + +export declare class CdkTreeNodePadding implements OnDestroy { + _indent: number; + _level: number; + indent: number | string; + indentUnits: string; + level: number; + constructor(_treeNode: CdkTreeNode, _tree: CdkTree, _renderer: Renderer2, _element: ElementRef, _dir: Directionality); + _paddingIndent(): string | null; + _setPadding(): void; + ngOnDestroy(): void; +} + +export declare class CdkTreeNodeToggle { + protected _recursive: boolean; + protected _tree: CdkTree; + protected _treeNode: CdkTreeNode; + recursive: boolean; + constructor(_tree: CdkTree, _treeNode: CdkTreeNode); + _toggle(event: Event): void; +} + +export declare class FlatTreeControl extends BaseTreeControl { + getLevel: (dataNode: T) => number; + isExpandable: (dataNode: T) => boolean; + constructor(getLevel: (dataNode: T) => number, isExpandable: (dataNode: T) => boolean); + expandAll(): void; + getDescendants(dataNode: T): T[]; +} + +export declare function getTreeControlFunctionsMissingError(): Error; + +export declare function getTreeControlMissingError(): Error; + +export declare function getTreeMissingMatchingNodeDefError(): Error; + +export declare function getTreeMultipleDefaultNodeDefsError(): Error; + +export declare function getTreeNoValidDataSourceError(): Error; + +export declare class NestedTreeControl extends BaseTreeControl { + getChildren: (dataNode: T) => (Observable | T[]); + constructor(getChildren: (dataNode: T) => (Observable | T[])); + protected _getDescendants(descendants: T[], dataNode: T): void; + expandAll(): void; + getDescendants(dataNode: T): T[]; +} + +export interface TreeControl { + dataNodes: T[]; + expansionModel: SelectionModel; + readonly getChildren: (dataNode: T) => Observable | T[]; + readonly getLevel: (dataNode: T) => number; + readonly isExpandable: (dataNode: T) => boolean; + collapse(dataNode: T): void; + collapseAll(): void; + collapseDescendants(dataNode: T): void; + expand(dataNode: T): void; + expandAll(): void; + expandDescendants(dataNode: T): void; + getDescendants(dataNode: T): any[]; + isExpanded(dataNode: T): boolean; + toggle(dataNode: T): void; + toggleDescendants(dataNode: T): void; +} diff --git a/tools/public_api_guard/generate-guard-tests.bzl b/tools/public_api_guard/generate-guard-tests.bzl new file mode 100644 index 000000000000..d0c8580bb9b3 --- /dev/null +++ b/tools/public_api_guard/generate-guard-tests.bzl @@ -0,0 +1,34 @@ +load("@angular//tools/ts-api-guardian:index.bzl", "ts_api_guardian_test") + +""" + Macro for generating ts-api-guardian Bazel test targets. Since there are multiple golden files + in this package, we don't want to manually set up all golden files. In order to make this + more maintainable, we allow passing a list of golden files that will be automatically verified + against the associated source entry point. +""" +def generate_test_targets(golden_files): + for golden_file in golden_files: + # Splits the path that is relative to the current directory into the package name and + # entry point tail path. The package name is always the first path segment (e.g. "cdk/") + [package_name, entry_point_tail] = golden_file.split("/", 1) + + # Name of the entry-point (e.g. "a11y", "drag-drop", "platform") + entry_point = entry_point_tail[:-len(".d.ts")] + + # Construct the path to the given entry-point. Note that we also need to find a way to + # allow guards for the primary entry-point of a package. e.g. "//src/cdk:cdk" should be also + # validated. We achieve this by checking if the package_name is equal to the entry_point name. + # For example: "public_api_guard/cdk/cdk.d.ts" will be the golden for the primary entry-point. + entry_point_path = "%s" % (package_name if entry_point == package_name + else "%s/%s" % (package_name, entry_point)) + + # Create the test rule that compares the build output with the golden file. + ts_api_guardian_test( + name = "%s_%s_api" % (package_name, entry_point), + actual = "angular_material/src/%s/index.d.ts" % entry_point_path, + data = [golden_file] + [ + "//src/%s" % (entry_point_path), + ], + golden = "angular_material/tools/public_api_guard/%s" % golden_file, + use_angular_tag_rules = False, + ) diff --git a/tsconfig.json b/tsconfig.json index cda8912c360c..9db1f4a58b1c 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -27,6 +27,9 @@ // cause ambiguous imports. For example `setTimeout()` will return a Timer instead of a number. "./src/universal-app/prerender.ts", + // Exclude the API goldens in order to not slow-down IDE's using this tsconfig file + "tools/public_api_guard/**/*.d.ts", + // IDEs should not type-check the different node_modules directories of the different packages. // This would cause the IDEs to be slower and also linters would check the node_modules. "node_modules/" diff --git a/tslint.json b/tslint.json index f24fc55f5763..fbd4824213de 100644 --- a/tslint.json +++ b/tslint.json @@ -134,6 +134,8 @@ }, "linterOptions": { "exclude": [ + // Exclude the API golden files + "tools/public_api_guard/**/*.d.ts", // Exclude schematic template files and test cases that can't be linted. "src/lib/schematics/ng-generate/*/files/**/*", "src/cdk/schematics/ng-generate/*/files/**/*",