cbvirtua 1.0.106 → 1.0.107

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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,172 @@
+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

@@ -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/packages/shared-utils/src/lang.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,53 @@
+/* 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

@@ -0,0 +1,45 @@
+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

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

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

@@ -0,0 +1,26 @@
+# @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

@@ -0,0 +1,24 @@
+# @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

@@ -0,0 +1,36 @@
+{
+	"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

@@ -0,0 +1,107 @@
+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
+  }
+}