foundation6-jekyll-base 0.0.1

data/assets/js/vendor/foundation/plugins/foundation.tabs.min.js

@@ -0,0 +1 @@
+"use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function t(t,e){for(var i=0;i<e.length;i++){var n=e[i];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}return function(e,i,n){return i&&t(e.prototype,i),n&&t(e,n),e}}();!function(t){var e=function(){function e(i,n){_classCallCheck(this,e),this.$element=i,this.options=t.extend({},e.defaults,this.$element.data(),n),this._init(),Foundation.registerPlugin(this,"Tabs"),Foundation.Keyboard.register("Tabs",{ENTER:"open",SPACE:"open",ARROW_RIGHT:"next",ARROW_UP:"previous",ARROW_DOWN:"next",ARROW_LEFT:"previous"})}return _createClass(e,[{key:"_init",value:function(){var e=this,i=this;if(this.$element.attr({role:"tablist"}),this.$tabTitles=this.$element.find("."+this.options.linkClass),this.$tabContent=t('[data-tabs-content="'+this.$element[0].id+'"]'),this.$tabTitles.each(function(){var e=t(this),n=e.find("a"),a=e.hasClass(""+i.options.linkActiveClass),s=n[0].hash.slice(1),o=n[0].id?n[0].id:s+"-label",l=t("#"+s);e.attr({role:"presentation"}),n.attr({role:"tab","aria-controls":s,"aria-selected":a,id:o}),l.attr({role:"tabpanel","aria-hidden":!a,"aria-labelledby":o}),a&&i.options.autoFocus&&t(window).load(function(){t("html, body").animate({scrollTop:e.offset().top},i.options.deepLinkSmudgeDelay,function(){n.focus()})})}),this.options.matchHeight){var n=this.$tabContent.find("img");n.length?Foundation.onImagesLoaded(n,this._setHeight.bind(this)):this._setHeight()}this._checkDeepLink=function(){var i=window.location.hash;if(i.length){var n=e.$element.find('[href="'+i+'"]');if(n.length){if(e.selectTab(t(i),!0),e.options.deepLinkSmudge){var a=e.$element.offset();t("html, body").animate({scrollTop:a.top},e.options.deepLinkSmudgeDelay)}e.$element.trigger("deeplink.zf.tabs",[n,t(i)])}}},this.options.deepLink&&this._checkDeepLink(),this._events()}},{key:"_events",value:function(){this._addKeyHandler(),this._addClickHandler(),this._setHeightMqHandler=null,this.options.matchHeight&&(this._setHeightMqHandler=this._setHeight.bind(this),t(window).on("changed.zf.mediaquery",this._setHeightMqHandler)),this.options.deepLink&&t(window).on("popstate",this._checkDeepLink)}},{key:"_addClickHandler",value:function(){var e=this;this.$element.off("click.zf.tabs").on("click.zf.tabs","."+this.options.linkClass,function(i){i.preventDefault(),i.stopPropagation(),e._handleTabChange(t(this))})}},{key:"_addKeyHandler",value:function(){var e=this;this.$tabTitles.off("keydown.zf.tabs").on("keydown.zf.tabs",function(i){if(9!==i.which){var n,a,s=t(this),o=s.parent("ul").children("li");o.each(function(i){if(t(this).is(s))return void(e.options.wrapOnKeys?(n=0===i?o.last():o.eq(i-1),a=i===o.length-1?o.first():o.eq(i+1)):(n=o.eq(Math.max(0,i-1)),a=o.eq(Math.min(i+1,o.length-1))))}),Foundation.Keyboard.handleKey(i,"Tabs",{open:function(){s.find('[role="tab"]').focus(),e._handleTabChange(s)},previous:function(){n.find('[role="tab"]').focus(),e._handleTabChange(n)},next:function(){a.find('[role="tab"]').focus(),e._handleTabChange(a)},handled:function(){i.stopPropagation(),i.preventDefault()}})}})}},{key:"_handleTabChange",value:function(t,e){if(t.hasClass(""+this.options.linkActiveClass))return void(this.options.activeCollapse&&(this._collapseTab(t),this.$element.trigger("collapse.zf.tabs",[t])));var i=this.$element.find("."+this.options.linkClass+"."+this.options.linkActiveClass),n=t.find('[role="tab"]'),a=n[0].hash,s=this.$tabContent.find(a);if(this._collapseTab(i),this._openTab(t),this.options.deepLink&&!e){var o=t.find("a").attr("href");this.options.updateHistory?history.pushState({},"",o):history.replaceState({},"",o)}this.$element.trigger("change.zf.tabs",[t,s]),s.find("[data-mutate]").trigger("mutateme.zf.trigger")}},{key:"_openTab",value:function(t){var e=t.find('[role="tab"]'),i=e[0].hash,n=this.$tabContent.find(i);t.addClass(""+this.options.linkActiveClass),e.attr({"aria-selected":"true"}),n.addClass(""+this.options.panelActiveClass).attr({"aria-hidden":"false"})}},{key:"_collapseTab",value:function(e){var i=e.removeClass(""+this.options.linkActiveClass).find('[role="tab"]').attr({"aria-selected":"false"});t("#"+i.attr("aria-controls")).removeClass(""+this.options.panelActiveClass).attr({"aria-hidden":"true"})}},{key:"selectTab",value:function(t,e){var i;i="object"==typeof t?t[0].id:t,i.indexOf("#")<0&&(i="#"+i);var n=this.$tabTitles.find('[href="'+i+'"]').parent("."+this.options.linkClass);this._handleTabChange(n,e)}},{key:"_setHeight",value:function(){var e=0,i=this;this.$tabContent.find("."+this.options.panelClass).css("height","").each(function(){var n=t(this),a=n.hasClass(""+i.options.panelActiveClass);a||n.css({visibility:"hidden",display:"block"});var s=this.getBoundingClientRect().height;a||n.css({visibility:"",display:""}),e=s>e?s:e}).css("height",e+"px")}},{key:"destroy",value:function(){this.$element.find("."+this.options.linkClass).off(".zf.tabs").hide().end().find("."+this.options.panelClass).hide(),this.options.matchHeight&&null!=this._setHeightMqHandler&&t(window).off("changed.zf.mediaquery",this._setHeightMqHandler),this.options.deepLink&&t(window).off("popstate",this._checkDeepLink),Foundation.unregisterPlugin(this)}}]),e}();e.defaults={deepLink:!1,deepLinkSmudge:!1,deepLinkSmudgeDelay:300,updateHistory:!1,autoFocus:!1,wrapOnKeys:!0,matchHeight:!1,activeCollapse:!1,linkClass:"tabs-title",linkActiveClass:"is-active",panelClass:"tabs-panel",panelActiveClass:"is-active"},Foundation.plugin(e,"Tabs")}(jQuery);

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

@@ -0,0 +1,169 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+!function ($) {
+
+  /**
+   * Toggler module.
+   * @module foundation.toggler
+   * @requires foundation.util.motion
+   * @requires foundation.util.triggers
+   */
+
+  var Toggler = function () {
+    /**
+     * Creates a new instance of Toggler.
+     * @class
+     * @fires Toggler#init
+     * @param {Object} element - jQuery object to add the trigger to.
+     * @param {Object} options - Overrides to the default plugin settings.
+     */
+    function Toggler(element, options) {
+      _classCallCheck(this, Toggler);
+
+      this.$element = element;
+      this.options = $.extend({}, Toggler.defaults, element.data(), options);
+      this.className = '';
+
+      this._init();
+      this._events();
+
+      Foundation.registerPlugin(this, 'Toggler');
+    }
+
+    /**
+     * Initializes the Toggler plugin by parsing the toggle class from data-toggler, or animation classes from data-animate.
+     * @function
+     * @private
+     */
+
+
+    _createClass(Toggler, [{
+      key: '_init',
+      value: function _init() {
+        var input;
+        // Parse animation classes if they were set
+        if (this.options.animate) {
+          input = this.options.animate.split(' ');
+
+          this.animationIn = input[0];
+          this.animationOut = input[1] || null;
+        }
+        // Otherwise, parse toggle class
+        else {
+            input = this.$element.data('toggler');
+            // Allow for a . at the beginning of the string
+            this.className = input[0] === '.' ? input.slice(1) : input;
+          }
+
+        // Add ARIA attributes to triggers
+        var id = this.$element[0].id;
+        $('[data-open="' + id + '"], [data-close="' + id + '"], [data-toggle="' + id + '"]').attr('aria-controls', id);
+        // If the target is hidden, add aria-hidden
+        this.$element.attr('aria-expanded', this.$element.is(':hidden') ? false : true);
+      }
+
+      /**
+       * Initializes events for the toggle trigger.
+       * @function
+       * @private
+       */
+
+    }, {
+      key: '_events',
+      value: function _events() {
+        this.$element.off('toggle.zf.trigger').on('toggle.zf.trigger', this.toggle.bind(this));
+      }
+
+      /**
+       * Toggles the target class on the target element. An event is fired from the original trigger depending on if the resultant state was "on" or "off".
+       * @function
+       * @fires Toggler#on
+       * @fires Toggler#off
+       */
+
+    }, {
+      key: 'toggle',
+      value: function toggle() {
+        this[this.options.animate ? '_toggleAnimate' : '_toggleClass']();
+      }
+    }, {
+      key: '_toggleClass',
+      value: function _toggleClass() {
+        this.$element.toggleClass(this.className);
+
+        var isOn = this.$element.hasClass(this.className);
+        if (isOn) {
+          /**
+           * Fires if the target element has the class after a toggle.
+           * @event Toggler#on
+           */
+          this.$element.trigger('on.zf.toggler');
+        } else {
+          /**
+           * Fires if the target element does not have the class after a toggle.
+           * @event Toggler#off
+           */
+          this.$element.trigger('off.zf.toggler');
+        }
+
+        this._updateARIA(isOn);
+        this.$element.find('[data-mutate]').trigger('mutateme.zf.trigger');
+      }
+    }, {
+      key: '_toggleAnimate',
+      value: function _toggleAnimate() {
+        var _this = this;
+
+        if (this.$element.is(':hidden')) {
+          Foundation.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 () {
+            _this._updateARIA(false);
+            this.trigger('off.zf.toggler');
+            this.find('[data-mutate]').trigger('mutateme.zf.trigger');
+          });
+        }
+      }
+    }, {
+      key: '_updateARIA',
+      value: function _updateARIA(isOn) {
+        this.$element.attr('aria-expanded', isOn ? true : false);
+      }
+
+      /**
+       * Destroys the instance of Toggler on the element.
+       * @function
+       */
+
+    }, {
+      key: 'destroy',
+      value: function destroy() {
+        this.$element.off('.zf.toggler');
+        Foundation.unregisterPlugin(this);
+      }
+    }]);
+
+    return Toggler;
+  }();
+
+  Toggler.defaults = {
+    /**
+     * Tells the plugin if the element should animated when toggled.
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    animate: false
+  };
+
+  // Window exports
+  Foundation.plugin(Toggler, 'Toggler');
+}(jQuery);

data/assets/js/vendor/foundation/plugins/foundation.toggler.min.js

@@ -0,0 +1 @@
+"use strict";function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}var _createClass=function(){function t(t,e){for(var i=0;i<e.length;i++){var n=e[i];n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(t,n.key,n)}}return function(e,i,n){return i&&t(e.prototype,i),n&&t(e,n),e}}();!function(t){var e=function(){function e(i,n){_classCallCheck(this,e),this.$element=i,this.options=t.extend({},e.defaults,i.data(),n),this.className="",this._init(),this._events(),Foundation.registerPlugin(this,"Toggler")}return _createClass(e,[{key:"_init",value:function(){var e;this.options.animate?(e=this.options.animate.split(" "),this.animationIn=e[0],this.animationOut=e[1]||null):(e=this.$element.data("toggler"),this.className="."===e[0]?e.slice(1):e);var i=this.$element[0].id;t('[data-open="'+i+'"], [data-close="'+i+'"], [data-toggle="'+i+'"]').attr("aria-controls",i),this.$element.attr("aria-expanded",!this.$element.is(":hidden"))}},{key:"_events",value:function(){this.$element.off("toggle.zf.trigger").on("toggle.zf.trigger",this.toggle.bind(this))}},{key:"toggle",value:function(){this[this.options.animate?"_toggleAnimate":"_toggleClass"]()}},{key:"_toggleClass",value:function(){this.$element.toggleClass(this.className);var t=this.$element.hasClass(this.className);t?this.$element.trigger("on.zf.toggler"):this.$element.trigger("off.zf.toggler"),this._updateARIA(t),this.$element.find("[data-mutate]").trigger("mutateme.zf.trigger")}},{key:"_toggleAnimate",value:function(){var t=this;this.$element.is(":hidden")?Foundation.Motion.animateIn(this.$element,this.animationIn,function(){t._updateARIA(!0),this.trigger("on.zf.toggler"),this.find("[data-mutate]").trigger("mutateme.zf.trigger")}):Foundation.Motion.animateOut(this.$element,this.animationOut,function(){t._updateARIA(!1),this.trigger("off.zf.toggler"),this.find("[data-mutate]").trigger("mutateme.zf.trigger")})}},{key:"_updateARIA",value:function(t){this.$element.attr("aria-expanded",!!t)}},{key:"destroy",value:function(){this.$element.off(".zf.toggler"),Foundation.unregisterPlugin(this)}}]),e}();e.defaults={animate:!1},Foundation.plugin(e,"Toggler")}(jQuery);

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

@@ -0,0 +1,492 @@
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+!function ($) {
+
+  /**
+   * Tooltip module.
+   * @module foundation.tooltip
+   * @requires foundation.util.box
+   * @requires foundation.util.mediaQuery
+   * @requires foundation.util.triggers
+   */
+
+  var Tooltip = function () {
+    /**
+     * Creates a new instance of a Tooltip.
+     * @class
+     * @fires Tooltip#init
+     * @param {jQuery} element - jQuery object to attach a tooltip to.
+     * @param {Object} options - object to extend the default configuration.
+     */
+    function Tooltip(element, options) {
+      _classCallCheck(this, Tooltip);
+
+      this.$element = element;
+      this.options = $.extend({}, Tooltip.defaults, this.$element.data(), options);
+
+      this.isActive = false;
+      this.isClick = false;
+      this._init();
+
+      Foundation.registerPlugin(this, 'Tooltip');
+    }
+
+    /**
+     * Initializes the tooltip by setting the creating the tip element, adding it's text, setting private variables and setting attributes on the anchor.
+     * @private
+     */
+
+
+    _createClass(Tooltip, [{
+      key: '_init',
+      value: function _init() {
+        var elemId = this.$element.attr('aria-describedby') || Foundation.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);
+
+        if (this.options.allowHtml) {
+          this.template.appendTo(document.body).html(this.options.tipText).hide();
+        } else {
+          this.template.appendTo(document.body).text(this.options.tipText).hide();
+        }
+
+        this.$element.attr({
+          'title': '',
+          'aria-describedby': elemId,
+          'data-yeti-box': elemId,
+          'data-toggle': elemId,
+          'data-resize': elemId
+        }).addClass(this.options.triggerClass);
+
+        //helper variables to track movement on collisions
+        this.usedPositions = [];
+        this.counter = 4;
+        this.classChanged = false;
+
+        this._events();
+      }
+
+      /**
+       * Grabs the current positioning class, if present, and returns the value or an empty string.
+       * @private
+       */
+
+    }, {
+      key: '_getPositionClass',
+      value: function _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;
+      }
+    }, {
+      key: '_buildTemplate',
+
+      /**
+       * builds the tooltip element, adds attributes, and returns the template.
+       * @private
+       */
+      value: function _buildTemplate(id) {
+        var templateClasses = (this.options.tooltipClass + ' ' + this.options.positionClass + ' ' + this.options.templateClasses).trim();
+        var $template = $('<div></div>').addClass(templateClasses).attr({
+          'role': 'tooltip',
+          'aria-hidden': true,
+          'data-is-active': false,
+          'data-is-focus': false,
+          'id': id
+        });
+        return $template;
+      }
+
+      /**
+       * Function that gets called if a collision event is detected.
+       * @param {String} position - positioning class to try
+       * @private
+       */
+
+    }, {
+      key: '_reposition',
+      value: function _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
+       */
+
+    }, {
+      key: '_setPosition',
+      value: function _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();
+        }
+      }
+
+      /**
+       * reveals the tooltip, and fires an event to close any other open tooltips on the page
+       * @fires Tooltip#closeme
+       * @fires Tooltip#show
+       * @function
+       */
+
+    }, {
+      key: 'show',
+      value: function show() {
+        if (this.options.showOn !== 'all' && !Foundation.MediaQuery.is(this.options.showOn)) {
+          // console.error('The screen is too small to display this tooltip');
+          return false;
+        }
+
+        var _this = this;
+        this.template.css('visibility', 'hidden').show();
+        this._setPosition();
+
+        /**
+         * Fires to close all other open tooltips on the page
+         * @event Closeme#tooltip
+         */
+        this.$element.trigger('closeme.zf.tooltip', this.template.attr('id'));
+
+        this.template.attr({
+          'data-is-active': true,
+          'aria-hidden': false
+        });
+        _this.isActive = true;
+        // console.log(this.template);
+        this.template.stop().hide().css('visibility', '').fadeIn(this.options.fadeInDuration, function () {
+          //maybe do stuff?
+        });
+        /**
+         * Fires when the tooltip is shown
+         * @event Tooltip#show
+         */
+        this.$element.trigger('show.zf.tooltip');
+      }
+
+      /**
+       * Hides the current tooltip, and resets the positioning class if it was changed due to collision
+       * @fires Tooltip#hide
+       * @function
+       */
+
+    }, {
+      key: 'hide',
+      value: function hide() {
+        // console.log('hiding', this.$element.data('yeti-box'));
+        var _this = this;
+        this.template.stop().attr({
+          'aria-hidden': true,
+          'data-is-active': false
+        }).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
+         * @event Tooltip#hide
+         */
+        this.$element.trigger('hide.zf.tooltip');
+      }
+
+      /**
+       * adds event listeners for the tooltip and its anchor
+       * TODO combine some of the listeners like focus and mouseenter, etc.
+       * @private
+       */
+
+    }, {
+      key: '_events',
+      value: function _events() {
+        var _this = this;
+        var $template = this.template;
+        var isFocus = false;
+
+        if (!this.options.disableHover) {
+
+          this.$element.on('mouseenter.zf.tooltip', function (e) {
+            if (!_this.isActive) {
+              _this.timeout = setTimeout(function () {
+                _this.show();
+              }, _this.options.hoverDelay);
+            }
+          }).on('mouseleave.zf.tooltip', function (e) {
+            clearTimeout(_this.timeout);
+            if (!isFocus || _this.isClick && !_this.options.clickOpen) {
+              _this.hide();
+            }
+          });
+        }
+
+        if (this.options.clickOpen) {
+          this.$element.on('mousedown.zf.tooltip', function (e) {
+            e.stopImmediatePropagation();
+            if (_this.isClick) {
+              //_this.hide();
+              // _this.isClick = false;
+            } else {
+              _this.isClick = true;
+              if ((_this.options.disableHover || !_this.$element.attr('tabindex')) && !_this.isActive) {
+                _this.show();
+              }
+            }
+          });
+        } else {
+          this.$element.on('mousedown.zf.tooltip', function (e) {
+            e.stopImmediatePropagation();
+            _this.isClick = true;
+          });
+        }
+
+        if (!this.options.disableForTouch) {
+          this.$element.on('tap.zf.tooltip touchend.zf.tooltip', function (e) {
+            _this.isActive ? _this.hide() : _this.show();
+          });
+        }
+
+        this.$element.on({
+          // 'toggle.zf.trigger': this.toggle.bind(this),
+          // 'close.zf.trigger': this.hide.bind(this)
+          'close.zf.trigger': this.hide.bind(this)
+        });
+
+        this.$element.on('focus.zf.tooltip', function (e) {
+          isFocus = true;
+          if (_this.isClick) {
+            // If we're not showing open on clicks, we need to pretend a click-launched focus isn't
+            // a real focus, otherwise on hover and come back we get bad behavior
+            if (!_this.options.clickOpen) {
+              isFocus = false;
+            }
+            return false;
+          } else {
+            _this.show();
+          }
+        }).on('focusout.zf.tooltip', function (e) {
+          isFocus = false;
+          _this.isClick = false;
+          _this.hide();
+        }).on('resizeme.zf.trigger', function () {
+          if (_this.isActive) {
+            _this._setPosition();
+          }
+        });
+      }
+
+      /**
+       * adds a toggle method, in addition to the static show() & hide() functions
+       * @function
+       */
+
+    }, {
+      key: 'toggle',
+      value: function toggle() {
+        if (this.isActive) {
+          this.hide();
+        } else {
+          this.show();
+        }
+      }
+
+      /**
+       * Destroys an instance of tooltip, removes template element from the view.
+       * @function
+       */
+
+    }, {
+      key: 'destroy',
+      value: function 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);
+      }
+    }]);
+
+    return Tooltip;
+  }();
+
+  Tooltip.defaults = {
+    disableForTouch: false,
+    /**
+     * Time, in ms, before a tooltip should open on hover.
+     * @option
+     * @type {number}
+     * @default 200
+     */
+    hoverDelay: 200,
+    /**
+     * Time, in ms, a tooltip should take to fade into view.
+     * @option
+     * @type {number}
+     * @default 150
+     */
+    fadeInDuration: 150,
+    /**
+     * Time, in ms, a tooltip should take to fade out of view.
+     * @option
+     * @type {number}
+     * @default 150
+     */
+    fadeOutDuration: 150,
+    /**
+     * Disables hover events from opening the tooltip if set to true
+     * @option
+     * @type {boolean}
+     * @default false
+     */
+    disableHover: false,
+    /**
+     * Optional addtional classes to apply to the tooltip template on init.
+     * @option
+     * @type {string}
+     * @default ''
+     */
+    templateClasses: '',
+    /**
+     * Non-optional class added to tooltip templates. Foundation default is 'tooltip'.
+     * @option
+     * @type {string}
+     * @default 'tooltip'
+     */
+    tooltipClass: 'tooltip',
+    /**
+     * Class applied to the tooltip anchor element.
+     * @option
+     * @type {string}
+     * @default 'has-tip'
+     */
+    triggerClass: 'has-tip',
+    /**
+     * Minimum breakpoint size at which to open the tooltip.
+     * @option
+     * @type {string}
+     * @default 'small'
+     */
+    showOn: 'small',
+    /**
+     * Custom template to be used to generate markup for tooltip.
+     * @option
+     * @type {string}
+     * @default ''
+     */
+    template: '',
+    /**
+     * Text displayed in the tooltip template on open.
+     * @option
+     * @type {string}
+     * @default ''
+     */
+    tipText: '',
+    touchCloseText: 'Tap to close.',
+    /**
+     * Allows the tooltip to remain open if triggered with a click or touch event.
+     * @option
+     * @type {boolean}
+     * @default true
+     */
+    clickOpen: true,
+    /**
+     * Additional positioning classes, set by the JS
+     * @option
+     * @type {string}
+     * @default ''
+     */
+    positionClass: '',
+    /**
+     * Distance, in pixels, the template should push away from the anchor on the Y axis.
+     * @option
+     * @type {number}
+     * @default 10
+     */
+    vOffset: 10,
+    /**
+     * Distance, in pixels, the template should push away from the anchor on the X axis, if aligned to a side.
+     * @option
+     * @type {number}
+     * @default 12
+     */
+    hOffset: 12,
+    /**
+    * Allow HTML in tooltip. Warning: If you are loading user-generated content into tooltips,
+    * allowing HTML may open yourself up to XSS attacks.
+    * @option
+    * @type {boolean}
+    * @default false
+    */
+    allowHtml: false
+  };
+
+  /**
+   * TODO utilize resize event trigger
+   */
+
+  // Window exports
+  Foundation.plugin(Tooltip, 'Tooltip');
+}(jQuery);