bxo 0.0.5-dev.34 → 0.0.5-dev.36

package/index.ts

@@ -88,6 +88,7 @@ export type Context<TConfig extends RouteConfig = {}> = {
       ? InferZodType<TConfig['response']>
       : any;
   redirect: (location: string, status?: number) => Response;
+  clearRedirect: () => void;
   [key: string]: any;
 };
 
@@ -318,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;
       }
@@ -338,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('/');
@@ -346,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;
@@ -382,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;
       }
@@ -402,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('/');
@@ -410,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;
@@ -601,16 +758,14 @@ export default class BXO {
           return data;
         }) as any,
                  redirect: ((location: string, status: number = 302) => {
-           // Persist redirect intent on context so it also works without returning
-           ctx.set.status = status;
-           ctx.set.headers = {
-             ...(ctx.set.headers || {}),
-             Location: location
-           };
+           // Record redirect intent only; avoid mutating generic status/headers so it can be canceled later
            ctx.set.redirect = { location, status };
 
-           // Prepare headers for immediate Response return (merging any existing headers)
-           const responseHeaders: Record<string, string> = { ...ctx.set.headers };
+           // Prepare headers for immediate Response return without persisting to ctx.set.headers
+           const responseHeaders: Record<string, string> = {
+             Location: location,
+             ...(ctx.set.headers || {})
+           };
 
            // Handle cookies if any are set on context
            if (ctx.set.cookies && ctx.set.cookies.length > 0) {
@@ -634,7 +789,23 @@ export default class BXO {
              status,
              headers: responseHeaders
            });
-         }) as any
+         }) as any,
+        clearRedirect: (() => {
+          // Clear explicit redirect intent
+          delete ctx.set.redirect;
+          // Remove any Location header if present
+          if (ctx.set.headers) {
+            for (const key of Object.keys(ctx.set.headers)) {
+              if (key.toLowerCase() === 'location') {
+                delete ctx.set.headers[key];
+              }
+            }
+          }
+          // Reset status if it is a redirect
+          if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
+            delete ctx.set.status;
+          }
+        }) as any
       };
     } catch (validationError) {
       // Validation failed - return error response

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bxo",
   "module": "index.ts",
-  "version": "0.0.5-dev.34",
+  "version": "0.0.5-dev.36",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {

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');