@mapl/web 0.0.8 → 0.1.1

package/README.md

@@ -1 +1,21 @@
-A fast Web Standard framework.
+# `@mapl/web`
+A compiled web framework for all runtimes.
+
+```ts
+import { router, handle, layer, compile } from '@mapl/web';
+
+const api = router.init(
+  [],
+  [ handle.get('/', () => 'Hi') ]
+);
+
+const app = router.init(
+  [ layer.attach('id', () => performance.now()) ],
+  [ handle.get('/path', (c) => c.id) ],
+  { '/api': api }
+);
+
+export default {
+  fetch: router.compile(app)
+};
+```

package/constants.d.ts

@@ -1,10 +1,12 @@
-export * from '@mapl/framework/constants';
+export * from "@mapl/framework/constants.js";
 export declare const WEB: string;
 export declare const CTX_FN: string;
 export declare const CTX_INIT: string;
 export declare const PARSE_PATH: string;
 export declare const CHTML: string;
 export declare const CJSON: string;
+export declare const OHTML: string;
+export declare const OJSON: string;
 export declare const R404: string;
 export declare const R400: string;
 export declare const GLOBALS: string;

package/constants.js

@@ -1 +1 @@
-import{MAPL,HEADERS,CTX,PATH,REQ,URL,PATH_START,PATH_END}from"@mapl/framework/constants";export*from"@mapl/framework/constants";export let WEB=MAPL+"w";export let CTX_FN=WEB+"c";export let CTX_INIT="let "+HEADERS+"=[],"+CTX+"="+CTX_FN+"("+REQ+","+HEADERS+");";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+".substring("+PATH_START+","+PATH_END+");";export let CHTML=WEB+"h";export let CJSON=WEB+"j";export let R404=WEB+"n";export let R400=WEB+"b";export let GLOBALS="let ["+CHTML+","+CJSON+']=["text/html","application/json"].map(c=>["content-type",c]),['+R404+","+R400+"]=[404,400].map(s=>new Response(null,{status:s}));";
+import{MAPL,HEADERS,CTX,PATH,REQ,URL,PATH_START,PATH_END,TMP}from"@mapl/framework/constants.js";export*from"@mapl/framework/constants.js";export let WEB=MAPL+`w`;export let CTX_FN=WEB+`c`;export let CTX_INIT=`let `+HEADERS+`=[],`+CTX+`=`+CTX_FN+`(`+REQ+`,`+HEADERS+`);`;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+`.substring(`+PATH_START+`,`+PATH_END+`);`;export let CHTML=WEB+`h`;export let CJSON=WEB+`j`;export let OHTML=WEB+`oh`;export let OJSON=WEB+`oj`;export let R404=WEB+`n`;export let R400=WEB+`b`;export let GLOBALS=`let `+TMP+`=["text/html","application/json"].map(c=>["Content-Type",c]),[`+CHTML+`,`+CJSON+`]=`+TMP+`,[`+OHTML+`,`+OJSON+`]=`+TMP+`.map(c=>({headers:[c]})),[`+R404+`,`+R400+`]=[404,400].map(s=>new Response(null,{status:s}));`;

package/core/compile.d.ts

@@ -0,0 +1,3 @@
+import type { AnyRouter } from "./index.js";
+declare const _default: (router: AnyRouter) => ((req: Request) => any);
+export default _default;

package/core/compile.js

@@ -0,0 +1 @@
+import{compileGroup,createArgSet,isFuncAsync}from"@mapl/framework";import{o2}from"@mapl/router/tree/compiler.js";import compile from"@mapl/router/method/compiler.js";import{countParams}from"@mapl/router/path/index.js";import{isErr}from"safe-throw";import createContext from"./context.js";let paramArgs=createArgSet(new Array(16).fill(0).map((_1,i)=>`q`+i));let compileReturn=(state,dat,fnAsync,scopeAsync,contextCreated,result)=>{let typ=dat.type;if(typ===`raw`)return`return `+result;if(fnAsync)result=`await `+result;let str=typ==null?`return new Response(`+result+(contextCreated?`,c)`:`)`):contextCreated?`mh.push(`+(typ===`json`?`mwj`:`mwh`)+`);return new Response(`+(typ===`json`?`JSON.stringify(`+result+`)`:result)+`,c)`:`return new Response(`+(typ===`json`?`JSON.stringify(`+result+`),mwoj`:result+`,mwoh`)+`)`;return scopeAsync?str+`})()`:fnAsync?`return (async()=>{`+str+`})()`:str};export default router=>{let baseRouter={};let dependencies=[];compileGroup(router,[baseRouter,dependencies,`let mh=[],c=mwc(r,mh);`,(fn,dat,path,state,scope)=>{let call=`f`+state[1].push(fn)+`(`;let paramCount=countParams(path);if(paramCount>0)call+=paramArgs[paramCount];if(fn.length>paramCount){call+=paramCount===0?`c`:`,c`;if(!scope[1])return state[2]+compileReturn(state,dat,isFuncAsync(fn),scope[0],true,call+`)`)}return compileReturn(state,dat,isFuncAsync(fn),scope[0],scope[1],call+`)`)},(fn,dat,state,scope)=>{let call=`f`+state[1].push(fn)+`(t`;if(fn.length>1){call+=`,c`;if(!scope[1])return state[2]+compileReturn(state,dat,isFuncAsync(fn),scope[0],true,call+`)`)}return compileReturn(state,dat,isFuncAsync(fn),scope[0],scope[1],call+`)`)}],[false,false,null,`return mwb`],``,``);return Function(`me`,`mwc`,...dependencies.map((_,i)=>`f`+(i+1)),`let t=["text/html","application/json"].map(c=>["Content-Type",c]),[mwh,mwj]=t,[mwoh,mwoj]=t.map(c=>({headers:[c]})),[mwn,mwb]=[404,400].map(s=>new Response(null,{status:s}));return(r)=>{`+compile(baseRouter,o2,`r.method`,`let u=r.url,s=u.indexOf("/",12)+1,e=u.indexOf("?",s),p=e===-1?u.slice(s):u.substring(s,e);`,1)+`return mwn}`)(isErr,createContext,...dependencies)};

package/core/context.d.ts

@@ -0,0 +1,10 @@
+export type Header = [string, string] | readonly [string, string];
+export type Headers = Header[];
+export interface Context {
+	req: Request;
+	headers: Headers;
+	status?: number;
+	statusText?: string;
+}
+declare const _default: (req: Request, headers: Headers) => Context;
+export default _default;

package/core/context.js

@@ -0,0 +1 @@
+import{proto}from"./utils.js";let ctxProto=proto({req:void 0,headers:void 0,status:200});export default (req,headers)=>{let obj=Object.create(ctxProto);obj.headers=headers;obj.req=req;return obj};

package/core/handler.d.ts

@@ -0,0 +1,62 @@
+import type { Err } from "safe-throw";
+import type { Context } from "./context.js";
+import { type Tag } from "./utils.js";
+import type { RouterTag } from "./index.js";
+export type ErrorHandler<E extends Err = Err> = (err: E, c: Context) => any;
+export type Handler<
+	Params extends string[] = string[],
+	T extends {} = Record<string, any>
+> = (...args: [...params: Params, c: Context & T]) => any;
+export type DefineHandler = <
+	P extends string,
+	S = {}
+>(path: P, handler: Handler<InferPath<P>, Required<S>>, ...dat: HandlerData[]) => HandlerTag<S>;
+export interface HandlerData extends Record<symbol, any> {
+	type?: "json" | "html" | "raw";
+}
+export type InferPath<T extends string> = T extends `${string}*${infer Next}` ? Next extends "*" ? [string] : [string, ...InferPath<Next>] : [];
+declare const handlerTag: unique symbol;
+export type HandlerTag<T> = Tag<T, typeof handlerTag>;
+/**
+* Return JSON
+*/
+export declare const json: {
+	readonly type: "json"
+};
+/**
+* Return HTML
+*/
+export declare const html: {
+	readonly type: "html"
+};
+/**
+* Return raw Response
+*/
+export declare const raw: {
+	readonly type: "raw"
+};
+/**
+* Handle errors of a router
+* @param f
+*/
+export declare const error: <const E extends Err>(r: RouterTag<E>, f: ErrorHandler<E>, ...dat: HandlerData[]) => RouterTag<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,
+	S = {}
+>(method: string, path: P, handler: Handler<InferPath<P>, Required<S>>, ...dat: HandlerData[]) => HandlerTag<S>;
+export declare const any: DefineHandler;
+export declare const get: DefineHandler;
+export declare const post: DefineHandler;
+export declare const put: DefineHandler;
+export declare const del: DefineHandler;
+export declare const patch: DefineHandler;
+export declare const options: DefineHandler;
+export declare const trace: DefineHandler;
+export {};

package/core/handler.js

@@ -0,0 +1 @@
+import{ALL}from"@mapl/router/method/index.js";import{proto}from"./utils.js";export let json={type:`json`};export let html={type:`html`};export let raw={type:`raw`};export let error=(r,f,...dat)=>{r[2]=[f,proto(...dat)];return r};export let route=(method,path,handler,...dat)=>[method,path,handler,proto(...dat)];export let any=(...a)=>route(ALL,...a);export let get=(...a)=>route(`GET`,...a);export let post=(...a)=>route(`POST`,...a);export let put=(...a)=>route(`PUT`,...a);export let del=(...a)=>route(`DELETE`,...a);export let patch=(...a)=>route(`PATCH`,...a);export let options=(...a)=>route(`OPTIONS`,...a);export let trace=(...a)=>route(`TRACE`,...a);

package/core/index.d.ts

@@ -0,0 +1,15 @@
+import type { HandlerTag } from "./handler.js";
+import type { AnyMiddlewareTypes } from "./middleware.js";
+import type { Tag, ToNever, UnionToIntersection } from "./utils.js";
+declare const routerTag: unique symbol;
+export type RouterTag<E = any> = Tag<E, typeof routerTag>;
+export type InferError<
+	T extends AnyMiddlewareTypes[],
+	S extends Record<string, RouterTag>
+> = ToNever<S[keyof S][typeof routerTag] | T[number][0]>;
+export type InferHandler<T extends AnyMiddlewareTypes[]> = HandlerTag<T extends [] ? {} : UnionToIntersection<T[number][1]>>;
+declare const _default: <
+	const T extends AnyMiddlewareTypes[],
+	const S extends Record<string, RouterTag> = {}
+>(middlewares: T, handlers: InferHandler<T>[], children?: S) => RouterTag<InferError<T, S>>;
+export default _default;

package/core/index.js

@@ -0,0 +1 @@
+export default (middlewares,handlers,children)=>[middlewares,handlers,null,children==null?[]:Object.entries(children)];

package/core/middleware.d.ts

@@ -0,0 +1,19 @@
+import type { InferErr } from "safe-throw";
+import type { AwaitedReturn } from "./utils.js";
+import type { Context } from "./context.js";
+export type MiddlewareHandler = (c: Context) => any;
+export type MiddlewareTypes<
+	E,
+	S
+> = [err: E, state: S];
+export type AnyMiddlewareTypes = MiddlewareTypes<any, any>;
+export declare const tap: (f: MiddlewareHandler) => MiddlewareTypes<never, {}>;
+export declare const attach: <
+	Prop extends string,
+	const T extends MiddlewareHandler
+>(prop: Prop, f: T) => MiddlewareTypes<never, Record<Prop, AwaitedReturn<T>>>;
+export declare const validate: <const T extends MiddlewareHandler>(f: T) => MiddlewareTypes<InferErr<AwaitedReturn<T>>, {}>;
+export declare const parse: <
+	Prop extends string,
+	const T extends MiddlewareHandler
+>(prop: Prop, f: T) => MiddlewareTypes<InferErr<AwaitedReturn<T>>, Record<Prop, AwaitedReturn<T>>>;

package/core/middleware.js

@@ -0,0 +1 @@
+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/{router → core}/utils.d.ts

@@ -1,3 +1,8 @@
-export type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+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 ToNever<T> = unknown extends T ? never : T;
+export type Tag<
+	S,
+	T extends symbol
+> = Record<T, S>;
 export declare const proto: <T extends any[]>(...f: T) => UnionToIntersection<T[number]>;

package/index.d.ts

@@ -1,3 +1,5 @@
-export { default as router } from './router';
-import type { AnyRouter } from './router';
-export declare const compile: (app: AnyRouter) => (req: Request) => any;
+export { default as router } from "./core/index.js";
+export * as handle from "./core/handler.js";
+export * as layer from "./core/middleware.js";
+export { default as compile } from "./core/compile.js";
+export { st } from "safe-throw";

package/index.js

@@ -1 +1 @@
-export{default as router}from"./router";import genericCompile from"./router/compiler";export let compile=(app)=>genericCompile(app,[]);
+export{default as router}from"./core/index.js";export*as handle from"./core/handler.js";export*as layer from"./core/middleware.js";export{default as compile}from"./core/compile.js";export{st}from"safe-throw";

package/package.json

@@ -1,41 +1,25 @@
 {
-  "name": "@mapl/web",
-  "version": "0.0.8",
-  "description": "A compiled web standard framework",
-  "keywords": [
-    "fast",
-    "compiled",
-    "cross-runtime",
-    "framework",
-    "web",
-    "backend"
-  ],
-  "license": "MIT",
-  "type": "module",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "scripts": {
-    "task": "bun scripts/task.ts",
-    "build:test": "bun task build && bun test",
-    "build:publish": "bun task build && bun task report-size && bun task publish",
-    "lint": "eslint ./src",
-    "lint:fix": "eslint ./src --fix"
-  },
-  "devDependencies": {
-    "@stylistic/eslint-plugin": "latest",
-    "@types/bun": "latest",
-    "@types/uglify-js": "latest",
-    "eslint": "latest",
-    "eslint-plugin-jsdoc": "latest",
-    "mitata": "latest",
-    "terser": "^5.39.0",
-    "tsx": "latest",
-    "typescript": "latest",
-    "typescript-eslint": "latest"
-  },
-  "dependencies": {
-    "@mapl/framework": "^0.1.0",
-    "@mapl/router": "^0.4.13",
-    "safe-throw": "^0.0.9"
-  }
+"name": "@mapl/web",
+"version": "0.1.1",
+"description": "A compiled web framework for all runtimes",
+"keywords": [],
+"license": "MIT",
+"type": "module",
+"main": "./index.js",
+"types": "./index.d.ts",
+"dependencies": {
+"@mapl/framework": "^0.1.3",
+"@mapl/router": "^0.4.15",
+"safe-throw": "^0.5.1"
+},
+"exports": {
+"./constants": "./constants.js",
+"./core/compile": "./core/compile.js",
+"./core/context": "./core/context.js",
+".": "./index.js",
+"./core/utils": "./core/utils.js",
+"./core/middleware": "./core/middleware.js",
+"./core": "./core/index.js",
+"./core/handler": "./core/handler.js"
 }
+}

package/modules/bearer.d.ts

@@ -1,6 +0,0 @@
-import { type Err } from 'safe-throw';
-import type { Context } from '../router/context';
-export type TokenParser = (token: string, c: Context) => Promise<any>;
-export type MalformedErr = Err<'Malformed bearer token'>;
-declare const _default: <const T extends TokenParser>(verifier: T) => (c: Parameters<T>[1]) => ReturnType<T> | Promise<MalformedErr>;
-export default _default;

package/modules/bearer.js

@@ -1 +0,0 @@
-export default (verifier)=>async(c)=>{let tok=c.req.headers.get("Authorization");return typeof tok==="string"&&tok.startsWith("Bearer ")&&tok.length>7?verifier(tok,c):malformedErr};import{err}from"safe-throw";let malformedErr=Promise.resolve(err("Malformed bearer token"));

package/router/compiler.d.ts

@@ -1,3 +0,0 @@
-import type { AnyRouter } from '.';
-declare const _default: (router: AnyRouter) => (req: Request) => any;
-export default _default;

package/router/compiler.js

@@ -1 +0,0 @@
-export default (router)=>{let baseRouter={};let dependencies=[];compileGroup(router._,[baseRouter,dependencies,"let mh=[],c=mwc(r,mh);",(fn,dat,path,state,scope)=>{let call="f"+state[1].push(fn)+"(";let paramCount=path[0].length;if(paramCount>0)call+=paramArgs[paramCount];if(fn.length>paramCount){call+=paramCount===0?"c":",c";if(!scope[1])return state[2]+compileReturn(state,dat,isFuncAsync(fn),scope[0],true,call+")")}return compileReturn(state,dat,isFuncAsync(fn),scope[0],scope[1],call+")")},(fn,dat,state,scope)=>{let call="f"+state[1].push(fn)+"(t";if(fn.length>1){call+=",c";if(!scope[1])return state[2]+compileReturn(state,dat,isFuncAsync(fn),scope[0],true,call+")")}return compileReturn(state,dat,isFuncAsync(fn),scope[0],scope[1],call+")")},transformRoute],[false,false,null,"return mwb"],"","");return Function("me","mwc",...dependencies.map((_,i)=>"f"+(i+1)),'let [mwh,mwj]=["text/html","application/json"].map(c=>["content-type",c]),[mwn,mwb]=[404,400].map(s=>new Response(null,{status:s}));return(r)=>{'+compile(baseRouter,o2,"r.method",'let u=r.url,s=u.indexOf("/",12)+1,e=u.indexOf("?",s),p=e===-1?u.slice(s):u.substring(s,e);',1)+"return mwn}")(isErr,createContext,...dependencies)};import{compileGroup,createArgSet,isFuncAsync}from"@mapl/framework";import{o2}from"@mapl/router/tree/compiler";import compile from"@mapl/router/method/compiler";import{transformRoute}from"@mapl/router/transform";import{isErr}from"safe-throw";import{createContext}from"./context";let paramArgs=createArgSet(new Array(16).fill(0).map((_1,i)=>"q"+i));let compileReturn=(state,dat,fnAsync,scopeAsync,contextCreated,result)=>{let typ=dat.type;if(typ==="raw")return"return "+result;if(fnAsync)result="await "+result;let str=typ==null?"return new Response("+result+(contextCreated?",c)":")"):(contextCreated?"":state[2])+"mh.push("+(typ==="json"?"mwj":"mwh")+");return new Response("+(typ==="json"?"JSON.stringify("+result+")":result)+",c)";return fnAsync&&!scopeAsync?"return (async()=>{"+str+"})()":scopeAsync?str+"})()":str};

package/router/context.d.ts

@@ -1,9 +0,0 @@
-export type Header = [string, string] | readonly [string, string];
-export type Headers = Header[];
-export interface Context {
-    req: Request;
-    headers: Headers;
-    status?: number;
-    statusText?: string;
-}
-export declare const createContext: (req: Request, headers: Headers) => Context;

package/router/context.js

@@ -1 +0,0 @@
-import{proto}from"./utils";let ctxProto=proto({req:null,headers:null,status:200});export let createContext=(req,headers)=>{let obj=Object.create(ctxProto);obj.headers=headers;obj.req=req;return obj};

package/router/handler.d.ts

@@ -1,14 +0,0 @@
-import type { Group } from '@mapl/framework';
-import type { Err } from 'safe-throw';
-import type { Context } from './context';
-export type ErrorFunc<E extends Err = Err, T extends {} = Record<string, any>, Args extends any[] = any[]> = (err: E, c: Context & T, ...args: Args) => any;
-export type HandlerFunc<Params extends string[] = string[], T extends {} = Record<string, any>> = (...args: [...params: Params, c: Context & T]) => any;
-export type MiddlewareFunc<T extends {} = Record<string, any>> = (c: Context & T) => any;
-/**
- * Basic information to compile
- */
-export interface Data {
-    type?: 'json' | 'html' | 'raw';
-}
-export type HandlerData = Data & Record<symbol, any>;
-export type HandlerGroup = Group<ErrorFunc, HandlerFunc, HandlerData>;

package/router/index.d.ts

@@ -1,22 +0,0 @@
-import type { Err, InferErr, InferResult } from 'safe-throw';
-import type { InferRoute } from '@mapl/router/transform';
-import { type AwaitedReturn } from './utils';
-import type { ErrorFunc, HandlerData, HandlerFunc, HandlerGroup, MiddlewareFunc } from './handler';
-import { type Methods } from './method';
-export type RouteRegister<in out State extends {}, in out E extends Err> = {
-    [K in Methods | 'any']: <Path extends string>(path: Path, handler: HandlerFunc<InferRoute<Path>, State>, ...data: HandlerData[]) => Router<State, E>;
-};
-export interface Router<in out State extends {} = {}, in out E extends Err = never> extends RouteRegister<State, E> {
-    _state: State;
-    _err: E;
-    _: HandlerGroup;
-    apply: (fn: MiddlewareFunc<State>) => this;
-    check: <const T extends MiddlewareFunc<State>>(fn: T) => Router<State, E | InferErr<AwaitedReturn<T>>>;
-    set: <Prop extends string, const T extends MiddlewareFunc<State>>(prop: Prop, fn: T) => Router<State & Record<Prop, AwaitedReturn<T>>, E>;
-    parse: <Prop extends string, const T extends MiddlewareFunc<State>>(prop: Prop, fn: T) => Router<State & Record<Prop, InferResult<AwaitedReturn<T>>>, E | InferErr<AwaitedReturn<T>>>;
-    route: <Prefix extends string, const App extends Router<any, any>>(prefix: Prefix, app: App) => this;
-    err: (fn: ErrorFunc<E, State>, ...data: HandlerData[]) => this;
-}
-export type AnyRouter = Router<any, any>;
-declare const _default: () => Router<[]>;
-export default _default;

package/router/index.js

@@ -1 +0,0 @@
-export default ()=>{let obj=Object.create(routerProto);obj._=[[],[],null,[]];return obj};import{proto}from"./utils";import{ALL,METHODS}from"./method";let createMethodRegister=(method)=>function(path,handler,...data){this._[1].push([method,path,handler,proto(...data)]);return this};let routerProto=proto({_:null,apply(f){this._[0].push([0,f]);return this},check(f){this._[0].push([2,f]);return this},set(prop,f){this._[0].push([1,f,prop]);return this},parse(prop,f){this._[0].push([3,f,prop]);return this},route(prefix,app){this._[3].push([prefix,app._]);return this},any:createMethodRegister(ALL),err(f,...data){this._[2]=[f,proto(...data)];return this}},Object.fromEntries(METHODS.map((method)=>[method,createMethodRegister(method.toUpperCase())])));

package/router/method.d.ts

@@ -1,5 +0,0 @@
-import { ALL } from '@mapl/router/method';
-export declare const METHODS: readonly ["get", "post", "put", "delete", "patch", "options", "trace"];
-export type Methods = typeof METHODS[number];
-export type RequestMethod = Uppercase<Methods> | ALL | (string & {});
-export { ALL };

package/router/method.js

@@ -1 +0,0 @@
-import{ALL}from"@mapl/router/method";export let METHODS=["get","post","put","delete","patch","options","trace"];export{ALL};