yrv/build/lib/router.js

import { writable } from 'svelte/store';
import { Router, parse } from './vendor';

import {
  ROOT_URL, HASHCHANGE, navigateTo, cleanPath, isActive, router,
} from './utils';

export var baseRouter = new Router();
export var routeInfo = writable({});

// private registries
var onError = {};
var shared = {};

var errors = [];
var routers = 0;
var interval;
var currentURL;

// take snapshot from current state...
router.subscribe(function (value) { shared.router = value; });
routeInfo.subscribe(function (value) { shared.routeInfo = value; });

export function doFallback(failure, fallback) {
  routeInfo.update(function (defaults) {
    var obj;

    return (Object.assign({}, defaults,
    ( obj = {}, obj[fallback] = Object.assign({}, shared.router,
      {failure: failure}), obj )));
  });
}

export function handleRoutes(map, params) {
  var keys = [];

  map.some(function (x) {
    if (x.key && x.matches && !shared.routeInfo[x.key]) {
      if (x.redirect && (x.condition === null || x.condition(shared.router) !== true)) {
        if (x.exact && shared.router.path !== x.path) { return false; }
        navigateTo(x.redirect);
        return true;
      }

      if (x.exact) {
        keys.push(x.key);
      }

      // extend shared params...
      Object.assign(params, x.params);

      // upgrade matching routes!
      routeInfo.update(function (defaults) {
        var obj;

        return (Object.assign({}, defaults,
        ( obj = {}, obj[x.key] = Object.assign({}, shared.router,
          x), obj )));
      });
    }

    return false;
  });

  return keys;
}

export function evtHandler() {
  var baseUri = !HASHCHANGE ? window.location.href.replace(window.location.origin, '') : window.location.hash || '/';
  var failure;

  // unprefix active URL
  if (ROOT_URL !== '/') {
    baseUri = baseUri.replace(cleanPath(ROOT_URL), '');
  }

  // skip given anchors if already exists on document, see #43
  if (
    /^#[\w-]+$/.test(window.location.hash)
    && document.querySelector(window.location.hash)
    && currentURL === baseUri.split('#')[0]
  ) { return; }

  // trailing slash is required to keep route-info on nested routes!
  // see: https://github.com/pateketrueke/abstract-nested-router/commit/0f338384bddcfbaee30f3ea2c4eb0c24cf5174cd
  var ref = baseUri.replace('/#', '#').replace(/^#\//, '/').split('?');
  var fixedUri = ref[0];
  var qs = ref[1];
  var fullpath = fixedUri.replace(/\/?$/, '/');
  var query = parse(qs);
  var params = {};
  var keys = [];

  // reset current state
  routeInfo.set({});

  if (currentURL !== baseUri) {
    currentURL = baseUri;
    router.set({
      path: cleanPath(fullpath),
      query: query,
      params: params,
    });
  }

  // load all matching routes...
  baseRouter.resolve(fullpath, function (err, result) {
    if (err) {
      failure = err;
      return;
    }

    // save exact-keys for deletion after failures!
    keys.push.apply(keys, handleRoutes(result, params));
  });

  var toDelete = {};

  // it's fine to omit failures for '/' paths
  if (failure && failure.path !== '/') {
    keys.reduce(function (prev, cur) {
      prev[cur] = null;
      return prev;
    }, toDelete);
  } else {
    failure = null;
  }

  // clear previously failed handlers
  errors.forEach(function (cb) { return cb(); });
  errors = [];

  try {
    // clear routes that not longer matches!
    baseRouter.find(cleanPath(fullpath))
      .forEach(function (sub) {
        if (sub.exact && !sub.matches) {
          toDelete[sub.key] = null;
        }
      });
  } catch (e) {
    // this is fine
  }

  // drop unwanted routes...
  routeInfo.update(function (defaults) { return (Object.assign({}, defaults,
    toDelete)); });

  var fallback;

  // invoke error-handlers to clear out previous state!
  Object.keys(onError).forEach(function (root) {
    if (isActive(root, fullpath, false)) {
      var fn = onError[root].callback;

      fn(failure);
      errors.push(fn);
    }

    if (!fallback && onError[root].fallback) {
      fallback = onError[root].fallback;
    }
  });

  // handle unmatched fallbacks
  if (failure && fallback) {
    doFallback(failure, fallback);
  }
}

export function findRoutes() {
  clearTimeout(interval);
  interval = setTimeout(evtHandler);
}

export function addRouter(root, fallback, callback) {
  if (!routers) {
    window.addEventListener('popstate', findRoutes, false);
  }

  // register error-handlers
  if (!onError[root] || fallback) {
    onError[root] = { fallback: fallback, callback: callback };
  }

  routers += 1;

  return function () {
    routers -= 1;

    if (!routers) {
      window.removeEventListener('popstate', findRoutes, false);
    }
  };
}