cbvirtua 1.0.109 → 1.0.115

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

@@ -1,58 +0,0 @@
-import BScroll from '@better-scroll/core'
-import MouseWheel from '@better-scroll/mouse-wheel'
-import ObserveDom from '@better-scroll/observe-dom'
-import PullDownRefresh from '@better-scroll/pull-down'
-import PullUpLoad from '@better-scroll/pull-up'
-import ScrollBar from '@better-scroll/scroll-bar'
-import Slide from '@better-scroll/slide'
-import Wheel from '@better-scroll/wheel'
-import Zoom from '@better-scroll/zoom'
-import NestedScroll from '@better-scroll/nested-scroll'
-import InfinityScroll from '@better-scroll/infinity'
-import Movable from '@better-scroll/movable'
-import ObserveImage from '@better-scroll/observe-image'
-import Indicators from '@better-scroll/indicators'
-
-export {
-  createBScroll,
-  BScrollInstance,
-  Options,
-  CustomOptions,
-  TranslaterPoint,
-  MountedBScrollHTMLElement,
-  Behavior,
-  Boundary,
-  CustomAPI
-} from '@better-scroll/core'
-
-export {
-  MouseWheel,
-  ObserveDom,
-  PullDownRefresh,
-  PullUpLoad,
-  ScrollBar,
-  Slide,
-  Wheel,
-  Zoom,
-  NestedScroll,
-  InfinityScroll,
-  Movable,
-  ObserveImage,
-  Indicators
-}
-
-BScroll.use(MouseWheel)
-  .use(ObserveDom)
-  .use(PullDownRefresh)
-  .use(PullUpLoad)
-  .use(ScrollBar)
-  .use(Slide)
-  .use(Wheel)
-  .use(Zoom)
-  .use(NestedScroll)
-  .use(InfinityScroll)
-  .use(Movable)
-  .use(ObserveImage)
-  .use(Indicators)
-
-export default BScroll

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

@@ -1,13 +0,0 @@
-# @better-scroll/core
-
-[中文文档](https://github.com/ustbhuangyi/better-scroll/blob/master/packages/core/README_zh-CN.md)
-
-core scroll from BetterScroll.
-
-## Usage
-
-```js
-import BScroll from '@better-scroll/core'
-
-const bs = new BScroll('.wrapper', {/* ... */})
-```

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

@@ -1,11 +0,0 @@
-# @better-scroll/core
-
-核心滚动，实现基础的列表滚动效果。
-
-## 使用
-
-```js
-import BScroll from '@better-scroll/core'
-
-const bs = new BScroll('.wrapper', {/* ... */})
-```

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

@@ -1,37 +0,0 @@
-{
-  "name": "@better-scroll/core",
-  "version": "2.5.1",
-  "description": "Minimalistic core scrolling for BetterScroll, it is pure and tiny",
-  "author": {
-    "name": "jizhi",
-    "email": "theniceangel@163.com"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "dist/core.js",
-  "module": "dist/core.esm.js",
-  "typings": "dist/types/index.d.ts",
-  "scripts": {},
-  "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@github.com:ustbhuangyi/better-scroll.git",
-    "directory": "packages/core"
-  },
-  "dependencies": {
-    "@better-scroll/shared-utils": "^2.5.1"
-  },
-  "gitHead": "f441227b6137d44ba0b44b97ed4cd49de9386130"
-}

package/better-scroll-dev/better-scroll-dev/packages/core/src/BScroll.ts

@@ -1,299 +0,0 @@
-import { BScrollInstance, propertiesConfig } from './Instance'
-import { Options, DefOptions, OptionsConstructor } from './Options'
-import Scroller from './scroller/Scroller'
-import {
-  getElement,
-  warn,
-  isUndef,
-  propertiesProxy,
-  ApplyOrder,
-  EventEmitter
-} from '@better-scroll/shared-utils'
-import { bubbling } from './utils/bubbling'
-import { UnionToIntersection } from './utils/typesHelper'
-
-interface PluginCtor {
-  pluginName: string
-  applyOrder?: ApplyOrder
-  new (scroll: BScroll): any
-}
-
-interface PluginItem {
-  name: string
-  applyOrder?: ApplyOrder.Pre | ApplyOrder.Post
-  ctor: PluginCtor
-}
-interface PluginsMap {
-  [key: string]: boolean
-}
-interface PropertyConfig {
-  key: string
-  sourceKey: string
-}
-
-type ElementParam = HTMLElement | string
-
-export interface MountedBScrollHTMLElement extends HTMLElement {
-  isBScrollContainer?: boolean
-}
-
-export class BScrollConstructor<O = {}> extends EventEmitter {
-  static plugins: PluginItem[] = []
-  static pluginsMap: PluginsMap = {}
-  scroller: Scroller
-  options: OptionsConstructor
-  hooks: EventEmitter
-  plugins: { [name: string]: any }
-  wrapper: HTMLElement
-  content: HTMLElement;
-  [key: string]: any
-
-  static use(ctor: PluginCtor) {
-    const name = ctor.pluginName
-    const installed = BScrollConstructor.plugins.some(
-      plugin => ctor === plugin.ctor
-    )
-    if (installed) return BScrollConstructor
-    if (isUndef(name)) {
-      warn(
-        `Plugin Class must specify plugin's name in static property by 'pluginName' field.`
-      )
-      return BScrollConstructor
-    }
-    BScrollConstructor.pluginsMap[name] = true
-    BScrollConstructor.plugins.push({
-      name,
-      applyOrder: ctor.applyOrder,
-      ctor
-    })
-    return BScrollConstructor
-  }
-
-  constructor(el: ElementParam, options?: Options & O) {
-    super([
-      'refresh',
-      'contentChanged',
-      'enable',
-      'disable',
-      'beforeScrollStart',
-      'scrollStart',
-      'scroll',
-      'scrollEnd',
-      'scrollCancel',
-      'touchEnd',
-      'flick',
-      'destroy'
-    ])
-
-    const wrapper = getElement(el)
-
-    if (!wrapper) {
-      warn('Can not resolve the wrapper DOM.')
-      return
-    }
-
-    this.plugins = {}
-    this.options = new OptionsConstructor().merge(options).process()
-
-    if (!this.setContent(wrapper).valid) {
-      return
-    }
-
-    this.hooks = new EventEmitter([
-      'refresh',
-      'enable',
-      'disable',
-      'destroy',
-      'beforeInitialScrollTo',
-      'contentChanged'
-    ])
-    this.init(wrapper)
-  }
-
-  setContent(wrapper: MountedBScrollHTMLElement) {
-    let contentChanged = false
-    let valid = true
-    const content = wrapper.children[
-      this.options.specifiedIndexAsContent
-    ] as HTMLElement
-    if (!content) {
-      warn(
-        'The wrapper need at least one child element to be content element to scroll.'
-      )
-      valid = false
-    } else {
-      contentChanged = this.content !== content
-      if (contentChanged) {
-        this.content = content
-      }
-    }
-    return {
-      valid,
-      contentChanged
-    }
-  }
-
-  private init(wrapper: MountedBScrollHTMLElement) {
-    this.wrapper = wrapper
-
-    // mark wrapper to recognize bs instance by DOM attribute
-    wrapper.isBScrollContainer = true
-    this.scroller = new Scroller(wrapper, this.content, this.options)
-    this.scroller.hooks.on(this.scroller.hooks.eventTypes.resize, () => {
-      this.refresh()
-    })
-
-    this.eventBubbling()
-    this.handleAutoBlur()
-    this.enable()
-
-    this.proxy(propertiesConfig)
-    this.applyPlugins()
-
-    // maybe boundary has changed, should refresh
-    this.refreshWithoutReset(this.content)
-    const { startX, startY } = this.options
-    const position = {
-      x: startX,
-      y: startY
-    }
-    // maybe plugins want to control scroll position
-    if (
-      this.hooks.trigger(this.hooks.eventTypes.beforeInitialScrollTo, position)
-    ) {
-      return
-    }
-    this.scroller.scrollTo(position.x, position.y)
-  }
-
-  private applyPlugins() {
-    const options = this.options
-    BScrollConstructor.plugins
-      .sort((a, b) => {
-        const applyOrderMap = {
-          [ApplyOrder.Pre]: -1,
-          [ApplyOrder.Post]: 1
-        }
-        const aOrder = a.applyOrder ? applyOrderMap[a.applyOrder] : 0
-        const bOrder = b.applyOrder ? applyOrderMap[b.applyOrder] : 0
-        return aOrder - bOrder
-      })
-      .forEach((item: PluginItem) => {
-        const ctor = item.ctor
-        if (options[item.name] && typeof ctor === 'function') {
-          this.plugins[item.name] = new ctor(this)
-        }
-      })
-  }
-
-  private handleAutoBlur() {
-    /* istanbul ignore if  */
-    if (this.options.autoBlur) {
-      this.on(this.eventTypes.beforeScrollStart, () => {
-        let activeElement = document.activeElement as HTMLElement
-        if (
-          activeElement &&
-          (activeElement.tagName === 'INPUT' ||
-            activeElement.tagName === 'TEXTAREA')
-        ) {
-          activeElement.blur()
-        }
-      })
-    }
-  }
-
-  private eventBubbling() {
-    bubbling(this.scroller.hooks, this, [
-      this.eventTypes.beforeScrollStart,
-      this.eventTypes.scrollStart,
-      this.eventTypes.scroll,
-      this.eventTypes.scrollEnd,
-      this.eventTypes.scrollCancel,
-      this.eventTypes.touchEnd,
-      this.eventTypes.flick
-    ])
-  }
-
-  private refreshWithoutReset(content: HTMLElement) {
-    this.scroller.refresh(content)
-    this.hooks.trigger(this.hooks.eventTypes.refresh, content)
-    this.trigger(this.eventTypes.refresh, content)
-  }
-
-  proxy(propertiesConfig: PropertyConfig[]) {
-    propertiesConfig.forEach(({ key, sourceKey }) => {
-      propertiesProxy(this, sourceKey, key)
-    })
-  }
-  refresh() {
-    const { contentChanged, valid } = this.setContent(this.wrapper)
-    if (valid) {
-      const content = this.content
-      this.refreshWithoutReset(content)
-      if (contentChanged) {
-        this.hooks.trigger(this.hooks.eventTypes.contentChanged, content)
-        this.trigger(this.eventTypes.contentChanged, content)
-      }
-      this.scroller.resetPosition()
-    }
-  }
-
-  enable() {
-    this.scroller.enable()
-    this.hooks.trigger(this.hooks.eventTypes.enable)
-    this.trigger(this.eventTypes.enable)
-  }
-
-  disable() {
-    this.scroller.disable()
-    this.hooks.trigger(this.hooks.eventTypes.disable)
-    this.trigger(this.eventTypes.disable)
-  }
-
-  destroy() {
-    this.hooks.trigger(this.hooks.eventTypes.destroy)
-    this.trigger(this.eventTypes.destroy)
-    this.scroller.destroy()
-  }
-  eventRegister(names: string[]) {
-    this.registerType(names)
-  }
-}
-
-export interface BScrollConstructor extends BScrollInstance {}
-
-export interface CustomAPI {
-  [key: string]: {}
-}
-
-type ExtractAPI<O> = {
-  [K in keyof O]: K extends string
-    ? DefOptions[K] extends undefined
-      ? CustomAPI[K]
-      : never
-    : never
-}[keyof O]
-
-export function createBScroll<O = {}>(
-  el: ElementParam,
-  options?: Options & O
-): BScrollConstructor & UnionToIntersection<ExtractAPI<O>> {
-  const bs = new BScrollConstructor(el, options)
-  return (bs as unknown) as BScrollConstructor &
-    UnionToIntersection<ExtractAPI<O>>
-}
-
-createBScroll.use = BScrollConstructor.use
-createBScroll.plugins = BScrollConstructor.plugins
-createBScroll.pluginsMap = BScrollConstructor.pluginsMap
-
-type createBScroll = typeof createBScroll
-export interface BScrollFactory extends createBScroll {
-  new <O = {}>(el: ElementParam, options?: Options & O): BScrollConstructor &
-    UnionToIntersection<ExtractAPI<O>>
-}
-
-export type BScroll<O = Options> = BScrollConstructor<O> &
-  UnionToIntersection<ExtractAPI<O>>
-
-export const BScroll = (createBScroll as unknown) as BScrollFactory

package/better-scroll-dev/better-scroll-dev/packages/core/src/Instance.ts

@@ -1,114 +0,0 @@
-import { Behavior } from './scroller/Behavior'
-import Actions from './scroller/Actions'
-import { ExposedAPI as ExposedAPIByScroller } from './scroller/Scroller'
-import { Animater } from './animater'
-import { ExposedAPI as ExposedAPIByAnimater } from './animater/Base'
-
-export interface BScrollInstance
-  extends ExposedAPIByScroller,
-    ExposedAPIByAnimater {
-  [key: string]: any
-  x: Behavior['currentPos']
-  y: Behavior['currentPos']
-  hasHorizontalScroll: Behavior['hasScroll']
-  hasVerticalScroll: Behavior['hasScroll']
-  scrollerWidth: Behavior['contentSize']
-  scrollerHeight: Behavior['contentSize']
-  maxScrollX: Behavior['maxScrollPos']
-  maxScrollY: Behavior['maxScrollPos']
-  minScrollX: Behavior['minScrollPos']
-  minScrollY: Behavior['minScrollPos']
-  movingDirectionX: Behavior['movingDirection']
-  movingDirectionY: Behavior['movingDirection']
-  directionX: Behavior['direction']
-  directionY: Behavior['direction']
-  enabled: Actions['enabled']
-  pending: Animater['pending']
-}
-
-export const propertiesConfig = [
-  {
-    sourceKey: 'scroller.scrollBehaviorX.currentPos',
-    key: 'x'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.currentPos',
-    key: 'y'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.hasScroll',
-    key: 'hasHorizontalScroll'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.hasScroll',
-    key: 'hasVerticalScroll'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.contentSize',
-    key: 'scrollerWidth'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.contentSize',
-    key: 'scrollerHeight'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.maxScrollPos',
-    key: 'maxScrollX'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.maxScrollPos',
-    key: 'maxScrollY'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.minScrollPos',
-    key: 'minScrollX'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.minScrollPos',
-    key: 'minScrollY'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.movingDirection',
-    key: 'movingDirectionX'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.movingDirection',
-    key: 'movingDirectionY'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorX.direction',
-    key: 'directionX'
-  },
-  {
-    sourceKey: 'scroller.scrollBehaviorY.direction',
-    key: 'directionY'
-  },
-  {
-    sourceKey: 'scroller.actions.enabled',
-    key: 'enabled'
-  },
-  {
-    sourceKey: 'scroller.animater.pending',
-    key: 'pending'
-  },
-  {
-    sourceKey: 'scroller.animater.stop',
-    key: 'stop'
-  },
-  {
-    sourceKey: 'scroller.scrollTo',
-    key: 'scrollTo'
-  },
-  {
-    sourceKey: 'scroller.scrollBy',
-    key: 'scrollBy'
-  },
-  {
-    sourceKey: 'scroller.scrollToElement',
-    key: 'scrollToElement'
-  },
-  {
-    sourceKey: 'scroller.resetPosition',
-    key: 'resetPosition'
-  }
-]