kdu-router 2.7.0 → 3.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kdu-router",
-  "version": "2.7.0",
-  "description": "Official router for Kdu",
+  "version": "3.0.0",
+  "description": "Official router for Kdu.js 2",
   "author": "NKDuy",
   "license": "MIT",
   "main": "dist/kdu-router.common.js",
@@ -9,11 +9,10 @@
   "unpkg": "dist/kdu-router.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/khanhduy1407/kdu-router.git"
+    "url": "https://github.com/kdujs/kdu-router.git"
   },
   "typings": "types/index.d.ts",
   "files": [
-    "src",
     "dist/*.js",
     "types/*.d.ts"
   ],
@@ -23,57 +22,43 @@
     "routing"
   ],
   "scripts": {
-    "dev": "node examples/server.js",
-    "dev:dist": "rollup -wm -c build/dev.config.js",
+    "dev:dist": "rollup -wm -c build/rollup.dev.config.js",
     "build": "node build/build.js",
-    "lint": "eslint src examples",
-    "test": "npm run lint && flow check && npm run test:unit && npm run test:e2e && npm run test:types",
-    "test:unit": "jasmine JASMINE_CONFIG_PATH=test/unit/jasmine.json",
-    "test:e2e": "node test/e2e/runner.js",
-    "test:types": "tsc -p types/test",
-    "docs": "cd docs && gitbook install && gitbook serve",
-    "docs:deploy": "bash ./build/update-docs.sh",
+    "lint": "eslint src",
     "release": "bash build/release.sh"
   },
   "devDependencies": {
     "babel-core": "^6.24.1",
-    "babel-eslint": "^7.2.3",
+    "babel-eslint": "^8.0.1",
     "babel-loader": "^7.0.0",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
     "babel-preset-es2015": "^6.24.1",
     "babel-preset-flow-kdu": "^1.0.0",
-    "buble": "^0.15.2",
-    "chromedriver": "^2.21.2",
+    "buble": "^0.16.0",
+    "chromedriver": "^2.33.1",
     "cross-spawn": "^5.0.1",
     "css-loader": "^0.28.0",
     "es6-promise": "^4.0.5",
-    "eslint": "^3.0.1",
+    "eslint": "^3.19.0",
     "eslint-plugin-flowtype": "^2.34.0",
-    "eslint-plugin-kdu-libs": "^1.0.0",
-    "express": "^4.14.0",
+    "eslint-plugin-kdu-libs": "^1.2.1",
+    "express": "^4.16.2",
     "express-urlrewrite": "^1.2.0",
-    "flow-bin": "^0.48.0",
-    "gitbook-plugin-edit-link": "^2.0.2",
-    "gitbook-plugin-github": "^3.0.0",
-    "jasmine": "2.6.0",
-    "nightwatch": "^0.9.5",
-    "nightwatch-helpers": "^1.0.0",
-    "path-to-regexp": "^1.5.3",
-    "phantomjs-prebuilt": "^2.1.14",
-    "rollup": "^0.43.0",
-    "rollup-plugin-buble": "^0.15.0",
-    "rollup-plugin-commonjs": "^8.0.2",
+    "flow-bin": "^0.56.0",
+    "jasmine": "2.8.0",
+    "kdu": "^2.5.0",
+    "path-to-regexp": "^1.7.0",
+    "rollup": "^0.50.0",
+    "rollup-plugin-buble": "^0.16.0",
+    "rollup-plugin-commonjs": "^8.2.1",
     "rollup-plugin-flow-no-whitespace": "^1.0.0",
     "rollup-plugin-node-resolve": "^3.0.0",
-    "rollup-plugin-replace": "^1.1.1",
+    "rollup-plugin-replace": "^2.0.0",
     "rollup-watch": "^4.0.0",
     "selenium-server": "^2.53.1",
-    "typescript": "^2.0.3",
-    "uglify-js": "^3.0.17",
-    "kdu": "^2.5.13",
-    "kdu-loader": "^13.5.0",
-    "kdu-template-compiler": "^2.5.13",
-    "webpack": "^2.4.1",
+    "typescript": "^2.5.3",
+    "uglify-js": "^3.1.3",
+    "webpack": "^3.7.1",
     "webpack-dev-middleware": "^1.9.0"
   }
 }

package/types/index.d.ts

@@ -1,21 +1,16 @@
 import "./kdu";
-import * as R from "./router";
+import { KduRouter } from "./router";
 
-// `KduRouter` in `export = KduRouter` must be a namespace
-// All available types are exported via this namespace
-declare namespace KduRouter {
-  export type RouterMode = R.RouterMode;
-  export type RawLocation = R.RawLocation;
-  export type RedirectOption = R.RedirectOption;
-  export type RouterOptions = R.RouterOptions;
-  export type RouteConfig = R.RouteConfig;
-  export type RouteRecord = R.RouteRecord;
-  export type Location = R.Location;
-  export type Route = R.Route;
-  export type NavigationGuard = R.NavigationGuard;
-}
+export default KduRouter;
 
-// TS cannot merge imported class with namespace, declare a subclass to bypass
-declare class KduRouter extends R.KduRouter {}
-
-export = KduRouter;
+export {
+  RouterMode,
+  RawLocation,
+  RedirectOption,
+  RouterOptions,
+  RouteConfig,
+  RouteRecord,
+  Location,
+  Route,
+  NavigationGuard
+} from "./router";

package/types/kdu.d.ts

@@ -2,9 +2,8 @@
  * Augment the typings of Kdu.js
  */
 
-import Kdu = require("types/kdu");
-import KduRouter = require("./index");
-import { Route, RawLocation, NavigationGuard } from "./index";
+import Kdu from "kdu";
+import KduRouter, { Route, RawLocation, NavigationGuard } from "./index";
 
 declare module "kdu/types/kdu" {
   interface Kdu {

package/types/router.d.ts

@@ -1,7 +1,6 @@
-import Kdu = require("types/kdu");
-import { ComponentOptions, PluginFunction } from "types/kdu";
+import Kdu, { ComponentOptions, PluginFunction, AsyncComponent } from "kdu";
 
-type Component = ComponentOptions<Kdu> | typeof Kdu;
+type Component = ComponentOptions<Kdu> | typeof Kdu | AsyncComponent;
 type Dictionary<T> = { [key: string]: T };
 
 export type RouterMode = "hash" | "history" | "abstract";
@@ -13,7 +12,7 @@ export type NavigationGuard = (
   next: (to?: RawLocation | false | ((vm: Kdu) => any) | void) => void
 ) => any
 
-declare class KduRouter {
+export declare class KduRouter {
   constructor (options?: RouterOptions);
 
   app: Kdu;
@@ -45,6 +44,7 @@ declare class KduRouter {
 }
 
 type Position = { x: number, y: number };
+type PositionResult = Position | { selector: string, offset?: Position } | void;
 
 export interface RouterOptions {
   routes?: RouteConfig[];
@@ -59,7 +59,7 @@ export interface RouterOptions {
     to: Route,
     from: Route,
     savedPosition: Position | void
-  ) => Position | { selector: string, offset?: Position } | void;
+  ) => PositionResult | Promise<PositionResult>;
 }
 
 type RoutePropsFunction = (route: Route) => Object;

package/src/components/link.js

@@ -1,138 +0,0 @@
-/* @flow */
-
-import { createRoute, isSameRoute, isIncludedRoute } from '../util/route'
-import { _Kdu } from '../install'
-
-// work around weird flow bug
-const toTypes: Array<Function> = [String, Object]
-const eventTypes: Array<Function> = [String, Array]
-
-export default {
-  name: 'router-link',
-  props: {
-    to: {
-      type: toTypes,
-      required: true
-    },
-    tag: {
-      type: String,
-      default: 'a'
-    },
-    exact: Boolean,
-    append: Boolean,
-    replace: Boolean,
-    activeClass: String,
-    exactActiveClass: String,
-    event: {
-      type: eventTypes,
-      default: 'click'
-    }
-  },
-  render (h: Function) {
-    const router = this.$router
-    const current = this.$route
-    const { location, route, href } = router.resolve(this.to, current, this.append)
-
-    const classes = {}
-    const globalActiveClass = router.options.linkActiveClass
-    const globalExactActiveClass = router.options.linkExactActiveClass
-    // Support global empty active class
-    const activeClassFallback = globalActiveClass == null
-            ? 'router-link-active'
-            : globalActiveClass
-    const exactActiveClassFallback = globalExactActiveClass == null
-            ? 'router-link-exact-active'
-            : globalExactActiveClass
-    const activeClass = this.activeClass == null
-            ? activeClassFallback
-            : this.activeClass
-    const exactActiveClass = this.exactActiveClass == null
-            ? exactActiveClassFallback
-            : this.exactActiveClass
-    const compareTarget = location.path
-      ? createRoute(null, location, null, router)
-      : route
-
-    classes[exactActiveClass] = isSameRoute(current, compareTarget)
-    classes[activeClass] = this.exact
-      ? classes[exactActiveClass]
-      : isIncludedRoute(current, compareTarget)
-
-    const handler = e => {
-      if (guardEvent(e)) {
-        if (this.replace) {
-          router.replace(location)
-        } else {
-          router.push(location)
-        }
-      }
-    }
-
-    const on = { click: guardEvent }
-    if (Array.isArray(this.event)) {
-      this.event.forEach(e => { on[e] = handler })
-    } else {
-      on[this.event] = handler
-    }
-
-    const data: any = {
-      class: classes
-    }
-
-    if (this.tag === 'a') {
-      data.on = on
-      data.attrs = { href }
-    } else {
-      // find the first <a> child and apply listener and href
-      const a = findAnchor(this.$slots.default)
-      if (a) {
-        // in case the <a> is a static node
-        a.isStatic = false
-        const extend = _Kdu.util.extend
-        const aData = a.data = extend({}, a.data)
-        aData.on = on
-        const aAttrs = a.data.attrs = extend({}, a.data.attrs)
-        aAttrs.href = href
-      } else {
-        // doesn't have <a> child, apply listener to self
-        data.on = on
-      }
-    }
-
-    return h(this.tag, data, this.$slots.default)
-  }
-}
-
-function guardEvent (e) {
-  // don't redirect with control keys
-  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return
-  // don't redirect when preventDefault called
-  if (e.defaultPrevented) return
-  // don't redirect on right click
-  if (e.button !== undefined && e.button !== 0) return
-  // don't redirect if `target="_blank"`
-  if (e.currentTarget && e.currentTarget.getAttribute) {
-    const target = e.currentTarget.getAttribute('target')
-    if (/\b_blank\b/i.test(target)) return
-  }
-  // this may be a Weex event which doesn't have this method
-  if (e.preventDefault) {
-    e.preventDefault()
-  }
-  return true
-}
-
-function findAnchor (children) {
-  if (children) {
-    let child
-    for (let i = 0; i < children.length; i++) {
-      child = children[i]
-      if (child.tag === 'a') {
-        return child
-      }
-      if (child.children && (child = findAnchor(child.children))) {
-        return child
-      }
-    }
-  }
-}

package/src/components/view.js

@@ -1,96 +0,0 @@
-import { warn } from '../util/warn'
-
-export default {
-  name: 'router-view',
-  functional: true,
-  props: {
-    name: {
-      type: String,
-      default: 'default'
-    }
-  },
-  render (_, { props, children, parent, data }) {
-    data.routerView = true
-
-    // directly use parent context's createElement() function
-    // so that components rendered by router-view can resolve named slots
-    const h = parent.$createElement
-    const name = props.name
-    const route = parent.$route
-    const cache = parent._routerViewCache || (parent._routerViewCache = {})
-
-    // determine current view depth, also check to see if the tree
-    // has been toggled inactive but kept-alive.
-    let depth = 0
-    let inactive = false
-    while (parent && parent._routerRoot !== parent) {
-      if (parent.$vnode && parent.$vnode.data.routerView) {
-        depth++
-      }
-      if (parent._inactive) {
-        inactive = true
-      }
-      parent = parent.$parent
-    }
-    data.routerViewDepth = depth
-
-    // render previous view if the tree is inactive and kept-alive
-    if (inactive) {
-      return h(cache[name], data, children)
-    }
-
-    const matched = route.matched[depth]
-    // render empty node if no matched route
-    if (!matched) {
-      cache[name] = null
-      return h()
-    }
-
-    const component = cache[name] = matched.components[name]
-
-    // attach instance registration hook
-    // this will be called in the instance's injected lifecycle hooks
-    data.registerRouteInstance = (vm, val) => {
-      // val could be undefined for unregistration
-      const current = matched.instances[name]
-      if (
-        (val && current !== vm) ||
-        (!val && current === vm)
-      ) {
-        matched.instances[name] = val
-      }
-    }
-
-    // also regiseter instance in prepatch hook
-    // in case the same component instance is reused across different routes
-    ;(data.hook || (data.hook = {})).prepatch = (_, vnode) => {
-      matched.instances[name] = vnode.componentInstance
-    }
-
-    // resolve props
-    data.props = resolveProps(route, matched.props && matched.props[name])
-
-    return h(component, data, children)
-  }
-}
-
-function resolveProps (route, config) {
-  switch (typeof config) {
-    case 'undefined':
-      return
-    case 'object':
-      return config
-    case 'function':
-      return config(route)
-    case 'boolean':
-      return config ? route.params : undefined
-    default:
-      if (process.env.NODE_ENV !== 'production') {
-        warn(
-          false,
-          `props in "${route.path}" is a ${typeof config}, ` +
-          `expecting an object, function or boolean.`
-        )
-      }
-  }
-}

package/src/create-matcher.js

@@ -1,201 +0,0 @@
-/* @flow */
-
-import type KduRouter from './index'
-import { resolvePath } from './util/path'
-import { assert, warn } from './util/warn'
-import { createRoute } from './util/route'
-import { fillParams } from './util/params'
-import { createRouteMap } from './create-route-map'
-import { normalizeLocation } from './util/location'
-
-export type Matcher = {
-  match: (raw: RawLocation, current?: Route, redirectedFrom?: Location) => Route;
-  addRoutes: (routes: Array<RouteConfig>) => void;
-};
-
-export function createMatcher (
-  routes: Array<RouteConfig>,
-  router: KduRouter
-): Matcher {
-  const { pathList, pathMap, nameMap } = createRouteMap(routes)
-
-  function addRoutes (routes) {
-    createRouteMap(routes, pathList, pathMap, nameMap)
-  }
-
-  function match (
-    raw: RawLocation,
-    currentRoute?: Route,
-    redirectedFrom?: Location
-  ): Route {
-    const location = normalizeLocation(raw, currentRoute, false, router)
-    const { name } = location
-
-    if (name) {
-      const record = nameMap[name]
-      if (process.env.NODE_ENV !== 'production') {
-        warn(record, `Route with name '${name}' does not exist`)
-      }
-      if (!record) return _createRoute(null, location)
-      const paramNames = record.regex.keys
-        .filter(key => !key.optional)
-        .map(key => key.name)
-
-      if (typeof location.params !== 'object') {
-        location.params = {}
-      }
-
-      if (currentRoute && typeof currentRoute.params === 'object') {
-        for (const key in currentRoute.params) {
-          if (!(key in location.params) && paramNames.indexOf(key) > -1) {
-            location.params[key] = currentRoute.params[key]
-          }
-        }
-      }
-
-      if (record) {
-        location.path = fillParams(record.path, location.params, `named route "${name}"`)
-        return _createRoute(record, location, redirectedFrom)
-      }
-    } else if (location.path) {
-      location.params = {}
-      for (let i = 0; i < pathList.length; i++) {
-        const path = pathList[i]
-        const record = pathMap[path]
-        if (matchRoute(record.regex, location.path, location.params)) {
-          return _createRoute(record, location, redirectedFrom)
-        }
-      }
-    }
-    // no match
-    return _createRoute(null, location)
-  }
-
-  function redirect (
-    record: RouteRecord,
-    location: Location
-  ): Route {
-    const originalRedirect = record.redirect
-    let redirect = typeof originalRedirect === 'function'
-        ? originalRedirect(createRoute(record, location, null, router))
-        : originalRedirect
-
-    if (typeof redirect === 'string') {
-      redirect = { path: redirect }
-    }
-
-    if (!redirect || typeof redirect !== 'object') {
-      if (process.env.NODE_ENV !== 'production') {
-        warn(
-          false, `invalid redirect option: ${JSON.stringify(redirect)}`
-        )
-      }
-      return _createRoute(null, location)
-    }
-
-    const re: Object = redirect
-    const { name, path } = re
-    let { query, hash, params } = location
-    query = re.hasOwnProperty('query') ? re.query : query
-    hash = re.hasOwnProperty('hash') ? re.hash : hash
-    params = re.hasOwnProperty('params') ? re.params : params
-
-    if (name) {
-      // resolved named direct
-      const targetRecord = nameMap[name]
-      if (process.env.NODE_ENV !== 'production') {
-        assert(targetRecord, `redirect failed: named route "${name}" not found.`)
-      }
-      return match({
-        _normalized: true,
-        name,
-        query,
-        hash,
-        params
-      }, undefined, location)
-    } else if (path) {
-      // 1. resolve relative redirect
-      const rawPath = resolveRecordPath(path, record)
-      // 2. resolve params
-      const resolvedPath = fillParams(rawPath, params, `redirect route with path "${rawPath}"`)
-      // 3. rematch with existing query and hash
-      return match({
-        _normalized: true,
-        path: resolvedPath,
-        query,
-        hash
-      }, undefined, location)
-    } else {
-      if (process.env.NODE_ENV !== 'production') {
-        warn(false, `invalid redirect option: ${JSON.stringify(redirect)}`)
-      }
-      return _createRoute(null, location)
-    }
-  }
-
-  function alias (
-    record: RouteRecord,
-    location: Location,
-    matchAs: string
-  ): Route {
-    const aliasedPath = fillParams(matchAs, location.params, `aliased route with path "${matchAs}"`)
-    const aliasedMatch = match({
-      _normalized: true,
-      path: aliasedPath
-    })
-    if (aliasedMatch) {
-      const matched = aliasedMatch.matched
-      const aliasedRecord = matched[matched.length - 1]
-      location.params = aliasedMatch.params
-      return _createRoute(aliasedRecord, location)
-    }
-    return _createRoute(null, location)
-  }
-
-  function _createRoute (
-    record: ?RouteRecord,
-    location: Location,
-    redirectedFrom?: Location
-  ): Route {
-    if (record && record.redirect) {
-      return redirect(record, redirectedFrom || location)
-    }
-    if (record && record.matchAs) {
-      return alias(record, location, record.matchAs)
-    }
-    return createRoute(record, location, redirectedFrom, router)
-  }
-
-  return {
-    match,
-    addRoutes
-  }
-}
-
-function matchRoute (
-  regex: RouteRegExp,
-  path: string,
-  params: Object
-): boolean {
-  const m = path.match(regex)
-
-  if (!m) {
-    return false
-  } else if (!params) {
-    return true
-  }
-
-  for (let i = 1, len = m.length; i < len; ++i) {
-    const key = regex.keys[i - 1]
-    const val = typeof m[i] === 'string' ? decodeURIComponent(m[i]) : m[i]
-    if (key) {
-      params[key.name] = val
-    }
-  }
-
-  return true
-}
-
-function resolveRecordPath (path: string, record: RouteRecord): string {
-  return resolvePath(path, record.parent ? record.parent.path : '/', true)
-}