kdu-router 2.7.0 → 3.1.3

package/src/history/base.js

@@ -1,328 +0,0 @@
-/* @flow */
-
-import { _Kdu } from '../install'
-import type Router from '../index'
-import { inBrowser } from '../util/dom'
-import { runQueue } from '../util/async'
-import { warn, isError } from '../util/warn'
-import { START, isSameRoute } from '../util/route'
-import {
-  flatten,
-  flatMapComponents,
-  resolveAsyncComponents
-} from '../util/resolve-components'
-
-export class History {
-  router: Router;
-  base: string;
-  current: Route;
-  pending: ?Route;
-  cb: (r: Route) => void;
-  ready: boolean;
-  readyCbs: Array<Function>;
-  readyErrorCbs: Array<Function>;
-  errorCbs: Array<Function>;
-
-  // implemented by sub-classes
-  +go: (n: number) => void;
-  +push: (loc: RawLocation) => void;
-  +replace: (loc: RawLocation) => void;
-  +ensureURL: (push?: boolean) => void;
-  +getCurrentLocation: () => string;
-
-  constructor (router: Router, base: ?string) {
-    this.router = router
-    this.base = normalizeBase(base)
-    // start with a route object that stands for "nowhere"
-    this.current = START
-    this.pending = null
-    this.ready = false
-    this.readyCbs = []
-    this.readyErrorCbs = []
-    this.errorCbs = []
-  }
-
-  listen (cb: Function) {
-    this.cb = cb
-  }
-
-  onReady (cb: Function, errorCb: ?Function) {
-    if (this.ready) {
-      cb()
-    } else {
-      this.readyCbs.push(cb)
-      if (errorCb) {
-        this.readyErrorCbs.push(errorCb)
-      }
-    }
-  }
-
-  onError (errorCb: Function) {
-    this.errorCbs.push(errorCb)
-  }
-
-  transitionTo (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    const route = this.router.match(location, this.current)
-    this.confirmTransition(route, () => {
-      this.updateRoute(route)
-      onComplete && onComplete(route)
-      this.ensureURL()
-
-      // fire ready cbs once
-      if (!this.ready) {
-        this.ready = true
-        this.readyCbs.forEach(cb => { cb(route) })
-      }
-    }, err => {
-      if (onAbort) {
-        onAbort(err)
-      }
-      if (err && !this.ready) {
-        this.ready = true
-        this.readyErrorCbs.forEach(cb => { cb(err) })
-      }
-    })
-  }
-
-  confirmTransition (route: Route, onComplete: Function, onAbort?: Function) {
-    const current = this.current
-    const abort = err => {
-      if (isError(err)) {
-        if (this.errorCbs.length) {
-          this.errorCbs.forEach(cb => { cb(err) })
-        } else {
-          warn(false, 'uncaught error during route navigation:')
-          console.error(err)
-        }
-      }
-      onAbort && onAbort(err)
-    }
-    if (
-      isSameRoute(route, current) &&
-      // in the case the route map has been dynamically appended to
-      route.matched.length === current.matched.length
-    ) {
-      this.ensureURL()
-      return abort()
-    }
-
-    const {
-      updated,
-      deactivated,
-      activated
-    } = resolveQueue(this.current.matched, route.matched)
-
-    const queue: Array<?NavigationGuard> = [].concat(
-      // in-component leave guards
-      extractLeaveGuards(deactivated),
-      // global before hooks
-      this.router.beforeHooks,
-      // in-component update hooks
-      extractUpdateHooks(updated),
-      // in-config enter guards
-      activated.map(m => m.beforeEnter),
-      // async components
-      resolveAsyncComponents(activated)
-    )
-
-    this.pending = route
-    const iterator = (hook: NavigationGuard, next) => {
-      if (this.pending !== route) {
-        return abort()
-      }
-      try {
-        hook(route, current, (to: any) => {
-          if (to === false || isError(to)) {
-            // next(false) -> abort navigation, ensure current URL
-            this.ensureURL(true)
-            abort(to)
-          } else if (
-            typeof to === 'string' ||
-            (typeof to === 'object' && (
-              typeof to.path === 'string' ||
-              typeof to.name === 'string'
-            ))
-          ) {
-            // next('/') or next({ path: '/' }) -> redirect
-            abort()
-            if (typeof to === 'object' && to.replace) {
-              this.replace(to)
-            } else {
-              this.push(to)
-            }
-          } else {
-            // confirm transition and pass on the value
-            next(to)
-          }
-        })
-      } catch (e) {
-        abort(e)
-      }
-    }
-
-    runQueue(queue, iterator, () => {
-      const postEnterCbs = []
-      const isValid = () => this.current === route
-      // wait until async components are resolved before
-      // extracting in-component enter guards
-      const enterGuards = extractEnterGuards(activated, postEnterCbs, isValid)
-      const queue = enterGuards.concat(this.router.resolveHooks)
-      runQueue(queue, iterator, () => {
-        if (this.pending !== route) {
-          return abort()
-        }
-        this.pending = null
-        onComplete(route)
-        if (this.router.app) {
-          this.router.app.$nextTick(() => {
-            postEnterCbs.forEach(cb => { cb() })
-          })
-        }
-      })
-    })
-  }
-
-  updateRoute (route: Route) {
-    const prev = this.current
-    this.current = route
-    this.cb && this.cb(route)
-    this.router.afterHooks.forEach(hook => {
-      hook && hook(route, prev)
-    })
-  }
-}
-
-function normalizeBase (base: ?string): string {
-  if (!base) {
-    if (inBrowser) {
-      // respect <base> tag
-      const baseEl = document.querySelector('base')
-      base = (baseEl && baseEl.getAttribute('href')) || '/'
-      // strip full URL origin
-      base = base.replace(/^https?:\/\/[^\/]+/, '')
-    } else {
-      base = '/'
-    }
-  }
-  // make sure there's the starting slash
-  if (base.charAt(0) !== '/') {
-    base = '/' + base
-  }
-  // remove trailing slash
-  return base.replace(/\/$/, '')
-}
-
-function resolveQueue (
-  current: Array<RouteRecord>,
-  next: Array<RouteRecord>
-): {
-  updated: Array<RouteRecord>,
-  activated: Array<RouteRecord>,
-  deactivated: Array<RouteRecord>
-} {
-  let i
-  const max = Math.max(current.length, next.length)
-  for (i = 0; i < max; i++) {
-    if (current[i] !== next[i]) {
-      break
-    }
-  }
-  return {
-    updated: next.slice(0, i),
-    activated: next.slice(i),
-    deactivated: current.slice(i)
-  }
-}
-
-function extractGuards (
-  records: Array<RouteRecord>,
-  name: string,
-  bind: Function,
-  reverse?: boolean
-): Array<?Function> {
-  const guards = flatMapComponents(records, (def, instance, match, key) => {
-    const guard = extractGuard(def, name)
-    if (guard) {
-      return Array.isArray(guard)
-        ? guard.map(guard => bind(guard, instance, match, key))
-        : bind(guard, instance, match, key)
-    }
-  })
-  return flatten(reverse ? guards.reverse() : guards)
-}
-
-function extractGuard (
-  def: Object | Function,
-  key: string
-): NavigationGuard | Array<NavigationGuard> {
-  if (typeof def !== 'function') {
-    // extend now so that global mixins are applied.
-    def = _Kdu.extend(def)
-  }
-  return def.options[key]
-}
-
-function extractLeaveGuards (deactivated: Array<RouteRecord>): Array<?Function> {
-  return extractGuards(deactivated, 'beforeRouteLeave', bindGuard, true)
-}
-
-function extractUpdateHooks (updated: Array<RouteRecord>): Array<?Function> {
-  return extractGuards(updated, 'beforeRouteUpdate', bindGuard)
-}
-
-function bindGuard (guard: NavigationGuard, instance: ?_Kdu): ?NavigationGuard {
-  if (instance) {
-    return function boundRouteGuard () {
-      return guard.apply(instance, arguments)
-    }
-  }
-}
-
-function extractEnterGuards (
-  activated: Array<RouteRecord>,
-  cbs: Array<Function>,
-  isValid: () => boolean
-): Array<?Function> {
-  return extractGuards(activated, 'beforeRouteEnter', (guard, _, match, key) => {
-    return bindEnterGuard(guard, match, key, cbs, isValid)
-  })
-}
-
-function bindEnterGuard (
-  guard: NavigationGuard,
-  match: RouteRecord,
-  key: string,
-  cbs: Array<Function>,
-  isValid: () => boolean
-): NavigationGuard {
-  return function routeEnterGuard (to, from, next) {
-    return guard(to, from, cb => {
-      next(cb)
-      if (typeof cb === 'function') {
-        cbs.push(() => {
-          // #750
-          // if a router-view is wrapped with an out-in transition,
-          // the instance may not have been registered at this time.
-          // we will need to poll for registration until current route
-          // is no longer valid.
-          poll(cb, match.instances, key, isValid)
-        })
-      }
-    })
-  }
-}
-
-function poll (
-  cb: any, // somehow flow cannot infer this is a function
-  instances: Object,
-  key: string,
-  isValid: () => boolean
-) {
-  if (instances[key]) {
-    cb(instances[key])
-  } else if (isValid()) {
-    setTimeout(() => {
-      poll(cb, instances, key, isValid)
-    }, 16)
-  }
-}

package/src/history/hash.js

@@ -1,97 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { History } from './base'
-import { cleanPath } from '../util/path'
-import { getLocation } from './html5'
-
-export class HashHistory extends History {
-  constructor (router: Router, base: ?string, fallback: boolean) {
-    super(router, base)
-    // check history fallback deeplinking
-    if (fallback && checkFallback(this.base)) {
-      return
-    }
-    ensureSlash()
-  }
-
-  // this is delayed until the app mounts
-  // to avoid the hashchange listener being fired too early
-  setupListeners () {
-    window.addEventListener('hashchange', () => {
-      if (!ensureSlash()) {
-        return
-      }
-      this.transitionTo(getHash(), route => {
-        replaceHash(route.fullPath)
-      })
-    })
-  }
-
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    this.transitionTo(location, route => {
-      pushHash(route.fullPath)
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  replace (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    this.transitionTo(location, route => {
-      replaceHash(route.fullPath)
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  go (n: number) {
-    window.history.go(n)
-  }
-
-  ensureURL (push?: boolean) {
-    const current = this.current.fullPath
-    if (getHash() !== current) {
-      push ? pushHash(current) : replaceHash(current)
-    }
-  }
-
-  getCurrentLocation () {
-    return getHash()
-  }
-}
-
-function checkFallback (base) {
-  const location = getLocation(base)
-  if (!/^\/#/.test(location)) {
-    window.location.replace(
-      cleanPath(base + '/#' + location)
-    )
-    return true
-  }
-}
-
-function ensureSlash (): boolean {
-  const path = getHash()
-  if (path.charAt(0) === '/') {
-    return true
-  }
-  replaceHash('/' + path)
-  return false
-}
-
-export function getHash (): string {
-  // We can't use window.location.hash here because it's not
-  // consistent across browsers - Firefox will pre-decode it!
-  const href = window.location.href
-  const index = href.indexOf('#')
-  return index === -1 ? '' : href.slice(index + 1)
-}
-
-function pushHash (path) {
-  window.location.hash = path
-}
-
-function replaceHash (path) {
-  const href = window.location.href
-  const i = href.indexOf('#')
-  const base = i >= 0 ? href.slice(0, i) : href
-  window.location.replace(`${base}#${path}`)
-}

package/src/history/html5.js

@@ -1,69 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { History } from './base'
-import { cleanPath } from '../util/path'
-import { setupScroll, handleScroll } from '../util/scroll'
-import { pushState, replaceState } from '../util/push-state'
-
-export class HTML5History extends History {
-  constructor (router: Router, base: ?string) {
-    super(router, base)
-
-    const expectScroll = router.options.scrollBehavior
-
-    if (expectScroll) {
-      setupScroll()
-    }
-
-    window.addEventListener('popstate', e => {
-      const current = this.current
-      this.transitionTo(getLocation(this.base), route => {
-        if (expectScroll) {
-          handleScroll(router, route, current, true)
-        }
-      })
-    })
-  }
-
-  go (n: number) {
-    window.history.go(n)
-  }
-
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    const { current: fromRoute } = this
-    this.transitionTo(location, route => {
-      pushState(cleanPath(this.base + route.fullPath))
-      handleScroll(this.router, route, fromRoute, false)
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  replace (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    const { current: fromRoute } = this
-    this.transitionTo(location, route => {
-      replaceState(cleanPath(this.base + route.fullPath))
-      handleScroll(this.router, route, fromRoute, false)
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  ensureURL (push?: boolean) {
-    if (getLocation(this.base) !== this.current.fullPath) {
-      const current = cleanPath(this.base + this.current.fullPath)
-      push ? pushState(current) : replaceState(current)
-    }
-  }
-
-  getCurrentLocation (): string {
-    return getLocation(this.base)
-  }
-}
-
-export function getLocation (base: string): string {
-  let path = window.location.pathname
-  if (base && path.indexOf(base) === 0) {
-    path = path.slice(base.length)
-  }
-  return (path || '/') + window.location.search + window.location.hash
-}

package/src/util/async.js

@@ -1,18 +0,0 @@
-/* @flow */
-
-export function runQueue (queue: Array<?NavigationGuard>, fn: Function, cb: Function) {
-  const step = index => {
-    if (index >= queue.length) {
-      cb()
-    } else {
-      if (queue[index]) {
-        fn(queue[index], () => {
-          step(index + 1)
-        })
-      } else {
-        step(index + 1)
-      }
-    }
-  }
-  step(0)
-}

package/src/util/dom.js

@@ -1,3 +0,0 @@
-/* @flow */
-
-export const inBrowser = typeof window !== 'undefined'

package/src/util/location.js

@@ -1,68 +0,0 @@
-/* @flow */
-
-import type KduRouter from '../index'
-import { parsePath, resolvePath } from './path'
-import { resolveQuery } from './query'
-import { fillParams } from './params'
-import { warn } from './warn'
-
-export function normalizeLocation (
-  raw: RawLocation,
-  current: ?Route,
-  append: ?boolean,
-  router: ?KduRouter
-): Location {
-  let next: Location = typeof raw === 'string' ? { path: raw } : raw
-  // named target
-  if (next.name || next._normalized) {
-    return next
-  }
-
-  // relative params
-  if (!next.path && next.params && current) {
-    next = assign({}, next)
-    next._normalized = true
-    const params: any = assign(assign({}, current.params), next.params)
-    if (current.name) {
-      next.name = current.name
-      next.params = params
-    } else if (current.matched.length) {
-      const rawPath = current.matched[current.matched.length - 1].path
-      next.path = fillParams(rawPath, params, `path ${current.path}`)
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(false, `relative params navigation requires a current route.`)
-    }
-    return next
-  }
-
-  const parsedPath = parsePath(next.path || '')
-  const basePath = (current && current.path) || '/'
-  const path = parsedPath.path
-    ? resolvePath(parsedPath.path, basePath, append || next.append)
-    : basePath
-
-  const query = resolveQuery(
-    parsedPath.query,
-    next.query,
-    router && router.options.parseQuery
-  )
-
-  let hash = next.hash || parsedPath.hash
-  if (hash && hash.charAt(0) !== '#') {
-    hash = `#${hash}`
-  }
-
-  return {
-    _normalized: true,
-    path,
-    query,
-    hash
-  }
-}
-
-function assign (a, b) {
-  for (const key in b) {
-    a[key] = b[key]
-  }
-  return a
-}

package/src/util/params.js

@@ -1,26 +0,0 @@
-/* @flow */
-
-import { warn } from './warn'
-import Regexp from 'path-to-regexp'
-
-const regexpCompileCache: {
-  [key: string]: Function
-} = Object.create(null)
-
-export function fillParams (
-  path: string,
-  params: ?Object,
-  routeMsg: string
-): string {
-  try {
-    const filler =
-      regexpCompileCache[path] ||
-      (regexpCompileCache[path] = Regexp.compile(path))
-    return filler(params || {}, { pretty: true })
-  } catch (e) {
-    if (process.env.NODE_ENV !== 'production') {
-      warn(false, `missing param for ${routeMsg}: ${e.message}`)
-    }
-    return ''
-  }
-}

package/src/util/path.js

@@ -1,74 +0,0 @@
-/* @flow */
-
-export function resolvePath (
-  relative: string,
-  base: string,
-  append?: boolean
-): string {
-  const firstChar = relative.charAt(0)
-  if (firstChar === '/') {
-    return relative
-  }
-
-  if (firstChar === '?' || firstChar === '#') {
-    return base + relative
-  }
-
-  const stack = base.split('/')
-
-  // remove trailing segment if:
-  // - not appending
-  // - appending to trailing slash (last segment is empty)
-  if (!append || !stack[stack.length - 1]) {
-    stack.pop()
-  }
-
-  // resolve relative path
-  const segments = relative.replace(/^\//, '').split('/')
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]
-    if (segment === '..') {
-      stack.pop()
-    } else if (segment !== '.') {
-      stack.push(segment)
-    }
-  }
-
-  // ensure leading slash
-  if (stack[0] !== '') {
-    stack.unshift('')
-  }
-
-  return stack.join('/')
-}
-
-export function parsePath (path: string): {
-  path: string;
-  query: string;
-  hash: string;
-} {
-  let hash = ''
-  let query = ''
-
-  const hashIndex = path.indexOf('#')
-  if (hashIndex >= 0) {
-    hash = path.slice(hashIndex)
-    path = path.slice(0, hashIndex)
-  }
-
-  const queryIndex = path.indexOf('?')
-  if (queryIndex >= 0) {
-    query = path.slice(queryIndex + 1)
-    path = path.slice(0, queryIndex)
-  }
-
-  return {
-    path,
-    query,
-    hash
-  }
-}
-
-export function cleanPath (path: string): string {
-  return path.replace(/\/\//g, '/')
-}