kdu-router 3.0.1 → 3.0.7

package/src/index.js

@@ -0,0 +1,247 @@
+/* @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 { HashHistory } from './history/hash'
+import { HTML5History } from './history/html5'
+import { AbstractHistory } from './history/abstract'
+
+import type { Matcher } from './create-matcher'
+
+export default class KduRouter {
+  static install: () => void;
+  static version: string;
+
+  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
+    })
+
+    // 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.transitionTo(history.getCurrentLocation())
+    } else if (history instanceof HashHistory) {
+      const setupHashListener = () => {
+        history.setupListeners()
+      }
+      history.transitionTo(
+        history.getCurrentLocation(),
+        setupHashListener,
+        setupHashListener
+      )
+    }
+
+    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) {
+    this.history.push(location, onComplete, onAbort)
+  }
+
+  replace (location: RawLocation, onComplete?: Function, onAbort?: Function) {
+    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__'
+
+if (inBrowser && window.Kdu) {
+  window.Kdu.use(KduRouter)
+}

package/src/install.js

@@ -0,0 +1,52 @@
+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/types/kdu.d.ts

@@ -15,8 +15,8 @@ declare module "kdu/types/kdu" {
 declare module "kdu/types/options" {
   interface ComponentOptions<V extends Kdu> {
     router?: KduRouter;
-    beforeRouteEnter?: NavigationGuard;
-    beforeRouteLeave?: NavigationGuard;
-    beforeRouteUpdate?: NavigationGuard;
+    beforeRouteEnter?: NavigationGuard<V>;
+    beforeRouteLeave?: NavigationGuard<V>;
+    beforeRouteUpdate?: NavigationGuard<V>;
   }
 }

package/types/router.d.ts

@@ -2,14 +2,15 @@ import Kdu, { ComponentOptions, PluginFunction, AsyncComponent } from "kdu";
 
 type Component = ComponentOptions<Kdu> | typeof Kdu | AsyncComponent;
 type Dictionary<T> = { [key: string]: T };
+type ErrorHandler = (err: Error) => void;
 
 export type RouterMode = "hash" | "history" | "abstract";
 export type RawLocation = string | Location;
 export type RedirectOption = RawLocation | ((to: Route) => RawLocation);
-export type NavigationGuard = (
+export type NavigationGuard<V extends Kdu = Kdu> = (
   to: Route,
   from: Route,
-  next: (to?: RawLocation | false | ((vm: Kdu) => any) | void) => void
+  next: (to?: RawLocation | false | ((vm: V) => any) | void) => void
 ) => any
 
 export declare class KduRouter {
@@ -22,14 +23,14 @@ export declare class KduRouter {
   beforeEach (guard: NavigationGuard): Function;
   beforeResolve (guard: NavigationGuard): Function;
   afterEach (hook: (to: Route, from: Route) => any): Function;
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function): void;
-  replace (location: RawLocation, onComplete?: Function, onAbort?: Function): void;
+  push (location: RawLocation, onComplete?: Function, onAbort?: ErrorHandler): void;
+  replace (location: RawLocation, onComplete?: Function, onAbort?: ErrorHandler): void;
   go (n: number): void;
   back (): void;
   forward (): void;
   getMatchedComponents (to?: RawLocation | Route): Component[];
-  onReady (cb: Function, errorCb?: Function): void;
-  onError (cb: Function): void;
+  onReady (cb: Function, errorCb?: ErrorHandler): void;
+  onError (cb: ErrorHandler): void;
   addRoutes (routes: RouteConfig[]): void;
   resolve (to: RawLocation, current?: Route, append?: boolean): {
     location: Location;
@@ -107,7 +108,7 @@ export interface Location {
   name?: string;
   path?: string;
   hash?: string;
-  query?: Dictionary<string>;
+  query?: Dictionary<string | (string | null)[] | null | undefined>;
   params?: Dictionary<string>;
   append?: boolean;
   replace?: boolean;
@@ -117,7 +118,7 @@ export interface Route {
   path: string;
   name?: string;
   hash: string;
-  query: Dictionary<string>;
+  query: Dictionary<string | (string | null)[]>;
   params: Dictionary<string>;
   fullPath: string;
   matched: RouteRecord[];