build: test material entry-points against api goldens

src/lib/BUILD.bazel

@@ -13,6 +13,12 @@ ng_module(
   deps = ["//src/lib/%s" % p for p in MATERIAL_PACKAGES],
 )
 
+# Alias so that developers can build Material using it's label shorthand (e.g. "build //src/lib")
+alias(
+  name = "lib",
+  actual = "material",
+)
+
 sass_bundle(
   name = "theming_bundle",
   srcs = [

tools/public_api_guard/BUILD.bazel

@@ -2,8 +2,8 @@ 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.
+# TODO(devversion): All entry-points except the CDK portal are currently validated. This is
+# 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"]))

tools/public_api_guard/lib/autocomplete.d.ts

@@ -0,0 +1,94 @@
+export declare const _MatAutocompleteMixinBase: CanDisableRippleCtor & typeof MatAutocompleteBase;
+
+export declare const AUTOCOMPLETE_OPTION_HEIGHT = 48;
+
+export declare const AUTOCOMPLETE_PANEL_HEIGHT = 256;
+
+export declare function getMatAutocompleteMissingPanelError(): Error;
+
+export declare const MAT_AUTOCOMPLETE_DEFAULT_OPTIONS: InjectionToken<MatAutocompleteDefaultOptions>;
+
+export declare function MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY(): MatAutocompleteDefaultOptions;
+
+export declare const MAT_AUTOCOMPLETE_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+
+export declare function MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+
+export declare const MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY;
+};
+
+export declare const MAT_AUTOCOMPLETE_VALUE_ACCESSOR: any;
+
+export declare class MatAutocomplete extends _MatAutocompleteMixinBase implements AfterContentInit, CanDisableRipple {
+    _classList: {
+        [key: string]: boolean;
+    };
+    _isOpen: boolean;
+    _keyManager: ActiveDescendantKeyManager<MatOption>;
+    autoActiveFirstOption: boolean;
+    classList: string;
+    readonly closed: EventEmitter<void>;
+    displayWith: ((value: any) => string) | null;
+    id: string;
+    readonly isOpen: boolean;
+    readonly opened: EventEmitter<void>;
+    optionGroups: QueryList<MatOptgroup>;
+    readonly optionSelected: EventEmitter<MatAutocompleteSelectedEvent>;
+    options: QueryList<MatOption>;
+    panel: ElementRef;
+    panelWidth: string | number;
+    showPanel: boolean;
+    template: TemplateRef<any>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, defaults: MatAutocompleteDefaultOptions);
+    _emitSelectEvent(option: MatOption): void;
+    _getScrollTop(): number;
+    _setScrollTop(scrollTop: number): void;
+    _setVisibility(): void;
+    ngAfterContentInit(): void;
+}
+
+export declare class MatAutocompleteBase {
+}
+
+export interface MatAutocompleteDefaultOptions {
+    autoActiveFirstOption?: boolean;
+}
+
+export declare class MatAutocompleteModule {
+}
+
+export declare class MatAutocompleteSelectedEvent {
+    option: MatOption;
+    source: MatAutocomplete;
+    constructor(
+    source: MatAutocomplete,
+    option: MatOption);
+}
+
+export declare class MatAutocompleteTrigger implements ControlValueAccessor, OnDestroy {
+    _onChange: (value: any) => void;
+    _onTouched: () => void;
+    readonly activeOption: MatOption | null;
+    autocomplete: MatAutocomplete;
+    autocompleteAttribute: string;
+    autocompleteDisabled: boolean;
+    connectedTo: MatAutocompleteOrigin;
+    readonly optionSelections: Observable<MatOptionSelectionChange>;
+    readonly panelClosingActions: Observable<MatOptionSelectionChange | null>;
+    readonly panelOpen: boolean;
+    constructor(_element: ElementRef<HTMLInputElement>, _overlay: Overlay, _viewContainerRef: ViewContainerRef, _zone: NgZone, _changeDetectorRef: ChangeDetectorRef, scrollStrategy: any, _dir: Directionality, _formField: MatFormField, _document: any, _viewportRuler?: ViewportRuler | undefined);
+    _handleFocus(): void;
+    _handleInput(event: KeyboardEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
+    closePanel(): void;
+    ngOnDestroy(): void;
+    openPanel(): void;
+    registerOnChange(fn: (value: any) => {}): void;
+    registerOnTouched(fn: () => {}): void;
+    setDisabledState(isDisabled: boolean): void;
+    updatePosition(): void;
+    writeValue(value: any): void;
+}

tools/public_api_guard/lib/badge.d.ts

@@ -0,0 +1,28 @@
+export declare const _MatBadgeMixinBase: CanDisableCtor & typeof MatBadgeBase;
+
+export declare class MatBadge extends _MatBadgeMixinBase implements OnDestroy, CanDisable {
+    _hasContent: boolean;
+    _id: number;
+    color: ThemePalette;
+    content: string;
+    description: string;
+    hidden: boolean;
+    overlap: boolean;
+    position: MatBadgePosition;
+    size: MatBadgeSize;
+    constructor(_document: any, _ngZone: NgZone, _elementRef: ElementRef<HTMLElement>, _ariaDescriber: AriaDescriber,
+    _renderer?: Renderer2 | undefined);
+    isAbove(): boolean;
+    isAfter(): boolean;
+    ngOnDestroy(): void;
+}
+
+export declare class MatBadgeBase {
+}
+
+export declare class MatBadgeModule {
+}
+
+export declare type MatBadgePosition = 'above after' | 'above before' | 'below before' | 'below after';
+
+export declare type MatBadgeSize = 'small' | 'medium' | 'large';

tools/public_api_guard/lib/bottom-sheet.d.ts

@@ -0,0 +1,60 @@
+export declare const MAT_BOTTOM_SHEET_DATA: InjectionToken<any>;
+
+export declare const MAT_BOTTOM_SHEET_DEFAULT_OPTIONS: InjectionToken<MatBottomSheetConfig<any>>;
+
+export declare class MatBottomSheet implements OnDestroy {
+    _openedBottomSheetRef: MatBottomSheetRef<any> | null;
+    constructor(_overlay: Overlay, _injector: Injector, _parentBottomSheet: MatBottomSheet, _location?: Location | undefined, _defaultOptions?: MatBottomSheetConfig<any> | undefined);
+    dismiss(): void;
+    ngOnDestroy(): void;
+    open<T, D = any, R = any>(template: TemplateRef<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+    open<T, D = any, R = any>(component: ComponentType<T>, config?: MatBottomSheetConfig<D>): MatBottomSheetRef<T, R>;
+}
+
+export declare const matBottomSheetAnimations: {
+    readonly bottomSheetState: AnimationTriggerMetadata;
+};
+
+export declare class MatBottomSheetConfig<D = any> {
+    ariaLabel?: string | null;
+    autoFocus?: boolean;
+    backdropClass?: string;
+    closeOnNavigation?: boolean;
+    data?: D | null;
+    direction?: Direction;
+    disableClose?: boolean;
+    hasBackdrop?: boolean;
+    panelClass?: string | string[];
+    restoreFocus?: boolean;
+    viewContainerRef?: ViewContainerRef;
+}
+
+export declare class MatBottomSheetContainer extends BasePortalOutlet implements OnDestroy {
+    _animationState: 'void' | 'visible' | 'hidden';
+    _animationStateChanged: EventEmitter<AnimationEvent>;
+    _portalOutlet: CdkPortalOutlet;
+    bottomSheetConfig: MatBottomSheetConfig;
+    constructor(_elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef, _focusTrapFactory: FocusTrapFactory, breakpointObserver: BreakpointObserver, document: any,
+    bottomSheetConfig: MatBottomSheetConfig);
+    _onAnimationDone(event: AnimationEvent): void;
+    _onAnimationStart(event: AnimationEvent): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    enter(): void;
+    exit(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatBottomSheetModule {
+}
+
+export declare class MatBottomSheetRef<T = any, R = any> {
+    containerInstance: MatBottomSheetContainer;
+    instance: T;
+    constructor(containerInstance: MatBottomSheetContainer, _overlayRef: OverlayRef, _location?: Location);
+    afterDismissed(): Observable<R | undefined>;
+    afterOpened(): Observable<void>;
+    backdropClick(): Observable<MouseEvent>;
+    dismiss(result?: R): void;
+    keydownEvents(): Observable<KeyboardEvent>;
+}

tools/public_api_guard/lib/button-toggle.d.ts

@@ -0,0 +1,79 @@
+export declare const _MatButtonToggleMixinBase: CanDisableRippleCtor & typeof MatButtonToggleBase;
+
+export declare const MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS: InjectionToken<MatButtonToggleDefaultOptions>;
+
+export declare const MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR: any;
+
+export declare class MatButtonToggle extends _MatButtonToggleMixinBase implements OnInit, CanDisableRipple, OnDestroy {
+    _buttonElement: ElementRef<HTMLButtonElement>;
+    _type: ToggleType;
+    appearance: MatButtonToggleAppearance;
+    ariaLabel: string;
+    ariaLabelledby: string | null;
+    readonly buttonId: string;
+    buttonToggleGroup: MatButtonToggleGroup;
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    checked: boolean;
+    disabled: boolean;
+    id: string;
+    name: string;
+    tabIndex: number | null;
+    value: any;
+    constructor(toggleGroup: MatButtonToggleGroup, _changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, _focusMonitor: FocusMonitor, defaultTabIndex: string, defaultOptions?: MatButtonToggleDefaultOptions);
+    _markForCheck(): void;
+    _onButtonClick(): void;
+    focus(): void;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+}
+
+export declare type MatButtonToggleAppearance = 'legacy' | 'standard';
+
+export declare class MatButtonToggleBase {
+}
+
+export declare class MatButtonToggleChange {
+    source: MatButtonToggle;
+    value: any;
+    constructor(
+    source: MatButtonToggle,
+    value: any);
+}
+
+export interface MatButtonToggleDefaultOptions {
+    appearance?: MatButtonToggleAppearance;
+}
+
+export declare class MatButtonToggleGroup implements ControlValueAccessor, OnInit, AfterContentInit {
+    _buttonToggles: QueryList<MatButtonToggle>;
+    _controlValueAccessorChangeFn: (value: any) => void;
+    _onTouched: () => any;
+    appearance: MatButtonToggleAppearance;
+    readonly change: EventEmitter<MatButtonToggleChange>;
+    disabled: boolean;
+    multiple: boolean;
+    name: string;
+    readonly selected: MatButtonToggle | MatButtonToggle[];
+    value: any;
+    readonly valueChange: EventEmitter<any>;
+    vertical: boolean;
+    constructor(_changeDetector: ChangeDetectorRef, defaultOptions?: MatButtonToggleDefaultOptions);
+    _emitChangeEvent(): void;
+    _isPrechecked(toggle: MatButtonToggle): boolean;
+    _isSelected(toggle: MatButtonToggle): boolean;
+    _syncButtonToggle(toggle: MatButtonToggle, select: boolean, isUserInput?: boolean): void;
+    ngAfterContentInit(): void;
+    ngOnInit(): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+}
+
+export declare class MatButtonToggleGroupMultiple {
+}
+
+export declare class MatButtonToggleModule {
+}
+
+export declare type ToggleType = 'checkbox' | 'radio';

tools/public_api_guard/lib/button.d.ts

@@ -0,0 +1,29 @@
+export declare const _MatButtonMixinBase: CanDisableRippleCtor & CanDisableCtor & CanColorCtor & typeof MatButtonBase;
+
+export declare class MatAnchor extends MatButton {
+    tabIndex: number;
+    constructor(platform: Platform, focusMonitor: FocusMonitor, elementRef: ElementRef, animationMode?: string);
+    _haltDisabledEvents(event: Event): void;
+}
+
+export declare class MatButton extends _MatButtonMixinBase implements OnDestroy, CanDisable, CanColor, CanDisableRipple {
+    _animationMode?: string | undefined;
+    readonly isIconButton: boolean;
+    readonly isRoundButton: boolean;
+    ripple: MatRipple;
+    constructor(elementRef: ElementRef,
+    _platform: Platform, _focusMonitor: FocusMonitor, _animationMode?: string | undefined);
+    _getHostElement(): any;
+    _hasHostAttributes(...attributes: string[]): boolean;
+    _isRippleDisabled(): boolean;
+    focus(): void;
+    ngOnDestroy(): void;
+}
+
+export declare class MatButtonBase {
+    _elementRef: ElementRef;
+    constructor(_elementRef: ElementRef);
+}
+
+export declare class MatButtonModule {
+}

tools/public_api_guard/lib/card.d.ts

@@ -0,0 +1,45 @@
+export declare class MatCard {
+}
+
+export declare class MatCardActions {
+    align: 'start' | 'end';
+}
+
+export declare class MatCardAvatar {
+}
+
+export declare class MatCardContent {
+}
+
+export declare class MatCardFooter {
+}
+
+export declare class MatCardHeader {
+}
+
+export declare class MatCardImage {
+}
+
+export declare class MatCardLgImage {
+}
+
+export declare class MatCardMdImage {
+}
+
+export declare class MatCardModule {
+}
+
+export declare class MatCardSmImage {
+}
+
+export declare class MatCardSubtitle {
+}
+
+export declare class MatCardTitle {
+}
+
+export declare class MatCardTitleGroup {
+}
+
+export declare class MatCardXlImage {
+}