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

package/dist/items/AbstractContentItem.js

@@ -1,9 +1,18 @@
-import utils from '../utils/index.js';
-import errors from '../errors/index.js';
-import config from '../config/index.js';
-var {
-  itemDefaultConfig
-} = config;
+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 { animFrame, BubblingEvent, EventEmitter } from "../utils/index.js";
+import { ConfigurationError } from "../errors/index.js";
+import { itemDefaultConfig } from "../config/index.js";
+export function isStack(item) {
+  return item.isStack;
+}
+export function isComponent(item) {
+  return item.isComponent;
+}
+export function isRoot(item) {
+  return item.isRoot;
+}
+
 /**
  * This is the baseclass that all content items inherit from.
  * Most methods provide a subset of what the sub-classes do.
@@ -25,79 +34,109 @@ var {
  *
  * @constructor
  */
+export default class AbstractContentItem extends EventEmitter {
+  constructor(layoutManager, config, parent, element) {
+    super();
+
+    _defineProperty(this, "config", void 0);
+
+    _defineProperty(this, "type", void 0);
+
+    _defineProperty(this, "contentItems", void 0);
+
+    _defineProperty(this, "parent", void 0);
+
+    _defineProperty(this, "layoutManager", void 0);
+
+    _defineProperty(this, "element", void 0);
+
+    _defineProperty(this, "childElementContainer", void 0);
+
+    _defineProperty(this, "componentName", void 0);
+
+    _defineProperty(this, "isInitialised", false);
+
+    _defineProperty(this, "isMaximised", false);
+
+    _defineProperty(this, "isRoot", false);
+
+    _defineProperty(this, "isRow", false);
+
+    _defineProperty(this, "isColumn", false);
+
+    _defineProperty(this, "isStack", false);
+
+    _defineProperty(this, "isComponent", false);
+
+    _defineProperty(this, "tab", void 0);
+
+    _defineProperty(this, "_pendingEventPropagations", void 0);
+
+    _defineProperty(this, "_throttledEvents", void 0);
+
+    this.element = element; // Some GL things expect this config to not change
+
+    this.config = this._extendItemNode(config);
+    this.type = config.type;
+    this.contentItems = [];
+    this.parent = parent;
+    this.layoutManager = layoutManager;
+    this._pendingEventPropagations = {};
+    this._throttledEvents = ['stateChanged'];
+    this.on(EventEmitter.ALL_EVENT, this._propagateEvent, this);
 
-var AbstractContentItem = function AbstractContentItem(layoutManager, config, parent) {
-  utils.EventEmitter.call(this);
-  this.config = this._extendItemNode(config);
-  this.type = config.type;
-  this.contentItems = [];
-  this.parent = parent;
-  this.isInitialised = false;
-  this.isMaximised = false;
-  this.isRoot = false;
-  this.isRow = false;
-  this.isColumn = false;
-  this.isStack = false;
-  this.isComponent = false;
-  this.layoutManager = layoutManager;
-  this._pendingEventPropagations = {};
-  this._throttledEvents = ['stateChanged'];
-  this.on(utils.EventEmitter.ALL_EVENT, this._propagateEvent, this);
-
-  if (config.content) {
-    this._createContentItems(config);
-  }
-};
-
-utils.copy(AbstractContentItem.prototype, {
+    if (config.content) {
+      this._createContentItems(config);
+    }
+  }
   /**
    * Set the size of the component and its children, called recursively
    *
    * @abstract
-   * @returns void
    */
-  setSize: function setSize() {
-    throw new Error('Abstract Method');
-  },
+
 
   /**
    * Calls a method recursively downwards on the tree
    *
-   * @param   {String} functionName      the name of the function to be called
-   * @param   {[Array]}functionArguments optional arguments that are passed to every function
-   * @param   {[bool]} bottomUp          Call methods from bottom to top, defaults to false
-   * @param   {[bool]} skipSelf          Don't invoke the method on the class that calls it, defaults to false
-   *
-   * @returns {void}
+   * @param functionName the name of the function to be called
+   * @param functionArguments optional arguments that are passed to every function
+   * @param bottomUp Call methods from bottom to top, defaults to false
+   * @param skipSelf Don't invoke the method on the class that calls it, defaults to false
    */
-  callDownwards: function callDownwards(functionName, functionArguments, bottomUp, skipSelf) {
-    var i;
+  callDownwards(functionName) {
+    var functionArguments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var bottomUp = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var skipSelf = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
     if (bottomUp !== true && skipSelf !== true) {
-      this[functionName].apply(this, functionArguments || []);
+      this[functionName].apply(this, functionArguments);
     }
 
-    for (i = 0; i < this.contentItems.length; i++) {
+    for (var i = 0; i < this.contentItems.length; i++) {
       this.contentItems[i].callDownwards(functionName, functionArguments, bottomUp);
     }
 
     if (bottomUp === true && skipSelf !== true) {
-      this[functionName].apply(this, functionArguments || []);
+      this[functionName].apply(this, functionArguments);
     }
-  },
-
+  }
   /**
    * Removes a child node (and its children) from the tree
    *
-   * @param   {lm.items.ContentItem} contentItem
-   *
-   * @returns {void}
+   * @param contentItem
    */
-  removeChild: function removeChild(contentItem, keepChild) {
+
+
+  removeChild(contentItem) {
+    var _this$config$content;
+
+    var keepChild = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
     /*
      * Get the position of the item that's to be removed within all content items this node contains
      */
-    var index = utils.indexOf(contentItem, this.contentItems);
+    var index = this.contentItems.indexOf(contentItem);
     /*
      * Make sure the content item to be removed is actually a child of this item
      */
@@ -123,7 +162,7 @@ utils.copy(AbstractContentItem.prototype, {
      * Remove the item from the configuration
      */
 
-    this.config.content.splice(index, 1);
+    (_this$config$content = this.config.content) === null || _this$config$content === void 0 ? void 0 : _this$config$content.splice(index, 1);
     /**
      * If this node still contains other content items, adjust their size
      */
@@ -134,19 +173,24 @@ utils.copy(AbstractContentItem.prototype, {
        * If this was the last content item, remove this node as well
        */
     } else if (this.type !== 'root' && this.config.isClosable) {
-      this.parent.removeChild(this);
-    }
-  },
+      var _this$parent;
 
+      (_this$parent = this.parent) === null || _this$parent === void 0 ? void 0 : _this$parent.removeChild(this);
+    }
+  }
   /**
    * Sets up the tree structure for the newly added child
    * The responsibility for the actual DOM manipulations lies
    * with the concrete item
    *
-   * @param {lm.items.AbstractContentItem} contentItem
-   * @param {[Int]} index If omitted item will be appended
+   * @param contentItem
+   * @param index If omitted item will be appended
    */
-  addChild: function addChild(contentItem, index) {
+
+
+  addChild(contentItem, index) {
+    contentItem = this.layoutManager._$normalizeContentItem(contentItem, this);
+
     if (index === undefined) {
       index = this.contentItems.length;
     }
@@ -163,27 +207,28 @@ utils.copy(AbstractContentItem.prototype, {
     if (contentItem.parent.isInitialised === true && contentItem.isInitialised === false) {
       contentItem._$init();
     }
-  },
-
+  }
   /**
    * Replaces oldChild with newChild. This used to use jQuery.replaceWith... which for
    * some reason removes all event listeners, so isn't really an option.
    *
-   * @param   {lm.item.AbstractContentItem} oldChild
-   * @param   {lm.item.AbstractContentItem} newChild
-   *
-   * @returns {void}
+   * @param oldChild
+   * @param newChild
    */
-  replaceChild: function replaceChild(oldChild, newChild, _$destroyOldChild) {
+
+
+  replaceChild(oldChild, newChild) {
+    var _$destroyOldChild = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
     newChild = this.layoutManager._$normalizeContentItem(newChild);
-    var index = utils.indexOf(oldChild, this.contentItems),
-        parentNode = oldChild.element[0].parentNode;
+    var index = this.contentItems.indexOf(oldChild);
+    var parentNode = oldChild.element[0].parentNode;
 
     if (index === -1) {
       throw new Error("Can't replace child. oldChild is not child of this");
     }
 
-    parentNode.replaceChild(newChild.element[0], oldChild.element[0]);
+    parentNode === null || parentNode === void 0 ? void 0 : parentNode.replaceChild(newChild.element[0], oldChild.element[0]);
     /*
      * Optionally destroy the old content item
      */
@@ -204,7 +249,7 @@ utils.copy(AbstractContentItem.prototype, {
      * Update tab reference
      */
 
-    if (this.isStack) {
+    if (isStack(this)) {
       this.header.tabs[index].contentItem = newChild;
     } //TODO This doesn't update the config... refactor to leave item nodes untouched after creation
 
@@ -214,36 +259,35 @@ utils.copy(AbstractContentItem.prototype, {
     }
 
     this.callDownwards('setSize');
-  },
-
+  }
   /**
    * Convenience method.
    * Shorthand for this.parent.removeChild( this )
-   *
-   * @returns {void}
    */
-  remove: function remove() {
-    this.parent.removeChild(this);
-  },
 
+
+  remove() {
+    var _this$parent2;
+
+    (_this$parent2 = this.parent) === null || _this$parent2 === void 0 ? void 0 : _this$parent2.removeChild(this);
+  }
   /**
    * Removes the component from the layout and creates a new
    * browser window with the component and its children inside
-   *
-   * @returns {lm.controls.BrowserPopout}
    */
-  popout: function popout() {
+
+
+  popout() {
     var browserPopout = this.layoutManager.createPopout(this);
     this.emitBubblingEvent('stateChanged');
     return browserPopout;
-  },
-
+  }
   /**
    * Maximises the Item or minimises it if it is already maximised
-   *
-   * @returns {void}
    */
-  toggleMaximise: function toggleMaximise(e) {
+
+
+  toggleMaximise(e) {
     e && e.preventDefault();
 
     if (this.isMaximised === true) {
@@ -254,74 +298,64 @@ utils.copy(AbstractContentItem.prototype, {
 
     this.isMaximised = !this.isMaximised;
     this.emitBubblingEvent('stateChanged');
-  },
-
+  }
   /**
    * Selects the item if it is not already selected
-   *
-   * @returns {void}
    */
-  select: function select() {
+
+
+  select() {
     if (this.layoutManager.selectedItem !== this) {
       this.layoutManager.selectItem(this, true);
       this.element.addClass('lm_selected');
     }
-  },
-
+  }
   /**
    * De-selects the item if it is selected
-   *
-   * @returns {void}
    */
-  deselect: function deselect() {
+
+
+  deselect() {
     if (this.layoutManager.selectedItem === this) {
       this.layoutManager.selectedItem = null;
       this.element.removeClass('lm_selected');
     }
-  },
-
+  }
   /**
    * Set this component's title
-   *
-   * @public
-   * @param {String} title
-   *
-   * @returns {void}
+   * @param title
    */
-  setTitle: function setTitle(title) {
+
+
+  setTitle(title) {
     this.config.title = title;
     this.emit('titleChanged', title);
     this.emitBubblingEvent('stateChanged');
-  },
-
+  }
   /**
    * Checks whether a provided id is present
-   *
-   * @public
-   * @param   {String}  id
-   *
-   * @returns {Boolean} isPresent
+   * @param id
+   * @returns isPresent
    */
-  hasId: function hasId(id) {
+
+
+  hasId(id) {
     if (!this.config.id) {
       return false;
     } else if (typeof this.config.id === 'string') {
       return this.config.id === id;
     } else if (this.config.id instanceof Array) {
-      return utils.indexOf(id, this.config.id) !== -1;
+      return this.config.id.indexOf(id) !== -1;
     }
-  },
-
+  }
   /**
    * Adds an id. Adds it as a string if the component doesn't
    * have an id yet or creates/uses an array
-   *
-   * @public
-   * @param {String} id
-   *
-   * @returns {void}
+   * @param id
    */
-  addId: function addId(id) {
+
+
+  addId(id) {
     if (this.hasId(id)) {
       return;
     }
@@ -333,18 +367,15 @@ utils.copy(AbstractContentItem.prototype, {
     } else if (this.config.id instanceof Array) {
       this.config.id.push(id);
     }
-  },
-
+  }
   /**
    * Removes an existing id. Throws an error
    * if the id is not present
-   *
-   * @public
-   * @param   {String} id
-   *
-   * @returns {void}
+   * @param id
    */
-  removeId: function removeId(id) {
+
+
+  removeId(id) {
     if (!this.hasId(id)) {
       throw new Error('Id not found');
     }
@@ -352,17 +383,19 @@ utils.copy(AbstractContentItem.prototype, {
     if (typeof this.config.id === 'string') {
       delete this.config.id;
     } else if (this.config.id instanceof Array) {
-      var index = utils.indexOf(id, this.config.id);
+      var index = this.config.id.indexOf(id);
       this.config.id.splice(index, 1);
     }
-  },
-
+  }
   /****************************************
    * SELECTOR
    ****************************************/
-  getItemsByFilter: function getItemsByFilter(filter) {
-    var result = [],
-        next = function next(contentItem) {
+
+
+  getItemsByFilter(filter) {
+    var result = [];
+
+    var next = function next(contentItem) {
       for (var i = 0; i < contentItem.contentItems.length; i++) {
         if (filter(contentItem.contentItems[i]) === true) {
           result.push(contentItem.contentItems[i]);
@@ -374,197 +407,210 @@ utils.copy(AbstractContentItem.prototype, {
 
     next(this);
     return result;
-  },
-  getItemsById: function getItemsById(id) {
+  }
+
+  getItemsById(id) {
     return this.getItemsByFilter(function (item) {
       if (item.config.id instanceof Array) {
-        return utils.indexOf(id, item.config.id) !== -1;
+        return item.config.id.indexOf(id) !== -1;
       } else {
         return item.config.id === id;
       }
     });
-  },
-  getItemsByType: function getItemsByType(type) {
+  }
+
+  getItemsByType(type) {
     return this._$getItemsByProperty('type', type);
-  },
-  getComponentsByName: function getComponentsByName(componentName) {
-    var components = this._$getItemsByProperty('componentName', componentName),
-        instances = [],
-        i;
+  }
+
+  getComponentsByName(componentName) {
+    var components = this._$getItemsByProperty('componentName', componentName);
 
-    for (i = 0; i < components.length; i++) {
+    var instances = [];
+
+    for (var i = 0; i < components.length; i++) {
       instances.push(components[i].instance);
     }
 
     return instances;
-  },
-
+  }
   /****************************************
    * PACKAGE PRIVATE
    ****************************************/
-  _$getItemsByProperty: function _$getItemsByProperty(key, value) {
+
+
+  _$getItemsByProperty(key, value) {
     return this.getItemsByFilter(function (item) {
       return item[key] === value;
     });
-  },
-  _$setParent: function _$setParent(parent) {
+  }
+
+  _$setParent(parent) {
     this.parent = parent;
-  },
-  _$highlightDropZone: function _$highlightDropZone(x, y, area) {
-    this.layoutManager.dropTargetIndicator.highlightArea(area);
-  },
-  _$onDrop: function _$onDrop(contentItem) {
+  }
+
+  _$highlightDropZone(x, y, area) {
+    var _this$layoutManager$d;
+
+    (_this$layoutManager$d = this.layoutManager.dropTargetIndicator) === null || _this$layoutManager$d === void 0 ? void 0 : _this$layoutManager$d.highlightArea(area);
+  }
+
+  _$onDrop(contentItem, area) {
     this.addChild(contentItem);
-  },
-  _$hide: function _$hide() {
+  }
+
+  _$hide() {
     this._callOnActiveComponents('hide');
 
     this.element.hide();
     this.layoutManager.updateSize();
-  },
-  _$show: function _$show() {
+  }
+
+  _$show() {
     this._callOnActiveComponents('show');
 
     this.element.show();
     this.layoutManager.updateSize();
-  },
-  _callOnActiveComponents: function _callOnActiveComponents(methodName) {
-    var stacks = this.getItemsByType('stack'),
-        activeContentItem,
-        i;
+  }
+
+  _callOnActiveComponents(methodName) {
+    var stacks = this.getItemsByType('stack');
+    var activeContentItem = null;
 
-    for (i = 0; i < stacks.length; i++) {
+    for (var i = 0; i < stacks.length; i++) {
       activeContentItem = stacks[i].getActiveContentItem();
 
-      if (activeContentItem && activeContentItem.isComponent) {
+      if (activeContentItem && isComponent(activeContentItem)) {
         activeContentItem.container[methodName]();
       }
     }
-  },
-
+  }
   /**
    * Destroys this item ands its children
-   *
-   * @returns {void}
    */
-  _$destroy: function _$destroy() {
+
+
+  _$destroy() {
     this.emitBubblingEvent('beforeItemDestroyed');
     this.callDownwards('_$destroy', [], true, true);
     this.element.remove();
     this.emitBubblingEvent('itemDestroyed');
-  },
-
+  }
   /**
    * Returns the area the component currently occupies in the format
    *
    * {
    *		x1: int
-   *		xy: int
+   *		x2: int
    *		y1: int
    *		y2: int
    *		contentItem: contentItem
    * }
    */
-  _$getArea: function _$getArea(element) {
+
+
+  _$getArea(element) {
+    var _element$offset, _element$width, _element$height;
+
     element = element || this.element;
-    var offset = element.offset(),
-        width = element.width(),
-        height = element.height();
+    var offset = (_element$offset = element.offset()) !== null && _element$offset !== void 0 ? _element$offset : {
+      left: 0,
+      top: 0
+    };
+    var width = (_element$width = element.width()) !== null && _element$width !== void 0 ? _element$width : 0;
+    var height = (_element$height = element.height()) !== null && _element$height !== void 0 ? _element$height : 0;
     return {
       x1: offset.left,
       y1: offset.top,
       x2: offset.left + width,
       y2: offset.top + height,
       surface: width * height,
-      contentItem: this
+      contentItem: this,
+      side: ''
     };
-  },
-
+  }
   /**
    * The tree of content items is created in two steps: First all content items are instantiated,
    * then init is called recursively from top to bottem. This is the basic init function,
    * it can be used, extended or overwritten by the content items
    *
    * Its behaviour depends on the content item
-   *
-   * @package private
-   *
-   * @returns {void}
    */
-  _$init: function _$init() {
-    var i;
+
+
+  _$init() {
     this.setSize();
 
-    for (i = 0; i < this.contentItems.length; i++) {
-      this.childElementContainer.append(this.contentItems[i].element);
+    for (var i = 0; i < this.contentItems.length; i++) {
+      var _this$childElementCon;
+
+      (_this$childElementCon = this.childElementContainer) === null || _this$childElementCon === void 0 ? void 0 : _this$childElementCon.append(this.contentItems[i].element);
     }
 
     this.isInitialised = true;
     this.emitBubblingEvent('itemCreated');
     this.emitBubblingEvent(this.type + 'Created');
-  },
-
+  }
   /**
    * Emit an event that bubbles up the item tree.
    *
-   * @param   {String} name The name of the event
-   *
-   * @returns {void}
+   * @param name The name of the event
    */
-  emitBubblingEvent: function emitBubblingEvent(name) {
-    var event = new utils.BubblingEvent(name, this);
-    this.emit(name, event);
-  },
 
+
+  emitBubblingEvent(name) {
+    var event = new BubblingEvent(name, this);
+    this.emit(name, event);
+  }
   /**
    * Private method, creates all content items for this node at initialisation time
    * PLEASE NOTE, please see addChild for adding contentItems add runtime
-   * @private
    * @param   {configuration item node} config
-   *
-   * @returns {void}
    */
-  _createContentItems: function _createContentItems(config) {
-    var oContentItem, i;
+
+
+  _createContentItems(config) {
+    var oContentItem;
 
     if (!(config.content instanceof Array)) {
-      throw new errors.ConfigurationError('content must be an Array', config);
+      throw new ConfigurationError('content must be an Array', config);
     }
 
-    for (i = 0; i < config.content.length; i++) {
+    for (var i = 0; i < config.content.length; i++) {
       oContentItem = this.layoutManager.createContentItem(config.content[i], this);
       this.contentItems.push(oContentItem);
     }
-  },
-
+  }
   /**
    * Extends an item configuration node with default settings
-   * @private
-   * @param   {configuration item node} config
-   *
-   * @returns {configuration item node} extended config
+   * @param config
+   * @returns extended config
    */
-  _extendItemNode: function _extendItemNode(config) {
-    for (var key in itemDefaultConfig) {
-      if (config[key] === undefined) {
-        config[key] = itemDefaultConfig[key];
+
+
+  _extendItemNode(config) {
+    for (var [key, value] of Object.entries(itemDefaultConfig)) {
+      // This just appeases TS
+      var k = key;
+
+      if (config[k] === undefined) {
+        config[k] = value;
       }
     }
 
     return config;
-  },
-
+  }
   /**
    * Called for every event on the item tree. Decides whether the event is a bubbling
    * event and propagates it to its parent
    *
-   * @param    {String} name the name of the event
-   * @param   {lm.utils.BubblingEvent} event
-   *
-   * @returns {void}
+   * @param name the name of the event
+   * @param event
    */
-  _propagateEvent: function _propagateEvent(name, event) {
-    if (event instanceof utils.BubblingEvent && event.isPropagationStopped === false && this.isInitialised === true) {
+
+
+  _propagateEvent(name, event) {
+    if (event instanceof BubblingEvent && event.isPropagationStopped === false && this.isInitialised === true) {
       /**
        * In some cases (e.g. if an element is created from a DragSource) it
        * doesn't have a parent and is not below root. If that's the case
@@ -572,46 +618,42 @@ utils.copy(AbstractContentItem.prototype, {
        * to the layoutManager
        */
       if (this.isRoot === false && this.parent) {
-        this.parent.emit.apply(this.parent, Array.prototype.slice.call(arguments, 0));
+        this.parent.emit.apply(this.parent, [name, event]);
       } else {
         this._scheduleEventPropagationToLayoutManager(name, event);
       }
     }
-  },
-
+  }
   /**
    * All raw events bubble up to the root element. Some events that
    * are propagated to - and emitted by - the layoutManager however are
    * only string-based, batched and sanitized to make them more usable
    *
-   * @param {String} name the name of the event
-   *
-   * @private
-   * @returns {void}
+   * @param name the name of the event
    */
-  _scheduleEventPropagationToLayoutManager: function _scheduleEventPropagationToLayoutManager(name, event) {
-    if (utils.indexOf(name, this._throttledEvents) === -1) {
+
+
+  _scheduleEventPropagationToLayoutManager(name, event) {
+    if (this._throttledEvents.indexOf(name) === -1) {
       this.layoutManager.emit(name, event.origin);
     } else {
       if (this._pendingEventPropagations[name] !== true) {
         this._pendingEventPropagations[name] = true;
-        utils.animFrame(utils.fnBind(this._propagateEventToLayoutManager, this, [name, event]));
+        animFrame(this._propagateEventToLayoutManager.bind(this, name, event));
       }
     }
-  },
-
+  }
   /**
    * Callback for events scheduled by _scheduleEventPropagationToLayoutManager
    *
-   * @param {String} name the name of the event
-   *
-   * @private
-   * @returns {void}
+   * @param name the name of the event
    */
-  _propagateEventToLayoutManager: function _propagateEventToLayoutManager(name, event) {
+
+
+  _propagateEventToLayoutManager(name, event) {
     this._pendingEventPropagations[name] = false;
     this.layoutManager.emit(name, event);
   }
-});
-export default AbstractContentItem;
+
+}
 //# sourceMappingURL=AbstractContentItem.js.map