cbvirtua 1.0.109 → 1.0.115

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__mocks__/Behavior.ts

@@ -1,56 +0,0 @@
-import { EventEmitter } from '@better-scroll/shared-utils'
-
-const Behavior = jest.fn().mockImplementation((content, bscrollOptions) => {
-  return {
-    content,
-    options: bscrollOptions,
-    startPos: 0,
-    currentPos: 0,
-    absStartPos: 0,
-    dist: 0,
-    minScrollPos: 0,
-    maxScrollPos: 0,
-    hasScroll: true,
-    direction: 0,
-    movingDirection: 0,
-    relativeOffset: 0,
-    wrapperSize: 0,
-    contentSize: 0,
-    hooks: new EventEmitter([
-      'momentum',
-      'end',
-      'beforeComputeBoundary',
-      'computeBoundary',
-      'ignoreHasScroll',
-    ]),
-    start: jest.fn(),
-    move: jest.fn(),
-    end: jest.fn(),
-    updateDirection: jest.fn(),
-    refresh: jest.fn(),
-    updatePosition: jest.fn(),
-    getCurrentPos: jest.fn().mockImplementation(() => {
-      return 0
-    }),
-    checkInBoundary: jest.fn().mockImplementation(() => {
-      return {
-        position: 0,
-        inBoundary: false,
-      }
-    }),
-    adjustPosition: jest.fn(),
-    updateStartPos: jest.fn(),
-    updateAbsStartPos: jest.fn(),
-    resetStartPos: jest.fn(),
-    getAbsDist: jest.fn().mockImplementation((delta: number) => {
-      return Math.abs(delta)
-    }),
-    destroy: jest.fn(),
-    computeBoundary: jest.fn(),
-    setMovingDirection: jest.fn(),
-    setDirection: jest.fn(),
-    performDampingAlgorithm: jest.fn(),
-  }
-})
-
-export { Behavior }

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__mocks__/DirectionLock.ts

@@ -1,24 +0,0 @@
-const DirectionLock = jest
-  .fn()
-  .mockImplementation((content, bscrollOptions) => {
-    return {
-      directionLocked: '',
-      directionLockThreshold: '5',
-      eventPassthrough: '',
-      freeScroll: false,
-      reset: jest.fn(),
-      checkMovingDirection: jest.fn().mockImplementation((ret = true) => {
-        return ret
-      }),
-      adjustDelta: jest
-        .fn()
-        .mockImplementation((deltaX: number = 0, deltaY: number = 0) => {
-          return {
-            deltaX,
-            deltaY,
-          }
-        }),
-    }
-  })
-
-export default DirectionLock

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__mocks__/Scroller.ts

@@ -1,77 +0,0 @@
-import createAnimater from '../../animater'
-import Translater from '../../translater'
-import { Behavior } from '../Behavior'
-import ActionsHandler from '../../base/ActionsHandler'
-import Actions from '../Actions'
-
-jest.mock('../../animater')
-jest.mock('../../translater')
-jest.mock('../Behavior')
-jest.mock('../../base/ActionsHandler')
-jest.mock('../Actions')
-
-import { EventEmitter, EventRegister } from '@better-scroll/shared-utils'
-
-const Scroller = jest.fn().mockImplementation((wrapper, bscrollOptions) => {
-  const content = wrapper.children[0]
-  const translater = new Translater(content)
-  const animater = createAnimater(content, translater, bscrollOptions)
-  const actionsHandler = new ActionsHandler(wrapper, bscrollOptions)
-  const scrollBehaviorX = new Behavior(
-    wrapper,
-    content,
-    Object.assign(bscrollOptions, { scrollable: bscrollOptions.scrollX })
-  )
-  const scrollBehaviorY = new Behavior(
-    wrapper,
-    content,
-    Object.assign(bscrollOptions, { scrollable: bscrollOptions.scrollY })
-  )
-  const actions = new Actions(
-    scrollBehaviorX,
-    scrollBehaviorY,
-    actionsHandler,
-    animater,
-    bscrollOptions
-  )
-  return {
-    wrapper,
-    content,
-    options: bscrollOptions,
-    translater,
-    animater,
-    actionsHandler,
-    actions,
-    hooks: new EventEmitter([
-      'beforeStart',
-      'beforeMove',
-      'beforeScrollStart',
-      'scrollStart',
-      'scroll',
-      'beforeEnd',
-      'scrollEnd',
-      'resize',
-      'touchEnd',
-      'end',
-      'flick',
-      'scrollCancel',
-      'momentum',
-      'scrollTo',
-      'minDistanceScroll',
-      'scrollToElement',
-      'transitionEnd',
-      'checkClick',
-      'beforeRefresh',
-    ]),
-    scrollBehaviorX,
-    scrollBehaviorY,
-    resizeRegister: new EventRegister(wrapper, []),
-    transitionEndRegister: new EventRegister(wrapper, []),
-    scrollTo: jest.fn(),
-    resetPosition: jest.fn(),
-    togglePointerEvents: jest.fn(),
-    reflow: jest.fn(),
-  }
-})
-
-export default Scroller

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__tests__/Actions.spec.ts

@@ -1,303 +0,0 @@
-import { Behavior } from '../Behavior'
-import createAnimater from '../../animater'
-import Translater from '../../translater'
-import { OptionsConstructor } from '../../Options'
-import ActionsHandler from '../../base/ActionsHandler'
-import DirectionLockAction from '../DirectionLock'
-
-jest.mock('../Behavior')
-jest.mock('../../animater')
-jest.mock('../../translater')
-jest.mock('../../Options')
-jest.mock('../../base/ActionsHandler')
-jest.mock('../DirectionLock')
-
-import Actions from '../Actions'
-
-describe('Actions Class tests', () => {
-  let actions: Actions
-  beforeEach(() => {
-    // redefine window.performance
-    // because we will use window.performance.timing.navigationStart
-    // in our file('src/util/lang.ts')
-    Object.defineProperty(window, 'performance', {
-      get() {
-        return undefined
-      },
-    })
-
-    let content = document.createElement('div')
-    let wrapper = document.createElement('div')
-    let bscrollOptions = new OptionsConstructor() as any
-    let scrollBehaviorX = new Behavior(wrapper, content, bscrollOptions)
-    let scrollBehaviorY = new Behavior(wrapper, content, bscrollOptions)
-    let actionsHandler = new ActionsHandler(wrapper, bscrollOptions)
-    let translater = new Translater(content)
-    let animater = createAnimater(content, translater, bscrollOptions)
-    actions = new Actions(
-      scrollBehaviorX,
-      scrollBehaviorY,
-      actionsHandler,
-      animater,
-      bscrollOptions
-    )
-  })
-
-  it('should init hooks when call constructor function', () => {
-    expect(actions.hooks.eventTypes).toHaveProperty('start')
-    expect(actions.hooks.eventTypes).toHaveProperty('beforeMove')
-    expect(actions.hooks.eventTypes).toHaveProperty('scroll')
-    expect(actions.hooks.eventTypes).toHaveProperty('beforeEnd')
-    expect(actions.hooks.eventTypes).toHaveProperty('end')
-    expect(actions.hooks.eventTypes).toHaveProperty('scrollEnd')
-  })
-
-  it('should invoke handleStart when actionsHandler trigger start hook', () => {
-    actions.actionsHandler.hooks.trigger('start')
-
-    expect(actions.fingerMoved).toBe(false)
-    expect(actions.scrollBehaviorX.start).toBeCalled()
-    expect(actions.scrollBehaviorY.start).toBeCalled()
-    expect(actions.scrollBehaviorX.resetStartPos).toBeCalled()
-    expect(actions.scrollBehaviorY.resetStartPos).toBeCalled()
-    expect(actions.animater.doStop).toBeCalled()
-  })
-
-  it('should invoke handleMove when actionsHandler trigger move hook', () => {
-    let e = new Event('touchmove')
-    let beforeMoveMockHandler = jest.fn()
-    let scrollStartHandler = jest.fn()
-    let scrollHandler = jest.fn()
-    // cancelable beforeMove hook
-    actions.hooks.on(
-      actions.hooks.eventTypes.beforeMove,
-      jest.fn().mockImplementationOnce(() => true)
-    )
-    actions.hooks.on(actions.hooks.eventTypes.beforeMove, beforeMoveMockHandler)
-    actions.hooks.on(actions.hooks.eventTypes.scrollStart, scrollStartHandler)
-    actions.hooks.on(actions.hooks.eventTypes.scroll, scrollHandler)
-
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-
-    expect(beforeMoveMockHandler).toHaveBeenCalledTimes(0)
-
-    // moved less than 15 px
-    actions.endTime = Date.now() - 400
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: 10,
-      e,
-    })
-
-    expect(beforeMoveMockHandler).toHaveBeenCalledTimes(1)
-    expect(actions.directionLockAction.checkMovingDirection).not.toBeCalled()
-
-    // lock direction
-    actions.endTime = Date.now()
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 10,
-      deltaY: 0,
-      e,
-    })
-    expect(beforeMoveMockHandler).toHaveBeenCalledTimes(2)
-    expect(actions.actionsHandler.setInitiated).toBeCalled()
-
-    actions.startTime = Date.now() - 400
-    actions.options.probeType = 1
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-    expect(beforeMoveMockHandler).toHaveBeenCalledTimes(3)
-    expect(scrollStartHandler).toBeCalled()
-    expect(scrollHandler).toBeCalledTimes(1)
-    expect(actions.scrollBehaviorY.getAbsDist).toHaveBeenCalledWith(-20)
-    expect(actions.scrollBehaviorY.move).toHaveBeenCalledWith(-20)
-
-    actions.startTime = Date.now()
-    actions.options.probeType = 3
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-    expect(scrollHandler).toBeCalledTimes(2)
-
-    const cbMock = jest.fn().mockImplementationOnce(() => true)
-    actions.fingerMoved = true
-    actions.hooks.on(actions.hooks.eventTypes.detectMovingDirection, cbMock)
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-
-    expect(cbMock).toBeCalled()
-    expect(actions.fingerMoved).toBe(true)
-
-    // content not moved
-    const mockFn = jest.fn()
-    actions.contentMoved = false
-    actions.hooks.on(actions.hooks.eventTypes.contentNotMoved, mockFn)
-    actions.startTime = Date.now() - 400
-    actions.scrollBehaviorX.move = jest.fn().mockImplementation(() => 0)
-    actions.scrollBehaviorY.move = jest.fn().mockImplementation(() => 0)
-
-    actions.endTime = Date.now() + 400
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: 0,
-      e,
-    })
-    expect(mockFn).toBeCalled()
-  })
-
-  it('should invoke handleEnd when actionsHandler trigger end hook', () => {
-    let beforeEndMockHandler = jest.fn()
-    let endMockHandler = jest.fn()
-    let scrollEndHandler = jest.fn()
-    let e = new Event('touchend')
-    // cancelable beforeEnd hook
-    actions.hooks.on(
-      actions.hooks.eventTypes.beforeEnd,
-      jest.fn().mockImplementationOnce(() => true)
-    )
-    // cancelable end hook
-    actions.hooks.on(
-      actions.hooks.eventTypes.end,
-      jest.fn().mockImplementationOnce(() => true)
-    )
-    actions.hooks.on(actions.hooks.eventTypes.beforeEnd, beforeEndMockHandler)
-    actions.hooks.on(actions.hooks.eventTypes.end, endMockHandler)
-    actions.hooks.on(actions.hooks.eventTypes.scrollEnd, scrollEndHandler)
-
-    actions.actionsHandler.hooks.trigger(
-      actions.actionsHandler.hooks.eventTypes.end,
-      e
-    )
-    expect(beforeEndMockHandler).not.toBeCalled()
-    expect(actions.scrollBehaviorX.updateDirection).not.toBeCalled()
-
-    actions.actionsHandler.hooks.trigger(
-      actions.actionsHandler.hooks.eventTypes.end,
-      e
-    )
-
-    expect(beforeEndMockHandler).toHaveBeenCalledTimes(1)
-    expect(actions.scrollBehaviorX.updateDirection).toHaveBeenCalledTimes(1)
-    expect(actions.scrollBehaviorY.updateDirection).toHaveBeenCalledTimes(1)
-    expect(endMockHandler).not.toBeCalled()
-
-    actions.actionsHandler.hooks.trigger(
-      actions.actionsHandler.hooks.eventTypes.end,
-      e
-    )
-    expect(scrollEndHandler).toBeCalled()
-  })
-
-  it('should get correct position when invoking getCurrentPos method', () => {
-    actions.getCurrentPos()
-    expect(actions.scrollBehaviorX.getCurrentPos).toBeCalled()
-    expect(actions.scrollBehaviorY.getCurrentPos).toBeCalled()
-  })
-
-  it('should reset endTime when refreshed', () => {
-    actions.refresh()
-
-    expect(actions.endTime).toBe(0)
-  })
-
-  it('destroy()', () => {
-    actions.destroy()
-
-    expect(actions.hooks.events).toEqual({})
-    expect(actions.hooks.eventTypes).toEqual({})
-  })
-
-  it('should can be disabled', () => {
-    actions.enabled = false
-    const actionsHandler = actions.actionsHandler
-
-    actionsHandler.hooks.trigger(actionsHandler.hooks.eventTypes.start)
-    expect(actions.directionLockAction.reset).not.toBeCalled()
-
-    actionsHandler.hooks.trigger(actionsHandler.hooks.eventTypes.move, {
-      deltaX: 0,
-      deltaY: 0,
-    })
-    expect(actions.scrollBehaviorX.getAbsDist).not.toBeCalled()
-
-    actionsHandler.hooks.trigger(actionsHandler.hooks.eventTypes.end)
-    expect(actions.scrollBehaviorX.updateDirection).not.toBeCalled()
-  })
-
-  it('should prevent native click event', () => {
-    actions.actionsHandler.hooks.trigger(
-      actions.actionsHandler.hooks.eventTypes.click,
-      {
-        _constructed: false,
-        target: document.createElement('div'),
-        preventDefault() {},
-        stopPropagation() {},
-      }
-    )
-  })
-
-  it('apply quadrant transformation when force rotating by CSS', () => {
-    let e = new Event('touchmove')
-
-    // second quadrant
-    actions.options.quadrant = 2
-
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-
-    expect(actions.scrollBehaviorX.getAbsDist).toBeCalledWith(-20)
-    expect(actions.scrollBehaviorY.getAbsDist).toBeCalledWith(-0)
-
-    // third quadrant
-    actions.options.quadrant = 3
-
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: -20,
-      deltaY: 0,
-      e,
-    })
-
-    expect(actions.scrollBehaviorX.getAbsDist).toBeCalledWith(20)
-    expect(actions.scrollBehaviorY.getAbsDist).toBeCalledWith(-0)
-
-    // forth quadrant
-    actions.options.quadrant = 4
-
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 20,
-      deltaY: 0,
-      e,
-    })
-
-    expect(actions.scrollBehaviorX.getAbsDist).toBeCalledWith(-0)
-    expect(actions.scrollBehaviorY.getAbsDist).toBeCalledWith(20)
-  })
-
-  it('coordinateTransformation hook', () => {
-    let e = new Event('touchmove')
-    const mockFn = jest.fn()
-    actions.hooks.on(actions.hooks.eventTypes.coordinateTransformation, mockFn)
-    actions.actionsHandler.hooks.trigger('move', {
-      deltaX: 0,
-      deltaY: -20,
-      e,
-    })
-
-    expect(mockFn).toBeCalled()
-  })
-})

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__tests__/Behavior.spec.ts

@@ -1,150 +0,0 @@
-import { Behavior } from '../Behavior'
-import { createDiv } from '../../__tests__/__utils__/layout'
-
-describe('Behavior Class tests', () => {
-  let behavior: Behavior
-  let content: HTMLElement
-  let wrapper: HTMLElement
-  let options = {
-    movable: false,
-    scrollable: true,
-    momentum: true,
-    momentumLimitTime: 300,
-    momentumLimitDistance: 15,
-    deceleration: 0.001,
-    swipeBounceTime: 2500,
-    outOfBoundaryDampingFactor: 1 / 3,
-    specifiedIndexAsContent: 0,
-    swipeTime: 2000,
-    bounces: [true, true] as [boolean, boolean],
-    rect: {
-      size: 'height',
-      position: 'top',
-    },
-  }
-  beforeEach(() => {
-    wrapper = createDiv(100, 200, 0, 0)
-    content = createDiv(100, 400, 0, 0)
-    document.body.appendChild(content)
-    wrapper.appendChild(content)
-    behavior = new Behavior(wrapper, content, options)
-  })
-
-  it('should init hooks when call constructor function', () => {
-    expect(behavior.hooks.eventTypes).toHaveProperty('momentum')
-    expect(behavior.hooks.eventTypes).toHaveProperty('end')
-    expect(behavior.currentPos).toBe(0)
-    expect(behavior.startPos).toBe(0)
-    expect(behavior.content).toEqual(content)
-  })
-
-  it('should refresh some properties when invoking refresh method', () => {
-    behavior.refresh(behavior.content)
-
-    expect(behavior.wrapperSize).toBe(200)
-    expect(behavior.contentSize).toBe(400)
-    expect(behavior.relativeOffset).toBe(0)
-    expect(behavior.minScrollPos).toBe(-0)
-    expect(behavior.maxScrollPos).toBe(-200)
-    expect(behavior.hasScroll).toBe(true)
-    expect(behavior.direction).toBe(0)
-  })
-
-  it('should refresh some properties when invoking start method', () => {
-    behavior.start()
-    expect(behavior.direction).toBe(0)
-    expect(behavior.movingDirection).toBe(0)
-    expect(behavior.dist).toBe(0)
-  })
-
-  it('should refresh some properties when invoking move method', () => {
-    behavior.refresh(behavior.content)
-    expect(behavior.move(-10)).toBe(-10)
-    expect(behavior.movingDirection).toBe(1)
-  })
-
-  it('should not trigger momentum scroll when duration is exceed momentumLimitTime', () => {
-    let endMockHandler = jest.fn()
-    behavior.hooks.on('end', endMockHandler)
-    behavior.refresh(behavior.content)
-    behavior.end(400)
-    expect(endMockHandler).toBeCalled()
-    expect(endMockHandler).toHaveBeenCalledWith({
-      duration: 0,
-    })
-  })
-
-  it('should trigger momentum scroll', () => {
-    behavior.refresh(behavior.content)
-    behavior.currentPos = -100
-
-    expect(behavior.end(100)).toEqual({
-      destination: -200,
-      duration: 2500,
-      rate: 15,
-    })
-    behavior.hooks.on(
-      behavior.hooks.eventTypes.momentum,
-      (momentumData: any) => {
-        momentumData.destination = 200
-      }
-    )
-    expect(behavior.end(100)).toEqual({
-      destination: -0,
-      duration: 2500,
-      rate: 15,
-    })
-  })
-
-  it('should keep direction unchanged when invoking updateDirection method', () => {
-    behavior.updateDirection()
-    expect(behavior.direction).toBe(0)
-  })
-
-  it('should update position when invoking updatePosition method', () => {
-    behavior.updatePosition(100)
-    expect(behavior.currentPos).toBe(100)
-  })
-
-  it('should auto bouncing within boundary when out of boundary', () => {
-    behavior.refresh(behavior.content)
-    behavior.updatePosition(-400)
-    expect(behavior.checkInBoundary()).toEqual({
-      position: -200,
-      inBoundary: false,
-    })
-  })
-
-  it('performDampingAlgorithm()', () => {
-    const ret = behavior.performDampingAlgorithm(20, 0.1)
-    expect(ret).toBe(2)
-
-    behavior.options.bounces = [false, false]
-    // simulate out of the boundaries and no bounce
-    const ret2 = behavior.performDampingAlgorithm(20, 0.1)
-    expect(ret2).toBe(-0)
-  })
-
-  it('getAbsDist()', () => {
-    const ret = behavior.getAbsDist(-20)
-    expect(ret).toBe(20)
-  })
-
-  it('adjustPosition()', () => {
-    const ret = behavior.adjustPosition(20.1)
-    expect(ret).toBe(-0)
-  })
-
-  it('computeBoundary()', () => {
-    behavior.hooks.on(
-      behavior.hooks.eventTypes.computeBoundary,
-      (boundary: { minScrollPos: number; maxScrollPos: number }) => {
-        boundary.minScrollPos = 20
-        boundary.maxScrollPos = 30
-      }
-    )
-    behavior.computeBoundary()
-
-    expect(behavior.maxScrollPos).toEqual(behavior.minScrollPos)
-  })
-})

package/better-scroll-dev/better-scroll-dev/packages/core/src/scroller/__tests__/DirectionLock.spec.ts

@@ -1,87 +0,0 @@
-import DirectionLock from '../DirectionLock'
-import {
-  Direction,
-  DirectionLock as DirectionLockEnum,
-} from '@better-scroll/shared-utils'
-describe('DirectionLock Class tests', () => {
-  let directionLock: DirectionLock
-  let e = new Event('touchstart') as any
-
-  beforeEach(() => {
-    directionLock = new DirectionLock(5, false, '')
-  })
-
-  it('should call reset when call constructor function', () => {
-    expect(directionLock.directionLocked).toBe('')
-  })
-
-  it('should lock vertically when scrolled in direction Y', () => {
-    directionLock.checkMovingDirection(0, 20, e)
-
-    expect(directionLock.directionLocked).toBe('vertical')
-  })
-
-  it('should lock horizontally when scrolled in direction X', () => {
-    directionLock.checkMovingDirection(20, 0, e)
-
-    expect(directionLock.directionLocked).toBe('horizontal')
-  })
-
-  it('should no lock when freeScroll is true', () => {
-    directionLock.freeScroll = true
-    directionLock.checkMovingDirection(20, 20, e)
-
-    expect(directionLock.directionLocked).toBe('')
-  })
-
-  it('adjustDelta() ', () => {
-    directionLock.directionLocked = DirectionLockEnum.Horizontal
-    const ret1 = directionLock.adjustDelta(20, 20)
-    expect(ret1).toMatchObject({
-      deltaX: 20,
-      deltaY: 0,
-    })
-
-    directionLock.directionLocked = DirectionLockEnum.Vertical
-    const ret2 = directionLock.adjustDelta(20, 20)
-    expect(ret2).toMatchObject({
-      deltaX: 0,
-      deltaY: 20,
-    })
-  })
-
-  it('reset()', () => {
-    directionLock.directionLocked = DirectionLockEnum.Vertical
-    directionLock.reset()
-    expect(directionLock.directionLocked).toBe(DirectionLockEnum.Default)
-  })
-
-  it('checkMovingDirection()', () => {
-    directionLock.directionLocked = DirectionLockEnum.Horizontal
-    directionLock.eventPassthrough = DirectionLockEnum.Horizontal
-    const ret1 = directionLock.checkMovingDirection(20, 20, {
-      preventDefault() {
-        return true
-      },
-    } as any)
-    expect(ret1).toBe(true)
-
-    directionLock.directionLocked = DirectionLockEnum.Horizontal
-    directionLock.eventPassthrough = DirectionLockEnum.Vertical
-    const ret2 = directionLock.checkMovingDirection(20, 20, {
-      preventDefault() {
-        return true
-      },
-    } as any)
-    expect(ret2).toBe(false)
-
-    // no locked
-    directionLock.directionLocked = DirectionLockEnum.Default
-    const ret3 = directionLock.checkMovingDirection(20, 20, {
-      preventDefault() {
-        return true
-      },
-    } as any)
-    expect(ret3).toBe(false)
-  })
-})