cbvirtua 1.0.105 → 1.0.107

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/BScroll.js

@@ -0,0 +1,221 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { propertiesConfig } from './Instance';
+import { OptionsConstructor } from './Options';
+import Scroller from './scroller/Scroller';
+import { getElement, warn, isUndef, propertiesProxy, EventEmitter } from '@better-scroll/shared-utils';
+import { bubbling } from './utils/bubbling';
+var BScrollConstructor = /** @class */ (function (_super) {
+    __extends(BScrollConstructor, _super);
+    function BScrollConstructor(el, options) {
+        var _this = _super.call(this, [
+            'refresh',
+            'contentChanged',
+            'enable',
+            'disable',
+            'beforeScrollStart',
+            'scrollStart',
+            'scroll',
+            'scrollEnd',
+            'scrollCancel',
+            'touchEnd',
+            'flick',
+            'destroy'
+        ]) || this;
+        var wrapper = getElement(el);
+        if (!wrapper) {
+            warn('Can not resolve the wrapper DOM.');
+            return _this;
+        }
+        _this.plugins = {};
+        _this.options = new OptionsConstructor().merge(options).process();
+        if (!_this.setContent(wrapper).valid) {
+            return _this;
+        }
+        _this.hooks = new EventEmitter([
+            'refresh',
+            'enable',
+            'disable',
+            'destroy',
+            'beforeInitialScrollTo',
+            'contentChanged'
+        ]);
+        _this.init(wrapper);
+        return _this;
+    }
+    BScrollConstructor.use = function (ctor) {
+        var name = ctor.pluginName;
+        var installed = BScrollConstructor.plugins.some(function (plugin) { return ctor === plugin.ctor; });
+        if (installed)
+            return BScrollConstructor;
+        if (isUndef(name)) {
+            warn("Plugin Class must specify plugin's name in static property by 'pluginName' field.");
+            return BScrollConstructor;
+        }
+        BScrollConstructor.pluginsMap[name] = true;
+        BScrollConstructor.plugins.push({
+            name: name,
+            applyOrder: ctor.applyOrder,
+            ctor: ctor
+        });
+        return BScrollConstructor;
+    };
+    BScrollConstructor.prototype.setContent = function (wrapper) {
+        var contentChanged = false;
+        var valid = true;
+        var content = wrapper.children[this.options.specifiedIndexAsContent];
+        if (!content) {
+            warn('The wrapper need at least one child element to be content element to scroll.');
+            valid = false;
+        }
+        else {
+            contentChanged = this.content !== content;
+            if (contentChanged) {
+                this.content = content;
+            }
+        }
+        return {
+            valid: valid,
+            contentChanged: contentChanged
+        };
+    };
+    BScrollConstructor.prototype.init = function (wrapper) {
+        var _this = this;
+        this.wrapper = wrapper;
+        // mark wrapper to recognize bs instance by DOM attribute
+        wrapper.isBScrollContainer = true;
+        this.scroller = new Scroller(wrapper, this.content, this.options);
+        this.scroller.hooks.on(this.scroller.hooks.eventTypes.resize, function () {
+            _this.refresh();
+        });
+        this.eventBubbling();
+        this.handleAutoBlur();
+        this.enable();
+        this.proxy(propertiesConfig);
+        this.applyPlugins();
+        // maybe boundary has changed, should refresh
+        this.refreshWithoutReset(this.content);
+        var _a = this.options, startX = _a.startX, startY = _a.startY;
+        var position = {
+            x: startX,
+            y: startY
+        };
+        // maybe plugins want to control scroll position
+        if (this.hooks.trigger(this.hooks.eventTypes.beforeInitialScrollTo, position)) {
+            return;
+        }
+        this.scroller.scrollTo(position.x, position.y);
+    };
+    BScrollConstructor.prototype.applyPlugins = function () {
+        var _this = this;
+        var options = this.options;
+        BScrollConstructor.plugins
+            .sort(function (a, b) {
+            var _a;
+            var applyOrderMap = (_a = {},
+                _a["pre" /* ApplyOrder.Pre */] = -1,
+                _a["post" /* ApplyOrder.Post */] = 1,
+                _a);
+            var aOrder = a.applyOrder ? applyOrderMap[a.applyOrder] : 0;
+            var bOrder = b.applyOrder ? applyOrderMap[b.applyOrder] : 0;
+            return aOrder - bOrder;
+        })
+            .forEach(function (item) {
+            var ctor = item.ctor;
+            if (options[item.name] && typeof ctor === 'function') {
+                _this.plugins[item.name] = new ctor(_this);
+            }
+        });
+    };
+    BScrollConstructor.prototype.handleAutoBlur = function () {
+        /* istanbul ignore if  */
+        if (this.options.autoBlur) {
+            this.on(this.eventTypes.beforeScrollStart, function () {
+                var activeElement = document.activeElement;
+                if (activeElement &&
+                    (activeElement.tagName === 'INPUT' ||
+                        activeElement.tagName === 'TEXTAREA')) {
+                    activeElement.blur();
+                }
+            });
+        }
+    };
+    BScrollConstructor.prototype.eventBubbling = function () {
+        bubbling(this.scroller.hooks, this, [
+            this.eventTypes.beforeScrollStart,
+            this.eventTypes.scrollStart,
+            this.eventTypes.scroll,
+            this.eventTypes.scrollEnd,
+            this.eventTypes.scrollCancel,
+            this.eventTypes.touchEnd,
+            this.eventTypes.flick
+        ]);
+    };
+    BScrollConstructor.prototype.refreshWithoutReset = function (content) {
+        this.scroller.refresh(content);
+        this.hooks.trigger(this.hooks.eventTypes.refresh, content);
+        this.trigger(this.eventTypes.refresh, content);
+    };
+    BScrollConstructor.prototype.proxy = function (propertiesConfig) {
+        var _this = this;
+        propertiesConfig.forEach(function (_a) {
+            var key = _a.key, sourceKey = _a.sourceKey;
+            propertiesProxy(_this, sourceKey, key);
+        });
+    };
+    BScrollConstructor.prototype.refresh = function () {
+        var _a = this.setContent(this.wrapper), contentChanged = _a.contentChanged, valid = _a.valid;
+        if (valid) {
+            var content = this.content;
+            this.refreshWithoutReset(content);
+            if (contentChanged) {
+                this.hooks.trigger(this.hooks.eventTypes.contentChanged, content);
+                this.trigger(this.eventTypes.contentChanged, content);
+            }
+            this.scroller.resetPosition();
+        }
+    };
+    BScrollConstructor.prototype.enable = function () {
+        this.scroller.enable();
+        this.hooks.trigger(this.hooks.eventTypes.enable);
+        this.trigger(this.eventTypes.enable);
+    };
+    BScrollConstructor.prototype.disable = function () {
+        this.scroller.disable();
+        this.hooks.trigger(this.hooks.eventTypes.disable);
+        this.trigger(this.eventTypes.disable);
+    };
+    BScrollConstructor.prototype.destroy = function () {
+        this.hooks.trigger(this.hooks.eventTypes.destroy);
+        this.trigger(this.eventTypes.destroy);
+        this.scroller.destroy();
+    };
+    BScrollConstructor.prototype.eventRegister = function (names) {
+        this.registerType(names);
+    };
+    BScrollConstructor.plugins = [];
+    BScrollConstructor.pluginsMap = {};
+    return BScrollConstructor;
+}(EventEmitter));
+export { BScrollConstructor };
+export function createBScroll(el, options) {
+    var bs = new BScrollConstructor(el, options);
+    return bs;
+}
+createBScroll.use = BScrollConstructor.use;
+createBScroll.plugins = BScrollConstructor.plugins;
+createBScroll.pluginsMap = BScrollConstructor.pluginsMap;
+export var BScroll = createBScroll;

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/Instance.d.ts

@@ -0,0 +1,28 @@
+import { Behavior } from './scroller/Behavior';
+import Actions from './scroller/Actions';
+import { ExposedAPI as ExposedAPIByScroller } from './scroller/Scroller';
+import { Animater } from './animater';
+import { ExposedAPI as ExposedAPIByAnimater } from './animater/Base';
+export interface BScrollInstance extends ExposedAPIByScroller, ExposedAPIByAnimater {
+    [key: string]: any;
+    x: Behavior['currentPos'];
+    y: Behavior['currentPos'];
+    hasHorizontalScroll: Behavior['hasScroll'];
+    hasVerticalScroll: Behavior['hasScroll'];
+    scrollerWidth: Behavior['contentSize'];
+    scrollerHeight: Behavior['contentSize'];
+    maxScrollX: Behavior['maxScrollPos'];
+    maxScrollY: Behavior['maxScrollPos'];
+    minScrollX: Behavior['minScrollPos'];
+    minScrollY: Behavior['minScrollPos'];
+    movingDirectionX: Behavior['movingDirection'];
+    movingDirectionY: Behavior['movingDirection'];
+    directionX: Behavior['direction'];
+    directionY: Behavior['direction'];
+    enabled: Actions['enabled'];
+    pending: Animater['pending'];
+}
+export declare const propertiesConfig: {
+    sourceKey: string;
+    key: string;
+}[];

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/Instance.js

@@ -0,0 +1,86 @@
+export var propertiesConfig = [
+    {
+        sourceKey: 'scroller.scrollBehaviorX.currentPos',
+        key: 'x'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.currentPos',
+        key: 'y'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.hasScroll',
+        key: 'hasHorizontalScroll'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.hasScroll',
+        key: 'hasVerticalScroll'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.contentSize',
+        key: 'scrollerWidth'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.contentSize',
+        key: 'scrollerHeight'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.maxScrollPos',
+        key: 'maxScrollX'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.maxScrollPos',
+        key: 'maxScrollY'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.minScrollPos',
+        key: 'minScrollX'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.minScrollPos',
+        key: 'minScrollY'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.movingDirection',
+        key: 'movingDirectionX'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.movingDirection',
+        key: 'movingDirectionY'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorX.direction',
+        key: 'directionX'
+    },
+    {
+        sourceKey: 'scroller.scrollBehaviorY.direction',
+        key: 'directionY'
+    },
+    {
+        sourceKey: 'scroller.actions.enabled',
+        key: 'enabled'
+    },
+    {
+        sourceKey: 'scroller.animater.pending',
+        key: 'pending'
+    },
+    {
+        sourceKey: 'scroller.animater.stop',
+        key: 'stop'
+    },
+    {
+        sourceKey: 'scroller.scrollTo',
+        key: 'scrollTo'
+    },
+    {
+        sourceKey: 'scroller.scrollBy',
+        key: 'scrollBy'
+    },
+    {
+        sourceKey: 'scroller.scrollToElement',
+        key: 'scrollToElement'
+    },
+    {
+        sourceKey: 'scroller.resetPosition',
+        key: 'resetPosition'
+    }
+];

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/Options.d.ts

@@ -0,0 +1,117 @@
+import { Quadrant } from '@better-scroll/shared-utils';
+export type Tap = 'tap' | '';
+export type BounceOptions = Partial<BounceConfig> | boolean;
+export type DblclickOptions = Partial<DblclickConfig> | boolean;
+export interface BounceConfig {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+}
+export interface DblclickConfig {
+    delay: number;
+}
+export interface CustomOptions {
+}
+export interface DefOptions {
+    [key: string]: any;
+    startX?: number;
+    startY?: number;
+    scrollX?: boolean;
+    scrollY?: boolean;
+    freeScroll?: boolean;
+    directionLockThreshold?: number;
+    eventPassthrough?: string;
+    click?: boolean;
+    tap?: Tap;
+    bounce?: BounceOptions;
+    bounceTime?: number;
+    momentum?: boolean;
+    momentumLimitTime?: number;
+    momentumLimitDistance?: number;
+    swipeTime?: number;
+    swipeBounceTime?: number;
+    deceleration?: number;
+    flickLimitTime?: number;
+    flickLimitDistance?: number;
+    resizePolling?: number;
+    probeType?: number;
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+    preventDefaultException?: {
+        tagName?: RegExp;
+        className?: RegExp;
+    };
+    tagException?: {
+        tagName?: RegExp;
+        className?: RegExp;
+    };
+    HWCompositing?: boolean;
+    useTransition?: boolean;
+    bindToWrapper?: boolean;
+    bindToTarget?: boolean;
+    disableMouse?: boolean;
+    disableTouch?: boolean;
+    autoBlur?: boolean;
+    translateZ?: string;
+    dblclick?: DblclickOptions;
+    autoEndDistance?: number;
+    outOfBoundaryDampingFactor?: number;
+    specifiedIndexAsContent?: number;
+    quadrant?: Quadrant;
+}
+export interface Options extends DefOptions, CustomOptions {
+}
+export declare class CustomOptions {
+}
+export declare class OptionsConstructor extends CustomOptions implements DefOptions {
+    [key: string]: any;
+    startX: number;
+    startY: number;
+    scrollX: boolean;
+    scrollY: boolean;
+    freeScroll: boolean;
+    directionLockThreshold: number;
+    eventPassthrough: string;
+    click: boolean;
+    tap: Tap;
+    bounce: BounceConfig;
+    bounceTime: number;
+    momentum: boolean;
+    momentumLimitTime: number;
+    momentumLimitDistance: number;
+    swipeTime: number;
+    swipeBounceTime: number;
+    deceleration: number;
+    flickLimitTime: number;
+    flickLimitDistance: number;
+    resizePolling: number;
+    probeType: number;
+    stopPropagation: boolean;
+    preventDefault: boolean;
+    preventDefaultException: {
+        tagName?: RegExp;
+        className?: RegExp;
+    };
+    tagException: {
+        tagName?: RegExp;
+        className?: RegExp;
+    };
+    HWCompositing: boolean;
+    useTransition: boolean;
+    bindToWrapper: boolean;
+    bindToTarget: boolean;
+    disableMouse: boolean;
+    disableTouch: boolean;
+    autoBlur: boolean;
+    translateZ: string;
+    dblclick: DblclickOptions;
+    autoEndDistance: number;
+    outOfBoundaryDampingFactor: number;
+    specifiedIndexAsContent: number;
+    quadrant: Quadrant;
+    constructor();
+    merge(options?: Options): this;
+    process(): this;
+    resolveBounce(bounceOptions: BounceOptions): BounceConfig;
+}

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/Options.js

@@ -0,0 +1,133 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { hasTransition, hasPerspective, hasTouch, extend, } from '@better-scroll/shared-utils';
+var CustomOptions = /** @class */ (function () {
+    function CustomOptions() {
+    }
+    return CustomOptions;
+}());
+export { CustomOptions };
+var OptionsConstructor = /** @class */ (function (_super) {
+    __extends(OptionsConstructor, _super);
+    function OptionsConstructor() {
+        var _this = _super.call(this) || this;
+        _this.startX = 0;
+        _this.startY = 0;
+        _this.scrollX = false;
+        _this.scrollY = true;
+        _this.freeScroll = false;
+        _this.directionLockThreshold = 0;
+        _this.eventPassthrough = "" /* EventPassthrough.None */;
+        _this.click = false;
+        _this.dblclick = false;
+        _this.tap = '';
+        _this.bounce = {
+            top: true,
+            bottom: true,
+            left: true,
+            right: true,
+        };
+        _this.bounceTime = 800;
+        _this.momentum = true;
+        _this.momentumLimitTime = 300;
+        _this.momentumLimitDistance = 15;
+        _this.swipeTime = 2500;
+        _this.swipeBounceTime = 500;
+        _this.deceleration = 0.0015;
+        _this.flickLimitTime = 200;
+        _this.flickLimitDistance = 100;
+        _this.resizePolling = 60;
+        _this.probeType = 0 /* Probe.Default */;
+        _this.stopPropagation = false;
+        _this.preventDefault = true;
+        _this.preventDefaultException = {
+            tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT|AUDIO)$/,
+        };
+        _this.tagException = {
+            tagName: /^TEXTAREA$/,
+        };
+        _this.HWCompositing = true;
+        _this.useTransition = true;
+        _this.bindToWrapper = false;
+        _this.bindToTarget = false;
+        _this.disableMouse = hasTouch;
+        _this.disableTouch = !hasTouch;
+        _this.autoBlur = true;
+        _this.autoEndDistance = 5;
+        _this.outOfBoundaryDampingFactor = 1 / 3;
+        _this.specifiedIndexAsContent = 0;
+        _this.quadrant = 1 /* Quadrant.First */;
+        return _this;
+    }
+    OptionsConstructor.prototype.merge = function (options) {
+        if (!options)
+            return this;
+        for (var key in options) {
+            if (key === 'bounce') {
+                this.bounce = this.resolveBounce(options[key]);
+                continue;
+            }
+            this[key] = options[key];
+        }
+        return this;
+    };
+    OptionsConstructor.prototype.process = function () {
+        this.translateZ =
+            this.HWCompositing && hasPerspective ? ' translateZ(1px)' : '';
+        this.useTransition = this.useTransition && hasTransition;
+        this.preventDefault = !this.eventPassthrough && this.preventDefault;
+        // If you want eventPassthrough I have to lock one of the axes
+        this.scrollX =
+            this.eventPassthrough === "horizontal" /* EventPassthrough.Horizontal */
+                ? false
+                : this.scrollX;
+        this.scrollY =
+            this.eventPassthrough === "vertical" /* EventPassthrough.Vertical */ ? false : this.scrollY;
+        // With eventPassthrough we also need lockDirection mechanism
+        this.freeScroll = this.freeScroll && !this.eventPassthrough;
+        // force true when freeScroll is true
+        this.scrollX = this.freeScroll ? true : this.scrollX;
+        this.scrollY = this.freeScroll ? true : this.scrollY;
+        this.directionLockThreshold = this.eventPassthrough
+            ? 0
+            : this.directionLockThreshold;
+        return this;
+    };
+    OptionsConstructor.prototype.resolveBounce = function (bounceOptions) {
+        var DEFAULT_BOUNCE = {
+            top: true,
+            right: true,
+            bottom: true,
+            left: true,
+        };
+        var NEGATED_BOUNCE = {
+            top: false,
+            right: false,
+            bottom: false,
+            left: false,
+        };
+        var ret;
+        if (typeof bounceOptions === 'object') {
+            ret = extend(DEFAULT_BOUNCE, bounceOptions);
+        }
+        else {
+            ret = bounceOptions ? DEFAULT_BOUNCE : NEGATED_BOUNCE;
+        }
+        return ret;
+    };
+    return OptionsConstructor;
+}(CustomOptions));
+export { OptionsConstructor };

package/better-scroll-dev/better-scroll-dev/dist/packages/core/src/animater/Animation.d.ts

@@ -0,0 +1,9 @@
+import Base from './Base';
+import { TranslaterPoint } from '../translater';
+import { EaseFn } from '@better-scroll/shared-utils';
+export default class Animation extends Base {
+    move(startPoint: TranslaterPoint, endPoint: TranslaterPoint, time: number, easingFn: EaseFn | string): void;
+    private animate;
+    doStop(): boolean;
+    stop(): void;
+}