slickgrid-react 3.0.0 → 3.0.2

package/dist/amd/components/slickgrid-react.js

@@ -1,1326 +0,0 @@
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-define(["require", "exports", "i18next", "react", "sortablejs", "@slickgrid-universal/common", "@slickgrid-universal/event-pub-sub", "@slickgrid-universal/custom-footer-component", "@slickgrid-universal/empty-warning-component", "@slickgrid-universal/pagination-component", "dequal/lite", "../constants", "../global-grid-options", "../services/index", "../services/singletons", "slickgrid/slick.core", "slickgrid/slick.interactions", "slickgrid/slick.grid", "slickgrid/slick.dataview"], function (require, exports, i18next_1, react_1, Sortable_, common_1, event_pub_sub_1, custom_footer_component_1, empty_warning_component_1, pagination_component_1, lite_1, constants_1, global_grid_options_1, index_1, singletons_1) {
-    "use strict";
-    var _a;
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.SlickgridReact = void 0;
-    i18next_1 = __importDefault(i18next_1);
-    react_1 = __importDefault(react_1);
-    Sortable_ = __importStar(Sortable_);
-    const Sortable = ((_a = Sortable_ === null || Sortable_ === void 0 ? void 0 : Sortable_['default']) !== null && _a !== void 0 ? _a : Sortable_); // patch for rollup
-    // add Sortable to the window object so that SlickGrid lib can use globally
-    window.Sortable = Sortable;
-    class CustomEventPubSubService extends event_pub_sub_1.EventPubSubService {
-        set elementSource(value) {
-            this._elementSource = value;
-        }
-    }
-    class SlickgridReact extends react_1.default.Component {
-        setStateValue(key, value, callback) {
-            var _a;
-            if (((_a = this.state) === null || _a === void 0 ? void 0 : _a[key]) === value) {
-                return;
-            }
-            if (!this._mounted) {
-                this.state = this.state || {};
-                this.state[key] = value;
-                return;
-            }
-            this.setState(() => {
-                const result = {};
-                result[key] = value;
-                return result;
-            }, callback);
-        }
-        get gridOptions() {
-            return this._gridOptions || {};
-        }
-        set gridOptions(options) {
-            var _a, _b, _c;
-            let mergedOptions;
-            // if we already have grid options, when grid was already initialized, we'll merge with those options
-            // else we'll merge with global grid options
-            if ((_a = this.grid) === null || _a === void 0 ? void 0 : _a.getOptions) {
-                mergedOptions = Slick.Utils.extend(true, {}, this.grid.getOptions(), options);
-            }
-            else {
-                mergedOptions = this.mergeGridOptions(options);
-            }
-            if (((_b = this.sharedService) === null || _b === void 0 ? void 0 : _b.gridOptions) && ((_c = this.grid) === null || _c === void 0 ? void 0 : _c.setOptions)) {
-                this.sharedService.gridOptions = mergedOptions;
-                this.grid.setOptions(mergedOptions, false, true); // make sure to supressColumnCheck (3rd arg) to avoid problem with changeColumnsArrangement() and custom grid view
-                this.grid.reRenderColumns(true); // then call a re-render since we did supressColumnCheck on previous setOptions
-            }
-            this._gridOptions = mergedOptions;
-        }
-        get paginationService() {
-            var _a;
-            return (_a = this.state) === null || _a === void 0 ? void 0 : _a.paginationService;
-        }
-        set paginationService(value) {
-            this.setStateValue('paginationService', value);
-        }
-        get dataset() {
-            var _a;
-            return ((_a = this.dataView) === null || _a === void 0 ? void 0 : _a.getItems()) || [];
-        }
-        set dataset(newDataset) {
-            var _a, _b;
-            const prevDatasetLn = this._currentDatasetLength;
-            const isDatasetEqual = (0, lite_1.dequal)(newDataset, this.dataset || []);
-            const isDeepCopyDataOnPageLoadEnabled = !!((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enableDeepCopyDatasetOnPageLoad);
-            let data = isDeepCopyDataOnPageLoadEnabled ? Slick.Utils.extend(true, [], newDataset) : 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.grid && ((_b = this.gridOptions) === null || _b === void 0 ? void 0 : _b.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.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.grid && this.gridOptions.autoFitColumnsOnFirstLoad && prevDatasetLn === 0) {
-                this.grid.autosizeColumns();
-            }
-        }
-        get datasetHierarchical() {
-            return this.sharedService.hierarchicalDataset;
-        }
-        set datasetHierarchical(newHierarchicalDataset) {
-            var _a, _b, _c, _d, _f, _g;
-            const isDatasetEqual = (0, lite_1.dequal)(newHierarchicalDataset, (_b = (_a = this.sharedService) === null || _a === void 0 ? void 0 : _a.hierarchicalDataset) !== null && _b !== void 0 ? _b : []);
-            const prevFlatDatasetLn = this._currentDatasetLength;
-            this.sharedService.hierarchicalDataset = newHierarchicalDataset;
-            if (newHierarchicalDataset && this.props.columnDefinitions && ((_c = this.filterService) === null || _c === void 0 ? void 0 : _c.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 (this.dataView && newHierarchicalDataset && this.grid && ((_d = this.sortService) === null || _d === void 0 ? void 0 : _d.processTreeDataInitialSort)) {
-                this.dataView.setItems([], (_g = (_f = this._gridOptions) === null || _f === void 0 ? void 0 : _f.datasetIdPropertyName) !== null && _g !== void 0 ? _g : '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(() => {
-                    var _a, _b;
-                    const flatDatasetLn = (_b = (_a = this.dataView) === null || _a === void 0 ? void 0 : _a.getItemCount()) !== null && _b !== void 0 ? _b : 0;
-                    if (flatDatasetLn > 0 && (flatDatasetLn !== prevFlatDatasetLn || !isDatasetEqual)) {
-                        this.filterService.refreshTreeDataFilters();
-                    }
-                });
-            }
-            this._isDatasetHierarchicalInitialized = true;
-        }
-        constructor(props) {
-            var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7;
-            super(props);
-            this.props = props;
-            this._mounted = false;
-            this._columnDefinitions = [];
-            this._currentDatasetLength = 0;
-            this._dataset = null;
-            this._hideHeaderRowAfterPageLoad = false;
-            this._isGridInitialized = false;
-            this._isDatasetInitialized = false;
-            this._isDatasetHierarchicalInitialized = false;
-            this._isPaginationInitialized = false;
-            this._isLocalGrid = true;
-            this._registeredResources = [];
-            this.showPagination = false;
-            this.serviceList = [];
-            this.subscriptions = [];
-            this.totalItems = 0;
-            this.instances = null;
-            const slickgridConfig = new common_1.SlickgridConfig();
-            this._eventHandler = new Slick.EventHandler();
-            this.showPagination = false;
-            // check if the user wants to hide the header row from the start
-            // we only want to do this check once in the constructor
-            this._hideHeaderRowAfterPageLoad = (((_a = props.gridOptions) === null || _a === void 0 ? void 0 : _a.showHeaderRow) === false);
-            this._gridOptions = this.mergeGridOptions(props.gridOptions || {});
-            // initialize and assign all Service Dependencies
-            this._eventPubSubService = (_c = (_b = this.props.externalServices) === null || _b === void 0 ? void 0 : _b.eventPubSubService) !== null && _c !== void 0 ? _c : new CustomEventPubSubService();
-            this._eventPubSubService.eventNamingStyle = common_1.EventNamingStyle.camelCase;
-            this.backendUtilityService = (_f = (_d = this.props.externalServices) === null || _d === void 0 ? void 0 : _d.backendUtilityService) !== null && _f !== void 0 ? _f : new common_1.BackendUtilityService();
-            this.gridEventService = (_h = (_g = this.props.externalServices) === null || _g === void 0 ? void 0 : _g.gridEventService) !== null && _h !== void 0 ? _h : new common_1.GridEventService();
-            this.sharedService = (_k = (_j = this.props.externalServices) === null || _j === void 0 ? void 0 : _j.sharedService) !== null && _k !== void 0 ? _k : new common_1.SharedService();
-            this.collectionService = (_m = (_l = this.props.externalServices) === null || _l === void 0 ? void 0 : _l.collectionService) !== null && _m !== void 0 ? _m : new common_1.CollectionService(this.props.translaterService);
-            this.extensionUtility = (_p = (_o = this.props.externalServices) === null || _o === void 0 ? void 0 : _o.extensionUtility) !== null && _p !== void 0 ? _p : new common_1.ExtensionUtility(this.sharedService, this.backendUtilityService, this.props.translaterService);
-            this.filterFactory = new common_1.FilterFactory(slickgridConfig, this.props.translaterService, this.collectionService);
-            this.filterService = (_r = (_q = this.props.externalServices) === null || _q === void 0 ? void 0 : _q.filterService) !== null && _r !== void 0 ? _r : new common_1.FilterService(this.filterFactory, this._eventPubSubService, this.sharedService, this.backendUtilityService);
-            this.resizerService = (_t = (_s = this.props.externalServices) === null || _s === void 0 ? void 0 : _s.resizerService) !== null && _t !== void 0 ? _t : new common_1.ResizerService(this._eventPubSubService);
-            this.sortService = (_v = (_u = this.props.externalServices) === null || _u === void 0 ? void 0 : _u.sortService) !== null && _v !== void 0 ? _v : new common_1.SortService(this.sharedService, this._eventPubSubService, this.backendUtilityService);
-            this.treeDataService = (_x = (_w = this.props.externalServices) === null || _w === void 0 ? void 0 : _w.treeDataService) !== null && _x !== void 0 ? _x : new common_1.TreeDataService(this._eventPubSubService, this.sharedService, this.sortService);
-            this.paginationService = (_z = (_y = this.props.externalServices) === null || _y === void 0 ? void 0 : _y.paginationService) !== null && _z !== void 0 ? _z : new common_1.PaginationService(this._eventPubSubService, this.sharedService, this.backendUtilityService);
-            this.extensionService = (_1 = (_0 = this.props.externalServices) === null || _0 === void 0 ? void 0 : _0.extensionService) !== null && _1 !== void 0 ? _1 : new common_1.ExtensionService(this.extensionUtility, this.filterService, this._eventPubSubService, this.sharedService, this.sortService, this.treeDataService, this.props.translaterService);
-            this.gridStateService = (_3 = (_2 = this.props.externalServices) === null || _2 === void 0 ? void 0 : _2.gridStateService) !== null && _3 !== void 0 ? _3 : new common_1.GridStateService(this.extensionService, this.filterService, this._eventPubSubService, this.sharedService, this.sortService, this.treeDataService);
-            this.gridService = (_5 = (_4 = this.props.externalServices) === null || _4 === void 0 ? void 0 : _4.gridService) !== null && _5 !== void 0 ? _5 : new common_1.GridService(this.gridStateService, this.filterService, this._eventPubSubService, this.paginationService, this.sharedService, this.sortService, this.treeDataService);
-            this.groupingService = (_7 = (_6 = this.props.externalServices) === null || _6 === void 0 ? void 0 : _6.groupingAndColspanService) !== null && _7 !== void 0 ? _7 : new common_1.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,
-            ];
-            if (this.props.datasetHierarchical) {
-                this.sharedService.hierarchicalDataset = this.props.datasetHierarchical || [];
-            }
-            // register all Service instances in the container
-            this.props.containerService.registerInstance('PubSubService', this._eventPubSubService);
-            this.props.containerService.registerInstance('EventPubSubService', this._eventPubSubService);
-            this.props.containerService.registerInstance('ExtensionUtility', this.extensionUtility);
-            this.props.containerService.registerInstance('FilterService', this.filterService);
-            this.props.containerService.registerInstance('CollectionService', this.collectionService);
-            this.props.containerService.registerInstance('ExtensionService', this.extensionService);
-            this.props.containerService.registerInstance('GridEventService', this.gridEventService);
-            this.props.containerService.registerInstance('GridService', this.gridService);
-            this.props.containerService.registerInstance('GridStateService', this.gridStateService);
-            this.props.containerService.registerInstance('GroupingAndColspanService', this.groupingService);
-            this.props.containerService.registerInstance('PaginationService', this.paginationService);
-            this.props.containerService.registerInstance('ResizerService', this.resizerService);
-            this.props.containerService.registerInstance('SharedService', this.sharedService);
-            this.props.containerService.registerInstance('SortService', this.sortService);
-            this.props.containerService.registerInstance('TranslaterService', this.props.translaterService);
-            this.props.containerService.registerInstance('TreeDataService', this.treeDataService);
-        }
-        get eventHandler() {
-            return this._eventHandler;
-        }
-        get isDatasetInitialized() {
-            return this._isDatasetInitialized;
-        }
-        set isDatasetInitialized(isInitialized) {
-            this._isDatasetInitialized = isInitialized;
-        }
-        set isDatasetHierarchicalInitialized(isInitialized) {
-            this._isDatasetHierarchicalInitialized = isInitialized;
-        }
-        get registeredResources() {
-            return this._registeredResources;
-        }
-        componentDidMount() {
-            var _a, _b;
-            this._mounted = true;
-            if (this._elm && this._eventPubSubService instanceof CustomEventPubSubService) {
-                this._eventPubSubService.elementSource = this._elm;
-                // React doesn't play well with Custom Events & also the render is called after the constructor which brings a second problem
-                // to fix both issues, we need to do the following:
-                // loop through all component and subscribe to all props that startsWith "on", assuming they are custom event
-                // and call their listener with event is dispatching
-                for (const prop in this.props) {
-                    if (prop.startsWith('on')) {
-                        this.subscriptions.push(this._eventPubSubService.subscribe(prop, (data) => {
-                            // eslint-disable-next-line @typescript-eslint/ban-types
-                            const callback = this.props[prop];
-                            const gridEventName = this._eventPubSubService.getEventNameByNamingConvention(prop, '');
-                            typeof callback === 'function' && callback.call(null, new CustomEvent(gridEventName, { detail: data }));
-                        }));
-                    }
-                }
-            }
-            this.initialization(this._eventHandler);
-            this._isGridInitialized = true;
-            if (!this._isPaginationInitialized && !this.props.datasetHierarchical && ((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enablePagination) && this._isLocalGrid) {
-                this.showPagination = true;
-                this.loadLocalGridPagination(this.dataset);
-            }
-            // recheck the empty warning message after grid is shown so that it works in every use case
-            if ((_b = this._gridOptions) === null || _b === void 0 ? void 0 : _b.enableEmptyDataWarningMessage) {
-                const dataset = this.props.dataset || [];
-                if (Array.isArray(dataset)) {
-                    const finalTotalCount = dataset.length;
-                    this.displayEmptyDataWarning(finalTotalCount < 1);
-                }
-            }
-        }
-        initialization(eventHandler) {
-            var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
-            if (!this._gridOptions || !this._columnDefinitions) {
-                throw new Error('Using `<SlickgridReact>` requires columnDefinitions and gridOptions, it seems that you might have forgot to provide them since at least of them is undefined.');
-            }
-            this._gridOptions.translater = this.props.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 = (_b = (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.eventNamingStyle) !== null && _b !== void 0 ? _b : common_1.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.props.dataset || [];
-            this._currentDatasetLength = this._dataset.length;
-            this._gridOptions = this.mergeGridOptions(this._gridOptions);
-            this._paginationOptions = (_c = this._gridOptions) === null || _c === void 0 ? void 0 : _c.pagination;
-            this.locales = (_f = (_d = this._gridOptions) === null || _d === void 0 ? void 0 : _d.locales) !== null && _f !== void 0 ? _f : constants_1.Constants.locales;
-            this.backendServiceApi = (_g = this._gridOptions) === null || _g === void 0 ? void 0 : _g.backendServiceApi;
-            this._isLocalGrid = !this.backendServiceApi; // considered a local grid if it doesn't have a backend service set
-            this.createBackendApiInternalPostProcessCallback(this._gridOptions);
-            if (!this.props.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 common_1.SlickGroupItemMetadataProvider();
-                    this.sharedService.groupItemMetadataProvider = this.groupItemMetadataProvider;
-                    dataViewOptions = Object.assign(Object.assign({}, 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 Slickgrid-React 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.props.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) {
-                (0, common_1.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;
-            // after subscribing to potential columns changed, we are ready to create these optional extensions
-            // when we did find some to create (RowMove, RowDetail, RowSelections), it will automatically modify column definitions (by previous subscribe)
-            this.extensionService.createExtensionsBeforeGridCreation(this._columnDefinitions, this._gridOptions);
-            // if user entered some Pinning/Frozen "presets", we need to apply them in the grid options
-            if ((_h = this.gridOptions.presets) === null || _h === void 0 ? void 0 : _h.pinning) {
-                this.gridOptions = Object.assign(Object.assign({}, this.gridOptions), this.gridOptions.presets.pinning);
-            }
-            // build SlickGrid Grid, also user might optionally pass a custom dataview (e.g. remote model)
-            this.grid = new Slick.Grid(`#${this.props.gridId}`, this.props.customDataView || this.dataView, this._columnDefinitions, this._gridOptions);
-            this.sharedService.dataView = this.dataView;
-            this.sharedService.slickGrid = this.grid;
-            this.sharedService.gridContainerElement = this._elm;
-            this.extensionService.bindDifferentExtensions();
-            this.bindDifferentHooks(this.grid, 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 = (_k = (_j = this._gridOptions) === null || _j === void 0 ? void 0 : _j.frozenColumn) !== null && _k !== void 0 ? _k : -1;
-            if (frozenColumnIndex >= 0 && frozenColumnIndex <= this._columnDefinitions.length && this._columnDefinitions.length > 0) {
-                this.sharedService.frozenVisibleColumnId = (_m = (_l = this._columnDefinitions[frozenColumnIndex]) === null || _l === void 0 ? void 0 : _l.id) !== null && _m !== void 0 ? _m : '';
-            }
-            // get any possible Services that user want to register
-            this.registerResources();
-            // initialize the SlickGrid grid
-            this.grid.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)
-            const gridContainerElm = this._elm;
-            if (gridContainerElm) {
-                this.resizerService.init(this.grid, gridContainerElm);
-            }
-            // 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 && gridContainerElm) {
-                this.slickFooter = new custom_footer_component_1.SlickFooterComponent(this.grid, this._gridOptions.customFooterOptions, this._eventPubSubService, this.props.translaterService);
-                this.slickFooter.renderFooter(gridContainerElm);
-            }
-            if (!this.props.customDataView && this.dataView) {
-                const initialDataset = ((_o = this._gridOptions) === null || _o === void 0 ? void 0 : _o.enableTreeData) ? this.sortTreeDataset(this.props.dataset) : this.props.dataset;
-                if (Array.isArray(initialDataset)) {
-                    this.dataView.setItems(initialDataset, (_p = this._gridOptions.datasetIdPropertyName) !== null && _p !== void 0 ? _p : 'id');
-                }
-                // 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
-                if (((_q = this.grid) === null || _q === void 0 ? void 0 : _q.getSelectionModel()) && ((_r = this._gridOptions) === null || _r === void 0 ? void 0 : _r.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.grid, preservedRowSelection);
-                    }
-                    else if (typeof syncGridSelection === 'object') {
-                        this.dataView.syncGridSelection(this.grid, syncGridSelection.preserveHidden, syncGridSelection.preserveHiddenOnSelectionChange);
-                    }
-                }
-                if (this._dataset.length > 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.grid);
-            // after the DataView is created & updated execute some processes & dispatch some events
-            if (!this.props.customDataView) {
-                this.executeAfterDataviewCreated(this.grid, this._gridOptions);
-            }
-            // bind resize ONLY after the dataView is ready
-            this.bindResizeHook(this.grid, this._gridOptions);
-            // bind the Backend Service API callback functions only after the grid is initialized
-            // because the preProcess() and onInit() might get triggered
-            if ((_s = this._gridOptions) === null || _s === void 0 ? void 0 : _s.backendServiceApi) {
-                this.bindBackendCallbackFunctions(this._gridOptions);
-            }
-            // create the React Grid Instance with reference to all Services
-            const reactElementInstance = {
-                element: this._elm,
-                // Slick Grid & DataView objects
-                dataView: this.dataView,
-                slickGrid: this.grid,
-                // public methods
-                dispose: this.dispose.bind(this),
-                // return all available Services (non-singleton)
-                backendService: (_u = (_t = this._gridOptions) === null || _t === void 0 ? void 0 : _t.backendServiceApi) === null || _u === void 0 ? void 0 : _u.service,
-                eventPubSubService: this._eventPubSubService,
-                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,
-            };
-            // addons (SlickGrid extra plugins/controls)
-            this.extensions = (_v = this.extensionService) === null || _v === void 0 ? void 0 : _v.extensionList;
-            // all instances (SlickGrid, DataView & all Services)
-            this.instances = reactElementInstance;
-            this.setStateValue('instances', reactElementInstance);
-            this._eventPubSubService.publish(`onReactGridCreated`, reactElementInstance);
-        }
-        componentWillUnmount(shouldEmptyDomElementContainer = false) {
-            var _a, _b, _c, _d, _f;
-            this._eventPubSubService.publish(`onBeforeGridDestroy`, this.grid);
-            (_a = this._eventHandler) === null || _a === void 0 ? void 0 : _a.unsubscribeAll();
-            i18next_1.default.off('languageChanged');
-            // we could optionally also empty the content of the grid container DOM element
-            if (shouldEmptyDomElementContainer) {
-                this.emptyGridContainerElm();
-            }
-            this._eventPubSubService.publish(`onAfterGridDestroyed`, true);
-            // dispose of all Services
-            this.serviceList.forEach((service) => {
-                if (service === null || service === void 0 ? void 0 : 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 === null || resource === void 0 ? void 0 : resource.dispose) {
-                        resource.dispose();
-                    }
-                }
-                this._registeredResources = [];
-            }
-            // dispose the Components
-            (_b = this.slickEmptyWarning) === null || _b === void 0 ? void 0 : _b.dispose();
-            (_c = this.slickFooter) === null || _c === void 0 ? void 0 : _c.dispose();
-            (_d = this.slickPagination) === null || _d === void 0 ? void 0 : _d.dispose();
-            if (this.dataView) {
-                if (this.dataView.setItems) {
-                    this.dataView.setItems([]);
-                }
-                if (this.dataView.destroy) {
-                    this.dataView.destroy();
-                }
-            }
-            if ((_f = this.grid) === null || _f === void 0 ? void 0 : _f.destroy) {
-                this.grid.destroy(shouldEmptyDomElementContainer);
-            }
-            // also dispose of all Subscriptions
-            this.subscriptions = (0, index_1.disposeAllSubscriptions)(this.subscriptions);
-            if (this.backendServiceApi) {
-                for (const prop of Object.keys(this.backendServiceApi)) {
-                    this.backendServiceApi[prop] = null;
-                }
-                this.backendServiceApi = undefined;
-            }
-            for (const prop of Object.keys(this.props.columnDefinitions)) {
-                this.props.columnDefinitions[prop] = null;
-            }
-            for (const prop of Object.keys(this.sharedService)) {
-                this.sharedService[prop] = null;
-            }
-            this._dataset = null;
-            this._columnDefinitions = [];
-        }
-        emptyGridContainerElm() {
-            var _a, _b;
-            const gridContainerId = (_b = (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.gridContainerId) !== null && _b !== void 0 ? _b : 'grid1';
-            const gridContainerElm = document.querySelector(`#${gridContainerId}`);
-            (0, common_1.emptyElement)(gridContainerElm);
-        }
-        dispose(shouldEmptyDomElementContainer = false) {
-            this.componentWillUnmount(shouldEmptyDomElementContainer);
-        }
-        componentDidUpdate(prevProps) {
-            // get the grid options (order of precedence is Global Options first, then user option which could overwrite the Global options)
-            if (this.props.gridOptions !== prevProps.gridOptions) {
-                this._gridOptions = Object.assign(Object.assign({}, global_grid_options_1.GlobalGridOptions), this._gridOptions);
-            }
-            if (this.props.columnDefinitions !== prevProps.columnDefinitions) {
-                this._columnDefinitions = this.props.columnDefinitions;
-                this.columnDefinitionsChanged();
-            }
-            if (this.props.dataset !== prevProps.dataset) {
-                this.dataset = this.props.dataset || prevProps.dataset;
-            }
-            if (this.props.datasetHierarchical && this.props.datasetHierarchical !== prevProps.datasetHierarchical) {
-                this.datasetHierarchical = this.props.datasetHierarchical;
-            }
-        }
-        columnDefinitionsChanged() {
-            this._columnDefinitions = this.props.columnDefinitions;
-            if (this._isGridInitialized) {
-                this.updateColumnDefinitionsList(this.props.columnDefinitions);
-            }
-            if (this._columnDefinitions.length > 0) {
-                this.copyColumnWidthsReference(this._columnDefinitions);
-            }
-        }
-        /**
-         * Commits the current edit to the grid
-         */
-        commitEdit(target) {
-            if (this.grid.getOptions().autoCommitEdit) {
-                const activeNode = this.grid.getActiveCellNode();
-                // a timeout must be set or this could come into conflict when slickgrid
-                // tries to commit the edit when going from one editor to another on the grid
-                // through the click event. If the timeout was not here it would
-                // try to commit/destroy the twice, which would throw an
-                // error about the element not being in the DOM
-                setTimeout(() => {
-                    var _a;
-                    // make sure the target is the active editor so we do not
-                    // commit prematurely
-                    if ((activeNode === null || activeNode === void 0 ? void 0 : activeNode.contains(target)) && this.grid.getEditorLock().isActive() && !((_a = target === null || target === void 0 ? void 0 : target.classList) === null || _a === void 0 ? void 0 : _a.contains('autocomplete'))) {
-                        this.grid.getEditorLock().commitCurrentEdit();
-                    }
-                });
-            }
-        }
-        /**
-         * 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 === null || gridOptions === void 0 ? void 0 : gridOptions.backendServiceApi;
-            if (backendApi === null || backendApi === void 0 ? void 0 : 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 === null || processResult === void 0 ? void 0 : 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);
-                        }
-                    };
-                }
-            }
-        }
-        bindDifferentHooks(grid, gridOptions, dataView) {
-            var _a, _b, _c;
-            // translate some of them on first load, then on each language change
-            if (gridOptions.enableTranslate) {
-                this.extensionService.translateAllExtensions();
-                this.translateColumnHeaderTitleKeys();
-                this.translateColumnGroupKeys();
-            }
-            // on locale change, we have to manually translate the Headers, GridMenu
-            i18next_1.default.on('languageChanged', () => {
-                // 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 ((_a = backendApi === null || backendApi === void 0 ? void 0 : backendApi.service) === null || _a === void 0 ? void 0 : _a.init) {
-                    backendApi.service.init(backendApi.options, gridOptions.pagination, this.grid, this.sharedService);
-                }
-            }
-            if (dataView && grid) {
-                const slickgridEventPrefix = (_c = (_b = this._gridOptions) === null || _b === void 0 ? void 0 : _b.defaultSlickgridEventPrefix) !== null && _c !== void 0 ? _c : '';
-                // 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) => {
-                            if (this.props.hasOwnProperty(prop)) {
-                                const callback = this.props[prop];
-                                return typeof callback === 'function' && callback(new CustomEvent(gridEventName, { detail: { eventData: event, args } }));
-                            }
-                            return true;
-                        });
-                    }
-                }
-                // 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);
-                            if (this.props.hasOwnProperty(prop)) {
-                                const callback = this.props[prop];
-                                return typeof callback === 'function' && callback(new CustomEvent(dataViewEventName, { detail: { eventData: event, args } }));
-                            }
-                            return true;
-                        });
-                    }
-                }
-                // on cell click, mainly used with the columnDef.action callback
-                this.gridEventService.bindOnBeforeEditCell(grid);
-                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);
-                        }
-                    }
-                    // when column are reordered, we need to update the visibleColumn array
-                    this._eventHandler.subscribe(grid.onColumnsReordered, (_e, args) => {
-                        this.sharedService.hasColumnsReordered = true;
-                        this.sharedService.visibleColumns = args.impactedColumns;
-                    });
-                    // 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(dataView.getFilteredItemCount() || 0, dataView.getItemCount() || 0);
-                    });
-                    this._eventHandler.subscribe(dataView.onSetItemsCalled, (_e, args) => {
-                        var _a;
-                        this.handleOnItemCountChanged(dataView.getFilteredItemCount() || 0, 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(!((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.resizeByContentOnlyOnFirstLoad));
-                        }
-                    });
-                    if ((gridOptions === null || gridOptions === void 0 ? void 0 : gridOptions.enableFiltering) && !gridOptions.enableRowDetailView) {
-                        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/slickgrid-universal/aurelia-slickgrid/commit/8c503a4d45fba11cbd8d8cc467fae8d177cc4f60
-                            if ((args === null || args === void 0 ? void 0 : 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 === null || gridOptions === void 0 ? void 0 : gridOptions.colspanCallback) && (dataView === null || dataView === void 0 ? void 0 : dataView.getItem) && (dataView === null || dataView === void 0 ? void 0 : dataView.getItemMetadata)) {
-                dataView.getItemMetadata = (rowNumber) => {
-                    let callbackResult = null;
-                    if (gridOptions.colspanCallback) {
-                        callbackResult = gridOptions.colspanCallback(dataView.getItem(rowNumber));
-                    }
-                    return callbackResult;
-                };
-            }
-        }
-        bindBackendCallbackFunctions(gridOptions) {
-            var _a, _b, _c, _d, _f;
-            const backendApi = gridOptions.backendServiceApi;
-            const backendApiService = backendApi === null || backendApi === void 0 ? void 0 : backendApi.service;
-            const serviceOptions = (backendApiService === null || backendApiService === void 0 ? void 0 : 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 === null || gridOptions === void 0 ? void 0 : 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 = ((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.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 ? ((_c = (_b = backendApi.process) === null || _b === void 0 ? void 0 : _b.call(backendApi, query)) !== null && _c !== void 0 ? _c : null) : ((_f = (_d = backendApi.onInit) === null || _d === void 0 ? void 0 : _d.call(backendApi, query)) !== null && _f !== void 0 ? _f : null);
-                    // wrap this inside a setTimeout to avoid timing issue since the gridOptions needs to be ready before running this onInit
-                    setTimeout(() => {
-                        var _a, _b, _c, _d;
-                        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 = (_c = (_b = (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.pagination) === null || _b === void 0 ? void 0 : _b.totalItems) !== null && _c !== void 0 ? _c : 0;
-                        if (process instanceof Promise) {
-                            process
-                                .then((processResult) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems))
-                                .catch((error) => backendUtilityService.onBackendError(error, backendApi));
-                        }
-                        else if (process && ((_d = this.rxjs) === null || _d === void 0 ? void 0 : _d.isObservable(process))) {
-                            this.subscriptions.push(process.subscribe((processResult) => backendUtilityService.executeBackendProcessesCallback(startTime, processResult, backendApi, totalItems), (error) => backendUtilityService.onBackendError(error, backendApi)));
-                        }
-                    });
-                }
-            }
-        }
-        bindResizeHook(grid, options) {
-            if ((options.autoFitColumnsOnFirstLoad && options.autosizeColumnsByCellContentOnFirstLoad) || (options.enableAutoSizeColumns && options.enableAutoResizeColumnsByCellContent)) {
-                throw new Error(`[Slickgrid-React] 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 && typeof grid.autosizeColumns === 'function') {
-                this.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 (grid && (options === null || options === void 0 ? void 0 : options.enableAutoResize)) {
-                if (options.autoFitColumnsOnFirstLoad && options.enableAutoSizeColumns && typeof grid.autosizeColumns === 'function') {
-                    grid.autosizeColumns();
-                }
-            }
-        }
-        executeAfterDataviewCreated(_grid, gridOptions) {
-            var _a;
-            // 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 = ((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.multiColumnSort) ? gridOptions.presets.sorters : gridOptions.presets.sorters.slice(0, 1);
-                    this.sortService.loadGridSorters(sortColumns);
-                }
-            }
-        }
-        /**
-         * 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 with a Backend Service (Odata, GraphQL), we need to reset any selection
-         */
-        paginationChanged(pagination) {
-            var _a, _b, _c;
-            const isSyncGridSelectionEnabled = (_b = (_a = this.gridStateService) === null || _a === void 0 ? void 0 : _a.needToPreserveRowSelection()) !== null && _b !== void 0 ? _b : false;
-            if (this.grid && !isSyncGridSelectionEnabled && ((_c = this.gridOptions) === null || _c === void 0 ? void 0 : _c.backendServiceApi) && (this.gridOptions.enableRowSelection || this.gridOptions.enableCheckboxSelector)) {
-                this.grid.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: common_1.GridStateType.pagination },
-                gridState: this.gridStateService.getCurrentGridState()
-            });
-        }
-        paginationOptionsChanged(newPaginationOptions) {
-            var _a;
-            if (newPaginationOptions && this._paginationOptions) {
-                this._paginationOptions = Object.assign(Object.assign({}, this._paginationOptions), newPaginationOptions);
-            }
-            else {
-                this._paginationOptions = newPaginationOptions;
-            }
-            if (this._gridOptions) {
-                this._gridOptions.pagination = this._paginationOptions;
-                this.paginationService.updateTotalItems((_a = newPaginationOptions === null || newPaginationOptions === void 0 ? void 0 : newPaginationOptions.totalItems) !== null && _a !== void 0 ? _a : 0, true);
-            }
-        }
-        /**
-         * When dataset changes, we need to refresh the entire grid UI & possibly resize it as well
-         * @param dataset
-         */
-        refreshGridData(dataset, totalCount) {
-            var _a, _b, _c, _d, _f, _g, _h, _j;
-            // 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.grid && this._gridOptions) {
-                if (((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enablePagination) && this._isLocalGrid) {
-                    this.showPagination = true;
-                    this.loadLocalGridPagination(dataset);
-                }
-                if (((_b = this._gridOptions) === null || _b === void 0 ? void 0 : _b.enableEmptyDataWarningMessage) && Array.isArray(dataset)) {
-                    const finalTotalCount = totalCount || dataset.length;
-                    this.displayEmptyDataWarning(finalTotalCount < 1);
-                }
-                if (Array.isArray(dataset) && this.grid && ((_c = this.dataView) === null || _c === void 0 ? void 0 : _c.setItems)) {
-                    this.dataView.setItems(dataset, (_d = this._gridOptions.datasetIdPropertyName) !== null && _d !== void 0 ? _d : '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.grid.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 && ((_f = this._gridOptions) === null || _f === void 0 ? void 0 : _f.pagination) && ((_g = this._gridOptions) === null || _g === void 0 ? void 0 : _g.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 : ((_j = (_h = this._gridOptions) === null || _h === void 0 ? void 0 : _h.pagination) === null || _j === void 0 ? void 0 : _j.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.grid && this._gridOptions.enableAutoResize) {
-                        const delay = this._gridOptions.autoResize && this._gridOptions.autoResize.delay;
-                        this.resizerService.resizeGrid(delay || 10);
-                    }
-                }
-            }
-        }
-        /**
-         * Show the filter row displayed on first row, we can optionally pass false to hide it.
-         * @param showing
-         */
-        showHeaderRow(showing = true) {
-            this.grid.setHeaderRowVisibility(showing, false);
-            if (showing === true && this._isGridInitialized) {
-                this.grid.setColumns(this.props.columnDefinitions);
-            }
-            return showing;
-        }
-        /**
-         * 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) {
-            var _a;
-            if (((_a = gridOptions.presets) === null || _a === void 0 ? void 0 : _a.pagination) && gridOptions.pagination) {
-                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) {
-            var _a, _b, _c;
-            if (this.grid && this._gridOptions && Array.isArray(newColumnDefinitions)) {
-                // map/swap the internal library Editor to the SlickGrid Editor factory
-                newColumnDefinitions = this.swapInternalEditorToSlickGridFactoryEditor(newColumnDefinitions);
-                // if the user wants to automatically add a Custom Editor Formatter, we need to call the auto add function again
-                if (this._gridOptions.autoAddCustomEditorFormatter) {
-                    (0, common_1.autoAddEditorFormatterToColumnsWithEditor)(newColumnDefinitions, this._gridOptions.autoAddCustomEditorFormatter);
-                }
-                if (this._gridOptions.enableTranslate) {
-                    this.extensionService.translateColumnHeaders(false, newColumnDefinitions);
-                }
-                else {
-                    this.extensionService.renderColumnHeaders(newColumnDefinitions, true);
-                }
-                if ((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enableAutoSizeColumns) {
-                    this.grid.autosizeColumns();
-                }
-                else if (((_b = this._gridOptions) === null || _b === void 0 ? void 0 : _b.enableAutoResizeColumnsByCellContent) && ((_c = this.resizerService) === null || _c === void 0 ? void 0 : _c.resizeColumnsByCellContent)) {
-                    this.resizerService.resizeColumnsByCellContent();
-                }
-            }
-        }
-        //
-        // protected 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) {
-            var _a;
-            (_a = this.slickEmptyWarning) === null || _a === void 0 ? void 0 : _a.showEmptyDataMessage(showWarning);
-        }
-        /** When data changes in the DataView, we'll refresh the metrics and/or display a warning if the dataset is empty */
-        handleOnItemCountChanged(currentPageRowItemCount, totalItemCount) {
-            var _a;
-            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 && ((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enableEmptyDataWarningMessage)) {
-                this.displayEmptyDataWarning(currentPageRowItemCount === 0);
-            }
-        }
-        /** Initialize the Pagination Service once */
-        initializePaginationService(paginationOptions) {
-            if (this.grid && this.gridOptions) {
-                this.paginationData = {
-                    gridOptions: this.gridOptions,
-                    paginationService: this.paginationService,
-                };
-                this.paginationService.totalItems = this.totalItems;
-                this.paginationService.init(this.grid, paginationOptions, this.backendServiceApi);
-                this.subscriptions.push(this._eventPubSubService.subscribe('onPaginationChanged', paginationChanges => this.paginationChanged(paginationChanges)), this._eventPubSubService.subscribe('onPaginationOptionsChanged', paginationChanges => this.paginationOptionsChanged(paginationChanges)), this._eventPubSubService.subscribe('onPaginationVisibilityChanged', (visibility) => {
-                    var _a, _b, _c;
-                    this.showPagination = (_a = visibility === null || visibility === void 0 ? void 0 : visibility.visible) !== null && _a !== void 0 ? _a : false;
-                    if ((_b = this.gridOptions) === null || _b === void 0 ? void 0 : _b.backendServiceApi) {
-                        (_c = this.backendUtilityService) === null || _c === void 0 ? void 0 : _c.refreshBackendDataset(this.gridOptions);
-                    }
-                    this.renderPagination(this.showPagination);
-                }));
-                // also initialize (render) the pagination component
-                this.renderPagination();
-                this._isPaginationInitialized = true;
-            }
-        }
-        /**
-         * 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) {
-            var _a;
-            if (((_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.enablePagination) && !this._isPaginationInitialized && showPagination) {
-                this.slickPagination = new pagination_component_1.SlickPaginationComponent(this.paginationService, this._eventPubSubService, this.sharedService, this.props.translaterService);
-                this.slickPagination.renderPagination(this._elm);
-                this._isPaginationInitialized = true;
-            }
-            else if (!showPagination) {
-                if (this.slickPagination) {
-                    this.slickPagination.dispose();
-                }
-                this._isPaginationInitialized = false;
-            }
-        }
-        /** Load the Editor Collection asynchronously and replace the "collection" property when Promise resolves */
-        loadEditorCollectionAsync(column) {
-            var _a;
-            const collectionAsync = (column === null || column === void 0 ? void 0 : column.editor).collectionAsync;
-            (column === null || column === void 0 ? void 0 : column.editor).disabled = true; // disable the Editor DOM element, we'll re-enable it after receiving the collection with "updateEditorCollection()"
-            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
-                    }
-                    else if (response instanceof Response && typeof response.json === 'function') {
-                        if (response.bodyUsed) {
-                            console.warn(`[SlickGrid-React] The response body passed to collectionAsync was already read.`
-                                + `Either pass the dataset from the Response or clone the response first using response.clone()`);
-                        }
-                        else {
-                            // from Fetch
-                            response.json().then(data => this.updateEditorCollection(column, data));
-                        }
-                    }
-                    else if (response === null || response === void 0 ? void 0 : response.content) {
-                        this.updateEditorCollection(column, response.content); // from http-client
-                    }
-                });
-            }
-            else if ((_a = this.rxjs) === null || _a === void 0 ? void 0 : _a.isObservable(collectionAsync)) {
-                // wrap this inside a setTimeout to avoid timing issue since updateEditorCollection requires to call SlickGrid getColumns() method
-                setTimeout(() => {
-                    this.subscriptions.push(collectionAsync.subscribe((resolvedCollection) => this.updateEditorCollection(column, resolvedCollection)));
-                });
-            }
-        }
-        insertDynamicPresetColumns(columnId, gridPresetColumns) {
-            if (this._columnDefinitions) {
-                const columnPosition = this._columnDefinitions.findIndex(c => c.id === columnId);
-                if (columnPosition >= 0) {
-                    const dynColumn = this._columnDefinitions[columnPosition];
-                    if ((dynColumn === null || dynColumn === void 0 ? void 0 : dynColumn.id) === columnId && !gridPresetColumns.some(c => c.id === columnId)) {
-                        columnPosition > 0
-                            ? gridPresetColumns.splice(columnPosition, 0, dynColumn)
-                            : gridPresetColumns.unshift(dynColumn);
-                    }
-                }
-            }
-        }
-        /** Load any possible Columns Grid Presets */
-        loadColumnPresetsWhenDatasetInitialized() {
-            var _a, _b, _c, _d, _f, _g, _h, _j, _k;
-            // if user entered some Columns "presets", we need to reflect them all in the grid
-            if (this.grid && this.gridOptions.presets && Array.isArray(this.gridOptions.presets.columns) && this.gridOptions.presets.columns.length > 0) {
-                const gridPresetColumns = this.gridStateService.getAssociatedGridColumns(this.grid, this.gridOptions.presets.columns);
-                if (gridPresetColumns && Array.isArray(gridPresetColumns) && gridPresetColumns.length > 0 && Array.isArray(this._columnDefinitions)) {
-                    // make sure that the dynamic columns are included in presets (1.Row Move, 2. Row Selection, 3. Row Detail)
-                    if (this.gridOptions.enableRowMoveManager) {
-                        const rmmColId = (_c = (_b = (_a = this.gridOptions) === null || _a === void 0 ? void 0 : _a.rowMoveManager) === null || _b === void 0 ? void 0 : _b.columnId) !== null && _c !== void 0 ? _c : '_move';
-                        this.insertDynamicPresetColumns(rmmColId, gridPresetColumns);
-                    }
-                    if (this.gridOptions.enableCheckboxSelector) {
-                        const chkColId = (_g = (_f = (_d = this.gridOptions) === null || _d === void 0 ? void 0 : _d.checkboxSelector) === null || _f === void 0 ? void 0 : _f.columnId) !== null && _g !== void 0 ? _g : '_checkbox_selector';
-                        this.insertDynamicPresetColumns(chkColId, gridPresetColumns);
-                    }
-                    if (this.gridOptions.enableRowDetailView) {
-                        const rdvColId = (_k = (_j = (_h = this.gridOptions) === null || _h === void 0 ? void 0 : _h.rowDetailView) === null || _j === void 0 ? void 0 : _j.columnId) !== null && _k !== void 0 ? _k : '_detail_selector';
-                        this.insertDynamicPresetColumns(rdvColId, gridPresetColumns);
-                    }
-                    // 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.
-                    gridPresetColumns.forEach(col => col.originalWidth = col.width);
-                    // finally set the new presets columns (including checkbox selector if need be)
-                    this.grid.setColumns(gridPresetColumns);
-                    this.sharedService.visibleColumns = gridPresetColumns;
-                }
-            }
-        }
-        /** Load any possible Filters Grid Presets */
-        loadFilterPresetsWhenDatasetInitialized() {
-            var _a, _b, _c;
-            if (this._gridOptions && !this.props.customDataView) {
-                // if user entered some Filter "presets", we need to reflect them all in the DOM
-                if (this._gridOptions.presets && (Array.isArray(this._gridOptions.presets.filters) || Array.isArray((_b = (_a = this._gridOptions.presets) === null || _a === void 0 ? void 0 : _a.treeData) === null || _b === void 0 ? void 0 : _b.toggledItems))) {
-                    this.filterService.populateColumnFilterSearchTermPresets(((_c = this._gridOptions.presets) === null || _c === void 0 ? void 0 : _c.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) {
-            var _a;
-            if (this._gridOptions && this._paginationOptions) {
-                this.totalItems = Array.isArray(dataset) ? dataset.length : 0;
-                if (this._paginationOptions && ((_a = this.dataView) === null || _a === void 0 ? void 0 : _a.getPagingInfo)) {
-                    const slickPagingInfo = this.dataView.getPagingInfo();
-                    if ((slickPagingInfo === null || slickPagingInfo === void 0 ? void 0 : 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() {
-            var _a, _b;
-            // if user entered some Row Selections "presets"
-            const presets = (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.presets;
-            const enableRowSelection = this._gridOptions && (this._gridOptions.enableCheckboxSelector || this._gridOptions.enableRowSelection);
-            if (enableRowSelection && ((_b = this.grid) === null || _b === void 0 ? void 0 : _b.getSelectionModel()) && (presets === null || presets === void 0 ? void 0 : 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) || [];
-                }
-                // apply row selection when defined as grid presets
-                if (this.grid && Array.isArray(gridRowIndexes)) {
-                    this.grid.setSelectedRows(gridRowIndexes);
-                    this.dataView.setSelectedIds(dataContextIds || [], {
-                        isRowBeingAdded: true,
-                        shouldTriggerEvent: false,
-                        applyRowSelectionToGrid: true
-                    });
-                }
-            }
-        }
-        mergeGridOptions(gridOptions) {
-            // use extend to deep merge & copy to avoid immutable properties being changed in GlobalGridOptions after a route change
-            const options = Slick.Utils.extend(true, {}, global_grid_options_1.GlobalGridOptions, gridOptions);
-            options.gridId = this.props.gridId;
-            options.gridContainerId = `slickGridContainer-${this.props.gridId}`;
-            // also make sure to show the header row if user have enabled filtering
-            if (options.enableFiltering && !options.showHeaderRow) {
-                options.showHeaderRow = options.enableFiltering;
-            }
-            // 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
-            options.enablePagination = ((gridOptions.backendServiceApi && gridOptions.enablePagination === undefined) ? true : gridOptions.enablePagination) || false;
-            // using copy 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.
-            // 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 === null || options === void 0 ? void 0 : options.pagination) && (gridOptions.enablePagination || gridOptions.backendServiceApi) && gridOptions.pagination && Array.isArray(gridOptions.pagination.pageSizes)) {
-                options.pagination.pageSizes = gridOptions.pagination.pageSizes;
-            }
-            // 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 (this.sharedService && !options.enableFiltering && options.enablePagination && this._isLocalGrid) {
-                options.enableFiltering = true;
-                options.showHeaderRow = false;
-                this._hideHeaderRowAfterPageLoad = true;
-                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 || [];
-            // 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 ((resource === null || resource === void 0 ? void 0 : resource.className) === 'RxJsResource') {
-                        this.registerRxJsResource(resource);
-                    }
-                }
-            }
-        }
-        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();
-            }
-            // also initialize (render) the empty warning component
-            this.slickEmptyWarning = new empty_warning_component_1.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 (this.grid && typeof resource.init === 'function') {
-                        resource.init(this.grid, this.props.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.props.containerService.registerInstance('RxJsResource', this.rxjs);
-        }
-        /**
-         * 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) {
-            var _a, _b;
-            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 ((_b = (_a = this._gridOptions) === null || _a === void 0 ? void 0 : _a.treeDataOptions) === null || _b === void 0 ? void 0 : _b.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 Slickgrid-React 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('[Slickgrid-React] 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) => {
-                var _a, _b;
-                // on every Editor which have a "collection" or a "collectionAsync"
-                if ((_a = column.editor) === null || _a === void 0 ? void 0 : _a.collectionAsync) {
-                    this.loadEditorCollectionAsync(column);
-                }
-                return Object.assign(Object.assign({}, column), { editor: (_b = column.editor) === null || _b === void 0 ? void 0 : _b.model, internalColumnEditor: Object.assign({}, column.editor) });
-            });
-        }
-        /** translate all columns (including hidden columns) */
-        translateColumnHeaderTitleKeys() {
-            this.extensionUtility.translateItems(this.sharedService.allColumns, 'nameKey', 'name');
-        }
-        /** translate all column groups (including hidden columns) */
-        translateColumnGroupKeys() {
-            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
-            if (Array.isArray(this._columnDefinitions)) {
-                const columnRef = this._columnDefinitions.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.grid.getCellEditor();
-            if ((currentEditor === null || currentEditor === void 0 ? void 0 : currentEditor.disable) && (currentEditor === null || currentEditor === void 0 ? void 0 : currentEditor.renderDomElement)) {
-                currentEditor.destroy();
-                currentEditor.disable(false);
-                currentEditor.renderDomElement(newCollection);
-            }
-        }
-        render() {
-            return (react_1.default.createElement("div", { id: `slickGridContainer-${this.props.gridId}`, className: "grid-pane", ref: elm => this._elm = elm },
-                this.props.header && react_1.default.createElement("div", { className: "header" }, this.props.header),
-                react_1.default.createElement("div", { id: `${this.props.gridId}`, className: "slickgrid-container", style: { width: '100%' }, onBlur: $event => this.commitEdit($event.target) }),
-                this.props.footer && react_1.default.createElement("div", { className: "footer" }, this.props.footer)));
-        }
-    }
-    SlickgridReact.defaultProps = {
-        reactUtilService: new index_1.ReactUtilService(),
-        containerService: singletons_1.GlobalContainerService,
-        translaterService: new index_1.TranslaterService(),
-        dataset: [],
-        gridId: '',
-        columnDefinitions: [],
-    };
-    exports.SlickgridReact = SlickgridReact;
-});
-//# sourceMappingURL=slickgrid-react.js.map