more es6 (wip)

Author: yyx990803

src/directives/view.js

@@ -1,22 +1,22 @@
-module.exports = function (Vue) {
+import { warn } from '../util'
 
-  var _ = Vue.util
-  var util = require('../util')
-  var componentDef = Vue.directive('_component')
+export default function (Vue) {
 
+  let _ = Vue.util
+  let componentDef = Vue.directive('_component')
   // <router-view> extends the internal component directive
-  var viewDef = _.extend({}, componentDef)
+  let viewDef = _.extend({}, componentDef)
 
   // with some overrides
   _.extend(viewDef, {
 
     _isRouterView: true,
 
     bind: function () {
-      var route = this.vm.$route
+      let route = this.vm.$route
       /* istanbul ignore if */
       if (!route) {
-        util.warn(
+        warn(
           '<router-view> can only be used inside a ' +
           'router-enabled app.'
         )
@@ -31,17 +31,17 @@ module.exports = function (Vue) {
       /* istanbul ignore if */
       if (this.keepAlive) {
         this.keepAlive = false
-        util.warn('<router-view> does not support keep-alive.')
+        warn('<router-view> does not support keep-alive.')
       }
 
       // all we need to do here is registering this view
       // in the router. actual component switching will be
       // managed by the pipeline.
-      var router = this.router = route._router
+      let router = this.router = route._router
       router._views.unshift(this)
 
       // note the views are in reverse order.
-      var parentView = router._views[1]
+      let parentView = router._views[1]
       if (parentView) {
         // register self as a child of the parent view,
         // instead of activating now. This is so that the

src/history/hash.js

@@ -1,54 +1,55 @@
-var util = require('../util')
+import { resolvePath } from '../util'
 
-function HashHistory (options) {
-  this.hashbang = options.hashbang
-  this.onChange = options.onChange
-}
+export default class HashHistory {
+
+  constructor (options) {
+    this.hashbang = options.hashbang
+    this.onChange = options.onChange
+  }
 
-HashHistory.prototype.start = function () {
-  var self = this
-  this.listener = function () {
-    var path = location.hash
-    var formattedPath = self.formatPath(path, true)
-    if (formattedPath !== path) {
-      location.replace(formattedPath)
-      return
+  start () {
+    let self = this
+    this.listener = function () {
+      let path = location.hash
+      let formattedPath = self.formatPath(path, true)
+      if (formattedPath !== path) {
+        location.replace(formattedPath)
+        return
+      }
+      let pathToMatch = decodeURI(
+        path.replace(/^#!?/, '') + location.search
+      )
+      self.onChange(pathToMatch)
     }
-    var pathToMatch = decodeURI(
-      path.replace(/^#!?/, '') + location.search
-    )
-    self.onChange(pathToMatch)
+    window.addEventListener('hashchange', this.listener)
+    this.listener()
   }
-  window.addEventListener('hashchange', this.listener)
-  this.listener()
-}
 
-HashHistory.prototype.stop = function () {
-  window.removeEventListener('hashchange', this.listener)
-}
+  stop () {
+    window.removeEventListener('hashchange', this.listener)
+  }
 
-HashHistory.prototype.go = function (path, replace) {
-  path = this.formatPath(path)
-  if (replace) {
-    location.replace(path)
-  } else {
-    location.hash = path
+  go (path, replace) {
+    path = this.formatPath(path)
+    if (replace) {
+      location.replace(path)
+    } else {
+      location.hash = path
+    }
   }
-}
 
-HashHistory.prototype.formatPath = function (path, expectAbsolute) {
-  path = path.replace(/^#!?/, '')
-  var isAbsoloute = path.charAt(0) === '/'
-  if (expectAbsolute && !isAbsoloute) {
-    path = '/' + path
+  formatPath (path, expectAbsolute) {
+    path = path.replace(/^#!?/, '')
+    let isAbsoloute = path.charAt(0) === '/'
+    if (expectAbsolute && !isAbsoloute) {
+      path = '/' + path
+    }
+    let prefix = '#' + (this.hashbang ? '!' : '')
+    return isAbsoloute || expectAbsolute
+      ? prefix + path
+      : prefix + resolvePath(
+          location.hash.replace(/^#!?/, ''),
+          path
+        )
   }
-  var prefix = '#' + (this.hashbang ? '!' : '')
-  return isAbsoloute || expectAbsolute
-    ? prefix + path
-    : prefix + util.resolvePath(
-        location.hash.replace(/^#!?/, ''),
-        path
-      )
 }
-
-module.exports = HashHistory

src/history/html5.js

@@ -1,75 +1,76 @@
-var util = require('../util')
-var hashRE = /#.*$/
+import { resolvePath } from '../util'
+const hashRE = /#.*$/
 
-function HTML5History (options) {
-  var root = options.root
-  if (root) {
-    // make sure there's the starting slash
-    if (root.charAt(0) !== '/') {
-      root = '/' + root
+export default class HTML5History {
+
+  constructor (options) {
+    let root = options.root
+    if (root) {
+      // make sure there's the starting slash
+      if (root.charAt(0) !== '/') {
+        root = '/' + root
+      }
+      // remove trailing slash
+      this.root = root.replace(/\/$/, '')
+      this.rootRE = new RegExp('^\\' + this.root)
+    } else {
+      this.root = null
     }
-    // remove trailing slash
-    this.root = root.replace(/\/$/, '')
-    this.rootRE = new RegExp('^\\' + this.root)
-  } else {
-    this.root = null
+    this.onChange = options.onChange
+    // check base tag
+    let baseEl = document.querySelector('base')
+    this.base = baseEl && baseEl.getAttribute('href')
   }
-  this.onChange = options.onChange
-  // check base tag
-  var baseEl = document.querySelector('base')
-  this.base = baseEl && baseEl.getAttribute('href')
-}
 
-HTML5History.prototype.start = function () {
-  var self = this
-  this.listener = function (e) {
-    var url = decodeURI(location.pathname + location.search)
-    if (this.root) {
-      url = url.replace(this.rootRE, '')
+  start () {
+    let self = this
+    this.listener = function (e) {
+      let url = decodeURI(location.pathname + location.search)
+      if (this.root) {
+        url = url.replace(this.rootRE, '')
+      }
+      self.onChange(url, e && e.state, location.hash)
     }
-    self.onChange(url, e && e.state, location.hash)
+    window.addEventListener('popstate', this.listener)
+    this.listener()
   }
-  window.addEventListener('popstate', this.listener)
-  this.listener()
-}
 
-HTML5History.prototype.stop = function () {
-  window.removeEventListener('popstate', this.listener)
-}
+  stop () {
+    window.removeEventListener('popstate', this.listener)
+  }
 
-HTML5History.prototype.go = function (path, replace) {
-  var root = this.root
-  var url = this.formatPath(path, root)
-  if (replace) {
-    history.replaceState({}, '', url)
-  } else {
-    // record scroll position by replacing current state
-    history.replaceState({
-      pos: {
-        x: window.pageXOffset,
-        y: window.pageYOffset
-      }
-    }, '')
-    // then push new state
-    history.pushState({}, '', url)
+  go (path, replace) {
+    let root = this.root
+    let url = this.formatPath(path, root)
+    if (replace) {
+      history.replaceState({}, '', url)
+    } else {
+      // record scroll position by replacing current state
+      history.replaceState({
+        pos: {
+          x: window.pageXOffset,
+          y: window.pageYOffset
+        }
+      }, '')
+      // then push new state
+      history.pushState({}, '', url)
+    }
+    let hashMatch = path.match(hashRE)
+    let hash = hashMatch && hashMatch[0]
+    path = url
+      // strip hash so it doesn't mess up params
+      .replace(hashRE, '')
+      // remove root before matching
+      .replace(this.rootRE, '')
+    this.onChange(path, null, hash)
   }
-  var hashMatch = path.match(hashRE)
-  var hash = hashMatch && hashMatch[0]
-  path = url
-    // strip hash so it doesn't mess up params
-    .replace(hashRE, '')
-    // remove root before matching
-    .replace(this.rootRE, '')
-  this.onChange(path, null, hash)
-}
 
-HTML5History.prototype.formatPath = function (path) {
-  return path.charAt(0) === '/'
-    // absolute path
-    ? this.root
-      ? this.root + '/' + path.replace(/^\//, '')
-      : path
-    : util.resolvePath(this.base || location.pathname, path)
+  formatPath (path) {
+    return path.charAt(0) === '/'
+      // absolute path
+      ? this.root
+        ? this.root + '/' + path.replace(/^\//, '')
+        : path
+      : resolvePath(this.base || location.pathname, path)
+  }
 }
-
-module.exports = HTML5History

src/route.js

@@ -1,4 +1,12 @@
+/**
+ * Route Context Object
+ *
+ * @param {String} path
+ * @param {Router} router
+ */
+
 export default class Route {
+
   constructor (path, router) {
     this.path = path
     let matched = router._recognizer.recognize(path)

src/router/api.js

@@ -1,13 +1,13 @@
-var routerUtil = require('../util')
+import { warn } from '../util'
 
-module.exports = function (Vue, Router) {
+export default function (Vue, Router) {
 
   /**
    * Register a map of top-level paths.
    */
 
   Router.prototype.map = function (map) {
-    for (var route in map) {
+    for (let route in map) {
       this.on(route, map[route])
     }
   }
@@ -39,7 +39,7 @@ module.exports = function (Vue, Router) {
    */
 
   Router.prototype.redirect = function (map) {
-    for (var path in map) {
+    for (let path in map) {
       this._addRedirect(path, map[path])
     }
   }
@@ -51,7 +51,7 @@ module.exports = function (Vue, Router) {
    */
 
   Router.prototype.alias = function (map) {
-    for (var path in map) {
+    for (let path in map) {
       this._addAlias(path, map[path])
     }
   }
@@ -99,7 +99,7 @@ module.exports = function (Vue, Router) {
   Router.prototype.start = function (App, container) {
     /* istanbul ignore if */
     if (this._started) {
-      routerUtil.warn('already started.')
+      warn('already started.')
       return
     }
     this._started = true