cbvirtua 1.0.105 → 1.0.107

package/better-scroll-dev/better-scroll-dev/scripts/build.js

@@ -0,0 +1,262 @@
+const fs = require('fs')
+const path = require('path')
+const inquirer = require('inquirer')
+const rollup = require('rollup')
+const chalk = require('chalk')
+const zlib = require('zlib')
+const rimraf = require('rimraf')
+const typescript = require('rollup-plugin-typescript2')
+const uglify = require('rollup-plugin-uglify').uglify
+const execa = require('execa')
+const ora = require('ora')
+const spinner = ora({
+  prefixText: `${chalk.green('\n[building tasks]')}`
+})
+
+function getPackagesName () {
+  let ret
+  let all = fs.readdirSync(resolve('packages'))
+  // drop hidden file whose name is startWidth '.'
+  // drop packages which would not be published(eg: examples and docs)
+  ret = all
+        .filter(name => {
+          const isHiddenFile = /^\./g.test(name)
+          return !isHiddenFile
+        }).filter(name => {
+          const isPrivatePackages = require(resolve(`packages/${name}/package.json`)).private
+          return !isPrivatePackages
+        })
+
+  return ret
+}
+
+function cleanPackagesOldDist(packagesName) {
+  packagesName.forEach(name => {
+    const distPath = resolve(`packages/${name}/dist`)
+    const typePath = resolve(`packages/${name}/dist/types`)
+
+    if (fs.existsSync(distPath)) {
+      rimraf.sync(distPath)
+    }
+
+    fs.mkdirSync(distPath)
+    fs.mkdirSync(typePath)
+  })
+}
+
+function resolve(p) {
+  return path.resolve(__dirname, '../', p)
+}
+
+function PascalCase(str){
+  const re=/-(\w)/g;
+  const newStr = str.replace(re, function (match, group1){
+      return group1.toUpperCase();
+  })
+  return newStr.charAt(0).toUpperCase() + newStr.slice(1);
+}
+
+const generateBanner = (packageName) => {
+  let ret =
+  '/*!\n' +
+  ' * better-scroll / ' + packageName + '\n' +
+  ' * (c) 2016-' + new Date().getFullYear() + ' ustbhuangyi\n' +
+  ' * Released under the MIT License.\n' +
+  ' */'
+  return ret
+}
+
+
+
+const buildType = [
+  {
+    format: 'umd',
+    ext: '.js'
+  },
+  {
+    format: 'umd',
+    ext: '.min.js'
+  },
+  {
+    format: 'es',
+    ext: '.esm.js'
+  }
+]
+
+function generateBuildConfigs(packagesName) {
+  const result = []
+  packagesName.forEach(name => {
+    buildType.forEach((type) => {
+      let config = {
+        input: resolve(`packages/${name}/src/index.ts`),
+        output: {
+          file: resolve(`packages/${name}/dist/${name}${type.ext}`),
+          name: PascalCase(name),
+          format: type.format,
+          banner: generateBanner(name)
+        },
+        plugins: generateBuildPluginsConfigs(type.ext.indexOf('min')>-1, name)
+      }
+      // rename
+      if (name === 'core' && config.output.format !== 'es') {
+        config.output.name = 'BScroll'
+        /** Disable warning for default imports */
+        config.output.exports = 'named'
+        // it seems the umd bundle can not satisfies our demand
+        config.output.footer = 'if(typeof window !== "undefined" && window.BScroll) { \n' +
+                              '  window.BScroll = window.BScroll.default;\n}'
+      }
+      // rollup will valiate config properties of config own and output a warning.
+      // put packageName in prototype to ignore warning.
+      Object.defineProperties(config, {
+        'packageName': {
+          value: name
+        },
+        'ext': {
+          value: type.ext
+        }
+      })
+      result.push(config)
+    })
+  })
+  return result
+}
+function generateBuildPluginsConfigs(isMin) {
+  const tsConfig = {
+    verbosity: -1,
+    tsconfig: path.resolve(__dirname, '../tsconfig.json'),
+  }
+  const plugins = []
+    if (isMin) {
+      plugins.push(uglify())
+    }
+  plugins.push(typescript(tsConfig))
+  return plugins
+}
+
+function build(builds) {
+  let built = 0
+  const total = builds.length
+  const next = () => {
+    buildEntry(builds[built], built + 1, () => {
+      builds[built-1] = null
+      built++
+      if (built < total) {
+        next()
+      }
+    })
+  }
+  next()
+}
+
+function buildEntry(config, curIndex, next) {
+  const isProd = /min\.js$/.test(config.output.file)
+
+  spinner.start(`${config.packageName}${config.ext} is buiding now. \n`)
+
+  rollup.rollup(config).then((bundle) => {
+    bundle.write(config.output).then(({ output }) => {
+      const code = output[0].code
+
+      spinner.succeed(`${config.packageName}${config.ext} building has ended.`)
+
+      function report(extra) {
+        console.log(chalk.magenta(path.relative(process.cwd(), config.output.file)) + ' ' + getSize(code) + (extra || ''))
+        next()
+      }
+      if (isProd) {
+        zlib.gzip(code, (err, zipped) => {
+          if (err) return reject(err)
+          let words =  `(gzipped: ${chalk.magenta(getSize(zipped))})`
+          report(words)
+        })
+      } else {
+        report()
+      }
+
+      // since we need bundle code for three types
+      // just generate .d.ts only once
+      if (curIndex % 3 === 0) {
+        copyDTSFiles(config.packageName)
+      }
+    })
+  }).catch((e) => {
+    spinner.fail('buiding is failed')
+    console.log(e)
+  })
+}
+
+function copyDTSFiles (packageName) {
+  console.log(chalk.cyan('> start copying .d.ts file to dist dir of packages own.'))
+  const sourceDir = resolve(`packages/${packageName}/dist/packages/${packageName}/src/*`)
+  const targetDir = resolve(`packages/${packageName}/dist/types/`)
+  execa.commandSync(`mv ${sourceDir} ${targetDir}`, { shell: true })
+  console.log(chalk.cyan('> copy job is done.'))
+  rimraf.sync(resolve(`packages/${packageName}/dist/packages`))
+  rimraf.sync(resolve(`packages/${packageName}/dist/node_modules`))
+}
+
+function getSize(code) {
+  return (code.length / 1024).toFixed(2) + 'kb'
+}
+
+const getAnswersFromInquirer = async (packagesName) => {
+  const question = {
+    type: 'checkbox',
+    name: 'packages',
+    scroll: false,
+    message: 'Select build repo(Support Multiple selection)',
+    choices: packagesName.map(name => ({
+      value: name,
+      name
+    }))
+  }
+  let { packages } = await inquirer.prompt(question)
+  // make no choice
+  if (!packages.length) {
+    console.log(chalk.yellow(`
+      It seems that you did't make a choice.
+
+      Please try it again.
+    `))
+    return
+  }
+
+  // chose 'all' option
+  if (packages.some(package => package === 'all')) {
+    packages = getPackagesName()
+  }
+  const { yes } = await inquirer.prompt([{
+    name: 'yes',
+    message: `Confirm build ${packages.join(' and ')} packages?`,
+    type: 'list',
+    choices: ['Y', 'N']
+  }])
+
+  if (yes === 'N') {
+    console.log(chalk.yellow('[release] cancelled.'))
+    return
+  }
+
+  return packages
+}
+const buildBootstrap = async () => {
+  const packagesName = getPackagesName()
+  // provide 'all' option
+  packagesName.unshift('all')
+
+  const answers = await getAnswersFromInquirer(packagesName)
+
+  if (!answers) return
+
+  cleanPackagesOldDist(answers)
+
+  const buildConfigs = generateBuildConfigs(answers)
+
+  build(buildConfigs)
+
+}
+buildBootstrap().catch(err => {
+  console.error(err)
+  process.exit(1)
+})

package/better-scroll-dev/better-scroll-dev/scripts/checkYarn.js

@@ -0,0 +1,6 @@
+if (!/yarn\.js$/.test(process.env.npm_execpath || '')) {
+  console.warn(
+    '\u001b[33mThis repository requires Yarn 1.x for scripts to work properly.\u001b[39m\n'
+  )
+  process.exit(1)
+}

package/better-scroll-dev/better-scroll-dev/scripts/release.js

@@ -0,0 +1,104 @@
+const execa = require('execa')
+const semver = require('semver')
+const inquirer = require('inquirer')
+const chalk = require('chalk')
+
+const curVersion = require('../lerna.json').version
+
+const release = async () => {
+  console.log(chalk.yellow(`Current version: ${curVersion}`))
+
+  const bumps = ['patch', 'minor', 'major', 'prerelease-alpha', 'prerelease-beta', 'premajor']
+  const versions = {}
+  bumps.forEach(b => {
+    const args = b.split('-')
+    versions[b] = semver.inc(curVersion, ...args)
+  })
+  const bumpChoices = bumps.map(b => ({ name: `${b} (${versions[b]})`, value: b }))
+
+  function getVersion (answers) {
+    return answers.customVersion || versions[answers.bump]
+  }
+
+  function getNpmTags (version) {
+    if (isPreRelease(version)) {
+      return ['next']
+    }
+    return ['latest', 'next']
+  }
+
+  function isPreRelease (version) {
+    return !!semver.prerelease(version)
+  }
+
+  const { bump, customVersion, npmTag } = await inquirer.prompt([
+    {
+      name: 'bump',
+      message: 'Select release type:',
+      type: 'list',
+      choices: [
+        ...bumpChoices,
+        { name: 'custom', value: 'custom' }
+      ]
+    },
+    {
+      name: 'customVersion',
+      message: 'Input version:',
+      type: 'input',
+      when: answers => answers.bump === 'custom'
+    },
+    {
+      name: 'npmTag',
+      message: 'Input npm tag:',
+      type: 'list',
+      choices: answers => getNpmTags(getVersion(answers))
+    }
+  ])
+
+  const version = customVersion || versions[bump]
+
+  const { yes } = await inquirer.prompt([{
+    name: 'yes',
+    message: `Confirm releasing ${version} (${npmTag})?`,
+    type: 'list',
+    choices: ['Y', 'N']
+  }])
+
+  if (yes === 'N') {
+    console.log(chalk.red('[release] cancelled.'))
+    return
+  }
+
+  const releaseArguments = [
+    'publish',
+    version,
+    '--force-publish',
+    '*',
+    '--npm-tag',
+    npmTag
+  ]
+
+  console.log(chalk.grey(`lerna ${releaseArguments.join(' ')}`))
+
+  await execa(require.resolve('lerna/cli'), releaseArguments, { stdio: 'inherit' })
+
+  // it seems that sometimes 'gitHead' property in packages/**/package.json will change
+  // but sometimes it won't, at this condition. work tree is clean, 'git commit ' will cause en error
+  // so put it in try/catch, because we want to sync dev from master
+  try {
+    await execa('git', ['add', '-A'], { stdio: 'inherit' })
+    await execa('git', ['commit', '-m', `chore: ${version} published`], { stdio: 'inherit' })
+    await execa('git', ['push', 'origin', `master`], { stdio: 'inherit' })
+  } catch (error) {}
+
+  // sync dev from master
+  await execa('git', ['checkout', 'dev'], { stdio: 'inherit' })
+  await execa('git', ['rebase', 'master'], { stdio: 'inherit' })
+  await execa('git', ['push', 'origin', 'dev'], { stdio: 'inherit' })
+  await execa('git', ['checkout', 'master'], { stdio: 'inherit' })
+}
+
+release().catch(err => {
+  console.error(err)
+  process.exit(1)
+})

package/better-scroll-dev/better-scroll-dev/test-dts/core.test-d.ts

@@ -0,0 +1,41 @@
+import {
+  BScroll,
+  expectFuncArguments,
+  expectFuncReturnValue,
+  Options
+} from './index'
+import { EaseItem } from '@better-scroll/shared-utils/src'
+
+describe('core api parameter type should be correct', () => {
+  type ExtraTransform = { start: object; end: object }
+  expectFuncArguments<[], BScroll['refresh']>()
+  expectFuncArguments<
+    [number, number, number?, EaseItem?, ExtraTransform?],
+    BScroll['scrollTo']
+  >()
+  expectFuncArguments<
+    [number, number, number?, EaseItem?],
+    BScroll['scrollBy']
+  >()
+  expectFuncArguments<
+    [
+      string | HTMLElement,
+      number,
+      number | boolean,
+      number | boolean,
+      EaseItem?
+    ],
+    BScroll['scrollToElement']
+  >()
+  expectFuncArguments<[], BScroll['stop']>()
+  expectFuncArguments<[], BScroll['enable']>()
+  expectFuncArguments<[], BScroll['disable']>()
+  expectFuncArguments<[], BScroll['destroy']>()
+  // Events API
+  expectFuncArguments<[string, Function, Object?], BScroll['on']>()
+  expectFuncArguments<[string, Function, Object?], BScroll['once']>()
+  expectFuncArguments<[string?, Function?], BScroll['off']>()
+  expectFuncReturnValue<BScroll<Options>, BScroll['on']>()
+  expectFuncReturnValue<BScroll<Options>, BScroll['once']>()
+  expectFuncReturnValue<BScroll<Options> | undefined, BScroll['off']>()
+})

package/better-scroll-dev/better-scroll-dev/test-dts/index.d.ts

@@ -0,0 +1,64 @@
+import BScroll from '@better-scroll/core'
+import Zoom from '@better-scroll/zoom'
+import Wheel from '@better-scroll/wheel'
+import Slide from '@better-scroll/slide'
+import ScrollBar from '@better-scroll/scroll-bar'
+import PullUp from '@better-scroll/pull-up'
+import PullDown from '@better-scroll/pull-down'
+import ObserveDom from '@better-scroll/observe-dom'
+import NestedScroll from '@better-scroll/nested-scroll'
+import MouseWheel from '@better-scroll/mouse-wheel'
+import Infinity from '@better-scroll/infinity'
+import Movable from '@better-scroll/movable'
+import { IfEquals } from './util'
+
+export * from '@better-scroll/core'
+export * from '@better-scroll/zoom'
+export * from '@better-scroll/wheel'
+export * from '@better-scroll/slide'
+export * from '@better-scroll/scroll-bar'
+export * from '@better-scroll/pull-up'
+export * from '@better-scroll/pull-down'
+export * from '@better-scroll/observe-dom'
+export * from '@better-scroll/nested-scroll'
+export * from '@better-scroll/mouse-wheel'
+export * from '@better-scroll/infinity'
+export * from '@better-scroll/movable'
+
+export type ArgumentsCheck<
+  T extends any[],
+  U extends (...args: any[]) => any
+> = (
+  ...args: any[]
+) => U extends (...args: infer P) => any
+  ? IfEquals<T, P, ReturnType<U>, T>
+  : never
+export type ReturnValueCheck<T, U extends (...args: any[]) => any> = (
+  ...args: any[]
+) => U extends (...args: any[]) => infer P ? IfEquals<T, P, P, T> : never
+export declare function expectType<T, T1 extends IfEquals<T, T1, T, T>>(): void
+export declare function expectError<T>(value: T): void
+export declare function expectAssignable<T1 extends T, T>(): void
+export declare function expectFuncArguments<
+  T extends any[],
+  T1 extends ArgumentsCheck<T, T1>
+>(): void
+export declare function expectFuncReturnValue<
+  T,
+  T1 extends ReturnValueCheck<T, T1>
+>(): void
+
+export {
+  BScroll,
+  Zoom,
+  Wheel,
+  Slide,
+  ScrollBar,
+  PullUp,
+  PullDown,
+  ObserveDom,
+  NestedScroll,
+  MouseWheel,
+  Infinity,
+  Movable
+}