cbvirtua 1.0.105 → 1.0.107

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

@@ -0,0 +1,37 @@
+import Indicator from './indicator';
+import { assert } from '@better-scroll/shared-utils';
+var Indicators = /** @class */ (function () {
+    function Indicators(scroll) {
+        this.scroll = scroll;
+        this.options = [];
+        this.indicators = [];
+        this.handleOptions();
+        this.handleHooks();
+    }
+    Indicators.prototype.handleOptions = function () {
+        var UserIndicatorsOptions = this.scroll.options.indicators;
+        assert(Array.isArray(UserIndicatorsOptions), "'indicators' must be an array.");
+        for (var _i = 0, UserIndicatorsOptions_1 = UserIndicatorsOptions; _i < UserIndicatorsOptions_1.length; _i++) {
+            var indicatorOptions = UserIndicatorsOptions_1[_i];
+            assert(!!indicatorOptions.relationElement, "'relationElement' must be a HTMLElement.");
+            this.createIndicators(indicatorOptions);
+        }
+    };
+    Indicators.prototype.createIndicators = function (options) {
+        this.indicators.push(new Indicator(this.scroll, options));
+    };
+    Indicators.prototype.handleHooks = function () {
+        var _this = this;
+        var scrollHooks = this.scroll.hooks;
+        scrollHooks.on(scrollHooks.eventTypes.destroy, function () {
+            for (var _i = 0, _a = _this.indicators; _i < _a.length; _i++) {
+                var indicator = _a[_i];
+                indicator.destroy();
+            }
+            _this.indicators = [];
+        });
+    };
+    Indicators.pluginName = 'indicators';
+    return Indicators;
+}());
+export default Indicators;

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

@@ -0,0 +1,47 @@
+import BScroll from '@better-scroll/core';
+import { IndicatorOptions, Postion, ValueSign } from './types';
+import { EventRegister, EventEmitter } from '@better-scroll/shared-utils';
+export default class Indicator {
+    scroll: BScroll;
+    options: IndicatorOptions;
+    wrapper: HTMLElement;
+    indicatorEl: HTMLElement;
+    maxScrollX: number;
+    minScrollX: number;
+    ratioX: number;
+    maxScrollY: number;
+    minScrollY: number;
+    translateXSign: ValueSign;
+    translateYSign: ValueSign;
+    ratioY: number;
+    currentPos: Postion;
+    moved: boolean;
+    startTime: number;
+    initiated: boolean;
+    lastPointX: number;
+    lastPointY: number;
+    startEventRegister: EventRegister;
+    moveEventRegister: EventRegister;
+    endEventRegister: EventRegister;
+    hooksFn: [EventEmitter, string, Function][];
+    constructor(scroll: BScroll, options: IndicatorOptions);
+    private handleDOM;
+    private handleHooks;
+    private transitionTime;
+    private transitionTimingFunction;
+    private handleInteractive;
+    private registerHooks;
+    private registerEvents;
+    refresh(): void;
+    private start;
+    private BScrollIsDisabled;
+    private move;
+    private end;
+    private getBScrollPosByRatio;
+    private indicatorNotMoved;
+    private syncBScroll;
+    updatePosition(BScrollPos: Postion): void;
+    private applyTransformProperty;
+    private getIndicatorPosByRatio;
+    destroy(): void;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/indicators/src/indicator.js

@@ -0,0 +1,286 @@
+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 { EventRegister, getRect, getClientSize, getNow, between, style, maybePrevent, } from '@better-scroll/shared-utils';
+var resolveRatioOption = function (ratioConfig) {
+    var ret = {
+        ratioX: 0,
+        ratioY: 0,
+    };
+    /* istanbul ignore if  */
+    if (!ratioConfig) {
+        return ret;
+    }
+    if (typeof ratioConfig === 'number') {
+        ret.ratioX = ret.ratioY = ratioConfig;
+    }
+    else if (typeof ratioConfig === 'object' && ratioConfig) {
+        ret.ratioX = ratioConfig.x || 0;
+        ret.ratioY = ratioConfig.y || 0;
+    }
+    return ret;
+};
+var handleBubbleAndCancelable = function (e) {
+    maybePrevent(e);
+    e.stopPropagation();
+};
+var Indicator = /** @class */ (function () {
+    function Indicator(scroll, options) {
+        this.scroll = scroll;
+        this.options = options;
+        this.currentPos = {
+            x: 0,
+            y: 0,
+        };
+        this.hooksFn = [];
+        this.handleDOM();
+        this.handleHooks();
+        this.handleInteractive();
+    }
+    Indicator.prototype.handleDOM = function () {
+        var _a = this.options, relationElement = _a.relationElement, _b = _a.relationElementHandleElementIndex, relationElementHandleElementIndex = _b === void 0 ? 0 : _b;
+        this.wrapper = relationElement;
+        this.indicatorEl = this.wrapper.children[relationElementHandleElementIndex];
+    };
+    Indicator.prototype.handleHooks = function () {
+        var _this = this;
+        var scroll = this.scroll;
+        var scrollHooks = scroll.hooks;
+        var translaterHooks = scroll.scroller.translater.hooks;
+        var animaterHooks = scroll.scroller.animater.hooks;
+        this.registerHooks(scrollHooks, scrollHooks.eventTypes.refresh, this.refresh);
+        this.registerHooks(translaterHooks, translaterHooks.eventTypes.translate, function (pos) {
+            _this.updatePosition(pos);
+        });
+        this.registerHooks(animaterHooks, animaterHooks.eventTypes.time, this.transitionTime);
+        this.registerHooks(animaterHooks, animaterHooks.eventTypes.timeFunction, this.transitionTimingFunction);
+    };
+    Indicator.prototype.transitionTime = function (time) {
+        if (time === void 0) { time = 0; }
+        this.indicatorEl.style[style.transitionDuration] = time + 'ms';
+    };
+    Indicator.prototype.transitionTimingFunction = function (easing) {
+        this.indicatorEl.style[style.transitionTimingFunction] = easing;
+    };
+    Indicator.prototype.handleInteractive = function () {
+        if (this.options.interactive !== false) {
+            this.registerEvents();
+        }
+    };
+    Indicator.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    Indicator.prototype.registerEvents = function () {
+        var _a = this.scroll.options, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch;
+        var startEvents = [];
+        var moveEvents = [];
+        var endEvents = [];
+        if (!disableMouse) {
+            startEvents.push({
+                name: 'mousedown',
+                handler: this.start.bind(this),
+            });
+            moveEvents.push({
+                name: 'mousemove',
+                handler: this.move.bind(this),
+            });
+            endEvents.push({
+                name: 'mouseup',
+                handler: this.end.bind(this),
+            });
+        }
+        if (!disableTouch) {
+            startEvents.push({
+                name: 'touchstart',
+                handler: this.start.bind(this),
+            });
+            moveEvents.push({
+                name: 'touchmove',
+                handler: this.move.bind(this),
+            });
+            endEvents.push({
+                name: 'touchend',
+                handler: this.end.bind(this),
+            }, {
+                name: 'touchcancel',
+                handler: this.end.bind(this),
+            });
+        }
+        this.startEventRegister = new EventRegister(this.indicatorEl, startEvents);
+        this.moveEventRegister = new EventRegister(window, moveEvents);
+        this.endEventRegister = new EventRegister(window, endEvents);
+    };
+    Indicator.prototype.refresh = function () {
+        var _a = this.scroll, x = _a.x, y = _a.y, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll, maxBScrollX = _a.maxScrollX, maxBScrollY = _a.maxScrollY;
+        var _b = resolveRatioOption(this.options.ratio), ratioX = _b.ratioX, ratioY = _b.ratioY;
+        var _c = getClientSize(this.wrapper), wrapperWidth = _c.width, wrapperHeight = _c.height;
+        var _d = getRect(this.indicatorEl), indicatorWidth = _d.width, indicatorHeight = _d.height;
+        if (hasHorizontalScroll) {
+            this.maxScrollX = wrapperWidth - indicatorWidth;
+            this.translateXSign =
+                this.maxScrollX > 0 ? -1 /* ValueSign.Positive */ : 1 /* ValueSign.NotPositive */;
+            this.minScrollX = 0;
+            // ensure positive
+            this.ratioX = ratioX ? ratioX : Math.abs(this.maxScrollX / maxBScrollX);
+        }
+        if (hasVerticalScroll) {
+            this.maxScrollY = wrapperHeight - indicatorHeight;
+            this.translateYSign =
+                this.maxScrollY > 0 ? -1 /* ValueSign.Positive */ : 1 /* ValueSign.NotPositive */;
+            this.minScrollY = 0;
+            this.ratioY = ratioY ? ratioY : Math.abs(this.maxScrollY / maxBScrollY);
+        }
+        this.updatePosition({
+            x: x,
+            y: y,
+        });
+    };
+    Indicator.prototype.start = function (e) {
+        if (this.BScrollIsDisabled()) {
+            return;
+        }
+        var point = (e.touches ? e.touches[0] : e);
+        handleBubbleAndCancelable(e);
+        this.initiated = true;
+        this.moved = false;
+        this.lastPointX = point.pageX;
+        this.lastPointY = point.pageY;
+        this.startTime = getNow();
+        this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.beforeScrollStart);
+    };
+    Indicator.prototype.BScrollIsDisabled = function () {
+        return !this.scroll.enabled;
+    };
+    Indicator.prototype.move = function (e) {
+        if (!this.initiated) {
+            return;
+        }
+        var point = (e.touches ? e.touches[0] : e);
+        var pointX = point.pageX;
+        var pointY = point.pageY;
+        handleBubbleAndCancelable(e);
+        var deltaX = pointX - this.lastPointX;
+        var deltaY = pointY - this.lastPointY;
+        this.lastPointX = pointX;
+        this.lastPointY = pointY;
+        if (!this.moved && !this.indicatorNotMoved(deltaX, deltaY)) {
+            this.moved = true;
+            this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollStart);
+        }
+        if (this.moved) {
+            var newPos = this.getBScrollPosByRatio(this.currentPos, deltaX, deltaY);
+            this.syncBScroll(newPos);
+        }
+    };
+    Indicator.prototype.end = function (e) {
+        if (!this.initiated) {
+            return;
+        }
+        this.initiated = false;
+        handleBubbleAndCancelable(e);
+        if (this.moved) {
+            var _a = this.scroll, x = _a.x, y = _a.y;
+            this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollEnd, {
+                x: x,
+                y: y,
+            });
+        }
+    };
+    Indicator.prototype.getBScrollPosByRatio = function (currentPos, deltaX, deltaY) {
+        var currentX = currentPos.x, currentY = currentPos.y;
+        var _a = this.scroll, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll, BScrollMinScrollX = _a.minScrollX, BScrollMaxScrollX = _a.maxScrollX, BScrollMinScrollY = _a.minScrollY, BScrollMaxScrollY = _a.maxScrollY;
+        var _b = this.scroll, x = _b.x, y = _b.y;
+        if (hasHorizontalScroll) {
+            var newPosX = between(currentX + deltaX, Math.min(this.minScrollX, this.maxScrollX), Math.max(this.minScrollX, this.maxScrollX));
+            var roundX = Math.round((newPosX / this.ratioX) * this.translateXSign);
+            x = between(roundX, BScrollMaxScrollX, BScrollMinScrollX);
+        }
+        if (hasVerticalScroll) {
+            var newPosY = between(currentY + deltaY, Math.min(this.minScrollY, this.maxScrollY), Math.max(this.minScrollY, this.maxScrollY));
+            var roundY = Math.round((newPosY / this.ratioY) * this.translateYSign);
+            y = between(roundY, BScrollMaxScrollY, BScrollMinScrollY);
+        }
+        return { x: x, y: y };
+    };
+    Indicator.prototype.indicatorNotMoved = function (deltaX, deltaY) {
+        var _a = this.currentPos, x = _a.x, y = _a.y;
+        var xNotMoved = (x === this.minScrollX && deltaX <= 0) ||
+            (x === this.maxScrollX && deltaX >= 0);
+        var yNotMoved = (y === this.minScrollY && deltaY <= 0) ||
+            (y === this.maxScrollY && deltaY >= 0);
+        return xNotMoved && yNotMoved;
+    };
+    Indicator.prototype.syncBScroll = function (newPos) {
+        var timestamp = getNow();
+        var _a = this.scroll, options = _a.options, scroller = _a.scroller;
+        var probeType = options.probeType, momentumLimitTime = options.momentumLimitTime;
+        scroller.translater.translate(newPos);
+        // dispatch scroll in interval time
+        if (timestamp - this.startTime > momentumLimitTime) {
+            this.startTime = timestamp;
+            if (probeType === 1 /* Probe.Throttle */) {
+                scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, newPos);
+            }
+        }
+        // dispatch scroll all the time
+        if (probeType > 1 /* Probe.Throttle */) {
+            scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, newPos);
+        }
+    };
+    Indicator.prototype.updatePosition = function (BScrollPos) {
+        var newIndicatorPos = this.getIndicatorPosByRatio(BScrollPos);
+        this.applyTransformProperty(newIndicatorPos);
+        this.currentPos = __assign({}, newIndicatorPos);
+    };
+    Indicator.prototype.applyTransformProperty = function (pos) {
+        var translateZ = this.scroll.options.translateZ;
+        var transformProperties = [
+            "translateX(".concat(pos.x, "px)"),
+            "translateY(".concat(pos.y, "px)"),
+            "".concat(translateZ),
+        ];
+        this.indicatorEl.style[style.transform] =
+            transformProperties.join(' ');
+    };
+    Indicator.prototype.getIndicatorPosByRatio = function (BScrollPos) {
+        var x = BScrollPos.x, y = BScrollPos.y;
+        var _a = this.scroll, hasHorizontalScroll = _a.hasHorizontalScroll, hasVerticalScroll = _a.hasVerticalScroll;
+        var position = __assign({}, this.currentPos);
+        if (hasHorizontalScroll) {
+            var roundX = Math.round(this.ratioX * x * this.translateXSign);
+            // maybe maxScrollX is negative
+            position.x = between(roundX, Math.min(this.minScrollX, this.maxScrollX), Math.max(this.minScrollX, this.maxScrollX));
+        }
+        if (hasVerticalScroll) {
+            var roundY = Math.round(this.ratioY * y * this.translateYSign);
+            // maybe maxScrollY is negative
+            position.y = between(roundY, Math.min(this.minScrollY, this.maxScrollY), Math.max(this.minScrollY, this.maxScrollY));
+        }
+        return position;
+    };
+    Indicator.prototype.destroy = function () {
+        if (this.options.interactive !== false) {
+            this.startEventRegister.destroy();
+            this.moveEventRegister.destroy();
+            this.endEventRegister.destroy();
+        }
+        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;
+    };
+    return Indicator;
+}());
+export default Indicator;

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

@@ -0,0 +1,23 @@
+export type Ratio = number | RatioOfDirection;
+export type RatioOfDirection = {
+    x: number;
+    y: number;
+};
+export interface IndicatorOptions {
+    interactive?: boolean;
+    ratio?: Ratio;
+    relationElementHandleElementIndex?: number;
+    relationElement: HTMLElement;
+}
+export declare const enum Direction {
+    Vertical = "vertical",
+    Horizontal = "horizontal"
+}
+export type Postion = {
+    x: number;
+    y: number;
+};
+export declare const enum ValueSign {
+    Positive = -1,
+    NotPositive = 1
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/indicators/src/types.js

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

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

@@ -0,0 +1,27 @@
+declare class ListItem {
+    data: any | null;
+    dom: HTMLElement | null;
+    tombstone: HTMLElement | null;
+    width: number;
+    height: number;
+    pos: number;
+    constructor();
+}
+export type pListItem = Partial<ListItem>;
+export default class DataManager {
+    private fetchFn;
+    private onFetchFinish;
+    loadedNum: number;
+    private fetching;
+    private hasMore;
+    private list;
+    constructor(list: Array<pListItem>, fetchFn: (len: number) => Promise<Array<any> | boolean>, onFetchFinish: (list: Array<pListItem>, hasMore: boolean) => number);
+    update(end: number): Promise<void>;
+    add(data: Array<any>): Array<pListItem>;
+    addEmptyData(len: number): Array<pListItem>;
+    fetch(len: number): Promise<Array<any> | boolean>;
+    checkToFetch(end: number): Promise<void>;
+    getList(): Partial<ListItem>[];
+    resetState(): void;
+}
+export {};

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

@@ -0,0 +1,164 @@
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var ListItem = /** @class */ (function () {
+    function ListItem() {
+        this.data = null;
+        this.dom = null;
+        this.tombstone = null;
+        this.width = 0;
+        this.height = 0;
+        this.pos = 0;
+    }
+    return ListItem;
+}());
+var DataManager = /** @class */ (function () {
+    function DataManager(list, fetchFn, onFetchFinish) {
+        this.fetchFn = fetchFn;
+        this.onFetchFinish = onFetchFinish;
+        this.loadedNum = 0;
+        this.fetching = false;
+        this.hasMore = true;
+        this.list = list || [];
+    }
+    DataManager.prototype.update = function (end) {
+        return __awaiter(this, void 0, void 0, function () {
+            var len;
+            return __generator(this, function (_a) {
+                if (!this.hasMore) {
+                    end = Math.min(end, this.list.length);
+                }
+                // add data placeholder
+                if (end > this.list.length) {
+                    len = end - this.list.length;
+                    this.addEmptyData(len);
+                }
+                // tslint:disable-next-line: no-floating-promises
+                return [2 /*return*/, this.checkToFetch(end)];
+            });
+        });
+    };
+    DataManager.prototype.add = function (data) {
+        for (var i = 0; i < data.length; i++) {
+            if (!this.list[this.loadedNum]) {
+                this.list[this.loadedNum] = { data: data[i] };
+            }
+            else {
+                this.list[this.loadedNum] = __assign(__assign({}, this.list[this.loadedNum]), { data: data[i] });
+            }
+            this.loadedNum++;
+        }
+        return this.list;
+    };
+    DataManager.prototype.addEmptyData = function (len) {
+        for (var i = 0; i < len; i++) {
+            this.list.push(new ListItem());
+        }
+        return this.list;
+    };
+    DataManager.prototype.fetch = function (len) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.fetching) {
+                            return [2 /*return*/, []];
+                        }
+                        this.fetching = true;
+                        return [4 /*yield*/, this.fetchFn(len)];
+                    case 1:
+                        data = _a.sent();
+                        this.fetching = false;
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    DataManager.prototype.checkToFetch = function (end) {
+        return __awaiter(this, void 0, void 0, function () {
+            var min, newData, currentEnd;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.hasMore) {
+                            return [2 /*return*/];
+                        }
+                        if (end <= this.loadedNum) {
+                            return [2 /*return*/];
+                        }
+                        min = end - this.loadedNum;
+                        return [4 /*yield*/, this.fetch(min)];
+                    case 1:
+                        newData = _a.sent();
+                        if (newData instanceof Array && newData.length) {
+                            this.add(newData);
+                            currentEnd = this.onFetchFinish(this.list, true);
+                            return [2 /*return*/, this.checkToFetch(currentEnd)];
+                        }
+                        else if (typeof newData === 'boolean' && newData === false) {
+                            this.hasMore = false;
+                            this.list.splice(this.loadedNum);
+                            this.onFetchFinish(this.list, false);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    DataManager.prototype.getList = function () {
+        return this.list;
+    };
+    DataManager.prototype.resetState = function () {
+        this.loadedNum = 0;
+        this.fetching = false;
+        this.hasMore = true;
+        this.list = [];
+    };
+    return DataManager;
+}());
+export default DataManager;

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

@@ -0,0 +1,26 @@
+import { pListItem } from './DataManager';
+import Tombstone from './Tombstone';
+export default class DomManager {
+    private renderFn;
+    private tombstone;
+    private content;
+    private unusedDom;
+    private timers;
+    constructor(content: HTMLElement, renderFn: (data: any, div?: HTMLElement) => HTMLElement, tombstone: Tombstone);
+    update(list: Array<pListItem>, start: number, end: number): {
+        start: number;
+        end: number;
+        startPos: number;
+        startDelta: number;
+        endPos: number;
+    };
+    private collectUnusedDom;
+    private createDom;
+    private cacheHeight;
+    private positionDom;
+    private getStartPos;
+    removeTombstone(): void;
+    setContent(content: HTMLElement): void;
+    destroy(): void;
+    resetState(): void;
+}