@mapl/web 0.5.3 → 0.6.0

package/README.md

@@ -1,31 +1,4 @@
 # `@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)(),
-};
-
-```
+See example usage in [./examples](./examples);

package/bun/index.d.ts

@@ -1,4 +1,4 @@
 import type { BunRequest, Server } from "bun";
-import type { LocalDependency } from "runtime-compiler";
-export declare const request: LocalDependency<BunRequest>;
-export declare const server: LocalDependency<Server<any>>;
+import type { Identifier } from "runtime-compiler";
+export declare const request: Identifier<BunRequest>;
+export declare const server: Identifier<Server<any>>;

package/cloudflare/compiler.d.ts

@@ -0,0 +1,20 @@
+import { type ExportedDependency, type Value } from "runtime-compiler";
+import type { Router } from "../router.ts";
+/**
+* Describe compiler compiled result
+*/
+export type CompiledResult = () => ExportedHandlerFetchHandler<Cloudflare.Env, unknown>;
+export declare const loadToString: () => Value<CompiledResult>;
+/**
+* @example
+* const createFetch = getDependency(build(app));
+*
+* export default {
+*   // Must be set as 'fetch' property of an object
+*   fetch(...args) {
+*     // Set up stuff...
+*     return (this.fetch = createFetch())(...args);
+*   }
+* } satisfies ExportedHandler<Env>;
+*/
+export declare const build: (router: Router) => ExportedDependency<CompiledResult>;

package/cloudflare/compiler.js

@@ -0,0 +1 @@
+import{evaluate,exportExpr,markExported}from"runtime-compiler";import{isHydrating,onlyBuild}from"runtime-compiler/config";import{_hydrate,_load,loadToString as genericLoadToString}from"../generic/compiler.js";import{SCOPE,setHandlerArgs}from"../compilers/globals.js";export let loadToString=()=>`()=>{`+SCOPE[0]+`return `+genericLoadToString()+`}`;export let build=isHydrating?router=>(_hydrate(router,[0]),markExported()):onlyBuild?router=>(setHandlerArgs(`(mr,mi,mec)`),_load(router),exportExpr(loadToString())):router=>{setHandlerArgs(`(mr,mi,mec)`);_load(router);let id=exportExpr(loadToString());evaluate();return id};

package/cloudflare/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="@cloudflare/workers-types" />
+import type { Request as WorkerRequest, ExecutionContext } from "@cloudflare/workers-types";
+import type { Identifier } from "runtime-compiler";
+export declare const request: Identifier<WorkerRequest>;
+export declare const env: Identifier<Cloudflare.Env>;
+export declare const ctx: Identifier<ExecutionContext>;
+export { build } from "./compiler.ts";

package/cloudflare/index.js

@@ -0,0 +1 @@
+export let request=`mr`;export let env=`mi`;export let ctx=`mec`;export{build}from"./compiler.js";

package/compilers/call.d.ts

@@ -0,0 +1,9 @@
+import { type Identifier } from "runtime-compiler";
+import type { HandlerScope } from "./scope.ts";
+import type { SendLayer } from "../response.ts";
+export interface Call<T extends (...args: any[]) => any> {
+	0: T;
+	1: Identifier<any>[];
+}
+export declare const buildCall: (scope: HandlerScope, fn: (...args: any[]) => any, args: string, argsCount: number) => string;
+export declare const buildRouteCall: SendLayer<any>[0];

package/compilers/call.js

@@ -0,0 +1 @@
+import{declareLocal,injectExternal}from"runtime-compiler";import{isHydrating}from"runtime-compiler/config";import{AsyncFunction}from"runtime-compiler/utils";import{SCOPE}from"./globals.js";export let buildCall=isHydrating?(scope,fn,_,argsCount)=>{fn instanceof AsyncFunction&&(scope[0]|=1);fn.length>argsCount&&(scope[0]|=2);return injectExternal(fn)}:(scope,fn,args,argsCount)=>{let str=declareLocal(SCOPE,injectExternal(fn))+`(`+args;if(fn instanceof AsyncFunction){scope[0]|=1;str=`await `+str}if(fn.length>argsCount){scope[0]|=2;str+=`,mc`}return str+`)`};export let buildRouteCall=isHydrating?(self,scope,_,paramsCount)=>{let args=self[2];return args.length>0?paramsCount>0?buildCall(scope,self[1],``,args.length+paramsCount):buildCall(scope,self[1],``,args.length):paramsCount>0?buildCall(scope,self[1],``,paramsCount):buildCall(scope,self[1],``,0)}:(self,scope,params,paramsCount)=>{let args=self[2];return args.length>0?paramsCount>0?buildCall(scope,self[1],args.join()+`,`+params,args.length+paramsCount):buildCall(scope,self[1],args.join(),args.length):paramsCount>0?buildCall(scope,self[1],params,paramsCount):buildCall(scope,self[1],``,0)};

package/compilers/globals.d.ts

@@ -0,0 +1,21 @@
+import { type Identifier, type Scope } from "runtime-compiler";
+import { isErr } from "@safe-std/error";
+/**
+* @example
+* '(req,env,ctx)'
+*/
+export declare let HANDLER_ARGS: string;
+/**
+* @example
+* setHandlerArgs('(req,env,ctx)');
+*/
+export declare const setHandlerArgs: (str: string) => void;
+/**
+* Store local variables
+*/
+export declare let SCOPE: Scope;
+/**
+* Check whether value is an error
+*/
+export declare let IS_ERR: Identifier<typeof isErr>;
+export declare const clearScope: () => void;

package/compilers/globals.js

@@ -0,0 +1 @@
+import{declareLocal,injectExternal}from"runtime-compiler";import{isErr}from"@safe-std/error";export let HANDLER_ARGS;export let setHandlerArgs=str=>{HANDLER_ARGS=str};export let SCOPE;export let IS_ERR;export let clearScope=()=>{SCOPE=[`let mhh=['content-type','text/html'],mho={headers:mhh},mnf=new Response(null,{status:404});`,0];IS_ERR=declareLocal(SCOPE,injectExternal(isErr))};clearScope();

package/compilers/scope.d.ts

@@ -0,0 +1,14 @@
+/**
+* Handler scope state.
+*/
+export interface HandlerScope {
+	/**
+	* Scope flags.
+	*
+	* bit 0: scope requires async or not
+	* bit 1: scope requires context or not
+	*/
+	0: number;
+	slice: () => this;
+}
+export declare const wrapScope: (scope: HandlerScope, content: string) => string;

package/compilers/scope.js

@@ -0,0 +1 @@
+import{declareLocal}from"runtime-compiler";import{HANDLER_ARGS,SCOPE}from"./globals.js";export let wrapScope=(scope,content)=>{let flags=scope[0];(flags&2)===2&&(content=`let mh=[],mc={status:200,headers:mh};`+content);return(flags&1)===1?`return `+declareLocal(SCOPE,`async`+HANDLER_ARGS+`=>{`+content+`}`)+HANDLER_ARGS:content};

package/constants.d.ts

@@ -8,10 +8,12 @@ export declare const CREATE_CTX: string;
 // Mapl locals
 export declare const REQ = "mr";
 export declare const INFO = "mi";
+export declare const EXEC_CTX = "mec";
 export declare const FULL_URL = "mu";
+export declare const GENERIC_ARGS: string;
+export declare const BUN_DENO_ARGS: string;
+export declare const CLOUDFLARE_ARGS: string;
 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

package/constants.js

@@ -1 +1 @@
-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});`;
+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 EXEC_CTX=`mec`;export let FULL_URL=`mu`;export let GENERIC_ARGS=`(${REQ})`;export let BUN_DENO_ARGS=`(${REQ},${INFO})`;export let CLOUDFLARE_ARGS=`(${REQ},${INFO},${EXEC_CTX})`;export let RES_404=`mnf`;export let HTML_HEADER=`mhh`;export let HTML_OPTION=`mho`;export let DECL_GLOBALS=`let ${HTML_HEADER}=['content-type','text/html'],${HTML_OPTION}={headers:${HTML_HEADER}},${RES_404}=new Response(null,{status:404});`;

package/deno/compiler.d.ts

@@ -0,0 +1,11 @@
+import { type ExportedDependency } from "runtime-compiler";
+import type { Router } from "../router.ts";
+/**
+* Describe compiler compiled result
+*/
+export type CompiledResult = (req: Request) => Response | Promise<Response>;
+/**
+* @example
+* Deno.serve(getDependency(build(app)));
+*/
+export declare const build: (router: Router) => ExportedDependency<CompiledResult>;

package/deno/compiler.js

@@ -0,0 +1 @@
+import{evaluate,exportExpr,markExported}from"runtime-compiler";import{isHydrating,onlyBuild}from"runtime-compiler/config";import{_hydrate,_load,loadToString}from"../generic/compiler.js";import{setHandlerArgs}from"../compilers/globals.js";export let build=isHydrating?router=>(_hydrate(router,[0]),markExported()):onlyBuild?router=>(setHandlerArgs(`(mr,mi)`),_load(router),exportExpr(loadToString())):router=>{setHandlerArgs(`(mr,mi)`);_load(router);let id=exportExpr(loadToString());evaluate();return id};

package/deno/index.d.ts

@@ -0,0 +1,4 @@
+import type { Identifier } from "runtime-compiler";
+export { request } from "../generic/index.ts";
+export declare const info: Identifier<Deno.ServeHandlerInfo<Deno.Addr>>;
+export { build } from "./compiler.ts";

package/deno/index.js

@@ -0,0 +1 @@
+export{request}from"../generic/index.js";export let info=`mi`;export{build}from"./compiler.js";

package/generic/compiler.d.ts

@@ -1,32 +1,28 @@
-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;
+import { type ExportedDependency, type Value } from "runtime-compiler";
+import { type HandlerScope } from "../compilers/scope.ts";
+import type { Router } from "../router.ts";
 /**
-* Build to a local dependency.
-* Use in `default` and `build` mode.
+* Describe compiler compiled result
 */
-export declare const buildToDependency: (router: Router) => LocalDependency<BuiltFn>;
+export type CompiledResult = (req: Request) => Response | Promise<Response>;
 /**
-* 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.
+* Load all global state for a router
 *
 * @example
-* `(${buildToString(app)})(hydrate(app));`
+* setHandlerArgs(constants.GENERIC_ARGS);
+* _load(router);
 */
-export declare const buildToString: (router: Router) => string;
+export declare const _load: (router: Router) => void;
+export declare const loadToString: () => Value<CompiledResult>;
 /**
-* Build the router to a lazy function.
-* Use in `default` mode.
+* Hydrate router data
 */
-export declare const build: (router: Router) => BuiltFn;
+export declare const _hydrate: (router: Router, scope: HandlerScope) => void;
 /**
-* Return the arguments needed in `hydrate` mode.
+* @example
+* export default {
+*   // Must be set as a property of an object
+*   fetch: getDependency(build(app))
+* };
 */
-export declare const hydrate: (router: Router) => any[];
+export declare const build: (router: Router) => ExportedDependency<CompiledResult>;

package/generic/compiler.js

@@ -1 +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);`,0)}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());
+import{createRouter as createMethodRouter,insertItem as insertItemToMethodRouter}from"@mapl/router/method";import compileMethodRouter from"@mapl/router/method/compiler";import{countParams}from"@mapl/router/utils";import{evaluate,exportScope,markExported}from"runtime-compiler";import{isHydrating,onlyBuild}from"runtime-compiler/config";import{SCOPE,setHandlerArgs}from"../compilers/globals.js";import{wrapScope}from"../compilers/scope.js";let METHOD_ROUTER;let PARAM_MAP;let loadToMethodRouter=(router,scope,prefix,content)=>{for(let i=0,layers=router[0];i<layers.length;i++){let self=layers[i];content+=self[0](self,scope)}for(let i=0,routes=router[1];i<routes.length;i++){let route=routes[i];let routeScope=scope.slice();let routeContent=content;for(let j=2,paramCount=countParams(route[1]),params=PARAM_MAP[paramCount];j<route.length;j++){let self=route[j];routeContent+=self[0](self,routeScope,params,paramCount)}insertItemToMethodRouter(METHOD_ROUTER,route[0],prefix+route[1],wrapScope(routeScope,routeContent))}for(let i=2;i<router.length;i++){let childRouter=router[i];loadToMethodRouter(childRouter[1],scope.slice(),childRouter[0]===`/`?prefix:prefix+childRouter[0],content)}};export let _load=router=>{METHOD_ROUTER=createMethodRouter();PARAM_MAP=[``,`q0`];for(let i=1;i<=8;i++)PARAM_MAP.push(`${PARAM_MAP[i]},q${i}`);loadToMethodRouter(router,[0],``,``)};export let loadToString=()=>`(mr)=>{${compileMethodRouter(METHOD_ROUTER,`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);`,0)}return mnf}`;export let _hydrate=(router,scope)=>{for(let i=0,layers=router[0];i<layers.length;i++){let self=layers[i];self[0](self,scope)}for(let i=0,routes=router[1];i<routes.length;i++)for(let j=2,route=routes[i],routeScope=scope.slice(),paramCount=countParams(route[1]);j<route.length;j++){let self=route[j];self[0](self,routeScope,``,paramCount)}for(let i=2;i<router.length;i++)_hydrate(router[i][1],scope.slice())};export let build=isHydrating?router=>(_hydrate(router,[0]),markExported()):onlyBuild?router=>(setHandlerArgs(`(mr)`),_load(router),exportScope(SCOPE,loadToString())):router=>{setHandlerArgs(`(mr)`);_load(router);let id=exportScope(SCOPE,loadToString());evaluate();return id};

package/generic/index.d.ts

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

package/generic/index.js

@@ -1 +1 @@
-export let request=`mr`;export*as compiler from"./compiler.js";
+export let request=`mr`;export{build}from"./compiler.js";

package/index.d.ts

@@ -1,7 +1,3 @@
-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;
+export * as send from "./response.ts";
+export * as router from "./router.ts";
+export * as layer from "./layer.ts";

package/index.js

@@ -1 +1 @@
-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];
+export*as send from"./response.js";export*as router from"./router.js";export*as layer from"./layer.js";

package/layer.d.ts

@@ -0,0 +1,45 @@
+import type { Identifier } from "runtime-compiler";
+import type { ResponseState } from "./response.ts";
+import type { HandlerScope } from "./compilers/scope.ts";
+/**
+* @example
+* f[0](f, scope);
+*/
+export interface AnyLayer {
+	0: (self: any, scope: HandlerScope) => string;
+}
+/**
+* @example
+* f[0](f, scope);
+*/
+export interface Layer {
+	0: (self: this, scope: HandlerScope) => string;
+}
+/**
+* @example
+* f[0](f, scope, 'p0,p1,');
+*/
+export interface AnyRouteLayer<Params extends any[]> {
+	0: (self: any, scope: HandlerScope, params: string, paramsCount: number) => string;
+	"~"?: Params;
+}
+/**
+* @example
+* f[0](f, scope, 'p0,p1,');
+*/
+export interface RouteLayer<Params extends any[]> {
+	0: (self: this, scope: HandlerScope, params: string, paramsCount: number) => string;
+	"~"?: Params;
+}
+///
+/// Impls
+///
+interface TapLayer extends Layer {
+	1: (...args: any[]) => any;
+	2: Identifier<any>[];
+}
+/**
+* Tap a function to request lifecycle.
+*/
+export declare const tap: <Args extends Identifier<any>[]>(fn: (...args: [...{ [K in keyof Args] : Args[K]["~type"] }, res: ResponseState]) => void | Promise<void>, ...args: Args) => TapLayer;
+export {};

package/layer.js

@@ -0,0 +1 @@
+import{buildCall}from"./compilers/call.js";let loadTap=(self,scope)=>{let args=self[2];return buildCall(scope,self[1],args.join(),args.length)+`;`};export let tap=(fn,...args)=>[loadTap,fn,args];

package/package.json

@@ -1,35 +1 @@
-{
-"name": "@mapl/web",
-"version": "0.5.3",
-"description": "A compiled web framework for all runtimes",
-"keywords": ["fast", "lightweight", "cross-runtime", "framework", "web", "backend"],
-"repository": {
-"type": "git",
-"url": "git+https://github.com/mapljs/web.git"
-},
-"license": "MIT",
-"type": "module",
-"main": "./index.js",
-"types": "./index.d.ts",
-"dependencies": {
-"@mapl/router": "^0.8.1",
-"@safe-std/error": "^2.0.4",
-"runtime-compiler": "^2.1.2"
-},
-"exports": {
-"./constants": "./constants.js",
-"./generic": "./generic/index.js",
-".": "./index.js",
-"./generic/route": "./generic/route.js",
-"./generic/layers": "./generic/layers.js",
-"./generic/types": "./generic/types.js",
-"./bun": "./bun/index.js",
-"./generic/handlers": "./generic/handlers.js",
-"./compiler/call": "./compiler/call.js",
-"./compiler/state": "./compiler/state.js",
-"./compiler/globals": "./compiler/globals.js",
-"./compiler/router": "./compiler/router.js",
-"./generic/compiler": "./generic/compiler.js",
-"./generic/parsers": "./generic/parsers.js"
-}
-}
+{"name":"@mapl/web","version":"0.6.0","description":"A compiled web framework for all runtimes","keywords":["fast","lightweight","cross-runtime","framework","web","backend"],"repository":{"type":"git","url":"git+https://github.com/mapljs/web.git"},"license":"MIT","type":"module","main":"./index.js","types":"./index.d.ts","dependencies":{"@mapl/router":"^0.8.2","@safe-std/error":"^2.0.4","runtime-compiler":"^3.0.9"},"exports":{"./utils":"./utils.js","./layer":"./layer.js","./constants":"./constants.js","./cloudflare":"./cloudflare/index.js","./cloudflare/compiler":"./cloudflare/compiler.js","./deno":"./deno/index.js","./bun":"./bun/index.js","./response":"./response.js",".":"./index.js","./generic":"./generic/index.js","./compilers/call":"./compilers/call.js","./router":"./router.js","./generic/compiler":"./generic/compiler.js","./compilers/globals":"./compilers/globals.js","./deno/compiler":"./deno/compiler.js","./compilers/scope":"./compilers/scope.js"}}

package/response.d.ts

@@ -0,0 +1,41 @@
+import type { Identifier } from "runtime-compiler";
+import type { RouteLayer } from "./layer.ts";
+/**
+* Describe a header pair
+*/
+export type ResponseHeader = [string, string] | readonly [string, string];
+/**
+* Response state
+*/
+export interface ResponseState {
+	status: number;
+	headers: ResponseHeader[];
+}
+export interface SendLayer<Params extends any[]> extends RouteLayer<Params> {
+	1: (...args: any[]) => any;
+	2: Identifier<any>[];
+}
+/**
+* @example
+* router.get('/', send.raw(() => 'Hi'))
+*/
+export declare const raw: <
+	const Args extends Identifier<any>[],
+	Params extends any[] = []
+>(fn: (...args: [...{ [K in keyof Args] : Args[K]["~type"] }, ...Params, res: ResponseState]) => BodyInit | Promise<BodyInit>, ...args: Args) => SendLayer<Params>;
+/**
+* @example
+* router.post('/', send.json(() => ({ hello: 'world' })))
+*/
+export declare const json: <
+	const Args extends Identifier<any>[],
+	Params extends any[] = []
+>(fn: (...args: [...{ [K in keyof Args] : Args[K]["~type"] }, ...Params, res: ResponseState]) => any, ...args: Args) => SendLayer<Params>;
+/**
+* @example
+* router.get('/', send.html(() => '<p>Hi</p>'))
+*/
+export declare const html: <
+	const Args extends Identifier<any>[],
+	Params extends any[] = []
+>(fn: (...args: [...{ [K in keyof Args] : Args[K]["~type"] }, ...Params, res: ResponseState]) => BodyInit | Promise<BodyInit>, ...args: Args) => SendLayer<Params>;

package/response.js

@@ -0,0 +1 @@
+import{buildRouteCall}from"./compilers/call.js";let loadRaw=(self,scope,params,paramsCount)=>`return new Response(`+buildRouteCall(self,scope,params,paramsCount)+((scope[0]&2)===2?`,mc)`:`)`);export let raw=(fn,...args)=>[loadRaw,fn,args];let loadJSON=(self,scope,params,paramsCount)=>`return Response.json(`+buildRouteCall(self,scope,params,paramsCount)+((scope[0]&2)===2?`,mc)`:`)`);export let json=(fn,...args)=>[loadJSON,fn,args];let loadHTML=(self,scope,params,paramsCount)=>{let call=buildRouteCall(self,scope,params,paramsCount);return(scope[0]&2)===2?`mh.push(mhh);return new Response(`+call+`,mc)`:`return new Response(`+call+`,mho)`};export let html=(fn,...args)=>[loadHTML,fn,args];

package/router.d.ts

@@ -0,0 +1,33 @@
+import type { AnyLayer, AnyRouteLayer } from "./layer.ts";
+/**
+* @example
+* ['GET', '/', ...]
+*/
+export type Route = [method: string, path: string, ...layers: AnyRouteLayer<any>[]];
+/**
+* Child router data
+*/
+export type ChildRouter = [subpath: string, Router];
+/**
+* Router data
+*/
+export type Router = [layers: AnyLayer[], routes: Route[], ...ChildRouter[]];
+/**
+* Infer param args from path
+*/
+export type InferParams<Path extends string> = Path extends `${string}*${infer Rest}` ? Rest extends "*" ? [string] : [string, ...InferParams<Rest>] : [];
+// Handle a specific method
+export type HandleMethod = <Path extends string>(path: Path, ...layers: AnyRouteLayer<InferParams<Path>>[]) => Route;
+/**
+* Create a router
+*/
+export declare const init: (...args: Router) => Router;
+export declare const handle: <Path extends string>(method: string, path: Path, ...layers: AnyRouteLayer<InferParams<Path>>[]) => Route;
+export declare const mount: (...args: ChildRouter) => ChildRouter;
+export declare const get: HandleMethod;
+export declare const post: HandleMethod;
+export declare const put: HandleMethod;
+export declare const del: HandleMethod;
+export declare const patch: HandleMethod;
+export declare const options: HandleMethod;
+export declare const trace: HandleMethod;

package/router.js

@@ -0,0 +1 @@
+import{argsToArray}from"./utils.js";export let init=argsToArray;export let handle=argsToArray;export let mount=argsToArray;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 DELETE=[`DELETE`];export let del=(...args)=>DELETE.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);

package/utils.d.ts

@@ -0,0 +1 @@
+export declare const argsToArray: <T extends any[]>(...args: T) => T;

package/utils.js

@@ -0,0 +1 @@
+export let argsToArray=(...args)=>args;

package/compiler/call.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/**
-* @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

@@ -1 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

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

package/generic/handlers.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1 +0,0 @@
-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/layers.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-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/generic/types.d.ts

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

package/generic/types.js

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