kdu-router 3.0.1 → 3.0.7

package/package.json

@@ -1,18 +1,21 @@
 {
   "name": "kdu-router",
-  "version": "3.0.1",
+  "version": "3.0.7",
   "description": "Official router for Kdu.js 2",
   "author": "NKDuy",
   "license": "MIT",
   "main": "dist/kdu-router.common.js",
   "module": "dist/kdu-router.esm.js",
   "unpkg": "dist/kdu-router.js",
+  "jsdelivr": "dist/kdu-router.js",
+  "sideEffects": false,
   "repository": {
     "type": "git",
     "url": "https://github.com/kdujs/kdu-router.git"
   },
   "typings": "types/index.d.ts",
   "files": [
+    "src/*.js",
     "dist/*.js",
     "types/*.d.ts"
   ],
@@ -25,40 +28,54 @@
     "dev:dist": "rollup -wm -c build/rollup.dev.config.js",
     "build": "node build/build.js",
     "lint": "eslint src",
-    "release": "bash build/release.sh"
+    "release": "bash scripts/release.sh"
+  },
+  "gitHooks": {
+    "commit-msg": "node scripts/verifyCommitMsg.js"
   },
   "devDependencies": {
+    "axios": "^0.19.0",
     "babel-core": "^6.24.1",
-    "babel-eslint": "^8.0.1",
-    "babel-loader": "^7.0.0",
+    "babel-eslint": "^10.0.2",
+    "babel-loader": "^7.1.3",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
-    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-env": "^1.6.1",
     "babel-preset-flow-kdu": "^1.0.0",
-    "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.19.0",
-    "eslint-plugin-flowtype": "^2.34.0",
-    "eslint-plugin-kdu-libs": "^1.2.1",
-    "express": "^4.16.2",
+    "browserstack-local": "^1.4.0",
+    "buble": "^0.19.8",
+    "chromedriver": "^74.0.0",
+    "conventional-changelog-cli": "^2.0.11",
+    "cross-spawn": "^6.0.5",
+    "css-loader": "^2.1.1",
+    "dotenv": "^8.0.0",
+    "es6-promise": "^4.2.8",
+    "eslint": "^4.19.1",
+    "eslint-plugin-flowtype": "^2.46.1",
+    "eslint-plugin-kdu-libs": "^2.1.0",
+    "express": "^4.17.1",
     "express-urlrewrite": "^1.2.0",
-    "flow-bin": "^0.56.0",
+    "flow-bin": "^0.66.0",
+    "geckodriver": "^1.16.2",
     "jasmine": "2.8.0",
-    "kdu": "^2.5.0",
+    "kdu": "^2.5.24",
+    "lint-staged": "^8.2.0",
     "path-to-regexp": "^1.7.0",
-    "rollup": "^0.50.0",
-    "rollup-plugin-buble": "^0.16.0",
-    "rollup-plugin-commonjs": "^8.2.1",
+    "rollup": "^0.56.4",
+    "rollup-plugin-buble": "^0.19.8",
+    "rollup-plugin-commonjs": "^9.0.0",
     "rollup-plugin-flow-no-whitespace": "^1.0.0",
-    "rollup-plugin-node-resolve": "^3.0.0",
+    "rollup-plugin-node-resolve": "^3.0.3",
     "rollup-plugin-replace": "^2.0.0",
     "rollup-watch": "^4.0.0",
-    "selenium-server": "^2.53.1",
-    "typescript": "^2.5.3",
-    "uglify-js": "^3.1.3",
-    "webpack": "^3.7.1",
-    "webpack-dev-middleware": "^1.9.0"
-  }
+    "selenium-server": "^3.141.59",
+    "terser": "^4.0.2",
+    "typescript": "^3.5.2",
+    "webpack": "^4.35.2",
+    "webpack-dev-middleware": "^3.7.0",
+    "yorkie": "^2.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/kdujs/kdu-router/issues"
+  },
+  "homepage": "https://github.com/kdujs/kdu-router#readme"
 }

package/src/create-matcher.js

@@ -0,0 +1,200 @@
+/* @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]
+          }
+        }
+      }
+
+      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) {
+      // Fix #1994: using * with props: true generates a param named 0
+      params[key.name || 'pathMatch'] = val
+    }
+  }
+
+  return true
+}
+
+function resolveRecordPath (path: string, record: RouteRecord): string {
+  return resolvePath(path, record.parent ? record.parent.path : '/', true)
+}

package/src/create-route-map.js

@@ -0,0 +1,171 @@
+/* @flow */
+
+import Regexp from 'path-to-regexp'
+import { cleanPath } from './util/path'
+import { assert, warn } from './util/warn'
+
+export function createRouteMap (
+  routes: Array<RouteConfig>,
+  oldPathList?: Array<string>,
+  oldPathMap?: Dictionary<RouteRecord>,
+  oldNameMap?: Dictionary<RouteRecord>
+): {
+  pathList: Array<string>;
+  pathMap: Dictionary<RouteRecord>;
+  nameMap: Dictionary<RouteRecord>;
+} {
+  // the path list is used to control path matching priority
+  const pathList: Array<string> = oldPathList || []
+  // $flow-disable-line
+  const pathMap: Dictionary<RouteRecord> = oldPathMap || Object.create(null)
+  // $flow-disable-line
+  const nameMap: Dictionary<RouteRecord> = oldNameMap || Object.create(null)
+
+  routes.forEach(route => {
+    addRouteRecord(pathList, pathMap, nameMap, route)
+  })
+
+  // ensure wildcard routes are always at the end
+  for (let i = 0, l = pathList.length; i < l; i++) {
+    if (pathList[i] === '*') {
+      pathList.push(pathList.splice(i, 1)[0])
+      l--
+      i--
+    }
+  }
+
+  return {
+    pathList,
+    pathMap,
+    nameMap
+  }
+}
+
+function addRouteRecord (
+  pathList: Array<string>,
+  pathMap: Dictionary<RouteRecord>,
+  nameMap: Dictionary<RouteRecord>,
+  route: RouteConfig,
+  parent?: RouteRecord,
+  matchAs?: string
+) {
+  const { path, name } = route
+  if (process.env.NODE_ENV !== 'production') {
+    assert(path != null, `"path" is required in a route configuration.`)
+    assert(
+      typeof route.component !== 'string',
+      `route config "component" for path: ${String(path || name)} cannot be a ` +
+      `string id. Use an actual component instead.`
+    )
+  }
+
+  const pathToRegexpOptions: PathToRegexpOptions = route.pathToRegexpOptions || {}
+  const normalizedPath = normalizePath(
+    path,
+    parent,
+    pathToRegexpOptions.strict
+  )
+
+  if (typeof route.caseSensitive === 'boolean') {
+    pathToRegexpOptions.sensitive = route.caseSensitive
+  }
+
+  const record: RouteRecord = {
+    path: normalizedPath,
+    regex: compileRouteRegex(normalizedPath, pathToRegexpOptions),
+    components: route.components || { default: route.component },
+    instances: {},
+    name,
+    parent,
+    matchAs,
+    redirect: route.redirect,
+    beforeEnter: route.beforeEnter,
+    meta: route.meta || {},
+    props: route.props == null
+      ? {}
+      : route.components
+        ? route.props
+        : { default: route.props }
+  }
+
+  if (route.children) {
+    // Warn if route is named, does not redirect and has a default child route.
+    // If users navigate to this route by name, the default child will
+    // not be rendered (GH Issue #629)
+    if (process.env.NODE_ENV !== 'production') {
+      if (route.name && !route.redirect && route.children.some(child => /^\/?$/.test(child.path))) {
+        warn(
+          false,
+          `Named Route '${route.name}' has a default child route. ` +
+          `When navigating to this named route (:to="{name: '${route.name}'"), ` +
+          `the default child route will not be rendered. Remove the name from ` +
+          `this route and use the name of the default child route for named ` +
+          `links instead.`
+        )
+      }
+    }
+    route.children.forEach(child => {
+      const childMatchAs = matchAs
+        ? cleanPath(`${matchAs}/${child.path}`)
+        : undefined
+      addRouteRecord(pathList, pathMap, nameMap, child, record, childMatchAs)
+    })
+  }
+
+  if (route.alias !== undefined) {
+    const aliases = Array.isArray(route.alias)
+      ? route.alias
+      : [route.alias]
+
+    aliases.forEach(alias => {
+      const aliasRoute = {
+        path: alias,
+        children: route.children
+      }
+      addRouteRecord(
+        pathList,
+        pathMap,
+        nameMap,
+        aliasRoute,
+        parent,
+        record.path || '/' // matchAs
+      )
+    })
+  }
+
+  if (!pathMap[record.path]) {
+    pathList.push(record.path)
+    pathMap[record.path] = record
+  }
+
+  if (name) {
+    if (!nameMap[name]) {
+      nameMap[name] = record
+    } else if (process.env.NODE_ENV !== 'production' && !matchAs) {
+      warn(
+        false,
+        `Duplicate named routes definition: ` +
+        `{ name: "${name}", path: "${record.path}" }`
+      )
+    }
+  }
+}
+
+function compileRouteRegex (path: string, pathToRegexpOptions: PathToRegexpOptions): RouteRegExp {
+  const regex = Regexp(path, [], pathToRegexpOptions)
+  if (process.env.NODE_ENV !== 'production') {
+    const keys: any = Object.create(null)
+    regex.keys.forEach(key => {
+      warn(!keys[key.name], `Duplicate param keys in route with path: "${path}"`)
+      keys[key.name] = true
+    })
+  }
+  return regex
+}
+
+function normalizePath (path: string, parent?: RouteRecord, strict?: boolean): string {
+  if (!strict) path = path.replace(/\/$/, '')
+  if (path[0] === '/') return path
+  if (parent == null) return path
+  return cleanPath(`${parent.path}/${path}`)
+}