cbvirtua 1.0.109 → 1.0.115

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

@@ -1,36 +0,0 @@
-// ssr support
-export const inBrowser = typeof window !== 'undefined'
-export const ua = inBrowser && navigator.userAgent.toLowerCase()
-export const isWeChatDevTools = !!(ua && /wechatdevtools/.test(ua))
-export const isAndroid = ua && ua.indexOf('android') > 0
-
-/* istanbul ignore next */
-export const isIOSBadVersion: boolean = (() => {
-  if (typeof ua === 'string') {
-    const regex = /os (\d\d?_\d(_\d)?)/
-    const matches = regex.exec(ua)
-    if (!matches) return false
-    const 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 let supportsPassive = false
-/* istanbul ignore next */
-if (inBrowser) {
-  const EventName = 'test-passive' as any
-  try {
-    const opts = {}
-    Object.defineProperty(opts, 'passive', {
-      get() {
-        supportsPassive = true
-      },
-    }) // https://github.com/facebook/flow/issues/285
-    window.addEventListener(EventName, () => {}, opts)
-  } catch (e) {}
-}

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

@@ -1,172 +0,0 @@
-import { warn } from './debug'
-import { addEvent, removeEvent } from './dom'
-
-interface Events {
-  [name: string]: [WithFnFunction, Object][]
-}
-
-interface EventTypes {
-  [type: string]: string
-}
-
-interface WithFnFunction extends Function {
-  fn?: Function
-}
-
-export class EventEmitter {
-  events: Events
-  eventTypes: EventTypes
-  constructor(names: string[]) {
-    this.events = {}
-    this.eventTypes = {}
-    this.registerType(names)
-  }
-
-  on(type: string, fn: Function, context: Object = this) {
-    this.hasType(type)
-    if (!this.events[type]) {
-      this.events[type] = []
-    }
-
-    this.events[type].push([fn, context])
-    return this
-  }
-
-  once(type: string, fn: Function, context: Object = this) {
-    this.hasType(type)
-    const magic = (...args: any[]) => {
-      this.off(type, magic)
-      const ret = fn.apply(context, args)
-      if (ret === true) {
-        return ret
-      }
-    }
-    magic.fn = fn
-
-    this.on(type, magic)
-    return this
-  }
-
-  off(type?: string, fn?: Function) {
-    if (!type && !fn) {
-      this.events = {}
-      return this
-    }
-
-    if (type) {
-      this.hasType(type)
-      if (!fn) {
-        this.events[type] = []
-        return this
-      }
-
-      let events = this.events[type]
-      if (!events) {
-        return this
-      }
-
-      let count = events.length
-      while (count--) {
-        if (
-          events[count][0] === fn ||
-          (events[count][0] && events[count][0].fn === fn)
-        ) {
-          events.splice(count, 1)
-        }
-      }
-
-      return this
-    }
-  }
-
-  trigger(type: string, ...args: any[]) {
-    this.hasType(type)
-    let events = this.events[type]
-    if (!events) {
-      return
-    }
-
-    let len = events.length
-    let eventsCopy = [...events]
-    let ret
-    for (let i = 0; i < len; i++) {
-      let event = eventsCopy[i]
-      let [fn, context] = event
-      if (fn) {
-        ret = fn.apply(context, args)
-        if (ret === true) {
-          return ret
-        }
-      }
-    }
-  }
-  registerType(names: string[]) {
-    names.forEach((type: string) => {
-      this.eventTypes[type] = type
-    })
-  }
-
-  destroy() {
-    this.events = {}
-    this.eventTypes = {}
-  }
-
-  private hasType(type: string) {
-    const types = this.eventTypes
-    const isType = types[type] === type
-    if (!isType) {
-      warn(
-        `EventEmitter has used unknown event type: "${type}", should be oneof [` +
-          `${Object.keys(types).map((_) => JSON.stringify(_))}` +
-          `]`
-      )
-    }
-  }
-}
-
-interface EventData {
-  name: string
-  handler(e: UIEvent): void
-  capture?: boolean
-}
-
-export class EventRegister {
-  constructor(
-    public wrapper: HTMLElement | Window,
-    public events: EventData[]
-  ) {
-    this.addDOMEvents()
-  }
-
-  destroy() {
-    this.removeDOMEvents()
-    this.events = []
-  }
-
-  private addDOMEvents() {
-    this.handleDOMEvents(addEvent)
-  }
-
-  private removeDOMEvents() {
-    this.handleDOMEvents(removeEvent)
-  }
-
-  private handleDOMEvents(eventOperation: Function) {
-    const wrapper = this.wrapper
-
-    this.events.forEach((event: EventData) => {
-      eventOperation(wrapper, event.name, this, !!event.capture)
-    })
-  }
-
-  private handleEvent(e: UIEvent) {
-    const eventType = e.type
-    this.events.some((event: EventData) => {
-      if (event.name === eventType) {
-        event.handler(e)
-        return true
-      }
-      return false
-    })
-  }
-}

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

@@ -1,11 +0,0 @@
-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/packages/shared-utils/src/lang.ts

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

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

@@ -1,53 +0,0 @@
-/* istanbul ignore next */
-const noop = function (val?: any) {}
-
-interface TraversedObject {
-  [key: string]: any
-}
-const sharedPropertyDefinition: PropertyDescriptor = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop,
-}
-
-const getProperty = (obj: TraversedObject, key: string) => {
-  const keys = key.split('.')
-  for (let i = 0; i < keys.length - 1; i++) {
-    obj = obj[keys[i]]
-    if (typeof obj !== 'object' || !obj) return
-  }
-  const lastKey = keys.pop() as string
-  if (typeof obj[lastKey] === 'function') {
-    return function () {
-      return obj[lastKey].apply(obj, arguments)
-    }
-  } else {
-    return obj[lastKey]
-  }
-}
-
-const setProperty = (obj: TraversedObject, key: string, value: any) => {
-  const keys = key.split('.')
-  let temp
-  for (let i = 0; i < keys.length - 1; i++) {
-    temp = keys[i]
-    if (!obj[temp]) obj[temp] = {}
-    obj = obj[temp]
-  }
-  obj[keys.pop() as string] = value
-}
-
-export function propertiesProxy(
-  target: Object,
-  sourceKey: string,
-  key: string
-) {
-  sharedPropertyDefinition.get = function proxyGetter() {
-    return getProperty(this, sourceKey)
-  }
-  sharedPropertyDefinition.set = function proxySetter(val) {
-    setProperty(this, sourceKey, val)
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition)
-}

package/better-scroll-dev/better-scroll-dev/packages/shared-utils/src/raf.ts

@@ -1,45 +0,0 @@
-import { inBrowser } from './env'
-
-interface DelayedHandler {
-  (): void
-  interval: number
-}
-
-const DEFAULT_INTERVAL = 1000 / 60
-const windowCompat = inBrowser && (window as any)
-
-/* istanbul ignore next */
-function noop() {}
-
-export const requestAnimationFrame = (() => {
-  /* istanbul ignore if  */
-  if (!inBrowser) {
-    return noop
-  }
-  return (
-    windowCompat.requestAnimationFrame ||
-    windowCompat.webkitRequestAnimationFrame ||
-    windowCompat.mozRequestAnimationFrame ||
-    windowCompat.oRequestAnimationFrame ||
-    // if all else fails, use setTimeout
-    function (callback: DelayedHandler) {
-      return window.setTimeout(callback, callback.interval || DEFAULT_INTERVAL) // make interval as precise as possible.
-    }
-  )
-})()
-
-export const cancelAnimationFrame = (() => {
-  /* istanbul ignore if  */
-  if (!inBrowser) {
-    return noop
-  }
-  return (
-    windowCompat.cancelAnimationFrame ||
-    windowCompat.webkitCancelAnimationFrame ||
-    windowCompat.mozCancelAnimationFrame ||
-    windowCompat.oCancelAnimationFrame ||
-    function (id: number) {
-      window.clearTimeout(id)
-    }
-  )
-})()

package/better-scroll-dev/better-scroll-dev/packages/shared-utils/src/types.ts

@@ -1,4 +0,0 @@
-export type Position = {
-  x: number
-  y: number
-}

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

@@ -1,26 +0,0 @@
-# @better-scroll/slide
-
-[中文文档](https://github.com/ustbhuangyi/better-scroll/blob/master/packages/slide/README_zh-CN.md)
-
-The ability to inject a Carousel effect for BetterScroll.
-
-## Usage
-
-```js
-import BScroll from '@better-scroll/core'
-import Slide from '@better-scroll/slide'
-BScroll.use(Slide)
-
-const bs = new BScroll('.div', {
-  scrollX: false,
-  scrollY: true,
-  slide: {
-    loop: true,
-    threshold: 100
-  },
-  useTransition: true,
-  momentum: false,
-  bounce: false,
-  stopPropagation: true
-})
-```

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

@@ -1,24 +0,0 @@
-# @better-scroll/slide
-
-实现轮播图的效果。
-
-## 使用
-
-```js
-import BScroll from '@better-scroll/core'
-import Slide from '@better-scroll/slide'
-BScroll.use(Slide)
-
-const bs = new BScroll('.div', {
-  scrollX: false,
-  scrollY: true,
-  slide: {
-    loop: true,
-    threshold: 100
-  },
-  useTransition: true,
-  momentum: false,
-  bounce: false,
-  stopPropagation: true
-})
-```

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

@@ -1,36 +0,0 @@
-{
-	"name": "@better-scroll/slide",
-	"version": "2.5.1",
-	"description": "a carousel effect triggered by BetterScroll",
-	"author": {
-		"name": "jizhi",
-		"email": "theniceangel@163.com"
-	},
-	"main": "dist/slide.min.js",
-	"module": "dist/slide.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/slide"
-	},
-	"dependencies": {
-		"@better-scroll/core": "^2.5.1"
-	},
-	"gitHead": "f441227b6137d44ba0b44b97ed4cd49de9386130"
-}

package/better-scroll-dev/better-scroll-dev/packages/slide/src/PagesMatrix.ts

@@ -1,107 +0,0 @@
-import BScroll from '@better-scroll/core'
-import { PageIndex } from './SlidePages'
-import { DEFAULT_PAGE_STATS } from './constants'
-
-export interface PageStats {
-  x: number
-  y: number
-  width: number
-  height: number
-  cx: number // center position of every page
-  cy: number
-}
-
-export default class PagesMatrix {
-  pages: Array<Array<PageStats>>
-  pageLengthOfX: number
-  pageLengthOfY: number
-  private wrapperWidth: number
-  private wrapperHeight: number
-  private scrollerWidth: number
-  private scrollerHeight: number
-  constructor(private scroll: BScroll) {
-    this.init()
-  }
-  init() {
-    const scroller = this.scroll.scroller
-    const { scrollBehaviorX, scrollBehaviorY } = scroller
-    this.wrapperWidth = scrollBehaviorX.wrapperSize
-    this.wrapperHeight = scrollBehaviorY.wrapperSize
-    this.scrollerHeight = scrollBehaviorY.contentSize
-    this.scrollerWidth = scrollBehaviorX.contentSize
-    this.pages = this.buildPagesMatrix(this.wrapperWidth, this.wrapperHeight)
-    this.pageLengthOfX = this.pages ? this.pages.length : 0
-    this.pageLengthOfY = this.pages && this.pages[0] ? this.pages[0].length : 0
-  }
-
-  getPageStats(pageX: number, pageY: number): PageStats {
-    // Returns the default Stats when no Stats are retrieved
-    // Scene: When the `content` element is an empty bounding box, the return value of the `width/height` function of el.getBoundingClientRect is 0 and pages will be calculated as an empty array.
-    // https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect
-    return this.pages[pageX] && this.pages[pageX][pageY]
-      ? this.pages[pageX][pageY]
-      : DEFAULT_PAGE_STATS
-  }
-
-  getNearestPageIndex(x: number, y: number): PageIndex {
-    let pageX = 0
-    let pageY = 0
-    let l = this.pages.length
-    for (; pageX < l - 1; pageX++) {
-      if (x >= this.pages[pageX][0].cx) {
-        break
-      }
-    }
-    l = this.pages[pageX] ? this.pages[pageX].length : 0
-    for (; pageY < l - 1; pageY++) {
-      if (y >= this.pages[0][pageY].cy) {
-        break
-      }
-    }
-    return {
-      pageX,
-      pageY,
-    }
-  }
-
-  // (n x 1) matrix for horizontal scroll or
-  // (1 * n) matrix for vertical scroll
-  private buildPagesMatrix(
-    stepX: number,
-    stepY: number
-  ): Array<Array<PageStats>> {
-    let pages: Array<Array<PageStats>> = []
-    let x = 0
-    let y
-    let cx
-    let cy
-    let i = 0
-    let l
-    const maxScrollPosX = this.scroll.scroller.scrollBehaviorX.maxScrollPos
-    const maxScrollPosY = this.scroll.scroller.scrollBehaviorY.maxScrollPos
-    cx = Math.round(stepX / 2)
-    cy = Math.round(stepY / 2)
-
-    while (x > -this.scrollerWidth) {
-      pages[i] = []
-      l = 0
-      y = 0
-      while (y > -this.scrollerHeight) {
-        pages[i][l] = {
-          x: Math.max(x, maxScrollPosX),
-          y: Math.max(y, maxScrollPosY),
-          width: stepX,
-          height: stepY,
-          cx: x - cx,
-          cy: y - cy,
-        }
-
-        y -= stepY
-        l++
-      }
-      x -= stepX
-      i++
-    }
-    return pages
-  }
-}