BJ_web_developers / cityOperationCenter

  /* @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 VueRouter {
    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 /* Vue component instance */) {
      process.env.NODE_ENV !== 'production' && assert(
        install.installed,
        `not installed. Make sure to call \`Vue.use(VueRouter)\` ` +
        `before creating root instance.`
      )
  
      this.apps.push(app)
  
      // main app already initialized.
      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
    } {
      const location = normalizeLocation(
        to,
        current || this.history.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
  }
  
  VueRouter.install = install
  VueRouter.version = '__VERSION__'
  
  if (inBrowser && window.Vue) {
    window.Vue.use(VueRouter)
  }