kdu-router 3.5.4 → 4.0.16

package/src/util/location.js

@@ -1,69 +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'
-import { extend } from './misc'
-
-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._normalized) {
-    return next
-  } else if (next.name) {
-    next = extend({}, raw)
-    const params = next.params
-    if (params && typeof params === 'object') {
-      next.params = extend({}, params)
-    }
-    return next
-  }
-
-  // relative params
-  if (!next.path && next.params && current) {
-    next = extend({}, next)
-    next._normalized = true
-    const params: any = extend(extend({}, 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
-  }
-}

package/src/util/misc.js

@@ -1,6 +0,0 @@
-export function extend (a, b) {
-  for (const key in b) {
-    a[key] = b[key]
-  }
-  return a
-}

package/src/util/params.js

@@ -1,37 +0,0 @@
-/* @flow */
-
-import { warn } from './warn'
-import Regexp from 'path-to-regexp'
-
-// $flow-disable-line
-const regexpCompileCache: {
-  [key: string]: Function
-} = Object.create(null)
-
-export function fillParams (
-  path: string,
-  params: ?Object,
-  routeMsg: string
-): string {
-  params = params || {}
-  try {
-    const filler =
-      regexpCompileCache[path] ||
-      (regexpCompileCache[path] = Regexp.compile(path))
-
-    // Fix #2505 resolving asterisk routes { name: 'not-found', params: { pathMatch: '/not-found' }}
-    // and fix #3106 so that you can work with location descriptor object having params.pathMatch equal to empty string
-    if (typeof params.pathMatch === 'string') params[0] = params.pathMatch
-
-    return filler(params, { pretty: true })
-  } catch (e) {
-    if (process.env.NODE_ENV !== 'production') {
-      // Fix #3072 no warn if `pathMatch` is string
-      warn(typeof params.pathMatch === 'string', `missing param for ${routeMsg}: ${e.message}`)
-    }
-    return ''
-  } finally {
-    // delete the 0 if it was added
-    delete params[0]
-  }
-}

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(/\/(?:\s*\/)+/g, '/')
-}

package/src/util/push-state.js

@@ -1,46 +0,0 @@
-/* @flow */
-
-import { inBrowser } from './dom'
-import { saveScrollPosition } from './scroll'
-import { genStateKey, setStateKey, getStateKey } from './state-key'
-import { extend } from './misc'
-
-export const supportsPushState =
-  inBrowser &&
-  (function () {
-    const ua = window.navigator.userAgent
-
-    if (
-      (ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) &&
-      ua.indexOf('Mobile Safari') !== -1 &&
-      ua.indexOf('Chrome') === -1 &&
-      ua.indexOf('Windows Phone') === -1
-    ) {
-      return false
-    }
-
-    return window.history && typeof window.history.pushState === 'function'
-  })()
-
-export function pushState (url?: string, replace?: boolean) {
-  saveScrollPosition()
-  // try...catch the pushState call to get around Safari
-  // DOM Exception 18 where it limits to 100 pushState calls
-  const history = window.history
-  try {
-    if (replace) {
-      // preserve existing history state as it could be overriden by the user
-      const stateCopy = extend({}, history.state)
-      stateCopy.key = getStateKey()
-      history.replaceState(stateCopy, '', url)
-    } else {
-      history.pushState({ key: setStateKey(genStateKey()) }, '', url)
-    }
-  } catch (e) {
-    window.location[replace ? 'replace' : 'assign'](url)
-  }
-}
-
-export function replaceState (url?: string) {
-  pushState(url, true)
-}

package/src/util/query.js

@@ -1,113 +0,0 @@
-/* @flow */
-
-import { warn } from './warn'
-
-const encodeReserveRE = /[!'()*]/g
-const encodeReserveReplacer = c => '%' + c.charCodeAt(0).toString(16)
-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, ',')
-
-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,
-  extraQuery: Dictionary<string> = {},
-  _parseQuery: ?Function
-): Dictionary<string> {
-  const parse = _parseQuery || parseQuery
-  let parsedQuery
-  try {
-    parsedQuery = parse(query || '')
-  } catch (e) {
-    process.env.NODE_ENV !== 'production' && warn(false, e.message)
-    parsedQuery = {}
-  }
-  for (const key in extraQuery) {
-    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 = {}
-
-  query = query.trim().replace(/^(\?|#|&)/, '')
-
-  if (!query) {
-    return res
-  }
-
-  query.split('&').forEach(param => {
-    const parts = param.replace(/\+/g, ' ').split('=')
-    const key = decode(parts.shift())
-    const val = parts.length > 0 ? decode(parts.join('=')) : null
-
-    if (res[key] === undefined) {
-      res[key] = val
-    } else if (Array.isArray(res[key])) {
-      res[key].push(val)
-    } else {
-      res[key] = [res[key], val]
-    }
-  })
-
-  return res
-}
-
-export function stringifyQuery (obj: Dictionary<string>): string {
-  const res = obj
-    ? Object.keys(obj)
-      .map(key => {
-        const val = obj[key]
-
-        if (val === undefined) {
-          return ''
-        }
-
-        if (val === null) {
-          return encode(key)
-        }
-
-        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 encode(key) + '=' + encode(val)
-      })
-      .filter(x => x.length > 0)
-      .join('&')
-    : null
-  return res ? `?${res}` : ''
-}

package/src/util/resolve-components.js

@@ -1,109 +0,0 @@
-/* @flow */
-
-import { _Kdu } from '../install'
-import { warn } from './warn'
-import { isError } from '../util/errors'
-
-export function resolveAsyncComponents (matched: Array<RouteRecord>): Function {
-  return (to, from, next) => {
-    let hasAsync = false
-    let pending = 0
-    let error = null
-
-    flatMapComponents(matched, (def, _, match, key) => {
-      // if it's a function and doesn't have cid attached,
-      // assume it's an async component resolve function.
-      // we are not using Kdu's default async resolving mechanism because
-      // we want to halt the navigation until the incoming component has been
-      // resolved.
-      if (typeof def === 'function' && def.cid === undefined) {
-        hasAsync = true
-        pending++
-
-        const resolve = once(resolvedDef => {
-          if (isESModule(resolvedDef)) {
-            resolvedDef = resolvedDef.default
-          }
-          // save resolved on async factory in case it's used elsewhere
-          def.resolved = typeof resolvedDef === 'function'
-            ? resolvedDef
-            : _Kdu.extend(resolvedDef)
-          match.components[key] = resolvedDef
-          pending--
-          if (pending <= 0) {
-            next()
-          }
-        })
-
-        const reject = once(reason => {
-          const msg = `Failed to resolve async component ${key}: ${reason}`
-          process.env.NODE_ENV !== 'production' && warn(false, msg)
-          if (!error) {
-            error = isError(reason)
-              ? reason
-              : new Error(msg)
-            next(error)
-          }
-        })
-
-        let res
-        try {
-          res = def(resolve, reject)
-        } catch (e) {
-          reject(e)
-        }
-        if (res) {
-          if (typeof res.then === 'function') {
-            res.then(resolve, reject)
-          } else {
-            // new syntax in Kdu 2.3
-            const comp = res.component
-            if (comp && typeof comp.then === 'function') {
-              comp.then(resolve, reject)
-            }
-          }
-        }
-      }
-    })
-
-    if (!hasAsync) next()
-  }
-}
-
-export function flatMapComponents (
-  matched: Array<RouteRecord>,
-  fn: Function
-): Array<?Function> {
-  return flatten(matched.map(m => {
-    return Object.keys(m.components).map(key => fn(
-      m.components[key],
-      m.instances[key],
-      m, key
-    ))
-  }))
-}
-
-export function flatten (arr: Array<any>): Array<any> {
-  return Array.prototype.concat.apply([], arr)
-}
-
-const hasSymbol =
-  typeof Symbol === 'function' &&
-  typeof Symbol.toStringTag === 'symbol'
-
-function isESModule (obj) {
-  return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module')
-}
-
-// in Webpack 2, require.ensure now also returns a Promise
-// so the resolve/reject functions may get called an extra time
-// if the user uses an arrow function shorthand that happens to
-// return that Promise.
-function once (fn) {
-  let called = false
-  return function (...args) {
-    if (called) return
-    called = true
-    return fn.apply(this, args)
-  }
-}

package/src/util/route.js

@@ -1,151 +0,0 @@
-/* @flow */
-
-import type KduRouter from '../index'
-import { stringifyQuery } from './query'
-
-const trailingSlashRE = /\/?$/
-
-export function createRoute (
-  record: ?RouteRecord,
-  location: Location,
-  redirectedFrom?: ?Location,
-  router?: KduRouter
-): Route {
-  const stringifyQuery = router && router.options.stringifyQuery
-
-  let query: any = location.query || {}
-  try {
-    query = clone(query)
-  } catch (e) {}
-
-  const route: Route = {
-    name: location.name || (record && record.name),
-    meta: (record && record.meta) || {},
-    path: location.path || '/',
-    hash: location.hash || '',
-    query,
-    params: location.params || {},
-    fullPath: getFullPath(location, stringifyQuery),
-    matched: record ? formatMatch(record) : []
-  }
-  if (redirectedFrom) {
-    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery)
-  }
-  return Object.freeze(route)
-}
-
-function clone (value) {
-  if (Array.isArray(value)) {
-    return value.map(clone)
-  } else if (value && typeof value === 'object') {
-    const res = {}
-    for (const key in value) {
-      res[key] = clone(value[key])
-    }
-    return res
-  } else {
-    return value
-  }
-}
-
-// the starting route that represents the initial state
-export const START = createRoute(null, {
-  path: '/'
-})
-
-function formatMatch (record: ?RouteRecord): Array<RouteRecord> {
-  const res = []
-  while (record) {
-    res.unshift(record)
-    record = record.parent
-  }
-  return res
-}
-
-function getFullPath (
-  { path, query = {}, hash = '' },
-  _stringifyQuery
-): string {
-  const stringify = _stringifyQuery || stringifyQuery
-  return (path || '/') + stringify(query) + hash
-}
-
-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, '') && (onlyPath ||
-      a.hash === b.hash &&
-      isObjectEqual(a.query, b.query))
-  } else if (a.name && b.name) {
-    return (
-      a.name === b.name &&
-      (onlyPath || (
-        a.hash === b.hash &&
-      isObjectEqual(a.query, b.query) &&
-      isObjectEqual(a.params, b.params))
-      )
-    )
-  } else {
-    return false
-  }
-}
-
-function isObjectEqual (a = {}, b = {}): boolean {
-  // handle null value #1566
-  if (!a || !b) return a === b
-  const aKeys = Object.keys(a).sort()
-  const bKeys = Object.keys(b).sort()
-  if (aKeys.length !== bKeys.length) {
-    return false
-  }
-  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)
-    }
-    return String(aVal) === String(bVal)
-  })
-}
-
-export function isIncludedRoute (current: Route, target: Route): boolean {
-  return (
-    current.path.replace(trailingSlashRE, '/').indexOf(
-      target.path.replace(trailingSlashRE, '/')
-    ) === 0 &&
-    (!target.hash || current.hash === target.hash) &&
-    queryIncludes(current.query, target.query)
-  )
-}
-
-function queryIncludes (current: Dictionary<string>, target: Dictionary<string>): boolean {
-  for (const key in target) {
-    if (!(key in current)) {
-      return false
-    }
-  }
-  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)
-      }
-    }
-  }
-}