@better-scroll/core
Version:
Minimalistic core scrolling for BetterScroll, it is pure and tiny
1,335 lines (1,309 loc) • 100 kB
JavaScript
/*!
* better-scroll / core
* (c) 2016-2022 ustbhuangyi
* Released under the MIT License.
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define(['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BScroll = {}));
})(this, (function (exports) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
var propertiesConfig = [
{
sourceKey: 'scroller.scrollBehaviorX.currentPos',
key: 'x'
},
{
sourceKey: 'scroller.scrollBehaviorY.currentPos',
key: 'y'
},
{
sourceKey: 'scroller.scrollBehaviorX.hasScroll',
key: 'hasHorizontalScroll'
},
{
sourceKey: 'scroller.scrollBehaviorY.hasScroll',
key: 'hasVerticalScroll'
},
{
sourceKey: 'scroller.scrollBehaviorX.contentSize',
key: 'scrollerWidth'
},
{
sourceKey: 'scroller.scrollBehaviorY.contentSize',
key: 'scrollerHeight'
},
{
sourceKey: 'scroller.scrollBehaviorX.maxScrollPos',
key: 'maxScrollX'
},
{
sourceKey: 'scroller.scrollBehaviorY.maxScrollPos',
key: 'maxScrollY'
},
{
sourceKey: 'scroller.scrollBehaviorX.minScrollPos',
key: 'minScrollX'
},
{
sourceKey: 'scroller.scrollBehaviorY.minScrollPos',
key: 'minScrollY'
},
{
sourceKey: 'scroller.scrollBehaviorX.movingDirection',
key: 'movingDirectionX'
},
{
sourceKey: 'scroller.scrollBehaviorY.movingDirection',
key: 'movingDirectionY'
},
{
sourceKey: 'scroller.scrollBehaviorX.direction',
key: 'directionX'
},
{
sourceKey: 'scroller.scrollBehaviorY.direction',
key: 'directionY'
},
{
sourceKey: 'scroller.actions.enabled',
key: 'enabled'
},
{
sourceKey: 'scroller.animater.pending',
key: 'pending'
},
{
sourceKey: 'scroller.animater.stop',
key: 'stop'
},
{
sourceKey: 'scroller.scrollTo',
key: 'scrollTo'
},
{
sourceKey: 'scroller.scrollBy',
key: 'scrollBy'
},
{
sourceKey: 'scroller.scrollToElement',
key: 'scrollToElement'
},
{
sourceKey: 'scroller.resetPosition',
key: 'resetPosition'
}
];
function warn(msg) {
console.error("[BScroll warn]: " + msg);
}
// ssr support
var inBrowser = typeof window !== 'undefined';
var ua = inBrowser && navigator.userAgent.toLowerCase();
var isWeChatDevTools = !!(ua && /wechatdevtools/.test(ua));
var isAndroid = ua && ua.indexOf('android') > 0;
/* istanbul ignore next */
var isIOSBadVersion = (function () {
if (typeof ua === 'string') {
var regex = /os (\d\d?_\d(_\d)?)/;
var matches = regex.exec(ua);
if (!matches)
return false;
var parts = matches[1].split('_').map(function (item) {
return parseInt(item, 10);
});
// ios version >= 13.4 issue 982
return !!(parts[0] === 13 && parts[1] >= 4);
}
return false;
})();
/* istanbul ignore next */
var supportsPassive = false;
/* istanbul ignore next */
if (inBrowser) {
var EventName = 'test-passive';
try {
var opts = {};
Object.defineProperty(opts, 'passive', {
get: function () {
supportsPassive = true;
},
}); // https://github.com/facebook/flow/issues/285
window.addEventListener(EventName, function () { }, opts);
}
catch (e) { }
}
function getNow() {
return window.performance &&
window.performance.now &&
window.performance.timing
? window.performance.now() + window.performance.timing.navigationStart
: +new Date();
}
var extend = function (target, source) {
for (var key in source) {
target[key] = source[key];
}
return target;
};
function isUndef(v) {
return v === undefined || v === null;
}
function between(x, min, max) {
if (x < min) {
return min;
}
if (x > max) {
return max;
}
return x;
}
var elementStyle = (inBrowser &&
document.createElement('div').style);
var vendor = (function () {
/* istanbul ignore if */
if (!inBrowser) {
return false;
}
var transformNames = [
{
key: 'standard',
value: 'transform',
},
{
key: 'webkit',
value: 'webkitTransform',
},
{
key: 'Moz',
value: 'MozTransform',
},
{
key: 'O',
value: 'OTransform',
},
{
key: 'ms',
value: 'msTransform',
},
];
for (var _i = 0, transformNames_1 = transformNames; _i < transformNames_1.length; _i++) {
var obj = transformNames_1[_i];
if (elementStyle[obj.value] !== undefined) {
return obj.key;
}
}
/* istanbul ignore next */
return false;
})();
/* istanbul ignore next */
function prefixStyle(style) {
if (vendor === false) {
return style;
}
if (vendor === 'standard') {
if (style === 'transitionEnd') {
return 'transitionend';
}
return style;
}
return vendor + style.charAt(0).toUpperCase() + style.substr(1);
}
function getElement(el) {
return (typeof el === 'string' ? document.querySelector(el) : el);
}
function addEvent(el, type, fn, capture) {
var useCapture = supportsPassive
? {
passive: false,
capture: !!capture,
}
: !!capture;
el.addEventListener(type, fn, useCapture);
}
function removeEvent(el, type, fn, capture) {
el.removeEventListener(type, fn, {
capture: !!capture,
});
}
function maybePrevent(e) {
if (e.cancelable) {
e.preventDefault();
}
}
function offset(el) {
var left = 0;
var top = 0;
while (el) {
left -= el.offsetLeft;
top -= el.offsetTop;
el = el.offsetParent;
}
return {
left: left,
top: top,
};
}
vendor && vendor !== 'standard' ? '-' + vendor.toLowerCase() + '-' : '';
var transform = prefixStyle('transform');
var transition = prefixStyle('transition');
var hasPerspective = inBrowser && prefixStyle('perspective') in elementStyle;
// fix issue #361
var hasTouch = inBrowser && ('ontouchstart' in window || isWeChatDevTools);
var hasTransition = inBrowser && transition in elementStyle;
var style = {
transform: transform,
transition: transition,
transitionTimingFunction: prefixStyle('transitionTimingFunction'),
transitionDuration: prefixStyle('transitionDuration'),
transitionDelay: prefixStyle('transitionDelay'),
transformOrigin: prefixStyle('transformOrigin'),
transitionEnd: prefixStyle('transitionEnd'),
transitionProperty: prefixStyle('transitionProperty'),
};
var eventTypeMap = {
touchstart: 1,
touchmove: 1,
touchend: 1,
touchcancel: 1,
mousedown: 2,
mousemove: 2,
mouseup: 2,
};
function getRect(el) {
/* istanbul ignore if */
if (el instanceof window.SVGElement) {
var rect = el.getBoundingClientRect();
return {
top: rect.top,
left: rect.left,
width: rect.width,
height: rect.height,
};
}
else {
return {
top: el.offsetTop,
left: el.offsetLeft,
width: el.offsetWidth,
height: el.offsetHeight,
};
}
}
function preventDefaultExceptionFn(el, exceptions) {
for (var i in exceptions) {
if (exceptions[i].test(el[i])) {
return true;
}
}
return false;
}
var tagExceptionFn = preventDefaultExceptionFn;
function tap(e, eventName) {
var ev = document.createEvent('Event');
ev.initEvent(eventName, true, true);
ev.pageX = e.pageX;
ev.pageY = e.pageY;
e.target.dispatchEvent(ev);
}
function click(e, event) {
if (event === void 0) { event = 'click'; }
var eventSource;
if (e.type === 'mouseup') {
eventSource = e;
}
else if (e.type === 'touchend' || e.type === 'touchcancel') {
eventSource = e.changedTouches[0];
}
var posSrc = {};
if (eventSource) {
posSrc.screenX = eventSource.screenX || 0;
posSrc.screenY = eventSource.screenY || 0;
posSrc.clientX = eventSource.clientX || 0;
posSrc.clientY = eventSource.clientY || 0;
}
var ev;
var bubbles = true;
var cancelable = true;
var ctrlKey = e.ctrlKey, shiftKey = e.shiftKey, altKey = e.altKey, metaKey = e.metaKey;
var pressedKeysMap = {
ctrlKey: ctrlKey,
shiftKey: shiftKey,
altKey: altKey,
metaKey: metaKey,
};
if (typeof MouseEvent !== 'undefined') {
try {
ev = new MouseEvent(event, extend(__assign({ bubbles: bubbles,
cancelable: cancelable }, pressedKeysMap), posSrc));
}
catch (e) {
/* istanbul ignore next */
createEvent();
}
}
else {
createEvent();
}
function createEvent() {
ev = document.createEvent('Event');
ev.initEvent(event, bubbles, cancelable);
extend(ev, posSrc);
}
// forwardedTouchEvent set to true in case of the conflict with fastclick
ev.forwardedTouchEvent = true;
ev._constructed = true;
e.target.dispatchEvent(ev);
}
function dblclick(e) {
click(e, 'dblclick');
}
var ease = {
// easeOutQuint
swipe: {
style: 'cubic-bezier(0.23, 1, 0.32, 1)',
fn: function (t) {
return 1 + --t * t * t * t * t;
}
},
// easeOutQuard
swipeBounce: {
style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
fn: function (t) {
return t * (2 - t);
}
},
// easeOutQuart
bounce: {
style: 'cubic-bezier(0.165, 0.84, 0.44, 1)',
fn: function (t) {
return 1 - --t * t * t * t;
}
}
};
var DEFAULT_INTERVAL = 1000 / 60;
var windowCompat = inBrowser && window;
/* istanbul ignore next */
function noop$1() { }
var requestAnimationFrame = (function () {
/* istanbul ignore if */
if (!inBrowser) {
return noop$1;
}
return (windowCompat.requestAnimationFrame ||
windowCompat.webkitRequestAnimationFrame ||
windowCompat.mozRequestAnimationFrame ||
windowCompat.oRequestAnimationFrame ||
// if all else fails, use setTimeout
function (callback) {
return window.setTimeout(callback, callback.interval || DEFAULT_INTERVAL); // make interval as precise as possible.
});
})();
var cancelAnimationFrame = (function () {
/* istanbul ignore if */
if (!inBrowser) {
return noop$1;
}
return (windowCompat.cancelAnimationFrame ||
windowCompat.webkitCancelAnimationFrame ||
windowCompat.mozCancelAnimationFrame ||
windowCompat.oCancelAnimationFrame ||
function (id) {
window.clearTimeout(id);
});
})();
/* istanbul ignore next */
var noop = function (val) { };
var sharedPropertyDefinition = {
enumerable: true,
configurable: true,
get: noop,
set: noop,
};
var getProperty = function (obj, key) {
var keys = key.split('.');
for (var i = 0; i < keys.length - 1; i++) {
obj = obj[keys[i]];
if (typeof obj !== 'object' || !obj)
return;
}
var lastKey = keys.pop();
if (typeof obj[lastKey] === 'function') {
return function () {
return obj[lastKey].apply(obj, arguments);
};
}
else {
return obj[lastKey];
}
};
var setProperty = function (obj, key, value) {
var keys = key.split('.');
var temp;
for (var i = 0; i < keys.length - 1; i++) {
temp = keys[i];
if (!obj[temp])
obj[temp] = {};
obj = obj[temp];
}
obj[keys.pop()] = value;
};
function propertiesProxy(target, sourceKey, key) {
sharedPropertyDefinition.get = function proxyGetter() {
return getProperty(this, sourceKey);
};
sharedPropertyDefinition.set = function proxySetter(val) {
setProperty(this, sourceKey, val);
};
Object.defineProperty(target, key, sharedPropertyDefinition);
}
var EventEmitter = /** @class */ (function () {
function EventEmitter(names) {
this.events = {};
this.eventTypes = {};
this.registerType(names);
}
EventEmitter.prototype.on = function (type, fn, context) {
if (context === void 0) { context = this; }
this.hasType(type);
if (!this.events[type]) {
this.events[type] = [];
}
this.events[type].push([fn, context]);
return this;
};
EventEmitter.prototype.once = function (type, fn, context) {
var _this = this;
if (context === void 0) { context = this; }
this.hasType(type);
var magic = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
_this.off(type, magic);
var ret = fn.apply(context, args);
if (ret === true) {
return ret;
}
};
magic.fn = fn;
this.on(type, magic);
return this;
};
EventEmitter.prototype.off = function (type, fn) {
if (!type && !fn) {
this.events = {};
return this;
}
if (type) {
this.hasType(type);
if (!fn) {
this.events[type] = [];
return this;
}
var events = this.events[type];
if (!events) {
return this;
}
var count = events.length;
while (count--) {
if (events[count][0] === fn ||
(events[count][0] && events[count][0].fn === fn)) {
events.splice(count, 1);
}
}
return this;
}
};
EventEmitter.prototype.trigger = function (type) {
var args = [];
for (var _i = 1; _i < arguments.length; _i++) {
args[_i - 1] = arguments[_i];
}
this.hasType(type);
var events = this.events[type];
if (!events) {
return;
}
var len = events.length;
var eventsCopy = __spreadArrays(events);
var ret;
for (var i = 0; i < len; i++) {
var event_1 = eventsCopy[i];
var fn = event_1[0], context = event_1[1];
if (fn) {
ret = fn.apply(context, args);
if (ret === true) {
return ret;
}
}
}
};
EventEmitter.prototype.registerType = function (names) {
var _this = this;
names.forEach(function (type) {
_this.eventTypes[type] = type;
});
};
EventEmitter.prototype.destroy = function () {
this.events = {};
this.eventTypes = {};
};
EventEmitter.prototype.hasType = function (type) {
var types = this.eventTypes;
var isType = types[type] === type;
if (!isType) {
warn("EventEmitter has used unknown event type: \"" + type + "\", should be oneof [" +
("" + Object.keys(types).map(function (_) { return JSON.stringify(_); })) +
"]");
}
};
return EventEmitter;
}());
var EventRegister = /** @class */ (function () {
function EventRegister(wrapper, events) {
this.wrapper = wrapper;
this.events = events;
this.addDOMEvents();
}
EventRegister.prototype.destroy = function () {
this.removeDOMEvents();
this.events = [];
};
EventRegister.prototype.addDOMEvents = function () {
this.handleDOMEvents(addEvent);
};
EventRegister.prototype.removeDOMEvents = function () {
this.handleDOMEvents(removeEvent);
};
EventRegister.prototype.handleDOMEvents = function (eventOperation) {
var _this = this;
var wrapper = this.wrapper;
this.events.forEach(function (event) {
eventOperation(wrapper, event.name, _this, !!event.capture);
});
};
EventRegister.prototype.handleEvent = function (e) {
var eventType = e.type;
this.events.some(function (event) {
if (event.name === eventType) {
event.handler(e);
return true;
}
return false;
});
};
return EventRegister;
}());
var CustomOptions = /** @class */ (function () {
function CustomOptions() {
}
return CustomOptions;
}());
var OptionsConstructor = /** @class */ (function (_super) {
__extends(OptionsConstructor, _super);
function OptionsConstructor() {
var _this = _super.call(this) || this;
_this.startX = 0;
_this.startY = 0;
_this.scrollX = false;
_this.scrollY = true;
_this.freeScroll = false;
_this.directionLockThreshold = 0;
_this.eventPassthrough = "" /* None */;
_this.click = false;
_this.dblclick = false;
_this.tap = '';
_this.bounce = {
top: true,
bottom: true,
left: true,
right: true,
};
_this.bounceTime = 800;
_this.momentum = true;
_this.momentumLimitTime = 300;
_this.momentumLimitDistance = 15;
_this.swipeTime = 2500;
_this.swipeBounceTime = 500;
_this.deceleration = 0.0015;
_this.flickLimitTime = 200;
_this.flickLimitDistance = 100;
_this.resizePolling = 60;
_this.probeType = 0 /* Default */;
_this.stopPropagation = false;
_this.preventDefault = true;
_this.preventDefaultException = {
tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/,
};
_this.tagException = {
tagName: /^TEXTAREA$/,
};
_this.HWCompositing = true;
_this.useTransition = true;
_this.bindToWrapper = false;
_this.bindToTarget = false;
_this.disableMouse = hasTouch;
_this.disableTouch = !hasTouch;
_this.autoBlur = true;
_this.autoEndDistance = 5;
_this.outOfBoundaryDampingFactor = 1 / 3;
_this.specifiedIndexAsContent = 0;
_this.quadrant = 1 /* First */;
return _this;
}
OptionsConstructor.prototype.merge = function (options) {
if (!options)
return this;
for (var key in options) {
if (key === 'bounce') {
this.bounce = this.resolveBounce(options[key]);
continue;
}
this[key] = options[key];
}
return this;
};
OptionsConstructor.prototype.process = function () {
this.translateZ =
this.HWCompositing && hasPerspective ? ' translateZ(1px)' : '';
this.useTransition = this.useTransition && hasTransition;
this.preventDefault = !this.eventPassthrough && this.preventDefault;
// If you want eventPassthrough I have to lock one of the axes
this.scrollX =
this.eventPassthrough === "horizontal" /* Horizontal */
? false
: this.scrollX;
this.scrollY =
this.eventPassthrough === "vertical" /* Vertical */ ? false : this.scrollY;
// With eventPassthrough we also need lockDirection mechanism
this.freeScroll = this.freeScroll && !this.eventPassthrough;
// force true when freeScroll is true
this.scrollX = this.freeScroll ? true : this.scrollX;
this.scrollY = this.freeScroll ? true : this.scrollY;
this.directionLockThreshold = this.eventPassthrough
? 0
: this.directionLockThreshold;
return this;
};
OptionsConstructor.prototype.resolveBounce = function (bounceOptions) {
var DEFAULT_BOUNCE = {
top: true,
right: true,
bottom: true,
left: true,
};
var NEGATED_BOUNCE = {
top: false,
right: false,
bottom: false,
left: false,
};
var ret;
if (typeof bounceOptions === 'object') {
ret = extend(DEFAULT_BOUNCE, bounceOptions);
}
else {
ret = bounceOptions ? DEFAULT_BOUNCE : NEGATED_BOUNCE;
}
return ret;
};
return OptionsConstructor;
}(CustomOptions));
var ActionsHandler = /** @class */ (function () {
function ActionsHandler(wrapper, options) {
this.wrapper = wrapper;
this.options = options;
this.hooks = new EventEmitter([
'beforeStart',
'start',
'move',
'end',
'click',
]);
this.handleDOMEvents();
}
ActionsHandler.prototype.handleDOMEvents = function () {
var _a = this.options, bindToWrapper = _a.bindToWrapper, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch, click = _a.click;
var wrapper = this.wrapper;
var target = bindToWrapper ? wrapper : window;
var wrapperEvents = [];
var targetEvents = [];
var shouldRegisterTouch = !disableTouch;
var shouldRegisterMouse = !disableMouse;
if (click) {
wrapperEvents.push({
name: 'click',
handler: this.click.bind(this),
capture: true,
});
}
if (shouldRegisterTouch) {
wrapperEvents.push({
name: 'touchstart',
handler: this.start.bind(this),
});
targetEvents.push({
name: 'touchmove',
handler: this.move.bind(this),
}, {
name: 'touchend',
handler: this.end.bind(this),
}, {
name: 'touchcancel',
handler: this.end.bind(this),
});
}
if (shouldRegisterMouse) {
wrapperEvents.push({
name: 'mousedown',
handler: this.start.bind(this),
});
targetEvents.push({
name: 'mousemove',
handler: this.move.bind(this),
}, {
name: 'mouseup',
handler: this.end.bind(this),
});
}
this.wrapperEventRegister = new EventRegister(wrapper, wrapperEvents);
this.targetEventRegister = new EventRegister(target, targetEvents);
};
ActionsHandler.prototype.beforeHandler = function (e, type) {
var _a = this.options, preventDefault = _a.preventDefault, stopPropagation = _a.stopPropagation, preventDefaultException = _a.preventDefaultException;
var preventDefaultConditions = {
start: function () {
return (preventDefault &&
!preventDefaultExceptionFn(e.target, preventDefaultException));
},
end: function () {
return (preventDefault &&
!preventDefaultExceptionFn(e.target, preventDefaultException));
},
move: function () {
return preventDefault;
},
};
if (preventDefaultConditions[type]()) {
e.preventDefault();
}
if (stopPropagation) {
e.stopPropagation();
}
};
ActionsHandler.prototype.setInitiated = function (type) {
if (type === void 0) { type = 0; }
this.initiated = type;
};
ActionsHandler.prototype.start = function (e) {
var _eventType = eventTypeMap[e.type];
if (this.initiated && this.initiated !== _eventType) {
return;
}
this.setInitiated(_eventType);
// if textarea or other html tags in options.tagException is manipulated
// do not make bs scroll
if (tagExceptionFn(e.target, this.options.tagException)) {
this.setInitiated();
return;
}
// only allow mouse left button
if (_eventType === 2 /* Mouse */ && e.button !== 0 /* Left */)
return;
if (this.hooks.trigger(this.hooks.eventTypes.beforeStart, e)) {
return;
}
this.beforeHandler(e, 'start');
var point = (e.touches ? e.touches[0] : e);
this.pointX = point.pageX;
this.pointY = point.pageY;
this.hooks.trigger(this.hooks.eventTypes.start, e);
};
ActionsHandler.prototype.move = function (e) {
if (eventTypeMap[e.type] !== this.initiated) {
return;
}
this.beforeHandler(e, 'move');
var point = (e.touches ? e.touches[0] : e);
var deltaX = point.pageX - this.pointX;
var deltaY = point.pageY - this.pointY;
this.pointX = point.pageX;
this.pointY = point.pageY;
if (this.hooks.trigger(this.hooks.eventTypes.move, {
deltaX: deltaX,
deltaY: deltaY,
e: e,
})) {
return;
}
// auto end when out of viewport
var scrollLeft = document.documentElement.scrollLeft ||
window.pageXOffset ||
document.body.scrollLeft;
var scrollTop = document.documentElement.scrollTop ||
window.pageYOffset ||
document.body.scrollTop;
var pX = this.pointX - scrollLeft;
var pY = this.pointY - scrollTop;
var autoEndDistance = this.options.autoEndDistance;
if (pX > document.documentElement.clientWidth - autoEndDistance ||
pY > document.documentElement.clientHeight - autoEndDistance ||
pX < autoEndDistance ||
pY < autoEndDistance) {
this.end(e);
}
};
ActionsHandler.prototype.end = function (e) {
if (eventTypeMap[e.type] !== this.initiated) {
return;
}
this.setInitiated();
this.beforeHandler(e, 'end');
this.hooks.trigger(this.hooks.eventTypes.end, e);
};
ActionsHandler.prototype.click = function (e) {
this.hooks.trigger(this.hooks.eventTypes.click, e);
};
ActionsHandler.prototype.setContent = function (content) {
if (content !== this.wrapper) {
this.wrapper = content;
this.rebindDOMEvents();
}
};
ActionsHandler.prototype.rebindDOMEvents = function () {
this.wrapperEventRegister.destroy();
this.targetEventRegister.destroy();
this.handleDOMEvents();
};
ActionsHandler.prototype.destroy = function () {
this.wrapperEventRegister.destroy();
this.targetEventRegister.destroy();
this.hooks.destroy();
};
return ActionsHandler;
}());
var translaterMetaData = {
x: ['translateX', 'px'],
y: ['translateY', 'px'],
};
var Translater = /** @class */ (function () {
function Translater(content) {
this.setContent(content);
this.hooks = new EventEmitter(['beforeTranslate', 'translate']);
}
Translater.prototype.getComputedPosition = function () {
var cssStyle = window.getComputedStyle(this.content, null);
var matrix = cssStyle[style.transform].split(')')[0].split(', ');
var x = +(matrix[12] || matrix[4]) || 0;
var y = +(matrix[13] || matrix[5]) || 0;
return {
x: x,
y: y,
};
};
Translater.prototype.translate = function (point) {
var transformStyle = [];
Object.keys(point).forEach(function (key) {
if (!translaterMetaData[key]) {
return;
}
var transformFnName = translaterMetaData[key][0];
if (transformFnName) {
var transformFnArgUnit = translaterMetaData[key][1];
var transformFnArg = point[key];
transformStyle.push(transformFnName + "(" + transformFnArg + transformFnArgUnit + ")");
}
});
this.hooks.trigger(this.hooks.eventTypes.beforeTranslate, transformStyle, point);
this.style[style.transform] = transformStyle.join(' ');
this.hooks.trigger(this.hooks.eventTypes.translate, point);
};
Translater.prototype.setContent = function (content) {
if (this.content !== content) {
this.content = content;
this.style = content.style;
}
};
Translater.prototype.destroy = function () {
this.hooks.destroy();
};
return Translater;
}());
var Base = /** @class */ (function () {
function Base(content, translater, options) {
this.translater = translater;
this.options = options;
this.timer = 0;
this.hooks = new EventEmitter([
'move',
'end',
'beforeForceStop',
'forceStop',
'callStop',
'time',
'timeFunction',
]);
this.setContent(content);
}
Base.prototype.translate = function (endPoint) {
this.translater.translate(endPoint);
};
Base.prototype.setPending = function (pending) {
this.pending = pending;
};
Base.prototype.setForceStopped = function (forceStopped) {
this.forceStopped = forceStopped;
};
Base.prototype.setCallStop = function (called) {
this.callStopWhenPending = called;
};
Base.prototype.setContent = function (content) {
if (this.content !== content) {
this.content = content;
this.style = content.style;
this.stop();
}
};
Base.prototype.clearTimer = function () {
if (this.timer) {
cancelAnimationFrame(this.timer);
this.timer = 0;
}
};
Base.prototype.destroy = function () {
this.hooks.destroy();
cancelAnimationFrame(this.timer);
};
return Base;
}());
// iOS 13.6 - 14.x, window.getComputedStyle sometimes will get wrong transform value
// when bs use transition mode
// eg: translateY -100px -> -200px, when the last frame which is about to scroll to -200px
// window.getComputedStyle(this.content) will calculate transformY to be -100px(startPoint)
// it is weird
// so we should validate position caculated by 'window.getComputedStyle'
var isValidPostion = function (startPoint, endPoint, currentPos, prePos) {
var computeDirection = function (endValue, startValue) {
var delta = endValue - startValue;
var direction = delta > 0
? -1 /* Negative */
: delta < 0
? 1 /* Positive */
: 0 /* Default */;
return direction;
};
var directionX = computeDirection(endPoint.x, startPoint.x);
var directionY = computeDirection(endPoint.y, startPoint.y);
var deltaX = currentPos.x - prePos.x;
var deltaY = currentPos.y - prePos.y;
return directionX * deltaX <= 0 && directionY * deltaY <= 0;
};
var Transition = /** @class */ (function (_super) {
__extends(Transition, _super);
function Transition() {
return _super !== null && _super.apply(this, arguments) || this;
}
Transition.prototype.startProbe = function (startPoint, endPoint) {
var _this = this;
var prePos = startPoint;
var probe = function () {
var pos = _this.translater.getComputedPosition();
if (isValidPostion(startPoint, endPoint, pos, prePos)) {
_this.hooks.trigger(_this.hooks.eventTypes.move, pos);
}
// call bs.stop() should not dispatch end hook again.
// forceStop hook will do this.
/* istanbul ignore if */
if (!_this.pending) {
if (_this.callStopWhenPending) {
_this.callStopWhenPending = false;
}
else {
// transition ends should dispatch end hook.
_this.hooks.trigger(_this.hooks.eventTypes.end, pos);
}
}
prePos = pos;
if (_this.pending) {
_this.timer = requestAnimationFrame(probe);
}
};
// when manually call bs.stop(), then bs.scrollTo()
// we should reset callStopWhenPending to dispatch end hook
if (this.callStopWhenPending) {
this.setCallStop(false);
}
cancelAnimationFrame(this.timer);
probe();
};
Transition.prototype.transitionTime = function (time) {
if (time === void 0) { time = 0; }
this.style[style.transitionDuration] = time + 'ms';
this.hooks.trigger(this.hooks.eventTypes.time, time);
};
Transition.prototype.transitionTimingFunction = function (easing) {
this.style[style.transitionTimingFunction] = easing;
this.hooks.trigger(this.hooks.eventTypes.timeFunction, easing);
};
Transition.prototype.transitionProperty = function () {
this.style[style.transitionProperty] = style.transform;
};
Transition.prototype.move = function (startPoint, endPoint, time, easingFn) {
this.setPending(time > 0);
this.transitionTimingFunction(easingFn);
this.transitionProperty();
this.transitionTime(time);
this.translate(endPoint);
var isRealtimeProbeType = this.options.probeType === 3 /* Realtime */;
if (time && isRealtimeProbeType) {
this.startProbe(startPoint, endPoint);
}
// if we change content's transformY in a tick
// such as: 0 -> 50px -> 0
// transitionend will not be triggered
// so we forceupdate by reflow
if (!time) {
this._reflow = this.content.offsetHeight;
if (isRealtimeProbeType) {
this.hooks.trigger(this.hooks.eventTypes.move, endPoint);
}
this.hooks.trigger(this.hooks.eventTypes.end, endPoint);
}
};
Transition.prototype.doStop = function () {
var pending = this.pending;
this.setForceStopped(false);
this.setCallStop(false);
// still in transition
if (pending) {
this.setPending(false);
cancelAnimationFrame(this.timer);
var _a = this.translater.getComputedPosition(), x = _a.x, y = _a.y;
this.transitionTime();
this.translate({ x: x, y: y });
this.setForceStopped(true);
this.setCallStop(true);
this.hooks.trigger(this.hooks.eventTypes.forceStop, { x: x, y: y });
}
return pending;
};
Transition.prototype.stop = function () {
var stopFromTransition = this.doStop();
if (stopFromTransition) {
this.hooks.trigger(this.hooks.eventTypes.callStop);
}
};
return Transition;
}(Base));
var Animation = /** @class */ (function (_super) {
__extends(Animation, _super);
function Animation() {
return _super !== null && _super.apply(this, arguments) || this;
}
Animation.prototype.move = function (startPoint, endPoint, time, easingFn) {
// time is 0
if (!time) {
this.translate(endPoint);
if (this.options.probeType === 3 /* Realtime */) {
this.hooks.trigger(this.hooks.eventTypes.move, endPoint);
}
this.hooks.trigger(this.hooks.eventTypes.end, endPoint);
return;
}
this.animate(startPoint, endPoint, time, easingFn);
};
Animation.prototype.animate = function (startPoint, endPoint, duration, easingFn) {
var _this = this;
var startTime = getNow();
var destTime = startTime + duration;
var isRealtimeProbeType = this.options.probeType === 3 /* Realtime */;
var step = function () {
var now = getNow();
// js animation end
if (now >= destTime) {
_this.translate(endPoint);
if (isRealtimeProbeType) {
_this.hooks.trigger(_this.hooks.eventTypes.move, endPoint);
}
_this.hooks.trigger(_this.hooks.eventTypes.end, endPoint);
return;
}
now = (now - startTime) / duration;
var easing = easingFn(now);
var newPoint = {};
Object.keys(endPoint).forEach(function (key) {
var startValue = startPoint[key];
var endValue = endPoint[key];
newPoint[key] = (endValue - startValue) * easing + startValue;
});
_this.translate(newPoint);
if (isRealtimeProbeType) {
_this.hooks.trigger(_this.hooks.eventTypes.move, newPoint);
}
if (_this.pending) {
_this.timer = requestAnimationFrame(step);
}
// call bs.stop() should not dispatch end hook again.
// forceStop hook will do this.
/* istanbul ignore if */
if (!_this.pending) {
if (_this.callStopWhenPending) {
_this.callStopWhenPending = false;
}
else {
// raf ends should dispatch end hook.
_this.hooks.trigger(_this.hooks.eventTypes.end, endPoint);
}
}
};
this.setPending(true);
// when manually call bs.stop(), then bs.scrollTo()
// we should reset callStopWhenPending to dispatch end hook
if (this.callStopWhenPending) {
this.setCallStop(false);
}
cancelAnimationFrame(this.timer);
step();
};
Animation.prototype.doStop = function () {
var pending = this.pending;
this.setForceStopped(false);
this.setCallStop(false);
// still in requestFrameAnimation
if (pending) {
this.setPending(false);
cancelAnimationFrame(this.timer);
var pos = this.translater.getComputedPosition();
this.setForceStopped(true);
this.setCallStop(true);
this.hooks.trigger(this.hooks.eventTypes.forceStop, pos);
}
return pending;
};
Animation.prototype.stop = function () {
var stopFromAnimation = this.doStop();
if (stopFromAnimation) {
this.hooks.trigger(this.hooks.eventTypes.callStop);
}
};
return Animation;
}(Base));
function createAnimater(element, translater, options) {
var useTransition = options.useTransition;
var animaterOptions = {};
Object.defineProperty(animaterOptions, 'probeType', {
enumerable: true,
configurable: false,
get: function () {
return options.probeType;
},
});
if (useTransition) {
return new Transition(element, translater, animaterOptions);
}
else {
return new Animation(element, translater, animaterOptions);
}
}
var Behavior = /** @class */ (function () {
function Behavior(wrapper, content, options) {
this.wrapper = wrapper;
this.options = options;
this.hooks = new EventEmitter([
'beforeComputeBoundary',
'computeBoundary',
'momentum',
'end',
'ignoreHasScroll'
]);
this.refresh(content);
}
Behavior.prototype.start = function () {
this.dist = 0;
this.setMovingDirection(0 /* Default */);
this.setDirection(0 /* Default */);
};
Behavior.prototype.move = function (delta) {
delta = this.hasScroll ? delta : 0;
this.setMovingDirection(delta);
return this.performDampingAlgorithm(delta, this.options.outOfBoundaryDampingFactor);
};
Behavior.prototype.setMovingDirection = function (delta) {
this.movingDirection =
delta > 0
? -1 /* Negative */
: delta < 0
? 1 /* Positive */
: 0 /* Default */;
};
Behavior.prototype.setDirection = function (delta) {
this.direction =
delta > 0
? -1 /* Negative */
: delta < 0
? 1 /* Positive */
: 0 /* Default */;
};
Behavior.prototype.performDampingAlgorithm = function (delta, dampingFactor) {
var newPos = this.currentPos + delta;
// Slow down or stop if outside of the boundaries
if (newPos > this.minScrollPos || newPos < this.maxScrollPos) {
if ((newPos > this.minScrollPos && this.options.bounces[0]) ||
(newPos < this.maxScrollPos && this.options.bounces[1])) {
newPos = this.currentPos + delta * dampingFactor;
}
else {
newPos =
newPos > this.minScrollPos ? this.minScrollPos : this.maxScrollPos;
}
}
return newPos;
};
Behavior.prototype.end = function (duration) {
var momentumInfo = {
duration: 0
};
var absDist = Math.abs(this.currentPos - this.startPos);