@thi.ng/router 3.2.42 → 3.2.44

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -68,7 +68,7 @@ For Node.js REPL:
 const router = await import("@thi.ng/router");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.50 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.57 KB
 
 ## Dependencies
 

package/api.js

@@ -1,5 +1,6 @@
-/**
- * ID of success event being triggered by `router.match()`
- */
-export const EVENT_ROUTE_CHANGED = "route-changed";
-export const EVENT_ROUTE_FAILED = "route-failed";
+const EVENT_ROUTE_CHANGED = "route-changed";
+const EVENT_ROUTE_FAILED = "route-failed";
+export {
+  EVENT_ROUTE_CHANGED,
+  EVENT_ROUTE_FAILED
+};

package/basic.js

@@ -1,174 +1,195 @@
-import { __decorate } from "tslib";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
 import { INotifyMixin } from "@thi.ng/api/mixins/inotify";
 import { isString } from "@thi.ng/checks/is-string";
 import { equiv } from "@thi.ng/equiv";
 import { assert } from "@thi.ng/errors/assert";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
-import { EVENT_ROUTE_CHANGED, EVENT_ROUTE_FAILED, } from "./api.js";
-let BasicRouter = class BasicRouter {
-    config;
-    current;
-    routeIndex;
-    constructor(config) {
-        this.config = {
-            authenticator: (route, _, params) => ({
-                id: route.id,
-                title: route.title,
-                params,
-            }),
-            prefix: "/",
-            separator: "/",
-            removeTrailingSlash: true,
-            ...config,
-        };
-        this.routeIndex = this.config.routes.reduce((acc, r) => ((acc[r.id] = r), acc), {});
-        assert(this.routeForID(this.config.defaultRouteID) !== undefined, `missing config for default route: '${this.config.defaultRouteID}'`);
-        if (config.initialRouteID) {
-            const route = this.routeForID(config.initialRouteID);
-            assert(route !== undefined, `missing config for initial route: ${this.config.initialRouteID}`);
-            assert(!isParametricRoute(route), "initial route MUST not be parametric");
-        }
+import {
+  EVENT_ROUTE_CHANGED,
+  EVENT_ROUTE_FAILED
+} from "./api.js";
+let BasicRouter = class {
+  config;
+  current;
+  routeIndex;
+  constructor(config) {
+    this.config = {
+      authenticator: (route, _, params) => ({
+        id: route.id,
+        title: route.title,
+        params
+      }),
+      prefix: "/",
+      separator: "/",
+      removeTrailingSlash: true,
+      ...config
+    };
+    this.routeIndex = this.config.routes.reduce(
+      (acc, r) => (acc[r.id] = r, acc),
+      {}
+    );
+    assert(
+      this.routeForID(this.config.defaultRouteID) !== void 0,
+      `missing config for default route: '${this.config.defaultRouteID}'`
+    );
+    if (config.initialRouteID) {
+      const route = this.routeForID(config.initialRouteID);
+      assert(
+        route !== void 0,
+        `missing config for initial route: ${this.config.initialRouteID}`
+      );
+      assert(
+        !isParametricRoute(route),
+        "initial route MUST not be parametric"
+      );
     }
-    /** {@inheritDoc @thi.ng/api#INotify.addListener} */
-    // @ts-ignore: arguments
-    // prettier-ignore
-    addListener(id, fn, scope) { }
-    /** {@inheritDoc @thi.ng/api#INotify.removeListener} */
-    // @ts-ignore: arguments
-    // prettier-ignore
-    removeListener(id, fn, scope) { }
-    /** {@inheritDoc @thi.ng/api#INotify.notify} */
-    // @ts-ignore: arguments
-    notify(event) { }
-    start() {
-        if (this.config.initialRouteID) {
-            const route = this.routeForID(this.config.initialRouteID);
-            this.current = { id: route.id, title: route.title, params: {} };
-            this.notify({ id: EVENT_ROUTE_CHANGED, value: this.current });
-        }
+  }
+  /** {@inheritDoc @thi.ng/api#INotify.addListener} */
+  // @ts-ignore: arguments
+  // prettier-ignore
+  addListener(id, fn, scope) {
+  }
+  /** {@inheritDoc @thi.ng/api#INotify.removeListener} */
+  // @ts-ignore: arguments
+  // prettier-ignore
+  removeListener(id, fn, scope) {
+  }
+  /** {@inheritDoc @thi.ng/api#INotify.notify} */
+  // @ts-ignore: arguments
+  notify(event) {
+  }
+  start() {
+    if (this.config.initialRouteID) {
+      const route = this.routeForID(this.config.initialRouteID);
+      this.current = { id: route.id, title: route.title, params: {} };
+      this.notify({ id: EVENT_ROUTE_CHANGED, value: this.current });
     }
-    /**
-     * Main router function. Attempts to match given input string against all
-     * configured routes. Before returning, triggers {@link EVENT_ROUTE_CHANGED}
-     * with return value as well. If none of the routes matches, emits
-     * {@link EVENT_ROUTE_FAILED} and then falls back to configured default
-     * route.
-     *
-     * @param src - route path to match
-     */
-    route(src) {
-        if (this.config.removeTrailingSlash &&
-            src.charAt(src.length - 1) === this.config.separator) {
-            src = src.substring(0, src.length - 1);
-        }
-        src = src.substring(this.config.prefix.length);
-        let match = this.matchRoutes(src);
-        if (!match) {
-            this.notify({ id: EVENT_ROUTE_FAILED, value: src });
-            if (!this.handleRouteFailure()) {
-                return;
-            }
-            const route = this.routeForID(this.config.defaultRouteID);
-            match = { id: route.id, title: route.title, params: {} };
-        }
-        if (!equiv(match, this.current)) {
-            this.current = match;
-            this.notify({ id: EVENT_ROUTE_CHANGED, value: match });
-        }
-        return match;
+  }
+  /**
+   * Main router function. Attempts to match given input string against all
+   * configured routes. Before returning, triggers {@link EVENT_ROUTE_CHANGED}
+   * with return value as well. If none of the routes matches, emits
+   * {@link EVENT_ROUTE_FAILED} and then falls back to configured default
+   * route.
+   *
+   * @param src - route path to match
+   */
+  route(src) {
+    if (this.config.removeTrailingSlash && src.charAt(src.length - 1) === this.config.separator) {
+      src = src.substring(0, src.length - 1);
     }
-    format(...args) {
-        let [id, params] = args;
-        let match;
-        switch (args.length) {
-            case 2:
-                match = { id, params };
-                break;
-            case 1:
-                match = isString(id) ? { id } : id;
-                break;
-            default:
-                illegalArity(args.length);
-        }
-        const route = this.routeForID(match.id);
-        if (route) {
-            const params = match.params || {};
-            return (this.config.prefix +
-                route.match
-                    .map((x) => {
-                    if (isRouteParam(x)) {
-                        const id = x.substring(1);
-                        const p = params[id];
-                        if (p != null)
-                            return p;
-                        illegalArgs(`missing value for param '${id}'`);
-                    }
-                    return x;
-                })
-                    .join(this.config.separator));
-        }
-        else {
-            illegalArgs(`invalid route ID: ${match.id}`);
-        }
+    src = src.substring(this.config.prefix.length);
+    let match = this.matchRoutes(src);
+    if (!match) {
+      this.notify({ id: EVENT_ROUTE_FAILED, value: src });
+      if (!this.handleRouteFailure()) {
+        return;
+      }
+      const route = this.routeForID(this.config.defaultRouteID);
+      match = { id: route.id, title: route.title, params: {} };
     }
-    routeForID(id) {
-        return this.routeIndex[id];
+    if (!equiv(match, this.current)) {
+      this.current = match;
+      this.notify({ id: EVENT_ROUTE_CHANGED, value: match });
     }
-    matchRoutes(src) {
-        const routes = this.config.routes;
-        const curr = src.split(this.config.separator);
-        for (let i = 0, n = routes.length; i < n; i++) {
-            const match = this.matchRoute(curr, routes[i]);
-            if (match) {
-                return match;
-            }
-        }
+    return match;
+  }
+  format(...args) {
+    let [id, params] = args;
+    let match;
+    switch (args.length) {
+      case 2:
+        match = { id, params };
+        break;
+      case 1:
+        match = isString(id) ? { id } : id;
+        break;
+      default:
+        illegalArity(args.length);
     }
-    matchRoute(curr, route) {
-        const match = route.match;
-        const n = match.length;
-        if (curr.length === n) {
-            const params = {};
-            for (let i = 0; i < n; i++) {
-                const m = match[i];
-                if (isRouteParam(m)) {
-                    params[m.substring(1)] = curr[i];
-                }
-                else if (curr[i] !== m) {
-                    return;
-                }
-            }
-            if (route.validate &&
-                !this.validateRouteParams(params, route.validate)) {
-                return;
-            }
-            return route.auth
-                ? this.config.authenticator(route, curr, params)
-                : { id: route.id, title: route.title, params };
+    const route = this.routeForID(match.id);
+    if (route) {
+      const params2 = match.params || {};
+      return this.config.prefix + route.match.map((x) => {
+        if (isRouteParam(x)) {
+          const id2 = x.substring(1);
+          const p = params2[id2];
+          if (p != null)
+            return p;
+          illegalArgs(`missing value for param '${id2}'`);
         }
+        return x;
+      }).join(this.config.separator);
+    } else {
+      illegalArgs(`invalid route ID: ${match.id}`);
+    }
+  }
+  routeForID(id) {
+    return this.routeIndex[id];
+  }
+  matchRoutes(src) {
+    const routes = this.config.routes;
+    const curr = src.split(this.config.separator);
+    for (let i = 0, n = routes.length; i < n; i++) {
+      const match = this.matchRoute(curr, routes[i]);
+      if (match) {
+        return match;
+      }
     }
-    validateRouteParams(params, validators) {
-        for (let id in validators) {
-            if (params[id] !== undefined) {
-                const val = validators[id];
-                if (val.coerce) {
-                    params[id] = val.coerce(params[id]);
-                }
-                if (val.check && !val.check(params[id])) {
-                    return false;
-                }
-            }
+  }
+  matchRoute(curr, route) {
+    const match = route.match;
+    const n = match.length;
+    if (curr.length === n) {
+      const params = {};
+      for (let i = 0; i < n; i++) {
+        const m = match[i];
+        if (isRouteParam(m)) {
+          params[m.substring(1)] = curr[i];
+        } else if (curr[i] !== m) {
+          return;
         }
-        return true;
+      }
+      if (route.validate && !this.validateRouteParams(params, route.validate)) {
+        return;
+      }
+      return route.auth ? this.config.authenticator(route, curr, params) : { id: route.id, title: route.title, params };
     }
-    handleRouteFailure() {
-        return true;
+  }
+  validateRouteParams(params, validators) {
+    for (let id in validators) {
+      if (params[id] !== void 0) {
+        const val = validators[id];
+        if (val.coerce) {
+          params[id] = val.coerce(params[id]);
+        }
+        if (val.check && !val.check(params[id])) {
+          return false;
+        }
+      }
     }
+    return true;
+  }
+  handleRouteFailure() {
+    return true;
+  }
 };
-BasicRouter = __decorate([
-    INotifyMixin
+BasicRouter = __decorateClass([
+  INotifyMixin
 ], BasicRouter);
-export { BasicRouter };
 const isParametricRoute = (route) => route.match.some(isRouteParam);
 const isRouteParam = (x) => x[0] === "?";
+export {
+  BasicRouter
+};

package/history.js

@@ -1,90 +1,96 @@
 import { equiv } from "@thi.ng/equiv";
 import { BasicRouter } from "./basic.js";
-export class HTMLRouter extends BasicRouter {
-    currentPath;
-    popHandler;
-    hashHandler;
-    useFragment;
-    ignoreHashChange;
-    constructor(config) {
-        super({ prefix: config.useFragment ? "#/" : "/", ...config });
-        this.useFragment = config.useFragment !== false;
-        this.ignoreHashChange = false;
+class HTMLRouter extends BasicRouter {
+  currentPath;
+  popHandler;
+  hashHandler;
+  useFragment;
+  ignoreHashChange;
+  constructor(config) {
+    super({ prefix: config.useFragment ? "#/" : "/", ...config });
+    this.useFragment = config.useFragment !== false;
+    this.ignoreHashChange = false;
+  }
+  start() {
+    window.addEventListener("popstate", this.handlePopChange());
+    if (this.useFragment) {
+      window.addEventListener("hashchange", this.handleHashChange());
     }
-    start() {
-        window.addEventListener("popstate", this.handlePopChange());
-        if (this.useFragment) {
-            window.addEventListener("hashchange", this.handleHashChange());
-        }
-        if (this.config.initialRouteID) {
-            const route = this.routeForID(this.config.initialRouteID);
-            this.route(this.format({
-                id: route.id,
-                title: route.title,
-            }));
-        }
-        else {
-            this.route(this.useFragment ? location.hash : location.pathname);
-        }
-    }
-    release() {
-        window.removeEventListener("popstate", this.popHandler);
-        if (this.useFragment) {
-            window.removeEventListener("hashchange", this.hashHandler);
-        }
+    if (this.config.initialRouteID) {
+      const route = this.routeForID(this.config.initialRouteID);
+      this.route(
+        this.format({
+          id: route.id,
+          title: route.title
+        })
+      );
+    } else {
+      this.route(this.useFragment ? location.hash : location.pathname);
     }
-    /**
-     * Like `BasicRouter.route()`, but takes additional arg to control
-     * if this routing operation should manipulate the browser's `history`.
-     * If called from userland, this normally is true. However, we want
-     * to avoid this if called from this router's own event handlers.
-     *
-     * @param src -
-     * @param pushState -
-     */
-    route(src, pushState = true) {
-        const old = this.current;
-        const route = super.route(src);
-        if (route && !equiv(route, old)) {
-            this.currentPath = this.format(route);
-            if (pushState) {
-                history.pushState(this.currentPath, route.title || window.document.title || "", this.currentPath);
-            }
-        }
-        return route;
-    }
-    routeTo(route) {
-        if (this.useFragment) {
-            location.hash = route;
-        }
-        this.route(route);
+  }
+  release() {
+    window.removeEventListener("popstate", this.popHandler);
+    if (this.useFragment) {
+      window.removeEventListener("hashchange", this.hashHandler);
     }
-    handlePopChange() {
-        return (this.popHandler =
-            this.popHandler ||
-                ((e) => {
-                    this.route(e.state ||
-                        (this.useFragment ? location.hash : location.pathname), false);
-                }).bind(this));
+  }
+  /**
+   * Like `BasicRouter.route()`, but takes additional arg to control
+   * if this routing operation should manipulate the browser's `history`.
+   * If called from userland, this normally is true. However, we want
+   * to avoid this if called from this router's own event handlers.
+   *
+   * @param src -
+   * @param pushState -
+   */
+  route(src, pushState = true) {
+    const old = this.current;
+    const route = super.route(src);
+    if (route && !equiv(route, old)) {
+      this.currentPath = this.format(route);
+      if (pushState) {
+        history.pushState(
+          this.currentPath,
+          route.title || window.document.title || "",
+          this.currentPath
+        );
+      }
     }
-    handleHashChange() {
-        return (this.hashHandler =
-            this.hashHandler ||
-                ((e) => {
-                    if (!this.ignoreHashChange) {
-                        const hash = e.newURL.substring(e.newURL.indexOf("#"));
-                        if (hash !== this.currentPath) {
-                            this.route(hash, false);
-                        }
-                    }
-                }).bind(this));
-    }
-    handleRouteFailure() {
-        this.ignoreHashChange = true;
-        location.hash = this.format({
-            id: this.routeForID(this.config.defaultRouteID).id,
-        });
-        this.ignoreHashChange = false;
-        return true;
+    return route;
+  }
+  routeTo(route) {
+    if (this.useFragment) {
+      location.hash = route;
     }
+    this.route(route);
+  }
+  handlePopChange() {
+    return this.popHandler = this.popHandler || ((e) => {
+      this.route(
+        e.state || (this.useFragment ? location.hash : location.pathname),
+        false
+      );
+    }).bind(this);
+  }
+  handleHashChange() {
+    return this.hashHandler = this.hashHandler || ((e) => {
+      if (!this.ignoreHashChange) {
+        const hash = e.newURL.substring(e.newURL.indexOf("#"));
+        if (hash !== this.currentPath) {
+          this.route(hash, false);
+        }
+      }
+    }).bind(this);
+  }
+  handleRouteFailure() {
+    this.ignoreHashChange = true;
+    location.hash = this.format({
+      id: this.routeForID(this.config.defaultRouteID).id
+    });
+    this.ignoreHashChange = false;
+    return true;
+  }
 }
+export {
+  HTMLRouter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/router",
-  "version": "3.2.42",
+  "version": "3.2.44",
   "description": "Generic router for browser & non-browser based applications",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,15 +35,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/equiv": "^2.1.35",
-    "@thi.ng/errors": "^2.4.4",
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/equiv": "^2.1.37",
+    "@thi.ng/errors": "^2.4.6",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -90,5 +92,5 @@
     ],
     "year": 2014
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }