cbvirtua 1.0.106 → 1.0.107

package/better-scroll-dev/better-scroll-dev/dist/packages/infinity/src/DomManager.js

@@ -0,0 +1,169 @@
+import Tombstone from './Tombstone';
+import { style, cssVendor } from '@better-scroll/shared-utils';
+var ANIMATION_DURATION_MS = 200;
+var DomManager = /** @class */ (function () {
+    function DomManager(content, renderFn, tombstone) {
+        this.renderFn = renderFn;
+        this.tombstone = tombstone;
+        this.unusedDom = [];
+        this.timers = [];
+        this.setContent(content);
+    }
+    DomManager.prototype.update = function (list, start, end) {
+        if (start >= list.length) {
+            start = list.length - 1;
+        }
+        if (end > list.length) {
+            end = list.length;
+        }
+        this.collectUnusedDom(list, start, end);
+        this.createDom(list, start, end);
+        this.cacheHeight(list, start, end);
+        var _a = this.positionDom(list, start, end), startPos = _a.startPos, startDelta = _a.startDelta, endPos = _a.endPos;
+        return {
+            start: start,
+            startPos: startPos,
+            startDelta: startDelta,
+            end: end,
+            endPos: endPos,
+        };
+    };
+    DomManager.prototype.collectUnusedDom = function (list, start, end) {
+        // TODO optimise
+        for (var i = 0; i < list.length; i++) {
+            if (i === start) {
+                i = end - 1;
+                continue;
+            }
+            if (list[i].dom) {
+                var dom = list[i].dom;
+                if (Tombstone.isTombstone(dom)) {
+                    this.tombstone.recycleOne(dom);
+                    dom.style.display = 'none';
+                }
+                else {
+                    this.unusedDom.push(dom);
+                }
+                list[i].dom = null;
+            }
+        }
+        return list;
+    };
+    DomManager.prototype.createDom = function (list, start, end) {
+        for (var i = start; i < end; i++) {
+            var dom = list[i].dom;
+            var data = list[i].data;
+            if (dom) {
+                if (Tombstone.isTombstone(dom) && data) {
+                    list[i].tombstone = dom;
+                    list[i].dom = null;
+                }
+                else {
+                    continue;
+                }
+            }
+            dom = data
+                ? this.renderFn(data, this.unusedDom.pop())
+                : this.tombstone.getOne();
+            dom.style.position = 'absolute';
+            list[i].dom = dom;
+            list[i].pos = -1;
+            this.content.appendChild(dom);
+        }
+    };
+    DomManager.prototype.cacheHeight = function (list, start, end) {
+        for (var i = start; i < end; i++) {
+            if (list[i].data && !list[i].height) {
+                list[i].height = list[i].dom.offsetHeight;
+            }
+        }
+    };
+    DomManager.prototype.positionDom = function (list, start, end) {
+        var _this = this;
+        var tombstoneEles = [];
+        var _a = this.getStartPos(list, start, end), startPos = _a.start, startDelta = _a.delta;
+        var pos = startPos;
+        for (var i = start; i < end; i++) {
+            var tombstone = list[i].tombstone;
+            if (tombstone) {
+                var tombstoneStyle = tombstone.style;
+                tombstoneStyle[style.transition] = "".concat(cssVendor, "transform ").concat(ANIMATION_DURATION_MS, "ms, opacity ").concat(ANIMATION_DURATION_MS, "ms");
+                tombstoneStyle[style.transform] = "translateY(".concat(pos, "px)");
+                tombstoneStyle.opacity = '0';
+                list[i].tombstone = null;
+                tombstoneEles.push(tombstone);
+            }
+            if (list[i].dom && list[i].pos !== pos) {
+                list[i].dom.style[style.transform] = "translateY(".concat(pos, "px)");
+                list[i].pos = pos;
+            }
+            pos += list[i].height || this.tombstone.height;
+        }
+        var timerId = window.setTimeout(function () {
+            _this.tombstone.recycle(tombstoneEles);
+        }, ANIMATION_DURATION_MS);
+        this.timers.push(timerId);
+        return {
+            startPos: startPos,
+            startDelta: startDelta,
+            endPos: pos,
+        };
+    };
+    DomManager.prototype.getStartPos = function (list, start, end) {
+        if (list[start] && list[start].pos !== -1) {
+            return {
+                start: list[start].pos,
+                delta: 0,
+            };
+        }
+        // TODO optimise
+        var pos = list[0].pos === -1 ? 0 : list[0].pos;
+        for (var i_1 = 0; i_1 < start; i_1++) {
+            pos += list[i_1].height || this.tombstone.height;
+        }
+        var originPos = pos;
+        var i;
+        for (i = start; i < end; i++) {
+            if (!Tombstone.isTombstone(list[i].dom) && list[i].pos !== -1) {
+                pos = list[i].pos;
+                break;
+            }
+        }
+        var x = i;
+        if (x < end) {
+            while (x > start) {
+                pos -= list[x - 1].height;
+                x--;
+            }
+        }
+        var delta = originPos - pos;
+        return {
+            start: pos,
+            delta: delta,
+        };
+    };
+    DomManager.prototype.removeTombstone = function () {
+        var tombstones = this.content.querySelectorAll('.tombstone');
+        for (var i = tombstones.length - 1; i >= 0; i--) {
+            this.content.removeChild(tombstones[i]);
+        }
+    };
+    DomManager.prototype.setContent = function (content) {
+        if (content !== this.content) {
+            this.content = content;
+        }
+    };
+    DomManager.prototype.destroy = function () {
+        this.removeTombstone();
+        this.timers.forEach(function (id) {
+            clearTimeout(id);
+        });
+    };
+    DomManager.prototype.resetState = function () {
+        this.destroy();
+        this.timers = [];
+        this.unusedDom = [];
+    };
+    return DomManager;
+}());
+export default DomManager;

package/better-scroll-dev/better-scroll-dev/dist/packages/infinity/src/IndexCalculator.d.ts

@@ -0,0 +1,16 @@
+export declare const PRE_NUM = 10;
+export declare const POST_NUM = 30;
+export default class IndexCalculator {
+    wrapperHeight: number;
+    private tombstoneHeight;
+    private lastDirection;
+    private lastPos;
+    constructor(wrapperHeight: number, tombstoneHeight: number);
+    calculate(pos: number, list: Array<any>): {
+        start: number;
+        end: number;
+    };
+    private getDirection;
+    private calculateIndex;
+    resetState(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/infinity/src/IndexCalculator.js

@@ -0,0 +1,71 @@
+export var PRE_NUM = 10;
+export var POST_NUM = 30;
+var IndexCalculator = /** @class */ (function () {
+    function IndexCalculator(wrapperHeight, tombstoneHeight) {
+        this.wrapperHeight = wrapperHeight;
+        this.tombstoneHeight = tombstoneHeight;
+        this.lastDirection = 1 /* DIRECTION.DOWN */;
+        this.lastPos = 0;
+    }
+    IndexCalculator.prototype.calculate = function (pos, list) {
+        var offset = pos - this.lastPos;
+        this.lastPos = pos;
+        var direction = this.getDirection(offset);
+        // important! start index is much more important than end index.
+        var start = this.calculateIndex(0, pos, list);
+        var end = this.calculateIndex(start, pos + this.wrapperHeight, list);
+        if (direction === 1 /* DIRECTION.DOWN */) {
+            start -= PRE_NUM;
+            end += POST_NUM;
+        }
+        else {
+            start -= POST_NUM;
+            end += PRE_NUM;
+        }
+        if (start < 0) {
+            start = 0;
+        }
+        return {
+            start: start,
+            end: end,
+        };
+    };
+    IndexCalculator.prototype.getDirection = function (offset) {
+        var direction;
+        if (offset > 0) {
+            direction = 1 /* DIRECTION.DOWN */;
+        }
+        else if (offset < 0) {
+            direction = 0 /* DIRECTION.UP */;
+        }
+        else {
+            return this.lastDirection;
+        }
+        this.lastDirection = direction;
+        return direction;
+    };
+    IndexCalculator.prototype.calculateIndex = function (start, offset, list) {
+        if (offset <= 0) {
+            return start;
+        }
+        var i = start;
+        var startPos = list[i] && list[i].pos !== -1 ? list[i].pos : 0;
+        var lastPos = startPos;
+        var tombstone = 0;
+        while (i < list.length && list[i].pos < offset) {
+            lastPos = list[i].pos;
+            i++;
+        }
+        if (i === list.length) {
+            tombstone = Math.floor((offset - lastPos) / this.tombstoneHeight);
+        }
+        i += tombstone;
+        return i;
+    };
+    IndexCalculator.prototype.resetState = function () {
+        this.lastDirection = 1 /* DIRECTION.DOWN */;
+        this.lastPos = 0;
+    };
+    return IndexCalculator;
+}());
+export default IndexCalculator;

package/better-scroll-dev/better-scroll-dev/dist/packages/infinity/src/Tombstone.d.ts

@@ -0,0 +1,13 @@
+export default class Tombstone {
+    private create;
+    private cached;
+    width: number;
+    height: number;
+    private initialed;
+    constructor(create: () => HTMLElement);
+    static isTombstone(el: HTMLElement): boolean;
+    private getSize;
+    getOne(): HTMLElement;
+    recycle(tombstones: Array<HTMLElement>): Array<HTMLElement>;
+    recycleOne(tombstone: HTMLElement): HTMLElement[];
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/infinity/src/Tombstone.js

@@ -0,0 +1,55 @@
+import { style } from '@better-scroll/shared-utils';
+var Tombstone = /** @class */ (function () {
+    function Tombstone(create) {
+        this.create = create;
+        this.cached = [];
+        this.width = 0;
+        this.height = 0;
+        this.initialed = false;
+        this.getSize();
+    }
+    Tombstone.isTombstone = function (el) {
+        if (el && el.classList) {
+            return el.classList.contains('tombstone');
+        }
+        return false;
+    };
+    Tombstone.prototype.getSize = function () {
+        if (!this.initialed) {
+            var tombstone = this.create();
+            tombstone.style.position = 'absolute';
+            document.body.appendChild(tombstone);
+            tombstone.style.display = '';
+            this.height = tombstone.offsetHeight;
+            this.width = tombstone.offsetWidth;
+            document.body.removeChild(tombstone);
+            this.cached.push(tombstone);
+        }
+    };
+    Tombstone.prototype.getOne = function () {
+        var tombstone = this.cached.pop();
+        if (tombstone) {
+            var tombstoneStyle = tombstone.style;
+            tombstoneStyle.display = '';
+            tombstoneStyle.opacity = '1';
+            tombstoneStyle[style.transform] = '';
+            tombstoneStyle[style.transition] = '';
+            return tombstone;
+        }
+        return this.create();
+    };
+    Tombstone.prototype.recycle = function (tombstones) {
+        for (var _i = 0, tombstones_1 = tombstones; _i < tombstones_1.length; _i++) {
+            var tombstone = tombstones_1[_i];
+            tombstone.style.display = 'none';
+            this.cached.push(tombstone);
+        }
+        return this.cached;
+    };
+    Tombstone.prototype.recycleOne = function (tombstone) {
+        this.cached.push(tombstone);
+        return this.cached;
+    };
+    return Tombstone;
+}());
+export default Tombstone;

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

@@ -0,0 +1,32 @@
+import BScroll from '@better-scroll/core';
+export interface InfinityOptions {
+    fetch: (count: number) => Promise<Array<any> | false>;
+    render: (item: any, div?: HTMLElement) => HTMLElement;
+    createTombstone: () => HTMLElement;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        infinity?: InfinityOptions;
+    }
+}
+export default class InfinityScroll {
+    scroll: BScroll;
+    static pluginName: string;
+    start: number;
+    end: number;
+    options: InfinityOptions;
+    private tombstone;
+    private domManager;
+    private dataManager;
+    private indexCalculator;
+    constructor(scroll: BScroll);
+    init(): void;
+    private modifyBoundary;
+    private handleOptions;
+    update(pos: {
+        y: number;
+    }): void;
+    private onFetchFinish;
+    private updateDom;
+    destroy(): void;
+}

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

@@ -0,0 +1,103 @@
+import { warn } from '@better-scroll/shared-utils';
+import IndexCalculator from './IndexCalculator';
+import DataManager from './DataManager';
+import DomManager from './DomManager';
+import Tombstone from './Tombstone';
+var EXTRA_SCROLL_Y = -2000;
+var InfinityScroll = /** @class */ (function () {
+    function InfinityScroll(scroll) {
+        this.scroll = scroll;
+        this.start = 0;
+        this.end = 0;
+        this.init();
+    }
+    InfinityScroll.prototype.init = function () {
+        var _this = this;
+        this.handleOptions();
+        var _a = this.options, fetchFn = _a.fetch, renderFn = _a.render, createTombstoneFn = _a.createTombstone;
+        this.tombstone = new Tombstone(createTombstoneFn);
+        this.indexCalculator = new IndexCalculator(this.scroll.scroller.scrollBehaviorY.wrapperSize, this.tombstone.height);
+        this.domManager = new DomManager(this.scroll.scroller.content, renderFn, this.tombstone);
+        this.dataManager = new DataManager([], fetchFn, this.onFetchFinish.bind(this));
+        this.scroll.on(this.scroll.eventTypes.destroy, this.destroy, this);
+        this.scroll.on(this.scroll.eventTypes.scroll, this.update, this);
+        this.scroll.on(this.scroll.eventTypes.contentChanged, function (content) {
+            _this.domManager.setContent(content);
+            _this.indexCalculator.resetState();
+            _this.domManager.resetState();
+            _this.dataManager.resetState();
+            _this.update({ y: 0 });
+        });
+        var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
+        scrollBehaviorY.hooks.on(scrollBehaviorY.hooks.eventTypes.computeBoundary, this.modifyBoundary, this);
+        this.update({ y: 0 });
+    };
+    InfinityScroll.prototype.modifyBoundary = function (boundary) {
+        // manually set position to allow scroll
+        boundary.maxScrollPos = EXTRA_SCROLL_Y;
+    };
+    InfinityScroll.prototype.handleOptions = function () {
+        // narrow down type to an object
+        var infinityOptions = this.scroll.options.infinity;
+        if (infinityOptions) {
+            if (typeof infinityOptions.fetch !== 'function') {
+                warn('Infinity plugin need fetch Function to new data.');
+            }
+            if (typeof infinityOptions.render !== 'function') {
+                warn('Infinity plugin need render Function to render each item.');
+            }
+            if (typeof infinityOptions.render !== 'function') {
+                warn('Infinity plugin need createTombstone Function to create tombstone.');
+            }
+            this.options = infinityOptions;
+        }
+        this.scroll.options.probeType = 3 /* Probe.Realtime */;
+    };
+    InfinityScroll.prototype.update = function (pos) {
+        var position = Math.round(-pos.y);
+        // important! calculate start/end index to render
+        var _a = this.indexCalculator.calculate(position, this.dataManager.getList()), start = _a.start, end = _a.end;
+        this.start = start;
+        this.end = end;
+        // tslint:disable-next-line: no-floating-promises
+        this.dataManager.update(end);
+        this.updateDom(this.dataManager.getList());
+    };
+    InfinityScroll.prototype.onFetchFinish = function (list, hasMore) {
+        var end = this.updateDom(list).end;
+        if (!hasMore) {
+            this.domManager.removeTombstone();
+            this.scroll.scroller.animater.stop();
+            this.scroll.resetPosition();
+        }
+        // tslint:disable-next-line: no-floating-promises
+        return end;
+    };
+    InfinityScroll.prototype.updateDom = function (list) {
+        var _a = this.domManager.update(list, this.start, this.end), end = _a.end, startPos = _a.startPos, endPos = _a.endPos, startDelta = _a.startDelta;
+        if (startDelta) {
+            this.scroll.minScrollY = startDelta;
+        }
+        if (endPos > this.scroll.maxScrollY) {
+            this.scroll.maxScrollY = -(endPos - this.scroll.scroller.scrollBehaviorY.wrapperSize);
+        }
+        return {
+            end: end,
+            startPos: startPos,
+            endPos: endPos,
+        };
+    };
+    InfinityScroll.prototype.destroy = function () {
+        var _a = this.scroll.scroller, content = _a.content, scrollBehaviorY = _a.scrollBehaviorY;
+        while (content.firstChild) {
+            content.removeChild(content.firstChild);
+        }
+        this.domManager.destroy();
+        this.scroll.off('scroll', this.update);
+        this.scroll.off('destroy', this.destroy);
+        scrollBehaviorY.hooks.off(scrollBehaviorY.hooks.eventTypes.computeBoundary);
+    };
+    InfinityScroll.pluginName = 'infinity';
+    return InfinityScroll;
+}());
+export default InfinityScroll;

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

@@ -0,0 +1,44 @@
+import BScroll from '@better-scroll/core';
+import { ApplyOrder } from '@better-scroll/shared-utils';
+export type MouseWheelOptions = Partial<MouseWheelConfig> | true;
+export interface MouseWheelConfig {
+    speed: number;
+    invert: boolean;
+    easeTime: number;
+    discreteTime: number;
+    throttleTime: number;
+    dampingFactor: number;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        mouseWheel?: MouseWheelOptions;
+    }
+}
+export default class MouseWheel {
+    scroll: BScroll;
+    static pluginName: string;
+    static applyOrder: ApplyOrder;
+    mouseWheelOpt: MouseWheelConfig;
+    private eventRegister;
+    private wheelEndTimer;
+    private wheelMoveTimer;
+    private wheelStart;
+    private deltaCache;
+    private hooksFn;
+    constructor(scroll: BScroll);
+    private init;
+    private handleBScroll;
+    private handleOptions;
+    private handleHooks;
+    private registerEvent;
+    private registerHooks;
+    private wheelHandler;
+    private wheelStartHandler;
+    private cleanCache;
+    private wheelMoveHandler;
+    private wheelEndDetector;
+    private getWheelDelta;
+    private beforeHandler;
+    private getEaseTime;
+    destroy(): void;
+}