@pirxpilot/router 1.1.0 → 2.0.1

package/index.js

@@ -1,38 +1,11 @@
-/*!
- * 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('./lib/layer')
-const parseUrl = require('parseurl')
-const Route = require('./lib/route')
+import { METHODS } from 'node:http';
+import parseUrl from 'parseurl';
+import Layer from './lib/layer.js';
+import Route from './lib/route.js';
 
-/**
- * Module variables.
- * @private
- */
-
-/**
- * Expose `Router`.
- */
+export { Route };
 
-module.exports = Router
-
-/**
- * Expose `Route`.
- */
-
-module.exports.Route = Route
+Router.Route = Route;
 
 /**
  * Initialize a new `Router` with the given `options`.
@@ -42,35 +15,32 @@ module.exports.Route = Route
  * @public
  */
 
-function Router (options) {
+export default function Router(options = {}) {
   if (!(this instanceof Router)) {
-    return new Router(options)
+    return new Router(options);
   }
 
-  const opts = options || {}
-
-  function router (req, res, next) {
-    router.handle(req, res, next)
+  function router(req, res, next) {
+    router.handle(req, res, next);
   }
 
   // inherit from the correct prototype
-  Object.setPrototypeOf(router, this)
+  Object.setPrototypeOf(router, this);
 
-  router.caseSensitive = opts.caseSensitive
-  router.mergeParams = opts.mergeParams
-  router.params = {}
-  router.strict = opts.strict
-  router.stack = []
+  router.caseSensitive = options.caseSensitive;
+  router.mergeParams = options.mergeParams;
+  router.params = {};
+  router.strict = options.strict;
+  router.stack = [];
 
-  return router
+  return router;
 }
 
 /**
  * Router prototype inherits from a Function.
  */
 
-/* istanbul ignore next */
-Router.prototype = function () {}
+Router.prototype = () => {};
 
 /**
  * Map the given param placeholder `name`(s) to the given callback.
@@ -105,233 +75,225 @@ Router.prototype = function () {}
  * @public
  */
 
-Router.prototype.param = function param (name, fn) {
+Router.prototype.param = function param(name, fn) {
   if (!name) {
-    throw new TypeError('argument name is required')
+    throw new TypeError('argument name is required');
   }
 
   if (typeof name !== 'string') {
-    throw new TypeError('argument name must be a string')
+    throw new TypeError('argument name must be a string');
   }
 
   if (!fn) {
-    throw new TypeError('argument fn is required')
+    throw new TypeError('argument fn is required');
   }
 
   if (typeof fn !== 'function') {
-    throw new TypeError('argument fn must be a function')
+    throw new TypeError('argument fn must be a function');
   }
 
-  let params = this.params[name]
+  let params = this.params[name];
 
   if (!params) {
-    params = this.params[name] = []
+    params = this.params[name] = [];
   }
 
-  params.push(fn)
+  params.push(fn);
 
-  return this
-}
+  return this;
+};
 
 /**
  * Dispatch a req, res into the router.
- *
- * @private
  */
 
-Router.prototype.handle = function handle (req, res, callback) {
+Router.prototype.handle = function handle(req, res, callback) {
   if (!callback) {
-    throw new TypeError('argument callback is required')
+    throw new TypeError('argument callback is required');
   }
 
-  let idx = 0
-  let methods
-  const protohost = getProtohost(req.url) || ''
-  let removed = ''
-  const self = this
-  let slashAdded = false
-  let sync = 0
-  const paramcalled = {}
+  let idx = 0;
+  let methods;
+  const protohost = getProtohost(req.url) || '';
+  let removed = '';
+  const self = this;
+  let slashAdded = false;
+  let sync = 0;
+  const paramcalled = {};
 
   // middleware and routes
-  const stack = this.stack
+  const stack = this.stack;
 
   // manage inter-router variables
-  const parentParams = req.params
-  const parentUrl = req.baseUrl || ''
-  let done = restore(callback, req, 'baseUrl', 'next', 'params')
+  const parentParams = req.params;
+  const parentUrl = req.baseUrl || '';
+  let done = restore(callback, req, 'baseUrl', 'next', 'params');
 
   // setup next layer
-  req.next = next
+  req.next = next;
 
   // for options requests, respond with a default if nothing else responds
   if (req.method === 'OPTIONS') {
-    methods = []
-    done = wrap(done, generateOptionsResponder(res, methods))
+    methods = [];
+    done = wrap(done, generateOptionsResponder(res, methods));
   }
 
   // setup basic req values
-  req.baseUrl = parentUrl
-  req.originalUrl = req.originalUrl || req.url
+  req.baseUrl = parentUrl;
+  req.originalUrl = req.originalUrl || req.url;
 
-  next()
+  next();
 
-  function next (err) {
-    let layerError = err === 'route'
-      ? null
-      : err
+  function next(err) {
+    let layerError = err === 'route' ? null : err;
 
     // remove added slash
     if (slashAdded) {
-      req.url = req.url.slice(1)
-      slashAdded = false
+      req.url = req.url.slice(1);
+      slashAdded = false;
     }
 
     // restore altered req.url
     if (removed.length !== 0) {
-      req.baseUrl = parentUrl
-      req.url = protohost + removed + req.url.slice(protohost.length)
-      removed = ''
+      req.baseUrl = parentUrl;
+      req.url = protohost + removed + req.url.slice(protohost.length);
+      removed = '';
     }
 
     // signal to exit router
     if (layerError === 'router') {
-      setImmediate(done, null)
-      return
+      setImmediate(done, null);
+      return;
     }
 
     // no more matching layers
     if (idx >= stack.length) {
-      setImmediate(done, layerError)
-      return
+      setImmediate(done, layerError);
+      return;
     }
 
     // max sync stack
     if (++sync > 100) {
-      return setImmediate(next, err)
+      return setImmediate(next, err);
     }
 
     // get pathname of request
-    const path = getPathname(req)
+    const path = getPathname(req);
 
     if (path == null) {
-      return done(layerError)
+      return done(layerError);
     }
 
     // find next matching layer
-    let layer
-    let match
-    let route
+    let layer;
+    let match;
+    let route;
 
     while (match !== true && idx < stack.length) {
-      layer = stack[idx++]
-      match = matchLayer(layer, path)
-      route = layer.route
+      layer = stack[idx++];
+      match = matchLayer(layer, path);
+      route = layer.route;
 
       if (typeof match !== 'boolean') {
         // hold on to layerError
-        layerError = layerError || match
+        layerError = layerError || match;
       }
 
       if (match !== true) {
-        continue
+        continue;
       }
 
       if (!route) {
         // process non-route handlers normally
-        continue
+        continue;
       }
 
       if (layerError) {
         // routes do not match with a pending error
-        match = false
-        continue
+        match = false;
+        continue;
       }
 
-      const method = req.method
-      const hasMethod = route._handlesMethod(method)
+      const method = req.method;
+      const hasMethod = route._handlesMethod(method);
 
       // build up automatic options response
       if (!hasMethod && method === 'OPTIONS' && methods) {
-        methods.push.apply(methods, route._methods())
+        methods.push.apply(methods, route._methods());
       }
 
       // don't even bother matching route
       if (!hasMethod && method !== 'HEAD') {
-        match = false
-        continue
+        match = false;
       }
     }
 
     // no match
     if (match !== true) {
-      return done(layerError)
+      return done(layerError);
     }
 
     // store route for dispatch on change
     if (route) {
-      req.route = route
+      req.route = route;
     }
 
     // Capture one-time layer values
-    req.params = self.mergeParams
-      ? mergeParams(layer.params, parentParams)
-      : layer.params
-    const layerPath = layer.path
+    req.params = self.mergeParams ? mergeParams(layer.params, parentParams) : layer.params;
+    const layerPath = layer.path;
 
     // this should be done for the layer
-    processParams(self.params, layer, paramcalled, req, res, function (err) {
+    processParams(self.params, layer, paramcalled, req, res, err => {
       if (err) {
-        next(layerError || err)
+        next(layerError || err);
       } else if (route) {
-        layer.handleRequest(req, res, next)
+        layer.handleRequest(req, res, next);
       } else {
-        trimPrefix(layer, layerError, layerPath, path)
+        trimPrefix(layer, layerError, layerPath, path);
       }
 
-      sync = 0
-    })
+      sync = 0;
+    });
   }
 
-  function trimPrefix (layer, layerError, layerPath, path) {
+  function trimPrefix(layer, layerError, layerPath, path) {
     if (layerPath.length !== 0) {
       // Validate path is a prefix match
       if (layerPath !== path.substring(0, layerPath.length)) {
-        next(layerError)
-        return
+        next(layerError);
+        return;
       }
 
       // Validate path breaks on a path separator
-      const c = path[layerPath.length]
+      const c = path[layerPath.length];
       if (c && c !== '/') {
-        next(layerError)
-        return
+        next(layerError);
+        return;
       }
 
       // Trim off the part of the url that matches the route
       // middleware (.use stuff) needs to have the path stripped
-      removed = layerPath
-      req.url = protohost + req.url.slice(protohost.length + removed.length)
+      removed = layerPath;
+      req.url = protohost + req.url.slice(protohost.length + removed.length);
 
       // Ensure leading slash
       if (!protohost && req.url[0] !== '/') {
-        req.url = '/' + req.url
-        slashAdded = true
+        req.url = `/${req.url}`;
+        slashAdded = true;
       }
 
       // Setup base URL (no trailing slash)
-      req.baseUrl = parentUrl + (removed[removed.length - 1] === '/'
-        ? removed.substring(0, removed.length - 1)
-        : removed)
+      req.baseUrl =
+        parentUrl + (removed[removed.length - 1] === '/' ? removed.substring(0, removed.length - 1) : removed);
     }
 
     if (layerError) {
-      layer.handleError(layerError, req, res, next)
+      layer.handleError(layerError, req, res, next);
     } else {
-      layer.handleRequest(req, res, next)
+      layer.handleRequest(req, res, next);
     }
   }
-}
+};
 
 /**
  * Use the given middleware function, with optional path, defaulting to "/".
@@ -348,51 +310,57 @@ Router.prototype.handle = function handle (req, res, callback) {
  * @public
  */
 
-Router.prototype.use = function use (handler, ...args) {
-  let path = '/'
+Router.prototype.use = function use(handler, ...args) {
+  let path = '/';
 
   // default path to '/'
   // disambiguate router.use([handler])
   if (typeof handler !== 'function') {
-    let arg = handler
+    let arg = handler;
 
     while (Array.isArray(arg) && arg.length !== 0) {
-      arg = arg[0]
+      arg = arg[0];
     }
 
     // first arg is the path
     if (typeof arg !== 'function') {
-      path = handler
-      handler = undefined
+      path = handler;
+      handler = undefined;
     }
   }
   if (handler !== undefined) {
-    args.unshift(handler)
+    args.unshift(handler);
   }
-  const callbacks = args.flat(Infinity)
+  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.stack.push(...callbacks.map(fn => {
-    if (typeof fn !== 'function') {
-      throw new TypeError('argument handler must be a function')
-    }
-
-    // add the middleware
-    const layer = new Layer(path, {
-      sensitive: this.caseSensitive,
-      strict: false,
-      end: false
-    }, fn)
+  this.stack.push(
+    ...callbacks.map(fn => {
+      if (typeof fn !== 'function') {
+        throw new TypeError('argument handler must be a function');
+      }
 
-    layer.route = undefined
-    return layer
-  }))
+      // add the middleware
+      const layer = new Layer(
+        path,
+        {
+          sensitive: this.caseSensitive,
+          strict: false,
+          end: false
+        },
+        fn
+      );
+
+      layer.route = undefined;
+      return layer;
+    })
+  );
 
-  return this
-}
+  return this;
+};
 
 /**
  * Create a new Route for the given path.
@@ -407,66 +375,68 @@ Router.prototype.use = function use (handler, ...args) {
  * @public
  */
 
-Router.prototype.route = function route (path) {
-  const route = new Route(path)
+Router.prototype.route = function route(path) {
+  const route = new Route(path);
 
-  const layer = new Layer(path, {
-    sensitive: this.caseSensitive,
-    strict: this.strict,
-    end: true
-  }, handle)
-
-  function handle (req, res, next) {
-    route.dispatch(req, res, next)
+  const layer = new Layer(
+    path,
+    {
+      sensitive: this.caseSensitive,
+      strict: this.strict,
+      end: true
+    },
+    handle
+  );
+
+  function handle(req, res, next) {
+    route.dispatch(req, res, next);
   }
 
-  layer.route = route
+  layer.route = route;
 
-  this.stack.push(layer)
-  return route
-}
+  this.stack.push(layer);
+  return route;
+};
 
 // create Router#VERB functions
 METHODS.concat('all')
   .map(m => m.toLowerCase())
   .forEach(method => {
     Router.prototype[method] = function (path, ...args) {
-      const route = this.route(path)
-      route[method].apply(route, args)
-      return this
-    }
-  })
+      const route = this.route(path);
+      route[method].apply(route, args);
+      return this;
+    };
+  });
 
 /**
  * Generate a callback that will make an OPTIONS response.
  *
  * @param {OutgoingMessage} res
  * @param {array} methods
- * @private
  */
 
-function generateOptionsResponder (res, methods) {
-  return function onDone (fn, err) {
+function generateOptionsResponder(res, methods) {
+  return function onDone(fn, err) {
     if (err || methods.length === 0) {
-      return fn(err)
+      return fn(err);
     }
 
-    trySendOptionsResponse(res, methods, fn)
-  }
+    trySendOptionsResponse(res, methods, fn);
+  };
 }
 
 /**
  * Get pathname of request.
  *
  * @param {IncomingMessage} req
- * @private
  */
 
-function getPathname (req) {
+function getPathname(req) {
   try {
-    return parseUrl(req).pathname
-  } catch (err) {
-    return undefined
+    return parseUrl(req).pathname;
+  } catch (_err) {
+    return undefined;
   }
 }
 
@@ -474,23 +444,18 @@ function getPathname (req) {
  * Get get protocol + host for a URL.
  *
  * @param {string} url
- * @private
  */
 
-function getProtohost (url) {
+function getProtohost(url) {
   if (typeof url !== 'string' || url.length === 0 || url[0] === '/') {
-    return undefined
+    return undefined;
   }
 
-  const searchIndex = url.indexOf('?')
-  const pathLength = searchIndex !== -1
-    ? searchIndex
-    : url.length
-  const fqdnIndex = url.substring(0, pathLength).indexOf('://')
+  const searchIndex = url.indexOf('?');
+  const pathLength = searchIndex !== -1 ? searchIndex : url.length;
+  const fqdnIndex = url.substring(0, pathLength).indexOf('://');
 
-  return fqdnIndex !== -1
-    ? url.substring(0, url.indexOf('/', 3 + fqdnIndex))
-    : undefined
+  return fqdnIndex !== -1 ? url.substring(0, url.indexOf('/', 3 + fqdnIndex)) : undefined;
 }
 
 /**
@@ -498,219 +463,205 @@ function getProtohost (url) {
  *
  * @param {Layer} layer
  * @param {string} path
- * @private
  */
 
-function matchLayer (layer, path) {
+function matchLayer(layer, path) {
   try {
-    return layer.match(path)
+    return layer.match(path);
   } catch (err) {
-    return err
+    return err;
   }
 }
 
 /**
  * Merge params with parent params
- *
- * @private
  */
 
-function mergeParams (params, parent) {
+function mergeParams(params, parent) {
   if (typeof parent !== 'object' || !parent) {
-    return params
+    return params;
   }
 
   // make copy of parent for base
-  const obj = { ...parent }
+  const obj = { ...parent };
 
   // simple non-numeric merging
   if (!(0 in params) || !(0 in parent)) {
-    return Object.assign(obj, params)
+    return Object.assign(obj, params);
   }
 
-  let i = 0
-  let o = 0
+  let i = 0;
+  let o = 0;
 
   // determine numeric gap in params
   while (i in params) {
-    i++
+    i++;
   }
 
   // determine numeric gap in parent
   while (o in parent) {
-    o++
+    o++;
   }
 
   // offset numeric indices in params before merge
   for (i--; i >= 0; i--) {
-    params[i + o] = params[i]
+    params[i + o] = params[i];
 
     // create holes for the merge when necessary
     if (i < o) {
-      delete params[i]
+      delete params[i];
     }
   }
 
-  return Object.assign(obj, params)
+  return Object.assign(obj, params);
 }
 
 /**
  * Process any parameters for the layer.
- *
- * @private
  */
 
-function processParams (params, layer, called, req, res, done) {
+function processParams(params, layer, called, req, res, done) {
   // captured parameters from the layer, keys and values
-  const keys = layer.keys
+  const keys = layer.keys;
 
   // fast track
   if (!keys || keys.length === 0) {
-    return done()
+    return done();
   }
 
-  let i = 0
-  let paramIndex = 0
-  let key
-  let paramVal
-  let paramCallbacks
-  let paramCalled
+  let i = 0;
+  let paramIndex = 0;
+  let key;
+  let paramVal;
+  let paramCallbacks;
+  let paramCalled;
 
   // process params in order
   // param callbacks can be async
-  function param (err) {
+  function param(err) {
     if (err) {
-      return done(err)
+      return done(err);
     }
 
     if (i >= keys.length) {
-      return done()
+      return done();
     }
 
-    paramIndex = 0
-    key = keys[i++]
-    paramVal = req.params[key]
-    paramCallbacks = params[key]
-    paramCalled = called[key]
+    paramIndex = 0;
+    key = keys[i++];
+    paramVal = req.params[key];
+    paramCallbacks = params[key];
+    paramCalled = called[key];
 
     if (paramVal === undefined || !paramCallbacks) {
-      return param()
+      return param();
     }
 
     // param previously called with same value or error occurred
-    if (paramCalled && (paramCalled.match === paramVal ||
-      (paramCalled.error && paramCalled.error !== 'route'))) {
+    if (paramCalled && (paramCalled.match === paramVal || (paramCalled.error && paramCalled.error !== 'route'))) {
       // restore value
-      req.params[key] = paramCalled.value
+      req.params[key] = paramCalled.value;
 
       // next param
-      return param(paramCalled.error)
+      return param(paramCalled.error);
     }
 
     called[key] = paramCalled = {
       error: null,
       match: paramVal,
       value: paramVal
-    }
+    };
 
-    paramCallback()
+    paramCallback();
   }
 
   // single param callbacks
-  function paramCallback (err) {
-    const fn = paramCallbacks[paramIndex++]
+  function paramCallback(err) {
+    const fn = paramCallbacks[paramIndex++];
 
     // store updated value
-    paramCalled.value = req.params[key]
+    paramCalled.value = req.params[key];
 
     if (err) {
       // store error
-      paramCalled.error = err
-      param(err)
-      return
+      paramCalled.error = err;
+      param(err);
+      return;
     }
 
-    if (!fn) return param()
+    if (!fn) return param();
 
     try {
-      const ret = fn(req, res, paramCallback, paramVal, key)
+      const ret = fn(req, res, paramCallback, paramVal, key);
       if (ret instanceof Promise) {
-        ret.catch((error = new Error('Rejected promise')) => paramCallback(error))
+        ret.catch((error = new Error('Rejected promise')) => paramCallback(error));
       }
     } catch (e) {
-      paramCallback(e)
+      paramCallback(e);
     }
   }
 
-  param()
+  param();
 }
 
 /**
  * Restore obj props after function
- *
- * @private
  */
 
-function restore (fn, obj, ...props) {
-  const vals = props.map(prop => obj[prop])
+function restore(fn, obj, ...props) {
+  const vals = props.map(prop => obj[prop]);
 
-  return function () {
+  return function (...args) {
     // restore vals
     for (let i = 0; i < props.length; i++) {
-      obj[props[i]] = vals[i]
+      obj[props[i]] = vals[i];
     }
 
-    return fn.apply(this, arguments)
-  }
+    return fn.apply(this, args);
+  };
 }
 
 /**
  * Send an OPTIONS response.
- *
- * @private
  */
 
-function sendOptionsResponse (res, methods) {
-  const options = Object.create(null)
+function sendOptionsResponse(res, methods) {
+  const options = Object.create(null);
 
   // build unique method map
   for (let i = 0; i < methods.length; i++) {
-    options[methods[i]] = true
+    options[methods[i]] = true;
   }
 
   // construct the allow list
-  const allow = Object.keys(options).sort().join(', ')
+  const allow = Object.keys(options).sort().join(', ');
 
   // send response
-  res.setHeader('Allow', allow)
-  res.setHeader('Content-Length', Buffer.byteLength(allow))
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('X-Content-Type-Options', 'nosniff')
-  res.end(allow)
+  res.setHeader('Allow', allow);
+  res.setHeader('Content-Length', Buffer.byteLength(allow));
+  res.setHeader('Content-Type', 'text/plain');
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  res.end(allow);
 }
 
 /**
  * Try to send an OPTIONS response.
- *
- * @private
  */
 
-function trySendOptionsResponse (res, methods, next) {
+function trySendOptionsResponse(res, methods, next) {
   try {
-    sendOptionsResponse(res, methods)
+    sendOptionsResponse(res, methods);
   } catch (err) {
-    next(err)
+    next(err);
   }
 }
 
 /**
  * Wrap a function
- *
- * @private
  */
 
-function wrap (old, fn) {
-  return function proxy (...args) {
-    fn.call(this, old, ...args)
-  }
+function wrap(old, fn) {
+  return function proxy(...args) {
+    fn.call(this, old, ...args);
+  };
 }