fulmine.js 5.0.0 → 5.1.0

package/src/utils.js

@@ -102,8 +102,10 @@ function getPatternMeta(pattern) {
  * throw: a route that quietly stops matching is worse than one that fails at startup. The names it
  * captures go in a WeakMap beside the regex, see PatternMeta.
  */
-function patternToRegex(pattern, isPrefix = false) {
+function patternToRegex(pattern, isPrefix = false, caseSensitive = true) {
     if (pattern instanceof RegExp) {
+        // the application's own RegExp matches as written, whatever the routing setting says,
+        // which is what express does with one
         return pattern;
     }
     if (isPrefix && pattern === "") {
@@ -247,7 +249,9 @@ function patternToRegex(pattern, isPrefix = false) {
         i++;
     }
 
-    const regex = /** @type {PathRegExp} */ (new RegExp(`^${regexPattern}${isPrefix ? "(?=$|/)" : "$"}`));
+    const regex = /** @type {PathRegExp} */ (
+        new RegExp(`^${regexPattern}${isPrefix ? "(?=$|/)" : "$"}`, caseSensitive ? "" : "i")
+    );
     // read back out of the finished pattern, so the list cannot disagree with the regex. Asking for
     // each name in turn beats walking match.groups with for-in: 176ns against 349
     const paramNames = [...regexPattern.matchAll(NAMED_GROUP)].map((m) => m[1]);
@@ -364,6 +368,37 @@ function pathsCanOverlap(a, b, aIsPrefix = false) {
     return true;
 }
 
+// a capture group opening: "(" not followed by "?", or "(?<name>". The same expression express
+// scans a user-supplied RegExp with, so the keys come out in the same order
+const MATCHING_GROUP_REGEXP = /\((?:\?<(.*?)>)?(?!\?)/g;
+
+/** @type {WeakMap<RegExp, (string|number)[]>} */
+const groupKeysCache = new WeakMap();
+
+/**
+ * What each capture group of a user-supplied RegExp is called in req.params: its own name when it
+ * has one, otherwise its position among the unnamed groups, counting from zero. Worked out once
+ * per pattern, since the source never changes.
+ *
+ * @param {RegExp} pattern
+ * @returns {(string|number)[]} one entry per capture group, in source order
+ */
+function regexpGroupKeys(pattern) {
+    let keys = groupKeysCache.get(pattern);
+    if (keys) {
+        return keys;
+    }
+    keys = [];
+    let unnamed = 0;
+    let match;
+    MATCHING_GROUP_REGEXP.lastIndex = 0;
+    while ((match = MATCHING_GROUP_REGEXP.exec(pattern.source)) !== null) {
+        keys.push(match[1] || unnamed++);
+    }
+    groupKeysCache.set(pattern, keys);
+    return keys;
+}
+
 /**
  * Whether µWS would answer with `earlier` every path that both paths match, which is what makes its
  * order agree with express's registration order.
@@ -538,7 +573,9 @@ const defaultSettings = {
     // asking which framework is running, and every hardening guide says to remove it. Set it back
     // to true if something depends on it.
     "x-powered-by": false,
-    "case sensitive routing": true,
+    // "case sensitive routing" is deliberately absent: unset means insensitive, as in Express 5.
+    // The native µWS router matches bytes, so the compiler in _compileOptimizedRoutes only hands
+    // it routes whose earlier siblings it can prove agree under either case rule.
     "declarative responses": true
 };
 
@@ -1032,6 +1069,7 @@ module.exports = {
     canBeOptimizedWithParams,
     pathsCanOverlap,
     uwsPrefersEarlier,
+    regexpGroupKeys,
     escapeHtml,
     withDefaultCharset,
     withUtf8Charset,