cbvirtua 1.0.105 → 1.0.107

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

@@ -0,0 +1,195 @@
+import { ease, extend } from '@better-scroll/shared-utils';
+import propertiesConfig from './propertiesConfig';
+var PULLING_DOWN_EVENT = 'pullingDown';
+var ENTER_THRESHOLD_EVENT = 'enterThreshold';
+var LEAVE_THRESHOLD_EVENT = 'leaveThreshold';
+var PullDown = /** @class */ (function () {
+    function PullDown(scroll) {
+        this.scroll = scroll;
+        this.pulling = 0 /* PullDownPhase.DEFAULT */;
+        this.thresholdBoundary = 0 /* ThresholdBoundary.DEFAULT */;
+        this.init();
+    }
+    PullDown.prototype.setPulling = function (status) {
+        this.pulling = status;
+    };
+    PullDown.prototype.setThresholdBoundary = function (boundary) {
+        this.thresholdBoundary = boundary;
+    };
+    PullDown.prototype.init = function () {
+        this.handleBScroll();
+        this.handleOptions(this.scroll.options.pullDownRefresh);
+        this.handleHooks();
+        this.watch();
+    };
+    PullDown.prototype.handleBScroll = function () {
+        this.scroll.registerType([
+            PULLING_DOWN_EVENT,
+            ENTER_THRESHOLD_EVENT,
+            LEAVE_THRESHOLD_EVENT,
+        ]);
+        this.scroll.proxy(propertiesConfig);
+    };
+    PullDown.prototype.handleOptions = function (userOptions) {
+        if (userOptions === void 0) { userOptions = {}; }
+        userOptions = (userOptions === true ? {} : userOptions);
+        var defaultOptions = {
+            threshold: 90,
+            stop: 40,
+        };
+        this.options = extend(defaultOptions, userOptions);
+        this.scroll.options.probeType = 3 /* Probe.Realtime */;
+    };
+    PullDown.prototype.handleHooks = function () {
+        var _this = this;
+        this.hooksFn = [];
+        var scroller = this.scroll.scroller;
+        var scrollBehaviorY = scroller.scrollBehaviorY;
+        this.currentMinScrollY = this.cachedOriginanMinScrollY =
+            scrollBehaviorY.minScrollPos;
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
+            _this.finishPullDown();
+        });
+        this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
+            // content is smaller than wrapper
+            if (boundary.maxScrollPos > 0) {
+                // allow scrolling when content is not full of wrapper
+                boundary.maxScrollPos = -1;
+            }
+            boundary.minScrollPos = _this.currentMinScrollY;
+        });
+        // integrate with mousewheel
+        if (this.hasMouseWheelPlugin()) {
+            this.registerHooks(this.scroll, this.scroll.eventTypes.alterOptions, function (mouseWheelOptions) {
+                var SANE_DISCRETE_TIME = 300;
+                var SANE_EASE_TIME = 350;
+                mouseWheelOptions.discreteTime = SANE_DISCRETE_TIME;
+                // easeTime > discreteTime ensure goInto checkPullDown function
+                mouseWheelOptions.easeTime = SANE_EASE_TIME;
+            });
+            this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelEnd, function () {
+                // mouseWheel need trigger checkPullDown manually
+                scroller.hooks.trigger(scroller.hooks.eventTypes.end);
+            });
+        }
+    };
+    PullDown.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    PullDown.prototype.hasMouseWheelPlugin = function () {
+        return !!this.scroll.eventTypes.alterOptions;
+    };
+    PullDown.prototype.watch = function () {
+        var scroller = this.scroll.scroller;
+        this.watching = true;
+        this.registerHooks(scroller.hooks, scroller.hooks.eventTypes.end, this.checkPullDown);
+        this.registerHooks(this.scroll, this.scroll.eventTypes.scrollStart, this.resetStateBeforeScrollStart);
+        this.registerHooks(this.scroll, this.scroll.eventTypes.scroll, this.checkLocationOfThresholdBoundary);
+        if (this.hasMouseWheelPlugin()) {
+            this.registerHooks(this.scroll, this.scroll.eventTypes.mousewheelStart, this.resetStateBeforeScrollStart);
+        }
+    };
+    PullDown.prototype.resetStateBeforeScrollStart = function () {
+        // current fetching pulldownRefresh has ended
+        if (!this.isFetchingStatus()) {
+            this.setPulling(1 /* PullDownPhase.MOVING */);
+            this.setThresholdBoundary(0 /* ThresholdBoundary.DEFAULT */);
+        }
+    };
+    PullDown.prototype.checkLocationOfThresholdBoundary = function () {
+        // pulldownRefresh is in the phase of Moving
+        if (this.pulling === 1 /* PullDownPhase.MOVING */) {
+            var scroll_1 = this.scroll;
+            // enter threshold boundary
+            var enteredThresholdBoundary = this.thresholdBoundary !== 1 /* ThresholdBoundary.INSIDE */ &&
+                this.locateInsideThresholdBoundary();
+            // leave threshold boundary
+            var leftThresholdBoundary = this.thresholdBoundary !== 2 /* ThresholdBoundary.OUTSIDE */ &&
+                !this.locateInsideThresholdBoundary();
+            if (enteredThresholdBoundary) {
+                this.setThresholdBoundary(1 /* ThresholdBoundary.INSIDE */);
+                scroll_1.trigger(ENTER_THRESHOLD_EVENT);
+            }
+            if (leftThresholdBoundary) {
+                this.setThresholdBoundary(2 /* ThresholdBoundary.OUTSIDE */);
+                scroll_1.trigger(LEAVE_THRESHOLD_EVENT);
+            }
+        }
+    };
+    PullDown.prototype.locateInsideThresholdBoundary = function () {
+        return this.scroll.y <= this.options.threshold;
+    };
+    PullDown.prototype.unwatch = function () {
+        var scroll = this.scroll;
+        var scroller = scroll.scroller;
+        this.watching = false;
+        scroller.hooks.off(scroller.hooks.eventTypes.end, this.checkPullDown);
+        scroll.off(scroll.eventTypes.scrollStart, this.resetStateBeforeScrollStart);
+        scroll.off(scroll.eventTypes.scroll, this.checkLocationOfThresholdBoundary);
+        if (this.hasMouseWheelPlugin()) {
+            scroll.off(scroll.eventTypes.mousewheelStart, this.resetStateBeforeScrollStart);
+        }
+    };
+    PullDown.prototype.checkPullDown = function () {
+        var _a = this.options, threshold = _a.threshold, stop = _a.stop;
+        // check if a real pull down action
+        if (this.scroll.y < threshold) {
+            return false;
+        }
+        if (this.pulling === 1 /* PullDownPhase.MOVING */) {
+            this.modifyBehaviorYBoundary(stop);
+            this.setPulling(2 /* PullDownPhase.FETCHING */);
+            this.scroll.trigger(PULLING_DOWN_EVENT);
+        }
+        this.scroll.scrollTo(this.scroll.x, stop, this.scroll.options.bounceTime, ease.bounce);
+        return this.isFetchingStatus();
+    };
+    PullDown.prototype.isFetchingStatus = function () {
+        return this.pulling === 2 /* PullDownPhase.FETCHING */;
+    };
+    PullDown.prototype.modifyBehaviorYBoundary = function (stopDistance) {
+        var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
+        // manually modify minScrollPos for a hang animation
+        // to prevent from resetPosition
+        this.cachedOriginanMinScrollY = scrollBehaviorY.minScrollPos;
+        this.currentMinScrollY = stopDistance;
+        scrollBehaviorY.computeBoundary();
+    };
+    PullDown.prototype.finishPullDown = function () {
+        if (this.isFetchingStatus()) {
+            var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
+            // restore minScrollY since the hang animation has ended
+            this.currentMinScrollY = this.cachedOriginanMinScrollY;
+            scrollBehaviorY.computeBoundary();
+            this.setPulling(0 /* PullDownPhase.DEFAULT */);
+            this.scroll.resetPosition(this.scroll.options.bounceTime, ease.bounce);
+        }
+    };
+    // allow 'true' type is compat for beta version implements
+    PullDown.prototype.openPullDown = function (config) {
+        if (config === void 0) { config = {}; }
+        this.handleOptions(config);
+        if (!this.watching) {
+            this.watch();
+        }
+    };
+    PullDown.prototype.closePullDown = function () {
+        this.unwatch();
+    };
+    PullDown.prototype.autoPullDownRefresh = function () {
+        var _a = this.options, threshold = _a.threshold, stop = _a.stop;
+        if (this.isFetchingStatus() || !this.watching) {
+            return;
+        }
+        this.modifyBehaviorYBoundary(stop);
+        this.scroll.trigger(this.scroll.eventTypes.scrollStart);
+        this.scroll.scrollTo(this.scroll.x, threshold);
+        this.setPulling(2 /* PullDownPhase.FETCHING */);
+        this.scroll.trigger(PULLING_DOWN_EVENT);
+        this.scroll.scrollTo(this.scroll.x, stop, this.scroll.options.bounceTime, ease.bounce);
+    };
+    PullDown.pluginName = 'pullDownRefresh';
+    return PullDown;
+}());
+export default PullDown;

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

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

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

@@ -0,0 +1,25 @@
+var sourcePrefix = 'plugins.pullDownRefresh';
+var propertiesMap = [
+    {
+        key: 'finishPullDown',
+        name: 'finishPullDown'
+    },
+    {
+        key: 'openPullDown',
+        name: 'openPullDown'
+    },
+    {
+        key: 'closePullDown',
+        name: 'closePullDown'
+    },
+    {
+        key: 'autoPullDownRefresh',
+        name: 'autoPullDownRefresh'
+    }
+];
+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/pull-up/src/index.d.ts

@@ -0,0 +1,41 @@
+import BScroll from '@better-scroll/core';
+export type PullUpLoadOptions = Partial<PullUpLoadConfig> | true;
+export interface PullUpLoadConfig {
+    threshold: number;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        pullUpLoad?: PullUpLoadOptions;
+    }
+    interface CustomAPI {
+        pullUpLoad: PluginAPI;
+    }
+}
+interface PluginAPI {
+    finishPullUp(): void;
+    openPullUp(config?: PullUpLoadOptions): void;
+    closePullUp(): void;
+    autoPullUpLoad(): void;
+}
+export default class PullUp implements PluginAPI {
+    scroll: BScroll;
+    static pluginName: string;
+    private hooksFn;
+    pulling: boolean;
+    watching: boolean;
+    options: PullUpLoadConfig;
+    constructor(scroll: BScroll);
+    private init;
+    private handleBScroll;
+    private handleOptions;
+    private handleHooks;
+    private registerHooks;
+    private watch;
+    private unwatch;
+    private checkPullUp;
+    finishPullUp(): void;
+    openPullUp(config?: PullUpLoadOptions): void;
+    closePullUp(): void;
+    autoPullUpLoad(): void;
+}
+export {};

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

@@ -0,0 +1,111 @@
+import { extend, } from '@better-scroll/shared-utils';
+import propertiesConfig from './propertiesConfig';
+var PULL_UP_HOOKS_NAME = 'pullingUp';
+var PullUp = /** @class */ (function () {
+    function PullUp(scroll) {
+        this.scroll = scroll;
+        this.pulling = false;
+        this.watching = false;
+        this.init();
+    }
+    PullUp.prototype.init = function () {
+        this.handleBScroll();
+        this.handleOptions(this.scroll.options.pullUpLoad);
+        this.handleHooks();
+        this.watch();
+    };
+    PullUp.prototype.handleBScroll = function () {
+        this.scroll.registerType([PULL_UP_HOOKS_NAME]);
+        this.scroll.proxy(propertiesConfig);
+    };
+    PullUp.prototype.handleOptions = function (userOptions) {
+        if (userOptions === void 0) { userOptions = {}; }
+        userOptions = (userOptions === true ? {} : userOptions);
+        var defaultOptions = {
+            threshold: 0,
+        };
+        this.options = extend(defaultOptions, userOptions);
+        this.scroll.options.probeType = 3 /* Probe.Realtime */;
+    };
+    PullUp.prototype.handleHooks = function () {
+        var _this = this;
+        this.hooksFn = [];
+        var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
+        this.registerHooks(this.scroll.hooks, this.scroll.hooks.eventTypes.contentChanged, function () {
+            _this.finishPullUp();
+        });
+        this.registerHooks(scrollBehaviorY.hooks, scrollBehaviorY.hooks.eventTypes.computeBoundary, function (boundary) {
+            // content is smaller than wrapper
+            if (boundary.maxScrollPos > 0) {
+                // allow scrolling when content is not full of wrapper
+                boundary.maxScrollPos = -1;
+            }
+        });
+    };
+    PullUp.prototype.registerHooks = function (hooks, name, handler) {
+        hooks.on(name, handler, this);
+        this.hooksFn.push([hooks, name, handler]);
+    };
+    PullUp.prototype.watch = function () {
+        if (this.watching) {
+            return;
+        }
+        this.watching = true;
+        this.registerHooks(this.scroll, this.scroll.eventTypes.scroll, this.checkPullUp);
+    };
+    PullUp.prototype.unwatch = function () {
+        this.watching = false;
+        this.scroll.off(this.scroll.eventTypes.scroll, this.checkPullUp);
+    };
+    PullUp.prototype.checkPullUp = function (pos) {
+        var _this = this;
+        var threshold = this.options.threshold;
+        if (this.scroll.movingDirectionY === 1 /* Direction.Positive */ &&
+            pos.y <= this.scroll.maxScrollY + threshold) {
+            this.pulling = true;
+            // must reset pulling after scrollEnd
+            this.scroll.once(this.scroll.eventTypes.scrollEnd, function () {
+                _this.pulling = false;
+            });
+            this.unwatch();
+            this.scroll.trigger(PULL_UP_HOOKS_NAME);
+        }
+    };
+    PullUp.prototype.finishPullUp = function () {
+        var _this = this;
+        // reset Direction, fix #936
+        this.scroll.scroller.scrollBehaviorY.setMovingDirection(0 /* Direction.Default */);
+        if (this.pulling) {
+            this.scroll.once(this.scroll.eventTypes.scrollEnd, function () {
+                _this.watch();
+            });
+        }
+        else {
+            this.watch();
+        }
+    };
+    // allow 'true' type is compat for beta version implements
+    PullUp.prototype.openPullUp = function (config) {
+        if (config === void 0) { config = {}; }
+        this.handleOptions(config);
+        this.watch();
+    };
+    PullUp.prototype.closePullUp = function () {
+        this.unwatch();
+    };
+    PullUp.prototype.autoPullUpLoad = function () {
+        var threshold = this.options.threshold;
+        var scrollBehaviorY = this.scroll.scroller.scrollBehaviorY;
+        if (this.pulling || !this.watching) {
+            return;
+        }
+        // simulate a pullUp action
+        var NEGATIVE_VALUE = -1;
+        var outOfBoundaryPos = scrollBehaviorY.maxScrollPos + threshold + NEGATIVE_VALUE;
+        this.scroll.scroller.scrollBehaviorY.setMovingDirection(NEGATIVE_VALUE);
+        this.scroll.scrollTo(this.scroll.x, outOfBoundaryPos, this.scroll.options.bounceTime);
+    };
+    PullUp.pluginName = 'pullUpLoad';
+    return PullUp;
+}());
+export default PullUp;

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

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

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

@@ -0,0 +1,25 @@
+var sourcePrefix = 'plugins.pullUpLoad';
+var propertiesMap = [
+    {
+        key: 'finishPullUp',
+        name: 'finishPullUp'
+    },
+    {
+        key: 'openPullUp',
+        name: 'openPullUp'
+    },
+    {
+        key: 'closePullUp',
+        name: 'closePullUp'
+    },
+    {
+        key: 'autoPullUpLoad',
+        name: 'autoPullUpLoad'
+    }
+];
+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/scroll-bar/src/event-handler.d.ts

@@ -0,0 +1,26 @@
+import BScroll from '@better-scroll/core';
+import { EventRegister, EventEmitter } from '@better-scroll/shared-utils';
+import Indicator from './indicator';
+interface EventHandlerOptions {
+    disableMouse: boolean;
+    disableTouch: boolean;
+}
+export default class EventHandler {
+    indicator: Indicator;
+    options: EventHandlerOptions;
+    startEventRegister: EventRegister;
+    moveEventRegister: EventRegister;
+    endEventRegister: EventRegister;
+    initiated: boolean;
+    lastPoint: number;
+    scroll: BScroll;
+    hooks: EventEmitter;
+    constructor(indicator: Indicator, options: EventHandlerOptions);
+    private registerEvents;
+    private BScrollIsDisabled;
+    private start;
+    private move;
+    private end;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,91 @@
+import { EventRegister, EventEmitter, maybePrevent, } from '@better-scroll/shared-utils';
+var EventHandler = /** @class */ (function () {
+    function EventHandler(indicator, options) {
+        this.indicator = indicator;
+        this.options = options;
+        this.hooks = new EventEmitter(['touchStart', 'touchMove', 'touchEnd']);
+        this.registerEvents();
+    }
+    EventHandler.prototype.registerEvents = function () {
+        var _a = this.options, disableMouse = _a.disableMouse, disableTouch = _a.disableTouch;
+        var startEvents = [];
+        var moveEvents = [];
+        var endEvents = [];
+        if (!disableMouse) {
+            startEvents.push({
+                name: 'mousedown',
+                handler: this.start.bind(this),
+            });
+            moveEvents.push({
+                name: 'mousemove',
+                handler: this.move.bind(this),
+            });
+            endEvents.push({
+                name: 'mouseup',
+                handler: this.end.bind(this),
+            });
+        }
+        if (!disableTouch) {
+            startEvents.push({
+                name: 'touchstart',
+                handler: this.start.bind(this),
+            });
+            moveEvents.push({
+                name: 'touchmove',
+                handler: this.move.bind(this),
+            });
+            endEvents.push({
+                name: 'touchend',
+                handler: this.end.bind(this),
+            }, {
+                name: 'touchcancel',
+                handler: this.end.bind(this),
+            });
+        }
+        this.startEventRegister = new EventRegister(this.indicator.indicatorEl, startEvents);
+        this.moveEventRegister = new EventRegister(window, moveEvents);
+        this.endEventRegister = new EventRegister(window, endEvents);
+    };
+    EventHandler.prototype.BScrollIsDisabled = function () {
+        return !this.indicator.scroll.enabled;
+    };
+    EventHandler.prototype.start = function (e) {
+        if (this.BScrollIsDisabled()) {
+            return;
+        }
+        var point = (e.touches ? e.touches[0] : e);
+        maybePrevent(e);
+        e.stopPropagation();
+        this.initiated = true;
+        this.lastPoint = point[this.indicator.keysMap.point];
+        this.hooks.trigger(this.hooks.eventTypes.touchStart);
+    };
+    EventHandler.prototype.move = function (e) {
+        if (!this.initiated) {
+            return;
+        }
+        var point = (e.touches ? e.touches[0] : e);
+        var pointPos = point[this.indicator.keysMap.point];
+        maybePrevent(e);
+        e.stopPropagation();
+        var delta = pointPos - this.lastPoint;
+        this.lastPoint = pointPos;
+        this.hooks.trigger(this.hooks.eventTypes.touchMove, delta);
+    };
+    EventHandler.prototype.end = function (e) {
+        if (!this.initiated) {
+            return;
+        }
+        this.initiated = false;
+        maybePrevent(e);
+        e.stopPropagation();
+        this.hooks.trigger(this.hooks.eventTypes.touchEnd);
+    };
+    EventHandler.prototype.destroy = function () {
+        this.startEventRegister.destroy();
+        this.moveEventRegister.destroy();
+        this.endEventRegister.destroy();
+    };
+    return EventHandler;
+}());
+export default EventHandler;

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

@@ -0,0 +1,30 @@
+import BScroll from '@better-scroll/core';
+import Indicator, { OffsetType } from './indicator';
+export type ScrollbarOptions = Partial<ScrollbarConfig> | true;
+export interface ScrollbarConfig {
+    fade: boolean;
+    fadeInTime: number;
+    fadeOutTime: number;
+    interactive: boolean;
+    customElements: HTMLElement[];
+    minSize: number;
+    scrollbarTrackClickable: boolean;
+    scrollbarTrackOffsetType: OffsetType;
+    scrollbarTrackOffsetTime: number;
+}
+declare module '@better-scroll/core' {
+    interface CustomOptions {
+        scrollbar?: ScrollbarOptions;
+    }
+}
+export default class ScrollBar {
+    scroll: BScroll;
+    static pluginName: string;
+    options: ScrollbarConfig;
+    indicators: Indicator[];
+    constructor(scroll: BScroll);
+    private handleHooks;
+    private handleOptions;
+    private createIndicators;
+    private createScrollbarElement;
+}

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

@@ -0,0 +1,112 @@
+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 Indicator from './indicator';
+import { extend } from '@better-scroll/shared-utils';
+var ScrollBar = /** @class */ (function () {
+    function ScrollBar(scroll) {
+        this.scroll = scroll;
+        this.handleOptions();
+        this.createIndicators();
+        this.handleHooks();
+    }
+    ScrollBar.prototype.handleHooks = function () {
+        var _this = this;
+        var scroll = this.scroll;
+        scroll.hooks.on(scroll.hooks.eventTypes.destroy, function () {
+            for (var _i = 0, _a = _this.indicators; _i < _a.length; _i++) {
+                var indicator = _a[_i];
+                indicator.destroy();
+            }
+        });
+    };
+    ScrollBar.prototype.handleOptions = function () {
+        var userOptions = (this.scroll.options.scrollbar === true
+            ? {}
+            : this.scroll.options.scrollbar);
+        var defaultOptions = {
+            fade: true,
+            fadeInTime: 250,
+            fadeOutTime: 500,
+            interactive: false,
+            customElements: [],
+            minSize: 8,
+            scrollbarTrackClickable: false,
+            scrollbarTrackOffsetType: "step" /* OffsetType.Step */,
+            scrollbarTrackOffsetTime: 300,
+        };
+        this.options = extend(defaultOptions, userOptions);
+    };
+    ScrollBar.prototype.createIndicators = function () {
+        var indicatorOptions;
+        var scroll = this.scroll;
+        var indicators = [];
+        var scrollDirectionConfigKeys = ['scrollX', 'scrollY'];
+        var indicatorDirections = [
+            "horizontal" /* IndicatorDirection.Horizontal */,
+            "vertical" /* IndicatorDirection.Vertical */,
+        ];
+        var customScrollbarEls = this.options.customElements;
+        for (var i = 0; i < scrollDirectionConfigKeys.length; i++) {
+            var key = scrollDirectionConfigKeys[i];
+            // wanna scroll in specified direction
+            if (scroll.options[key]) {
+                var customElement = customScrollbarEls.shift();
+                var direction = indicatorDirections[i];
+                var isCustom = false;
+                var scrollbarWrapper = customElement
+                    ? customElement
+                    : this.createScrollbarElement(direction);
+                // internal scrollbar
+                if (scrollbarWrapper !== customElement) {
+                    scroll.wrapper.appendChild(scrollbarWrapper);
+                }
+                else {
+                    // custom scrollbar passed by users
+                    isCustom = true;
+                }
+                indicatorOptions = __assign(__assign({ wrapper: scrollbarWrapper, direction: direction }, this.options), { isCustom: isCustom });
+                indicators.push(new Indicator(scroll, indicatorOptions));
+            }
+        }
+        this.indicators = indicators;
+    };
+    ScrollBar.prototype.createScrollbarElement = function (direction, scrollbarTrackClickable) {
+        if (scrollbarTrackClickable === void 0) { scrollbarTrackClickable = this.options.scrollbarTrackClickable; }
+        var scrollbarWrapperEl = document.createElement('div');
+        var scrollbarIndicatorEl = document.createElement('div');
+        scrollbarWrapperEl.style.cssText =
+            'position:absolute;z-index:9999;overflow:hidden;';
+        scrollbarIndicatorEl.style.cssText =
+            'box-sizing:border-box;position:absolute;background:rgba(0,0,0,0.5);border:1px solid rgba(255,255,255,0.9);border-radius:3px;';
+        scrollbarIndicatorEl.className = 'bscroll-indicator';
+        if (direction === "horizontal" /* IndicatorDirection.Horizontal */) {
+            scrollbarWrapperEl.style.cssText +=
+                'height:7px;left:2px;right:2px;bottom:0;';
+            scrollbarIndicatorEl.style.height = '100%';
+            scrollbarWrapperEl.className = 'bscroll-horizontal-scrollbar';
+        }
+        else {
+            scrollbarWrapperEl.style.cssText +=
+                'width:7px;bottom:2px;top:2px;right:1px;';
+            scrollbarIndicatorEl.style.width = '100%';
+            scrollbarWrapperEl.className = 'bscroll-vertical-scrollbar';
+        }
+        if (!scrollbarTrackClickable) {
+            scrollbarWrapperEl.style.cssText += 'pointer-events:none;';
+        }
+        scrollbarWrapperEl.appendChild(scrollbarIndicatorEl);
+        return scrollbarWrapperEl;
+    };
+    ScrollBar.pluginName = 'scrollbar';
+    return ScrollBar;
+}());
+export default ScrollBar;