0http-bun 1.1.0 → 1.1.2

package/common.d.ts

@@ -1,4 +1,4 @@
-import { Pattern, Methods } from 'trouter'
+import {Pattern, Methods} from 'trouter'
 
 export interface IRouterConfig {
   defaultRoute?: RequestHandler
@@ -16,7 +16,7 @@ type ZeroRequest = Request & {
 
 export type RequestHandler = (
   req: ZeroRequest,
-  next: StepFunction
+  next: StepFunction,
 ) => Response | Promise<Response>
 
 export interface IRouter {

package/index.d.ts

@@ -1,7 +1,7 @@
-import { IRouter, IRouterConfig } from './common'
+import {IRouter, IRouterConfig} from './common'
 
 export default function zero(config?: IRouterConfig): {
   router: IRouter
 }
 
-export * from './common'
+export * from './common'

package/index.js

@@ -3,6 +3,6 @@ module.exports = (config = {}) => {
   const router = require('./lib/router/sequential')(config)
 
   return {
-    router
+    router,
   }
 }

package/lib/next.js

@@ -1,16 +1,25 @@
-module.exports = function next (middlewares, req, index, defaultRoute, errorHandler) {
-  if (index >= middlewares.length) {
+module.exports = function next(
+  middlewares,
+  req,
+  index,
+  defaultRoute,
+  errorHandler,
+) {
+  // Optimized loop unrolling for common cases
+  const length = middlewares.length
+  if (index >= length) {
     return defaultRoute(req)
   }
 
-  const middleware = middlewares[index++]
+  const middleware = middlewares[index]
+  const nextIndex = index + 1
 
   try {
     return middleware(req, (err) => {
       if (err) {
         return errorHandler(err, req)
       }
-      return next(middlewares, req, index, defaultRoute, errorHandler)
+      return next(middlewares, req, nextIndex, defaultRoute, errorHandler)
     })
   } catch (err) {
     return errorHandler(err, req)

package/lib/router/sequential.d.ts

@@ -1,3 +1,3 @@
-import { IRouter, IRouterConfig } from './../../index'
+import {IRouter, IRouterConfig} from './../../index'
 
 export default function createSequentialRouter(config?: IRouterConfig): IRouter

package/lib/router/sequential.js

@@ -1,27 +1,27 @@
-const Trouter = require('trouter')
+const {Trouter} = require('trouter')
 const qs = require('fast-querystring')
 const next = require('./../next')
 
 const STATUS_404 = {
-  status: 404
+  status: 404,
 }
 const STATUS_500 = {
-  status: 500
+  status: 500,
 }
 
 module.exports = (config = {}) => {
   const cache = new Map()
 
-  if (!config.defaultRoute) {
-    config.defaultRoute = () => {
-      return new Response(null, STATUS_404)
-    }
-  }
-  if (!config.errorHandler) {
-    config.errorHandler = (err) => {
-      return new Response(err.message, STATUS_500)
-    }
-  }
+  // Pre-create default responses to avoid object creation overhead
+  const default404Response = new Response(null, STATUS_404)
+
+  // Cache default functions to avoid closure creation
+  const defaultRouteHandler = config.defaultRoute || (() => default404Response)
+  const errorHandlerFn =
+    config.errorHandler || ((err) => new Response(err.message, STATUS_500))
+
+  // Optimize empty params object reuse
+  const emptyParams = {}
 
   const router = new Trouter()
   router.port = config.port || 3000
@@ -40,35 +40,89 @@ module.exports = (config = {}) => {
 
   router.fetch = (req) => {
     const url = req.url
-    const startIndex = url.indexOf('/', 11)
-    const queryIndex = url.indexOf('?', startIndex + 1)
-    const path = queryIndex === -1 ? url.substring(startIndex) : url.substring(startIndex, queryIndex)
 
-    req.path = path || '/'
-    req.query = queryIndex > 0 ? qs.parse(url.substring(queryIndex + 1)) : {}
+    // Highly optimized URL parsing - single pass through the string
+    let pathStart = 0
+    let pathEnd = url.length
+    let queryString = null
+
+    // Find protocol end
+    const protocolEnd = url.indexOf('://')
+    if (protocolEnd !== -1) {
+      // Find host end (start of path)
+      pathStart = url.indexOf('/', protocolEnd + 3)
+      if (pathStart === -1) {
+        pathStart = url.length
+      }
+    }
+
+    // Find query start
+    const queryStart = url.indexOf('?', pathStart)
+    if (queryStart !== -1) {
+      pathEnd = queryStart
+      queryString = url.substring(queryStart + 1)
+    }
+
+    const path = pathStart < pathEnd ? url.substring(pathStart, pathEnd) : '/'
 
-    const cacheKey = `${req.method}:${req.path}`
-    let match = null
-    if (cache.has(cacheKey)) {
-      match = cache.get(cacheKey)
+    req.path = path
+    req.query = queryString ? qs.parse(queryString) : {}
+
+    // Optimized cache lookup with method-based Map structure
+    const method = req.method
+    let methodCache = cache.get(method)
+    let match_result
+
+    if (methodCache) {
+      match_result = methodCache.get(path)
+      if (match_result === undefined) {
+        match_result = router.find(method, path)
+        methodCache.set(path, match_result)
+      }
     } else {
-      match = router.find(req.method, req.path)
-      cache.set(cacheKey, match)
+      match_result = router.find(method, path)
+      methodCache = new Map([[path, match_result]])
+      cache.set(method, methodCache)
     }
 
-    if (match?.handlers?.length > 0) {
-      if (!req.params) {
-        req.params = {}
+    if (match_result?.handlers?.length > 0) {
+      // Fast path for params assignment
+      const params = match_result.params
+      if (params) {
+        // Check if params object has properties without Object.keys()
+        let hasParams = false
+        for (const key in params) {
+          hasParams = true
+          break
+        }
+
+        if (hasParams) {
+          req.params = req.params || {}
+          // Direct property copy - faster than Object.keys() + loop
+          for (const key in params) {
+            req.params[key] = params[key]
+          }
+        } else if (!req.params) {
+          req.params = emptyParams
+        }
+      } else if (!req.params) {
+        req.params = emptyParams
       }
-      Object.assign(req.params, match.params)
 
-      return next(match.handlers, req, 0, config.defaultRoute, config.errorHandler)
+      return next(
+        match_result.handlers,
+        req,
+        0,
+        defaultRouteHandler,
+        errorHandlerFn,
+      )
     } else {
-      return config.defaultRoute(req)
+      return defaultRouteHandler(req)
     }
   }
 
-  router.on = (method, pattern, ...handlers) => router.add(method, pattern, handlers)
+  router.on = (method, pattern, ...handlers) =>
+    router.add(method, pattern, handlers)
 
   return router
 }

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "0http-bun",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "0http for Bun",
   "main": "index.js",
   "scripts": {
-    "lint": "bun x standard",
-    "format": "bun x standard --fix",
-    "test": "bun test"
+    "lint": "prettier --check **/*.js",
+    "test": "bun --coverage test",
+    "bench": "bun run bench.js",
+    "format": "prettier --write **/*.js"
   },
   "dependencies": {
     "fast-querystring": "^1.1.2",
-    "trouter": "^3.2.1"
+    "trouter": "^4.0.0"
   },
   "repository": {
     "type": "git",
@@ -25,9 +26,10 @@
     "lib/"
   ],
   "devDependencies": {
-    "0http-bun": "^1.0.3",
-    "bun-types": "^1.1.8",
-    "mitata": "^1.0.32"
+    "0http-bun": "^1.1.0",
+    "bun-types": "^1.2.5",
+    "mitata": "^1.0.34",
+    "prettier": "^3.5.3"
   },
   "keywords": [
     "http",