Method resolve

src/universal-router.ts:291–355

* Traverses the list of routes in the order they are defined until it finds * the first route that matches provided URL path string and whose action function * returns anything other than `null` or `undefined`.

(pathnameOrContext: string | ResolveContext)

   * returns anything other than `null` or `undefined`.
   */
  resolve(pathnameOrContext: string | ResolveContext): Promise<RouteResult<R>> {
    const context: ResolveContext = {
      router: this,
      ...this.options.context,
      ...(typeof pathnameOrContext === 'string'
        ? { pathname: pathnameOrContext }
        : pathnameOrContext),
    }
    const matchResult = matchRoute(
      this.root,
      this.baseUrl,
      this.options,
      context.pathname.substr(this.baseUrl.length),
    )
    const resolve = this.options.resolveRoute || resolveRoute
    let matches: IteratorResult<RouteMatch<R, C>, false>
    let nextMatches: IteratorResult<RouteMatch<R, C>, false> | null
    let currentContext = context

    function next(
      resume: boolean,
      parent: Route<R, C> | false = !matches.done && matches.value.route,
      prevResult?: RouteResult<R>,
    ): Promise<RouteResult<R>> {
      const routeToSkip =
        prevResult === null && !matches.done && matches.value.route
      matches = nextMatches || matchResult.next(routeToSkip)
      nextMatches = null

      if (!resume) {
        if (matches.done || !isChildRoute(parent, matches.value.route)) {
          nextMatches = matches
          return Promise.resolve(null)
        }
      }

      if (matches.done) {
        const error: RouteError = new Error('Route not found')
        error.status = 404
        return Promise.reject(error)
      }

      currentContext = { ...context, ...matches.value }

      return Promise.resolve(
        resolve(currentContext as RouteContext<R, C>, matches.value.params),
      ).then((result) => {
        if (result !== null && result !== undefined) {
          return result
        }
        return next(resume, parent, result)
      })
    }

    context['next'] = next

    return Promise.resolve()
      .then(() => next(true, this.root))