@angular/cdk-experimental 16.0.0-next.4 → 16.0.0-rc.0

package/esm2022/popover-edit/table-directives.mjs

@@ -0,0 +1,400 @@
+import { TemplatePortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, NgZone, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { fromEvent, fromEventPattern, merge, Subject } from 'rxjs';
+import { filter, map, mapTo, share, startWith, takeUntil, throttleTime, withLatestFrom, } from 'rxjs/operators';
+import { CELL_SELECTOR, EDIT_PANE_CLASS, EDIT_PANE_SELECTOR, ROW_SELECTOR } from './constants';
+import { EditEventDispatcher } from './edit-event-dispatcher';
+import { EditServices } from './edit-services';
+import { FocusDispatcher } from './focus-dispatcher';
+import { FocusEscapeNotifierFactory, } from './focus-escape-notifier';
+import { closest } from './polyfill';
+import * as i0 from "@angular/core";
+import * as i1 from "./edit-event-dispatcher";
+import * as i2 from "./focus-dispatcher";
+import * as i3 from "./edit-services";
+import * as i4 from "./focus-escape-notifier";
+/** Used for rate-limiting mousemove events. */
+const MOUSE_MOVE_THROTTLE_TIME_MS = 10;
+/**
+ * A directive that must be attached to enable editability on a table.
+ * It is responsible for setting up delegated event handlers and providing the
+ * EditEventDispatcher service for use by the other edit directives.
+ */
+class CdkEditable {
+    constructor(elementRef, editEventDispatcher, focusDispatcher, ngZone) {
+        this.elementRef = elementRef;
+        this.editEventDispatcher = editEventDispatcher;
+        this.focusDispatcher = focusDispatcher;
+        this.ngZone = ngZone;
+        this.destroyed = new Subject();
+    }
+    ngAfterViewInit() {
+        this._listenForTableEvents();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    _listenForTableEvents() {
+        const element = this.elementRef.nativeElement;
+        const toClosest = (selector) => map((event) => closest(event.target, selector));
+        this.ngZone.runOutsideAngular(() => {
+            // Track mouse movement over the table to hide/show hover content.
+            fromEvent(element, 'mouseover')
+                .pipe(toClosest(ROW_SELECTOR), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.hovering);
+            fromEvent(element, 'mouseleave')
+                .pipe(mapTo(null), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.hovering);
+            fromEvent(element, 'mousemove')
+                .pipe(throttleTime(MOUSE_MOVE_THROTTLE_TIME_MS), toClosest(ROW_SELECTOR), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.mouseMove);
+            // Track focus within the table to hide/show/make focusable hover content.
+            fromEventPattern(handler => element.addEventListener('focus', handler, true), handler => element.removeEventListener('focus', handler, true))
+                .pipe(toClosest(ROW_SELECTOR), share(), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.focused);
+            merge(fromEventPattern(handler => element.addEventListener('blur', handler, true), handler => element.removeEventListener('blur', handler, true)), fromEvent(element, 'keydown').pipe(filter(event => event.key === 'Escape')))
+                .pipe(mapTo(null), share(), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.focused);
+            // Keep track of rows within the table. This is used to know which rows with hover content
+            // are first or last in the table. They are kept focusable in case focus enters from above
+            // or below the table.
+            this.ngZone.onStable
+                .pipe(
+            // Optimization: ignore dom changes while focus is within the table as we already
+            // ensure that rows above and below the focused/active row are tabbable.
+            withLatestFrom(this.editEventDispatcher.editingOrFocused), filter(([_, activeRow]) => activeRow == null), map(() => element.querySelectorAll(ROW_SELECTOR)), share(), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.allRows);
+            fromEvent(element, 'keydown')
+                .pipe(filter(event => event.key === 'Enter'), toClosest(CELL_SELECTOR), takeUntil(this.destroyed))
+                .subscribe(this.editEventDispatcher.editing);
+            // Keydown must be used here or else key auto-repeat does not work properly on some platforms.
+            fromEvent(element, 'keydown')
+                .pipe(takeUntil(this.destroyed))
+                .subscribe(this.focusDispatcher.keyObserver);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkEditable, deps: [{ token: i0.ElementRef }, { token: i1.EditEventDispatcher }, { token: i2.FocusDispatcher }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.7", type: CdkEditable, selector: "table[editable], cdk-table[editable], mat-table[editable]", providers: [EditEventDispatcher, EditServices], ngImport: i0 }); }
+}
+export { CdkEditable };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkEditable, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'table[editable], cdk-table[editable], mat-table[editable]',
+                    providers: [EditEventDispatcher, EditServices],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.EditEventDispatcher }, { type: i2.FocusDispatcher }, { type: i0.NgZone }]; } });
+const POPOVER_EDIT_HOST_BINDINGS = {
+    '[attr.tabindex]': 'disabled ? null : 0',
+    'class': 'cdk-popover-edit-cell',
+    '[attr.aria-haspopup]': '!disabled',
+};
+const POPOVER_EDIT_INPUTS = [
+    'template: cdkPopoverEdit',
+    'context: cdkPopoverEditContext',
+    'colspan: cdkPopoverEditColspan',
+    'disabled: cdkPopoverEditDisabled',
+];
+/**
+ * Attaches an ng-template to a cell and shows it when instructed to by the
+ * EditEventDispatcher service.
+ * Makes the cell focusable.
+ */
+class CdkPopoverEdit {
+    /**
+     * Specifies that the popup should cover additional table cells before and/or after
+     * this one.
+     */
+    get colspan() {
+        return this._colspan;
+    }
+    set colspan(value) {
+        this._colspan = value;
+        // Recompute positioning when the colspan changes.
+        if (this.overlayRef) {
+            this.overlayRef.updatePositionStrategy(this._getPositionStrategy());
+            if (this.overlayRef.hasAttached()) {
+                this._updateOverlaySize();
+            }
+        }
+    }
+    /** Whether popover edit is disabled for this cell. */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = value;
+        if (value) {
+            this.services.editEventDispatcher.doneEditingCell(this.elementRef.nativeElement);
+            this.services.editEventDispatcher.disabledCells.set(this.elementRef.nativeElement, true);
+        }
+        else {
+            this.services.editEventDispatcher.disabledCells.delete(this.elementRef.nativeElement);
+        }
+    }
+    constructor(services, elementRef, viewContainerRef) {
+        this.services = services;
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        /** The edit lens template shown over the cell on edit. */
+        this.template = null;
+        this._colspan = {};
+        this._disabled = false;
+        this.destroyed = new Subject();
+    }
+    ngAfterViewInit() {
+        this._startListeningToEditEvents();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+        if (this.focusTrap) {
+            this.focusTrap.destroy();
+            this.focusTrap = undefined;
+        }
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+        }
+    }
+    initFocusTrap() {
+        this.focusTrap = this.services.focusTrapFactory.create(this.overlayRef.overlayElement);
+    }
+    closeEditOverlay() {
+        this.services.editEventDispatcher.doneEditingCell(this.elementRef.nativeElement);
+    }
+    panelClass() {
+        return EDIT_PANE_CLASS;
+    }
+    _startListeningToEditEvents() {
+        this.services.editEventDispatcher
+            .editingCell(this.elementRef.nativeElement)
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(open => {
+            if (open && this.template) {
+                if (!this.overlayRef) {
+                    this._createEditOverlay();
+                }
+                this._showEditOverlay();
+            }
+            else if (this.overlayRef) {
+                this._maybeReturnFocusToCell();
+                this.overlayRef.detach();
+            }
+        });
+    }
+    _createEditOverlay() {
+        this.overlayRef = this.services.overlay.create({
+            disposeOnNavigation: true,
+            panelClass: this.panelClass(),
+            positionStrategy: this._getPositionStrategy(),
+            scrollStrategy: this.services.overlay.scrollStrategies.reposition(),
+            direction: this.services.directionality,
+        });
+        this.initFocusTrap();
+        this.overlayRef.overlayElement.setAttribute('aria-role', 'dialog');
+        this.overlayRef.detachments().subscribe(() => this.closeEditOverlay());
+    }
+    _showEditOverlay() {
+        this.overlayRef.attach(new TemplatePortal(this.template, this.viewContainerRef, { $implicit: this.context }));
+        // We have to defer trapping focus, because doing so too early can cause the form inside
+        // the overlay to be submitted immediately if it was opened on an Enter keydown event.
+        this.services.ngZone.runOutsideAngular(() => {
+            setTimeout(() => {
+                this.focusTrap.focusInitialElement();
+            });
+        });
+        // Update the size of the popup initially and on subsequent changes to
+        // scroll position and viewport size.
+        merge(this.services.scrollDispatcher.scrolled(), this.services.viewportRuler.change())
+            .pipe(startWith(null), takeUntil(merge(this.overlayRef.detachments(), this.destroyed)))
+            .subscribe(() => {
+            this._updateOverlaySize();
+        });
+    }
+    _getOverlayCells() {
+        const cell = closest(this.elementRef.nativeElement, CELL_SELECTOR);
+        if (!this._colspan.before && !this._colspan.after) {
+            return [cell];
+        }
+        const row = closest(this.elementRef.nativeElement, ROW_SELECTOR);
+        const rowCells = Array.from(row.querySelectorAll(CELL_SELECTOR));
+        const ownIndex = rowCells.indexOf(cell);
+        return rowCells.slice(ownIndex - (this._colspan.before || 0), ownIndex + (this._colspan.after || 0) + 1);
+    }
+    _getPositionStrategy() {
+        return this.services.positionFactory.positionStrategyForCells(this._getOverlayCells());
+    }
+    _updateOverlaySize() {
+        this.overlayRef.updateSize(this.services.positionFactory.sizeConfigForCells(this._getOverlayCells()));
+    }
+    _maybeReturnFocusToCell() {
+        if (closest(document.activeElement, EDIT_PANE_SELECTOR) === this.overlayRef.overlayElement) {
+            this.elementRef.nativeElement.focus();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkPopoverEdit, deps: [{ token: i3.EditServices }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.7", type: CdkPopoverEdit, selector: "[cdkPopoverEdit]:not([cdkPopoverEditTabOut])", inputs: { template: ["cdkPopoverEdit", "template"], context: ["cdkPopoverEditContext", "context"], colspan: ["cdkPopoverEditColspan", "colspan"], disabled: ["cdkPopoverEditDisabled", "disabled"] }, host: { properties: { "attr.tabindex": "disabled ? null : 0", "attr.aria-haspopup": "!disabled" }, classAttribute: "cdk-popover-edit-cell" }, ngImport: i0 }); }
+}
+export { CdkPopoverEdit };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkPopoverEdit, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkPopoverEdit]:not([cdkPopoverEditTabOut])',
+                    host: POPOVER_EDIT_HOST_BINDINGS,
+                    inputs: POPOVER_EDIT_INPUTS,
+                }]
+        }], ctorParameters: function () { return [{ type: i3.EditServices }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }]; } });
+/**
+ * Attaches an ng-template to a cell and shows it when instructed to by the
+ * EditEventDispatcher service.
+ * Makes the cell focusable.
+ */
+class CdkPopoverEditTabOut extends CdkPopoverEdit {
+    constructor(elementRef, viewContainerRef, services, focusEscapeNotifierFactory) {
+        super(services, elementRef, viewContainerRef);
+        this.focusEscapeNotifierFactory = focusEscapeNotifierFactory;
+        this.focusTrap = undefined;
+    }
+    initFocusTrap() {
+        this.focusTrap = this.focusEscapeNotifierFactory.create(this.overlayRef.overlayElement);
+        this.focusTrap
+            .escapes()
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(direction => {
+            this.services.editEventDispatcher.editRef?.blur();
+            this.services.focusDispatcher.moveFocusHorizontally(closest(this.elementRef.nativeElement, CELL_SELECTOR), direction === 0 /* FocusEscapeNotifierDirection.START */ ? -1 : 1);
+            this.closeEditOverlay();
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkPopoverEditTabOut, deps: [{ token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i3.EditServices }, { token: i4.FocusEscapeNotifierFactory }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.7", type: CdkPopoverEditTabOut, selector: "[cdkPopoverEdit][cdkPopoverEditTabOut]", inputs: { template: ["cdkPopoverEdit", "template"], context: ["cdkPopoverEditContext", "context"], colspan: ["cdkPopoverEditColspan", "colspan"], disabled: ["cdkPopoverEditDisabled", "disabled"] }, host: { properties: { "attr.tabindex": "disabled ? null : 0", "attr.aria-haspopup": "!disabled" }, classAttribute: "cdk-popover-edit-cell" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { CdkPopoverEditTabOut };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkPopoverEditTabOut, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkPopoverEdit][cdkPopoverEditTabOut]',
+                    host: POPOVER_EDIT_HOST_BINDINGS,
+                    inputs: POPOVER_EDIT_INPUTS,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i3.EditServices }, { type: i4.FocusEscapeNotifierFactory }]; } });
+/**
+ * A structural directive that shows its contents when the table row containing
+ * it is hovered or when an element in the row has focus.
+ */
+class CdkRowHoverContent {
+    constructor(services, elementRef, templateRef, viewContainerRef) {
+        this.services = services;
+        this.elementRef = elementRef;
+        this.templateRef = templateRef;
+        this.viewContainerRef = viewContainerRef;
+        this.destroyed = new Subject();
+        this.viewRef = null;
+    }
+    ngAfterViewInit() {
+        this._row = closest(this.elementRef.nativeElement, ROW_SELECTOR);
+        this.services.editEventDispatcher.registerRowWithHoverContent(this._row);
+        this._listenForHoverAndFocusEvents();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+        if (this.viewRef) {
+            this.viewRef.destroy();
+        }
+        if (this._row) {
+            this.services.editEventDispatcher.deregisterRowWithHoverContent(this._row);
+        }
+    }
+    /**
+     * Called immediately after the hover content is created and added to the dom.
+     * In the CDK version, this is a noop but subclasses such as MatRowHoverContent use this
+     * to prepare/style the inserted element.
+     */
+    initElement(_) { }
+    /**
+     * Called when the hover content needs to be focusable to preserve a reasonable tab ordering
+     * but should not yet be shown.
+     */
+    makeElementHiddenButFocusable(element) {
+        element.style.opacity = '0';
+    }
+    /**
+     * Called when the hover content needs to be focusable to preserve a reasonable tab ordering
+     * but should not yet be shown.
+     */
+    makeElementVisible(element) {
+        element.style.opacity = '';
+    }
+    _listenForHoverAndFocusEvents() {
+        this.services.editEventDispatcher
+            .hoverOrFocusOnRow(this._row)
+            .pipe(takeUntil(this.destroyed))
+            .subscribe(eventState => {
+            // When in FOCUSABLE state, add the hover content to the dom but make it transparent so
+            // that it is in the tab order relative to the currently focused row.
+            if (eventState === 2 /* HoverContentState.ON */ || eventState === 1 /* HoverContentState.FOCUSABLE */) {
+                if (!this.viewRef) {
+                    this.viewRef = this.viewContainerRef.createEmbeddedView(this.templateRef, {});
+                    this.initElement(this.viewRef.rootNodes[0]);
+                    this.viewRef.markForCheck();
+                }
+                else if (this.viewContainerRef.indexOf(this.viewRef) === -1) {
+                    this.viewContainerRef.insert(this.viewRef);
+                    this.viewRef.markForCheck();
+                }
+                if (eventState === 2 /* HoverContentState.ON */) {
+                    this.makeElementVisible(this.viewRef.rootNodes[0]);
+                }
+                else {
+                    this.makeElementHiddenButFocusable(this.viewRef.rootNodes[0]);
+                }
+            }
+            else if (this.viewRef) {
+                this.viewContainerRef.detach(this.viewContainerRef.indexOf(this.viewRef));
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkRowHoverContent, deps: [{ token: i3.EditServices }, { token: i0.ElementRef }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.7", type: CdkRowHoverContent, selector: "[cdkRowHoverContent]", ngImport: i0 }); }
+}
+export { CdkRowHoverContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkRowHoverContent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkRowHoverContent]',
+                }]
+        }], ctorParameters: function () { return [{ type: i3.EditServices }, { type: i0.ElementRef }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; } });
+/**
+ * Opens the closest edit popover to this element, whether it's associated with this exact
+ * element or an ancestor element.
+ */
+class CdkEditOpen {
+    constructor(elementRef, editEventDispatcher) {
+        this.elementRef = elementRef;
+        this.editEventDispatcher = editEventDispatcher;
+        const nativeElement = elementRef.nativeElement;
+        // Prevent accidental form submits.
+        if (nativeElement.nodeName === 'BUTTON' && !nativeElement.getAttribute('type')) {
+            nativeElement.setAttribute('type', 'button');
+        }
+    }
+    openEdit(evt) {
+        this.editEventDispatcher.editing.next(closest(this.elementRef.nativeElement, CELL_SELECTOR));
+        evt.stopPropagation();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkEditOpen, deps: [{ token: i0.ElementRef }, { token: i1.EditEventDispatcher }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0-next.7", type: CdkEditOpen, selector: "[cdkEditOpen]", host: { listeners: { "click": "openEdit($event)" } }, ngImport: i0 }); }
+}
+export { CdkEditOpen };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0-next.7", ngImport: i0, type: CdkEditOpen, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cdkEditOpen]',
+                    host: {
+                        '(click)': 'openEdit($event)',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.EditEventDispatcher }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-directives.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/popover-edit/table-directives.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 */\nimport {FocusTrap} from '@angular/cdk/a11y';\nimport {OverlayRef, PositionStrategy} from '@angular/cdk/overlay';\nimport {TemplatePortal} from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  NgZone,\n  OnDestroy,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport {fromEvent, fromEventPattern, merge, Subject} from 'rxjs';\nimport {\n  filter,\n  map,\n  mapTo,\n  share,\n  startWith,\n  takeUntil,\n  throttleTime,\n  withLatestFrom,\n} from 'rxjs/operators';\n\nimport {CELL_SELECTOR, EDIT_PANE_CLASS, EDIT_PANE_SELECTOR, ROW_SELECTOR} from './constants';\nimport {EditEventDispatcher, HoverContentState} from './edit-event-dispatcher';\nimport {EditServices} from './edit-services';\nimport {FocusDispatcher} from './focus-dispatcher';\nimport {\n  FocusEscapeNotifier,\n  FocusEscapeNotifierDirection,\n  FocusEscapeNotifierFactory,\n} from './focus-escape-notifier';\nimport {closest} from './polyfill';\nimport {EditRef} from './edit-ref';\n\n/**\n * Describes the number of columns before and after the originating cell that the\n * edit popup should span. In left to right locales, before means left and after means\n * right. In right to left locales before means right and after means left.\n */\nexport interface CdkPopoverEditColspan {\n  before?: number;\n  after?: number;\n}\n\n/** Used for rate-limiting mousemove events. */\nconst MOUSE_MOVE_THROTTLE_TIME_MS = 10;\n\n/**\n * A directive that must be attached to enable editability on a table.\n * It is responsible for setting up delegated event handlers and providing the\n * EditEventDispatcher service for use by the other edit directives.\n */\n@Directive({\n  selector: 'table[editable], cdk-table[editable], mat-table[editable]',\n  providers: [EditEventDispatcher, EditServices],\n})\nexport class CdkEditable implements AfterViewInit, OnDestroy {\n  protected readonly destroyed = new Subject<void>();\n\n  constructor(\n    protected readonly elementRef: ElementRef,\n    protected readonly editEventDispatcher: EditEventDispatcher<EditRef<unknown>>,\n    protected readonly focusDispatcher: FocusDispatcher,\n    protected readonly ngZone: NgZone,\n  ) {}\n\n  ngAfterViewInit(): void {\n    this._listenForTableEvents();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed.next();\n    this.destroyed.complete();\n  }\n\n  private _listenForTableEvents(): void {\n    const element = this.elementRef.nativeElement;\n    const toClosest = (selector: string) =>\n      map((event: UIEvent) => closest(event.target, selector));\n\n    this.ngZone.runOutsideAngular(() => {\n      // Track mouse movement over the table to hide/show hover content.\n      fromEvent<MouseEvent>(element, 'mouseover')\n        .pipe(toClosest(ROW_SELECTOR), takeUntil(this.destroyed))\n        .subscribe(this.editEventDispatcher.hovering);\n      fromEvent<MouseEvent>(element, 'mouseleave')\n        .pipe(mapTo(null), takeUntil(this.destroyed))\n        .subscribe(this.editEventDispatcher.hovering);\n      fromEvent<MouseEvent>(element, 'mousemove')\n        .pipe(\n          throttleTime(MOUSE_MOVE_THROTTLE_TIME_MS),\n          toClosest(ROW_SELECTOR),\n          takeUntil(this.destroyed),\n        )\n        .subscribe(this.editEventDispatcher.mouseMove);\n\n      // Track focus within the table to hide/show/make focusable hover content.\n      fromEventPattern<FocusEvent>(\n        handler => element.addEventListener('focus', handler, true),\n        handler => element.removeEventListener('focus', handler, true),\n      )\n        .pipe(toClosest(ROW_SELECTOR), share(), takeUntil(this.destroyed))\n        .subscribe(this.editEventDispatcher.focused);\n\n      merge(\n        fromEventPattern<FocusEvent>(\n          handler => element.addEventListener('blur', handler, true),\n          handler => element.removeEventListener('blur', handler, true),\n        ),\n        fromEvent<KeyboardEvent>(element, 'keydown').pipe(filter(event => event.key === 'Escape')),\n      )\n        .pipe(mapTo(null), share(), takeUntil(this.destroyed))\n        .subscribe(this.editEventDispatcher.focused);\n\n      // Keep track of rows within the table. This is used to know which rows with hover content\n      // are first or last in the table. They are kept focusable in case focus enters from above\n      // or below the table.\n      this.ngZone.onStable\n        .pipe(\n          // Optimization: ignore dom changes while focus is within the table as we already\n          // ensure that rows above and below the focused/active row are tabbable.\n          withLatestFrom(this.editEventDispatcher.editingOrFocused),\n          filter(([_, activeRow]) => activeRow == null),\n          map(() => element.querySelectorAll(ROW_SELECTOR)),\n          share(),\n          takeUntil(this.destroyed),\n        )\n        .subscribe(this.editEventDispatcher.allRows);\n\n      fromEvent<KeyboardEvent>(element, 'keydown')\n        .pipe(\n          filter(event => event.key === 'Enter'),\n          toClosest(CELL_SELECTOR),\n          takeUntil(this.destroyed),\n        )\n        .subscribe(this.editEventDispatcher.editing);\n\n      // Keydown must be used here or else key auto-repeat does not work properly on some platforms.\n      fromEvent<KeyboardEvent>(element, 'keydown')\n        .pipe(takeUntil(this.destroyed))\n        .subscribe(this.focusDispatcher.keyObserver);\n    });\n  }\n}\n\nconst POPOVER_EDIT_HOST_BINDINGS = {\n  '[attr.tabindex]': 'disabled ? null : 0',\n  'class': 'cdk-popover-edit-cell',\n  '[attr.aria-haspopup]': '!disabled',\n};\n\nconst POPOVER_EDIT_INPUTS = [\n  'template: cdkPopoverEdit',\n  'context: cdkPopoverEditContext',\n  'colspan: cdkPopoverEditColspan',\n  'disabled: cdkPopoverEditDisabled',\n];\n\n/**\n * Attaches an ng-template to a cell and shows it when instructed to by the\n * EditEventDispatcher service.\n * Makes the cell focusable.\n */\n@Directive({\n  selector: '[cdkPopoverEdit]:not([cdkPopoverEditTabOut])',\n  host: POPOVER_EDIT_HOST_BINDINGS,\n  inputs: POPOVER_EDIT_INPUTS,\n})\nexport class CdkPopoverEdit<C> implements AfterViewInit, OnDestroy {\n  /** The edit lens template shown over the cell on edit. */\n  template: TemplateRef<any> | null = null;\n\n  /**\n   * Implicit context to pass along to the template. Can be omitted if the template\n   * is defined within the cell.\n   */\n  context?: C;\n\n  /**\n   * Specifies that the popup should cover additional table cells before and/or after\n   * this one.\n   */\n  get colspan(): CdkPopoverEditColspan {\n    return this._colspan;\n  }\n  set colspan(value: CdkPopoverEditColspan) {\n    this._colspan = value;\n\n    // Recompute positioning when the colspan changes.\n    if (this.overlayRef) {\n      this.overlayRef.updatePositionStrategy(this._getPositionStrategy());\n\n      if (this.overlayRef.hasAttached()) {\n        this._updateOverlaySize();\n      }\n    }\n  }\n  private _colspan: CdkPopoverEditColspan = {};\n\n  /** Whether popover edit is disabled for this cell. */\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: boolean) {\n    this._disabled = value;\n\n    if (value) {\n      this.services.editEventDispatcher.doneEditingCell(this.elementRef.nativeElement!);\n      this.services.editEventDispatcher.disabledCells.set(this.elementRef.nativeElement!, true);\n    } else {\n      this.services.editEventDispatcher.disabledCells.delete(this.elementRef.nativeElement!);\n    }\n  }\n  private _disabled = false;\n\n  protected focusTrap?: FocusTrap;\n  protected overlayRef?: OverlayRef;\n  protected readonly destroyed = new Subject<void>();\n\n  constructor(\n    protected readonly services: EditServices,\n    protected readonly elementRef: ElementRef,\n    protected readonly viewContainerRef: ViewContainerRef,\n  ) {}\n\n  ngAfterViewInit(): void {\n    this._startListeningToEditEvents();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed.next();\n    this.destroyed.complete();\n\n    if (this.focusTrap) {\n      this.focusTrap.destroy();\n      this.focusTrap = undefined;\n    }\n\n    if (this.overlayRef) {\n      this.overlayRef.dispose();\n    }\n  }\n\n  protected initFocusTrap(): void {\n    this.focusTrap = this.services.focusTrapFactory.create(this.overlayRef!.overlayElement);\n  }\n\n  protected closeEditOverlay(): void {\n    this.services.editEventDispatcher.doneEditingCell(this.elementRef.nativeElement!);\n  }\n\n  protected panelClass(): string {\n    return EDIT_PANE_CLASS;\n  }\n\n  private _startListeningToEditEvents(): void {\n    this.services.editEventDispatcher\n      .editingCell(this.elementRef.nativeElement!)\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(open => {\n        if (open && this.template) {\n          if (!this.overlayRef) {\n            this._createEditOverlay();\n          }\n\n          this._showEditOverlay();\n        } else if (this.overlayRef) {\n          this._maybeReturnFocusToCell();\n\n          this.overlayRef.detach();\n        }\n      });\n  }\n\n  private _createEditOverlay(): void {\n    this.overlayRef = this.services.overlay.create({\n      disposeOnNavigation: true,\n      panelClass: this.panelClass(),\n      positionStrategy: this._getPositionStrategy(),\n      scrollStrategy: this.services.overlay.scrollStrategies.reposition(),\n      direction: this.services.directionality,\n    });\n\n    this.initFocusTrap();\n    this.overlayRef.overlayElement.setAttribute('aria-role', 'dialog');\n\n    this.overlayRef.detachments().subscribe(() => this.closeEditOverlay());\n  }\n\n  private _showEditOverlay(): void {\n    this.overlayRef!.attach(\n      new TemplatePortal(this.template!, this.viewContainerRef, {$implicit: this.context}),\n    );\n\n    // We have to defer trapping focus, because doing so too early can cause the form inside\n    // the overlay to be submitted immediately if it was opened on an Enter keydown event.\n    this.services.ngZone.runOutsideAngular(() => {\n      setTimeout(() => {\n        this.focusTrap!.focusInitialElement();\n      });\n    });\n\n    // Update the size of the popup initially and on subsequent changes to\n    // scroll position and viewport size.\n    merge(this.services.scrollDispatcher.scrolled(), this.services.viewportRuler.change())\n      .pipe(startWith(null), takeUntil(merge(this.overlayRef!.detachments(), this.destroyed)))\n      .subscribe(() => {\n        this._updateOverlaySize();\n      });\n  }\n\n  private _getOverlayCells(): HTMLElement[] {\n    const cell = closest(this.elementRef.nativeElement!, CELL_SELECTOR) as HTMLElement;\n\n    if (!this._colspan.before && !this._colspan.after) {\n      return [cell];\n    }\n\n    const row = closest(this.elementRef.nativeElement!, ROW_SELECTOR)!;\n    const rowCells = Array.from(row.querySelectorAll(CELL_SELECTOR)) as HTMLElement[];\n    const ownIndex = rowCells.indexOf(cell);\n\n    return rowCells.slice(\n      ownIndex - (this._colspan.before || 0),\n      ownIndex + (this._colspan.after || 0) + 1,\n    );\n  }\n\n  private _getPositionStrategy(): PositionStrategy {\n    return this.services.positionFactory.positionStrategyForCells(this._getOverlayCells());\n  }\n\n  private _updateOverlaySize(): void {\n    this.overlayRef!.updateSize(\n      this.services.positionFactory.sizeConfigForCells(this._getOverlayCells()),\n    );\n  }\n\n  private _maybeReturnFocusToCell(): void {\n    if (closest(document.activeElement, EDIT_PANE_SELECTOR) === this.overlayRef!.overlayElement) {\n      this.elementRef.nativeElement!.focus();\n    }\n  }\n}\n\n/**\n * Attaches an ng-template to a cell and shows it when instructed to by the\n * EditEventDispatcher service.\n * Makes the cell focusable.\n */\n@Directive({\n  selector: '[cdkPopoverEdit][cdkPopoverEditTabOut]',\n  host: POPOVER_EDIT_HOST_BINDINGS,\n  inputs: POPOVER_EDIT_INPUTS,\n})\nexport class CdkPopoverEditTabOut<C> extends CdkPopoverEdit<C> {\n  protected override focusTrap?: FocusEscapeNotifier = undefined;\n\n  constructor(\n    elementRef: ElementRef,\n    viewContainerRef: ViewContainerRef,\n    services: EditServices,\n    protected readonly focusEscapeNotifierFactory: FocusEscapeNotifierFactory,\n  ) {\n    super(services, elementRef, viewContainerRef);\n  }\n\n  protected override initFocusTrap(): void {\n    this.focusTrap = this.focusEscapeNotifierFactory.create(this.overlayRef!.overlayElement);\n\n    this.focusTrap\n      .escapes()\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(direction => {\n        this.services.editEventDispatcher.editRef?.blur();\n        this.services.focusDispatcher.moveFocusHorizontally(\n          closest(this.elementRef.nativeElement!, CELL_SELECTOR) as HTMLElement,\n          direction === FocusEscapeNotifierDirection.START ? -1 : 1,\n        );\n\n        this.closeEditOverlay();\n      });\n  }\n}\n\n/**\n * A structural directive that shows its contents when the table row containing\n * it is hovered or when an element in the row has focus.\n */\n@Directive({\n  selector: '[cdkRowHoverContent]',\n})\nexport class CdkRowHoverContent implements AfterViewInit, OnDestroy {\n  protected readonly destroyed = new Subject<void>();\n  protected viewRef: EmbeddedViewRef<any> | null = null;\n\n  private _row?: Element;\n\n  constructor(\n    protected readonly services: EditServices,\n    protected readonly elementRef: ElementRef,\n    protected readonly templateRef: TemplateRef<any>,\n    protected readonly viewContainerRef: ViewContainerRef,\n  ) {}\n\n  ngAfterViewInit(): void {\n    this._row = closest(this.elementRef.nativeElement!, ROW_SELECTOR)!;\n\n    this.services.editEventDispatcher.registerRowWithHoverContent(this._row);\n    this._listenForHoverAndFocusEvents();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed.next();\n    this.destroyed.complete();\n\n    if (this.viewRef) {\n      this.viewRef.destroy();\n    }\n\n    if (this._row) {\n      this.services.editEventDispatcher.deregisterRowWithHoverContent(this._row);\n    }\n  }\n\n  /**\n   * Called immediately after the hover content is created and added to the dom.\n   * In the CDK version, this is a noop but subclasses such as MatRowHoverContent use this\n   * to prepare/style the inserted element.\n   */\n  protected initElement(_: HTMLElement): void {}\n\n  /**\n   * Called when the hover content needs to be focusable to preserve a reasonable tab ordering\n   * but should not yet be shown.\n   */\n  protected makeElementHiddenButFocusable(element: HTMLElement): void {\n    element.style.opacity = '0';\n  }\n\n  /**\n   * Called when the hover content needs to be focusable to preserve a reasonable tab ordering\n   * but should not yet be shown.\n   */\n  protected makeElementVisible(element: HTMLElement): void {\n    element.style.opacity = '';\n  }\n\n  private _listenForHoverAndFocusEvents(): void {\n    this.services.editEventDispatcher\n      .hoverOrFocusOnRow(this._row!)\n      .pipe(takeUntil(this.destroyed))\n      .subscribe(eventState => {\n        // When in FOCUSABLE state, add the hover content to the dom but make it transparent so\n        // that it is in the tab order relative to the currently focused row.\n\n        if (eventState === HoverContentState.ON || eventState === HoverContentState.FOCUSABLE) {\n          if (!this.viewRef) {\n            this.viewRef = this.viewContainerRef.createEmbeddedView(this.templateRef, {});\n            this.initElement(this.viewRef.rootNodes[0] as HTMLElement);\n            this.viewRef.markForCheck();\n          } else if (this.viewContainerRef.indexOf(this.viewRef) === -1) {\n            this.viewContainerRef.insert(this.viewRef!);\n            this.viewRef.markForCheck();\n          }\n\n          if (eventState === HoverContentState.ON) {\n            this.makeElementVisible(this.viewRef.rootNodes[0] as HTMLElement);\n          } else {\n            this.makeElementHiddenButFocusable(this.viewRef.rootNodes[0] as HTMLElement);\n          }\n        } else if (this.viewRef) {\n          this.viewContainerRef.detach(this.viewContainerRef.indexOf(this.viewRef));\n        }\n      });\n  }\n}\n\n/**\n * Opens the closest edit popover to this element, whether it's associated with this exact\n * element or an ancestor element.\n */\n@Directive({\n  selector: '[cdkEditOpen]',\n  host: {\n    '(click)': 'openEdit($event)',\n  },\n})\nexport class CdkEditOpen {\n  constructor(\n    protected readonly elementRef: ElementRef<HTMLElement>,\n    protected readonly editEventDispatcher: EditEventDispatcher<EditRef<unknown>>,\n  ) {\n    const nativeElement = elementRef.nativeElement;\n\n    // Prevent accidental form submits.\n    if (nativeElement.nodeName === 'BUTTON' && !nativeElement.getAttribute('type')) {\n      nativeElement.setAttribute('type', 'button');\n    }\n  }\n\n  openEdit(evt: Event): void {\n    this.editEventDispatcher.editing.next(closest(this.elementRef.nativeElement!, CELL_SELECTOR));\n    evt.stopPropagation();\n  }\n}\n"]}