@jetbrains/ring-ui 5.0.155 → 5.0.157

package/dist/table-legacy-ng/table-legacy-ng__selection-navigate-actions.js

@@ -1,92 +1,115 @@
+import { _ as _createClass, b as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
+
 /**
  * Class with default hotkey actions (e.g. select, clear selection, move up/down)
  * @param {Selection?} tableSelection selection associated with rg-table
  * (if tableSelection is not defined, use method setSelection to configure instance)
  */
-class SelectionNavigateActions {
-  constructor(tableSelection) {
+var SelectionNavigateActions = /*#__PURE__*/function () {
+  function SelectionNavigateActions(tableSelection) {
+    _classCallCheck(this, SelectionNavigateActions);
     this._selection = tableSelection;
     this._addSelectionMode = null;
   }
-  setSelection(tableSelection) {
-    this._selection = tableSelection;
-  }
-  moveUp() {
-    if (!this._selection) {
-      return false;
-    }
-    const activeItem = this._selection.activatePreviousItem();
-    if (activeItem && activeItem.unselectable) {
-      return this.moveUp();
+  _createClass(SelectionNavigateActions, [{
+    key: "setSelection",
+    value: function setSelection(tableSelection) {
+      this._selection = tableSelection;
     }
-    return !activeItem;
-  }
-  moveDown() {
-    if (this._selection) {
-      const activeItem = this._selection.activateNextItem();
-      if (!activeItem) {
-        this._selection.setActiveItemIndex(0);
-      } else if (activeItem.unselectable) {
-        return this.moveDown();
+  }, {
+    key: "moveUp",
+    value: function moveUp() {
+      if (!this._selection) {
+        return false;
       }
+      var activeItem = this._selection.activatePreviousItem();
+      if (activeItem && activeItem.unselectable) {
+        return this.moveUp();
+      }
+      return !activeItem;
     }
-    return false;
-  }
-  reset() {
-    this._addSelectionMode = null;
-    return !!this._selection;
-  }
-  selectUp() {
-    if (!this._selection) {
-      return false;
-    }
-    this._changeCheckedItemsArray();
-    return this.moveUp();
-  }
-  selectDown() {
-    if (!this._selection) {
+  }, {
+    key: "moveDown",
+    value: function moveDown() {
+      if (this._selection) {
+        var activeItem = this._selection.activateNextItem();
+        if (!activeItem) {
+          this._selection.setActiveItemIndex(0);
+        } else if (activeItem.unselectable) {
+          return this.moveDown();
+        }
+      }
       return false;
     }
-    this._changeCheckedItemsArray();
-    return this.moveDown();
-  }
-  selectCurrent() {
-    if (!this._selection) {
-      return false;
+  }, {
+    key: "reset",
+    value: function reset() {
+      this._addSelectionMode = null;
+      return !!this._selection;
     }
-    const activeItem = this._selection.getActiveItem();
-    if (!activeItem) {
-      return true;
-    } else {
-      this._selection.toggleCheck(activeItem);
-      return false;
+  }, {
+    key: "selectUp",
+    value: function selectUp() {
+      if (!this._selection) {
+        return false;
+      }
+      this._changeCheckedItemsArray();
+      return this.moveUp();
     }
-  }
-  clearSelection() {
-    if (!this._selection) {
-      return false;
+  }, {
+    key: "selectDown",
+    value: function selectDown() {
+      if (!this._selection) {
+        return false;
+      }
+      this._changeCheckedItemsArray();
+      return this.moveDown();
     }
-    const activeItem = this._selection.getActiveItem();
-    if (activeItem) {
-      if (this._selection.getCheckedItems().length > 0) {
-        this._selection.clearSelection();
+  }, {
+    key: "selectCurrent",
+    value: function selectCurrent() {
+      if (!this._selection) {
+        return false;
+      }
+      var activeItem = this._selection.getActiveItem();
+      if (!activeItem) {
+        return true;
+      } else {
+        this._selection.toggleCheck(activeItem);
         return false;
       }
-      this._selection.clearActivity();
     }
-    return true;
-  }
-  _changeCheckedItemsArray() {
-    if (!this._selection) {
-      return false;
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      if (!this._selection) {
+        return false;
+      }
+      var activeItem = this._selection.getActiveItem();
+      if (activeItem) {
+        if (this._selection.getCheckedItems().length > 0) {
+          this._selection.clearSelection();
+          return false;
+        }
+        this._selection.clearActivity();
+      }
+      return true;
     }
-    const activeItem = this._selection.getActiveItem();
-    if (activeItem && !this._addSelectionMode) {
-      this._addSelectionMode = activeItem.checked ? 'uncheckItem' : 'checkItem';
+  }, {
+    key: "_changeCheckedItemsArray",
+    value: function _changeCheckedItemsArray() {
+      if (!this._selection) {
+        return false;
+      }
+      var activeItem = this._selection.getActiveItem();
+      if (activeItem && !this._addSelectionMode) {
+        this._addSelectionMode = activeItem.checked ? 'uncheckItem' : 'checkItem';
+      }
+      this._selection[this._addSelectionMode](activeItem);
+      return undefined;
     }
-    this._selection[this._addSelectionMode](activeItem);
-    return undefined;
-  }
-}
+  }]);
+  return SelectionNavigateActions;
+}();
 
 export { SelectionNavigateActions as default };

package/dist/table-legacy-ng/table-legacy-ng__selection.js

@@ -1,145 +1,195 @@
+import { _ as _createClass, b as _classCallCheck, c as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.array.find.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
+
 /**
  * Selection class, catches all selection and activation operations and triggers events
  */
-class Selection {
-  suggestedItem = null;
-  constructor(items, emitEvent) {
-    let singleActiveElementAsSelection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+var Selection = /*#__PURE__*/function () {
+  function Selection(items, emitEvent) {
+    var singleActiveElementAsSelection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    _classCallCheck(this, Selection);
+    _defineProperty(this, "suggestedItem", null);
     this.items = items;
     this.emitEvent = emitEvent;
     this.singleActiveElementAsSelection = singleActiveElementAsSelection;
   }
-  setItems(items) {
-    this.items = items;
-    this.suggestedItem = null;
-    this.emitEvent('rgLegacyTable:itemsChanged', items);
-  }
-  activateItem(item) {
-    if (item && !item.unselectable) {
-      this.clearActivity();
-      item.active = true;
-      this.emitEvent('rgLegacyTable:activateItem', item, this.items.indexOf(item));
+  _createClass(Selection, [{
+    key: "setItems",
+    value: function setItems(items) {
+      this.items = items;
+      this.suggestedItem = null;
+      this.emitEvent('rgLegacyTable:itemsChanged', items);
     }
-  }
-  getActiveItem() {
-    if (!this.items) {
-      return undefined;
+  }, {
+    key: "activateItem",
+    value: function activateItem(item) {
+      if (item && !item.unselectable) {
+        this.clearActivity();
+        item.active = true;
+        this.emitEvent('rgLegacyTable:activateItem', item, this.items.indexOf(item));
+      }
     }
-    return this.items.find(item => item.active);
-  }
-  getActiveItemIndex() {
-    return this.items.indexOf(this.getActiveItem());
-  }
-  setActiveItemIndex(index) {
-    const item = this.items[index];
-    this.activateItem(item);
-  }
-  findNextActiveItem(startIndex, direction) {
-    const maxIndex = this.items.length - 1;
-    if (direction) {
-      for (let i = startIndex + 1; i <= maxIndex; i++) {
-        if (!this.items[i].unselectable) {
-          return this.items[i];
-        }
+  }, {
+    key: "getActiveItem",
+    value: function getActiveItem() {
+      if (!this.items) {
+        return undefined;
       }
-    } else {
-      for (let i = startIndex - 1; i >= 0; i--) {
-        if (!this.items[i].unselectable) {
-          return this.items[i];
+      return this.items.find(function (item) {
+        return item.active;
+      });
+    }
+  }, {
+    key: "getActiveItemIndex",
+    value: function getActiveItemIndex() {
+      return this.items.indexOf(this.getActiveItem());
+    }
+  }, {
+    key: "setActiveItemIndex",
+    value: function setActiveItemIndex(index) {
+      var item = this.items[index];
+      this.activateItem(item);
+    }
+  }, {
+    key: "findNextActiveItem",
+    value: function findNextActiveItem(startIndex, direction) {
+      var maxIndex = this.items.length - 1;
+      if (direction) {
+        for (var i = startIndex + 1; i <= maxIndex; i++) {
+          if (!this.items[i].unselectable) {
+            return this.items[i];
+          }
+        }
+      } else {
+        for (var _i = startIndex - 1; _i >= 0; _i--) {
+          if (!this.items[_i].unselectable) {
+            return this.items[_i];
+          }
         }
       }
-    }
-    return undefined;
-  }
-  activateNextItem() {
-    const activeItemIndex = this.items.indexOf(this.getActiveItem());
-    if (activeItemIndex === -1 && this.suggestedItem) {
-      this.activateItem(this.suggestedItem);
-      return this.suggestedItem;
-    } else if (activeItemIndex >= 0 && activeItemIndex < this.items.length - 1) {
-      const newActiveItem = this.findNextActiveItem(activeItemIndex, 1);
-      this.activateItem(newActiveItem);
-      return newActiveItem;
-    } else {
-      this.clearActivity();
       return undefined;
     }
-  }
-  activatePreviousItem() {
-    const activeItemIndex = this.items.indexOf(this.getActiveItem());
-    if (activeItemIndex === -1 && this.suggestedItem) {
-      this.activateItem(this.suggestedItem);
-      return this.suggestedItem;
-    } else if (activeItemIndex > 0 && activeItemIndex <= this.items.length - 1) {
-      const newActiveItem = this.findNextActiveItem(activeItemIndex, 0);
-      this.activateItem(newActiveItem);
-      return newActiveItem;
-    } else {
-      this.clearActivity();
-      return undefined;
+  }, {
+    key: "activateNextItem",
+    value: function activateNextItem() {
+      var activeItemIndex = this.items.indexOf(this.getActiveItem());
+      if (activeItemIndex === -1 && this.suggestedItem) {
+        this.activateItem(this.suggestedItem);
+        return this.suggestedItem;
+      } else if (activeItemIndex >= 0 && activeItemIndex < this.items.length - 1) {
+        var newActiveItem = this.findNextActiveItem(activeItemIndex, 1);
+        this.activateItem(newActiveItem);
+        return newActiveItem;
+      } else {
+        this.clearActivity();
+        return undefined;
+      }
     }
-  }
-  clearSelection() {
-    this.clearCheckedItems();
-    if (this.singleActiveElementAsSelection) {
-      this.clearActivity();
+  }, {
+    key: "activatePreviousItem",
+    value: function activatePreviousItem() {
+      var activeItemIndex = this.items.indexOf(this.getActiveItem());
+      if (activeItemIndex === -1 && this.suggestedItem) {
+        this.activateItem(this.suggestedItem);
+        return this.suggestedItem;
+      } else if (activeItemIndex > 0 && activeItemIndex <= this.items.length - 1) {
+        var newActiveItem = this.findNextActiveItem(activeItemIndex, 0);
+        this.activateItem(newActiveItem);
+        return newActiveItem;
+      } else {
+        this.clearActivity();
+        return undefined;
+      }
     }
-  }
-  clearCheckedItems() {
-    this.items.forEach(item => {
-      item.checked = false;
-    });
-  }
-  clearActivity() {
-    const activeItem = this.getActiveItem();
-    if (activeItem) {
-      activeItem.active = false;
+  }, {
+    key: "clearSelection",
+    value: function clearSelection() {
+      this.clearCheckedItems();
+      if (this.singleActiveElementAsSelection) {
+        this.clearActivity();
+      }
     }
-    this.emitEvent('rgLegacyTable:activateItem', null);
-  }
-  checkItem(item) {
-    if (item && !item.uncheckable && !item.unselectable) {
-      item.checked = true;
-      this.triggerSelectionChanged(item);
+  }, {
+    key: "clearCheckedItems",
+    value: function clearCheckedItems() {
+      this.items.forEach(function (item) {
+        item.checked = false;
+      });
     }
-  }
-  uncheckItem(item) {
-    if (item) {
-      item.checked = false;
-      this.triggerSelectionChanged(item);
+  }, {
+    key: "clearActivity",
+    value: function clearActivity() {
+      var activeItem = this.getActiveItem();
+      if (activeItem) {
+        activeItem.active = false;
+      }
+      this.emitEvent('rgLegacyTable:activateItem', null);
     }
-  }
-  toggleCheck(item) {
-    if (item && !item.uncheckable && !item.unselectable) {
-      item.checked = !item.checked;
-      this.triggerSelectionChanged(item);
+  }, {
+    key: "checkItem",
+    value: function checkItem(item) {
+      if (item && !item.uncheckable && !item.unselectable) {
+        item.checked = true;
+        this.triggerSelectionChanged(item);
+      }
     }
-  }
-  triggerSelectionChanged(item) {
-    this.emitEvent('rgLegacyTable:selectionChanged', item);
-  }
-  getCheckedItems() {
-    if (!this.items) {
-      return [];
+  }, {
+    key: "uncheckItem",
+    value: function uncheckItem(item) {
+      if (item) {
+        item.checked = false;
+        this.triggerSelectionChanged(item);
+      }
     }
-    return this.items.filter(item => item.checked);
-  }
-  getSelectedItems() {
-    const checked = this.getCheckedItems();
-    if (!checked.length) {
-      const active = this.getActiveItem();
-      if (active && this.singleActiveElementAsSelection) {
-        return [active];
-      } else {
+  }, {
+    key: "toggleCheck",
+    value: function toggleCheck(item) {
+      if (item && !item.uncheckable && !item.unselectable) {
+        item.checked = !item.checked;
+        this.triggerSelectionChanged(item);
+      }
+    }
+  }, {
+    key: "triggerSelectionChanged",
+    value: function triggerSelectionChanged(item) {
+      this.emitEvent('rgLegacyTable:selectionChanged', item);
+    }
+  }, {
+    key: "getCheckedItems",
+    value: function getCheckedItems() {
+      if (!this.items) {
         return [];
       }
-    } else {
-      return checked;
+      return this.items.filter(function (item) {
+        return item.checked;
+      });
     }
-  }
-  setSuggestedItem(item) {
-    this.suggestedItem = item;
-  }
-}
+  }, {
+    key: "getSelectedItems",
+    value: function getSelectedItems() {
+      var checked = this.getCheckedItems();
+      if (!checked.length) {
+        var active = this.getActiveItem();
+        if (active && this.singleActiveElementAsSelection) {
+          return [active];
+        } else {
+          return [];
+        }
+      } else {
+        return checked;
+      }
+    }
+  }, {
+    key: "setSuggestedItem",
+    value: function setSuggestedItem(item) {
+      this.suggestedItem = item;
+    }
+  }]);
+  return Selection;
+}();
 
 export { Selection as default };

package/dist/table-legacy-ng/table-legacy-ng__toolbar.js

@@ -1,10 +1,23 @@
 import angular from 'angular';
 import { getDocumentScrollTop } from '../global/dom.js';
 import scheduleRAF from '../global/schedule-raf.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 
-const angularModule = angular.module('Ring.table-legacy.toolbar', []);
+var angularModule = angular.module('Ring.table-legacy.toolbar', []);
 angularModule.directive('rgLegacyTableToolbar', function rgLegacyTableToolbarDirective() {
-  const scheduleScrollListener = scheduleRAF();
+  var scheduleScrollListener = scheduleRAF();
   return {
     restrict: 'E',
     replace: true,
@@ -17,29 +30,31 @@ angularModule.directive('rgLegacyTableToolbar', function rgLegacyTableToolbarDir
       /**
        * Use plain DOM functions without any jquery. Should work with IE8+
        */
-      const element = iElement[0];
-      const controlsContainer = element.querySelector('.ring-table__toolbar-controls');
-      let savedToolbarTop;
-      const toolbarScrollListener = () => scheduleScrollListener(() => {
-        const scrolledTop = getDocumentScrollTop();
-        const elementTop = element.getBoundingClientRect().top + scrolledTop;
-        const toolbarTop = savedToolbarTop || elementTop;
-        if (scrolledTop > toolbarTop && !savedToolbarTop) {
-          //save height to style to prevent collapsing after fixing controls
-          element.style.height = `${element.offsetHeight}px`;
-          savedToolbarTop = toolbarTop;
-          controlsContainer.classList.add('ring-table__toolbar-controls_fixed');
-        } else if (scrolledTop <= toolbarTop && savedToolbarTop >= 0) {
-          savedToolbarTop = null;
-          element.style.height = null;
-          controlsContainer.classList.remove('ring-table__toolbar-controls_fixed');
-        }
-      });
+      var element = iElement[0];
+      var controlsContainer = element.querySelector('.ring-table__toolbar-controls');
+      var savedToolbarTop;
+      var toolbarScrollListener = function toolbarScrollListener() {
+        return scheduleScrollListener(function () {
+          var scrolledTop = getDocumentScrollTop();
+          var elementTop = element.getBoundingClientRect().top + scrolledTop;
+          var toolbarTop = savedToolbarTop || elementTop;
+          if (scrolledTop > toolbarTop && !savedToolbarTop) {
+            //save height to style to prevent collapsing after fixing controls
+            element.style.height = "".concat(element.offsetHeight, "px");
+            savedToolbarTop = toolbarTop;
+            controlsContainer.classList.add('ring-table__toolbar-controls_fixed');
+          } else if (scrolledTop <= toolbarTop && savedToolbarTop >= 0) {
+            savedToolbarTop = null;
+            element.style.height = null;
+            controlsContainer.classList.remove('ring-table__toolbar-controls_fixed');
+          }
+        });
+      };
 
       //Stick toolbar if sticking is enabled
       if (attrs.stick !== undefined) {
         window.addEventListener('scroll', toolbarScrollListener);
-        scope.$on('$destroy', () => {
+        scope.$on('$destroy', function () {
           window.removeEventListener('scroll', toolbarScrollListener);
         });
       }

package/dist/table-ng/smart-table-ng.js

@@ -1,30 +1,56 @@
 import angularComponentFactory from '../global/angular-component-factory.js';
 import SmartTable from '../table/smart-table.js';
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.keys.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.slice.js';
 import 'angular';
 import 'react';
 import '../global/react-render-adapter.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.string.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
 import 'react-dom';
 import '../global/ring-angular-component.js';
 import '../global/react-dom-renderer.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.from.js';
 import 'prop-types';
-import '../_helpers/_rollupPluginBabelHelpers.js';
 import '../table/table.js';
+import 'core-js/modules/es.array.map.js';
 import 'classnames';
 import 'react-movable';
 import '../global/focus-sensor-hoc.js';
 import '../global/prop-types.js';
 import '../global/composeRefs.js';
 import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
 import '../shortcuts/shortcuts.js';
 import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
 import 'combokeys';
 import '../global/sniffer.js';
 import 'sniffr';
 import '../loader/loader.js';
 import '../global/data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.entries.js';
 import '../loader/loader__core.js';
+import 'core-js/modules/es.array.fill.js';
+import 'core-js/modules/es.array.filter.js';
 import '../global/dom.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.set.js';
 import '../table/selection.js';
+import 'core-js/modules/es.array.index-of.js';
 import '../table/header.js';
 import '../checkbox/checkbox.js';
 import '@jetbrains/icons/checkmark-14px';
@@ -34,7 +60,10 @@ import 'util-deprecate';
 import '../icon/icon__constants.js';
 import '../_helpers/icon.js';
 import '../icon/icon__svg.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.string.starts-with.js';
 import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
 import '../_helpers/checkbox.js';
 import '../_helpers/table.js';
 import '../table/header-cell.js';
@@ -56,6 +85,7 @@ import '../popup/popup.js';
 import '../global/schedule-raf.js';
 import '../tab-trap/tab-trap.js';
 import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
 import '../popup/popup.consts.js';
 import '../popup/popup.target.js';
 import '../table/cell.js';