@ndiinginc/router 4.11.0 → 4.11.2

package/README.md

@@ -50,23 +50,19 @@ app.listen(3000);
 
 Yang diekspor adalah class `App`, dengan tiga properti tambahan:
 
-| Export | Keterangan |
-| --- | --- |
-| `App` | Router + HTTP server (`listen`) |
+| Export       | Keterangan                               |
+| ------------ | ---------------------------------------- |
+| `App`        | Router + HTTP server (`listen`)          |
 | `App.Router` | Router tanpa server, untuk nested router |
-| `App.json` | Middleware JSON body parser |
-| `App.cors` | Middleware CORS |
+| `App.json`   | Middleware JSON body parser              |
+| `App.cors`   | Middleware CORS                          |
 
 ## Routing
 
 Semua method mengembalikan `this`, jadi bisa di-chain.
 
 ```js
-app.get("/users", handler)
-   .post("/users", handler)
-   .put("/users/:id", handler)
-   .patch("/users/:id", handler)
-   .delete("/users/:id", handler);
+app.get("/users", handler).post("/users", handler).put("/users/:id", handler).patch("/users/:id", handler).delete("/users/:id", handler);
 ```
 
 Method yang tersedia: `get`, `post`, `put`, `patch`, `delete`, `head`, `options`, `trace`, `connect`, `query`, dan `use` (semua method).
@@ -236,12 +232,12 @@ app.get("/proxy", async (req, res) => {
 
 ## Request
 
-| Properti | Keterangan |
-| --- | --- |
-| `req.path` | Pathname tanpa query string |
-| `req.query` | Object query string, di-parse secara lazy. Key yang berulang menjadi array, dan `+` di-decode menjadi spasi |
-| `req.params` | Parameter dari route dinamis (sudah di-decode). Wildcard `*` ada di `req.params.wildcard` |
-| `req.body` | Hasil parse body (butuh middleware `json()`) |
+| Properti         | Keterangan                                                                                                  |
+| ---------------- | ----------------------------------------------------------------------------------------------------------- |
+| `req.path`       | Pathname tanpa query string                                                                                 |
+| `req.query`      | Object query string, di-parse secara lazy. Key yang berulang menjadi array, dan `+` di-decode menjadi spasi |
+| `req.params`     | Parameter dari route dinamis (sudah di-decode). Wildcard `*` ada di `req.params.wildcard`                   |
+| `req.body`       | Hasil parse body (butuh middleware `json()`)                                                                |
 | `req.controller` | `AbortController` untuk request ini. Di-abort saat timeout atau error handler (jika `requestTimeout` aktif) |
 
 ```js
@@ -257,11 +253,11 @@ app.get("/search", (req, res) => {
 
 ## Response
 
-| Method | Keterangan |
-| --- | --- |
-| `res.status(code)` | Set status code, mengembalikan `res` sehingga bisa di-chain |
-| `res.send(chunk)` | Kirim response dan akhiri |
-| `res.json(value)` | Set `Content-Type: application/json; charset=utf-8`, serialize, lalu kirim |
+| Method             | Keterangan                                                                 |
+| ------------------ | -------------------------------------------------------------------------- |
+| `res.status(code)` | Set status code, mengembalikan `res` sehingga bisa di-chain                |
+| `res.send(chunk)`  | Kirim response dan akhiri                                                  |
+| `res.json(value)`  | Set `Content-Type: application/json; charset=utf-8`, serialize, lalu kirim |
 
 ```js
 res.status(201).json({ created: true });
@@ -277,8 +273,8 @@ res.status(201).json({ created: true });
 app.use(App.json({ limit: 100 * 1024 })); // default 100 KB
 ```
 
-| Opsi | Default | Keterangan |
-| --- | --- | --- |
+| Opsi    | Default  | Keterangan                      |
+| ------- | -------- | ------------------------------- |
 | `limit` | `102400` | Ukuran body maksimum dalam byte |
 
 Perilaku:
@@ -303,13 +299,13 @@ app.use(
 );
 ```
 
-| Opsi | Default | Keterangan |
-| --- | --- | --- |
-| `origin` | `"*"` | `"*"`, satu origin, atau array origin. `null` tidak mengirim header `Access-Control-Allow-Origin` sama sekali |
-| `credentials` | `false` | Mengirim `Access-Control-Allow-Credentials: true` |
-| `headers` | - | `"*"` atau array nama header (tidak membedakan huruf besar/kecil) |
-| `methods` | - | `"*"` atau array nama method (tidak membedakan huruf besar/kecil) |
-| `maxAge` | `0` | Lama cache preflight (detik). `0` berarti header tidak dikirim |
+| Opsi          | Default | Keterangan                                                                                                    |
+| ------------- | ------- | ------------------------------------------------------------------------------------------------------------- |
+| `origin`      | `"*"`   | `"*"`, satu origin, atau array origin. `null` tidak mengirim header `Access-Control-Allow-Origin` sama sekali |
+| `credentials` | `false` | Mengirim `Access-Control-Allow-Credentials: true`                                                             |
+| `headers`     | -       | `"*"` atau array nama header (tidak membedakan huruf besar/kecil)                                             |
+| `methods`     | -       | `"*"` atau array nama method (tidak membedakan huruf besar/kecil)                                             |
+| `maxAge`      | `0`     | Lama cache preflight (detik). `0` berarti header tidak dikirim                                                |
 
 Perilaku:
 
@@ -329,9 +325,9 @@ Perilaku:
 const app = new App({ requestTimeout: 5000 });
 ```
 
-| Opsi | Default | Keterangan |
-| --- | --- | --- |
-| `requestTimeout` | `0` | Batas waktu handler dalam ms (khusus `App`). Lihat bagian [Timeout](#timeout) |
+| Opsi             | Default | Keterangan                                                                    |
+| ---------------- | ------- | ----------------------------------------------------------------------------- |
+| `requestTimeout` | `0`     | Batas waktu handler dalam ms (khusus `App`). Lihat bagian [Timeout](#timeout) |
 
 `Router` tidak memiliki opsi sendiri; `requestTimeout` hanya dipakai oleh `App`.
 
@@ -373,10 +369,7 @@ console.log(server.address().port);
 ```js
 const https = require("https");
 
-const server = https.createServer(
-    { ...App.SERVER_OPTIONS, key, cert },
-    (req, res) => app.handle(req, res),
-);
+const server = https.createServer({ ...App.SERVER_OPTIONS, key, cert }, (req, res) => app.handle(req, res));
 server.listen(443);
 ```
 
@@ -384,11 +377,11 @@ server.listen(443);
 
 Hello world dengan satu route `GET /`, diuji memakai `autocannon -c 100 -d 40 -p 10` di mesin lokal.
 
-| | Req/sec (avg) | Latency (avg) |
-| --- | --- | --- |
-| Fastify | 31.475 | 31,27 ms |
-| **@ndiinginc/router** | 29.735 | 33,12 ms |
-| Express | 20.211 | 48,93 ms |
+|                       | Req/sec (avg) | Latency (avg) |
+| --------------------- | ------------- | ------------- |
+| Fastify               | 31.475        | 31,27 ms      |
+| **@ndiinginc/router** | 29.735        | 33,12 ms      |
+| Express               | 20.211        | 48,93 ms      |
 
 Hasil bervariasi tergantung mesin, versi Node.js, dan jumlah route. Benchmark ini hanya menggambarkan overhead dasar, bukan performa aplikasi nyata.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ndiinginc/router",
-  "version": "4.11.0",
+  "version": "4.11.2",
   "description": "",
   "main": "./src/index.js",
   "scripts": {
@@ -22,6 +22,6 @@
     "@ndiinginc/test": "^1.17.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^26.6.5",
-    "autocannon": "^8.0.0"
+    "autocannon": "^2.0.1"
   }
 }

package/src/app.js

@@ -11,26 +11,27 @@ const SERVER_OPTIONS = {
 };
 
 class App extends Router {
+    /**
+     * @param {Request} req
+     * @param {Response} res
+     * @param {Promise} handlerPromise
+     */
     async withTimeout(req, res, handlerPromise) {
         let handleAbort;
         const timeoutPromise = new Promise((_, reject) => {
             handleAbort = () => reject(req.controller.signal.reason);
             req.controller.signal.addEventListener("abort", handleAbort, { once: true });
         });
-
         const timeout = setTimeout(() => {
             res.statusCode = 504;
             req.controller.abort(new Error(http.STATUS_CODES[res.statusCode]));
         }, this.requestTimeout);
-
         const promise = handlerPromise().catch((error) => {
             if (!req.controller.signal.aborted) {
                 req.controller.abort(error);
             } else {
-                console.error(error); // swallow error?
             }
         });
-
         try {
             await Promise.race([promise, timeoutPromise]);
         } finally {
@@ -39,34 +40,34 @@ class App extends Router {
         }
     }
 
+    /**
+     * @param {Response} res
+     * @param {Error} err
+     */
     fallback(res, err) {
         if (!res.writableEnded) {
             if (!err) {
                 res.statusCode = 404;
                 err = new Error(http.STATUS_CODES[res.statusCode]);
             }
-
             if (res.statusCode < 400) {
                 res.statusCode = 500;
             }
-
             const error = { message: err.message };
             if (process.env.NODE_ENV === "development") {
                 error.stack = err.stack;
             }
-
             res.json({ error });
         }
     }
 
     /**
-     * @param {import('http').IncomingMessage & import('./request').Request} req
-     * @param {import('http').ServerResponse & import('./response').Response} res
+     * @param {Request} req
+     * @param {Response} res
      */
     async handle(req, res) {
         const { params, paramsLength, handlers, errorHandlers } = this.find(req.method, req.path);
         req.params = paramsLength ? Object.assign(Object.create(null), params) : EMPTY_PARAMS;
-
         let err;
         try {
             const handlerPromise = async () => {
@@ -75,7 +76,6 @@ class App extends Router {
                     await handler(req, res);
                 }
             };
-
             if (this.requestTimeout) {
                 await this.withTimeout(req, res, handlerPromise);
             } else {
@@ -83,7 +83,6 @@ class App extends Router {
             }
         } catch (error) {
             err = error;
-            
             try {
                 for (const handler of errorHandlers) {
                     if (res.writableEnded) break;
@@ -93,10 +92,13 @@ class App extends Router {
                 err = new Error(error.message, { cause: err });
             }
         }
-
         this.fallback(res, err);
     }
 
+    /**
+     * @param  {import('net').ListenOptions} args
+     * @returns {import('http').Server}
+     */
     listen(...args) {
         const requestListener = (req, res) => this.handle(req, res);
         const server = http.createServer(SERVER_OPTIONS, requestListener);
@@ -105,6 +107,6 @@ class App extends Router {
     }
 }
 
-App.SERVER_OPTIONS=SERVER_OPTIONS
+App.SERVER_OPTIONS = SERVER_OPTIONS;
 
 exports.App = App;

package/src/middleware/cors.js

@@ -1,14 +1,21 @@
 /**
- * @typedef CORSOptions
- * @property {String|Array|Null} [origin="*"]
- * @property {Boolean} [credentials=false]
- * @property {String|Array} [headers]
- * @property {Number} [maxAge=0]
- * @property {String|Array} [methods]
+ * @typedef {Object} Options
+ * @property {string|array} origin
+ * @property {boolean} credentials
+ * @property {string|array} headers
+ * @property {Number} maxAge
+ * @property {string|array} methods
  */
 
 /**
- * @param {CORSOptions} options
+ * @callback Callback
+ * @param {import('../request')} req
+ * @param {import('../response')} res
+ */
+
+/**
+ * @param {Options} Options
+ * @returns {Callback}
  */
 function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods } = {}) {
     if (Array.isArray(headers)) {
@@ -28,15 +35,12 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
         const reqOrigin = req.headers["origin"];
         let value;
         let explicit = false;
-
         if (origin === "*" && !credentials) {
             value = "*";
         } else if (origin === "*" || origin === reqOrigin || (Array.isArray(origin) && origin.includes(reqOrigin))) {
             value = reqOrigin;
             explicit = true;
         }
-        // origin === null -> skip (jangan set "null", celah keamanan)
-
         if (value) res.setHeader("Access-Control-Allow-Origin", value);
         if (explicit) res.appendHeader("Vary", "Origin");
     }
@@ -44,9 +48,7 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
     function setAllowHeaders(req, res) {
         const reqHeaders = req.headers["access-control-request-headers"];
         if (!reqHeaders) return;
-
         const requested = reqHeaders.split(",").map((h) => h.trim().toLowerCase());
-
         let value;
         if (headers === "*" && !credentials) {
             value = "*";
@@ -54,7 +56,6 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
             const allowed = requested.filter((h) => headers.includes(h));
             if (allowed.length === requested.length) value = headers;
         } else {
-            // headers undefined -> echo request headers (wajib per spec)
             value = requested;
         }
         if (value) res.setHeader("Access-Control-Allow-Headers", value);
@@ -63,16 +64,13 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
     function setAllowMethods(req, res) {
         const reqMethod = req.headers["access-control-request-method"];
         if (!reqMethod) return;
-
         const method = reqMethod.toUpperCase();
-
         let value;
         if (methods === "*" && !credentials) {
             value = "*";
         } else if (Array.isArray(methods)) {
             if (methods.includes(method)) value = methods;
         } else {
-            // methods undefined -> echo request method
             value = [method];
         }
         if (value) res.setHeader("Access-Control-Allow-Methods", value);
@@ -96,9 +94,7 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
 
     return (req, res) => {
         setAllowCredentials(res);
-
         if (req.method === "OPTIONS" && req.headers["access-control-request-method"]) {
-            // preflight
             setAllowOrigin(req, res);
             setAllowHeaders(req, res);
             setAllowMethods(req, res);
@@ -107,7 +103,6 @@ function cors({ origin = "*", credentials = false, headers, maxAge = 0, methods
             res.setHeader("Content-Length", "0");
             res.end();
         } else {
-            // normal response (termasuk OPTIONS non-preflight)
             setAllowOrigin(req, res);
             setExposeHeaders(res);
         }

package/src/middleware/json.js

@@ -1,12 +1,27 @@
 const http = require("http");
+/**
+ * @typedef {Object} Options
+ * @property {Number} [limit=1.024e+5]
+ */
 
-function json({ limit = 100 * 1024 } = {}) {
+/**
+ * @callback Callback
+ * @param {import('../request')} req
+ * @param {import('../response')} res
+ */
+
+/**
+ * @param {Options} Options
+ * @returns {Callback}
+ */
+function json({ limit = 1.024e5 } = {}) {
     const reviver = (key, value) => {
         if (key === "__proto__" || key === "constructor" || key === "prototype") {
             return undefined;
         }
         return value;
     };
+
     return async (req, res) => {
         if (!["POST", "PUT", "PATCH", "QUERY"].includes(req.method)) {
             return;

package/src/node.js

@@ -1,32 +1,49 @@
 class Node {
+    /**
+     * @param {String} segment
+     */
     constructor(segment = "") {
         this.segment = segment;
-        /** @type {Map<string, Node>} static children */
+        if (segment.startsWith(":")) {
+            /**@type {String}*/
+            this.name = segment.slice(1);
+        }
+
+        /**@type {Map<string,Node>}*/
         this.children = new Map();
-        /** @type {Map<string, Node>} param children, key = ':name' */
+
+        /**@type {Map<string,Node>}*/
         this.params = new Map();
-        /** @type {Node | null} wildcard child */
+
+        /**@type {Node}*/
         this.wildcard = null;
+        /**@type {Map<string,Function[]>}*/
         this.handlers = new Map();
     }
 
+    /**
+     * @param {String} segment
+     * @returns {Node}
+     */
     add(segment) {
         if (segment === "*") {
             if (!this.wildcard) this.wildcard = new Node("*");
             return this.wildcard;
         }
-
         if (segment.startsWith(":")) {
             return this.params.getOrInsertComputed(segment, (segment) => {
                 return new Node(segment);
             });
         }
-
         return this.children.getOrInsertComputed(segment, (segment) => {
             return new Node(segment);
         });
     }
 
+    /**
+     * @param {Node} node
+     * @param {Number} offset
+     */
     merge(node, offset) {
         for (const [method, entries] of node.handlers) {
             for (const entry of entries) {
@@ -36,41 +53,36 @@ class Node {
                 });
             }
         }
-
         if (node.wildcard) {
             this.add("*").merge(node.wildcard, offset);
         }
-
         for (const [segment, child] of node.params) {
             this.add(segment).merge(child, offset);
         }
-
         for (const [segment, child] of node.children) {
             this.add(segment).merge(child, offset);
         }
     }
 
+    /**
+     * @returns {Number}
+     */
     getMaxSeq() {
         let max = -1;
-
         for (const [, entries] of this.handlers) {
             for (const entry of entries) {
                 max = Math.max(max, entry.seq);
             }
         }
-
         if (this.wildcard) {
             max = Math.max(max, this.wildcard.getMaxSeq());
         }
-
         for (const [, child] of this.params) {
             max = Math.max(max, child.getMaxSeq());
         }
-
         for (const [, child] of this.children) {
             max = Math.max(max, child.getMaxSeq());
         }
-
         return max;
     }
 }

package/src/polyfill.js

@@ -1,5 +1,3 @@
-
-// Polyfill for Map.prototype.getOrInsert
 if (!Map.prototype.getOrInsert) {
     Map.prototype.getOrInsert = function (key, defaultValue) {
         if (!this.has(key)) {
@@ -8,7 +6,7 @@ if (!Map.prototype.getOrInsert) {
         return this.get(key);
     };
 }
-// Polyfill for Map.prototype.getOrInsertComputed
+
 if (!Map.prototype.getOrInsertComputed) {
     Map.prototype.getOrInsertComputed = function (key, callback) {
         if (typeof callback !== "function") {

package/src/request.js

@@ -13,7 +13,6 @@ class Request extends http.IncomingMessage {
             this._path = path;
             this._queryString = queryString;
         }
-
         return this._path;
     }
 
@@ -21,18 +20,13 @@ class Request extends http.IncomingMessage {
         if (!this._query) {
             this._query = parseQueryString(this._queryString);
         }
-
         return this._query;
     }
 
-    /**
-     * @returns {AbortController}
-     */
     get controller() {
         if (!this._controller) {
             this._controller = new AbortController();
         }
-        
         return this._controller;
     }
 }

package/src/response.js

@@ -1,16 +1,26 @@
 const http = require("http");
 
 class Response extends http.ServerResponse {
+    /**
+     * @param {Number} code
+     * @returns {Response}
+     */
     status(code) {
         this.statusCode = code;
         return this;
     }
 
+    /**
+     * @param {String} chunk
+     */
     send(chunk) {
         if (this.writableEnded) return;
         this.end(chunk, null, null);
     }
-    
+
+    /**
+     * @param {Object} value
+     */
     json(value) {
         if (!this.headersSent) {
             this.setHeader("Content-Type", "application/json; charset=utf-8");

package/src/router.js

@@ -1,31 +1,45 @@
 const { decodeParam } = require("./util");
 const { Node } = require("./node");
 
+/**
+ * @typedef {Object} Options
+ * @property {Number} requestTimeout
+ */
+
 class Router {
+    /**
+     * @param {Options} options
+     */
     constructor(options = {}) {
         this.requestTimeout = options.requestTimeout ?? 0;
         this.root = new Node();
         this.seq = 0;
     }
 
+    /**
+     * @param {String} path
+     * @returns {String[]}
+     */
     split(path) {
         return path.split("/").filter(Boolean);
     }
 
+    /**
+     * @param {String} method
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     */
     add(method, path, ...handlers) {
         if (typeof path === "function") {
             handlers = [path, ...handlers];
             path = null;
         }
-
         let node = this.root;
-
         if (path) {
             for (const segment of this.split(path)) {
                 node = node.add(segment);
             }
         }
-
         for (const handler of handlers) {
             if (handler.root) {
                 node.merge(handler.root, this.seq);
@@ -40,128 +54,193 @@ class Router {
         }
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     use(path, ...handlers) {
         this.add("ALL", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     get(path, ...handlers) {
         this.add("GET", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     query(path, ...handlers) {
         this.add("QUERY", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     head(path, ...handlers) {
         this.add("HEAD", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     options(path, ...handlers) {
         this.add("OPTIONS", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     trace(path, ...handlers) {
         this.add("TRACE", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     put(path, ...handlers) {
         this.add("PUT", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     delete(path, ...handlers) {
         this.add("DELETE", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     post(path, ...handlers) {
         this.add("POST", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     patch(path, ...handlers) {
         this.add("PATCH", path, ...handlers);
         return this;
     }
 
+    /**
+     * @param {String|Function} path
+     * @param  {Function[]} handlers
+     * @returns {this}
+     */
     connect(path, ...handlers) {
         this.add("CONNECT", path, ...handlers);
         return this;
     }
 
     /**
+     * @param {String} method
+     * @param {String[]} segments
      * @param {Node} node
-     * @param {string[]} segments
-     * @param {number} index
-     * @param {Node[]} path
-     * @param {Record<string, string>} params
-     * @param {{ best: { nodes: Node[], params: Record<string, string> } }} state
-     * @returns {{ nodes: Node[], params: Record<string, string>, matched: boolean }}
-     */
-    search(node, segments, index, path, params, state,method) {
+     * @param {Array} path
+     * @param {Object} params
+     * @param {Object} state
+     * @param {Number} index
+     * @returns {{path:Array,params:Object,matched:Boolean}}
+     */
+    search(method, segments, node, path = [], params = {}, state = { path: [], params: {} }, index = 0) {
         path.push(node);
-
-        // habis segmen -> full match
-        // if (index === segments.length) {
-        //     return { nodes: path.slice(), params: { ...params }, matched: true };
-        // }
         if (index === segments.length) {
-            if (node.handlers.has(method)) {
-                return { nodes: path.slice(), params: { ...params }, matched: true };
+            if (node.handlers.has(method) || node.handlers.has("ALL")) {
+                return { path, params, matched: true };
             }
-            // node ada tapi tidak punya handler method ini: catat sebagai partial, lalu coba cabang lain
-            if (path.length > state.best.nodes.length) {
-                state.best = { nodes: path.slice(), params: { ...params } };
+            if (path.length > state.path.length) {
+                state.path = path.slice();
+                state.params = { ...params };
             }
             path.pop();
-            return { matched: false };
+            return { path: state.path, params: state.params, matched: false };
         }
-
         const segment = segments[index];
-
-        // 1. static (prioritas tertinggi)
-        const staticChild = node.children.get(segment);
-        if (staticChild) {
-            const res = this.search(staticChild, segments, index + 1, path, params, state,method);
+        if (node.children.has(segment)) {
+            const res = this.search(
+                //
+                method,
+                segments,
+                node.children.get(segment),
+                path,
+                params,
+                state,
+                index + 1,
+            );
             if (res.matched) return res;
         }
-
-        // 2. semua param child (bisa lebih dari satu)
-        for (const [key, child] of node.params) {
-            const name = key.slice(1); // buang ':'
-            const prev = params[name];
-            params[name] = decodeParam(segment);
-            const res = this.search(child, segments, index + 1, path, params, state,method);
-            if (res.matched) return res;
-            // backtrack param value
-            if (prev === undefined) delete params[name];
-            else params[name] = prev;
+        if (node.params.size) {
+            for (const [, child] of node.params) {
+                const prev = params[child.name];
+                params[child.name] = decodeParam(segment);
+                const res = this.search(
+                    //
+                    method,
+                    segments,
+                    child,
+                    path,
+                    params,
+                    state,
+                    index + 1,
+                );
+                if (res.matched) return res;
+                if (prev === undefined) {
+                    const { [child.name]: _, ...rest } = params;
+                    params = rest;
+                } else params[child.name] = prev;
+            }
         }
-
-        // 3. wildcard (prioritas terendah, menyerap sisa segmen)
-        if (node.wildcard) {
+        if (node.wildcard && (node.wildcard.handlers.get(method) || node.wildcard.handlers.get("ALL"))) {
             const rest = segments.slice(index).join("/");
             params["wildcard"] = decodeParam(rest);
             path.push(node.wildcard);
-            return { nodes: path.slice(), params: { ...params }, matched: true };
+            return { path, params, matched: true };
         }
-
-        // tidak match di sini -> update partial terpanjang
-        // path.length > state.best.nodes.length artinya kita sudah lebih dalam
-        if (path.length > state.best.nodes.length) {
-            state.best = { nodes: path.slice(), params: { ...params } };
+        if (path.length > state.path.length) {
+            state.path = path.slice();
+            state.params = { ...params };
         }
-
         path.pop();
-        return { matched: false };
+        return { path: state.path, params: state.params, matched: false };
     }
 
+    /**
+     * @param {Node} r
+     * @param {String} method
+     * @param {Object} handlers
+     */
     collectHandler(r, method, handlers) {
         if (r.handlers.has(method)) {
             for (const entry of r.handlers.get(method)) {
@@ -170,49 +249,40 @@ class Router {
         }
     }
 
-    collectErrorHandler(r, errorHandlers) {
-        if (r.handlers.has("CATCH")) {
-            for (const entry of r.handlers.get("CATCH")) {
-                errorHandlers[entry.seq] = entry.handler;
-            }
-        }
-    }
-
+    /**
+     * @param {Node} r
+     * @param {Object} handlers
+     * @param {Object} errorHandlers
+     */
     collectMiddleware(r, handlers, errorHandlers) {
         this.collectHandler(r, "ALL", handlers);
-        this.collectErrorHandler(r, errorHandlers);
+        this.collectHandler(r, "CATCH", errorHandlers);
     }
 
+    /**
+     * @param {String} method
+     * @param {String} path
+     * @returns {{matched: boolean;params: Object;paramsLength: number;handlers: any[];errorHandlers: any[];}}
+     */
     find(method, path) {
-        const segments = this.split(path);
-
-        const params = {};
+        const res = this.search(
+            //
+            method,
+            this.split(path),
+            this.root,
+        );
         const handlers = {};
         const errorHandlers = {};
-
-        /** @type {{ best: { nodes: Node[], params: Record<string, string> } }} */
-        const state = { best: { nodes: [], params: {} } };
-
-        const res = this.search(this.root, segments, 0, [], params, state,method);
-
-        const matchedNodes = res.matched ? res.nodes : state.best.nodes;
-        const finalParams = res.matched ? res.params : state.best.params;
-
-        // middleware dari semua node di jalur (partial atau full)
-        for (const r of matchedNodes) {
+        for (const r of res.path) {
             this.collectMiddleware(r, handlers, errorHandlers);
         }
-
-        // method handler HANYA kalau full match
         if (res.matched) {
-            const leaf = matchedNodes[matchedNodes.length - 1];
-            this.collectHandler(leaf, method, handlers);
+            this.collectHandler(res.path.at(-1), method, handlers);
         }
-
         return {
             matched: res.matched,
-            params: finalParams,
-            paramsLength: Object.keys(finalParams).length,
+            params: res.params,
+            paramsLength: Object.keys(res.params).length,
             handlers: Object.values(handlers),
             errorHandlers: Object.values(errorHandlers),
         };

package/src/util.js

@@ -1,7 +1,10 @@
-// const EMPTY_PARAMS = Object.freeze(Object.create(null));
-const EMPTY_PARAMS = Object.create(null)
+const EMPTY_PARAMS = Object.create(null);
 exports.EMPTY_PARAMS = EMPTY_PARAMS;
 
+/**
+ * @param {String} raw
+ * @returns {String}
+ */
 function decodeParam(raw) {
     try {
         return decodeURIComponent(raw);
@@ -11,9 +14,12 @@ function decodeParam(raw) {
 }
 exports.decodeParam = decodeParam;
 
+/**
+ * @param {String} raw
+ * @returns {String}
+ */
 function decodeQuery(raw) {
     const normalized = raw.replace(/\+/g, " ");
-
     try {
         return decodeURIComponent(normalized);
     } catch (error) {
@@ -21,19 +27,19 @@ function decodeQuery(raw) {
     }
 }
 
+/**
+ * @param {String} queryString
+ * @returns {Object}
+ */
 function parseQueryString(queryString) {
     if (queryString === "") return Object.create(null);
-
     const regex = /([^=&]*)=([^&]*)/g;
     const result = Object.create(null);
-
     let match;
     while ((match = regex.exec(queryString))) {
         const [, rawName, rawValue] = match;
-
         const name = decodeQuery(rawName);
         const value = decodeQuery(rawValue);
-
         if (Object.hasOwn(result, name)) {
             if (Array.isArray(result[name])) result[name].push(value);
             else result[name] = [result[name], value];
@@ -44,14 +50,16 @@ function parseQueryString(queryString) {
 }
 exports.parseQueryString = parseQueryString;
 
+/**
+ * @param {String} url
+ * @returns {{path: any;queryString: any;}}
+ */
 function parseUrl(url) {
     if (!(url.includes("?") || url.includes("#"))) {
         return { path: url, queryString: "" };
     }
-
     const regex = /^([^?#]*)(\?([^#]*))?(#.*)?$/;
     const [, path = "/", , queryString = ""] = regex.exec(url);
-    
     return { path, queryString };
 }
 exports.parseUrl = parseUrl;