bun-router 0.7.0 → 0.7.2

package/README.md

@@ -1,83 +1,56 @@
-# Bun Router
-
-I needed a router for `Bun`, so I made one. It's simple, naive, and hardly anything is abstracted. 
+# Bun router
 
 ### Usage
-```typescript
-import { router } from 'bun-router';
-
-const r = router();
+`npm i -s bun-router` 
 
-r.add('/', 'GET', (ctx) => new Response('Hello World'));
-
-r.serve();
-```
-#### Static Files
-```typescript
-import { router } from 'bun-router';
+or 
 
-const r = router();
+`bun i bun-router`
 
-r.static('/', './pages');
 
-r.serve();
-```
+#### Examples
+##### URL Parameters
+```ts
+import { Router, http } from 'bun-router';
 
-##### Example
-```typescript
-import {router, html, json } from 'bun-router';
+const router = Router();
 
-const r = router(3001);
+router.add('/', 'GET', () => http.ok());
 
-r.add('/', (ctx) => html('<h1>Hello World</h1>'));
+router.get('/u/:username', ctx => {
+    const username = ctx.params.get('username');
 
-r.add('/greeting/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    if (!name) return new Response('invalid url parameters', {status: 400});
+    if (!username) return http.badRequest();
 
-    return html(`<h4>Greetings, ${name}!</h4>`);
+    return ctx.json({ username: username });
 });
 
-const store: Map<string, string> = new Map();
+router.serve();
+```
 
-r.add('/user/:id', 'GET', (ctx) => {
-    const id = ctx.params.get('id');
-    if (!id) return new Response('user not found', {status: 404});
-    
-    const user = store.get(id);
+##### Static
+```ts
+import { Router } from 'bun-router';
 
-    if (!user) return new Response('user not found', { status: 404 });
+const router = Router();
 
-    return json(user);
-});
+router.static('/assets', 'static');
 
-r.serve();
+router.serve();
 ```
 
-**SQLite**
+##### SQLite
 ```ts
-import { router, json } from 'bun-router';
-import { Database } from 'bun:sqlite';
-
-const r = router(3000, {db: './examples/dbs/test.db'});
+import { Router } from 'bun-router'
 
-r.add('/u/new/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const rando = Math.floor(Math.random()*1000);
+const router = Router(3000, { db: 'test.db'});
 
-    ctx.db.run(`INSERT INTO test VALUES(${rando}, "${name}")`);
+router.post('/register', ctx => {
+    const query = ctx.db.query("select 'Hello' as message;");
 
-    return json({message: 'ok'});
+    return http.ok(query.get());
 });
 
-r.add('/u/:name', 'GET', (ctx) => {
-    const name = ctx.params.get('name');
-    const data = ctx.db.query(`SELECT * FROM test WHERE name = "${name}";`).get();
-    const d = data as {id: number, name: string};
-
-    return d ? json(d) : new Response('not found', {status: 404});
-});
+```
 
-r.serve();
 
-```

package/examples/basic.ts

@@ -1,13 +1,13 @@
-import { router, http } from '..';
+import { Router, http } from '..';
 
-const r = router();
+const router = Router();
 
-r.add('/', 'GET', () => http.json(200, 'ok'));
+router.add('/', 'GET', () => http.json(200, 'ok'));
 
-r.add('/user/:name', 'GET', (ctx) => {
+router.add('/user/:name', 'GET', (ctx) => {
     const name = ctx.params.get('name');
     if (!name) return http.json(500, 'no name');
     return http.json(200, name);
 });
 
-r.serve();
+router.serve();

package/examples/db.ts

@@ -0,0 +1,10 @@
+import { Router, http } from '..';
+
+const router = Router(3000, {db: './dbs/test.db'});
+
+router.add('/', 'GET', async (ctx) => {
+    const formData = await ctx.formData;
+    const name = formData?.get('name');
+    return http.ok();
+});
+

package/examples/dynamic.ts

@@ -1,7 +1,7 @@
-import { router, http } from '..';
+import { Router, http } from '..';
 import { Context } from '../lib/router/router.d';
 
-const home = (ctx: Context) => new Response('Welcome Home', { status: 200 });
+const home = () => new Response('Welcome Home', { status: 200 });
 
 const subreddit = (ctx: Context) => {
     const sub = ctx.params.get('subreddit');
@@ -15,7 +15,7 @@ const user = (ctx: Context) => {
     return http.json(200, { user: user });
 }
 
-const r = router();
+const r = Router();
 
 r.add('/', 'GET', home);
 r.add('/r/:subreddit', 'GET', subreddit);

package/examples/logger.ts

@@ -1,16 +1,11 @@
-import { router, logger, http } from '..';
+import { Router, http } from '..';
 
-const r = router();
-const log = logger();
+const r = Router();
 
-r.add('/:foo', 'GET', (ctx) => {
-    const url = new URL(ctx.request.url);
-    const foo = ctx.params.get('foo');
-    if (!foo) {
-        log.error(500, url.pathname, ctx.request.method, new Error('undefined'));
-        return http.json(500,{text: 'Foo is undefined'});
-    }
-    return http.html(200, `<h4 style='font-family: sans-serif;'>Oh hello, ${foo}</h4>`)
+r.get('/', ctx => {
+    ctx.logger.debug('hello from home');
+    
+    return http.ok();
 });
 
 r.serve();

package/examples/static.ts

@@ -1,6 +1,6 @@
-import { router } from '..';
+import { Router } from '..';
 
-const r = router(3001);
+const r = Router(3001);
 
 r.static('/', './examples/pages');
 r.serve();

package/examples/todo.ts

@@ -1,5 +1,4 @@
-import { router, http } from '..';
-import { Context } from '../lib/router/router.d';
+import { Router, http } from '..';
 
 const Todo = () => {
     const list: Record<string, string> = {};
@@ -15,7 +14,7 @@ const Todo = () => {
 
 const todo = Todo();
 
-const r = router();
+const r = Router();
 
 r.add('/api/new', 'POST', ctx => {
     const query = new URL(ctx.request.url).searchParams;

package/lib/fs/fsys.ts

@@ -5,22 +5,21 @@ import path from 'path';
 // check if the file path is a directory
 const isDir = async (fp: string): Promise<boolean> => (await fs.lstat(fp)).isDirectory();
 
-// read a directory recursively and apply the callback to each one
-const readDir = async (dirpath: string, handler: (filepath: string, entry: BunFile) => void) => {
-        const files = await fs.readdir(dirpath);
+async function readDir(dirpath: string, handler: (filepath: string, entry: BunFile) => void) {
+    const files = await fs.readdir(dirpath);
 
-        for (const file of files) {
-            const bunFile = Bun.file(file);
+    for (const file of files) {
+        const bunFile = Bun.file(file);
 
-            if (typeof bunFile.name === 'undefined') return
+        if (typeof bunFile.name === 'undefined') return
 
-            const fp = path.join(dirpath, bunFile.name);
-            const isdir = await isDir(fp);
-
-            if (isdir) await readDir(fp, handler);
-            else handler(fp, bunFile);
-        }
+        const fp = path.join(dirpath, bunFile.name);
+        const isdir = await isDir(fp);
 
+        if (isdir) await readDir(fp, handler);
+        else handler(fp, bunFile);
+    }
 }
 
+
 export { readDir }

package/lib/http/{generic-methods.ts → http.ts}

@@ -1,6 +1,12 @@
 import { httpStatusCodes } from "./status";
 
 const http = {
+    ok: async (msg?: string): Promise<Response> => {
+        return Promise.resolve(new Response(msg ?? httpStatusCodes[200], {
+            status: 200,
+            statusText: httpStatusCodes[200],
+        }));
+    },
     json: async (statusCode: number, data: any): Promise<Response> => {
         const jsonString = JSON.stringify(data);
         return Promise.resolve(new Response(jsonString, {
@@ -65,7 +71,7 @@ const http = {
             headers: {'Content-Type': 'text/html; charset-utf-8'},
         });
         return Promise.resolve(response)
-    }, 
+    },
 }
 
 export { http }

package/lib/logger/color.ts

@@ -23,13 +23,13 @@ const Colors: Record<string,string> = {
   } as const;
 
   
-const color = (c: string, bkg: string, msg: string) => {
-    const foreground = Colors[c];
-    const background = Colors[bkg];
-    const reset = Colors.reset;
 
-    return `${foreground}${background}${msg}${reset}`;
-};
+function color(foreground: string, background: string, message: string) {
+  const _foreground = Colors[foreground];
+  const _background = Colors[background];
+  const reset = Colors.reset;
+  return `${_foreground}${_background}${message}${reset}`;
+}
 
 
   

package/lib/logger/logger.d.ts

@@ -1,9 +1,8 @@
-type Logger = {
-    start: (port: number | string) => void,
+type BunLogger = {
     info: (statusCode: number, routePath: string, method: string, message?: string) => void,
     error: (statusCode: number, routePath: string, method: string, error: Error) => void,
-    warn: (msg: string) => void,
-    message: (msg: string) => void,
+    warn: (message: string) => void,
+    message: (message: string) => void,
 }
 
-export { Logger }
+export { BunLogger }

package/lib/logger/logger.ts

@@ -1,7 +1,6 @@
 import { color } from './color';
-import {Logger} from './logger.d';
+import { BunLogger } from './logger.d';
 
-const pad = (n: number) => String(n).padStart(2, '0'); 
 
 const TITLE = `
 _                          _           
@@ -10,8 +9,50 @@ _                          _
 |___|___|_|_|  |_| |___|___|_| |___|_|  
                                                                                     
 `
+const VERSION = '0.7.1';
+const Logger = (): BunLogger => {
+    return {
+        info: async (statusCode: number, routePath: string, method: string, message?: string) => {
+            const { stamp } = timestamp((new Date(Date.now())));
+            const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
+            const rp = color('white', 'bgBlack', routePath);
+
+            message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}${ message ?? ''}\n`
 
-const timestamp = (date: Date) => {
+            await Bun.write(Bun.stdout, message);
+
+        },
+        error: async (statusCode: number, routePath: string, method: string, error: Error) => {
+            const { stamp } = timestamp((new Date(Date.now())));
+            const source = color('black', 'bgRed', `[error ${stamp}]`);
+            const rp = color('white', 'bgBlack', routePath);
+
+            const message = `${source}: ${setColor(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${error.message}\n`
+
+            await Bun.write(Bun.stdout, message);
+        },
+        warn: async (message: string) => {
+            const { stamp } = timestamp((new Date(Date.now())));
+            const source = color('black', 'bgYellow', `[warning ${stamp}]`);
+            const messageColor = color('yellow', 'bgBlack', message);
+
+            message = `${source} : ${messageColor}\n`;
+
+            await Bun.write(Bun.stdout, message);
+        },
+        message: async (message: string) => {
+            const { stamp } = timestamp((new Date(Date.now())));
+            const source = color('black', 'bgCyan', `[message ${stamp}]`);
+            const messageColor = color('yellow', 'bgBlack', message);
+
+            message = `${source}: ${messageColor}\n`;
+
+            await Bun.write(Bun.stdout, message);
+        },
+    }
+}
+
+function timestamp(date: Date) {
     const month = pad(date.getMonth());
     const day = pad(date.getDate());
     const hour = pad(date.getHours());
@@ -22,80 +63,32 @@ const timestamp = (date: Date) => {
     return {month, day, hour, minute, stamp};
 }
 
-// append ANSI color escape sequences to a string based on the given HTTP status code.
-const colorCode = (n: number, text?:string): string => {
+function setColor(n: number, text?: string){
     const s = ` [${String(n)}${text ?? ''}] `;
+
     if (n < 100) return color('black', 'bgYellow', s);
     else if (n >= 100 && n < 200) return color('black', 'bgCyan', s);
     else if (n >= 200 && n < 300) return color('black', 'bgGreen', s);
     else if (n >= 300 && n < 400) return color('black', 'bgRed', s);
     else if (n >= 400 && n < 500) return color('black', 'bgRed', s);
     else if (n >= 500) return color('white', 'bgRed', s);
+
     return color('white', 'bgBlack', `[${s}]`).trim();
 }
 
-
-const clean = (s: string) => s.replace(/\x1B\[\d{1,2}(;\d{1,2}){0,2}m/g, '');
-
-const format = (statusCode: number, routePath: string, method: string, message?: string): string => {
+function startMessage(port: number | string) {
     const { stamp } = timestamp((new Date(Date.now())));
-    const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
-    const rp = color('white', 'bgBlack', routePath);
+    const source = color('green', 'bgBlack', `[bun-router ${stamp}]`)
+    const portColor = color('green', 'bgBlack', String(port));
+    const msg = `${source}: Starting Server on :${portColor}\n`;
+    const version = color('red', 'bgBlack', `v${VERSION}\n`);
 
-    return `${source} : ${colorCode(statusCode)} : ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}\n`
+    Bun.write(Bun.stdout, TITLE + '\n' + version);
+    Bun.write(Bun.stdout, msg);
 }
 
-const logger = (): Logger => {
-    const messages: string[] = [];
-    const errors: string[] = [];
-    return {
-        // initial log message
-        start: async (port: number | string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('green', 'bgBlack', `[bun-router ${stamp}]`)
-            const portColor = color('green', 'bgBlack', String(port));
-            const msg = `${source}: Starting Server on :${portColor}\n`;
-
-            await Bun.write(Bun.stdout, TITLE);
-            await Bun.write(Bun.stdout, msg);
-        },
-        info: async (statusCode: number, routePath: string, method: string, message?: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('green', 'bgBlack', `[bun-router ${stamp}]`);
-            const rp = color('white', 'bgBlack', routePath);
-            const msg = `${source}: ${colorCode(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${method}${' | ' +message ?? ''}\n`
-
-            await Bun.write(Bun.stdout, msg);
-
-            messages.push(clean(msg));
-        },
-        error: async (statusCode: number, routePath: string, method: string, error: Error) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgRed', `[error ${stamp}]`);
-            const rp = color('white', 'bgBlack', routePath);
-            const msg = `${source}: ${colorCode(statusCode)}: ${rp} ${(method === 'GET') ? '->' : '<-'} ${error.message}\n`;
-
-            await Bun.write(Bun.stdout, msg);
-
-            errors.push(clean(msg));
-        },
-        warn: async (msg: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgYellow', `[warning ${stamp}]`);
-            const msgColor = color('yellow', 'bgBlack', msg);
-            msg = `${source} : ${msgColor}\n`;
-            await Bun.write(Bun.stdout, msg);
-        },
-        message: async (msg: string) => {
-            const { stamp } = timestamp((new Date(Date.now())));
-            const source = color('black', 'bgCyan', `[message ${stamp}]`);
-            const msgColor = color('yellow', 'bgBlack', msg);
-            msg = `${source}: ${msgColor}\n`;
-            await Bun.write(Bun.stdout, msg);
-
-            messages.push(clean(msg));
-        }
-    }
+function pad(n: number) {
+    return String(n).padStart(2, '0');
 }
 
-export { logger }
+export { Logger, startMessage }

package/lib/router/context.ts

@@ -0,0 +1,51 @@
+import { Route, Context } from "./router.d";
+import { Logger } from "../..";
+import { http } from "./router";
+
+async function createContext(path: string, route: Route, request: Request): Promise<Context> {
+    const params = extractParams(path, route);
+    const query = new URLSearchParams(path);
+    const formData = isMultiPartForm(request.headers) ? await request.formData() : new FormData();
+
+    return Promise.resolve({
+        params,
+        request,
+        query,
+        formData,
+        logger: Logger(),
+        json: (statusCode: number, data: any) => http.json(statusCode, data),
+    });
+}
+
+function extractParams(path: string, route: Route): Map<string, string> {
+    const params: Map<string, string> = new Map();
+    const pathSegments = path.split('/');
+    const routeSegments = route.path.split('/');
+
+    if (pathSegments.length !== routeSegments.length) return params;
+
+    for (let i = 0; i < pathSegments.length; i++) {
+        if (routeSegments[i][0] === ':') {
+            const key = routeSegments[i].replace(':', '');
+            const value = pathSegments[i];
+            params.set(key, value);
+        }
+    }
+
+    return params;
+}
+
+function getContentType(headers: Headers): string {
+    const contentType = headers.get('Content-Type');
+    if (!contentType) return '';
+    return contentType;
+}
+
+function isMultiPartForm(headers: Headers): boolean {
+    const contentType = getContentType(headers);
+    return contentType.includes('multipart/form-data');
+}
+
+
+
+export { createContext }

package/lib/router/router.d.ts

@@ -2,29 +2,36 @@ import { TLSOptions, TLSWebSocketServeOptions, WebSocketServeOptions, ServeOptio
 import { Logger } from '../logger/logger';
 import { Database } from 'bun:sqlite';
 
-type HttpHandler = (ctx: Context) => Response | Promise<Response>
+type BunRouter = (port?: number | string, options?: RouterOptions) => {
+    add: (pattern: string, method: string, callback: HttpHandler) => void;
+    get: (pattern: string, callback: HttpHandler) => void;
+    post: (pattern: string, callback: HttpHandler) => void;
+    put: (pattern: string, callback: HttpHandler) => void;
+    delete: (pattern: string, callback: HttpHandler) => void;
+    static: (pattern: string, root: string) => void;
+    serve: () => void;
+}
+
+type Route = {
+    children: Map<string, Route>;
+    path: string;
+    dynamicPath: string;
+    method: string;
+    handler: HttpHandler;
+    isLast: boolean;
+}
 
 type Context = {
-    cookies: Map<string, string>;
     db?: Database;
-    formData: FormData | Promise<FormData> | undefined;
+    formData: FormData | Promise<FormData>;
     json: (statusCode: number, data: any) => Response | Promise<Response>;
     logger: Logger;
     params: Map<string, string>;
     query: URLSearchParams;
     request: Request;
-    token?: string;
 };
 
-
-type Route = {
-    children: Map<string, Route>;
-    path: string;
-    dynamicPath: string;
-    method: string;
-    handler: HttpHandler;
-    isLast: boolean;
-}
+type HttpHandler = (ctx: Context) => Response | Promise<Response>
 
 type Options = {
     db: string,
@@ -36,13 +43,4 @@ type RouterOptions<Options> = ServeOptions
 | TLSWebSocketServeOptions<Options>
 | undefined
 
-
-type Router = (port?: number | string, options?: RouterOptions) => {
-    add: (pattern: string, method: string, callback: (req: Context) => Response | Promise<Response>) => void;
-    static: (pattern: string, root: string) => void;
-    serve: () => void;
-}
-
-
-
-export { Context , Route, Router, RouterOptions, Options, HttpHandler }
+export { Context , Route, BunRouter, RouterOptions, Options, HttpHandler }

package/lib/router/router.ts

@@ -1,42 +1,26 @@
 import path from 'path';
 import { Database } from 'bun:sqlite';
-import { Route, Router, Context, RouterOptions, Options, HttpHandler } from './router.d';
+import { Route, BunRouter, RouterOptions, Options, HttpHandler } from './router.d';
 import { httpStatusCodes } from '../http/status';
 import { readDir } from '../fs/fsys';
-import { logger } from '../logger/logger';
-import { http } from '../http/generic-methods';
-import {Radix, createContext} from './tree';
+import { Logger, startMessage } from '../logger/logger';
+import { http } from '../http/http';
+import {RouteTree } from './tree';
+import { createContext } from './context';
 
-const extract = (path: string, ctx: Context) => {
-    const url = new URL(ctx.request.url);
-    const pathSegments = path.split('/');
-    const urlSegments = url.pathname.split('/');
 
-    if (pathSegments.length !== urlSegments.length) return
-
-    return {
-        params: () => {
-            for (let i = 0; i < pathSegments.length; i++) {
-                if((pathSegments[i][0] === ':')) {
-                    const k = pathSegments[i].replace(':', '');
-                    const v = urlSegments[i];
-                    ctx.params.set(k,v);
-                }
-            }
-        }
-    }
-
-}
-
-const router: Router = (port?: number | string, options?: RouterOptions<Options>) => {
-    const {addRoute, findRoute} = Radix();
-    const lgr = logger();
+const Router: BunRouter = (port?: number | string, options?: RouterOptions<Options>) => {
+    const { addRoute, findRoute } = RouteTree();
+    const logger = Logger();
 
     return {
         // add a route to the router tree 
-        add: (pattern: string, method: string, callback: HttpHandler) => {
-            addRoute(pattern, method, callback);
-        },
+        add: (pattern, method, callback) => { addRoute(pattern, method, callback) },
+        get: (pattern: string, callback: HttpHandler) => { addRoute(pattern, 'GET', callback) },
+        post: (pattern, callback) => { addRoute(pattern, 'POST', callback) },
+        put: (pattern, callback) => { addRoute(pattern, 'PUT', callback)},
+        delete: (pattern, callback) => { addRoute(pattern, 'DELETE', callback) },
+        
         // add a static route to the router tree
         static: async (pattern: string, root: string) => {
             await readDir(root, async (fp, _) => {
@@ -67,10 +51,9 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
         },
         // start the server
         serve: () => {
-            lgr.start(port ?? 3000);
+            startMessage(port ?? 3000);
             let opts: Options = { db: ':memory:' };
 
-            // TODO: add support for TLS and WebSockets
             Bun.serve({
                 port: port ?? 3000,
                 ...options,
@@ -89,24 +72,24 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
                     // if the route exists, execute the handler
                     if (route) {
                         if (route.method !== req.method) {
-                            lgr.info(405, url.pathname, req.method, httpStatusCodes[405]);
-                            return Promise.resolve(http.methodNotAllowed());
+                            logger.info(405, url.pathname, req.method, httpStatusCodes[405]);
+                            return Promise.resolve(http.errMethodNotAllowed());
                         }
 
-                        const context = createContext(path, route, req);
+                        const context = await createContext(path, route, req);
                         context.db = new Database(opts.db);
 
                         const response = await route.handler(context);
 
-                        lgr.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+                        logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
                         return Promise.resolve(response);
                     } 
 
                     // if no route is found, return 404
-                    const response = await http.notFound();
+                    const response = await http.errNotFound();
                         
-                    lgr.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
-                    return Promise.resolve(http.notFound());
+                    logger.info(response.status, url.pathname, req.method, httpStatusCodes[response.status]);
+                    return Promise.resolve(http.errNotFound());
 
                 }
             });
@@ -114,5 +97,4 @@ const router: Router = (port?: number | string, options?: RouterOptions<Options>
     }
 }
 
-
-export { router, extract, http }
+export { Router, http }

package/lib/router/tree.ts

@@ -1,5 +1,6 @@
-import { HttpHandler, Context, Route } from "./router.d";
-import { http } from "../http/generic-methods";
+import { HttpHandler, Route } from "./router.d";
+import { http } from "../http/http";
+import { createContext } from './context';
 
 const splitPath = (s: string): string[] => s.split('/').filter(x => x !== '');
 
@@ -16,35 +17,7 @@ const createRoute = (path: string, method: string, handler: HttpHandler): Route
     return route;
 };
 
-const extractParams = (path: string, route: Route, params: Map<string, string>) => {
-    const pathParts = splitPath(path);
-    const routeParts = splitPath(route.path);
-
-    for (let i = 0; i < routeParts.length; i++) {
-        const part = routeParts[i];
-        if (part.startsWith(':')) {
-            params.set(part.slice(1), pathParts[i]);
-        }
-    }
-};
-
-const createContext = (path: string, route: Route, req: Request): Context => {
-    const params: Map<string, string> = new Map();
-
-    if (route) extractParams(path, route, params);
-
-    return {
-        params: params,
-        request: req,
-        query: new URLSearchParams(path),
-        cookies: new Map(),
-        formData: undefined,
-        logger: undefined,
-        json: (statusCode: number, data: any) => http.json(statusCode, data),
-    }
-};
-
-const Radix = () => {
+const RouteTree = () => {
     let root = createRoute('', 'GET', () => http.notFound());
 
     const addRoute = (path: string, method: string, handler: HttpHandler) => {
@@ -87,4 +60,4 @@ const Radix = () => {
 
 };
 
-export { Radix, createContext }
+export { RouteTree, createContext }

package/lib/util/strings.ts

@@ -0,0 +1,3 @@
+const splitPath = (path: string): string[] => path.split('/').filter(Boolean);
+
+export { splitPath }

package/package.json

@@ -8,5 +8,5 @@
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
-  "version": "0.7.0"
+  "version": "0.7.2"
 }

package/examples/cookies.ts

@@ -1,15 +0,0 @@
-import { router } from '..';
-
-const r = router();
-
-r.add('/set-cookie', 'GET', ctx => {
-    ctx.cookies.set('domain', 'localhost');
-    ctx.cookies.set('path', '/set-cookie');
-
-    ctx.logger.message(ctx.token ?? 'no token provided');
-
-    return ctx.json( 200, {message: 'cookie stored'});
-});
-
-
-r.serve();