@skyux/ag-grid 8.6.0 → 9.0.0-alpha.0

package/esm2022/lib/modules/ag-grid/ag-grid-row-delete.directive.mjs

@@ -0,0 +1,268 @@
+import { ContentChild, Directive, EventEmitter, Inject, Input, Optional, Output, } from '@angular/core';
+import { SKY_STACKING_CONTEXT, SkyAffixAutoFitContext, } from '@skyux/core';
+import { AgGridAngular } from 'ag-grid-angular';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyAgGridRowDeleteComponent } from './ag-grid-row-delete.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/core";
+export class SkyAgGridRowDeleteDirective {
+    /**
+     * The IDs of the data in the rows where the inline delete appears.
+     */
+    set rowDeleteIds(value) {
+        this.#rowDeleteIdsInternal = value;
+        if (!value) {
+            for (const config of this.#rowDeleteConfigs) {
+                this.#destroyRowDelete(config.id);
+            }
+            this.#changeDetector.markForCheck();
+            return;
+        }
+        for (const id of value) {
+            const existingConfig = this.#rowDeleteConfigs.find((config) => config.id === id);
+            if (existingConfig) {
+                existingConfig.pending = false;
+            }
+            else if (this.#rowDeleteComponent && this.agGrid) {
+                this.#rowDeleteConfigs.push({
+                    id: id,
+                    pending: false,
+                });
+                const overlay = this.#overlayService.create({
+                    enableScroll: true,
+                    showBackdrop: false,
+                    closeOnNavigation: true,
+                    enableClose: false,
+                    enablePointerEvents: true,
+                });
+                if (this.#rowDeleteComponent.inlineDeleteTemplateRef) {
+                    overlay.attachTemplate(this.#rowDeleteComponent.inlineDeleteTemplateRef, {
+                        $implicit: this.agGrid.api.getRowNode(id),
+                        tableWidth: () => this.#elementRef.nativeElement.querySelector('.sky-ag-grid')
+                            .offsetWidth,
+                        getRowDeleteItem: (row) => this.getRowDeleteItem(row),
+                        cancelRowDelete: (row) => this.cancelRowDelete(row),
+                        confirmRowDelete: (row) => this.confirmRowDelete(row),
+                    });
+                }
+                /**
+                 * We are manually setting the z-index here because overlays will always be on top of
+                 * the omnibar. The default manual setting is 2 less than the omnibar's z-index of 1000 and one less than
+                 * the header row's viewkeeper which is 999. We discussed changing the overlay service to allow for this
+                 * but decided against that change at this time due to its niche nature.
+                 */
+                this.#zIndex
+                    .pipe(takeUntil(this.#ngUnsubscribe))
+                    .subscribe((zIndex) => {
+                    overlay.componentRef.instance.zIndex = zIndex.toString(10);
+                });
+                this.#clipPath
+                    .pipe(takeUntil(this.#ngUnsubscribe))
+                    .subscribe((clipPath) => {
+                    overlay.componentRef.instance.updateClipPath(clipPath);
+                });
+                setTimeout(() => {
+                    const inlineDeleteRef = this.#rowDeleteComponent?.inlineDeleteRefs
+                        ?.toArray()
+                        .find((elRef) => elRef.nativeElement.id === 'row-delete-ref-' + id);
+                    const affixer = this.#affixService.createAffixer(inlineDeleteRef);
+                    this.#affixToRow(affixer, id);
+                    this.#rowDeleteContents[id] = {
+                        affixer: affixer,
+                        overlay: overlay,
+                    };
+                });
+            }
+        }
+        for (const config of this.#rowDeleteConfigs) {
+            if (value.indexOf(config.id) < 0) {
+                this.#destroyRowDelete(config.id);
+            }
+        }
+        this.#changeDetector.markForCheck();
+    }
+    get rowDeleteIds() {
+        return this.#rowDeleteIdsInternal;
+    }
+    #rowDeleteConfigs;
+    #ngUnsubscribe;
+    #rowDeleteComponent;
+    #rowDeleteContents;
+    #rowDeleteIdsInternal;
+    #affixService;
+    #changeDetector;
+    #elementRef;
+    #overlayService;
+    #viewContainerRef;
+    #scrollableHostService;
+    #clipPath;
+    #zIndex;
+    #hasStackingContext;
+    constructor(affixService, changeDetector, elementRef, overlayService, viewContainerRef, scrollableHostService, stackingContext) {
+        /**
+         * Emits a `SkyAgGridRowDeleteCancelArgs` object when a row's inline delete is cancelled.
+         */
+        this.rowDeleteCancel = new EventEmitter();
+        /**
+         * Emits a `SkyAgGridRowDeleteConfirmArgs` object when a row's inline delete is confirmed.
+         */
+        this.rowDeleteConfirm = new EventEmitter();
+        /**
+         * Emits when the list of ids of the data in the rows where inline deletes are shown changes.
+         */
+        this.rowDeleteIdsChange = new EventEmitter();
+        this.#rowDeleteConfigs = [];
+        this.#ngUnsubscribe = new Subject();
+        this.#rowDeleteContents = {};
+        this.#clipPath = new BehaviorSubject(undefined);
+        this.#zIndex = new BehaviorSubject(998);
+        this.#affixService = affixService;
+        this.#changeDetector = changeDetector;
+        this.#elementRef = elementRef;
+        this.#overlayService = overlayService;
+        this.#viewContainerRef = viewContainerRef;
+        this.#scrollableHostService = scrollableHostService;
+        this.#hasStackingContext = !!stackingContext;
+        if (stackingContext) {
+            stackingContext.zIndex
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((zIndex) => {
+                this.#zIndex.next(zIndex);
+            });
+        }
+    }
+    ngAfterContentInit() {
+        this.#rowDeleteComponent = this.#viewContainerRef.createComponent(SkyAgGridRowDeleteComponent).instance;
+        if (this.agGrid) {
+            this.agGrid.rowDataUpdated
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#updateRowDeleteStates();
+            });
+            this.agGrid.sortChanged
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#updateRowDeleteStates();
+            });
+            this.agGrid.filterChanged
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#updateRowDeleteStates();
+            });
+        }
+    }
+    ngAfterViewInit() {
+        if (this.#hasStackingContext) {
+            this.#scrollableHostService
+                .watchScrollableHostClipPathChanges(this.#elementRef)
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((clipPath) => {
+                this.#clipPath.next(clipPath);
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+        Object.keys(this.#rowDeleteContents).forEach((id) => {
+            this.#destroyRowDelete(id);
+        });
+    }
+    cancelRowDelete(row) {
+        if (row.id) {
+            this.#rowDeleteConfigs = this.#rowDeleteConfigs.filter((config) => config.id !== row.id);
+            this.rowDeleteCancel.emit({ id: row.id });
+            this.#destroyRowDelete(row.id);
+        }
+    }
+    confirmRowDelete(row) {
+        if (row.id) {
+            const rowConfig = this.#rowDeleteConfigs.find((config) => config.id === row.id);
+            if (rowConfig) {
+                rowConfig.pending = true;
+                this.rowDeleteConfirm.emit({ id: row.id });
+            }
+        }
+    }
+    getRowDeleteItem(row) {
+        return this.#rowDeleteConfigs.find((rowDelete) => rowDelete.id === row.id);
+    }
+    #affixToRow(affixer, id) {
+        let rowElement = this.#elementRef.nativeElement.querySelector(`
+      [row-id="${id}"] div[aria-colindex="1"],
+      .ag-row.sky-ag-grid-row-${id} div[aria-colindex="1"]
+    `);
+        // This covers cases where AG Grid places the column index on an inner element (such as with the `enableCellTextSelection` option)
+        // This appears to have been fixed by AG Grid in version 24 and so it is not testable after that version.
+        /* istanbul ignore if */
+        if (!rowElement) {
+            const columns = this.#elementRef.nativeElement.querySelectorAll('[row-id="' + id + '"] > div');
+            for (let i = 0; i < columns.length; i++) {
+                if (columns[i].querySelector('[aria-colindex="1"]')) {
+                    rowElement = columns[i];
+                    break;
+                }
+            }
+        }
+        affixer.affixTo(rowElement, {
+            autoFitContext: SkyAffixAutoFitContext.Viewport,
+            isSticky: true,
+            placement: 'above',
+            verticalAlignment: 'top',
+            horizontalAlignment: 'left',
+            enableAutoFit: false,
+        });
+    }
+    #destroyRowDelete(id) {
+        const rowDeleteContents = this.#rowDeleteContents[id];
+        /* sanity check */
+        /* istanbul ignore else */
+        if (rowDeleteContents) {
+            rowDeleteContents.affixer.destroy();
+            this.#overlayService.close(rowDeleteContents.overlay);
+            delete this.#rowDeleteContents[id];
+            this.#rowDeleteConfigs = this.#rowDeleteConfigs.filter((config) => config.id !== id);
+            this.#rowDeleteIdsInternal = this.rowDeleteIds?.filter((arrayId) => arrayId !== id);
+            this.rowDeleteIdsChange.emit(this.#rowDeleteIdsInternal);
+        }
+    }
+    #updateRowDeleteStates() {
+        this.#rowDeleteConfigs.forEach((config) => {
+            if (!this.agGrid?.api.getRowNode(config.id)) {
+                this.#destroyRowDelete(config.id);
+            }
+            else {
+                // We must reaffix things when the data changes because the rows rerender and the previous element that the delete was affixed
+                // to is destroyed.
+                this.#affixToRow(this.#rowDeleteContents[config.id].affixer, config.id);
+            }
+        });
+        this.#changeDetector.markForCheck();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAgGridRowDeleteDirective, deps: [{ token: i1.SkyAffixService }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.SkyOverlayService }, { token: i0.ViewContainerRef }, { token: i1.SkyScrollableHostService }, { token: SKY_STACKING_CONTEXT, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: SkyAgGridRowDeleteDirective, selector: "[skyAgGridRowDelete]", inputs: { rowDeleteIds: "rowDeleteIds" }, outputs: { rowDeleteCancel: "rowDeleteCancel", rowDeleteConfirm: "rowDeleteConfirm", rowDeleteIdsChange: "rowDeleteIdsChange" }, queries: [{ propertyName: "agGrid", first: true, predicate: AgGridAngular, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAgGridRowDeleteDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyAgGridRowDelete]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyAffixService }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.SkyOverlayService }, { type: i0.ViewContainerRef }, { type: i1.SkyScrollableHostService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SKY_STACKING_CONTEXT]
+                }] }]; }, propDecorators: { rowDeleteIds: [{
+                type: Input
+            }], rowDeleteCancel: [{
+                type: Output
+            }], rowDeleteConfirm: [{
+                type: Output
+            }], rowDeleteIdsChange: [{
+                type: Output
+            }], agGrid: [{
+                type: ContentChild,
+                args: [AgGridAngular]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ag-grid-row-delete.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/ag-grid/src/lib/modules/ag-grid/ag-grid-row-delete.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectorRef,\n  ContentChild,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n  ViewContainerRef,\n} from '@angular/core';\nimport {\n  SKY_STACKING_CONTEXT,\n  SkyAffixAutoFitContext,\n  SkyAffixService,\n  SkyAffixer,\n  SkyOverlayService,\n  SkyScrollableHostService,\n  SkyStackingContext,\n} from '@skyux/core';\n\nimport { AgGridAngular } from 'ag-grid-angular';\nimport { RowNode } from 'ag-grid-community';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyAgGridRowDeleteComponent } from './ag-grid-row-delete.component';\nimport { SkyAgGridRowDeleteCancelArgs } from './types/ag-grid-row-delete-cancel-args';\nimport { SkyAgGridRowDeleteConfig } from './types/ag-grid-row-delete-config';\nimport { SkyAgGridRowDeleteConfirmArgs } from './types/ag-grid-row-delete-confirm-args';\nimport { SkyAgGridRowDeleteContents } from './types/ag-grid-row-delete-contents';\n\n@Directive({\n  selector: '[skyAgGridRowDelete]',\n})\nexport class SkyAgGridRowDeleteDirective\n  implements AfterContentInit, AfterViewInit, OnDestroy\n{\n  /**\n   * The IDs of the data in the rows where the inline delete appears.\n   */\n  @Input()\n  public set rowDeleteIds(value: string[] | undefined) {\n    this.#rowDeleteIdsInternal = value;\n\n    if (!value) {\n      for (const config of this.#rowDeleteConfigs) {\n        this.#destroyRowDelete(config.id);\n      }\n\n      this.#changeDetector.markForCheck();\n\n      return;\n    }\n\n    for (const id of value) {\n      const existingConfig = this.#rowDeleteConfigs.find(\n        (config) => config.id === id\n      );\n      if (existingConfig) {\n        existingConfig.pending = false;\n      } else if (this.#rowDeleteComponent && this.agGrid) {\n        this.#rowDeleteConfigs.push({\n          id: id,\n          pending: false,\n        });\n\n        const overlay = this.#overlayService.create({\n          enableScroll: true,\n          showBackdrop: false,\n          closeOnNavigation: true,\n          enableClose: false,\n          enablePointerEvents: true,\n        });\n\n        if (this.#rowDeleteComponent.inlineDeleteTemplateRef) {\n          overlay.attachTemplate(\n            this.#rowDeleteComponent.inlineDeleteTemplateRef,\n            {\n              $implicit: this.agGrid.api.getRowNode(id),\n              tableWidth: () =>\n                this.#elementRef.nativeElement.querySelector('.sky-ag-grid')\n                  .offsetWidth,\n              getRowDeleteItem: (row: RowNode) => this.getRowDeleteItem(row),\n              cancelRowDelete: (row: RowNode) => this.cancelRowDelete(row),\n              confirmRowDelete: (row: RowNode) => this.confirmRowDelete(row),\n            }\n          );\n        }\n\n        /**\n         * We are manually setting the z-index here because overlays will always be on top of\n         * the omnibar. The default manual setting is 2 less than the omnibar's z-index of 1000 and one less than\n         * the header row's viewkeeper which is 999. We discussed changing the overlay service to allow for this\n         * but decided against that change at this time due to its niche nature.\n         */\n        this.#zIndex\n          .pipe(takeUntil(this.#ngUnsubscribe))\n          .subscribe((zIndex) => {\n            overlay.componentRef.instance.zIndex = zIndex.toString(10);\n          });\n        this.#clipPath\n          .pipe(takeUntil(this.#ngUnsubscribe))\n          .subscribe((clipPath) => {\n            overlay.componentRef.instance.updateClipPath(clipPath);\n          });\n\n        setTimeout(() => {\n          const inlineDeleteRef = this.#rowDeleteComponent?.inlineDeleteRefs\n            ?.toArray()\n            .find(\n              (elRef) => elRef.nativeElement.id === 'row-delete-ref-' + id\n            ) as ElementRef;\n          const affixer = this.#affixService.createAffixer(inlineDeleteRef);\n\n          this.#affixToRow(affixer, id);\n\n          this.#rowDeleteContents[id] = {\n            affixer: affixer,\n            overlay: overlay,\n          };\n        });\n      }\n    }\n\n    for (const config of this.#rowDeleteConfigs) {\n      if (value.indexOf(config.id) < 0) {\n        this.#destroyRowDelete(config.id);\n      }\n    }\n\n    this.#changeDetector.markForCheck();\n  }\n\n  public get rowDeleteIds(): string[] | undefined {\n    return this.#rowDeleteIdsInternal;\n  }\n\n  /**\n   * Emits a `SkyAgGridRowDeleteCancelArgs` object when a row's inline delete is cancelled.\n   */\n  @Output()\n  public rowDeleteCancel = new EventEmitter<SkyAgGridRowDeleteCancelArgs>();\n\n  /**\n   * Emits a `SkyAgGridRowDeleteConfirmArgs` object when a row's inline delete is confirmed.\n   */\n  @Output()\n  public rowDeleteConfirm = new EventEmitter<SkyAgGridRowDeleteConfirmArgs>();\n\n  /**\n   * Emits when the list of ids of the data in the rows where inline deletes are shown changes.\n   */\n  @Output()\n  public rowDeleteIdsChange = new EventEmitter<string[]>();\n\n  #rowDeleteConfigs: SkyAgGridRowDeleteConfig[] = [];\n\n  @ContentChild(AgGridAngular)\n  public agGrid: AgGridAngular | undefined;\n\n  #ngUnsubscribe = new Subject<void>();\n  #rowDeleteComponent: SkyAgGridRowDeleteComponent | undefined;\n  #rowDeleteContents: { [id: string]: SkyAgGridRowDeleteContents } = {};\n\n  #rowDeleteIdsInternal: string[] | undefined;\n  #affixService: SkyAffixService;\n  #changeDetector: ChangeDetectorRef;\n  #elementRef: ElementRef;\n  #overlayService: SkyOverlayService;\n  #viewContainerRef: ViewContainerRef;\n  #scrollableHostService: SkyScrollableHostService;\n  #clipPath = new BehaviorSubject<string | undefined>(undefined);\n  #zIndex = new BehaviorSubject(998);\n  #hasStackingContext: boolean;\n\n  constructor(\n    affixService: SkyAffixService,\n    changeDetector: ChangeDetectorRef,\n    elementRef: ElementRef,\n    overlayService: SkyOverlayService,\n    viewContainerRef: ViewContainerRef,\n    scrollableHostService: SkyScrollableHostService,\n    @Optional()\n    @Inject(SKY_STACKING_CONTEXT)\n    stackingContext?: SkyStackingContext\n  ) {\n    this.#affixService = affixService;\n    this.#changeDetector = changeDetector;\n    this.#elementRef = elementRef;\n    this.#overlayService = overlayService;\n    this.#viewContainerRef = viewContainerRef;\n    this.#scrollableHostService = scrollableHostService;\n    this.#hasStackingContext = !!stackingContext;\n    if (stackingContext) {\n      stackingContext.zIndex\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((zIndex) => {\n          this.#zIndex.next(zIndex);\n        });\n    }\n  }\n\n  public ngAfterContentInit(): void {\n    this.#rowDeleteComponent = this.#viewContainerRef.createComponent(\n      SkyAgGridRowDeleteComponent\n    ).instance;\n\n    if (this.agGrid) {\n      this.agGrid.rowDataUpdated\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#updateRowDeleteStates();\n        });\n\n      this.agGrid.sortChanged\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#updateRowDeleteStates();\n        });\n\n      this.agGrid.filterChanged\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#updateRowDeleteStates();\n        });\n    }\n  }\n\n  public ngAfterViewInit(): void {\n    if (this.#hasStackingContext) {\n      this.#scrollableHostService\n        .watchScrollableHostClipPathChanges(this.#elementRef)\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((clipPath) => {\n          this.#clipPath.next(clipPath);\n        });\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n\n    Object.keys(this.#rowDeleteContents).forEach((id) => {\n      this.#destroyRowDelete(id);\n    });\n  }\n\n  public cancelRowDelete(row: RowNode): void {\n    if (row.id) {\n      this.#rowDeleteConfigs = this.#rowDeleteConfigs.filter(\n        (config) => config.id !== row.id\n      );\n      this.rowDeleteCancel.emit({ id: row.id });\n\n      this.#destroyRowDelete(row.id);\n    }\n  }\n\n  public confirmRowDelete(row: RowNode): void {\n    if (row.id) {\n      const rowConfig = this.#rowDeleteConfigs.find(\n        (config) => config.id === row.id\n      );\n\n      if (rowConfig) {\n        rowConfig.pending = true;\n        this.rowDeleteConfirm.emit({ id: row.id });\n      }\n    }\n  }\n\n  public getRowDeleteItem(row: RowNode): SkyAgGridRowDeleteConfig | undefined {\n    return this.#rowDeleteConfigs.find((rowDelete) => rowDelete.id === row.id);\n  }\n\n  #affixToRow(affixer: SkyAffixer, id: string): void {\n    let rowElement: HTMLElement = this.#elementRef.nativeElement.querySelector(`\n      [row-id=\"${id}\"] div[aria-colindex=\"1\"],\n      .ag-row.sky-ag-grid-row-${id} div[aria-colindex=\"1\"]\n    `);\n\n    // This covers cases where AG Grid places the column index on an inner element (such as with the `enableCellTextSelection` option)\n    // This appears to have been fixed by AG Grid in version 24 and so it is not testable after that version.\n    /* istanbul ignore if */\n    if (!rowElement) {\n      const columns = this.#elementRef.nativeElement.querySelectorAll(\n        '[row-id=\"' + id + '\"] > div'\n      );\n\n      for (let i = 0; i < columns.length; i++) {\n        if (columns[i].querySelector('[aria-colindex=\"1\"]')) {\n          rowElement = columns[i];\n          break;\n        }\n      }\n    }\n\n    affixer.affixTo(rowElement, {\n      autoFitContext: SkyAffixAutoFitContext.Viewport,\n      isSticky: true,\n      placement: 'above',\n      verticalAlignment: 'top',\n      horizontalAlignment: 'left',\n      enableAutoFit: false,\n    });\n  }\n\n  #destroyRowDelete(id: string): void {\n    const rowDeleteContents = this.#rowDeleteContents[id];\n\n    /* sanity check */\n    /* istanbul ignore else */\n    if (rowDeleteContents) {\n      rowDeleteContents.affixer.destroy();\n      this.#overlayService.close(rowDeleteContents.overlay);\n      delete this.#rowDeleteContents[id];\n      this.#rowDeleteConfigs = this.#rowDeleteConfigs.filter(\n        (config) => config.id !== id\n      );\n      this.#rowDeleteIdsInternal = this.rowDeleteIds?.filter(\n        (arrayId) => arrayId !== id\n      );\n      this.rowDeleteIdsChange.emit(this.#rowDeleteIdsInternal);\n    }\n  }\n\n  #updateRowDeleteStates(): void {\n    this.#rowDeleteConfigs.forEach((config: SkyAgGridRowDeleteConfig) => {\n      if (!this.agGrid?.api.getRowNode(config.id)) {\n        this.#destroyRowDelete(config.id);\n      } else {\n        // We must reaffix things when the data changes because the rows rerender and the previous element that the delete was affixed\n        // to is destroyed.\n        this.#affixToRow(this.#rowDeleteContents[config.id].affixer, config.id);\n      }\n    });\n    this.#changeDetector.markForCheck();\n  }\n}\n"]}

package/esm2022/lib/modules/ag-grid/ag-grid-wrapper.component.mjs

@@ -0,0 +1,259 @@
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ElementRef, HostBinding, inject, } from '@angular/core';
+import { SkyMutationObserverService } from '@skyux/core';
+import { SkyThemeService } from '@skyux/theme';
+import { AgGridAngular } from 'ag-grid-angular';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { take, takeUntil } from 'rxjs/operators';
+import { SkyAgGridAdapterService } from './ag-grid-adapter.service';
+import { SkyAgGridService } from './ag-grid.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@skyux/core";
+let idIndex = 0;
+export class SkyAgGridWrapperComponent {
+    get viewkeeperClasses() {
+        return this.#_viewkeeperClasses;
+    }
+    set viewkeeperClasses(value) {
+        this.#_viewkeeperClasses = value;
+        this.#changeDetector.markForCheck();
+    }
+    get #isInEditMode() {
+        /* istanbul ignore else */
+        if (this.agGrid && this.agGrid.api) {
+            const primaryGridEditing = this.agGrid.api.getEditingCells().length > 0;
+            if (primaryGridEditing) {
+                return true;
+            }
+            else {
+                let innerEditing = false;
+                this.agGrid.api.forEachDetailGridInfo((detailGrid) => {
+                    if (detailGrid?.api && detailGrid.api.getEditingCells().length > 0) {
+                        innerEditing = true;
+                    }
+                });
+                return innerEditing;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    #_viewkeeperClasses;
+    #agGridService;
+    #ngUnsubscribe;
+    #themeSvc;
+    #wrapperClasses;
+    #currentTheme;
+    #adapterService;
+    #changeDetector;
+    #parentChangeDetector;
+    #elementRef;
+    #document;
+    #mutationObserverService;
+    #hasEditableClass;
+    constructor() {
+        this.isNormalLayout = false;
+        this.#_viewkeeperClasses = [];
+        this.#agGridService = inject(SkyAgGridService);
+        this.#ngUnsubscribe = new Subject();
+        this.#themeSvc = inject(SkyThemeService, {
+            optional: true,
+        });
+        this.#wrapperClasses = new BehaviorSubject([
+            `ag-theme-sky-data-grid-default`,
+        ]);
+        this.#currentTheme = undefined;
+        this.#adapterService = inject(SkyAgGridAdapterService);
+        this.#changeDetector = inject(ChangeDetectorRef);
+        this.#parentChangeDetector = inject(ChangeDetectorRef, {
+            optional: true,
+            skipSelf: true,
+        });
+        this.#elementRef = inject(ElementRef);
+        this.#document = inject(DOCUMENT);
+        this.#mutationObserverService = inject(SkyMutationObserverService);
+        this.#hasEditableClass = false;
+        idIndex++;
+        this.afterAnchorId = 'sky-ag-grid-nav-anchor-after-' + idIndex;
+        this.beforeAnchorId = 'sky-ag-grid-nav-anchor-before-' + idIndex;
+        this.gridId = 'sky-ag-grid-' + idIndex;
+        this.wrapperClasses$ = this.#wrapperClasses.asObservable();
+    }
+    ngAfterContentInit() {
+        if (this.agGrid) {
+            const domLayout = this.agGrid.gridOptions?.domLayout;
+            if (domLayout === 'autoHeight') {
+                if (this.agGrid.gridOptions.context?.enableTopScroll) {
+                    this.viewkeeperClasses.push('.ag-header', '.ag-body-horizontal-scroll');
+                }
+                else {
+                    this.viewkeeperClasses.push('.ag-header');
+                }
+            }
+            else if (domLayout === 'normal') {
+                this.isNormalLayout = true;
+                this.#parentChangeDetector?.detectChanges();
+            }
+            this.agGrid.gridReady
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#moveHorizontalScroll();
+            });
+            this.agGrid.firstDataRendered
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#moveHorizontalScroll();
+            });
+            this.agGrid.rowDataUpdated
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#moveHorizontalScroll();
+            });
+            this.agGrid.cellEditingStarted
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((params) => {
+                if (params.colDef.type) {
+                    const types = Array.isArray(params.colDef.type)
+                        ? params.colDef.type
+                        : [params.colDef.type];
+                    const addClasses = types.map((t) => `sky-ag-grid-cell-editing-${t}`);
+                    this.#wrapperClasses.next([
+                        ...this.#wrapperClasses.getValue(),
+                        ...addClasses,
+                    ]);
+                }
+            });
+            this.agGrid.cellEditingStopped
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe(() => {
+                this.#wrapperClasses.next(this.#wrapperClasses
+                    .getValue()
+                    .filter((c) => c.startsWith('ag-theme-')));
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    ngOnInit() {
+        this.#themeSvc?.settingsChange
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((settings) => {
+            this.#updateGridTheme(settings.currentSettings);
+            if (!this.#currentTheme) {
+                // Initial theme settings.
+                this.#currentTheme = settings.currentSettings;
+            }
+            else if (this.agGrid?.api) {
+                // On subsequent theme changes, we need to call the api to re-render the grid.
+                this.#currentTheme = settings.currentSettings;
+                this.agGrid.api.setHeaderHeight(this.#agGridService.getHeaderHeight());
+                this.agGrid.api.resetRowHeights();
+                this.agGrid.api.refreshCells();
+            }
+        });
+    }
+    ngAfterViewInit() {
+        const agGridElement = this.#elementRef.nativeElement.querySelector('ag-grid-angular');
+        const callback = () => {
+            this.#hasEditableClass = !!agGridElement?.classList.contains('sky-ag-grid-editable');
+            this.#updateGridTheme(this.#currentTheme);
+        };
+        if (agGridElement) {
+            const agGridClassObserver = this.#mutationObserverService.create(callback);
+            agGridClassObserver.observe(agGridElement, {
+                attributes: true,
+            });
+            this.#ngUnsubscribe.pipe(take(1)).subscribe(() => {
+                agGridClassObserver.disconnect();
+            });
+        }
+        setTimeout(callback);
+    }
+    /**
+     * Prevent closing a modal when focused in AG Grid.
+     */
+    onKeyUpEscape($event) {
+        $event.stopPropagation();
+        this.agGrid?.api.stopEditing(true);
+    }
+    onGridKeydown(event) {
+        if (this.agGrid && !this.#isInEditMode && event.key === 'Tab') {
+            const idToFocus = event.shiftKey
+                ? this.beforeAnchorId
+                : this.afterAnchorId;
+            this.#adapterService.setFocusedElementById(this.#elementRef.nativeElement, idToFocus);
+        }
+    }
+    onAnchorFocus(event) {
+        const relatedTarget = event.relatedTarget;
+        const previousWasGrid = relatedTarget && !!this.#elementRef.nativeElement.contains(relatedTarget);
+        if (this.agGrid && !previousWasGrid) {
+            const firstColumn = this.agGrid.columnApi.getAllDisplayedColumns()[0];
+            if (firstColumn) {
+                this.agGrid.api.ensureColumnVisible(firstColumn);
+                this.#adapterService.focusOnColumnHeader(this.#elementRef.nativeElement, firstColumn.getColId());
+            }
+        }
+    }
+    #moveHorizontalScroll() {
+        if (this.agGrid && this.agGrid.api) {
+            const toTop = !!this.agGrid.gridOptions.context?.enableTopScroll;
+            const root = this.#elementRef.nativeElement.querySelector('.ag-root');
+            const header = root.querySelector('.ag-header');
+            const floatingBottom = root.querySelector('.ag-floating-bottom');
+            const scrollbar = root.querySelector('.ag-body-horizontal-scroll');
+            if (header && floatingBottom && scrollbar) {
+                if (scrollbar.style.height !==
+                    scrollbar.style.getPropertyValue('--sky-ag-body-horizontal-scroll-width')) {
+                    scrollbar.style.setProperty('--sky-ag-body-horizontal-scroll-width', scrollbar.style.height);
+                }
+                const isTop = !!root.children[1].matches('.ag-body-horizontal-scroll');
+                if (toTop && !isTop) {
+                    const fragment = this.#document.createDocumentFragment();
+                    fragment.appendChild(scrollbar);
+                    header.after(fragment);
+                }
+                else if (!toTop && isTop) {
+                    const fragment = this.#document.createDocumentFragment();
+                    fragment.appendChild(scrollbar);
+                    floatingBottom.after(fragment);
+                }
+            }
+        }
+    }
+    #updateGridTheme(themeSettings) {
+        let agTheme;
+        if (themeSettings?.theme.name === 'modern') {
+            agTheme = `modern-${themeSettings.mode.name}`;
+        }
+        else {
+            agTheme = `default`;
+        }
+        const variation = this.#hasEditableClass ? 'data-entry-grid' : 'data-grid';
+        this.#wrapperClasses.next([
+            ...this.#wrapperClasses
+                .getValue()
+                .filter((c) => !c.startsWith('ag-theme-')),
+            `ag-theme-sky-${variation}-${agTheme}`,
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAgGridWrapperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.7", type: SkyAgGridWrapperComponent, selector: "sky-ag-grid-wrapper", host: { properties: { "class.sky-ag-grid-layout-normal": "this.isNormalLayout" } }, queries: [{ propertyName: "agGrid", first: true, predicate: AgGridAngular, descendants: true, static: true }], ngImport: i0, template: "<span\n  class=\"nav-anchor\"\n  tabindex=\"0\"\n  [id]=\"beforeAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n<div\n  class=\"sky-ag-grid\"\n  [class.sky-ag-grid-top-scrollbar]=\"\n    agGrid?.gridOptions?.context &&\n    agGrid?.gridOptions?.context['enableTopScroll']\n  \"\n  [ngClass]=\"wrapperClasses$ | async\"\n  tabindex=\"0\"\n  [id]=\"gridId\"\n  [skyViewkeeper]=\"viewkeeperClasses\"\n  (keydown)=\"onGridKeydown($event)\"\n  (keyup.escape)=\"onKeyUpEscape($event)\"\n>\n  <ng-content></ng-content>\n</div>\n<span\n  tabindex=\"0\"\n  class=\"nav-anchor\"\n  [id]=\"afterAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.λ3, selector: "[skyViewkeeper]", inputs: ["skyViewkeeper"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyAgGridWrapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-ag-grid-wrapper', changeDetection: ChangeDetectionStrategy.OnPush, template: "<span\n  class=\"nav-anchor\"\n  tabindex=\"0\"\n  [id]=\"beforeAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n<div\n  class=\"sky-ag-grid\"\n  [class.sky-ag-grid-top-scrollbar]=\"\n    agGrid?.gridOptions?.context &&\n    agGrid?.gridOptions?.context['enableTopScroll']\n  \"\n  [ngClass]=\"wrapperClasses$ | async\"\n  tabindex=\"0\"\n  [id]=\"gridId\"\n  [skyViewkeeper]=\"viewkeeperClasses\"\n  (keydown)=\"onGridKeydown($event)\"\n  (keyup.escape)=\"onKeyUpEscape($event)\"\n>\n  <ng-content></ng-content>\n</div>\n<span\n  tabindex=\"0\"\n  class=\"nav-anchor\"\n  [id]=\"afterAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { agGrid: [{
+                type: ContentChild,
+                args: [AgGridAngular, {
+                        static: true,
+                    }]
+            }], isNormalLayout: [{
+                type: HostBinding,
+                args: ['class.sky-ag-grid-layout-normal']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ag-grid-wrapper.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/ag-grid/src/lib/modules/ag-grid/ag-grid-wrapper.component.ts","../../../../../../../../libs/components/ag-grid/src/lib/modules/ag-grid/ag-grid-wrapper.component.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ElementRef,\n  HostBinding,\n  OnDestroy,\n  OnInit,\n  inject,\n} from '@angular/core';\nimport { SkyMutationObserverService } from '@skyux/core';\nimport { SkyThemeService, SkyThemeSettings } from '@skyux/theme';\n\nimport { AgGridAngular } from 'ag-grid-angular';\nimport { CellEditingStartedEvent, DetailGridInfo } from 'ag-grid-community';\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { take, takeUntil } from 'rxjs/operators';\n\nimport { SkyAgGridAdapterService } from './ag-grid-adapter.service';\nimport { SkyAgGridService } from './ag-grid.service';\n\nlet idIndex = 0;\n\n@Component({\n  selector: 'sky-ag-grid-wrapper',\n  templateUrl: './ag-grid-wrapper.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SkyAgGridWrapperComponent\n  implements AfterContentInit, AfterViewInit, OnDestroy, OnInit\n{\n  @ContentChild(AgGridAngular, {\n    static: true,\n  })\n  public agGrid: AgGridAngular | undefined;\n\n  @HostBinding('class.sky-ag-grid-layout-normal')\n  public isNormalLayout = false;\n\n  public afterAnchorId: string;\n  public beforeAnchorId: string;\n  public gridId: string;\n  public wrapperClasses$: Observable<string[]>;\n\n  public get viewkeeperClasses(): string[] {\n    return this.#_viewkeeperClasses;\n  }\n\n  public set viewkeeperClasses(value: string[]) {\n    this.#_viewkeeperClasses = value;\n    this.#changeDetector.markForCheck();\n  }\n\n  get #isInEditMode(): boolean {\n    /* istanbul ignore else */\n    if (this.agGrid && this.agGrid.api) {\n      const primaryGridEditing = this.agGrid.api.getEditingCells().length > 0;\n      if (primaryGridEditing) {\n        return true;\n      } else {\n        let innerEditing = false;\n        this.agGrid.api.forEachDetailGridInfo((detailGrid: DetailGridInfo) => {\n          if (detailGrid?.api && detailGrid.api.getEditingCells().length > 0) {\n            innerEditing = true;\n          }\n        });\n\n        return innerEditing;\n      }\n    } else {\n      return false;\n    }\n  }\n\n  #_viewkeeperClasses: string[] = [];\n\n  #agGridService = inject(SkyAgGridService);\n  #ngUnsubscribe = new Subject<void>();\n  #themeSvc = inject(SkyThemeService, {\n    optional: true,\n  });\n  #wrapperClasses = new BehaviorSubject<string[]>([\n    `ag-theme-sky-data-grid-default`,\n  ]);\n  #currentTheme: SkyThemeSettings | undefined = undefined;\n  #adapterService = inject(SkyAgGridAdapterService);\n  #changeDetector = inject(ChangeDetectorRef);\n  #parentChangeDetector = inject(ChangeDetectorRef, {\n    optional: true,\n    skipSelf: true,\n  });\n  #elementRef = inject(ElementRef);\n  #document = inject(DOCUMENT);\n  #mutationObserverService = inject(SkyMutationObserverService);\n  #hasEditableClass = false;\n\n  constructor() {\n    idIndex++;\n    this.afterAnchorId = 'sky-ag-grid-nav-anchor-after-' + idIndex;\n    this.beforeAnchorId = 'sky-ag-grid-nav-anchor-before-' + idIndex;\n    this.gridId = 'sky-ag-grid-' + idIndex;\n    this.wrapperClasses$ = this.#wrapperClasses.asObservable();\n  }\n\n  public ngAfterContentInit(): void {\n    if (this.agGrid) {\n      const domLayout = this.agGrid.gridOptions?.domLayout;\n      if (domLayout === 'autoHeight') {\n        if (this.agGrid.gridOptions.context?.enableTopScroll) {\n          this.viewkeeperClasses.push(\n            '.ag-header',\n            '.ag-body-horizontal-scroll'\n          );\n        } else {\n          this.viewkeeperClasses.push('.ag-header');\n        }\n      } else if (domLayout === 'normal') {\n        this.isNormalLayout = true;\n        this.#parentChangeDetector?.detectChanges();\n      }\n      this.agGrid.gridReady\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#moveHorizontalScroll();\n        });\n      this.agGrid.firstDataRendered\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#moveHorizontalScroll();\n        });\n      this.agGrid.rowDataUpdated\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#moveHorizontalScroll();\n        });\n      this.agGrid.cellEditingStarted\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((params: CellEditingStartedEvent) => {\n          if (params.colDef.type) {\n            const types = Array.isArray(params.colDef.type)\n              ? params.colDef.type\n              : [params.colDef.type];\n            const addClasses = types.map(\n              (t) => `sky-ag-grid-cell-editing-${t}`\n            );\n            this.#wrapperClasses.next([\n              ...this.#wrapperClasses.getValue(),\n              ...addClasses,\n            ]);\n          }\n        });\n      this.agGrid.cellEditingStopped\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe(() => {\n          this.#wrapperClasses.next(\n            this.#wrapperClasses\n              .getValue()\n              .filter((c) => c.startsWith('ag-theme-'))\n          );\n        });\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n  }\n\n  public ngOnInit(): void {\n    this.#themeSvc?.settingsChange\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((settings) => {\n        this.#updateGridTheme(settings.currentSettings);\n        if (!this.#currentTheme) {\n          // Initial theme settings.\n          this.#currentTheme = settings.currentSettings;\n        } else if (this.agGrid?.api) {\n          // On subsequent theme changes, we need to call the api to re-render the grid.\n          this.#currentTheme = settings.currentSettings;\n          this.agGrid.api.setHeaderHeight(\n            this.#agGridService.getHeaderHeight()\n          );\n          this.agGrid.api.resetRowHeights();\n          this.agGrid.api.refreshCells();\n        }\n      });\n  }\n\n  public ngAfterViewInit(): void {\n    const agGridElement: HTMLElement | undefined =\n      this.#elementRef.nativeElement.querySelector('ag-grid-angular');\n    const callback = (): void => {\n      this.#hasEditableClass = !!agGridElement?.classList.contains(\n        'sky-ag-grid-editable'\n      );\n      this.#updateGridTheme(this.#currentTheme);\n    };\n    if (agGridElement) {\n      const agGridClassObserver =\n        this.#mutationObserverService.create(callback);\n      agGridClassObserver.observe(agGridElement, {\n        attributes: true,\n      });\n      this.#ngUnsubscribe.pipe(take(1)).subscribe(() => {\n        agGridClassObserver.disconnect();\n      });\n    }\n    setTimeout(callback);\n  }\n\n  /**\n   * Prevent closing a modal when focused in AG Grid.\n   */\n  public onKeyUpEscape($event: Event): void {\n    $event.stopPropagation();\n    this.agGrid?.api.stopEditing(true);\n  }\n\n  public onGridKeydown(event: KeyboardEvent): void {\n    if (this.agGrid && !this.#isInEditMode && event.key === 'Tab') {\n      const idToFocus = event.shiftKey\n        ? this.beforeAnchorId\n        : this.afterAnchorId;\n      this.#adapterService.setFocusedElementById(\n        this.#elementRef.nativeElement,\n        idToFocus\n      );\n    }\n  }\n\n  public onAnchorFocus(event: FocusEvent): void {\n    const relatedTarget = event.relatedTarget as HTMLElement | undefined;\n    const previousWasGrid =\n      relatedTarget && !!this.#elementRef.nativeElement.contains(relatedTarget);\n\n    if (this.agGrid && !previousWasGrid) {\n      const firstColumn = this.agGrid.columnApi.getAllDisplayedColumns()[0];\n\n      if (firstColumn) {\n        this.agGrid.api.ensureColumnVisible(firstColumn);\n        this.#adapterService.focusOnColumnHeader(\n          this.#elementRef.nativeElement,\n          firstColumn.getColId()\n        );\n      }\n    }\n  }\n\n  #moveHorizontalScroll(): void {\n    if (this.agGrid && this.agGrid.api) {\n      const toTop = !!this.agGrid.gridOptions.context?.enableTopScroll;\n      const root: HTMLElement =\n        this.#elementRef.nativeElement.querySelector('.ag-root');\n      const header: HTMLDivElement | null = root.querySelector('.ag-header');\n      const floatingBottom: HTMLDivElement | null = root.querySelector(\n        '.ag-floating-bottom'\n      );\n      const scrollbar: HTMLDivElement | null = root.querySelector(\n        '.ag-body-horizontal-scroll'\n      );\n      if (header && floatingBottom && scrollbar) {\n        if (\n          scrollbar.style.height !==\n          scrollbar.style.getPropertyValue(\n            '--sky-ag-body-horizontal-scroll-width'\n          )\n        ) {\n          scrollbar.style.setProperty(\n            '--sky-ag-body-horizontal-scroll-width',\n            scrollbar.style.height\n          );\n        }\n        const isTop = !!root.children[1].matches('.ag-body-horizontal-scroll');\n        if (toTop && !isTop) {\n          const fragment = this.#document.createDocumentFragment();\n          fragment.appendChild(scrollbar);\n          header.after(fragment);\n        } else if (!toTop && isTop) {\n          const fragment = this.#document.createDocumentFragment();\n          fragment.appendChild(scrollbar);\n          floatingBottom.after(fragment);\n        }\n      }\n    }\n  }\n\n  #updateGridTheme(themeSettings?: SkyThemeSettings): void {\n    let agTheme: 'default' | 'modern-light' | 'modern-dark';\n    if (themeSettings?.theme.name === 'modern') {\n      agTheme = `modern-${themeSettings.mode.name}` as\n        | 'modern-light'\n        | 'modern-dark';\n    } else {\n      agTheme = `default`;\n    }\n    const variation = this.#hasEditableClass ? 'data-entry-grid' : 'data-grid';\n    this.#wrapperClasses.next([\n      ...this.#wrapperClasses\n        .getValue()\n        .filter((c) => !c.startsWith('ag-theme-')),\n      `ag-theme-sky-${variation}-${agTheme}`,\n    ]);\n  }\n}\n","<span\n  class=\"nav-anchor\"\n  tabindex=\"0\"\n  [id]=\"beforeAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n<div\n  class=\"sky-ag-grid\"\n  [class.sky-ag-grid-top-scrollbar]=\"\n    agGrid?.gridOptions?.context &&\n    agGrid?.gridOptions?.context['enableTopScroll']\n  \"\n  [ngClass]=\"wrapperClasses$ | async\"\n  tabindex=\"0\"\n  [id]=\"gridId\"\n  [skyViewkeeper]=\"viewkeeperClasses\"\n  (keydown)=\"onGridKeydown($event)\"\n  (keyup.escape)=\"onKeyUpEscape($event)\"\n>\n  <ng-content></ng-content>\n</div>\n<span\n  tabindex=\"0\"\n  class=\"nav-anchor\"\n  [id]=\"afterAnchorId\"\n  (focusin)=\"onAnchorFocus($event)\"\n>\n</span>\n"]}