kdu-router 2.7.0 → 3.0.0

package/src/util/resolve-components.js

@@ -1,100 +0,0 @@
-/* @flow */
-
-import { _Kdu } from '../install'
-import { warn, isError } from './warn'
-
-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 (resolvedDef.__esModule && resolvedDef.default) {
-            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
-            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)
-}
-
-// 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,110 +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
-  const route: Route = {
-    name: location.name || (record && record.name),
-    meta: (record && record.meta) || {},
-    path: location.path || '/',
-    hash: location.hash || '',
-    query: location.query || {},
-    params: location.params || {},
-    fullPath: getFullPath(location, stringifyQuery),
-    matched: record ? formatMatch(record) : []
-  }
-  if (redirectedFrom) {
-    route.redirectedFrom = getFullPath(redirectedFrom, stringifyQuery)
-  }
-  return Object.freeze(route)
-}
-
-// 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): 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, '') &&
-      a.hash === b.hash &&
-      isObjectEqual(a.query, b.query)
-    )
-  } else if (a.name && b.name) {
-    return (
-      a.name === b.name &&
-      a.hash === b.hash &&
-      isObjectEqual(a.query, b.query) &&
-      isObjectEqual(a.params, b.params)
-    )
-  } else {
-    return false
-  }
-}
-
-function isObjectEqual (a = {}, b = {}): boolean {
-  const aKeys = Object.keys(a)
-  const bKeys = Object.keys(b)
-  if (aKeys.length !== bKeys.length) {
-    return false
-  }
-  return aKeys.every(key => {
-    const aVal = a[key]
-    const bVal = b[key]
-    // 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
-}

package/src/util/scroll.js

@@ -1,111 +0,0 @@
-/* @flow */
-
-import type Router from '../index'
-import { assert } from './warn'
-import { getStateKey, setStateKey } from './push-state'
-
-const positionStore = Object.create(null)
-
-export function setupScroll () {
-  window.addEventListener('popstate', e => {
-    saveScrollPosition()
-    if (e.state && e.state.key) {
-      setStateKey(e.state.key)
-    }
-  })
-}
-
-export function handleScroll (
-  router: Router,
-  to: Route,
-  from: Route,
-  isPop: boolean
-) {
-  if (!router.app) {
-    return
-  }
-
-  const behavior = router.options.scrollBehavior
-  if (!behavior) {
-    return
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    assert(typeof behavior === 'function', `scrollBehavior must be a function`)
-  }
-
-  // wait until re-render finishes before scrolling
-  router.app.$nextTick(() => {
-    let position = getScrollPosition()
-    const shouldScroll = behavior(to, from, isPop ? position : null)
-    if (!shouldScroll) {
-      return
-    }
-    const isObject = typeof shouldScroll === 'object'
-    if (isObject && typeof shouldScroll.selector === 'string') {
-      const el = document.querySelector(shouldScroll.selector)
-      if (el) {
-        let offset = shouldScroll.offset && typeof shouldScroll.offset === 'object' ? shouldScroll.offset : {}
-        offset = normalizeOffset(offset)
-        position = getElementPosition(el, offset)
-      } else if (isValidPosition(shouldScroll)) {
-        position = normalizePosition(shouldScroll)
-      }
-    } else if (isObject && isValidPosition(shouldScroll)) {
-      position = normalizePosition(shouldScroll)
-    }
-
-    if (position) {
-      window.scrollTo(position.x, position.y)
-    }
-  })
-}
-
-export function saveScrollPosition () {
-  const key = getStateKey()
-  if (key) {
-    positionStore[key] = {
-      x: window.pageXOffset,
-      y: window.pageYOffset
-    }
-  }
-}
-
-function getScrollPosition (): ?Object {
-  const key = getStateKey()
-  if (key) {
-    return positionStore[key]
-  }
-}
-
-function getElementPosition (el: Element, offset: Object): Object {
-  const docEl: any = document.documentElement
-  const docRect = docEl.getBoundingClientRect()
-  const elRect = el.getBoundingClientRect()
-  return {
-    x: elRect.left - docRect.left - offset.x,
-    y: elRect.top - docRect.top - offset.y
-  }
-}
-
-function isValidPosition (obj: Object): boolean {
-  return isNumber(obj.x) || isNumber(obj.y)
-}
-
-function normalizePosition (obj: Object): Object {
-  return {
-    x: isNumber(obj.x) ? obj.x : window.pageXOffset,
-    y: isNumber(obj.y) ? obj.y : window.pageYOffset
-  }
-}
-
-function normalizeOffset (obj: Object): Object {
-  return {
-    x: isNumber(obj.x) ? obj.x : 0,
-    y: isNumber(obj.y) ? obj.y : 0
-  }
-}
-
-function isNumber (v: any): boolean {
-  return typeof v === 'number'
-}

package/src/util/warn.js

@@ -1,17 +0,0 @@
-/* @flow */
-
-export function assert (condition: any, message: string) {
-  if (!condition) {
-    throw new Error(`[kdu-router] ${message}`)
-  }
-}
-
-export function warn (condition: any, message: string) {
-  if (process.env.NODE_ENV !== 'production' && !condition) {
-    typeof console !== 'undefined' && console.warn(`[kdu-router] ${message}`)
-  }
-}
-
-export function isError (err: any): boolean {
-  return Object.prototype.toString.call(err).indexOf('Error') > -1
-}