@blox/material
Version:
Material Components for Angular
392 lines • 44.5 kB
JavaScript
import { ContentChildren, Directive, ElementRef, EventEmitter, HostBinding, Input, Output, Renderer2, Inject, Optional, Self, HostListener } from '@angular/core';
import { MDCDismissibleDrawerFoundation, MDCModalDrawerFoundation } from '@material/drawer';
import { asBoolean } from '../../utils/value.utils';
import { DOCUMENT } from '@angular/common';
import { AbstractMdcFocusTrap } from '../focus-trap/abstract.mdc.focus-trap';
import { MdcListItemDirective } from '../list/mdc.list.directive';
/**
* Directive for the title of a drawer. The use of this directive is optional.
* If used, it should be placed as first element inside an `mdcDrawerHeader`
*/
export class MdcDrawerTitleDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcDrawerTitleDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerTitle]'
},] }
];
MdcDrawerTitleDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer__title',] }]
};
/**
* Directive for the subtitle of a drawer. The use of this directive is optional.
* If used, it should be placed as a sibling element of `mdcDrawerTitle`
* inside an `mdcDrawerHeader`
*/
export class MdcDrawerSubtitleDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcDrawerSubtitleDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerSubtitle]'
},] }
];
MdcDrawerSubtitleDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer__subtitle',] }]
};
/**
* A toolbar header is an optional first child of an `mdcDrawer`.
* The header will not scroll with the rest of the drawer content, so is a
* good place to place titles and account switchers.
*
* Directives that are typically used inside an `mdcDrawerHeader`:
* `mdcDrawerTitle`, and `mdcDrawerSubTitle`
*/
export class MdcDrawerHeaderDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcDrawerHeaderDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerHeader]'
},] }
];
MdcDrawerHeaderDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer__header',] }]
};
/**
* Directive for the drawer content. You would typically also apply the `mdcList`
* or `mdcListGroup` directive to the drawer content (see the examples).
*/
export class MdcDrawerContentDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcDrawerContentDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerContent]'
},] }
];
MdcDrawerContentDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer__content',] }]
};
export class MdcDrawerScrimDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcDrawerScrimDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerScrim]'
},] }
];
MdcDrawerScrimDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer-scrim',] }]
};
/**
* Directive for a (navigation) drawer. The following drawer types are
* supported:
* * `permanent`: the default type if none was specified.
* * `dismissible`: the drawer is hidden by default, and can slide into view.
* Typically used when navigation is not common, and the main app content is
* prioritized.
* * `modal`: the drawer is hidden by default. When activated, the drawer is elevated
* above the UI of the app. It uses a scrim to block interaction with the rest of
* the app with a scrim.
*
* Drawers may contain an `mdcDrawerHeader`, and should contain an `mdcDrawerContent`
* directive.
*/
export class MdcDrawerDirective {
constructor(_elm, _rndr, doc, _focusTrap) {
this._elm = _elm;
this._rndr = _rndr;
this._focusTrap = _focusTrap;
/** @internal */
this._cls = true;
this._onDocumentClick = (event) => this.onDocumentClick(event);
this.focusTrapHandle = null;
this.type = 'permanent';
this.previousFocus = null;
this._open = null;
this.mdcAdapter = {
addClass: (className) => this._rndr.addClass(this._elm.nativeElement, className),
removeClass: (className) => this._rndr.removeClass(this._elm.nativeElement, className),
hasClass: (className) => this._elm.nativeElement.classList.contains(className),
elementHasClass: (element, className) => element.classList.contains(className),
saveFocus: () => this.previousFocus = this.document.activeElement,
restoreFocus: () => {
const prev = this.previousFocus;
if (prev && prev.focus && this._elm.nativeElement.contains(this.document.activeElement))
prev.focus();
},
focusActiveNavigationItem: () => {
const active = this._items.find(item => item.active);
active === null || active === void 0 ? void 0 : active._elm.nativeElement.focus();
},
notifyClose: () => {
this.fixOpenClose(false);
this.afterClosed.emit();
this.document.removeEventListener('click', this._onDocumentClick);
},
notifyOpen: () => {
this.fixOpenClose(true);
this.afterOpened.emit();
if (this.type === 'modal')
this.document.addEventListener('click', this._onDocumentClick);
},
trapFocus: () => this.trapFocus(),
releaseFocus: () => this.untrapFocus()
};
this.foundation = null; // MDCModalDrawerFoundation extends MDCDismissibleDrawerFoundation
/**
* Event emitted when the drawer is opened or closed. The event value will be
* `true` when the drawer is opened, and `false` when the
* drawer is closed. (When this event is triggered, the drawer is starting to open/close,
* but the animation may not have fully completed yet)
*/
this.openChange = new EventEmitter();
/**
* Event emitted after the drawer has fully opened. When this event is emitted the full
* opening animation has completed, and the drawer is visible.
*/
this.afterOpened = new EventEmitter();
/**
* Event emitted after the drawer has fully closed. When this event is emitted the full
* closing animation has completed, and the drawer is not visible anymore.
*/
this.afterClosed = new EventEmitter();
this.document = doc; // work around ngc issue https://github.com/angular/angular/issues/20351
}
ngAfterContentInit() {
this.initDrawer();
}
ngOnDestroy() {
this.destroyDrawer();
}
destroyDrawer() {
// when foundation is reconstructed and then .open() is called,
// if these classes are still available the foundation assumes open was already called,
// and it won't do anything:
this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--animate');
this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--closing');
this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--open');
this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--opening');
if (this.foundation) {
this.document.removeEventListener('click', this._onDocumentClick);
this.foundation.destroy();
this.foundation = null;
}
}
initDrawer() {
this.destroyDrawer();
let newFoundation = null;
const thiz = this;
if (this.type === 'dismissible')
newFoundation = new class extends MDCDismissibleDrawerFoundation {
close() {
const emit = thiz._open;
thiz._open = false;
super.close();
emit ? thiz.openChange.emit(thiz._open) : undefined;
}
open() {
const emit = !thiz._open;
thiz._open = true;
super.open();
emit ? thiz.openChange.emit(thiz._open) : undefined;
}
}(this.mdcAdapter);
else if (this.type === 'modal')
newFoundation = new class extends MDCModalDrawerFoundation {
close() {
const emit = thiz._open;
thiz._open = false;
super.close();
emit ? thiz.openChange.emit(thiz._open) : undefined;
}
open() {
const emit = !thiz._open;
thiz._open = true;
super.open();
emit ? thiz.openChange.emit(thiz._open) : undefined;
}
}(this.mdcAdapter);
// else: permanent drawer -> doesn't need a foundation, just styling
if (newFoundation) {
this.foundation = newFoundation;
newFoundation.init();
if (this._open)
newFoundation.open();
}
}
/** @internal */
get _isModal() {
return this.type === 'modal';
}
/** @internal */
get _isDismisible() {
return this.type === 'dismissible';
}
/**
* Set the type of drawer. Either `permanent`, `dismissible`, or `modal`.
* The default type is `permanent`.
*/
get mdcDrawer() {
return this.type;
}
set mdcDrawer(value) {
if (value !== 'dismissible' && value !== 'modal')
value = 'permanent';
if (value !== this.type) {
this.type = value;
this.initDrawer();
}
}
/**
* Input to open (assign value `true`) or close (assign value `false`)
* the drawer.
*/
get open() {
return !!this._open;
}
set open(value) {
let newValue = asBoolean(value);
if (newValue !== this._open) {
if (this.foundation) {
newValue ? this.foundation.open() : this.foundation.close();
}
else {
this._open = newValue;
this.openChange.emit(newValue);
}
}
}
fixOpenClose(open) {
// the foundation ignores calls to open/close while an opening/closing animation is running.
// so when the animation ends, we're just going to try again
// (needs to be done in the next micro cycle, because otherwise foundation will still think it's
// running the opening/closing animation):
Promise.resolve().then(() => {
if (this._open !== open) {
if (this._open)
this.foundation.open();
else
this.foundation.close();
}
});
}
trapFocus() {
this.untrapFocus();
if (this._focusTrap)
this.focusTrapHandle = this._focusTrap.trapFocus();
}
untrapFocus() {
if (this.focusTrapHandle && this.focusTrapHandle.active) {
this.focusTrapHandle.untrap();
this.focusTrapHandle = null;
}
}
/** @internal */
onKeydown(event) {
var _a;
(_a = this.foundation) === null || _a === void 0 ? void 0 : _a.handleKeydown(event);
}
/** @internal */
handleTransitionEnd(event) {
var _a;
(_a = this.foundation) === null || _a === void 0 ? void 0 : _a.handleTransitionEnd(event);
}
/** @internal */
onDocumentClick(event) {
var _a;
if (this.type === 'modal') {
// instead of listening to click event on mdcDrawerScrim (which would require wiring between
// mdcDrawerScrim and mdcDrawer), we just listen to document clicks.
let el = event.target;
while (el) {
if (el === this._elm.nativeElement)
return;
el = el.parentElement;
}
(_a = this.foundation) === null || _a === void 0 ? void 0 : _a.handleScrimClick();
}
}
}
MdcDrawerDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawer]'
},] }
];
MdcDrawerDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: Renderer2 },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
{ type: AbstractMdcFocusTrap, decorators: [{ type: Optional }, { type: Self }] }
];
MdcDrawerDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer',] }],
_items: [{ type: ContentChildren, args: [MdcListItemDirective, { descendants: true },] }],
openChange: [{ type: Output }],
afterOpened: [{ type: Output }],
afterClosed: [{ type: Output }],
_isModal: [{ type: HostBinding, args: ['class.mdc-drawer--modal',] }],
_isDismisible: [{ type: HostBinding, args: ['class.mdc-drawer--dismissible',] }],
mdcDrawer: [{ type: Input }],
open: [{ type: Input }],
onKeydown: [{ type: HostListener, args: ['keydown', ['$event'],] }],
handleTransitionEnd: [{ type: HostListener, args: ['transitionend', ['$event'],] }]
};
/**
* Use this directive for marking the sibling element after a dismissible `mdcDrawer`.
* This will apply styling so that the open/close animations work correctly.
*/
export class MdcDrawerAppContent {
constructor() {
/** @internal */
this._cls = true;
}
/**
* Set this to false to disable the styling for sibbling app content of a dismissible drawer.
* This is typically only used when your `mdcDrawer` type is dynamic. In those cases you can
* disable the `mdcDrawerAppContent` when you set your drawer type to anything other than
* `dismissible`.
*/
get mdcDrawerAppContent() {
return this._cls;
}
set mdcDrawerAppContent(value) {
this._cls = asBoolean(value);
}
}
MdcDrawerAppContent.decorators = [
{ type: Directive, args: [{
selector: '[mdcDrawerAppContent]'
},] }
];
MdcDrawerAppContent.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-drawer-app-content',] }],
mdcDrawerAppContent: [{ type: Input }]
};
export const DRAWER_DIRECTIVES = [
MdcDrawerTitleDirective,
MdcDrawerSubtitleDirective,
MdcDrawerHeaderDirective,
MdcDrawerContentDirective,
MdcDrawerScrimDirective,
MdcDrawerDirective,
MdcDrawerAppContent
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mdc.drawer.directive.js","sourceRoot":"","sources":["../../../../src/components/drawer/mdc.drawer.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ContentChildren, Directive, ElementRef, EventEmitter, HostBinding,\n    Input, OnDestroy, Output, QueryList, Renderer2, Inject, Optional, Self, HostListener } from '@angular/core';\nimport { MDCDismissibleDrawerFoundation, MDCModalDrawerFoundation, MDCDrawerAdapter } from '@material/drawer';\nimport { asBoolean } from '../../utils/value.utils';\nimport { DOCUMENT } from '@angular/common';\nimport { AbstractMdcFocusTrap, FocusTrapHandle } from '../focus-trap/abstract.mdc.focus-trap';\nimport { MdcListItemDirective } from '../list/mdc.list.directive';\n\n/**\n * Directive for the title of a drawer. The use of this directive is optional.\n * If used, it should be placed as first element inside an `mdcDrawerHeader`\n */\n@Directive({\n    selector: '[mdcDrawerTitle]'\n})\nexport class MdcDrawerTitleDirective {\n    /** @internal */\n    @HostBinding('class.mdc-drawer__title') readonly _cls = true;\n}\n\n/**\n * Directive for the subtitle of a drawer. The use of this directive is optional.\n * If used, it should be placed as a sibling element of `mdcDrawerTitle`\n * inside an `mdcDrawerHeader`\n */\n@Directive({\n    selector: '[mdcDrawerSubtitle]'\n})\nexport class MdcDrawerSubtitleDirective {\n    /** @internal */\n    @HostBinding('class.mdc-drawer__subtitle') readonly _cls = true;\n}\n\n/**\n * A toolbar header is an optional first child of an `mdcDrawer`.\n * The header will not scroll with the rest of the drawer content, so is a\n * good place to place titles and account switchers.\n * \n * Directives that are typically used inside an `mdcDrawerHeader`:\n * `mdcDrawerTitle`, and `mdcDrawerSubTitle`\n */\n@Directive({\n    selector: '[mdcDrawerHeader]'\n})\nexport class MdcDrawerHeaderDirective {\n    /** @internal */\n    @HostBinding('class.mdc-drawer__header') readonly _cls = true;\n}\n\n/**\n * Directive for the drawer content. You would typically also apply the `mdcList`\n * or `mdcListGroup` directive to the drawer content (see the examples).\n */\n@Directive({\n    selector: '[mdcDrawerContent]'\n})\nexport class MdcDrawerContentDirective {\n    /** @internal */\n    @HostBinding('class.mdc-drawer__content') readonly _cls = true;\n}\n\n@Directive({\n    selector: '[mdcDrawerScrim]'\n})\nexport class MdcDrawerScrimDirective {\n    /** @internal */\n    @HostBinding('class.mdc-drawer-scrim') readonly _cls = true;\n}\n\n/**\n * Directive for a (navigation) drawer. The following drawer types are\n * supported:\n * * `permanent`: the default type if none was specified.\n * * `dismissible`: the drawer is hidden by default, and can slide into view.\n *   Typically used when navigation is not common, and the main app content is\n *   prioritized.\n * * `modal`: the drawer is hidden by default. When activated, the drawer is elevated\n *   above the UI of the app. It uses a scrim to block interaction with the rest of\n *   the app with a scrim.\n * \n * Drawers may contain an `mdcDrawerHeader`, and should contain an `mdcDrawerContent`\n * directive.\n */\n@Directive({\n    selector: '[mdcDrawer]'\n})\nexport class MdcDrawerDirective implements AfterContentInit, OnDestroy {\n    /** @internal */\n    @HostBinding('class.mdc-drawer') readonly _cls = true;\n    /** @internal */\n    @ContentChildren(MdcListItemDirective, {descendants: true}) _items?: QueryList<MdcListItemDirective>;\n    private _onDocumentClick = (event: MouseEvent) => this.onDocumentClick(event);\n    private focusTrapHandle: FocusTrapHandle | null = null;\n    private type: 'permanent' | 'dismissible' | 'modal' = 'permanent';\n    private previousFocus: Element | HTMLOrSVGElement | null = null;\n    private _open: boolean | null = null;\n    private document: Document;\n    private mdcAdapter: MDCDrawerAdapter = {\n        addClass: (className) =>  this._rndr.addClass(this._elm.nativeElement, className),\n        removeClass: (className) => this._rndr.removeClass(this._elm.nativeElement, className),\n        hasClass: (className) => this._elm.nativeElement.classList.contains(className),\n        elementHasClass: (element, className) => element.classList.contains(className),\n        saveFocus: () => this.previousFocus = this.document.activeElement,\n        restoreFocus: () => {\n            const prev = this.previousFocus as HTMLOrSVGElement | null;\n            if (prev && prev.focus && this._elm.nativeElement.contains(this.document.activeElement))\n                prev.focus();\n        },\n        focusActiveNavigationItem: () => {\n            const active = this._items!.find(item => item.active);\n            active?._elm.nativeElement.focus();\n        },\n        notifyClose: () => {\n            this.fixOpenClose(false);\n            this.afterClosed.emit();\n            this.document.removeEventListener('click', this._onDocumentClick);\n        },\n        notifyOpen: () => {\n            this.fixOpenClose(true);\n            this.afterOpened.emit();\n            if (this.type === 'modal')\n                this.document.addEventListener('click', this._onDocumentClick);\n        },\n        trapFocus: () => this.trapFocus(),\n        releaseFocus: () => this.untrapFocus()\n    };\n    private foundation: MDCDismissibleDrawerFoundation | null = null; // MDCModalDrawerFoundation extends MDCDismissibleDrawerFoundation\n    /**\n     * Event emitted when the drawer is opened or closed. The event value will be\n     * `true` when the drawer is opened, and `false` when the\n     * drawer is closed. (When this event is triggered, the drawer is starting to open/close,\n     * but the animation may not have fully completed yet)\n     */\n    @Output() readonly openChange: EventEmitter<boolean> = new EventEmitter<boolean>();\n    /**\n     * Event emitted after the drawer has fully opened. When this event is emitted the full\n     * opening animation has completed, and the drawer is visible.\n     */\n    @Output() readonly afterOpened: EventEmitter<void> = new EventEmitter();\n    /**\n     * Event emitted after the drawer has fully closed. When this event is emitted the full\n     * closing animation has completed, and the drawer is not visible anymore.\n     */\n    @Output() readonly afterClosed: EventEmitter<void> = new EventEmitter();\n    \n    constructor(public _elm: ElementRef, protected _rndr: Renderer2, @Inject(DOCUMENT) doc: any,\n        @Optional() @Self() private _focusTrap: AbstractMdcFocusTrap) {\n        this.document = doc as Document; // work around ngc issue https://github.com/angular/angular/issues/20351\n    }\n\n    ngAfterContentInit() {\n        this.initDrawer();\n    }\n\n    ngOnDestroy() {\n        this.destroyDrawer();\n    }\n\n    private destroyDrawer() {\n        // when foundation is reconstructed and then .open() is called,\n        // if these classes are still available the foundation assumes open was already called,\n        // and it won't do anything:\n        this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--animate');\n        this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--closing');\n        this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--open');\n        this._rndr.removeClass(this._elm.nativeElement, 'mdc-drawer--opening');\n        if (this.foundation) {\n            this.document.removeEventListener('click', this._onDocumentClick);\n            this.foundation.destroy();\n            this.foundation = null;\n        }\n    }\n\n    private initDrawer() {\n        this.destroyDrawer();\n        let newFoundation: MDCDismissibleDrawerFoundation | null = null;\n        const thiz = this;\n        if (this.type === 'dismissible')\n            newFoundation = new class extends MDCDismissibleDrawerFoundation{\n                close() {\n                    const emit = thiz._open;\n                    thiz._open = false;\n                    super.close();\n                    emit ? thiz.openChange.emit(thiz._open) : undefined;\n                }\n                open() {\n                    const emit = !thiz._open;\n                    thiz._open = true;\n                    super.open();\n                    emit ? thiz.openChange.emit(thiz._open) : undefined;\n                }\n            }(this.mdcAdapter);\n        else if (this.type === 'modal')\n            newFoundation = new class extends MDCModalDrawerFoundation{\n                close() {\n                    const emit = thiz._open;\n                    thiz._open = false;\n                    super.close();\n                    emit ? thiz.openChange.emit(thiz._open) : undefined;\n                }\n                open() {\n                    const emit = !thiz._open;\n                    thiz._open = true;\n                    super.open();\n                    emit ? thiz.openChange.emit(thiz._open) : undefined;\n                }\n            }(this.mdcAdapter);\n        // else: permanent drawer -> doesn't need a foundation, just styling\n        if (newFoundation) {\n            this.foundation = newFoundation;\n            newFoundation.init();\n            if (this._open)\n                newFoundation.open();\n        }\n    }\n\n    /** @internal */\n    @HostBinding('class.mdc-drawer--modal') get _isModal() {\n        return this.type === 'modal';\n    }\n\n    /** @internal */\n    @HostBinding('class.mdc-drawer--dismissible') get _isDismisible() {\n        return this.type === 'dismissible';\n    }\n\n    /**\n     * Set the type of drawer. Either `permanent`, `dismissible`, or `modal`.\n     * The default type is `permanent`.\n     */\n    @Input() get mdcDrawer(): 'permanent' | 'dismissible' | 'modal' {\n        return this.type;\n    }\n\n    set mdcDrawer(value: 'permanent' | 'dismissible' | 'modal') {\n        if (value !== 'dismissible' && value !== 'modal')\n            value = 'permanent';\n        if (value !== this.type) {\n            this.type = value;\n            this.initDrawer();\n        }\n    }\n\n    static ngAcceptInputType_mdcDrawer: 'permanent' | 'dismissible' | 'modal' | '';\n\n    /**\n     * Input to open (assign value `true`) or close (assign value `false`)\n     * the drawer.\n     */\n    @Input() get open() {\n        return !!this._open;\n    }\n\n    set open(value: boolean) {\n        let newValue = asBoolean(value);\n        if (newValue !== this._open) {\n            if (this.foundation) {\n                newValue ? this.foundation.open() : this.foundation.close();\n            } else {\n                this._open = newValue;\n                this.openChange.emit(newValue);\n            }\n        }\n    }\n\n    static ngAcceptInputType_open: boolean | '';\n\n    private fixOpenClose(open: boolean) {\n        // the foundation ignores calls to open/close while an opening/closing animation is running.\n        // so when the animation ends, we're just going to try again\n        // (needs to be done in the next micro cycle, because otherwise foundation will still think it's\n        // running the opening/closing animation):\n        Promise.resolve().then(() => {\n            if (this._open !== open) {\n                if (this._open)\n                    this.foundation!.open();\n                else\n                    this.foundation!.close();\n            }\n        });\n    }\n\n    private trapFocus() {\n        this.untrapFocus();\n        if (this._focusTrap)\n            this.focusTrapHandle = this._focusTrap.trapFocus();\n    }\n\n    private untrapFocus() {\n        if (this.focusTrapHandle && this.focusTrapHandle.active) {\n            this.focusTrapHandle.untrap();\n            this.focusTrapHandle = null;\n        }\n    }\n\n    /** @internal */\n    @HostListener('keydown', ['$event']) onKeydown(event: KeyboardEvent) {\n        this.foundation?.handleKeydown(event);\n    }\n\n    /** @internal */\n    @HostListener('transitionend', ['$event']) handleTransitionEnd(event: TransitionEvent) {\n        this.foundation?.handleTransitionEnd(event);\n    }\n\n    /** @internal */\n    onDocumentClick(event: MouseEvent) {\n        if (this.type === 'modal') {\n            // instead of listening to click event on mdcDrawerScrim (which would require wiring between\n            // mdcDrawerScrim and mdcDrawer), we just listen to document clicks.\n            let el: Element | null = event.target as Element;\n            while (el) {\n                if (el === this._elm.nativeElement)\n                    return;\n                el = el.parentElement;\n            }\n            (this.foundation as MDCModalDrawerFoundation)?.handleScrimClick();\n        }\n    }\n}\n\n/**\n * Use this directive for marking the sibling element after a dismissible `mdcDrawer`.\n * This will apply styling so that the open/close animations work correctly.\n */\n@Directive({\n    selector: '[mdcDrawerAppContent]'\n})\nexport class MdcDrawerAppContent {\n    /** @internal */\n    @HostBinding('class.mdc-drawer-app-content') _cls = true;\n\n    /**\n     * Set this to false to disable the styling for sibbling app content of a dismissible drawer.\n     * This is typically only used when your `mdcDrawer` type is dynamic. In those cases you can\n     * disable the `mdcDrawerAppContent` when you set your drawer type to anything other than\n     * `dismissible`.\n     */\n    @Input() get mdcDrawerAppContent() {\n        return this._cls;\n    }\n\n    set mdcDrawerAppContent(value: boolean) {\n        this._cls = asBoolean(value);\n    }\n\n    static ngAcceptInputType_mdcDrawerAppContent: boolean | '';\n}\n\nexport const DRAWER_DIRECTIVES = [\n    MdcDrawerTitleDirective,\n    MdcDrawerSubtitleDirective,\n    MdcDrawerHeaderDirective,\n    MdcDrawerContentDirective,\n    MdcDrawerScrimDirective,\n    MdcDrawerDirective,\n    MdcDrawerAppContent\n];\n"]}