@pirxpilot/router 1.1.0 → 2.0.1

package/lib/layer.js

@@ -1,60 +1,17 @@
-/*!
- * router
- * Copyright(c) 2013 Roman Shtylman
- * Copyright(c) 2014-2022 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-const pathRegexp = require('path-to-regexp')
-
-/**
- * Module variables.
- * @private
- */
-
-const TRAILING_SLASH_REGEXP = /\/+$/
-const MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g
-
-/**
- * Expose `Layer`.
- */
+import matcher from './matcher.js';
 
-module.exports = Layer
-
-function Layer (path, opts = {}, fn, method) {
+export default function Layer(path, opts = {}, fn, method) {
   if (typeof fn !== 'function') {
-    throw new TypeError('argument handler must be a function')
+    throw new TypeError('argument handler must be a function');
   }
-  this.handle = fn
-  this.keys = []
-  this.name = fn.name || '<anonymous>'
-  this.params = undefined
-  this.path = undefined
-  this.slash = path === '/' && opts.end === false
-  this.matchers = this.slash
-    ? []
-    : Array.isArray(path)
-      ? path.map(p => matcher(p, opts))
-      : [matcher(path, opts)]
-  this.method = method
-}
-
-function matcher (path, { sensitive, end, strict }) {
-  return path instanceof RegExp
-    ? createRegexMatcher(path)
-    : pathRegexp.match((strict ? path : loosen(path)), {
-      sensitive,
-      end,
-      trailing: !strict,
-      decode: decodeParam
-    })
+  this.handle = fn;
+  this.keys = [];
+  this.name = fn.name || '<anonymous>';
+  this.params = undefined;
+  this.path = undefined;
+  this.slash = path === '/' && opts.end === false;
+  this.matchers = this.slash ? [] : Array.isArray(path) ? path.map(p => matcher(p, opts)) : [matcher(path, opts)];
+  this.method = method;
 }
 
 /**
@@ -67,26 +24,26 @@ function matcher (path, { sensitive, end, strict }) {
  * @api private
  */
 
-Layer.prototype.handleError = function handleError (error, req, res, next) {
-  const fn = this.handle
+Layer.prototype.handleError = function handleError(error, req, res, next) {
+  const fn = this.handle;
 
   if (fn.length !== 4) {
     // not a standard error handler
-    return next(error)
+    return next(error);
   }
 
   try {
     // invoke function
-    const ret = fn(error, req, res, next)
+    const ret = fn(error, req, res, next);
 
     // wait for returned promise
     if (ret instanceof Promise) {
-      ret.catch((error = new Error('Rejected promise')) => next(error))
+      ret.catch((error = new Error('Rejected promise')) => next(error));
     }
   } catch (err) {
-    next(err)
+    next(err);
   }
-}
+};
 
 /**
  * Handle the request for the layer.
@@ -97,26 +54,26 @@ Layer.prototype.handleError = function handleError (error, req, res, next) {
  * @api private
  */
 
-Layer.prototype.handleRequest = function handleRequest (req, res, next) {
-  const fn = this.handle
+Layer.prototype.handleRequest = function handleRequest(req, res, next) {
+  const fn = this.handle;
 
   if (fn.length > 3) {
     // not a standard request handler
-    return next()
+    return next();
   }
 
   try {
     // invoke function
-    const ret = fn(req, res, next)
+    const ret = fn(req, res, next);
 
     // wait for returned promise
     if (ret instanceof Promise) {
-      ret.catch((error = new Error('Rejected promise')) => next(error))
+      ret.catch((error = new Error('Rejected promise')) => next(error));
     }
   } catch (err) {
-    next(err)
+    next(err);
   }
-}
+};
 
 /**
  * Check if this route matches `path`, if so
@@ -127,101 +84,28 @@ Layer.prototype.handleRequest = function handleRequest (req, res, next) {
  * @api private
  */
 
-Layer.prototype.match = function match (path) {
+Layer.prototype.match = function match(path) {
   if (path != null) {
     // fast path non-ending match for / (any path matches)
     if (this.slash) {
-      this.params = {}
-      this.path = ''
-      return true
+      this.params = {};
+      this.path = '';
+      return true;
     }
 
     for (const matcher of this.matchers) {
-      const matched = matcher(path)
+      const matched = matcher(path);
       if (matched) {
         // store values
-        this.params = matched.params
-        this.path = matched.path
-        this.keys = Object.keys(matched.params)
-        return true
+        this.params = matched.params;
+        this.path = matched.path;
+        this.keys = matched.keys;
+        return true;
       }
     }
   }
 
-  this.params = undefined
-  this.path = undefined
-  return false
-}
-
-function createRegexMatcher (path) {
-  const keys = []
-  let name = 0
-
-  for (const m of path.source.matchAll(MATCHING_GROUP_REGEXP)) {
-    keys.push({
-      name: m[1] || name++,
-      offset: m.index
-    })
-  }
-
-  return function regexpMatcher (p) {
-    const match = path.exec(p)
-    if (!match) {
-      return false
-    }
-
-    const params = {}
-    for (let i = 1; i < match.length; i++) {
-      const key = keys[i - 1]
-      const prop = key.name
-      const val = decodeParam(match[i])
-
-      if (val !== undefined) {
-        params[prop] = val
-      }
-    }
-
-    return {
-      params,
-      path: match[0]
-    }
-  }
-}
-
-/**
- * Decode param value.
- *
- * @param {string} val
- * @return {string}
- * @private
- */
-
-function decodeParam (val) {
-  if (typeof val !== 'string' || val.length === 0) {
-    return val
-  }
-
-  try {
-    return decodeURIComponent(val)
-  } catch (err) {
-    if (err instanceof URIError) {
-      err.message = `Failed to decode param '${val}'`
-      err.status = 400
-    }
-
-    throw err
-  }
-}
-
-/**
- * Loosens the given path for path-to-regexp matching.
- */
-function loosen (path) {
-  if (path instanceof RegExp || path === '/') {
-    return path
-  }
-
-  return Array.isArray(path)
-    ? path.map(p => loosen(p))
-    : String(path).replace(TRAILING_SLASH_REGEXP, '')
-}
+  this.params = undefined;
+  this.path = undefined;
+  return false;
+};

package/lib/matcher.js

@@ -0,0 +1,147 @@
+const MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g;
+
+export default function matcher(path, { sensitive = false, end = true, strict = false } = {}) {
+  return path instanceof RegExp
+    ? createRegexMatcher(path)
+    : createURLPatternMatcher(path, {
+        sensitive,
+        end,
+        strict
+      });
+}
+
+export function createRegexMatcher(path) {
+  const regexKeys = [];
+  let name = 0;
+
+  for (const m of path.source.matchAll(MATCHING_GROUP_REGEXP)) {
+    regexKeys.push({
+      name: m[1] || name++,
+      offset: m.index
+    });
+  }
+
+  return function regexpMatcher(p) {
+    const match = path.exec(p);
+    if (!match) {
+      return false;
+    }
+
+    const params = {};
+    const keys = [];
+    for (let i = 1; i < match.length; i++) {
+      const { name } = regexKeys[i - 1];
+      const val = decodeParam(match[i]);
+
+      if (val !== undefined) {
+        keys.push(name);
+        params[name] = val;
+      }
+    }
+
+    return {
+      params,
+      keys,
+      path: match[0]
+    };
+  };
+}
+
+const parameterRegex = /:([a-zA-Z_]\w*)/g;
+
+export function createURLPatternMatcher(pathname, { sensitive, end, strict }) {
+  // Extract parameter names from the pattern in order
+  const parameterOrder = new Set(pathname.matchAll(parameterRegex).map(m => m[1]));
+
+  // Build the pattern:
+  // - For end=false (prefix matching): add {/*}? to match optional trailing content
+  // - For end=true with trailing=true: add {/}? to match optional trailing slash
+
+  if (!end) {
+    if (pathname.endsWith('/')) pathname = pathname.slice(0, -1);
+    pathname += '{/*}?';
+  } else if (!strict) {
+    if (pathname.endsWith('/')) pathname = pathname.slice(0, -1);
+    pathname += '{/}?';
+  }
+
+  const pattern = new URLPattern({ pathname }, { ignoreCase: !sensitive });
+
+  return function urlPatternMatcher(p) {
+    const match = pattern.exec(p);
+    if (!match) {
+      return false;
+    }
+
+    const params = {};
+    const keys = [];
+
+    // Process parameters in the order they appear in the pattern
+    // Use the preserved parameter order
+    for (const key of parameterOrder) {
+      const value = match.pathname.groups[key];
+      if (value !== undefined) {
+        keys.push(key);
+        params[key] = decodeParam(value);
+      }
+    }
+
+    // Also handle any additional groups not in parameterOrder (e.g., numbered groups)
+    for (const [key, value] of Object.entries(match.pathname.groups)) {
+      // Skip the default wildcard capture group '0'
+      if (key === '0') continue;
+      // Skip if we already processed this key
+      if (parameterOrder.has(key)) continue;
+      if (value !== undefined) {
+        keys.push(key);
+        params[key] = decodeParam(value);
+      }
+    }
+
+    // For prefix matching, calculate the matched path length
+    let matchedPath = match.pathname.input;
+    if (!end) {
+      // Remove the wildcard matched portion to get just the prefix
+      const wildcardMatch = match.pathname.groups['0'];
+      if (wildcardMatch !== undefined && wildcardMatch !== '') {
+        // The wildcard captures content after the /, so we need to remove "/" + wildcard
+        matchedPath = matchedPath.slice(0, -(wildcardMatch.length + 1));
+      } else if (wildcardMatch === '') {
+        // Empty string means we matched a trailing slash: /foo/ with pattern /foo{/*}?
+        // Remove the trailing slash to normalize
+        matchedPath = matchedPath.slice(0, -1);
+      }
+    }
+
+    return {
+      params,
+      keys,
+      path: matchedPath
+    };
+  };
+}
+
+/**
+ * Decode param value.
+ *
+ * @param {string} val
+ * @return {string}
+ * @private
+ */
+
+export function decodeParam(val) {
+  if (typeof val !== 'string' || val.length === 0) {
+    return val;
+  }
+
+  try {
+    return decodeURIComponent(val);
+  } catch (err) {
+    if (err instanceof URIError) {
+      err.message = `Failed to decode param '${val}'`;
+      err.status = 400;
+    }
+
+    throw err;
+  }
+}

package/lib/route.js

@@ -1,30 +1,5 @@
-/*!
- * router
- * Copyright(c) 2013 Roman Shtylman
- * Copyright(c) 2014-2022 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-'use strict'
-
-/**
- * Module dependencies.
- * @private
- */
-
-const { METHODS } = require('node:http')
-const Layer = require('./layer')
-
-/**
- * Module variables.
- * @private
- */
-
-/**
- * Expose `Route`.
- */
-
-module.exports = Route
+import { METHODS } from 'node:http';
+import Layer from './layer.js';
 
 /**
  * Initialize `Route` with the given `path`,
@@ -33,45 +8,41 @@ module.exports = Route
  * @api private
  */
 
-function Route (path) {
-  this.path = path
-  this.stack = []
+export default function Route(path) {
+  this.path = path;
+  this.stack = [];
 
   // route handlers for various http methods
-  this.methods = new Set()
+  this.methods = new Set();
 }
 
-/**
- * @private
- */
-
-Route.prototype._handlesMethod = function _handlesMethod (method) {
+Route.prototype._handlesMethod = function _handlesMethod(method) {
   if (this.methods._all) {
-    return true
+    return true;
   }
 
   if (method === 'HEAD' && !this.methods.has('HEAD')) {
-    method = 'GET'
+    method = 'GET';
   }
 
-  return this.methods.has(method)
-}
+  return this.methods.has(method);
+};
 
 /**
  * @return {array} supported HTTP methods
  * @private
  */
 
-Route.prototype._methods = function _methods () {
-  const methods = [...this.methods]
+Route.prototype._methods = function _methods() {
+  const methods = [...this.methods];
 
   // append automatic head
   if (this.methods.has('GET') && !this.methods.has('HEAD')) {
-    methods.push('HEAD')
+    methods.push('HEAD');
   }
 
-  return methods
-}
+  return methods;
+};
 
 /**
  * dispatch req, res into this route
@@ -79,71 +50,71 @@ Route.prototype._methods = function _methods () {
  * @private
  */
 
-Route.prototype.dispatch = function dispatch (req, res, done) {
-  let idx = 0
-  const stack = this.stack
-  let sync = 0
+Route.prototype.dispatch = function dispatch(req, res, done) {
+  let idx = 0;
+  const stack = this.stack;
+  let sync = 0;
 
   if (stack.length === 0) {
-    return done()
+    return done();
   }
 
-  let { method } = req
+  let { method } = req;
   if (method === 'HEAD' && !this.methods.has('HEAD')) {
-    method = 'GET'
+    method = 'GET';
   }
 
-  req.route = this
+  req.route = this;
 
-  next()
+  next();
 
-  function next (err) {
+  function next(err) {
     // signal to exit route
     if (err && err === 'route') {
-      return done()
+      return done();
     }
 
     // signal to exit router
     if (err && err === 'router') {
-      return done(err)
+      return done(err);
     }
 
     // no more matching layers
     if (idx >= stack.length) {
-      return done(err)
+      return done(err);
     }
 
     // max sync stack
     if (++sync > 100) {
-      return setImmediate(next, err)
+      return setImmediate(next, err);
     }
 
-    let layer
-    let match
+    let layer;
+    let match;
 
     // find next matching layer
     while (idx < stack.length) {
-      layer = stack[idx++]
-      match = !layer.method || layer.method === method
+      layer = stack[idx++];
+      match = !layer.method || layer.method === method;
       if (match) {
-        break
+        break;
       }
     }
 
     // no match
     if (match !== true) {
-      return done(err)
+      return done(err);
     }
 
     if (err) {
-      layer.handleError(err, req, res, next)
+      layer.handleError(err, req, res, next);
     } else {
-      layer.handleRequest(req, res, next)
+      layer.handleRequest(req, res, next);
     }
 
-    sync = 0
+    sync = 0;
   }
-}
+};
 
 /**
  * Add a handler for all HTTP verbs to this route.
@@ -173,31 +144,30 @@ Route.prototype.dispatch = function dispatch (req, res, done) {
  * @api public
  */
 
-Route.prototype.all = function all (...args) {
-  const callbacks = args.flat(Infinity)
+Route.prototype.all = function all(...args) {
+  const callbacks = args.flat(Number.POSITIVE_INFINITY);
 
   if (callbacks.length === 0) {
-    throw new TypeError('argument handler is required')
+    throw new TypeError('argument handler is required');
   }
 
-  this.methods._all = true
-  this.stack.push(...callbacks.map(fn => new Layer('/', {}, fn)))
+  this.methods._all = true;
+  this.stack.push(...callbacks.map(fn => new Layer('/', {}, fn)));
 
-  return this
-}
+  return this;
+};
 
-METHODS
-  .forEach(method => {
-    Route.prototype[method.toLowerCase()] = function (...args) {
-      const callbacks = args.flat(Infinity)
+METHODS.forEach(method => {
+  Route.prototype[method.toLowerCase()] = function (...args) {
+    const callbacks = args.flat(Number.POSITIVE_INFINITY);
 
-      if (callbacks.length === 0) {
-        throw new TypeError('argument handler is required')
-      }
+    if (callbacks.length === 0) {
+      throw new TypeError('argument handler is required');
+    }
 
-      this.methods.add(method)
-      this.stack.push(...callbacks.map(fn => new Layer('/', {}, fn, method)))
+    this.methods.add(method);
+    this.stack.push(...callbacks.map(fn => new Layer('/', {}, fn, method)));
 
-      return this
-    }
-  })
+    return this;
+  };
+});

package/package.json

@@ -1,35 +1,32 @@
 {
   "name": "@pirxpilot/router",
   "description": "Simple middleware-style router",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "author": "Douglas Christopher Wilson <doug@somethingdoug.com>",
   "contributors": [
     "Blake Embrey <hello@blakeembrey.com>"
   ],
   "license": "MIT",
+  "exports": "./index.js",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pirxpilot/router.git"
   },
   "dependencies": {
-    "parseurl": "~1",
-    "path-to-regexp": "~8"
+    "parseurl": "~1"
   },
   "devDependencies": {
-    "finalhandler": "~1",
-    "standard": "~17",
+    "@biomejs/biome": "2.3.1",
+    "finalhandler": "~2",
     "supertest": "~7"
   },
   "files": [
     "lib/",
-    "LICENSE",
-    "HISTORY.md",
-    "README.md",
-    "SECURITY.md",
     "index.js"
   ],
   "engines": {
-    "node": ">= 0.10"
+    "node": ">= 23.8.0"
   },
   "scripts": {
     "test": "make check"