angular-slickgrid 3.3.0 → 4.1.0

package/esm2020/app/modules/angular-slickgrid/components/angular-slickgrid.component.mjs

@@ -0,0 +1,1167 @@
+// import 3rd party vendor libs
+// only import the necessary core lib, each will be imported on demand when enabled (via require)
+import 'jquery-ui/ui/widgets/draggable';
+import 'jquery-ui/ui/widgets/droppable';
+import 'jquery-ui/ui/widgets/sortable';
+import 'slickgrid/lib/jquery.event.drag-2.3.0';
+import 'slickgrid/lib/jquery.mousewheel';
+import 'slickgrid/slick.core';
+import 'slickgrid/slick.grid';
+import 'slickgrid/slick.dataview';
+// ...then everything else...
+import { ApplicationRef, Component, Inject, Input, Optional, } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ExtensionName, 
+// services
+BackendUtilityService, CollectionService, EventNamingStyle, ExtensionService, ExtensionUtility, FilterFactory, FilterService, GridEventService, GridService, GridStateService, GroupingAndColspanService, PaginationService, ResizerService, SharedService, SlickgridConfig, SlickGroupItemMetadataProvider, SortService, TreeDataService, 
+// utilities
+autoAddEditorFormatterToColumnsWithEditor, emptyElement, GridStateType, unsubscribeAll, } from '@slickgrid-universal/common';
+import { EventPubSubService } from '@slickgrid-universal/event-pub-sub';
+import { SlickEmptyWarningComponent } from '@slickgrid-universal/empty-warning-component';
+import { SlickFooterComponent } from '@slickgrid-universal/custom-footer-component';
+import { SlickPaginationComponent } from '@slickgrid-universal/pagination-component';
+import { RxJsResource } from '@slickgrid-universal/rxjs-observable';
+import { dequal } from 'dequal/lite';
+import { Constants } from '../constants';
+import { GlobalGridOptions } from './../global-grid-options';
+import { TranslaterService } from '../services/translater.service';
+// Services
+import { AngularUtilService } from '../services/angularUtil.service';
+import { SlickRowDetailView } from '../extensions/slickRowDetailView';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/angularUtil.service";
+import * as i2 from "../services/container.service";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../services/translater.service";
+export class AngularSlickgridComponent {
+    constructor(angularUtilService, appRef, cd, containerService, elm, translate, translaterService, forRootConfig, externalServices) {
+        this.angularUtilService = angularUtilService;
+        this.appRef = appRef;
+        this.cd = cd;
+        this.containerService = containerService;
+        this.elm = elm;
+        this.translate = translate;
+        this.translaterService = translaterService;
+        this.forRootConfig = forRootConfig;
+        this._currentDatasetLength = 0;
+        this._eventHandler = new Slick.EventHandler();
+        this._hideHeaderRowAfterPageLoad = false;
+        this._isGridInitialized = false;
+        this._isDatasetInitialized = false;
+        this._isDatasetHierarchicalInitialized = false;
+        this._isPaginationInitialized = false;
+        this._isLocalGrid = true;
+        this._registeredResources = [];
+        this.groupingDefinition = {};
+        this.showPagination = false;
+        this.serviceList = [];
+        this.totalItems = 0;
+        this.subscriptions = [];
+        this.gridId = '';
+        const slickgridConfig = new SlickgridConfig();
+        // initialize and assign all Service Dependencies
+        this._eventPubSubService = externalServices?.eventPubSubService ?? new EventPubSubService(this.elm.nativeElement);
+        this._eventPubSubService.eventNamingStyle = EventNamingStyle.camelCase;
+        this.backendUtilityService = externalServices?.backendUtilityService ?? new BackendUtilityService();
+        this.gridEventService = externalServices?.gridEventService ?? new GridEventService();
+        this.sharedService = externalServices?.sharedService ?? new SharedService();
+        this.collectionService = externalServices?.collectionService ?? new CollectionService(this.translaterService);
+        this.extensionUtility = externalServices?.extensionUtility ?? new ExtensionUtility(this.sharedService, this.backendUtilityService, this.translaterService);
+        this.filterFactory = new FilterFactory(slickgridConfig, this.translaterService, this.collectionService);
+        this.filterService = externalServices?.filterService ?? new FilterService(this.filterFactory, this._eventPubSubService, this.sharedService, this.backendUtilityService);
+        this.resizerService = externalServices?.resizerService ?? new ResizerService(this._eventPubSubService);
+        this.sortService = externalServices?.sortService ?? new SortService(this.sharedService, this._eventPubSubService, this.backendUtilityService);
+        this.treeDataService = externalServices?.treeDataService ?? new TreeDataService(this._eventPubSubService, this.sharedService, this.sortService);
+        this.paginationService = externalServices?.paginationService ?? new PaginationService(this._eventPubSubService, this.sharedService, this.backendUtilityService);
+        this.extensionService = externalServices?.extensionService ?? new ExtensionService(this.extensionUtility, this.filterService, this._eventPubSubService, this.sharedService, this.sortService, this.treeDataService, this.translaterService);
+        this.gridStateService = externalServices?.gridStateService ?? new GridStateService(this.extensionService, this.filterService, this._eventPubSubService, this.sharedService, this.sortService, this.treeDataService);
+        this.gridService = externalServices?.gridService ?? new GridService(this.gridStateService, this.filterService, this._eventPubSubService, this.paginationService, this.sharedService, this.sortService, this.treeDataService);
+        this.groupingService = externalServices?.groupingAndColspanService ?? new GroupingAndColspanService(this.extensionUtility, this._eventPubSubService);
+        this.serviceList = [
+            this.extensionService,
+            this.filterService,
+            this.gridEventService,
+            this.gridService,
+            this.gridStateService,
+            this.groupingService,
+            this.paginationService,
+            this.resizerService,
+            this.sortService,
+            this.treeDataService,
+        ];
+        // register all Service instances in the container
+        this.containerService.registerInstance('ExtensionUtility', this.extensionUtility);
+        this.containerService.registerInstance('FilterService', this.filterService);
+        this.containerService.registerInstance('CollectionService', this.collectionService);
+        this.containerService.registerInstance('ExtensionService', this.extensionService);
+        this.containerService.registerInstance('GridEventService', this.gridEventService);
+        this.containerService.registerInstance('GridService', this.gridService);
+        this.containerService.registerInstance('GridStateService', this.gridStateService);
+        this.containerService.registerInstance('GroupingAndColspanService', this.groupingService);
+        this.containerService.registerInstance('PaginationService', this.paginationService);
+        this.containerService.registerInstance('ResizerService', this.resizerService);
+        this.containerService.registerInstance('SharedService', this.sharedService);
+        this.containerService.registerInstance('SortService', this.sortService);
+        this.containerService.registerInstance('EventPubSubService', this._eventPubSubService);
+        this.containerService.registerInstance('PubSubService', this._eventPubSubService);
+        this.containerService.registerInstance('TranslaterService', this.translaterService);
+        this.containerService.registerInstance('TreeDataService', this.treeDataService);
+    }
+    get paginationOptions() {
+        return this._paginationOptions;
+    }
+    set paginationOptions(newPaginationOptions) {
+        if (newPaginationOptions && this._paginationOptions) {
+            this._paginationOptions = { ...this.gridOptions.pagination, ...this._paginationOptions, ...newPaginationOptions };
+        }
+        else {
+            this._paginationOptions = newPaginationOptions;
+        }
+        this.gridOptions.pagination = this._paginationOptions ?? this.gridOptions.pagination;
+        this.paginationService.updateTotalItems(this.gridOptions.pagination?.totalItems ?? 0, true);
+    }
+    set columnDefinitions(columnDefinitions) {
+        this._columnDefinitions = columnDefinitions;
+        if (this._isGridInitialized) {
+            this.updateColumnDefinitionsList(columnDefinitions);
+        }
+        if (columnDefinitions.length > 0) {
+            this.copyColumnWidthsReference(columnDefinitions);
+        }
+    }
+    get columnDefinitions() {
+        return this._columnDefinitions;
+    }
+    get dataset() {
+        return (this.customDataView ? this.slickGrid?.getData?.() : this.dataView?.getItems?.()) || [];
+    }
+    set dataset(newDataset) {
+        const prevDatasetLn = this._currentDatasetLength;
+        const isDatasetEqual = dequal(newDataset, this._dataset || []);
+        let data = newDataset;
+        // when Tree Data is enabled and we don't yet have the hierarchical dataset filled, we can force a convert+sort of the array
+        if (this.slickGrid && this.gridOptions?.enableTreeData && Array.isArray(newDataset) && (newDataset.length > 0 || newDataset.length !== prevDatasetLn || !isDatasetEqual)) {
+            this._isDatasetHierarchicalInitialized = false;
+            data = this.sortTreeDataset(newDataset, !isDatasetEqual); // if dataset changed, then force a refresh anyway
+        }
+        this._dataset = data;
+        this.refreshGridData(data || []);
+        this._currentDatasetLength = (newDataset || []).length;
+        // expand/autofit columns on first page load
+        // we can assume that if the prevDataset was empty then we are on first load
+        if (this.gridOptions?.autoFitColumnsOnFirstLoad && prevDatasetLn === 0) {
+            this.slickGrid.autosizeColumns();
+        }
+    }
+    get datasetHierarchical() {
+        return this.sharedService.hierarchicalDataset;
+    }
+    set datasetHierarchical(newHierarchicalDataset) {
+        const isDatasetEqual = dequal(newHierarchicalDataset, this.sharedService?.hierarchicalDataset ?? []);
+        const prevFlatDatasetLn = this._currentDatasetLength;
+        this.sharedService.hierarchicalDataset = newHierarchicalDataset;
+        if (newHierarchicalDataset && this.columnDefinitions && this.filterService?.clearFilters) {
+            this.filterService.clearFilters();
+        }
+        // when a hierarchical dataset is set afterward, we can reset the flat dataset and call a tree data sort that will overwrite the flat dataset
+        if (newHierarchicalDataset && this.slickGrid && this.sortService?.processTreeDataInitialSort) {
+            this.dataView.setItems([], this.gridOptions.datasetIdPropertyName ?? 'id');
+            this.sortService.processTreeDataInitialSort();
+            // we also need to reset/refresh the Tree Data filters because if we inserted new item(s) then it might not show up without doing this refresh
+            // however we need 1 cpu cycle before having the DataView refreshed, so we need to wrap this check in a setTimeout
+            setTimeout(() => {
+                const flatDatasetLn = this.dataView.getItemCount();
+                if (flatDatasetLn > 0 && (flatDatasetLn !== prevFlatDatasetLn || !isDatasetEqual)) {
+                    this.filterService.refreshTreeDataFilters();
+                }
+            });
+            this._isDatasetHierarchicalInitialized = true;
+        }
+    }
+    get elementRef() {
+        return this.elm;
+    }
+    get eventHandler() {
+        return this._eventHandler;
+    }
+    get gridContainerElement() {
+        return document.querySelector(`#${this.gridOptions.gridContainerId || ''}`);
+    }
+    /** GETTER to know if dataset was initialized or not */
+    get isDatasetInitialized() {
+        return this._isDatasetInitialized;
+    }
+    /** SETTER to change if dataset was initialized or not (stringly used for unit testing purposes) */
+    set isDatasetInitialized(isInitialized) {
+        this._isDatasetInitialized = isInitialized;
+    }
+    set isDatasetHierarchicalInitialized(isInitialized) {
+        this._isDatasetHierarchicalInitialized = isInitialized;
+    }
+    get registeredResources() {
+        return this._registeredResources;
+    }
+    ngAfterViewInit() {
+        this.initialization(this._eventHandler);
+        this._isGridInitialized = true;
+        // recheck the empty warning message after grid is shown so that it works in every use case
+        if (this.gridOptions && this.gridOptions.enableEmptyDataWarningMessage && Array.isArray(this.dataset)) {
+            const finalTotalCount = this.dataset.length;
+            this.displayEmptyDataWarning(finalTotalCount < 1);
+        }
+    }
+    ngOnDestroy() {
+        this._eventPubSubService.publish('onBeforeGridDestroy', this.slickGrid);
+        this.destroy();
+        this._eventPubSubService.publish('onAfterGridDestroyed', true);
+    }
+    destroy(shouldEmptyDomElementContainer = false) {
+        // dispose of all Services
+        this.serviceList.forEach((service) => {
+            if (service && service.dispose) {
+                service.dispose();
+            }
+        });
+        this.serviceList = [];
+        // dispose all registered external resources
+        if (Array.isArray(this._registeredResources)) {
+            while (this._registeredResources.length > 0) {
+                const resource = this._registeredResources.pop();
+                if (resource?.dispose) {
+                    resource.dispose();
+                }
+            }
+            this._registeredResources = [];
+        }
+        // dispose the Components
+        this.slickEmptyWarning?.dispose();
+        this.slickFooter?.dispose();
+        this.slickPagination?.dispose();
+        if (this._eventHandler?.unsubscribeAll) {
+            this._eventHandler.unsubscribeAll();
+        }
+        this._eventPubSubService?.unsubscribeAll();
+        if (this.dataView) {
+            if (this.dataView?.setItems) {
+                this.dataView.setItems([]);
+            }
+            if (this.dataView.destroy) {
+                this.dataView.destroy();
+            }
+        }
+        if (this.slickGrid?.destroy) {
+            this.slickGrid.destroy(shouldEmptyDomElementContainer);
+        }
+        if (this.backendServiceApi) {
+            for (const prop of Object.keys(this.backendServiceApi)) {
+                delete this.backendServiceApi[prop];
+            }
+            this.backendServiceApi = undefined;
+        }
+        for (const prop of Object.keys(this.columnDefinitions)) {
+            this.columnDefinitions[prop] = null;
+        }
+        for (const prop of Object.keys(this.sharedService)) {
+            this.sharedService[prop] = null;
+        }
+        // we could optionally also empty the content of the grid container DOM element
+        if (shouldEmptyDomElementContainer) {
+            this.emptyGridContainerElm();
+        }
+        // also unsubscribe all RxJS subscriptions
+        this.subscriptions = unsubscribeAll(this.subscriptions);
+        this._dataset = null;
+        this.datasetHierarchical = undefined;
+        this._columnDefinitions = [];
+        this._angularGridInstances = undefined;
+    }
+    emptyGridContainerElm() {
+        const gridContainerId = this.gridOptions?.gridContainerId ?? 'grid1';
+        const gridContainerElm = document.querySelector(`#${gridContainerId}`);
+        emptyElement(gridContainerElm);
+    }
+    /**
+     * Define our internal Post Process callback, it will execute internally after we get back result from the Process backend call
+     * For now, this is GraphQL Service ONLY feature and it will basically refresh the Dataset & Pagination without having the user to create his own PostProcess every time
+     */
+    createBackendApiInternalPostProcessCallback(gridOptions) {
+        const backendApi = gridOptions && gridOptions.backendServiceApi;
+        if (backendApi && backendApi.service) {
+            const backendApiService = backendApi.service;
+            // internalPostProcess only works (for now) with a GraphQL Service, so make sure it is of that type
+            if (typeof backendApiService.getDatasetName === 'function') {
+                backendApi.internalPostProcess = (processResult) => {
+                    const datasetName = (backendApi && backendApiService && typeof backendApiService.getDatasetName === 'function') ? backendApiService.getDatasetName() : '';
+                    if (processResult?.data[datasetName]) {
+                        const data = processResult.data[datasetName].hasOwnProperty('nodes') ? processResult.data[datasetName].nodes : processResult.data[datasetName];
+                        const totalCount = processResult.data[datasetName].hasOwnProperty('totalCount') ? processResult.data[datasetName].totalCount : processResult.data[datasetName].length;
+                        this.refreshGridData(data, totalCount || 0);
+                    }
+                };
+            }
+        }
+    }
+    initialization(eventHandler) {
+        this.gridOptions.translater = this.translaterService;
+        this._eventHandler = eventHandler;
+        // when detecting a frozen grid, we'll automatically enable the mousewheel scroll handler so that we can scroll from both left/right frozen containers
+        if (this.gridOptions && ((this.gridOptions.frozenRow !== undefined && this.gridOptions.frozenRow >= 0) || this.gridOptions.frozenColumn !== undefined && this.gridOptions.frozenColumn >= 0) && this.gridOptions.enableMouseWheelScrollHandler === undefined) {
+            this.gridOptions.enableMouseWheelScrollHandler = true;
+        }
+        this._eventPubSubService.eventNamingStyle = this.gridOptions?.eventNamingStyle ?? EventNamingStyle.camelCase;
+        this._eventPubSubService.publish('onBeforeGridCreate', true);
+        // make sure the dataset is initialized (if not it will throw an error that it cannot getLength of null)
+        this._dataset = this._dataset || [];
+        this.gridOptions = this.mergeGridOptions(this.gridOptions);
+        this._paginationOptions = this.gridOptions?.pagination;
+        this.locales = this.gridOptions?.locales ?? Constants.locales;
+        this.backendServiceApi = this.gridOptions?.backendServiceApi;
+        this._isLocalGrid = !this.backendServiceApi; // considered a local grid if it doesn't have a backend service set
+        this.createBackendApiInternalPostProcessCallback(this.gridOptions);
+        if (!this.customDataView) {
+            const dataviewInlineFilters = this.gridOptions.dataView && this.gridOptions.dataView.inlineFilters || false;
+            let dataViewOptions = { inlineFilters: dataviewInlineFilters };
+            if (this.gridOptions.draggableGrouping || this.gridOptions.enableGrouping) {
+                this.groupItemMetadataProvider = new SlickGroupItemMetadataProvider();
+                this.sharedService.groupItemMetadataProvider = this.groupItemMetadataProvider;
+                dataViewOptions = { ...dataViewOptions, groupItemMetadataProvider: this.groupItemMetadataProvider };
+            }
+            this.dataView = new Slick.Data.DataView(dataViewOptions);
+            this._eventPubSubService.publish('onDataviewCreated', this.dataView);
+        }
+        // get any possible Services that user want to register which don't require SlickGrid to be instantiated
+        // RxJS Resource is in this lot because it has to be registered before anything else and doesn't require SlickGrid to be initialized
+        this.preRegisterResources();
+        // for convenience to the user, we provide the property "editor" as an Angular-Slickgrid editor complex object
+        // however "editor" is used internally by SlickGrid for it's own Editor Factory
+        // so in our lib we will swap "editor" and copy it into a new property called "internalColumnEditor"
+        // then take back "editor.model" and make it the new "editor" so that SlickGrid Editor Factory still works
+        this._columnDefinitions = this.swapInternalEditorToSlickGridFactoryEditor(this._columnDefinitions);
+        // if the user wants to automatically add a Custom Editor Formatter, we need to call the auto add function again
+        if (this.gridOptions.autoAddCustomEditorFormatter) {
+            autoAddEditorFormatterToColumnsWithEditor(this._columnDefinitions, this.gridOptions.autoAddCustomEditorFormatter);
+        }
+        // save reference for all columns before they optionally become hidden/visible
+        this.sharedService.allColumns = this._columnDefinitions;
+        this.sharedService.visibleColumns = this._columnDefinitions;
+        this.extensionService.createExtensionsBeforeGridCreation(this._columnDefinitions, this.gridOptions);
+        // if user entered some Pinning/Frozen "presets", we need to apply them in the grid options
+        if (this.gridOptions.presets?.pinning) {
+            this.gridOptions = { ...this.gridOptions, ...this.gridOptions.presets.pinning };
+        }
+        // build SlickGrid Grid, also user might optionally pass a custom dataview (e.g. remote model)
+        this.slickGrid = new Slick.Grid(`#${this.gridId}`, this.customDataView || this.dataView, this._columnDefinitions, this.gridOptions);
+        this.sharedService.dataView = this.dataView;
+        this.sharedService.slickGrid = this.slickGrid;
+        this.sharedService.gridContainerElement = this.elm.nativeElement;
+        this.extensionService.bindDifferentExtensions();
+        this.bindDifferentHooks(this.slickGrid, this.gridOptions, this.dataView);
+        // when it's a frozen grid, we need to keep the frozen column id for reference if we ever show/hide column from ColumnPicker/GridMenu afterward
+        const frozenColumnIndex = this.gridOptions.frozenColumn !== undefined ? this.gridOptions.frozenColumn : -1;
+        if (frozenColumnIndex >= 0 && frozenColumnIndex <= this._columnDefinitions.length) {
+            this.sharedService.frozenVisibleColumnId = this._columnDefinitions[frozenColumnIndex].id || '';
+        }
+        // get any possible Services that user want to register
+        this.registerResources();
+        // initialize the SlickGrid grid
+        this.slickGrid.init();
+        // initialized the resizer service only after SlickGrid is initialized
+        // if we don't we end up binding our resize to a grid element that doesn't yet exist in the DOM and the resizer service will fail silently (because it has a try/catch that unbinds the resize without throwing back)
+        if (this.gridContainerElement) {
+            this.resizerService.init(this.slickGrid, this.gridContainerElement);
+        }
+        // user could show a custom footer with the data metrics (dataset length and last updated timestamp)
+        if (!this.gridOptions.enablePagination && this.gridOptions.showCustomFooter && this.gridOptions.customFooterOptions && this.gridContainerElement) {
+            this.slickFooter = new SlickFooterComponent(this.slickGrid, this.gridOptions.customFooterOptions, this._eventPubSubService, this.translaterService);
+            this.slickFooter.renderFooter(this.gridContainerElement);
+        }
+        if (!this.customDataView && this.dataView) {
+            // load the data in the DataView (unless it's a hierarchical dataset, if so it will be loaded after the initial tree sort)
+            const initialDataset = this.gridOptions?.enableTreeData ? this.sortTreeDataset(this._dataset) : this._dataset;
+            this.dataView.beginUpdate();
+            this.dataView.setItems(initialDataset || [], this.gridOptions.datasetIdPropertyName ?? 'id');
+            this.dataView.endUpdate();
+            // if you don't want the items that are not visible (due to being filtered out or being on a different page)
+            // to stay selected, pass 'false' to the second arg
+            const selectionModel = this.slickGrid?.getSelectionModel();
+            if (selectionModel && this.gridOptions && this.gridOptions.dataView && this.gridOptions.dataView.hasOwnProperty('syncGridSelection')) {
+                // if we are using a Backend Service, we will do an extra flag check, the reason is because it might have some unintended behaviors
+                // with the BackendServiceApi because technically the data in the page changes the DataView on every page change.
+                let preservedRowSelectionWithBackend = false;
+                if (this.gridOptions.backendServiceApi && this.gridOptions.dataView.hasOwnProperty('syncGridSelectionWithBackendService')) {
+                    preservedRowSelectionWithBackend = this.gridOptions.dataView.syncGridSelectionWithBackendService;
+                }
+                const syncGridSelection = this.gridOptions.dataView.syncGridSelection;
+                if (typeof syncGridSelection === 'boolean') {
+                    let preservedRowSelection = syncGridSelection;
+                    if (!this._isLocalGrid) {
+                        // when using BackendServiceApi, we'll be using the "syncGridSelectionWithBackendService" flag BUT "syncGridSelection" must also be set to True
+                        preservedRowSelection = syncGridSelection && preservedRowSelectionWithBackend;
+                    }
+                    this.dataView.syncGridSelection(this.slickGrid, preservedRowSelection);
+                }
+                else if (typeof syncGridSelection === 'object') {
+                    this.dataView.syncGridSelection(this.slickGrid, syncGridSelection.preserveHidden, syncGridSelection.preserveHiddenOnSelectionChange);
+                }
+            }
+            const datasetLn = this.dataView.getLength() || this._dataset && this._dataset.length || 0;
+            if (datasetLn > 0) {
+                if (!this._isDatasetInitialized && (this.gridOptions.enableCheckboxSelector || this.gridOptions.enableRowSelection)) {
+                    this.loadRowSelectionPresetWhenExists();
+                }
+                this.loadFilterPresetsWhenDatasetInitialized();
+                this._isDatasetInitialized = true;
+            }
+        }
+        // user might want to hide the header row on page load but still have `enableFiltering: true`
+        // if that is the case, we need to hide the headerRow ONLY AFTER all filters got created & dataView exist
+        if (this._hideHeaderRowAfterPageLoad) {
+            this.showHeaderRow(false);
+            this.sharedService.hideHeaderRowAfterPageLoad = this._hideHeaderRowAfterPageLoad;
+        }
+        // publish & dispatch certain events
+        this._eventPubSubService.publish('onGridCreated', this.slickGrid);
+        // after the DataView is created & updated execute some processes
+        if (!this.customDataView) {
+            this.executeAfterDataviewCreated(this.slickGrid, this.gridOptions);
+        }
+        // bind resize ONLY after the dataView is ready
+        this.bindResizeHook(this.slickGrid, this.gridOptions);
+        // bind the Backend Service API callback functions only after the grid is initialized
+        // because the preProcess() and onInit() might get triggered
+        if (this.gridOptions?.backendServiceApi) {
+            this.bindBackendCallbackFunctions(this.gridOptions);
+        }
+        // local grid, check if we need to show the Pagination
+        // if so then also check if there's any presets and finally initialize the PaginationService
+        // a local grid with Pagination presets will potentially have a different total of items, we'll need to get it from the DataView and update our total
+        if (this.gridOptions?.enablePagination && this._isLocalGrid) {
+            this.showPagination = true;
+            this.loadLocalGridPagination(this.dataset);
+        }
+        this._angularGridInstances = {
+            // Slick Grid & DataView objects
+            dataView: this.dataView,
+            slickGrid: this.slickGrid,
+            extensions: this.extensionService?.extensionList,
+            // public methods
+            destroy: this.destroy.bind(this),
+            // return all available Services (non-singleton)
+            backendService: this.gridOptions?.backendServiceApi?.service,
+            filterService: this.filterService,
+            gridEventService: this.gridEventService,
+            gridStateService: this.gridStateService,
+            gridService: this.gridService,
+            groupingService: this.groupingService,
+            extensionService: this.extensionService,
+            paginationService: this.paginationService,
+            resizerService: this.resizerService,
+            sortService: this.sortService,
+            treeDataService: this.treeDataService,
+        };
+        // all instances (SlickGrid, DataView & all Services)
+        this._eventPubSubService.publish('onAngularGridCreated', this._angularGridInstances);
+    }
+    /**
+     * On a Pagination changed, we will trigger a Grid State changed with the new pagination info
+     * Also if we use Row Selection or the Checkbox Selector, we need to reset any selection
+     */
+    paginationChanged(pagination) {
+        const isSyncGridSelectionEnabled = this.gridStateService?.needToPreserveRowSelection() ?? false;
+        if (!isSyncGridSelectionEnabled && (this.gridOptions.enableRowSelection || this.gridOptions.enableCheckboxSelector)) {
+            this.slickGrid.setSelectedRows([]);
+        }
+        const { pageNumber, pageSize } = pagination;
+        if (this.sharedService) {
+            if (pageSize !== undefined && pageNumber !== undefined) {
+                this.sharedService.currentPagination = { pageNumber, pageSize };
+            }
+        }
+        this._eventPubSubService.publish('onGridStateChanged', {
+            change: { newValues: { pageNumber, pageSize }, type: GridStateType.pagination },
+            gridState: this.gridStateService.getCurrentGridState()
+        });
+        this.cd.markForCheck();
+    }
+    /**
+     * When dataset changes, we need to refresh the entire grid UI & possibly resize it as well
+     * @param dataset
+     */
+    refreshGridData(dataset, totalCount) {
+        if (this.gridOptions && this.gridOptions.enableEmptyDataWarningMessage && Array.isArray(dataset)) {
+            const finalTotalCount = totalCount || dataset.length;
+            this.displayEmptyDataWarning(finalTotalCount < 1);
+        }
+        if (Array.isArray(dataset) && this.slickGrid && this.dataView?.setItems) {
+            this.dataView.setItems(dataset, this.gridOptions.datasetIdPropertyName ?? 'id');
+            if (!this.gridOptions.backendServiceApi && !this.gridOptions.enableTreeData) {
+                this.dataView.reSort();
+            }
+            if (dataset.length > 0) {
+                if (!this._isDatasetInitialized) {
+                    this.loadFilterPresetsWhenDatasetInitialized();
+                    if (this.gridOptions.enableCheckboxSelector) {
+                        this.loadRowSelectionPresetWhenExists();
+                    }
+                }
+                this._isDatasetInitialized = true;
+            }
+            if (dataset) {
+                this.slickGrid.invalidate();
+            }
+            // display the Pagination component only after calling this refresh data first, we call it here so that if we preset pagination page number it will be shown correctly
+            this.showPagination = (this.gridOptions && (this.gridOptions.enablePagination || (this.gridOptions.backendServiceApi && this.gridOptions.enablePagination === undefined))) ? true : false;
+            if (this._paginationOptions && this.gridOptions?.pagination && this.gridOptions?.backendServiceApi) {
+                const paginationOptions = this.setPaginationOptionsWhenPresetDefined(this.gridOptions, this._paginationOptions);
+                // when we have a totalCount use it, else we'll take it from the pagination object
+                // only update the total items if it's different to avoid refreshing the UI
+                const totalRecords = (totalCount !== undefined) ? totalCount : (this.gridOptions?.pagination?.totalItems);
+                if (totalRecords !== undefined && totalRecords !== this.totalItems) {
+                    this.totalItems = +totalRecords;
+                }
+                // initialize the Pagination Service with new pagination options (which might have presets)
+                if (!this._isPaginationInitialized) {
+                    this.initializePaginationService(paginationOptions);
+                }
+                else {
+                    // update the pagination service with the new total
+                    this.paginationService.updateTotalItems(this.totalItems);
+                }
+            }
+            // resize the grid inside a slight timeout, in case other DOM element changed prior to the resize (like a filter/pagination changed)
+            if (this.slickGrid && this.gridOptions.enableAutoResize) {
+                const delay = this.gridOptions.autoResize && this.gridOptions.autoResize.delay;
+                this.resizerService.resizeGrid(delay || 10);
+            }
+        }
+    }
+    /**
+     * Check if there's any Pagination Presets defined in the Grid Options,
+     * if there are then load them in the paginationOptions object
+     */
+    setPaginationOptionsWhenPresetDefined(gridOptions, paginationOptions) {
+        if (gridOptions.presets?.pagination && paginationOptions && !this._isPaginationInitialized) {
+            paginationOptions.pageSize = gridOptions.presets.pagination.pageSize;
+            paginationOptions.pageNumber = gridOptions.presets.pagination.pageNumber;
+        }
+        return paginationOptions;
+    }
+    /**
+     * Dynamically change or update the column definitions list.
+     * We will re-render the grid so that the new header and data shows up correctly.
+     * If using i18n, we also need to trigger a re-translate of the column headers
+     */
+    updateColumnDefinitionsList(newColumnDefinitions) {
+        // map/swap the internal library Editor to the SlickGrid Editor factory
+        newColumnDefinitions = this.swapInternalEditorToSlickGridFactoryEditor(newColumnDefinitions);
+        if (this.gridOptions.enableTranslate) {
+            this.extensionService.translateColumnHeaders(false, newColumnDefinitions);
+        }
+        else {
+            this.extensionService.renderColumnHeaders(newColumnDefinitions, true);
+        }
+        if (this.gridOptions?.enableAutoSizeColumns) {
+            this.slickGrid.autosizeColumns();
+        }
+        else if (this.gridOptions?.enableAutoResizeColumnsByCellContent && this.resizerService?.resizeColumnsByCellContent) {
+            this.resizerService.resizeColumnsByCellContent();
+        }
+    }
+    /**
+     * Show the filter row displayed on first row, we can optionally pass false to hide it.
+     * @param showing
+     */
+    showHeaderRow(showing = true) {
+        this.slickGrid.setHeaderRowVisibility(showing, false);
+        if (showing === true && this._isGridInitialized) {
+            this.slickGrid.setColumns(this.columnDefinitions);
+        }
+        return showing;
+    }
+    //
+    // private functions
+    // ------------------
+    /**
+     * Loop through all column definitions and copy the original optional `width` properties optionally provided by the user.
+     * We will use this when doing a resize by cell content, if user provided a `width` it won't override it.
+     */
+    copyColumnWidthsReference(columnDefinitions) {
+        columnDefinitions.forEach(col => col.originalWidth = col.width);
+    }
+    displayEmptyDataWarning(showWarning = true) {
+        this.slickEmptyWarning?.showEmptyDataMessage(showWarning);
+    }
+    bindDifferentHooks(grid, gridOptions, dataView) {
+        // on locale change, we have to manually translate the Headers, GridMenu
+        if (this.translate?.onLangChange) {
+            // translate some of them on first load, then on each language change
+            if (gridOptions.enableTranslate) {
+                this.extensionService.translateAllExtensions();
+                this.translateColumnHeaderTitleKeys();
+                this.translateColumnGroupKeys();
+            }
+            this.subscriptions.push(this.translate.onLangChange.subscribe(() => {
+                // publish event of the same name that Slickgrid-Universal uses on a language change event
+                this._eventPubSubService.publish('onLanguageChange');
+                if (gridOptions.enableTranslate) {
+                    this.extensionService.translateAllExtensions();
+                    this.translateColumnHeaderTitleKeys();
+                    this.translateColumnGroupKeys();
+                    if (gridOptions.createPreHeaderPanel && !gridOptions.enableDraggableGrouping) {
+                        this.groupingService.translateGroupingAndColSpan();
+                    }
+                }
+            }));
+        }
+        // if user set an onInit Backend, we'll run it right away (and if so, we also need to run preProcess, internalPostProcess & postProcess)
+        if (gridOptions.backendServiceApi) {
+            const backendApi = gridOptions.backendServiceApi;
+            if (backendApi?.service?.init) {
+                backendApi.service.init(backendApi.options, gridOptions.pagination, this.slickGrid, this.sharedService);
+            }
+        }
+        if (dataView && grid) {
+            const slickgridEventPrefix = this.gridOptions?.defaultSlickgridEventPrefix ?? '';
+            // expose all Slick Grid Events through dispatch
+            for (const prop in grid) {
+                if (grid.hasOwnProperty(prop) && prop.startsWith('on')) {
+                    const gridEventName = this._eventPubSubService.getEventNameByNamingConvention(prop, slickgridEventPrefix);
+                    this._eventHandler.subscribe(grid[prop], (event, args) => {
+                        return this._eventPubSubService.dispatchCustomEvent(gridEventName, { eventData: event, args });
+                    });
+                }
+            }
+            // expose all Slick DataView Events through dispatch
+            for (const prop in dataView) {
+                if (dataView.hasOwnProperty(prop) && prop.startsWith('on')) {
+                    this._eventHandler.subscribe(dataView[prop], (event, args) => {
+                        const dataViewEventName = this._eventPubSubService.getEventNameByNamingConvention(prop, slickgridEventPrefix);
+                        return this._eventPubSubService.dispatchCustomEvent(dataViewEventName, { eventData: event, args });
+                    });
+                }
+            }
+            // on cell click, mainly used with the columnDef.action callback
+            this.gridEventService.bindOnCellChange(grid);
+            this.gridEventService.bindOnClick(grid);
+            if (dataView && grid) {
+                // bind external sorting (backend) when available or default onSort (dataView)
+                if (gridOptions.enableSorting) {
+                    // bind external sorting (backend) unless specified to use the local one
+                    if (gridOptions.backendServiceApi && !gridOptions.backendServiceApi.useLocalSorting) {
+                        this.sortService.bindBackendOnSort(grid);
+                    }
+                    else {
+                        this.sortService.bindLocalOnSort(grid);
+                    }
+                }
+                // bind external filter (backend) when available or default onFilter (dataView)
+                if (gridOptions.enableFiltering) {
+                    this.filterService.init(grid);
+                    // bind external filter (backend) unless specified to use the local one
+                    if (gridOptions.backendServiceApi && !gridOptions.backendServiceApi.useLocalFiltering) {
+                        this.filterService.bindBackendOnFilter(grid);
+                    }
+                    else {
+                        this.filterService.bindLocalOnFilter(grid);
+                    }
+                }
+                // load any presets if any (after dataset is initialized)
+                this.loadColumnPresetsWhenDatasetInitialized();
+                this.loadFilterPresetsWhenDatasetInitialized();
+                // When data changes in the DataView, we need to refresh the metrics and/or display a warning if the dataset is empty
+                this._eventHandler.subscribe(dataView.onRowCountChanged, () => {
+                    grid.invalidate();
+                    this.handleOnItemCountChanged(this.dataView.getFilteredItemCount() || 0, dataView.getItemCount());
+                });
+                this._eventHandler.subscribe(dataView.onSetItemsCalled, (_e, args) => {
+                    grid.invalidate();
+                    this.handleOnItemCountChanged(this.dataView.getFilteredItemCount(), args.itemCount);
+                    // when user has resize by content enabled, we'll force a full width calculation since we change our entire dataset
+                    if (args.itemCount > 0 && (this.gridOptions.autosizeColumnsByCellContentOnFirstLoad || this.gridOptions.enableAutoResizeColumnsByCellContent)) {
+                        this.resizerService.resizeColumnsByCellContent(!this.gridOptions?.resizeByContentOnlyOnFirstLoad);
+                    }
+                });
+                this._eventHandler.subscribe(dataView.onRowsChanged, (_e, args) => {
+                    // filtering data with local dataset will not always show correctly unless we call this updateRow/render
+                    // also don't use "invalidateRows" since it destroys the entire row and as bad user experience when updating a row
+                    // see commit: https://github.com/ghiscoding/aurelia-slickgrid/commit/8c503a4d45fba11cbd8d8cc467fae8d177cc4f60
+                    if (gridOptions && gridOptions.enableFiltering && !gridOptions.enableRowDetailView) {
+                        if (args?.rows && Array.isArray(args.rows)) {
+                            args.rows.forEach((row) => grid.updateRow(row));
+                            grid.render();
+                        }
+                    }
+                });
+            }
+        }
+        // did the user add a colspan callback? If so, hook it into the DataView getItemMetadata
+        if (gridOptions && gridOptions.colspanCallback && dataView && dataView.getItem && dataView.getItemMetadata) {
+            dataView.getItemMetadata = (rowNumber) => {
+                let callbackResult = null;
+                if (gridOptions.colspanCallback && gridOptions.colspanCallback) {
+                    callbackResult = gridOptions.colspanCallback(dataView.getItem(rowNumber));
+                }
+                return callbackResult;
+            };
+        }
+    }
+    bindBackendCallbackFunctions(gridOptions) {
+        const backendApi = gridOptions.backendServiceApi;
+        const backendApiService = backendApi && backendApi.service;
+        const serviceOptions = backendApiService?.options ?? {};
+        const isExecuteCommandOnInit = (!serviceOptions) ? false : ((serviceOptions && serviceOptions.hasOwnProperty('executeProcessCommandOnInit')) ? serviceOptions['executeProcessCommandOnInit'] : true);
+        if (backendApiService) {
+            // update backend filters (if need be) BEFORE the query runs (via the onInit command a few lines below)
+            // if user entered some any "presets", we need to reflect them all in the grid
+            if (gridOptions && gridOptions.presets) {
+                // Filters "presets"
+                if (backendApiService.updateFilters && Array.isArray(gridOptions.presets.filters) && gridOptions.presets.filters.length > 0) {
+                    backendApiService.updateFilters(gridOptions.presets.filters, true);
+                }
+                // Sorters "presets"
+                if (backendApiService.updateSorters && Array.isArray(gridOptions.presets.sorters) && gridOptions.presets.sorters.length > 0) {
+                    // when using multi-column sort, we can have multiple but on single sort then only grab the first sort provided
+                    const sortColumns = this.gridOptions.multiColumnSort ? gridOptions.presets.sorters : gridOptions.presets.sorters.slice(0, 1);
+                    backendApiService.updateSorters(undefined, sortColumns);
+                }
+                // Pagination "presets"
+                if (backendApiService.updatePagination && gridOptions.presets.pagination) {
+                    const { pageNumber, pageSize } = gridOptions.presets.pagination;
+                    backendApiService.updatePagination(pageNumber, pageSize);
+                }
+            }
+            else {
+                const columnFilters = this.filterService.getColumnFilters();
+                if (columnFilters && backendApiService.updateFilters) {
+                    backendApiService.updateFilters(columnFilters, false);
+                }
+            }
+            // execute onInit command when necessary
+            if (backendApi && backendApiService && (backendApi.onInit || isExecuteCommandOnInit)) {
+                const query = (typeof backendApiService.buildQuery === 'function') ? backendApiService.buildQuery() : '';
+                const process = (isExecuteCommandOnInit) ? (backendApi.process && backendApi.process(query) || null) : (backendApi.onInit && backendApi.onInit(query) || null);
+                // wrap this inside a setTimeout to avoid timing issue since the gridOptions needs to be ready before running this onInit
+                setTimeout(() => {
+                    const backendUtilityService = this.backendUtilityService;
+                    // keep start time & end timestamps & return it after process execution
+                    const startTime = new Date();
+                    // run any pre-process, if defined, for example a spinner
+                    if (backendApi.preProcess) {
+                        backendApi.preProcess();
+                    }
+                    // the processes can be a Promise (like Http)
+                    const totalItems = this.gridOptions?.pagination?.totalItems ?? 0;
+                    if (process instanceof Promise) {
+                        process
+                            .then((processResult) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems))
+                            .catch((error) => backendUtilityService.onBackendError(error, backendApi));
+                    }
+                    else if (process && this.rxjs?.isObservable(process)) {
+                        this.subscriptions.push(process.subscribe({
+                            next: (processResult) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems),
+                            error: (error) => backendUtilityService.onBackendError(error, backendApi)
+                        }));
+                    }
+                });
+            }
+        }
+    }
+    bindResizeHook(grid, options) {
+        if ((options.autoFitColumnsOnFirstLoad && options.autosizeColumnsByCellContentOnFirstLoad) || (options.enableAutoSizeColumns && options.enableAutoResizeColumnsByCellContent)) {
+            throw new Error(`[Angular-Slickgrid] You cannot enable both autosize/fit viewport & resize by content, you must choose which resize technique to use. You can enable these 2 options ("autoFitColumnsOnFirstLoad" and "enableAutoSizeColumns") OR these other 2 options ("autosizeColumnsByCellContentOnFirstLoad" and "enableAutoResizeColumnsByCellContent").`);
+        }
+        // expand/autofit columns on first page load
+        if (grid && options.autoFitColumnsOnFirstLoad && options.enableAutoSizeColumns) {
+            grid.autosizeColumns();
+        }
+        // auto-resize grid on browser resize
+        if (options.gridHeight || options.gridWidth) {
+            this.resizerService.resizeGrid(0, { height: options.gridHeight, width: options.gridWidth });
+        }
+        else {
+            this.resizerService.resizeGrid();
+        }
+        if (options.enableAutoResize) {
+            if (grid && options.autoFitColumnsOnFirstLoad && options.enableAutoSizeColumns) {
+                grid.autosizeColumns();
+            }
+        }
+    }
+    executeAfterDataviewCreated(_grid, gridOptions) {
+        // if user entered some Sort "presets", we need to reflect them all in the DOM
+        if (gridOptions.enableSorting) {
+            if (gridOptions.presets && Array.isArray(gridOptions.presets.sorters)) {
+                // when using multi-column sort, we can have multiple but on single sort then only grab the first sort provided
+                const sortColumns = this.gridOptions.multiColumnSort ? gridOptions.presets.sorters : gridOptions.presets.sorters.slice(0, 1);
+                this.sortService.loadGridSorters(sortColumns);
+            }
+        }
+    }
+    /** When data changes in the DataView, we'll refresh the metrics and/or display a warning if the dataset is empty */
+    handleOnItemCountChanged(currentPageRowItemCount, totalItemCount) {
+        this._currentDatasetLength = totalItemCount;
+        this.metrics = {
+            startTime: new Date(),
+            endTime: new Date(),
+            itemCount: currentPageRowItemCount,
+            totalItemCount
+        };
+        // if custom footer is enabled, then we'll update its metrics
+        if (this.slickFooter) {
+            this.slickFooter.metrics = this.metrics;
+        }
+        // when using local (in-memory) dataset, we'll display a warning message when filtered data is empty
+        if (this._isLocalGrid && this.gridOptions?.enableEmptyDataWarningMessage) {
+            this.displayEmptyDataWarning(currentPageRowItemCount === 0);
+        }
+    }
+    initializePaginationService(paginationOptions) {
+        if (this.gridOptions) {
+            this.paginationData = {
+                gridOptions: this.gridOptions,
+                paginationService: this.paginationService,
+            };
+            this.paginationService.totalItems = this.totalItems;
+            this.paginationService.init(this.slickGrid, paginationOptions, this.backendServiceApi);
+            this.subscriptions.push(this._eventPubSubService.subscribe('onPaginationChanged', (paginationChanges) => {
+                this.paginationChanged(paginationChanges);
+            }), this._eventPubSubService.subscribe('onPaginationVisibilityChanged', (visibility) => {
+                this.showPagination = visibility?.visible ?? false;
+                if (this.gridOptions?.backendServiceApi) {
+                    this.backendUtilityService?.refreshBackendDataset(this.gridOptions);
+                }
+                this.renderPagination(this.showPagination);
+            }));
+            // also initialize (render) the pagination component
+            this.renderPagination();
+            this._isPaginationInitialized = true;
+        }
+        this.cd.detectChanges();
+    }
+    /** Load the Editor Collection asynchronously and replace the "collection" property when Observable resolves */
+    loadEditorCollectionAsync(column) {
+        const collectionAsync = column && column.editor && column.editor.collectionAsync;
+        if (collectionAsync instanceof Observable) {
+            this.subscriptions.push(collectionAsync.subscribe((resolvedCollection) => this.updateEditorCollection(column, resolvedCollection)));
+        }
+        else if (collectionAsync instanceof Promise) {
+            // wait for the "collectionAsync", once resolved we will save it into the "collection"
+            // the collectionAsync can be of 3 types HttpClient, HttpFetch or a Promise
+            collectionAsync.then((response) => {
+                if (Array.isArray(response)) {
+                    this.updateEditorCollection(column, response); // from Promise
+                }
+            });
+        }
+    }
+    /** Load any possible Columns Grid Presets */
+    loadColumnPresetsWhenDatasetInitialized() {
+        // if user entered some Columns "presets", we need to reflect them all in the grid
+        if (this.gridOptions.presets && Array.isArray(this.gridOptions.presets.columns) && this.gridOptions.presets.columns.length > 0) {
+            const gridColumns = this.gridStateService.getAssociatedGridColumns(this.slickGrid, this.gridOptions.presets.columns);
+            if (gridColumns && Array.isArray(gridColumns) && gridColumns.length > 0) {
+                // make sure that the checkbox selector is also visible if it is enabled
+                if (this.gridOptions.enableCheckboxSelector) {
+                    const checkboxColumn = (Array.isArray(this._columnDefinitions) && this._columnDefinitions.length > 0) ? this._columnDefinitions[0] : null;
+                    if (checkboxColumn && checkboxColumn.id === '_checkbox_selector' && gridColumns[0].id !== '_checkbox_selector') {
+                        gridColumns.unshift(checkboxColumn);
+                    }
+                }
+                // keep copy the original optional `width` properties optionally provided by the user.
+                // We will use this when doing a resize by cell content, if user provided a `width` it won't override it.
+                gridColumns.forEach(col => col.originalWidth = col.width);
+                // finally set the new presets columns (including checkbox selector if need be)
+                this.slickGrid.setColumns(gridColumns);
+                this.sharedService.visibleColumns = gridColumns;
+            }
+        }
+    }
+    /** Load any possible Filters Grid Presets */
+    loadFilterPresetsWhenDatasetInitialized() {
+        if (this.gridOptions && !this.customDataView) {
+            // if user entered some Filter "presets", we need to reflect them all in the DOM
+            // also note that a presets of Tree Data Toggling will also call this method because Tree Data toggling does work with data filtering
+            // (collapsing a parent will basically use Filter for hidding (aka collapsing) away the child underneat it)
+            if (this.gridOptions.presets && (Array.isArray(this.gridOptions.presets.filters) || Array.isArray(this.gridOptions.presets?.treeData?.toggledItems))) {
+                this.filterService.populateColumnFilterSearchTermPresets(this.gridOptions.presets?.filters || []);
+            }
+        }
+    }
+    /**
+     * local grid, check if we need to show the Pagination
+     * if so then also check if there's any presets and finally initialize the PaginationService
+     * a local grid with Pagination presets will potentially have a different total of items, we'll need to get it from the DataView and update our total
+     */
+    loadLocalGridPagination(dataset) {
+        if (this.gridOptions && this._paginationOptions) {
+            this.totalItems = Array.isArray(dataset) ? dataset.length : 0;
+            if (this._paginationOptions && this.dataView?.getPagingInfo) {
+                const slickPagingInfo = this.dataView.getPagingInfo();
+                if (slickPagingInfo?.hasOwnProperty('totalRows') && this._paginationOptions.totalItems !== slickPagingInfo.totalRows) {
+                    this.totalItems = slickPagingInfo.totalRows || 0;
+                }
+            }
+            this._paginationOptions.totalItems = this.totalItems;
+            const paginationOptions = this.setPaginationOptionsWhenPresetDefined(this.gridOptions, this._paginationOptions);
+            this.initializePaginationService(paginationOptions);
+        }
+    }
+    /** Load any Row Selections into the DataView that were presets by the user */
+    loadRowSelectionPresetWhenExists() {
+        // if user entered some Row Selections "presets"
+        const presets = this.gridOptions?.presets;
+        const selectionModel = this.slickGrid?.getSelectionModel();
+        const enableRowSelection = this.gridOptions && (this.gridOptions.enableCheckboxSelector || this.gridOptions.enableRowSelection);
+        if (enableRowSelection && selectionModel && presets && presets.rowSelection && (Array.isArray(presets.rowSelection.gridRowIndexes) || Array.isArray(presets.rowSelection.dataContextIds))) {
+            let dataContextIds = presets.rowSelection.dataContextIds;
+            let gridRowIndexes = presets.rowSelection.gridRowIndexes;
+            // maps the IDs to the Grid Rows and vice versa, the "dataContextIds" has precedence over the other
+            if (Array.isArray(dataContextIds) && dataContextIds.length > 0) {
+                gridRowIndexes = this.dataView.mapIdsToRows(dataContextIds) || [];
+            }
+            else if (Array.isArray(gridRowIndexes) && gridRowIndexes.length > 0) {
+                dataContextIds = this.dataView.mapRowsToIds(gridRowIndexes) || [];
+            }
+            this.gridStateService.selectedRowDataContextIds = dataContextIds;
+            // change the selected rows except UNLESS it's a Local Grid with Pagination
+            // local Pagination uses the DataView and that also trigger a change/refresh
+            // and we don't want to trigger 2 Grid State changes just 1
+            if ((this._isLocalGrid && !this.gridOptions.enablePagination) || !this._isLocalGrid) {
+                setTimeout(() => {
+                    if (this.slickGrid && Array.isArray(gridRowIndexes)) {
+                        this.slickGrid.setSelectedRows(gridRowIndexes);
+                    }
+                });
+            }
+        }
+    }
+    mergeGridOptions(gridOptions) {
+        gridOptions.gridId = this.gridId;
+        gridOptions.gridContainerId = `slickGridContainer-${this.gridId}`;
+        // if we have a backendServiceApi and the enablePagination is undefined, we'll assume that we do want to see it, else get that defined value
+        gridOptions.enablePagination = ((gridOptions.backendServiceApi && gridOptions.enablePagination === undefined) ? true : gridOptions.enablePagination) || false;
+        // use jquery extend to deep merge & copy to avoid immutable properties being changed in GlobalGridOptions after a route change
+        const options = $.extend(true, {}, GlobalGridOptions, this.forRootConfig, gridOptions);
+        // using jQuery extend to do a deep clone has an unwanted side on objects and pageSizes but ES6 spread has other worst side effects
+        // so we will just overwrite the pageSizes when needed, this is the only one causing issues so far.
+        // jQuery wrote this on their docs:: On a deep extend, Object and Array are extended, but object wrappers on primitive types such as String, Boolean, and Number are not.
+        if (options?.pagination && (gridOptions.enablePagination || gridOptions.backendServiceApi) && gridOptions.pagination && Array.isArray(gridOptions.pagination.pageSizes)) {
+            options.pagination.pageSizes = gridOptions.pagination.pageSizes;
+        }
+        // also make sure to show the header row if user have enabled filtering
+        this._hideHeaderRowAfterPageLoad = (options.showHeaderRow === false);
+        if (options.enableFiltering && !options.showHeaderRow) {
+            options.showHeaderRow = options.enableFiltering;
+        }
+        // when we use Pagination on Local Grid, it doesn't seem to work without enableFiltering
+        // so we'll enable the filtering but we'll keep the header row hidden
+        if (options && !options.enableFiltering && options.enablePagination && this._isLocalGrid) {
+            options.enableFiltering = true;
+            options.showHeaderRow = false;
+            this._hideHeaderRowAfterPageLoad = true;
+            if (this.sharedService) {
+                this.sharedService.hideHeaderRowAfterPageLoad = true;
+            }
+        }
+        return options;
+    }
+    /** Pre-Register any Resource that don't require SlickGrid to be instantiated (for example RxJS Resource) */
+    preRegisterResources() {
+        this._registeredResources = this.gridOptions.registerExternalResources || [];
+        // Angular-Slickgrid requires RxJS, so we'll register it as the first resource
+        this.registerRxJsResource(new RxJsResource());
+    }
+    registerResources() {
+        // at this point, we consider all the registered services as external services, anything else registered afterward aren't external
+        if (Array.isArray(this._registeredResources)) {
+            this.sharedService.externalRegisteredResources = this._registeredResources;
+        }
+        // push all other Services that we want to be registered
+        this._registeredResources.push(this.gridService, this.gridStateService);
+        // when using Grouping/DraggableGrouping/Colspan register its Service
+        if (this.gridOptions.createPreHeaderPanel && !this.gridOptions.enableDraggableGrouping) {
+            this._registeredResources.push(this.groupingService);
+        }
+        // when using Tree Data View, register its Service
+        if (this.gridOptions.enableTreeData) {
+            this._registeredResources.push(this.treeDataService);
+        }
+        // when user enables translation, we need to translate Headers on first pass & subsequently in the bindDifferentHooks
+        if (this.gridOptions.enableTranslate) {
+            this.extensionService.translateColumnHeaders();
+        }
+        if (this.gridOptions.enableRowDetailView) {
+            this.slickRowDetailView = new SlickRowDetailView(this.angularUtilService, this.appRef, this._eventPubSubService, this.elm.nativeElement, this.rxjs);
+            this.slickRowDetailView.create(this.columnDefinitions, this.gridOptions);
+            this._registeredResources.push(this.slickRowDetailView);
+            this.extensionService.addExtensionToList(ExtensionName.rowDetailView, { name: ExtensionName.rowDetailView, instance: this.slickRowDetailView });
+        }
+        // also initialize (render) the empty warning component
+        this.slickEmptyWarning = new SlickEmptyWarningComponent();
+        this._registeredResources.push(this.slickEmptyWarning);
+        // bind & initialize all Components/Services that were tagged as enabled
+        // register all services by executing their init method and providing them with the Grid object
+        if (Array.isArray(this._registeredResources)) {
+            for (const resource of this._registeredResources) {
+                if (typeof resource.init === 'function') {
+                    resource.init(this.slickGrid, this.containerService);
+                }
+            }
+        }
+    }
+    /** Register the RxJS Resource in all necessary services which uses */
+    registerRxJsResource(resource) {
+        this.rxjs = resource;
+        this.backendUtilityService.addRxJsResource(this.rxjs);
+        this.filterFactory.addRxJsResource(this.rxjs);
+        this.filterService.addRxJsResource(this.rxjs);
+        this.sortService.addRxJsResource(this.rxjs);
+        this.paginationService.addRxJsResource(this.rxjs);
+        this.containerService.registerInstance('RxJsResource', this.rxjs);
+    }
+    /**
+     * Render (or dispose) the Pagination Component, user can optionally provide False (to not show it) which will in term dispose of the Pagination,
+     * also while disposing we can choose to omit the disposable of the Pagination Service (if we are simply toggling the Pagination, we want to keep the Service alive)
+     * @param {Boolean} showPagination - show (new render) or not (dispose) the Pagination
+     * @param {Boolean} shouldDisposePaginationService - when disposing the Pagination, do we also want to dispose of the Pagination Service? (defaults to True)
+     */
+    renderPagination(showPagination = true) {
+        if (this.gridOptions?.enablePagination && !this._isPaginationInitialized && showPagination) {
+            this.slickPagination = new SlickPaginationComponent(this.paginationService, this._eventPubSubService, this.sharedService, this.translaterService);
+            this.slickPagination.renderPagination(this.gridContainerElement);
+            this._isPaginationInitialized = true;
+        }
+        else if (!showPagination) {
+            if (this.slickPagination) {
+                this.slickPagination.dispose();
+            }
+            this._isPaginationInitialized = false;
+        }
+    }
+    /**
+     * Takes a flat dataset with parent/child relationship, sort it (via its tree structure) and return the sorted flat array
+     * @param {Array<Object>} flatDatasetInput - flat dataset input
+     * @param {Boolean} forceGridRefresh - optionally force a full grid refresh
+     * @returns {Array<Object>} sort flat parent/child dataset
+     */
+    sortTreeDataset(flatDatasetInput, forceGridRefresh = false) {
+        const prevDatasetLn = this._currentDatasetLength;
+        let sortedDatasetResult;
+        let flatDatasetOutput = [];
+        // if the hierarchical dataset was already initialized then no need to re-convert it, we can use it directly from the shared service ref
+        if (this._isDatasetHierarchicalInitialized && this.datasetHierarchical) {
+            sortedDatasetResult = this.treeDataService.sortHierarchicalDataset(this.datasetHierarchical);
+            flatDatasetOutput = sortedDatasetResult.flat;
+        }
+        else if (Array.isArray(flatDatasetInput) && flatDatasetInput.length > 0) {
+            if (this.gridOptions?.treeDataOptions?.initialSort) {
+                // else we need to first convert the flat dataset to a hierarchical dataset and then sort
+                sortedDatasetResult = this.treeDataService.convertFlatParentChildToTreeDatasetAndSort(flatDatasetInput, this._columnDefinitions, this.gridOptions);
+                this.sharedService.hierarchicalDataset = sortedDatasetResult.hierarchical;
+                flatDatasetOutput = sortedDatasetResult.flat;
+            }
+            else {
+                // else we assume that the user provided an array that is already sorted (user's responsability)
+                // and so we can simply convert the array to a tree structure and we're done, no need to sort
+                this.sharedService.hierarchicalDataset = this.treeDataService.convertFlatParentChildToTreeDataset(flatDatasetInput, this.gridOptions);
+                flatDatasetOutput = flatDatasetInput || [];
+            }
+        }
+        // if we add/remove item(s) from the dataset, we need to also refresh our tree data filters
+        if (flatDatasetInput.length > 0 && (forceGridRefresh || flatDatasetInput.length !== prevDatasetLn)) {
+            this.filterService.refreshTreeDataFilters(flatDatasetOutput);
+        }
+        return flatDatasetOutput;
+    }
+    /**
+     * For convenience to the user, we provide the property "editor" as an Angular-Slickgrid editor complex object
+     * however "editor" is used internally by SlickGrid for it's own Editor Factory
+     * so in our lib we will swap "editor" and copy it into a new property called "internalColumnEditor"
+     * then take back "editor.model" and make it the new "editor" so that SlickGrid Editor Factory still works
+     */
+    swapInternalEditorToSlickGridFactoryEditor(columnDefinitions) {
+        if (columnDefinitions.some(col => `${col.id}`.includes('.'))) {
+            console.error('[Angular-Slickgrid] Make sure that none of your Column Definition "id" property includes a dot in its name because that will cause some problems with the Editors. For example if your column definition "field" property is "user.firstName" then use "firstName" as the column "id".');
+        }
+        return columnDefinitions.map((column) => {
+            // on every Editor that have a "collectionAsync", resolve the data and assign it to the "collection" property
+            if (column && column.editor && column.editor.collectionAsync) {
+                this.loadEditorCollectionAsync(column);
+            }
+            return { ...column, editor: column.editor && column.editor.model, internalColumnEditor: { ...column.editor } };
+        });
+    }
+    translateColumnHeaderTitleKeys() {
+        // translate all columns (including hidden columns)
+        this.extensionUtility.translateItems(this.sharedService.allColumns, 'nameKey', 'name');
+    }
+    translateColumnGroupKeys() {
+        // translate all column groups (including hidden columns)
+        this.extensionUtility.translateItems(this.sharedService.allColumns, 'columnGroupKey', 'columnGroup');
+    }
+    /**
+     * Update the "internalColumnEditor.collection" property.
+     * Since this is called after the async call resolves, the pointer will not be the same as the "column" argument passed.
+     * Once we found the new pointer, we will reassign the "editor" and "collection" to the "internalColumnEditor" so it has newest collection
+     */
+    updateEditorCollection(column, newCollection) {
+        column.editor.collection = newCollection;
+        column.editor.disabled = false;
+        // find the new column reference pointer & re-assign the new editor to the internalColumnEditor
+        const columns = this.slickGrid.getColumns();
+        if (Array.isArray(columns)) {
+            const columnRef = columns.find((col) => col.id === column.id);
+            if (columnRef) {
+                columnRef.internalColumnEditor = column.editor;
+            }
+        }
+        // get current Editor, remove it from the DOM then re-enable it and re-render it with the new collection.
+        const currentEditor = this.slickGrid.getCellEditor();
+        if (currentEditor?.disable && currentEditor?.renderDomElement) {
+            currentEditor.destroy();
+            currentEditor.disable(false);
+            currentEditor.renderDomElement(newCollection);
+        }
+    }
+}
+AngularSlickgridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularSlickgridComponent, deps: [{ token: i1.AngularUtilService }, { token: i0.ApplicationRef }, { token: i0.ChangeDetectorRef }, { token: i2.ContainerService }, { token: i0.ElementRef }, { token: i3.TranslateService, optional: true }, { token: i4.TranslaterService, optional: true }, { token: 'config' }, { token: 'externalService' }], target: i0.ɵɵFactoryTarget.Component });
+AngularSlickgridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: AngularSlickgridComponent, selector: "angular-slickgrid", inputs: { customDataView: "customDataView", gridId: "gridId", gridOptions: "gridOptions", paginationOptions: "paginationOptions", columnDefinitions: "columnDefinitions", dataset: "dataset", datasetHierarchical: "datasetHierarchical" }, providers: [
+        // make everything transient (non-singleton)
+        AngularUtilService,
+        ApplicationRef,
+        TranslaterService,
+    ], ngImport: i0, template: "<div id=\"slickGridContainer-{{gridId}}\" class=\"gridPane\">\r\n  <div attr.id='{{gridId}}' class=\"slickgrid-container\" style=\"width: 100%\">\r\n  </div>\r\n</div>" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: AngularSlickgridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'angular-slickgrid', providers: [
+                        // make everything transient (non-singleton)
+                        AngularUtilService,
+                        ApplicationRef,
+                        TranslaterService,
+                    ], template: "<div id=\"slickGridContainer-{{gridId}}\" class=\"gridPane\">\r\n  <div attr.id='{{gridId}}' class=\"slickgrid-container\" style=\"width: 100%\">\r\n  </div>\r\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.AngularUtilService }, { type: i0.ApplicationRef }, { type: i0.ChangeDetectorRef }, { type: i2.ContainerService }, { type: i0.ElementRef }, { type: i3.TranslateService, decorators: [{
+                    type: Optional
+                }] }, { type: i4.TranslaterService, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['config']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['externalService']
+                }] }]; }, propDecorators: { customDataView: [{
+                type: Input
+            }], gridId: [{
+                type: Input
+            }], gridOptions: [{
+                type: Input
+            }], paginationOptions: [{
+                type: Input
+            }], columnDefinitions: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], datasetHierarchical: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-slickgrid.component.js","sourceRoot":"","sources":["../../../../../../src/app/modules/angular-slickgrid/components/angular-slickgrid.component.ts","../../../../../../src/app/modules/angular-slickgrid/components/angular-slickgrid.component.html"],"names":[],"mappings":"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","sourcesContent":["// import 3rd party vendor libs\r\n// only import the necessary core lib, each will be imported on demand when enabled (via require)\r\nimport 'jquery-ui/ui/widgets/draggable';\r\nimport 'jquery-ui/ui/widgets/droppable';\r\nimport 'jquery-ui/ui/widgets/sortable';\r\nimport 'slickgrid/lib/jquery.event.drag-2.3.0';\r\nimport 'slickgrid/lib/jquery.mousewheel';\r\nimport 'slickgrid/slick.core';\r\nimport 'slickgrid/slick.grid';\r\nimport 'slickgrid/slick.dataview';\r\n\r\n// ...then everything else...\r\nimport { AfterViewInit, ApplicationRef, ChangeDetectorRef, Component, ElementRef, Inject, Input, OnDestroy, Optional, } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport {\r\n  // interfaces/types\r\n  AutoCompleteEditor,\r\n  BackendServiceApi,\r\n  BackendServiceOption,\r\n  Column,\r\n  ColumnEditor,\r\n  DataViewOption,\r\n  EventSubscription,\r\n  ExtensionName,\r\n  ExternalResource,\r\n  Locale,\r\n  Metrics,\r\n  Pagination,\r\n  SelectEditor,\r\n  ServicePagination,\r\n  SlickDataView,\r\n  SlickEventHandler,\r\n  SlickGrid,\r\n  SlickNamespace,\r\n\r\n  // services\r\n  BackendUtilityService,\r\n  CollectionService,\r\n  EventNamingStyle,\r\n  ExtensionService,\r\n  ExtensionUtility,\r\n  FilterFactory,\r\n  FilterService,\r\n  GridEventService,\r\n  GridService,\r\n  GridStateService,\r\n  GroupingAndColspanService,\r\n  PaginationService,\r\n  ResizerService,\r\n  RxJsFacade,\r\n  SharedService,\r\n  SlickgridConfig,\r\n  SlickGroupItemMetadataProvider,\r\n  SortService,\r\n  TreeDataService,\r\n\r\n  // utilities\r\n  autoAddEditorFormatterToColumnsWithEditor,\r\n  emptyElement,\r\n  GridStateType,\r\n  unsubscribeAll,\r\n} from '@slickgrid-universal/common';\r\nimport { EventPubSubService } from '@slickgrid-universal/event-pub-sub';\r\nimport { SlickEmptyWarningComponent } from '@slickgrid-universal/empty-warning-component';\r\nimport { SlickFooterComponent } from '@slickgrid-universal/custom-footer-component';\r\nimport { SlickPaginationComponent } from '@slickgrid-universal/pagination-component';\r\nimport { RxJsResource } from '@slickgrid-universal/rxjs-observable';\r\nimport { dequal } from 'dequal/lite';\r\n\r\nimport { Constants } from '../constants';\r\nimport { AngularGridInstance, ExternalTestingDependencies, GridOption, } from './../models/index';\r\nimport { GlobalGridOptions } from './../global-grid-options';\r\nimport { TranslaterService } from '../services/translater.service';\r\n\r\n// Services\r\nimport { AngularUtilService } from '../services/angularUtil.service';\r\nimport { SlickRowDetailView } from '../extensions/slickRowDetailView';\r\nimport { ContainerService } from '../services/container.service';\r\n\r\n// using external non-typed js libraries\r\ndeclare const Slick: SlickNamespace;\r\n\r\n@Component({\r\n  selector: 'angular-slickgrid',\r\n  templateUrl: './angular-slickgrid.component.html',\r\n  providers: [\r\n    // make everything transient (non-singleton)\r\n    AngularUtilService,\r\n    ApplicationRef,\r\n    TranslaterService,\r\n  ]\r\n})\r\nexport class AngularSlickgridComponent implements AfterViewInit, OnDestroy {\r\n  private _dataset?: any[] | null;\r\n  private _columnDefinitions!: Column[];\r\n  private _currentDatasetLength = 0;\r\n  private _eventHandler: SlickEventHandler = new Slick.EventHandler();\r\n  private _eventPubSubService!: EventPubSubService;\r\n  private _angularGridInstances: AngularGridInstance | undefined;\r\n  private _hideHeaderRowAfterPageLoad = false;\r\n  private _isGridInitialized = false;\r\n  private _isDatasetInitialized = false;\r\n  private _isDatasetHierarchicalInitialized = false;\r\n  private _isPaginationInitialized = false;\r\n  private _isLocalGrid = true;\r\n  private _paginationOptions: Pagination | undefined;\r\n  private _registeredResources: ExternalResource[] = [];\r\n  dataView!: SlickDataView;\r\n  slickGrid!: SlickGrid;\r\n  groupingDefinition: any = {};\r\n  groupItemMetadataProvider?: SlickGroupItemMetadataProvider;\r\n  backendServiceApi?: BackendServiceApi;\r\n  locales!: Locale;\r\n  metrics?: Metrics;\r\n  showPagination = false;\r\n  serviceList: any[] = [];\r\n  totalItems = 0;\r\n  paginationData?: {\r\n    gridOptions: GridOption;\r\n    paginationService: PaginationService;\r\n  };\r\n  subscriptions: EventSubscription[] = [];\r\n\r\n  // components / plugins\r\n  slickEmptyWarning?: SlickEmptyWarningComponent;\r\n  slickFooter?: SlickFooterComponent;\r\n  slickPagination?: SlickPaginationComponent;\r\n  slickRowDetailView?: SlickRowDetailView;\r\n\r\n  // services\r\n  backendUtilityService!: BackendUtilityService;\r\n  collectionService: CollectionService;\r\n  extensionService: ExtensionService;\r\n  extensionUtility: ExtensionUtility;\r\n  filterFactory!: FilterFactory;\r\n  filterService: FilterService;\r\n  gridEventService: GridEventService;\r\n  gridService: GridService;\r\n  gridStateService: GridStateService;\r\n  groupingService: GroupingAndColspanService;\r\n  paginationService: PaginationService;\r\n  resizerService!: ResizerService;\r\n  rxjs?: RxJsFacade;\r\n  sharedService: SharedService;\r\n  sortService: SortService;\r\n  treeDataService: TreeDataService;\r\n\r\n  @Input() customDataView: any;\r\n  @Input() gridId: string = '';\r\n  @Input() gridOptions!: GridOption;\r\n\r\n  @Input()\r\n  get paginationOptions(): Pagination | undefined {\r\n    return this._paginationOptions;\r\n  }\r\n  set paginationOptions(newPaginationOptions: Pagination | undefined) {\r\n    if (newPaginationOptions && this._paginationOptions) {\r\n      this._paginationOptions = { ...this.gridOptions.pagination, ...this._paginationOptions, ...newPaginationOptions };\r\n    } else {\r\n      this._paginationOptions = newPaginationOptions;\r\n    }\r\n    this.gridOptions.pagination = this._paginationOptions ?? this.gridOptions.pagination;\r\n    this.paginationService.updateTotalItems(this.gridOptions.pagination?.totalItems ?? 0, true);\r\n  }\r\n\r\n  @Input()\r\n  set columnDefinitions(columnDefinitions: Column[]) {\r\n    this._columnDefinitions = columnDefinitions;\r\n    if (this._isGridInitialized) {\r\n      this.updateColumnDefinitionsList(columnDefinitions);\r\n    }\r\n    if (columnDefinitions.length > 0) {\r\n      this.copyColumnWidthsReference(columnDefinitions);\r\n    }\r\n  }\r\n  get columnDefinitions(): Column[] {\r\n    return this._columnDefinitions;\r\n  }\r\n\r\n  @Input()\r\n  get dataset(): any[] {\r\n    return (this.customDataView ? this.slickGrid?.getData?.() : this.dataView?.getItems?.()) || [];\r\n  }\r\n  set dataset(newDataset: any[]) {\r\n    const prevDatasetLn = this._currentDatasetLength;\r\n    const isDatasetEqual = dequal(newDataset, this._dataset || []);\r\n    let data = newDataset;\r\n\r\n    // when Tree Data is enabled and we don't yet have the hierarchical dataset filled, we can force a convert+sort of the array\r\n    if (this.slickGrid && this.gridOptions?.enableTreeData && Array.isArray(newDataset) && (newDataset.length > 0 || newDataset.length !== prevDatasetLn || !isDatasetEqual)) {\r\n      this._isDatasetHierarchicalInitialized = false;\r\n      data = this.sortTreeDataset(newDataset, !isDatasetEqual); // if dataset changed, then force a refresh anyway\r\n    }\r\n    this._dataset = data;\r\n    this.refreshGridData(data || []);\r\n    this._currentDatasetLength = (newDataset || []).length;\r\n\r\n    // expand/autofit columns on first page load\r\n    // we can assume that if the prevDataset was empty then we are on first load\r\n    if (this.gridOptions?.autoFitColumnsOnFirstLoad && prevDatasetLn === 0) {\r\n      this.slickGrid.autosizeColumns();\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  get datasetHierarchical(): any[] | undefined {\r\n    return this.sharedService.hierarchicalDataset;\r\n  }\r\n  set datasetHierarchical(newHierarchicalDataset: any[] | undefined) {\r\n    const isDatasetEqual = dequal(newHierarchicalDataset, this.sharedService?.hierarchicalDataset ?? []);\r\n    const prevFlatDatasetLn = this._currentDatasetLength;\r\n    this.sharedService.hierarchicalDataset = newHierarchicalDataset;\r\n\r\n    if (newHierarchicalDataset && this.columnDefinitions && this.filterService?.clearFilters) {\r\n      this.filterService.clearFilters();\r\n    }\r\n\r\n    // when a hierarchical dataset is set afterward, we can reset the flat dataset and call a tree data sort that will overwrite the flat dataset\r\n    if (newHierarchicalDataset && this.slickGrid && this.sortService?.processTreeDataInitialSort) {\r\n      this.dataView.setItems([], this.gridOptions.datasetIdPropertyName ?? 'id');\r\n      this.sortService.processTreeDataInitialSort();\r\n\r\n      // we also need to reset/refresh the Tree Data filters because if we inserted new item(s) then it might not show up without doing this refresh\r\n      // however we need 1 cpu cycle before having the DataView refreshed, so we need to wrap this check in a setTimeout\r\n      setTimeout(() => {\r\n        const flatDatasetLn = this.dataView.getItemCount();\r\n        if (flatDatasetLn > 0 && (flatDatasetLn !== prevFlatDatasetLn || !isDatasetEqual)) {\r\n          this.filterService.refreshTreeDataFilters();\r\n        }\r\n      });\r\n      this._isDatasetHierarchicalInitialized = true;\r\n    }\r\n  }\r\n\r\n  get elementRef(): ElementRef {\r\n    return this.elm;\r\n  }\r\n\r\n  get eventHandler(): SlickEventHandler {\r\n    return this._eventHandler;\r\n  }\r\n\r\n  get gridContainerElement(): HTMLElement | null {\r\n    return document.querySelector(`#${this.gridOptions.gridContainerId || ''}`);\r\n  }\r\n\r\n  /** GETTER to know if dataset was initialized or not */\r\n  get isDatasetInitialized(): boolean {\r\n    return this._isDatasetInitialized;\r\n  }\r\n  /** SETTER to change if dataset was initialized or not (stringly used for unit testing purposes) */\r\n  set isDatasetInitialized(isInitialized: boolean) {\r\n    this._isDatasetInitialized = isInitialized;\r\n  }\r\n  set isDatasetHierarchicalInitialized(isInitialized: boolean) {\r\n    this._isDatasetHierarchicalInitialized = isInitialized;\r\n  }\r\n\r\n  get registeredResources(): ExternalResource[] {\r\n    return this._registeredResources;\r\n  }\r\n\r\n  constructor(\r\n    private readonly angularUtilService: AngularUtilService,\r\n    private readonly appRef: ApplicationRef,\r\n    private readonly cd: ChangeDetectorRef,\r\n    private readonly containerService: ContainerService,\r\n    private readonly elm: ElementRef,\r\n    @Optional() private readonly translate: TranslateService,\r\n    @Optional() private readonly translaterService: TranslaterService,\r\n    @Inject('config') private forRootConfig: GridOption,\r\n    @Inject('externalService') externalServices: ExternalTestingDependencies\r\n  ) {\r\n    const slickgridConfig = new SlickgridConfig();\r\n\r\n    // initialize and assign all Service Dependencies\r\n    this._eventPubSubService = externalServices?.eventPubSubService ?? new EventPubSubService(this.elm.nativeElement);\r\n    this._eventPubSubService.eventNamingStyle = EventNamingStyle.camelCase;\r\n\r\n    this.backendUtilityService = externalServices?.backendUtilityService ?? new BackendUtilityService();\r\n    this.gridEventService = externalServices?.gridEventService ?? new GridEventService();\r\n    this.sharedService = externalServices?.sharedService ?? new SharedService();\r\n    this.collectionService = externalServices?.collectionService ?? new CollectionService(this.translaterService);\r\n    this.extensionUtility = externalServices?.extensionUtility ?? new ExtensionUtility(this.sharedService, this.backendUtilityService, this.translaterService);\r\n    this.filterFactory = new FilterFactory(slickgridConfig, this.translaterService, this.collectionService);\r\n    this.filterService = externalServices?.filterService ?? new FilterService(this.filterFactory as any, this._eventPubSubService, this.sharedService, this.backendUtilityService);\r\n    this.resizerService = externalServices?.resizerService ?? new ResizerService(this._eventPubSubService);\r\n    this.sortService = externalServices?.sortService ?? new SortService(this.sharedService, this._eventPubSubService, this.backendUtilityService);\r\n    this.treeDataService = externalServices?.treeDataService ?? new TreeDataService(this._eventPubSubService, this.sharedService, this.sortService);\r\n    this.paginationService = externalServices?.paginationService ?? new PaginationService(this._eventPubSubService, this.sharedService, this.backendUtilityService);\r\n\r\n    this.extensionService = externalServices?.extensionService ?? new ExtensionService(\r\n      this.extensionUtility,\r\n      this.filterService,\r\n      this._eventPubSubService,\r\n      this.sharedService,\r\n      this.sortService,\r\n      this.treeDataService,\r\n      this.translaterService,\r\n    );\r\n\r\n    this.gridStateService = externalServices?.gridStateService ?? new GridStateService(this.extensionService, this.filterService, this._eventPubSubService, this.sharedService, this.sortService, this.treeDataService);\r\n    this.gridService = externalServices?.gridService ?? new GridService(this.gridStateService, this.filterService, this._eventPubSubService, this.paginationService, this.sharedService, this.sortService, this.treeDataService);\r\n    this.groupingService = externalServices?.groupingAndColspanService ?? new GroupingAndColspanService(this.extensionUtility, this._eventPubSubService);\r\n\r\n    this.serviceList = [\r\n      this.extensionService,\r\n      this.filterService,\r\n      this.gridEventService,\r\n      this.gridService,\r\n      this.gridStateService,\r\n      this.groupingService,\r\n      this.paginationService,\r\n      this.resizerService,\r\n      this.sortService,\r\n      this.treeDataService,\r\n    ];\r\n\r\n    // register all Service instances in the container\r\n    this.containerService.registerInstance('ExtensionUtility', this.extensionUtility);\r\n    this.containerService.registerInstance('FilterService', this.filterService);\r\n    this.containerService.registerInstance('CollectionService', this.collectionService);\r\n    this.containerService.registerInstance('ExtensionService', this.extensionService);\r\n    this.containerService.registerInstance('GridEventService', this.gridEventService);\r\n    this.containerService.registerInstance('GridService', this.gridService);\r\n    this.containerService.registerInstance('GridStateService', this.gridStateService);\r\n    this.containerService.registerInstance('GroupingAndColspanService', this.groupingService);\r\n    this.containerService.registerInstance('PaginationService', this.paginationService);\r\n    this.containerService.registerInstance('ResizerService', this.resizerService);\r\n    this.containerService.registerInstance('SharedService', this.sharedService);\r\n    this.containerService.registerInstance('SortService', this.sortService);\r\n    this.containerService.registerInstance('EventPubSubService', this._eventPubSubService);\r\n    this.containerService.registerInstance('PubSubService', this._eventPubSubService);\r\n    this.containerService.registerInstance('TranslaterService', this.translaterService);\r\n    this.containerService.registerInstance('TreeDataService', this.treeDataService);\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.initialization(this._eventHandler);\r\n    this._isGridInitialized = true;\r\n\r\n    // recheck the empty warning message after grid is shown so that it works in every use case\r\n    if (this.gridOptions && this.gridOptions.enableEmptyDataWarningMessage && Array.isArray(this.dataset)) {\r\n      const finalTotalCount = this.dataset.length;\r\n      this.displayEmptyDataWarning(finalTotalCount < 1);\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._eventPubSubService.publish('onBeforeGridDestroy', this.slickGrid);\r\n    this.destroy();\r\n    this._eventPubSubService.publish('onAfterGridDestroyed', true);\r\n  }\r\n\r\n  destroy(shouldEmptyDomElementContainer = false) {\r\n    // dispose of all Services\r\n    this.serviceList.forEach((service: any) => {\r\n      if (service && service.dispose) {\r\n        service.dispose();\r\n      }\r\n    });\r\n    this.serviceList = [];\r\n\r\n    // dispose all registered external resources\r\n    if (Array.isArray(this._registeredResources)) {\r\n      while (this._registeredResources.length > 0) {\r\n        const resource = this._registeredResources.pop();\r\n        if (resource?.dispose) {\r\n          resource.dispose();\r\n        }\r\n      }\r\n      this._registeredResources = [];\r\n    }\r\n\r\n    // dispose the Components\r\n    this.slickEmptyWarning?.dispose();\r\n    this.slickFooter?.dispose();\r\n    this.slickPagination?.dispose();\r\n\r\n    if (this._eventHandler?.unsubscribeAll) {\r\n      this._eventHandler.unsubscribeAll();\r\n    }\r\n    this._eventPubSubService?.unsubscribeAll();\r\n    if (this.dataView) {\r\n      if (this.dataView?.setItems) {\r\n        this.dataView.setItems([]);\r\n      }\r\n      if (this.dataView.destroy) {\r\n        this.dataView.destroy();\r\n      }\r\n    }\r\n    if (this.slickGrid?.destroy) {\r\n      this.slickGrid.destroy(shouldEmptyDomElementContainer);\r\n    }\r\n\r\n    if (this.backendServiceApi) {\r\n      for (const prop of Object.keys(this.backendServiceApi)) {\r\n        delete this.backendServiceApi[prop as keyof BackendServiceApi];\r\n      }\r\n      this.backendServiceApi = undefined;\r\n    }\r\n    for (const prop of Object.keys(this.columnDefinitions)) {\r\n      (this.columnDefinitions as any)[prop] = null;\r\n    }\r\n    for (const prop of Object.keys(this.sharedService)) {\r\n      (this.sharedService as any)[prop] = null;\r\n    }\r\n\r\n    // we could optionally also empty the content of the grid container DOM element\r\n    if (shouldEmptyDomElementContainer) {\r\n      this.emptyGridContainerElm();\r\n    }\r\n\r\n    // also unsubscribe all RxJS subscriptions\r\n    this.subscriptions = unsubscribeAll(this.subscriptions);\r\n\r\n    this._dataset = null;\r\n    this.datasetHierarchical = undefined;\r\n    this._columnDefinitions = [];\r\n    this._angularGridInstances = undefined;\r\n  }\r\n\r\n  emptyGridContainerElm() {\r\n    const gridContainerId = this.gridOptions?.gridContainerId ?? 'grid1';\r\n    const gridContainerElm = document.querySelector(`#${gridContainerId}`);\r\n    emptyElement(gridContainerElm);\r\n  }\r\n\r\n  /**\r\n   * Define our internal Post Process callback, it will execute internally after we get back result from the Process backend call\r\n   * For now, this is GraphQL Service ONLY feature and it will basically refresh the Dataset & Pagination without having the user to create his own PostProcess every time\r\n   */\r\n  createBackendApiInternalPostProcessCallback(gridOptions: GridOption) {\r\n    const backendApi = gridOptions && gridOptions.backendServiceApi;\r\n    if (backendApi && backendApi.service) {\r\n      const backendApiService = backendApi.service;\r\n\r\n      // internalPostProcess only works (for now) with a GraphQL Service, so make sure it is of that type\r\n      if (typeof backendApiService.getDatasetName === 'function') {\r\n        backendApi.internalPostProcess = (processResult: any) => {\r\n          const datasetName = (backendApi && backendApiService && typeof backendApiService.getDatasetName === 'function') ? backendApiService.getDatasetName() : '';\r\n          if (processResult?.data[datasetName]) {\r\n            const data = processResult.data[datasetName].hasOwnProperty('nodes') ? (processResult as any).data[datasetName].nodes : (processResult as any).data[datasetName];\r\n            const totalCount = processResult.data[datasetName].hasOwnProperty('totalCount') ? (processResult as any).data[datasetName].totalCount : (processResult as any).data[datasetName].length;\r\n            this.refreshGridData(data, totalCount || 0);\r\n          }\r\n        };\r\n      }\r\n    }\r\n  }\r\n\r\n  initialization(eventHandler: SlickEventHandler) {\r\n    this.gridOptions.translater = this.translaterService;\r\n    this._eventHandler = eventHandler;\r\n\r\n    // when detecting a frozen grid, we'll automatically enable the mousewheel scroll handler so that we can scroll from both left/right frozen containers\r\n    if (this.gridOptions && ((this.gridOptions.frozenRow !== undefined && this.gridOptions.frozenRow >= 0) || this.gridOptions.frozenColumn !== undefined && this.gridOptions.frozenColumn >= 0) && this.gridOptions.enableMouseWheelScrollHandler === undefined) {\r\n      this.gridOptions.enableMouseWheelScrollHandler = true;\r\n    }\r\n\r\n    this._eventPubSubService.eventNamingStyle = this.gridOptions?.eventNamingStyle ?? EventNamingStyle.camelCase;\r\n    this._eventPubSubService.publish('onBeforeGridCreate', true);\r\n\r\n    // make sure the dataset is initialized (if not it will throw an error that it cannot getLength of null)\r\n    this._dataset = this._dataset || [];\r\n    this.gridOptions = this.mergeGridOptions(this.gridOptions);\r\n    this._paginationOptions = this.gridOptions?.pagination;\r\n    this.locales = this.gridOptions?.locales ?? Constants.locales;\r\n    this.backendServiceApi = this.gridOptions?.backendServiceApi;\r\n    this._isLocalGrid = !this.backendServiceApi; // considered a local grid if it doesn't have a backend service set\r\n\r\n    this.createBackendApiInternalPostProcessCallback(this.gridOptions);\r\n\r\n    if (!this.customDataView) {\r\n      const dataviewInlineFilters = this.gridOptions.dataView && this.gridOptions.dataView.inlineFilters || false;\r\n      let dataViewOptions: DataViewOption = { inlineFilters: dataviewInlineFilters };\r\n\r\n      if (this.gridOptions.draggableGrouping || this.gridOptions.enableGrouping) {\r\n        this.groupItemMetadataProvider = new SlickGroupItemMetadataProvider();\r\n        this.sharedService.groupItemMetadataProvider = this.groupItemMetadataProvider;\r\n        dataViewOptions = { ...dataViewOptions, groupItemMetadataProvider: this.groupItemMetadataProvider };\r\n      }\r\n      this.dataView = new Slick.Data.DataView(dataViewOptions);\r\n      this._eventPubSubService.publish('onDataviewCreated', this.dataView);\r\n    }\r\n\r\n    // get any possible Services that user want to register which don't require SlickGrid to be instantiated\r\n    // RxJS Resource is in this lot because it has to be registered before anything else and doesn't require SlickGrid to be initialized\r\n    this.preRegisterResources();\r\n\r\n    // for convenience to the user, we provide the property \"editor\" as an Angular-Slickgrid editor complex object\r\n    // however \"editor\" is used internally by SlickGrid for it's own Editor Factory\r\n    // so in our lib we will swap \"editor\" and copy it into a new property called \"internalColumnEditor\"\r\n    // then take back \"editor.model\" and make it the new \"editor\" so that SlickGrid Editor Factory still works\r\n    this._columnDefinitions = this.swapInternalEditorToSlickGridFactoryEditor(this._columnDefinitions);\r\n\r\n    // if the user wants to automatically add a Custom Editor Formatter, we need to call the auto add function again\r\n    if (this.gridOptions.autoAddCustomEditorFormatter) {\r\n      autoAddEditorFormatterToColumnsWithEditor(this._columnDefinitions, this.gridOptions.autoAddCustomEditorFormatter);\r\n    }\r\n\r\n    // save reference for all columns before they optionally become hidden/visible\r\n    this.sharedService.allColumns = this._columnDefinitions;\r\n    this.sharedService.visibleColumns = this._columnDefinitions;\r\n    this.extensionService.createExtensionsBeforeGridCreation(this._columnDefinitions, this.gridOptions);\r\n\r\n    // if user entered some Pinning/Frozen \"presets\", we need to apply them in the grid options\r\n    if (this.gridOptions.presets?.pinning) {\r\n      this.gridOptions = { ...this.gridOptions, ...this.gridOptions.presets.pinning };\r\n    }\r\n\r\n    // build SlickGrid Grid, also user might optionally pass a custom dataview (e.g. remote model)\r\n    this.slickGrid = new Slick.Grid(`#${this.gridId}`, this.customDataView || this.dataView, this._columnDefinitions, this.gridOptions);\r\n    this.sharedService.dataView = this.dataView;\r\n    this.sharedService.slickGrid = this.slickGrid;\r\n    this.sharedService.gridContainerElement = this.elm.nativeElement as HTMLDivElement;\r\n\r\n    this.extensionService.bindDifferentExtensions();\r\n    this.bindDifferentHooks(this.slickGrid, this.gridOptions, this.dataView);\r\n\r\n    // when it's a frozen grid, we need to keep the frozen column id for reference if we ever show/hide column from ColumnPicker/GridMenu afterward\r\n    const frozenColumnIndex = this.gridOptions.frozenColumn !== undefined ? this.gridOptions.frozenColumn : -1;\r\n    if (frozenColumnIndex >= 0 && frozenColumnIndex <= this._columnDefinitions.length) {\r\n      this.sharedService.frozenVisibleColumnId = this._columnDefinitions[frozenColumnIndex].id || '';\r\n    }\r\n\r\n    // get any possible Services that user want to register\r\n    this.registerResources();\r\n\r\n    // initialize the SlickGrid grid\r\n    this.slickGrid.init();\r\n\r\n    // initialized the resizer service only after SlickGrid is initialized\r\n    // if we don't we end up binding our resize to a grid element that doesn't yet exist in the DOM and the resizer service will fail silently (because it has a try/catch that unbinds the resize without throwing back)\r\n    if (this.gridContainerElement) {\r\n      this.resizerService.init(this.slickGrid, this.gridContainerElement as HTMLDivElement);\r\n    }\r\n\r\n    // user could show a custom footer with the data metrics (dataset length and last updated timestamp)\r\n    if (!this.gridOptions.enablePagination && this.gridOptions.showCustomFooter && this.gridOptions.customFooterOptions && this.gridContainerElement) {\r\n      this.slickFooter = new SlickFooterComponent(this.slickGrid, this.gridOptions.customFooterOptions, this._eventPubSubService, this.translaterService);\r\n      this.slickFooter.renderFooter(this.gridContainerElement);\r\n    }\r\n\r\n    if (!this.customDataView && this.dataView) {\r\n      // load the data in the DataView (unless it's a hierarchical dataset, if so it will be loaded after the initial tree sort)\r\n      const initialDataset = this.gridOptions?.enableTreeData ? this.sortTreeDataset(this._dataset) : this._dataset;\r\n      this.dataView.beginUpdate();\r\n      this.dataView.setItems(initialDataset || [], this.gridOptions.datasetIdPropertyName ?? 'id');\r\n      this.dataView.endUpdate();\r\n\r\n      // if you don't want the items that are not visible (due to being filtered out or being on a different page)\r\n      // to stay selected, pass 'false' to the second arg\r\n      const selectionModel = this.slickGrid?.getSelectionModel();\r\n      if (selectionModel && this.gridOptions && this.gridOptions.dataView && this.gridOptions.dataView.hasOwnProperty('syncGridSelection')) {\r\n        // if we are using a Backend Service, we will do an extra flag check, the reason is because it might have some unintended behaviors\r\n        // with the BackendServiceApi because technically the data in the page changes the DataView on every page change.\r\n        let preservedRowSelectionWithBackend = false;\r\n        if (this.gridOptions.backendServiceApi && this.gridOptions.dataView.hasOwnProperty('syncGridSelectionWithBackendService')) {\r\n          preservedRowSelectionWithBackend = this.gridOptions.dataView.syncGridSelectionWithBackendService as boolean;\r\n        }\r\n\r\n        const syncGridSelection = this.gridOptions.dataView.syncGridSelection;\r\n        if (typeof syncGridSelection === 'boolean') {\r\n          let preservedRowSelection = syncGridSelection;\r\n          if (!this._isLocalGrid) {\r\n            // when using BackendServiceApi, we'll be using the \"syncGridSelectionWithBackendService\" flag BUT \"syncGridSelection\" must also be set to True\r\n            preservedRowSelection = syncGridSelection && preservedRowSelectionWithBackend;\r\n          }\r\n          this.dataView.syncGridSelection(this.slickGrid, preservedRowSelection);\r\n        } else if (typeof syncGridSelection === 'object') {\r\n          this.dataView.syncGridSelection(this.slickGrid, syncGridSelection.preserveHidden, syncGridSelection.preserveHiddenOnSelectionChange);\r\n        }\r\n      }\r\n\r\n      const datasetLn = this.dataView.getLength() || this._dataset && this._dataset.length || 0;\r\n      if (datasetLn > 0) {\r\n        if (!this._isDatasetInitialized && (this.gridOptions.enableCheckboxSelector || this.gridOptions.enableRowSelection)) {\r\n          this.loadRowSelectionPresetWhenExists();\r\n        }\r\n        this.loadFilterPresetsWhenDatasetInitialized();\r\n        this._isDatasetInitialized = true;\r\n      }\r\n    }\r\n\r\n    // user might want to hide the header row on page load but still have `enableFiltering: true`\r\n    // if that is the case, we need to hide the headerRow ONLY AFTER all filters got created & dataView exist\r\n    if (this._hideHeaderRowAfterPageLoad) {\r\n      this.showHeaderRow(false);\r\n      this.sharedService.hideHeaderRowAfterPageLoad = this._hideHeaderRowAfterPageLoad;\r\n    }\r\n\r\n    // publish & dispatch certain events\r\n    this._eventPubSubService.publish('onGridCreated', this.slickGrid);\r\n\r\n    // after the DataView is created & updated execute some processes\r\n    if (!this.customDataView) {\r\n      this.executeAfterDataviewCreated(this.slickGrid, this.gridOptions);\r\n    }\r\n\r\n    // bind resize ONLY after the dataView is ready\r\n    this.bindResizeHook(this.slickGrid, this.gridOptions);\r\n\r\n    // bind the Backend Service API callback functions only after the grid is initialized\r\n    // because the preProcess() and onInit() might get triggered\r\n    if (this.gridOptions?.backendServiceApi) {\r\n      this.bindBackendCallbackFunctions(this.gridOptions);\r\n    }\r\n\r\n    // local grid, check if we need to show the Pagination\r\n    // if so then also check if there's any presets and finally initialize the PaginationService\r\n    // a local grid with Pagination presets will potentially have a different total of items, we'll need to get it from the DataView and update our total\r\n    if (this.gridOptions?.enablePagination && this._isLocalGrid) {\r\n      this.showPagination = true;\r\n      this.loadLocalGridPagination(this.dataset);\r\n    }\r\n\r\n    this._angularGridInstances = {\r\n      // Slick Grid & DataView objects\r\n      dataView: this.dataView,\r\n      slickGrid: this.slickGrid,\r\n      extensions: this.extensionService?.extensionList,\r\n\r\n      // public methods\r\n      destroy: this.destroy.bind(this),\r\n\r\n      // return all available Services (non-singleton)\r\n      backendService: this.gridOptions?.backendServiceApi?.service,\r\n      filterService: this.filterService,\r\n      gridEventService: this.gridEventService,\r\n      gridStateService: this.gridStateService,\r\n      gridService: this.gridService,\r\n      groupingService: this.groupingService,\r\n      extensionService: this.extensionService,\r\n      paginationService: this.paginationService,\r\n      resizerService: this.resizerService,\r\n      sortService: this.sortService,\r\n      treeDataService: this.treeDataService,\r\n    }\r\n\r\n    // all instances (SlickGrid, DataView & all Services)\r\n    this._eventPubSubService.publish('onAngularGridCreated', this._angularGridInstances);\r\n  }\r\n\r\n  /**\r\n   * On a Pagination changed, we will trigger a Grid State changed with the new pagination info\r\n   * Also if we use Row Selection or the Checkbox Selector, we need to reset any selection\r\n   */\r\n  paginationChanged(pagination: ServicePagination) {\r\n    const isSyncGridSelectionEnabled = this.gridStateService?.needToPreserveRowSelection() ?? false;\r\n    if (!isSyncGridSelectionEnabled && (this.gridOptions.enableRowSelection || this.gridOptions.enableCheckboxSelector)) {\r\n      this.slickGrid.setSelectedRows([]);\r\n    }\r\n    const { pageNumber, pageSize } = pagination;\r\n    if (this.sharedService) {\r\n      if (pageSize !== undefined && pageNumber !== undefined) {\r\n        this.sharedService.currentPagination = { pageNumber, pageSize };\r\n      }\r\n    }\r\n    this._eventPubSubService.publish('onGridStateChanged', {\r\n      change: { newValues: { pageNumber, pageSize }, type: GridStateType.pagination },\r\n      gridState: this.gridStateService.getCurrentGridState()\r\n    });\r\n    this.cd.markForCheck();\r\n  }\r\n\r\n  /**\r\n   * When dataset changes, we need to refresh the entire grid UI & possibly resize it as well\r\n   * @param dataset\r\n   */\r\n  refreshGridData(dataset: any[], totalCount?: number) {\r\n    if (this.gridOptions && this.gridOptions.enableEmptyDataWarningMessage && Array.isArray(dataset)) {\r\n      const finalTotalCount = totalCount || dataset.length;\r\n      this.displayEmptyDataWarning(finalTotalCount < 1);\r\n    }\r\n\r\n    if (Array.isArray(dataset) && this.slickGrid && this.dataView?.setItems) {\r\n      this.dataView.setItems(dataset, this.gridOptions.datasetIdPropertyName ?? 'id');\r\n      if (!this.gridOptions.backendServiceApi && !this.gridOptions.enableTreeData) {\r\n        this.dataView.reSort();\r\n      }\r\n\r\n      if (dataset.length > 0) {\r\n        if (!this._isDatasetInitialized) {\r\n          this.loadFilterPresetsWhenDatasetInitialized();\r\n\r\n          if (this.gridOptions.enableCheckboxSelector) {\r\n            this.loadRowSelectionPresetWhenExists();\r\n          }\r\n        }\r\n        this._isDatasetInitialized = true;\r\n      }\r\n\r\n      if (dataset) {\r\n        this.slickGrid.invalidate();\r\n      }\r\n\r\n      // display the Pagination component only after calling this refresh data first, we call it here so that if we preset pagination page number it will be shown correctly\r\n      this.showPagination = (this.gridOptions && (this.gridOptions.enablePagination || (this.gridOptions.backendServiceApi && this.gridOptions.enablePagination === undefined))) ? true : false;\r\n\r\n      if (this._paginationOptions && this.gridOptions?.pagination && this.gridOptions?.backendServiceApi) {\r\n        const paginationOptions = this.setPaginationOptionsWhenPresetDefined(this.gridOptions, this._paginationOptions as Pagination);\r\n        // when we have a totalCount use it, else we'll take it from the pagination object\r\n        // only update the total items if it's different to avoid refreshing the UI\r\n        const totalRecords = (totalCount !== undefined) ? totalCount : (this.gridOptions?.pagination?.totalItems);\r\n        if (totalRecords !== undefined && totalRecords !== this.totalItems) {\r\n          this.totalItems = +totalRecords;\r\n        }\r\n\r\n        // initialize the Pagination Service with new pagination options (which might have presets)\r\n        if (!this._isPaginationInitialized) {\r\n          this.initializePaginationService(paginationOptions);\r\n        } else {\r\n          // update the pagination service with the new total\r\n          this.paginationService.updateTotalItems(this.totalItems);\r\n        }\r\n      }\r\n\r\n      // resize the grid inside a slight timeout, in case other DOM element changed prior to the resize (like a filter/pagination changed)\r\n      if (this.slickGrid && this.gridOptions.enableAutoResize) {\r\n        const delay = this.gridOptions.autoResize && this.gridOptions.autoResize.delay;\r\n        this.resizerService.resizeGrid(delay || 10);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if there's any Pagination Presets defined in the Grid Options,\r\n   * if there are then load them in the paginationOptions object\r\n   */\r\n  setPaginationOptionsWhenPresetDefined(gridOptions: GridOption, paginationOptions: Pagination): Pagination {\r\n    if (gridOptions.presets?.pagination && paginationOptions && !this._isPaginationInitialized) {\r\n      paginationOptions.pageSize = gridOptions.presets.pagination.pageSize;\r\n      paginationOptions.pageNumber = gridOptions.presets.pagination.pageNumber;\r\n    }\r\n    return paginationOptions;\r\n  }\r\n\r\n  /**\r\n   * Dynamically change or update the column definitions list.\r\n   * We will re-render the grid so that the new header and data shows up correctly.\r\n   * If using i18n, we also need to trigger a re-translate of the column headers\r\n   */\r\n  updateColumnDefinitionsList(newColumnDefinitions: Column[]) {\r\n    // map/swap the internal library Editor to the SlickGrid Editor factory\r\n    newColumnDefinitions = this.swapInternalEditorToSlickGridFactoryEditor(newColumnDefinitions);\r\n\r\n    if (this.gridOptions.enableTranslate) {\r\n      this.extensionService.translateColumnHeaders(false, newColumnDefinitions);\r\n    } else {\r\n      this.extensionService.renderColumnHeaders(newColumnDefinitions, true);\r\n    }\r\n\r\n    if (this.gridOptions?.enableAutoSizeColumns) {\r\n      this.slickGrid.autosizeColumns();\r\n    } else if (this.gridOptions?.enableAutoResizeColumnsByCellContent && this.resizerService?.resizeColumnsByCellContent) {\r\n      this.resizerService.resizeColumnsByCellContent();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Show the filter row displayed on first row, we can optionally pass false to hide it.\r\n   * @param showing\r\n   */\r\n  showHeaderRow(showing = true) {\r\n    this.slickGrid.setHeaderRowVisibility(showing, false);\r\n    if (showing === true && this._isGridInitialized) {\r\n      this.slickGrid.setColumns(this.columnDefinitions);\r\n    }\r\n    return showing;\r\n  }\r\n\r\n  //\r\n  // private functions\r\n  // ------------------\r\n\r\n  /**\r\n   * Loop through all column definitions and copy the original optional `width` properties optionally provided by the user.\r\n   * We will use this when doing a resize by cell content, if user provided a `width` it won't override it.\r\n   */\r\n  private copyColumnWidthsReference(columnDefinitions: Column[]) {\r\n    columnDefinitions.forEach(col => col.originalWidth = col.width);\r\n  }\r\n\r\n  private displayEmptyDataWarning(showWarning = true) {\r\n    this.slickEmptyWarning?.showEmptyDataMessage(showWarning);\r\n  }\r\n\r\n  private bindDifferentHooks(grid: SlickGrid, gridOptions: GridOption, dataView: SlickDataView) {\r\n    // on locale change, we have to manually translate the Headers, GridMenu\r\n    if (this.translate?.onLangChange) {\r\n      // translate some of them on first load, then on each language change\r\n      if (gridOptions.enableTranslate) {\r\n        this.extensionService.translateAllExtensions();\r\n        this.translateColumnHeaderTitleKeys();\r\n        this.translateColumnGroupKeys();\r\n      }\r\n\r\n      this.subscriptions.push(\r\n        this.translate.onLangChange.subscribe(() => {\r\n          // publish event of the same name that Slickgrid-Universal uses on a language change event\r\n          this._eventPubSubService.publish('onLanguageChange');\r\n\r\n          if (gridOptions.enableTranslate) {\r\n            this.extensionService.translateAllExtensions();\r\n            this.translateColumnHeaderTitleKeys();\r\n            this.translateColumnGroupKeys();\r\n            if (gridOptions.createPreHeaderPanel && !gridOptions.enableDraggableGrouping) {\r\n              this.groupingService.translateGroupingAndColSpan();\r\n            }\r\n          }\r\n        })\r\n      );\r\n    }\r\n\r\n    // if user set an onInit Backend, we'll run it right away (and if so, we also need to run preProcess, internalPostProcess & postProcess)\r\n    if (gridOptions.backendServiceApi) {\r\n      const backendApi = gridOptions.backendServiceApi;\r\n\r\n      if (backendApi?.service?.init) {\r\n        backendApi.service.init(backendApi.options, gridOptions.pagination, this.slickGrid, this.sharedService);\r\n      }\r\n    }\r\n\r\n    if (dataView && grid) {\r\n      const slickgridEventPrefix = this.gridOptions?.defaultSlickgridEventPrefix ?? '';\r\n\r\n      // expose all Slick Grid Events through dispatch\r\n      for (const prop in grid) {\r\n        if (grid.hasOwnProperty(prop) && prop.startsWith('on')) {\r\n          const gridEventName = this._eventPubSubService.getEventNameByNamingConvention(prop, slickgridEventPrefix);\r\n          this._eventHandler.subscribe((grid as any)[prop], (event, args) => {\r\n            return this._eventPubSubService.dispatchCustomEvent(gridEventName, { eventData: event, args });\r\n          });\r\n        }\r\n      }\r\n\r\n      // expose all Slick DataView Events through dispatch\r\n      for (const prop in dataView) {\r\n        if (dataView.hasOwnProperty(prop) && prop.startsWith('on')) {\r\n          this._eventHandler.subscribe((dataView as any)[prop], (event, args) => {\r\n            const dataViewEventName = this._eventPubSubService.getEventNameByNamingConvention(prop, slickgridEventPrefix);\r\n            return this._eventPubSubService.dispatchCustomEvent(dataViewEventName, { eventData: event, args });\r\n          });\r\n        }\r\n      }\r\n\r\n      // on cell click, mainly used with the columnDef.action callback\r\n      this.gridEventService.bindOnCellChange(grid);\r\n      this.gridEventService.bindOnClick(grid);\r\n\r\n      if (dataView && grid) {\r\n        // bind external sorting (backend) when available or default onSort (dataView)\r\n        if (gridOptions.enableSorting) {\r\n          // bind external sorting (backend) unless specified to use the local one\r\n          if (gridOptions.backendServiceApi && !gridOptions.backendServiceApi.useLocalSorting) {\r\n            this.sortService.bindBackendOnSort(grid);\r\n          } else {\r\n            this.sortService.bindLocalOnSort(grid);\r\n          }\r\n        }\r\n\r\n        // bind external filter (backend) when available or default onFilter (dataView)\r\n        if (gridOptions.enableFiltering) {\r\n          this.filterService.init(grid);\r\n\r\n          // bind external filter (backend) unless specified to use the local one\r\n          if (gridOptions.backendServiceApi && !gridOptions.backendServiceApi.useLocalFiltering) {\r\n            this.filterService.bindBackendOnFilter(grid);\r\n          } else {\r\n            this.filterService.bindLocalOnFilter(grid);\r\n          }\r\n        }\r\n\r\n        // load any presets if any (after dataset is initialized)\r\n        this.loadColumnPresetsWhenDatasetInitialized();\r\n        this.loadFilterPresetsWhenDatasetInitialized();\r\n\r\n        // When data changes in the DataView, we need to refresh the metrics and/or display a warning if the dataset is empty\r\n        this._eventHandler.subscribe(dataView.onRowCountChanged, () => {\r\n          grid.invalidate();\r\n          this.handleOnItemCountChanged(this.dataView.getFilteredItemCount() || 0, dataView.getItemCount());\r\n        });\r\n        this._eventHandler.subscribe(dataView.onSetItemsCalled, (_e, args) => {\r\n          grid.invalidate();\r\n          this.handleOnItemCountChanged(this.dataView.getFilteredItemCount(), args.itemCount);\r\n\r\n          // when user has resize by content enabled, we'll force a full width calculation since we change our entire dataset\r\n          if (args.itemCount > 0 && (this.gridOptions.autosizeColumnsByCellContentOnFirstLoad || this.gridOptions.enableAutoResizeColumnsByCellContent)) {\r\n            this.resizerService.resizeColumnsByCellContent(!this.gridOptions?.resizeByContentOnlyOnFirstLoad);\r\n          }\r\n        });\r\n\r\n        this._eventHandler.subscribe(dataView.onRowsChanged, (_e, args) => {\r\n          // filtering data with local dataset will not always show correctly unless we call this updateRow/render\r\n          // also don't use \"invalidateRows\" since it destroys the entire row and as bad user experience when updating a row\r\n          // see commit: https://github.com/ghiscoding/aurelia-slickgrid/commit/8c503a4d45fba11cbd8d8cc467fae8d177cc4f60\r\n          if (gridOptions && gridOptions.enableFiltering && !gridOptions.enableRowDetailView) {\r\n            if (args?.rows && Array.isArray(args.rows)) {\r\n              args.rows.forEach((row: number) => grid.updateRow(row));\r\n              grid.render();\r\n            }\r\n          }\r\n        });\r\n      }\r\n    }\r\n\r\n    // did the user add a colspan callback? If so, hook it into the DataView getItemMetadata\r\n    if (gridOptions && gridOptions.colspanCallback && dataView && dataView.getItem && dataView.getItemMetadata) {\r\n      dataView.getItemMetadata = (rowNumber: number) => {\r\n        let callbackResult = null;\r\n        if (gridOptions.colspanCallback && gridOptions.colspanCallback) {\r\n          callbackResult = gridOptions.colspanCallback(dataView.getItem(rowNumber));\r\n        }\r\n        return callbackResult;\r\n      };\r\n    }\r\n  }\r\n\r\n  private bindBackendCallbackFunctions(gridOptions: GridOption) {\r\n    const backendApi = gridOptions.backendServiceApi;\r\n    const backendApiService = backendApi && backendApi.service;\r\n    const serviceOptions: BackendServiceOption = backendApiService?.options ?? {};\r\n    const isExecuteCommandOnInit = (!serviceOptions) ? false : ((serviceOptions && serviceOptions.hasOwnProperty('executeProcessCommandOnInit')) ? serviceOptions['executeProcessCommandOnInit'] : true);\r\n\r\n    if (backendApiService) {\r\n      // update backend filters (if need be) BEFORE the query runs (via the onInit command a few lines below)\r\n      // if user entered some any \"presets\", we need to reflect them all in the grid\r\n      if (gridOptions && gridOptions.presets) {\r\n        // Filters \"presets\"\r\n        if (backendApiService.updateFilters && Array.isArray(gridOptions.presets.filters) && gridOptions.presets.filters.length > 0) {\r\n          backendApiService.updateFilters(gridOptions.presets.filters, true);\r\n        }\r\n        // Sorters \"presets\"\r\n        if (backendApiService.updateSorters && Array.isArray(gridOptions.presets.sorters) && gridOptions.presets.sorters.length > 0) {\r\n          // when using multi-column sort, we can have multiple but on single sort then only grab the first sort provided\r\n          const sortColumns = this.gridOptions.multiColumnSort ? gridOptions.presets.sorters : gridOptions.presets.sorters.slice(0, 1);\r\n          backendApiService.updateSorters(undefined, sortColumns);\r\n        }\r\n        // Pagination \"presets\"\r\n        if (backendApiService.updatePagination && gridOptions.presets.pagination) {\r\n          const { pageNumber, pageSize } = gridOptions.presets.pagination;\r\n          backendApiService.updatePagination(pageNumber, pageSize);\r\n        }\r\n      } else {\r\n        const columnFilters = this.filterService.getColumnFilters();\r\n        if (columnFilters && backendApiService.updateFilters) {\r\n          backendApiService.updateFilters(columnFilters, false);\r\n        }\r\n      }\r\n\r\n      // execute onInit command when necessary\r\n      if (backendApi && backendApiService && (backendApi.onInit || isExecuteCommandOnInit)) {\r\n        const query = (typeof backendApiService.buildQuery === 'function') ? backendApiService.buildQuery() : '';\r\n        const process = (isExecuteCommandOnInit) ? (backendApi.process && backendApi.process(query) || null) : (backendApi.onInit && backendApi.onInit(query) || null);\r\n\r\n        // wrap this inside a setTimeout to avoid timing issue since the gridOptions needs to be ready before running this onInit\r\n        setTimeout(() => {\r\n          const backendUtilityService = this.backendUtilityService as BackendUtilityService;\r\n\r\n          // keep start time & end timestamps & return it after process execution\r\n          const startTime = new Date();\r\n\r\n          // run any pre-process, if defined, for example a spinner\r\n          if (backendApi.preProcess) {\r\n            backendApi.preProcess();\r\n          }\r\n\r\n          // the processes can be a Promise (like Http)\r\n          const totalItems = this.gridOptions?.pagination?.totalItems ?? 0;\r\n          if (process instanceof Promise) {\r\n            process\r\n              .then((processResult: any) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems))\r\n              .catch((error) => backendUtilityService.onBackendError(error, backendApi));\r\n          } else if (process && this.rxjs?.isObservable(process)) {\r\n            this.subscriptions.push(\r\n              (process as Observable<any>).subscribe({\r\n                next: (processResult: any) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems),\r\n                error: (error: any) => backendUtilityService.onBackendError(error, backendApi)\r\n              })\r\n            );\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private bindResizeHook(grid: SlickGrid, options: GridOption) {\r\n    if ((options.autoFitColumnsOnFirstLoad && options.autosizeColumnsByCellContentOnFirstLoad) || (options.enableAutoSizeColumns && options.enableAutoResizeColumnsByCellContent)) {\r\n      throw new Error(`[Angular-Slickgrid] You cannot enable both autosize/fit viewport & resize by content, you must choose which resize technique to use. You can enable these 2 options (\"autoFitColumnsOnFirstLoad\" and \"enableAutoSizeColumns\") OR these other 2 options (\"autosizeColumnsByCellContentOnFirstLoad\" and \"enableAutoResizeColumnsByCellContent\").`);\r\n    }\r\n\r\n    // expand/autofit columns on first page load\r\n    if (grid && options.autoFitColumnsOnFirstLoad && options.enableAutoSizeColumns) {\r\n      grid.autosizeColumns();\r\n    }\r\n\r\n    // auto-resize grid on browser resize\r\n    if (options.gridHeight || options.gridWidth) {\r\n      this.resizerService.resizeGrid(0, { height: options.gridHeight, width: options.gridWidth });\r\n    } else {\r\n      this.resizerService.resizeGrid();\r\n    }\r\n    if (options.enableAutoResize) {\r\n      if (grid && options.autoFitColumnsOnFirstLoad && options.enableAutoSizeColumns) {\r\n        grid.autosizeColumns();\r\n      }\r\n    }\r\n  }\r\n\r\n  private executeAfterDataviewCreated(_grid: SlickGrid, gridOptions: GridOption) {\r\n    // if user entered some Sort \"presets\", we need to reflect them all in the DOM\r\n    if (gridOptions.enableSorting) {\r\n      if (gridOptions.presets && Array.isArray(gridOptions.presets.sorters)) {\r\n        // when using multi-column sort, we can have multiple but on single sort then only grab the first sort provided\r\n        const sortColumns = this.gridOptions.multiColumnSort ? gridOptions.presets.sorters : gridOptions.presets.sorters.slice(0, 1);\r\n        this.sortService.loadGridSorters(sortColumns);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** When data changes in the DataView, we'll refresh the metrics and/or display a warning if the dataset is empty */\r\n  private handleOnItemCountChanged(currentPageRowItemCount: number, totalItemCount: number) {\r\n    this._currentDatasetLength = totalItemCount;\r\n    this.metrics = {\r\n      startTime: new Date(),\r\n      endTime: new Date(),\r\n      itemCount: currentPageRowItemCount,\r\n      totalItemCount\r\n    };\r\n    // if custom footer is enabled, then we'll update its metrics\r\n    if (this.slickFooter) {\r\n      this.slickFooter.metrics = this.metrics;\r\n    }\r\n\r\n    // when using local (in-memory) dataset, we'll display a warning message when filtered data is empty\r\n    if (this._isLocalGrid && this.gridOptions?.enableEmptyDataWarningMessage) {\r\n      this.displayEmptyDataWarning(currentPageRowItemCount === 0);\r\n    }\r\n  }\r\n\r\n  private initializePaginationService(paginationOptions: Pagination) {\r\n    if (this.gridOptions) {\r\n      this.paginationData = {\r\n        gridOptions: this.gridOptions,\r\n        paginationService: this.paginationService,\r\n      };\r\n      this.paginationService.totalItems = this.totalItems;\r\n      this.paginationService.init(this.slickGrid, paginationOptions, this.backendServiceApi);\r\n      this.subscriptions.push(\r\n        this._eventPubSubService.subscribe('onPaginationChanged', (paginationChanges: ServicePagination) => {\r\n          this.paginationChanged(paginationChanges);\r\n        }),\r\n        this._eventPubSubService.subscribe('onPaginationVisibilityChanged', (visibility: { visible: boolean }) => {\r\n          this.showPagination = visibility?.visible ?? false;\r\n          if (this.gridOptions?.backendServiceApi) {\r\n            this.backendUtilityService?.refreshBackendDataset(this.gridOptions);\r\n          }\r\n          this.renderPagination(this.showPagination);\r\n        })\r\n      );\r\n      // also initialize (render) the pagination component\r\n      this.renderPagination();\r\n      this._isPaginationInitialized = true;\r\n    }\r\n    this.cd.detectChanges();\r\n  }\r\n\r\n  /** Load the Editor Collection asynchronously and replace the \"collection\" property when Observable resolves */\r\n  private loadEditorCollectionAsync(column: Column) {\r\n    const collectionAsync = column && column.editor && (column.editor as ColumnEditor).collectionAsync;\r\n    if (collectionAsync instanceof Observable) {\r\n      this.subscriptions.push(\r\n        collectionAsync.subscribe((resolvedCollection) => this.updateEditorCollection(column, resolvedCollection))\r\n      );\r\n    } else if (collectionAsync instanceof Promise) {\r\n      // wait for the \"collectionAsync\", once resolved we will save it into the \"collection\"\r\n      // the collectionAsync can be of 3 types HttpClient, HttpFetch or a Promise\r\n      collectionAsync.then((response: any | any[]) => {\r\n        if (Array.isArray(response)) {\r\n          this.updateEditorCollection(column, response); // from Promise\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Load any possible Columns Grid Presets */\r\n  private loadColumnPresetsWhenDatasetInitialized() {\r\n    // if user entered some Columns \"presets\", we need to reflect them all in the grid\r\n    if (this.gridOptions.presets && Array.isArray(this.gridOptions.presets.columns) && this.gridOptions.presets.columns.length > 0) {\r\n      const gridColumns: Column[] = this.gridStateService.getAssociatedGridColumns(this.slickGrid, this.gridOptions.presets.columns);\r\n      if (gridColumns && Array.isArray(gridColumns) && gridColumns.length > 0) {\r\n        // make sure that the checkbox selector is also visible if it is enabled\r\n        if (this.gridOptions.enableCheckboxSelector) {\r\n          const checkboxColumn = (Array.isArray(this._columnDefinitions) && this._columnDefinitions.length > 0) ? this._columnDefinitions[0] : null;\r\n          if (checkboxColumn && checkboxColumn.id === '_checkbox_selector' && gridColumns[0].id !== '_checkbox_selector') {\r\n            gridColumns.unshift(checkboxColumn);\r\n          }\r\n        }\r\n\r\n        // keep copy the original optional `width` properties optionally provided by the user.\r\n        // We will use this when doing a resize by cell content, if user provided a `width` it won't override it.\r\n        gridColumns.forEach(col => col.originalWidth = col.width);\r\n\r\n        // finally set the new presets columns (including checkbox selector if need be)\r\n        this.slickGrid.setColumns(gridColumns);\r\n        this.sharedService.visibleColumns = gridColumns;\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Load any possible Filters Grid Presets */\r\n  private loadFilterPresetsWhenDatasetInitialized() {\r\n    if (this.gridOptions && !this.customDataView) {\r\n      // if user entered some Filter \"presets\", we need to reflect them all in the DOM\r\n      // also note that a presets of Tree Data Toggling will also call this method because Tree Data toggling does work with data filtering\r\n      // (collapsing a parent will basically use Filter for hidding (aka collapsing) away the child underneat it)\r\n      if (this.gridOptions.presets && (Array.isArray(this.gridOptions.presets.filters) || Array.isArray(this.gridOptions.presets?.treeData?.toggledItems))) {\r\n        this.filterService.populateColumnFilterSearchTermPresets(this.gridOptions.presets?.filters || []);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * local grid, check if we need to show the Pagination\r\n   * if so then also check if there's any presets and finally initialize the PaginationService\r\n   * a local grid with Pagination presets will potentially have a different total of items, we'll need to get it from the DataView and update our total\r\n   */\r\n  private loadLocalGridPagination(dataset?: any[]) {\r\n    if (this.gridOptions && this._paginationOptions) {\r\n      this.totalItems = Array.isArray(dataset) ? dataset.length : 0;\r\n      if (this._paginationOptions && this.dataView?.getPagingInfo) {\r\n        const slickPagingInfo = this.dataView.getPagingInfo();\r\n        if (slickPagingInfo?.hasOwnProperty('totalRows') && this._paginationOptions.totalItems !== slickPagingInfo.totalRows) {\r\n          this.totalItems = slickPagingInfo.totalRows || 0;\r\n        }\r\n      }\r\n      this._paginationOptions.totalItems = this.totalItems;\r\n      const paginationOptions = this.setPaginationOptionsWhenPresetDefined(this.gridOptions, this._paginationOptions);\r\n      this.initializePaginationService(paginationOptions);\r\n    }\r\n  }\r\n\r\n  /** Load any Row Selections into the DataView that were presets by the user */\r\n  private loadRowSelectionPresetWhenExists() {\r\n    // if user entered some Row Selections \"presets\"\r\n    const presets = this.gridOptions?.presets;\r\n    const selectionModel = this.slickGrid?.getSelectionModel();\r\n    const enableRowSelection = this.gridOptions && (this.gridOptions.enableCheckboxSelector || this.gridOptions.enableRowSelection);\r\n    if (enableRowSelection && selectionModel && presets && presets.rowSelection && (Array.isArray(presets.rowSelection.gridRowIndexes) || Array.isArray(presets.rowSelection.dataContextIds))) {\r\n      let dataContextIds = presets.rowSelection.dataContextIds;\r\n      let gridRowIndexes = presets.rowSelection.gridRowIndexes;\r\n\r\n      // maps the IDs to the Grid Rows and vice versa, the \"dataContextIds\" has precedence over the other\r\n      if (Array.isArray(dataContextIds) && dataContextIds.length > 0) {\r\n        gridRowIndexes = this.dataView.mapIdsToRows(dataContextIds) || [];\r\n      } else if (Array.isArray(gridRowIndexes) && gridRowIndexes.length > 0) {\r\n        dataContextIds = this.dataView.mapRowsToIds(gridRowIndexes) || [];\r\n      }\r\n      this.gridStateService.selectedRowDataContextIds = dataContextIds;\r\n\r\n      // change the selected rows except UNLESS it's a Local Grid with Pagination\r\n      // local Pagination uses the DataView and that also trigger a change/refresh\r\n      // and we don't want to trigger 2 Grid State changes just 1\r\n      if ((this._isLocalGrid && !this.gridOptions.enablePagination) || !this._isLocalGrid) {\r\n        setTimeout(() => {\r\n          if (this.slickGrid && Array.isArray(gridRowIndexes)) {\r\n            this.slickGrid.setSelectedRows(gridRowIndexes);\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  private mergeGridOptions(gridOptions: GridOption): GridOption {\r\n    gridOptions.gridId = this.gridId;\r\n    gridOptions.gridContainerId = `slickGridContainer-${this.gridId}`;\r\n\r\n    // if we have a backendServiceApi and the enablePagination is undefined, we'll assume that we do want to see it, else get that defined value\r\n    gridOptions.enablePagination = ((gridOptions.backendServiceApi && gridOptions.enablePagination === undefined) ? true : gridOptions.enablePagination) || false;\r\n\r\n    // use jquery extend to deep merge & copy to avoid immutable properties being changed in GlobalGridOptions after a route change\r\n    const options = $.extend(true, {}, GlobalGridOptions, this.forRootConfig, gridOptions) as GridOption;\r\n\r\n    // using jQuery extend to do a deep clone has an unwanted side on objects and pageSizes but ES6 spread has other worst side effects\r\n    // so we will just overwrite the pageSizes when needed, this is the only one causing issues so far.\r\n    // jQuery wrote this on their docs:: On a deep extend, Object and Array are extended, but object wrappers on primitive types such as String, Boolean, and Number are not.\r\n    if (options?.pagination && (gridOptions.enablePagination || gridOptions.backendServiceApi) && gridOptions.pagination && Array.isArray(gridOptions.pagination.pageSizes)) {\r\n      options.pagination.pageSizes = gridOptions.pagination.pageSizes;\r\n    }\r\n\r\n    // also make sure to show the header row if user have enabled filtering\r\n    this._hideHeaderRowAfterPageLoad = (options.showHeaderRow === false);\r\n    if (options.enableFiltering && !options.showHeaderRow) {\r\n      options.showHeaderRow = options.enableFiltering;\r\n    }\r\n\r\n    // when we use Pagination on Local Grid, it doesn't seem to work without enableFiltering\r\n    // so we'll enable the filtering but we'll keep the header row hidden\r\n    if (options && !options.enableFiltering && options.enablePagination && this._isLocalGrid) {\r\n      options.enableFiltering = true;\r\n      options.showHeaderRow = false;\r\n      this._hideHeaderRowAfterPageLoad = true;\r\n      if (this.sharedService) {\r\n        this.sharedService.hideHeaderRowAfterPageLoad = true;\r\n      }\r\n    }\r\n\r\n    return options;\r\n  }\r\n\r\n  /** Pre-Register any Resource that don't require SlickGrid to be instantiated (for example RxJS Resource) */\r\n  private preRegisterResources() {\r\n    this._registeredResources = this.gridOptions.registerExternalResources || [];\r\n\r\n    // Angular-Slickgrid requires RxJS, so we'll register it as the first resource\r\n    this.registerRxJsResource(new RxJsResource() as RxJsFacade);\r\n  }\r\n\r\n  private registerResources() {\r\n    // at this point, we consider all the registered services as external services, anything else registered afterward aren't external\r\n    if (Array.isArray(this._registeredResources)) {\r\n      this.sharedService.externalRegisteredResources = this._registeredResources;\r\n    }\r\n\r\n    // push all other Services that we want to be registered\r\n    this._registeredResources.push(this.gridService, this.gridStateService);\r\n\r\n    // when using Grouping/DraggableGrouping/Colspan register its Service\r\n    if (this.gridOptions.createPreHeaderPanel && !this.gridOptions.enableDraggableGrouping) {\r\n      this._registeredResources.push(this.groupingService);\r\n    }\r\n\r\n    // when using Tree Data View, register its Service\r\n    if (this.gridOptions.enableTreeData) {\r\n      this._registeredResources.push(this.treeDataService);\r\n    }\r\n\r\n    // when user enables translation, we need to translate Headers on first pass & subsequently in the bindDifferentHooks\r\n    if (this.gridOptions.enableTranslate) {\r\n      this.extensionService.translateColumnHeaders();\r\n    }\r\n\r\n    if (this.gridOptions.enableRowDetailView) {\r\n      this.slickRowDetailView = new SlickRowDetailView(this.angularUtilService, this.appRef, this._eventPubSubService, this.elm.nativeElement, this.rxjs);\r\n      this.slickRowDetailView.create(this.columnDefinitions, this.gridOptions);\r\n      this._registeredResources.push(this.slickRowDetailView);\r\n      this.extensionService.addExtensionToList(ExtensionName.rowDetailView, { name: ExtensionName.rowDetailView, instance: this.slickRowDetailView });\r\n    }\r\n\r\n    // also initialize (render) the empty warning component\r\n    this.slickEmptyWarning = new SlickEmptyWarningComponent();\r\n    this._registeredResources.push(this.slickEmptyWarning);\r\n\r\n    // bind & initialize all Components/Services that were tagged as enabled\r\n    // register all services by executing their init method and providing them with the Grid object\r\n    if (Array.isArray(this._registeredResources)) {\r\n      for (const resource of this._registeredResources) {\r\n        if (typeof resource.init === 'function') {\r\n          resource.init(this.slickGrid, this.containerService);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Register the RxJS Resource in all necessary services which uses */\r\n  private registerRxJsResource(resource: RxJsFacade) {\r\n    this.rxjs = resource;\r\n    this.backendUtilityService.addRxJsResource(this.rxjs);\r\n    this.filterFactory.addRxJsResource(this.rxjs);\r\n    this.filterService.addRxJsResource(this.rxjs);\r\n    this.sortService.addRxJsResource(this.rxjs);\r\n    this.paginationService.addRxJsResource(this.rxjs);\r\n    this.containerService.registerInstance('RxJsResource', this.rxjs);\r\n  }\r\n\r\n  /**\r\n   * Render (or dispose) the Pagination Component, user can optionally provide False (to not show it) which will in term dispose of the Pagination,\r\n   * also while disposing we can choose to omit the disposable of the Pagination Service (if we are simply toggling the Pagination, we want to keep the Service alive)\r\n   * @param {Boolean} showPagination - show (new render) or not (dispose) the Pagination\r\n   * @param {Boolean} shouldDisposePaginationService - when disposing the Pagination, do we also want to dispose of the Pagination Service? (defaults to True)\r\n   */\r\n  private renderPagination(showPagination = true) {\r\n    if (this.gridOptions?.enablePagination && !this._isPaginationInitialized && showPagination) {\r\n      this.slickPagination = new SlickPaginationComponent(this.paginationService, this._eventPubSubService, this.sharedService, this.translaterService);\r\n      this.slickPagination.renderPagination(this.gridContainerElement as HTMLElement);\r\n      this._isPaginationInitialized = true;\r\n    } else if (!showPagination) {\r\n      if (this.slickPagination) {\r\n        this.slickPagination.dispose();\r\n      }\r\n      this._isPaginationInitialized = false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Takes a flat dataset with parent/child relationship, sort it (via its tree structure) and return the sorted flat array\r\n   * @param {Array<Object>} flatDatasetInput - flat dataset input\r\n   * @param {Boolean} forceGridRefresh - optionally force a full grid refresh\r\n   * @returns {Array<Object>} sort flat parent/child dataset\r\n   */\r\n  private sortTreeDataset<T>(flatDatasetInput: T[], forceGridRefresh = false): T[] {\r\n    const prevDatasetLn = this._currentDatasetLength;\r\n    let sortedDatasetResult;\r\n    let flatDatasetOutput: any[] = [];\r\n\r\n    // if the hierarchical dataset was already initialized then no need to re-convert it, we can use it directly from the shared service ref\r\n    if (this._isDatasetHierarchicalInitialized && this.datasetHierarchical) {\r\n      sortedDatasetResult = this.treeDataService.sortHierarchicalDataset(this.datasetHierarchical);\r\n      flatDatasetOutput = sortedDatasetResult.flat;\r\n    } else if (Array.isArray(flatDatasetInput) && flatDatasetInput.length > 0) {\r\n      if (this.gridOptions?.treeDataOptions?.initialSort) {\r\n        // else we need to first convert the flat dataset to a hierarchical dataset and then sort\r\n        sortedDatasetResult = this.treeDataService.convertFlatParentChildToTreeDatasetAndSort(flatDatasetInput, this._columnDefinitions, this.gridOptions);\r\n        this.sharedService.hierarchicalDataset = sortedDatasetResult.hierarchical;\r\n        flatDatasetOutput = sortedDatasetResult.flat;\r\n      } else {\r\n        // else we assume that the user provided an array that is already sorted (user's responsability)\r\n        // and so we can simply convert the array to a tree structure and we're done, no need to sort\r\n        this.sharedService.hierarchicalDataset = this.treeDataService.convertFlatParentChildToTreeDataset(flatDatasetInput, this.gridOptions);\r\n        flatDatasetOutput = flatDatasetInput || [];\r\n      }\r\n    }\r\n\r\n    // if we add/remove item(s) from the dataset, we need to also refresh our tree data filters\r\n    if (flatDatasetInput.length > 0 && (forceGridRefresh || flatDatasetInput.length !== prevDatasetLn)) {\r\n      this.filterService.refreshTreeDataFilters(flatDatasetOutput);\r\n    }\r\n\r\n    return flatDatasetOutput;\r\n  }\r\n\r\n  /**\r\n   * For convenience to the user, we provide the property \"editor\" as an Angular-Slickgrid editor complex object\r\n   * however \"editor\" is used internally by SlickGrid for it's own Editor Factory\r\n   * so in our lib we will swap \"editor\" and copy it into a new property called \"internalColumnEditor\"\r\n   * then take back \"editor.model\" and make it the new \"editor\" so that SlickGrid Editor Factory still works\r\n   */\r\n  private swapInternalEditorToSlickGridFactoryEditor(columnDefinitions: Column[]) {\r\n    if (columnDefinitions.some(col => `${col.id}`.includes('.'))) {\r\n      console.error('[Angular-Slickgrid] Make sure that none of your Column Definition \"id\" property includes a dot in its name because that will cause some problems with the Editors. For example if your column definition \"field\" property is \"user.firstName\" then use \"firstName\" as the column \"id\".');\r\n    }\r\n\r\n    return columnDefinitions.map((column: Column | any) => {\r\n      // on every Editor that have a \"collectionAsync\", resolve the data and assign it to the \"collection\" property\r\n      if (column && column.editor && column.editor.collectionAsync) {\r\n        this.loadEditorCollectionAsync(column);\r\n      }\r\n      return { ...column, editor: column.editor && column.editor.model, internalColumnEditor: { ...column.editor } };\r\n    });\r\n  }\r\n\r\n  private translateColumnHeaderTitleKeys() {\r\n    // translate all columns (including hidden columns)\r\n    this.extensionUtility.translateItems(this.sharedService.allColumns, 'nameKey', 'name');\r\n  }\r\n\r\n  private translateColumnGroupKeys() {\r\n    // translate all column groups (including hidden columns)\r\n    this.extensionUtility.translateItems(this.sharedService.allColumns, 'columnGroupKey', 'columnGroup');\r\n  }\r\n\r\n  /**\r\n   * Update the \"internalColumnEditor.collection\" property.\r\n   * Since this is called after the async call resolves, the pointer will not be the same as the \"column\" argument passed.\r\n   * Once we found the new pointer, we will reassign the \"editor\" and \"collection\" to the \"internalColumnEditor\" so it has newest collection\r\n   */\r\n  private updateEditorCollection<T = any>(column: Column<T>, newCollection: T[]) {\r\n    (column.editor as ColumnEditor).collection = newCollection;\r\n    (column.editor as ColumnEditor).disabled = false;\r\n\r\n    // find the new column reference pointer & re-assign the new editor to the internalColumnEditor\r\n    const columns = this.slickGrid.getColumns();\r\n    if (Array.isArray(columns)) {\r\n      const columnRef = columns.find((col: Column) => col.id === column.id);\r\n      if (columnRef) {\r\n        columnRef.internalColumnEditor = column.editor as ColumnEditor;\r\n      }\r\n    }\r\n\r\n    // get current Editor, remove it from the DOM then re-enable it and re-render it with the new collection.\r\n    const currentEditor = this.slickGrid.getCellEditor() as AutoCompleteEditor | SelectEditor;\r\n    if (currentEditor?.disable && currentEditor?.renderDomElement) {\r\n      currentEditor.destroy();\r\n      currentEditor.disable(false);\r\n      currentEditor.renderDomElement(newCollection);\r\n    }\r\n  }\r\n}\r\n","<div id=\"slickGridContainer-{{gridId}}\" class=\"gridPane\">\r\n  <div attr.id='{{gridId}}' class=\"slickgrid-container\" style=\"width: 100%\">\r\n  </div>\r\n</div>"]}