cbvirtua 1.0.106 → 1.0.107

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

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

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

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

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

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

@@ -0,0 +1,114 @@
+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'
+  }
+]