cbvirtua 1.0.109 → 1.0.115

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

@@ -1,401 +0,0 @@
-import { between, prepend, removeChild, ease, extend, warn, } from '@better-scroll/shared-utils';
-import SlidePages from './SlidePages';
-import propertiesConfig from './propertiesConfig';
-import { BASE_PAGE } from './constants';
-var samePage = function (p1, p2) {
-    return p1.pageX === p2.pageX && p1.pageY === p2.pageY;
-};
-var Slide = /** @class */ (function () {
-    function Slide(scroll) {
-        this.scroll = scroll;
-        this.cachedClonedPageDOM = [];
-        this.resetLooping = false;
-        this.autoplayTimer = 0;
-        if (!this.satisfyInitialization()) {
-            return;
-        }
-        this.init();
-    }
-    Slide.prototype.satisfyInitialization = function () {
-        if (this.scroll.scroller.content.children.length <= 0) {
-            warn("slide need at least one slide page to be initialised." +
-                "please check your DOM layout.");
-            return false;
-        }
-        return true;
-    };
-    Slide.prototype.init = function () {
-        this.willChangeToPage = extend({}, BASE_PAGE);
-        this.handleBScroll();
-        this.handleOptions();
-        this.handleHooks();
-        this.createPages();
-    };
-    Slide.prototype.createPages = function () {
-        this.pages = new SlidePages(this.scroll, this.options);
-    };
-    Slide.prototype.handleBScroll = function () {
-        this.scroll.registerType(['slideWillChange', 'slidePageChanged']);
-        this.scroll.proxy(propertiesConfig);
-    };
-    Slide.prototype.handleOptions = function () {
-        var userOptions = (this.scroll.options.slide === true
-            ? {}
-            : this.scroll.options.slide);
-        var defaultOptions = {
-            loop: true,
-            threshold: 0.1,
-            speed: 400,
-            easing: ease.bounce,
-            listenFlick: true,
-            autoplay: true,
-            interval: 3000,
-            startPageXIndex: 0,
-            startPageYIndex: 0,
-        };
-        this.options = extend(defaultOptions, userOptions);
-    };
-    Slide.prototype.handleLoop = function (prevSlideContent) {
-        var loop = this.options.loop;
-        var slideContent = this.scroll.scroller.content;
-        var currentSlidePagesLength = slideContent.children.length;
-        // only should respect loop scene
-        if (loop) {
-            if (slideContent !== prevSlideContent) {
-                this.resetLoopChangedStatus();
-                this.removeClonedSlidePage(prevSlideContent);
-                currentSlidePagesLength > 1 &&
-                    this.cloneFirstAndLastSlidePage(slideContent);
-            }
-            else {
-                // many pages reduce to one page
-                if (currentSlidePagesLength === 3 && this.initialised) {
-                    this.removeClonedSlidePage(slideContent);
-                    this.moreToOnePageInLoop = true;
-                    this.oneToMorePagesInLoop = false;
-                }
-                else if (currentSlidePagesLength > 1) {
-                    // one page increases to many page
-                    if (this.initialised && this.cachedClonedPageDOM.length === 0) {
-                        this.oneToMorePagesInLoop = true;
-                        this.moreToOnePageInLoop = false;
-                    }
-                    else {
-                        this.removeClonedSlidePage(slideContent);
-                        this.resetLoopChangedStatus();
-                    }
-                    this.cloneFirstAndLastSlidePage(slideContent);
-                }
-                else {
-                    this.resetLoopChangedStatus();
-                }
-            }
-        }
-    };
-    Slide.prototype.resetLoopChangedStatus = function () {
-        this.moreToOnePageInLoop = false;
-        this.oneToMorePagesInLoop = false;
-    };
-    Slide.prototype.handleHooks = function () {
-        var _this = this;
-        var scrollHooks = this.scroll.hooks;
-        var scrollerHooks = this.scroll.scroller.hooks;
-        var listenFlick = this.options.listenFlick;
-        this.prevContent = this.scroll.scroller.content;
-        this.hooksFn = [];
-        // scroll
-        this.registerHooks(this.scroll, this.scroll.eventTypes.beforeScrollStart, this.pausePlay);
-        this.registerHooks(this.scroll, this.scroll.eventTypes.scrollEnd, this.modifyCurrentPage);
-        this.registerHooks(this.scroll, this.scroll.eventTypes.scrollEnd, this.startPlay);
-        // for mousewheel event
-        if (this.scroll.eventTypes.mousewheelMove) {
-            this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelMove, function () {
-                // prevent default action of mousewheelMove
-                return true;
-            });
-            this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelEnd, function (delta) {
-                if (delta.directionX === 1 /* Direction.Positive */ ||
-                    delta.directionY === 1 /* Direction.Positive */) {
-                    _this.next();
-                }
-                if (delta.directionX === -1 /* Direction.Negative */ ||
-                    delta.directionY === -1 /* Direction.Negative */) {
-                    _this.prev();
-                }
-            });
-        }
-        // scrollHooks
-        this.registerHooks(scrollHooks, scrollHooks.eventTypes.refresh, this.refreshHandler);
-        this.registerHooks(scrollHooks, scrollHooks.eventTypes.destroy, this.destroy);
-        // scroller
-        this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.beforeRefresh, function () {
-            _this.handleLoop(_this.prevContent);
-            _this.setSlideInlineStyle();
-        });
-        this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.momentum, this.modifyScrollMetaHandler);
-        this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.scroll, this.scrollHandler);
-        // a click operation will clearTimer, so restart a new one
-        this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.checkClick, this.startPlay);
-        if (listenFlick) {
-            this.registerHooks(scrollerHooks, scrollerHooks.eventTypes.flick, this.flickHandler);
-        }
-    };
-    Slide.prototype.startPlay = function () {
-        var _this = this;
-        var _a = this.options, interval = _a.interval, autoplay = _a.autoplay;
-        if (autoplay) {
-            clearTimeout(this.autoplayTimer);
-            this.autoplayTimer = window.setTimeout(function () {
-                _this.next();
-            }, interval);
-        }
-    };
-    Slide.prototype.pausePlay = function () {
-        if (this.options.autoplay) {
-            clearTimeout(this.autoplayTimer);
-        }
-    };
-    Slide.prototype.setSlideInlineStyle = function () {
-        var styleConfigurations = [
-            {
-                direction: 'scrollX',
-                sizeType: 'offsetWidth',
-                styleType: 'width',
-            },
-            {
-                direction: 'scrollY',
-                sizeType: 'offsetHeight',
-                styleType: 'height',
-            },
-        ];
-        var _a = this.scroll.scroller, slideContent = _a.content, slideWrapper = _a.wrapper;
-        var scrollOptions = this.scroll.options;
-        styleConfigurations.forEach(function (_a) {
-            var direction = _a.direction, sizeType = _a.sizeType, styleType = _a.styleType;
-            // wanna scroll in this direction
-            if (scrollOptions[direction]) {
-                var size = slideWrapper[sizeType];
-                var children = slideContent.children;
-                var length_1 = children.length;
-                for (var i = 0; i < length_1; i++) {
-                    var slidePageDOM = children[i];
-                    slidePageDOM.style[styleType] = size + 'px';
-                }
-                slideContent.style[styleType] = size * length_1 + 'px';
-            }
-        });
-    };
-    Slide.prototype.next = function (time, easing) {
-        var _a = this.pages.nextPageIndex(), pageX = _a.pageX, pageY = _a.pageY;
-        this.goTo(pageX, pageY, time, easing);
-    };
-    Slide.prototype.prev = function (time, easing) {
-        var _a = this.pages.prevPageIndex(), pageX = _a.pageX, pageY = _a.pageY;
-        this.goTo(pageX, pageY, time, easing);
-    };
-    Slide.prototype.goToPage = function (pageX, pageY, time, easing) {
-        var pageIndex = this.pages.getValidPageIndex(pageX, pageY);
-        this.goTo(pageIndex.pageX, pageIndex.pageY, time, easing);
-    };
-    Slide.prototype.getCurrentPage = function () {
-        return this.exposedPage || this.pages.getInitialPage(false, true);
-    };
-    Slide.prototype.setCurrentPage = function (page) {
-        this.pages.setCurrentPage(page);
-        this.exposedPage = this.pages.getExposedPage(page);
-    };
-    Slide.prototype.nearestPage = function (x, y) {
-        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
-        var maxScrollPosX = scrollBehaviorX.maxScrollPos, minScrollPosX = scrollBehaviorX.minScrollPos;
-        var maxScrollPosY = scrollBehaviorY.maxScrollPos, minScrollPosY = scrollBehaviorY.minScrollPos;
-        return this.pages.getNearestPage(between(x, maxScrollPosX, minScrollPosX), between(y, maxScrollPosY, minScrollPosY));
-    };
-    Slide.prototype.satisfyThreshold = function (x, y) {
-        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
-        var satisfied = true;
-        if (Math.abs(x - scrollBehaviorX.absStartPos) <= this.thresholdX &&
-            Math.abs(y - scrollBehaviorY.absStartPos) <= this.thresholdY) {
-            satisfied = false;
-        }
-        return satisfied;
-    };
-    Slide.prototype.refreshHandler = function (content) {
-        var _this = this;
-        if (!this.satisfyInitialization()) {
-            return;
-        }
-        this.pages.refresh();
-        this.computeThreshold();
-        var contentChanged = (this.contentChanged = this.prevContent !== content);
-        if (contentChanged) {
-            this.prevContent = content;
-        }
-        var initPage = this.pages.getInitialPage(this.oneToMorePagesInLoop || this.moreToOnePageInLoop, contentChanged || !this.initialised);
-        if (this.initialised) {
-            this.goTo(initPage.pageX, initPage.pageY, 0);
-        }
-        else {
-            this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.beforeInitialScrollTo, function (position) {
-                _this.initialised = true;
-                position.x = initPage.x;
-                position.y = initPage.y;
-            });
-        }
-        this.startPlay();
-    };
-    Slide.prototype.computeThreshold = function () {
-        var threshold = this.options.threshold;
-        // Integer
-        if (threshold % 1 === 0) {
-            this.thresholdX = threshold;
-            this.thresholdY = threshold;
-        }
-        else {
-            // decimal
-            var _a = this.pages.getPageStats(), width = _a.width, height = _a.height;
-            this.thresholdX = Math.round(width * threshold);
-            this.thresholdY = Math.round(height * threshold);
-        }
-    };
-    Slide.prototype.cloneFirstAndLastSlidePage = function (slideContent) {
-        var children = slideContent.children;
-        var preprendDOM = children[children.length - 1].cloneNode(true);
-        var appendDOM = children[0].cloneNode(true);
-        prepend(preprendDOM, slideContent);
-        slideContent.appendChild(appendDOM);
-        this.cachedClonedPageDOM = [preprendDOM, appendDOM];
-    };
-    Slide.prototype.removeClonedSlidePage = function (slideContent) {
-        // maybe slideContent has removed from DOM Tree
-        var slidePages = (slideContent && slideContent.children) || [];
-        if (slidePages.length) {
-            this.cachedClonedPageDOM.forEach(function (el) {
-                removeChild(slideContent, el);
-            });
-        }
-        this.cachedClonedPageDOM = [];
-    };
-    Slide.prototype.modifyCurrentPage = function (point) {
-        var _a = this.getCurrentPage(), prevExposedPageX = _a.pageX, prevExposedPageY = _a.pageY;
-        var newPage = this.nearestPage(point.x, point.y);
-        this.setCurrentPage(newPage);
-        /* istanbul ignore if */
-        if (this.contentChanged) {
-            this.contentChanged = false;
-            return true;
-        }
-        var _b = this.getCurrentPage(), currentExposedPageX = _b.pageX, currentExposedPageY = _b.pageY;
-        this.pageWillChangeTo(newPage);
-        // loop is true, and one page becomes many pages when call bs.refresh
-        if (this.oneToMorePagesInLoop) {
-            this.oneToMorePagesInLoop = false;
-            return true;
-        }
-        // loop is true, and many page becomes one page when call bs.refresh
-        // if prevPage > 0, dispatch slidePageChanged and scrollEnd events
-        /* istanbul ignore if */
-        if (this.moreToOnePageInLoop &&
-            prevExposedPageX === 0 &&
-            prevExposedPageY === 0) {
-            this.moreToOnePageInLoop = false;
-            return true;
-        }
-        if (prevExposedPageX !== currentExposedPageX ||
-            prevExposedPageY !== currentExposedPageY) {
-            // only trust pageX & pageY when loop is true
-            var page = this.pages.getExposedPageByPageIndex(currentExposedPageX, currentExposedPageY);
-            this.scroll.trigger(this.scroll.eventTypes.slidePageChanged, page);
-        }
-        // triggered by resetLoop
-        if (this.resetLooping) {
-            this.resetLooping = false;
-            return;
-        }
-        var changePage = this.pages.resetLoopPage();
-        if (changePage) {
-            this.resetLooping = true;
-            this.goTo(changePage.pageX, changePage.pageY, 0);
-            // stop user's scrollEnd
-            // since it is a seamless scroll
-            return true;
-        }
-    };
-    Slide.prototype.goTo = function (pageX, pageY, time, easing) {
-        var newPage = this.pages.getInternalPage(pageX, pageY);
-        var scrollEasing = easing || this.options.easing || ease.bounce;
-        var x = newPage.x, y = newPage.y;
-        var deltaX = x - this.scroll.scroller.scrollBehaviorX.currentPos;
-        var deltaY = y - this.scroll.scroller.scrollBehaviorY.currentPos;
-        /* istanbul ignore if */
-        if (!deltaX && !deltaY) {
-            this.scroll.scroller.togglePointerEvents(true);
-            return;
-        }
-        time = time === undefined ? this.getEaseTime(deltaX, deltaY) : time;
-        this.scroll.scroller.scrollTo(x, y, time, scrollEasing);
-    };
-    Slide.prototype.flickHandler = function () {
-        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY;
-        var currentPosX = scrollBehaviorX.currentPos, startPosX = scrollBehaviorX.startPos, directionX = scrollBehaviorX.direction;
-        var currentPosY = scrollBehaviorY.currentPos, startPosY = scrollBehaviorY.startPos, directionY = scrollBehaviorY.direction;
-        var _b = this.pages.currentPage, pageX = _b.pageX, pageY = _b.pageY;
-        var time = this.getEaseTime(currentPosX - startPosX, currentPosY - startPosY);
-        this.goTo(pageX + directionX, pageY + directionY, time);
-    };
-    Slide.prototype.getEaseTime = function (deltaX, deltaY) {
-        return (this.options.speed ||
-            Math.max(Math.max(Math.min(Math.abs(deltaX), 1000), Math.min(Math.abs(deltaY), 1000)), 300));
-    };
-    Slide.prototype.modifyScrollMetaHandler = function (scrollMeta) {
-        var _a = this.scroll.scroller, scrollBehaviorX = _a.scrollBehaviorX, scrollBehaviorY = _a.scrollBehaviorY, animater = _a.animater;
-        var newX = scrollMeta.newX;
-        var newY = scrollMeta.newY;
-        var newPage = this.satisfyThreshold(newX, newY) || animater.forceStopped
-            ? this.pages.getPageByDirection(this.nearestPage(newX, newY), scrollBehaviorX.direction, scrollBehaviorY.direction)
-            : this.pages.currentPage;
-        scrollMeta.time = this.getEaseTime(scrollMeta.newX - newPage.x, scrollMeta.newY - newPage.y);
-        scrollMeta.newX = newPage.x;
-        scrollMeta.newY = newPage.y;
-        scrollMeta.easing = this.options.easing || ease.bounce;
-    };
-    Slide.prototype.scrollHandler = function (_a) {
-        var x = _a.x, y = _a.y;
-        if (this.satisfyThreshold(x, y)) {
-            var newPage = this.nearestPage(x, y);
-            this.pageWillChangeTo(newPage);
-        }
-    };
-    Slide.prototype.pageWillChangeTo = function (newPage) {
-        var changeToPage = this.pages.getWillChangedPage(newPage);
-        if (!samePage(this.willChangeToPage, changeToPage)) {
-            this.willChangeToPage = changeToPage;
-            this.scroll.trigger(this.scroll.eventTypes.slideWillChange, this.willChangeToPage);
-        }
-    };
-    Slide.prototype.registerHooks = function (hooks, name, handler) {
-        hooks.on(name, handler, this);
-        this.hooksFn.push([hooks, name, handler]);
-    };
-    Slide.prototype.destroy = function () {
-        var slideContent = this.scroll.scroller.content;
-        var _a = this.options, loop = _a.loop, autoplay = _a.autoplay;
-        if (loop) {
-            this.removeClonedSlidePage(slideContent);
-        }
-        if (autoplay) {
-            clearTimeout(this.autoplayTimer);
-        }
-        this.hooksFn.forEach(function (item) {
-            var hooks = item[0];
-            var hooksName = item[1];
-            var handlerFn = item[2];
-            if (hooks.eventTypes[hooksName]) {
-                hooks.off(hooksName, handlerFn);
-            }
-        });
-        this.hooksFn.length = 0;
-    };
-    Slide.pluginName = 'slide';
-    return Slide;
-}());
-export default Slide;

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

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

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

@@ -1,33 +0,0 @@
-var sourcePrefix = 'plugins.slide';
-var propertiesMap = [
-    {
-        key: 'next',
-        name: 'next',
-    },
-    {
-        key: 'prev',
-        name: 'prev',
-    },
-    {
-        key: 'goToPage',
-        name: 'goToPage',
-    },
-    {
-        key: 'getCurrentPage',
-        name: 'getCurrentPage',
-    },
-    {
-        key: 'startPlay',
-        name: 'startPlay',
-    },
-    {
-        key: 'pausePlay',
-        name: 'pausePlay',
-    },
-];
-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/wheel/src/index.d.ts

@@ -1,51 +0,0 @@
-import BScroll from '@better-scroll/core';
-import { EaseItem } from '@better-scroll/shared-utils';
-export type WheelOptions = Partial<WheelConfig> | true;
-export interface WheelConfig {
-    selectedIndex: number;
-    rotate: number;
-    adjustTime: number;
-    wheelWrapperClass: string;
-    wheelItemClass: string;
-    wheelDisabledItemClass: string;
-}
-declare module '@better-scroll/core' {
-    interface CustomOptions {
-        wheel?: WheelOptions;
-    }
-    interface CustomAPI {
-        wheel: PluginAPI;
-    }
-}
-interface PluginAPI {
-    wheelTo(index?: number, time?: number, ease?: EaseItem): void;
-    getSelectedIndex(): number;
-    restorePosition(): void;
-}
-export default class Wheel implements PluginAPI {
-    scroll: BScroll;
-    static pluginName: string;
-    options: WheelConfig;
-    wheelItemsAllDisabled: boolean;
-    items: HTMLCollection;
-    itemHeight: number;
-    selectedIndex: number;
-    isAdjustingPosition: boolean;
-    target: EventTarget | null;
-    constructor(scroll: BScroll);
-    init(): void;
-    private handleBScroll;
-    private handleOptions;
-    private handleHooks;
-    private refreshBoundary;
-    setSelectedIndex(index: number, contentChanged?: boolean): void;
-    getSelectedIndex(): number;
-    wheelTo(index?: number, time?: number, ease?: EaseItem): void;
-    restorePosition(): void;
-    private transitionDuration;
-    private timeFunction;
-    private rotateX;
-    private findNearestValidWheel;
-    private checkWheelAllDisabled;
-}
-export {};