ngssm-ag-grid 15.3.14 → 16.0.1

package/esm2022/lib/components/ngssm-actions-cell-renderer/ngssm-actions-cell-renderer.component.mjs

@@ -0,0 +1,75 @@
+import { Component, ChangeDetectionStrategy } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { BehaviorSubject, isObservable, takeUntil } from 'rxjs';
+import { NgSsmComponent } from 'ngssm-store';
+import * as i0 from "@angular/core";
+import * as i1 from "ngssm-store";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/tooltip";
+class NgssmActionsCellRendererComponent extends NgSsmComponent {
+    constructor(store) {
+        super(store);
+        this._actionButtons$ = new BehaviorSubject([]);
+    }
+    get actionButtons$() {
+        return this._actionButtons$.asObservable();
+    }
+    agInit(params) {
+        this.cellParams = params;
+        this.setupActions(params);
+    }
+    refresh(params) {
+        this.cellParams = params;
+        this._actionButtons$.getValue().forEach((a) => {
+            if (a.actionConfig.isDisabled instanceof Function) {
+                a.disabled$.next(a.actionConfig.isDisabled(params));
+            }
+            if (a.actionConfig.isHidden instanceof Function) {
+                a.hidden$.next(a.actionConfig.isHidden(params));
+            }
+        });
+        return true;
+    }
+    executeAction(action) {
+        action.actionConfig.click?.(this.cellParams);
+    }
+    setupActions(rendererParams) {
+        const actionButtons = (rendererParams?.actions ?? []).map((a) => {
+            const actionButton = {
+                cssClass: a.cssClass,
+                color: a.color ?? 'primary',
+                disabled$: new BehaviorSubject(false),
+                hidden$: new BehaviorSubject(false),
+                actionConfig: a,
+                tooltip: a.tooltip ?? ''
+            };
+            if (a.isDisabled instanceof Function) {
+                actionButton.disabled$.next(a.isDisabled(rendererParams));
+            }
+            else if (isObservable(a.isDisabled)) {
+                a.isDisabled.pipe(takeUntil(this.unsubscribeAll$)).subscribe((v) => actionButton.disabled$.next(v));
+            }
+            if (a.isHidden instanceof Function) {
+                actionButton.hidden$.next(a.isHidden(rendererParams));
+            }
+            else if (isObservable(a.isHidden)) {
+                a.isHidden.pipe(takeUntil(this.unsubscribeAll$)).subscribe((v) => actionButton.hidden$.next(v));
+            }
+            return actionButton;
+        });
+        this._actionButtons$.next(actionButtons);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmActionsCellRendererComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgssmActionsCellRendererComponent, isStandalone: true, selector: "ngssm-actions-cell-renderer", usesInheritance: true, ngImport: i0, template: "<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { NgssmActionsCellRendererComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmActionsCellRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngssm-actions-cell-renderer', standalone: true, imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngssm-actions-cell-renderer.component.js","sourceRoot":"","sources":["../../../../../../projects/ngssm-ag-grid/src/lib/components/ngssm-actions-cell-renderer/ngssm-actions-cell-renderer.component.ts","../../../../../../projects/ngssm-ag-grid/src/lib/components/ngssm-actions-cell-renderer/ngssm-actions-cell-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ChangeDetectionStrategy } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatTooltipModule } from '@angular/material/tooltip';\nimport { BehaviorSubject, isObservable, Observable, takeUntil } from 'rxjs';\n\nimport { ICellRendererAngularComp } from 'ag-grid-angular';\nimport { ICellRendererParams } from 'ag-grid-community';\n\nimport { NgSsmComponent, Store } from 'ngssm-store';\n\nimport { NgssmActionsCellRendererParams } from './ngssm-actions-cell-renderer-params';\nimport { ActionConfig } from './action-config';\n\ninterface ActionButton {\n  cssClass: string;\n  color: string;\n  disabled$: BehaviorSubject<boolean>;\n  hidden$: BehaviorSubject<boolean>;\n\n  actionConfig: ActionConfig;\n\n  tooltip: string;\n}\n\n@Component({\n  selector: 'ngssm-actions-cell-renderer',\n  standalone: true,\n  imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule],\n  templateUrl: './ngssm-actions-cell-renderer.component.html',\n  styleUrls: ['./ngssm-actions-cell-renderer.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class NgssmActionsCellRendererComponent extends NgSsmComponent implements ICellRendererAngularComp {\n  private readonly _actionButtons$ = new BehaviorSubject<ActionButton[]>([]);\n\n  private cellParams: ICellRendererParams<any, any> | undefined;\n\n  constructor(store: Store) {\n    super(store);\n  }\n\n  public get actionButtons$(): Observable<ActionButton[]> {\n    return this._actionButtons$.asObservable();\n  }\n\n  public agInit(params: ICellRendererParams<any, any>): void {\n    this.cellParams = params;\n    this.setupActions(params as any);\n  }\n\n  public refresh(params: ICellRendererParams<any, any>): boolean {\n    this.cellParams = params;\n    this._actionButtons$.getValue().forEach((a) => {\n      if (a.actionConfig.isDisabled instanceof Function) {\n        a.disabled$.next(a.actionConfig.isDisabled(params as any));\n      }\n\n      if (a.actionConfig.isHidden instanceof Function) {\n        a.hidden$.next(a.actionConfig.isHidden(params as any));\n      }\n    });\n    return true;\n  }\n\n  public executeAction(action: ActionButton): void {\n    action.actionConfig.click?.(this.cellParams as any);\n  }\n\n  private setupActions(rendererParams: NgssmActionsCellRendererParams): void {\n    const actionButtons: ActionButton[] = (rendererParams?.actions ?? []).map((a) => {\n      const actionButton: ActionButton = {\n        cssClass: a.cssClass,\n        color: a.color ?? 'primary',\n        disabled$: new BehaviorSubject<boolean>(false),\n        hidden$: new BehaviorSubject<boolean>(false),\n        actionConfig: a,\n        tooltip: a.tooltip ?? ''\n      };\n\n      if (a.isDisabled instanceof Function) {\n        actionButton.disabled$.next(a.isDisabled(rendererParams as any));\n      } else if (isObservable(a.isDisabled)) {\n        a.isDisabled.pipe(takeUntil(this.unsubscribeAll$)).subscribe((v) => actionButton.disabled$.next(v));\n      }\n\n      if (a.isHidden instanceof Function) {\n        actionButton.hidden$.next(a.isHidden(rendererParams as any));\n      } else if (isObservable(a.isHidden)) {\n        a.isHidden.pipe(takeUntil(this.unsubscribeAll$)).subscribe((v) => actionButton.hidden$.next(v));\n      }\n\n      return actionButton;\n    });\n\n    this._actionButtons$.next(actionButtons);\n  }\n}\n","<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>"]}

package/esm2022/lib/components/ngssm-ag-grid-theme.directive.mjs

@@ -0,0 +1,29 @@
+import { Directive, HostBinding, Inject, Optional } from '@angular/core';
+import { NgssmAgGridOptions, NGSSM_AG_GRID_OPTIONS } from '../ngssm-ag-grid-options';
+import * as i0 from "@angular/core";
+import * as i1 from "../ngssm-ag-grid-options";
+class NgssmAgGridThemeDirective {
+    constructor(options) {
+        this.className = '';
+        this.className = (options ?? new NgssmAgGridOptions()).theme;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridThemeDirective, deps: [{ token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgssmAgGridThemeDirective, isStandalone: true, selector: "[ngssmAgGridTheme]", host: { properties: { "class": "this.className" } }, ngImport: i0 }); }
+}
+export { NgssmAgGridThemeDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridThemeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngssmAgGridTheme]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgssmAgGridOptions, decorators: [{
+                    type: Inject,
+                    args: [NGSSM_AG_GRID_OPTIONS]
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { className: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdzc20tYWctZ3JpZC10aGVtZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3NzbS1hZy1ncmlkL3NyYy9saWIvY29tcG9uZW50cy9uZ3NzbS1hZy1ncmlkLXRoZW1lLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDOzs7QUFFckYsTUFJYSx5QkFBeUI7SUFHcEMsWUFBdUQsT0FBMkI7UUFGNUQsY0FBUyxHQUFHLEVBQUUsQ0FBQztRQUduQyxJQUFJLENBQUMsU0FBUyxHQUFHLENBQUMsT0FBTyxJQUFJLElBQUksa0JBQWtCLEVBQUUsQ0FBQyxDQUFDLEtBQUssQ0FBQztJQUMvRCxDQUFDOzhHQUxVLHlCQUF5QixrQkFHaEIscUJBQXFCO2tHQUg5Qix5QkFBeUI7O1NBQXpCLHlCQUF5QjsyRkFBekIseUJBQXlCO2tCQUpyQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxvQkFBb0I7b0JBQzlCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs7MEJBSWMsTUFBTTsyQkFBQyxxQkFBcUI7OzBCQUFHLFFBQVE7NENBRjlCLFNBQVM7c0JBQTlCLFdBQVc7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdEJpbmRpbmcsIEluamVjdCwgT3B0aW9uYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgTmdzc21BZ0dyaWRPcHRpb25zLCBOR1NTTV9BR19HUklEX09QVElPTlMgfSBmcm9tICcuLi9uZ3NzbS1hZy1ncmlkLW9wdGlvbnMnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbbmdzc21BZ0dyaWRUaGVtZV0nLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIE5nc3NtQWdHcmlkVGhlbWVEaXJlY3RpdmUge1xuICBASG9zdEJpbmRpbmcoJ2NsYXNzJykgY2xhc3NOYW1lID0gJyc7XG5cbiAgY29uc3RydWN0b3IoQEluamVjdChOR1NTTV9BR19HUklEX09QVElPTlMpIEBPcHRpb25hbCgpIG9wdGlvbnM6IE5nc3NtQWdHcmlkT3B0aW9ucykge1xuICAgIHRoaXMuY2xhc3NOYW1lID0gKG9wdGlvbnMgPz8gbmV3IE5nc3NtQWdHcmlkT3B0aW9ucygpKS50aGVtZTtcbiAgfVxufVxuIl19

package/esm2022/lib/components/ngssm-ag-grid.directive.mjs

@@ -0,0 +1,157 @@
+import { Directive, Inject, Input, Optional } from '@angular/core';
+import { BehaviorSubject, combineLatest, map, Subject, take, takeUntil } from 'rxjs';
+import { AgGridAction, AgGridActionType, RegisterAgGridStateAction, RegisterSelectedRowsAction } from '../actions';
+import { ChangeOrigin, selectAgGridState } from '../state';
+import { NGSSM_AG_GRID_OPTIONS } from '../ngssm-ag-grid-options';
+import * as i0 from "@angular/core";
+import * as i1 from "ngssm-store";
+import * as i2 from "ag-grid-angular";
+import * as i3 from "../ngssm-ag-grid-options";
+class NgssmAgGridDirective {
+    constructor(store, agGridAngular, options) {
+        this.store = store;
+        this.agGridAngular = agGridAngular;
+        this.unsubsribeAll$ = new Subject();
+        this._config$ = new BehaviorSubject({
+            gridId: ''
+        });
+        if (this.agGridAngular.statusBar === undefined) {
+            this.agGridAngular.statusBar = options?.statusBar;
+        }
+        this.agGridAngular.gridReady.pipe(take(1)).subscribe((v) => {
+            combineLatest([
+                this.store.state$.pipe(take(1), map((s) => selectAgGridState(s))),
+                this._config$
+            ])
+                .pipe(take(1))
+                .subscribe((values) => {
+                if (values[0].gridStates[values[1].gridId]) {
+                    this.agGridAngular.columnApi.applyColumnState({
+                        state: values[0].gridStates[values[1].gridId].columnsState,
+                        applyOrder: true
+                    });
+                }
+                if (values[0].selectedRows[values[1].gridId]) {
+                    if (values[1].keepSelection === true) {
+                        const ids = values[0].selectedRows[values[1].gridId]?.ids ?? [];
+                        this.agGridAngular.api.forEachNode((node) => {
+                            if (node.id) {
+                                node.setSelected(ids.includes(node.id));
+                            }
+                        });
+                    }
+                }
+                this.initSateChangeListener();
+            });
+        });
+        combineLatest([this.store.state$.pipe(map((s) => selectAgGridState(s).gridStates)), this._config$])
+            .pipe(takeUntil(this.unsubsribeAll$))
+            .subscribe((values) => {
+            if (values[0][values[1].gridId]?.origin === ChangeOrigin.other) {
+                this.agGridAngular.columnApi.applyColumnState({
+                    state: values[0][values[1].gridId].columnsState,
+                    applyOrder: true
+                });
+            }
+        });
+        combineLatest([this.store.state$.pipe(map((s) => selectAgGridState(s).selectedRows)), this._config$])
+            .pipe(takeUntil(this.unsubsribeAll$))
+            .subscribe((values) => {
+            if (values[0][values[1].gridId]?.origin === ChangeOrigin.other && values[1].keepSelection === true) {
+                const ids = values[0][values[1].gridId]?.ids ?? [];
+                this.agGridAngular.api.forEachNode((node) => {
+                    if (node.id) {
+                        node.setSelected(ids.includes(node.id));
+                    }
+                });
+            }
+        });
+        this.agGridAngular.getContextMenuItems = (params) => this.getContextMenuItems(params);
+    }
+    set config(value) {
+        if (typeof value === 'string') {
+            this._config$.next({
+                gridId: value
+            });
+        }
+        else {
+            this._config$.next(value);
+        }
+    }
+    ngOnDestroy() {
+        this.unsubsribeAll$.next();
+        this.unsubsribeAll$.complete();
+    }
+    initSateChangeListener() {
+        this.agGridAngular.sortChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());
+        this.agGridAngular.filterChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());
+        this.agGridAngular.columnPinned.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());
+        this.agGridAngular.columnResized.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());
+        this.agGridAngular.displayedColumnsChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());
+        this.agGridAngular.rowSelected.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.processSelectionChanged());
+    }
+    saveGridState() {
+        const state = this.agGridAngular.columnApi.getColumnState();
+        this._config$
+            .pipe(take(1))
+            .subscribe((gridId) => this.store.dispatchAction(new RegisterAgGridStateAction(gridId.gridId, ChangeOrigin.agGrid, state)));
+    }
+    processSelectionChanged() {
+        const selectedRows = this.agGridAngular.api
+            .getSelectedNodes()
+            .map((n) => n.id ?? '')
+            .filter((n) => n !== '');
+        this._config$.pipe(take(1)).subscribe((config) => {
+            if (config.keepSelection === true) {
+                this.store.dispatchAction(new RegisterSelectedRowsAction(config.gridId, ChangeOrigin.agGrid, selectedRows));
+            }
+        });
+    }
+    getContextMenuItems(params) {
+        const menuItems = [...(params.defaultItems ?? [])];
+        if (this._config$.getValue().canSaveOnDiskColumnsState === true) {
+            menuItems.push(...[
+                'separator',
+                {
+                    name: 'Save columns state',
+                    action: () => this._config$
+                        .pipe(take(1))
+                        .subscribe((config) => this.store.dispatchAction(new AgGridAction(AgGridActionType.saveColumnsStateOnDisk, config.gridId))),
+                    icon: '<i class="fa-regular fa-floppy-disk"></i>'
+                },
+                {
+                    name: 'Restore columns state',
+                    action: () => this._config$
+                        .pipe(take(1))
+                        .subscribe((config) => this.store.dispatchAction(new AgGridAction(AgGridActionType.resetColumnsStateFromDisk, config.gridId))),
+                    icon: '<i class="fa-solid fa-rotate-right"></i>'
+                },
+                {
+                    name: 'Reset columns state to default',
+                    action: () => this.agGridAngular.columnApi.resetColumnState(),
+                    icon: '<i class="fa-solid fa-clock-rotate-left"></i>'
+                }
+            ]);
+        }
+        return menuItems;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridDirective, deps: [{ token: i1.Store }, { token: i2.AgGridAngular }, { token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgssmAgGridDirective, isStandalone: true, selector: "[ngssmAgGrid]", inputs: { config: ["ngssmAgGrid", "config"] }, ngImport: i0 }); }
+}
+export { NgssmAgGridDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ngssmAgGrid]',
+                    standalone: true
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Store }, { type: i2.AgGridAngular }, { type: i3.NgssmAgGridOptions, decorators: [{
+                    type: Inject,
+                    args: [NGSSM_AG_GRID_OPTIONS]
+                }, {
+                    type: Optional
+                }] }]; }, propDecorators: { config: [{
+                type: Input,
+                args: ['ngssmAgGrid']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngssm-ag-grid.directive.js","sourceRoot":"","sources":["../../../../../projects/ngssm-ag-grid/src/lib/components/ngssm-ag-grid.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Inject, Input, OnDestroy, Optional } from '@angular/core';\nimport { BehaviorSubject, combineLatest, map, Subject, take, takeUntil } from 'rxjs';\n\nimport { AgGridAngular } from 'ag-grid-angular';\nimport { GetContextMenuItemsParams, MenuItemDef } from 'ag-grid-community';\n\nimport { Store } from 'ngssm-store';\n\nimport { AgGridAction, AgGridActionType, RegisterAgGridStateAction, RegisterSelectedRowsAction } from '../actions';\nimport { ChangeOrigin, selectAgGridState } from '../state';\nimport { NgssmAgGridConfig } from './ngssm-ag-grid-config';\nimport { NgssmAgGridOptions, NGSSM_AG_GRID_OPTIONS } from '../ngssm-ag-grid-options';\n\n@Directive({\n  selector: '[ngssmAgGrid]',\n  standalone: true\n})\nexport class NgssmAgGridDirective implements OnDestroy {\n  private readonly unsubsribeAll$ = new Subject<void>();\n  private readonly _config$ = new BehaviorSubject<NgssmAgGridConfig>({\n    gridId: ''\n  });\n\n  constructor(\n    private store: Store,\n    private agGridAngular: AgGridAngular,\n    @Inject(NGSSM_AG_GRID_OPTIONS) @Optional() options: NgssmAgGridOptions\n  ) {\n    if (this.agGridAngular.statusBar === undefined) {\n      this.agGridAngular.statusBar = options?.statusBar;\n    }\n\n    this.agGridAngular.gridReady.pipe(take(1)).subscribe((v) => {\n      combineLatest([\n        this.store.state$.pipe(\n          take(1),\n          map((s) => selectAgGridState(s))\n        ),\n        this._config$\n      ])\n        .pipe(take(1))\n        .subscribe((values) => {\n          if (values[0].gridStates[values[1].gridId]) {\n            this.agGridAngular.columnApi.applyColumnState({\n              state: values[0].gridStates[values[1].gridId].columnsState,\n              applyOrder: true\n            });\n          }\n\n          if (values[0].selectedRows[values[1].gridId]) {\n            if (values[1].keepSelection === true) {\n              const ids = values[0].selectedRows[values[1].gridId]?.ids ?? [];\n              this.agGridAngular.api.forEachNode((node) => {\n                if (node.id) {\n                  node.setSelected(ids.includes(node.id));\n                }\n              });\n            }\n          }\n\n          this.initSateChangeListener();\n        });\n    });\n\n    combineLatest([this.store.state$.pipe(map((s) => selectAgGridState(s).gridStates)), this._config$])\n      .pipe(takeUntil(this.unsubsribeAll$))\n      .subscribe((values) => {\n        if (values[0][values[1].gridId]?.origin === ChangeOrigin.other) {\n          this.agGridAngular.columnApi.applyColumnState({\n            state: values[0][values[1].gridId].columnsState,\n            applyOrder: true\n          });\n        }\n      });\n\n    combineLatest([this.store.state$.pipe(map((s) => selectAgGridState(s).selectedRows)), this._config$])\n      .pipe(takeUntil(this.unsubsribeAll$))\n      .subscribe((values) => {\n        if (values[0][values[1].gridId]?.origin === ChangeOrigin.other && values[1].keepSelection === true) {\n          const ids = values[0][values[1].gridId]?.ids ?? [];\n          this.agGridAngular.api.forEachNode((node) => {\n            if (node.id) {\n              node.setSelected(ids.includes(node.id));\n            }\n          });\n        }\n      });\n\n    this.agGridAngular.getContextMenuItems = (params) => this.getContextMenuItems(params);\n  }\n\n  @Input('ngssmAgGrid') public set config(value: string | NgssmAgGridConfig) {\n    if (typeof value === 'string') {\n      this._config$.next({\n        gridId: value as string\n      });\n    } else {\n      this._config$.next(value as NgssmAgGridConfig);\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.unsubsribeAll$.next();\n    this.unsubsribeAll$.complete();\n  }\n\n  private initSateChangeListener(): void {\n    this.agGridAngular.sortChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());\n    this.agGridAngular.filterChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());\n    this.agGridAngular.columnPinned.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());\n    this.agGridAngular.columnResized.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());\n    this.agGridAngular.displayedColumnsChanged.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.saveGridState());\n    this.agGridAngular.rowSelected.pipe(takeUntil(this.unsubsribeAll$)).subscribe(() => this.processSelectionChanged());\n  }\n\n  private saveGridState(): void {\n    const state = this.agGridAngular.columnApi.getColumnState();\n    this._config$\n      .pipe(take(1))\n      .subscribe((gridId) => this.store.dispatchAction(new RegisterAgGridStateAction(gridId.gridId, ChangeOrigin.agGrid, state)));\n  }\n\n  private processSelectionChanged(): void {\n    const selectedRows = this.agGridAngular.api\n      .getSelectedNodes()\n      .map((n) => n.id ?? '')\n      .filter((n) => n !== '');\n    this._config$.pipe(take(1)).subscribe((config) => {\n      if (config.keepSelection === true) {\n        this.store.dispatchAction(new RegisterSelectedRowsAction(config.gridId, ChangeOrigin.agGrid, selectedRows));\n      }\n    });\n  }\n\n  private getContextMenuItems(params: GetContextMenuItemsParams): (string | MenuItemDef)[] {\n    const menuItems: (string | MenuItemDef)[] = [...(params.defaultItems ?? [])];\n    if (this._config$.getValue().canSaveOnDiskColumnsState === true) {\n      menuItems.push(\n        ...[\n          'separator',\n          {\n            name: 'Save columns state',\n            action: () =>\n              this._config$\n                .pipe(take(1))\n                .subscribe((config) => this.store.dispatchAction(new AgGridAction(AgGridActionType.saveColumnsStateOnDisk, config.gridId))),\n            icon: '<i class=\"fa-regular fa-floppy-disk\"></i>'\n          },\n          {\n            name: 'Restore columns state',\n            action: () =>\n              this._config$\n                .pipe(take(1))\n                .subscribe((config) =>\n                  this.store.dispatchAction(new AgGridAction(AgGridActionType.resetColumnsStateFromDisk, config.gridId))\n                ),\n            icon: '<i class=\"fa-solid fa-rotate-right\"></i>'\n          },\n          {\n            name: 'Reset columns state to default',\n            action: () => this.agGridAngular.columnApi.resetColumnState(),\n            icon: '<i class=\"fa-solid fa-clock-rotate-left\"></i>'\n          }\n        ]\n      );\n    }\n    return menuItems;\n  }\n}\n"]}

package/esm2022/lib/effects/local-storage.effect.mjs

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { NGSSM_EFFECT } from 'ngssm-store';
+import { AgGridActionType, RegisterAgGridStateAction } from '../actions';
+import { ChangeOrigin, selectAgGridState } from '../state';
+import * as i0 from "@angular/core";
+import * as i1 from "ngssm-store";
+class LocalStorageEffect {
+    constructor(logger) {
+        this.logger = logger;
+        this.processedActions = [AgGridActionType.saveColumnsStateOnDisk, AgGridActionType.resetColumnsStateFromDisk];
+    }
+    processAction(store, state, action) {
+        const agGridAction = action;
+        switch (action.type) {
+            case AgGridActionType.saveColumnsStateOnDisk:
+                const columnsState = selectAgGridState(state).gridStates[agGridAction.gridId];
+                if (columnsState) {
+                    localStorage.setItem(this.getColumnsStateLocalStorageKey(agGridAction.gridId), JSON.stringify(columnsState.columnsState));
+                }
+                break;
+            case AgGridActionType.resetColumnsStateFromDisk:
+                const stored = localStorage.getItem(this.getColumnsStateLocalStorageKey(agGridAction.gridId));
+                console.log(stored);
+                if (stored) {
+                    try {
+                        const columnsState = JSON.parse(stored);
+                        if (Array.isArray(columnsState)) {
+                            store.dispatchAction(new RegisterAgGridStateAction(agGridAction.gridId, ChangeOrigin.other, columnsState));
+                        }
+                        else {
+                            this.logger.error(`Wrong columns state config for grid '${agGridAction.gridId}'`, stored);
+                        }
+                    }
+                    catch (error) {
+                        this.logger.error(`Unable to load config for grid '${agGridAction.gridId}'`, error);
+                    }
+                }
+                break;
+        }
+    }
+    getColumnsStateLocalStorageKey(gridId) {
+        return `ngssm-ag-grid_${gridId}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect, deps: [{ token: i1.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect }); }
+}
+export { LocalStorageEffect };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Logger }]; } });
+export const localStorageEffectProvider = {
+    provide: NGSSM_EFFECT,
+    useClass: LocalStorageEffect,
+    multi: true
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/reducers/grid-states.reducer.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { NGSSM_REDUCER } from 'ngssm-store';
+import { AgGridActionType } from '../actions';
+import { updateAgGridState } from '../state';
+import * as i0 from "@angular/core";
+class GridStatesReducer {
+    constructor() {
+        this.processedActions = [AgGridActionType.registerAgGridState];
+    }
+    updateState(state, action) {
+        switch (action.type) {
+            case AgGridActionType.registerAgGridState:
+                const registerAgGridStateAction = action;
+                return updateAgGridState(state, {
+                    gridStates: {
+                        [registerAgGridStateAction.gridId]: {
+                            $set: {
+                                origin: registerAgGridStateAction.origin,
+                                columnsState: registerAgGridStateAction.columnStates
+                            }
+                        }
+                    }
+                });
+        }
+        return state;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer }); }
+}
+export { GridStatesReducer };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer, decorators: [{
+            type: Injectable
+        }] });
+export const gridStatesReducerProvider = {
+    provide: NGSSM_REDUCER,
+    useClass: GridStatesReducer,
+    multi: true
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/reducers/selected-rows.reducer.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { NGSSM_REDUCER } from 'ngssm-store';
+import { AgGridActionType } from '../actions';
+import { updateAgGridState } from '../state';
+import * as i0 from "@angular/core";
+class SelectedRowsReducer {
+    constructor() {
+        this.processedActions = [AgGridActionType.registerSelectedRows];
+    }
+    updateState(state, action) {
+        switch (action.type) {
+            case AgGridActionType.registerSelectedRows:
+                const registerSelectedRowsAction = action;
+                return updateAgGridState(state, {
+                    selectedRows: {
+                        [registerSelectedRowsAction.gridId]: {
+                            $set: {
+                                origin: registerSelectedRowsAction.origin,
+                                ids: registerSelectedRowsAction.ids
+                            }
+                        }
+                    }
+                });
+        }
+        return state;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer }); }
+}
+export { SelectedRowsReducer };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer, decorators: [{
+            type: Injectable
+        }] });
+export const selectedRowsReducerProvider = {
+    provide: NGSSM_REDUCER,
+    useClass: SelectedRowsReducer,
+    multi: true
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/state/ag-grid.state.mjs

@@ -0,0 +1,23 @@
+var AgGridStateSpecification_1;
+import { __decorate } from "tslib";
+import update from 'immutability-helper';
+import { NgSsmFeatureState } from 'ngssm-store';
+export const selectAgGridState = (state) => state[AgGridStateSpecification.featureStateKey];
+export const updateAgGridState = (state, command) => update(state, {
+    [AgGridStateSpecification.featureStateKey]: command
+});
+let AgGridStateSpecification = AgGridStateSpecification_1 = class AgGridStateSpecification {
+    static { this.featureStateKey = 'ag-grid-state'; }
+    static { this.initialState = {
+        gridStates: {},
+        selectedRows: {}
+    }; }
+};
+AgGridStateSpecification = AgGridStateSpecification_1 = __decorate([
+    NgSsmFeatureState({
+        featureStateKey: AgGridStateSpecification_1.featureStateKey,
+        initialState: AgGridStateSpecification_1.initialState
+    })
+], AgGridStateSpecification);
+export { AgGridStateSpecification };
+//# sourceMappingURL=data:application/json;base64,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

package/{fesm2020 → fesm2022}/ngssm-ag-grid.mjs

@@ -54,11 +54,11 @@ const updateAgGridState = (state, command) => update(state, {
     [AgGridStateSpecification.featureStateKey]: command
 });
 let AgGridStateSpecification = AgGridStateSpecification_1 = class AgGridStateSpecification {
-};
-AgGridStateSpecification.featureStateKey = 'ag-grid-state';
-AgGridStateSpecification.initialState = {
-    gridStates: {},
-    selectedRows: {}
+    static { this.featureStateKey = 'ag-grid-state'; }
+    static { this.initialState = {
+        gridStates: {},
+        selectedRows: {}
+    }; }
 };
 AgGridStateSpecification = AgGridStateSpecification_1 = __decorate([
     NgSsmFeatureState({
@@ -126,10 +126,10 @@ class NgssmActionsCellRendererComponent extends NgSsmComponent {
         });
         this._actionButtons$.next(actionButtons);
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmActionsCellRendererComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgssmActionsCellRendererComponent, isStandalone: true, selector: "ngssm-actions-cell-renderer", usesInheritance: true, ngImport: i0, template: "<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-NgssmActionsCellRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmActionsCellRendererComponent, deps: [{ token: i1.Store }], target: i0.ɵɵFactoryTarget.Component });
-NgssmActionsCellRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: NgssmActionsCellRendererComponent, isStandalone: true, selector: "ngssm-actions-cell-renderer", usesInheritance: true, ngImport: i0, template: "<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i3.MatIconButton, selector: "button[mat-icon-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmActionsCellRendererComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmActionsCellRendererComponent, decorators: [{
             type: Component,
             args: [{ selector: 'ngssm-actions-cell-renderer', standalone: true, imports: [CommonModule, MatButtonModule, MatIconModule, MatTooltipModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"ngssm-actions-cell\">\n    <div *ngFor=\"let actionButton of actionButtons$ | async; let index=index\">\n        <button mat-icon-button class=\"ngssm-actions-cell-button\" [color]=\"actionButton.color\" id=\"action_{{index}}\"\n            [disabled]=\"actionButton.disabled$ | async\" (click)=\"executeAction(actionButton)\"\n            [matTooltip]=\"actionButton.tooltip\" *ngIf=\"(actionButton.hidden$ | async) === false\">\n            <mat-icon [class]=\"actionButton.cssClass\"></mat-icon>\n        </button>\n    </div>\n\n</div>" }]
         }], ctorParameters: function () { return [{ type: i1.Store }]; } });
@@ -152,10 +152,10 @@ class NgssmAgGridThemeDirective {
         this.className = '';
         this.className = (options ?? new NgssmAgGridOptions()).theme;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridThemeDirective, deps: [{ token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgssmAgGridThemeDirective, isStandalone: true, selector: "[ngssmAgGridTheme]", host: { properties: { "class": "this.className" } }, ngImport: i0 }); }
 }
-NgssmAgGridThemeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmAgGridThemeDirective, deps: [{ token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-NgssmAgGridThemeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: NgssmAgGridThemeDirective, isStandalone: true, selector: "[ngssmAgGridTheme]", host: { properties: { "class": "this.className" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmAgGridThemeDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridThemeDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[ngssmAgGridTheme]',
@@ -299,10 +299,10 @@ class NgssmAgGridDirective {
         }
         return menuItems;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridDirective, deps: [{ token: i1.Store }, { token: i2$1.AgGridAngular }, { token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgssmAgGridDirective, isStandalone: true, selector: "[ngssmAgGrid]", inputs: { config: ["ngssmAgGrid", "config"] }, ngImport: i0 }); }
 }
-NgssmAgGridDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmAgGridDirective, deps: [{ token: i1.Store }, { token: i2$1.AgGridAngular }, { token: NGSSM_AG_GRID_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
-NgssmAgGridDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.8", type: NgssmAgGridDirective, isStandalone: true, selector: "[ngssmAgGrid]", inputs: { config: ["ngssmAgGrid", "config"] }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: NgssmAgGridDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgssmAgGridDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[ngssmAgGrid]',
@@ -359,10 +359,10 @@ class LocalStorageEffect {
     getColumnsStateLocalStorageKey(gridId) {
         return `ngssm-ag-grid_${gridId}`;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect, deps: [{ token: i1.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect }); }
 }
-LocalStorageEffect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: LocalStorageEffect, deps: [{ token: i1.Logger }], target: i0.ɵɵFactoryTarget.Injectable });
-LocalStorageEffect.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: LocalStorageEffect });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: LocalStorageEffect, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LocalStorageEffect, decorators: [{
             type: Injectable
         }], ctorParameters: function () { return [{ type: i1.Logger }]; } });
 const localStorageEffectProvider = {
@@ -392,10 +392,10 @@ class GridStatesReducer {
         }
         return state;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer }); }
 }
-GridStatesReducer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: GridStatesReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-GridStatesReducer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: GridStatesReducer });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: GridStatesReducer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: GridStatesReducer, decorators: [{
             type: Injectable
         }] });
 const gridStatesReducerProvider = {
@@ -425,10 +425,10 @@ class SelectedRowsReducer {
         }
         return state;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer }); }
 }
-SelectedRowsReducer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SelectedRowsReducer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-SelectedRowsReducer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SelectedRowsReducer });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: SelectedRowsReducer, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SelectedRowsReducer, decorators: [{
             type: Injectable
         }] });
 const selectedRowsReducerProvider = {