princejs 1.2.3 → 1.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matthew Michael (MatthewTheCoder1218)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Readme.md

@@ -1,7 +1,7 @@
 # PrinceJS
 
 **The fastest backend framework ever made.**  <br>
-**Under 5 kB • Beats Hono and Express • Built in 3 days** <br>
+**Beats Hono and Express • Built in 3 days** <br>
 
 ---
 

package/dist/prince.js

@@ -1,20 +1,27 @@
 // @bun
 // prince.ts
+class TrieNode {
+  children = Object.create(null);
+  paramChild;
+  wildcardChild;
+  catchAllChild;
+  handlers = null;
+}
+
 class Prince {
-  routes = Object.create(null);
+  devMode;
+  rawRoutes = [];
   middlewares = [];
-  use(middleware) {
-    this.middlewares.push(middleware);
+  errorHandler;
+  constructor(devMode = false) {
+    this.devMode = devMode;
+  }
+  use(mw) {
+    this.middlewares.push(mw);
     return this;
   }
-  error(handler) {
-    this.use(async (req, next) => {
-      try {
-        return await next();
-      } catch (err) {
-        return handler(err, req);
-      }
-    });
+  error(fn) {
+    this.errorHandler = fn;
     return this;
   }
   json(data, status = 200) {
@@ -45,45 +52,183 @@ class Prince {
     return this.add("HEAD", path, handler);
   }
   add(method, path, handler) {
-    this.routes[path] ??= Object.create(null);
-    this.routes[path][method] = handler;
+    if (!path.startsWith("/"))
+      path = "/" + path;
+    if (path.length > 1 && path.endsWith("/"))
+      path = path.slice(0, -1);
+    const parts = path === "/" ? [""] : path.split("/").slice(1);
+    this.rawRoutes.push({ method: method.toUpperCase(), path, parts, handler });
     return this;
   }
+  fastPathname(req) {
+    const u = req.url;
+    const protoSep = u.indexOf("://");
+    const start = protoSep !== -1 ? u.indexOf("/", protoSep + 3) : u.indexOf("/");
+    if (start === -1)
+      return "/";
+    const q = u.indexOf("?", start);
+    const h = u.indexOf("#", start);
+    const end = q !== -1 ? q : h !== -1 ? h : u.length;
+    return u.slice(start, end);
+  }
+  buildRouter() {
+    const root = new TrieNode;
+    for (const route of this.rawRoutes) {
+      let node = root;
+      const parts = route.parts;
+      if (parts.length === 1 && parts[0] === "") {
+        if (!node.handlers)
+          node.handlers = Object.create(null);
+        node.handlers[route.method] = route.handler;
+        continue;
+      }
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "**") {
+          node.catchAllChild ??= { node: new TrieNode };
+          node = node.catchAllChild.node;
+          break;
+        } else if (part === "*") {
+          if (!node.wildcardChild)
+            node.wildcardChild = new TrieNode;
+          node = node.wildcardChild;
+        } else if (part.startsWith(":")) {
+          const name = part.slice(1);
+          if (!node.paramChild)
+            node.paramChild = { name, node: new TrieNode };
+          node = node.paramChild.node;
+        } else {
+          if (!node.children[part])
+            node.children[part] = new TrieNode;
+          node = node.children[part];
+        }
+      }
+      if (!node.handlers)
+        node.handlers = Object.create(null);
+      node.handlers[route.method] = route.handler;
+    }
+    return root;
+  }
+  compilePipeline(handler, paramsFromMatch) {
+    const mws = this.middlewares.slice();
+    return async (req) => {
+      let idx = 0;
+      const runNext = async () => {
+        if (idx >= mws.length) {
+          const params = paramsFromMatch(req);
+          const res = await handler(req, params);
+          if (res instanceof Response)
+            return res;
+          if (typeof res === "string")
+            return new Response(res, { status: 200 });
+          if (res instanceof Uint8Array || res instanceof ArrayBuffer)
+            return new Response(res, { status: 200 });
+          return this.json(res);
+        }
+        const mw = mws[idx++];
+        const maybe = await mw(req, runNext);
+        return maybe;
+      };
+      const out = await runNext();
+      if (out instanceof Response)
+        return out;
+      if (out !== undefined) {
+        if (typeof out === "string")
+          return new Response(out, { status: 200 });
+        if (out instanceof Uint8Array || out instanceof ArrayBuffer)
+          return new Response(out, { status: 200 });
+        return this.json(out);
+      }
+      return new Response(null, { status: 204 });
+    };
+  }
   listen(port = 3000) {
-    const mw = this.middlewares;
-    const mwLen = mw.length;
-    const routes = this.routes;
-    return Bun.serve({
+    const root = this.buildRouter();
+    const handlerMap = new Map;
+    Bun.serve({
       port,
       fetch: async (req) => {
         try {
-          const url = req.url;
-          const path = url.slice(url.indexOf("/", 8));
-          const route = routes[path];
-          const handler = route?.[req.method] ?? route?.["GET"];
-          if (!handler) {
+          const pathname = this.fastPathname(req);
+          const segments = pathname === "/" ? [] : pathname.slice(1).split("/");
+          let node = root;
+          const params = Object.create(null);
+          let matched = true;
+          if (segments.length === 0) {
+            if (!node.handlers)
+              return this.json({ error: "Route not found" }, 404);
+            const handler2 = node.handlers[req.method];
+            if (!handler2)
+              return this.json({ error: "Method not allowed" }, 405);
+            let methodMap2 = handlerMap.get(node);
+            if (!methodMap2) {
+              methodMap2 = Object.create(null);
+              handlerMap.set(node, methodMap2);
+            }
+            if (!methodMap2[req.method]) {
+              methodMap2[req.method] = this.compilePipeline(handler2, (_) => params);
+            }
+            return await methodMap2[req.method](req);
+          }
+          for (let i = 0;i < segments.length; i++) {
+            const seg = segments[i];
+            if (!node) {
+              matched = false;
+              break;
+            }
+            if (node.children[seg]) {
+              node = node.children[seg];
+              continue;
+            }
+            if (node.paramChild) {
+              params[node.paramChild.name] = seg;
+              node = node.paramChild.node;
+              continue;
+            }
+            if (node.wildcardChild) {
+              node = node.wildcardChild;
+              continue;
+            }
+            if (node.catchAllChild) {
+              const remaining = segments.slice(i).join("/");
+              if (node.catchAllChild.name)
+                params[node.catchAllChild.name] = remaining;
+              node = node.catchAllChild.node;
+              i = segments.length;
+              break;
+            }
+            matched = false;
+            break;
+          }
+          if (!matched || !node || !node.handlers)
             return this.json({ error: "Route not found" }, 404);
+          const byMethod = node.handlers;
+          const handler = byMethod[req.method] ?? byMethod["GET"];
+          if (!handler)
+            return this.json({ error: "Method not allowed" }, 405);
+          let methodMap = handlerMap.get(node);
+          if (!methodMap) {
+            methodMap = Object.create(null);
+            handlerMap.set(node, methodMap);
           }
-          if (!mwLen) {
-            const result = await handler(req);
-            return result instanceof Response ? result : this.json(result);
+          if (!methodMap[req.method]) {
+            methodMap[req.method] = this.compilePipeline(handler, (_) => params);
           }
-          let idx = 0;
-          const next = async () => {
-            if (idx < mwLen)
-              return mw[idx++](req, next);
-            const result = await handler(req);
-            return result instanceof Response ? result : this.json(result);
-          };
-          return next();
+          return await methodMap[req.method](req);
         } catch (err) {
+          if (this.errorHandler) {
+            try {
+              return this.errorHandler(err, req);
+            } catch {}
+          }
           return this.json({ error: String(err) }, 500);
         }
       }
     });
+    console.log(`PrinceJS v2 running at http://localhost:${port}`);
   }
 }
-var prince = () => new Prince;
+var prince = (dev = false) => new Prince(dev);
 export {
   prince,
   Prince

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "princejs",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "An easy and fast backend framework — by a 13yo developer, for developers.",
   "main": "dist/prince.js",
   "types": "dist/prince.d.ts",
@@ -15,7 +15,7 @@
     "easy",
     "princejs"
   ],
-  "author": "Matthew Micheal",
+  "author": "Matthew Michael (MatthewTheCoder1218)",
   "license": "MIT",
   "repository": "https://github.com/MatthewTheCoder1218/princejs",
   "publishConfig": {