cbvirtua 1.0.109 → 1.0.115

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

@@ -1,82 +0,0 @@
-import BScroll, { TranslaterPoint } from '@better-scroll/core';
-import { EventEmitter, EventRegister } from '@better-scroll/shared-utils';
-import EventHandler from './event-handler';
-export declare const enum IndicatorDirection {
-    Horizontal = "horizontal",
-    Vertical = "vertical"
-}
-export declare const enum OffsetType {
-    Step = "step",
-    Point = "clickedPoint"
-}
-export interface IndicatorOptions {
-    wrapper: HTMLElement;
-    direction: IndicatorDirection;
-    fade: boolean;
-    fadeInTime: number;
-    fadeOutTime: number;
-    interactive: boolean;
-    minSize: number;
-    isCustom: boolean;
-    scrollbarTrackClickable: boolean;
-    scrollbarTrackOffsetType: OffsetType;
-    scrollbarTrackOffsetTime: number;
-}
-interface KeysMap {
-    hasScroll: 'hasVerticalScroll' | 'hasHorizontalScroll';
-    size: 'height' | 'width';
-    wrapperSize: 'clientHeight' | 'clientWidth';
-    scrollerSize: 'scrollerHeight' | 'scrollerWidth';
-    maxScrollPos: 'maxScrollY' | 'maxScrollX';
-    pos: 'y' | 'x';
-    point: 'pageX' | 'pageY';
-    translateProperty: 'translateY' | 'translateX';
-    domRect: 'top' | 'left';
-}
-interface ScrollInfo {
-    maxScrollPos: number;
-    minScrollPos: number;
-    sizeRatio: number;
-    baseSize: number;
-}
-export default class Indicator {
-    scroll: BScroll;
-    options: IndicatorOptions;
-    wrapper: HTMLElement;
-    wrapperRect: DOMRect;
-    indicatorEl: HTMLElement;
-    direction: IndicatorDirection;
-    scrollInfo: ScrollInfo;
-    currentPos: number;
-    moved: boolean;
-    startTime: number;
-    keysMap: KeysMap;
-    eventHandler: EventHandler;
-    clickEventRegister: EventRegister;
-    hooksFn: [EventEmitter, string, Function][];
-    constructor(scroll: BScroll, options: IndicatorOptions);
-    private handleFade;
-    private handleHooks;
-    private registerHooks;
-    private bindClick;
-    private handleClick;
-    private calculateclickOffsetPos;
-    getKeysMap(): KeysMap;
-    fade(visible?: boolean): void;
-    refresh(): void;
-    transitionTime(time?: number): void;
-    transitionTimingFunction(easing: string): void;
-    private canScroll;
-    private refreshScrollInfo;
-    updatePosition(point: TranslaterPoint): void;
-    private caculatePosAndSize;
-    private refreshStyle;
-    startHandler(): void;
-    moveHandler(delta: number): void;
-    endHandler(): void;
-    private indicatorNotMoved;
-    private syncBScroll;
-    private newPos;
-    destroy(): void;
-}
-export {};

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

@@ -1,298 +0,0 @@
-import { style, between, getNow, EventRegister, } from '@better-scroll/shared-utils';
-import EventHandler from './event-handler';
-var Indicator = /** @class */ (function () {
-    function Indicator(scroll, options) {
-        this.scroll = scroll;
-        this.options = options;
-        this.hooksFn = [];
-        this.wrapper = options.wrapper;
-        this.direction = options.direction;
-        this.indicatorEl = this.wrapper.children[0];
-        this.keysMap = this.getKeysMap();
-        this.handleFade();
-        this.handleHooks();
-    }
-    Indicator.prototype.handleFade = function () {
-        if (this.options.fade) {
-            this.wrapper.style.opacity = '0';
-        }
-    };
-    Indicator.prototype.handleHooks = function () {
-        var _this = this;
-        var _a = this.options, fade = _a.fade, interactive = _a.interactive, scrollbarTrackClickable = _a.scrollbarTrackClickable;
-        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) {
-            var hasScrollKey = _this.keysMap.hasScroll;
-            if (_this.scroll[hasScrollKey]) {
-                _this.updatePosition(pos);
-            }
-        });
-        this.registerHooks(animaterHooks, animaterHooks.eventTypes.time, this.transitionTime);
-        this.registerHooks(animaterHooks, animaterHooks.eventTypes.timeFunction, this.transitionTimingFunction);
-        if (fade) {
-            this.registerHooks(scroll, scroll.eventTypes.scrollEnd, function () {
-                _this.fade();
-            });
-            this.registerHooks(scroll, scroll.eventTypes.scrollStart, function () {
-                _this.fade(true);
-            });
-            // for mousewheel event
-            if (scroll.eventTypes.mousewheelStart &&
-                scroll.eventTypes.mousewheelEnd) {
-                this.registerHooks(scroll, scroll.eventTypes.mousewheelStart, function () {
-                    _this.fade(true);
-                });
-                this.registerHooks(scroll, scroll.eventTypes.mousewheelMove, function () {
-                    _this.fade(true);
-                });
-                this.registerHooks(scroll, scroll.eventTypes.mousewheelEnd, function () {
-                    _this.fade();
-                });
-            }
-        }
-        if (interactive) {
-            var _b = this.scroll.options, disableMouse = _b.disableMouse, disableTouch = _b.disableTouch;
-            this.eventHandler = new EventHandler(this, {
-                disableMouse: disableMouse,
-                disableTouch: disableTouch,
-            });
-            var eventHandlerHooks = this.eventHandler.hooks;
-            this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchStart, this.startHandler);
-            this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchMove, this.moveHandler);
-            this.registerHooks(eventHandlerHooks, eventHandlerHooks.eventTypes.touchEnd, this.endHandler);
-        }
-        if (scrollbarTrackClickable) {
-            this.bindClick();
-        }
-    };
-    Indicator.prototype.registerHooks = function (hooks, name, handler) {
-        hooks.on(name, handler, this);
-        this.hooksFn.push([hooks, name, handler]);
-    };
-    Indicator.prototype.bindClick = function () {
-        var wrapper = this.wrapper;
-        this.clickEventRegister = new EventRegister(wrapper, [
-            {
-                name: 'click',
-                handler: this.handleClick.bind(this),
-            },
-        ]);
-    };
-    Indicator.prototype.handleClick = function (e) {
-        var newPos = this.calculateclickOffsetPos(e);
-        var _a = this.scroll, x = _a.x, y = _a.y;
-        x = this.direction === "horizontal" /* IndicatorDirection.Horizontal */ ? newPos : x;
-        y = this.direction === "vertical" /* IndicatorDirection.Vertical */ ? newPos : y;
-        this.scroll.scrollTo(x, y, this.options.scrollbarTrackOffsetTime);
-    };
-    Indicator.prototype.calculateclickOffsetPos = function (e) {
-        var _a = this.keysMap, poinKey = _a.point, domRectKey = _a.domRect;
-        var scrollbarTrackOffsetType = this.options.scrollbarTrackOffsetType;
-        var clickPointOffset = e[poinKey] - this.wrapperRect[domRectKey];
-        var scrollToWhere = clickPointOffset < this.currentPos ? -1 /* ScrollTo.Up */ : 1 /* ScrollTo.Down */;
-        var delta = 0;
-        var currentPos = this.currentPos;
-        if (scrollbarTrackOffsetType === "step" /* OffsetType.Step */) {
-            delta = this.scrollInfo.baseSize * scrollToWhere;
-        }
-        else {
-            delta = 0;
-            currentPos = clickPointOffset;
-        }
-        return this.newPos(currentPos, delta, this.scrollInfo);
-    };
-    Indicator.prototype.getKeysMap = function () {
-        if (this.direction === "vertical" /* IndicatorDirection.Vertical */) {
-            return {
-                hasScroll: 'hasVerticalScroll',
-                size: 'height',
-                wrapperSize: 'clientHeight',
-                scrollerSize: 'scrollerHeight',
-                maxScrollPos: 'maxScrollY',
-                pos: 'y',
-                point: 'pageY',
-                translateProperty: 'translateY',
-                domRect: 'top',
-            };
-        }
-        return {
-            hasScroll: 'hasHorizontalScroll',
-            size: 'width',
-            wrapperSize: 'clientWidth',
-            scrollerSize: 'scrollerWidth',
-            maxScrollPos: 'maxScrollX',
-            pos: 'x',
-            point: 'pageX',
-            translateProperty: 'translateX',
-            domRect: 'left',
-        };
-    };
-    Indicator.prototype.fade = function (visible) {
-        var _a = this.options, fadeInTime = _a.fadeInTime, fadeOutTime = _a.fadeOutTime;
-        var time = visible ? fadeInTime : fadeOutTime;
-        var wrapper = this.wrapper;
-        wrapper.style[style.transitionDuration] = time + 'ms';
-        wrapper.style.opacity = visible ? '1' : '0';
-    };
-    Indicator.prototype.refresh = function () {
-        var hasScrollKey = this.keysMap.hasScroll;
-        var scroll = this.scroll;
-        var x = scroll.x, y = scroll.y;
-        this.wrapperRect = this.wrapper.getBoundingClientRect();
-        if (this.canScroll(scroll[hasScrollKey])) {
-            var _a = this.keysMap, wrapperSizeKey = _a.wrapperSize, scrollerSizeKey = _a.scrollerSize, maxScrollPosKey = _a.maxScrollPos;
-            this.scrollInfo = this.refreshScrollInfo(this.wrapper[wrapperSizeKey], scroll[scrollerSizeKey], scroll[maxScrollPosKey], this.indicatorEl[wrapperSizeKey]);
-            this.updatePosition({
-                x: x,
-                y: y,
-            });
-        }
-    };
-    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.canScroll = function (hasScroll) {
-        this.wrapper.style.display = hasScroll ? 'block' : 'none';
-        return hasScroll;
-    };
-    Indicator.prototype.refreshScrollInfo = function (wrapperSize, scrollerSize, maxScrollPos, indicatorElSize) {
-        var baseSize = Math.max(Math.round((wrapperSize * wrapperSize) / (scrollerSize || wrapperSize || 1)), this.options.minSize);
-        if (this.options.isCustom) {
-            baseSize = indicatorElSize;
-        }
-        var maxIndicatorScrollPos = wrapperSize - baseSize;
-        // sizeRatio is negative
-        var sizeRatio = maxIndicatorScrollPos / maxScrollPos;
-        return {
-            baseSize: baseSize,
-            maxScrollPos: maxIndicatorScrollPos,
-            minScrollPos: 0,
-            sizeRatio: sizeRatio,
-        };
-    };
-    Indicator.prototype.updatePosition = function (point) {
-        var _a = this.caculatePosAndSize(point, this.scrollInfo), pos = _a.pos, size = _a.size;
-        this.refreshStyle(size, pos);
-        this.currentPos = pos;
-    };
-    Indicator.prototype.caculatePosAndSize = function (point, scrollInfo) {
-        var posKey = this.keysMap.pos;
-        var sizeRatio = scrollInfo.sizeRatio, baseSize = scrollInfo.baseSize, maxScrollPos = scrollInfo.maxScrollPos, minScrollPos = scrollInfo.minScrollPos;
-        var minSize = this.options.minSize;
-        var pos = Math.round(sizeRatio * point[posKey]);
-        var size;
-        // when out of boundary, slow down size reduction
-        if (pos < minScrollPos) {
-            size = Math.max(baseSize + pos * 3, minSize);
-            pos = minScrollPos;
-        }
-        else if (pos > maxScrollPos) {
-            size = Math.max(baseSize - (pos - maxScrollPos) * 3, minSize);
-            pos = maxScrollPos + baseSize - size;
-        }
-        else {
-            size = baseSize;
-        }
-        return {
-            pos: pos,
-            size: size,
-        };
-    };
-    Indicator.prototype.refreshStyle = function (size, pos) {
-        var _a = this.keysMap, translatePropertyKey = _a.translateProperty, sizeKey = _a.size;
-        var translateZ = this.scroll.options.translateZ;
-        this.indicatorEl.style[sizeKey] = "".concat(size, "px");
-        this.indicatorEl.style[style.transform] = "".concat(translatePropertyKey, "(").concat(pos, "px)").concat(translateZ);
-    };
-    Indicator.prototype.startHandler = function () {
-        this.moved = false;
-        this.startTime = getNow();
-        this.transitionTime();
-        this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.beforeScrollStart);
-    };
-    Indicator.prototype.moveHandler = function (delta) {
-        if (!this.moved && !this.indicatorNotMoved(delta)) {
-            this.moved = true;
-            this.scroll.scroller.hooks.trigger(this.scroll.scroller.hooks.eventTypes.scrollStart);
-        }
-        if (this.moved) {
-            var newPos = this.newPos(this.currentPos, delta, this.scrollInfo);
-            this.syncBScroll(newPos);
-        }
-    };
-    Indicator.prototype.endHandler = function () {
-        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.indicatorNotMoved = function (delta) {
-        var currentPos = this.currentPos;
-        var _a = this.scrollInfo, maxScrollPos = _a.maxScrollPos, minScrollPos = _a.minScrollPos;
-        var notMoved = (currentPos === minScrollPos && delta <= 0) ||
-            (currentPos === maxScrollPos && delta >= 0);
-        return notMoved;
-    };
-    Indicator.prototype.syncBScroll = function (newPos) {
-        var timestamp = getNow();
-        var _a = this.scroll, x = _a.x, y = _a.y, options = _a.options, scroller = _a.scroller, maxScrollY = _a.maxScrollY, minScrollY = _a.minScrollY, maxScrollX = _a.maxScrollX, minScrollX = _a.minScrollX;
-        var probeType = options.probeType, momentumLimitTime = options.momentumLimitTime;
-        var position = { x: x, y: y };
-        if (this.direction === "vertical" /* IndicatorDirection.Vertical */) {
-            position.y = between(newPos, maxScrollY, minScrollY);
-        }
-        else {
-            position.x = between(newPos, maxScrollX, minScrollX);
-        }
-        scroller.translater.translate(position);
-        // 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, position);
-            }
-        }
-        // dispatch scroll all the time
-        if (probeType > 1 /* Probe.Throttle */) {
-            scroller.hooks.trigger(scroller.hooks.eventTypes.scroll, position);
-        }
-    };
-    Indicator.prototype.newPos = function (currentPos, delta, scrollInfo) {
-        var maxScrollPos = scrollInfo.maxScrollPos, sizeRatio = scrollInfo.sizeRatio, minScrollPos = scrollInfo.minScrollPos;
-        var newPos = currentPos + delta;
-        newPos = between(newPos, minScrollPos, maxScrollPos);
-        return Math.round(newPos / sizeRatio);
-    };
-    Indicator.prototype.destroy = function () {
-        var _a = this.options, interactive = _a.interactive, scrollbarTrackClickable = _a.scrollbarTrackClickable, isCustom = _a.isCustom;
-        if (interactive) {
-            this.eventHandler.destroy();
-        }
-        if (scrollbarTrackClickable) {
-            this.clickEventRegister.destroy();
-        }
-        if (!isCustom) {
-            this.wrapper.parentNode.removeChild(this.wrapper);
-        }
-        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/shared-utils/src/Touch.d.ts

@@ -1,29 +0,0 @@
-interface TouchList {
-    length: number;
-    [index: number]: Touch;
-    item: (index: number) => Touch;
-}
-interface Touch {
-    identifier: number;
-    target: EventTarget;
-    screenX: number;
-    screenY: number;
-    clientX: number;
-    clientY: number;
-    pageX: number;
-    pageY: number;
-}
-export interface TouchEvent extends UIEvent {
-    touches: TouchList;
-    targetTouches: TouchList;
-    changedTouches: TouchList;
-    altKey: boolean;
-    metaKey: boolean;
-    ctrlKey: boolean;
-    shiftKey: boolean;
-    rotation: number;
-    scale: number;
-    button: number;
-    _constructed?: boolean;
-}
-export {};

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

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

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

@@ -1,2 +0,0 @@
-export declare function warn(msg: string): void;
-export declare function assert(condition: string | boolean, msg: string): void;

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

@@ -1,8 +0,0 @@
-export function warn(msg) {
-    console.error("[BScroll warn]: ".concat(msg));
-}
-export function assert(condition, msg) {
-    if (!condition) {
-        throw new Error('[BScroll] ' + msg);
-    }
-}

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

@@ -1,67 +0,0 @@
-export type safeCSSStyleDeclaration = {
-    [key: string]: string;
-} & CSSStyleDeclaration;
-export interface DOMRect {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-    [key: string]: number;
-}
-export declare function getElement(el: HTMLElement | string): HTMLElement;
-export declare function addEvent(el: HTMLElement, type: string, fn: EventListenerOrEventListenerObject, capture?: AddEventListenerOptions): void;
-export declare function removeEvent(el: HTMLElement, type: string, fn: EventListenerOrEventListenerObject, capture?: EventListenerOptions): void;
-export declare function maybePrevent(e: Event): void;
-export declare function offset(el: HTMLElement | null): {
-    left: number;
-    top: number;
-};
-export declare function offsetToBody(el: HTMLElement): {
-    left: number;
-    top: number;
-};
-export declare const cssVendor: string;
-export declare const hasPerspective: boolean;
-export declare const hasTouch: boolean;
-export declare const hasTransition: boolean;
-export declare const style: {
-    transform: string;
-    transition: string;
-    transitionTimingFunction: string;
-    transitionDuration: string;
-    transitionDelay: string;
-    transformOrigin: string;
-    transitionEnd: string;
-    transitionProperty: string;
-};
-export declare const eventTypeMap: {
-    [key: string]: number;
-    touchstart: number;
-    touchmove: number;
-    touchend: number;
-    touchcancel: number;
-    mousedown: number;
-    mousemove: number;
-    mouseup: number;
-};
-export declare function getRect(el: HTMLElement): DOMRect;
-export declare function preventDefaultExceptionFn(el: any, exceptions: {
-    tagName?: RegExp;
-    className?: RegExp;
-    [key: string]: any;
-}): boolean;
-export declare const tagExceptionFn: typeof preventDefaultExceptionFn;
-export declare function tap(e: any, eventName: string): void;
-export declare function click(e: any, event?: string): void;
-export declare function dblclick(e: Event): void;
-export declare function prepend(el: HTMLElement, target: HTMLElement): void;
-export declare function before(el: HTMLElement, target: HTMLElement): void;
-export declare function removeChild(el: HTMLElement, child: HTMLElement): void;
-export declare function hasClass(el: HTMLElement, className: string): boolean;
-export declare function addClass(el: HTMLElement, className: string): void;
-export declare function removeClass(el: HTMLElement, className: string): void;
-export declare function HTMLCollectionToArray(el: HTMLCollection): any[];
-export declare function getClientSize(el: HTMLElement): {
-    width: number;
-    height: number;
-};