ng-primitives 0.7.0 → 0.7.2

package/esm2022/dialog/dialog/dialog.directive.mjs

@@ -1,34 +1,61 @@
-import { booleanAttribute, contentChild, Directive, input } from '@angular/core';
+import { booleanAttribute, Directive, HostListener, input, signal } from '@angular/core';
+import { NgpFocusTrap } from 'ng-primitives/focus-trap';
 import { uniqueId } from 'ng-primitives/utils';
-import { NgpDialogTitleToken } from '../dialog-title/dialog-title.token';
+import { injectDialogConfig } from '../config/dialog.config';
+import { injectDialogRef } from './dialog-ref';
 import { NgpDialogToken } from './dialog.token';
 import * as i0 from "@angular/core";
+import * as i1 from "ng-primitives/focus-trap";
 export class NgpDialog {
     constructor() {
-        /**
-         * Define the id of the dialog.
-         */
+        this.config = injectDialogConfig();
+        /** Access the dialog ref */
+        this.dialogRef = injectDialogRef();
+        /** The id of the dialog */
         this.id = input(uniqueId('ngp-dialog'));
-        /**
-         * The open state of the dialog.
-         */
-        this.open = input(false, {
-            alias: 'ngpDialogOpen',
-            transform: booleanAttribute,
-        });
-        /**
-         * The type of the dialog.
-         */
-        this.type = input('dialog', {
+        /** The dialog role. */
+        this.role = input(this.config.role, {
             alias: 'ngpDialogRole',
         });
-        /**
-         * Access the title of the dialog.
-         */
-        this.title = contentChild(NgpDialogTitleToken, { descendants: true });
+        /** Whether the dialog is a modal. */
+        this.modal = input(this.config.modal ?? false, {
+            alias: 'ngpDialogModal',
+            transform: booleanAttribute,
+        });
+        /** The labelledby ids */
+        this.labelledBy = signal([]);
+        /** The describedby ids */
+        this.describedBy = signal([]);
+    }
+    ngOnDestroy() {
+        this.close();
+    }
+    /** Close the dialog. */
+    close() {
+        this.dialogRef.close();
+    }
+    /** Stop click events from propagating to the overlay */
+    onClick(event) {
+        event.stopPropagation();
+    }
+    /** @internal register a labelledby id */
+    setLabelledBy(id) {
+        this.labelledBy.update(ids => [...ids, id]);
+    }
+    /** @internal register a describedby id */
+    setDescribedBy(id) {
+        this.describedBy.update(ids => [...ids, id]);
+    }
+    /** @internal remove a labelledby id */
+    removeLabelledBy(id) {
+        this.labelledBy.update(ids => ids.filter(i => i !== id));
+    }
+    /** @internal remove a describedby id */
+    removeDescribedBy(id) {
+        this.describedBy.update(ids => ids.filter(i => i !== id));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialog, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "18.1.1", type: NgpDialog, isStandalone: true, selector: "[ngpDialog]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, open: { classPropertyName: "open", publicName: "ngpDialogOpen", isSignal: true, isRequired: false, transformFunction: null }, type: { classPropertyName: "type", publicName: "ngpDialogRole", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "role": "dialog" }, properties: { "id": "id()", "attr.tabindex": "-1", "attr.data-open": "open()", "attr.aria-labelledby": "title() ?? null" } }, providers: [{ provide: NgpDialogToken, useExisting: NgpDialog }], queries: [{ propertyName: "title", first: true, predicate: NgpDialogTitleToken, descendants: true, isSignal: true }], exportAs: ["ngpDialog"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpDialog, isStandalone: true, selector: "[ngpDialog]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null }, role: { classPropertyName: "role", publicName: "ngpDialogRole", isSignal: true, isRequired: false, transformFunction: null }, modal: { classPropertyName: "modal", publicName: "ngpDialogModal", isSignal: true, isRequired: false, transformFunction: null } }, host: { attributes: { "tabindex": "-1" }, listeners: { "click": "onClick($event)" }, properties: { "id": "id()", "attr.role": "role()", "attr.aria-modal": "modal()", "attr.aria-labelledby": "labelledBy().join(\" \")", "attr.aria-describedby": "describedBy().join(\" \")" } }, providers: [{ provide: NgpDialogToken, useExisting: NgpDialog }], exportAs: ["ngpDialog"], hostDirectives: [{ directive: i1.NgpFocusTrap }], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialog, decorators: [{
             type: Directive,
@@ -37,13 +64,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImpor
                     selector: '[ngpDialog]',
                     exportAs: 'ngpDialog',
                     providers: [{ provide: NgpDialogToken, useExisting: NgpDialog }],
+                    hostDirectives: [NgpFocusTrap],
                     host: {
-                        role: 'dialog',
+                        tabindex: '-1',
                         '[id]': 'id()',
-                        '[attr.tabindex]': '-1',
-                        '[attr.data-open]': 'open()',
-                        '[attr.aria-labelledby]': 'title() ?? null',
+                        '[attr.role]': 'role()',
+                        '[attr.aria-modal]': 'modal()',
+                        '[attr.aria-labelledby]': 'labelledBy().join(" ")',
+                        '[attr.aria-describedby]': 'describedBy().join(" ")',
                     },
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/dialog/dialog/dialog.service.mjs

@@ -0,0 +1,202 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Overlay, OverlayConfig, OverlayContainer } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Injectable, Injector, inject, isDevMode, } from '@angular/core';
+import { uniqueId } from 'ng-primitives/utils';
+import { Subject, defer } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { injectDialogConfig } from '../config/dialog.config';
+import { NgpDialogRef } from './dialog-ref';
+import * as i0 from "@angular/core";
+/**
+ * This is based on the Angular CDK Dialog service.
+ * https://github.com/angular/components/blob/main/src/cdk/dialog/dialog.ts
+ */
+export class NgpDialogManager {
+    constructor() {
+        this.overlay = inject(Overlay);
+        this.defaultOptions = injectDialogConfig();
+        this.parentDialogManager = inject(NgpDialogManager, {
+            optional: true,
+            skipSelf: true,
+        });
+        this.overlayContainer = inject(OverlayContainer);
+        this.scrollStrategy = this.defaultOptions.scrollStrategy ?? this.overlay.scrollStrategies.block();
+        this.openDialogsAtThisLevel = [];
+        this.afterAllClosedAtThisLevel = new Subject();
+        this.afterOpenedAtThisLevel = new Subject();
+        this.ariaHiddenElements = new Map();
+        /**
+         * 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)));
+    }
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs() {
+        return this.parentDialogManager
+            ? this.parentDialogManager.openDialogs
+            : this.openDialogsAtThisLevel;
+    }
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpened() {
+        return this.parentDialogManager
+            ? this.parentDialogManager.afterOpened
+            : this.afterOpenedAtThisLevel;
+    }
+    /**
+     * Opens a modal dialog containing the given template.
+     */
+    open(templateRef, config) {
+        const defaults = this.defaultOptions;
+        config = { ...defaults, ...config };
+        config.id = config.id ?? uniqueId('ngp-dialog');
+        if (config.id && this.getDialogById(config.id) && isDevMode()) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const overlayConfig = this.getOverlayConfig(config);
+        const overlayRef = this.overlay.create(overlayConfig);
+        const dialogRef = new NgpDialogRef(overlayRef, config);
+        const injector = this.createInjector(config, dialogRef, undefined);
+        const context = {
+            $implicit: dialogRef,
+            close: dialogRef.close.bind(dialogRef),
+        };
+        overlayRef.attach(new TemplatePortal(templateRef, config.viewContainerRef, context, injector));
+        // 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.closed.subscribe(() => this.removeOpenDialog(dialogRef, true));
+        this.afterOpened.next(dialogRef);
+        return dialogRef;
+    }
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        reverseForEach(this.openDialogs, dialog => dialog.close());
+    }
+    /**
+     * 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() {
+        // Make one pass over all the dialogs that need to be untracked, but should not be closed. We
+        // want to stop tracking the open dialog even if it hasn't been closed, because the tracking
+        // determines when `aria-hidden` is removed from elements outside the dialog.
+        reverseForEach(this.openDialogsAtThisLevel, dialog => {
+            // Check for `false` specifically since we want `undefined` to be interpreted as `true`.
+            this.removeOpenDialog(dialog, false);
+        });
+        // Make a second pass and close the remaining dialogs. We do this second pass in order to
+        // correctly dispatch the `afterAllClosed` event in case we have a mixed array of dialogs
+        // that should be closed and dialogs that should not.
+        reverseForEach(this.openDialogsAtThisLevel, dialog => dialog.close());
+        this.afterAllClosedAtThisLevel.complete();
+        this.afterOpenedAtThisLevel.complete();
+        this.openDialogsAtThisLevel = [];
+    }
+    /**
+     * Creates an overlay config from a dialog config.
+     */
+    getOverlayConfig(config) {
+        const state = new OverlayConfig({
+            positionStrategy: this.overlay.position().global().centerHorizontally().centerVertically(),
+            scrollStrategy: config.scrollStrategy || this.scrollStrategy,
+            hasBackdrop: false,
+            disposeOnNavigation: config.closeOnNavigation,
+        });
+        return state;
+    }
+    /**
+     * 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.
+     */
+    createInjector(config, dialogRef, fallbackInjector) {
+        const userInjector = config.injector || config.viewContainerRef?.injector;
+        const providers = [{ provide: NgpDialogRef, useValue: dialogRef }];
+        return Injector.create({ parent: userInjector || fallbackInjector, providers });
+    }
+    /**
+     * Removes a dialog from the array of open dialogs.
+     */
+    removeOpenDialog(dialogRef, emitEvent) {
+        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();
+                if (emitEvent) {
+                    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--) {
+                const 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');
+                }
+            }
+        }
+    }
+    getAfterAllClosed() {
+        const parent = this.parentDialogManager;
+        return parent ? parent.getAfterAllClosed() : this.afterAllClosedAtThisLevel;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogManager, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+/**
+ * Executes a callback against all elements in an array while iterating in reverse.
+ * Useful if the array is being modified as it is being iterated.
+ */
+function reverseForEach(items, callback) {
+    let i = items.length;
+    while (i--) {
+        callback(items[i]);
+    }
+}
+export function injectDialogManager() {
+    return inject(NgpDialogManager);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../packages/ng-primitives/dialog/src/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright © 2024 Angular Primitives.\n * https://github.com/ng-primitives/ng-primitives\n *\n * This source code is licensed under the Apache 2.0 license found in the\n * LICENSE file in the root directory of this source tree.\n */\nimport { Overlay, OverlayConfig, OverlayContainer, ScrollStrategy } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport {\n  Injectable,\n  Injector,\n  OnDestroy,\n  StaticProvider,\n  TemplateRef,\n  inject,\n  isDevMode,\n} from '@angular/core';\nimport { uniqueId } from 'ng-primitives/utils';\nimport { Observable, Subject, defer } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { NgpDialogConfig, injectDialogConfig } from '../config/dialog.config';\nimport { NgpDialogRef } from './dialog-ref';\n\n/**\n * This is based on the Angular CDK Dialog service.\n * https://github.com/angular/components/blob/main/src/cdk/dialog/dialog.ts\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NgpDialogManager implements OnDestroy {\n  private readonly overlay = inject(Overlay);\n  private readonly defaultOptions = injectDialogConfig();\n  private readonly parentDialogManager = inject(NgpDialogManager, {\n    optional: true,\n    skipSelf: true,\n  });\n  private readonly overlayContainer = inject(OverlayContainer);\n  private readonly scrollStrategy: ScrollStrategy =\n    this.defaultOptions.scrollStrategy ?? this.overlay.scrollStrategies.block();\n\n  private openDialogsAtThisLevel: NgpDialogRef[] = [];\n  private readonly afterAllClosedAtThisLevel = new Subject<void>();\n  private readonly afterOpenedAtThisLevel = new Subject<NgpDialogRef>();\n  private ariaHiddenElements = new Map<Element, string | null>();\n\n  /** Keeps track of the currently-open dialogs. */\n  get openDialogs(): readonly NgpDialogRef[] {\n    return this.parentDialogManager\n      ? this.parentDialogManager.openDialogs\n      : this.openDialogsAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  get afterOpened(): Subject<NgpDialogRef> {\n    return this.parentDialogManager\n      ? this.parentDialogManager.afterOpened\n      : this.afterOpenedAtThisLevel;\n  }\n\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  );\n\n  /**\n   * Opens a modal dialog containing the given template.\n   */\n  open(templateRef: TemplateRef<NgpDialogContext>, config?: NgpDialogConfig): NgpDialogRef {\n    const defaults = this.defaultOptions;\n    config = { ...defaults, ...config };\n    config.id = config.id ?? uniqueId('ngp-dialog');\n\n    if (config.id && this.getDialogById(config.id) && isDevMode()) {\n      throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`);\n    }\n\n    const overlayConfig = this.getOverlayConfig(config);\n    const overlayRef = this.overlay.create(overlayConfig);\n    const dialogRef = new NgpDialogRef(overlayRef, config);\n    const injector = this.createInjector(config, dialogRef, undefined);\n    const context: NgpDialogContext = {\n      $implicit: dialogRef,\n      close: dialogRef.close.bind(dialogRef),\n    };\n\n    overlayRef.attach(new TemplatePortal(templateRef, config.viewContainerRef!, context, injector));\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 as NgpDialogRef[]).push(dialogRef);\n    dialogRef.closed.subscribe(() => this.removeOpenDialog(dialogRef, true));\n    this.afterOpened.next(dialogRef);\n\n    return dialogRef;\n  }\n\n  /**\n   * Closes all of the currently-open dialogs.\n   */\n  closeAll(): void {\n    reverseForEach(this.openDialogs, dialog => dialog.close());\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): NgpDialogRef | undefined {\n    return this.openDialogs.find(dialog => dialog.id === id);\n  }\n\n  ngOnDestroy(): void {\n    // Make one pass over all the dialogs that need to be untracked, but should not be closed. We\n    // want to stop tracking the open dialog even if it hasn't been closed, because the tracking\n    // determines when `aria-hidden` is removed from elements outside the dialog.\n    reverseForEach(this.openDialogsAtThisLevel, dialog => {\n      // Check for `false` specifically since we want `undefined` to be interpreted as `true`.\n      this.removeOpenDialog(dialog, false);\n    });\n\n    // Make a second pass and close the remaining dialogs. We do this second pass in order to\n    // correctly dispatch the `afterAllClosed` event in case we have a mixed array of dialogs\n    // that should be closed and dialogs that should not.\n    reverseForEach(this.openDialogsAtThisLevel, dialog => dialog.close());\n\n    this.afterAllClosedAtThisLevel.complete();\n    this.afterOpenedAtThisLevel.complete();\n    this.openDialogsAtThisLevel = [];\n  }\n\n  /**\n   * Creates an overlay config from a dialog config.\n   */\n  private getOverlayConfig(config: NgpDialogConfig): OverlayConfig {\n    const state = new OverlayConfig({\n      positionStrategy: this.overlay.position().global().centerHorizontally().centerVertically(),\n      scrollStrategy: config.scrollStrategy || this.scrollStrategy,\n      hasBackdrop: false,\n      disposeOnNavigation: config.closeOnNavigation,\n    });\n\n    return state;\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   */\n  private createInjector(\n    config: NgpDialogConfig,\n    dialogRef: NgpDialogRef,\n    fallbackInjector: Injector | undefined,\n  ): Injector {\n    const userInjector = config.injector || config.viewContainerRef?.injector;\n    const providers: StaticProvider[] = [{ provide: NgpDialogRef, useValue: dialogRef }];\n\n    return Injector.create({ parent: userInjector || fallbackInjector, providers });\n  }\n\n  /**\n   * Removes a dialog from the array of open dialogs.\n   */\n  private removeOpenDialog(dialogRef: NgpDialogRef, emitEvent: boolean) {\n    const index = this.openDialogs.indexOf(dialogRef);\n\n    if (index > -1) {\n      (this.openDialogs as NgpDialogRef[]).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\n        if (emitEvent) {\n          this.getAfterAllClosed().next();\n        }\n      }\n    }\n  }\n\n  /** Hides all of the content that isn't an overlay from assistive technology. */\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        const 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(sibling, sibling.getAttribute('aria-hidden'));\n          sibling.setAttribute('aria-hidden', 'true');\n        }\n      }\n    }\n  }\n\n  private getAfterAllClosed(): Subject<void> {\n    const parent = this.parentDialogManager;\n    return parent ? parent.getAfterAllClosed() : this.afterAllClosedAtThisLevel;\n  }\n}\n\n/**\n * Executes a callback against all elements in an array while iterating in reverse.\n * Useful if the array is being modified as it is being iterated.\n */\nfunction reverseForEach<T>(items: T[] | readonly T[], callback: (current: T) => void) {\n  let i = items.length;\n\n  while (i--) {\n    callback(items[i]);\n  }\n}\n\nexport interface NgpDialogContext {\n  $implicit: NgpDialogRef;\n  close: () => void;\n}\n\nexport function injectDialogManager(): NgpDialogManager {\n  return inject(NgpDialogManager);\n}\n"]}

package/esm2022/dialog/dialog-description/dialog-description.directive.mjs

@@ -0,0 +1,46 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Directive, input } from '@angular/core';
+import { onChange, uniqueId } from 'ng-primitives/utils';
+import { injectDialog } from '../dialog/dialog.token';
+import { NgpDialogDescriptionToken } from './dialog-description.token';
+import * as i0 from "@angular/core";
+export class NgpDialogDescription {
+    constructor() {
+        /** Access the dialog */
+        this.dialog = injectDialog();
+        /** The id of the descriptions. */
+        this.id = input(uniqueId('ngp-dialog-description'));
+        onChange(this.id, (id, prevId) => {
+            if (prevId) {
+                this.dialog.removeDescribedBy(prevId);
+            }
+            if (id) {
+                this.dialog.setDescribedBy(id);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.dialog.removeDescribedBy(this.id());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogDescription, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpDialogDescription, isStandalone: true, selector: "[ngpDialogDescription]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "id": "id()" } }, providers: [{ provide: NgpDialogDescriptionToken, useExisting: NgpDialogDescription }], exportAs: ["ngpDialogDescription"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogDescription, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpDialogDescription]',
+                    exportAs: 'ngpDialogDescription',
+                    providers: [{ provide: NgpDialogDescriptionToken, useExisting: NgpDialogDescription }],
+                    host: {
+                        '[id]': 'id()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/dialog/dialog-description/dialog-description.token.mjs

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpDialogDescriptionToken = new InjectionToken('NgpDialogDescriptionToken');
+/**
+ * Inject the DialogDescription directive instance
+ */
+export function injectDialogDescription() {
+    return inject(NgpDialogDescriptionToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWRlc2NyaXB0aW9uLnRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmctcHJpbWl0aXZlcy9kaWFsb2cvc3JjL2RpYWxvZy1kZXNjcmlwdGlvbi9kaWFsb2ctZGVzY3JpcHRpb24udG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsSUFBSSxjQUFjLENBQ3pELDJCQUEyQixDQUM1QixDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLFVBQVUsdUJBQXVCO0lBQ3JDLE9BQU8sTUFBTSxDQUFDLHlCQUF5QixDQUFDLENBQUM7QUFDM0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSAyLjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBOZ3BEaWFsb2dEZXNjcmlwdGlvbiB9IGZyb20gJy4vZGlhbG9nLWRlc2NyaXB0aW9uLmRpcmVjdGl2ZSc7XG5cbmV4cG9ydCBjb25zdCBOZ3BEaWFsb2dEZXNjcmlwdGlvblRva2VuID0gbmV3IEluamVjdGlvblRva2VuPE5ncERpYWxvZ0Rlc2NyaXB0aW9uPihcbiAgJ05ncERpYWxvZ0Rlc2NyaXB0aW9uVG9rZW4nLFxuKTtcblxuLyoqXG4gKiBJbmplY3QgdGhlIERpYWxvZ0Rlc2NyaXB0aW9uIGRpcmVjdGl2ZSBpbnN0YW5jZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5qZWN0RGlhbG9nRGVzY3JpcHRpb24oKTogTmdwRGlhbG9nRGVzY3JpcHRpb24ge1xuICByZXR1cm4gaW5qZWN0KE5ncERpYWxvZ0Rlc2NyaXB0aW9uVG9rZW4pO1xufVxuIl19

package/esm2022/dialog/dialog-overlay/dialog-overlay.directive.mjs

@@ -0,0 +1,35 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Directive, HostListener } from '@angular/core';
+import { injectDialogRef } from '../dialog/dialog-ref';
+import { NgpDialogOverlayToken } from './dialog-overlay.token';
+import * as i0 from "@angular/core";
+export class NgpDialogOverlay {
+    constructor() {
+        /** Access the dialog ref. */
+        this.dialogRef = injectDialogRef();
+    }
+    close() {
+        this.dialogRef.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogOverlay, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: NgpDialogOverlay, isStandalone: true, selector: "[ngpDialogOverlay]", host: { listeners: { "click": "close()" } }, providers: [{ provide: NgpDialogOverlayToken, useExisting: NgpDialogOverlay }], exportAs: ["ngpDialogOverlay"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogOverlay, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[ngpDialogOverlay]',
+                    exportAs: 'ngpDialogOverlay',
+                    providers: [{ provide: NgpDialogOverlayToken, useExisting: NgpDialogOverlay }],
+                }]
+        }], propDecorators: { close: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/dialog/dialog-overlay/dialog-overlay.token.mjs

@@ -0,0 +1,16 @@
+/**
+ * Copyright © 2024 Angular Primitives.
+ * https://github.com/ng-primitives/ng-primitives
+ *
+ * This source code is licensed under the Apache 2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { InjectionToken, inject } from '@angular/core';
+export const NgpDialogOverlayToken = new InjectionToken('NgpDialogOverlayToken');
+/**
+ * Inject the DialogOverlay directive instance
+ */
+export function injectDialogOverlay() {
+    return inject(NgpDialogOverlayToken);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLW92ZXJsYXkudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy1wcmltaXRpdmVzL2RpYWxvZy9zcmMvZGlhbG9nLW92ZXJsYXkvZGlhbG9nLW92ZXJsYXkudG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHdkQsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQUcsSUFBSSxjQUFjLENBQW1CLHVCQUF1QixDQUFDLENBQUM7QUFFbkc7O0dBRUc7QUFDSCxNQUFNLFVBQVUsbUJBQW1CO0lBQ2pDLE9BQU8sTUFBTSxDQUFDLHFCQUFxQixDQUFDLENBQUM7QUFDdkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSAyLjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHR5cGUgeyBOZ3BEaWFsb2dPdmVybGF5IH0gZnJvbSAnLi9kaWFsb2ctb3ZlcmxheS5kaXJlY3RpdmUnO1xuXG5leHBvcnQgY29uc3QgTmdwRGlhbG9nT3ZlcmxheVRva2VuID0gbmV3IEluamVjdGlvblRva2VuPE5ncERpYWxvZ092ZXJsYXk+KCdOZ3BEaWFsb2dPdmVybGF5VG9rZW4nKTtcblxuLyoqXG4gKiBJbmplY3QgdGhlIERpYWxvZ092ZXJsYXkgZGlyZWN0aXZlIGluc3RhbmNlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3REaWFsb2dPdmVybGF5KCk6IE5ncERpYWxvZ092ZXJsYXkge1xuICByZXR1cm4gaW5qZWN0KE5ncERpYWxvZ092ZXJsYXlUb2tlbik7XG59XG4iXX0=

package/esm2022/dialog/dialog-title/dialog-title.directive.mjs

@@ -6,18 +6,30 @@
  * LICENSE file in the root directory of this source tree.
  */
 import { Directive, input } from '@angular/core';
-import { uniqueId } from 'ng-primitives/utils';
+import { onChange, uniqueId } from 'ng-primitives/utils';
+import { injectDialog } from '../dialog/dialog.token';
 import { NgpDialogTitleToken } from './dialog-title.token';
 import * as i0 from "@angular/core";
 export class NgpDialogTitle {
     constructor() {
-        /**
-         * The id of the dialog title.
-         */
+        /** Access the dialog. */
+        this.dialog = injectDialog();
+        /** The id of the title. */
         this.id = input(uniqueId('ngp-dialog-title'));
+        onChange(this.id, (id, prevId) => {
+            if (prevId) {
+                this.dialog.removeLabelledBy(prevId);
+            }
+            if (id) {
+                this.dialog.setLabelledBy(id);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.dialog.removeLabelledBy(this.id());
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogTitle, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpDialogTitle, isStandalone: true, selector: "[ngpDialogTitle]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NgpDialogTitleToken, useExisting: NgpDialogTitle }], exportAs: ["ngpDialogTitle"], ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.1.1", type: NgpDialogTitle, isStandalone: true, selector: "[ngpDialogTitle]", inputs: { id: { classPropertyName: "id", publicName: "id", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "id": "id()" } }, providers: [{ provide: NgpDialogTitleToken, useExisting: NgpDialogTitle }], exportAs: ["ngpDialogTitle"], ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: NgpDialogTitle, decorators: [{
             type: Directive,
@@ -26,6 +38,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImpor
                     selector: '[ngpDialogTitle]',
                     exportAs: 'ngpDialogTitle',
                     providers: [{ provide: NgpDialogTitleToken, useExisting: NgpDialogTitle }],
+                    host: {
+                        '[id]': 'id()',
+                    },
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLXRpdGxlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nLXByaW1pdGl2ZXMvZGlhbG9nL3NyYy9kaWFsb2ctdGl0bGUvZGlhbG9nLXRpdGxlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNqRCxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7O0FBUTNELE1BQU0sT0FBTyxjQUFjO0lBTjNCO1FBT0U7O1dBRUc7UUFDTSxPQUFFLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDLENBQUM7S0FDbkQ7OEdBTFksY0FBYztrR0FBZCxjQUFjLDBMQUZkLENBQUMsRUFBRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsV0FBVyxFQUFFLGNBQWMsRUFBRSxDQUFDOzsyRkFFL0QsY0FBYztrQkFOMUIsU0FBUzttQkFBQztvQkFDVCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFLGtCQUFrQjtvQkFDNUIsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsU0FBUyxFQUFFLENBQUMsRUFBRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsV0FBVyxnQkFBZ0IsRUFBRSxDQUFDO2lCQUMzRSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IMKpIDIwMjQgQW5ndWxhciBQcmltaXRpdmVzLlxuICogaHR0cHM6Ly9naXRodWIuY29tL25nLXByaW1pdGl2ZXMvbmctcHJpbWl0aXZlc1xuICpcbiAqIFRoaXMgc291cmNlIGNvZGUgaXMgbGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSAyLjAgbGljZW5zZSBmb3VuZCBpbiB0aGVcbiAqIExJQ0VOU0UgZmlsZSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBzb3VyY2UgdHJlZS5cbiAqL1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBpbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgdW5pcXVlSWQgfSBmcm9tICduZy1wcmltaXRpdmVzL3V0aWxzJztcbmltcG9ydCB7IE5ncERpYWxvZ1RpdGxlVG9rZW4gfSBmcm9tICcuL2RpYWxvZy10aXRsZS50b2tlbic7XG5cbkBEaXJlY3RpdmUoe1xuICBzdGFuZGFsb25lOiB0cnVlLFxuICBzZWxlY3RvcjogJ1tuZ3BEaWFsb2dUaXRsZV0nLFxuICBleHBvcnRBczogJ25ncERpYWxvZ1RpdGxlJyxcbiAgcHJvdmlkZXJzOiBbeyBwcm92aWRlOiBOZ3BEaWFsb2dUaXRsZVRva2VuLCB1c2VFeGlzdGluZzogTmdwRGlhbG9nVGl0bGUgfV0sXG59KVxuZXhwb3J0IGNsYXNzIE5ncERpYWxvZ1RpdGxlIHtcbiAgLyoqXG4gICAqIFRoZSBpZCBvZiB0aGUgZGlhbG9nIHRpdGxlLlxuICAgKi9cbiAgcmVhZG9ubHkgaWQgPSBpbnB1dCh1bmlxdWVJZCgnbmdwLWRpYWxvZy10aXRsZScpKTtcbn1cbiJdfQ==
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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