kdu-router 2.7.0 → 3.1.3

package/types/kdu.d.ts

@@ -1,23 +1,22 @@
-/**
- * Augment the typings of Kdu.js
- */
-
-import Kdu = require("types/kdu");
-import KduRouter = require("./index");
-import { Route, RawLocation, NavigationGuard } from "./index";
-
-declare module "kdu/types/kdu" {
-  interface Kdu {
-    $router: KduRouter;
-    $route: Route;
-  }
-}
-
-declare module "kdu/types/options" {
-  interface ComponentOptions<V extends Kdu> {
-    router?: KduRouter;
-    beforeRouteEnter?: NavigationGuard;
-    beforeRouteLeave?: NavigationGuard;
-    beforeRouteUpdate?: NavigationGuard;
-  }
-}
+/**
+ * Augment the typings of Kdu.js
+ */
+
+import Kdu from 'kdu'
+import KduRouter, { Route, RawLocation, NavigationGuard } from './index'
+
+declare module 'kdu/types/kdu' {
+  interface Kdu {
+    $router: KduRouter
+    $route: Route
+  }
+}
+
+declare module 'kdu/types/options' {
+  interface ComponentOptions<V extends Kdu> {
+    router?: KduRouter
+    beforeRouteEnter?: NavigationGuard<V>
+    beforeRouteLeave?: NavigationGuard<V>
+    beforeRouteUpdate?: NavigationGuard<V>
+  }
+}

package/types/router.d.ts

@@ -1,126 +1,145 @@
-import Kdu = require("types/kdu");
-import { ComponentOptions, PluginFunction } from "types/kdu";
-
-type Component = ComponentOptions<Kdu> | typeof Kdu;
-type Dictionary<T> = { [key: string]: T };
-
-export type RouterMode = "hash" | "history" | "abstract";
-export type RawLocation = string | Location;
-export type RedirectOption = RawLocation | ((to: Route) => RawLocation);
-export type NavigationGuard = (
-  to: Route,
-  from: Route,
-  next: (to?: RawLocation | false | ((vm: Kdu) => any) | void) => void
-) => any
-
-declare class KduRouter {
-  constructor (options?: RouterOptions);
-
-  app: Kdu;
-  mode: RouterMode;
-  currentRoute: Route;
-
-  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;
-  go (n: number): void;
-  back (): void;
-  forward (): void;
-  getMatchedComponents (to?: RawLocation | Route): Component[];
-  onReady (cb: Function, errorCb?: Function): void;
-  onError (cb: Function): void;
-  addRoutes (routes: RouteConfig[]): void;
-  resolve (to: RawLocation, current?: Route, append?: boolean): {
-    location: Location;
-    route: Route;
-    href: string;
-    // backwards compat
-    normalizedTo: Location;
-    resolved: Route;
-  };
-
-  static install: PluginFunction<never>;
-}
-
-type Position = { x: number, y: number };
-
-export interface RouterOptions {
-  routes?: RouteConfig[];
-  mode?: RouterMode;
-  fallback?: boolean;
-  base?: string;
-  linkActiveClass?: string;
-  linkExactActiveClass?: string;
-  parseQuery?: (query: string) => Object;
-  stringifyQuery?: (query: Object) => string;
-  scrollBehavior?: (
-    to: Route,
-    from: Route,
-    savedPosition: Position | void
-  ) => Position | { selector: string, offset?: Position } | void;
-}
-
-type RoutePropsFunction = (route: Route) => Object;
-
-export interface PathToRegexpOptions {
-  sensitive?: boolean;
-  strict?: boolean;
-  end?: boolean;
-}
-
-export interface RouteConfig {
-  path: string;
-  name?: string;
-  component?: Component;
-  components?: Dictionary<Component>;
-  redirect?: RedirectOption;
-  alias?: string | string[];
-  children?: RouteConfig[];
-  meta?: any;
-  beforeEnter?: NavigationGuard;
-  props?: boolean | Object | RoutePropsFunction;
-  caseSensitive?: boolean;
-  pathToRegexpOptions?: PathToRegexpOptions;
-}
-
-export interface RouteRecord {
-  path: string;
-  regex: RegExp;
-  components: Dictionary<Component>;
-  instances: Dictionary<Kdu>;
-  name?: string;
-  parent?: RouteRecord;
-  redirect?: RedirectOption;
-  matchAs?: string;
-  meta: any;
-  beforeEnter?: (
-    route: Route,
-    redirect: (location: RawLocation) => void,
-    next: () => void
-  ) => any;
-  props: boolean | Object | RoutePropsFunction | Dictionary<boolean | Object | RoutePropsFunction>;
-}
-
-export interface Location {
-  name?: string;
-  path?: string;
-  hash?: string;
-  query?: Dictionary<string>;
-  params?: Dictionary<string>;
-  append?: boolean;
-  replace?: boolean;
-}
-
-export interface Route {
-  path: string;
-  name?: string;
-  hash: string;
-  query: Dictionary<string>;
-  params: Dictionary<string>;
-  fullPath: string;
-  matched: RouteRecord[];
-  redirectedFrom?: string;
-  meta?: any;
-}
+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 < V extends Kdu = Kdu > = (
+    to: Route,
+    from: Route,
+    next: (to?: RawLocation | false | ((vm: V) => any) | void) => void
+) => any
+
+export declare class KduRouter {
+  constructor(options?: RouterOptions)
+
+  app: Kdu
+  mode: RouterMode
+  currentRoute: Route
+
+  beforeEach(guard: NavigationGuard): Function
+  beforeResolve(guard: NavigationGuard): Function
+  afterEach(hook: (to: Route, from: Route) => any): Function
+  push(location: RawLocation): Promise<Route>
+  replace(location: RawLocation): Promise<Route>
+  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?: ErrorHandler): void
+  onError(cb: ErrorHandler): void
+  addRoutes(routes: RouteConfig[]): void
+  resolve(
+      to: RawLocation,
+      current?: Route,
+      append?: boolean
+  ): {
+    location: Location
+    route: Route
+    href: string
+    // backwards compat
+    normalizedTo: Location
+    resolved: Route
+  }
+
+  static install: PluginFunction<never>
+}
+
+type Position = { x: number; y: number }
+type PositionResult = Position | { selector: string; offset?: Position } | void
+
+export interface RouterOptions {
+  routes?: RouteConfig[]
+  mode?: RouterMode
+  fallback?: boolean
+  base?: string
+  linkActiveClass?: string
+  linkExactActiveClass?: string
+  parseQuery?: (query: string) => Object
+  stringifyQuery?: (query: Object) => string
+  scrollBehavior?: (
+      to: Route,
+      from: Route,
+      savedPosition: Position | void
+  ) => PositionResult | Promise<PositionResult>
+}
+
+type RoutePropsFunction = (route: Route) => Object
+
+export interface PathToRegexpOptions {
+  sensitive?: boolean
+  strict?: boolean
+  end?: boolean
+}
+
+export interface RouteConfig {
+  path: string
+  name?: string
+  component?: Component
+  components?: Dictionary<Component>
+  redirect?: RedirectOption
+  alias?: string | string[]
+  children?: RouteConfig[]
+  meta?: any
+  beforeEnter?: NavigationGuard
+  props?: boolean | Object | RoutePropsFunction
+  caseSensitive?: boolean
+  pathToRegexpOptions?: PathToRegexpOptions
+}
+
+export interface RouteRecord {
+  path: string
+  regex: RegExp
+  components: Dictionary<Component>
+  instances: Dictionary<Kdu>
+  name?: string
+  parent?: RouteRecord
+  redirect?: RedirectOption
+  matchAs?: string
+  meta: any
+  beforeEnter?: (
+      route: Route,
+      redirect: (location: RawLocation) => void,
+      next: () => void
+  ) => any
+  props:
+      | boolean
+      | Object
+      | RoutePropsFunction
+      | Dictionary<boolean | Object | RoutePropsFunction>
+}
+
+export interface Location {
+  name?: string
+  path?: string
+  hash?: string
+  query?: Dictionary<string | (string | null)[] | null | undefined>
+  params?: Dictionary<string>
+  append?: boolean
+  replace?: boolean
+}
+
+export interface Route {
+  path: string
+  name?: string
+  hash: string
+  query: Dictionary<string | (string | null)[]>
+  params: Dictionary<string>
+  fullPath: string
+  matched: RouteRecord[]
+  redirectedFrom?: string
+  meta?: any
+}

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/history/abstract.js

@@ -1,51 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { History } from './base'
-
-export class AbstractHistory extends History {
-  index: number;
-  stack: Array<Route>;
-
-  constructor (router: Router, base: ?string) {
-    super(router, base)
-    this.stack = []
-    this.index = -1
-  }
-
-  push (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    this.transitionTo(location, route => {
-      this.stack = this.stack.slice(0, this.index + 1).concat(route)
-      this.index++
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  replace (location: RawLocation, onComplete?: Function, onAbort?: Function) {
-    this.transitionTo(location, route => {
-      this.stack = this.stack.slice(0, this.index).concat(route)
-      onComplete && onComplete(route)
-    }, onAbort)
-  }
-
-  go (n: number) {
-    const targetIndex = this.index + n
-    if (targetIndex < 0 || targetIndex >= this.stack.length) {
-      return
-    }
-    const route = this.stack[targetIndex]
-    this.confirmTransition(route, () => {
-      this.index = targetIndex
-      this.updateRoute(route)
-    })
-  }
-
-  getCurrentLocation () {
-    const current = this.stack[this.stack.length - 1]
-    return current ? current.fullPath : '/'
-  }
-
-  ensureURL () {
-    // noop
-  }
-}