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

package/esm2020/popover-edit/edit-event-dispatcher.mjs

@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable, NgZone } from '@angular/core';
+import { combineLatest, Observable, pipe, Subject } from 'rxjs';
+import { audit, auditTime, debounceTime, distinctUntilChanged, filter, map, skip, startWith, shareReplay, } from 'rxjs/operators';
+import { CELL_SELECTOR, ROW_SELECTOR } from './constants';
+import { closest } from './polyfill';
+import * as i0 from "@angular/core";
+/** The delay applied to mouse events before hiding or showing hover content. */
+const MOUSE_EVENT_DELAY_MS = 40;
+/** The delay for reacting to focus/blur changes. */
+const FOCUS_DELAY = 0;
+// Note: this class is generic, rather than referencing EditRef directly, in order to avoid
+// circular imports. If we were to reference it here, importing the registry into the
+// class that is registering itself will introduce a circular import.
+/**
+ * Service for sharing delegated events and state for triggering table edits.
+ */
+export class EditEventDispatcher {
+    constructor(_ngZone) {
+        this._ngZone = _ngZone;
+        /** A subject that indicates which table cell is currently editing (unless it is disabled). */
+        this.editing = new Subject();
+        /** A subject that indicates which table row is currently hovered. */
+        this.hovering = new Subject();
+        /** A subject that indicates which table row currently contains focus. */
+        this.focused = new Subject();
+        /** A subject that indicates all elements in the table matching ROW_SELECTOR. */
+        this.allRows = new Subject();
+        /** A subject that emits mouse move events from the table indicating the targeted row. */
+        this.mouseMove = new Subject();
+        // TODO: Use WeakSet once IE11 support is dropped.
+        /**
+         * Tracks the currently disabled editable cells - edit calls will be ignored
+         * for these cells.
+         */
+        this.disabledCells = new WeakMap();
+        this._editRef = null;
+        // Optimization: Precompute common pipeable operators used per row/cell.
+        this._distinctUntilChanged = distinctUntilChanged();
+        this._startWithNull = startWith(null);
+        this._distinctShare = pipe(this._distinctUntilChanged, shareReplay(1));
+        this._startWithNullDistinct = pipe(this._startWithNull, this._distinctUntilChanged);
+        this.editingAndEnabled = this.editing.pipe(filter(cell => cell == null || !this.disabledCells.has(cell)), shareReplay(1));
+        /** An observable that emits the row containing focus or an active edit. */
+        this.editingOrFocused = combineLatest([
+            this.editingAndEnabled.pipe(map(cell => closest(cell, ROW_SELECTOR)), this._startWithNull),
+            this.focused.pipe(this._startWithNull),
+        ]).pipe(map(([editingRow, focusedRow]) => focusedRow || editingRow), this._distinctUntilChanged, auditTime(FOCUS_DELAY), // Use audit to skip over blur events to the next focused element.
+        this._distinctUntilChanged, shareReplay(1));
+        /** Tracks rows that contain hover content with a reference count. */
+        this._rowsWithHoverContent = new WeakMap();
+        /** The table cell that has an active edit lens (or null). */
+        this._currentlyEditing = null;
+        /** The combined set of row hover content states organized by row. */
+        this._hoveredContentStateDistinct = combineLatest([
+            this._getFirstRowWithHoverContent(),
+            this._getLastRowWithHoverContent(),
+            this.editingOrFocused,
+            this.hovering.pipe(distinctUntilChanged(), audit(row => this.mouseMove.pipe(filter(mouseMoveRow => row === mouseMoveRow), this._startWithNull, debounceTime(MOUSE_EVENT_DELAY_MS))), this._startWithNullDistinct),
+        ]).pipe(skip(1), // Skip the initial emission of [null, null, null, null].
+        map(computeHoverContentState), distinctUntilChanged(areMapEntriesEqual), 
+        // Optimization: Enter the zone before shareReplay so that we trigger a single
+        // ApplicationRef.tick for all row updates.
+        this._enterZone(), shareReplay(1));
+        this._editingAndEnabledDistinct = this.editingAndEnabled.pipe(distinctUntilChanged(), this._enterZone(), shareReplay(1));
+        // Optimization: Share row events observable with subsequent callers.
+        // At startup, calls will be sequential by row.
+        this._lastSeenRow = null;
+        this._lastSeenRowHoverOrFocus = null;
+        this._editingAndEnabledDistinct.subscribe(cell => {
+            this._currentlyEditing = cell;
+        });
+    }
+    /** The EditRef for the currently active edit lens (if any). */
+    get editRef() {
+        return this._editRef;
+    }
+    /**
+     * Gets an Observable that emits true when the specified element's cell
+     * is editing and false when not.
+     */
+    editingCell(element) {
+        let cell = null;
+        return this._editingAndEnabledDistinct.pipe(map(editCell => editCell === (cell || (cell = closest(element, CELL_SELECTOR)))), this._distinctUntilChanged);
+    }
+    /**
+     * Stops editing for the specified cell. If the specified cell is not the current
+     * edit cell, does nothing.
+     */
+    doneEditingCell(element) {
+        const cell = closest(element, CELL_SELECTOR);
+        if (this._currentlyEditing === cell) {
+            this.editing.next(null);
+        }
+    }
+    /** Sets the currently active EditRef. */
+    setActiveEditRef(ref) {
+        this._editRef = ref;
+    }
+    /** Unsets the currently active EditRef, if the specified editRef is active. */
+    unsetActiveEditRef(ref) {
+        if (this._editRef !== ref) {
+            return;
+        }
+        this._editRef = null;
+    }
+    /** Adds the specified table row to be tracked for first/last row comparisons. */
+    registerRowWithHoverContent(row) {
+        this._rowsWithHoverContent.set(row, (this._rowsWithHoverContent.get(row) || 0) + 1);
+    }
+    /**
+     * Reference decrements and ultimately removes the specified table row from first/last row
+     * comparisons.
+     */
+    deregisterRowWithHoverContent(row) {
+        const refCount = this._rowsWithHoverContent.get(row) || 0;
+        if (refCount <= 1) {
+            this._rowsWithHoverContent.delete(row);
+        }
+        else {
+            this._rowsWithHoverContent.set(row, refCount - 1);
+        }
+    }
+    /**
+     * Gets an Observable that emits true when the specified element's row
+     * contains the focused element or is being hovered over and false when not.
+     * Hovering is defined as when the mouse has momentarily stopped moving over the cell.
+     */
+    hoverOrFocusOnRow(row) {
+        if (row !== this._lastSeenRow) {
+            this._lastSeenRow = row;
+            this._lastSeenRowHoverOrFocus = this._hoveredContentStateDistinct.pipe(map(state => state.get(row) || 0 /* OFF */), this._distinctShare);
+        }
+        return this._lastSeenRowHoverOrFocus;
+    }
+    /**
+     * RxJS operator that enters the Angular zone, used to reduce boilerplate in
+     * re-entering the zone for stream pipelines.
+     */
+    _enterZone() {
+        return (source) => new Observable(observer => source.subscribe({
+            next: value => this._ngZone.run(() => observer.next(value)),
+            error: err => observer.error(err),
+            complete: () => observer.complete(),
+        }));
+    }
+    _getFirstRowWithHoverContent() {
+        return this._mapAllRowsToSingleRow(rows => {
+            for (let i = 0, row; (row = rows[i]); i++) {
+                if (this._rowsWithHoverContent.has(row)) {
+                    return row;
+                }
+            }
+            return null;
+        });
+    }
+    _getLastRowWithHoverContent() {
+        return this._mapAllRowsToSingleRow(rows => {
+            for (let i = rows.length - 1, row; (row = rows[i]); i--) {
+                if (this._rowsWithHoverContent.has(row)) {
+                    return row;
+                }
+            }
+            return null;
+        });
+    }
+    _mapAllRowsToSingleRow(mapper) {
+        return this.allRows.pipe(map(mapper), this._startWithNullDistinct);
+    }
+}
+EditEventDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditEventDispatcher, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+EditEventDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditEventDispatcher });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditEventDispatcher, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+function computeHoverContentState([firstRow, lastRow, activeRow, hoverRow,]) {
+    const hoverContentState = new Map();
+    // Add focusable rows.
+    for (const focussableRow of [
+        firstRow,
+        lastRow,
+        activeRow && activeRow.previousElementSibling,
+        activeRow && activeRow.nextElementSibling,
+    ]) {
+        if (focussableRow) {
+            hoverContentState.set(focussableRow, 1 /* FOCUSABLE */);
+        }
+    }
+    // Add/overwrite with fully visible rows.
+    for (const onRow of [activeRow, hoverRow]) {
+        if (onRow) {
+            hoverContentState.set(onRow, 2 /* ON */);
+        }
+    }
+    return hoverContentState;
+}
+function areMapEntriesEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    // TODO: use Map.prototype.entries once we're off IE11.
+    for (const aKey of Array.from(a.keys())) {
+        if (b.get(aKey) !== a.get(aKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"edit-event-dispatcher.js","sourceRoot":"","sources":["../../../../../../src/cdk-experimental/popover-edit/edit-event-dispatcher.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injectable, NgZone} from '@angular/core';\nimport {combineLatest, MonoTypeOperatorFunction, Observable, pipe, Subject} from 'rxjs';\nimport {\n  audit,\n  auditTime,\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  skip,\n  startWith,\n  shareReplay,\n} from 'rxjs/operators';\n\nimport {CELL_SELECTOR, ROW_SELECTOR} from './constants';\nimport {closest} from './polyfill';\n\n/** The delay applied to mouse events before hiding or showing hover content. */\nconst MOUSE_EVENT_DELAY_MS = 40;\n\n/** The delay for reacting to focus/blur changes. */\nconst FOCUS_DELAY = 0;\n\n/**\n * The possible states for hover content:\n * OFF - Not rendered.\n * FOCUSABLE - Rendered in the dom and styled for its contents to be focusable but invisible.\n * ON - Rendered and fully visible.\n */\nexport const enum HoverContentState {\n  OFF = 0,\n  FOCUSABLE,\n  ON,\n}\n\n// Note: this class is generic, rather than referencing EditRef directly, in order to avoid\n// circular imports. If we were to reference it here, importing the registry into the\n// class that is registering itself will introduce a circular import.\n\n/**\n * Service for sharing delegated events and state for triggering table edits.\n */\n@Injectable()\nexport class EditEventDispatcher<R> {\n  /** A subject that indicates which table cell is currently editing (unless it is disabled). */\n  readonly editing = new Subject<Element | null>();\n\n  /** A subject that indicates which table row is currently hovered. */\n  readonly hovering = new Subject<Element | null>();\n\n  /** A subject that indicates which table row currently contains focus. */\n  readonly focused = new Subject<Element | null>();\n\n  /** A subject that indicates all elements in the table matching ROW_SELECTOR. */\n  readonly allRows = new Subject<NodeList>();\n\n  /** A subject that emits mouse move events from the table indicating the targeted row. */\n  readonly mouseMove = new Subject<Element | null>();\n\n  // TODO: Use WeakSet once IE11 support is dropped.\n  /**\n   * Tracks the currently disabled editable cells - edit calls will be ignored\n   * for these cells.\n   */\n  readonly disabledCells = new WeakMap<Element, boolean>();\n\n  /** The EditRef for the currently active edit lens (if any). */\n  get editRef(): R | null {\n    return this._editRef;\n  }\n  private _editRef: R | null = null;\n\n  // Optimization: Precompute common pipeable operators used per row/cell.\n  private readonly _distinctUntilChanged = distinctUntilChanged<\n    Element | HoverContentState | boolean | null\n  >();\n  private readonly _startWithNull = startWith<Element | null>(null);\n  private readonly _distinctShare = pipe(\n    this._distinctUntilChanged as MonoTypeOperatorFunction<HoverContentState>,\n    shareReplay(1),\n  );\n  private readonly _startWithNullDistinct = pipe(\n    this._startWithNull,\n    this._distinctUntilChanged as MonoTypeOperatorFunction<Element | null>,\n  );\n\n  readonly editingAndEnabled = this.editing.pipe(\n    filter(cell => cell == null || !this.disabledCells.has(cell)),\n    shareReplay(1),\n  );\n\n  /** An observable that emits the row containing focus or an active edit. */\n  readonly editingOrFocused = combineLatest([\n    this.editingAndEnabled.pipe(\n      map(cell => closest(cell, ROW_SELECTOR)),\n      this._startWithNull,\n    ),\n    this.focused.pipe(this._startWithNull),\n  ]).pipe(\n    map(([editingRow, focusedRow]) => focusedRow || editingRow),\n    this._distinctUntilChanged as MonoTypeOperatorFunction<Element | null>,\n    auditTime(FOCUS_DELAY), // Use audit to skip over blur events to the next focused element.\n    this._distinctUntilChanged as MonoTypeOperatorFunction<Element | null>,\n    shareReplay(1),\n  );\n\n  /** Tracks rows that contain hover content with a reference count. */\n  private _rowsWithHoverContent = new WeakMap<Element, number>();\n\n  /** The table cell that has an active edit lens (or null). */\n  private _currentlyEditing: Element | null = null;\n\n  /** The combined set of row hover content states organized by row. */\n  private readonly _hoveredContentStateDistinct = combineLatest([\n    this._getFirstRowWithHoverContent(),\n    this._getLastRowWithHoverContent(),\n    this.editingOrFocused,\n    this.hovering.pipe(\n      distinctUntilChanged(),\n      audit(row =>\n        this.mouseMove.pipe(\n          filter(mouseMoveRow => row === mouseMoveRow),\n          this._startWithNull,\n          debounceTime(MOUSE_EVENT_DELAY_MS),\n        ),\n      ),\n      this._startWithNullDistinct,\n    ),\n  ]).pipe(\n    skip(1), // Skip the initial emission of [null, null, null, null].\n    map(computeHoverContentState),\n    distinctUntilChanged(areMapEntriesEqual),\n    // Optimization: Enter the zone before shareReplay so that we trigger a single\n    // ApplicationRef.tick for all row updates.\n    this._enterZone(),\n    shareReplay(1),\n  );\n\n  private readonly _editingAndEnabledDistinct = this.editingAndEnabled.pipe(\n    distinctUntilChanged(),\n    this._enterZone(),\n    shareReplay(1),\n  );\n\n  // Optimization: Share row events observable with subsequent callers.\n  // At startup, calls will be sequential by row.\n  private _lastSeenRow: Element | null = null;\n  private _lastSeenRowHoverOrFocus: Observable<HoverContentState> | null = null;\n\n  constructor(private readonly _ngZone: NgZone) {\n    this._editingAndEnabledDistinct.subscribe(cell => {\n      this._currentlyEditing = cell;\n    });\n  }\n\n  /**\n   * Gets an Observable that emits true when the specified element's cell\n   * is editing and false when not.\n   */\n  editingCell(element: Element | EventTarget): Observable<boolean> {\n    let cell: Element | null = null;\n\n    return this._editingAndEnabledDistinct.pipe(\n      map(editCell => editCell === (cell || (cell = closest(element, CELL_SELECTOR)))),\n      this._distinctUntilChanged as MonoTypeOperatorFunction<boolean>,\n    );\n  }\n\n  /**\n   * Stops editing for the specified cell. If the specified cell is not the current\n   * edit cell, does nothing.\n   */\n  doneEditingCell(element: Element | EventTarget): void {\n    const cell = closest(element, CELL_SELECTOR);\n\n    if (this._currentlyEditing === cell) {\n      this.editing.next(null);\n    }\n  }\n\n  /** Sets the currently active EditRef. */\n  setActiveEditRef(ref: R) {\n    this._editRef = ref;\n  }\n\n  /** Unsets the currently active EditRef, if the specified editRef is active. */\n  unsetActiveEditRef(ref: R) {\n    if (this._editRef !== ref) {\n      return;\n    }\n\n    this._editRef = null;\n  }\n\n  /** Adds the specified table row to be tracked for first/last row comparisons. */\n  registerRowWithHoverContent(row: Element): void {\n    this._rowsWithHoverContent.set(row, (this._rowsWithHoverContent.get(row) || 0) + 1);\n  }\n\n  /**\n   * Reference decrements and ultimately removes the specified table row from first/last row\n   * comparisons.\n   */\n  deregisterRowWithHoverContent(row: Element): void {\n    const refCount = this._rowsWithHoverContent.get(row) || 0;\n\n    if (refCount <= 1) {\n      this._rowsWithHoverContent.delete(row);\n    } else {\n      this._rowsWithHoverContent.set(row, refCount - 1);\n    }\n  }\n\n  /**\n   * Gets an Observable that emits true when the specified element's row\n   * contains the focused element or is being hovered over and false when not.\n   * Hovering is defined as when the mouse has momentarily stopped moving over the cell.\n   */\n  hoverOrFocusOnRow(row: Element): Observable<HoverContentState> {\n    if (row !== this._lastSeenRow) {\n      this._lastSeenRow = row;\n      this._lastSeenRowHoverOrFocus = this._hoveredContentStateDistinct.pipe(\n        map(state => state.get(row) || HoverContentState.OFF),\n        this._distinctShare,\n      );\n    }\n\n    return this._lastSeenRowHoverOrFocus!;\n  }\n\n  /**\n   * RxJS operator that enters the Angular zone, used to reduce boilerplate in\n   * re-entering the zone for stream pipelines.\n   */\n  private _enterZone<T>(): MonoTypeOperatorFunction<T> {\n    return (source: Observable<T>) =>\n      new Observable<T>(observer =>\n        source.subscribe({\n          next: value => this._ngZone.run(() => observer.next(value)),\n          error: err => observer.error(err),\n          complete: () => observer.complete(),\n        }),\n      );\n  }\n\n  private _getFirstRowWithHoverContent(): Observable<Element | null> {\n    return this._mapAllRowsToSingleRow(rows => {\n      for (let i = 0, row; (row = rows[i]); i++) {\n        if (this._rowsWithHoverContent.has(row as Element)) {\n          return row as Element;\n        }\n      }\n      return null;\n    });\n  }\n\n  private _getLastRowWithHoverContent(): Observable<Element | null> {\n    return this._mapAllRowsToSingleRow(rows => {\n      for (let i = rows.length - 1, row; (row = rows[i]); i--) {\n        if (this._rowsWithHoverContent.has(row as Element)) {\n          return row as Element;\n        }\n      }\n      return null;\n    });\n  }\n\n  private _mapAllRowsToSingleRow(\n    mapper: (rows: NodeList) => Element | null,\n  ): Observable<Element | null> {\n    return this.allRows.pipe(map(mapper), this._startWithNullDistinct);\n  }\n}\n\nfunction computeHoverContentState([\n  firstRow,\n  lastRow,\n  activeRow,\n  hoverRow,\n]: (Element | null)[]): Map<Element, HoverContentState> {\n  const hoverContentState = new Map<Element, HoverContentState>();\n\n  // Add focusable rows.\n  for (const focussableRow of [\n    firstRow,\n    lastRow,\n    activeRow && activeRow.previousElementSibling,\n    activeRow && activeRow.nextElementSibling,\n  ]) {\n    if (focussableRow) {\n      hoverContentState.set(focussableRow as Element, HoverContentState.FOCUSABLE);\n    }\n  }\n\n  // Add/overwrite with fully visible rows.\n  for (const onRow of [activeRow, hoverRow]) {\n    if (onRow) {\n      hoverContentState.set(onRow, HoverContentState.ON);\n    }\n  }\n\n  return hoverContentState;\n}\n\nfunction areMapEntriesEqual<K, V>(a: Map<K, V>, b: Map<K, V>): boolean {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  // TODO: use Map.prototype.entries once we're off IE11.\n  for (const aKey of Array.from(a.keys())) {\n    if (b.get(aKey) !== a.get(aKey)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"]}

package/esm2020/popover-edit/edit-ref.mjs

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable, Self, NgZone } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { EditEventDispatcher } from './edit-event-dispatcher';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./edit-event-dispatcher";
+/**
+ * Used for communication between the form within the edit lens and the
+ * table that launched it. Provided by CdkEditControl within the lens.
+ */
+export class EditRef {
+    constructor(_form, _editEventDispatcher, _ngZone) {
+        this._form = _form;
+        this._editEventDispatcher = _editEventDispatcher;
+        this._ngZone = _ngZone;
+        /** Emits the final value of this edit instance before closing. */
+        this._finalValueSubject = new Subject();
+        this.finalValue = this._finalValueSubject;
+        /** Emits when the user tabs out of this edit lens before closing. */
+        this._blurredSubject = new Subject();
+        this.blurred = this._blurredSubject;
+        this._editEventDispatcher.setActiveEditRef(this);
+    }
+    /**
+     * Called by the host directive's OnInit hook. Reads the initial state of the
+     * form and overrides it with persisted state from previous openings, if
+     * applicable.
+     */
+    init(previousFormValue) {
+        // Wait for the zone to stabilize before caching the initial value.
+        // This ensures that all form controls have been initialized.
+        this._ngZone.onStable.pipe(take(1)).subscribe(() => {
+            this.updateRevertValue();
+            if (previousFormValue) {
+                this.reset(previousFormValue);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._editEventDispatcher.unsetActiveEditRef(this);
+        this._finalValueSubject.next(this._form.value);
+        this._finalValueSubject.complete();
+    }
+    /** Whether the attached form is in a valid state. */
+    isValid() {
+        return this._form.valid;
+    }
+    /** Set the form's current value as what it will be set to on revert/reset. */
+    updateRevertValue() {
+        this._revertFormValue = this._form.value;
+    }
+    /** Tells the table to close the edit popup. */
+    close() {
+        this._editEventDispatcher.editing.next(null);
+    }
+    /** Notifies the active edit that the user has moved focus out of the lens. */
+    blur() {
+        this._blurredSubject.next();
+    }
+    /**
+     * Resets the form value to the specified value or the previously set
+     * revert value.
+     */
+    reset(value) {
+        this._form.reset(value || this._revertFormValue);
+    }
+}
+EditRef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditRef, deps: [{ token: i1.ControlContainer, self: true }, { token: i2.EditEventDispatcher }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+EditRef.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditRef });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditRef, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.ControlContainer, decorators: [{
+                    type: Self
+                }] }, { type: i2.EditEventDispatcher }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover-edit/edit-services.mjs

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable, NgZone } from '@angular/core';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay } from '@angular/cdk/overlay';
+import { ScrollDispatcher, ViewportRuler } from '@angular/cdk/scrolling';
+import { EditEventDispatcher } from './edit-event-dispatcher';
+import { FocusDispatcher } from './focus-dispatcher';
+import { PopoverEditPositionStrategyFactory } from './popover-edit-position-strategy-factory';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "./edit-event-dispatcher";
+import * as i3 from "./focus-dispatcher";
+import * as i4 from "@angular/cdk/a11y";
+import * as i5 from "@angular/cdk/overlay";
+import * as i6 from "./popover-edit-position-strategy-factory";
+import * as i7 from "@angular/cdk/scrolling";
+/**
+ * Optimization
+ * Collects multiple Injectables into a singleton shared across the table. By reducing the
+ * number of services injected into each CdkPopoverEdit, this saves about 0.023ms of cpu time
+ * and 56 bytes of memory per instance.
+ */
+export class EditServices {
+    constructor(directionality, editEventDispatcher, focusDispatcher, focusTrapFactory, ngZone, overlay, positionFactory, scrollDispatcher, viewportRuler) {
+        this.directionality = directionality;
+        this.editEventDispatcher = editEventDispatcher;
+        this.focusDispatcher = focusDispatcher;
+        this.focusTrapFactory = focusTrapFactory;
+        this.ngZone = ngZone;
+        this.overlay = overlay;
+        this.positionFactory = positionFactory;
+        this.scrollDispatcher = scrollDispatcher;
+        this.viewportRuler = viewportRuler;
+    }
+}
+EditServices.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditServices, deps: [{ token: i1.Directionality }, { token: i2.EditEventDispatcher }, { token: i3.FocusDispatcher }, { token: i4.FocusTrapFactory }, { token: i0.NgZone }, { token: i5.Overlay }, { token: i6.PopoverEditPositionStrategyFactory }, { token: i7.ScrollDispatcher }, { token: i7.ViewportRuler }], target: i0.ɵɵFactoryTarget.Injectable });
+EditServices.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditServices });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: EditServices, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Directionality }, { type: i2.EditEventDispatcher }, { type: i3.FocusDispatcher }, { type: i4.FocusTrapFactory }, { type: i0.NgZone }, { type: i5.Overlay }, { type: i6.PopoverEditPositionStrategyFactory }, { type: i7.ScrollDispatcher }, { type: i7.ViewportRuler }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover-edit/focus-dispatcher.mjs

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from '@angular/cdk/bidi';
+import { LEFT_ARROW, UP_ARROW, RIGHT_ARROW, DOWN_ARROW } from '@angular/cdk/keycodes';
+import { Injectable } from '@angular/core';
+import { EDITABLE_CELL_SELECTOR, ROW_SELECTOR, TABLE_SELECTOR } from './constants';
+import { closest } from './polyfill';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+/**
+ * Service responsible for moving cell focus around in response to keyboard events.
+ * May be overridden to customize the keyboard behavior of popover edit.
+ */
+export class FocusDispatcher {
+    constructor(directionality) {
+        this.directionality = directionality;
+        this.keyObserver = { next: event => this.handleKeyboardEvent(event) };
+    }
+    /**
+     * Moves focus to earlier or later cells (in dom order) by offset cells relative to
+     * currentCell.
+     */
+    moveFocusHorizontally(currentCell, offset) {
+        const cells = Array.from(closest(currentCell, TABLE_SELECTOR).querySelectorAll(EDITABLE_CELL_SELECTOR));
+        const currentIndex = cells.indexOf(currentCell);
+        const newIndex = currentIndex + offset;
+        if (cells[newIndex]) {
+            cells[newIndex].focus();
+        }
+    }
+    /** Moves focus to up or down by row by offset cells relative to currentCell. */
+    moveFocusVertically(currentCell, offset) {
+        const currentRow = closest(currentCell, ROW_SELECTOR);
+        const rows = Array.from(closest(currentRow, TABLE_SELECTOR).querySelectorAll(ROW_SELECTOR));
+        const currentRowIndex = rows.indexOf(currentRow);
+        const currentIndexWithinRow = Array.from(currentRow.querySelectorAll(EDITABLE_CELL_SELECTOR)).indexOf(currentCell);
+        const newRowIndex = currentRowIndex + offset;
+        if (rows[newRowIndex]) {
+            const rowToFocus = Array.from(rows[newRowIndex].querySelectorAll(EDITABLE_CELL_SELECTOR));
+            if (rowToFocus[currentIndexWithinRow]) {
+                rowToFocus[currentIndexWithinRow].focus();
+            }
+        }
+    }
+    /** Translates arrow keydown events into focus move operations. */
+    handleKeyboardEvent(event) {
+        const cell = closest(event.target, EDITABLE_CELL_SELECTOR);
+        if (!cell) {
+            return;
+        }
+        switch (event.keyCode) {
+            case UP_ARROW:
+                this.moveFocusVertically(cell, -1);
+                break;
+            case DOWN_ARROW:
+                this.moveFocusVertically(cell, 1);
+                break;
+            case LEFT_ARROW:
+                this.moveFocusHorizontally(cell, this.directionality.value === 'ltr' ? -1 : 1);
+                break;
+            case RIGHT_ARROW:
+                this.moveFocusHorizontally(cell, this.directionality.value === 'ltr' ? 1 : -1);
+                break;
+            default:
+                // If the keyboard event is not handled, return now so that we don't `preventDefault`.
+                return;
+        }
+        event.preventDefault();
+    }
+}
+FocusDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusDispatcher, deps: [{ token: i1.Directionality }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusDispatcher, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusDispatcher, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Directionality }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover-edit/focus-escape-notifier.mjs

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Inject, Injectable, NgZone } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { FocusTrap, InteractivityChecker } from '@angular/cdk/a11y';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+/**
+ * Like FocusTrap, but rather than trapping focus within a dom region, notifies subscribers when
+ * focus leaves the region.
+ */
+export class FocusEscapeNotifier extends FocusTrap {
+    constructor(element, checker, ngZone, document) {
+        super(element, checker, ngZone, document, true /* deferAnchors */);
+        this._escapeSubject = new Subject();
+        // The focus trap adds "anchors" at the beginning and end of a trapped region that redirect
+        // focus. We override that redirect behavior here with simply emitting on a stream.
+        this.startAnchorListener = () => {
+            this._escapeSubject.next(0 /* START */);
+            return true;
+        };
+        this.endAnchorListener = () => {
+            this._escapeSubject.next(1 /* END */);
+            return true;
+        };
+        this.attachAnchors();
+    }
+    escapes() {
+        return this._escapeSubject;
+    }
+}
+/** Factory that allows easy instantiation of focus escape notifiers. */
+export class FocusEscapeNotifierFactory {
+    constructor(_checker, _ngZone, _document) {
+        this._checker = _checker;
+        this._ngZone = _ngZone;
+        this._document = _document;
+    }
+    /**
+     * Creates a focus escape notifier region around the given element.
+     * @param element The element around which focus will be monitored.
+     * @returns The created focus escape notifier instance.
+     */
+    create(element) {
+        return new FocusEscapeNotifier(element, this._checker, this._ngZone, this._document);
+    }
+}
+FocusEscapeNotifierFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusEscapeNotifierFactory, deps: [{ token: i1.InteractivityChecker }, { token: i0.NgZone }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+FocusEscapeNotifierFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusEscapeNotifierFactory, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: FocusEscapeNotifierFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover-edit/index.mjs

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