kdu-router 3.4.0-beta.0 → 4.0.0

package/src/history/hash.js

@@ -1,163 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { History } from './base'
-import { cleanPath } from '../util/path'
-import { getLocation } from './html5'
-import { setupScroll, handleScroll } from '../util/scroll'
-import { pushState, replaceState, supportsPushState } from '../util/push-state'
-
-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 () {
-    if (this.listeners.length > 0) {
-      return
-    }
-
-    const router = this.router
-    const expectScroll = router.options.scrollBehavior
-    const supportsScroll = supportsPushState && expectScroll
-
-    if (supportsScroll) {
-      this.listeners.push(setupScroll())
-    }
-
-    const handleRoutingEvent = () => {
-      const current = this.current
-      if (!ensureSlash()) {
-        return
-      }
-      this.transitionTo(getHash(), route => {
-        if (supportsScroll) {
-          handleScroll(this.router, route, current, true)
-        }
-        if (!supportsPushState) {
-          replaceHash(route.fullPath)
-        }
-      })
-    }
-    const eventType = supportsPushState ? 'popstate' : 'hashchange'
-    window.addEventListener(
-      eventType,
-      handleRoutingEvent
-    )
-    this.listeners.push(() => {
-      window.removeEventListener(eventType, handleRoutingEvent)
-    })
-  }
-
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    const { current: fromRoute } = this
-    this.transitionTo(
-      location,
-      route => {
-        pushHash(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 => {
-        replaceHash(route.fullPath)
-        handleScroll(this.router, route, fromRoute, false)
-        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!
-  let href = window.location.href
-  const index = href.indexOf('#')
-  // empty path
-  if (index < 0) return ''
-
-  href = href.slice(index + 1)
-  // decode the hash but not the search or hash
-  // as search(query) is already decoded
-  const searchIndex = href.indexOf('?')
-  if (searchIndex < 0) {
-    const hashIndex = href.indexOf('#')
-    if (hashIndex > -1) {
-      href = decodeURI(href.slice(0, hashIndex)) + href.slice(hashIndex)
-    } else href = decodeURI(href)
-  } else {
-    href = decodeURI(href.slice(0, searchIndex)) + href.slice(searchIndex)
-  }
-
-  return href
-}
-
-function getUrl (path) {
-  const href = window.location.href
-  const i = href.indexOf('#')
-  const base = i >= 0 ? href.slice(0, i) : href
-  return `${base}#${path}`
-}
-
-function pushHash (path) {
-  if (supportsPushState) {
-    pushState(getUrl(path))
-  } else {
-    window.location.hash = path
-  }
-}
-
-function replaceHash (path) {
-  if (supportsPushState) {
-    replaceState(getUrl(path))
-  } else {
-    window.location.replace(getUrl(path))
-  }
-}

package/src/history/html5.js

@@ -1,94 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { History } from './base'
-import { cleanPath } from '../util/path'
-import { START } from '../util/route'
-import { setupScroll, handleScroll } from '../util/scroll'
-import { pushState, replaceState, supportsPushState } from '../util/push-state'
-
-export class HTML5History extends History {
-  _startLocation: string
-
-  constructor (router: Router, base: ?string) {
-    super(router, base)
-
-    this._startLocation = getLocation(this.base)
-  }
-
-  setupListeners () {
-    if (this.listeners.length > 0) {
-      return
-    }
-
-    const router = this.router
-    const expectScroll = router.options.scrollBehavior
-    const supportsScroll = supportsPushState && expectScroll
-
-    if (supportsScroll) {
-      this.listeners.push(setupScroll())
-    }
-
-    const handleRoutingEvent = () => {
-      const current = this.current
-
-      // Avoiding first `popstate` event dispatched in some browsers but first
-      // history route not updated since async guard at the same time.
-      const location = getLocation(this.base)
-      if (this.current === START && location === this._startLocation) {
-        return
-      }
-
-      this.transitionTo(location, route => {
-        if (supportsScroll) {
-          handleScroll(router, route, current, true)
-        }
-      })
-    }
-    window.addEventListener('popstate', handleRoutingEvent)
-    this.listeners.push(() => {
-      window.removeEventListener('popstate', handleRoutingEvent)
-    })
-  }
-
-  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 = decodeURI(window.location.pathname)
-  if (base && path.toLowerCase().indexOf(base.toLowerCase()) === 0) {
-    path = path.slice(base.length)
-  }
-  return (path || '/') + window.location.search + window.location.hash
-}

package/src/index.js

@@ -1,277 +0,0 @@
-/* @flow */
-
-import { install } from './install'
-import { START } from './util/route'
-import { assert } from './util/warn'
-import { inBrowser } from './util/dom'
-import { cleanPath } from './util/path'
-import { createMatcher } from './create-matcher'
-import { normalizeLocation } from './util/location'
-import { supportsPushState } from './util/push-state'
-import { handleScroll } from './util/scroll'
-
-import { HashHistory } from './history/hash'
-import { HTML5History } from './history/html5'
-import { AbstractHistory } from './history/abstract'
-
-import type { Matcher } from './create-matcher'
-
-import { isNavigationFailure, NavigationFailureType } from './util/errors'
-
-export default class KduRouter {
-  static install: () => void
-  static version: string
-  static isNavigationFailure: Function
-  static NavigationFailureType: any
-
-  app: any
-  apps: Array<any>
-  ready: boolean
-  readyCbs: Array<Function>
-  options: RouterOptions
-  mode: string
-  history: HashHistory | HTML5History | AbstractHistory
-  matcher: Matcher
-  fallback: boolean
-  beforeHooks: Array<?NavigationGuard>
-  resolveHooks: Array<?NavigationGuard>
-  afterHooks: Array<?AfterNavigationHook>
-
-  constructor (options: RouterOptions = {}) {
-    this.app = null
-    this.apps = []
-    this.options = options
-    this.beforeHooks = []
-    this.resolveHooks = []
-    this.afterHooks = []
-    this.matcher = createMatcher(options.routes || [], this)
-
-    let mode = options.mode || 'hash'
-    this.fallback =
-      mode === 'history' && !supportsPushState && options.fallback !== false
-    if (this.fallback) {
-      mode = 'hash'
-    }
-    if (!inBrowser) {
-      mode = 'abstract'
-    }
-    this.mode = mode
-
-    switch (mode) {
-      case 'history':
-        this.history = new HTML5History(this, options.base)
-        break
-      case 'hash':
-        this.history = new HashHistory(this, options.base, this.fallback)
-        break
-      case 'abstract':
-        this.history = new AbstractHistory(this, options.base)
-        break
-      default:
-        if (process.env.NODE_ENV !== 'production') {
-          assert(false, `invalid mode: ${mode}`)
-        }
-    }
-  }
-
-  match (raw: RawLocation, current?: Route, redirectedFrom?: Location): Route {
-    return this.matcher.match(raw, current, redirectedFrom)
-  }
-
-  get currentRoute (): ?Route {
-    return this.history && this.history.current
-  }
-
-  init (app: any /* Kdu component instance */) {
-    process.env.NODE_ENV !== 'production' &&
-      assert(
-        install.installed,
-        `not installed. Make sure to call \`Kdu.use(KduRouter)\` ` +
-          `before creating root instance.`
-      )
-
-    this.apps.push(app)
-
-    // set up app destroyed handler
-    app.$once('hook:destroyed', () => {
-      // clean out app from this.apps array once destroyed
-      const index = this.apps.indexOf(app)
-      if (index > -1) this.apps.splice(index, 1)
-      // ensure we still have a main app or null if no apps
-      // we do not release the router so it can be reused
-      if (this.app === app) this.app = this.apps[0] || null
-
-      if (!this.app) {
-        // clean up event listeners
-        this.history.teardownListeners()
-      }
-    })
-
-    // main app previously initialized
-    // return as we don't need to set up new history listener
-    if (this.app) {
-      return
-    }
-
-    this.app = app
-
-    const history = this.history
-
-    if (history instanceof HTML5History || history instanceof HashHistory) {
-      const handleInitialScroll = routeOrError => {
-        const from = history.current
-        const expectScroll = this.options.scrollBehavior
-        const supportsScroll = supportsPushState && expectScroll
-
-        if (supportsScroll && 'fullPath' in routeOrError) {
-          handleScroll(this, routeOrError, from, false)
-        }
-      }
-      const setupListeners = routeOrError => {
-        history.setupListeners()
-        handleInitialScroll(routeOrError)
-      }
-      history.transitionTo(
-        history.getCurrentLocation(),
-        setupListeners,
-        setupListeners
-      )
-    }
-
-    history.listen(route => {
-      this.apps.forEach(app => {
-        app._route = route
-      })
-    })
-  }
-
-  beforeEach (fn: Function): Function {
-    return registerHook(this.beforeHooks, fn)
-  }
-
-  beforeResolve (fn: Function): Function {
-    return registerHook(this.resolveHooks, fn)
-  }
-
-  afterEach (fn: Function): Function {
-    return registerHook(this.afterHooks, fn)
-  }
-
-  onReady (cb: Function, errorCb?: Function) {
-    this.history.onReady(cb, errorCb)
-  }
-
-  onError (errorCb: Function) {
-    this.history.onError(errorCb)
-  }
-
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    // $flow-disable-line
-    if (!onComplete && !onAbort && typeof Promise !== 'undefined') {
-      return new Promise((resolve, reject) => {
-        this.history.push(location, resolve, reject)
-      })
-    } else {
-      this.history.push(location, onComplete, onAbort)
-    }
-  }
-
-  replace (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    // $flow-disable-line
-    if (!onComplete && !onAbort && typeof Promise !== 'undefined') {
-      return new Promise((resolve, reject) => {
-        this.history.replace(location, resolve, reject)
-      })
-    } else {
-      this.history.replace(location, onComplete, onAbort)
-    }
-  }
-
-  go (n: number) {
-    this.history.go(n)
-  }
-
-  back () {
-    this.go(-1)
-  }
-
-  forward () {
-    this.go(1)
-  }
-
-  getMatchedComponents (to?: RawLocation | Route): Array<any> {
-    const route: any = to
-      ? to.matched
-        ? to
-        : this.resolve(to).route
-      : this.currentRoute
-    if (!route) {
-      return []
-    }
-    return [].concat.apply(
-      [],
-      route.matched.map(m => {
-        return Object.keys(m.components).map(key => {
-          return m.components[key]
-        })
-      })
-    )
-  }
-
-  resolve (
-    to: RawLocation,
-    current?: Route,
-    append?: boolean
-  ): {
-    location: Location,
-    route: Route,
-    href: string,
-    // for backwards compat
-    normalizedTo: Location,
-    resolved: Route
-  } {
-    current = current || this.history.current
-    const location = normalizeLocation(to, current, append, this)
-    const route = this.match(location, current)
-    const fullPath = route.redirectedFrom || route.fullPath
-    const base = this.history.base
-    const href = createHref(base, fullPath, this.mode)
-    return {
-      location,
-      route,
-      href,
-      // for backwards compat
-      normalizedTo: location,
-      resolved: route
-    }
-  }
-
-  addRoutes (routes: Array<RouteConfig>) {
-    this.matcher.addRoutes(routes)
-    if (this.history.current !== START) {
-      this.history.transitionTo(this.history.getCurrentLocation())
-    }
-  }
-}
-
-function registerHook (list: Array<any>, fn: Function): Function {
-  list.push(fn)
-  return () => {
-    const i = list.indexOf(fn)
-    if (i > -1) list.splice(i, 1)
-  }
-}
-
-function createHref (base: string, fullPath: string, mode) {
-  var path = mode === 'hash' ? '#' + fullPath : fullPath
-  return base ? cleanPath(base + '/' + path) : path
-}
-
-KduRouter.install = install
-KduRouter.version = '__VERSION__'
-KduRouter.isNavigationFailure = isNavigationFailure
-KduRouter.NavigationFailureType = NavigationFailureType
-
-if (inBrowser && window.Kdu) {
-  window.Kdu.use(KduRouter)
-}

package/src/install.js

@@ -1,52 +0,0 @@
-import View from './components/view'
-import Link from './components/link'
-
-export let _Kdu
-
-export function install (Kdu) {
-  if (install.installed && _Kdu === Kdu) return
-  install.installed = true
-
-  _Kdu = Kdu
-
-  const isDef = v => v !== undefined
-
-  const registerInstance = (vm, callVal) => {
-    let i = vm.$options._parentKnode
-    if (isDef(i) && isDef(i = i.data) && isDef(i = i.registerRouteInstance)) {
-      i(vm, callVal)
-    }
-  }
-
-  Kdu.mixin({
-    beforeCreate () {
-      if (isDef(this.$options.router)) {
-        this._routerRoot = this
-        this._router = this.$options.router
-        this._router.init(this)
-        Kdu.util.defineReactive(this, '_route', this._router.history.current)
-      } else {
-        this._routerRoot = (this.$parent && this.$parent._routerRoot) || this
-      }
-      registerInstance(this, this)
-    },
-    destroyed () {
-      registerInstance(this)
-    }
-  })
-
-  Object.defineProperty(Kdu.prototype, '$router', {
-    get () { return this._routerRoot._router }
-  })
-
-  Object.defineProperty(Kdu.prototype, '$route', {
-    get () { return this._routerRoot._route }
-  })
-
-  Kdu.component('RouterView', View)
-  Kdu.component('RouterLink', Link)
-
-  const strats = Kdu.config.optionMergeStrategies
-  // use the same hook merging strategy for route hooks
-  strats.beforeRouteEnter = strats.beforeRouteLeave = strats.beforeRouteUpdate = strats.created
-}

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/errors.js

@@ -1,85 +0,0 @@
-export const NavigationFailureType = {
-  redirected: 2,
-  aborted: 4,
-  cancelled: 8,
-  duplicated: 16
-}
-
-export function createNavigationRedirectedError (from, to) {
-  return createRouterError(
-    from,
-    to,
-    NavigationFailureType.redirected,
-    `Redirected when going from "${from.fullPath}" to "${stringifyRoute(
-      to
-    )}" via a navigation guard.`
-  )
-}
-
-export function createNavigationDuplicatedError (from, to) {
-  const error = createRouterError(
-    from,
-    to,
-    NavigationFailureType.duplicated,
-    `Avoided redundant navigation to current location: "${from.fullPath}".`
-  )
-  // backwards compatible with the first introduction of Errors
-  error.name = 'NavigationDuplicated'
-  return error
-}
-
-export function createNavigationCancelledError (from, to) {
-  return createRouterError(
-    from,
-    to,
-    NavigationFailureType.cancelled,
-    `Navigation cancelled from "${from.fullPath}" to "${
-      to.fullPath
-    }" with a new navigation.`
-  )
-}
-
-export function createNavigationAbortedError (from, to) {
-  return createRouterError(
-    from,
-    to,
-    NavigationFailureType.aborted,
-    `Navigation aborted from "${from.fullPath}" to "${
-      to.fullPath
-    }" via a navigation guard.`
-  )
-}
-
-function createRouterError (from, to, type, message) {
-  const error = new Error(message)
-  error._isRouter = true
-  error.from = from
-  error.to = to
-  error.type = type
-
-  return error
-}
-
-const propertiesToLog = ['params', 'query', 'hash']
-
-function stringifyRoute (to) {
-  if (typeof to === 'string') return to
-  if ('path' in to) return to.path
-  const location = {}
-  propertiesToLog.forEach(key => {
-    if (key in to) location[key] = to[key]
-  })
-  return JSON.stringify(location, null, 2)
-}
-
-export function isError (err) {
-  return Object.prototype.toString.call(err).indexOf('Error') > -1
-}
-
-export function isNavigationFailure (err, errorType) {
-  return (
-    isError(err) &&
-    err._isRouter &&
-    (errorType == null || err.type === errorType)
-  )
-}