@mobilelivenpm/fds-angular-qa
Version:
This library was generated with [Nx](https://nx.dev).
339 lines • 47.8 kB
JavaScript
import { Overlay, OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';
import { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
import { Location } from '@angular/common';
import { Directive, Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef, Type } from '@angular/core';
import { defer, of as observableOf, Subject } from 'rxjs';
import { startWith } from 'rxjs/operators';
import { FdsModalConfig } from './modal-config';
import { FdsModalContainer } from './modal-container';
import { FdsModalRef } from './modal-ref';
import { Directionality } from '@angular/cdk/bidi';
// TODO: @Dmitriy remove from here and check how to use devMode
const ngDevMode = false;
/** Injection token that can be used to access the data that was passed in to a dialog. */
export const MAT_DIALOG_DATA = new InjectionToken('FdsModalData');
/** Injection token that can be used to specify default dialog options. */
export const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('fds-modal-default-options');
/** Injection token that determines the scroll handling while the dialog is open. */
export const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken('fds-modal-scroll-strategy');
/** @docs-private */
export function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(overlay) {
return () => overlay.scrollStrategies.block();
}
/** @docs-private */
export function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
return () => overlay.scrollStrategies.block();
}
/** @docs-private */
export const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {
provide: MAT_DIALOG_SCROLL_STRATEGY,
deps: [Overlay],
useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY
};
/**
* Base class for dialog services. The base dialog service allows
* for arbitrary dialog refs and dialog container components.
*/
export class _FdsModalBase {
constructor(_overlay, _injector, _defaultOptions, _parentDialog, _overlayContainer, scrollStrategy, _dialogRefConstructor, _dialogContainerType, _dialogDataToken) {
this._overlay = _overlay;
this._injector = _injector;
this._defaultOptions = _defaultOptions;
this._parentDialog = _parentDialog;
this._overlayContainer = _overlayContainer;
this._dialogRefConstructor = _dialogRefConstructor;
this._dialogContainerType = _dialogContainerType;
this._dialogDataToken = _dialogDataToken;
/**
* Stream that emits when all open dialog have finished closing.
* Will emit on subscribe if there are no open dialogs to begin with.
*/
this.afterAllClosed = defer(() => this.openDialogs.length
? this._getAfterAllClosed()
: this._getAfterAllClosed().pipe(startWith(undefined)));
this._openDialogsAtThisLevel = [];
this._afterAllClosedAtThisLevel = new Subject();
this._afterOpenedAtThisLevel = new Subject();
this._ariaHiddenElements = new Map();
this._scrollStrategy = scrollStrategy;
}
/** Keeps track of the currently-open dialogs. */
get openDialogs() {
return this._parentDialog
? this._parentDialog.openDialogs
: this._openDialogsAtThisLevel;
}
/** Stream that emits when a dialog has been opened. */
get afterOpened() {
return this._parentDialog
? this._parentDialog.afterOpened
: this._afterOpenedAtThisLevel;
}
_getAfterAllClosed() {
const parent = this._parentDialog;
return parent
? parent._getAfterAllClosed()
: this._afterAllClosedAtThisLevel;
}
/**
* Opens a modal dialog containing the given component.
* @param componentOrTemplateRef Type of the component to load into the dialog,
* or a TemplateRef to instantiate as the dialog content.
* @param config Extra configuration options.
* @returns Reference to the newly-opened dialog.
*/
open(componentOrTemplateRef, config) {
config = _applyConfigDefaults(config, this._defaultOptions || new FdsModalConfig());
if (config.id &&
this.getDialogById(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._attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);
// If this is the first dialog that we're opening, hide all the non-overlay content.
if (!this.openDialogs.length) {
this._hideNonDialogContentFromAssistiveTechnology();
}
this.openDialogs.push(dialogRef);
dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));
this.afterOpened.next(dialogRef);
// Notify the dialog container that the content has been attached.
dialogContainer._initializeWithAttachedContent();
return dialogRef;
}
/**
* Closes all of the currently-open dialogs.
*/
closeAll() {
this._closeDialogs(this.openDialogs);
}
/**
* Finds an open dialog by its id.
* @param id ID to use when looking up the dialog.
*/
getDialogById(id) {
return this.openDialogs.find(dialog => dialog.id === id);
}
ngOnDestroy() {
// Only close the dialogs at this level on destroy
// since the parent service may still be active.
this._closeDialogs(this._openDialogsAtThisLevel);
this._afterAllClosedAtThisLevel.complete();
this._afterOpenedAtThisLevel.complete();
}
/**
* Creates the overlay into which the dialog will be loaded.
* @param config The dialog configuration.
* @returns A promise resolving to the OverlayRef for the created overlay.
*/
_createOverlay(config) {
const overlayConfig = this._getOverlayConfig(config);
return this._overlay.create(overlayConfig);
}
/**
* Creates an overlay config from a dialog config.
* @param dialogConfig The dialog configuration.
* @returns The overlay configuration.
*/
_getOverlayConfig(dialogConfig) {
const state = new OverlayConfig({
positionStrategy: this._overlay.position().global(),
scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),
panelClass: dialogConfig.panelClass,
hasBackdrop: dialogConfig.hasBackdrop,
direction: dialogConfig.direction,
minWidth: dialogConfig.minWidth,
minHeight: dialogConfig.minHeight,
maxWidth: dialogConfig.maxWidth,
maxHeight: dialogConfig.maxHeight,
disposeOnNavigation: dialogConfig.closeOnNavigation
});
if (dialogConfig.backdropClass) {
state.backdropClass = dialogConfig.backdropClass;
}
return state;
}
/**
* Attaches a dialog container 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 userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
const injector = Injector.create({
parent: userInjector || this._injector,
providers: [{ provide: FdsModalConfig, useValue: config }]
});
const containerPortal = new ComponentPortal(this._dialogContainerType, config.viewContainerRef, injector, config.componentFactoryResolver);
const containerRef = overlay.attach(containerPortal);
return containerRef.instance;
}
/**
* Attaches the user-provided component to the already-created dialog container.
* @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 dialog container.
* @param overlayRef Reference to the overlay in which the dialog resides.
* @param config The dialog configuration.
* @returns A promise resolving to the FdsModalRef that should be returned to the user.
*/
_attachDialogContent(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 = new this._dialogRefConstructor(overlayRef, dialogContainer, config.id);
if (componentOrTemplateRef instanceof TemplateRef) {
dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, {
$implicit: config.data,
dialogRef
}));
}
else {
const injector = this._createInjector(config, dialogRef, dialogContainer);
const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, config.viewContainerRef, injector));
dialogRef.componentInstance = contentRef.instance;
}
dialogRef
.updateSize(config.width, config.height)
.updatePosition(config.position);
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 dialogContainer 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;
// The dialog container should be provided as the dialog container and the dialog's
// content are created out of the same `ViewContainerRef` and as such, are siblings
// for injector purposes. To allow the hierarchy that is expected, the dialog
// container is explicitly provided in the injector.
const providers = [
{ provide: this._dialogContainerType, useValue: dialogContainer },
{ provide: this._dialogDataToken, useValue: config.data },
{ provide: this._dialogRefConstructor, useValue: dialogRef }
];
if (config.direction &&
(!userInjector ||
!userInjector.get(Directionality, null))) {
providers.push({
provide: Directionality,
useValue: { value: config.direction, change: observableOf() }
});
}
return Injector.create({
parent: userInjector || this._injector,
providers
});
}
/**
* Removes a dialog from the array of open dialogs.
* @param dialogRef Dialog to be removed.
*/
_removeOpenDialog(dialogRef) {
const index = this.openDialogs.indexOf(dialogRef);
if (index > -1) {
this.openDialogs.splice(index, 1);
// If all the dialogs were closed, remove/restore the `aria-hidden`
// to a the siblings and emit to the `afterAllClosed` stream.
if (!this.openDialogs.length) {
this._ariaHiddenElements.forEach((previousValue, element) => {
if (previousValue) {
element.setAttribute('aria-hidden', previousValue);
}
else {
element.removeAttribute('aria-hidden');
}
});
this._ariaHiddenElements.clear();
this._getAfterAllClosed().next();
}
}
}
/**
* Hides all of the content that isn't an overlay from assistive technology.
*/
_hideNonDialogContentFromAssistiveTechnology() {
const overlayContainer = this._overlayContainer.getContainerElement();
// Ensure that the overlay container is attached to the DOM.
if (overlayContainer.parentElement) {
const siblings = overlayContainer.parentElement.children;
for (let i = siblings.length - 1; i > -1; i--) {
let sibling = siblings[i];
if (sibling !== overlayContainer &&
sibling.nodeName !== 'SCRIPT' &&
sibling.nodeName !== 'STYLE' &&
!sibling.hasAttribute('aria-live')) {
this._ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));
sibling.setAttribute('aria-hidden', 'true');
}
}
}
}
/** Closes all of the dialogs in an array. */
_closeDialogs(dialogs) {
let i = dialogs.length;
while (i--) {
// The `_openDialogs` property isn't updated after close until the rxjs subscription
// runs on the next microtask, in addition to modifying the array as we're going
// through it. We loop through all of them and call close without assuming that
// they'll be removed from the list instantaneously.
dialogs[i].close();
}
}
}
_FdsModalBase.decorators = [
{ type: Directive }
];
_FdsModalBase.ctorParameters = () => [
{ type: Overlay },
{ type: Injector },
{ type: undefined },
{ type: undefined },
{ type: OverlayContainer },
{ type: undefined },
{ type: Type },
{ type: Type },
{ type: InjectionToken }
];
/**
* Service to open modal dialogs.
*/
export class FdsModalService extends _FdsModalBase {
constructor(overlay, injector,
/**
* @deprecated `_location` parameter to be removed.
* @breaking-change 10.0.0
*/
location, defaultOptions, scrollStrategy, parentDialog, overlayContainer) {
super(overlay, injector, defaultOptions, parentDialog, overlayContainer, scrollStrategy, FdsModalRef, FdsModalContainer, MAT_DIALOG_DATA);
}
}
FdsModalService.decorators = [
{ type: Injectable }
];
FdsModalService.ctorParameters = () => [
{ type: Overlay },
{ type: Injector },
{ type: Location, decorators: [{ type: Optional }] },
{ type: FdsModalConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_SCROLL_STRATEGY,] }] },
{ type: FdsModalService, decorators: [{ type: Optional }, { type: SkipSelf }] },
{ type: OverlayContainer }
];
/**
* Applies default options to the dialog config.
* @param config Config to be modified.
* @param defaultOptions Default options provided.
* @returns The new configuration object.
*/
function _applyConfigDefaults(config, defaultOptions) {
return Object.assign(Object.assign({}, defaultOptions), config);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/lib/modal/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Overlay,\n  OverlayConfig,\n  OverlayContainer,\n  OverlayRef,\n  ScrollStrategy\n} from '@angular/cdk/overlay';\nimport {\n  ComponentPortal,\n  ComponentType,\n  TemplatePortal\n} from '@angular/cdk/portal';\nimport { Location } from '@angular/common';\nimport {\n  Directive,\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  StaticProvider,\n  TemplateRef,\n  Type\n} from '@angular/core';\nimport { defer, Observable, of as observableOf, Subject } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { FdsModalConfig } from './modal-config';\nimport { _FdsModalContainerBase, FdsModalContainer } from './modal-container';\nimport { FdsModalRef } from './modal-ref';\nimport { Directionality } from '@angular/cdk/bidi';\n\n// TODO: @Dmitriy remove from here and check how to use devMode\nconst ngDevMode = false;\n\n/** Injection token that can be used to access the data that was passed in to a dialog. */\nexport const MAT_DIALOG_DATA = new InjectionToken<any>('FdsModalData');\n\n/** Injection token that can be used to specify default dialog options. */\nexport const MAT_DIALOG_DEFAULT_OPTIONS = new InjectionToken<FdsModalConfig>(\n  'fds-modal-default-options'\n);\n\n/** Injection token that determines the scroll handling while the dialog is open. */\nexport const MAT_DIALOG_SCROLL_STRATEGY = new InjectionToken<\n  () => ScrollStrategy\n>('fds-modal-scroll-strategy');\n\n/** @docs-private */\nexport function MAT_DIALOG_SCROLL_STRATEGY_FACTORY(\n  overlay: Overlay\n): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.block();\n}\n\n/** @docs-private */\nexport function MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(\n  overlay: Overlay\n): () => ScrollStrategy {\n  return () => overlay.scrollStrategies.block();\n}\n\n/** @docs-private */\nexport const MAT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n  provide: MAT_DIALOG_SCROLL_STRATEGY,\n  deps: [Overlay],\n  useFactory: MAT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY\n};\n\n/**\n * Base class for dialog services. The base dialog service allows\n * for arbitrary dialog refs and dialog container components.\n */\n@Directive()\nexport abstract class _FdsModalBase<C extends _FdsModalContainerBase>\n  implements OnDestroy {\n  /**\n   * Stream that emits when all open dialog have finished closing.\n   * Will emit on subscribe if there are no open dialogs to begin with.\n   */\n  readonly afterAllClosed: Observable<void> = defer(() =>\n    this.openDialogs.length\n      ? this._getAfterAllClosed()\n      : this._getAfterAllClosed().pipe(startWith(undefined))\n  ) as Observable<any>;\n  private _openDialogsAtThisLevel: FdsModalRef<any>[] = [];\n  private readonly _afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly _afterOpenedAtThisLevel = new Subject<FdsModalRef<any>>();\n  private _ariaHiddenElements = new Map<Element, string | null>();\n  private _scrollStrategy: () => ScrollStrategy;\n\n  constructor(\n    private _overlay: Overlay,\n    private _injector: Injector,\n    private _defaultOptions: FdsModalConfig | undefined,\n    private _parentDialog: _FdsModalBase<C> | undefined,\n    private _overlayContainer: OverlayContainer,\n    scrollStrategy: any,\n    private _dialogRefConstructor: Type<FdsModalRef<any>>,\n    private _dialogContainerType: Type<C>,\n    private _dialogDataToken: InjectionToken<any>\n  ) {\n    this._scrollStrategy = scrollStrategy;\n  }\n\n  /** Keeps track of the currently-open dialogs. */\n  get openDialogs(): FdsModalRef<any>[] {\n    return this._parentDialog\n      ? this._parentDialog.openDialogs\n      : this._openDialogsAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  get afterOpened(): Subject<FdsModalRef<any>> {\n    return this._parentDialog\n      ? this._parentDialog.afterOpened\n      : this._afterOpenedAtThisLevel;\n  }\n\n  _getAfterAllClosed(): Subject<void> {\n    const parent = this._parentDialog;\n    return parent\n      ? parent._getAfterAllClosed()\n      : this._afterAllClosedAtThisLevel;\n  }\n\n  /**\n   * Opens a modal dialog containing the given component.\n   * @param componentOrTemplateRef Type of the component to load into the dialog,\n   *     or a TemplateRef to instantiate as the dialog content.\n   * @param config Extra configuration options.\n   * @returns Reference to the newly-opened dialog.\n   */\n  open<T, D = any, R = any>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    config?: FdsModalConfig<D>\n  ): FdsModalRef<T, R> {\n    config = _applyConfigDefaults(\n      config,\n      this._defaultOptions || new FdsModalConfig()\n    );\n\n    if (\n      config.id &&\n      this.getDialogById(config.id) &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)\n    ) {\n      throw Error(\n        `Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`\n      );\n    }\n\n    const overlayRef = this._createOverlay(config);\n    const dialogContainer = this._attachDialogContainer(overlayRef, config);\n    const dialogRef = this._attachDialogContent<T, R>(\n      componentOrTemplateRef,\n      dialogContainer,\n      overlayRef,\n      config\n    );\n\n    // If this is the first dialog that we're opening, hide all the non-overlay content.\n    if (!this.openDialogs.length) {\n      this._hideNonDialogContentFromAssistiveTechnology();\n    }\n\n    this.openDialogs.push(dialogRef);\n    dialogRef.afterClosed().subscribe(() => this._removeOpenDialog(dialogRef));\n    this.afterOpened.next(dialogRef);\n\n    // Notify the dialog container that the content has been attached.\n    dialogContainer._initializeWithAttachedContent();\n\n    return dialogRef;\n  }\n\n  /**\n   * Closes all of the currently-open dialogs.\n   */\n  closeAll(): void {\n    this._closeDialogs(this.openDialogs);\n  }\n\n  /**\n   * Finds an open dialog by its id.\n   * @param id ID to use when looking up the dialog.\n   */\n  getDialogById(id: string): FdsModalRef<any> | undefined {\n    return this.openDialogs.find(dialog => dialog.id === id);\n  }\n\n  ngOnDestroy() {\n    // Only close the dialogs at this level on destroy\n    // since the parent service may still be active.\n    this._closeDialogs(this._openDialogsAtThisLevel);\n    this._afterAllClosedAtThisLevel.complete();\n    this._afterOpenedAtThisLevel.complete();\n  }\n\n  /**\n   * Creates the overlay into which the dialog will be loaded.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the OverlayRef for the created overlay.\n   */\n  private _createOverlay(config: FdsModalConfig): OverlayRef {\n    const overlayConfig = this._getOverlayConfig(config);\n    return this._overlay.create(overlayConfig);\n  }\n\n  /**\n   * Creates an overlay config from a dialog config.\n   * @param dialogConfig The dialog configuration.\n   * @returns The overlay configuration.\n   */\n  private _getOverlayConfig(dialogConfig: FdsModalConfig): OverlayConfig {\n    const state = new OverlayConfig({\n      positionStrategy: this._overlay.position().global(),\n      scrollStrategy: dialogConfig.scrollStrategy || this._scrollStrategy(),\n      panelClass: dialogConfig.panelClass,\n      hasBackdrop: dialogConfig.hasBackdrop,\n      direction: dialogConfig.direction,\n      minWidth: dialogConfig.minWidth,\n      minHeight: dialogConfig.minHeight,\n      maxWidth: dialogConfig.maxWidth,\n      maxHeight: dialogConfig.maxHeight,\n      disposeOnNavigation: dialogConfig.closeOnNavigation\n    });\n\n    if (dialogConfig.backdropClass) {\n      state.backdropClass = dialogConfig.backdropClass;\n    }\n\n    return state;\n  }\n\n  /**\n   * Attaches a dialog container 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  private _attachDialogContainer(\n    overlay: OverlayRef,\n    config: FdsModalConfig\n  ): C {\n    const userInjector =\n      config && config.viewContainerRef && config.viewContainerRef.injector;\n    const injector = Injector.create({\n      parent: userInjector || this._injector,\n      providers: [{ provide: FdsModalConfig, useValue: config }]\n    });\n\n    const containerPortal = new ComponentPortal(\n      this._dialogContainerType,\n      config.viewContainerRef,\n      injector,\n      config.componentFactoryResolver\n    );\n    const containerRef = overlay.attach<C>(containerPortal);\n\n    return containerRef.instance;\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created dialog container.\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 dialog container.\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 FdsModalRef that should be returned to the user.\n   */\n  private _attachDialogContent<T, R>(\n    componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n    dialogContainer: C,\n    overlayRef: OverlayRef,\n    config: FdsModalConfig\n  ): FdsModalRef<T, R> {\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 = new this._dialogRefConstructor(\n      overlayRef,\n      dialogContainer,\n      config.id\n    );\n\n    if (componentOrTemplateRef instanceof TemplateRef) {\n      dialogContainer.attachTemplatePortal(\n        new TemplatePortal<T>(componentOrTemplateRef, null!, <any>{\n          $implicit: config.data,\n          dialogRef\n        })\n      );\n    } else {\n      const injector = this._createInjector<T>(\n        config,\n        dialogRef,\n        dialogContainer\n      );\n      const contentRef = dialogContainer.attachComponentPortal<T>(\n        new ComponentPortal(\n          componentOrTemplateRef,\n          config.viewContainerRef,\n          injector\n        )\n      );\n      dialogRef.componentInstance = contentRef.instance;\n    }\n\n    dialogRef\n      .updateSize(config.width, config.height)\n      .updatePosition(config.position);\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 dialogContainer 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: FdsModalConfig,\n    dialogRef: FdsModalRef<T>,\n    dialogContainer: C\n  ): Injector {\n    const userInjector =\n      config && config.viewContainerRef && config.viewContainerRef.injector;\n\n    // The dialog container should be provided as the dialog container and the dialog's\n    // content are created out of the same `ViewContainerRef` and as such, are siblings\n    // for injector purposes. To allow the hierarchy that is expected, the dialog\n    // container is explicitly provided in the injector.\n    const providers: StaticProvider[] = [\n      { provide: this._dialogContainerType, useValue: dialogContainer },\n      { provide: this._dialogDataToken, useValue: config.data },\n      { provide: this._dialogRefConstructor, useValue: dialogRef }\n    ];\n\n    if (\n      config.direction &&\n      (!userInjector ||\n        !userInjector.get<Directionality | null>(Directionality, null))\n    ) {\n      providers.push({\n        provide: Directionality,\n        useValue: { value: config.direction, change: observableOf() }\n      });\n    }\n\n    return Injector.create({\n      parent: userInjector || this._injector,\n      providers\n    });\n  }\n\n  /**\n   * Removes a dialog from the array of open dialogs.\n   * @param dialogRef Dialog to be removed.\n   */\n  private _removeOpenDialog(dialogRef: FdsModalRef<any>) {\n    const index = this.openDialogs.indexOf(dialogRef);\n\n    if (index > -1) {\n      this.openDialogs.splice(index, 1);\n\n      // If all the dialogs were closed, remove/restore the `aria-hidden`\n      // to a the siblings and emit to the `afterAllClosed` stream.\n      if (!this.openDialogs.length) {\n        this._ariaHiddenElements.forEach((previousValue, element) => {\n          if (previousValue) {\n            element.setAttribute('aria-hidden', previousValue);\n          } else {\n            element.removeAttribute('aria-hidden');\n          }\n        });\n\n        this._ariaHiddenElements.clear();\n        this._getAfterAllClosed().next();\n      }\n    }\n  }\n\n  /**\n   * Hides all of the content that isn't an overlay from assistive technology.\n   */\n  private _hideNonDialogContentFromAssistiveTechnology() {\n    const overlayContainer = this._overlayContainer.getContainerElement();\n\n    // Ensure that the overlay container is attached to the DOM.\n    if (overlayContainer.parentElement) {\n      const siblings = overlayContainer.parentElement.children;\n\n      for (let i = siblings.length - 1; i > -1; i--) {\n        let sibling = siblings[i];\n\n        if (\n          sibling !== overlayContainer &&\n          sibling.nodeName !== 'SCRIPT' &&\n          sibling.nodeName !== 'STYLE' &&\n          !sibling.hasAttribute('aria-live')\n        ) {\n          this._ariaHiddenElements.set(\n            sibling,\n            sibling.getAttribute('aria-hidden')\n          );\n          sibling.setAttribute('aria-hidden', 'true');\n        }\n      }\n    }\n  }\n\n  /** Closes all of the dialogs in an array. */\n  private _closeDialogs(dialogs: FdsModalRef<any>[]) {\n    let i = dialogs.length;\n\n    while (i--) {\n      // The `_openDialogs` property isn't updated after close until the rxjs subscription\n      // runs on the next microtask, in addition to modifying the array as we're going\n      // through it. We loop through all of them and call close without assuming that\n      // they'll be removed from the list instantaneously.\n      dialogs[i].close();\n    }\n  }\n}\n\n/**\n * Service to open modal dialogs.\n */\n@Injectable()\nexport class FdsModalService extends _FdsModalBase<FdsModalContainer> {\n  constructor(\n    overlay: Overlay,\n    injector: Injector,\n    /**\n     * @deprecated `_location` parameter to be removed.\n     * @breaking-change 10.0.0\n     */\n    @Optional() location: Location,\n    @Optional()\n    @Inject(MAT_DIALOG_DEFAULT_OPTIONS)\n    defaultOptions: FdsModalConfig,\n    @Inject(MAT_DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n    @Optional() @SkipSelf() parentDialog: FdsModalService,\n    overlayContainer: OverlayContainer\n  ) {\n    super(\n      overlay,\n      injector,\n      defaultOptions,\n      parentDialog,\n      overlayContainer,\n      scrollStrategy,\n      FdsModalRef,\n      FdsModalContainer,\n      MAT_DIALOG_DATA\n    );\n  }\n}\n\n/**\n * Applies default options to the dialog config.\n * @param config Config to be modified.\n * @param defaultOptions Default options provided.\n * @returns The new configuration object.\n */\nfunction _applyConfigDefaults(\n  config?: FdsModalConfig,\n  defaultOptions?: FdsModalConfig\n): FdsModalConfig {\n  return { ...defaultOptions, ...config };\n}\n"]}