abstract-nested-router/dist/index.umd.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
  typeof define === 'function' && define.amd ? define(factory) :
  (global = global || self, global.AbstractNestedRouter = factory());
}(this, function () { 'use strict';

  var defaultExport = /*@__PURE__*/(function (Error) {
    function defaultExport(route, path) {
      var message = "Unreachable '" + route + "', segment '" + path + "' is not defined";
      Error.call(this, message);
      this.message = message;
    }

    if ( Error ) defaultExport.__proto__ = Error;
    defaultExport.prototype = Object.create( Error && Error.prototype );
    defaultExport.prototype.constructor = defaultExport;

    return defaultExport;
  }(Error));

  function buildMatcher(path, parent) {
    var regex;

    var _isSplat;

    var _priority = -100;

    var keys = [];
    regex = path.replace(/[-$.]/g, '\\$&').replace(/\(/g, '(?:').replace(/\)/g, ')?').replace(/([:*]\w+)(?:<([^<>]+?)>)?/g, function (_, key, expr) {
      keys.push(key.substr(1));

      if (key.charAt() === ':') {
        _priority += 100;
        return ("((?!#)" + (expr || '[^#/]+?') + ")");
      }

      _isSplat = true;
      _priority += 500;
      return ("((?!#)" + (expr || '[^#]+?') + ")");
    });

    try {
      regex = new RegExp(("^" + regex + "$"));
    } catch (e) {
      throw new TypeError(("Invalid route expression, given '" + parent + "'"));
    }

    var _hashed = path.includes('#') ? 0.5 : 1;

    var _depth = path.length * _priority * _hashed;

    return {
      keys: keys,
      regex: regex,
      _depth: _depth,
      _isSplat: _isSplat
    };
  }
  var PathMatcher = function PathMatcher(path, parent) {
    var ref = buildMatcher(path, parent);
    var keys = ref.keys;
    var regex = ref.regex;
    var _depth = ref._depth;
    var _isSplat = ref._isSplat;
    return {
      _isSplat: _isSplat,
      _depth: _depth,
      match: function (value) {
        var matches = value.match(regex);

        if (matches) {
          return keys.reduce(function (prev, cur, i) {
            prev[cur] = typeof matches[i + 1] === 'string' ? decodeURIComponent(matches[i + 1]) : null;
            return prev;
          }, {});
        }
      }
    };
  };

  PathMatcher.push = function push (key, prev, leaf, parent) {
    var root = prev[key] || (prev[key] = {});

    if (!root.pattern) {
      root.pattern = new PathMatcher(key, parent);
      root.route = (leaf || '').replace(/\/$/, '') || '/';
    }

    prev.keys = prev.keys || [];

    if (!prev.keys.includes(key)) {
      prev.keys.push(key);
      PathMatcher.sort(prev);
    }

    return root;
  };

  PathMatcher.sort = function sort (root) {
    root.keys.sort(function (a, b) {
      return root[a].pattern._depth - root[b].pattern._depth;
    });
  };

  function merge(path, parent) {
    return ("" + (parent && parent !== '/' ? parent : '') + (path || ''));
  }
  function walk(path, cb) {
    var matches = path.match(/<[^<>]*\/[^<>]*>/);

    if (matches) {
      throw new TypeError(("RegExp cannot contain slashes, given '" + matches + "'"));
    }

    var parts = path !== '/' ? path.split('/') : [''];
    var root = [];
    parts.some(function (x, i) {
      var parent = root.concat(x).join('/') || null;
      var segment = parts.slice(i + 1).join('/') || null;
      var retval = cb(("/" + x), parent, segment ? ((x ? ("/" + x) : '') + "/" + segment) : null);
      root.push(x);
      return retval;
    });
  }
  function reduce(key, root, _seen) {
    var params = {};
    var out = [];
    var splat;
    walk(key, function (x, leaf, extra) {
      var found;

      if (!root.keys) {
        throw new defaultExport(key, x);
      }

      root.keys.some(function (k) {
        if (_seen.includes(k)) { return false; }
        var ref = root[k].pattern;
        var match = ref.match;
        var _isSplat = ref._isSplat;
        var matches = match(_isSplat ? extra || x : x);

        if (matches) {
          Object.assign(params, matches);

          if (root[k].route) {
            var routeInfo = Object.assign({}, root[k].info); // properly handle exact-routes!

            var hasMatch = false;

            if (routeInfo.exact) {
              hasMatch = extra === null;
            } else {
              hasMatch = x && leaf === null || x === leaf || _isSplat || !extra;
            }

            routeInfo.matches = hasMatch;
            routeInfo.params = Object.assign({}, params);
            routeInfo.route = root[k].route;
            routeInfo.path = _isSplat ? extra : leaf || x;
            out.push(routeInfo);
          }

          if (extra === null && !root[k].keys) {
            return true;
          }

          if (k !== '/') { _seen.push(k); }
          splat = _isSplat;
          root = root[k];
          found = true;
          return true;
        }

        return false;
      });

      if (!(found || root.keys.some(function (k) { return root[k].pattern.match(x); }))) {
        throw new defaultExport(key, x);
      }

      return splat || !found;
    });
    return out;
  }
  function find(path, routes, retries) {
    var get = reduce.bind(null, path, routes);
    var set = [];

    while (retries > 0) {
      retries -= 1;

      try {
        return get(set);
      } catch (e) {
        if (retries > 0) {
          return get(set);
        }

        throw e;
      }
    }
  }
  function add(path, routes, parent, routeInfo) {
    var fullpath = merge(path, parent);
    var root = routes;
    var key;

    if (routeInfo && routeInfo.nested !== true) {
      key = routeInfo.key;
      delete routeInfo.key;
    }

    walk(fullpath, function (x, leaf) {
      root = PathMatcher.push(x, root, leaf, fullpath);

      if (x !== '/') {
        root.info = root.info || Object.assign({}, routeInfo);
      }
    });
    root.info = root.info || Object.assign({}, routeInfo);

    if (key) {
      root.info.key = key;
    }

    return fullpath;
  }
  function rm(path, routes, parent) {
    var fullpath = merge(path, parent);
    var root = routes;
    var leaf = null;
    var key = null;
    walk(fullpath, function (x) {
      if (!root) {
        leaf = null;
        return true;
      }

      key = x;
      leaf = x === '/' ? routes['/'] : root;

      if (!leaf.keys) {
        throw new defaultExport(path, x);
      }

      root = root[x];
    });

    if (!(leaf && key)) {
      throw new defaultExport(path, key);
    }

    delete leaf[key];

    if (key === '/') {
      delete leaf.info;
      delete leaf.route;
    }

    var offset = leaf.keys.indexOf(key);

    if (offset !== -1) {
      leaf.keys.splice(leaf.keys.indexOf(key), 1);
      PathMatcher.sort(leaf);
    }
  }

  var Router = function Router() {
    var routes = {};
    var stack = [];
    return {
      resolve: function (path, cb) {
        var ref = path.split(/(?=[#?])/);
        var uri = ref[0];
        var hash = ref[1];
        var query = ref[2];
        var segments = uri.substr(1).split('/');
        var prefix = [];
        var seen = [];
        segments.some(function (key) {
          var sub = prefix.concat(("/" + key)).join('');
          if (key.length) { prefix.push(("/" + key)); }

          try {
            var next = find(sub, routes, 1);
            cb(null, next.filter(function (x) {
              if (!seen.includes(x.route)) {
                seen.push(x.route);
                return true;
              }

              return false;
            }));
          } catch (e) {
            cb(e, []);
            return true;
          }

          return false;
        });

        if (hash) {
          cb(null, find(("" + uri + hash), routes, 1));
        }
      },
      mount: function (path, cb) {
        if (path !== '/') {
          stack.push(path);
        }

        cb();
        stack.pop();
      },
      find: function (path, retries) { return find(path, routes, retries === true ? 2 : retries || 1); },
      add: function (path, routeInfo) { return add(path, routes, stack.join(''), routeInfo); },
      rm: function (path) { return rm(path, routes, stack.join('')); }
    };
  };

  return Router;

}));