@mapl/web 0.4.1 → 0.5.0

package/README.md

@@ -1,13 +1,31 @@
-A compiled web framework for all runtimes.
-
-## AOT compilation (experimental)
-Build `@mapl/web` to improve startup time.
-
-### Rolldown
-Try it out using:
-```sh
-npm install -g degit
-degit github:mapljs/web/examples/generic
-# or with Bun
-degit github:mapljs/web/examples/bun
+# `@mapl/web`
+A low level, fast and type-safe framework.
+
+```ts
+import { inject, route, router, send } from '@mapl/web';
+import { compiler, request } from '@mapl/web/generic';
+
+const app = router(
+  [],
+  [
+    route.get(
+      '/',
+      send.raw((c) => {
+        c.status = 418;
+        return 'Hi';
+      }),
+    ),
+    route.post(
+      '/body',
+      send.json(
+        inject([request], async (req) => req.json())
+      ),
+    ),
+  ],
+);
+
+export default {
+  fetch: compiler.buildSync(app)(),
+};
+
 ```

package/bun/index.d.ts

@@ -1,11 +1,4 @@
 import type { BunRequest, Server } from "bun";
-import { type ChildRouters, type InferHandlers, type InferRouter } from "../core/index.js";
-import type { MiddlewareTypes } from "../core/middleware.js";
-export interface BunContext {
-	readonly req: BunRequest;
-	readonly server: Server<any>;
-}
-export declare const router: <
-	const T extends MiddlewareTypes<BunContext, any, any>[],
-	const S extends ChildRouters<BunContext> = {}
->(middlewares: T, handlers: InferHandlers<BunContext, T>, children?: S) => InferRouter<BunContext, T, S>;
+import type { LocalDependency } from "runtime-compiler";
+export declare const request: LocalDependency<BunRequest>;
+export declare const server: LocalDependency<Server<any>>;

package/bun/index.js

@@ -1 +1 @@
-import{routerImpl}from"../core/index.js";export let router=routerImpl;
+export let request=`mr`;export let server=`mi`;

package/compiler/call.d.ts

@@ -0,0 +1,10 @@
+import type { State } from "./state.ts";
+/**
+* Compile a function to call statement.
+* Use in `default` and `build` mode.
+*/
+export declare const buildCall: (state: State, fn: (...args: any[]) => any, paramCount: number, params: string) => string;
+/**
+* Hydrate a call.
+*/
+export declare const hydrateCall: (state: State, fn: (...args: any[]) => any, paramCount: number) => void;

package/compiler/call.js

@@ -0,0 +1 @@
+import{getDeps}from"runtime-compiler/call";import{injectExternalDependency}from"runtime-compiler";import{AsyncFunction}from"runtime-compiler/utils";export let buildCall=(state,fn,paramCount,params)=>{let fnId=injectExternalDependency(fn);if(fn instanceof AsyncFunction){state[0]=true;fnId=`await `+fnId}let deps=getDeps(fn);return deps==null?fn.length>paramCount?(state[1]=true,`${fnId}(${params}mc)`):`${fnId}(${params})`:fn.length>paramCount+deps.length?(state[1]=true,`${fnId}(${deps.join()},${params}mc)`):`${fnId}(${deps.join()},${params})`};export let hydrateCall=(state,fn,paramCount)=>{injectExternalDependency(fn);state[0]||=fn instanceof AsyncFunction;let deps=getDeps(fn);state[1]||=fn.length>(deps==null?paramCount:deps.length+paramCount)};

package/compiler/globals.d.ts

@@ -0,0 +1,34 @@
+/**
+* @module Global compiler hooks
+*/
+import type { Route } from "./router.ts";
+import type { State } from "./state.ts";
+export declare let registerRoute: (route: Route, state: State, prefix: string, content: string) => any;
+/**
+* Set a callback that register routes to a router.
+* Use in `default` and `build` mode.
+*/
+export declare const setRegisterRoute: (f: typeof registerRoute) => void;
+export declare let routeParamMap: string[];
+/**
+* Set route param map.
+* Use in `default` and `build` mode.
+*
+* @example
+* setRouteParamMap([
+*   '', 'err'
+* ]);
+*
+* routeParamMap[paramCount << 1]; // No context
+* routeParamMap[paramCount << 1 | 1]; // With context
+*/
+export declare const setRouteParamMap: (m: string[]) => void;
+export declare let handlerArgs: string;
+/**
+* Set request handler args.
+* Use in `default` and `build` mode.
+*
+* @example
+* setHandlerArgs('(req, env, ctx)');
+*/
+export declare const setHandlerArgs: (a: string) => void;

package/compiler/globals.js

@@ -0,0 +1 @@
+export let registerRoute;export let setRegisterRoute=f=>{registerRoute=f};export let routeParamMap=[];export let setRouteParamMap=m=>{routeParamMap=m};export let handlerArgs;export let setHandlerArgs=a=>{handlerArgs=a};

package/compiler/router.d.ts

@@ -0,0 +1,37 @@
+import type { State } from "./state.ts";
+/*
+* From what i've tested closures use 5x more
+* memory than [fn, ...data] and runs slower too
+*/
+export type Layer<Data extends any[] = any[]> = [build: (data: any[], state: State) => string, ...Data];
+export type InferPath<Path extends string> = Path extends `${string}*${infer Rest}` ? Rest extends "*" ? [string] : [string, ...InferPath<Rest>] : [];
+export type RouteLayer<Params extends any[]> = [build: (data: any[], state: State, paramCount: number, paramString: string) => string, ...any[]] & {
+	_?: Params;
+};
+export type Route = [method: string, path: string, ...layers: RouteLayer<any[]>[]];
+export type RegisterRouteFn = <const Path extends string>(path: Path, ...layers: RouteLayer<InferPath<Path>>[]) => Route;
+export type RegisterRouteWithMethodFn = <const Path extends string>(method: string, path: Path, ...layers: RouteLayer<InferPath<Path>>[]) => Route;
+export type Router = [layers: Layer[], routes: Route[]] | [layers: Layer[], routes: Route[], children: Record<string, Router>];
+/**
+* Run a layer
+*/
+export declare const evaluateLayer: (layer: Layer, state: State) => string;
+/**
+* Run a route layer
+*/
+export declare const evaluateRouteLayer: (layer: RouteLayer<any[]>, state: State, paramCount: number, params: string) => string;
+// Build implementations
+/**
+* Use in `default` and `build` mode.
+*
+* @example
+* build(router, [false, false] as any, '', '');
+*/
+export declare const build: (router: Router, state: State, prefix: string, content: string) => void;
+/**
+* Use in `hydrate` mode.
+*
+* @example
+* build(router, [false, false] as any);
+*/
+export declare const hydrate: (router: Router, state: State) => void;

package/compiler/router.js

@@ -0,0 +1 @@
+import{countParams}from"@mapl/router/utils";import{registerRoute,routeParamMap}from"./globals.js";export let evaluateLayer=(layer,state)=>layer[0](layer,state);export let evaluateRouteLayer=(layer,state,paramCount,params)=>layer[0](layer,state,paramCount,params);export let build=(router,state,prefix,content)=>{for(let i=0,layers=router[0];i<layers.length;i++)content+=evaluateLayer(layers[i],state);for(let i=0,routes=router[1];i<routes.length;i++){let route=routes[i];let routeState=state.slice();let routeContent=content;for(let j=2,paramCount=countParams(route[1]),params=routeParamMap[paramCount];j<route.length;j++)routeContent+=evaluateRouteLayer(route[j],routeState,paramCount,params);registerRoute(route,routeState,prefix,routeContent)}if(router.length>2){let children=router[2];for(let key in children)build(children[key],state.slice(),key===`/`?prefix:prefix+key,content)}};export let hydrate=(router,state)=>{for(let i=0,layers=router[0];i<layers.length;i++)evaluateLayer(layers[i],state);for(let i=0,routes=router[1];i<routes.length;i++){let route=routes[i];let routeState=state.slice();for(let j=2,paramCount=countParams(route[1]);j<route.length;j++)evaluateRouteLayer(route[j],routeState,paramCount,``)}if(router.length>2){let children=router[2];for(const key in children)hydrate(children[key],state.slice())}};

package/compiler/state.d.ts

@@ -0,0 +1,32 @@
+export interface State extends Array<any> {
+	/**
+	* Whether scope should be async
+	*/
+	0: boolean;
+	/**
+	* Whether the scope needs a context object
+	*/
+	1: boolean;
+	/**
+	* Fork the current state
+	*/
+	slice: () => this;
+}
+/**
+* Create initial state
+*/
+export declare const initState: () => State;
+/**
+* Use in `default` and `build` mode.
+*
+* @example
+* finalizeReturn([true, true], 'return await fn(c);');
+*/
+export declare const finalizeReturn: (state: State, content: string) => string;
+/**
+* Use in `default` and `build` mode.
+*
+* @example
+* finalizeFn([true, true], 'return await fn(c);');
+*/
+export declare const finalizeFn: (state: State, content: string) => string;

package/compiler/state.js

@@ -0,0 +1 @@
+import{injectDependency}from"runtime-compiler";import{handlerArgs}from"./globals.js";export let initState=()=>[false,false];export let finalizeReturn=(state,content)=>state[0]?`return `+injectDependency(`async${handlerArgs}=>{${state[1]?`let mh=[],mc={status:200,headers:mh};`+content:content}}`)+handlerArgs:state[1]?`let mh=[],mc={status:200,headers:mh};`+content:content;export let finalizeFn=(state,content)=>injectDependency(`${state[0]?`async`+handlerArgs:handlerArgs}=>{${state[1]?`let mh=[],mc={status:200,headers:mh};`+content:content}}`);

package/constants.d.ts

@@ -1,6 +1,18 @@
 export * from "@mapl/framework/constants";
-export declare const HEADERS: string;
-export declare const SERVER_INFO: string;
-export declare const BUN_FN_ARGS: string;
-export declare const BUN_FN_START: string;
-export declare const PARSE_PATH: string;
+export * from "@mapl/router/constants";
+// Additional args
+export declare const CTX = "mc";
+export declare const HEADERS = "mh";
+export declare const PARSED_RESULT = "mt";
+export declare const CREATE_CTX: string;
+// Mapl locals
+export declare const REQ = "mr";
+export declare const INFO = "mi";
+export declare const FULL_URL = "mu";
+export declare const RES_404 = "mnf";
+export declare const JSON_HEADER = "mjh";
+export declare const JSON_OPTION = "mjo";
+export declare const HTML_HEADER = "mhh";
+export declare const HTML_OPTION = "mho";
+// Fast path for injecting mapl symbols
+export declare const DECL_GLOBALS: string;

package/constants.js

@@ -1 +1 @@
-import{PATH,REQ,URL,PATH_START,PATH_END}from"@mapl/framework/constants";export*from"@mapl/framework/constants";export let HEADERS=`h`;export let SERVER_INFO=`s`;export let BUN_FN_ARGS=`(`+REQ+`,s)`;export let BUN_FN_START=BUN_FN_ARGS+`=>`;export let PARSE_PATH=`let `+URL+`=`+REQ+`.url,`+PATH_START+`=`+URL+`.indexOf("/",12)+1,`+PATH_END+`=`+URL+`.indexOf("?",`+PATH_START+`),`+PATH+`=`+PATH_END+`===-1?`+URL+`.slice(`+PATH_START+`):`+URL+`.slice(`+PATH_START+`,`+PATH_END+`);`;
+export*from"@mapl/framework/constants";export*from"@mapl/router/constants";export let CTX=`mc`;export let HEADERS=`mh`;export let PARSED_RESULT=`mt`;export let CREATE_CTX=`let ${HEADERS}=[],${CTX}={status:200,headers:${HEADERS}};`;export let REQ=`mr`;export let INFO=`mi`;export let FULL_URL=`mu`;export let RES_404=`mnf`;export let JSON_HEADER=`mjh`;export let JSON_OPTION=`mjo`;export let HTML_HEADER=`mhh`;export let HTML_OPTION=`mho`;export let DECL_GLOBALS=`var ${JSON_HEADER}=['content-type','application/json'],${JSON_OPTION}={headers:${JSON_HEADER}},${HTML_HEADER}=['content-type','text/html'],${HTML_OPTION}={headers:${HTML_HEADER}},${RES_404}=new Response(null,{status:404});`;

package/generic/compiler.d.ts

@@ -0,0 +1,32 @@
+import { type LocalDependency } from "runtime-compiler";
+import { type Router } from "../compiler/router.ts";
+import { type registerRoute } from "../compiler/globals.ts";
+export type BuiltFn = () => (req: Request) => any;
+export declare const registerRouteCb: typeof registerRoute;
+/**
+* Build to a local dependency.
+* Use in `default` and `build` mode.
+*/
+export declare const buildToDependency: (router: Router) => LocalDependency<BuiltFn>;
+/**
+* Hydrate to a local dependency.
+* Use in `hydrate` mode.
+*/
+export declare const hydrateToDependency: (router: Router) => void;
+/**
+* Build the router into evaluatable string.
+* Use in `build` mode.
+*
+* @example
+* `(${buildToString(app)})(hydrate(app));`
+*/
+export declare const buildToString: (router: Router) => string;
+/**
+* Build the router to a lazy function.
+* Use in `default` mode.
+*/
+export declare const build: (router: Router) => BuiltFn;
+/**
+* Return the arguments needed in `hydrate` mode.
+*/
+export declare const hydrate: (router: Router) => any[];

package/generic/compiler.js

@@ -0,0 +1 @@
+import{createRouter,insertItem}from"@mapl/router/method";import compileMethodRouter from"@mapl/router/method/compiler";import{addExtraCode,evaluate,evaluateToString,hydrate as finishHydration,injectDependency}from"runtime-compiler";import{build as buildRouter,hydrate as hydrateRouter}from"../compiler/router.js";import{finalizeReturn}from"../compiler/state.js";import{setHandlerArgs,setRegisterRoute,setRouteParamMap}from"../compiler/globals.js";let methodRouter;export let registerRouteCb=(route,state,prefix,content)=>{insertItem(methodRouter,route[0],prefix+route[1],finalizeReturn(state,content))};let buildWrapper=router=>{setHandlerArgs(`(mr)`);methodRouter=createRouter();setRegisterRoute(registerRouteCb);let paramMap=[``,`q0,`];for(let i=1;i<=8;i++)paramMap.push(`${paramMap[i]}q${i},`);setRouteParamMap(paramMap);buildRouter(router,[false,false],``,``);return`()=>{var mjh=['content-type','application/json'],mjo={headers:mjh},mhh=['content-type','text/html'],mho={headers:mhh},mnf=new Response(null,{status:404});return(mr)=>{${compileMethodRouter(methodRouter,`mr.method`,`let mu=mr.url,s=mu.indexOf('/',10)+1,e=mu.indexOf('?',s),p=e===-1?mu.slice(s):mu.slice(s,e);`,1)}return mnf}}`};export let buildToDependency=router=>injectDependency(buildWrapper(router));export let hydrateToDependency=router=>{hydrateRouter(router,[false,false])};export let buildToString=router=>(addExtraCode(`return`+buildWrapper(router)),evaluateToString());export let build=router=>(addExtraCode(`return`+buildWrapper(router)),evaluate());export let hydrate=router=>(hydrateToDependency(router),finishHydration());

package/generic/handlers.d.ts

@@ -0,0 +1,23 @@
+import type { Context, MaybePromise } from "./types.ts";
+import type { RouteLayer } from "../compiler/router.ts";
+// Send text and streams
+type SendFn<Params extends any[]> = (...args: [...Params, c: Context]) => MaybePromise<BodyInit | null>;
+export declare const sendFn: RouteLayer<any[]>[0];
+/**
+* Send raw content
+*/
+export declare const raw: <Params extends any[]>(fn: SendFn<Params>) => RouteLayer<Params>;
+// Send JSON
+type SendJSONFn<Params extends any[]> = (...args: [...Params, c: Context]) => any;
+export declare const sendJSONFn: RouteLayer<any[]>[0];
+/**
+* Send JSON
+*/
+export declare const json: <Params extends any[]>(fn: SendJSONFn<Params>) => RouteLayer<Params>;
+// Send HTML
+export declare const sendHTMLFn: RouteLayer<any[]>[0];
+/**
+* Send HTML
+*/
+export declare const html: <Params extends any[]>(fn: SendFn<Params>) => RouteLayer<Params>;
+export {};

package/generic/handlers.js

@@ -0,0 +1 @@
+import{isHydrating}from"runtime-compiler/config";import{buildCall,hydrateCall}from"../compiler/call.js";let onlyHydrateCall=(data,state,paramCount)=>(hydrateCall(state,data[1],paramCount),``);export let sendFn=isHydrating?onlyHydrateCall:(data,state,paramCount,params)=>{let call=buildCall(state,data[1],paramCount,params);return state[1]?`return new Response(${call},mc)`:`return new Response(${call})`};export let raw=fn=>[sendFn,fn];export let sendJSONFn=isHydrating?onlyHydrateCall:(data,state,paramCount,params)=>{let call=buildCall(state,data[1],paramCount,params);return state[1]?`mh.push(mjh);return new Response(${call},mc)`:`return new Response(${call},mjo)`};export let json=fn=>[sendJSONFn,fn];export let sendHTMLFn=isHydrating?onlyHydrateCall:(data,state,paramCount,params)=>{let call=buildCall(state,data[1],paramCount,params);return state[1]?`mh.push(mhh);return new Response(${call},mc)`:`return new Response(${call},mho)`};export let html=fn=>[sendHTMLFn,fn];

package/generic/index.d.ts

@@ -0,0 +1,3 @@
+import type { LocalDependency } from "runtime-compiler";
+export declare const request: LocalDependency<Request>;
+export * as compiler from "./compiler.ts";

package/generic/index.js

@@ -0,0 +1 @@
+export let request=`mr`;export*as compiler from"./compiler.js";

package/generic/layers.d.ts

@@ -0,0 +1,6 @@
+import type { Layer } from "../compiler/router.ts";
+import type { Context } from "./types.ts";
+/**
+* Run a function on every request
+*/
+export declare const tap: <const Fn extends (c: Context) => any>(fn: Fn) => Layer<[Fn]>;

package/generic/layers.js

@@ -0,0 +1 @@
+import{isHydrating}from"runtime-compiler/config";import{buildCall,hydrateCall}from"../compiler/call.js";let buildTap=isHydrating?(data,state)=>(hydrateCall(state,data[1],0),``):(data,state)=>buildCall(state,data[1],0,``)+`;`;export let tap=fn=>[buildTap,fn];

package/generic/parsers.d.ts

@@ -0,0 +1,21 @@
+import { type InferErr, type InferResult, isErr } from "@safe-std/error";
+import { type LocalDependency } from "runtime-compiler";
+import type { Context } from "./types.ts";
+import { type Layer, type RouteLayer } from "../compiler/router.ts";
+interface ParseLayerFn {
+	<const T>(fn: (c: Context) => T, handleError: RouteLayer<[InferErr<Awaited<T>>]>): Layer<[LocalDependency<InferResult<Awaited<T>>>, typeof fn, typeof handleError]>;
+	<const T>(fn: (c: Context) => T): Layer<[LocalDependency<Awaited<T>>, typeof fn]>;
+}
+/**
+* Check whether value is an error
+*/
+export declare const IS_ERR: LocalDependency<typeof isErr>;
+/**
+* Parse and assign the value to a local variable on every request
+*/
+export declare const init: ParseLayerFn;
+/**
+* Get the parsed result of a parser
+*/
+export declare const result: <T extends LocalDependency<any>>(parser: Layer<[T, ...any[]]>) => T;
+export {};

package/generic/parsers.js

@@ -0,0 +1 @@
+import{isErr}from"@safe-std/error";import{injectExternalDependency}from"runtime-compiler";import{isHydrating}from"runtime-compiler/config";import{evaluateRouteLayer}from"../compiler/router.js";import{buildCall,hydrateCall}from"../compiler/call.js";export let IS_ERR=injectExternalDependency(isErr);let buildParse=isHydrating?(data,state)=>(hydrateCall(state,data[2],0),data.length>3?evaluateRouteLayer(data[3],state,1,data[1]):``):(data,state)=>{let id=data[1];return`let ${id}=${buildCall(state,data[2],0,``)};`+(data.length>3?`if(${IS_ERR}(${id})){${evaluateRouteLayer(data[3],state,1,id+`,`)}}`:``)};let tmpId=0;export let init=(fn,handleError)=>handleError==null?[buildParse,`mt`+ tmpId++,fn]:[buildParse,`mt`+ tmpId++,fn,handleError];export let result=parser=>parser[1];

package/generic/route.d.ts

@@ -0,0 +1,11 @@
+import type { RegisterRouteFn, RegisterRouteWithMethodFn } from "../compiler/router.ts";
+export declare const get: RegisterRouteFn;
+export declare const post: RegisterRouteFn;
+export declare const put: RegisterRouteFn;
+export declare const del: RegisterRouteFn;
+export declare const patch: RegisterRouteFn;
+export declare const options: RegisterRouteFn;
+export declare const trace: RegisterRouteFn;
+export declare const query: RegisterRouteFn;
+export declare const any: RegisterRouteFn;
+export declare const def: RegisterRouteWithMethodFn;

package/generic/route.js

@@ -0,0 +1 @@
+let GET=[`GET`];export let get=(...args)=>GET.concat(args);let POST=[`POST`];export let post=(...args)=>POST.concat(args);let PUT=[`PUT`];export let put=(...args)=>PUT.concat(args);let DEL=[`DELETE`];export let del=(...args)=>DEL.concat(args);let PATCH=[`PATCH`];export let patch=(...args)=>PATCH.concat(args);let OPTIONS=[`OPTIONS`];export let options=(...args)=>OPTIONS.concat(args);let TRACE=[`TRACE`];export let trace=(...args)=>TRACE.concat(args);let QUERY=[`QUERY`];export let query=(...args)=>QUERY.concat(args);let ANY=[``];export let any=(...args)=>ANY.concat(args);export let def=(...args)=>args;

package/{core/context.d.ts → generic/types.d.ts}

@@ -1,6 +1,6 @@
 export type Header = [string, string] | readonly [string, string];
 export interface Context {
-	headers: Header[];
 	status: number;
-	statusText?: string;
+	headers: Header[];
 }
+export type MaybePromise<T> = T | Promise<T>;

package/index.d.ts

@@ -1,23 +1,7 @@
-import { type ChildRouters, type InferHandlers, type InferRouter } from "./core/index.js";
-import type { MiddlewareTypes } from "./core/middleware.js";
-/**
-* Generic context
-*/
-export interface GenericContext {
-	readonly req: Request;
-}
-/**
-* Generic router
-*/
-export declare const router: <
-	const T extends MiddlewareTypes<GenericContext, any, any>[],
-	const S extends ChildRouters<GenericContext> = {}
->(middlewares: T, handlers: InferHandlers<GenericContext, T>, children?: S) => InferRouter<GenericContext, T, S>;
-export * as layer from "./core/middleware.js";
-export * as handle from "./core/handler.js";
-export * as cors from "./utils/cors.js";
-export * as bearerAuth from "./utils/bearer-auth.js";
-export * as basicAuth from "./utils/basic-auth.js";
-export * as bodyLimit from "./utils/body-limit.js";
-export { default as redirect } from "./utils/redirect.js";
-export { default as staticHeaders } from "./utils/static-headers.js";
+import type { Router } from "./compiler/router.ts";
+export * as send from "./generic/handlers.ts";
+export * as route from "./generic/route.ts";
+export * as layer from "./generic/layers.ts";
+export * as parser from "./generic/parsers.ts";
+export { inject } from "runtime-compiler/call";
+export declare const router: (layers: Router[0], routes: Router[1], children?: Router[2]) => Router;

package/index.js

@@ -1 +1 @@
-import{routerImpl}from"./core/index.js";export let router=routerImpl;export*as layer from"./core/middleware.js";export*as handle from"./core/handler.js";export*as cors from"./utils/cors.js";export*as bearerAuth from"./utils/bearer-auth.js";export*as basicAuth from"./utils/basic-auth.js";export*as bodyLimit from"./utils/body-limit.js";export{default as redirect}from"./utils/redirect.js";export{default as staticHeaders}from"./utils/static-headers.js";
+export*as send from"./generic/handlers.js";export*as route from"./generic/route.js";export*as layer from"./generic/layers.js";export*as parser from"./generic/parsers.js";export{inject}from"runtime-compiler/call";export let router=(layers,routes,children)=>children==null?[layers,routes]:[layers,routes,children];

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "@mapl/web",
-"version": "0.4.1",
+"version": "0.5.0",
 "description": "A compiled web framework for all runtimes",
 "keywords": ["fast", "lightweight", "cross-runtime", "framework", "web", "backend"],
 "repository": {
@@ -12,32 +12,25 @@
 "main": "./index.js",
 "types": "./index.d.ts",
 "dependencies": {
-"@mapl/framework": "^0.6.3",
-"@mapl/router": "^0.6.4",
+"@biomejs/biome": "^2.3.2",
+"@mapl/router": "^0.7.7",
 "@safe-std/error": "^2.0.4",
-"runtime-compiler": "^1.2.7"
+"runtime-compiler": "^2.1.2"
 },
 "exports": {
-".": "./index.js",
 "./constants": "./constants.js",
-"./core/utils": "./core/utils.js",
-"./core/middleware": "./core/middleware.js",
-"./core/context": "./core/context.js",
-"./utils/cors": "./utils/cors.js",
-"./core/handler": "./core/handler.js",
-"./utils/redirect": "./utils/redirect.js",
-"./utils/body-limit": "./utils/body-limit.js",
-"./utils/bearer-auth": "./utils/bearer-auth.js",
-"./utils/static-headers": "./utils/static-headers.js",
-"./utils/basic-auth": "./utils/basic-auth.js",
-"./bun/compiler/router": "./bun/compiler/router.js",
-"./compiler/aot": "./compiler/aot.js",
-"./bun/compiler/aot": "./bun/compiler/aot.js",
-"./compiler/jit": "./compiler/jit.js",
+"./compiler/call": "./compiler/call.js",
+"./generic": "./generic/index.js",
+"./generic/compiler": "./generic/compiler.js",
+"./generic/handlers": "./generic/handlers.js",
+"./generic/route": "./generic/route.js",
+"./generic/parsers": "./generic/parsers.js",
+"./generic/layers": "./generic/layers.js",
+"./compiler/router": "./compiler/router.js",
+"./compiler/globals": "./compiler/globals.js",
 "./bun": "./bun/index.js",
-"./bun/compiler/jit": "./bun/compiler/jit.js",
-"./build/rolldown": "./build/rolldown.js",
-"./core": "./core/index.js",
-"./build/utils": "./build/utils.js"
+"./compiler/state": "./compiler/state.js",
+".": "./index.js",
+"./generic/types": "./generic/types.js"
 }
 }

package/build/rolldown.d.ts

@@ -1,36 +0,0 @@
-import { type BuildOptions, type OutputOptions, type RolldownWatcher, type RolldownPluginOption } from "rolldown";
-export interface MaplBuildOptions extends Omit<BuildOptions, "input" | "output"> {
-	output?: Omit<OutputOptions, "file" | "dir">;
-}
-export interface MaplOptions {
-	/**
-	* App entry point
-	*/
-	main: string;
-	/**
-	* Output directory
-	*/
-	outputDir: string;
-	/**
-	* Build options
-	*/
-	build?: MaplBuildOptions;
-	/**
-	* Whether to emit asynchronous output
-	*/
-	asynchronous?: boolean;
-	/**
-	* Compiler module to use
-	*/
-	target?: "bun";
-	/**
-	* Hydrate specific options
-	*/
-	hydrate?: MaplBuildOptions;
-}
-// Plugins to manipulate imports
-export declare const hydrateImportsPlugin: RolldownPluginOption;
-export declare const SERVER_ENTRY = "index.js";
-export declare const hydrate: (options: MaplOptions) => Promise<void>;
-export declare const onceBundled: (watcher: RolldownWatcher) => Promise<void>;
-export declare const dev: (options: MaplOptions) => RolldownWatcher | void;

package/build/rolldown.js

@@ -1,15 +0,0 @@
-import{mkdirSync,writeFileSync}from"node:fs";import{build,watch}from"rolldown";import{evaluateToString}from"runtime-compiler/jit";import{resolve}from"node:path";import{EXTERNALS}from"./utils.js";export let hydrateImportsPlugin={name:`mapl-web-hydrate-config-replacer`,resolveId(source){return this.resolve(source===`runtime-compiler/config`?`runtime-compiler/hydrate-config`:source)}};export let SERVER_ENTRY=`index.js`;let mkdirSafe=dir=>{try{mkdirSync(dir,{recursive:true})}catch{}};let getTargetCompilerMod=targetOption=>targetOption==null?`@mapl/web/compiler/`:`@mapl/web/`+targetOption+`/compiler/`;export let hydrate=async options=>{let buildOptions=options.build;let hydrateOptions=options.hydrate;let asyncOption=options.asynchronous;let inputFile=resolve(options.main);let compilerPrefix=getTargetCompilerMod(options.target);let tmpFile;if(buildOptions==null){tmpFile=inputFile;mkdirSafe(options.outputDir)}else{tmpFile=resolve(options.outputDir,`tmp.js`);let outputOptions=buildOptions?.output;let currentExternals=buildOptions?.external;await build({...buildOptions,input:inputFile,output:{...outputOptions,file:tmpFile},external:currentExternals==null?EXTERNALS:typeof currentExternals===`function`?(id,...args)=>EXTERNALS.includes(id)||currentExternals(id,...args):EXTERNALS.concat(currentExternals)})}let appMod=await import(tmpFile);let{compileToExportedDependency}=await import(compilerPrefix+`jit`);let HANDLER=compileToExportedDependency(appMod.default);let outputFile=resolve(options.outputDir,SERVER_ENTRY);writeFileSync(outputFile,`
-      import app from ${JSON.stringify(tmpFile)};
-      import hydrateRouter from '${compilerPrefix}aot';
-      hydrateRouter(app);
-
-      import { hydrate } from 'runtime-compiler/hydrate';
-      import { getDependency } from 'runtime-compiler';
-
-      ${asyncOption?`await(async`:`(`}${evaluateToString()})(...hydrate());
-      export default getDependency(${HANDLER});
-    `);let currentPlugins=hydrateOptions?.plugins;await build({...hydrateOptions,input:outputFile,output:{...hydrateOptions?.output,file:outputFile},plugins:!currentPlugins?hydrateImportsPlugin:Array.isArray(currentPlugins)?[hydrateImportsPlugin].concat(currentPlugins):[hydrateImportsPlugin,currentPlugins]})};let jitContent=(inputFile,options)=>{let asyncOption=options.asynchronous===true;return`
-    import app from ${JSON.stringify(inputFile)};
-    import { ${asyncOption?`compileToHandler`:`compileToHandlerSync`} } from '${getTargetCompilerMod(options.target)}jit';
-    export default ${asyncOption?`await compileToHandler`:`compileToHandlerSync`}(app);
-  `};export let onceBundled=watcher=>new Promise((res,rej)=>watcher.on(`event`,function f(e){if(e.code===`ERROR`)rej(e.error);else if(e.code===`BUNDLE_END`)res();watcher.off(`event`,f)}));export let dev=options=>{let outputFile=resolve(options.outputDir,SERVER_ENTRY);mkdirSafe(options.outputDir);let content=jitContent(resolve(options.main),options);if(options.build!=null){let buildOptions=options.build;let outputOptions=buildOptions?.output;let tmpFile=resolve(options.outputDir,`tmp.js`);mkdirSafe(options.outputDir);writeFileSync(tmpFile,content);return watch({...buildOptions,input:tmpFile,output:{...outputOptions,file:outputFile}})}writeFileSync(outputFile,content)};

package/build/utils.d.ts

@@ -1,2 +0,0 @@
-// Packages that can be affected by compiling app first
-export declare const EXTERNALS: string[];

package/build/utils.js

@@ -1 +0,0 @@
-export let EXTERNALS=[`runtime-compiler`,`runtime-compiler/config`,`@mapl/framework`,`@mapl/web`];

package/bun/compiler/aot.d.ts

@@ -1,2 +0,0 @@
-import aot from "../../compiler/aot.js";
-export default aot;

package/bun/compiler/aot.js

@@ -1 +0,0 @@
-import aot from"../../compiler/aot.js";export default aot;

package/bun/compiler/jit.d.ts

@@ -1,8 +0,0 @@
-import type { RouterTag } from "../../core/index.js";
-import { type CompiledDependency } from "runtime-compiler";
-import type { BunContext } from "../index.js";
-import type { Serve } from "bun";
-export declare const compileToString: (router: RouterTag<BunContext>) => string;
-export declare const compileToExportedDependency: (router: RouterTag<BunContext>) => CompiledDependency<Serve.Routes<any, any>>;
-export declare const compileToHandler: (router: RouterTag<BunContext>) => Promise<Serve.Routes<any, any>>;
-export declare const compileToHandlerSync: (router: RouterTag<BunContext>) => Serve.Routes<any, any>;

package/bun/compiler/jit.js

@@ -1 +0,0 @@
-import{compileGroup,contextInit,setContextInit,hooks,getParamArgs}from"@mapl/framework";import{countParams}from"@mapl/router/path";import{AsyncFunction,exportDependency,getDependency,injectDependency,injectExternalDependency}from"runtime-compiler";import{evaluate,evaluateSync}from"runtime-compiler/jit";import{compileErrorHandler,compileReturn,RES400}from"../../compiler/jit.js";import{insertRoute,resetRouter,routerToString}from"./router.js";let compileToState=router=>{resetRouter();hooks.compileHandler=(handler,prevContent,path,scope)=>{let fn=handler[2];let paramCount=countParams(handler[1]);let call=injectExternalDependency(fn)+`(`+getParamArgs(paramCount);if(fn.length>paramCount){call+=`c`;if(!scope[1]){insertRoute(handler[0],path,prevContent+contextInit+compileReturn(handler[3],fn instanceof AsyncFunction,scope[0],true,call+`)`)+(scope[0]?`})()`:``));return}}insertRoute(handler[0],path,prevContent+compileReturn(handler[3],fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)+(scope[0]?`})()`:``))};hooks.compileErrorHandler=compileErrorHandler;setContextInit(`let h=[],c={status:200,req:r,headers:h,server:s};`);compileGroup(router,[false,false,,`return `+RES400(),false],``,``)};export let compileToString=router=>{compileToState(router);return routerToString()};export let compileToExportedDependency=router=>exportDependency(injectDependency(compileToString(router)));export let compileToHandler=async router=>{let id=compileToExportedDependency(router);await evaluate();return getDependency(id)};export let compileToHandlerSync=router=>{let id=compileToExportedDependency(router);evaluateSync();return getDependency(id)};

package/bun/compiler/router.d.ts

@@ -1,3 +0,0 @@
-export declare const resetRouter: () => void;
-export declare const insertRoute: (method: string, path: string, content: string) => void;
-export declare const routerToString: () => string;

package/bun/compiler/router.js

@@ -1 +0,0 @@
-import{injectDependency}from"runtime-compiler";import{RES404}from"../../compiler/jit.js";let ROUTES;export let resetRouter=()=>{ROUTES={}};export let insertRoute=(method,path,content)=>{let isWildcard=path.endsWith(`**`);let i=0;let bunPattern=isWildcard?path.slice(-2).replace(/\*/g,()=>`:q`+ i++)+`*`:path.replace(/\*/g,()=>`:q`+ i++);let str=`(r,s)=>{`;if(i>0){str+=`let {q0`;for(let j=1,l=i-(isWildcard?1:0);j<l;j++)str+=`q,`+j;str+=`}=r.params`+(isWildcard?`,q`+i+`=r.params["*"];`:`;`)}(ROUTES[bunPattern]??={})[method]=str+content+`}`;if(method!==``&&method!==`GET`&&method!==`HEAD`&&method!==`OPTIONS`&&method!==`DELETE`&&method!==`PATCH`&&method!==`POST`&&method!==`PUT`)ROUTES[bunPattern][``]??=RES404();if(isWildcard)(ROUTES[bunPattern===`/*`?`/`:bunPattern.slice(0,-3)]??={})[method]??=RES404()};export let routerToString=()=>{let str=`{`;for(let pattern in ROUTES){str+=`"`+pattern+`":`;let methods=ROUTES[pattern];let allMethods=methods[``];if(allMethods==null){str+=`{`;for(let method in methods)str+=method+`:`+methods[method]+`,`;str+=`},`}else if(Object.keys(methods).length===1)str+=methods[``]+`,`;else{str+=`(r,s)=>`;for(let method in methods)if(method!==``){let fn=methods[method];str+=`r.method==="`+method+`"?`+(fn.startsWith(`(r,s)=>`)?injectDependency(fn)+`(r,s)`:fn)+`:`}str+=(allMethods.startsWith(`(r,s)=>`)?injectDependency(allMethods)+`(r,s)`:allMethods)+`,`}}return str+`}`};

package/compiler/aot.d.ts

@@ -1,6 +0,0 @@
-import type { RouterTag } from "../core/index.js";
-import "../core/context.js";
-import type { GenericContext } from "../index.js";
-export declare const hydrateRouter: (router: RouterTag<GenericContext>) => void;
-declare const _default: (router: RouterTag<GenericContext>) => void;
-export default _default;

package/compiler/aot.js

@@ -1 +0,0 @@
-import{hydrateDependency,hooks}from"@mapl/framework";import{countParams}from"@mapl/router/path";import{injectExternalDependency,markExported}from"runtime-compiler";import"../core/context.js";export let hydrateRouter=router=>{hooks.compileHandler=(handler,_,_1,scope)=>{let fn=handler[2];injectExternalDependency(fn);handler[3]?.handler?.(``,scope[1]||fn.length>countParams(handler[1]))};hooks.compileErrorHandler=(_,fn,dat,scope)=>{injectExternalDependency(fn);dat?.handler?.(``,scope[1]||fn.length>1);return``};hydrateDependency(router,[false,false,,``,false],``)};export default router=>{hydrateRouter(router);markExported()};

package/compiler/jit.d.ts

@@ -1,10 +0,0 @@
-import type { RouterTag } from "../core/index.js";
-import { type CompiledDependency } from "runtime-compiler";
-import type { FetchFn } from "../core/utils.js";
-import type { GenericContext } from "../index.js";
-export declare const RES404: () => string;
-export declare const RES400: () => string;
-export declare const compileToString: (router: RouterTag<GenericContext>) => string;
-export declare const compileToExportedDependency: (router: RouterTag<GenericContext>) => CompiledDependency<FetchFn>;
-export declare const compileToHandler: (router: RouterTag<GenericContext>) => Promise<FetchFn>;
-export declare const compileToHandlerSync: (router: RouterTag<GenericContext>) => FetchFn;

package/compiler/jit.js

@@ -1 +0,0 @@
-import{compileGroup,contextInit,setContextInit,hooks,getParamArgs}from"@mapl/framework";import compile from"@mapl/router/method/compiler";import{countParams}from"@mapl/router/path";import{insertItem}from"@mapl/router/method";import{AsyncFunction,exportDependency,getDependency,injectDependency,injectExternalDependency,lazyDependency,noOp}from"runtime-compiler";import{evaluate,evaluateSync}from"runtime-compiler/jit";import{isHydrating}from"runtime-compiler/config";let URL_ROUTER;export let RES404=isHydrating?noOp:lazyDependency(injectDependency,`new Response(null,{status:404})`);export let RES400=isHydrating?noOp:lazyDependency(injectDependency,`new Response(null,{status:400})`);export let compileReturn=(dat,fnAsync,scopeAsync,contextCreated,result)=>{let res=dat?.handler;if(res==null)return`return `+result;let str=res(fnAsync?`await `+result:result,contextCreated);return fnAsync&&!scopeAsync?`return (async()=>{`+str+`})()`:str};export let compileErrorHandler=(input,fn,dat,scope)=>{let call=injectExternalDependency(fn)+`(`+input;if(fn.length>1){call+=`,c`;if(!scope[1])return contextInit+compileReturn(dat,fn instanceof AsyncFunction,scope[0],true,call+`)`)}return compileReturn(dat,fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)};let compileToState=router=>{URL_ROUTER={};hooks.compileHandler=(handler,prevContent,path,scope)=>{let fn=handler[2];let paramCount=countParams(handler[1]);let call=injectExternalDependency(fn)+`(`+getParamArgs(paramCount);if(fn.length>paramCount){call+=`c`;if(!scope[1]){insertItem(URL_ROUTER,handler[0],path,prevContent+contextInit+compileReturn(handler[3],fn instanceof AsyncFunction,scope[0],true,call+`)`)+(scope[0]?`})()`:``));return}}insertItem(URL_ROUTER,handler[0],path,prevContent+compileReturn(handler[3],fn instanceof AsyncFunction,scope[0],scope[1],call+`)`)+(scope[0]?`})()`:``))};hooks.compileErrorHandler=compileErrorHandler;setContextInit(`let h=[],c={status:200,req:r,headers:h};`);compileGroup(router,[false,false,,`return `+RES400(),false],``,``)};export let compileToString=router=>{compileToState(router);return`(r)=>{`+compile(URL_ROUTER,`r.method`,`let u=r.url,s=u.indexOf("/",12)+1,e=u.indexOf("?",s),p=e===-1?u.slice(s):u.slice(s,e);`,1)+`return `+RES404()+`}`};export let compileToExportedDependency=router=>exportDependency(injectDependency(compileToString(router)));export let compileToHandler=async router=>{let id=compileToExportedDependency(router);await evaluate();return getDependency(id)};export let compileToHandlerSync=router=>{let id=compileToExportedDependency(router);evaluateSync();return getDependency(id)};

package/core/handler.d.ts

@@ -1,94 +0,0 @@
-import type { AnyErr } from "@safe-std/error";
-import type { Context } from "./context.js";
-import type { RouterTag } from "./index.js";
-import type { MaybePromise, RequestMethod } from "./utils.js";
-export interface HandlerResponse<I = any> {
-	(response: string, hasContext: boolean): string;
-	(response: string, hasContext: boolean, _: I): string;
-}
-export interface HandlerData extends Record<symbol, any> {
-	handler?: HandlerResponse;
-}
-export type Handler<
-	Params extends string[] = string[],
-	T extends {} = Record<string, any>,
-	R = any
-> = (...args: [...params: Params, c: Context & T]) => R;
-export type InferPath<T extends string> = T extends `${string}*${infer Next}` ? Next extends "*" ? [string] : [string, ...InferPath<Next>] : [];
-// toResponse macro
-export type InferReturn<D extends HandlerData | undefined> = MaybePromise<D extends HandlerData ? D["handler"] extends HandlerResponse<infer I> ? I : Response : Response>;
-export type InferHandler<
-	P extends string,
-	D extends HandlerData | undefined,
-	C
-> = Handler<InferPath<P>, Required<C>, InferReturn<D>>;
-export interface DefineHandler {
-	<
-		P extends string,
-		const D extends HandlerData,
-		C
-	>(path: P, handler: NoInfer<InferHandler<P, D, C>>, dat: D): HandlerTag<C>;
-	<
-		P extends string,
-		C
-	>(path: P, handler: NoInfer<InferHandler<P, undefined, C>>): HandlerTag<C>;
-}
-// Unique tags
-declare const handlerTag: unique symbol;
-export interface HandlerTag<out T> {
-	[handlerTag]: T;
-}
-export declare const JSON_HEADER: () => string;
-export declare const JSON_OPTIONS: () => string;
-/**
-* Return JSON
-*/
-export declare const json: HandlerResponse;
-export declare const HTML_HEADER: () => string;
-export declare const HTML_OPTIONS: () => string;
-/**
-* Return HTML
-*/
-export declare const html: HandlerResponse<BodyInit>;
-/**
-* Return a body init
-*/
-export declare const text: HandlerResponse<BodyInit>;
-/**
-* Handle errors of a router
-* @param f
-*/
-export declare const error: <
-	C,
-	const E extends AnyErr,
-	const D extends HandlerData | undefined = undefined
->(r: RouterTag<C, E>, f: NoInfer<(err: E, c: Context & C) => InferReturn<D>>, dat?: D) => RouterTag<C, never>;
-/**
-* Handle requests to a path with a specific method
-* @param method
-* @param path
-* @param handler
-* @param dat
-*/
-export declare const route: <
-	P extends string,
-	const D extends HandlerData | undefined = undefined,
-	C = {}
->(method: RequestMethod, path: P, handler: NoInfer<InferHandler<P, D, C>>, dat?: D) => HandlerTag<C>;
-// @ts-ignore
-export declare const any: DefineHandler;
-// @ts-ignore
-export declare const get: DefineHandler;
-// @ts-ignore
-export declare const post: DefineHandler;
-// @ts-ignore
-export declare const put: DefineHandler;
-// @ts-ignore
-export declare const del: DefineHandler;
-// @ts-ignore
-export declare const patch: DefineHandler;
-// @ts-ignore
-export declare const options: DefineHandler;
-// @ts-ignore
-export declare const trace: DefineHandler;
-export {};

package/core/handler.js

@@ -1 +0,0 @@
-import{isHydrating}from"runtime-compiler/config";import{injectDependency,lazyDependency,noOp}from"runtime-compiler";export let JSON_HEADER=isHydrating?noOp:lazyDependency(injectDependency,`["content-type","application/json"]`);export let JSON_OPTIONS=isHydrating?noOp:lazyDependency(injectDependency,`{headers:[`+JSON_HEADER()+`]}`);export let json=isHydrating?noOp:(res,hasContext)=>hasContext?`h.push(`+JSON_HEADER()+`);return new Response(JSON.stringify(`+res+`),c)`:`return new Response(JSON.stringify(`+res+`),`+JSON_OPTIONS()+`)`;export let HTML_HEADER=isHydrating?noOp:lazyDependency(injectDependency,`["content-type","application/json"]`);export let HTML_OPTIONS=isHydrating?noOp:lazyDependency(injectDependency,`{headers:[`+JSON_HEADER()+`]}`);export let html=isHydrating?noOp:(res,hasContext)=>hasContext?`h.push(`+HTML_HEADER()+`);return new Response(`+res+`,c)`:`return new Response(`+res+`,`+HTML_OPTIONS()+`)`;export let text=isHydrating?noOp:(res,hasContext)=>`return new Response(`+res+(hasContext?`,c)`:`)`);export let error=(r,f,dat)=>{r[2]=[f,dat];return r};export let route=(method,path,handler,dat)=>[method,path,handler,dat];export let any=(path,handler,dat)=>[``,path,handler,dat];export let get=(path,handler,dat)=>[`GET`,path,handler,dat];export let post=(path,handler,dat)=>[`POST`,path,handler,dat];export let put=(path,handler,dat)=>[`PUT`,path,handler,dat];export let del=(path,handler,dat)=>[`DELETE`,path,handler,dat];export let patch=(path,handler,dat)=>[`PATCH`,path,handler,dat];export let options=(path,handler,dat)=>[`OPTIONS`,path,handler,dat];export let trace=(path,handler,dat)=>[`TRACE`,path,handler,dat];

package/core/index.d.ts

@@ -1,22 +0,0 @@
-import type { HandlerTag } from "./handler.js";
-import type { AnyMiddlewareTypes, InferMiddlewareState, InferMiddlewareErr } from "./middleware.js";
-import type { UnionToIntersection } from "./utils.js";
-declare const _: unique symbol;
-export interface RouterTag<
-	out C,
-	out E = any
-> {
-	[_]: [E, C];
-}
-export type ChildRouters<C> = Record<string, RouterTag<C, any>>;
-export type InferHandlers<
-	C,
-	T extends AnyMiddlewareTypes[]
-> = HandlerTag<T extends [] ? C : C & UnionToIntersection<InferMiddlewareState<T[number]>>>[];
-export type InferRouterErr<T extends RouterTag<any>> = T[typeof _][0];
-export type InferRouter<
-	C,
-	T extends AnyMiddlewareTypes[],
-	S extends ChildRouters<C>
-> = RouterTag<C, InferRouterErr<S[keyof S]> | InferMiddlewareErr<T[number]>>;
-export {};

package/core/index.js

@@ -1 +0,0 @@
-export let routerImpl=(middlewares,handlers,children)=>[middlewares,handlers,,children];

package/core/middleware.d.ts

@@ -1,38 +0,0 @@
-import type { ScopeState } from "@mapl/framework";
-import type { AwaitedReturn } from "./utils.js";
-import type { Context } from "./context.js";
-import type { InferErr, InferResult } from "@safe-std/error";
-declare const _: unique symbol;
-export interface MiddlewareTypes<
-	out Context,
-	out Err,
-	in out State
-> {
-	[_]: [Context, Err, State];
-}
-export type AnyMiddlewareTypes = MiddlewareTypes<any, any, any>;
-export type InferMiddlewareState<T extends AnyMiddlewareTypes> = T[typeof _][2];
-export type InferMiddlewareErr<T extends AnyMiddlewareTypes> = T[typeof _][1];
-export type MiddlewareHandler<C> = (c: Context & C) => any;
-export declare const macro: <
-	C,
-	E = never,
-	S = {}
->(f: (scope: ScopeState) => string) => MiddlewareTypes<C, E, S>;
-export declare const noOpMacro: MiddlewareTypes<any, never, {}>;
-export declare const tap: <C>(f: MiddlewareHandler<C>) => MiddlewareTypes<C, never, {}>;
-export declare const attach: <
-	C,
-	Prop extends string,
-	const T extends MiddlewareHandler<C>
->(prop: Prop, f: T) => MiddlewareTypes<C, never, Record<Prop, AwaitedReturn<T>>>;
-export declare const validate: <
-	C,
-	const T extends MiddlewareHandler<C>
->(f: T) => MiddlewareTypes<C, InferErr<AwaitedReturn<T>>, {}>;
-export declare const parse: <
-	C,
-	Prop extends string,
-	const T extends MiddlewareHandler<C>
->(prop: Prop, f: T) => MiddlewareTypes<C, InferErr<AwaitedReturn<T>>, Record<Prop, InferResult<AwaitedReturn<T>>>>;
-export {};

package/core/middleware.js

@@ -1 +0,0 @@
-import{noOp}from"runtime-compiler";export let macro=f=>[-1,f];export let noOpMacro=macro(noOp);export let tap=f=>[0,f];export let attach=(prop,f)=>[1,f,prop];export let validate=f=>[2,f];export let parse=(prop,f)=>[3,f,prop];

package/core/utils.d.ts

@@ -1,5 +0,0 @@
-export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export type AwaitedReturn<U extends (...a: any[]) => any> = Awaited<ReturnType<U>>;
-export type MaybePromise<T> = Promise<T> | T;
-export type RequestMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "TRACE" | (string & {});
-export type FetchFn = (req: Request) => any;

package/core/utils.js

@@ -1 +0,0 @@
-export{};

package/utils/basic-auth.d.ts

@@ -1,7 +0,0 @@
-import type { Header } from "../core/context.js";
-export declare const extract: (req: Request) => {
-	name: string;
-	pwd: string;
-} | undefined;
-export declare const realm: (val: string) => Header;
-export declare const error: (val: string) => Header;

package/utils/basic-auth.js

@@ -1 +0,0 @@
-export let extract=req=>{let header=req.headers.get(`authorization`);if(header?.startsWith(`Basic `))try{let sliced=atob(header.slice(6));let sep=sliced.indexOf(`:`);if(sep>-1)return{name:sliced.slice(0,sep),pwd:sliced.slice(sep+1)}}catch{}};export let realm=val=>[`www-authenticate`,`Basic realm=`+JSON.stringify(val)];export let error=val=>[`www-authenticate`,`Basic error=`+JSON.stringify(val)];

package/utils/bearer-auth.d.ts

@@ -1,4 +0,0 @@
-import type { Header } from "../core/context.js";
-export declare const extract: (req: Request) => string | undefined;
-export declare const realm: (val: string) => Header;
-export declare const error: (val: string) => Header;

package/utils/bearer-auth.js

@@ -1 +0,0 @@
-export let extract=req=>{let header=req.headers.get(`authorization`);if(header?.startsWith(`Bearer `))return header.slice(7)};export let realm=val=>[`www-authenticate`,`Basic realm=`+JSON.stringify(val)];export let error=val=>[`www-authenticate`,`Basic error=`+JSON.stringify(val)];

package/utils/body-limit.d.ts

@@ -1,7 +0,0 @@
-import { type MiddlewareTypes } from "../core/middleware.js";
-export declare const RES413: () => string;
-/**
-* Set size limit for body.
-* If you use Bun, use their `maxRequestBodySize` option instead.
-*/
-export declare const size: (bytes: number) => MiddlewareTypes<any, never, {}>;

package/utils/body-limit.js

@@ -1 +0,0 @@
-import{macro}from"../core/middleware.js";import{injectDependency,lazyDependency,noOp}from"runtime-compiler";import{isHydrating}from"runtime-compiler/config";import{createAsyncScope}from"@mapl/framework";export let RES413=isHydrating?noOp:lazyDependency(injectDependency,`new Response(null,{status:413})`);export let size=isHydrating?()=>macro(createAsyncScope):bytes=>macro(scope=>createAsyncScope(scope)+`if(await `+injectDependency(`async(r)=>{if(r.body!==null){let l=r.headers.get("content-length");if(l===null||r.headers.has("transfer-encoding")){let g=r.clone().body.getReader(),i=await g.read(),s=0;while(!i.done){s+=i.value.byteLength;if(s>`+bytes+`)return true;i=await g.read()}}else if(+l>`+bytes+`)return true}return false}`)+`(r))return `+RES413()+`;`);

package/utils/cors.d.ts

@@ -1,18 +0,0 @@
-import { type MiddlewareTypes } from "../core/middleware.js";
-import type { RequestMethod } from "../core/utils.js";
-import type { Header } from "../core/context.js";
-// Ensure people don't make mistake categorizing headers
-declare const _: unique symbol;
-export type CORSHeader = Header & {
-	[_]: 0;
-};
-export type CORSPreflightHeader = Header & {
-	[_]: 1;
-};
-export declare const allowMethods: (v: [RequestMethod, RequestMethod, ...RequestMethod[]] | RequestMethod | "*") => CORSPreflightHeader;
-export declare const allowHeaders: (v: string[] | string) => CORSPreflightHeader;
-export declare const maxAge: (v: number) => CORSPreflightHeader;
-export declare const allowCredentials: CORSHeader;
-export declare const exposeHeaders: (v: "*" | (string & {}) | [string, string, ...string[]]) => CORSHeader;
-export declare const init: (origins: "*" | (string & {}) | [string, string, ...string[]], preflightHeaders?: CORSPreflightHeader[], headers?: Header[]) => MiddlewareTypes<any, never, {}>;
-export {};

package/utils/cors.js

@@ -1 +0,0 @@
-import{injectDependency}from"runtime-compiler";import{isHydrating}from"runtime-compiler/config";import{createContext}from"@mapl/framework";import{macro}from"../core/middleware.js";import{injectList}from"./static-headers.js";export let allowMethods=v=>[`access-control-allow-methods`,``+v];export let allowHeaders=v=>[`access-control-allow-headers`,``+v];export let maxAge=v=>[`access-control-max-age`,``+v];export let allowCredentials=[`access-control-allow-credentials`,`true`];export let exposeHeaders=v=>[`access-control-expose-headers`,``+v];let createContextMacro=macro(createContext);export let init=isHydrating?()=>createContextMacro:(origins,preflightHeaders=[],headers=[])=>{if(origins!==`*`){headers.push([`vary`,`origin`]);if(Array.isArray(origins))return macro(scope=>{let str=`(r,h)=>{let o=r.headers.get("origin");h.push(["access-control-allow-origin",typeof o==="string"&&o===`+JSON.stringify(origins[1]);for(let i=2;i<origins.length;i++)str+=`||o===`+JSON.stringify(origins[i]);return createContext(scope)+(injectDependency(str+`?o:`+JSON.stringify(origins[0])+`]);`+(headers.length>0?`h.push(`+injectList(headers)+`);`:``)+(preflightHeaders.length>0?`r.method==="OPTIONS"&&h.push(`+injectList(preflightHeaders)+`)}`:`}`))+`(r,h);`)})}headers.push([`access-control-allow-origin`,origins]);return macro(scope=>{let pushHeaders=headers.length>0?`h.push(`+injectList(headers)+`);`:``;return createContext(scope)+(preflightHeaders.length>0?injectDependency(`(r,h)=>{`+pushHeaders+`r.method==="OPTIONS"&&h.push(`+injectList(preflightHeaders)+`)}`)+`(r,h);`:pushHeaders)})};

package/utils/redirect.d.ts

@@ -1,3 +0,0 @@
-import type { Context } from "../core/context.js";
-declare const _default: (c: Context, location: string, status: 301 | 302 | 307 | 308) => void;
-export default _default;

package/utils/redirect.js

@@ -1 +0,0 @@
-export default (c,location,status)=>{c.status=status;c.headers.push([`location`,location])};

package/utils/static-headers.d.ts

@@ -1,5 +0,0 @@
-import type { Header } from "../core/context.js";
-import { type MiddlewareTypes } from "../core/middleware.js";
-export declare const injectList: (list: any[]) => string;
-declare const _default: (headers: Headers | Header[] | Record<string, any>) => MiddlewareTypes<any, never, {}>;
-export default _default;

package/utils/static-headers.js

@@ -1 +0,0 @@
-import{isHydrating}from"runtime-compiler/config";import{injectDependency}from"runtime-compiler";import{macro,noOpMacro}from"../core/middleware.js";export let injectList=list=>list.length!==1?`...`+injectDependency(JSON.stringify(list)):injectDependency(JSON.stringify(list[0]));export default isHydrating?()=>noOpMacro:headers=>macro(()=>`h.push(`+injectList(Array.isArray(headers)?headers:headers instanceof Headers?headers.entries().toArray():Object.entries(headers))+`);`);