text: 'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var _vue = require('vue');
  
  var _vue2 = _interopRequireDefault(_vue);
  
  var _positionable = require('./positionable');
  
  var _positionable2 = _interopRequireDefault(_positionable);
  
  var _stackable = require('./stackable');
  
  var _stackable2 = _interopRequireDefault(_stackable);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  /* eslint-disable object-property-newline */
  var dimensions = {
      activator: {
          top: 0, left: 0,
          bottom: 0, right: 0,
          width: 0, height: 0,
          offsetTop: 0, scrollHeight: 0
      },
      content: {
          top: 0, left: 0,
          bottom: 0, right: 0,
          width: 0, height: 0,
          offsetTop: 0, scrollHeight: 0
      },
      hasWindow: false
  };
  /* eslint-enable object-property-newline */
  /**
   * Menuable
   *
   * @mixin
   *
   * Used for fixed or absolutely positioning
   * elements within the DOM
   * Can calculate X and Y axis overflows
   * As well as be manually positioned
   */
  /* @vue/component */
  exports.default = _vue2.default.extend({
      name: 'menuable',
      mixins: [_positionable2.default, _stackable2.default],
      props: {
          activator: {
              default: null,
              validator: function validator(val) {
                  return ['string', 'object'].includes(typeof val === 'undefined' ? 'undefined' : _typeof(val));
              }
          },
          allowOverflow: Boolean,
          inputActivator: Boolean,
          light: Boolean,
          dark: Boolean,
          maxWidth: {
              type: [Number, String],
              default: 'auto'
          },
          minWidth: [Number, String],
          nudgeBottom: {
              type: [Number, String],
              default: 0
          },
          nudgeLeft: {
              type: [Number, String],
              default: 0
          },
          nudgeRight: {
              type: [Number, String],
              default: 0
          },
          nudgeTop: {
              type: [Number, String],
              default: 0
          },
          nudgeWidth: {
              type: [Number, String],
              default: 0
          },
          offsetOverflow: Boolean,
          positionX: {
              type: Number,
              default: null
          },
          positionY: {
              type: Number,
              default: null
          },
          zIndex: {
              type: [Number, String],
              default: null
          }
      },
      data: function data() {
          return {
              absoluteX: 0,
              absoluteY: 0,
              dimensions: Object.assign({}, dimensions),
              isContentActive: false,
              pageYOffset: 0,
              stackClass: 'v-menu__content--active',
              stackMinZIndex: 6
          };
      },
      computed: {
          computedLeft: function computedLeft() {
              var a = this.dimensions.activator;
              var c = this.dimensions.content;
              var minWidth = a.width < c.width ? c.width : a.width;
              var left = 0;
              left += this.left ? a.left - (minWidth - a.width) : a.left;
              if (this.offsetX) left += this.left ? -a.width : a.width;
              if (this.nudgeLeft) left -= parseInt(this.nudgeLeft);
              if (this.nudgeRight) left += parseInt(this.nudgeRight);
              return left;
          },
          computedTop: function computedTop() {
              var a = this.dimensions.activator;
              var c = this.dimensions.content;
              var top = this.top ? a.bottom - c.height : a.top;
              if (!this.isAttached) top += this.pageYOffset;
              if (this.offsetY) top += this.top ? -a.height : a.height;
              if (this.nudgeTop) top -= parseInt(this.nudgeTop);
              if (this.nudgeBottom) top += parseInt(this.nudgeBottom);
              return top;
          },
          hasActivator: function hasActivator() {
              return !!this.$slots.activator || this.activator || this.inputActivator;
          },
          isAttached: function isAttached() {
              return this.attach !== false;
          }
      },
      watch: {
          disabled: function disabled(val) {
              val && this.callDeactivate();
          },
          isActive: function isActive(val) {
              if (this.disabled) return;
              val ? this.callActivate() : this.callDeactivate();
          }
      },
      beforeMount: function beforeMount() {
          this.checkForWindow();
      },
  
      methods: {
          absolutePosition: function absolutePosition() {
              return {
                  offsetTop: 0,
                  scrollHeight: 0,
                  top: this.positionY || this.absoluteY,
                  bottom: this.positionY || this.absoluteY,
                  left: this.positionX || this.absoluteX,
                  right: this.positionX || this.absoluteX,
                  height: 0,
                  width: 0
              };
          },
          activate: function activate() {},
          calcLeft: function calcLeft() {
              return (this.isAttached ? this.computedLeft : this.calcXOverflow(this.computedLeft)) + 'px';
          },
          calcTop: function calcTop() {
              return (this.isAttached ? this.computedTop : this.calcYOverflow(this.computedTop)) + 'px';
          },
          calcXOverflow: function calcXOverflow(left) {
              var parsedMaxWidth = isNaN(parseInt(this.maxWidth)) ? 0 : parseInt(this.maxWidth);
              var innerWidth = this.getInnerWidth();
              var maxWidth = Math.max(this.dimensions.content.width, parsedMaxWidth);
              var totalWidth = left + maxWidth;
              var availableWidth = totalWidth - innerWidth;
              if ((!this.left || this.right) && availableWidth > 0) {
                  left = innerWidth - maxWidth - (innerWidth > 600 ? 30 : 12) // Account for scrollbar
                  ;
              }
              if (left < 0) left = 12;
              return left + this.getOffsetLeft();
          },
          calcYOverflow: function calcYOverflow(top) {
              var documentHeight = this.getInnerHeight();
              var toTop = this.pageYOffset + documentHeight;
              var activator = this.dimensions.activator;
              var contentHeight = this.dimensions.content.height;
              var totalHeight = top + contentHeight;
              var isOverflowing = toTop < totalHeight;
              // If overflowing bottom and offset
              // TODO: set 'bottom' position instead of 'top'
              if (isOverflowing && this.offsetOverflow &&
              // If we don't have enough room to offset
              // the overflow, don't offset
              activator.top > contentHeight) {
                  top = this.pageYOffset + (activator.top - contentHeight);
                  // If overflowing bottom
              } else if (isOverflowing && !this.allowOverflow) {
                  top = toTop - contentHeight - 12;
                  // If overflowing top
              } else if (top < this.pageYOffset && !this.allowOverflow) {
                  top = this.pageYOffset + 12;
              }
              return top < 12 ? 12 : top;
          },
          callActivate: function callActivate() {
              if (!this.hasWindow) return;
              this.activate();
          },
          callDeactivate: function callDeactivate() {
              this.isContentActive = false;
              this.deactivate();
          },
          checkForWindow: function checkForWindow() {
              if (!this.hasWindow) {
                  this.hasWindow = typeof window !== 'undefined';
              }
          },
          checkForPageYOffset: function checkForPageYOffset() {
              if (this.hasWindow) {
                  this.pageYOffset = this.getOffsetTop();
              }
          },
          deactivate: function deactivate() {},
          getActivator: function getActivator() {
              if (this.inputActivator) {
                  return this.$el.querySelector('.v-input__slot');
              }
              if (this.activator) {
                  return typeof this.activator === 'string' ? document.querySelector(this.activator) : this.activator;
              }
              return this.$refs.activator.children.length > 0 ? this.$refs.activator.children[0] : this.$refs.activator;
          },
          getInnerHeight: function getInnerHeight() {
              if (!this.hasWindow) return 0;
              return window.innerHeight || document.documentElement.clientHeight;
          },
          getInnerWidth: function getInnerWidth() {
              if (!this.hasWindow) return 0;
              return window.innerWidth;
          },
          getOffsetLeft: function getOffsetLeft() {
              if (!this.hasWindow) return 0;
              return window.pageXOffset || document.documentElement.scrollLeft;
          },
          getOffsetTop: function getOffsetTop() {
              if (!this.hasWindow) return 0;
              return window.pageYOffset || document.documentElement.scrollTop;
          },
          getRoundedBoundedClientRect: function getRoundedBoundedClientRect(el) {
              var rect = el.getBoundingClientRect();
              return {
                  top: Math.round(rect.top),
                  left: Math.round(rect.left),
                  bottom: Math.round(rect.bottom),
                  right: Math.round(rect.right),
                  width: Math.round(rect.width),
                  height: Math.round(rect.height)
              };
          },
          measure: function measure(el, selector) {
              el = selector ? el.querySelector(selector) : el;
              if (!el || !this.hasWindow) return null;
              var rect = this.getRoundedBoundedClientRect(el);
              // Account for activator margin
              if (this.isAttached) {
                  var style = window.getComputedStyle(el);
                  rect.left = parseInt(style.marginLeft);
                  rect.top = parseInt(style.marginTop);
              }
              return rect;
          },
          sneakPeek: function sneakPeek(cb) {
              var _this = this;
  
              requestAnimationFrame(function () {
                  var el = _this.$refs.content;
                  if (!el || _this.isShown(el)) return cb();
                  el.style.display = 'inline-block';
                  cb();
                  el.style.display = 'none';
              });
          },
          startTransition: function startTransition() {
              var _this2 = this;
  
              return new Promise(function (resolve) {
                  return requestAnimationFrame(function () {
                      _this2.isContentActive = true;
                      resolve();
                  });
              });
          },
          isShown: function isShown(el) {
              return el.style.display !== 'none';
          },
          updateDimensions: function updateDimensions() {
              var _this3 = this;
  
              this.checkForWindow();
              this.checkForPageYOffset();
              var dimensions = {};
              // Activator should already be shown
              dimensions.activator = !this.hasActivator || this.absolute ? this.absolutePosition() : this.measure(this.getActivator());
              // Display and hide to get dimensions
              this.sneakPeek(function () {
                  dimensions.content = _this3.measure(_this3.$refs.content);
                  _this3.dimensions = dimensions;
              });
          }
      }
  });
  //# sourceMappingURL=menuable.js.map