",
options: {
classes: {},
disabled: false,
// Callbacks
create: null
},
_createWidget: function _createWidget(options, element) {
element = $(element || this.defaultElement || this)[0];
this.element = $(element);
this.uuid = widgetUuid++;
this.eventNamespace = "." + this.widgetName + this.uuid;
this.bindings = $();
this.hoverable = $();
this.focusable = $();
this.classesElementLookup = {};
if (element !== this) {
$.data(element, this.widgetFullName, this);
this._on(true, this.element, {
remove: function remove(event) {
if (event.target === element) {
this.destroy();
}
}
});
this.document = $(element.style ?
// Element within the document
element.ownerDocument :
// Element is window or document
element.document || element);
this.window = $(this.document[0].defaultView || this.document[0].parentWindow);
}
this.options = $.widget.extend({}, this.options, this._getCreateOptions(), options);
this._create();
if (this.options.disabled) {
this._setOptionDisabled(this.options.disabled);
}
this._trigger("create", null, this._getCreateEventData());
this._init();
},
_getCreateOptions: function _getCreateOptions() {
return {};
},
_getCreateEventData: $.noop,
_create: $.noop,
_init: $.noop,
destroy: function destroy() {
var that = this;
this._destroy();
$.each(this.classesElementLookup, function (key, value) {
that._removeClass(value, key);
});
// We can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element.off(this.eventNamespace).removeData(this.widgetFullName);
this.widget().off(this.eventNamespace).removeAttr("aria-disabled");
// Clean up events and states
this.bindings.off(this.eventNamespace);
},
_destroy: $.noop,
widget: function widget() {
return this.element;
},
option: function option(key, value) {
var options = key;
var parts;
var curOption;
var i;
if (arguments.length === 0) {
// Don't return a reference to the internal hash
return $.widget.extend({}, this.options);
}
if (typeof key === "string") {
// Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
parts = key.split(".");
key = parts.shift();
if (parts.length) {
curOption = options[key] = $.widget.extend({}, this.options[key]);
for (i = 0; i < parts.length - 1; i++) {
curOption[parts[i]] = curOption[parts[i]] || {};
curOption = curOption[parts[i]];
}
key = parts.pop();
if (arguments.length === 1) {
return curOption[key] === undefined ? null : curOption[key];
}
curOption[key] = value;
} else {
if (arguments.length === 1) {
return this.options[key] === undefined ? null : this.options[key];
}
options[key] = value;
}
}
this._setOptions(options);
return this;
},
_setOptions: function _setOptions(options) {
var key;
for (key in options) {
this._setOption(key, options[key]);
}
return this;
},
_setOption: function _setOption(key, value) {
if (key === "classes") {
this._setOptionClasses(value);
}
this.options[key] = value;
if (key === "disabled") {
this._setOptionDisabled(value);
}
return this;
},
_setOptionClasses: function _setOptionClasses(value) {
var classKey, elements, currentElements;
for (classKey in value) {
currentElements = this.classesElementLookup[classKey];
if (value[classKey] === this.options.classes[classKey] || !currentElements || !currentElements.length) {
continue;
}
// We are doing this to create a new jQuery object because the _removeClass() call
// on the next line is going to destroy the reference to the current elements being
// tracked. We need to save a copy of this collection so that we can add the new classes
// below.
elements = $(currentElements.get());
this._removeClass(currentElements, classKey);
// We don't use _addClass() here, because that uses this.options.classes
// for generating the string of classes. We want to use the value passed in from
// _setOption(), this is the new value of the classes option which was passed to
// _setOption(). We pass this value directly to _classes().
elements.addClass(this._classes({
element: elements,
keys: classKey,
classes: value,
add: true
}));
}
},
_setOptionDisabled: function _setOptionDisabled(value) {
this._toggleClass(this.widget(), this.widgetFullName + "-disabled", null, !!value);
// If the widget is becoming disabled, then nothing is interactive
if (value) {
this._removeClass(this.hoverable, null, "ui-state-hover");
this._removeClass(this.focusable, null, "ui-state-focus");
}
},
enable: function enable() {
return this._setOptions({ disabled: false });
},
disable: function disable() {
return this._setOptions({ disabled: true });
},
_classes: function _classes(options) {
var full = [];
var that = this;
options = $.extend({
element: this.element,
classes: this.options.classes || {}
}, options);
function processClassString(classes, checkOption) {
var current, i;
for (i = 0; i < classes.length; i++) {
current = that.classesElementLookup[classes[i]] || $();
if (options.add) {
current = $($.unique(current.get().concat(options.element.get())));
} else {
current = $(current.not(options.element).get());
}
that.classesElementLookup[classes[i]] = current;
full.push(classes[i]);
if (checkOption && options.classes[classes[i]]) {
full.push(options.classes[classes[i]]);
}
}
}
this._on(options.element, {
"remove": "_untrackClassesElement"
});
if (options.keys) {
processClassString(options.keys.match(/\S+/g) || [], true);
}
if (options.extra) {
processClassString(options.extra.match(/\S+/g) || []);
}
return full.join(" ");
},
_untrackClassesElement: function _untrackClassesElement(event) {
var that = this;
$.each(that.classesElementLookup, function (key, value) {
if ($.inArray(event.target, value) !== -1) {
that.classesElementLookup[key] = $(value.not(event.target).get());
}
});
},
_removeClass: function _removeClass(element, keys, extra) {
return this._toggleClass(element, keys, extra, false);
},
_addClass: function _addClass(element, keys, extra) {
return this._toggleClass(element, keys, extra, true);
},
_toggleClass: function _toggleClass(element, keys, extra, add) {
add = typeof add === "boolean" ? add : extra;
var shift = typeof element === "string" || element === null,
options = {
extra: shift ? keys : extra,
keys: shift ? element : keys,
element: shift ? this.element : element,
add: add
};
options.element.toggleClass(this._classes(options), add);
return this;
},
_on: function _on(suppressDisabledCheck, element, handlers) {
var delegateElement;
var instance = this;
// No suppressDisabledCheck flag, shuffle arguments
if (typeof suppressDisabledCheck !== "boolean") {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// No element argument, shuffle and use this.element
if (!handlers) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
element = delegateElement = $(element);
this.bindings = this.bindings.add(element);
}
$.each(handlers, function (event, handler) {
function handlerProxy() {
// Allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if (!suppressDisabledCheck && (instance.options.disabled === true || $(this).hasClass("ui-state-disabled"))) {
return;
}
return (typeof handler === "string" ? instance[handler] : handler).apply(instance, arguments);
}
// Copy the guid so direct unbinding works
if (typeof handler !== "string") {
handlerProxy.guid = handler.guid = handler.guid || handlerProxy.guid || $.guid++;
}
var match = event.match(/^([\w:-]*)\s*(.*)$/);
var eventName = match[1] + instance.eventNamespace;
var selector = match[2];
if (selector) {
delegateElement.on(eventName, selector, handlerProxy);
} else {
element.on(eventName, handlerProxy);
}
});
},
_off: function _off(element, eventName) {
eventName = (eventName || "").split(" ").join(this.eventNamespace + " ") + this.eventNamespace;
element.off(eventName).off(eventName);
// Clear the stack to avoid memory leaks (#10056)
this.bindings = $(this.bindings.not(element).get());
this.focusable = $(this.focusable.not(element).get());
this.hoverable = $(this.hoverable.not(element).get());
},
_delay: function _delay(handler, delay) {
function handlerProxy() {
return (typeof handler === "string" ? instance[handler] : handler).apply(instance, arguments);
}
var instance = this;
return setTimeout(handlerProxy, delay || 0);
},
_hoverable: function _hoverable(element) {
this.hoverable = this.hoverable.add(element);
this._on(element, {
mouseenter: function mouseenter(event) {
this._addClass($(event.currentTarget), null, "ui-state-hover");
},
mouseleave: function mouseleave(event) {
this._removeClass($(event.currentTarget), null, "ui-state-hover");
}
});
},
_focusable: function _focusable(element) {
this.focusable = this.focusable.add(element);
this._on(element, {
focusin: function focusin(event) {
this._addClass($(event.currentTarget), null, "ui-state-focus");
},
focusout: function focusout(event) {
this._removeClass($(event.currentTarget), null, "ui-state-focus");
}
});
},
_trigger: function _trigger(type, event, data) {
var prop, orig;
var callback = this.options[type];
data = data || {};
event = $.Event(event);
event.type = (type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type).toLowerCase();
// The original event may come from any element
// so we need to reset the target on the new event
event.target = this.element[0];
// Copy original event properties over to the new event
orig = event.originalEvent;
if (orig) {
for (prop in orig) {
if (!(prop in event)) {
event[prop] = orig[prop];
}
}
}
this.element.trigger(event, data);
return !($.isFunction(callback) && callback.apply(this.element[0], [event].concat(data)) === false || event.isDefaultPrevented());
}
};
$.each({ show: "fadeIn", hide: "fadeOut" }, function (method, defaultEffect) {
$.Widget.prototype["_" + method] = function (element, options, callback) {
if (typeof options === "string") {
options = { effect: options };
}
var hasOptions;
var effectName = !options ? method : options === true || typeof options === "number" ? defaultEffect : options.effect || defaultEffect;
options = options || {};
if (typeof options === "number") {
options = { duration: options };
}
hasOptions = !$.isEmptyObject(options);
options.complete = callback;
if (options.delay) {
element.delay(options.delay);
}
if (hasOptions && $.effects && $.effects.effect[effectName]) {
element[method](options);
} else if (effectName !== method && element[effectName]) {
element[effectName](options.duration, options.easing, callback);
} else {
element.queue(function (next) {
$(this)[method]();
if (callback) {
callback.call(element[0]);
}
next();
});
}
};
});
var widget = $.widget;
/*!
* jQuery UI Keycode 1.12.1
* http://jqueryui.com
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*/
//>>label: Keycode
//>>group: Core
//>>description: Provide keycodes as keynames
//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
var keycode = $.ui.keyCode = {
BACKSPACE: 8,
COMMA: 188,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
PERIOD: 190,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38
};
// This file is deprecated
var ie = $.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase());
/*!
* jQuery UI Mouse 1.12.1
* http://jqueryui.com
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*/
//>>label: Mouse
//>>group: Widgets
//>>description: Abstracts mouse-based interactions to assist in creating certain widgets.
//>>docs: http://api.jqueryui.com/mouse/
var mouseHandled = false;
$(document).on("mouseup", function () {
mouseHandled = false;
});
var widgetsMouse = $.widget("ui.mouse", {
version: "1.12.1",
options: {
cancel: "input, textarea, button, select, option",
distance: 1,
delay: 0
},
_mouseInit: function _mouseInit() {
var that = this;
this.element.on("mousedown." + this.widgetName, function (event) {
return that._mouseDown(event);
}).on("click." + this.widgetName, function (event) {
if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
$.removeData(event.target, that.widgetName + ".preventClickEvent");
event.stopImmediatePropagation();
return false;
}
});
this.started = false;
},
// TODO: make sure destroying one instance of mouse doesn't mess with
// other instances of mouse
_mouseDestroy: function _mouseDestroy() {
this.element.off("." + this.widgetName);
if (this._mouseMoveDelegate) {
this.document.off("mousemove." + this.widgetName, this._mouseMoveDelegate).off("mouseup." + this.widgetName, this._mouseUpDelegate);
}
},
_mouseDown: function _mouseDown(event) {
// don't let more than one widget handle mouseStart
if (mouseHandled) {
return;
}
this._mouseMoved = false;
// We may have missed mouseup (out of window)
this._mouseStarted && this._mouseUp(event);
this._mouseDownEvent = event;
var that = this,
btnIsLeft = event.which === 1,
// event.target.nodeName works around a bug in IE 8 with
// disabled inputs (#7620)
elIsCancel = typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false;
if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
return true;
}
this.mouseDelayMet = !this.options.delay;
if (!this.mouseDelayMet) {
this._mouseDelayTimer = setTimeout(function () {
that.mouseDelayMet = true;
}, this.options.delay);
}
if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
this._mouseStarted = this._mouseStart(event) !== false;
if (!this._mouseStarted) {
event.preventDefault();
return true;
}
}
// Click event may never have fired (Gecko & Opera)
if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
$.removeData(event.target, this.widgetName + ".preventClickEvent");
}
// These delegates are required to keep context
this._mouseMoveDelegate = function (event) {
return that._mouseMove(event);
};
this._mouseUpDelegate = function (event) {
return that._mouseUp(event);
};
this.document.on("mousemove." + this.widgetName, this._mouseMoveDelegate).on("mouseup." + this.widgetName, this._mouseUpDelegate);
event.preventDefault();
mouseHandled = true;
return true;
},
_mouseMove: function _mouseMove(event) {
// Only check for mouseups outside the document if you've moved inside the document
// at least once. This prevents the firing of mouseup in the case of IE<9, which will
// fire a mousemove event if content is placed under the cursor. See #7778
// Support: IE <9
if (this._mouseMoved) {
// IE mouseup check - mouseup happened when mouse was out of window
if ($.ui.ie && (!document.documentMode || document.documentMode < 9) && !event.button) {
return this._mouseUp(event);
// Iframe mouseup check - mouseup occurred in another document
} else if (!event.which) {
// Support: Safari <=8 - 9
// Safari sets which to 0 if you press any of the following keys
// during a drag (#14461)
if (event.originalEvent.altKey || event.originalEvent.ctrlKey || event.originalEvent.metaKey || event.originalEvent.shiftKey) {
this.ignoreMissingWhich = true;
} else if (!this.ignoreMissingWhich) {
return this._mouseUp(event);
}
}
}
if (event.which || event.button) {
this._mouseMoved = true;
}
if (this._mouseStarted) {
this._mouseDrag(event);
return event.preventDefault();
}
if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
this._mouseStarted = this._mouseStart(this._mouseDownEvent, event) !== false;
this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event);
}
return !this._mouseStarted;
},
_mouseUp: function _mouseUp(event) {
this.document.off("mousemove." + this.widgetName, this._mouseMoveDelegate).off("mouseup." + this.widgetName, this._mouseUpDelegate);
if (this._mouseStarted) {
this._mouseStarted = false;
if (event.target === this._mouseDownEvent.target) {
$.data(event.target, this.widgetName + ".preventClickEvent", true);
}
this._mouseStop(event);
}
if (this._mouseDelayTimer) {
clearTimeout(this._mouseDelayTimer);
delete this._mouseDelayTimer;
}
this.ignoreMissingWhich = false;
mouseHandled = false;
event.preventDefault();
},
_mouseDistanceMet: function _mouseDistanceMet(event) {
return Math.max(Math.abs(this._mouseDownEvent.pageX - event.pageX), Math.abs(this._mouseDownEvent.pageY - event.pageY)) >= this.options.distance;
},
_mouseDelayMet: function _mouseDelayMet() /* event */{
return this.mouseDelayMet;
},
// These are placeholder methods, to be overriden by extending plugin
_mouseStart: function _mouseStart() /* event */{},
_mouseDrag: function _mouseDrag() /* event */{},
_mouseStop: function _mouseStop() /* event */{},
_mouseCapture: function _mouseCapture() /* event */{
return true;
}
});
/*!
* jQuery UI Slider 1.12.1
* http://jqueryui.com
*
* Copyright jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*/
//>>label: Slider
//>>group: Widgets
//>>description: Displays a flexible slider with ranges and accessibility via keyboard.
//>>docs: http://api.jqueryui.com/slider/
//>>demos: http://jqueryui.com/slider/
//>>css.structure: ../../themes/base/core.css
//>>css.structure: ../../themes/base/slider.css
//>>css.theme: ../../themes/base/theme.css
var widgetsSlider = $.widget("ui.slider", $.ui.mouse, {
version: "1.12.1",
widgetEventPrefix: "slide",
options: {
animate: false,
classes: {
"ui-slider": "ui-corner-all",
"ui-slider-handle": "ui-corner-all",
// Note: ui-widget-header isn't the most fittingly semantic framework class for this
// element, but worked best visually with a variety of themes
"ui-slider-range": "ui-corner-all ui-widget-header"
},
distance: 0,
max: 100,
min: 0,
orientation: "horizontal",
range: false,
step: 1,
value: 0,
values: null,
// Callbacks
change: null,
slide: null,
start: null,
stop: null
},
// Number of pages in a slider
// (how many times can you page up/down to go through the whole range)
numPages: 5,
_create: function _create() {
this._keySliding = false;
this._mouseSliding = false;
this._animateOff = true;
this._handleIndex = null;
this._detectOrientation();
this._mouseInit();
this._calculateNewMax();
this._addClass("ui-slider ui-slider-" + this.orientation, "ui-widget ui-widget-content");
this._refresh();
this._animateOff = false;
},
_refresh: function _refresh() {
this._createRange();
this._createHandles();
this._setupEvents();
this._refreshValue();
},
_createHandles: function _createHandles() {
var i,
handleCount,
options = this.options,
existingHandles = this.element.find(".ui-slider-handle"),
handle = "
",
handles = [];
handleCount = options.values && options.values.length || 1;
if (existingHandles.length > handleCount) {
existingHandles.slice(handleCount).remove();
existingHandles = existingHandles.slice(0, handleCount);
}
for (i = existingHandles.length; i < handleCount; i++) {
handles.push(handle);
}
this.handles = existingHandles.add($(handles.join("")).appendTo(this.element));
this._addClass(this.handles, "ui-slider-handle", "ui-state-default");
this.handle = this.handles.eq(0);
this.handles.each(function (i) {
$(this).data("ui-slider-handle-index", i).attr("tabIndex", 0);
});
},
_createRange: function _createRange() {
var options = this.options;
if (options.range) {
if (options.range === true) {
if (!options.values) {
options.values = [this._valueMin(), this._valueMin()];
} else if (options.values.length && options.values.length !== 2) {
options.values = [options.values[0], options.values[0]];
} else if ($.isArray(options.values)) {
options.values = options.values.slice(0);
}
}
if (!this.range || !this.range.length) {
this.range = $("
").appendTo(this.element);
this._addClass(this.range, "ui-slider-range");
} else {
this._removeClass(this.range, "ui-slider-range-min ui-slider-range-max");
// Handle range switching from true to min/max
this.range.css({
"left": "",
"bottom": ""
});
}
if (options.range === "min" || options.range === "max") {
this._addClass(this.range, "ui-slider-range-" + options.range);
}
} else {
if (this.range) {
this.range.remove();
}
this.range = null;
}
},
_setupEvents: function _setupEvents() {
this._off(this.handles);
this._on(this.handles, this._handleEvents);
this._hoverable(this.handles);
this._focusable(this.handles);
},
_destroy: function _destroy() {
this.handles.remove();
if (this.range) {
this.range.remove();
}
this._mouseDestroy();
},
_mouseCapture: function _mouseCapture(event) {
var position,
normValue,
distance,
closestHandle,
index,
allowed,
offset,
mouseOverHandle,
that = this,
o = this.options;
if (o.disabled) {
return false;
}
this.elementSize = {
width: this.element.outerWidth(),
height: this.element.outerHeight()
};
this.elementOffset = this.element.offset();
position = { x: event.pageX, y: event.pageY };
normValue = this._normValueFromMouse(position);
distance = this._valueMax() - this._valueMin() + 1;
this.handles.each(function (i) {
var thisDistance = Math.abs(normValue - that.values(i));
if (distance > thisDistance || distance === thisDistance && (i === that._lastChangedValue || that.values(i) === o.min)) {
distance = thisDistance;
closestHandle = $(this);
index = i;
}
});
allowed = this._start(event, index);
if (allowed === false) {
return false;
}
this._mouseSliding = true;
this._handleIndex = index;
this._addClass(closestHandle, null, "ui-state-active");
closestHandle.trigger("focus");
offset = closestHandle.offset();
mouseOverHandle = !$(event.target).parents().addBack().is(".ui-slider-handle");
this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
left: event.pageX - offset.left - closestHandle.width() / 2,
top: event.pageY - offset.top - closestHandle.height() / 2 - (parseInt(closestHandle.css("borderTopWidth"), 10) || 0) - (parseInt(closestHandle.css("borderBottomWidth"), 10) || 0) + (parseInt(closestHandle.css("marginTop"), 10) || 0)
};
if (!this.handles.hasClass("ui-state-hover")) {
this._slide(event, index, normValue);
}
this._animateOff = true;
return true;
},
_mouseStart: function _mouseStart() {
return true;
},
_mouseDrag: function _mouseDrag(event) {
var position = { x: event.pageX, y: event.pageY },
normValue = this._normValueFromMouse(position);
this._slide(event, this._handleIndex, normValue);
return false;
},
_mouseStop: function _mouseStop(event) {
this._removeClass(this.handles, null, "ui-state-active");
this._mouseSliding = false;
this._stop(event, this._handleIndex);
this._change(event, this._handleIndex);
this._handleIndex = null;
this._clickOffset = null;
this._animateOff = false;
return false;
},
_detectOrientation: function _detectOrientation() {
this.orientation = this.options.orientation === "vertical" ? "vertical" : "horizontal";
},
_normValueFromMouse: function _normValueFromMouse(position) {
var pixelTotal, pixelMouse, percentMouse, valueTotal, valueMouse;
if (this.orientation === "horizontal") {
pixelTotal = this.elementSize.width;
pixelMouse = position.x - this.elementOffset.left - (this._clickOffset ? this._clickOffset.left : 0);
} else {
pixelTotal = this.elementSize.height;
pixelMouse = position.y - this.elementOffset.top - (this._clickOffset ? this._clickOffset.top : 0);
}
percentMouse = pixelMouse / pixelTotal;
if (percentMouse > 1) {
percentMouse = 1;
}
if (percentMouse < 0) {
percentMouse = 0;
}
if (this.orientation === "vertical") {
percentMouse = 1 - percentMouse;
}
valueTotal = this._valueMax() - this._valueMin();
valueMouse = this._valueMin() + percentMouse * valueTotal;
return this._trimAlignValue(valueMouse);
},
_uiHash: function _uiHash(index, value, values) {
var uiHash = {
handle: this.handles[index],
handleIndex: index,
value: value !== undefined ? value : this.value()
};
if (this._hasMultipleValues()) {
uiHash.value = value !== undefined ? value : this.values(index);
uiHash.values = values || this.values();
}
return uiHash;
},
_hasMultipleValues: function _hasMultipleValues() {
return this.options.values && this.options.values.length;
},
_start: function _start(event, index) {
return this._trigger("start", event, this._uiHash(index));
},
_slide: function _slide(event, index, newVal) {
var allowed,
otherVal,
currentValue = this.value(),
newValues = this.values();
if (this._hasMultipleValues()) {
otherVal = this.values(index ? 0 : 1);
currentValue = this.values(index);
if (this.options.values.length === 2 && this.options.range === true) {
newVal = index === 0 ? Math.min(otherVal, newVal) : Math.max(otherVal, newVal);
}
newValues[index] = newVal;
}
if (newVal === currentValue) {
return;
}
allowed = this._trigger("slide", event, this._uiHash(index, newVal, newValues));
// A slide can be canceled by returning false from the slide callback
if (allowed === false) {
return;
}
if (this._hasMultipleValues()) {
this.values(index, newVal);
} else {
this.value(newVal);
}
},
_stop: function _stop(event, index) {
this._trigger("stop", event, this._uiHash(index));
},
_change: function _change(event, index) {
if (!this._keySliding && !this._mouseSliding) {
//store the last changed value index for reference when handles overlap
this._lastChangedValue = index;
this._trigger("change", event, this._uiHash(index));
}
},
value: function value(newValue) {
if (arguments.length) {
this.options.value = this._trimAlignValue(newValue);
this._refreshValue();
this._change(null, 0);
return;
}
return this._value();
},
values: function values(index, newValue) {
var vals, newValues, i;
if (arguments.length > 1) {
this.options.values[index] = this._trimAlignValue(newValue);
this._refreshValue();
this._change(null, index);
return;
}
if (arguments.length) {
if ($.isArray(arguments[0])) {
vals = this.options.values;
newValues = arguments[0];
for (i = 0; i < vals.length; i += 1) {
vals[i] = this._trimAlignValue(newValues[i]);
this._change(null, i);
}
this._refreshValue();
} else {
if (this._hasMultipleValues()) {
return this._values(index);
} else {
return this.value();
}
}
} else {
return this._values();
}
},
_setOption: function _setOption(key, value) {
var i,
valsLength = 0;
if (key === "range" && this.options.range === true) {
if (value === "min") {
this.options.value = this._values(0);
this.options.values = null;
} else if (value === "max") {
this.options.value = this._values(this.options.values.length - 1);
this.options.values = null;
}
}
if ($.isArray(this.options.values)) {
valsLength = this.options.values.length;
}
this._super(key, value);
switch (key) {
case "orientation":
this._detectOrientation();
this._removeClass("ui-slider-horizontal ui-slider-vertical")._addClass("ui-slider-" + this.orientation);
this._refreshValue();
if (this.options.range) {
this._refreshRange(value);
}
// Reset positioning from previous orientation
this.handles.css(value === "horizontal" ? "bottom" : "left", "");
break;
case "value":
this._animateOff = true;
this._refreshValue();
this._change(null, 0);
this._animateOff = false;
break;
case "values":
this._animateOff = true;
this._refreshValue();
// Start from the last handle to prevent unreachable handles (#9046)
for (i = valsLength - 1; i >= 0; i--) {
this._change(null, i);
}
this._animateOff = false;
break;
case "step":
case "min":
case "max":
this._animateOff = true;
this._calculateNewMax();
this._refreshValue();
this._animateOff = false;
break;
case "range":
this._animateOff = true;
this._refresh();
this._animateOff = false;
break;
}
},
_setOptionDisabled: function _setOptionDisabled(value) {
this._super(value);
this._toggleClass(null, "ui-state-disabled", !!value);
},
//internal value getter
// _value() returns value trimmed by min and max, aligned by step
_value: function _value() {
var val = this.options.value;
val = this._trimAlignValue(val);
return val;
},
//internal values getter
// _values() returns array of values trimmed by min and max, aligned by step
// _values( index ) returns single value trimmed by min and max, aligned by step
_values: function _values(index) {
var val, vals, i;
if (arguments.length) {
val = this.options.values[index];
val = this._trimAlignValue(val);
return val;
} else if (this._hasMultipleValues()) {
// .slice() creates a copy of the array
// this copy gets trimmed by min and max and then returned
vals = this.options.values.slice();
for (i = 0; i < vals.length; i += 1) {
vals[i] = this._trimAlignValue(vals[i]);
}
return vals;
} else {
return [];
}
},
// Returns the step-aligned value that val is closest to, between (inclusive) min and max
_trimAlignValue: function _trimAlignValue(val) {
if (val <= this._valueMin()) {
return this._valueMin();
}
if (val >= this._valueMax()) {
return this._valueMax();
}
var step = this.options.step > 0 ? this.options.step : 1,
valModStep = (val - this._valueMin()) % step,
alignValue = val - valModStep;
if (Math.abs(valModStep) * 2 >= step) {
alignValue += valModStep > 0 ? step : -step;
}
// Since JavaScript has problems with large floats, round
// the final value to 5 digits after the decimal point (see #4124)
return parseFloat(alignValue.toFixed(5));
},
_calculateNewMax: function _calculateNewMax() {
var max = this.options.max,
min = this._valueMin(),
step = this.options.step,
aboveMin = Math.round((max - min) / step) * step;
max = aboveMin + min;
if (max > this.options.max) {
//If max is not divisible by step, rounding off may increase its value
max -= step;
}
this.max = parseFloat(max.toFixed(this._precision()));
},
_precision: function _precision() {
var precision = this._precisionOf(this.options.step);
if (this.options.min !== null) {
precision = Math.max(precision, this._precisionOf(this.options.min));
}
return precision;
},
_precisionOf: function _precisionOf(num) {
var str = num.toString(),
decimal = str.indexOf(".");
return decimal === -1 ? 0 : str.length - decimal - 1;
},
_valueMin: function _valueMin() {
return this.options.min;
},
_valueMax: function _valueMax() {
return this.max;
},
_refreshRange: function _refreshRange(orientation) {
if (orientation === "vertical") {
this.range.css({ "width": "", "left": "" });
}
if (orientation === "horizontal") {
this.range.css({ "height": "", "bottom": "" });
}
},
_refreshValue: function _refreshValue() {
var lastValPercent,
valPercent,
value,
valueMin,
valueMax,
oRange = this.options.range,
o = this.options,
that = this,
animate = !this._animateOff ? o.animate : false,
_set = {};
if (this._hasMultipleValues()) {
this.handles.each(function (i) {
valPercent = (that.values(i) - that._valueMin()) / (that._valueMax() - that._valueMin()) * 100;
_set[that.orientation === "horizontal" ? "left" : "bottom"] = valPercent + "%";
$(this).stop(1, 1)[animate ? "animate" : "css"](_set, o.animate);
if (that.options.range === true) {
if (that.orientation === "horizontal") {
if (i === 0) {
that.range.stop(1, 1)[animate ? "animate" : "css"]({
left: valPercent + "%"
}, o.animate);
}
if (i === 1) {
that.range[animate ? "animate" : "css"]({
width: valPercent - lastValPercent + "%"
}, {
queue: false,
duration: o.animate
});
}
} else {
if (i === 0) {
that.range.stop(1, 1)[animate ? "animate" : "css"]({
bottom: valPercent + "%"
}, o.animate);
}
if (i === 1) {
that.range[animate ? "animate" : "css"]({
height: valPercent - lastValPercent + "%"
}, {
queue: false,
duration: o.animate
});
}
}
}
lastValPercent = valPercent;
});
} else {
value = this.value();
valueMin = this._valueMin();
valueMax = this._valueMax();
valPercent = valueMax !== valueMin ? (value - valueMin) / (valueMax - valueMin) * 100 : 0;
_set[this.orientation === "horizontal" ? "left" : "bottom"] = valPercent + "%";
this.handle.stop(1, 1)[animate ? "animate" : "css"](_set, o.animate);
if (oRange === "min" && this.orientation === "horizontal") {
this.range.stop(1, 1)[animate ? "animate" : "css"]({
width: valPercent + "%"
}, o.animate);
}
if (oRange === "max" && this.orientation === "horizontal") {
this.range.stop(1, 1)[animate ? "animate" : "css"]({
width: 100 - valPercent + "%"
}, o.animate);
}
if (oRange === "min" && this.orientation === "vertical") {
this.range.stop(1, 1)[animate ? "animate" : "css"]({
height: valPercent + "%"
}, o.animate);
}
if (oRange === "max" && this.orientation === "vertical") {
this.range.stop(1, 1)[animate ? "animate" : "css"]({
height: 100 - valPercent + "%"
}, o.animate);
}
}
},
_handleEvents: {
keydown: function keydown(event) {
var allowed,
curVal,
newVal,
step,
index = $(event.target).data("ui-slider-handle-index");
switch (event.keyCode) {
case $.ui.keyCode.HOME:
case $.ui.keyCode.END:
case $.ui.keyCode.PAGE_UP:
case $.ui.keyCode.PAGE_DOWN:
case $.ui.keyCode.UP:
case $.ui.keyCode.RIGHT:
case $.ui.keyCode.DOWN:
case $.ui.keyCode.LEFT:
event.preventDefault();
if (!this._keySliding) {
this._keySliding = true;
this._addClass($(event.target), null, "ui-state-active");
allowed = this._start(event, index);
if (allowed === false) {
return;
}
}
break;
}
step = this.options.step;
if (this._hasMultipleValues()) {
curVal = newVal = this.values(index);
} else {
curVal = newVal = this.value();
}
switch (event.keyCode) {
case $.ui.keyCode.HOME:
newVal = this._valueMin();
break;
case $.ui.keyCode.END:
newVal = this._valueMax();
break;
case $.ui.keyCode.PAGE_UP:
newVal = this._trimAlignValue(curVal + (this._valueMax() - this._valueMin()) / this.numPages);
break;
case $.ui.keyCode.PAGE_DOWN:
newVal = this._trimAlignValue(curVal - (this._valueMax() - this._valueMin()) / this.numPages);
break;
case $.ui.keyCode.UP:
case $.ui.keyCode.RIGHT:
if (curVal === this._valueMax()) {
return;
}
newVal = this._trimAlignValue(curVal + step);
break;
case $.ui.keyCode.DOWN:
case $.ui.keyCode.LEFT:
if (curVal === this._valueMin()) {
return;
}
newVal = this._trimAlignValue(curVal - step);
break;
}
this._slide(event, index, newVal);
},
keyup: function keyup(event) {
var index = $(event.target).data("ui-slider-handle-index");
if (this._keySliding) {
this._keySliding = false;
this._stop(event, index);
this._change(event, index);
this._removeClass($(event.target), null, "ui-state-active");
}
}
}
});
});
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;
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; };
(function (global, factory) {
( false ? 'undefined' : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : true ? !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
__WEBPACK_AMD_DEFINE_FACTORY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : global.StickySidebar = factory();
})(undefined, function () {
'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");
}
}
/**
* Sticky Sidebar JavaScript Plugin.
* @version 3.2.0
* @autor ThurData
* @license The MIT License (MIT)
*/
var StickySidebar = function () {
// ---------------------------------
// # Define Constants
// ---------------------------------
//
var EVENT_KEY = '.stickySidebar';
var DEFAULTS = {
/**
* Additional top spacing of the element when it becomes sticky.
* @type {Numeric|Function}
*/
topSpacing: 0,
/**
* Additional bottom spacing of the element when it becomes sticky.
* @type {Numeric|Function}
*/
bottomSpacing: 0,
/**
* Container sidebar selector to know what the beginning and end of sticky element.
* @type {String|False}
*/
containerSelector: false,
/**
* Inner wrapper selector.
* @type {String}
*/
innerWrapperSelector: '.inner-wrapper-sticky',
/**
* The name of CSS class to apply to elements when they have become stuck.
* @type {String|False}
*/
stickyClass: 'is-affixed',
/**
* Detect when sidebar and its container change height so re-calculate their dimensions.
* @type {Boolean}
*/
resizeSensor: true,
/**
* The sidebar returns to its normal position if its width below this value.
* @type {Numeric}
*/
minWidth: false
};
// ---------------------------------
// # Class Definition
// ---------------------------------
//
/**
* Sticky Sidebar Class.
* @public
*/
var StickySidebar = function () {
/**
* Sticky Sidebar Constructor.
* @constructor
* @param {HTMLElement|String} sidebar - The sidebar element or sidebar selector.
* @param {Object} options - The options of sticky sidebar.
*/
function StickySidebar(sidebar) {
var _this = this;
var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
_classCallCheck(this, StickySidebar);
this.options = StickySidebar.extend(DEFAULTS, options);
// Sidebar element query if there's no one, throw error.
this.sidebar = 'string' === typeof sidebar ? document.querySelector(sidebar) : sidebar;
if ('undefined' === typeof this.sidebar) throw new Error("There is no specific sidebar element.");
this.sidebarInner = false;
this.container = this.sidebar.parentElement;
// Current Affix Type of sidebar element.
this.affixedType = 'STATIC';
this.direction = 'down';
this.support = {
transform: false,
transform3d: false
};
this._initialized = false;
this._breakpoint = false;
this._resizeListeners = [];
// Dimenstions of sidebar, container and screen viewport.
this.dimensions = {
translateY: 0,
topSpacing: 0,
bottomSpacing: 0,
sidebarHeight: 0,
sidebarWidth: 0,
containerTop: 0,
containerHeight: 0,
viewportHeight: 0,
viewportTop: 0,
lastViewportTop: 0
};
// Bind event handlers for referencability.
['handleEvent'].forEach(function (method) {
_this[method] = _this[method].bind(_this);
});
// Initialize sticky sidebar for first time.
this.initialize();
}
/**
* Initializes the sticky sidebar by adding inner wrapper, define its container,
* min-width breakpoint, calculating dimenstions, adding helper classes and inline style.
* @private
*/
_createClass(StickySidebar, [{
key: 'initialize',
value: function initialize() {
var _this2 = this;
this._setSupportFeatures();
// Get sticky sidebar inner wrapper, if not found, will create one.
if (this.options.innerWrapperSelector) {
this.sidebarInner = this.sidebar.querySelector(this.options.innerWrapperSelector);
if (null === this.sidebarInner) this.sidebarInner = false;
}
if (!this.sidebarInner) {
var wrapper = document.createElement('div');
wrapper.setAttribute('class', 'inner-wrapper-sticky');
this.sidebar.appendChild(wrapper);
while (this.sidebar.firstChild != wrapper) {
wrapper.appendChild(this.sidebar.firstChild);
}this.sidebarInner = this.sidebar.querySelector('.inner-wrapper-sticky');
}
// Container wrapper of the sidebar.
if (this.options.containerSelector) {
var containers = document.querySelectorAll(this.options.containerSelector);
containers = Array.prototype.slice.call(containers);
containers.forEach(function (container, item) {
if (!container.contains(_this2.sidebar)) return;
_this2.container = container;
});
if (!containers.length) throw new Error("The container does not contains on the sidebar.");
}
// If top/bottom spacing is not function parse value to integer.
if ('function' !== typeof this.options.topSpacing) this.options.topSpacing = parseInt(this.options.topSpacing) || 0;
if ('function' !== typeof this.options.bottomSpacing) this.options.bottomSpacing = parseInt(this.options.bottomSpacing) || 0;
// Breakdown sticky sidebar if screen width below `options.minWidth`.
this._widthBreakpoint();
// Calculate dimensions of sidebar, container and viewport.
this.calcDimensions();
// Affix sidebar in proper position.
this.stickyPosition();
// Bind all events.
this.bindEvents();
// Inform other properties the sticky sidebar is initialized.
this._initialized = true;
}
/**
* Bind all events of sticky sidebar plugin.
* @protected
*/
}, {
key: 'bindEvents',
value: function bindEvents() {
window.addEventListener('resize', this, { passive: true });
window.addEventListener('scroll', this, { passive: true });
this.sidebar.addEventListener('update' + EVENT_KEY, this);
if (this.options.resizeSensor && 'undefined' !== typeof ResizeSensor) {
new ResizeSensor(this.sidebarInner, this.handleEvent);
new ResizeSensor(this.container, this.handleEvent);
}
}
/**
* Handles all events of the plugin.
* @param {Object} event - Event object passed from listener.
*/
}, {
key: 'handleEvent',
value: function handleEvent(event) {
this.updateSticky(event);
}
/**
* Calculates dimesntions of sidebar, container and screen viewpoint
* @public
*/
}, {
key: 'calcDimensions',
value: function calcDimensions() {
if (this._breakpoint) return;
var dims = this.dimensions;
// Container of sticky sidebar dimensions.
dims.containerTop = StickySidebar.offsetRelative(this.container).top;
dims.containerHeight = this.container.clientHeight;
dims.containerBottom = dims.containerTop + dims.containerHeight;
// Sidebar dimensions.
dims.sidebarHeight = this.sidebarInner.offsetHeight;
dims.sidebarWidth = this.sidebar.offsetWidth;
// Screen viewport dimensions.
dims.viewportHeight = window.innerHeight;
this._calcDimensionsWithScroll();
}
/**
* Some dimensions values need to be up-to-date when scrolling the page.
* @private
*/
}, {
key: '_calcDimensionsWithScroll',
value: function _calcDimensionsWithScroll() {
var dims = this.dimensions;
dims.sidebarLeft = StickySidebar.offsetRelative(this.sidebar).left;
dims.viewportTop = document.documentElement.scrollTop || document.body.scrollTop;
dims.viewportBottom = dims.viewportTop + dims.viewportHeight;
dims.viewportLeft = document.documentElement.scrollLeft || document.body.scrollLeft;
dims.topSpacing = this.options.topSpacing;
dims.bottomSpacing = this.options.bottomSpacing;
if ('function' === typeof dims.topSpacing) dims.topSpacing = parseInt(dims.topSpacing(this.sidebar)) || 0;
if ('function' === typeof dims.bottomSpacing) dims.bottomSpacing = parseInt(dims.bottomSpacing(this.sidebar)) || 0;
}
/**
* Detarmine wheather the sidebar is bigger than viewport.
* @public
* @return {Boolean}
*/
}, {
key: 'isSidebarFitsViewport',
value: function isSidebarFitsViewport() {
return this.dimensions.sidebarHeight < this.dimensions.viewportHeight;
}
/**
* Observe browser scrolling direction top and down.
*/
}, {
key: 'observeScrollDir',
value: function observeScrollDir() {
var dims = this.dimensions;
if (dims.lastViewportTop === dims.viewportTop) return;
var furthest = 'down' === this.direction ? Math.min : Math.max;
// If the browser is scrolling not in the same direction.
if (dims.viewportTop === furthest(dims.viewportTop, dims.lastViewportTop)) this.direction = 'down' === this.direction ? 'up' : 'down';
}
/**
* Gets affix type of sidebar according to current scrollTop and scrollLeft.
* Holds all logical affix of the sidebar when scrolling up and down and when sidebar
* is bigger than viewport and vice versa.
* @public
* @return {String|False} - Proper affix type.
*/
}, {
key: 'getAffixType',
value: function getAffixType() {
var dims = this.dimensions,
affixType = false;
this._calcDimensionsWithScroll();
var sidebarBottom = dims.sidebarHeight + dims.containerTop;
var colliderTop = dims.viewportTop + dims.topSpacing;
var colliderBottom = dims.viewportBottom - dims.bottomSpacing;
// When browser is scrolling top.
if ('up' === this.direction) {
if (colliderTop <= dims.containerTop) {
dims.translateY = 0;
affixType = 'STATIC';
} else if (colliderTop <= dims.translateY + dims.containerTop) {
dims.translateY = colliderTop - dims.containerTop;
affixType = 'VIEWPORT-TOP';
} else if (!this.isSidebarFitsViewport() && dims.containerTop <= colliderTop) {
affixType = 'VIEWPORT-UNBOTTOM';
}
// When browser is scrolling up.
} else {
// When sidebar element is not bigger than screen viewport.
if (this.isSidebarFitsViewport()) {
if (dims.sidebarHeight + colliderTop >= dims.containerBottom) {
dims.translateY = dims.containerBottom - sidebarBottom;
affixType = 'CONTAINER-BOTTOM';
} else if (colliderTop >= dims.containerTop) {
dims.translateY = colliderTop - dims.containerTop;
affixType = 'VIEWPORT-TOP';
}
// When sidebar element is bigger than screen viewport.
} else {
if (dims.containerBottom <= colliderBottom) {
dims.translateY = dims.containerBottom - sidebarBottom;
affixType = 'CONTAINER-BOTTOM';
} else if (sidebarBottom + dims.translateY <= colliderBottom) {
dims.translateY = colliderBottom - sidebarBottom;
affixType = 'VIEWPORT-BOTTOM';
} else if (dims.containerTop + dims.translateY <= colliderTop) {
affixType = 'VIEWPORT-UNBOTTOM';
}
}
}
// Make sure the translate Y is not bigger than container height.
dims.translateY = Math.max(0, dims.translateY);
dims.translateY = Math.min(dims.containerHeight, dims.translateY);
dims.lastViewportTop = dims.viewportTop;
return affixType;
}
/**
* Gets inline style of sticky sidebar wrapper and inner wrapper according
* to its affix type.
* @private
* @param {String} affixType - Affix type of sticky sidebar.
* @return {Object}
*/
}, {
key: '_getStyle',
value: function _getStyle(affixType) {
if ('undefined' === typeof affixType) return;
var style = { inner: {}, outer: {} };
var dims = this.dimensions;
switch (affixType) {
case 'VIEWPORT-TOP':
style.inner = { position: 'fixed', top: this.options.topSpacing,
left: dims.sidebarLeft - dims.viewportLeft, width: dims.sidebarWidth };
break;
case 'VIEWPORT-BOTTOM':
style.inner = { position: 'fixed', top: 'auto', left: dims.sidebarLeft,
bottom: this.options.bottomSpacing, width: dims.sidebarWidth };
break;
case 'CONTAINER-BOTTOM':
case 'VIEWPORT-UNBOTTOM':
var translate = this._getTranslate(0, dims.translateY + 'px');
if (translate) style.inner = { transform: translate };else style.inner = { position: 'absolute', top: dims.translateY, width: dims.sidebarWidth };
break;
}
switch (affixType) {
case 'VIEWPORT-TOP':
case 'VIEWPORT-BOTTOM':
case 'VIEWPORT-UNBOTTOM':
case 'CONTAINER-BOTTOM':
style.outer = { height: dims.sidebarHeight, position: 'relative' };
break;
}
style.outer = StickySidebar.extend({ height: '', position: '' }, style.outer);
style.inner = StickySidebar.extend({ position: 'relative', top: '', left: '',
bottom: '', width: '', transform: this._getTranslate() }, style.inner);
return style;
}
/**
* Cause the sidebar to be sticky according to affix type by adding inline
* style, adding helper class and trigger events.
* @function
* @protected
* @param {string} force - Update sticky sidebar position by force.
*/
}, {
key: 'stickyPosition',
value: function stickyPosition(force) {
if (this._breakpoint) return;
force = force || false;
var affixType = this.getAffixType();
var style = this._getStyle(affixType);
if ((this.affixedType != affixType || force) && affixType) {
var affixEvent = 'affix.' + affixType.toLowerCase().replace('viewport-', '') + EVENT_KEY;
StickySidebar.eventTrigger(this.sidebar, affixEvent);
if ('STATIC' === affixType) StickySidebar.removeClass(this.sidebar, this.options.stickyClass);else StickySidebar.addClass(this.sidebar, this.options.stickyClass);
for (var key in style.outer) {
this.sidebar.style[key] = style.outer[key];
}
for (var _key in style.inner) {
var _unit2 = 'number' === typeof style.inner[_key] ? 'px' : '';
this.sidebarInner.style[_key] = style.inner[_key] + _unit2;
}
var affixedEvent = 'affixed.' + affixType.toLowerCase().replace('viewport', '') + EVENT_KEY;
StickySidebar.eventTrigger(this.sidebar, affixedEvent);
} else {
if (this._initialized) this.sidebarInner.style.left = style.inner.left;
}
this.affixedType = affixType;
}
/**
* Breakdown sticky sidebar when window width is below `options.minWidth` value.
* @protected
*/
}, {
key: '_widthBreakpoint',
value: function _widthBreakpoint() {
if (window.innerWidth <= this.options.minWidth) {
this._breakpoint = true;
this.affixedType = 'STATIC';
this.sidebar.removeAttribute('style');
StickySidebar.removeClass(this.sidebar, this.options.stickyClass);
this.sidebarInner.removeAttribute('style');
} else {
this._breakpoint = false;
}
}
/**
* Switchs between functions stack for each event type, if there's no
* event, it will re-initialize sticky sidebar.
* @public
*/
}, {
key: 'updateSticky',
value: function updateSticky() {
var _this3 = this;
var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (this._running) return;
this._running = true;
(function (eventType) {
requestAnimationFrame(function () {
switch (eventType) {
// When browser is scrolling and re-calculate just dimensions
// within scroll.
case 'scroll':
_this3._calcDimensionsWithScroll();
_this3.observeScrollDir();
_this3.stickyPosition();
break;
// When browser is resizing or there's no event, observe width
// breakpoint and re-calculate dimensions.
case 'resize':
default:
_this3._widthBreakpoint();
_this3.calcDimensions();
_this3.stickyPosition(true);
break;
}
_this3._running = false;
});
})(event.type);
}
/**
* Set browser support features to the public property.
* @private
*/
}, {
key: '_setSupportFeatures',
value: function _setSupportFeatures() {
var support = this.support;
support.transform = StickySidebar.supportTransform();
support.transform3d = StickySidebar.supportTransform(true);
}
/**
* Get translate value, if the browser supports transfrom3d, it will adopt it.
* and the same with translate. if browser doesn't support both return false.
* @param {Number} y - Value of Y-axis.
* @param {Number} x - Value of X-axis.
* @param {Number} z - Value of Z-axis.
* @return {String|False}
*/
}, {
key: '_getTranslate',
value: function _getTranslate() {
var y = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
if (this.support.transform3d) return 'translate3d(' + y + ', ' + x + ', ' + z + ')';else if (this.support.translate) return 'translate(' + y + ', ' + x + ')';else return false;
}
/**
* Destroy sticky sidebar plugin.
* @public
*/
}, {
key: 'destroy',
value: function destroy() {
window.removeEventListener('resize', this);
window.removeEventListener('scroll', this);
this.sidebar.classList.remove(this.options.stickyClass);
this.sidebar.style.minHeight = '';
this.sidebar.removeEventListener('update' + EVENT_KEY, this);
var styleReset = { inner: {}, outer: {} };
styleReset.inner = { position: '', top: '', left: '', bottom: '', width: '', transform: '' };
styleReset.outer = { height: '', position: '' };
for (var key in styleReset.outer) {
this.sidebar.style[key] = styleReset.outer[key];
}for (var _key2 in styleReset.inner) {
this.sidebarInner.style[_key2] = styleReset.inner[_key2];
}if (this.options.resizeSensor && 'undefined' !== typeof ResizeSensor) {
ResizeSensor.detach(this.sidebarInner, this.handleEvent);
ResizeSensor.detach(this.container, this.handleEvent);
}
}
/**
* Detarmine if the browser supports CSS transfrom feature.
* @function
* @static
* @param {Boolean} transform3d - Detect transform with translate3d.
* @return {String}
*/
}], [{
key: 'supportTransform',
value: function supportTransform(transform3d) {
var result = false,
property = transform3d ? 'perspective' : 'transform',
upper = property.charAt(0).toUpperCase() + property.slice(1),
prefixes = ['Webkit', 'Moz', 'O', 'ms'],
support = document.createElement('support'),
style = support.style;
(property + ' ' + prefixes.join(upper + ' ') + upper).split(' ').forEach(function (property, i) {
if (style[property] !== undefined) {
result = property;
return false;
}
});
return result;
}
/**
* Trigger custom event.
* @static
* @param {DOMObject} element - Target element on the DOM.
* @param {String} eventName - Event name.
* @param {Object} data -
*/
}, {
key: 'eventTrigger',
value: function eventTrigger(element, eventName, data) {
try {
var event = new CustomEvent(eventName, { detail: data });
} catch (e) {
var event = document.createEvent('CustomEvent');
event.initCustomEvent(eventName, true, true, data);
}
element.dispatchEvent(event);
}
/**
* Extend options object with defaults.
* @function
* @static
*/
}, {
key: 'extend',
value: function extend(defaults, options) {
var results = {};
for (var key in defaults) {
if ('undefined' !== typeof options[key]) results[key] = options[key];else results[key] = defaults[key];
}
return results;
}
/**
* Get current coordinates left and top of specific element.
* @static
*/
}, {
key: 'offsetRelative',
value: function offsetRelative(element) {
var result = { left: 0, top: 0 };
do {
var offsetTop = element.offsetTop;
var offsetLeft = element.offsetLeft;
if (!isNaN(offsetTop)) result.top += offsetTop;
if (!isNaN(offsetLeft)) result.left += offsetLeft;
} while (element = element.offsetParent);
return result;
}
/**
* Add specific class name to specific element.
* @static
* @param {ObjectDOM} element
* @param {String} className
*/
}, {
key: 'addClass',
value: function addClass(element, className) {
if (!StickySidebar.hasClass(element, className)) {
if (element.classList) element.classList.add(className);else element.className += ' ' + className;
}
}
/**
* Remove specific class name to specific element
* @static
* @param {ObjectDOM} element
* @param {String} className
*/
}, {
key: 'removeClass',
value: function removeClass(element, className) {
if (StickySidebar.hasClass(element, className)) {
if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\b)' + className.split(' ').join('|') + '(\\b|$)', 'gi'), ' ');
}
}
/**
* Detarmine weather the element has specific class name.
* @static
* @param {ObjectDOM} element
* @param {String} className
*/
}, {
key: 'hasClass',
value: function hasClass(element, className) {
if (element.classList) return element.classList.contains(className);else return new RegExp('(^| )' + className + '( |$)', 'gi').test(element.className);
}
}]);
return StickySidebar;
}();
return StickySidebar;
}();
// Global
// -------------------------
window.StickySidebar = StickySidebar;
return StickySidebar;
});
//# sourceMappingURL=sticky-sidebar.js.map
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;
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; };
/*! tether 1.4.0 */
(function (root, factory) {
if (true) {
!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
__WEBPACK_AMD_DEFINE_FACTORY__),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if ((typeof exports === 'undefined' ? 'undefined' : _typeof(exports)) === 'object') {
module.exports = factory(require, exports, module);
} else {
root.Tether = factory();
}
})(undefined, function (require, exports, module) {
'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');
}
}
var TetherBase = undefined;
if (typeof TetherBase === 'undefined') {
TetherBase = { modules: [] };
}
var zeroElement = null;
// Same as native getBoundingClientRect, except it takes into account parent offsets
// if the element lies within a nested document ( or