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

package/es/components/DataGrid/modules/master-detail/masterDetail/detailCellRendererCtrl.js

@@ -0,0 +1,245 @@
+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, BeanStub, RowNode, Events, _ } from "@ag-grid-community/core";
+export var DetailCellRendererCtrl = /*#__PURE__*/function (_BeanStub) {
+  _inherits(DetailCellRendererCtrl, _BeanStub);
+
+  var _super = _createSuper(DetailCellRendererCtrl);
+
+  function DetailCellRendererCtrl() {
+    var _this;
+
+    _classCallCheck(this, DetailCellRendererCtrl);
+
+    _this = _super.apply(this, arguments);
+    _this.loadRowDataVersion = 0;
+    _this.needRefresh = false;
+    return _this;
+  }
+
+  _createClass(DetailCellRendererCtrl, [{
+    key: "init",
+    value: function init(comp, params) {
+      var _this2 = this;
+
+      this.params = params;
+      this.comp = comp;
+      var doNothingBecauseInsidePinnedSection = params.pinned != null;
+
+      if (doNothingBecauseInsidePinnedSection) {
+        return;
+      }
+
+      this.setAutoHeightClasses();
+      this.setupRefreshStrategy();
+      this.addThemeToDetailGrid();
+      this.createDetailGrid();
+      this.loadRowData();
+      this.addManagedListener(params.node.parent, RowNode.EVENT_DATA_CHANGED, function () {
+        _this2.needRefresh = true;
+      });
+      this.addManagedListener(this.eventService, Events.EVENT_FULL_WIDTH_ROW_FOCUSED, this.onFullWidthRowFocused.bind(this));
+    }
+  }, {
+    key: "onFullWidthRowFocused",
+    value: function onFullWidthRowFocused(e) {
+      var params = this.params;
+      var row = {
+        rowIndex: params.node.rowIndex,
+        rowPinned: params.node.rowPinned
+      };
+      var eventRow = {
+        rowIndex: e.rowIndex,
+        rowPinned: e.rowPinned
+      };
+      var isSameRow = this.rowPositionUtils.sameRow(row, eventRow);
+
+      if (!isSameRow) {
+        return;
+      }
+
+      this.focusService.focusInto(this.comp.getGui(), e.fromBelow);
+    }
+  }, {
+    key: "setAutoHeightClasses",
+    value: function setAutoHeightClasses() {
+      var autoHeight = this.gridOptionsService.is('detailRowAutoHeight');
+      var parentClass = autoHeight ? 'ag-details-row-auto-height' : 'ag-details-row-fixed-height';
+      var detailClass = autoHeight ? 'ag-details-grid-auto-height' : 'ag-details-grid-fixed-height';
+      this.comp.addOrRemoveCssClass(parentClass, true);
+      this.comp.addOrRemoveDetailGridCssClass(detailClass, true);
+    }
+  }, {
+    key: "setupRefreshStrategy",
+    value: function setupRefreshStrategy() {
+      var providedStrategy = this.params.refreshStrategy;
+      var validSelection = providedStrategy == 'everything' || providedStrategy == 'nothing' || providedStrategy == 'rows';
+
+      if (validSelection) {
+        this.refreshStrategy = providedStrategy;
+        return;
+      }
+
+      if (providedStrategy != null) {
+        console.warn("AG Grid: invalid cellRendererParams.refreshStrategy = '" + providedStrategy + "' supplied, defaulting to refreshStrategy = 'rows'.");
+      }
+
+      this.refreshStrategy = 'rows';
+    }
+  }, {
+    key: "addThemeToDetailGrid",
+    value: function addThemeToDetailGrid() {
+      // this is needed by environment service of the child grid, the class needs to be on
+      // the grid div itself - the browser's CSS on the other hand just inherits from the parent grid theme.
+      var _this$environment$get = this.environment.getTheme(),
+          theme = _this$environment$get.theme;
+
+      if (theme) {
+        this.comp.addOrRemoveDetailGridCssClass(theme, true);
+      }
+    }
+  }, {
+    key: "createDetailGrid",
+    value: function createDetailGrid() {
+      if (_.missing(this.params.detailGridOptions)) {
+        console.warn('AG Grid: could not find detail grid options for master detail, ' + 'please set gridOptions.detailCellRendererParams.detailGridOptions');
+        return;
+      }
+
+      var autoHeight = this.gridOptionsService.is('detailRowAutoHeight'); // we clone the detail grid options, as otherwise it would be shared
+      // across many instances, and that would be a problem because we set
+      // api and columnApi into gridOptions
+
+      var gridOptions = Object.assign({}, this.params.detailGridOptions);
+
+      if (autoHeight) {
+        gridOptions.domLayout = 'autoHeight';
+      }
+
+      this.comp.setDetailGrid(gridOptions);
+    }
+  }, {
+    key: "registerDetailWithMaster",
+    value: function registerDetailWithMaster(api, columnApi) {
+      var rowId = this.params.node.id;
+      var masterGridApi = this.params.api;
+      var gridInfo = {
+        id: rowId,
+        api: api,
+        columnApi: columnApi
+      };
+      var rowNode = this.params.node; // register with api
+
+      masterGridApi.addDetailGridInfo(rowId, gridInfo); // register with node
+
+      rowNode.detailGridInfo = gridInfo;
+      this.addDestroyFunc(function () {
+        // the gridInfo can be stale if a refresh happens and
+        // a new row is created before the old one is destroyed.
+        if (rowNode.detailGridInfo !== gridInfo) {
+          return;
+        }
+
+        masterGridApi.removeDetailGridInfo(rowId); // unregister from api
+
+        rowNode.detailGridInfo = null; // unregister from node
+      });
+    }
+  }, {
+    key: "loadRowData",
+    value: function loadRowData() {
+      var _this3 = this;
+
+      // in case a refresh happens before the last refresh completes (as we depend on async
+      // application logic) we keep track on what the latest call was.
+      this.loadRowDataVersion++;
+      var versionThisCall = this.loadRowDataVersion;
+      var userFunc = this.params.getDetailRowData;
+
+      if (!userFunc) {
+        console.warn('AG Grid: could not find getDetailRowData for master / detail, ' + 'please set gridOptions.detailCellRendererParams.getDetailRowData');
+        return;
+      }
+
+      var successCallback = function successCallback(rowData) {
+        var mostRecentCall = _this3.loadRowDataVersion === versionThisCall;
+
+        if (mostRecentCall) {
+          _this3.comp.setRowData(rowData);
+        }
+      };
+
+      var funcParams = {
+        node: this.params.node,
+        // we take data from node, rather than params.data
+        // as the data could have been updated with new instance
+        data: this.params.node.data,
+        successCallback: successCallback,
+        context: this.gridOptionsService.context
+      };
+      userFunc(funcParams);
+    }
+  }, {
+    key: "refresh",
+    value: function refresh() {
+      var GET_GRID_TO_REFRESH = false;
+      var GET_GRID_TO_DO_NOTHING = true; // if we return true, it means we pretend to the grid
+      // that we have refreshed, so refresh will never happen.
+
+      var doNotRefresh = !this.needRefresh || this.refreshStrategy === 'nothing';
+
+      if (doNotRefresh) {
+        // we do nothing in this refresh method, and also tell the grid to do nothing
+        return GET_GRID_TO_DO_NOTHING;
+      } // reset flag, so don't refresh again until more data changes.
+
+
+      this.needRefresh = false;
+
+      if (this.refreshStrategy === 'everything') {
+        // we want full refresh, so tell the grid to destroy and recreate this cell
+        return GET_GRID_TO_REFRESH;
+      } else {
+        // do the refresh here, and tell the grid to do nothing
+        this.loadRowData();
+        return GET_GRID_TO_DO_NOTHING;
+      }
+    }
+  }]);
+
+  return DetailCellRendererCtrl;
+}(BeanStub);
+
+__decorate([Autowired('rowPositionUtils')], DetailCellRendererCtrl.prototype, "rowPositionUtils", void 0);
+
+__decorate([Autowired('focusService')], DetailCellRendererCtrl.prototype, "focusService", void 0);

package/es/components/DataGrid/modules/master-detail/masterDetailModule.d.ts

@@ -0,0 +1,2 @@
+import { Module } from "@ag-grid-community/core";
+export declare const MasterDetailModule: Module;

package/es/components/DataGrid/modules/master-detail/masterDetailModule.js

@@ -0,0 +1,18 @@
+import { ModuleNames } from "@ag-grid-community/core";
+import { DetailCellRenderer } from "./masterDetail/detailCellRenderer";
+import { DetailCellRendererCtrl } from "./masterDetail/detailCellRendererCtrl";
+import { VERSION } from "./version";
+export var MasterDetailModule = {
+  version: VERSION,
+  moduleName: ModuleNames.MasterDetailModule,
+  beans: [],
+  userComponents: [{
+    componentName: 'agDetailCellRenderer',
+    componentClass: DetailCellRenderer
+  }],
+  controllers: [{
+    controllerName: 'detailCellRenderer',
+    controllerClass: DetailCellRendererCtrl
+  }],
+  dependantModules: []
+};

package/es/components/DataGrid/modules/master-detail/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "29.2.0";

package/es/components/DataGrid/modules/master-detail/version.js

@@ -0,0 +1,2 @@
+// DO NOT UPDATE MANUALLY: Generated from script during build time
+export var VERSION = '29.2.0';

package/es/components/DataGrid/modules/menu/menu/chartMenuItemMapper.d.ts

@@ -0,0 +1,13 @@
+import { BeanStub, MenuItemDef } from '@ag-grid-community/core';
+export declare class ChartMenuItemMapper extends BeanStub {
+    private readonly chartService;
+    getChartItems(key: 'pivotChart' | 'chartRange'): MenuItemDef | undefined;
+    private cleanInternals;
+    private static buildLookup;
+    /**
+     * Make the MenuItem match the charts provided and their ordering on the ChartGroupsDef config object as provided by the user.
+     */
+    private static filterAndOrderChartMenu;
+}
+export declare type PivotMenuOptionName = 'pivotChart' | 'pivotColumnChart' | 'pivotGroupedColumn' | 'pivotStackedColumn' | 'pivotNormalizedColumn' | 'pivotBarChart' | 'pivotGroupedBar' | 'pivotStackedBar' | 'pivotNormalizedBar' | 'pivotPieChart' | 'pivotPie' | 'pivotDoughnut' | 'pivotLineChart' | 'pivotXYChart' | 'pivotScatter' | 'pivotBubble' | 'pivotAreaChart' | 'pivotArea' | 'pivotStackedArea' | 'pivotNormalizedArea' | 'pivotHistogramChart' | 'pivotCombinationChart' | 'pivotColumnLineCombo' | 'pivotAreaColumnCombo';
+export declare type RangeMenuOptionName = 'chartRange' | 'rangeColumnChart' | 'rangeGroupedColumn' | 'rangeStackedColumn' | 'rangeNormalizedColumn' | 'rangeBarChart' | 'rangeGroupedBar' | 'rangeStackedBar' | 'rangeNormalizedBar' | 'rangePieChart' | 'rangePie' | 'rangeDoughnut' | 'rangeLineChart' | 'rangeXYChart' | 'rangeScatter' | 'rangeBubble' | 'rangeAreaChart' | 'rangeArea' | 'rangeStackedArea' | 'rangeNormalizedArea' | 'rangeHistogramChart' | 'rangeCombinationChart' | 'rangeColumnLineCombo' | 'rangeAreaColumnCombo';