cbvirtua 1.0.106 → 1.0.107

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Animation.js

@@ -0,0 +1,111 @@
+var __extends = (this && this.__extends) || (function () {
+    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);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import Base from './Base';
+import { getNow, requestAnimationFrame, cancelAnimationFrame, } from '@better-scroll/shared-utils';
+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 /* Probe.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 /* Probe.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));
+export default Animation;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Base.d.ts

@@ -0,0 +1,33 @@
+import { EaseFn, safeCSSStyleDeclaration, EventEmitter } from '@better-scroll/shared-utils';
+import Translater, { TranslaterPoint } from '../translater';
+export interface ExposedAPI {
+    stop(): void;
+}
+export default abstract class Base implements ExposedAPI {
+    translater: Translater;
+    options: {
+        probeType: number;
+    };
+    content: HTMLElement;
+    style: safeCSSStyleDeclaration;
+    hooks: EventEmitter;
+    timer: number;
+    pending: boolean;
+    callStopWhenPending: boolean;
+    forceStopped: boolean;
+    _reflow: number;
+    [key: string]: any;
+    constructor(content: HTMLElement, translater: Translater, options: {
+        probeType: number;
+    });
+    translate(endPoint: TranslaterPoint): void;
+    setPending(pending: boolean): void;
+    setForceStopped(forceStopped: boolean): void;
+    setCallStop(called: boolean): void;
+    setContent(content: HTMLElement): void;
+    clearTimer(): void;
+    abstract move(startPoint: TranslaterPoint, endPoint: TranslaterPoint, time: number, easing: string | EaseFn): void;
+    abstract doStop(): void;
+    abstract stop(): void;
+    destroy(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Base.js

@@ -0,0 +1,49 @@
+import { cancelAnimationFrame, EventEmitter, } from '@better-scroll/shared-utils';
+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;
+}());
+export default Base;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Transition.d.ts

@@ -0,0 +1,12 @@
+import { EaseFn } from '@better-scroll/shared-utils';
+import Base from './Base';
+import { TranslaterPoint } from '../translater';
+export default class Transition extends Base {
+    startProbe(startPoint: TranslaterPoint, endPoint: TranslaterPoint): void;
+    transitionTime(time?: number): void;
+    transitionTimingFunction(easing: string): void;
+    transitionProperty(): void;
+    move(startPoint: TranslaterPoint, endPoint: TranslaterPoint, time: number, easingFn: string | EaseFn): void;
+    doStop(): boolean;
+    stop(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Transition.js

@@ -0,0 +1,116 @@
+var __extends = (this && this.__extends) || (function () {
+    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);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { style, requestAnimationFrame, cancelAnimationFrame, } from '@better-scroll/shared-utils';
+import Base from './Base';
+import { isValidPostion } from '../utils/compat';
+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 /* Probe.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));
+export default Transition;

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

@@ -0,0 +1,7 @@
+import Translater from '../translater';
+import { Options as BScrollOptions } from '../Options';
+import Animater from './Base';
+import Transition from './Transition';
+import Animation from './Animation';
+export { Animater, Transition, Animation };
+export default function createAnimater(element: HTMLElement, translater: Translater, options: BScrollOptions): Transition | Animation;

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

@@ -0,0 +1,21 @@
+import Animater from './Base';
+import Transition from './Transition';
+import Animation from './Animation';
+export { Animater, Transition, Animation };
+export default 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);
+    }
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/base/ActionsHandler.d.ts

@@ -0,0 +1,39 @@
+import { EventRegister, EventEmitter } from '@better-scroll/shared-utils';
+type Exception = {
+    tagName?: RegExp;
+    className?: RegExp;
+};
+export interface Options {
+    [key: string]: boolean | number | Exception;
+    click: boolean;
+    bindToWrapper: boolean;
+    disableMouse: boolean;
+    disableTouch: boolean;
+    preventDefault: boolean;
+    stopPropagation: boolean;
+    preventDefaultException: Exception;
+    tagException: Exception;
+    autoEndDistance: number;
+}
+export default class ActionsHandler {
+    wrapper: HTMLElement;
+    options: Options;
+    hooks: EventEmitter;
+    initiated: number;
+    pointX: number;
+    pointY: number;
+    wrapperEventRegister: EventRegister;
+    targetEventRegister: EventRegister;
+    constructor(wrapper: HTMLElement, options: Options);
+    private handleDOMEvents;
+    private beforeHandler;
+    setInitiated(type?: number): void;
+    private start;
+    private move;
+    private end;
+    private click;
+    setContent(content: HTMLElement): void;
+    rebindDOMEvents(): void;
+    destroy(): void;
+}
+export {};

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/base/ActionsHandler.js

@@ -0,0 +1,177 @@
+import { 
+// dom
+preventDefaultExceptionFn, tagExceptionFn, eventTypeMap, EventRegister, EventEmitter, } from '@better-scroll/shared-utils';
+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 /* EventType.Mouse */ && e.button !== 0 /* MouseButton.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;
+}());
+export default ActionsHandler;

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

@@ -0,0 +1,8 @@
+import { BScroll } from './BScroll';
+export { BScrollInstance } from './Instance';
+export { Options, CustomOptions } from './Options';
+export { TranslaterPoint } from './translater';
+export { MountedBScrollHTMLElement } from './BScroll';
+export { Behavior, Boundary } from './scroller/Behavior';
+export { createBScroll, CustomAPI } from './BScroll';
+export default BScroll;

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

@@ -0,0 +1,5 @@
+import { BScroll } from './BScroll';
+export { CustomOptions } from './Options';
+export { Behavior } from './scroller/Behavior';
+export { createBScroll } from './BScroll';
+export default BScroll;

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

@@ -0,0 +1,34 @@
+import ActionsHandler from '../base/ActionsHandler';
+import { Behavior } from './Behavior';
+import DirectionLockAction from './DirectionLock';
+import { Animater } from '../animater';
+import { OptionsConstructor as BScrollOptions } from '../Options';
+import { TranslaterPoint } from '../translater';
+import { EventEmitter } from '@better-scroll/shared-utils';
+export default class ScrollerActions {
+    hooks: EventEmitter;
+    scrollBehaviorX: Behavior;
+    scrollBehaviorY: Behavior;
+    actionsHandler: ActionsHandler;
+    animater: Animater;
+    options: BScrollOptions;
+    directionLockAction: DirectionLockAction;
+    fingerMoved: boolean;
+    contentMoved: boolean;
+    enabled: boolean;
+    startTime: number;
+    endTime: number;
+    ensuringInteger: boolean;
+    constructor(scrollBehaviorX: Behavior, scrollBehaviorY: Behavior, actionsHandler: ActionsHandler, animater: Animater, options: BScrollOptions);
+    private bindActionsHandler;
+    private handleStart;
+    private handleMove;
+    private dispatchScroll;
+    private checkMomentum;
+    private handleEnd;
+    private ensureIntegerPos;
+    private handleClick;
+    getCurrentPos(): TranslaterPoint;
+    refresh(): void;
+    destroy(): void;
+}