cbvirtua 1.0.106 → 1.0.107

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

@@ -0,0 +1,231 @@
+import { warn, preventDefaultExceptionFn, EventRegister, extend, maybePrevent, } from '@better-scroll/shared-utils';
+var MouseWheel = /** @class */ (function () {
+    function MouseWheel(scroll) {
+        this.scroll = scroll;
+        this.wheelEndTimer = 0;
+        this.wheelMoveTimer = 0;
+        this.wheelStart = false;
+        this.init();
+    }
+    MouseWheel.prototype.init = function () {
+        this.handleBScroll();
+        this.handleOptions();
+        this.handleHooks();
+        this.registerEvent();
+    };
+    MouseWheel.prototype.handleBScroll = function () {
+        this.scroll.registerType([
+            'alterOptions',
+            'mousewheelStart',
+            'mousewheelMove',
+            'mousewheelEnd',
+        ]);
+    };
+    MouseWheel.prototype.handleOptions = function () {
+        var userOptions = (this.scroll.options.mouseWheel === true
+            ? {}
+            : this.scroll.options.mouseWheel);
+        var defaultOptions = {
+            speed: 20,
+            invert: false,
+            easeTime: 300,
+            discreteTime: 400,
+            throttleTime: 0,
+            dampingFactor: 0.1,
+        };
+        this.mouseWheelOpt = extend(defaultOptions, userOptions);
+    };
+    MouseWheel.prototype.handleHooks = function () {
+        this.hooksFn = [];
+        this.registerHooks(this.scroll.hooks, 'destroy', this.destroy);
+    };
+    MouseWheel.prototype.registerEvent = function () {
+        this.eventRegister = new EventRegister(this.scroll.scroller.wrapper, [
+            {
+                name: 'wheel',
+                handler: this.wheelHandler.bind(this),
+            },
+            {
+                name: 'mousewheel',
+                handler: this.wheelHandler.bind(this),
+            },
+            {
+                name: 'DOMMouseScroll', // FireFox
+                handler: this.wheelHandler.bind(this),
+            },
+        ]);
+    };
+    MouseWheel.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    MouseWheel.prototype.wheelHandler = function (e) {
+        if (!this.scroll.enabled) {
+            return;
+        }
+        this.beforeHandler(e);
+        // start
+        if (!this.wheelStart) {
+            this.wheelStartHandler(e);
+            this.wheelStart = true;
+        }
+        // move
+        var delta = this.getWheelDelta(e);
+        this.wheelMoveHandler(delta);
+        // end
+        this.wheelEndDetector(delta);
+    };
+    MouseWheel.prototype.wheelStartHandler = function (e) {
+        this.cleanCache();
+        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
+        scrollBehaviorX.setMovingDirection(0 /* Direction.Default */);
+        scrollBehaviorY.setMovingDirection(0 /* Direction.Default */);
+        scrollBehaviorX.setDirection(0 /* Direction.Default */);
+        scrollBehaviorY.setDirection(0 /* Direction.Default */);
+        this.scroll.trigger(this.scroll.eventTypes.alterOptions, this.mouseWheelOpt);
+        this.scroll.trigger(this.scroll.eventTypes.mousewheelStart);
+    };
+    MouseWheel.prototype.cleanCache = function () {
+        this.deltaCache = [];
+    };
+    MouseWheel.prototype.wheelMoveHandler = function (delta) {
+        var _this = this;
+        var _a = this.mouseWheelOpt, throttleTime = _a.throttleTime, dampingFactor = _a.dampingFactor;
+        if (throttleTime && this.wheelMoveTimer) {
+            this.deltaCache.push(delta);
+        }
+        else {
+            var cachedDelta = this.deltaCache.reduce(function (prev, current) {
+                return {
+                    x: prev.x + current.x,
+                    y: prev.y + current.y,
+                };
+            }, { x: 0, y: 0 });
+            this.cleanCache();
+            var _b = this.scroll.scroller, scrollBehaviorX = _b.scrollBehaviorX, scrollBehaviorY = _b.scrollBehaviorY;
+            scrollBehaviorX.setMovingDirection(-delta.directionX);
+            scrollBehaviorY.setMovingDirection(-delta.directionY);
+            scrollBehaviorX.setDirection(delta.x);
+            scrollBehaviorY.setDirection(delta.y);
+            // when out of boundary, perform a damping scroll
+            var newX = scrollBehaviorX.performDampingAlgorithm(Math.round(delta.x) + cachedDelta.x, dampingFactor);
+            var newY = scrollBehaviorY.performDampingAlgorithm(Math.round(delta.y) + cachedDelta.x, dampingFactor);
+            if (!this.scroll.trigger(this.scroll.eventTypes.mousewheelMove, {
+                x: newX,
+                y: newY,
+            })) {
+                var easeTime = this.getEaseTime();
+                if (newX !== this.scroll.x || newY !== this.scroll.y) {
+                    this.scroll.scrollTo(newX, newY, easeTime);
+                }
+            }
+            if (throttleTime) {
+                this.wheelMoveTimer = window.setTimeout(function () {
+                    _this.wheelMoveTimer = 0;
+                }, throttleTime);
+            }
+        }
+    };
+    MouseWheel.prototype.wheelEndDetector = function (delta) {
+        var _this = this;
+        window.clearTimeout(this.wheelEndTimer);
+        this.wheelEndTimer = window.setTimeout(function () {
+            _this.wheelStart = false;
+            window.clearTimeout(_this.wheelMoveTimer);
+            _this.wheelMoveTimer = 0;
+            _this.scroll.trigger(_this.scroll.eventTypes.mousewheelEnd, delta);
+        }, this.mouseWheelOpt.discreteTime);
+    };
+    MouseWheel.prototype.getWheelDelta = function (e) {
+        var _a = this.mouseWheelOpt, speed = _a.speed, invert = _a.invert;
+        var wheelDeltaX = 0;
+        var wheelDeltaY = 0;
+        var direction = invert ? -1 /* Direction.Negative */ : 1 /* Direction.Positive */;
+        switch (true) {
+            case 'deltaX' in e:
+                if (e.deltaMode === 1) {
+                    wheelDeltaX = -e.deltaX * speed;
+                    wheelDeltaY = -e.deltaY * speed;
+                }
+                else {
+                    wheelDeltaX = -e.deltaX;
+                    wheelDeltaY = -e.deltaY;
+                }
+                break;
+            case 'wheelDeltaX' in e:
+                wheelDeltaX = (e.wheelDeltaX / 120) * speed;
+                wheelDeltaY = (e.wheelDeltaY / 120) * speed;
+                break;
+            case 'wheelDelta' in e:
+                wheelDeltaX = wheelDeltaY = (e.wheelDelta / 120) * speed;
+                break;
+            case 'detail' in e:
+                wheelDeltaX = wheelDeltaY = (-e.detail / 3) * speed;
+                break;
+        }
+        wheelDeltaX *= direction;
+        wheelDeltaY *= direction;
+        if (!this.scroll.hasVerticalScroll) {
+            if (Math.abs(wheelDeltaY) > Math.abs(wheelDeltaX)) {
+                wheelDeltaX = wheelDeltaY;
+            }
+            wheelDeltaY = 0;
+        }
+        if (!this.scroll.hasHorizontalScroll) {
+            wheelDeltaX = 0;
+        }
+        var directionX = wheelDeltaX > 0
+            ? -1 /* Direction.Negative */
+            : wheelDeltaX < 0
+                ? 1 /* Direction.Positive */
+                : 0 /* Direction.Default */;
+        var directionY = wheelDeltaY > 0
+            ? -1 /* Direction.Negative */
+            : wheelDeltaY < 0
+                ? 1 /* Direction.Positive */
+                : 0 /* Direction.Default */;
+        return {
+            x: wheelDeltaX,
+            y: wheelDeltaY,
+            directionX: directionX,
+            directionY: directionY,
+        };
+    };
+    MouseWheel.prototype.beforeHandler = function (e) {
+        var _a = this.scroll.options, preventDefault = _a.preventDefault, stopPropagation = _a.stopPropagation, preventDefaultException = _a.preventDefaultException;
+        if (preventDefault &&
+            !preventDefaultExceptionFn(e.target, preventDefaultException)) {
+            maybePrevent(e);
+        }
+        if (stopPropagation) {
+            e.stopPropagation();
+        }
+    };
+    MouseWheel.prototype.getEaseTime = function () {
+        var SAFE_EASETIME = 100;
+        var easeTime = this.mouseWheelOpt.easeTime;
+        // scrollEnd event will be triggered in every calling of scrollTo when easeTime is too small
+        // easeTime needs to be greater than 100
+        if (easeTime < SAFE_EASETIME) {
+            warn("easeTime should be greater than 100." +
+                "If mouseWheel easeTime is too small," +
+                "scrollEnd will be triggered many times.");
+        }
+        return Math.max(easeTime, SAFE_EASETIME);
+    };
+    MouseWheel.prototype.destroy = function () {
+        this.eventRegister.destroy();
+        window.clearTimeout(this.wheelEndTimer);
+        window.clearTimeout(this.wheelMoveTimer);
+        this.hooksFn.forEach(function (item) {
+            var hooks = item[0];
+            var hooksName = item[1];
+            var handlerFn = item[2];
+            hooks.off(hooksName, handlerFn);
+        });
+    };
+    MouseWheel.pluginName = 'mouseWheel';
+    MouseWheel.applyOrder = "pre" /* ApplyOrder.Pre */;
+    return MouseWheel;
+}());
+export default MouseWheel;

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

@@ -0,0 +1,29 @@
+import BScroll from '@better-scroll/core';
+import { ApplyOrder, EaseItem } from '@better-scroll/shared-utils';
+type PositionX = number | 'left' | 'right' | 'center';
+type PositionY = number | 'top' | 'bottom' | 'center';
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        movable?: true;
+    }
+    interface CustomAPI {
+        movable: PluginAPI;
+    }
+}
+interface PluginAPI {
+    putAt(x: PositionX, y: PositionY, time?: number, easing?: EaseItem): void;
+}
+export default class Movable implements PluginAPI {
+    scroll: BScroll;
+    static pluginName: string;
+    static applyOrder: ApplyOrder;
+    private hooksFn;
+    constructor(scroll: BScroll);
+    private handleBScroll;
+    private handleHooks;
+    putAt(x: PositionX, y: PositionY, time?: number, easing?: EaseItem): void;
+    private resolvePostion;
+    destroy(): void;
+    private registerHooks;
+}
+export {};

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

@@ -0,0 +1,85 @@
+import { ease, } from '@better-scroll/shared-utils';
+import propertiesConfig from './propertiesConfig';
+var Movable = /** @class */ (function () {
+    function Movable(scroll) {
+        this.scroll = scroll;
+        this.handleBScroll();
+        this.handleHooks();
+    }
+    Movable.prototype.handleBScroll = function () {
+        this.scroll.proxy(propertiesConfig);
+    };
+    Movable.prototype.handleHooks = function () {
+        var _this = this;
+        this.hooksFn = [];
+        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
+        var computeBoundary = function (boundary, behavior) {
+            if (boundary.maxScrollPos > 0) {
+                // content is smaller than wrapper
+                boundary.minScrollPos = behavior.wrapperSize - behavior.contentSize;
+                boundary.maxScrollPos = 0;
+            }
+        };
+        this.registerHooks(scrollBehaviorX.hooks, scrollBehaviorX.hooks.eventTypes.ignoreHasScroll, function () { return true; });
+        this.registerHooks(scrollBehaviorX.hooks, scrollBehaviorX.hooks.eventTypes.computeBoundary, function (boundary) {
+            computeBoundary(boundary, scrollBehaviorX);
+        });
+        this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.ignoreHasScroll, function () { return true; });
+        this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
+            computeBoundary(boundary, scrollBehaviorY);
+        });
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.destroy, function () {
+            _this.destroy();
+        });
+    };
+    Movable.prototype.putAt = function (x, y, time, easing) {
+        if (time === void 0) { time = this.scroll.options.bounceTime; }
+        if (easing === void 0) { easing = ease.bounce; }
+        var position = this.resolvePostion(x, y);
+        this.scroll.scrollTo(position.x, position.y, time, easing);
+    };
+    Movable.prototype.resolvePostion = function (x, y) {
+        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
+        var resolveFormula = {
+            left: function () {
+                return 0;
+            },
+            top: function () {
+                return 0;
+            },
+            right: function () {
+                return scrollBehaviorX.minScrollPos;
+            },
+            bottom: function () {
+                return scrollBehaviorY.minScrollPos;
+            },
+            center: function (index) {
+                var baseSize = index === 0
+                    ? scrollBehaviorX.minScrollPos
+                    : scrollBehaviorY.minScrollPos;
+                return baseSize / 2;
+            },
+        };
+        return {
+            x: typeof x === 'number' ? x : resolveFormula[x](0),
+            y: typeof y === 'number' ? y : resolveFormula[y](1),
+        };
+    };
+    Movable.prototype.destroy = function () {
+        this.hooksFn.forEach(function (item) {
+            var hooks = item[0];
+            var hooksName = item[1];
+            var handlerFn = item[2];
+            hooks.off(hooksName, handlerFn);
+        });
+        this.hooksFn.length = 0;
+    };
+    Movable.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    Movable.pluginName = 'movable';
+    Movable.applyOrder = "pre" /* ApplyOrder.Pre */;
+    return Movable;
+}());
+export default Movable;

package/better-scroll-dev/better-scroll-dev/dist/packages/movable/src/propertiesConfig.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    key: string;
+    sourceKey: string;
+}[];
+export default _default;

package/better-scroll-dev/better-scroll-dev/dist/packages/movable/src/propertiesConfig.js

@@ -0,0 +1,13 @@
+var sourcePrefix = 'plugins.movable';
+var propertiesMap = [
+    {
+        key: 'putAt',
+        name: 'putAt',
+    },
+];
+export default propertiesMap.map(function (item) {
+    return {
+        key: item.key,
+        sourceKey: "".concat(sourcePrefix, ".").concat(item.name),
+    };
+});

package/better-scroll-dev/better-scroll-dev/dist/packages/nested-scroll/src/BScrollFamily.d.ts

@@ -0,0 +1,21 @@
+import BScroll from '@better-scroll/core';
+import { EventEmitter } from '@better-scroll/shared-utils';
+export type BScrollFamilyTuple = [BScrollFamily, number];
+export default class BScrollFamily {
+    static create(scroll: BScroll): BScrollFamily;
+    ancestors: BScrollFamilyTuple[];
+    descendants: BScrollFamilyTuple[];
+    hooksManager: [EventEmitter, string, Function][];
+    selfScroll: BScroll;
+    analyzed: boolean;
+    constructor(scroll: BScroll);
+    hasAncestors(bscrollFamily: BScrollFamily): boolean;
+    hasDescendants(bscrollFamily: BScrollFamily): boolean;
+    addAncestor(bscrollFamily: BScrollFamily, distance: number): void;
+    addDescendant(bscrollFamily: BScrollFamily, distance: number): void;
+    removeAncestor(bscrollFamily: BScrollFamily): BScrollFamilyTuple[] | undefined;
+    removeDescendant(bscrollFamily: BScrollFamily): BScrollFamilyTuple[] | undefined;
+    registerHooks(hook: EventEmitter, eventType: string, handler: Function): void;
+    setAnalyzed(flag?: boolean): void;
+    purge(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/nested-scroll/src/BScrollFamily.js

@@ -0,0 +1,95 @@
+import { findIndex } from '@better-scroll/shared-utils';
+var BScrollFamily = /** @class */ (function () {
+    function BScrollFamily(scroll) {
+        this.ancestors = [];
+        this.descendants = [];
+        this.hooksManager = [];
+        this.analyzed = false;
+        this.selfScroll = scroll;
+    }
+    BScrollFamily.create = function (scroll) {
+        return new BScrollFamily(scroll);
+    };
+    BScrollFamily.prototype.hasAncestors = function (bscrollFamily) {
+        var index = findIndex(this.ancestors, function (_a) {
+            var item = _a[0];
+            return item === bscrollFamily;
+        });
+        return index > -1;
+    };
+    BScrollFamily.prototype.hasDescendants = function (bscrollFamily) {
+        var index = findIndex(this.descendants, function (_a) {
+            var item = _a[0];
+            return item === bscrollFamily;
+        });
+        return index > -1;
+    };
+    BScrollFamily.prototype.addAncestor = function (bscrollFamily, distance) {
+        var ancestors = this.ancestors;
+        ancestors.push([bscrollFamily, distance]);
+        // by ascend
+        ancestors.sort(function (a, b) {
+            return a[1] - b[1];
+        });
+    };
+    BScrollFamily.prototype.addDescendant = function (bscrollFamily, distance) {
+        var descendants = this.descendants;
+        descendants.push([bscrollFamily, distance]);
+        // by ascend
+        descendants.sort(function (a, b) {
+            return a[1] - b[1];
+        });
+    };
+    BScrollFamily.prototype.removeAncestor = function (bscrollFamily) {
+        var ancestors = this.ancestors;
+        if (ancestors.length) {
+            var index = findIndex(this.ancestors, function (_a) {
+                var item = _a[0];
+                return item === bscrollFamily;
+            });
+            if (index > -1) {
+                return ancestors.splice(index, 1);
+            }
+        }
+    };
+    BScrollFamily.prototype.removeDescendant = function (bscrollFamily) {
+        var descendants = this.descendants;
+        if (descendants.length) {
+            var index = findIndex(this.descendants, function (_a) {
+                var item = _a[0];
+                return item === bscrollFamily;
+            });
+            if (index > -1) {
+                return descendants.splice(index, 1);
+            }
+        }
+    };
+    BScrollFamily.prototype.registerHooks = function (hook, eventType, handler) {
+        hook.on(eventType, handler);
+        this.hooksManager.push([hook, eventType, handler]);
+    };
+    BScrollFamily.prototype.setAnalyzed = function (flag) {
+        if (flag === void 0) { flag = false; }
+        this.analyzed = flag;
+    };
+    BScrollFamily.prototype.purge = function () {
+        var _this = this;
+        // remove self from graph
+        this.ancestors.forEach(function (_a) {
+            var bscrollFamily = _a[0];
+            bscrollFamily.removeDescendant(_this);
+        });
+        this.descendants.forEach(function (_a) {
+            var bscrollFamily = _a[0];
+            bscrollFamily.removeAncestor(_this);
+        });
+        // remove all hook handlers
+        this.hooksManager.forEach(function (_a) {
+            var hooks = _a[0], eventType = _a[1], handler = _a[2];
+            hooks.off(eventType, handler);
+        });
+        this.hooksManager = [];
+    };
+    return BScrollFamily;
+}());
+export default BScrollFamily;

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

@@ -0,0 +1,44 @@
+import BScroll from '@better-scroll/core';
+import BScrollFamily from './BScrollFamily';
+export declare const DEFAUL_GROUP_ID = "INTERNAL_NESTED_SCROLL";
+export type NestedScrollGroupId = string | number;
+export interface NestedScrollConfig {
+    groupId: NestedScrollGroupId;
+}
+export type NestedScrollOptions = NestedScrollConfig | true;
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        nestedScroll?: NestedScrollOptions;
+    }
+    interface CustomAPI {
+        nestedScroll: PluginAPI;
+    }
+}
+interface PluginAPI {
+    purgeNestedScroll(groupId: NestedScrollGroupId): void;
+}
+interface NestedScrollInstancesMap {
+    [key: string]: NestedScroll;
+    [index: number]: NestedScroll;
+}
+export default class NestedScroll implements PluginAPI {
+    static pluginName: string;
+    static instancesMap: NestedScrollInstancesMap;
+    store: BScrollFamily[];
+    options: NestedScrollConfig;
+    private hooksFn;
+    constructor(scroll: BScroll);
+    static getAllNestedScrolls(): NestedScroll[];
+    static purgeAllNestedScrolls(): void;
+    private handleOptions;
+    private init;
+    private handleHooks;
+    deleteScroll(scroll: BScroll): void;
+    addBScroll(scroll: BScroll): void;
+    private buildBScrollGraph;
+    private analyzeBScrollGraph;
+    private ensureEventInvokeSequence;
+    private registerHooks;
+    purgeNestedScroll(): void;
+}
+export {};