cbvirtua 1.0.106 → 1.0.107

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

@@ -0,0 +1,291 @@
+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));
+};
+import { extend, warn, findIndex, } from '@better-scroll/shared-utils';
+import BScrollFamily from './BScrollFamily';
+import propertiesConfig from './propertiesConfig';
+export var DEFAUL_GROUP_ID = 'INTERNAL_NESTED_SCROLL';
+var forceScrollStopHandler = function (scrolls) {
+    scrolls.forEach(function (scroll) {
+        if (scroll.pending) {
+            scroll.stop();
+            scroll.resetPosition();
+        }
+    });
+};
+var enableScrollHander = function (scrolls) {
+    scrolls.forEach(function (scroll) {
+        scroll.enable();
+    });
+};
+var disableScrollHander = function (scrolls, currentScroll) {
+    scrolls.forEach(function (scroll) {
+        if (scroll.hasHorizontalScroll === currentScroll.hasHorizontalScroll ||
+            scroll.hasVerticalScroll === currentScroll.hasVerticalScroll) {
+            scroll.disable();
+        }
+    });
+};
+var syncTouchstartData = function (scrolls) {
+    scrolls.forEach(function (scroll) {
+        var _a = scroll.scroller, actions = _a.actions, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
+        // prevent click triggering many times
+        actions.fingerMoved = true;
+        actions.contentMoved = false;
+        actions.directionLockAction.reset();
+        scrollBehaviorX.start();
+        scrollBehaviorY.start();
+        scrollBehaviorX.resetStartPos();
+        scrollBehaviorY.resetStartPos();
+        actions.startTime = +new Date();
+    });
+};
+var isOutOfBoundary = function (scroll) {
+    var hasHorizontalScroll = scroll.hasHorizontalScroll, hasVerticalScroll = scroll.hasVerticalScroll, x = scroll.x, y = scroll.y, minScrollX = scroll.minScrollX, maxScrollX = scroll.maxScrollX, minScrollY = scroll.minScrollY, maxScrollY = scroll.maxScrollY, movingDirectionX = scroll.movingDirectionX, movingDirectionY = scroll.movingDirectionY;
+    var ret = false;
+    var outOfLeftBoundary = x >= minScrollX && movingDirectionX === -1 /* Direction.Negative */;
+    var outOfRightBoundary = x <= maxScrollX && movingDirectionX === 1 /* Direction.Positive */;
+    var outOfTopBoundary = y >= minScrollY && movingDirectionY === -1 /* Direction.Negative */;
+    var outOfBottomBoundary = y <= maxScrollY && movingDirectionY === 1 /* Direction.Positive */;
+    if (hasVerticalScroll) {
+        ret = outOfTopBoundary || outOfBottomBoundary;
+    }
+    else if (hasHorizontalScroll) {
+        ret = outOfLeftBoundary || outOfRightBoundary;
+    }
+    return ret;
+};
+var isResettingPosition = function (scroll) {
+    var hasHorizontalScroll = scroll.hasHorizontalScroll, hasVerticalScroll = scroll.hasVerticalScroll, x = scroll.x, y = scroll.y, minScrollX = scroll.minScrollX, maxScrollX = scroll.maxScrollX, minScrollY = scroll.minScrollY, maxScrollY = scroll.maxScrollY;
+    var ret = false;
+    var outOfLeftBoundary = x > minScrollX;
+    var outOfRightBoundary = x < maxScrollX;
+    var outOfTopBoundary = y > minScrollY;
+    var outOfBottomBoundary = y < maxScrollY;
+    if (hasVerticalScroll) {
+        ret = outOfTopBoundary || outOfBottomBoundary;
+    }
+    else if (hasHorizontalScroll) {
+        ret = outOfLeftBoundary || outOfRightBoundary;
+    }
+    return ret;
+};
+var resetPositionHandler = function (scroll) {
+    scroll.scroller.reflow();
+    scroll.resetPosition(0 /* Immediately */);
+};
+var calculateDistance = function (childNode, parentNode) {
+    var distance = 0;
+    var parent = childNode.parentNode;
+    while (parent && parent !== parentNode) {
+        distance++;
+        parent = parent.parentNode;
+    }
+    return distance;
+};
+var NestedScroll = /** @class */ (function () {
+    function NestedScroll(scroll) {
+        var groupId = this.handleOptions(scroll);
+        var instance = NestedScroll.instancesMap[groupId];
+        if (!instance) {
+            instance = NestedScroll.instancesMap[groupId] = this;
+            instance.store = [];
+            instance.hooksFn = [];
+        }
+        instance.init(scroll);
+        return instance;
+    }
+    NestedScroll.getAllNestedScrolls = function () {
+        var instancesMap = NestedScroll.instancesMap;
+        return Object.keys(instancesMap).map(function (key) { return instancesMap[key]; });
+    };
+    NestedScroll.purgeAllNestedScrolls = function () {
+        var nestedScrolls = NestedScroll.getAllNestedScrolls();
+        nestedScrolls.forEach(function (ns) { return ns.purgeNestedScroll(); });
+    };
+    NestedScroll.prototype.handleOptions = function (scroll) {
+        var userOptions = (scroll.options.nestedScroll === true
+            ? {}
+            : scroll.options.nestedScroll);
+        var defaultOptions = {
+            groupId: DEFAUL_GROUP_ID,
+        };
+        this.options = extend(defaultOptions, userOptions);
+        var groupIdType = typeof this.options.groupId;
+        if (groupIdType !== 'string' && groupIdType !== 'number') {
+            warn('groupId must be string or number for NestedScroll plugin');
+        }
+        return this.options.groupId;
+    };
+    NestedScroll.prototype.init = function (scroll) {
+        scroll.proxy(propertiesConfig);
+        this.addBScroll(scroll);
+        this.buildBScrollGraph();
+        this.analyzeBScrollGraph();
+        this.ensureEventInvokeSequence();
+        this.handleHooks(scroll);
+    };
+    NestedScroll.prototype.handleHooks = function (scroll) {
+        var _this = this;
+        this.registerHooks(scroll.hooks, scroll.hooks.eventTypes.destroy, function () {
+            _this.deleteScroll(scroll);
+        });
+    };
+    NestedScroll.prototype.deleteScroll = function (scroll) {
+        var wrapper = scroll.wrapper;
+        wrapper.isBScrollContainer = undefined;
+        var store = this.store;
+        var hooksFn = this.hooksFn;
+        var i = findIndex(store, function (bscrollFamily) {
+            return bscrollFamily.selfScroll === scroll;
+        });
+        if (i > -1) {
+            var bscrollFamily = store[i];
+            bscrollFamily.purge();
+            store.splice(i, 1);
+        }
+        var k = findIndex(hooksFn, function (_a) {
+            var hooks = _a[0];
+            return hooks === scroll.hooks;
+        });
+        if (k > -1) {
+            var _a = hooksFn[k], hooks = _a[0], eventType = _a[1], handler = _a[2];
+            hooks.off(eventType, handler);
+            hooksFn.splice(k, 1);
+        }
+    };
+    NestedScroll.prototype.addBScroll = function (scroll) {
+        this.store.push(BScrollFamily.create(scroll));
+    };
+    NestedScroll.prototype.buildBScrollGraph = function () {
+        var store = this.store;
+        var bf1;
+        var bf2;
+        var wrapper1;
+        var wrapper2;
+        var len = this.store.length;
+        // build graph
+        for (var i = 0; i < len; i++) {
+            bf1 = store[i];
+            wrapper1 = bf1.selfScroll.wrapper;
+            for (var j = 0; j < len; j++) {
+                bf2 = store[j];
+                wrapper2 = bf2.selfScroll.wrapper;
+                // same bs
+                if (bf1 === bf2)
+                    continue;
+                if (!wrapper1.contains(wrapper2))
+                    continue;
+                // bs1 contains bs2
+                var distance = calculateDistance(wrapper2, wrapper1);
+                if (!bf1.hasDescendants(bf2)) {
+                    bf1.addDescendant(bf2, distance);
+                }
+                if (!bf2.hasAncestors(bf1)) {
+                    bf2.addAncestor(bf1, distance);
+                }
+            }
+        }
+    };
+    NestedScroll.prototype.analyzeBScrollGraph = function () {
+        this.store.forEach(function (bscrollFamily) {
+            if (bscrollFamily.analyzed) {
+                return;
+            }
+            var ancestors = bscrollFamily.ancestors, descendants = bscrollFamily.descendants, currentScroll = bscrollFamily.selfScroll;
+            var beforeScrollStartHandler = function () {
+                // always get the latest scroll
+                var ancestorScrolls = ancestors.map(function (_a) {
+                    var bscrollFamily = _a[0];
+                    return bscrollFamily.selfScroll;
+                });
+                var descendantScrolls = descendants.map(function (_a) {
+                    var bscrollFamily = _a[0];
+                    return bscrollFamily.selfScroll;
+                });
+                forceScrollStopHandler(__spreadArray(__spreadArray([], ancestorScrolls, true), descendantScrolls, true));
+                if (isResettingPosition(currentScroll)) {
+                    resetPositionHandler(currentScroll);
+                }
+                syncTouchstartData(ancestorScrolls);
+                disableScrollHander(ancestorScrolls, currentScroll);
+            };
+            var touchEndHandler = function () {
+                var ancestorScrolls = ancestors.map(function (_a) {
+                    var bscrollFamily = _a[0];
+                    return bscrollFamily.selfScroll;
+                });
+                var descendantScrolls = descendants.map(function (_a) {
+                    var bscrollFamily = _a[0];
+                    return bscrollFamily.selfScroll;
+                });
+                enableScrollHander(__spreadArray(__spreadArray([], ancestorScrolls, true), descendantScrolls, true));
+            };
+            bscrollFamily.registerHooks(currentScroll, currentScroll.eventTypes.beforeScrollStart, beforeScrollStartHandler);
+            bscrollFamily.registerHooks(currentScroll, currentScroll.eventTypes.touchEnd, touchEndHandler);
+            var selfActionsHooks = currentScroll.scroller.actions.hooks;
+            bscrollFamily.registerHooks(selfActionsHooks, selfActionsHooks.eventTypes.detectMovingDirection, function () {
+                var ancestorScrolls = ancestors.map(function (_a) {
+                    var bscrollFamily = _a[0];
+                    return bscrollFamily.selfScroll;
+                });
+                var parentScroll = ancestorScrolls[0];
+                var otherAncestorScrolls = ancestorScrolls.slice(1);
+                var contentMoved = currentScroll.scroller.actions.contentMoved;
+                var isTopScroll = ancestorScrolls.length === 0;
+                if (contentMoved) {
+                    disableScrollHander(ancestorScrolls, currentScroll);
+                }
+                else if (!isTopScroll) {
+                    if (isOutOfBoundary(currentScroll)) {
+                        disableScrollHander([currentScroll], currentScroll);
+                        if (parentScroll) {
+                            enableScrollHander([parentScroll]);
+                        }
+                        disableScrollHander(otherAncestorScrolls, currentScroll);
+                        return true;
+                    }
+                }
+            });
+            bscrollFamily.setAnalyzed(true);
+        });
+    };
+    // make sure touchmove|touchend invoke from child to parent
+    NestedScroll.prototype.ensureEventInvokeSequence = function () {
+        var copied = this.store.slice();
+        var sequencedScroll = copied.sort(function (a, b) {
+            return a.descendants.length - b.descendants.length;
+        });
+        sequencedScroll.forEach(function (bscrollFamily) {
+            var scroll = bscrollFamily.selfScroll;
+            scroll.scroller.actionsHandler.rebindDOMEvents();
+        });
+    };
+    NestedScroll.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    NestedScroll.prototype.purgeNestedScroll = function () {
+        var groupId = this.options.groupId;
+        this.store.forEach(function (bscrollFamily) {
+            bscrollFamily.purge();
+        });
+        this.store = [];
+        this.hooksFn.forEach(function (_a) {
+            var hooks = _a[0], eventType = _a[1], handler = _a[2];
+            hooks.off(eventType, handler);
+        });
+        this.hooksFn = [];
+        delete NestedScroll.instancesMap[groupId];
+    };
+    NestedScroll.pluginName = 'nestedScroll';
+    NestedScroll.instancesMap = {};
+    return NestedScroll;
+}());
+export default NestedScroll;

package/better-scroll-dev/better-scroll-dev/dist/packages/nested-scroll/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/nested-scroll/src/propertiesConfig.js

@@ -0,0 +1,13 @@
+var sourcePrefix = 'plugins.nestedScroll';
+var propertiesMap = [
+    {
+        key: 'purgeNestedScroll',
+        name: 'purgeNestedScroll',
+    },
+];
+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/observe-dom/src/index.d.ts

@@ -0,0 +1,24 @@
+import BScroll from '@better-scroll/core';
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        observeDOM?: true;
+    }
+}
+export default class ObserveDOM {
+    scroll: BScroll;
+    static pluginName: string;
+    observer: MutationObserver;
+    private stopObserver;
+    private hooksFn;
+    constructor(scroll: BScroll);
+    init(): void;
+    private handleMutationObserver;
+    private handleHooks;
+    private mutationObserverHandler;
+    private startObserve;
+    private shouldNotRefresh;
+    private checkDOMUpdate;
+    private registerHooks;
+    private stopObserve;
+    destroy(): void;
+}

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

@@ -0,0 +1,145 @@
+import { getRect } from '@better-scroll/shared-utils';
+var ObserveDOM = /** @class */ (function () {
+    function ObserveDOM(scroll) {
+        this.scroll = scroll;
+        this.stopObserver = false;
+        this.init();
+    }
+    ObserveDOM.prototype.init = function () {
+        this.handleMutationObserver();
+        this.handleHooks();
+    };
+    ObserveDOM.prototype.handleMutationObserver = function () {
+        var _this = this;
+        if (typeof MutationObserver !== 'undefined') {
+            var timer_1 = 0;
+            this.observer = new MutationObserver(function (mutations) {
+                _this.mutationObserverHandler(mutations, timer_1);
+            });
+            this.startObserve(this.observer);
+        }
+        else {
+            this.checkDOMUpdate();
+        }
+    };
+    ObserveDOM.prototype.handleHooks = function () {
+        var _this = this;
+        this.hooksFn = [];
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
+            _this.stopObserve();
+            // launch a new mutationObserver
+            _this.handleMutationObserver();
+        });
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.enable, function () {
+            if (_this.stopObserver) {
+                _this.handleMutationObserver();
+            }
+        });
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.disable, function () {
+            _this.stopObserve();
+        });
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.destroy, function () {
+            _this.destroy();
+        });
+    };
+    ObserveDOM.prototype.mutationObserverHandler = function (mutations, timer) {
+        var _this = this;
+        if (this.shouldNotRefresh()) {
+            return;
+        }
+        var immediateRefresh = false;
+        var deferredRefresh = false;
+        for (var i = 0; i < mutations.length; i++) {
+            var mutation = mutations[i];
+            if (mutation.type !== 'attributes') {
+                immediateRefresh = true;
+                break;
+            }
+            else {
+                if (mutation.target !== this.scroll.scroller.content) {
+                    deferredRefresh = true;
+                    break;
+                }
+            }
+        }
+        if (immediateRefresh) {
+            this.scroll.refresh();
+        }
+        else if (deferredRefresh) {
+            // attributes changes too often
+            clearTimeout(timer);
+            timer = window.setTimeout(function () {
+                if (!_this.shouldNotRefresh()) {
+                    _this.scroll.refresh();
+                }
+            }, 60);
+        }
+    };
+    ObserveDOM.prototype.startObserve = function (observer) {
+        var config = {
+            attributes: true,
+            childList: true,
+            subtree: true,
+        };
+        observer.observe(this.scroll.scroller.content, config);
+    };
+    ObserveDOM.prototype.shouldNotRefresh = function () {
+        var scroller = this.scroll.scroller;
+        var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
+        var outsideBoundaries = scrollBehaviorX.currentPos > scrollBehaviorX.minScrollPos ||
+            scrollBehaviorX.currentPos < scrollBehaviorX.maxScrollPos ||
+            scrollBehaviorY.currentPos > scrollBehaviorY.minScrollPos ||
+            scrollBehaviorY.currentPos < scrollBehaviorY.maxScrollPos;
+        return scroller.animater.pending || outsideBoundaries;
+    };
+    ObserveDOM.prototype.checkDOMUpdate = function () {
+        var _this = this;
+        var content = this.scroll.scroller.content;
+        var contentRect = getRect(content);
+        var oldWidth = contentRect.width;
+        var oldHeight = contentRect.height;
+        var check = function () {
+            if (_this.stopObserver) {
+                return;
+            }
+            contentRect = getRect(content);
+            var newWidth = contentRect.width;
+            var newHeight = contentRect.height;
+            if (oldWidth !== newWidth || oldHeight !== newHeight) {
+                _this.scroll.refresh();
+            }
+            oldWidth = newWidth;
+            oldHeight = newHeight;
+            next();
+        };
+        var next = function () {
+            setTimeout(function () {
+                check();
+            }, 1000);
+        };
+        next();
+    };
+    ObserveDOM.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    ObserveDOM.prototype.stopObserve = function () {
+        this.stopObserver = true;
+        if (this.observer) {
+            this.observer.disconnect();
+        }
+    };
+    ObserveDOM.prototype.destroy = function () {
+        this.stopObserve();
+        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;
+    };
+    ObserveDOM.pluginName = 'observeDOM';
+    return ObserveDOM;
+}());
+export default ObserveDOM;

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

@@ -0,0 +1,24 @@
+import BScroll from '@better-scroll/core';
+import { EventRegister } from '@better-scroll/shared-utils';
+export type ObserveImageOptions = Partial<ObserveImageConfig> | true;
+export interface ObserveImageConfig {
+    debounceTime: number;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        observeImage?: ObserveImageOptions;
+    }
+}
+export default class ObserveImage {
+    scroll: BScroll;
+    static pluginName: string;
+    imageLoadEventRegister: EventRegister;
+    imageErrorEventRegister: EventRegister;
+    refreshTimer: number;
+    options: ObserveImageConfig;
+    constructor(scroll: BScroll);
+    init(): void;
+    private handleOptions;
+    private bindEventsToWrapper;
+    private load;
+}

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

@@ -0,0 +1,59 @@
+import { EventRegister, extend } from '@better-scroll/shared-utils';
+var isImageTag = function (el) {
+    return el.tagName.toLowerCase() === 'img';
+};
+var ObserveImage = /** @class */ (function () {
+    function ObserveImage(scroll) {
+        this.scroll = scroll;
+        this.refreshTimer = 0;
+        this.init();
+    }
+    ObserveImage.prototype.init = function () {
+        this.handleOptions(this.scroll.options.observeImage);
+        this.bindEventsToWrapper();
+    };
+    ObserveImage.prototype.handleOptions = function (userOptions) {
+        if (userOptions === void 0) { userOptions = {}; }
+        userOptions = (userOptions === true ? {} : userOptions);
+        var defaultOptions = {
+            debounceTime: 100, // ms
+        };
+        this.options = extend(defaultOptions, userOptions);
+    };
+    ObserveImage.prototype.bindEventsToWrapper = function () {
+        var wrapper = this.scroll.scroller.wrapper;
+        this.imageLoadEventRegister = new EventRegister(wrapper, [
+            {
+                name: 'load',
+                handler: this.load.bind(this),
+                capture: true,
+            },
+        ]);
+        this.imageErrorEventRegister = new EventRegister(wrapper, [
+            {
+                name: 'error',
+                handler: this.load.bind(this),
+                capture: true,
+            },
+        ]);
+    };
+    ObserveImage.prototype.load = function (e) {
+        var _this = this;
+        var target = e.target;
+        var debounceTime = this.options.debounceTime;
+        if (target && isImageTag(target)) {
+            if (debounceTime === 0) {
+                this.scroll.refresh();
+            }
+            else {
+                clearTimeout(this.refreshTimer);
+                this.refreshTimer = window.setTimeout(function () {
+                    _this.scroll.refresh();
+                }, this.options.debounceTime);
+            }
+        }
+    };
+    ObserveImage.pluginName = 'observeImage';
+    return ObserveImage;
+}());
+export default ObserveImage;

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

@@ -0,0 +1,63 @@
+import BScroll from '@better-scroll/core';
+export type PullDownRefreshOptions = Partial<PullDownRefreshConfig> | true;
+declare const enum PullDownPhase {
+    DEFAULT = 0,
+    MOVING = 1,
+    FETCHING = 2
+}
+declare const enum ThresholdBoundary {
+    DEFAULT = 0,
+    INSIDE = 1,
+    OUTSIDE = 2
+}
+export interface PullDownRefreshConfig {
+    threshold: number;
+    stop: number;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        pullDownRefresh?: PullDownRefreshOptions;
+    }
+    interface CustomAPI {
+        pullDownRefresh: PluginAPI;
+    }
+}
+interface PluginAPI {
+    finishPullDown(): void;
+    openPullDown(config?: PullDownRefreshOptions): void;
+    closePullDown(): void;
+    autoPullDownRefresh(): void;
+}
+export default class PullDown implements PluginAPI {
+    scroll: BScroll;
+    static pluginName: string;
+    private hooksFn;
+    pulling: PullDownPhase;
+    thresholdBoundary: ThresholdBoundary;
+    watching: boolean;
+    options: PullDownRefreshConfig;
+    cachedOriginanMinScrollY: number;
+    currentMinScrollY: number;
+    constructor(scroll: BScroll);
+    private setPulling;
+    private setThresholdBoundary;
+    private init;
+    private handleBScroll;
+    private handleOptions;
+    private handleHooks;
+    private registerHooks;
+    private hasMouseWheelPlugin;
+    private watch;
+    private resetStateBeforeScrollStart;
+    private checkLocationOfThresholdBoundary;
+    private locateInsideThresholdBoundary;
+    private unwatch;
+    private checkPullDown;
+    private isFetchingStatus;
+    private modifyBehaviorYBoundary;
+    finishPullDown(): void;
+    openPullDown(config?: PullDownRefreshOptions): void;
+    closePullDown(): void;
+    autoPullDownRefresh(): void;
+}
+export {};