bxo 0.0.5-dev.35 → 0.0.5-dev.37

package/index.ts

@@ -319,13 +319,22 @@ export default class BXO {
       const params: Record<string, string> = {};
       let isMatch = true;
 
-      // Handle wildcard at the end (catch-all)
+      // Check for double wildcard (**) in the route
+      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
+      
+      // Handle double wildcard at the end (catch-all with slashes)
+      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
+      
+      // Handle single wildcard at the end (catch-all)
       const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
 
-      if (hasWildcardAtEnd) {
-        // For catch-all wildcard, path must have at least as many segments as route (minus the wildcard)
+      if (hasDoubleWildcardAtEnd) {
+        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
         if (pathSegments.length < routeSegments.length - 1) continue;
-      } else {
+      } else if (hasWildcardAtEnd) {
+        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (!hasDoubleWildcard) {
         // For exact matching (with possible single-segment wildcards), lengths must match
         if (routeSegments.length !== pathSegments.length) continue;
       }
@@ -339,7 +348,14 @@ export default class BXO {
           break;
         }
 
-        // Handle catch-all wildcard at the end
+        // Handle double wildcard at the end (matches everything including slashes)
+        if (routeSegment === '**' && i === routeSegments.length - 1) {
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['**'] = remainingPath;
+          break;
+        }
+
+        // Handle single wildcard at the end (catch-all)
         if (routeSegment === '*' && i === routeSegments.length - 1) {
           // Wildcard at end matches remaining path segments
           const remainingPath = pathSegments.slice(i).join('/');
@@ -347,6 +363,68 @@ export default class BXO {
           break;
         }
 
+        // Handle double wildcard in the middle (matches everything including slashes)
+        if (routeSegment === '**') {
+          // Find the next non-wildcard segment to match against
+          let nextNonWildcardIndex = i + 1;
+          while (nextNonWildcardIndex < routeSegments.length && 
+                 (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
+            nextNonWildcardIndex++;
+          }
+          
+          if (nextNonWildcardIndex >= routeSegments.length) {
+            // Double wildcard is at the end or followed by other wildcards
+            const remainingPath = pathSegments.slice(i).join('/');
+            params['**'] = remainingPath;
+            break;
+          }
+          
+          // Find the next matching segment in the path
+          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
+          if (!nextRouteSegment) {
+            isMatch = false;
+            break;
+          }
+          
+          let foundMatch = false;
+          let matchedPath = '';
+          
+          for (let j = i; j < pathSegments.length; j++) {
+            const currentPathSegment = pathSegments[j];
+            
+            // Check if this path segment matches the next route segment
+            if (nextRouteSegment.startsWith(':')) {
+              // Param segment - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === '*') {
+              // Single wildcard - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === currentPathSegment) {
+              // Exact match
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            }
+          }
+          
+          if (!foundMatch) {
+            isMatch = false;
+            break;
+          }
+          
+          continue;
+        }
+
         if (!pathSegment) {
           isMatch = false;
           break;
@@ -383,13 +461,22 @@ export default class BXO {
       const params: Record<string, string> = {};
       let isMatch = true;
 
-      // Handle wildcard at the end (catch-all)
+      // Check for double wildcard (**) in the route
+      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
+      
+      // Handle double wildcard at the end (catch-all with slashes)
+      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
+      
+      // Handle single wildcard at the end (catch-all)
       const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
 
-      if (hasWildcardAtEnd) {
-        // For catch-all wildcard, path must have at least as many segments as route (minus the wildcard)
+      if (hasDoubleWildcardAtEnd) {
+        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
         if (pathSegments.length < routeSegments.length - 1) continue;
-      } else {
+      } else if (hasWildcardAtEnd) {
+        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
+        if (pathSegments.length < routeSegments.length - 1) continue;
+      } else if (!hasDoubleWildcard) {
         // For exact matching (with possible single-segment wildcards), lengths must match
         if (routeSegments.length !== pathSegments.length) continue;
       }
@@ -403,7 +490,14 @@ export default class BXO {
           break;
         }
 
-        // Handle catch-all wildcard at the end
+        // Handle double wildcard at the end (matches everything including slashes)
+        if (routeSegment === '**' && i === routeSegments.length - 1) {
+          const remainingPath = pathSegments.slice(i).join('/');
+          params['**'] = remainingPath;
+          break;
+        }
+
+        // Handle single wildcard at the end (catch-all)
         if (routeSegment === '*' && i === routeSegments.length - 1) {
           // Wildcard at end matches remaining path segments
           const remainingPath = pathSegments.slice(i).join('/');
@@ -411,6 +505,68 @@ export default class BXO {
           break;
         }
 
+        // Handle double wildcard in the middle (matches everything including slashes)
+        if (routeSegment === '**') {
+          // Find the next non-wildcard segment to match against
+          let nextNonWildcardIndex = i + 1;
+          while (nextNonWildcardIndex < routeSegments.length && 
+                 (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
+            nextNonWildcardIndex++;
+          }
+          
+          if (nextNonWildcardIndex >= routeSegments.length) {
+            // Double wildcard is at the end or followed by other wildcards
+            const remainingPath = pathSegments.slice(i).join('/');
+            params['**'] = remainingPath;
+            break;
+          }
+          
+          // Find the next matching segment in the path
+          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
+          if (!nextRouteSegment) {
+            isMatch = false;
+            break;
+          }
+          
+          let foundMatch = false;
+          let matchedPath = '';
+          
+          for (let j = i; j < pathSegments.length; j++) {
+            const currentPathSegment = pathSegments[j];
+            
+            // Check if this path segment matches the next route segment
+            if (nextRouteSegment.startsWith(':')) {
+              // Param segment - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === '*') {
+              // Single wildcard - always matches
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            } else if (nextRouteSegment === currentPathSegment) {
+              // Exact match
+              matchedPath = pathSegments.slice(i, j).join('/');
+              params['**'] = matchedPath;
+              i = j - 1; // Adjust index for the next iteration
+              foundMatch = true;
+              break;
+            }
+          }
+          
+          if (!foundMatch) {
+            isMatch = false;
+            break;
+          }
+          
+          continue;
+        }
+
         if (!pathSegment) {
           isMatch = false;
           break;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bxo",
   "module": "index.ts",
-  "version": "0.0.5-dev.35",
+  "version": "0.0.5-dev.37",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {
@@ -15,6 +15,6 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "zod": "^4.0.5"
+    "zod": "^3.25.76"
   }
 }

package/example.ts

@@ -1,33 +0,0 @@
-import BXO, { createCookie, redirect } from 'bxo';
-
-const app = new BXO();
-
-// 1) Explicit return redirect (302 default)
-app.get('/old', ({ redirect }) => {
-  return redirect('/new');
-});
-
-// 2) Implicit redirect (no return needed)
-app.get('/implicit', (ctx) => {
-  ctx.redirect('/new');
-});
-
-// 3) Custom status (303 after POST)
-app.post('/submit', (ctx) => {
-  // ...handle form...
-  return ctx.redirect('/thanks', 303);
-});
-
-// 4) Redirect with cookie
-app.get('/login', (ctx) => {
-  ctx.set.cookies = [
-    createCookie('sid', 'abc123', { httpOnly: true, path: '/' })
-  ];
-  ctx.redirect('/dashboard'); // no return required
-});
-
-// 5) Using top-level helper (outside ctx)
-app.get('/go-external', () => redirect('https://example.com', 307));
-
-await app.start(3000);
-console.log('Server running at http://localhost:3000');