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

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('')); }
  };
};

export default Router;