foundation-rails 6.3.1.0 → 6.4.1.0

data/vendor/assets/js/foundation.toggler.js.es6

@@ -1,6 +1,9 @@
 'use strict';
 
-!function($) {
+import $ from 'jquery';
+import { Motion } from './foundation.util.motion';
+import { Plugin } from './foundation.plugin';
+import { Triggers } from './foundation.util.triggers';
 
 /**
  * Toggler module.
@@ -9,23 +12,26 @@
  * @requires foundation.util.triggers
  */
 
-class Toggler {
+class Toggler extends Plugin {
   /**
    * Creates a new instance of Toggler.
    * @class
+   * @name Toggler
    * @fires Toggler#init
    * @param {Object} element - jQuery object to add the trigger to.
    * @param {Object} options - Overrides to the default plugin settings.
    */
-  constructor(element, options) {
+  _setup(element, options) {
     this.$element = element;
     this.options = $.extend({}, Toggler.defaults, element.data(), options);
     this.className = '';
+    this.className = 'Toggler'; // ie9 back compat
+
+    // Triggers init is idempotent, just need to make sure it is initialized
+    Triggers.init($);
 
     this._init();
     this._events();
-
-    Foundation.registerPlugin(this, 'Toggler');
   }
 
   /**
@@ -103,14 +109,14 @@ class Toggler {
     var _this = this;
 
     if (this.$element.is(':hidden')) {
-      Foundation.Motion.animateIn(this.$element, this.animationIn, function() {
+      Motion.animateIn(this.$element, this.animationIn, function() {
         _this._updateARIA(true);
         this.trigger('on.zf.toggler');
         this.find('[data-mutate]').trigger('mutateme.zf.trigger');
       });
     }
     else {
-      Foundation.Motion.animateOut(this.$element, this.animationOut, function() {
+      Motion.animateOut(this.$element, this.animationOut, function() {
         _this._updateARIA(false);
         this.trigger('off.zf.toggler');
         this.find('[data-mutate]').trigger('mutateme.zf.trigger');
@@ -126,9 +132,8 @@ class Toggler {
    * Destroys the instance of Toggler on the element.
    * @function
    */
-  destroy() {
+  _destroy() {
     this.$element.off('.zf.toggler');
-    Foundation.unregisterPlugin(this);
   }
 }
 
@@ -142,7 +147,4 @@ Toggler.defaults = {
   animate: false
 };
 
-// Window exports
-Foundation.plugin(Toggler, 'Toggler');
-
-}(jQuery);
+export {Toggler};

data/vendor/assets/js/foundation.tooltip.js.es6

@@ -1,6 +1,11 @@
 'use strict';
 
-!function($) {
+import $ from 'jquery';
+
+import { GetYoDigits } from './foundation.util.core';
+import { MediaQuery } from './foundation.util.mediaQuery';
+import { Triggers } from './foundation.util.triggers';
+import { Positionable } from './foundation.positionable';
 
 /**
  * Tooltip module.
@@ -10,23 +15,27 @@
  * @requires foundation.util.triggers
  */
 
-class Tooltip {
+class Tooltip extends Positionable {
   /**
    * Creates a new instance of a Tooltip.
    * @class
+   * @name Tooltip
    * @fires Tooltip#init
    * @param {jQuery} element - jQuery object to attach a tooltip to.
    * @param {Object} options - object to extend the default configuration.
    */
-  constructor(element, options) {
+  _setup(element, options) {
     this.$element = element;
     this.options = $.extend({}, Tooltip.defaults, this.$element.data(), options);
+    this.className = 'Tooltip'; // ie9 back compat
 
     this.isActive = false;
     this.isClick = false;
-    this._init();
 
-    Foundation.registerPlugin(this, 'Tooltip');
+    // Triggers init is idempotent, just need to make sure it is initialized
+    Triggers.init($);
+
+    this._init();
   }
 
   /**
@@ -34,9 +43,9 @@ class Tooltip {
    * @private
    */
   _init() {
-    var elemId = this.$element.attr('aria-describedby') || Foundation.GetYoDigits(6, 'tooltip');
+    MediaQuery._init();
+    var elemId = this.$element.attr('aria-describedby') || GetYoDigits(6, 'tooltip');
 
-    this.options.positionClass = this.options.positionClass || this._getPositionClass(this.$element);
     this.options.tipText = this.options.tipText || this.$element.attr('title');
     this.template = this.options.template ? $(this.options.template) : this._buildTemplate(elemId);
 
@@ -58,25 +67,36 @@ class Tooltip {
       'data-resize': elemId
     }).addClass(this.options.triggerClass);
 
-    //helper variables to track movement on collisions
-    this.usedPositions = [];
-    this.counter = 4;
-    this.classChanged = false;
-
+    super._init();
     this._events();
   }
 
-  /**
-   * Grabs the current positioning class, if present, and returns the value or an empty string.
-   * @private
-   */
-  _getPositionClass(element) {
-    if (!element) { return ''; }
-    // var position = element.attr('class').match(/top|left|right/g);
-    var position = element[0].className.match(/\b(top|left|right)\b/g);
-        position = position ? position[0] : '';
-    return position;
-  };
+  _getDefaultPosition() {
+    // handle legacy classnames
+    var position = this.$element[0].className.match(/\b(top|left|right|bottom)\b/g);
+    return position ? position[0] : 'top';
+  }
+
+  _getDefaultAlignment() {
+    return 'center';
+  }
+
+  _getHOffset() {
+    if(this.position === 'left' || this.position === 'right') {
+      return this.options.hOffset + this.options.tooltipWidth;
+    } else {
+      return this.options.hOffset
+    }
+  }
+
+  _getVOffset() {
+    if(this.position === 'top' || this.position === 'bottom') {
+      return this.options.vOffset + this.options.tooltipHeight;
+    } else {
+      return this.options.vOffset
+    }
+  }
+
   /**
    * builds the tooltip element, adds attributes, and returns the template.
    * @private
@@ -93,75 +113,13 @@ class Tooltip {
     return $template;
   }
 
-  /**
-   * Function that gets called if a collision event is detected.
-   * @param {String} position - positioning class to try
-   * @private
-   */
-  _reposition(position) {
-    this.usedPositions.push(position ? position : 'bottom');
-
-    //default, try switching to opposite side
-    if (!position && (this.usedPositions.indexOf('top') < 0)) {
-      this.template.addClass('top');
-    } else if (position === 'top' && (this.usedPositions.indexOf('bottom') < 0)) {
-      this.template.removeClass(position);
-    } else if (position === 'left' && (this.usedPositions.indexOf('right') < 0)) {
-      this.template.removeClass(position)
-          .addClass('right');
-    } else if (position === 'right' && (this.usedPositions.indexOf('left') < 0)) {
-      this.template.removeClass(position)
-          .addClass('left');
-    }
-
-    //if default change didn't work, try bottom or left first
-    else if (!position && (this.usedPositions.indexOf('top') > -1) && (this.usedPositions.indexOf('left') < 0)) {
-      this.template.addClass('left');
-    } else if (position === 'top' && (this.usedPositions.indexOf('bottom') > -1) && (this.usedPositions.indexOf('left') < 0)) {
-      this.template.removeClass(position)
-          .addClass('left');
-    } else if (position === 'left' && (this.usedPositions.indexOf('right') > -1) && (this.usedPositions.indexOf('bottom') < 0)) {
-      this.template.removeClass(position);
-    } else if (position === 'right' && (this.usedPositions.indexOf('left') > -1) && (this.usedPositions.indexOf('bottom') < 0)) {
-      this.template.removeClass(position);
-    }
-    //if nothing cleared, set to bottom
-    else {
-      this.template.removeClass(position);
-    }
-    this.classChanged = true;
-    this.counter--;
-  }
-
   /**
    * sets the position class of an element and recursively calls itself until there are no more possible positions to attempt, or the tooltip element is no longer colliding.
    * if the tooltip is larger than the screen width, default to full width - any user selected margin
    * @private
    */
   _setPosition() {
-    var position = this._getPositionClass(this.template),
-        $tipDims = Foundation.Box.GetDimensions(this.template),
-        $anchorDims = Foundation.Box.GetDimensions(this.$element),
-        direction = (position === 'left' ? 'left' : ((position === 'right') ? 'left' : 'top')),
-        param = (direction === 'top') ? 'height' : 'width',
-        offset = (param === 'height') ? this.options.vOffset : this.options.hOffset,
-        _this = this;
-
-    if (($tipDims.width >= $tipDims.windowDims.width) || (!this.counter && !Foundation.Box.ImNotTouchingYou(this.template))) {
-      this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({
-      // this.$element.offset(Foundation.GetOffsets(this.template, this.$element, 'center bottom', this.options.vOffset, this.options.hOffset, true)).css({
-        'width': $anchorDims.windowDims.width - (this.options.hOffset * 2),
-        'height': 'auto'
-      });
-      return false;
-    }
-
-    this.template.offset(Foundation.Box.GetOffsets(this.template, this.$element,'center ' + (position || 'bottom'), this.options.vOffset, this.options.hOffset));
-
-    while(!Foundation.Box.ImNotTouchingYou(this.template) && this.counter) {
-      this._reposition(position);
-      this._setPosition();
-    }
+    super._setPosition(this.$element, this.template);
   }
 
   /**
@@ -171,7 +129,7 @@ class Tooltip {
    * @function
    */
   show() {
-    if (this.options.showOn !== 'all' && !Foundation.MediaQuery.is(this.options.showOn)) {
+    if (this.options.showOn !== 'all' && !MediaQuery.is(this.options.showOn)) {
       // console.error('The screen is too small to display this tooltip');
       return false;
     }
@@ -179,6 +137,8 @@ class Tooltip {
     var _this = this;
     this.template.css('visibility', 'hidden').show();
     this._setPosition();
+    this.template.removeClass('top bottom left right').addClass(this.position)
+    this.template.removeClass('align-top align-bottom align-left align-right align-center').addClass('align-' + this.alignment);
 
     /**
      * Fires to close all other open tooltips on the page
@@ -217,15 +177,6 @@ class Tooltip {
     }).fadeOut(this.options.fadeOutDuration, function() {
       _this.isActive = false;
       _this.isClick = false;
-      if (_this.classChanged) {
-        _this.template
-             .removeClass(_this._getPositionClass(_this.template))
-             .addClass(_this.options.positionClass);
-
-       _this.usedPositions = [];
-       _this.counter = 4;
-       _this.classChanged = false;
-      }
     });
     /**
      * fires when the tooltip is hidden
@@ -337,15 +288,13 @@ class Tooltip {
    * Destroys an instance of tooltip, removes template element from the view.
    * @function
    */
-  destroy() {
+  _destroy() {
     this.$element.attr('title', this.template.text())
                  .off('.zf.trigger .zf.tooltip')
                  .removeClass('has-tip top right left')
                  .removeAttr('aria-describedby aria-haspopup data-disable-hover data-resize data-toggle data-tooltip data-yeti-box');
 
     this.template.remove();
-
-    Foundation.unregisterPlugin(this);
   }
 }
 
@@ -430,26 +379,72 @@ Tooltip.defaults = {
    */
   clickOpen: true,
   /**
-   * Additional positioning classes, set by the JS
+   * DEPRECATED Additional positioning classes, set by the JS
    * @option
    * @type {string}
    * @default ''
    */
   positionClass: '',
+  /**
+   * Position of tooltip. Can be left, right, bottom, top, or auto.
+   * @option
+   * @type {string}
+   * @default 'auto'
+   */
+  position: 'auto',
+  /**
+   * Alignment of tooltip relative to anchor. Can be left, right, bottom, top, center, or auto.
+   * @option
+   * @type {string}
+   * @default 'auto'
+   */
+  alignment: 'auto',
+  /**
+   * Allow overlap of container/window. If false, tooltip will first try to
+   * position as defined by data-position and data-alignment, but reposition if
+   * it would cause an overflow.  @option
+   * @type {boolean}
+   * @default false
+   */
+  allowOverlap: false,
+  /**
+   * Allow overlap of only the bottom of the container. This is the most common
+   * behavior for dropdowns, allowing the dropdown to extend the bottom of the
+   * screen but not otherwise influence or break out of the container.
+   * Less common for tooltips.
+   * @option
+   * @type {boolean}
+   * @default false
+   */
+  allowBottomOverlap: false,
   /**
    * Distance, in pixels, the template should push away from the anchor on the Y axis.
    * @option
    * @type {number}
-   * @default 10
+   * @default 0
    */
-  vOffset: 10,
+  vOffset: 0,
   /**
-   * Distance, in pixels, the template should push away from the anchor on the X axis, if aligned to a side.
+   * Distance, in pixels, the template should push away from the anchor on the X axis
+   * @option
+   * @type {number}
+   * @default 0
+   */
+  hOffset: 0,
+  /**
+   * Distance, in pixels, the template spacing auto-adjust for a vertical tooltip
+   * @option
+   * @type {number}
+   * @default 14
+   */
+  tooltipHeight: 14,
+  /**
+   * Distance, in pixels, the template spacing auto-adjust for a horizontal tooltip
    * @option
    * @type {number}
    * @default 12
    */
-  hOffset: 12,
+  tooltipWidth: 12,
     /**
    * Allow HTML in tooltip. Warning: If you are loading user-generated content into tooltips,
    * allowing HTML may open yourself up to XSS attacks.
@@ -464,7 +459,4 @@ Tooltip.defaults = {
  * TODO utilize resize event trigger
  */
 
-// Window exports
-Foundation.plugin(Tooltip, 'Tooltip');
-
-}(jQuery);
+export {Tooltip};

data/vendor/assets/js/foundation.util.box.js.es6

@@ -1,11 +1,14 @@
 'use strict';
 
-!function($) {
 
-Foundation.Box = {
+import { rtl as Rtl } from "./foundation.util.core";
+
+var Box = {
   ImNotTouchingYou: ImNotTouchingYou,
+  OverlapArea: OverlapArea,
   GetDimensions: GetDimensions,
-  GetOffsets: GetOffsets
+  GetOffsets: GetOffsets,
+  GetExplicitOffsets: GetExplicitOffsets
 }
 
 /**
@@ -18,37 +21,43 @@ Foundation.Box = {
  * @default if no parent object passed, detects collisions with `window`.
  * @returns {Boolean} - true if collision free, false if a collision in any direction.
  */
-function ImNotTouchingYou(element, parent, lrOnly, tbOnly) {
-  var eleDims = GetDimensions(element),
-      top, bottom, left, right;
+function ImNotTouchingYou(element, parent, lrOnly, tbOnly, ignoreBottom) {
+  return OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) === 0;
+};
 
+function OverlapArea(element, parent, lrOnly, tbOnly, ignoreBottom) {
+  var eleDims = GetDimensions(element),
+  topOver, bottomOver, leftOver, rightOver;
   if (parent) {
     var parDims = GetDimensions(parent);
 
-    bottom = (eleDims.offset.top + eleDims.height <= parDims.height + parDims.offset.top);
-    top    = (eleDims.offset.top >= parDims.offset.top);
-    left   = (eleDims.offset.left >= parDims.offset.left);
-    right  = (eleDims.offset.left + eleDims.width <= parDims.width + parDims.offset.left);
+    bottomOver = (parDims.height + parDims.offset.top) - (eleDims.offset.top + eleDims.height);
+    topOver    = eleDims.offset.top - parDims.offset.top;
+    leftOver   = eleDims.offset.left - parDims.offset.left;
+    rightOver  = (parDims.width + parDims.offset.left) - (eleDims.offset.left + eleDims.width);
   }
   else {
-    bottom = (eleDims.offset.top + eleDims.height <= eleDims.windowDims.height + eleDims.windowDims.offset.top);
-    top    = (eleDims.offset.top >= eleDims.windowDims.offset.top);
-    left   = (eleDims.offset.left >= eleDims.windowDims.offset.left);
-    right  = (eleDims.offset.left + eleDims.width <= eleDims.windowDims.width);
+    bottomOver = (eleDims.windowDims.height + eleDims.windowDims.offset.top) - (eleDims.offset.top + eleDims.height);
+    topOver    = eleDims.offset.top - eleDims.windowDims.offset.top;
+    leftOver   = eleDims.offset.left - eleDims.windowDims.offset.left;
+    rightOver  = eleDims.windowDims.width - (eleDims.offset.left + eleDims.width);
   }
 
-  var allDirs = [bottom, top, left, right];
+  bottomOver = ignoreBottom ? 0 : Math.min(bottomOver, 0);
+  topOver    = Math.min(topOver, 0);
+  leftOver   = Math.min(leftOver, 0);
+  rightOver  = Math.min(rightOver, 0);
 
   if (lrOnly) {
-    return left === right === true;
+    return leftOver + rightOver;
   }
-
   if (tbOnly) {
-    return top === bottom === true;
+    return topOver + bottomOver;
   }
 
-  return allDirs.indexOf(false) === -1;
-};
+  // use sum of squares b/c we care about overlap area.
+  return Math.sqrt((topOver * topOver) + (bottomOver * bottomOver) + (leftOver * leftOver) + (rightOver * rightOver));
+}
 
 /**
  * Uses native methods to return an object of dimension values.
@@ -98,7 +107,9 @@ function GetDimensions(elem, test){
 
 /**
  * Returns an object of top and left integer pixel values for dynamically rendered elements,
- * such as: Tooltip, Reveal, and Dropdown
+ * such as: Tooltip, Reveal, and Dropdown. Maintained for backwards compatibility, and where
+ * you don't know alignment, but generally from
+ * 6.4 forward you should use GetExplicitOffsets, as GetOffsets conflates position and alignment.
  * @function
  * @param {jQuery} element - jQuery object for the element being positioned.
  * @param {jQuery} anchor - jQuery object for the element's anchor point.
@@ -109,61 +120,38 @@ function GetDimensions(elem, test){
  * TODO alter/rewrite to work with `em` values as well/instead of pixels
  */
 function GetOffsets(element, anchor, position, vOffset, hOffset, isOverflow) {
-  var $eleDims = GetDimensions(element),
-      $anchorDims = anchor ? GetDimensions(anchor) : null;
-
+  console.log("NOTE: GetOffsets is deprecated in favor of GetExplicitOffsets and will be removed in 6.5");
   switch (position) {
     case 'top':
-      return {
-        left: (Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left),
-        top: $anchorDims.offset.top - ($eleDims.height + vOffset)
-      }
-      break;
-    case 'left':
-      return {
-        left: $anchorDims.offset.left - ($eleDims.width + hOffset),
-        top: $anchorDims.offset.top
-      }
-      break;
-    case 'right':
-      return {
-        left: $anchorDims.offset.left + $anchorDims.width + hOffset,
-        top: $anchorDims.offset.top
-      }
-      break;
+      return Rtl() ?
+        GetExplicitOffsets(element, anchor, 'top', 'left', vOffset, hOffset, isOverflow) :
+        GetExplicitOffsets(element, anchor, 'top', 'right', vOffset, hOffset, isOverflow);
+    case 'bottom':
+      return Rtl() ?
+        GetExplicitOffsets(element, anchor, 'bottom', 'left', vOffset, hOffset, isOverflow) :
+        GetExplicitOffsets(element, anchor, 'bottom', 'right', vOffset, hOffset, isOverflow);
     case 'center top':
-      return {
-        left: ($anchorDims.offset.left + ($anchorDims.width / 2)) - ($eleDims.width / 2),
-        top: $anchorDims.offset.top - ($eleDims.height + vOffset)
-      }
-      break;
+      return GetExplicitOffsets(element, anchor, 'top', 'center', vOffset, hOffset, isOverflow);
     case 'center bottom':
-      return {
-        left: isOverflow ? hOffset : (($anchorDims.offset.left + ($anchorDims.width / 2)) - ($eleDims.width / 2)),
-        top: $anchorDims.offset.top + $anchorDims.height + vOffset
-      }
-      break;
+      return GetExplicitOffsets(element, anchor, 'bottom', 'center', vOffset, hOffset, isOverflow);
     case 'center left':
-      return {
-        left: $anchorDims.offset.left - ($eleDims.width + hOffset),
-        top: ($anchorDims.offset.top + ($anchorDims.height / 2)) - ($eleDims.height / 2)
-      }
-      break;
+      return GetExplicitOffsets(element, anchor, 'left', 'center', vOffset, hOffset, isOverflow);
     case 'center right':
-      return {
-        left: $anchorDims.offset.left + $anchorDims.width + hOffset + 1,
-        top: ($anchorDims.offset.top + ($anchorDims.height / 2)) - ($eleDims.height / 2)
-      }
-      break;
+      return GetExplicitOffsets(element, anchor, 'right', 'center', vOffset, hOffset, isOverflow);
+    case 'left bottom':
+      return GetExplicitOffsets(element, anchor, 'bottom', 'left', vOffset, hOffset, isOverflow);
+    case 'right bottom':
+      return GetExplicitOffsets(element, anchor, 'bottom', 'right', vOffset, hOffset, isOverflow);
+    // Backwards compatibility... this along with the reveal and reveal full
+    // classes are the only ones that didn't reference anchor
     case 'center':
       return {
-        left: ($eleDims.windowDims.offset.left + ($eleDims.windowDims.width / 2)) - ($eleDims.width / 2),
-        top: ($eleDims.windowDims.offset.top + ($eleDims.windowDims.height / 2)) - ($eleDims.height / 2)
+        left: ($eleDims.windowDims.offset.left + ($eleDims.windowDims.width / 2)) - ($eleDims.width / 2) + hOffset,
+        top: ($eleDims.windowDims.offset.top + ($eleDims.windowDims.height / 2)) - ($eleDims.height / 2 + vOffset)
       }
-      break;
     case 'reveal':
       return {
-        left: ($eleDims.windowDims.width - $eleDims.width) / 2,
+        left: ($eleDims.windowDims.width - $eleDims.width) / 2 + hOffset,
         top: $eleDims.windowDims.offset.top + vOffset
       }
     case 'reveal full':
@@ -172,24 +160,72 @@ function GetOffsets(element, anchor, position, vOffset, hOffset, isOverflow) {
         top: $eleDims.windowDims.offset.top
       }
       break;
-    case 'left bottom':
+    default:
       return {
-        left: $anchorDims.offset.left,
+        left: (Rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width - hOffset: $anchorDims.offset.left + hOffset),
         top: $anchorDims.offset.top + $anchorDims.height + vOffset
-      };
+      }
+
+  }
+
+}
+
+function GetExplicitOffsets(element, anchor, position, alignment, vOffset, hOffset, isOverflow) {
+  var $eleDims = GetDimensions(element),
+      $anchorDims = anchor ? GetDimensions(anchor) : null;
+
+      var topVal, leftVal;
+
+  // set position related attribute
+
+  switch (position) {
+    case 'top':
+      topVal = $anchorDims.offset.top - ($eleDims.height + vOffset);
       break;
-    case 'right bottom':
-      return {
-        left: $anchorDims.offset.left + $anchorDims.width + hOffset - $eleDims.width,
-        top: $anchorDims.offset.top + $anchorDims.height + vOffset
-      };
+    case 'bottom':
+      topVal = $anchorDims.offset.top + $anchorDims.height + vOffset;
       break;
-    default:
-      return {
-        left: (Foundation.rtl() ? $anchorDims.offset.left - $eleDims.width + $anchorDims.width : $anchorDims.offset.left + hOffset),
-        top: $anchorDims.offset.top + $anchorDims.height + vOffset
+    case 'left':
+      leftVal = $anchorDims.offset.left - ($eleDims.width + hOffset);
+      break;
+    case 'right':
+      leftVal = $anchorDims.offset.left + $anchorDims.width + hOffset;
+      break;
+  }
+
+
+  // set alignment related attribute
+  switch (position) {
+    case 'top':
+    case 'bottom':
+      switch (alignment) {
+        case 'left':
+          leftVal = $anchorDims.offset.left + hOffset;
+          break;
+        case 'right':
+          leftVal = $anchorDims.offset.left - $eleDims.width + $anchorDims.width - hOffset;
+          break;
+        case 'center':
+          leftVal = isOverflow ? hOffset : (($anchorDims.offset.left + ($anchorDims.width / 2)) - ($eleDims.width / 2)) + hOffset;
+          break;
       }
+      break;
+    case 'right':
+    case 'left':
+      switch (alignment) {
+        case 'bottom':
+          topVal = $anchorDims.offset.top - vOffset + $anchorDims.height - $eleDims.height;
+          break;
+        case 'top':
+          topVal = $anchorDims.offset.top + vOffset
+          break;
+        case 'center':
+          topVal = ($anchorDims.offset.top + vOffset + ($anchorDims.height / 2)) - ($eleDims.height / 2)
+          break;
+      }
+      break;
   }
+  return {top: topVal, left: leftVal};
 }
 
-}(jQuery);
+export {Box};