@jsenv/server 16.0.3 → 16.0.5

package/dist/jsenv_server.js

@@ -1718,7 +1718,7 @@ const fromNodeRequest = (
         `formData() called on a request with content-type: "${contentType}". multipart/form-data was expected.`,
       );
     }
-    const { formidable } = await import("./js/formidable_index.js");
+    const { formidable } = await import("./formidable_index/formidable_index.js");
     const form = formidable({});
     nodeRequest.resume(); // was paused in line #53
     const [fields, files] = await form.parse(nodeRequest);
@@ -3600,6 +3600,13 @@ const applyPattern = ({ url, pattern }) => {
   };
 };
 
+/**
+ * Core pattern matching function that processes patterns against strings
+ * @param {string} pattern - The pattern with special syntax (*,**,/) to match against
+ * @param {string} string - The string to test against the pattern
+ * @returns {Object} Result containing match status and capture groups
+ * @private
+ */
 const applyMatching = (pattern, string) => {
   const groups = [];
   let patternIndex = 0;
@@ -3624,22 +3631,6 @@ const applyMatching = (pattern, string) => {
     return consumeString(remainingString.length);
   };
 
-  let matched;
-  const iterate = () => {
-    const patternIndexBefore = patternIndex;
-    const indexBefore = index;
-    matched = matchOne();
-    if (matched === undefined) {
-      consumePattern(1);
-      consumeString(1);
-      iterate();
-      return;
-    }
-    if (matched === false && restoreIndexes) {
-      patternIndex = patternIndexBefore;
-      index = indexBefore;
-    }
-  };
   const matchOne = () => {
     // pattern consumed
     if (remainingPattern === "") {
@@ -3649,12 +3640,11 @@ const applyMatching = (pattern, string) => {
       if (remainingString[0] === "?") {
         // match search params
         consumeRemainingString();
-
         return true;
       }
-      // if remainingString
       return false; // fails because string longer than expect
     }
+
     // -- from this point pattern is not consumed --
     // string consumed, pattern not consumed
     if (remainingString === "") {
@@ -3668,6 +3658,7 @@ const applyMatching = (pattern, string) => {
       }
       return false; // fail because string shorter than expect
     }
+
     // -- from this point pattern and string are not consumed --
     // fast path trailing slash
     if (remainingPattern === "/") {
@@ -3679,25 +3670,30 @@ const applyMatching = (pattern, string) => {
       }
       return false;
     }
+
     // fast path trailing '**'
     if (remainingPattern === "**") {
       consumePattern(2);
       consumeRemainingString();
       return true;
     }
+
     if (remainingPattern.slice(0, 4) === "/**/") {
       consumePattern(3); // consumes "/**/"
-      const skipResult = skipUntilMatch({
+      const skipResult = skipUntilMatchIterative({
         pattern: remainingPattern,
         string: remainingString,
         canSkipSlash: true,
       });
-      groups.push(...skipResult.groups);
+      for (let i = 0; i < skipResult.groups.length; i++) {
+        groups.push(skipResult.groups[i]);
+      }
       consumePattern(skipResult.patternIndex);
       consumeRemainingString();
       restoreIndexes = false;
       return skipResult.matched;
     }
+
     // pattern leading **
     if (remainingPattern.slice(0, 2) === "**") {
       consumePattern(2); // consumes "**"
@@ -3707,7 +3703,7 @@ const applyMatching = (pattern, string) => {
         // when remainingPattern was preceeded by "**/"
         // and remainingString have no "/"
         // then skip is not allowed, a regular match will be performed
-        if (!remainingString.includes("/")) {
+        if (remainingString.includes("/")) {
           skipAllowed = false;
         }
       }
@@ -3717,18 +3713,21 @@ const applyMatching = (pattern, string) => {
         return true;
       }
       if (skipAllowed) {
-        const skipResult = skipUntilMatch({
+        const skipResult = skipUntilMatchIterative({
           pattern: remainingPattern,
           string: remainingString,
           canSkipSlash: true,
         });
-        groups.push(...skipResult.groups);
+        for (let i = 0; i < skipResult.groups.length; i++) {
+          groups.push(skipResult.groups[i]);
+        }
         consumePattern(skipResult.patternIndex);
         consumeRemainingString();
         restoreIndexes = false;
         return skipResult.matched;
       }
     }
+
     if (remainingPattern[0] === "*") {
       consumePattern(1); // consumes "*"
       if (remainingPattern === "") {
@@ -3748,23 +3747,53 @@ const applyMatching = (pattern, string) => {
         patternIndex = patternIndex - 1;
         return false;
       }
-      const skipResult = skipUntilMatch({
+      const skipResult = skipUntilMatchIterative({
         pattern: remainingPattern,
         string: remainingString,
         canSkipSlash: false,
       });
-      groups.push(skipResult.group, ...skipResult.groups);
+      groups.push(skipResult.group);
+      for (let i = 0; i < skipResult.groups.length; i++) {
+        groups.push(skipResult.groups[i]);
+      }
       consumePattern(skipResult.patternIndex);
       consumeString(skipResult.index);
       restoreIndexes = false;
       return skipResult.matched;
     }
+
     if (remainingPattern[0] !== remainingString[0]) {
       return false;
     }
+
     return undefined;
   };
-  iterate();
+
+  // Replace recursive iterate() with iterative approach
+  let matched;
+  let continueIteration = true;
+
+  while (continueIteration) {
+    const patternIndexBefore = patternIndex;
+    const indexBefore = index;
+
+    matched = matchOne();
+
+    if (matched === undefined) {
+      consumePattern(1);
+      consumeString(1);
+      // Continue the loop instead of recursion
+      continue;
+    }
+
+    if (matched === false && restoreIndexes) {
+      patternIndex = patternIndexBefore;
+      index = indexBefore;
+    }
+
+    // End the loop
+    continueIteration = false;
+  }
 
   return {
     matched,
@@ -3774,7 +3803,15 @@ const applyMatching = (pattern, string) => {
   };
 };
 
-const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
+/**
+ * Iterative version of skipUntilMatch that avoids recursion
+ * @param {Object} params
+ * @param {string} params.pattern - The pattern to match
+ * @param {string} params.string - The string to test against
+ * @param {boolean} params.canSkipSlash - Whether slash characters can be skipped
+ * @returns {Object} Result of the matching attempt
+ */
+const skipUntilMatchIterative = ({ pattern, string, canSkipSlash }) => {
   let index = 0;
   let remainingString = string;
   let longestAttemptRange = null;
@@ -3792,8 +3829,10 @@ const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
     };
   };
 
-  const tryToMatch = () => {
+  // Loop until a match is found or all attempts fail
+  while (true) {
     const matchAttempt = applyMatching(pattern, remainingString);
+
     if (matchAttempt.matched) {
       return {
         matched: true,
@@ -3808,6 +3847,7 @@ const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
         },
       };
     }
+
     const attemptIndex = matchAttempt.index;
     const attemptRange = {
       patternIndex: matchAttempt.patternIndex,
@@ -3815,19 +3855,23 @@ const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
       length: attemptIndex,
       groups: matchAttempt.groups,
     };
+
     if (
       !longestAttemptRange ||
       longestAttemptRange.length < attemptRange.length
     ) {
       longestAttemptRange = attemptRange;
     }
+
     if (isLastAttempt) {
       return failure();
     }
+
     const nextIndex = attemptIndex + 1;
     if (nextIndex >= remainingString.length) {
       return failure();
     }
+
     if (remainingString[0] === "/") {
       if (!canSkipSlash) {
         return failure();
@@ -3837,12 +3881,11 @@ const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
         isLastAttempt = true;
       }
     }
+
     // search against the next unattempted string
     index += nextIndex;
     remainingString = remainingString.slice(nextIndex);
-    return tryToMatch();
-  };
-  return tryToMatch();
+  }
 };
 
 const applyPatternMatching = ({ url, pattern }) => {
@@ -3852,9 +3895,19 @@ const applyPatternMatching = ({ url, pattern }) => {
   return applyPattern({ url, pattern });
 };
 
-const resolveAssociations = (associations, baseUrl) => {
-  if (baseUrl && typeof baseUrl.href === "string") baseUrl = baseUrl.href;
-  assertUrlLike(baseUrl, "baseUrl");
+const resolveAssociations = (associations, resolver) => {
+  let resolve = () => {};
+  if (typeof resolver === "function") {
+    resolve = resolver;
+  } else if (typeof resolver === "string") {
+    const baseUrl = resolver;
+    assertUrlLike(baseUrl, "baseUrl");
+    resolve = (pattern) => new URL(pattern, baseUrl).href;
+  } else if (resolver && typeof resolver.href === "string") {
+    const baseUrl = resolver.href;
+    assertUrlLike(baseUrl, "baseUrl");
+    resolve = (pattern) => new URL(pattern, baseUrl).href;
+  }
 
   const associationsResolved = {};
   for (const key of Object.keys(associations)) {
@@ -3865,12 +3918,11 @@ const resolveAssociations = (associations, baseUrl) => {
         const valueAssociated = value[pattern];
         let patternResolved;
         try {
-          patternResolved = String(new URL(pattern, baseUrl));
+          patternResolved = resolve(pattern);
         } catch {
           // it's not really an url, no need to perform url resolution nor encoding
           patternResolved = pattern;
         }
-
         valueMapResolved[patternResolved] = valueAssociated;
       }
       associationsResolved[key] = valueMapResolved;
@@ -3993,34 +4045,29 @@ const urlChildMayMatch = ({ url, associations, predicate }) => {
 };
 
 const applyAliases = ({ url, aliases }) => {
-  let aliasFullMatchResult;
-  const aliasMatchingKey = Object.keys(aliases).find((key) => {
-    const aliasMatchResult = applyPatternMatching({
+  for (const key of Object.keys(aliases)) {
+    const matchResult = applyPatternMatching({
       pattern: key,
       url,
     });
-    if (aliasMatchResult.matched) {
-      aliasFullMatchResult = aliasMatchResult;
-      return true;
+    if (!matchResult.matched) {
+      continue;
     }
-    return false;
-  });
-  if (!aliasMatchingKey) {
-    return url;
-  }
-  const { matchGroups } = aliasFullMatchResult;
-  const alias = aliases[aliasMatchingKey];
-  const parts = alias.split("*");
-  let newUrl = "";
-  let index = 0;
-  for (const part of parts) {
-    newUrl += `${part}`;
-    if (index < parts.length - 1) {
-      newUrl += matchGroups[index];
+    const { matchGroups } = matchResult;
+    const alias = aliases[key];
+    const parts = alias.split("*");
+    let newUrl = "";
+    let index = 0;
+    for (const part of parts) {
+      newUrl += `${part}`;
+      if (index < parts.length - 1) {
+        newUrl += matchGroups[index];
+      }
+      index++;
     }
-    index++;
+    return newUrl;
   }
-  return newUrl;
+  return url;
 };
 
 const matches = (url, patterns) => {
@@ -6446,7 +6493,7 @@ const replacePlaceholdersInHtml = (html, replacers) => {
   });
 };
 
-const clientErrorHtmlTemplateFileUrl = import.meta.resolve("./html/4xx.html");
+const clientErrorHtmlTemplateFileUrl = import.meta.resolve("./client/4xx/4xx.html");
 
 const jsenvServiceDefaultBody4xx5xx = () => {
   return {
@@ -6525,7 +6572,7 @@ const generateBadStatusResponse = (
   );
 };
 
-const jsenvServerRootDirectoryUrl = import.meta.resolve("../");
+const jsenvServerRootDirectoryUrl = import.meta.resolve("./");
 
 const jsenvServiceInternalClientFiles = () => {
   return {
@@ -6593,7 +6640,7 @@ const jsenvServiceOpenFile = () => {
 };
 
 const routeInspectorHtmlFileUrl = import.meta.resolve(
-  "./html/route_inspector.html",
+  "./client/route_inspector/route_inspector.html",
 );
 
 const jsenvServiceRouteInspector = () => {
@@ -7584,7 +7631,7 @@ const startServer = async ({
     const webSocketSet = new Set();
     let upgradeRequestToWebSocket;
     const loadUpgradeRequestToWebSocket = async () => {
-      const { WebSocketServer } = await import("./js/ws.js");
+      const { WebSocketServer } = await import("./ws/ws.js");
       let webSocketServer = new WebSocketServer({ noServer: true });
       stopCallbackSet.add(() => {
         webSocketServer.close();
@@ -7769,7 +7816,7 @@ const PROCESS_TEARDOWN_EVENTS_MAP = {
   exit: STOP_REASON_PROCESS_EXIT,
 };
 
-const internalErrorHtmlFileUrl = import.meta.resolve("./html/500.html");
+const internalErrorHtmlFileUrl = import.meta.resolve("./client/500/500.html");
 
 const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "16.0.3",
+  "version": "16.0.5",
   "description": "A modern Node.js HTTP server with declarative routing, content negotiation, and WebSocket support",
   "license": "MIT",
   "author": {
@@ -42,7 +42,7 @@
     "launch-editor": "2.10.0",
     "@jsenv/abort": "4.3.1",
     "@jsenv/humanize": "1.3.1",
-    "@jsenv/url-meta": "8.5.4",
+    "@jsenv/url-meta": "8.5.6",
     "@jsenv/utils": "2.2.1",
     "ws": "8.18.1",
     "formidable": "3.5.2"