kdu-router 3.1.7 → 3.5.4

package/src/util/errors.js

@@ -0,0 +1,86 @@
+// When changing thing, also edit router.d.ts
+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)
+  )
+}

package/src/util/path.js

@@ -70,5 +70,5 @@ export function parsePath (path: string): {
 }
 
 export function cleanPath (path: string): string {
-  return path.replace(/\/\//g, '/')
+  return path.replace(/\/(?:\s*\/)+/g, '/')
 }

package/src/util/push-state.js

@@ -19,7 +19,7 @@ export const supportsPushState =
       return false
     }
 
-    return window.history && 'pushState' in window.history
+    return window.history && typeof window.history.pushState === 'function'
   })()
 
 export function pushState (url?: string, replace?: boolean) {

package/src/util/query.js

@@ -9,11 +9,21 @@ const commaRE = /%2C/g
 // fixed encodeURIComponent which is more conformant to RFC3986:
 // - escapes [!'()*]
 // - preserve commas
-const encode = str => encodeURIComponent(str)
-  .replace(encodeReserveRE, encodeReserveReplacer)
-  .replace(commaRE, ',')
+const encode = str =>
+  encodeURIComponent(str)
+    .replace(encodeReserveRE, encodeReserveReplacer)
+    .replace(commaRE, ',')
 
-const decode = decodeURIComponent
+export function decode (str: string) {
+  try {
+    return decodeURIComponent(str)
+  } catch (err) {
+    if (process.env.NODE_ENV !== 'production') {
+      warn(false, `Error decoding "${str}". Leaving it intact.`)
+    }
+  }
+  return str
+}
 
 export function resolveQuery (
   query: ?string,
@@ -29,11 +39,16 @@ export function resolveQuery (
     parsedQuery = {}
   }
   for (const key in extraQuery) {
-    parsedQuery[key] = extraQuery[key]
+    const value = extraQuery[key]
+    parsedQuery[key] = Array.isArray(value)
+      ? value.map(castQueryParamValue)
+      : castQueryParamValue(value)
   }
   return parsedQuery
 }
 
+const castQueryParamValue = value => (value == null || typeof value === 'object' ? value : String(value))
+
 function parseQuery (query: string): Dictionary<string> {
   const res = {}
 
@@ -46,9 +61,7 @@ function parseQuery (query: string): Dictionary<string> {
   query.split('&').forEach(param => {
     const parts = param.replace(/\+/g, ' ').split('=')
     const key = decode(parts.shift())
-    const val = parts.length > 0
-      ? decode(parts.join('='))
-      : null
+    const val = parts.length > 0 ? decode(parts.join('=')) : null
 
     if (res[key] === undefined) {
       res[key] = val
@@ -63,33 +76,38 @@ function parseQuery (query: string): Dictionary<string> {
 }
 
 export function stringifyQuery (obj: Dictionary<string>): string {
-  const res = obj ? Object.keys(obj).map(key => {
-    const val = obj[key]
-
-    if (val === undefined) {
-      return ''
-    }
+  const res = obj
+    ? Object.keys(obj)
+      .map(key => {
+        const val = obj[key]
 
-    if (val === null) {
-      return encode(key)
-    }
+        if (val === undefined) {
+          return ''
+        }
 
-    if (Array.isArray(val)) {
-      const result = []
-      val.forEach(val2 => {
-        if (val2 === undefined) {
-          return
+        if (val === null) {
+          return encode(key)
         }
-        if (val2 === null) {
-          result.push(encode(key))
-        } else {
-          result.push(encode(key) + '=' + encode(val2))
+
+        if (Array.isArray(val)) {
+          const result = []
+          val.forEach(val2 => {
+            if (val2 === undefined) {
+              return
+            }
+            if (val2 === null) {
+              result.push(encode(key))
+            } else {
+              result.push(encode(key) + '=' + encode(val2))
+            }
+          })
+          return result.join('&')
         }
-      })
-      return result.join('&')
-    }
 
-    return encode(key) + '=' + encode(val)
-  }).filter(x => x.length > 0).join('&') : null
+        return encode(key) + '=' + encode(val)
+      })
+      .filter(x => x.length > 0)
+      .join('&')
+    : null
   return res ? `?${res}` : ''
 }

package/src/util/resolve-components.js

@@ -1,7 +1,8 @@
 /* @flow */
 
 import { _Kdu } from '../install'
-import { warn, isError } from './warn'
+import { warn } from './warn'
+import { isError } from '../util/errors'
 
 export function resolveAsyncComponents (matched: Array<RouteRecord>): Function {
   return (to, from, next) => {

package/src/util/route.js

@@ -70,23 +70,23 @@ function getFullPath (
   return (path || '/') + stringify(query) + hash
 }
 
-export function isSameRoute (a: Route, b: ?Route): boolean {
+export function isSameRoute (a: Route, b: ?Route, onlyPath: ?boolean): boolean {
   if (b === START) {
     return a === b
   } else if (!b) {
     return false
   } else if (a.path && b.path) {
-    return (
-      a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') &&
+    return a.path.replace(trailingSlashRE, '') === b.path.replace(trailingSlashRE, '') && (onlyPath ||
       a.hash === b.hash &&
-      isObjectEqual(a.query, b.query)
-    )
+      isObjectEqual(a.query, b.query))
   } else if (a.name && b.name) {
     return (
       a.name === b.name &&
-      a.hash === b.hash &&
+      (onlyPath || (
+        a.hash === b.hash &&
       isObjectEqual(a.query, b.query) &&
-      isObjectEqual(a.params, b.params)
+      isObjectEqual(a.params, b.params))
+      )
     )
   } else {
     return false
@@ -96,14 +96,18 @@ export function isSameRoute (a: Route, b: ?Route): boolean {
 function isObjectEqual (a = {}, b = {}): boolean {
   // handle null value #1566
   if (!a || !b) return a === b
-  const aKeys = Object.keys(a)
-  const bKeys = Object.keys(b)
+  const aKeys = Object.keys(a).sort()
+  const bKeys = Object.keys(b).sort()
   if (aKeys.length !== bKeys.length) {
     return false
   }
-  return aKeys.every(key => {
+  return aKeys.every((key, i) => {
     const aVal = a[key]
+    const bKey = bKeys[i]
+    if (bKey !== key) return false
     const bVal = b[key]
+    // query values can be null and undefined
+    if (aVal == null || bVal == null) return aVal === bVal
     // check nested equality
     if (typeof aVal === 'object' && typeof bVal === 'object') {
       return isObjectEqual(aVal, bVal)
@@ -130,3 +134,18 @@ function queryIncludes (current: Dictionary<string>, target: Dictionary<string>)
   }
   return true
 }
+
+export function handleRouteEntered (route: Route) {
+  for (let i = 0; i < route.matched.length; i++) {
+    const record = route.matched[i]
+    for (const name in record.instances) {
+      const instance = record.instances[name]
+      const cbs = record.enteredCbs[name]
+      if (!instance || !cbs) continue
+      delete record.enteredCbs[name]
+      for (let i = 0; i < cbs.length; i++) {
+        if (!instance._isBeingDestroyed) cbs[i](instance)
+      }
+    }
+  }
+}

package/src/util/scroll.js

@@ -8,6 +8,10 @@ import { extend } from './misc'
 const positionStore = Object.create(null)
 
 export function setupScroll () {
+  // Prevent browser scroll behavior on History popstate
+  if ('scrollRestoration' in window.history) {
+    window.history.scrollRestoration = 'manual'
+  }
   // Fix for #1585 for Firefox
   // Fix for #2195 Add optional third attribute to workaround a bug in safari https://bugs.webkit.org/show_bug.cgi?id=182678
   // Fix for #2774 Support for apps loaded from Windows file shares not mapped to network drives: replaced location.origin with
@@ -19,12 +23,10 @@ export function setupScroll () {
   const stateCopy = extend({}, window.history.state)
   stateCopy.key = getStateKey()
   window.history.replaceState(stateCopy, '', absolutePath)
-  window.addEventListener('popstate', e => {
-    saveScrollPosition()
-    if (e.state && e.state.key) {
-      setStateKey(e.state.key)
-    }
-  })
+  window.addEventListener('popstate', handlePopState)
+  return () => {
+    window.removeEventListener('popstate', handlePopState)
+  }
 }
 
 export function handleScroll (
@@ -86,6 +88,13 @@ export function saveScrollPosition () {
   }
 }
 
+function handlePopState (e) {
+  saveScrollPosition()
+  if (e.state && e.state.key) {
+    setStateKey(e.state.key)
+  }
+}
+
 function getScrollPosition (): ?Object {
   const key = getStateKey()
   if (key) {
@@ -151,6 +160,16 @@ function scrollToPosition (shouldScroll, position) {
   }
 
   if (position) {
-    window.scrollTo(position.x, position.y)
+    // $flow-disable-line
+    if ('scrollBehavior' in document.documentElement.style) {
+      window.scrollTo({
+        left: position.x,
+        top: position.y,
+        // $flow-disable-line
+        behavior: shouldScroll.behavior
+      })
+    } else {
+      window.scrollTo(position.x, position.y)
+    }
   }
 }

package/src/util/warn.js

@@ -7,19 +7,8 @@ export function assert (condition: any, message: string) {
 }
 
 export function warn (condition: any, message: string) {
-  if (process.env.NODE_ENV !== 'production' && !condition) {
+  if (!condition) {
     typeof console !== 'undefined' && console.warn(`[kdu-router] ${message}`)
   }
 }
 
-export function isError (err: any): boolean {
-  return Object.prototype.toString.call(err).indexOf('Error') > -1
-}
-
-export function isExtendedError (constructor: Function, err: any): boolean {
-  return (
-    err instanceof constructor ||
-    // _name is to support IE9 too
-    (err && (err.name === constructor.name || err._name === constructor._name))
-  )
-}

package/types/index.d.ts

@@ -5,12 +5,17 @@ export default KduRouter
 
 export {
   RouterMode,
+  RouteMeta,
   RawLocation,
   RedirectOption,
   RouterOptions,
   RouteConfig,
   RouteRecord,
+  RouteRecordPublic,
   Location,
   Route,
-  NavigationGuard
+  NavigationGuard,
+  NavigationGuardNext,
+  NavigationFailureType,
+  NavigationFailure
 } from './router'

package/types/router.d.ts

@@ -1,22 +1,27 @@
 import Kdu, { ComponentOptions, PluginFunction, AsyncComponent } from 'kdu'
 
 type Component = ComponentOptions<Kdu> | typeof Kdu | AsyncComponent
-type Dictionary < T > = { [key: string]: T }
+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 > = (
+export type NavigationGuardNext<V extends Kdu = Kdu> = (
+  to?: RawLocation | false | ((vm: V) => any) | void
+) => void
+
+export type NavigationGuard<V extends Kdu = Kdu> = (
   to: Route,
   from: Route,
-  next: (to?: RawLocation | false | ((vm: V) => any) | void) => void
+  next: NavigationGuardNext<V>
 ) => any
 
 export declare class KduRouter {
   constructor(options?: RouterOptions)
 
   app: Kdu
+  options: RouterOptions
   mode: RouterMode
   currentRoute: Route
 
@@ -38,10 +43,16 @@ export declare class KduRouter {
   go(n: number): void
   back(): void
   forward(): void
+  match (raw: RawLocation, current?: Route, redirectedFrom?: Location): Route
   getMatchedComponents(to?: RawLocation | Route): Component[]
   onReady(cb: Function, errorCb?: ErrorHandler): void
   onError(cb: ErrorHandler): void
   addRoutes(routes: RouteConfig[]): void
+
+  addRoute(parent: string, route: RouteConfig): void
+  addRoute(route: RouteConfig): void
+  getRoutes(): RouteRecordPublic[]
+
   resolve(
     to: RawLocation,
     current?: Route,
@@ -56,10 +67,34 @@ export declare class KduRouter {
   }
 
   static install: PluginFunction<never>
+  static version: string
+
+  static isNavigationFailure: (
+    error: any,
+    type?: number
+  ) => error is NavigationFailure
+  static NavigationFailureType: {
+    [k in keyof typeof NavigationFailureType]: NavigationFailureType
+  }
+
+  static START_LOCATION: Route
+}
+
+export enum NavigationFailureType {
+  redirected = 2,
+  aborted = 4,
+  cancelled = 8,
+  duplicated = 16
+}
+
+export interface NavigationFailure extends Error {
+  to: Route
+  from: Route
+  type: number
 }
 
 type Position = { x: number; y: number }
-type PositionResult = Position | { selector: string; offset?: Position } | void
+type PositionResult = Position | { selector: string; offset?: Position, behavior?: ScrollBehavior } | void
 
 export interface RouterOptions {
   routes?: RouteConfig[]
@@ -85,21 +120,30 @@ export interface PathToRegexpOptions {
   end?: boolean
 }
 
-export interface RouteConfig {
+interface _RouteConfigBase {
   path: string
   name?: string
-  component?: Component
-  components?: Dictionary<Component>
+  children?: RouteConfig[]
   redirect?: RedirectOption
   alias?: string | string[]
-  children?: RouteConfig[]
-  meta?: any
+  meta?: RouteMeta
   beforeEnter?: NavigationGuard
-  props?: boolean | Object | RoutePropsFunction
   caseSensitive?: boolean
   pathToRegexpOptions?: PathToRegexpOptions
 }
 
+interface RouteConfigSingleView extends _RouteConfigBase {
+  component?: Component
+  props?: boolean | Object | RoutePropsFunction
+}
+
+interface RouteConfigMultipleViews extends _RouteConfigBase {
+  components?: Dictionary<Component>
+  props?: Dictionary<boolean | Object | RoutePropsFunction>
+}
+
+export type RouteConfig = RouteConfigSingleView | RouteConfigMultipleViews
+
 export interface RouteRecord {
   path: string
   regex: RegExp
@@ -109,6 +153,25 @@ export interface RouteRecord {
   parent?: RouteRecord
   redirect?: RedirectOption
   matchAs?: string
+  meta: RouteMeta
+  beforeEnter?: (
+    route: Route,
+    redirect: (location: RawLocation) => void,
+    next: () => void
+  ) => any
+  props:
+    | boolean
+    | Object
+    | RoutePropsFunction
+    | Dictionary<boolean | Object | RoutePropsFunction>
+}
+
+export interface RouteRecordPublic {
+  path: string
+  components: Dictionary<Component>
+  instances: Dictionary<Kdu>
+  name?: string
+  redirect?: RedirectOption
   meta: any
   beforeEnter?: (
     route: Route,
@@ -122,6 +185,7 @@ export interface RouteRecord {
     | Dictionary<boolean | Object | RoutePropsFunction>
 }
 
+
 export interface Location {
   name?: string
   path?: string
@@ -141,5 +205,7 @@ export interface Route {
   fullPath: string
   matched: RouteRecord[]
   redirectedFrom?: string
-  meta?: any
+  meta?: RouteMeta
 }
+
+export interface RouteMeta extends Record<string | number | symbol, any> {}

package/src/history/errors.js

@@ -1,22 +0,0 @@
-export class NavigationDuplicated extends Error {
-  constructor (normalizedLocation) {
-    super()
-    this.name = this._name = 'NavigationDuplicated'
-    // passing the message to super() doesn't seem to work in the transpiled version
-    this.message = `Navigating to current location ("${
-      normalizedLocation.fullPath
-    }") is not allowed`
-    // add a stack property so services like Sentry can correctly display it
-    Object.defineProperty(this, 'stack', {
-      value: new Error().stack,
-      writable: true,
-      configurable: true
-    })
-    // we could also have used
-    // Error.captureStackTrace(this, this.constructor)
-    // but it only exists on node and chrome
-  }
-}
-
-// support IE9
-NavigationDuplicated._name = 'NavigationDuplicated'