cbvirtua 1.0.105 → 1.0.107

package/better-scroll-dev/better-scroll-dev/dist/packages/shared-utils/src/propertiesProxy.js

@@ -0,0 +1,45 @@
+/* istanbul ignore next */
+var noop = function (val) { };
+var sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+var getProperty = function (obj, key) {
+    var keys = key.split('.');
+    for (var i = 0; i < keys.length - 1; i++) {
+        obj = obj[keys[i]];
+        if (typeof obj !== 'object' || !obj)
+            return;
+    }
+    var lastKey = keys.pop();
+    if (typeof obj[lastKey] === 'function') {
+        return function () {
+            return obj[lastKey].apply(obj, arguments);
+        };
+    }
+    else {
+        return obj[lastKey];
+    }
+};
+var setProperty = function (obj, key, value) {
+    var keys = key.split('.');
+    var temp;
+    for (var i = 0; i < keys.length - 1; i++) {
+        temp = keys[i];
+        if (!obj[temp])
+            obj[temp] = {};
+        obj = obj[temp];
+    }
+    obj[keys.pop()] = value;
+};
+export function propertiesProxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return getProperty(this, sourceKey);
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        setProperty(this, sourceKey, val);
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/shared-utils/src/raf.d.ts

@@ -0,0 +1,2 @@
+export declare const requestAnimationFrame: any;
+export declare const cancelAnimationFrame: any;

package/better-scroll-dev/better-scroll-dev/dist/packages/shared-utils/src/raf.js

@@ -0,0 +1,32 @@
+import { inBrowser } from './env';
+var DEFAULT_INTERVAL = 1000 / 60;
+var windowCompat = inBrowser && window;
+/* istanbul ignore next */
+function noop() { }
+export var requestAnimationFrame = (function () {
+    /* istanbul ignore if  */
+    if (!inBrowser) {
+        return noop;
+    }
+    return (windowCompat.requestAnimationFrame ||
+        windowCompat.webkitRequestAnimationFrame ||
+        windowCompat.mozRequestAnimationFrame ||
+        windowCompat.oRequestAnimationFrame ||
+        // if all else fails, use setTimeout
+        function (callback) {
+            return window.setTimeout(callback, callback.interval || DEFAULT_INTERVAL); // make interval as precise as possible.
+        });
+})();
+export var cancelAnimationFrame = (function () {
+    /* istanbul ignore if  */
+    if (!inBrowser) {
+        return noop;
+    }
+    return (windowCompat.cancelAnimationFrame ||
+        windowCompat.webkitCancelAnimationFrame ||
+        windowCompat.mozCancelAnimationFrame ||
+        windowCompat.oCancelAnimationFrame ||
+        function (id) {
+            window.clearTimeout(id);
+        });
+})();

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

@@ -0,0 +1,4 @@
+export type Position = {
+    x: number;
+    y: number;
+};

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

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

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/PagesMatrix.d.ts

@@ -0,0 +1,25 @@
+import BScroll from '@better-scroll/core';
+import { PageIndex } from './SlidePages';
+export interface PageStats {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    cx: number;
+    cy: number;
+}
+export default class PagesMatrix {
+    private scroll;
+    pages: Array<Array<PageStats>>;
+    pageLengthOfX: number;
+    pageLengthOfY: number;
+    private wrapperWidth;
+    private wrapperHeight;
+    private scrollerWidth;
+    private scrollerHeight;
+    constructor(scroll: BScroll);
+    init(): void;
+    getPageStats(pageX: number, pageY: number): PageStats;
+    getNearestPageIndex(x: number, y: number): PageIndex;
+    private buildPagesMatrix;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/PagesMatrix.js

@@ -0,0 +1,83 @@
+import { DEFAULT_PAGE_STATS } from './constants';
+var PagesMatrix = /** @class */ (function () {
+    function PagesMatrix(scroll) {
+        this.scroll = scroll;
+        this.init();
+    }
+    PagesMatrix.prototype.init = function () {
+        var scroller = this.scroll.scroller;
+        var scrollBehaviorX = scroller.scrollBehaviorX, scrollBehaviorY = scroller.scrollBehaviorY;
+        this.wrapperWidth = scrollBehaviorX.wrapperSize;
+        this.wrapperHeight = scrollBehaviorY.wrapperSize;
+        this.scrollerHeight = scrollBehaviorY.contentSize;
+        this.scrollerWidth = scrollBehaviorX.contentSize;
+        this.pages = this.buildPagesMatrix(this.wrapperWidth, this.wrapperHeight);
+        this.pageLengthOfX = this.pages ? this.pages.length : 0;
+        this.pageLengthOfY = this.pages && this.pages[0] ? this.pages[0].length : 0;
+    };
+    PagesMatrix.prototype.getPageStats = function (pageX, pageY) {
+        // Returns the default Stats when no Stats are retrieved
+        // Scene: When the `content` element is an empty bounding box, the return value of the `width/height` function of el.getBoundingClientRect is 0 and pages will be calculated as an empty array.
+        // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect
+        return this.pages[pageX] && this.pages[pageX][pageY]
+            ? this.pages[pageX][pageY]
+            : DEFAULT_PAGE_STATS;
+    };
+    PagesMatrix.prototype.getNearestPageIndex = function (x, y) {
+        var pageX = 0;
+        var pageY = 0;
+        var l = this.pages.length;
+        for (; pageX < l - 1; pageX++) {
+            if (x >= this.pages[pageX][0].cx) {
+                break;
+            }
+        }
+        l = this.pages[pageX] ? this.pages[pageX].length : 0;
+        for (; pageY < l - 1; pageY++) {
+            if (y >= this.pages[0][pageY].cy) {
+                break;
+            }
+        }
+        return {
+            pageX: pageX,
+            pageY: pageY,
+        };
+    };
+    // (n x 1) matrix for horizontal scroll or
+    // (1 * n) matrix for vertical scroll
+    PagesMatrix.prototype.buildPagesMatrix = function (stepX, stepY) {
+        var pages = [];
+        var x = 0;
+        var y;
+        var cx;
+        var cy;
+        var i = 0;
+        var l;
+        var maxScrollPosX = this.scroll.scroller.scrollBehaviorX.maxScrollPos;
+        var maxScrollPosY = this.scroll.scroller.scrollBehaviorY.maxScrollPos;
+        cx = Math.round(stepX / 2);
+        cy = Math.round(stepY / 2);
+        while (x > -this.scrollerWidth) {
+            pages[i] = [];
+            l = 0;
+            y = 0;
+            while (y > -this.scrollerHeight) {
+                pages[i][l] = {
+                    x: Math.max(x, maxScrollPosX),
+                    y: Math.max(y, maxScrollPosY),
+                    width: stepX,
+                    height: stepY,
+                    cx: x - cx,
+                    cy: y - cy,
+                };
+                y -= stepY;
+                l++;
+            }
+            x -= stepX;
+            i++;
+        }
+        return pages;
+    };
+    return PagesMatrix;
+}());
+export default PagesMatrix;

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/SlidePages.d.ts

@@ -0,0 +1,42 @@
+import BScroll from '@better-scroll/core';
+import { SlideConfig } from './index';
+import PagesMatrix, { PageStats } from './PagesMatrix';
+export interface PageIndex {
+    pageX: number;
+    pageY: number;
+}
+export interface Position {
+    x: number;
+    y: number;
+}
+export type Page = PageIndex & Position;
+export default class SlidePages {
+    scroll: BScroll;
+    private slideOptions;
+    loopX: boolean;
+    loopY: boolean;
+    slideX: boolean;
+    slideY: boolean;
+    wannaLoop: boolean;
+    pagesMatrix: PagesMatrix;
+    currentPage: Page;
+    constructor(scroll: BScroll, slideOptions: SlideConfig);
+    refresh(): void;
+    getAdjustedCurrentPage(): Page;
+    setCurrentPage(newPage: Page): void;
+    getInternalPage(pageX: number, pageY: number): Page;
+    getInitialPage(showFirstPage?: boolean, firstInitialised?: boolean): Page;
+    getExposedPage(page: Page): Page;
+    getExposedPageByPageIndex(pageIndexX: number, pageIndexY: number): Page;
+    getWillChangedPage(page: Page): Page;
+    private fixedPage;
+    getPageStats(): PageStats;
+    getValidPageIndex(x: number, y: number): PageIndex;
+    nextPageIndex(): PageIndex;
+    prevPageIndex(): PageIndex;
+    getNearestPage(x: number, y: number): Page;
+    getPageByDirection(page: Page, directionX: number, directionY: number): Page;
+    resetLoopPage(): PageIndex | undefined;
+    private getPageIndexByDirection;
+    private checkSlideLoop;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/SlidePages.js

@@ -0,0 +1,260 @@
+import { between, extend, warn } from '@better-scroll/shared-utils';
+import PagesMatrix from './PagesMatrix';
+import { BASE_PAGE } from './constants';
+var SlidePages = /** @class */ (function () {
+    function SlidePages(scroll, slideOptions) {
+        this.scroll = scroll;
+        this.slideOptions = slideOptions;
+        this.slideX = false;
+        this.slideY = false;
+        this.currentPage = extend({}, BASE_PAGE);
+    }
+    SlidePages.prototype.refresh = function () {
+        this.pagesMatrix = new PagesMatrix(this.scroll);
+        this.checkSlideLoop();
+        this.currentPage = this.getAdjustedCurrentPage();
+    };
+    SlidePages.prototype.getAdjustedCurrentPage = function () {
+        var _a = this.currentPage, pageX = _a.pageX, pageY = _a.pageY;
+        // page index should be handled
+        // because page counts may reduce
+        pageX = Math.min(pageX, this.pagesMatrix.pageLengthOfX - 1);
+        pageY = Math.min(pageY, this.pagesMatrix.pageLengthOfY - 1);
+        // loop scene should also be respected
+        // because clonedNode will cause pageLength increasing
+        if (this.loopX) {
+            pageX = Math.min(pageX, this.pagesMatrix.pageLengthOfX - 2);
+        }
+        if (this.loopY) {
+            pageY = Math.min(pageY, this.pagesMatrix.pageLengthOfY - 2);
+        }
+        var _b = this.pagesMatrix.getPageStats(pageX, pageY), x = _b.x, y = _b.y;
+        return { pageX: pageX, pageY: pageY, x: x, y: y };
+    };
+    SlidePages.prototype.setCurrentPage = function (newPage) {
+        this.currentPage = newPage;
+    };
+    SlidePages.prototype.getInternalPage = function (pageX, pageY) {
+        if (pageX >= this.pagesMatrix.pageLengthOfX) {
+            pageX = this.pagesMatrix.pageLengthOfX - 1;
+        }
+        else if (pageX < 0) {
+            pageX = 0;
+        }
+        if (pageY >= this.pagesMatrix.pageLengthOfY) {
+            pageY = this.pagesMatrix.pageLengthOfY - 1;
+        }
+        else if (pageY < 0) {
+            pageY = 0;
+        }
+        var _a = this.pagesMatrix.getPageStats(pageX, pageY), x = _a.x, y = _a.y;
+        return {
+            pageX: pageX,
+            pageY: pageY,
+            x: x,
+            y: y,
+        };
+    };
+    SlidePages.prototype.getInitialPage = function (showFirstPage, firstInitialised) {
+        if (showFirstPage === void 0) { showFirstPage = false; }
+        if (firstInitialised === void 0) { firstInitialised = false; }
+        var _a = this.slideOptions, startPageXIndex = _a.startPageXIndex, startPageYIndex = _a.startPageYIndex;
+        var firstPageX = this.loopX ? 1 : 0;
+        var firstPageY = this.loopY ? 1 : 0;
+        var pageX = showFirstPage ? firstPageX : this.currentPage.pageX;
+        var pageY = showFirstPage ? firstPageY : this.currentPage.pageY;
+        if (firstInitialised) {
+            pageX = this.loopX ? startPageXIndex + 1 : startPageXIndex;
+            pageY = this.loopY ? startPageYIndex + 1 : startPageYIndex;
+        }
+        else {
+            pageX = showFirstPage ? firstPageX : this.currentPage.pageX;
+            pageY = showFirstPage ? firstPageY : this.currentPage.pageY;
+        }
+        var _b = this.pagesMatrix.getPageStats(pageX, pageY), x = _b.x, y = _b.y;
+        return {
+            pageX: pageX,
+            pageY: pageY,
+            x: x,
+            y: y,
+        };
+    };
+    SlidePages.prototype.getExposedPage = function (page) {
+        var exposedPage = extend({}, page);
+        // only pageX or pageY need fix
+        if (this.loopX) {
+            exposedPage.pageX = this.fixedPage(exposedPage.pageX, this.pagesMatrix.pageLengthOfX - 2);
+        }
+        if (this.loopY) {
+            exposedPage.pageY = this.fixedPage(exposedPage.pageY, this.pagesMatrix.pageLengthOfY - 2);
+        }
+        return exposedPage;
+    };
+    SlidePages.prototype.getExposedPageByPageIndex = function (pageIndexX, pageIndexY) {
+        var page = {
+            pageX: pageIndexX,
+            pageY: pageIndexY,
+        };
+        if (this.loopX) {
+            page.pageX = pageIndexX + 1;
+        }
+        if (this.loopY) {
+            page.pageY = pageIndexY + 1;
+        }
+        var _a = this.pagesMatrix.getPageStats(page.pageX, page.pageY), x = _a.x, y = _a.y;
+        return {
+            x: x,
+            y: y,
+            pageX: pageIndexX,
+            pageY: pageIndexY,
+        };
+    };
+    SlidePages.prototype.getWillChangedPage = function (page) {
+        page = extend({}, page);
+        // Page need fix
+        if (this.loopX) {
+            page.pageX = this.fixedPage(page.pageX, this.pagesMatrix.pageLengthOfX - 2);
+            page.x = this.pagesMatrix.getPageStats(page.pageX + 1, 0).x;
+        }
+        if (this.loopY) {
+            page.pageY = this.fixedPage(page.pageY, this.pagesMatrix.pageLengthOfY - 2);
+            page.y = this.pagesMatrix.getPageStats(0, page.pageY + 1).y;
+        }
+        return page;
+    };
+    SlidePages.prototype.fixedPage = function (page, realPageLen) {
+        var pageIndex = [];
+        for (var i = 0; i < realPageLen; i++) {
+            pageIndex.push(i);
+        }
+        pageIndex.unshift(realPageLen - 1);
+        pageIndex.push(0);
+        return pageIndex[page];
+    };
+    SlidePages.prototype.getPageStats = function () {
+        return this.pagesMatrix.getPageStats(this.currentPage.pageX, this.currentPage.pageY);
+    };
+    SlidePages.prototype.getValidPageIndex = function (x, y) {
+        var lastX = this.pagesMatrix.pageLengthOfX - 1;
+        var lastY = this.pagesMatrix.pageLengthOfY - 1;
+        var firstX = 0;
+        var firstY = 0;
+        if (this.loopX) {
+            x += 1;
+            firstX = firstX + 1;
+            lastX = lastX - 1;
+        }
+        if (this.loopY) {
+            y += 1;
+            firstY = firstY + 1;
+            lastY = lastY - 1;
+        }
+        x = between(x, firstX, lastX);
+        y = between(y, firstY, lastY);
+        return {
+            pageX: x,
+            pageY: y,
+        };
+    };
+    SlidePages.prototype.nextPageIndex = function () {
+        return this.getPageIndexByDirection("positive" /* Direction.Positive */);
+    };
+    SlidePages.prototype.prevPageIndex = function () {
+        return this.getPageIndexByDirection("negative" /* Direction.Negative */);
+    };
+    SlidePages.prototype.getNearestPage = function (x, y) {
+        var pageIndex = this.pagesMatrix.getNearestPageIndex(x, y);
+        var pageX = pageIndex.pageX, pageY = pageIndex.pageY;
+        var newX = this.pagesMatrix.getPageStats(pageX, 0).x;
+        var newY = this.pagesMatrix.getPageStats(0, pageY).y;
+        return {
+            x: newX,
+            y: newY,
+            pageX: pageX,
+            pageY: pageY,
+        };
+    };
+    SlidePages.prototype.getPageByDirection = function (page, directionX, directionY) {
+        var pageX = page.pageX, pageY = page.pageY;
+        if (pageX === this.currentPage.pageX) {
+            pageX = between(pageX + directionX, 0, this.pagesMatrix.pageLengthOfX - 1);
+        }
+        if (pageY === this.currentPage.pageY) {
+            pageY = between(pageY + directionY, 0, this.pagesMatrix.pageLengthOfY - 1);
+        }
+        var x = this.pagesMatrix.getPageStats(pageX, 0).x;
+        var y = this.pagesMatrix.getPageStats(0, pageY).y;
+        return {
+            x: x,
+            y: y,
+            pageX: pageX,
+            pageY: pageY,
+        };
+    };
+    SlidePages.prototype.resetLoopPage = function () {
+        if (this.loopX) {
+            if (this.currentPage.pageX === 0) {
+                return {
+                    pageX: this.pagesMatrix.pageLengthOfX - 2,
+                    pageY: this.currentPage.pageY,
+                };
+            }
+            if (this.currentPage.pageX === this.pagesMatrix.pageLengthOfX - 1) {
+                return {
+                    pageX: 1,
+                    pageY: this.currentPage.pageY,
+                };
+            }
+        }
+        if (this.loopY) {
+            if (this.currentPage.pageY === 0) {
+                return {
+                    pageX: this.currentPage.pageX,
+                    pageY: this.pagesMatrix.pageLengthOfY - 2,
+                };
+            }
+            if (this.currentPage.pageY === this.pagesMatrix.pageLengthOfY - 1) {
+                return {
+                    pageX: this.currentPage.pageX,
+                    pageY: 1,
+                };
+            }
+        }
+    };
+    SlidePages.prototype.getPageIndexByDirection = function (direction) {
+        var x = this.currentPage.pageX;
+        var y = this.currentPage.pageY;
+        if (this.slideX) {
+            x = direction === "negative" /* Direction.Negative */ ? x - 1 : x + 1;
+        }
+        if (this.slideY) {
+            y = direction === "negative" /* Direction.Negative */ ? y - 1 : y + 1;
+        }
+        return {
+            pageX: x,
+            pageY: y,
+        };
+    };
+    SlidePages.prototype.checkSlideLoop = function () {
+        this.wannaLoop = this.slideOptions.loop;
+        if (this.pagesMatrix.pageLengthOfX > 1) {
+            this.slideX = true;
+        }
+        else {
+            this.slideX = false;
+        }
+        if (this.pagesMatrix.pages[0] && this.pagesMatrix.pageLengthOfY > 1) {
+            this.slideY = true;
+        }
+        else {
+            this.slideY = false;
+        }
+        this.loopX = this.wannaLoop && this.slideX;
+        this.loopY = this.wannaLoop && this.slideY;
+        if (this.slideX && this.slideY) {
+            warn('slide does not support two direction at the same time.');
+        }
+    };
+    return SlidePages;
+}());
+export default SlidePages;

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const BASE_PAGE: {
+    pageX: number;
+    pageY: number;
+    x: number;
+    y: number;
+};
+export declare const DEFAULT_PAGE_STATS: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    cx: number;
+    cy: number;
+};

package/better-scroll-dev/better-scroll-dev/dist/packages/slide/src/constants.js

@@ -0,0 +1,14 @@
+export var BASE_PAGE = {
+    pageX: 0,
+    pageY: 0,
+    x: 0,
+    y: 0,
+};
+export var DEFAULT_PAGE_STATS = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    cx: 0,
+    cy: 0,
+};

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

@@ -0,0 +1,86 @@
+import BScroll from '@better-scroll/core';
+import { EaseItem } from '@better-scroll/shared-utils';
+import SlidePages, { Page } from './SlidePages';
+export interface SlideConfig {
+    loop: boolean;
+    threshold: number;
+    speed: number;
+    easing: {
+        style: string;
+        fn: (t: number) => number;
+    };
+    listenFlick: boolean;
+    autoplay: boolean;
+    interval: number;
+    startPageXIndex: number;
+    startPageYIndex: number;
+}
+export type SlideOptions = Partial<SlideConfig> | true;
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        slide?: SlideOptions;
+    }
+    interface CustomAPI {
+        slide: PluginAPI;
+    }
+}
+interface PluginAPI {
+    next(time?: number, easing?: EaseItem): void;
+    prev(time?: number, easing?: EaseItem): void;
+    goToPage(x: number, y: number, time?: number, easing?: EaseItem): void;
+    getCurrentPage(): Page;
+    startPlay(): void;
+    pausePlay(): void;
+}
+export default class Slide implements PluginAPI {
+    scroll: BScroll;
+    static pluginName: string;
+    pages: SlidePages;
+    options: SlideConfig;
+    initialised: boolean;
+    contentChanged: boolean;
+    prevContent: HTMLElement;
+    exposedPage: Page;
+    private cachedClonedPageDOM;
+    private oneToMorePagesInLoop;
+    private moreToOnePageInLoop;
+    private thresholdX;
+    private thresholdY;
+    private hooksFn;
+    private resetLooping;
+    private willChangeToPage;
+    private autoplayTimer;
+    constructor(scroll: BScroll);
+    private satisfyInitialization;
+    init(): void;
+    private createPages;
+    private handleBScroll;
+    private handleOptions;
+    private handleLoop;
+    private resetLoopChangedStatus;
+    private handleHooks;
+    startPlay(): void;
+    pausePlay(): void;
+    private setSlideInlineStyle;
+    next(time?: number, easing?: EaseItem): void;
+    prev(time?: number, easing?: EaseItem): void;
+    goToPage(pageX: number, pageY: number, time?: number, easing?: EaseItem): void;
+    getCurrentPage(): Page;
+    setCurrentPage(page: Page): void;
+    nearestPage(x: number, y: number): Page;
+    private satisfyThreshold;
+    private refreshHandler;
+    private computeThreshold;
+    private cloneFirstAndLastSlidePage;
+    private removeClonedSlidePage;
+    private modifyCurrentPage;
+    private goTo;
+    private flickHandler;
+    private getEaseTime;
+    private modifyScrollMetaHandler;
+    private scrollHandler;
+    private pageWillChangeTo;
+    private registerHooks;
+    destroy(): void;
+}
+export {};