/******/ (function(modules) { // webpackBootstrap /******/ // The module cache /******/ var installedModules = {}; /******/ /******/ // The require function /******/ function __webpack_require__(moduleId) { /******/ /******/ // Check if module is in cache /******/ if(installedModules[moduleId]) { /******/ return installedModules[moduleId].exports; /******/ } /******/ // Create a new module (and put it into the cache) /******/ var module = installedModules[moduleId] = { /******/ i: moduleId, /******/ l: false, /******/ exports: {} /******/ }; /******/ /******/ // Execute the module function /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); /******/ /******/ // Flag the module as loaded /******/ module.l = true; /******/ /******/ // Return the exports of the module /******/ return module.exports; /******/ } /******/ /******/ /******/ // expose the modules object (__webpack_modules__) /******/ __webpack_require__.m = modules; /******/ /******/ // expose the module cache /******/ __webpack_require__.c = installedModules; /******/ /******/ // identity function for calling harmony imports with the correct context /******/ __webpack_require__.i = function(value) { return value; }; /******/ /******/ // define getter function for harmony exports /******/ __webpack_require__.d = function(exports, name, getter) { /******/ if(!__webpack_require__.o(exports, name)) { /******/ Object.defineProperty(exports, name, { /******/ configurable: false, /******/ enumerable: true, /******/ get: getter /******/ }); /******/ } /******/ }; /******/ /******/ // getDefaultExport function for compatibility with non-harmony modules /******/ __webpack_require__.n = function(module) { /******/ var getter = module && module.__esModule ? /******/ function getDefault() { return module['default']; } : /******/ function getModuleExports() { return module; }; /******/ __webpack_require__.d(getter, 'a', getter); /******/ return getter; /******/ }; /******/ /******/ // Object.prototype.hasOwnProperty.call /******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; /******/ /******/ // __webpack_public_path__ /******/ __webpack_require__.p = ""; /******/ /******/ // Load entry module and return exports /******/ return __webpack_require__(__webpack_require__.s = 94); /******/ }) /************************************************************************/ /******/ ({ /***/ 0: /***/ (function(module, exports) { module.exports = jQuery; /***/ }), /***/ 1: /***/ (function(module, exports) { module.exports = {Foundation: window.Foundation}; /***/ }), /***/ 12: /***/ (function(module, exports) { module.exports = {Touch: window.Foundation.Touch}; /***/ }), /***/ 2: /***/ (function(module, exports) { module.exports = {Plugin: window.Foundation.Plugin}; /***/ }), /***/ 28: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; Object.defineProperty(__webpack_exports__, "__esModule", { value: true }); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core__ = __webpack_require__(1); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__foundation_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__foundation_core__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_slider__ = __webpack_require__(58); __WEBPACK_IMPORTED_MODULE_0__foundation_core__["Foundation"].plugin(__WEBPACK_IMPORTED_MODULE_1__foundation_slider__["a" /* Slider */], 'Slider'); /***/ }), /***/ 3: /***/ (function(module, exports) { module.exports = {rtl: window.Foundation.rtl, GetYoDigits: window.Foundation.GetYoDigits, transitionend: window.Foundation.transitionend}; /***/ }), /***/ 4: /***/ (function(module, exports) { module.exports = {Motion: window.Foundation.Motion, Move: window.Foundation.Move}; /***/ }), /***/ 5: /***/ (function(module, exports) { module.exports = {Keyboard: window.Foundation.Keyboard}; /***/ }), /***/ 58: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Slider; }); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__ = __webpack_require__(5); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__foundation_util_motion__ = __webpack_require__(4); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__foundation_util_motion___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2__foundation_util_motion__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__foundation_util_core__ = __webpack_require__(3); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__foundation_util_core___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3__foundation_util_core__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__foundation_plugin__ = __webpack_require__(2); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__foundation_plugin___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4__foundation_plugin__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__foundation_util_touch__ = __webpack_require__(12); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__foundation_util_touch___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5__foundation_util_touch__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_6__foundation_util_triggers__ = __webpack_require__(7); 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 _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; } function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /** * Slider module. * @module foundation.slider * @requires foundation.util.motion * @requires foundation.util.triggers * @requires foundation.util.keyboard * @requires foundation.util.touch */ var Slider = function (_Plugin) { _inherits(Slider, _Plugin); function Slider() { _classCallCheck(this, Slider); return _possibleConstructorReturn(this, (Slider.__proto__ || Object.getPrototypeOf(Slider)).apply(this, arguments)); } _createClass(Slider, [{ key: '_setup', /** * Creates a new instance of a slider control. * @class * @name Slider * @param {jQuery} element - jQuery object to make into a slider control. * @param {Object} options - Overrides to the default plugin settings. */ value: function _setup(element, options) { this.$element = element; this.options = __WEBPACK_IMPORTED_MODULE_0_jquery___default.a.extend({}, Slider.defaults, this.$element.data(), options); this.className = 'Slider'; // ie9 back compat // Touch and Triggers inits are idempotent, we just need to make sure it's initialied. __WEBPACK_IMPORTED_MODULE_5__foundation_util_touch__["Touch"].init(__WEBPACK_IMPORTED_MODULE_0_jquery___default.a); __WEBPACK_IMPORTED_MODULE_6__foundation_util_triggers__["a" /* Triggers */].init(__WEBPACK_IMPORTED_MODULE_0_jquery___default.a); this._init(); __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__["Keyboard"].register('Slider', { 'ltr': { 'ARROW_RIGHT': 'increase', 'ARROW_UP': 'increase', 'ARROW_DOWN': 'decrease', 'ARROW_LEFT': 'decrease', 'SHIFT_ARROW_RIGHT': 'increase_fast', 'SHIFT_ARROW_UP': 'increase_fast', 'SHIFT_ARROW_DOWN': 'decrease_fast', 'SHIFT_ARROW_LEFT': 'decrease_fast', 'HOME': 'min', 'END': 'max' }, 'rtl': { 'ARROW_LEFT': 'increase', 'ARROW_RIGHT': 'decrease', 'SHIFT_ARROW_LEFT': 'increase_fast', 'SHIFT_ARROW_RIGHT': 'decrease_fast' } }); } /** * Initilizes the plugin by reading/setting attributes, creating collections and setting the initial position of the handle(s). * @function * @private */ }, { key: '_init', value: function _init() { this.inputs = this.$element.find('input'); this.handles = this.$element.find('[data-slider-handle]'); this.$handle = this.handles.eq(0); this.$input = this.inputs.length ? this.inputs.eq(0) : __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + this.$handle.attr('aria-controls')); this.$fill = this.$element.find('[data-slider-fill]').css(this.options.vertical ? 'height' : 'width', 0); var isDbl = false, _this = this; if (this.options.disabled || this.$element.hasClass(this.options.disabledClass)) { this.options.disabled = true; this.$element.addClass(this.options.disabledClass); } if (!this.inputs.length) { this.inputs = __WEBPACK_IMPORTED_MODULE_0_jquery___default()().add(this.$input); this.options.binding = true; } this._setInitAttr(0); if (this.handles[1]) { this.options.doubleSided = true; this.$handle2 = this.handles.eq(1); this.$input2 = this.inputs.length > 1 ? this.inputs.eq(1) : __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + this.$handle2.attr('aria-controls')); if (!this.inputs[1]) { this.inputs = this.inputs.add(this.$input2); } isDbl = true; // this.$handle.triggerHandler('click.zf.slider'); this._setInitAttr(1); } // Set handle positions this.setHandles(); this._events(); } }, { key: 'setHandles', value: function setHandles() { var _this3 = this; if (this.handles[1]) { this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true, function () { _this3._setHandlePos(_this3.$handle2, _this3.inputs.eq(1).val(), true); }); } else { this._setHandlePos(this.$handle, this.inputs.eq(0).val(), true); } } }, { key: '_reflow', value: function _reflow() { this.setHandles(); } /** * @function * @private * @param {Number} value - floating point (the value) to be transformed using to a relative position on the slider (the inverse of _value) */ }, { key: '_pctOfBar', value: function _pctOfBar(value) { var pctOfBar = percent(value - this.options.start, this.options.end - this.options.start); switch (this.options.positionValueFunction) { case "pow": pctOfBar = this._logTransform(pctOfBar); break; case "log": pctOfBar = this._powTransform(pctOfBar); break; } return pctOfBar.toFixed(2); } /** * @function * @private * @param {Number} pctOfBar - floating point, the relative position of the slider (typically between 0-1) to be transformed to a value */ }, { key: '_value', value: function _value(pctOfBar) { switch (this.options.positionValueFunction) { case "pow": pctOfBar = this._powTransform(pctOfBar); break; case "log": pctOfBar = this._logTransform(pctOfBar); break; } var value = (this.options.end - this.options.start) * pctOfBar + this.options.start; return value; } /** * @function * @private * @param {Number} value - floating point (typically between 0-1) to be transformed using the log function */ }, { key: '_logTransform', value: function _logTransform(value) { return baseLog(this.options.nonLinearBase, value * (this.options.nonLinearBase - 1) + 1); } /** * @function * @private * @param {Number} value - floating point (typically between 0-1) to be transformed using the power function */ }, { key: '_powTransform', value: function _powTransform(value) { return (Math.pow(this.options.nonLinearBase, value) - 1) / (this.options.nonLinearBase - 1); } /** * Sets the position of the selected handle and fill bar. * @function * @private * @param {jQuery} $hndl - the selected handle to move. * @param {Number} location - floating point between the start and end values of the slider bar. * @param {Function} cb - callback function to fire on completion. * @fires Slider#moved * @fires Slider#changed */ }, { key: '_setHandlePos', value: function _setHandlePos($hndl, location, noInvert, cb) { // don't move if the slider has been disabled since its initialization if (this.$element.hasClass(this.options.disabledClass)) { return; } //might need to alter that slightly for bars that will have odd number selections. location = parseFloat(location); //on input change events, convert string to number...grumble. // prevent slider from running out of bounds, if value exceeds the limits set through options, override the value to min/max if (location < this.options.start) { location = this.options.start; } else if (location > this.options.end) { location = this.options.end; } var isDbl = this.options.doubleSided; //this is for single-handled vertical sliders, it adjusts the value to account for the slider being "upside-down" //for click and drag events, it's weird due to the scale(-1, 1) css property if (this.options.vertical && !noInvert) { location = this.options.end - location; } if (isDbl) { //this block is to prevent 2 handles from crossing eachother. Could/should be improved. if (this.handles.index($hndl) === 0) { var h2Val = parseFloat(this.$handle2.attr('aria-valuenow')); location = location >= h2Val ? h2Val - this.options.step : location; } else { var h1Val = parseFloat(this.$handle.attr('aria-valuenow')); location = location <= h1Val ? h1Val + this.options.step : location; } } var _this = this, vert = this.options.vertical, hOrW = vert ? 'height' : 'width', lOrT = vert ? 'top' : 'left', handleDim = $hndl[0].getBoundingClientRect()[hOrW], elemDim = this.$element[0].getBoundingClientRect()[hOrW], //percentage of bar min/max value based on click or drag point pctOfBar = this._pctOfBar(location), //number of actual pixels to shift the handle, based on the percentage obtained above pxToMove = (elemDim - handleDim) * pctOfBar, //percentage of bar to shift the handle movement = (percent(pxToMove, elemDim) * 100).toFixed(this.options.decimal); //fixing the decimal value for the location number, is passed to other methods as a fixed floating-point value location = parseFloat(location.toFixed(this.options.decimal)); // declare empty object for css adjustments, only used with 2 handled-sliders var css = {}; this._setValues($hndl, location); // TODO update to calculate based on values set to respective inputs?? if (isDbl) { var isLeftHndl = this.handles.index($hndl) === 0, //empty variable, will be used for min-height/width for fill bar dim, //percentage w/h of the handle compared to the slider bar handlePct = ~~(percent(handleDim, elemDim) * 100); //if left handle, the math is slightly different than if it's the right handle, and the left/top property needs to be changed for the fill bar if (isLeftHndl) { //left or top percentage value to apply to the fill bar. css[lOrT] = movement + '%'; //calculate the new min-height/width for the fill bar. dim = parseFloat(this.$handle2[0].style[lOrT]) - movement + handlePct; //this callback is necessary to prevent errors and allow the proper placement and initialization of a 2-handled slider //plus, it means we don't care if 'dim' isNaN on init, it won't be in the future. if (cb && typeof cb === 'function') { cb(); } //this is only needed for the initialization of 2 handled sliders } else { //just caching the value of the left/bottom handle's left/top property var handlePos = parseFloat(this.$handle[0].style[lOrT]); //calculate the new min-height/width for the fill bar. Use isNaN to prevent false positives for numbers <= 0 //based on the percentage of movement of the handle being manipulated, less the opposing handle's left/top position, plus the percentage w/h of the handle itself dim = movement - (isNaN(handlePos) ? (this.options.initialStart - this.options.start) / ((this.options.end - this.options.start) / 100) : handlePos) + handlePct; } // assign the min-height/width to our css object css['min-' + hOrW] = dim + '%'; } this.$element.one('finished.zf.animate', function () { /** * Fires when the handle is done moving. * @event Slider#moved */ _this.$element.trigger('moved.zf.slider', [$hndl]); }); //because we don't know exactly how the handle will be moved, check the amount of time it should take to move. var moveTime = this.$element.data('dragging') ? 1000 / 60 : this.options.moveTime; __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_2__foundation_util_motion__["Move"])(moveTime, $hndl, function () { // adjusting the left/top property of the handle, based on the percentage calculated above // if movement isNaN, that is because the slider is hidden and we cannot determine handle width, // fall back to next best guess. if (isNaN(movement)) { $hndl.css(lOrT, pctOfBar * 100 + '%'); } else { $hndl.css(lOrT, movement + '%'); } if (!_this.options.doubleSided) { //if single-handled, a simple method to expand the fill bar _this.$fill.css(hOrW, pctOfBar * 100 + '%'); } else { //otherwise, use the css object we created above _this.$fill.css(css); } }); /** * Fires when the value has not been change for a given time. * @event Slider#changed */ clearTimeout(_this.timeout); _this.timeout = setTimeout(function () { _this.$element.trigger('changed.zf.slider', [$hndl]); }, _this.options.changedDelay); } /** * Sets the initial attribute for the slider element. * @function * @private * @param {Number} idx - index of the current handle/input to use. */ }, { key: '_setInitAttr', value: function _setInitAttr(idx) { var initVal = idx === 0 ? this.options.initialStart : this.options.initialEnd; var id = this.inputs.eq(idx).attr('id') || __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__foundation_util_core__["GetYoDigits"])(6, 'slider'); this.inputs.eq(idx).attr({ 'id': id, 'max': this.options.end, 'min': this.options.start, 'step': this.options.step }); this.inputs.eq(idx).val(initVal); this.handles.eq(idx).attr({ 'role': 'slider', 'aria-controls': id, 'aria-valuemax': this.options.end, 'aria-valuemin': this.options.start, 'aria-valuenow': initVal, 'aria-orientation': this.options.vertical ? 'vertical' : 'horizontal', 'tabindex': 0 }); } /** * Sets the input and `aria-valuenow` values for the slider element. * @function * @private * @param {jQuery} $handle - the currently selected handle. * @param {Number} val - floating point of the new value. */ }, { key: '_setValues', value: function _setValues($handle, val) { var idx = this.options.doubleSided ? this.handles.index($handle) : 0; this.inputs.eq(idx).val(val); $handle.attr('aria-valuenow', val); } /** * Handles events on the slider element. * Calculates the new location of the current handle. * If there are two handles and the bar was clicked, it determines which handle to move. * @function * @private * @param {Object} e - the `event` object passed from the listener. * @param {jQuery} $handle - the current handle to calculate for, if selected. * @param {Number} val - floating point number for the new value of the slider. * TODO clean this up, there's a lot of repeated code between this and the _setHandlePos fn. */ }, { key: '_handleEvent', value: function _handleEvent(e, $handle, val) { var value, hasVal; if (!val) { //click or drag events e.preventDefault(); var _this = this, vertical = this.options.vertical, param = vertical ? 'height' : 'width', direction = vertical ? 'top' : 'left', eventOffset = vertical ? e.pageY : e.pageX, halfOfHandle = this.$handle[0].getBoundingClientRect()[param] / 2, barDim = this.$element[0].getBoundingClientRect()[param], windowScroll = vertical ? __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).scrollTop() : __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).scrollLeft(); var elemOffset = this.$element.offset()[direction]; // touch events emulated by the touch util give position relative to screen, add window.scroll to event coordinates... // best way to guess this is simulated is if clientY == pageY if (e.clientY === e.pageY) { eventOffset = eventOffset + windowScroll; } var eventFromBar = eventOffset - elemOffset; var barXY; if (eventFromBar < 0) { barXY = 0; } else if (eventFromBar > barDim) { barXY = barDim; } else { barXY = eventFromBar; } var offsetPct = percent(barXY, barDim); value = this._value(offsetPct); // turn everything around for RTL, yay math! if (__webpack_require__.i(__WEBPACK_IMPORTED_MODULE_3__foundation_util_core__["rtl"])() && !this.options.vertical) { value = this.options.end - value; } value = _this._adjustValue(null, value); //boolean flag for the setHandlePos fn, specifically for vertical sliders hasVal = false; if (!$handle) { //figure out which handle it is, pass it to the next function. var firstHndlPos = absPosition(this.$handle, direction, barXY, param), secndHndlPos = absPosition(this.$handle2, direction, barXY, param); $handle = firstHndlPos <= secndHndlPos ? this.$handle : this.$handle2; } } else { //change event on input value = this._adjustValue(null, val); hasVal = true; } this._setHandlePos($handle, value, hasVal); } /** * Adjustes value for handle in regard to step value. returns adjusted value * @function * @private * @param {jQuery} $handle - the selected handle. * @param {Number} value - value to adjust. used if $handle is falsy */ }, { key: '_adjustValue', value: function _adjustValue($handle, value) { var val, step = this.options.step, div = parseFloat(step / 2), left, prev_val, next_val; if (!!$handle) { val = parseFloat($handle.attr('aria-valuenow')); } else { val = value; } left = val % step; prev_val = val - left; next_val = prev_val + step; if (left === 0) { return val; } val = val >= prev_val + div ? next_val : prev_val; return val; } /** * Adds event listeners to the slider elements. * @function * @private */ }, { key: '_events', value: function _events() { this._eventsForHandle(this.$handle); if (this.handles[1]) { this._eventsForHandle(this.$handle2); } } /** * Adds event listeners a particular handle * @function * @private * @param {jQuery} $handle - the current handle to apply listeners to. */ }, { key: '_eventsForHandle', value: function _eventsForHandle($handle) { var _this = this, curHandle, timer; this.inputs.off('change.zf.slider').on('change.zf.slider', function (e) { var idx = _this.inputs.index(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this)); _this._handleEvent(e, _this.handles.eq(idx), __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).val()); }); if (this.options.clickSelect) { this.$element.off('click.zf.slider').on('click.zf.slider', function (e) { if (_this.$element.data('dragging')) { return false; } if (!__WEBPACK_IMPORTED_MODULE_0_jquery___default()(e.target).is('[data-slider-handle]')) { if (_this.options.doubleSided) { _this._handleEvent(e); } else { _this._handleEvent(e, _this.$handle); } } }); } if (this.options.draggable) { this.handles.addTouch(); var $body = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('body'); $handle.off('mousedown.zf.slider').on('mousedown.zf.slider', function (e) { $handle.addClass('is-dragging'); _this.$fill.addClass('is-dragging'); // _this.$element.data('dragging', true); curHandle = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(e.currentTarget); $body.on('mousemove.zf.slider', function (e) { e.preventDefault(); _this._handleEvent(e, curHandle); }).on('mouseup.zf.slider', function (e) { _this._handleEvent(e, curHandle); $handle.removeClass('is-dragging'); _this.$fill.removeClass('is-dragging'); _this.$element.data('dragging', false); $body.off('mousemove.zf.slider mouseup.zf.slider'); }); }) // prevent events triggered by touch .on('selectstart.zf.slider touchmove.zf.slider', function (e) { e.preventDefault(); }); } $handle.off('keydown.zf.slider').on('keydown.zf.slider', function (e) { var _$handle = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), idx = _this.options.doubleSided ? _this.handles.index(_$handle) : 0, oldValue = parseFloat(_this.inputs.eq(idx).val()), newValue; // handle keyboard event with keyboard util __WEBPACK_IMPORTED_MODULE_1__foundation_util_keyboard__["Keyboard"].handleKey(e, 'Slider', { decrease: function () { newValue = oldValue - _this.options.step; }, increase: function () { newValue = oldValue + _this.options.step; }, decrease_fast: function () { newValue = oldValue - _this.options.step * 10; }, increase_fast: function () { newValue = oldValue + _this.options.step * 10; }, min: function () { newValue = _this.options.start; }, max: function () { newValue = _this.options.end; }, handled: function () { // only set handle pos when event was handled specially e.preventDefault(); _this._setHandlePos(_$handle, newValue, true); } }); /*if (newValue) { // if pressed key has special function, update value e.preventDefault(); _this._setHandlePos(_$handle, newValue); }*/ }); } /** * Destroys the slider plugin. */ }, { key: '_destroy', value: function _destroy() { this.handles.off('.zf.slider'); this.inputs.off('.zf.slider'); this.$element.off('.zf.slider'); clearTimeout(this.timeout); } }]); return Slider; }(__WEBPACK_IMPORTED_MODULE_4__foundation_plugin__["Plugin"]); Slider.defaults = { /** * Minimum value for the slider scale. * @option * @type {number} * @default 0 */ start: 0, /** * Maximum value for the slider scale. * @option * @type {number} * @default 100 */ end: 100, /** * Minimum value change per change event. * @option * @type {number} * @default 1 */ step: 1, /** * Value at which the handle/input *(left handle/first input)* should be set to on initialization. * @option * @type {number} * @default 0 */ initialStart: 0, /** * Value at which the right handle/second input should be set to on initialization. * @option * @type {number} * @default 100 */ initialEnd: 100, /** * Allows the input to be located outside the container and visible. Set to by the JS * @option * @type {boolean} * @default false */ binding: false, /** * Allows the user to click/tap on the slider bar to select a value. * @option * @type {boolean} * @default true */ clickSelect: true, /** * Set to true and use the `vertical` class to change alignment to vertical. * @option * @type {boolean} * @default false */ vertical: false, /** * Allows the user to drag the slider handle(s) to select a value. * @option * @type {boolean} * @default true */ draggable: true, /** * Disables the slider and prevents event listeners from being applied. Double checked by JS with `disabledClass`. * @option * @type {boolean} * @default false */ disabled: false, /** * Allows the use of two handles. Double checked by the JS. Changes some logic handling. * @option * @type {boolean} * @default false */ doubleSided: false, /** * Potential future feature. */ // steps: 100, /** * Number of decimal places the plugin should go to for floating point precision. * @option * @type {number} * @default 2 */ decimal: 2, /** * Time delay for dragged elements. */ // dragDelay: 0, /** * Time, in ms, to animate the movement of a slider handle if user clicks/taps on the bar. Needs to be manually set if updating the transition time in the Sass settings. * @option * @type {number} * @default 200 */ moveTime: 200, //update this if changing the transition time in the sass /** * Class applied to disabled sliders. * @option * @type {string} * @default 'disabled' */ disabledClass: 'disabled', /** * Will invert the default layout for a vertical slider. * @option * @type {boolean} * @default false */ invertVertical: false, /** * Milliseconds before the `changed.zf-slider` event is triggered after value change. * @option * @type {number} * @default 500 */ changedDelay: 500, /** * Basevalue for non-linear sliders * @option * @type {number} * @default 5 */ nonLinearBase: 5, /** * Basevalue for non-linear sliders, possible values are: `'linear'`, `'pow'` & `'log'`. Pow and Log use the nonLinearBase setting. * @option * @type {string} * @default 'linear' */ positionValueFunction: 'linear' }; function percent(frac, num) { return frac / num; } function absPosition($handle, dir, clickPos, param) { return Math.abs($handle.position()[dir] + $handle[param]() / 2 - clickPos); } function baseLog(base, value) { return Math.log(value) / Math.log(base); } /***/ }), /***/ 7: /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Triggers; }); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery__ = __webpack_require__(0); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery__); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__ = __webpack_require__(4); /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__); var MutationObserver = function () { var prefixes = ['WebKit', 'Moz', 'O', 'Ms', '']; for (var i = 0; i < prefixes.length; i++) { if (prefixes[i] + 'MutationObserver' in window) { return window[prefixes[i] + 'MutationObserver']; } } return false; }(); var triggers = function (el, type) { el.data(type).split(' ').forEach(function (id) { __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + id)[type === 'close' ? 'trigger' : 'triggerHandler'](type + '.zf.trigger', [el]); }); }; var Triggers = { Listeners: { Basic: {}, Global: {} }, Initializers: {} }; Triggers.Listeners.Basic = { openListener: function () { triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'open'); }, closeListener: function () { var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('close'); if (id) { triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'close'); } else { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('close.zf.trigger'); } }, toggleListener: function () { var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('toggle'); if (id) { triggers(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), 'toggle'); } else { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('toggle.zf.trigger'); } }, closeableListener: function (e) { e.stopPropagation(); var animation = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('closable'); if (animation !== '') { __WEBPACK_IMPORTED_MODULE_1__foundation_util_motion__["Motion"].animateOut(__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this), animation, function () { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).trigger('closed.zf'); }); } else { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).fadeOut().trigger('closed.zf'); } }, toggleFocusListener: function () { var id = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).data('toggle-focus'); __WEBPACK_IMPORTED_MODULE_0_jquery___default()('#' + id).triggerHandler('toggle.zf.trigger', [__WEBPACK_IMPORTED_MODULE_0_jquery___default()(this)]); } }; // Elements with [data-open] will reveal a plugin that supports it when clicked. Triggers.Initializers.addOpenListener = function ($elem) { $elem.off('click.zf.trigger', Triggers.Listeners.Basic.openListener); $elem.on('click.zf.trigger', '[data-open]', Triggers.Listeners.Basic.openListener); }; // Elements with [data-close] will close a plugin that supports it when clicked. // If used without a value on [data-close], the event will bubble, allowing it to close a parent component. Triggers.Initializers.addCloseListener = function ($elem) { $elem.off('click.zf.trigger', Triggers.Listeners.Basic.closeListener); $elem.on('click.zf.trigger', '[data-close]', Triggers.Listeners.Basic.closeListener); }; // Elements with [data-toggle] will toggle a plugin that supports it when clicked. Triggers.Initializers.addToggleListener = function ($elem) { $elem.off('click.zf.trigger', Triggers.Listeners.Basic.toggleListener); $elem.on('click.zf.trigger', '[data-toggle]', Triggers.Listeners.Basic.toggleListener); }; // Elements with [data-closable] will respond to close.zf.trigger events. Triggers.Initializers.addCloseableListener = function ($elem) { $elem.off('close.zf.trigger', Triggers.Listeners.Basic.closeableListener); $elem.on('close.zf.trigger', '[data-closeable], [data-closable]', Triggers.Listeners.Basic.closeableListener); }; // Elements with [data-toggle-focus] will respond to coming in and out of focus Triggers.Initializers.addToggleFocusListener = function ($elem) { $elem.off('focus.zf.trigger blur.zf.trigger', Triggers.Listeners.Basic.toggleFocusListener); $elem.on('focus.zf.trigger blur.zf.trigger', '[data-toggle-focus]', Triggers.Listeners.Basic.toggleFocusListener); }; // More Global/complex listeners and triggers Triggers.Listeners.Global = { resizeListener: function ($nodes) { if (!MutationObserver) { //fallback for IE 9 $nodes.each(function () { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).triggerHandler('resizeme.zf.trigger'); }); } //trigger all listening elements and signal a resize event $nodes.attr('data-events', "resize"); }, scrollListener: function ($nodes) { if (!MutationObserver) { //fallback for IE 9 $nodes.each(function () { __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this).triggerHandler('scrollme.zf.trigger'); }); } //trigger all listening elements and signal a scroll event $nodes.attr('data-events', "scroll"); }, closeMeListener: function (e, pluginId) { var plugin = e.namespace.split('.')[0]; var plugins = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-' + plugin + ']').not('[data-yeti-box="' + pluginId + '"]'); plugins.each(function () { var _this = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(this); _this.triggerHandler('close.zf.trigger', [_this]); }); } // Global, parses whole document. };Triggers.Initializers.addClosemeListener = function (pluginName) { var yetiBoxes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-yeti-box]'), plugNames = ['dropdown', 'tooltip', 'reveal']; if (pluginName) { if (typeof pluginName === 'string') { plugNames.push(pluginName); } else if (typeof pluginName === 'object' && typeof pluginName[0] === 'string') { plugNames.concat(pluginName); } else { console.error('Plugin names must be strings'); } } if (yetiBoxes.length) { var listeners = plugNames.map(function (name) { return 'closeme.zf.' + name; }).join(' '); __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off(listeners).on(listeners, Triggers.Listeners.Global.closeMeListener); } }; function debounceGlobalListener(debounce, trigger, listener) { var timer = void 0, args = Array.prototype.slice.call(arguments, 3); __WEBPACK_IMPORTED_MODULE_0_jquery___default()(window).off(trigger).on(trigger, function (e) { if (timer) { clearTimeout(timer); } timer = setTimeout(function () { listener.apply(null, args); }, debounce || 10); //default time to emit scroll event }); } Triggers.Initializers.addResizeListener = function (debounce) { var $nodes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-resize]'); if ($nodes.length) { debounceGlobalListener(debounce, 'resize.zf.trigger', Triggers.Listeners.Global.resizeListener, $nodes); } }; Triggers.Initializers.addScrollListener = function (debounce) { var $nodes = __WEBPACK_IMPORTED_MODULE_0_jquery___default()('[data-scroll]'); if ($nodes.length) { debounceGlobalListener(debounce, 'scroll.zf.trigger', Triggers.Listeners.Global.scrollListener, $nodes); } }; Triggers.Initializers.addMutationEventsListener = function ($elem) { if (!MutationObserver) { return false; } var $nodes = $elem.find('[data-resize], [data-scroll], [data-mutate]'); //element callback var listeningElementsMutation = function (mutationRecordsList) { var $target = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(mutationRecordsList[0].target); //trigger the event handler for the element depending on type switch (mutationRecordsList[0].type) { case "attributes": if ($target.attr("data-events") === "scroll" && mutationRecordsList[0].attributeName === "data-events") { $target.triggerHandler('scrollme.zf.trigger', [$target, window.pageYOffset]); } if ($target.attr("data-events") === "resize" && mutationRecordsList[0].attributeName === "data-events") { $target.triggerHandler('resizeme.zf.trigger', [$target]); } if (mutationRecordsList[0].attributeName === "style") { $target.closest("[data-mutate]").attr("data-events", "mutate"); $target.closest("[data-mutate]").triggerHandler('mutateme.zf.trigger', [$target.closest("[data-mutate]")]); } break; case "childList": $target.closest("[data-mutate]").attr("data-events", "mutate"); $target.closest("[data-mutate]").triggerHandler('mutateme.zf.trigger', [$target.closest("[data-mutate]")]); break; default: return false; //nothing } }; if ($nodes.length) { //for each element that needs to listen for resizing, scrolling, or mutation add a single observer for (var i = 0; i <= $nodes.length - 1; i++) { var elementObserver = new MutationObserver(listeningElementsMutation); elementObserver.observe($nodes[i], { attributes: true, childList: true, characterData: false, subtree: true, attributeFilter: ["data-events", "style"] }); } } }; Triggers.Initializers.addSimpleListeners = function () { var $document = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(document); Triggers.Initializers.addOpenListener($document); Triggers.Initializers.addCloseListener($document); Triggers.Initializers.addToggleListener($document); Triggers.Initializers.addCloseableListener($document); Triggers.Initializers.addToggleFocusListener($document); }; Triggers.Initializers.addGlobalListeners = function () { var $document = __WEBPACK_IMPORTED_MODULE_0_jquery___default()(document); Triggers.Initializers.addMutationEventsListener($document); Triggers.Initializers.addResizeListener(); Triggers.Initializers.addScrollListener(); Triggers.Initializers.addClosemeListener(); }; Triggers.init = function ($, Foundation) { if (typeof $.triggersInitialized === 'undefined') { var $document = $(document); if (document.readyState === "complete") { Triggers.Initializers.addSimpleListeners(); Triggers.Initializers.addGlobalListeners(); } else { $(window).on('load', function () { Triggers.Initializers.addSimpleListeners(); Triggers.Initializers.addGlobalListeners(); }); } $.triggersInitialized = true; } if (Foundation) { Foundation.Triggers = Triggers; // Legacy included to be backwards compatible for now. Foundation.IHearYou = Triggers.Initializers.addGlobalListeners; } }; /***/ }), /***/ 94: /***/ (function(module, exports, __webpack_require__) { module.exports = __webpack_require__(28); /***/ }) /******/ });