cbvirtua 1.0.106 → 1.0.107

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/Scroller.js

@@ -0,0 +1,456 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+import ActionsHandler from '../base/ActionsHandler';
+import Translater from '../translater';
+import createAnimater from '../animater';
+import { Behavior } from './Behavior';
+import ScrollerActions from './Actions';
+import { createActionsHandlerOptions, createBehaviorOptions, } from './createOptions';
+import { getElement, ease, offset, style, preventDefaultExceptionFn, isAndroid, isIOSBadVersion, click, dblclick, tap, isUndef, getNow, cancelAnimationFrame, EventEmitter, EventRegister, } from '@better-scroll/shared-utils';
+import { bubbling } from '../utils/bubbling';
+import { isSamePoint } from '../utils/compare';
+var MIN_SCROLL_DISTANCE = 1;
+var Scroller = /** @class */ (function () {
+    function Scroller(wrapper, content, options) {
+        this.wrapper = wrapper;
+        this.content = content;
+        this.resizeTimeout = 0;
+        this.hooks = new EventEmitter([
+            'beforeStart',
+            'beforeMove',
+            'beforeScrollStart',
+            'scrollStart',
+            'scroll',
+            'beforeEnd',
+            'scrollEnd',
+            'resize',
+            'touchEnd',
+            'end',
+            'flick',
+            'scrollCancel',
+            'momentum',
+            'scrollTo',
+            'minDistanceScroll',
+            'scrollToElement',
+            'beforeRefresh',
+        ]);
+        this.options = options;
+        var _a = this.options.bounce, left = _a.left, right = _a.right, top = _a.top, bottom = _a.bottom;
+        // direction X
+        this.scrollBehaviorX = new Behavior(wrapper, content, createBehaviorOptions(options, 'scrollX', [left, right], {
+            size: 'width',
+            position: 'left',
+        }));
+        // direction Y
+        this.scrollBehaviorY = new Behavior(wrapper, content, createBehaviorOptions(options, 'scrollY', [top, bottom], {
+            size: 'height',
+            position: 'top',
+        }));
+        this.translater = new Translater(this.content);
+        this.animater = createAnimater(this.content, this.translater, this.options);
+        this.actionsHandler = new ActionsHandler(this.options.bindToTarget ? this.content : wrapper, createActionsHandlerOptions(this.options));
+        this.actions = new ScrollerActions(this.scrollBehaviorX, this.scrollBehaviorY, this.actionsHandler, this.animater, this.options);
+        var resizeHandler = this.resize.bind(this);
+        this.resizeRegister = new EventRegister(window, [
+            {
+                name: 'orientationchange',
+                handler: resizeHandler,
+            },
+            {
+                name: 'resize',
+                handler: resizeHandler,
+            },
+        ]);
+        this.registerTransitionEnd();
+        this.init();
+    }
+    Scroller.prototype.init = function () {
+        var _this = this;
+        this.bindTranslater();
+        this.bindAnimater();
+        this.bindActions();
+        // enable pointer events when scrolling ends
+        this.hooks.on(this.hooks.eventTypes.scrollEnd, function () {
+            _this.togglePointerEvents(true);
+        });
+    };
+    Scroller.prototype.registerTransitionEnd = function () {
+        this.transitionEndRegister = new EventRegister(this.content, [
+            {
+                name: style.transitionEnd,
+                handler: this.transitionEnd.bind(this),
+            },
+        ]);
+    };
+    Scroller.prototype.bindTranslater = function () {
+        var _this = this;
+        var hooks = this.translater.hooks;
+        hooks.on(hooks.eventTypes.beforeTranslate, function (transformStyle) {
+            if (_this.options.translateZ) {
+                transformStyle.push(_this.options.translateZ);
+            }
+        });
+        // disable pointer events when scrolling
+        hooks.on(hooks.eventTypes.translate, function (pos) {
+            var prevPos = _this.getCurrentPos();
+            _this.updatePositions(pos);
+            // scrollEnd will dispatch when scroll is force stopping in touchstart handler
+            // so in touchend handler, don't toggle pointer-events
+            if (_this.actions.ensuringInteger === true) {
+                _this.actions.ensuringInteger = false;
+                return;
+            }
+            // a valid translate
+            if (pos.x !== prevPos.x || pos.y !== prevPos.y) {
+                _this.togglePointerEvents(false);
+            }
+        });
+    };
+    Scroller.prototype.bindAnimater = function () {
+        var _this = this;
+        // reset position
+        this.animater.hooks.on(this.animater.hooks.eventTypes.end, function (pos) {
+            if (!_this.resetPosition(_this.options.bounceTime)) {
+                _this.animater.setPending(false);
+                _this.hooks.trigger(_this.hooks.eventTypes.scrollEnd, pos);
+            }
+        });
+        bubbling(this.animater.hooks, this.hooks, [
+            {
+                source: this.animater.hooks.eventTypes.move,
+                target: this.hooks.eventTypes.scroll,
+            },
+            {
+                source: this.animater.hooks.eventTypes.forceStop,
+                target: this.hooks.eventTypes.scrollEnd,
+            },
+        ]);
+    };
+    Scroller.prototype.bindActions = function () {
+        var _this = this;
+        var actions = this.actions;
+        bubbling(actions.hooks, this.hooks, [
+            {
+                source: actions.hooks.eventTypes.start,
+                target: this.hooks.eventTypes.beforeStart,
+            },
+            {
+                source: actions.hooks.eventTypes.start,
+                target: this.hooks.eventTypes.beforeScrollStart, // just for event api
+            },
+            {
+                source: actions.hooks.eventTypes.beforeMove,
+                target: this.hooks.eventTypes.beforeMove,
+            },
+            {
+                source: actions.hooks.eventTypes.scrollStart,
+                target: this.hooks.eventTypes.scrollStart,
+            },
+            {
+                source: actions.hooks.eventTypes.scroll,
+                target: this.hooks.eventTypes.scroll,
+            },
+            {
+                source: actions.hooks.eventTypes.beforeEnd,
+                target: this.hooks.eventTypes.beforeEnd,
+            },
+        ]);
+        actions.hooks.on(actions.hooks.eventTypes.end, function (e, pos) {
+            _this.hooks.trigger(_this.hooks.eventTypes.touchEnd, pos);
+            if (_this.hooks.trigger(_this.hooks.eventTypes.end, pos)) {
+                return true;
+            }
+            // check if it is a click operation
+            if (!actions.fingerMoved) {
+                _this.hooks.trigger(_this.hooks.eventTypes.scrollCancel);
+                if (_this.checkClick(e)) {
+                    return true;
+                }
+            }
+            // reset if we are outside of the boundaries
+            if (_this.resetPosition(_this.options.bounceTime, ease.bounce)) {
+                _this.animater.setForceStopped(false);
+                return true;
+            }
+        });
+        actions.hooks.on(actions.hooks.eventTypes.scrollEnd, function (pos, duration) {
+            var deltaX = Math.abs(pos.x - _this.scrollBehaviorX.startPos);
+            var deltaY = Math.abs(pos.y - _this.scrollBehaviorY.startPos);
+            if (_this.checkFlick(duration, deltaX, deltaY)) {
+                _this.animater.setForceStopped(false);
+                _this.hooks.trigger(_this.hooks.eventTypes.flick);
+                return;
+            }
+            if (_this.momentum(pos, duration)) {
+                _this.animater.setForceStopped(false);
+                return;
+            }
+            if (actions.contentMoved) {
+                _this.hooks.trigger(_this.hooks.eventTypes.scrollEnd, pos);
+            }
+            if (_this.animater.forceStopped) {
+                _this.animater.setForceStopped(false);
+            }
+        });
+    };
+    Scroller.prototype.checkFlick = function (duration, deltaX, deltaY) {
+        var flickMinMovingDistance = 1; // distinguish flick from click
+        if (this.hooks.events.flick.length > 1 &&
+            duration < this.options.flickLimitTime &&
+            deltaX < this.options.flickLimitDistance &&
+            deltaY < this.options.flickLimitDistance &&
+            (deltaY > flickMinMovingDistance || deltaX > flickMinMovingDistance)) {
+            return true;
+        }
+    };
+    Scroller.prototype.momentum = function (pos, duration) {
+        var meta = {
+            time: 0,
+            easing: ease.swiper,
+            newX: pos.x,
+            newY: pos.y,
+        };
+        // start momentum animation if needed
+        var momentumX = this.scrollBehaviorX.end(duration);
+        var momentumY = this.scrollBehaviorY.end(duration);
+        meta.newX = isUndef(momentumX.destination)
+            ? meta.newX
+            : momentumX.destination;
+        meta.newY = isUndef(momentumY.destination)
+            ? meta.newY
+            : momentumY.destination;
+        meta.time = Math.max(momentumX.duration, momentumY.duration);
+        this.hooks.trigger(this.hooks.eventTypes.momentum, meta, this);
+        // when x or y changed, do momentum animation now!
+        if (meta.newX !== pos.x || meta.newY !== pos.y) {
+            // change easing function when scroller goes out of the boundaries
+            if (meta.newX > this.scrollBehaviorX.minScrollPos ||
+                meta.newX < this.scrollBehaviorX.maxScrollPos ||
+                meta.newY > this.scrollBehaviorY.minScrollPos ||
+                meta.newY < this.scrollBehaviorY.maxScrollPos) {
+                meta.easing = ease.swipeBounce;
+            }
+            this.scrollTo(meta.newX, meta.newY, meta.time, meta.easing);
+            return true;
+        }
+    };
+    Scroller.prototype.checkClick = function (e) {
+        var cancelable = {
+            preventClick: this.animater.forceStopped,
+        };
+        // we scrolled less than momentumLimitDistance pixels
+        if (this.hooks.trigger(this.hooks.eventTypes.checkClick)) {
+            this.animater.setForceStopped(false);
+            return true;
+        }
+        if (!cancelable.preventClick) {
+            var _dblclick = this.options.dblclick;
+            var dblclickTrigged = false;
+            if (_dblclick && this.lastClickTime) {
+                var _a = _dblclick.delay, delay = _a === void 0 ? 300 : _a;
+                if (getNow() - this.lastClickTime < delay) {
+                    dblclickTrigged = true;
+                    dblclick(e);
+                }
+            }
+            if (this.options.tap) {
+                tap(e, this.options.tap);
+            }
+            if (this.options.click &&
+                !preventDefaultExceptionFn(e.target, this.options.preventDefaultException)) {
+                click(e);
+            }
+            this.lastClickTime = dblclickTrigged ? null : getNow();
+            return true;
+        }
+        return false;
+    };
+    Scroller.prototype.resize = function () {
+        var _this = this;
+        if (!this.actions.enabled) {
+            return;
+        }
+        // fix a scroll problem under Android condition
+        /* istanbul ignore if  */
+        if (isAndroid) {
+            this.wrapper.scrollTop = 0;
+        }
+        clearTimeout(this.resizeTimeout);
+        this.resizeTimeout = window.setTimeout(function () {
+            _this.hooks.trigger(_this.hooks.eventTypes.resize);
+        }, this.options.resizePolling);
+    };
+    /* istanbul ignore next */
+    Scroller.prototype.transitionEnd = function (e) {
+        if (e.target !== this.content || !this.animater.pending) {
+            return;
+        }
+        var animater = this.animater;
+        animater.transitionTime();
+        if (!this.resetPosition(this.options.bounceTime, ease.bounce)) {
+            this.animater.setPending(false);
+            if (this.options.probeType !== 3 /* Probe.Realtime */) {
+                this.hooks.trigger(this.hooks.eventTypes.scrollEnd, this.getCurrentPos());
+            }
+        }
+    };
+    Scroller.prototype.togglePointerEvents = function (enabled) {
+        if (enabled === void 0) { enabled = true; }
+        var el = this.content.children.length
+            ? this.content.children
+            : [this.content];
+        var pointerEvents = enabled ? 'auto' : 'none';
+        for (var i = 0; i < el.length; i++) {
+            var node = el[i];
+            // ignore BetterScroll instance's wrapper DOM
+            /* istanbul ignore if  */
+            if (node.isBScrollContainer) {
+                continue;
+            }
+            node.style.pointerEvents = pointerEvents;
+        }
+    };
+    Scroller.prototype.refresh = function (content) {
+        var contentChanged = this.setContent(content);
+        this.hooks.trigger(this.hooks.eventTypes.beforeRefresh);
+        this.scrollBehaviorX.refresh(content);
+        this.scrollBehaviorY.refresh(content);
+        if (contentChanged) {
+            this.translater.setContent(content);
+            this.animater.setContent(content);
+            this.transitionEndRegister.destroy();
+            this.registerTransitionEnd();
+            if (this.options.bindToTarget) {
+                this.actionsHandler.setContent(content);
+            }
+        }
+        this.actions.refresh();
+        this.wrapperOffset = offset(this.wrapper);
+    };
+    Scroller.prototype.setContent = function (content) {
+        var contentChanged = content !== this.content;
+        if (contentChanged) {
+            this.content = content;
+        }
+        return contentChanged;
+    };
+    Scroller.prototype.scrollBy = function (deltaX, deltaY, time, easing) {
+        if (time === void 0) { time = 0; }
+        var _a = this.getCurrentPos(), x = _a.x, y = _a.y;
+        easing = !easing ? ease.bounce : easing;
+        deltaX += x;
+        deltaY += y;
+        this.scrollTo(deltaX, deltaY, time, easing);
+    };
+    Scroller.prototype.scrollTo = function (x, y, time, easing, extraTransform) {
+        if (time === void 0) { time = 0; }
+        if (easing === void 0) { easing = ease.bounce; }
+        if (extraTransform === void 0) { extraTransform = {
+            start: {},
+            end: {},
+        }; }
+        var easingFn = this.options.useTransition ? easing.style : easing.fn;
+        var currentPos = this.getCurrentPos();
+        var startPoint = __assign({ x: currentPos.x, y: currentPos.y }, extraTransform.start);
+        var endPoint = __assign({ x: x, y: y }, extraTransform.end);
+        this.hooks.trigger(this.hooks.eventTypes.scrollTo, endPoint);
+        // it is an useless move
+        if (isSamePoint(startPoint, endPoint))
+            return;
+        var deltaX = Math.abs(endPoint.x - startPoint.x);
+        var deltaY = Math.abs(endPoint.y - startPoint.y);
+        // considering of browser compatibility for decimal transform value
+        // force translating immediately
+        if (deltaX < MIN_SCROLL_DISTANCE && deltaY < MIN_SCROLL_DISTANCE) {
+            time = 0;
+            this.hooks.trigger(this.hooks.eventTypes.minDistanceScroll);
+        }
+        this.animater.move(startPoint, endPoint, time, easingFn);
+    };
+    Scroller.prototype.scrollToElement = function (el, time, offsetX, offsetY, easing) {
+        var targetEle = getElement(el);
+        var pos = offset(targetEle);
+        var getOffset = function (offset, size, wrapperSize) {
+            if (typeof offset === 'number') {
+                return offset;
+            }
+            // if offsetX/Y are true we center the element to the screen
+            return offset ? Math.round(size / 2 - wrapperSize / 2) : 0;
+        };
+        offsetX = getOffset(offsetX, targetEle.offsetWidth, this.wrapper.offsetWidth);
+        offsetY = getOffset(offsetY, targetEle.offsetHeight, this.wrapper.offsetHeight);
+        var getPos = function (pos, wrapperPos, offset, scrollBehavior) {
+            pos -= wrapperPos;
+            pos = scrollBehavior.adjustPosition(pos - offset);
+            return pos;
+        };
+        pos.left = getPos(pos.left, this.wrapperOffset.left, offsetX, this.scrollBehaviorX);
+        pos.top = getPos(pos.top, this.wrapperOffset.top, offsetY, this.scrollBehaviorY);
+        if (this.hooks.trigger(this.hooks.eventTypes.scrollToElement, targetEle, pos)) {
+            return;
+        }
+        this.scrollTo(pos.left, pos.top, time, easing);
+    };
+    Scroller.prototype.resetPosition = function (time, easing) {
+        if (time === void 0) { time = 0; }
+        if (easing === void 0) { easing = ease.bounce; }
+        var _a = this.scrollBehaviorX.checkInBoundary(), x = _a.position, xInBoundary = _a.inBoundary;
+        var _b = this.scrollBehaviorY.checkInBoundary(), y = _b.position, yInBoundary = _b.inBoundary;
+        if (xInBoundary && yInBoundary) {
+            return false;
+        }
+        /* istanbul ignore if  */
+        if (isIOSBadVersion) {
+            // fix ios 13.4 bouncing
+            // see it in issues 982
+            this.reflow();
+        }
+        // out of boundary
+        this.scrollTo(x, y, time, easing);
+        return true;
+    };
+    /* istanbul ignore next */
+    Scroller.prototype.reflow = function () {
+        this._reflow = this.content.offsetHeight;
+    };
+    Scroller.prototype.updatePositions = function (pos) {
+        this.scrollBehaviorX.updatePosition(pos.x);
+        this.scrollBehaviorY.updatePosition(pos.y);
+    };
+    Scroller.prototype.getCurrentPos = function () {
+        return this.actions.getCurrentPos();
+    };
+    Scroller.prototype.enable = function () {
+        this.actions.enabled = true;
+    };
+    Scroller.prototype.disable = function () {
+        cancelAnimationFrame(this.animater.timer);
+        this.actions.enabled = false;
+    };
+    Scroller.prototype.destroy = function () {
+        var _this = this;
+        var keys = [
+            'resizeRegister',
+            'transitionEndRegister',
+            'actionsHandler',
+            'actions',
+            'hooks',
+            'animater',
+            'translater',
+            'scrollBehaviorX',
+            'scrollBehaviorY',
+        ];
+        keys.forEach(function (key) { return _this[key].destroy(); });
+    };
+    return Scroller;
+}());
+export default Scroller;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/createOptions.d.ts

@@ -0,0 +1,5 @@
+import { Options as BScrollOptions } from '../Options';
+import { Options as ActionsHandlerOptions } from '../base/ActionsHandler';
+import { Options as BehaviorOptions, Bounces, Rect } from './Behavior';
+export declare function createActionsHandlerOptions(bsOptions: BScrollOptions): ActionsHandlerOptions;
+export declare function createBehaviorOptions(bsOptions: BScrollOptions, extraProp: 'scrollX' | 'scrollY', bounces: Bounces, rect: Rect): BehaviorOptions;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/scroller/createOptions.js

@@ -0,0 +1,37 @@
+export function createActionsHandlerOptions(bsOptions) {
+    var options = [
+        'click',
+        'bindToWrapper',
+        'disableMouse',
+        'disableTouch',
+        'preventDefault',
+        'stopPropagation',
+        'tagException',
+        'preventDefaultException',
+        'autoEndDistance',
+    ].reduce(function (prev, cur) {
+        prev[cur] = bsOptions[cur];
+        return prev;
+    }, {});
+    return options;
+}
+export function createBehaviorOptions(bsOptions, extraProp, bounces, rect) {
+    var options = [
+        'momentum',
+        'momentumLimitTime',
+        'momentumLimitDistance',
+        'deceleration',
+        'swipeBounceTime',
+        'swipeTime',
+        'outOfBoundaryDampingFactor',
+        'specifiedIndexAsContent',
+    ].reduce(function (prev, cur) {
+        prev[cur] = bsOptions[cur];
+        return prev;
+    }, {});
+    // add extra property
+    options.scrollable = !!bsOptions[extraProp];
+    options.bounces = bounces;
+    options.rect = rect;
+    return options;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/translater/index.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '@better-scroll/shared-utils';
+export interface TranslaterPoint {
+    x: number;
+    y: number;
+    [key: string]: number;
+}
+export default class Translater {
+    content: HTMLElement;
+    style: CSSStyleDeclaration;
+    hooks: EventEmitter;
+    constructor(content: HTMLElement);
+    getComputedPosition(): {
+        x: number;
+        y: number;
+    };
+    translate(point: TranslaterPoint): void;
+    setContent(content: HTMLElement): void;
+    destroy(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/translater/index.js

@@ -0,0 +1,49 @@
+import { style, EventEmitter, } from '@better-scroll/shared-utils';
+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("".concat(transformFnName, "(").concat(transformFnArg).concat(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;
+}());
+export default Translater;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/bubbling.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from '@better-scroll/shared-utils';
+interface BubblingEventMap {
+    source: string;
+    target: string;
+}
+type BubblingEventConfig = BubblingEventMap | string;
+export declare function bubbling(source: EventEmitter, target: EventEmitter, events: BubblingEventConfig[]): void;
+export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/bubbling.js

@@ -0,0 +1,29 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+export function bubbling(source, target, events) {
+    events.forEach(function (event) {
+        var sourceEvent;
+        var targetEvent;
+        if (typeof event === 'string') {
+            sourceEvent = targetEvent = event;
+        }
+        else {
+            sourceEvent = event.source;
+            targetEvent = event.target;
+        }
+        source.on(sourceEvent, function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return target.trigger.apply(target, __spreadArray([targetEvent], args, false));
+        });
+    });
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compare.d.ts

@@ -0,0 +1,2 @@
+import { TranslaterPoint } from '../translater';
+export declare function isSamePoint(startPoint: TranslaterPoint, endPoint: TranslaterPoint): boolean;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compare.js

@@ -0,0 +1,10 @@
+export function isSamePoint(startPoint, endPoint) {
+    // keys of startPoint and endPoint should be equal
+    var keys = Object.keys(startPoint);
+    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+        var key = keys_1[_i];
+        if (startPoint[key] !== endPoint[key])
+            return false;
+    }
+    return true;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compat.d.ts

@@ -0,0 +1,7 @@
+import { TranslaterPoint } from '../translater';
+type Position = {
+    x: number;
+    y: number;
+};
+export declare const isValidPostion: (startPoint: TranslaterPoint, endPoint: TranslaterPoint, currentPos: Position, prePos: Position) => boolean;
+export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/compat.js

@@ -0,0 +1,22 @@
+// 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'
+export var isValidPostion = function (startPoint, endPoint, currentPos, prePos) {
+    var computeDirection = function (endValue, startValue) {
+        var delta = endValue - startValue;
+        var direction = delta > 0
+            ? -1 /* Direction.Negative */
+            : delta < 0
+                ? 1 /* Direction.Positive */
+                : 0 /* Direction.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;
+};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/typesHelper.d.ts

@@ -0,0 +1 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/utils/typesHelper.js

@@ -0,0 +1 @@
+export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/indicators/src/index.d.ts

@@ -0,0 +1,18 @@
+import BScroll from '@better-scroll/core';
+import Indicator from './indicator';
+import { IndicatorOptions } from './types';
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        indicators?: IndicatorOptions[];
+    }
+}
+export default class Indicators {
+    scroll: BScroll;
+    static pluginName: string;
+    options: IndicatorOptions[];
+    indicators: Indicator[];
+    constructor(scroll: BScroll);
+    private handleOptions;
+    private createIndicators;
+    private handleHooks;
+}