cbvirtua 1.0.106 → 1.0.107

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

@@ -0,0 +1,263 @@
+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 { inBrowser, isWeChatDevTools, supportsPassive } from './env';
+import { extend } from './lang';
+var elementStyle = (inBrowser &&
+    document.createElement('div').style);
+var vendor = (function () {
+    /* istanbul ignore if  */
+    if (!inBrowser) {
+        return false;
+    }
+    var transformNames = [
+        {
+            key: 'standard',
+            value: 'transform',
+        },
+        {
+            key: 'webkit',
+            value: 'webkitTransform',
+        },
+        {
+            key: 'Moz',
+            value: 'MozTransform',
+        },
+        {
+            key: 'O',
+            value: 'OTransform',
+        },
+        {
+            key: 'ms',
+            value: 'msTransform',
+        },
+    ];
+    for (var _i = 0, transformNames_1 = transformNames; _i < transformNames_1.length; _i++) {
+        var obj = transformNames_1[_i];
+        if (elementStyle[obj.value] !== undefined) {
+            return obj.key;
+        }
+    }
+    /* istanbul ignore next  */
+    return false;
+})();
+/* istanbul ignore next  */
+function prefixStyle(style) {
+    if (vendor === false) {
+        return style;
+    }
+    if (vendor === 'standard') {
+        if (style === 'transitionEnd') {
+            return 'transitionend';
+        }
+        return style;
+    }
+    return vendor + style.charAt(0).toUpperCase() + style.substr(1);
+}
+export function getElement(el) {
+    return (typeof el === 'string' ? document.querySelector(el) : el);
+}
+export function addEvent(el, type, fn, capture) {
+    var useCapture = supportsPassive
+        ? {
+            passive: false,
+            capture: !!capture,
+        }
+        : !!capture;
+    el.addEventListener(type, fn, useCapture);
+}
+export function removeEvent(el, type, fn, capture) {
+    el.removeEventListener(type, fn, {
+        capture: !!capture,
+    });
+}
+export function maybePrevent(e) {
+    if (e.cancelable) {
+        e.preventDefault();
+    }
+}
+export function offset(el) {
+    var left = 0;
+    var top = 0;
+    while (el) {
+        left -= el.offsetLeft;
+        top -= el.offsetTop;
+        el = el.offsetParent;
+    }
+    return {
+        left: left,
+        top: top,
+    };
+}
+export function offsetToBody(el) {
+    var rect = el.getBoundingClientRect();
+    return {
+        left: -(rect.left + window.pageXOffset),
+        top: -(rect.top + window.pageYOffset),
+    };
+}
+export var cssVendor = vendor && vendor !== 'standard' ? '-' + vendor.toLowerCase() + '-' : '';
+var transform = prefixStyle('transform');
+var transition = prefixStyle('transition');
+export var hasPerspective = inBrowser && prefixStyle('perspective') in elementStyle;
+// fix issue #361
+export var hasTouch = inBrowser && ('ontouchstart' in window || isWeChatDevTools);
+export var hasTransition = inBrowser && transition in elementStyle;
+export var style = {
+    transform: transform,
+    transition: transition,
+    transitionTimingFunction: prefixStyle('transitionTimingFunction'),
+    transitionDuration: prefixStyle('transitionDuration'),
+    transitionDelay: prefixStyle('transitionDelay'),
+    transformOrigin: prefixStyle('transformOrigin'),
+    transitionEnd: prefixStyle('transitionEnd'),
+    transitionProperty: prefixStyle('transitionProperty'),
+};
+export var eventTypeMap = {
+    touchstart: 1,
+    touchmove: 1,
+    touchend: 1,
+    touchcancel: 1,
+    mousedown: 2,
+    mousemove: 2,
+    mouseup: 2,
+};
+export function getRect(el) {
+    /* istanbul ignore if  */
+    if (el instanceof window.SVGElement) {
+        var rect = el.getBoundingClientRect();
+        return {
+            top: rect.top,
+            left: rect.left,
+            width: rect.width,
+            height: rect.height,
+        };
+    }
+    else {
+        return {
+            top: el.offsetTop,
+            left: el.offsetLeft,
+            width: el.offsetWidth,
+            height: el.offsetHeight,
+        };
+    }
+}
+export function preventDefaultExceptionFn(el, exceptions) {
+    for (var i in exceptions) {
+        if (exceptions[i].test(el[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+export var tagExceptionFn = preventDefaultExceptionFn;
+export function tap(e, eventName) {
+    var ev = document.createEvent('Event');
+    ev.initEvent(eventName, true, true);
+    ev.pageX = e.pageX;
+    ev.pageY = e.pageY;
+    e.target.dispatchEvent(ev);
+}
+export function click(e, event) {
+    if (event === void 0) { event = 'click'; }
+    var eventSource;
+    if (e.type === 'mouseup') {
+        eventSource = e;
+    }
+    else if (e.type === 'touchend' || e.type === 'touchcancel') {
+        eventSource = e.changedTouches[0];
+    }
+    var posSrc = {};
+    if (eventSource) {
+        posSrc.screenX = eventSource.screenX || 0;
+        posSrc.screenY = eventSource.screenY || 0;
+        posSrc.clientX = eventSource.clientX || 0;
+        posSrc.clientY = eventSource.clientY || 0;
+    }
+    var ev;
+    var bubbles = true;
+    var cancelable = true;
+    var ctrlKey = e.ctrlKey, shiftKey = e.shiftKey, altKey = e.altKey, metaKey = e.metaKey;
+    var pressedKeysMap = {
+        ctrlKey: ctrlKey,
+        shiftKey: shiftKey,
+        altKey: altKey,
+        metaKey: metaKey,
+    };
+    if (typeof MouseEvent !== 'undefined') {
+        try {
+            ev = new MouseEvent(event, extend(__assign({ bubbles: bubbles, cancelable: cancelable }, pressedKeysMap), posSrc));
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            createEvent();
+        }
+    }
+    else {
+        createEvent();
+    }
+    function createEvent() {
+        ev = document.createEvent('Event');
+        ev.initEvent(event, bubbles, cancelable);
+        extend(ev, posSrc);
+    }
+    // forwardedTouchEvent set to true in case of the conflict with fastclick
+    ev.forwardedTouchEvent = true;
+    ev._constructed = true;
+    e.target.dispatchEvent(ev);
+}
+export function dblclick(e) {
+    click(e, 'dblclick');
+}
+export function prepend(el, target) {
+    var firstChild = target.firstChild;
+    if (firstChild) {
+        before(el, firstChild);
+    }
+    else {
+        target.appendChild(el);
+    }
+}
+export function before(el, target) {
+    var parentNode = target.parentNode;
+    parentNode.insertBefore(el, target);
+}
+export function removeChild(el, child) {
+    el.removeChild(child);
+}
+export function hasClass(el, className) {
+    var reg = new RegExp('(^|\\s)' + className + '(\\s|$)');
+    return reg.test(el.className);
+}
+export function addClass(el, className) {
+    if (hasClass(el, className)) {
+        return;
+    }
+    var newClass = el.className.split(' ');
+    newClass.push(className);
+    el.className = newClass.join(' ');
+}
+export function removeClass(el, className) {
+    if (!hasClass(el, className)) {
+        return;
+    }
+    var reg = new RegExp('(^|\\s)' + className + '(\\s|$)', 'g');
+    el.className = el.className.replace(reg, ' ');
+}
+export function HTMLCollectionToArray(el) {
+    return Array.prototype.slice.call(el, 0);
+}
+export function getClientSize(el) {
+    return {
+        width: el.clientWidth,
+        height: el.clientHeight,
+    };
+}

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

@@ -0,0 +1,12 @@
+export interface EaseItem {
+    style: string;
+    fn: EaseFn;
+}
+interface EaseMap {
+    [key: string]: EaseItem;
+}
+export interface EaseFn {
+    (t: number): number;
+}
+export declare const ease: EaseMap;
+export {};

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

@@ -0,0 +1,23 @@
+export var ease = {
+    // easeOutQuint
+    swipe: {
+        style: 'cubic-bezier(0.23, 1, 0.32, 1)',
+        fn: function (t) {
+            return 1 + --t * t * t * t * t;
+        }
+    },
+    // easeOutQuard
+    swipeBounce: {
+        style: 'cubic-bezier(0.25, 0.46, 0.45, 0.94)',
+        fn: function (t) {
+            return t * (2 - t);
+        }
+    },
+    // easeOutQuart
+    bounce: {
+        style: 'cubic-bezier(0.165, 0.84, 0.44, 1)',
+        fn: function (t) {
+            return 1 - --t * t * t * t;
+        }
+    }
+};

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

@@ -0,0 +1,41 @@
+export declare const enum DirectionLock {
+    Default = "",
+    Horizontal = "horizontal",
+    Vertical = "vertical",
+    None = "none"
+}
+export declare const enum Direction {
+    Positive = 1,
+    Negative = -1,
+    Default = 0
+}
+export declare const enum ApplyOrder {
+    Pre = "pre",
+    Post = "post"
+}
+export declare const enum EventPassthrough {
+    None = "",
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}
+export declare const enum EventType {
+    Touch = 1,
+    Mouse = 2
+}
+export declare const enum MouseButton {
+    Left = 0,
+    Middle = 1,
+    Right = 2
+}
+export declare const enum Probe {
+    Default = 0,
+    Throttle = 1,
+    Normal = 2,
+    Realtime = 3
+}
+export declare const enum Quadrant {
+    First = 1,
+    Second = 2,
+    Third = 3,
+    Forth = 4
+}

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

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

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

@@ -0,0 +1,6 @@
+export declare const inBrowser: boolean;
+export declare const ua: string | false;
+export declare const isWeChatDevTools: boolean;
+export declare const isAndroid: boolean | "";
+export declare const isIOSBadVersion: boolean;
+export declare let supportsPassive: boolean;

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

@@ -0,0 +1,36 @@
+// ssr support
+export var inBrowser = typeof window !== 'undefined';
+export var ua = inBrowser && navigator.userAgent.toLowerCase();
+export var isWeChatDevTools = !!(ua && /wechatdevtools/.test(ua));
+export var isAndroid = ua && ua.indexOf('android') > 0;
+/* istanbul ignore next */
+export var isIOSBadVersion = (function () {
+    if (typeof ua === 'string') {
+        var regex = /os (\d\d?_\d(_\d)?)/;
+        var matches = regex.exec(ua);
+        if (!matches)
+            return false;
+        var parts = matches[1].split('_').map(function (item) {
+            return parseInt(item, 10);
+        });
+        // ios version >= 13.4 issue 982
+        return !!(parts[0] === 13 && parts[1] >= 4);
+    }
+    return false;
+})();
+/* istanbul ignore next */
+export var supportsPassive = false;
+/* istanbul ignore next */
+if (inBrowser) {
+    var EventName = 'test-passive';
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function () {
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener(EventName, function () { }, opts);
+    }
+    catch (e) { }
+}

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

@@ -0,0 +1,37 @@
+interface Events {
+    [name: string]: [WithFnFunction, Object][];
+}
+interface EventTypes {
+    [type: string]: string;
+}
+interface WithFnFunction extends Function {
+    fn?: Function;
+}
+export declare class EventEmitter {
+    events: Events;
+    eventTypes: EventTypes;
+    constructor(names: string[]);
+    on(type: string, fn: Function, context?: Object): this;
+    once(type: string, fn: Function, context?: Object): this;
+    off(type?: string, fn?: Function): this | undefined;
+    trigger(type: string, ...args: any[]): any;
+    registerType(names: string[]): void;
+    destroy(): void;
+    private hasType;
+}
+interface EventData {
+    name: string;
+    handler(e: UIEvent): void;
+    capture?: boolean;
+}
+export declare class EventRegister {
+    wrapper: HTMLElement | Window;
+    events: EventData[];
+    constructor(wrapper: HTMLElement | Window, events: EventData[]);
+    destroy(): void;
+    private addDOMEvents;
+    private removeDOMEvents;
+    private handleDOMEvents;
+    private handleEvent;
+}
+export {};

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

@@ -0,0 +1,152 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { warn } from './debug';
+import { addEvent, removeEvent } from './dom';
+var EventEmitter = /** @class */ (function () {
+    function EventEmitter(names) {
+        this.events = {};
+        this.eventTypes = {};
+        this.registerType(names);
+    }
+    EventEmitter.prototype.on = function (type, fn, context) {
+        if (context === void 0) { context = this; }
+        this.hasType(type);
+        if (!this.events[type]) {
+            this.events[type] = [];
+        }
+        this.events[type].push([fn, context]);
+        return this;
+    };
+    EventEmitter.prototype.once = function (type, fn, context) {
+        var _this = this;
+        if (context === void 0) { context = this; }
+        this.hasType(type);
+        var magic = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            _this.off(type, magic);
+            var ret = fn.apply(context, args);
+            if (ret === true) {
+                return ret;
+            }
+        };
+        magic.fn = fn;
+        this.on(type, magic);
+        return this;
+    };
+    EventEmitter.prototype.off = function (type, fn) {
+        if (!type && !fn) {
+            this.events = {};
+            return this;
+        }
+        if (type) {
+            this.hasType(type);
+            if (!fn) {
+                this.events[type] = [];
+                return this;
+            }
+            var events = this.events[type];
+            if (!events) {
+                return this;
+            }
+            var count = events.length;
+            while (count--) {
+                if (events[count][0] === fn ||
+                    (events[count][0] && events[count][0].fn === fn)) {
+                    events.splice(count, 1);
+                }
+            }
+            return this;
+        }
+    };
+    EventEmitter.prototype.trigger = function (type) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        this.hasType(type);
+        var events = this.events[type];
+        if (!events) {
+            return;
+        }
+        var len = events.length;
+        var eventsCopy = __spreadArray([], events, true);
+        var ret;
+        for (var i = 0; i < len; i++) {
+            var event_1 = eventsCopy[i];
+            var fn = event_1[0], context = event_1[1];
+            if (fn) {
+                ret = fn.apply(context, args);
+                if (ret === true) {
+                    return ret;
+                }
+            }
+        }
+    };
+    EventEmitter.prototype.registerType = function (names) {
+        var _this = this;
+        names.forEach(function (type) {
+            _this.eventTypes[type] = type;
+        });
+    };
+    EventEmitter.prototype.destroy = function () {
+        this.events = {};
+        this.eventTypes = {};
+    };
+    EventEmitter.prototype.hasType = function (type) {
+        var types = this.eventTypes;
+        var isType = types[type] === type;
+        if (!isType) {
+            warn("EventEmitter has used unknown event type: \"".concat(type, "\", should be oneof [") +
+                "".concat(Object.keys(types).map(function (_) { return JSON.stringify(_); })) +
+                "]");
+        }
+    };
+    return EventEmitter;
+}());
+export { EventEmitter };
+var EventRegister = /** @class */ (function () {
+    function EventRegister(wrapper, events) {
+        this.wrapper = wrapper;
+        this.events = events;
+        this.addDOMEvents();
+    }
+    EventRegister.prototype.destroy = function () {
+        this.removeDOMEvents();
+        this.events = [];
+    };
+    EventRegister.prototype.addDOMEvents = function () {
+        this.handleDOMEvents(addEvent);
+    };
+    EventRegister.prototype.removeDOMEvents = function () {
+        this.handleDOMEvents(removeEvent);
+    };
+    EventRegister.prototype.handleDOMEvents = function (eventOperation) {
+        var _this = this;
+        var wrapper = this.wrapper;
+        this.events.forEach(function (event) {
+            eventOperation(wrapper, event.name, _this, !!event.capture);
+        });
+    };
+    EventRegister.prototype.handleEvent = function (e) {
+        var eventType = e.type;
+        this.events.some(function (event) {
+            if (event.name === eventType) {
+                event.handler(e);
+                return true;
+            }
+            return false;
+        });
+    };
+    return EventRegister;
+}());
+export { EventRegister };

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

@@ -0,0 +1,11 @@
+export * from './debug';
+export * from './dom';
+export * from './ease';
+export * from './env';
+export * from './lang';
+export * from './raf';
+export * from './Touch';
+export * from './propertiesProxy';
+export * from './enums';
+export * from './events';
+export * from './types';

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

@@ -0,0 +1,11 @@
+export * from './debug';
+export * from './dom';
+export * from './ease';
+export * from './env';
+export * from './lang';
+export * from './raf';
+export * from './Touch';
+export * from './propertiesProxy';
+export * from './enums';
+export * from './events';
+export * from './types';

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

@@ -0,0 +1,6 @@
+export declare function getNow(): number;
+export declare const extend: <T extends object, U extends object>(target: T, source: U) => T & U;
+export declare function isUndef(v: any): boolean;
+export declare function getDistance(x: number, y: number): number;
+export declare function between(x: number, min: number, max: number): number;
+export declare function findIndex<T>(ary: T[], fn: (value: T, index: number, arr?: T[]) => boolean): number;

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

@@ -0,0 +1,43 @@
+export function getNow() {
+    return window.performance &&
+        window.performance.now &&
+        window.performance.timing
+        ? window.performance.now() + window.performance.timing.navigationStart
+        : +new Date();
+}
+export var extend = function (target, source) {
+    for (var key in source) {
+        ;
+        target[key] = source[key];
+    }
+    return target;
+};
+export function isUndef(v) {
+    return v === undefined || v === null;
+}
+export function getDistance(x, y) {
+    return Math.sqrt(x * x + y * y);
+}
+export function between(x, min, max) {
+    if (x < min) {
+        return min;
+    }
+    if (x > max) {
+        return max;
+    }
+    return x;
+}
+export function findIndex(ary, fn) {
+    if (ary.findIndex) {
+        return ary.findIndex(fn);
+    }
+    var index = -1;
+    ary.some(function (item, i, ary) {
+        var ret = fn(item, i, ary);
+        if (ret) {
+            index = i;
+            return ret;
+        }
+    });
+    return index;
+}

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

@@ -0,0 +1 @@
+export declare function propertiesProxy(target: Object, sourceKey: string, key: string): void;