cbvirtua 1.0.109 → 1.0.115

package/better-scroll-dev/better-scroll-dev/packages/mouse-wheel/src/index.ts

@@ -1,327 +0,0 @@
-import BScroll from '@better-scroll/core'
-import {
-  warn,
-  preventDefaultExceptionFn,
-  EventRegister,
-  EventEmitter,
-  Direction,
-  ApplyOrder,
-  extend,
-  maybePrevent,
-} from '@better-scroll/shared-utils'
-
-export type MouseWheelOptions = Partial<MouseWheelConfig> | true
-
-export interface MouseWheelConfig {
-  speed: number
-  invert: boolean
-  easeTime: number
-  discreteTime: number
-  throttleTime: number
-  dampingFactor: number
-}
-
-declare module '@better-scroll/core' {
-  interface CustomOptions {
-    mouseWheel?: MouseWheelOptions
-  }
-}
-
-interface CompatibleWheelEvent extends WheelEvent {
-  pageX: number
-  pageY: number
-  readonly wheelDeltaX: number
-  readonly wheelDeltaY: number
-  readonly wheelDelta: number
-}
-
-interface WheelDelta {
-  x: number
-  y: number
-  directionX: Direction
-  directionY: Direction
-}
-
-export default class MouseWheel {
-  static pluginName = 'mouseWheel'
-  static applyOrder = ApplyOrder.Pre
-  mouseWheelOpt: MouseWheelConfig
-  private eventRegister: EventRegister
-  private wheelEndTimer: number = 0
-  private wheelMoveTimer: number = 0
-  private wheelStart = false
-  private deltaCache: { x: number; y: number }[]
-  private hooksFn: Array<[EventEmitter, string, Function]>
-  constructor(public scroll: BScroll) {
-    this.init()
-  }
-
-  private init() {
-    this.handleBScroll()
-    this.handleOptions()
-    this.handleHooks()
-
-    this.registerEvent()
-  }
-
-  private handleBScroll() {
-    this.scroll.registerType([
-      'alterOptions',
-      'mousewheelStart',
-      'mousewheelMove',
-      'mousewheelEnd',
-    ])
-  }
-
-  private handleOptions() {
-    const userOptions = (
-      this.scroll.options.mouseWheel === true
-        ? {}
-        : this.scroll.options.mouseWheel
-    ) as Partial<MouseWheelConfig>
-    const defaultOptions: MouseWheelConfig = {
-      speed: 20,
-      invert: false,
-      easeTime: 300,
-      discreteTime: 400,
-      throttleTime: 0,
-      dampingFactor: 0.1,
-    }
-    this.mouseWheelOpt = extend(defaultOptions, userOptions)
-  }
-
-  private handleHooks() {
-    this.hooksFn = []
-    this.registerHooks(this.scroll.hooks, 'destroy', this.destroy)
-  }
-
-  private registerEvent() {
-    this.eventRegister = new EventRegister(this.scroll.scroller.wrapper, [
-      {
-        name: 'wheel',
-        handler: this.wheelHandler.bind(this),
-      },
-      {
-        name: 'mousewheel',
-        handler: this.wheelHandler.bind(this),
-      },
-      {
-        name: 'DOMMouseScroll', // FireFox
-        handler: this.wheelHandler.bind(this),
-      },
-    ])
-  }
-
-  private registerHooks(hooks: EventEmitter, name: string, handler: Function) {
-    hooks.on(name, handler, this)
-    this.hooksFn.push([hooks, name, handler])
-  }
-
-  private wheelHandler(e: CompatibleWheelEvent) {
-    if (!this.scroll.enabled) {
-      return
-    }
-    this.beforeHandler(e)
-
-    // start
-    if (!this.wheelStart) {
-      this.wheelStartHandler(e)
-      this.wheelStart = true
-    }
-
-    // move
-    const delta = this.getWheelDelta(e)
-    this.wheelMoveHandler(delta)
-
-    // end
-    this.wheelEndDetector(delta)
-  }
-
-  private wheelStartHandler(e: CompatibleWheelEvent) {
-    this.cleanCache()
-    const { scrollBehaviorX, scrollBehaviorY } = this.scroll.scroller
-
-    scrollBehaviorX.setMovingDirection(Direction.Default)
-    scrollBehaviorY.setMovingDirection(Direction.Default)
-    scrollBehaviorX.setDirection(Direction.Default)
-    scrollBehaviorY.setDirection(Direction.Default)
-
-    this.scroll.trigger(this.scroll.eventTypes.alterOptions, this.mouseWheelOpt)
-    this.scroll.trigger(this.scroll.eventTypes.mousewheelStart)
-  }
-
-  private cleanCache() {
-    this.deltaCache = []
-  }
-
-  private wheelMoveHandler(delta: {
-    x: number
-    y: number
-    directionX: number
-    directionY: number
-  }) {
-    const { throttleTime, dampingFactor } = this.mouseWheelOpt
-    if (throttleTime && this.wheelMoveTimer) {
-      this.deltaCache.push(delta)
-    } else {
-      const cachedDelta = this.deltaCache.reduce(
-        (prev, current) => {
-          return {
-            x: prev.x + current.x,
-            y: prev.y + current.y,
-          }
-        },
-        { x: 0, y: 0 }
-      )
-
-      this.cleanCache()
-
-      const { scrollBehaviorX, scrollBehaviorY } = this.scroll.scroller
-
-      scrollBehaviorX.setMovingDirection(-delta.directionX)
-      scrollBehaviorY.setMovingDirection(-delta.directionY)
-      scrollBehaviorX.setDirection(delta.x)
-      scrollBehaviorY.setDirection(delta.y)
-
-      // when out of boundary, perform a damping scroll
-      const newX = scrollBehaviorX.performDampingAlgorithm(
-        Math.round(delta.x) + cachedDelta.x,
-        dampingFactor
-      )
-      const newY = scrollBehaviorY.performDampingAlgorithm(
-        Math.round(delta.y) + cachedDelta.x,
-        dampingFactor
-      )
-
-      if (
-        !this.scroll.trigger(this.scroll.eventTypes.mousewheelMove, {
-          x: newX,
-          y: newY,
-        })
-      ) {
-        const easeTime = this.getEaseTime()
-        if (newX !== this.scroll.x || newY !== this.scroll.y) {
-          this.scroll.scrollTo(newX, newY, easeTime)
-        }
-      }
-      if (throttleTime) {
-        this.wheelMoveTimer = window.setTimeout(() => {
-          this.wheelMoveTimer = 0
-        }, throttleTime)
-      }
-    }
-  }
-
-  private wheelEndDetector(delta: WheelDelta) {
-    window.clearTimeout(this.wheelEndTimer)
-    this.wheelEndTimer = window.setTimeout(() => {
-      this.wheelStart = false
-      window.clearTimeout(this.wheelMoveTimer)
-      this.wheelMoveTimer = 0
-
-      this.scroll.trigger(this.scroll.eventTypes.mousewheelEnd, delta)
-    }, this.mouseWheelOpt.discreteTime)
-  }
-
-  private getWheelDelta(e: CompatibleWheelEvent): WheelDelta {
-    const { speed, invert } = this.mouseWheelOpt
-    let wheelDeltaX = 0
-    let wheelDeltaY = 0
-    let direction = invert ? Direction.Negative : Direction.Positive
-    switch (true) {
-      case 'deltaX' in e:
-        if (e.deltaMode === 1) {
-          wheelDeltaX = -e.deltaX * speed
-          wheelDeltaY = -e.deltaY * speed
-        } else {
-          wheelDeltaX = -e.deltaX
-          wheelDeltaY = -e.deltaY
-        }
-        break
-      case 'wheelDeltaX' in e:
-        wheelDeltaX = (e.wheelDeltaX / 120) * speed
-        wheelDeltaY = (e.wheelDeltaY / 120) * speed
-        break
-      case 'wheelDelta' in e:
-        wheelDeltaX = wheelDeltaY = (e.wheelDelta / 120) * speed
-        break
-      case 'detail' in e:
-        wheelDeltaX = wheelDeltaY = (-e.detail / 3) * speed
-        break
-    }
-    wheelDeltaX *= direction
-    wheelDeltaY *= direction
-
-    if (!this.scroll.hasVerticalScroll) {
-      if (Math.abs(wheelDeltaY) > Math.abs(wheelDeltaX)) {
-        wheelDeltaX = wheelDeltaY
-      }
-      wheelDeltaY = 0
-    }
-    if (!this.scroll.hasHorizontalScroll) {
-      wheelDeltaX = 0
-    }
-
-    const directionX =
-      wheelDeltaX > 0
-        ? Direction.Negative
-        : wheelDeltaX < 0
-        ? Direction.Positive
-        : Direction.Default
-    const directionY =
-      wheelDeltaY > 0
-        ? Direction.Negative
-        : wheelDeltaY < 0
-        ? Direction.Positive
-        : Direction.Default
-    return {
-      x: wheelDeltaX,
-      y: wheelDeltaY,
-      directionX,
-      directionY,
-    }
-  }
-
-  private beforeHandler(e: CompatibleWheelEvent) {
-    const { preventDefault, stopPropagation, preventDefaultException } =
-      this.scroll.options
-    if (
-      preventDefault &&
-      !preventDefaultExceptionFn(e.target, preventDefaultException)
-    ) {
-      maybePrevent(e)
-    }
-    if (stopPropagation) {
-      e.stopPropagation()
-    }
-  }
-
-  private getEaseTime() {
-    const SAFE_EASETIME = 100
-    const easeTime = this.mouseWheelOpt.easeTime
-    // scrollEnd event will be triggered in every calling of scrollTo when easeTime is too small
-    // easeTime needs to be greater than 100
-    if (easeTime < SAFE_EASETIME) {
-      warn(
-        `easeTime should be greater than 100.` +
-          `If mouseWheel easeTime is too small,` +
-          `scrollEnd will be triggered many times.`
-      )
-    }
-    return Math.max(easeTime, SAFE_EASETIME)
-  }
-
-  destroy() {
-    this.eventRegister.destroy()
-
-    window.clearTimeout(this.wheelEndTimer)
-    window.clearTimeout(this.wheelMoveTimer)
-
-    this.hooksFn.forEach((item) => {
-      const hooks = item[0]
-      const hooksName = item[1]
-      const handlerFn = item[2]
-      hooks.off(hooksName, handlerFn)
-    })
-  }
-}

package/better-scroll-dev/better-scroll-dev/packages/movable/README.md

@@ -1,18 +0,0 @@
-# @better-scroll/movable
-
-[中文文档](https://github.com/ustbhuangyi/better-scroll/blob/master/packages/movable/README.md)
-
-Movable area plugin.
-
-## Usage
-
-```js
-import BScroll from '@better-scroll/core'
-import Movable from '@better-scroll/movable'
-
-BScroll.use(Movable)
-
-const bs = new BScroll('.wrapper', {
-  movable: true
-})
-```

package/better-scroll-dev/better-scroll-dev/packages/movable/README_zh-CN.md

@@ -1,18 +0,0 @@
-# @better-scroll/movable
-
-[中文文档](https://github.com/ustbhuangyi/better-scroll/blob/master/packages/movable/README_zh-CN.md)
-
-Movable 可移动区域插件。
-
-## 使用
-
-```js
-import BScroll from '@better-scroll/core'
-import Movable from '@better-scroll/movable'
-
-BScroll.use(Movable)
-
-const bs = new BScroll('.wrapper', {
-  movable: true
-})
-```

package/better-scroll-dev/better-scroll-dev/packages/movable/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "@better-scroll/movable",
-  "version": "2.5.1",
-  "description": "Movable plugin for BetterScroll",
-  "author": {
-    "name": "jizhi",
-    "email": "theniceangel@163.com"
-  },
-  "main": "dist/movable.min.js",
-  "module": "dist/movable.esm.js",
-  "typings": "dist/types/index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bugs": {
-    "url": "https://github.com/ustbhuangyi/better-scroll/issues"
-  },
-  "homepage": "https://github.com/ustbhuangyi/better-scroll",
-  "keywords": [
-    "scroll",
-    "iscroll",
-    "javascript",
-    "typescript",
-    "ios"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/ustbhuangyi/better-scroll.git",
-    "directory": "packages/observe-dom"
-  },
-  "dependencies": {
-    "@better-scroll/core": "^2.5.1"
-  }
-}

package/better-scroll-dev/better-scroll-dev/packages/movable/src/__tests__/index.spec.ts

@@ -1,118 +0,0 @@
-import BScroll, { Boundary } from '@better-scroll/core'
-jest.mock('@better-scroll/core')
-import { createDiv } from '@better-scroll/core/src/__tests__/__utils__/layout'
-import Movable from '../index'
-
-const createMovableEls = () => {
-  const wrapper = createDiv(100, 100, 0, 0)
-  const content = createDiv(100, 100, 0, 0)
-  wrapper.appendChild(content)
-
-  return {
-    wrapper,
-    content,
-  }
-}
-describe('movable plugin', () => {
-  let scroll: BScroll
-  let movable: Movable
-
-  beforeEach(() => {
-    // create DOM
-    const { wrapper } = createMovableEls()
-    scroll = new BScroll(wrapper)
-    movable = new Movable(scroll)
-  })
-
-  afterEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should proxy properties to BScroll instance', () => {
-    expect(scroll.proxy).toBeCalled()
-    expect(scroll.proxy).toHaveBeenLastCalledWith([
-      {
-        key: 'putAt',
-        sourceKey: 'plugins.movable.putAt',
-      },
-    ])
-  })
-
-  it('should modify boundary', () => {
-    const { scrollBehaviorX, scrollBehaviorY } = scroll.scroller
-    scrollBehaviorX.options.scrollable = true
-    scrollBehaviorY.options.scrollable = true
-
-    scrollBehaviorX.wrapperSize = 200
-    scrollBehaviorX.contentSize = 100
-    scrollBehaviorY.wrapperSize = 400
-    scrollBehaviorY.contentSize = 200
-
-    let boundaryX: Boundary = { minScrollPos: 0, maxScrollPos: 1 }
-    let boundaryY: Boundary = { minScrollPos: 0, maxScrollPos: 1 }
-
-    scrollBehaviorX.hooks.trigger(
-      scrollBehaviorX.hooks.eventTypes.computeBoundary,
-      boundaryX
-    )
-    scrollBehaviorY.hooks.trigger(
-      scrollBehaviorY.hooks.eventTypes.computeBoundary,
-      boundaryY
-    )
-
-    expect(boundaryX).toMatchObject({
-      minScrollPos: 100,
-      maxScrollPos: 0,
-    })
-
-    expect(boundaryY).toMatchObject({
-      minScrollPos: 200,
-      maxScrollPos: 0,
-    })
-  })
-
-  it('should register ignoreHasScroll hook', () => {
-    const { scrollBehaviorX, scrollBehaviorY } = scroll.scroller
-    const retX = scrollBehaviorX.hooks.trigger(
-      scrollBehaviorX.hooks.eventTypes.ignoreHasScroll
-    )
-    const retY = scrollBehaviorY.hooks.trigger(
-      scrollBehaviorY.hooks.eventTypes.ignoreHasScroll
-    )
-
-    expect(retX).toBe(true)
-    expect(retY).toBe(true)
-  })
-
-  it('should work well when call putAt()', () => {
-    // integer
-    movable.putAt(20, 20)
-    expect(scroll.scrollTo).toBeCalledWith(20, 20, 800, expect.anything())
-
-    // simulate minScrollPos
-    scroll.scroller.scrollBehaviorX.minScrollPos = 300
-    scroll.scroller.scrollBehaviorY.minScrollPos = 300
-
-    // [left, bottom]
-    movable.putAt('left', 'bottom')
-    expect(scroll.scrollTo).toBeCalledWith(0, 300, 800, expect.anything())
-
-    // [right, top]
-    movable.putAt('right', 'top')
-    expect(scroll.scrollTo).toBeCalledWith(300, 0, 800, expect.anything())
-
-    // [center, center]
-    movable.putAt('center', 'center')
-    expect(scroll.scrollTo).toBeCalledWith(150, 150, 800, expect.anything())
-  })
-
-  it('should destroy all events', () => {
-    const { scrollBehaviorX, scrollBehaviorY } = scroll.scroller
-    scroll.hooks.trigger(scroll.hooks.eventTypes.destroy)
-    expect(scrollBehaviorX.hooks.events['computeBoundary'].length).toBe(0)
-    expect(scrollBehaviorX.hooks.events['ignoreHasScroll'].length).toBe(0)
-
-    expect(scrollBehaviorY.hooks.events['computeBoundary'].length).toBe(0)
-    expect(scrollBehaviorY.hooks.events['ignoreHasScroll'].length).toBe(0)
-  })
-})

package/better-scroll-dev/better-scroll-dev/packages/movable/src/index.ts

@@ -1,138 +0,0 @@
-import BScroll, { Behavior, Boundary } from '@better-scroll/core'
-import {
-  ease,
-  EventEmitter,
-  ApplyOrder,
-  EaseItem,
-} from '@better-scroll/shared-utils'
-import propertiesConfig from './propertiesConfig'
-
-type PositionX = number | 'left' | 'right' | 'center'
-type PositionY = number | 'top' | 'bottom' | 'center'
-
-declare module '@better-scroll/core' {
-  interface CustomOptions {
-    movable?: true
-  }
-  interface CustomAPI {
-    movable: PluginAPI
-  }
-}
-
-interface PluginAPI {
-  putAt(x: PositionX, y: PositionY, time?: number, easing?: EaseItem): void
-}
-
-export default class Movable implements PluginAPI {
-  static pluginName = 'movable'
-  static applyOrder = ApplyOrder.Pre
-  private hooksFn: Array<[EventEmitter, string, Function]>
-  constructor(public scroll: BScroll) {
-    this.handleBScroll()
-    this.handleHooks()
-  }
-
-  private handleBScroll() {
-    this.scroll.proxy(propertiesConfig)
-  }
-
-  private handleHooks() {
-    this.hooksFn = []
-    const { scrollBehaviorX, scrollBehaviorY } = this.scroll.scroller
-
-    const computeBoundary = (boundary: Boundary, behavior: Behavior) => {
-      if (boundary.maxScrollPos > 0) {
-        // content is smaller than wrapper
-        boundary.minScrollPos = behavior.wrapperSize - behavior.contentSize
-        boundary.maxScrollPos = 0
-      }
-    }
-
-    this.registerHooks(
-      scrollBehaviorX.hooks,
-      scrollBehaviorX.hooks.eventTypes.ignoreHasScroll,
-      () => true
-    )
-    this.registerHooks(
-      scrollBehaviorX.hooks,
-      scrollBehaviorX.hooks.eventTypes.computeBoundary,
-      (boundary: Boundary) => {
-        computeBoundary(boundary, scrollBehaviorX)
-      }
-    )
-
-    this.registerHooks(
-      scrollBehaviorY.hooks,
-      scrollBehaviorY.hooks.eventTypes.ignoreHasScroll,
-      () => true
-    )
-    this.registerHooks(
-      scrollBehaviorY.hooks,
-      scrollBehaviorY.hooks.eventTypes.computeBoundary,
-      (boundary: Boundary) => {
-        computeBoundary(boundary, scrollBehaviorY)
-      }
-    )
-
-    this.registerHooks(
-      this.scroll.hooks,
-      this.scroll.hooks.eventTypes.destroy,
-      () => {
-        this.destroy()
-      }
-    )
-  }
-
-  putAt(
-    x: PositionX,
-    y: PositionY,
-    time = this.scroll.options.bounceTime,
-    easing = ease.bounce
-  ) {
-    const position = this.resolvePostion(x, y)
-    this.scroll.scrollTo(position.x, position.y, time, easing)
-  }
-
-  private resolvePostion(x: PositionX, y: PositionY): { x: number; y: number } {
-    const { scrollBehaviorX, scrollBehaviorY } = this.scroll.scroller
-    const resolveFormula = {
-      left() {
-        return 0
-      },
-      top() {
-        return 0
-      },
-      right() {
-        return scrollBehaviorX.minScrollPos
-      },
-      bottom() {
-        return scrollBehaviorY.minScrollPos
-      },
-      center(index: number) {
-        const baseSize =
-          index === 0
-            ? scrollBehaviorX.minScrollPos
-            : scrollBehaviorY.minScrollPos
-        return baseSize / 2
-      },
-    }
-    return {
-      x: typeof x === 'number' ? x : resolveFormula[x](0),
-      y: typeof y === 'number' ? y : resolveFormula[y](1),
-    }
-  }
-
-  destroy() {
-    this.hooksFn.forEach((item) => {
-      const hooks = item[0]
-      const hooksName = item[1]
-      const handlerFn = item[2]
-      hooks.off(hooksName, handlerFn)
-    })
-    this.hooksFn.length = 0
-  }
-  private registerHooks(hooks: EventEmitter, name: string, handler: Function) {
-    hooks.on(name, handler, this)
-    this.hooksFn.push([hooks, name, handler])
-  }
-}

package/better-scroll-dev/better-scroll-dev/packages/movable/src/propertiesConfig.ts

@@ -1,13 +0,0 @@
-const sourcePrefix = 'plugins.movable'
-const propertiesMap = [
-  {
-    key: 'putAt',
-    name: 'putAt',
-  },
-]
-export default propertiesMap.map((item) => {
-  return {
-    key: item.key,
-    sourceKey: `${sourcePrefix}.${item.name}`,
-  }
-})

package/better-scroll-dev/better-scroll-dev/packages/nested-scroll/README.md

@@ -1,23 +0,0 @@
-# better-scroll
-
-[中文文档](https://github.com/ustbhuangyi/better-scroll/blob/master/packages/nested-scroll/README_zh-CN.md)
-
-nestedScroll is a plugin which helps you solve the trouble of nested Scroll
-
-## Usage
-
-```js
-  import BScroll from 'better-scroll'
-  import NestedScroll from '@better-scroll/nested-scroll'
-
-  BScroll.use(NestedScroll)
-
-  // parent bs
-  new BScroll('.outerWrapper', {
-    nestedScroll: true
-  })
-  // child bs
-  new BScroll('.innerWrapper', {
-    nestedScroll: true
-  })
-```