@deephaven/golden-layout 0.19.2-beta.0 → 0.19.2-beta.11

package/dist/items/RowOrColumn.js

@@ -1,39 +1,62 @@
+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; }
+
 import $ from 'jquery';
-import AbstractContentItem from './AbstractContentItem.js';
-import utils from '../utils/index.js';
-import controls from '../controls/index.js';
-
-var RowOrColumn = function RowOrColumn(isColumn, layoutManager, config, parent) {
-  AbstractContentItem.call(this, layoutManager, config, parent);
-  this.isRow = !isColumn;
-  this.isColumn = isColumn;
-  this.element = $('<div class="lm_item lm_' + (isColumn ? 'column' : 'row') + '"></div>');
-  this.childElementContainer = this.element;
-  this._splitterSize = layoutManager.config.dimensions.borderWidth;
-  this._splitterGrabSize = layoutManager.config.dimensions.borderGrabWidth;
-  this._isColumn = isColumn;
-  this._dimension = isColumn ? 'height' : 'width';
-  this._splitter = [];
-  this._splitterPosition = null;
-  this._splitterMinPosition = null;
-  this._splitterMaxPosition = null;
-};
-
-utils.extend(RowOrColumn, AbstractContentItem);
-utils.copy(RowOrColumn.prototype, {
+import AbstractContentItem from "./AbstractContentItem.js";
+import { animFrame } from "../utils/index.js";
+import { Splitter } from "../controls/index.js";
+export default class RowOrColumn extends AbstractContentItem {
+  constructor(isColumn, layoutManager, config, parent) {
+    super(layoutManager, config, parent, $('<div class="lm_item lm_' + (isColumn ? 'column' : 'row') + '"></div>'));
+
+    _defineProperty(this, "isRow", void 0);
+
+    _defineProperty(this, "isColumn", void 0);
+
+    _defineProperty(this, "childElementContainer", void 0);
+
+    _defineProperty(this, "parent", void 0);
+
+    _defineProperty(this, "_splitter", []);
+
+    _defineProperty(this, "_splitterSize", void 0);
+
+    _defineProperty(this, "_splitterGrabSize", void 0);
+
+    _defineProperty(this, "_isColumn", void 0);
+
+    _defineProperty(this, "_dimension", void 0);
+
+    _defineProperty(this, "_splitterPosition", null);
+
+    _defineProperty(this, "_splitterMinPosition", null);
+
+    _defineProperty(this, "_splitterMaxPosition", null);
+
+    this.parent = parent;
+    this.isRow = !isColumn;
+    this.isColumn = isColumn;
+    this.childElementContainer = this.element;
+    this._splitterSize = layoutManager.config.dimensions.borderWidth;
+    this._splitterGrabSize = layoutManager.config.dimensions.borderGrabWidth;
+    this._isColumn = isColumn;
+    this._dimension = isColumn ? 'height' : 'width';
+    this._splitterPosition = null;
+    this._splitterMinPosition = null;
+    this._splitterMaxPosition = null;
+  }
   /**
    * Add a new contentItem to the Row or Column
    *
-   * @param {lm.item.AbstractContentItem} contentItem
-   * @param {[int]} index The position of the new item within the Row or Column.
-   *                      If no index is provided the item will be added to the end
-   * @param {[bool]} _$suspendResize If true the items won't be resized. This will leave the item in
-   *                                 an inconsistent state and is only intended to be used if multiple
-   *                                 children need to be added in one go and resize is called afterwards
-   *
-   * @returns {void}
+   * @param contentItem
+   * @param index The position of the new item within the Row or Column.
+   *              If no index is provided the item will be added to the end
+   * @param _$suspendResize If true the items won't be resized. This will leave the item in
+   *                           an inconsistent state and is only intended to be used if multiple
+   *                           children need to be added in one go and resize is called afterwards
    */
-  addChild: function addChild(contentItem, index, _$suspendResize) {
+
+
+  addChild(contentItem, index, _$suspendResize) {
     var newItemSize, itemSize, i, splitterElement;
     contentItem = this.layoutManager._$normalizeContentItem(contentItem, this);
 
@@ -67,26 +90,29 @@ utils.copy(RowOrColumn.prototype, {
       if (this.contentItems[i] === contentItem) {
         contentItem.config[this._dimension] = newItemSize;
       } else {
-        itemSize = this.contentItems[i].config[this._dimension] *= (100 - newItemSize) / 100;
+        var _this$contentItems$i$;
+
+        itemSize = ((_this$contentItems$i$ = this.contentItems[i].config[this._dimension]) !== null && _this$contentItems$i$ !== void 0 ? _this$contentItems$i$ : 0) * (100 - newItemSize) / 100;
         this.contentItems[i].config[this._dimension] = itemSize;
       }
     }
 
     this.callDownwards('setSize');
     this.emitBubblingEvent('stateChanged');
-  },
-
+  }
   /**
    * Removes a child of this element
    *
-   * @param   {lm.items.AbstractContentItem} contentItem
-   * @param   {boolean} keepChild   If true the child will be removed, but not destroyed
-   *
-   * @returns {void}
+   * @param contentItem
+   * @param keepChild   If true the child will be removed, but not destroyed
    */
-  removeChild: function removeChild(contentItem, keepChild) {
-    var removedItemSize = contentItem.config[this._dimension],
-        index = utils.indexOf(contentItem, this.contentItems),
+
+
+  removeChild(contentItem, keepChild) {
+    var _contentItem$config$t;
+
+    var removedItemSize = (_contentItem$config$t = contentItem.config[this._dimension]) !== null && _contentItem$config$t !== void 0 ? _contentItem$config$t : 0,
+        index = this.contentItems.indexOf(contentItem),
         splitterIndex = Math.max(index - 1, 0),
         i,
         childItem;
@@ -112,7 +138,9 @@ utils.copy(RowOrColumn.prototype, {
 
     for (i = 0; i < this.contentItems.length; i++) {
       if (this.contentItems[i] !== contentItem) {
-        this.contentItems[i].config[this._dimension] += removedItemSize / (this.contentItems.length - 1);
+        var _this$contentItems$i$2;
+
+        this.contentItems[i].config[this._dimension] = ((_this$contentItems$i$2 = this.contentItems[i].config[this._dimension]) !== null && _this$contentItems$i$2 !== void 0 ? _this$contentItems$i$2 : 0) + removedItemSize / (this.contentItems.length - 1);
       }
     }
 
@@ -126,30 +154,28 @@ utils.copy(RowOrColumn.prototype, {
       this.callDownwards('setSize');
       this.emitBubblingEvent('stateChanged');
     }
-  },
-
+  }
   /**
    * Replaces a child of this Row or Column with another contentItem
    *
-   * @param   {lm.items.AbstractContentItem} oldChild
-   * @param   {lm.items.AbstractContentItem} newChild
-   *
-   * @returns {void}
+   * @param oldChild
+   * @param newChild
    */
-  replaceChild: function replaceChild(oldChild, newChild) {
+
+
+  replaceChild(oldChild, newChild) {
     var size = oldChild.config[this._dimension];
-    AbstractContentItem.prototype.replaceChild.call(this, oldChild, newChild);
+    super.replaceChild(oldChild, newChild);
     newChild.config[this._dimension] = size;
     this.callDownwards('setSize');
     this.emitBubblingEvent('stateChanged');
-  },
-
+  }
   /**
    * Called whenever the dimensions of this item or one of its parents change
-   *
-   * @returns {void}
    */
-  setSize: function setSize() {
+
+
+  setSize() {
     if (this.contentItems.length > 0) {
       this._calculateRelativeSizes();
 
@@ -158,18 +184,15 @@ utils.copy(RowOrColumn.prototype, {
 
     this.emitBubblingEvent('stateChanged');
     this.emit('resize');
-  },
-
+  }
   /**
    * Invoked recursively by the layout manager. AbstractContentItem.init appends
    * the contentItem's DOM elements to the container, RowOrColumn init adds splitters
    * in between them
-   *
-   * @package private
-   * @override AbstractContentItem._$init
-   * @returns {void}
    */
-  _$init: function _$init() {
+
+
+  _$init() {
     if (this.isInitialised === true) return;
     var i;
 
@@ -178,18 +201,16 @@ utils.copy(RowOrColumn.prototype, {
     for (i = 0; i < this.contentItems.length - 1; i++) {
       this.contentItems[i].element.after(this._createSplitter(i).element);
     }
-  },
-
+  }
   /**
    * Turns the relative sizes calculated by _calculateRelativeSizes into
    * absolute pixel values and applies them to the children's DOM elements
    *
    * Assigns additional pixels to counteract Math.floor
-   *
-   * @private
-   * @returns {void}
    */
-  _setAbsoluteSizes: function _setAbsoluteSizes() {
+
+
+  _setAbsoluteSizes() {
     var i,
         sizeData = this._calculateAbsoluteSizes();
 
@@ -206,21 +227,21 @@ utils.copy(RowOrColumn.prototype, {
         this.contentItems[i].element.height(sizeData.totalHeight);
       }
     }
-  },
-
+  }
   /**
    * Calculates the absolute sizes of all of the children of this Item.
    * @returns {object} - Set with absolute sizes and additional pixels.
    */
-  _calculateAbsoluteSizes: function _calculateAbsoluteSizes() {
-    var i,
-        totalSplitterSize = (this.contentItems.length - 1) * this._splitterSize,
-        totalWidth = this.element.width(),
-        totalHeight = this.element.height(),
-        totalAssigned = 0,
-        additionalPixel,
-        itemSize,
-        itemSizes = [];
+
+
+  _calculateAbsoluteSizes() {
+    var _this$element$width, _this$element$height;
+
+    var totalSplitterSize = (this.contentItems.length - 1) * this._splitterSize;
+    var totalWidth = (_this$element$width = this.element.width()) !== null && _this$element$width !== void 0 ? _this$element$width : 0;
+    var totalHeight = (_this$element$height = this.element.height()) !== null && _this$element$height !== void 0 ? _this$element$height : 0;
+    var totalAssigned = 0;
+    var itemSizes = [];
 
     if (this._isColumn) {
       totalHeight -= totalSplitterSize;
@@ -228,26 +249,22 @@ utils.copy(RowOrColumn.prototype, {
       totalWidth -= totalSplitterSize;
     }
 
-    for (i = 0; i < this.contentItems.length; i++) {
-      if (this._isColumn) {
-        itemSize = Math.floor(totalHeight * (this.contentItems[i].config.height / 100));
-      } else {
-        itemSize = Math.floor(totalWidth * (this.contentItems[i].config.width / 100));
-      }
+    for (var i = 0; i < this.contentItems.length; i++) {
+      var _this$contentItems$i$3, _this$contentItems$i$4;
 
+      var itemSize = this._isColumn ? Math.floor(totalHeight * (((_this$contentItems$i$3 = this.contentItems[i].config.height) !== null && _this$contentItems$i$3 !== void 0 ? _this$contentItems$i$3 : 0) / 100)) : Math.floor(totalWidth * (((_this$contentItems$i$4 = this.contentItems[i].config.width) !== null && _this$contentItems$i$4 !== void 0 ? _this$contentItems$i$4 : 0) / 100));
       totalAssigned += itemSize;
       itemSizes.push(itemSize);
     }
 
-    additionalPixel = Math.floor((this._isColumn ? totalHeight : totalWidth) - totalAssigned);
+    var additionalPixel = Math.floor((this._isColumn ? totalHeight : totalWidth) - totalAssigned);
     return {
-      itemSizes: itemSizes,
-      additionalPixel: additionalPixel,
-      totalWidth: totalWidth,
-      totalHeight: totalHeight
+      itemSizes,
+      additionalPixel,
+      totalWidth,
+      totalHeight
     };
-  },
-
+  }
   /**
    * Calculates the relative sizes of all children of this Item. The logic
    * is as follows:
@@ -265,19 +282,19 @@ utils.copy(RowOrColumn.prototype, {
    *        If there are items without set dimensions, distribute the remainder to 100 evenly between them
    *        If there are no items without set dimensions, increase all items sizes relative to
    *        their original size so that they add up to 100
-   *
-   * @private
-   * @returns {void}
    */
-  _calculateRelativeSizes: function _calculateRelativeSizes() {
-    var i,
-        total = 0,
-        itemsWithoutSetDimension = [],
-        dimension = this._isColumn ? 'height' : 'width';
 
-    for (i = 0; i < this.contentItems.length; i++) {
+
+  _calculateRelativeSizes() {
+    var total = 0;
+    var itemsWithoutSetDimension = [];
+    var dimension = this._isColumn ? 'height' : 'width';
+
+    for (var i = 0; i < this.contentItems.length; i++) {
       if (this.contentItems[i].config[dimension] !== undefined) {
-        total += this.contentItems[i].config[dimension];
+        var _this$contentItems$i$5;
+
+        total += (_this$contentItems$i$5 = this.contentItems[i].config[dimension]) !== null && _this$contentItems$i$5 !== void 0 ? _this$contentItems$i$5 : 0;
       } else {
         itemsWithoutSetDimension.push(this.contentItems[i]);
       }
@@ -298,8 +315,8 @@ utils.copy(RowOrColumn.prototype, {
 
 
     if (Math.round(total) < 100 && itemsWithoutSetDimension.length > 0) {
-      for (i = 0; i < itemsWithoutSetDimension.length; i++) {
-        itemsWithoutSetDimension[i].config[dimension] = (100 - total) / itemsWithoutSetDimension.length;
+      for (var _i = 0; _i < itemsWithoutSetDimension.length; _i++) {
+        itemsWithoutSetDimension[_i].config[dimension] = (100 - total) / itemsWithoutSetDimension.length;
       }
 
       this._respectMinItemWidth();
@@ -315,8 +332,8 @@ utils.copy(RowOrColumn.prototype, {
 
 
     if (Math.round(total) > 100) {
-      for (i = 0; i < itemsWithoutSetDimension.length; i++) {
-        itemsWithoutSetDimension[i].config[dimension] = 50;
+      for (var _i2 = 0; _i2 < itemsWithoutSetDimension.length; _i2++) {
+        itemsWithoutSetDimension[_i2].config[dimension] = 50;
         total += 50;
       }
     }
@@ -325,43 +342,43 @@ utils.copy(RowOrColumn.prototype, {
      */
 
 
-    for (i = 0; i < this.contentItems.length; i++) {
-      this.contentItems[i].config[dimension] = this.contentItems[i].config[dimension] / total * 100;
+    for (var _i3 = 0; _i3 < this.contentItems.length; _i3++) {
+      var _this$contentItems$_i;
+
+      this.contentItems[_i3].config[dimension] = ((_this$contentItems$_i = this.contentItems[_i3].config[dimension]) !== null && _this$contentItems$_i !== void 0 ? _this$contentItems$_i : 0) / total * 100;
     }
 
     this._respectMinItemWidth();
-  },
-
+  }
   /**
    * Adjusts the column widths to respect the dimensions minItemWidth if set.
-   * @returns {}
    */
-  _respectMinItemWidth: function _respectMinItemWidth() {
-    var minItemWidth = this.layoutManager.config.dimensions ? this.layoutManager.config.dimensions.minItemWidth || 0 : 0,
-        sizeData = null,
-        entriesOverMin = [],
-        totalOverMin = 0,
-        totalUnderMin = 0,
-        remainingWidth = 0,
-        itemSize = 0,
-        contentItem = null,
-        reducePercent,
-        reducedWidth,
-        allEntries = [],
-        entry;
+
+
+  _respectMinItemWidth() {
+    var _this$layoutManager$c;
+
+    var minItemWidth = this.layoutManager.config.dimensions ? (_this$layoutManager$c = this.layoutManager.config.dimensions.minItemWidth) !== null && _this$layoutManager$c !== void 0 ? _this$layoutManager$c : 0 : 0;
+    var entriesOverMin = [];
+    var totalOverMin = 0;
+    var totalUnderMin = 0;
+    var remainingWidth = 0;
+    var allEntries = [];
+    var entry;
 
     if (this._isColumn || !minItemWidth || this.contentItems.length <= 1) {
       return;
     }
 
-    sizeData = this._calculateAbsoluteSizes();
+    var sizeData = this._calculateAbsoluteSizes();
     /**
      * Figure out how much we are under the min item size total and how much room we have to use.
      */
 
+
     for (var i = 0; i < this.contentItems.length; i++) {
-      contentItem = this.contentItems[i];
-      itemSize = sizeData.itemSizes[i];
+      var contentItem = this.contentItems[i];
+      var itemSize = sizeData.itemSizes[i];
 
       if (itemSize < minItemWidth) {
         totalUnderMin += minItemWidth - itemSize;
@@ -391,12 +408,12 @@ utils.copy(RowOrColumn.prototype, {
      */
 
 
-    reducePercent = totalUnderMin / totalOverMin;
+    var reducePercent = totalUnderMin / totalOverMin;
     remainingWidth = totalUnderMin;
 
-    for (i = 0; i < entriesOverMin.length; i++) {
-      entry = entriesOverMin[i];
-      reducedWidth = Math.round((entry.width - minItemWidth) * reducePercent);
+    for (var _i4 = 0; _i4 < entriesOverMin.length; _i4++) {
+      entry = entriesOverMin[_i4];
+      var reducedWidth = Math.round((entry.width - minItemWidth) * reducePercent);
       remainingWidth -= reducedWidth;
       entry.width -= reducedWidth;
     }
@@ -413,138 +430,153 @@ utils.copy(RowOrColumn.prototype, {
      */
 
 
-    for (i = 0; i < this.contentItems.length; i++) {
-      this.contentItems[i].config.width = allEntries[i].width / sizeData.totalWidth * 100;
+    for (var _i5 = 0; _i5 < this.contentItems.length; _i5++) {
+      this.contentItems[_i5].config.width = allEntries[_i5].width / sizeData.totalWidth * 100;
     }
-  },
-
+  }
   /**
    * Instantiates a new lm.controls.Splitter, binds events to it and adds
    * it to the array of splitters at the position specified as the index argument
    *
    * What it doesn't do though is append the splitter to the DOM
    *
-   * @param   {Int} index The position of the splitter
-   *
-   * @returns {lm.controls.Splitter}
+   * @param index The position of the splitter
+   * @returns The created splitter
    */
-  _createSplitter: function _createSplitter(index) {
+
+
+  _createSplitter(index) {
     var splitter;
-    splitter = new controls.Splitter(this._isColumn, this._splitterSize, this._splitterGrabSize);
-    splitter.on('drag', utils.fnBind(this._onSplitterDrag, this, [splitter]), this);
-    splitter.on('dragStop', utils.fnBind(this._onSplitterDragStop, this, [splitter]), this);
-    splitter.on('dragStart', utils.fnBind(this._onSplitterDragStart, this, [splitter]), this);
+    splitter = new Splitter(this._isColumn, this._splitterSize, this._splitterGrabSize);
+    splitter.on('drag', this._onSplitterDrag.bind(this, splitter), this);
+    splitter.on('dragStop', this._onSplitterDragStop.bind(this, splitter), this);
+    splitter.on('dragStart', this._onSplitterDragStart.bind(this, splitter), this);
 
     this._splitter.splice(index, 0, splitter);
 
     return splitter;
-  },
-
+  }
   /**
    * Locates the instance of lm.controls.Splitter in the array of
    * registered splitters and returns a map containing the contentItem
    * before and after the splitters, both of which are affected if the
    * splitter is moved
    *
-   * @param   {lm.controls.Splitter} splitter
+   * @param splitter
    *
-   * @returns {Object} A map of contentItems that the splitter affects
+   * @returns A map of contentItems that the splitter affects
    */
-  _getItemsForSplitter: function _getItemsForSplitter(splitter) {
-    var index = utils.indexOf(splitter, this._splitter);
+
+
+  _getItemsForSplitter(splitter) {
+    var index = this._splitter.indexOf(splitter);
+
+    if (index < 0) {
+      throw new Error('Splitter not found in RowOrColumn');
+    }
+
     return {
       before: this.contentItems[index],
       after: this.contentItems[index + 1]
     };
-  },
-
+  }
   /**
    * Gets the minimum dimensions for the given item configuration array
    * @param item
    * @private
    */
-  _getMinimumDimensions: function _getMinimumDimensions(arr) {
+
+
+  _getMinimumDimensions(arr) {
     var minWidth = 0,
         minHeight = 0;
 
     for (var i = 0; i < arr.length; ++i) {
-      minWidth = Math.max(arr[i].minWidth || 0, minWidth);
-      minHeight = Math.max(arr[i].minHeight || 0, minHeight);
+      var _arr$i$minWidth, _arr$i$minHeight;
+
+      minWidth = Math.max((_arr$i$minWidth = arr[i].minWidth) !== null && _arr$i$minWidth !== void 0 ? _arr$i$minWidth : 0, minWidth);
+      minHeight = Math.max((_arr$i$minHeight = arr[i].minHeight) !== null && _arr$i$minHeight !== void 0 ? _arr$i$minHeight : 0, minHeight);
     }
 
     return {
       horizontal: minWidth,
       vertical: minHeight
     };
-  },
-
+  }
   /**
    * Invoked when a splitter's dragListener fires dragStart. Calculates the splitters
    * movement area once (so that it doesn't need calculating on every mousemove event)
    *
-   * @param   {lm.controls.Splitter} splitter
-   *
-   * @returns {void}
+   * @param splitter
    */
-  _onSplitterDragStart: function _onSplitterDragStart(splitter) {
-    var items = this._getItemsForSplitter(splitter),
-        minSize = this.layoutManager.config.dimensions[this._isColumn ? 'minItemHeight' : 'minItemWidth'];
 
-    var beforeMinDim = this._getMinimumDimensions(items.before.config.content);
+
+  _onSplitterDragStart(splitter) {
+    var _items$before$config$, _items$after$config$c, _items$before$element, _items$after$element$;
+
+    var items = this._getItemsForSplitter(splitter);
+
+    var minSize = this.layoutManager.config.dimensions[this._isColumn ? 'minItemHeight' : 'minItemWidth'];
+
+    var beforeMinDim = this._getMinimumDimensions((_items$before$config$ = items.before.config.content) !== null && _items$before$config$ !== void 0 ? _items$before$config$ : []);
 
     var beforeMinSize = this._isColumn ? beforeMinDim.vertical : beforeMinDim.horizontal;
 
-    var afterMinDim = this._getMinimumDimensions(items.after.config.content);
+    var afterMinDim = this._getMinimumDimensions((_items$after$config$c = items.after.config.content) !== null && _items$after$config$c !== void 0 ? _items$after$config$c : []);
 
     var afterMinSize = this._isColumn ? afterMinDim.vertical : afterMinDim.horizontal;
     this._splitterPosition = 0;
-    this._splitterMinPosition = -1 * (items.before.element[this._dimension]() - (beforeMinSize || minSize));
-    this._splitterMaxPosition = items.after.element[this._dimension]() - (afterMinSize || minSize);
-  },
-
+    this._splitterMinPosition = -1 * (((_items$before$element = items.before.element[this._dimension]()) !== null && _items$before$element !== void 0 ? _items$before$element : 0) - (beforeMinSize || minSize));
+    this._splitterMaxPosition = ((_items$after$element$ = items.after.element[this._dimension]()) !== null && _items$after$element$ !== void 0 ? _items$after$element$ : 0) - (afterMinSize || minSize);
+  }
   /**
    * Invoked when a splitter's DragListener fires drag. Updates the splitters DOM position,
    * but not the sizes of the elements the splitter controls in order to minimize resize events
    *
-   * @param   {lm.controls.Splitter} splitter
-   * @param   {Int} offsetX  Relative pixel values to the splitters original position. Can be negative
-   * @param   {Int} offsetY  Relative pixel values to the splitters original position. Can be negative
-   *
-   * @returns {void}
+   * @param splitter
+   * @param offsetX  Relative pixel values to the splitters original position. Can be negative
+   * @param offsetY  Relative pixel values to the splitters original position. Can be negative
    */
-  _onSplitterDrag: function _onSplitterDrag(splitter, offsetX, offsetY) {
+
+
+  _onSplitterDrag(splitter, offsetX, offsetY) {
     var offset = this._isColumn ? offsetY : offsetX;
 
+    if (this._splitterMaxPosition == null || this._splitterMinPosition == null) {
+      return;
+    }
+
     if (offset > this._splitterMinPosition && offset < this._splitterMaxPosition) {
       this._splitterPosition = offset;
       splitter.element.css(this._isColumn ? 'top' : 'left', offset);
     }
-  },
-
+  }
   /**
    * Invoked when a splitter's DragListener fires dragStop. Resets the splitters DOM position,
    * and applies the new sizes to the elements before and after the splitter and their children
    * on the next animation frame
    *
    * @param   {lm.controls.Splitter} splitter
-   *
-   * @returns {void}
    */
-  _onSplitterDragStop: function _onSplitterDragStop(splitter) {
-    var items = this._getItemsForSplitter(splitter),
-        sizeBefore = items.before.element[this._dimension](),
-        sizeAfter = items.after.element[this._dimension](),
-        splitterPositionInRange = (this._splitterPosition + sizeBefore) / (sizeBefore + sizeAfter),
-        totalRelativeSize = items.before.config[this._dimension] + items.after.config[this._dimension];
 
+
+  _onSplitterDragStop(splitter) {
+    var _items$before$element2, _items$after$element$2, _this$_splitterPositi, _items$before$config$2, _items$after$config$t;
+
+    var items = this._getItemsForSplitter(splitter);
+
+    var sizeBefore = (_items$before$element2 = items.before.element[this._dimension]()) !== null && _items$before$element2 !== void 0 ? _items$before$element2 : 0;
+    var sizeAfter = (_items$after$element$2 = items.after.element[this._dimension]()) !== null && _items$after$element$2 !== void 0 ? _items$after$element$2 : 0;
+    var splitterPositionInRange = (((_this$_splitterPositi = this._splitterPosition) !== null && _this$_splitterPositi !== void 0 ? _this$_splitterPositi : 0) + sizeBefore) / (sizeBefore + sizeAfter);
+    var totalRelativeSize = ((_items$before$config$2 = items.before.config[this._dimension]) !== null && _items$before$config$2 !== void 0 ? _items$before$config$2 : 0) + ((_items$after$config$t = items.after.config[this._dimension]) !== null && _items$after$config$t !== void 0 ? _items$after$config$t : 0);
     items.before.config[this._dimension] = splitterPositionInRange * totalRelativeSize;
     items.after.config[this._dimension] = (1 - splitterPositionInRange) * totalRelativeSize;
     splitter.element.css({
       top: 0,
       left: 0
     });
-    utils.animFrame(utils.fnBind(this.callDownwards, this, ['setSize']));
+    animFrame(this.callDownwards.bind(this, 'setSize', undefined, undefined, undefined));
   }
-});
-export default RowOrColumn;
+
+}
 //# sourceMappingURL=RowOrColumn.js.map