@angular/cdk-experimental 13.0.0-next.7 → 13.0.0-rc.2

package/esm2020/dialog/dialog.mjs

@@ -0,0 +1,252 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { SkipSelf, Optional, Injectable, Injector, Inject, Type, InjectFlags, } from '@angular/core';
+import { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { of as observableOf, Subject, defer } from 'rxjs';
+import { Location } from '@angular/common';
+import { DialogConfig } from './dialog-config';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay, OverlayConfig, } from '@angular/cdk/overlay';
+import { startWith } from 'rxjs/operators';
+import { DIALOG_SCROLL_STRATEGY, DIALOG_DATA, DIALOG_REF, DIALOG_CONTAINER, DIALOG_CONFIG, } from './dialog-injectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+/**
+ * Service to open modal dialogs.
+ */
+export class Dialog {
+    constructor(_overlay, _injector, _dialogRefConstructor, 
+    // TODO(crisbeto): the `any` here can be replaced
+    // with the proper type once we start using Ivy.
+    scrollStrategy, _parentDialog, location) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+        this._dialogRefConstructor = _dialogRefConstructor;
+        this._parentDialog = _parentDialog;
+        this._afterAllClosedBase = new Subject();
+        // TODO(jelbourn): tighten the type on the right-hand side of this expression.
+        this.afterAllClosed = defer(() => this.openDialogs.length
+            ? this._getAfterAllClosed()
+            : this._getAfterAllClosed().pipe(startWith(undefined)));
+        this._afterOpened = new Subject();
+        this._openDialogs = [];
+        // Close all of the dialogs when the user goes forwards/backwards in history or when the
+        // location hash changes. Note that this usually doesn't include clicking on links (unless
+        // the user is using the `HashLocationStrategy`).
+        if (!_parentDialog && location) {
+            location.subscribe(() => this.closeAll());
+        }
+        this._scrollStrategy = scrollStrategy;
+    }
+    /** Stream that emits when all dialogs are closed. */
+    _getAfterAllClosed() {
+        return this._parentDialog ? this._parentDialog.afterAllClosed : this._afterAllClosedBase;
+    }
+    /** Stream that emits when a dialog is opened. */
+    get afterOpened() {
+        return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpened;
+    }
+    /** Stream that emits when a dialog is opened. */
+    get openDialogs() {
+        return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogs;
+    }
+    /** Gets an open dialog by id. */
+    getById(id) {
+        return this._openDialogs.find(ref => ref.id === id);
+    }
+    /** Closes all open dialogs. */
+    closeAll() {
+        this.openDialogs.forEach(ref => ref.close());
+    }
+    /** Opens a dialog from a component. */
+    openFromComponent(component, config) {
+        config = this._applyConfigDefaults(config);
+        if (config.id && this.getById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const overlayRef = this._createOverlay(config);
+        const dialogContainer = this._attachDialogContainer(overlayRef, config);
+        const dialogRef = this._attachDialogContentForComponent(component, dialogContainer, overlayRef, config);
+        this._registerDialogRef(dialogRef);
+        dialogContainer._initializeWithAttachedContent();
+        return dialogRef;
+    }
+    /** Opens a dialog from a template. */
+    openFromTemplate(template, config) {
+        config = this._applyConfigDefaults(config);
+        if (config.id && this.getById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const overlayRef = this._createOverlay(config);
+        const dialogContainer = this._attachDialogContainer(overlayRef, config);
+        const dialogRef = this._attachDialogContentForTemplate(template, dialogContainer, overlayRef, config);
+        this._registerDialogRef(dialogRef);
+        dialogContainer._initializeWithAttachedContent();
+        return dialogRef;
+    }
+    ngOnDestroy() {
+        // Only close all the dialogs at this level.
+        this._openDialogs.forEach(ref => ref.close());
+    }
+    /**
+     * Forwards emitting events for when dialogs are opened and all dialogs are closed.
+     */
+    _registerDialogRef(dialogRef) {
+        this.openDialogs.push(dialogRef);
+        const dialogOpenSub = dialogRef.afterOpened().subscribe(() => {
+            this.afterOpened.next(dialogRef);
+            dialogOpenSub.unsubscribe();
+        });
+        const dialogCloseSub = dialogRef.afterClosed().subscribe(() => {
+            let dialogIndex = this._openDialogs.indexOf(dialogRef);
+            if (dialogIndex > -1) {
+                this._openDialogs.splice(dialogIndex, 1);
+            }
+            if (!this._openDialogs.length) {
+                this._afterAllClosedBase.next();
+                dialogCloseSub.unsubscribe();
+            }
+        });
+    }
+    /**
+     * Creates an overlay config from a dialog config.
+     * @param config The dialog configuration.
+     * @returns The overlay configuration.
+     */
+    _createOverlay(config) {
+        const overlayConfig = new OverlayConfig({
+            positionStrategy: this._overlay.position().global(),
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: config.panelClass,
+            hasBackdrop: config.hasBackdrop,
+            direction: config.direction,
+            minWidth: config.minWidth,
+            minHeight: config.minHeight,
+            maxWidth: config.maxWidth,
+            maxHeight: config.maxHeight,
+        });
+        if (config.backdropClass) {
+            overlayConfig.backdropClass = config.backdropClass;
+        }
+        return this._overlay.create(overlayConfig);
+    }
+    /**
+     * Attaches an MatDialogContainer to a dialog's already-created overlay.
+     * @param overlay Reference to the dialog's underlying overlay.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to a ComponentRef for the attached container.
+     */
+    _attachDialogContainer(overlay, config) {
+        const container = config.containerComponent || this._injector.get(DIALOG_CONTAINER);
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const injector = Injector.create({
+            parent: userInjector || this._injector,
+            providers: [{ provide: DialogConfig, useValue: config }],
+        });
+        const containerPortal = new ComponentPortal(container, config.viewContainerRef, injector);
+        const containerRef = overlay.attach(containerPortal);
+        containerRef.instance._config = config;
+        return containerRef.instance;
+    }
+    /**
+     * Attaches the user-provided component to the already-created MatDialogContainer.
+     * @param componentOrTemplateRef The type of component being loaded into the dialog,
+     *     or a TemplateRef to instantiate as the content.
+     * @param dialogContainer Reference to the wrapping MatDialogContainer.
+     * @param overlayRef Reference to the overlay in which the dialog resides.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to the MatDialogRef that should be returned to the user.
+     */
+    _attachDialogContentForComponent(componentOrTemplateRef, dialogContainer, overlayRef, config) {
+        // Create a reference to the dialog we're creating in order to give the user a handle
+        // to modify and close it.
+        const dialogRef = this._createDialogRef(overlayRef, dialogContainer, config);
+        const injector = this._createInjector(config, dialogRef, dialogContainer);
+        const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, undefined, injector));
+        dialogRef.componentInstance = contentRef.instance;
+        return dialogRef;
+    }
+    /**
+     * Attaches the user-provided component to the already-created MatDialogContainer.
+     * @param componentOrTemplateRef The type of component being loaded into the dialog,
+     *     or a TemplateRef to instantiate as the content.
+     * @param dialogContainer Reference to the wrapping MatDialogContainer.
+     * @param overlayRef Reference to the overlay in which the dialog resides.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to the MatDialogRef that should be returned to the user.
+     */
+    _attachDialogContentForTemplate(componentOrTemplateRef, dialogContainer, overlayRef, config) {
+        // Create a reference to the dialog we're creating in order to give the user a handle
+        // to modify and close it.
+        const dialogRef = this._createDialogRef(overlayRef, dialogContainer, config);
+        dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, {
+            $implicit: config.data,
+            dialogRef,
+        }));
+        return dialogRef;
+    }
+    /**
+     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside
+     * of a dialog to close itself and, optionally, to return a value.
+     * @param config Config object that is used to construct the dialog.
+     * @param dialogRef Reference to the dialog.
+     * @param container Dialog container element that wraps all of the contents.
+     * @returns The custom injector that can be used inside the dialog.
+     */
+    _createInjector(config, dialogRef, dialogContainer) {
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const providers = [
+            { provide: this._injector.get(DIALOG_REF), useValue: dialogRef },
+            { provide: this._injector.get(DIALOG_CONTAINER), useValue: dialogContainer },
+            { provide: DIALOG_DATA, useValue: config.data },
+        ];
+        if (config.direction &&
+            (!userInjector ||
+                !userInjector.get(Directionality, null, InjectFlags.Optional))) {
+            providers.push({
+                provide: Directionality,
+                useValue: { value: config.direction, change: observableOf() },
+            });
+        }
+        return Injector.create({ parent: userInjector || this._injector, providers });
+    }
+    /** Creates a new dialog ref. */
+    _createDialogRef(overlayRef, dialogContainer, config) {
+        const dialogRef = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);
+        dialogRef.disableClose = config.disableClose;
+        dialogRef.updateSize(config).updatePosition(config.position);
+        return dialogRef;
+    }
+    /**
+     * Expands the provided configuration object to include the default values for properties which
+     * are undefined.
+     */
+    _applyConfigDefaults(config) {
+        const dialogConfig = this._injector.get(DIALOG_CONFIG);
+        return { ...new dialogConfig(), ...config };
+    }
+}
+Dialog.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Dialog, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: DIALOG_REF }, { token: DIALOG_SCROLL_STRATEGY }, { token: Dialog, optional: true, skipSelf: true }, { token: i2.Location, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+Dialog.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Dialog });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: Dialog, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i0.Type, decorators: [{
+                    type: Inject,
+                    args: [DIALOG_REF]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DIALOG_SCROLL_STRATEGY]
+                }] }, { type: Dialog, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i2.Location, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/dialog/dialog.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  TemplateRef,\n  SkipSelf,\n  Optional,\n  Injectable,\n  Injector,\n  Inject,\n  ComponentRef,\n  OnDestroy,\n  Type,\n  StaticProvider,\n  InjectFlags,\n} from '@angular/core';\nimport {ComponentPortal, TemplatePortal} from '@angular/cdk/portal';\nimport {of as observableOf, Observable, Subject, defer} from 'rxjs';\nimport {DialogRef} from './dialog-ref';\nimport {Location} from '@angular/common';\nimport {DialogConfig} from './dialog-config';\nimport {Directionality} from '@angular/cdk/bidi';\nimport {CdkDialogContainer} from './dialog-container';\nimport {\n  ComponentType,\n  Overlay,\n  OverlayRef,\n  OverlayConfig,\n  ScrollStrategy,\n} from '@angular/cdk/overlay';\nimport {startWith} from 'rxjs/operators';\n\nimport {\n  DIALOG_SCROLL_STRATEGY,\n  DIALOG_DATA,\n  DIALOG_REF,\n  DIALOG_CONTAINER,\n  DIALOG_CONFIG,\n} from './dialog-injectors';\n\n/**\n * Service to open modal dialogs.\n */\n@Injectable()\nexport class Dialog implements OnDestroy {\n  private _scrollStrategy: () => ScrollStrategy;\n\n  /** Stream that emits when all dialogs are closed. */\n  _getAfterAllClosed(): Observable<void> {\n    return this._parentDialog ? this._parentDialog.afterAllClosed : this._afterAllClosedBase;\n  }\n  readonly _afterAllClosedBase = new Subject<void>();\n\n  // TODO(jelbourn): tighten the type on the right-hand side of this expression.\n  afterAllClosed: Observable<void> = defer(() =>\n    this.openDialogs.length\n      ? this._getAfterAllClosed()\n      : this._getAfterAllClosed().pipe(startWith(undefined)),\n  );\n\n  /** Stream that emits when a dialog is opened. */\n  get afterOpened(): Subject<DialogRef<any>> {\n    return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpened;\n  }\n  readonly _afterOpened = new Subject<DialogRef<any>>();\n\n  /** Stream that emits when a dialog is opened. */\n  get openDialogs(): DialogRef<any>[] {\n    return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogs;\n  }\n  _openDialogs: DialogRef<any>[] = [];\n\n  constructor(\n    private _overlay: Overlay,\n    private _injector: Injector,\n    @Inject(DIALOG_REF) private _dialogRefConstructor: Type<DialogRef<any>>,\n    // TODO(crisbeto): the `any` here can be replaced\n    // with the proper type once we start using Ivy.\n    @Inject(DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n    @Optional() @SkipSelf() private _parentDialog: Dialog,\n    @Optional() location: Location,\n  ) {\n    // Close all of the dialogs when the user goes forwards/backwards in history or when the\n    // location hash changes. Note that this usually doesn't include clicking on links (unless\n    // the user is using the `HashLocationStrategy`).\n    if (!_parentDialog && location) {\n      location.subscribe(() => this.closeAll());\n    }\n\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  /** Gets an open dialog by id. */\n  getById(id: string): DialogRef<any> | undefined {\n    return this._openDialogs.find(ref => ref.id === id);\n  }\n\n  /** Closes all open dialogs. */\n  closeAll(): void {\n    this.openDialogs.forEach(ref => ref.close());\n  }\n\n  /** Opens a dialog from a component. */\n  openFromComponent<T>(component: ComponentType<T>, config?: DialogConfig): DialogRef<any> {\n    config = this._applyConfigDefaults(config);\n\n    if (config.id && this.getById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n    }\n\n    const overlayRef = this._createOverlay(config);\n    const dialogContainer = this._attachDialogContainer(overlayRef, config);\n    const dialogRef = this._attachDialogContentForComponent(\n      component,\n      dialogContainer,\n      overlayRef,\n      config,\n    );\n\n    this._registerDialogRef(dialogRef);\n    dialogContainer._initializeWithAttachedContent();\n\n    return dialogRef;\n  }\n\n  /** Opens a dialog from a template. */\n  openFromTemplate<T>(template: TemplateRef<T>, config?: DialogConfig): DialogRef<any> {\n    config = this._applyConfigDefaults(config);\n\n    if (config.id && this.getById(config.id) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n    }\n\n    const overlayRef = this._createOverlay(config);\n    const dialogContainer = this._attachDialogContainer(overlayRef, config);\n    const dialogRef = this._attachDialogContentForTemplate(\n      template,\n      dialogContainer,\n      overlayRef,\n      config,\n    );\n\n    this._registerDialogRef(dialogRef);\n    dialogContainer._initializeWithAttachedContent();\n\n    return dialogRef;\n  }\n\n  ngOnDestroy() {\n    // Only close all the dialogs at this level.\n    this._openDialogs.forEach(ref => ref.close());\n  }\n\n  /**\n   * Forwards emitting events for when dialogs are opened and all dialogs are closed.\n   */\n  private _registerDialogRef(dialogRef: DialogRef<any>): void {\n    this.openDialogs.push(dialogRef);\n\n    const dialogOpenSub = dialogRef.afterOpened().subscribe(() => {\n      this.afterOpened.next(dialogRef);\n      dialogOpenSub.unsubscribe();\n    });\n\n    const dialogCloseSub = dialogRef.afterClosed().subscribe(() => {\n      let dialogIndex = this._openDialogs.indexOf(dialogRef);\n\n      if (dialogIndex > -1) {\n        this._openDialogs.splice(dialogIndex, 1);\n      }\n\n      if (!this._openDialogs.length) {\n        this._afterAllClosedBase.next();\n        dialogCloseSub.unsubscribe();\n      }\n    });\n  }\n\n  /**\n   * Creates an overlay config from a dialog config.\n   * @param config The dialog configuration.\n   * @returns The overlay configuration.\n   */\n  protected _createOverlay(config: DialogConfig): OverlayRef {\n    const overlayConfig = new OverlayConfig({\n      positionStrategy: this._overlay.position().global(),\n      scrollStrategy: this._scrollStrategy(),\n      panelClass: config.panelClass,\n      hasBackdrop: config.hasBackdrop,\n      direction: config.direction,\n      minWidth: config.minWidth,\n      minHeight: config.minHeight,\n      maxWidth: config.maxWidth,\n      maxHeight: config.maxHeight,\n    });\n\n    if (config.backdropClass) {\n      overlayConfig.backdropClass = config.backdropClass;\n    }\n    return this._overlay.create(overlayConfig);\n  }\n\n  /**\n   * Attaches an MatDialogContainer to a dialog's already-created overlay.\n   * @param overlay Reference to the dialog's underlying overlay.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to a ComponentRef for the attached container.\n   */\n  protected _attachDialogContainer(overlay: OverlayRef, config: DialogConfig): CdkDialogContainer {\n    const container = config.containerComponent || this._injector.get(DIALOG_CONTAINER);\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n    const injector = Injector.create({\n      parent: userInjector || this._injector,\n      providers: [{provide: DialogConfig, useValue: config}],\n    });\n    const containerPortal = new ComponentPortal(container, config.viewContainerRef, injector);\n    const containerRef: ComponentRef<CdkDialogContainer> = overlay.attach(containerPortal);\n    containerRef.instance._config = config;\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created MatDialogContainer.\n   * @param componentOrTemplateRef The type of component being loaded into the dialog,\n   *     or a TemplateRef to instantiate as the content.\n   * @param dialogContainer Reference to the wrapping MatDialogContainer.\n   * @param overlayRef Reference to the overlay in which the dialog resides.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n   */\n  protected _attachDialogContentForComponent<T>(\n    componentOrTemplateRef: ComponentType<T>,\n    dialogContainer: CdkDialogContainer,\n    overlayRef: OverlayRef,\n    config: DialogConfig,\n  ): DialogRef<any> {\n    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    const dialogRef = this._createDialogRef(overlayRef, dialogContainer, config);\n    const injector = this._createInjector<T>(config, dialogRef, dialogContainer);\n    const contentRef = dialogContainer.attachComponentPortal(\n      new ComponentPortal(componentOrTemplateRef, undefined, injector),\n    );\n    dialogRef.componentInstance = contentRef.instance;\n    return dialogRef;\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created MatDialogContainer.\n   * @param componentOrTemplateRef The type of component being loaded into the dialog,\n   *     or a TemplateRef to instantiate as the content.\n   * @param dialogContainer Reference to the wrapping MatDialogContainer.\n   * @param overlayRef Reference to the overlay in which the dialog resides.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n   */\n  protected _attachDialogContentForTemplate<T>(\n    componentOrTemplateRef: TemplateRef<T>,\n    dialogContainer: CdkDialogContainer,\n    overlayRef: OverlayRef,\n    config: DialogConfig,\n  ): DialogRef<any> {\n    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    const dialogRef = this._createDialogRef(overlayRef, dialogContainer, config);\n    dialogContainer.attachTemplatePortal(\n      new TemplatePortal<T>(componentOrTemplateRef, null!, <any>{\n        $implicit: config.data,\n        dialogRef,\n      }),\n    );\n    return dialogRef;\n  }\n\n  /**\n   * Creates a custom injector to be used inside the dialog. This allows a component loaded inside\n   * of a dialog to close itself and, optionally, to return a value.\n   * @param config Config object that is used to construct the dialog.\n   * @param dialogRef Reference to the dialog.\n   * @param container Dialog container element that wraps all of the contents.\n   * @returns The custom injector that can be used inside the dialog.\n   */\n  private _createInjector<T>(\n    config: DialogConfig,\n    dialogRef: DialogRef<T>,\n    dialogContainer: CdkDialogContainer,\n  ): Injector {\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;\n    const providers: StaticProvider[] = [\n      {provide: this._injector.get(DIALOG_REF), useValue: dialogRef},\n      {provide: this._injector.get(DIALOG_CONTAINER), useValue: dialogContainer},\n      {provide: DIALOG_DATA, useValue: config.data},\n    ];\n\n    if (\n      config.direction &&\n      (!userInjector ||\n        !userInjector.get<Directionality | null>(Directionality, null, InjectFlags.Optional))\n    ) {\n      providers.push({\n        provide: Directionality,\n        useValue: {value: config.direction, change: observableOf()},\n      });\n    }\n\n    return Injector.create({parent: userInjector || this._injector, providers});\n  }\n\n  /** Creates a new dialog ref. */\n  private _createDialogRef(\n    overlayRef: OverlayRef,\n    dialogContainer: CdkDialogContainer,\n    config: DialogConfig,\n  ) {\n    const dialogRef = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);\n    dialogRef.disableClose = config.disableClose;\n    dialogRef.updateSize(config).updatePosition(config.position);\n    return dialogRef;\n  }\n\n  /**\n   * Expands the provided configuration object to include the default values for properties which\n   * are undefined.\n   */\n  private _applyConfigDefaults(config?: DialogConfig): DialogConfig {\n    const dialogConfig = this._injector.get(DIALOG_CONFIG) as typeof DialogConfig;\n    return {...new dialogConfig(), ...config};\n  }\n}\n"]}

package/esm2020/dialog/dialog_public_index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nX3B1YmxpY19pbmRleC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jZGstZXhwZXJpbWVudGFsL2RpYWxvZy9kaWFsb2dfcHVibGljX2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2020/dialog/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9kaWFsb2cvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/listbox/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9saXN0Ym94L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2020/listbox/listbox-module.mjs

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { NgModule } from '@angular/core';
+import { CdkListbox, CdkOption } from './listbox';
+import * as i0 from "@angular/core";
+const EXPORTED_DECLARATIONS = [CdkListbox, CdkOption];
+export class CdkListboxModule {
+}
+CdkListboxModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkListboxModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CdkListboxModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkListboxModule, declarations: [CdkListbox, CdkOption], exports: [CdkListbox, CdkOption] });
+CdkListboxModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkListboxModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: CdkListboxModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: EXPORTED_DECLARATIONS,
+                    declarations: EXPORTED_DECLARATIONS,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdGJveC1tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvY2RrLWV4cGVyaW1lbnRhbC9saXN0Ym94L2xpc3Rib3gtbW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFVBQVUsRUFBRSxTQUFTLEVBQUMsTUFBTSxXQUFXLENBQUM7O0FBRWhELE1BQU0scUJBQXFCLEdBQUcsQ0FBQyxVQUFVLEVBQUUsU0FBUyxDQUFDLENBQUM7QUFLdEQsTUFBTSxPQUFPLGdCQUFnQjs7cUhBQWhCLGdCQUFnQjtzSEFBaEIsZ0JBQWdCLGlCQUxFLFVBQVUsRUFBRSxTQUFTLGFBQXJCLFVBQVUsRUFBRSxTQUFTO3NIQUt2QyxnQkFBZ0I7bUdBQWhCLGdCQUFnQjtrQkFKNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUscUJBQXFCO29CQUM5QixZQUFZLEVBQUUscUJBQXFCO2lCQUNwQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q2RrTGlzdGJveCwgQ2RrT3B0aW9ufSBmcm9tICcuL2xpc3Rib3gnO1xuXG5jb25zdCBFWFBPUlRFRF9ERUNMQVJBVElPTlMgPSBbQ2RrTGlzdGJveCwgQ2RrT3B0aW9uXTtcbkBOZ01vZHVsZSh7XG4gIGV4cG9ydHM6IEVYUE9SVEVEX0RFQ0xBUkFUSU9OUyxcbiAgZGVjbGFyYXRpb25zOiBFWFBPUlRFRF9ERUNMQVJBVElPTlMsXG59KVxuZXhwb3J0IGNsYXNzIENka0xpc3Rib3hNb2R1bGUge31cbiJdfQ==