@lemon-fe/kits 1.0.0-21 → 1.0.0-211

package/es/components/DataGrid/modules/client-side-row-model/clientSideRowModel/clientSideNodeManager.js

@@ -1,378 +0,0 @@
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-
-import { Events, RowNode, _ } from "@ag-grid-community/core";
-export var ClientSideNodeManager = /*#__PURE__*/function () {
-  function ClientSideNodeManager(rootNode, gridOptionsWrapper, eventService, columnModel, selectionService, beans) {
-    _classCallCheck(this, ClientSideNodeManager);
-
-    this.nextId = 0; // when user is provide the id's, we also keep a map of ids to row nodes for convenience
-
-    this.allNodesMap = {};
-    this.rootNode = rootNode;
-    this.gridOptionsWrapper = gridOptionsWrapper;
-    this.eventService = eventService;
-    this.columnModel = columnModel;
-    this.beans = beans;
-    this.selectionService = selectionService;
-    this.rootNode.group = true;
-    this.rootNode.level = -1;
-    this.rootNode.id = ClientSideNodeManager.ROOT_NODE_ID;
-    this.rootNode.allLeafChildren = [];
-    this.rootNode.childrenAfterGroup = [];
-    this.rootNode.childrenAfterSort = [];
-    this.rootNode.childrenAfterAggFilter = [];
-    this.rootNode.childrenAfterFilter = []; // if we make this class a bean, then can annotate postConstruct
-
-    this.postConstruct();
-  } // @PostConstruct - this is not a bean, so postConstruct called by constructor
-
-
-  _createClass(ClientSideNodeManager, [{
-    key: "postConstruct",
-    value: function postConstruct() {
-      // func below doesn't have 'this' pointer, so need to pull out these bits
-      this.suppressParentsInRowNodes = this.gridOptionsWrapper.isSuppressParentsInRowNodes();
-      this.isRowMasterFunc = this.gridOptionsWrapper.getIsRowMasterFunc();
-      this.doingTreeData = this.gridOptionsWrapper.isTreeData();
-      this.doingMasterDetail = this.gridOptionsWrapper.isMasterDetail();
-    }
-  }, {
-    key: "getCopyOfNodesMap",
-    value: function getCopyOfNodesMap() {
-      return _.cloneObject(this.allNodesMap);
-    }
-  }, {
-    key: "getRowNode",
-    value: function getRowNode(id) {
-      return this.allNodesMap[id];
-    }
-  }, {
-    key: "setRowData",
-    value: function setRowData(rowData) {
-      var _this = this;
-
-      if (typeof rowData === 'string') {
-        console.warn('AG Grid: rowData must be an array, however you passed in a string. If you are loading JSON, make sure you convert the JSON string to JavaScript objects first');
-        return;
-      }
-
-      var rootNode = this.rootNode;
-      var sibling = this.rootNode.sibling;
-      rootNode.childrenAfterFilter = null;
-      rootNode.childrenAfterGroup = null;
-      rootNode.childrenAfterAggFilter = null;
-      rootNode.childrenAfterSort = null;
-      rootNode.childrenMapped = null;
-      rootNode.updateHasChildren();
-      this.nextId = 0;
-      this.allNodesMap = {};
-
-      if (rowData) {
-        // we use rootNode as the parent, however if using ag-grid-enterprise, the grouping stage
-        // sets the parent node on each row (even if we are not grouping). so setting parent node
-        // here is for benefit of ag-grid-community users
-        rootNode.allLeafChildren = rowData.map(function (dataItem) {
-          return _this.createNode(dataItem, _this.rootNode, ClientSideNodeManager.TOP_LEVEL);
-        });
-      } else {
-        rootNode.allLeafChildren = [];
-        rootNode.childrenAfterGroup = [];
-      }
-
-      if (sibling) {
-        sibling.childrenAfterFilter = rootNode.childrenAfterFilter;
-        sibling.childrenAfterGroup = rootNode.childrenAfterGroup;
-        sibling.childrenAfterAggFilter = rootNode.childrenAfterAggFilter;
-        sibling.childrenAfterSort = rootNode.childrenAfterSort;
-        sibling.childrenMapped = rootNode.childrenMapped;
-        sibling.allLeafChildren = rootNode.allLeafChildren;
-      }
-    }
-  }, {
-    key: "updateRowData",
-    value: function updateRowData(rowDataTran, rowNodeOrder) {
-      var rowNodeTransaction = {
-        remove: [],
-        update: [],
-        add: []
-      };
-      var nodesToUnselect = [];
-      this.executeRemove(rowDataTran, rowNodeTransaction, nodesToUnselect);
-      this.executeUpdate(rowDataTran, rowNodeTransaction, nodesToUnselect);
-      this.executeAdd(rowDataTran, rowNodeTransaction);
-      this.updateSelection(nodesToUnselect);
-
-      if (rowNodeOrder) {
-        _.sortRowNodesByOrder(this.rootNode.allLeafChildren, rowNodeOrder);
-      }
-
-      return rowNodeTransaction;
-    }
-  }, {
-    key: "updateSelection",
-    value: function updateSelection(nodesToUnselect) {
-      var selectionChanged = nodesToUnselect.length > 0;
-
-      if (selectionChanged) {
-        nodesToUnselect.forEach(function (rowNode) {
-          rowNode.setSelected(false, false, true);
-        });
-      } // we do this regardless of nodes to unselect or not, as it's possible
-      // a new node was inserted, so a parent that was previously selected (as all
-      // children were selected) should not be tri-state (as new one unselected against
-      // all other selected children).
-
-
-      this.selectionService.updateGroupsFromChildrenSelections();
-
-      if (selectionChanged) {
-        var event = {
-          type: Events.EVENT_SELECTION_CHANGED
-        };
-        this.eventService.dispatchEvent(event);
-      }
-    }
-  }, {
-    key: "executeAdd",
-    value: function executeAdd(rowDataTran, rowNodeTransaction) {
-      var _this2 = this;
-
-      var add = rowDataTran.add,
-          addIndex = rowDataTran.addIndex;
-
-      if (_.missingOrEmpty(add)) {
-        return;
-      } // create new row nodes for each data item
-
-
-      var newNodes = add.map(function (item) {
-        return _this2.createNode(item, _this2.rootNode, ClientSideNodeManager.TOP_LEVEL);
-      }); // add new row nodes to the root nodes 'allLeafChildren'
-
-      var useIndex = typeof addIndex === 'number' && addIndex >= 0;
-      var nodesBeforeIndex;
-      var nodesAfterIndex;
-
-      if (useIndex) {
-        // new rows are inserted in one go by concatenating them in between the existing rows at the desired index.
-        // this is much faster than splicing them individually into 'allLeafChildren' when there are large inserts.
-        // allLeafChildren can be out of order, so we loop over all the Nodes to find the correct index that
-        // represents the position `addIndex` intended to be.
-        var allLeafChildren = this.rootNode.allLeafChildren; // if addIndex is 0, it should always be added at the start of the array
-        // there is no need to verify the order of node by nodeIndex.
-
-        var normalizedAddIndex = addIndex === 0 ? 0 : allLeafChildren.reduce(function (prevIdx, currNode, currIdx) {
-          var _a;
-
-          var rowIndex = currNode.rowIndex;
-          var prevValueAtIndex = (_a = allLeafChildren[prevIdx]) === null || _a === void 0 ? void 0 : _a.rowIndex;
-          var shouldUpdateIndex = rowIndex != null && prevValueAtIndex != null && rowIndex < addIndex && rowIndex > prevValueAtIndex;
-          return shouldUpdateIndex ? currIdx : prevIdx;
-        }, 0) + 1;
-        nodesBeforeIndex = allLeafChildren.slice(0, normalizedAddIndex);
-        nodesAfterIndex = allLeafChildren.slice(normalizedAddIndex, allLeafChildren.length);
-      } else {
-        nodesBeforeIndex = this.rootNode.allLeafChildren;
-        nodesAfterIndex = [];
-      }
-
-      this.rootNode.allLeafChildren = [].concat(_toConsumableArray(nodesBeforeIndex), _toConsumableArray(newNodes), _toConsumableArray(nodesAfterIndex));
-
-      if (this.rootNode.sibling) {
-        this.rootNode.sibling.allLeafChildren = this.rootNode.allLeafChildren;
-      } // add new row nodes to the transaction add items
-
-
-      rowNodeTransaction.add = newNodes;
-    }
-  }, {
-    key: "executeRemove",
-    value: function executeRemove(rowDataTran, rowNodeTransaction, nodesToUnselect) {
-      var _this3 = this;
-
-      var remove = rowDataTran.remove;
-
-      if (_.missingOrEmpty(remove)) {
-        return;
-      }
-
-      var rowIdsRemoved = {};
-      remove.forEach(function (item) {
-        var rowNode = _this3.lookupRowNode(item);
-
-        if (!rowNode) {
-          return;
-        } // do delete - setting 'suppressFinishActions = true' to ensure EVENT_SELECTION_CHANGED is not raised for
-        // each row node updated, instead it is raised once by the calling code if any selected nodes exist.
-
-
-        if (rowNode.isSelected()) {
-          nodesToUnselect.push(rowNode);
-        } // so row renderer knows to fade row out (and not reposition it)
-
-
-        rowNode.clearRowTopAndRowIndex(); // NOTE: were we could remove from allLeaveChildren, however _.removeFromArray() is expensive, especially
-        // if called multiple times (eg deleting lots of rows) and if allLeafChildren is a large list
-
-        rowIdsRemoved[rowNode.id] = true; // _.removeFromArray(this.rootNode.allLeafChildren, rowNode);
-
-        delete _this3.allNodesMap[rowNode.id];
-        rowNodeTransaction.remove.push(rowNode);
-      });
-      this.rootNode.allLeafChildren = this.rootNode.allLeafChildren.filter(function (rowNode) {
-        return !rowIdsRemoved[rowNode.id];
-      });
-
-      if (this.rootNode.sibling) {
-        this.rootNode.sibling.allLeafChildren = this.rootNode.allLeafChildren;
-      }
-    }
-  }, {
-    key: "executeUpdate",
-    value: function executeUpdate(rowDataTran, rowNodeTransaction, nodesToUnselect) {
-      var _this4 = this;
-
-      var update = rowDataTran.update;
-
-      if (_.missingOrEmpty(update)) {
-        return;
-      }
-
-      update.forEach(function (item) {
-        var rowNode = _this4.lookupRowNode(item);
-
-        if (!rowNode) {
-          return;
-        }
-
-        rowNode.updateData(item);
-
-        if (!rowNode.selectable && rowNode.isSelected()) {
-          nodesToUnselect.push(rowNode);
-        }
-
-        _this4.setMasterForRow(rowNode, item, ClientSideNodeManager.TOP_LEVEL, false);
-
-        rowNodeTransaction.update.push(rowNode);
-      });
-    }
-  }, {
-    key: "lookupRowNode",
-    value: function lookupRowNode(data) {
-      var getRowIdFunc = this.gridOptionsWrapper.getRowIdFunc();
-      var rowNode;
-
-      if (getRowIdFunc) {
-        // find rowNode using id
-        var id = getRowIdFunc({
-          data: data,
-          level: 0
-        });
-        rowNode = this.allNodesMap[id];
-
-        if (!rowNode) {
-          console.error("AG Grid: could not find row id=".concat(id, ", data item was not found for this id"));
-          return null;
-        }
-      } else {
-        // find rowNode using object references
-        rowNode = this.rootNode.allLeafChildren.find(function (node) {
-          return node.data === data;
-        });
-
-        if (!rowNode) {
-          console.error("AG Grid: could not find data item as object was not found", data);
-          console.error("Consider using getRowId to help the Grid find matching row data");
-          return null;
-        }
-      }
-
-      return rowNode || null;
-    }
-  }, {
-    key: "createNode",
-    value: function createNode(dataItem, parent, level) {
-      var node = new RowNode(this.beans);
-      node.group = false;
-      this.setMasterForRow(node, dataItem, level, true);
-
-      if (parent && !this.suppressParentsInRowNodes) {
-        node.parent = parent;
-      }
-
-      node.level = level;
-      node.setDataAndId(dataItem, this.nextId.toString());
-
-      if (this.allNodesMap[node.id]) {
-        console.warn("AG Grid: duplicate node id '".concat(node.id, "' detected from getRowId callback, this could cause issues in your grid."));
-      }
-
-      this.allNodesMap[node.id] = node;
-      this.nextId++;
-      return node;
-    }
-  }, {
-    key: "setMasterForRow",
-    value: function setMasterForRow(rowNode, data, level, setExpanded) {
-      if (this.doingTreeData) {
-        rowNode.setMaster(false);
-
-        if (setExpanded) {
-          rowNode.expanded = false;
-        }
-      } else {
-        // this is the default, for when doing grid data
-        if (this.doingMasterDetail) {
-          // if we are doing master detail, then the
-          // default is that everything can be a Master Row.
-          if (this.isRowMasterFunc) {
-            rowNode.setMaster(this.isRowMasterFunc(data));
-          } else {
-            rowNode.setMaster(true);
-          }
-        } else {
-          rowNode.setMaster(false);
-        }
-
-        if (setExpanded) {
-          var rowGroupColumns = this.columnModel.getRowGroupColumns();
-          var numRowGroupColumns = rowGroupColumns ? rowGroupColumns.length : 0; // need to take row group into account when determining level
-
-          var masterRowLevel = level + numRowGroupColumns;
-          rowNode.expanded = rowNode.master ? this.isExpanded(masterRowLevel) : false;
-        }
-      }
-    }
-  }, {
-    key: "isExpanded",
-    value: function isExpanded(level) {
-      var expandByDefault = this.gridOptionsWrapper.getGroupDefaultExpanded();
-
-      if (expandByDefault === -1) {
-        return true;
-      }
-
-      return level < expandByDefault;
-    }
-  }]);
-
-  return ClientSideNodeManager;
-}();
-ClientSideNodeManager.TOP_LEVEL = 0;
-ClientSideNodeManager.ROOT_NODE_ID = 'ROOT_NODE_ID';

package/es/components/DataGrid/modules/client-side-row-model/clientSideRowModel/clientSideRowModel.d.ts

@@ -1,99 +0,0 @@
-import { BeanStub, ChangedPath, IClientSideRowModel, RefreshModelParams, RowBounds, RowDataTransaction, RowNode, RowHighlightPosition, RowNodeTransaction } from "@ag-grid-community/core";
-export interface BatchTransactionItem<TData = any> {
-    rowDataTransaction: RowDataTransaction<TData>;
-    callback: ((res: RowNodeTransaction<TData>) => void) | undefined;
-}
-export interface RowNodeMap {
-    [id: string]: RowNode;
-}
-export declare class ClientSideRowModel extends BeanStub implements IClientSideRowModel {
-    private columnModel;
-    private selectionService;
-    private filterManager;
-    private valueCache;
-    private beans;
-    private filterStage;
-    private sortStage;
-    private flattenStage;
-    private groupStage;
-    private aggregationStage;
-    private pivotStage;
-    private filterAggregatesStage;
-    private onRowHeightChanged_debounced;
-    private rootNode;
-    private rowsToDisplay;
-    private nodeManager;
-    private rowDataTransactionBatch;
-    private lastHighlightedRow;
-    private applyAsyncTransactionsTimeout;
-    init(): void;
-    start(): void;
-    ensureRowHeightsValid(startPixel: number, endPixel: number, startLimitIndex: number, endLimitIndex: number): boolean;
-    private setRowTopAndRowIndex;
-    private clearRowTopAndRowIndex;
-    ensureRowsAtPixel(rowNodes: RowNode[], pixel: number, increment?: number): boolean;
-    highlightRowAtPixel(rowNode: RowNode | null, pixel?: number): void;
-    getHighlightPosition(pixel: number, rowNode?: RowNode): RowHighlightPosition;
-    getLastHighlightedRowNode(): RowNode | null;
-    isLastRowIndexKnown(): boolean;
-    getRowCount(): number;
-    getTopLevelRowCount(): number;
-    getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
-    getRowBounds(index: number): RowBounds | null;
-    onRowGroupOpened(): void;
-    private onFilterChanged;
-    private onSortChanged;
-    getType(): string;
-    private onValueChanged;
-    private createChangePath;
-    private isSuppressModelUpdateAfterUpdateTransaction;
-    refreshModel(params: RefreshModelParams): void;
-    isEmpty(): boolean;
-    isRowsToRender(): boolean;
-    getNodesInRangeForSelection(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
-    setDatasource(datasource: any): void;
-    getTopLevelNodes(): RowNode[] | null;
-    getRootNode(): RowNode;
-    getRow(index: number): RowNode;
-    isRowPresent(rowNode: RowNode): boolean;
-    getRowIndexAtPixel(pixelToMatch: number): number;
-    private isRowInPixel;
-    forEachLeafNode(callback: (node: RowNode, index: number) => void): void;
-    forEachNode(callback: (node: RowNode, index: number) => void): void;
-    forEachNodeAfterFilter(callback: (node: RowNode, index: number) => void): void;
-    forEachNodeAfterFilterAndSort(callback: (node: RowNode, index: number) => void): void;
-    forEachPivotNode(callback: (node: RowNode, index: number) => void): void;
-    private recursivelyWalkNodesAndCallback;
-    doAggregate(changedPath?: ChangedPath): void;
-    private doFilterAggregates;
-    expandOrCollapseAll(expand: boolean): void;
-    private doSort;
-    private doRowGrouping;
-    private restoreGroupState;
-    private doFilter;
-    private doPivot;
-    private getGroupState;
-    getCopyOfNodesMap(): {
-        [id: string]: RowNode;
-    };
-    getRowNode(id: string): RowNode | undefined;
-    setRowData(rowData: any[]): void;
-    batchUpdateRowData(rowDataTransaction: RowDataTransaction, callback?: (res: RowNodeTransaction) => void): void;
-    flushAsyncTransactions(): void;
-    private executeBatchUpdateRowData;
-    updateRowData(rowDataTran: RowDataTransaction, rowNodeOrder?: {
-        [id: string]: number;
-    }): RowNodeTransaction | null;
-    private createRowNodeOrder;
-    private commonUpdateRowData;
-    private doRowsToDisplay;
-    onRowHeightChanged(): void;
-    /** This method is debounced. It is used for row auto-height. If we don't debounce,
-     * then the Row Models will end up recalculating each row position
-     * for each row height change and result in the Row Renderer laying out rows.
-     * This is particularly bad if using print layout, and showing eg 1,000 rows,
-     * each row will change it's height, causing Row Model to update 1,000 times.
-     */
-    onRowHeightChangedDebounced(): void;
-    resetRowHeights(): void;
-}