space-router 0.8.5 → 0.9.0

package/dist/esm/match.js

@@ -1,90 +1,76 @@
 export function match(routes, url, qs) {
-  if (!url) {
-    return;
-  }
-
-  for (let i = 0; i < routes.length; i++) {
-    const m = matchOne(routes[i].pattern, url, qs);
-
-    if (m) {
-      return m;
+    if (!url) {
+        return;
+    }
+    for(var i = 0; i < routes.length; i++){
+        var m = matchOne(routes[i].pattern, url, qs);
+        if (m) {
+            return m;
+        }
     }
-  }
 }
 export function matchOne(pattern, url, qs) {
-  if (!pattern) {
-    return false;
-  }
-
-  const re = /(?:\?([^#]*))?(#.*)?$/;
-  const originalUrl = url;
-  const originalPattern = pattern;
-  const c = url.match(re);
-  const params = {};
-  let query = {};
-  let search = '';
-  let hash = '';
-  let ret;
-
-  if (c && c[1]) {
-    search = '?' + c[1];
-    query = qs.parse(c[1]);
-  }
-
-  if (c && c[2]) {
-    hash = c[2] || '';
-  }
-
-  if (pattern !== '*') {
-    url = segmentize(url.replace(re, ''));
-    pattern = segmentize(pattern || '');
-    const max = Math.max(url.length, pattern.length);
-
-    for (let i = 0; i < max; i++) {
-      if (pattern[i] && pattern[i].charAt(0) === ':') {
-        const param = pattern[i].replace(/(^:|[+*?]+$)/g, '');
-        const flags = (pattern[i].match(/[+*?]+$/) || {})[0] || '';
-        const plus = flags.indexOf('+') > -1;
-        const star = flags.indexOf('*') > -1;
-        const val = url[i] || '';
-
-        if (!val && !star && (flags.indexOf('?') < 0 || plus)) {
-          ret = false;
-          break;
+    if (!pattern) {
+        return false;
+    }
+    var re = /(?:\?([^#]*))?(#.*)?$/;
+    var originalUrl = url;
+    var originalPattern = pattern;
+    var c = url.match(re);
+    var params = {};
+    var query = {};
+    var search = "";
+    var hash = "";
+    var ret;
+    if (c && c[1]) {
+        search = "?" + c[1];
+        query = qs.parse(c[1]);
+    }
+    if (c && c[2]) {
+        hash = c[2] || "";
+    }
+    if (pattern !== "*") {
+        url = segmentize(url.replace(re, ""));
+        pattern = segmentize(pattern || "");
+        var max = Math.max(url.length, pattern.length);
+        for(var i = 0; i < max; i++){
+            if (pattern[i] && pattern[i].charAt(0) === ":") {
+                var param = pattern[i].replace(/(^:|[+*?]+$)/g, "");
+                var flags = (pattern[i].match(/[+*?]+$/) || {})[0] || "";
+                var plus = flags.indexOf("+") > -1;
+                var star = flags.indexOf("*") > -1;
+                var val = url[i] || "";
+                if (!val && !star && (flags.indexOf("?") < 0 || plus)) {
+                    ret = false;
+                    break;
+                }
+                params[param] = decodeURIComponent(val);
+                if (plus || star) {
+                    params[param] = url.slice(i).map(decodeURIComponent).join("/");
+                    break;
+                }
+            } else if (pattern[i] !== url[i]) {
+                ret = false;
+                break;
+            }
         }
-
-        params[param] = decodeURIComponent(val);
-
-        if (plus || star) {
-          params[param] = url.slice(i).map(decodeURIComponent).join('/');
-          break;
+        if (ret === false) {
+            return false;
         }
-      } else if (pattern[i] !== url[i]) {
-        ret = false;
-        break;
-      }
-    }
-
-    if (ret === false) {
-      return false;
     }
-  }
-
-  return {
-    pattern: originalPattern,
-    url: originalUrl,
-    pathname: originalUrl.replace(re, ''),
-    params,
-    query,
-    search,
-    hash
-  };
+    return {
+        pattern: originalPattern,
+        url: originalUrl,
+        pathname: originalUrl.replace(re, ""),
+        params: params,
+        query: query,
+        search: search,
+        hash: hash
+    };
 }
-
 function segmentize(url) {
-  return strip(url).split('/');
+    return strip(url).split("/");
 }
-
 function strip(url) {
-  return url.replace(/(^\/+|\/+$)/g, '');
-}
+    return url.replace(/(^\/+|\/+$)/g, "");
+}

package/dist/esm/qs.js

@@ -1,20 +1,17 @@
-export const qs = {
-  parse(queryString) {
-    return queryString.split('&').reduce((acc, pair) => {
-      const parts = pair.split('=');
-      acc[parts[0]] = decodeURIComponent(parts[1]);
-      return acc;
-    }, {});
-  },
-
-  stringify(query) {
-    return Object.keys(query).reduce((acc, key) => {
-      if (query[key] !== undefined) {
-        acc.push(key + '=' + encodeURIComponent(query[key]));
-      }
-
-      return acc;
-    }, []).join('&');
-  }
-
-};
+export var qs = {
+    parse: function parse(queryString) {
+        return queryString.split("&").reduce(function(acc, pair) {
+            var parts = pair.split("=");
+            acc[parts[0]] = decodeURIComponent(parts[1]);
+            return acc;
+        }, {});
+    },
+    stringify: function stringify(query) {
+        return Object.keys(query).reduce(function(acc, key) {
+            if (query[key] !== undefined) {
+                acc.push(key + "=" + encodeURIComponent(query[key]));
+            }
+            return acc;
+        }, []).join("&");
+    }
+};

package/dist/esm/router.js

@@ -1,175 +1,249 @@
-import { match as findMatch } from './match';
-import { createHistory } from './history';
-import { qs as defaultQs } from './qs';
-export function createRouter(options = {}) {
-  let history = null;
-  let routes = [];
-  const mode = options.mode || 'history';
-  const qs = options.qs || defaultQs;
-  const sync = options.sync || false;
-  const router = {
-    listen(routeMap, cb) {
-      if (history) {
-        throw new Error('Already listening');
-      }
-
-      routes = flatten(routeMap);
-      history = createHistory({
-        mode,
-        sync
-      });
-      const dispose = history.listen(url => transition(router, url, cb));
-      return () => {
-        dispose();
-        history = null;
-        routes = [];
-      };
-    },
-
-    navigate(to, curr) {
-      if (typeof to === 'string') {
-        to = {
-          url: to
-        };
-      }
-
-      const url = router.href(to, curr);
-
-      if (to.replace) {
-        history.replace(url);
-      } else {
-        history.push(url);
-      }
-    },
-
-    href(to, curr) {
-      // already a url
-      if (typeof to === 'string') {
-        return to;
-      } // align with navigate API
-
-
-      if (to.url) {
-        return to.url;
-      }
-
-      if (to.merge) {
-        curr = curr || router.match(router.getUrl());
-        to = merge(curr, to);
-      }
-
-      let url = to.pathname || '/';
-
-      if (to.params) {
-        Object.keys(to.params).forEach(param => {
-          url = url.replace(':' + param, to.params[param]);
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
         });
-      }
-
-      if (to.query && Object.keys(to.query).length) {
-        const query = qs.stringify(to.query);
-
-        if (query) {
-          url = url + '?' + query;
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
         }
-      }
-
-      if (to.hash) {
-        const prefix = to.hash.startsWith('#') ? '' : '#';
-        url = url + prefix + to.hash;
-      }
-
-      return url;
-    },
-
-    match(url) {
-      const route = findMatch(routes, url, qs);
-
-      if (route) {
-        return { ...route,
-          data: data(routes, route)
-        };
-      }
-    },
-
-    getUrl() {
-      return history.getUrl();
     }
-
-  };
-  return router;
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+import { match as findMatch } from "./match.js";
+import { createHistory } from "./history.js";
+import { qs as defaultQs } from "./qs.js";
+export function createRouter() {
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var history = null;
+    var routes = [];
+    var mode = options.mode || "history";
+    var qs = options.qs || defaultQs;
+    var sync = options.sync || false;
+    var router = {
+        listen: function listen(routeMap, cb) {
+            if (history) {
+                throw new Error("Already listening");
+            }
+            routes = flatten(routeMap);
+            history = createHistory({
+                mode: mode,
+                sync: sync
+            });
+            var dispose = history.listen(function(url) {
+                return transition(router, url, cb);
+            });
+            return function() {
+                dispose();
+                history = null;
+                routes = [];
+            };
+        },
+        navigate: function navigate(to, curr) {
+            if (typeof to === "string") {
+                to = {
+                    url: to
+                };
+            }
+            var url = router.href(to, curr);
+            if (to.replace) {
+                history.replace(url);
+            } else {
+                history.push(url);
+            }
+        },
+        href: function href(to, curr) {
+            // already a url
+            if (typeof to === "string") {
+                return to;
+            }
+            // align with navigate API
+            if (to.url) {
+                return to.url;
+            }
+            if (to.merge) {
+                curr = curr || router.match(router.getUrl());
+                to = merge(curr, to);
+            }
+            var url = to.pathname || "/";
+            if (to.params) {
+                Object.keys(to.params).forEach(function(param) {
+                    url = url.replace(":" + param, to.params[param]);
+                });
+            }
+            if (to.query && Object.keys(to.query).length) {
+                var query = qs.stringify(to.query);
+                if (query) {
+                    url = url + "?" + query;
+                }
+            }
+            if (to.hash) {
+                var prefix = to.hash.startsWith("#") ? "" : "#";
+                url = url + prefix + to.hash;
+            }
+            return url;
+        },
+        match: function match(url) {
+            var route = findMatch(routes, url, qs);
+            if (route) {
+                return _object_spread_props(_object_spread({}, route), {
+                    data: data(routes, route)
+                });
+            }
+        },
+        getUrl: function getUrl() {
+            return history.getUrl();
+        }
+    };
+    return router;
 }
 export function flatten(routeMap) {
-  const routes = [];
-  const parentData = [];
-
-  function addLevel(level) {
-    level.forEach(route => {
-      const {
-        path = '',
-        routes: children,
-        ...routeData
-      } = route;
-      routes.push({
-        pattern: path,
-        data: parentData.concat([routeData])
-      });
-
-      if (children) {
-        parentData.push(routeData);
-        addLevel(children);
-        parentData.pop();
-      }
-    });
-  }
-
-  addLevel(routeMap);
-  return routes;
+    var routes = [];
+    var parentData = [];
+    function addLevel(level) {
+        level.forEach(function(route) {
+            var _route_path = route.path, path = _route_path === void 0 ? "" : _route_path, children = route.routes, routeData = _object_without_properties(route, [
+                "path",
+                "routes"
+            ]);
+            routes.push({
+                pattern: path,
+                data: parentData.concat([
+                    routeData
+                ])
+            });
+            if (children) {
+                parentData.push(routeData);
+                addLevel(children);
+                parentData.pop();
+            }
+        });
+    }
+    addLevel(routeMap);
+    return routes;
 }
-
 function transition(router, url, onNavigated) {
-  const route = router.match(url);
-
-  if (route) {
-    for (const r of route.data) {
-      if (r.redirect) {
-        const url = redirectUrl(router, r.redirect, route);
-        return router.navigate({
-          url,
-          replace: true
-        });
-      }
+    var route = router.match(url);
+    if (route) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = route.data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var r = _step.value;
+                if (r.redirect) {
+                    var _$url = redirectUrl(router, r.redirect, route);
+                    return router.navigate({
+                        url: _$url,
+                        replace: true
+                    });
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        onNavigated && onNavigated(route);
     }
-
-    onNavigated && onNavigated(route);
-  }
 }
-
 function redirectUrl(router, redirect, matchingRoute) {
-  if (typeof redirect === 'function') {
-    redirect = redirect(matchingRoute);
-  }
-
-  return router.href(redirect);
+    if (typeof redirect === "function") {
+        redirect = redirect(matchingRoute);
+    }
+    return router.href(redirect);
 }
-
 function data(routes, matchingRoute) {
-  for (let i = 0; i < routes.length; i++) {
-    if (routes[i].pattern === matchingRoute.pattern) {
-      return routes[i].data;
+    for(var i = 0; i < routes.length; i++){
+        if (routes[i].pattern === matchingRoute.pattern) {
+            return routes[i].data;
+        }
     }
-  }
 }
-
-export function merge(curr = {}, to) {
-  const pathname = to.pathname || curr.pattern || curr.pathname;
-  const params = Object.assign({}, curr.params, to.params);
-  const query = to.query === null ? null : Object.assign({}, curr.query, to.query);
-  const hash = to.hash === null ? null : to.hash || curr.hash || '';
-  return {
-    pathname,
-    params,
-    query,
-    hash
-  };
-}
+export function merge() {
+    var curr = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, to = arguments.length > 1 ? arguments[1] : void 0;
+    var pathname = to.pathname || curr.pattern || curr.pathname;
+    var params = Object.assign({}, curr.params, to.params);
+    var query = to.query === null ? null : Object.assign({}, curr.query, to.query);
+    var hash = to.hash === null ? null : to.hash || curr.hash || "";
+    return {
+        pathname: pathname,
+        params: params,
+        query: query,
+        hash: hash
+    };
+}

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "space-router",
   "description": "All the routing essentials.",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "main": "dist/cjs",
   "module": "dist/esm",
+  "type": "module",
   "license": "ICS",
   "repository": {
     "type": "git",
@@ -21,27 +22,25 @@
   ],
   "author": "Karolis Narkevicius",
   "scripts": {
-    "test": "healthier && prettier --check '**/*.{js,css,yml}' && nyc ava",
+    "test": "npm run build && healthier && prettier --check '**/*.{js,css,yml}' && c8 ava",
     "format": "prettier --write '**/*.{js,css,yml}'",
-    "coverage": "nyc --reporter=html ava",
+    "coverage": "c8 --reporter=html ava",
     "build": "node ./tasks/build.js",
     "watch": "node ./tasks/build.js -w",
-    "version": "npm run build",
     "release": "np --no-release-draft",
     "release:beta": "np --tag=beta --no-release-draft",
     "release:docs": "hugo -s docs && gh-pages -d docs/public"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.6",
-    "@babel/preset-env": "^7.16.11",
-    "ava": "^3.15.0",
+    "@swc/cli": "^0.1.62",
+    "@swc/core": "^1.3.49",
+    "ava": "^5.2.0",
+    "c8": "^7.13.0",
     "esm": "^3.2.25",
-    "execa": "^5.1.1",
-    "gh-pages": "^3.2.3",
-    "healthier": "^5.0.1",
-    "np": "^7.6.1",
-    "nyc": "^15.1.0",
-    "prettier": "^2.6.2"
+    "execa": "^7.1.1",
+    "gh-pages": "^5.0.0",
+    "healthier": "^6.3.0",
+    "prettier": "^2.8.7"
   },
   "healthier": {
     "global": [

package/src/index.js

@@ -1,3 +1,3 @@
-export { createRouter, merge } from './router'
-export { createHistory } from './history'
-export { qs } from './qs'
+export { createRouter, merge } from './router.js'
+export { createHistory } from './history.js'
+export { qs } from './qs.js'

package/src/router.js

@@ -1,6 +1,6 @@
-import { match as findMatch } from './match'
-import { createHistory } from './history'
-import { qs as defaultQs } from './qs'
+import { match as findMatch } from './match.js'
+import { createHistory } from './history.js'
+import { qs as defaultQs } from './qs.js'
 
 export function createRouter(options = {}) {
   let history = null