@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/clipboard/clipboard/clipboardService.js

@@ -0,0 +1,923 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+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; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === 'object' && typeof Reflect.decorate === 'function') r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
+    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+import { _, Autowired, Bean, BeanStub, ChangedPath, Constants, Events, PostConstruct, Optional } from '@ag-grid-community/core';
+
+var ClipboardService = /*#__PURE__*/function (_BeanStub) {
+  _inherits(ClipboardService, _BeanStub);
+
+  var _super = _createSuper(ClipboardService);
+
+  function ClipboardService() {
+    var _this;
+
+    _classCallCheck(this, ClipboardService);
+
+    _this = _super.apply(this, arguments);
+    _this.lastPasteOperationTime = 0;
+    _this.navigatorApiFailed = false;
+    return _this;
+  }
+
+  _createClass(ClipboardService, [{
+    key: "init",
+    value: function init() {
+      var _this2 = this;
+
+      this.logger = this.loggerFactory.create('ClipboardService');
+
+      if (this.rowModel.getType() === Constants.ROW_MODEL_TYPE_CLIENT_SIDE) {
+        this.clientSideRowModel = this.rowModel;
+      }
+
+      this.ctrlsService.whenReady(function (p) {
+        _this2.gridCtrl = p.gridCtrl;
+      });
+    }
+  }, {
+    key: "pasteFromClipboard",
+    value: function pasteFromClipboard() {
+      var _this3 = this;
+
+      this.logger.log('pasteFromClipboard'); // Method 1 - native clipboard API, available in modern chrome browsers
+
+      var allowNavigator = !this.gridOptionsWrapper.isSuppressClipboardApi(); // Some browsers (Firefox) do not allow Web Applications to read from
+      // the clipboard so verify if not only the ClipboardAPI is available,
+      // but also if the `readText` method is public.
+
+      if (allowNavigator && !this.navigatorApiFailed && navigator.clipboard && navigator.clipboard.readText) {
+        navigator.clipboard.readText().then(this.processClipboardData.bind(this)).catch(function (e) {
+          _.doOnce(function () {
+            console.warn(e);
+            console.warn('AG Grid: Unable to use the Clipboard API (navigator.clipboard.readText()). ' + 'The reason why it could not be used has been logged in the previous line. ' + "For this reason the grid has defaulted to using a workaround which doesn't perform as well. " + 'Either fix why Clipboard API is blocked, OR stop this message from appearing by setting grid ' + 'property suppressClipboardApi=true (which will default the grid to using the workaround rather than the API');
+          }, 'clipboardApiError');
+
+          _this3.navigatorApiFailed = true;
+
+          _this3.pasteFromClipboardLegacy();
+        });
+      } else {
+        this.pasteFromClipboardLegacy();
+      }
+    }
+  }, {
+    key: "pasteFromClipboardLegacy",
+    value: function pasteFromClipboardLegacy() {
+      var _this4 = this;
+
+      // Method 2 - if modern API fails, the old school hack
+      var defaultPrevented = false;
+
+      var handlePasteEvent = function handlePasteEvent(e) {
+        var currentPastOperationTime = new Date().getTime();
+
+        if (currentPastOperationTime - _this4.lastPasteOperationTime < 50) {
+          defaultPrevented = true;
+          e.preventDefault();
+        }
+
+        _this4.lastPasteOperationTime = currentPastOperationTime;
+      };
+
+      this.executeOnTempElement(function (textArea) {
+        textArea.addEventListener('paste', handlePasteEvent);
+        textArea.focus({
+          preventScroll: true
+        });
+      }, function (element) {
+        var data = element.value;
+
+        if (!defaultPrevented) {
+          _this4.processClipboardData(data);
+        } else {
+          _this4.refocusLastFocusedCell();
+        }
+
+        element.removeEventListener('paste', handlePasteEvent);
+      });
+    }
+  }, {
+    key: "refocusLastFocusedCell",
+    value: function refocusLastFocusedCell() {
+      var focusedCell = this.focusService.getFocusedCell();
+
+      if (focusedCell) {
+        this.focusService.setFocusedCell({
+          rowIndex: focusedCell.rowIndex,
+          column: focusedCell.column,
+          rowPinned: focusedCell.rowPinned,
+          forceBrowserFocus: true
+        });
+      }
+    }
+  }, {
+    key: "processClipboardData",
+    value: function processClipboardData(data) {
+      var _this5 = this;
+
+      if (data == null) {
+        return;
+      }
+
+      var parsedData = _.stringToArray(data, this.gridOptionsWrapper.getClipboardDelimiter());
+
+      var userFunc = this.gridOptionsWrapper.getProcessDataFromClipboardFunc();
+
+      if (userFunc) {
+        parsedData = userFunc({
+          data: parsedData
+        });
+      }
+
+      if (parsedData == null) {
+        return;
+      }
+
+      if (this.gridOptionsWrapper.isSuppressLastEmptyLineOnPaste()) {
+        this.removeLastLineIfBlank(parsedData);
+      }
+
+      var pasteOperation = function pasteOperation(cellsToFlash, updatedRowNodes, focusedCell, changedPath) {
+        var rangeActive = _this5.rangeService && _this5.rangeService.isMoreThanOneCell();
+
+        var pasteIntoRange = rangeActive && !_this5.hasOnlyOneValueToPaste(parsedData);
+
+        if (pasteIntoRange) {
+          _this5.pasteIntoActiveRange(parsedData, cellsToFlash, updatedRowNodes, changedPath);
+        } else {
+          _this5.pasteStartingFromFocusedCell(parsedData, cellsToFlash, updatedRowNodes, focusedCell, changedPath);
+        }
+      };
+
+      this.doPasteOperation(pasteOperation);
+    } // common code to paste operations, e.g. paste to cell, paste to range, and copy range down
+
+  }, {
+    key: "doPasteOperation",
+    value: function doPasteOperation(pasteOperationFunc) {
+      var api = this.gridOptionsWrapper.getApi();
+      var columnApi = this.gridOptionsWrapper.getColumnApi();
+      var source = 'clipboard';
+      this.eventService.dispatchEvent({
+        type: Events.EVENT_PASTE_START,
+        api: api,
+        columnApi: columnApi,
+        source: source
+      });
+      var changedPath;
+
+      if (this.clientSideRowModel) {
+        var onlyChangedColumns = this.gridOptionsWrapper.isAggregateOnlyChangedColumns();
+        changedPath = new ChangedPath(onlyChangedColumns, this.clientSideRowModel.getRootNode());
+      }
+
+      var cellsToFlash = {};
+      var updatedRowNodes = [];
+      var focusedCell = this.focusService.getFocusedCell();
+      pasteOperationFunc(cellsToFlash, updatedRowNodes, focusedCell, changedPath);
+
+      if (changedPath) {
+        this.clientSideRowModel.doAggregate(changedPath);
+      }
+
+      this.rowRenderer.refreshCells();
+      this.dispatchFlashCells(cellsToFlash);
+      this.fireRowChanged(updatedRowNodes); // if using the clipboard hack with a temp element, then the focus has been lost,
+      // so need to put it back. otherwise paste operation loosed focus on cell and keyboard
+      // navigation stops.
+
+      this.refocusLastFocusedCell();
+      var event = {
+        type: Events.EVENT_PASTE_END,
+        source: source
+      };
+      this.eventService.dispatchEvent(event);
+    }
+  }, {
+    key: "pasteIntoActiveRange",
+    value: function pasteIntoActiveRange(clipboardData, cellsToFlash, updatedRowNodes, changedPath) {
+      var _this6 = this;
+
+      // true if clipboard data can be evenly pasted into range, otherwise false
+      var abortRepeatingPasteIntoRows = this.getRangeSize() % clipboardData.length != 0;
+      var indexOffset = 0;
+      var dataRowIndex = 0;
+
+      var rowCallback = function rowCallback(currentRow, rowNode, columns, index) {
+        var atEndOfClipboardData = index - indexOffset >= clipboardData.length;
+
+        if (atEndOfClipboardData) {
+          if (abortRepeatingPasteIntoRows) {
+            return;
+          } // increment offset and reset data index to repeat paste of data
+
+
+          indexOffset += dataRowIndex;
+          dataRowIndex = 0;
+        }
+
+        var currentRowData = clipboardData[index - indexOffset]; // otherwise we are not the first row, so copy
+
+        updatedRowNodes.push(rowNode);
+
+        var processCellFromClipboardFunc = _this6.gridOptionsWrapper.getProcessCellFromClipboardFunc();
+
+        columns.forEach(function (column, idx) {
+          if (!column.isCellEditable(rowNode) || column.isSuppressPaste(rowNode)) {
+            return;
+          } // repeat data for columns we don't have data for - happens when to range is bigger than copied data range
+
+
+          if (idx >= currentRowData.length) {
+            idx = idx % currentRowData.length;
+          }
+
+          var newValue = _this6.processCell(rowNode, column, currentRowData[idx], Constants.EXPORT_TYPE_DRAG_COPY, processCellFromClipboardFunc);
+
+          rowNode.setDataValue(column, newValue, Constants.SOURCE_PASTE);
+
+          if (changedPath) {
+            changedPath.addParentNode(rowNode.parent, [column]);
+          }
+
+          var cellId = _this6.cellPositionUtils.createIdFromValues(currentRow.rowIndex, column, currentRow.rowPinned);
+
+          cellsToFlash[cellId] = true;
+        });
+        dataRowIndex++;
+      };
+
+      this.iterateActiveRanges(false, rowCallback);
+    }
+  }, {
+    key: "pasteStartingFromFocusedCell",
+    value: function pasteStartingFromFocusedCell(parsedData, cellsToFlash, updatedRowNodes, focusedCell, changedPath) {
+      if (!focusedCell) {
+        return;
+      }
+
+      var currentRow = {
+        rowIndex: focusedCell.rowIndex,
+        rowPinned: focusedCell.rowPinned
+      };
+      var columnsToPasteInto = this.columnModel.getDisplayedColumnsStartingAt(focusedCell.column);
+
+      if (this.isPasteSingleValueIntoRange(parsedData)) {
+        this.pasteSingleValueIntoRange(parsedData, updatedRowNodes, cellsToFlash, changedPath);
+      } else {
+        this.pasteMultipleValues(parsedData, currentRow, updatedRowNodes, columnsToPasteInto, cellsToFlash, Constants.EXPORT_TYPE_CLIPBOARD, changedPath);
+      }
+    } // if range is active, and only one cell, then we paste this cell into all cells in the active range.
+
+  }, {
+    key: "isPasteSingleValueIntoRange",
+    value: function isPasteSingleValueIntoRange(parsedData) {
+      return this.hasOnlyOneValueToPaste(parsedData) && this.rangeService != null && !this.rangeService.isEmpty();
+    }
+  }, {
+    key: "pasteSingleValueIntoRange",
+    value: function pasteSingleValueIntoRange(parsedData, updatedRowNodes, cellsToFlash, changedPath) {
+      var _this7 = this;
+
+      var value = parsedData[0][0];
+
+      var rowCallback = function rowCallback(currentRow, rowNode, columns) {
+        updatedRowNodes.push(rowNode);
+        columns.forEach(function (column) {
+          return _this7.updateCellValue(rowNode, column, value, cellsToFlash, Constants.EXPORT_TYPE_CLIPBOARD, changedPath);
+        });
+      };
+
+      this.iterateActiveRanges(false, rowCallback);
+    }
+  }, {
+    key: "hasOnlyOneValueToPaste",
+    value: function hasOnlyOneValueToPaste(parsedData) {
+      return parsedData.length === 1 && parsedData[0].length === 1;
+    }
+  }, {
+    key: "copyRangeDown",
+    value: function copyRangeDown() {
+      var _this8 = this;
+
+      if (!this.rangeService || this.rangeService.isEmpty()) {
+        return;
+      }
+
+      var firstRowValues = [];
+
+      var pasteOperation = function pasteOperation(cellsToFlash, updatedRowNodes, focusedCell, changedPath) {
+        var processCellForClipboardFunc = _this8.gridOptionsWrapper.getProcessCellForClipboardFunc();
+
+        var processCellFromClipboardFunc = _this8.gridOptionsWrapper.getProcessCellFromClipboardFunc();
+
+        var rowCallback = function rowCallback(currentRow, rowNode, columns) {
+          // take reference of first row, this is the one we will be using to copy from
+          if (!firstRowValues.length) {
+            // two reasons for looping through columns
+            columns.forEach(function (column) {
+              // get the initial values to copy down
+              var value = _this8.processCell(rowNode, column, _this8.valueService.getValue(column, rowNode), Constants.EXPORT_TYPE_DRAG_COPY, processCellForClipboardFunc);
+
+              firstRowValues.push(value);
+            });
+          } else {
+            // otherwise we are not the first row, so copy
+            updatedRowNodes.push(rowNode);
+            columns.forEach(function (column, index) {
+              if (!column.isCellEditable(rowNode) || column.isSuppressPaste(rowNode)) {
+                return;
+              }
+
+              var firstRowValue = _this8.processCell(rowNode, column, firstRowValues[index], Constants.EXPORT_TYPE_DRAG_COPY, processCellFromClipboardFunc);
+
+              rowNode.setDataValue(column, firstRowValue, Constants.SOURCE_PASTE);
+
+              if (changedPath) {
+                changedPath.addParentNode(rowNode.parent, [column]);
+              }
+
+              var cellId = _this8.cellPositionUtils.createIdFromValues(currentRow.rowIndex, column, currentRow.rowPinned);
+
+              cellsToFlash[cellId] = true;
+            });
+          }
+        };
+
+        _this8.iterateActiveRanges(true, rowCallback);
+      };
+
+      this.doPasteOperation(pasteOperation);
+    }
+  }, {
+    key: "removeLastLineIfBlank",
+    value: function removeLastLineIfBlank(parsedData) {
+      // remove last row if empty, excel puts empty last row in
+      var lastLine = _.last(parsedData);
+
+      var lastLineIsBlank = lastLine && lastLine.length === 1 && lastLine[0] === '';
+
+      if (lastLineIsBlank) {
+        // do not remove the last empty line when that is the only line pasted
+        if (parsedData.length === 1) {
+          return;
+        }
+
+        _.removeFromArray(parsedData, lastLine);
+      }
+    }
+  }, {
+    key: "fireRowChanged",
+    value: function fireRowChanged(rowNodes) {
+      var _this9 = this;
+
+      if (!this.gridOptionsWrapper.isFullRowEdit()) {
+        return;
+      }
+
+      rowNodes.forEach(function (rowNode) {
+        var event = {
+          type: Events.EVENT_ROW_VALUE_CHANGED,
+          node: rowNode,
+          data: rowNode.data,
+          rowIndex: rowNode.rowIndex,
+          rowPinned: rowNode.rowPinned
+        };
+
+        _this9.eventService.dispatchEvent(event);
+      });
+    }
+  }, {
+    key: "pasteMultipleValues",
+    value: function pasteMultipleValues(clipboardGridData, currentRow, updatedRowNodes, columnsToPasteInto, cellsToFlash, type, changedPath) {
+      var _this10 = this;
+
+      var rowPointer = currentRow; // if doing CSRM and NOT tree data, then it means groups are aggregates, which are read only,
+      // so we should skip them when doing paste operations.
+
+      var skipGroupRows = this.clientSideRowModel != null && !this.gridOptionsWrapper.isTreeData();
+
+      var getNextGoodRowNode = function getNextGoodRowNode() {
+        while (true) {
+          if (!rowPointer) {
+            return null;
+          }
+
+          var res = _this10.rowPositionUtils.getRowNode(rowPointer); // move to next row down for next set of values
+
+
+          rowPointer = _this10.cellNavigationService.getRowBelow({
+            rowPinned: rowPointer.rowPinned,
+            rowIndex: rowPointer.rowIndex
+          }); // if no more rows, return null
+
+          if (res == null) {
+            return null;
+          } // skip details rows and footer rows, never paste into them as they don't hold data
+
+
+          var skipRow = res.detail || res.footer || skipGroupRows && res.group; // skipping row means we go into the next iteration of the while loop
+
+          if (!skipRow) {
+            return res;
+          }
+        }
+      };
+
+      clipboardGridData.forEach(function (clipboardRowData) {
+        var rowNode = getNextGoodRowNode(); // if we have come to end of rows in grid, then skip
+
+        if (!rowNode) {
+          return;
+        }
+
+        clipboardRowData.forEach(function (value, index) {
+          return _this10.updateCellValue(rowNode, columnsToPasteInto[index], value, cellsToFlash, type, changedPath);
+        });
+        updatedRowNodes.push(rowNode);
+      });
+    }
+  }, {
+    key: "updateCellValue",
+    value: function updateCellValue(rowNode, column, value, cellsToFlash, type, changedPath) {
+      if (!rowNode || !column || !column.isCellEditable(rowNode) || column.isSuppressPaste(rowNode)) {
+        return;
+      }
+
+      var processedValue = this.processCell(rowNode, column, value, type, this.gridOptionsWrapper.getProcessCellFromClipboardFunc());
+      rowNode.setDataValue(column, processedValue, Constants.SOURCE_PASTE);
+      var cellId = this.cellPositionUtils.createIdFromValues(rowNode.rowIndex, column, rowNode.rowPinned);
+      cellsToFlash[cellId] = true;
+
+      if (changedPath) {
+        changedPath.addParentNode(rowNode.parent, [column]);
+      }
+    }
+  }, {
+    key: "copyToClipboard",
+    value: function copyToClipboard() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var includeHeaders = params.includeHeaders,
+          includeGroupHeaders = params.includeGroupHeaders;
+      this.logger.log("copyToClipboard: includeHeaders = ".concat(includeHeaders)); // don't override 'includeHeaders' if it has been explicitly set to 'false'
+
+      if (includeHeaders == null) {
+        includeHeaders = this.gridOptionsWrapper.isCopyHeadersToClipboard();
+      }
+
+      if (includeGroupHeaders == null) {
+        includeGroupHeaders = this.gridOptionsWrapper.isCopyGroupHeadersToClipboard();
+      }
+
+      var copyParams = {
+        includeHeaders: includeHeaders,
+        includeGroupHeaders: includeGroupHeaders
+      };
+      var shouldCopyRows = !this.gridOptionsWrapper.isSuppressCopyRowsToClipboard(); // Copy priority is Range > Row > Focus
+
+      if (this.rangeService && !this.rangeService.isEmpty() && !this.shouldSkipSingleCellRange()) {
+        this.copySelectedRangeToClipboard(copyParams);
+      } else if (shouldCopyRows && !this.selectionService.isEmpty()) {
+        this.copySelectedRowsToClipboard(copyParams);
+      } else if (this.focusService.isAnyCellFocused()) {
+        this.copyFocusedCellToClipboard(copyParams);
+      }
+    }
+  }, {
+    key: "shouldSkipSingleCellRange",
+    value: function shouldSkipSingleCellRange() {
+      return this.gridOptionsWrapper.isSuppressCopySingleCellRanges() && !this.rangeService.isMoreThanOneCell();
+    }
+  }, {
+    key: "iterateActiveRanges",
+    value: function iterateActiveRanges(onlyFirst, rowCallback, columnCallback) {
+      var _this11 = this;
+
+      if (!this.rangeService || this.rangeService.isEmpty()) {
+        return;
+      }
+
+      var cellRanges = this.rangeService.getCellRanges();
+
+      if (onlyFirst) {
+        this.iterateActiveRange(cellRanges[0], rowCallback, columnCallback, true);
+      } else {
+        cellRanges.forEach(function (range, idx) {
+          return _this11.iterateActiveRange(range, rowCallback, columnCallback, idx === cellRanges.length - 1);
+        });
+      }
+    }
+  }, {
+    key: "iterateActiveRange",
+    value: function iterateActiveRange(range, rowCallback, columnCallback, isLastRange) {
+      if (!this.rangeService) {
+        return;
+      }
+
+      var currentRow = this.rangeService.getRangeStartRow(range);
+      var lastRow = this.rangeService.getRangeEndRow(range);
+
+      if (columnCallback && range.columns) {
+        columnCallback(range.columns);
+      }
+
+      var rangeIndex = 0;
+      var isLastRow = false; // the currentRow could be missing if the user sets the active range manually, and sets a range
+      // that is outside of the grid (eg. sets range rows 0 to 100, but grid has only 20 rows).
+
+      while (!isLastRow && currentRow != null) {
+        var rowNode = this.rowPositionUtils.getRowNode(currentRow);
+        isLastRow = this.rowPositionUtils.sameRow(currentRow, lastRow);
+        rowCallback(currentRow, rowNode, range.columns, rangeIndex++, isLastRow && isLastRange);
+        currentRow = this.cellNavigationService.getRowBelow(currentRow);
+      }
+    }
+  }, {
+    key: "copySelectedRangeToClipboard",
+    value: function copySelectedRangeToClipboard() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (!this.rangeService || this.rangeService.isEmpty()) {
+        return;
+      }
+
+      var allRangesMerge = this.rangeService.areAllRangesAbleToMerge();
+
+      var _ref = allRangesMerge ? this.buildDataFromMergedRanges(params) : this.buildDataFromRanges(params),
+          data = _ref.data,
+          cellsToFlash = _ref.cellsToFlash;
+
+      this.copyDataToClipboard(data);
+      this.dispatchFlashCells(cellsToFlash);
+    }
+  }, {
+    key: "buildDataFromMergedRanges",
+    value: function buildDataFromMergedRanges(params) {
+      var _this12 = this;
+
+      var columnsSet = new Set();
+      var ranges = this.rangeService.getCellRanges();
+      var rowPositionsMap = new Map();
+      var allRowPositions = [];
+      var allCellsToFlash = {};
+      ranges.forEach(function (range) {
+        range.columns.forEach(function (col) {
+          return columnsSet.add(col);
+        });
+
+        var _this12$getRangeRowPo = _this12.getRangeRowPositionsAndCellsToFlash(range),
+            rowPositions = _this12$getRangeRowPo.rowPositions,
+            cellsToFlash = _this12$getRangeRowPo.cellsToFlash;
+
+        rowPositions.forEach(function (rowPosition) {
+          var rowPositionAsString = "".concat(rowPosition.rowIndex, "-").concat(rowPosition.rowPinned || 'null');
+
+          if (!rowPositionsMap.get(rowPositionAsString)) {
+            rowPositionsMap.set(rowPositionAsString, true);
+            allRowPositions.push(rowPosition);
+          }
+        });
+        Object.assign(allCellsToFlash, cellsToFlash);
+      });
+      var allColumns = this.columnModel.getAllDisplayedColumns();
+      var exportedColumns = Array.from(columnsSet);
+      exportedColumns.sort(function (a, b) {
+        var posA = allColumns.indexOf(a);
+        var posB = allColumns.indexOf(b);
+        return posA - posB;
+      });
+      var data = this.buildExportParams({
+        columns: exportedColumns,
+        rowPositions: allRowPositions,
+        includeHeaders: params.includeHeaders,
+        includeGroupHeaders: params.includeGroupHeaders
+      });
+      return {
+        data: data,
+        cellsToFlash: allCellsToFlash
+      };
+    }
+  }, {
+    key: "buildDataFromRanges",
+    value: function buildDataFromRanges(params) {
+      var _this13 = this;
+
+      var ranges = this.rangeService.getCellRanges();
+      var data = [];
+      var allCellsToFlash = {};
+      ranges.forEach(function (range) {
+        var _this13$getRangeRowPo = _this13.getRangeRowPositionsAndCellsToFlash(range),
+            rowPositions = _this13$getRangeRowPo.rowPositions,
+            cellsToFlash = _this13$getRangeRowPo.cellsToFlash;
+
+        Object.assign(allCellsToFlash, cellsToFlash);
+        data.push(_this13.buildExportParams({
+          columns: range.columns,
+          rowPositions: rowPositions,
+          includeHeaders: params.includeHeaders,
+          includeGroupHeaders: params.includeGroupHeaders
+        }));
+      });
+      return {
+        data: data.join('\n'),
+        cellsToFlash: allCellsToFlash
+      };
+    }
+  }, {
+    key: "getRangeRowPositionsAndCellsToFlash",
+    value: function getRangeRowPositionsAndCellsToFlash(range) {
+      var _this14 = this;
+
+      var rowPositions = [];
+      var cellsToFlash = {};
+      var startRow = this.rangeService.getRangeStartRow(range);
+      var lastRow = this.rangeService.getRangeEndRow(range);
+      var node = startRow;
+
+      while (node) {
+        rowPositions.push(node);
+        range.columns.forEach(function (column) {
+          var cellId = _this14.cellPositionUtils.createIdFromValues(node.rowIndex, column, node.rowPinned);
+
+          cellsToFlash[cellId] = true;
+        });
+
+        if (this.rowPositionUtils.sameRow(node, lastRow)) {
+          break;
+        }
+
+        node = this.cellNavigationService.getRowBelow(node);
+      }
+
+      return {
+        rowPositions: rowPositions,
+        cellsToFlash: cellsToFlash
+      };
+    }
+  }, {
+    key: "copyFocusedCellToClipboard",
+    value: function copyFocusedCellToClipboard() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var focusedCell = this.focusService.getFocusedCell();
+
+      if (focusedCell == null) {
+        return;
+      }
+
+      var cellId = this.cellPositionUtils.createId(focusedCell);
+      var currentRow = {
+        rowPinned: focusedCell.rowPinned,
+        rowIndex: focusedCell.rowIndex
+      };
+      var column = focusedCell.column;
+      var data = this.buildExportParams({
+        columns: [column],
+        rowPositions: [currentRow],
+        includeHeaders: params.includeHeaders,
+        includeGroupHeaders: params.includeGroupHeaders
+      });
+      this.copyDataToClipboard(data);
+      this.dispatchFlashCells(_defineProperty({}, cellId, true));
+    }
+  }, {
+    key: "copySelectedRowsToClipboard",
+    value: function copySelectedRowsToClipboard() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var columnKeys = params.columnKeys,
+          includeHeaders = params.includeHeaders,
+          includeGroupHeaders = params.includeGroupHeaders;
+      var data = this.buildExportParams({
+        columns: columnKeys,
+        includeHeaders: includeHeaders,
+        includeGroupHeaders: includeGroupHeaders
+      });
+      this.copyDataToClipboard(data);
+    }
+  }, {
+    key: "buildExportParams",
+    value: function buildExportParams(params) {
+      var columns = params.columns,
+          rowPositions = params.rowPositions,
+          _params$includeHeader = params.includeHeaders,
+          includeHeaders = _params$includeHeader === void 0 ? false : _params$includeHeader,
+          _params$includeGroupH = params.includeGroupHeaders,
+          includeGroupHeaders = _params$includeGroupH === void 0 ? false : _params$includeGroupH;
+      var exportParams = {
+        columnKeys: columns,
+        rowPositions: rowPositions,
+        skipColumnHeaders: !includeHeaders,
+        skipColumnGroupHeaders: !includeGroupHeaders,
+        suppressQuotes: true,
+        columnSeparator: this.gridOptionsWrapper.getClipboardDelimiter(),
+        onlySelected: !rowPositions,
+        processCellCallback: this.gridOptionsWrapper.getProcessCellForClipboardFunc(),
+        processRowGroupCallback: function processRowGroupCallback(params) {
+          return params.node.key;
+        },
+        processHeaderCallback: this.gridOptionsWrapper.getProcessHeaderForClipboardFunc(),
+        processGroupHeaderCallback: this.gridOptionsWrapper.getProcessGroupHeaderForClipboardFunc()
+      };
+      return this.csvCreator.getDataAsCsv(exportParams, true);
+    }
+  }, {
+    key: "dispatchFlashCells",
+    value: function dispatchFlashCells(cellsToFlash) {
+      var _this15 = this;
+
+      window.setTimeout(function () {
+        var event = {
+          type: Events.EVENT_FLASH_CELLS,
+          cells: cellsToFlash
+        };
+
+        _this15.eventService.dispatchEvent(event);
+      }, 0);
+    }
+  }, {
+    key: "processCell",
+    value: function processCell(rowNode, column, value, type, func) {
+      if (func) {
+        var params = {
+          column: column,
+          node: rowNode,
+          value: value,
+          type: type
+        };
+        return func(params);
+      }
+
+      return value;
+    }
+  }, {
+    key: "copyDataToClipboard",
+    value: function copyDataToClipboard(data) {
+      var _this16 = this;
+
+      var userProvidedFunc = this.gridOptionsWrapper.getSendToClipboardFunc(); // method 1 - user provided func
+
+      if (userProvidedFunc) {
+        userProvidedFunc({
+          data: data
+        });
+        return;
+      } // method 2 - native clipboard API, available in modern chrome browsers
+
+
+      var allowNavigator = !this.gridOptionsWrapper.isSuppressClipboardApi();
+
+      if (allowNavigator && navigator.clipboard) {
+        navigator.clipboard.writeText(data).catch(function (e) {
+          _.doOnce(function () {
+            console.warn(e);
+            console.warn('AG Grid: Unable to use the Clipboard API (navigator.clipboard.writeText()). ' + 'The reason why it could not be used has been logged in the previous line. ' + "For this reason the grid has defaulted to using a workaround which doesn't perform as well. " + 'Either fix why Clipboard API is blocked, OR stop this message from appearing by setting grid ' + 'property suppressClipboardApi=true (which will default the grid to using the workaround rather than the API.');
+          }, 'clipboardApiError');
+
+          _this16.copyDataToClipboardLegacy(data);
+        });
+        return;
+      }
+
+      this.copyDataToClipboardLegacy(data);
+    }
+  }, {
+    key: "copyDataToClipboardLegacy",
+    value: function copyDataToClipboardLegacy(data) {
+      var _this17 = this;
+
+      // method 3 - if all else fails, the old school hack
+      this.executeOnTempElement(function (element) {
+        var eDocument = _this17.gridOptionsWrapper.getDocument();
+
+        var focusedElementBefore = eDocument.activeElement;
+        element.value = data || ' '; // has to be non-empty value or execCommand will not do anything
+
+        element.select();
+        element.focus({
+          preventScroll: true
+        });
+        var result = eDocument.execCommand('copy');
+
+        if (!result) {
+          console.warn("AG Grid: Browser did not allow document.execCommand('copy'). Ensure " + 'api.copySelectedRowsToClipboard() is invoked via a user event, i.e. button click, otherwise ' + 'the browser will prevent it for security reasons.');
+        }
+
+        if (focusedElementBefore != null && focusedElementBefore.focus != null) {
+          focusedElementBefore.focus({
+            preventScroll: true
+          });
+        }
+      });
+    }
+  }, {
+    key: "executeOnTempElement",
+    value: function executeOnTempElement(callbackNow, callbackAfter) {
+      var eDoc = this.gridOptionsWrapper.getDocument();
+      var eTempInput = eDoc.createElement('textarea');
+      eTempInput.style.width = '1px';
+      eTempInput.style.height = '1px'; // removing items from the DOM causes the document element to scroll to the
+      // position where the element was positioned. Here we set scrollTop / scrollLeft
+      // to prevent the document element from scrolling when we remove it from the DOM.
+
+      eTempInput.style.top = eDoc.documentElement.scrollTop + 'px';
+      eTempInput.style.left = eDoc.documentElement.scrollLeft + 'px';
+      eTempInput.style.position = 'absolute';
+      eTempInput.style.opacity = '0';
+      var guiRoot = this.gridCtrl.getGui();
+      guiRoot.appendChild(eTempInput);
+
+      try {
+        callbackNow(eTempInput);
+      } catch (err) {
+        console.warn("AG Grid: Browser does not support document.execCommand('copy') for clipboard operations");
+      } //It needs 100 otherwise OS X seemed to not always be able to paste... Go figure...
+
+
+      if (callbackAfter) {
+        window.setTimeout(function () {
+          callbackAfter(eTempInput);
+          guiRoot.removeChild(eTempInput);
+        }, 100);
+      } else {
+        guiRoot.removeChild(eTempInput);
+      }
+    }
+  }, {
+    key: "getRangeSize",
+    value: function getRangeSize() {
+      var ranges = this.rangeService.getCellRanges();
+      var startRangeIndex = 0;
+      var endRangeIndex = 0;
+
+      if (ranges.length > 0) {
+        startRangeIndex = this.rangeService.getRangeStartRow(ranges[0]).rowIndex;
+        endRangeIndex = this.rangeService.getRangeEndRow(ranges[0]).rowIndex;
+      }
+
+      return startRangeIndex - endRangeIndex + 1;
+    }
+  }]);
+
+  return ClipboardService;
+}(BeanStub);
+
+__decorate([Autowired('csvCreator')], ClipboardService.prototype, 'csvCreator', void 0);
+
+__decorate([Autowired('loggerFactory')], ClipboardService.prototype, 'loggerFactory', void 0);
+
+__decorate([Autowired('selectionService')], ClipboardService.prototype, 'selectionService', void 0);
+
+__decorate([Optional('rangeService')], ClipboardService.prototype, 'rangeService', void 0);
+
+__decorate([Autowired('rowModel')], ClipboardService.prototype, 'rowModel', void 0);
+
+__decorate([Autowired('ctrlsService')], ClipboardService.prototype, 'ctrlsService', void 0);
+
+__decorate([Autowired('valueService')], ClipboardService.prototype, 'valueService', void 0);
+
+__decorate([Autowired('focusService')], ClipboardService.prototype, 'focusService', void 0);
+
+__decorate([Autowired('rowRenderer')], ClipboardService.prototype, 'rowRenderer', void 0);
+
+__decorate([Autowired('columnModel')], ClipboardService.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('cellNavigationService')], ClipboardService.prototype, 'cellNavigationService', void 0);
+
+__decorate([Autowired('cellPositionUtils')], ClipboardService.prototype, 'cellPositionUtils', void 0);
+
+__decorate([Autowired('rowPositionUtils')], ClipboardService.prototype, 'rowPositionUtils', void 0);
+
+__decorate([PostConstruct], ClipboardService.prototype, 'init', null);
+
+ClipboardService = __decorate([Bean('clipboardService')], ClipboardService);
+export { ClipboardService };