import { window, document } from 'ssr-window';
|
import $ from '../../utils/dom';
|
import Utils from '../../utils/utils';
|
|
function isEventSupported() {
|
const eventName = 'onwheel';
|
let isSupported = eventName in document;
|
|
if (!isSupported) {
|
const element = document.createElement('div');
|
element.setAttribute(eventName, 'return;');
|
isSupported = typeof element[eventName] === 'function';
|
}
|
|
if (!isSupported
|
&& document.implementation
|
&& document.implementation.hasFeature
|
// always returns true in newer browsers as per the standard.
|
// @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature
|
&& document.implementation.hasFeature('', '') !== true
|
) {
|
// This is the only way to test support for the `wheel` event in IE9+.
|
isSupported = document.implementation.hasFeature('Events.wheel', '3.0');
|
}
|
|
return isSupported;
|
}
|
const Mousewheel = {
|
lastScrollTime: Utils.now(),
|
lastEventBeforeSnap: undefined,
|
recentWheelEvents: [],
|
event() {
|
if (window.navigator.userAgent.indexOf('firefox') > -1) return 'DOMMouseScroll';
|
return isEventSupported() ? 'wheel' : 'mousewheel';
|
},
|
normalize(e) {
|
// Reasonable defaults
|
const PIXEL_STEP = 10;
|
const LINE_HEIGHT = 40;
|
const PAGE_HEIGHT = 800;
|
|
let sX = 0;
|
let sY = 0; // spinX, spinY
|
let pX = 0;
|
let pY = 0; // pixelX, pixelY
|
|
// Legacy
|
if ('detail' in e) {
|
sY = e.detail;
|
}
|
if ('wheelDelta' in e) {
|
sY = -e.wheelDelta / 120;
|
}
|
if ('wheelDeltaY' in e) {
|
sY = -e.wheelDeltaY / 120;
|
}
|
if ('wheelDeltaX' in e) {
|
sX = -e.wheelDeltaX / 120;
|
}
|
|
// side scrolling on FF with DOMMouseScroll
|
if ('axis' in e && e.axis === e.HORIZONTAL_AXIS) {
|
sX = sY;
|
sY = 0;
|
}
|
|
pX = sX * PIXEL_STEP;
|
pY = sY * PIXEL_STEP;
|
|
if ('deltaY' in e) {
|
pY = e.deltaY;
|
}
|
if ('deltaX' in e) {
|
pX = e.deltaX;
|
}
|
|
if (e.shiftKey && !pX) { // if user scrolls with shift he wants horizontal scroll
|
pX = pY;
|
pY = 0;
|
}
|
|
if ((pX || pY) && e.deltaMode) {
|
if (e.deltaMode === 1) { // delta in LINE units
|
pX *= LINE_HEIGHT;
|
pY *= LINE_HEIGHT;
|
} else { // delta in PAGE units
|
pX *= PAGE_HEIGHT;
|
pY *= PAGE_HEIGHT;
|
}
|
}
|
|
// Fall-back if spin cannot be determined
|
if (pX && !sX) {
|
sX = (pX < 1) ? -1 : 1;
|
}
|
if (pY && !sY) {
|
sY = (pY < 1) ? -1 : 1;
|
}
|
|
return {
|
spinX: sX,
|
spinY: sY,
|
pixelX: pX,
|
pixelY: pY,
|
};
|
},
|
handleMouseEnter() {
|
const swiper = this;
|
swiper.mouseEntered = true;
|
},
|
handleMouseLeave() {
|
const swiper = this;
|
swiper.mouseEntered = false;
|
},
|
handle(event) {
|
let e = event;
|
const swiper = this;
|
const params = swiper.params.mousewheel;
|
|
if (swiper.params.cssMode) {
|
e.preventDefault();
|
}
|
|
let target = swiper.$el;
|
if (swiper.params.mousewheel.eventsTarged !== 'container') {
|
target = $(swiper.params.mousewheel.eventsTarged);
|
}
|
if (!swiper.mouseEntered && !target[0].contains(e.target) && !params.releaseOnEdges) return true;
|
|
if (e.originalEvent) e = e.originalEvent; // jquery fix
|
let delta = 0;
|
const rtlFactor = swiper.rtlTranslate ? -1 : 1;
|
|
const data = Mousewheel.normalize(e);
|
|
if (params.forceToAxis) {
|
if (swiper.isHorizontal()) {
|
if (Math.abs(data.pixelX) > Math.abs(data.pixelY)) delta = -data.pixelX * rtlFactor;
|
else return true;
|
} else if (Math.abs(data.pixelY) > Math.abs(data.pixelX)) delta = -data.pixelY;
|
else return true;
|
} else {
|
delta = Math.abs(data.pixelX) > Math.abs(data.pixelY) ? -data.pixelX * rtlFactor : -data.pixelY;
|
}
|
|
if (delta === 0) return true;
|
|
if (params.invert) delta = -delta;
|
|
if (!swiper.params.freeMode) {
|
// Register the new event in a variable which stores the relevant data
|
const newEvent = {
|
time: Utils.now(),
|
delta: Math.abs(delta),
|
direction: Math.sign(delta),
|
raw: event,
|
};
|
|
// Keep the most recent events
|
const recentWheelEvents = swiper.mousewheel.recentWheelEvents;
|
if (recentWheelEvents.length >= 2) {
|
recentWheelEvents.shift(); // only store the last N events
|
}
|
const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;
|
recentWheelEvents.push(newEvent);
|
|
// If there is at least one previous recorded event:
|
// If direction has changed or
|
// if the scroll is quicker than the previous one:
|
// Animate the slider.
|
// Else (this is the first time the wheel is moved):
|
// Animate the slider.
|
if (prevEvent) {
|
if (newEvent.direction !== prevEvent.direction || newEvent.delta > prevEvent.delta || newEvent.time > prevEvent.time + 150) {
|
swiper.mousewheel.animateSlider(newEvent);
|
}
|
} else {
|
swiper.mousewheel.animateSlider(newEvent);
|
}
|
|
// If it's time to release the scroll:
|
// Return now so you don't hit the preventDefault.
|
if (swiper.mousewheel.releaseScroll(newEvent)) {
|
return true;
|
}
|
} else {
|
// Freemode or scrollContainer:
|
|
// If we recently snapped after a momentum scroll, then ignore wheel events
|
// to give time for the deceleration to finish. Stop ignoring after 500 msecs
|
// or if it's a new scroll (larger delta or inverse sign as last event before
|
// an end-of-momentum snap).
|
const newEvent = { time: Utils.now(), delta: Math.abs(delta), direction: Math.sign(delta) };
|
const { lastEventBeforeSnap } = swiper.mousewheel;
|
const ignoreWheelEvents = lastEventBeforeSnap
|
&& newEvent.time < lastEventBeforeSnap.time + 500
|
&& newEvent.delta <= lastEventBeforeSnap.delta
|
&& newEvent.direction === lastEventBeforeSnap.direction;
|
if (!ignoreWheelEvents) {
|
swiper.mousewheel.lastEventBeforeSnap = undefined;
|
|
if (swiper.params.loop) {
|
swiper.loopFix();
|
}
|
let position = swiper.getTranslate() + (delta * params.sensitivity);
|
const wasBeginning = swiper.isBeginning;
|
const wasEnd = swiper.isEnd;
|
|
if (position >= swiper.minTranslate()) position = swiper.minTranslate();
|
if (position <= swiper.maxTranslate()) position = swiper.maxTranslate();
|
|
swiper.setTransition(0);
|
swiper.setTranslate(position);
|
swiper.updateProgress();
|
swiper.updateActiveIndex();
|
swiper.updateSlidesClasses();
|
|
if ((!wasBeginning && swiper.isBeginning) || (!wasEnd && swiper.isEnd)) {
|
swiper.updateSlidesClasses();
|
}
|
|
if (swiper.params.freeModeSticky) {
|
// When wheel scrolling starts with sticky (aka snap) enabled, then detect
|
// the end of a momentum scroll by storing recent (N=15?) wheel events.
|
// 1. do all N events have decreasing or same (absolute value) delta?
|
// 2. did all N events arrive in the last M (M=500?) msecs?
|
// 3. does the earliest event have an (absolute value) delta that's
|
// at least P (P=1?) larger than the most recent event's delta?
|
// 4. does the latest event have a delta that's smaller than Q (Q=6?) pixels?
|
// If 1-4 are "yes" then we're near the end of a momuntum scroll deceleration.
|
// Snap immediately and ignore remaining wheel events in this scroll.
|
// See comment above for "remaining wheel events in this scroll" determination.
|
// If 1-4 aren't satisfied, then wait to snap until 500ms after the last event.
|
clearTimeout(swiper.mousewheel.timeout);
|
swiper.mousewheel.timeout = undefined;
|
const recentWheelEvents = swiper.mousewheel.recentWheelEvents;
|
if (recentWheelEvents.length >= 15) {
|
recentWheelEvents.shift(); // only store the last N events
|
}
|
const prevEvent = recentWheelEvents.length ? recentWheelEvents[recentWheelEvents.length - 1] : undefined;
|
const firstEvent = recentWheelEvents[0];
|
recentWheelEvents.push(newEvent);
|
if (prevEvent && (newEvent.delta > prevEvent.delta || newEvent.direction !== prevEvent.direction)) {
|
// Increasing or reverse-sign delta means the user started scrolling again. Clear the wheel event log.
|
recentWheelEvents.splice(0);
|
} else if (recentWheelEvents.length >= 15
|
&& newEvent.time - firstEvent.time < 500
|
&& firstEvent.delta - newEvent.delta >= 1
|
&& newEvent.delta <= 6
|
) {
|
// We're at the end of the deceleration of a momentum scroll, so there's no need
|
// to wait for more events. Snap ASAP on the next tick.
|
// Also, because there's some remaining momentum we'll bias the snap in the
|
// direction of the ongoing scroll because it's better UX for the scroll to snap
|
// in the same direction as the scroll instead of reversing to snap. Therefore,
|
// if it's already scrolled more than 20% in the current direction, keep going.
|
const snapToThreshold = delta > 0 ? 0.8 : 0.2;
|
swiper.mousewheel.lastEventBeforeSnap = newEvent;
|
recentWheelEvents.splice(0);
|
swiper.mousewheel.timeout = Utils.nextTick(() => {
|
swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);
|
}, 0); // no delay; move on next tick
|
}
|
if (!swiper.mousewheel.timeout) {
|
// if we get here, then we haven't detected the end of a momentum scroll, so
|
// we'll consider a scroll "complete" when there haven't been any wheel events
|
// for 500ms.
|
swiper.mousewheel.timeout = Utils.nextTick(() => {
|
const snapToThreshold = 0.5;
|
swiper.mousewheel.lastEventBeforeSnap = newEvent;
|
recentWheelEvents.splice(0);
|
swiper.slideToClosest(swiper.params.speed, true, undefined, snapToThreshold);
|
}, 500);
|
}
|
}
|
|
// Emit event
|
if (!ignoreWheelEvents) swiper.emit('scroll', e);
|
|
// Stop autoplay
|
if (swiper.params.autoplay && swiper.params.autoplayDisableOnInteraction) swiper.autoplay.stop();
|
// Return page scroll on edge positions
|
if (position === swiper.minTranslate() || position === swiper.maxTranslate()) return true;
|
}
|
}
|
|
if (e.preventDefault) e.preventDefault();
|
else e.returnValue = false;
|
return false;
|
},
|
animateSlider(newEvent) {
|
const swiper = this;
|
// If the movement is NOT big enough and
|
// if the last time the user scrolled was too close to the current one (avoid continuously triggering the slider):
|
// Don't go any further (avoid insignificant scroll movement).
|
if (newEvent.delta >= 6 && Utils.now() - swiper.mousewheel.lastScrollTime < 60) {
|
// Return false as a default
|
return true;
|
}
|
// If user is scrolling towards the end:
|
// If the slider hasn't hit the latest slide or
|
// if the slider is a loop and
|
// if the slider isn't moving right now:
|
// Go to next slide and
|
// emit a scroll event.
|
// Else (the user is scrolling towards the beginning) and
|
// if the slider hasn't hit the first slide or
|
// if the slider is a loop and
|
// if the slider isn't moving right now:
|
// Go to prev slide and
|
// emit a scroll event.
|
if (newEvent.direction < 0) {
|
if ((!swiper.isEnd || swiper.params.loop) && !swiper.animating) {
|
swiper.slideNext();
|
swiper.emit('scroll', newEvent.raw);
|
}
|
} else if ((!swiper.isBeginning || swiper.params.loop) && !swiper.animating) {
|
swiper.slidePrev();
|
swiper.emit('scroll', newEvent.raw);
|
}
|
// If you got here is because an animation has been triggered so store the current time
|
swiper.mousewheel.lastScrollTime = (new window.Date()).getTime();
|
// Return false as a default
|
return false;
|
},
|
releaseScroll(newEvent) {
|
const swiper = this;
|
const params = swiper.params.mousewheel;
|
if (newEvent.direction < 0) {
|
if (swiper.isEnd && !swiper.params.loop && params.releaseOnEdges) {
|
// Return true to animate scroll on edges
|
return true;
|
}
|
} else if (swiper.isBeginning && !swiper.params.loop && params.releaseOnEdges) {
|
// Return true to animate scroll on edges
|
return true;
|
}
|
return false;
|
},
|
enable() {
|
const swiper = this;
|
const event = Mousewheel.event();
|
if (swiper.params.cssMode) {
|
swiper.wrapperEl.removeEventListener(event, swiper.mousewheel.handle);
|
return true;
|
}
|
if (!event) return false;
|
if (swiper.mousewheel.enabled) return false;
|
let target = swiper.$el;
|
if (swiper.params.mousewheel.eventsTarged !== 'container') {
|
target = $(swiper.params.mousewheel.eventsTarged);
|
}
|
target.on('mouseenter', swiper.mousewheel.handleMouseEnter);
|
target.on('mouseleave', swiper.mousewheel.handleMouseLeave);
|
target.on(event, swiper.mousewheel.handle);
|
swiper.mousewheel.enabled = true;
|
return true;
|
},
|
disable() {
|
const swiper = this;
|
const event = Mousewheel.event();
|
if (swiper.params.cssMode) {
|
swiper.wrapperEl.addEventListener(event, swiper.mousewheel.handle);
|
return true;
|
}
|
if (!event) return false;
|
if (!swiper.mousewheel.enabled) return false;
|
let target = swiper.$el;
|
if (swiper.params.mousewheel.eventsTarged !== 'container') {
|
target = $(swiper.params.mousewheel.eventsTarged);
|
}
|
target.off(event, swiper.mousewheel.handle);
|
swiper.mousewheel.enabled = false;
|
return true;
|
},
|
};
|
|
export default {
|
name: 'mousewheel',
|
params: {
|
mousewheel: {
|
enabled: false,
|
releaseOnEdges: false,
|
invert: false,
|
forceToAxis: false,
|
sensitivity: 1,
|
eventsTarged: 'container',
|
},
|
},
|
create() {
|
const swiper = this;
|
Utils.extend(swiper, {
|
mousewheel: {
|
enabled: false,
|
enable: Mousewheel.enable.bind(swiper),
|
disable: Mousewheel.disable.bind(swiper),
|
handle: Mousewheel.handle.bind(swiper),
|
handleMouseEnter: Mousewheel.handleMouseEnter.bind(swiper),
|
handleMouseLeave: Mousewheel.handleMouseLeave.bind(swiper),
|
animateSlider: Mousewheel.animateSlider.bind(swiper),
|
releaseScroll: Mousewheel.releaseScroll.bind(swiper),
|
lastScrollTime: Utils.now(),
|
lastEventBeforeSnap: undefined,
|
recentWheelEvents: [],
|
},
|
});
|
},
|
on: {
|
init() {
|
const swiper = this;
|
if (!swiper.params.mousewheel.enabled && swiper.params.cssMode) {
|
swiper.mousewheel.disable();
|
}
|
if (swiper.params.mousewheel.enabled) swiper.mousewheel.enable();
|
},
|
destroy() {
|
const swiper = this;
|
if (swiper.params.cssMode) {
|
swiper.mousewheel.enable();
|
}
|
if (swiper.mousewheel.enabled) swiper.mousewheel.disable();
|
},
|
},
|
};
|
