@mapl/web 0.3.11 → 0.3.12

package/README.md

@@ -38,4 +38,3 @@ Try it out using:
 npm install -g degit
 degit github:mapljs/web/examples/generic
 ```
-And change `@mapl/web` version in `package.json`.

package/build/rolldown.d.ts

@@ -20,7 +20,7 @@ export interface MaplOptions {
 	*/
 	asynchronous?: boolean;
 	/**
-	* Build target
+	* Compiler module to use
 	*/
 	target?: "bun";
 	/**
@@ -30,7 +30,6 @@ export interface MaplOptions {
 }
 export declare const hydrateImportsPlugin: RolldownPluginOption;
 export declare const SERVER_ENTRY = "index.js";
-declare const _default: (options: MaplOptions) => Promise<void>;
-export default _default;
-export declare const watcherReady: (watcher: RolldownWatcher) => Promise<void>;
+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,20 +1,15 @@
-import{mkdirSync,writeFileSync}from"node:fs";import{build,watch}from"rolldown";import{compileToExportedDependency as generic}from"../compiler/jit.js";import{compileToExportedDependency as bun}from"../compiler/bun/jit.js";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{}};export default async options=>{let buildOptions=options.build;let hydrateOptions=options.hydrate;let targetOption=options.target;let asyncOption=options.asynchronous;let inputFile=resolve(options.main);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 HANDLER=(targetOption===`bun`?bun:generic)(appMod.default);let outputFile=resolve(options.outputDir,SERVER_ENTRY);writeFileSync(outputFile,`
+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 '@mapl/web/compiler/${targetOption===`bun`?`bun/`:``}aot';
+      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 {
-        ${targetOption===`bun`?`routes`:`fetch`}: 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;let targetOption=options.target;return`
+      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 '@mapl/web/compiler/${targetOption===`bun`?`bun/`:``}jit';
-
-    export default {
-      ${targetOption===`bun`?`routes`:`fetch`}: ${asyncOption?`await compileToHandler`:`compileToHandlerSync`}(app)
-    };
-  `};export let watcherReady=watcher=>new Promise((res,rej)=>{let listener=e=>{if(e.code===`ERROR`)rej(e.error);else if(e.code===`BUNDLE_END`)res();watcher.off(`event`,listener)};watcher.on(`event`,listener)});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)};
+    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/bun/compiler/aot.d.ts

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

package/bun/compiler/aot.js

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

package/bun/compiler/jit.d.ts

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

package/bun/compiler/jit.js

@@ -0,0 +1 @@
+import{compileGroup,AsyncFunction,contextInit,setContextInit,hooks}from"@mapl/framework";import{countParams}from"@mapl/router/path";import{exportDependency,getDependency,injectDependency,injectExternalDependency}from"runtime-compiler";import{evaluate,evaluateSync}from"runtime-compiler/jit";import{compileErrorHandler,compileReturn,paramArgs,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 call=injectExternalDependency(fn)+`(`;let paramCount=countParams(handler[1]);paramCount>0&&(call+=paramArgs[paramCount]);if(fn.length>paramCount){call+=paramCount===0?`c`:`,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.js

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

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

package/bun/index.js

@@ -0,0 +1 @@
+import{routerImpl}from"../core/index.js";export let router=routerImpl;

package/compiler/aot.d.ts

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

package/compiler/jit.d.ts

@@ -1,10 +1,11 @@
 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 paramArgs: string[];
-export declare const compileToString: (router: RouterTag) => string;
-export declare const compileToExportedDependency: (router: RouterTag) => CompiledDependency<FetchFn>;
-export declare const compileToHandler: (router: RouterTag) => Promise<FetchFn>;
-export declare const compileToHandlerSync: (router: RouterTag) => FetchFn;
+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/core/context.d.ts

@@ -1,6 +1,5 @@
 export type Header = [string, string] | readonly [string, string];
 export interface Context {
-	req: Request;
 	headers: Header[];
 	status?: number;
 	statusText?: string;

package/core/handler.d.ts

@@ -57,9 +57,10 @@ export declare const text: HandlerResponse<BodyInit>;
 * @param f
 */
 export declare const error: <
+	C,
 	const E extends Err,
 	const D extends HandlerData | undefined = undefined
->(r: RouterTag<E>, f: NoInfer<(err: E, c: Context) => InferReturn<D>>, dat?: D) => RouterTag<never>;
+>(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

package/core/index.d.ts

@@ -1,12 +1,22 @@
 import type { HandlerTag } from "./handler.js";
-import type { AnyMiddlewareTypes } from "./middleware.js";
+import type { AnyMiddlewareTypes, InferMiddlewareState, InferMiddlewareErr } from "./middleware.js";
 import type { UnionToIntersection } from "./utils.js";
 declare const _: unique symbol;
-export interface RouterTag<E = any> {
-	[_]: E;
+export interface RouterTag<
+	C,
+	E = any
+> {
+	[_]: [E, C];
 }
-declare const _default: <
-	const T extends AnyMiddlewareTypes[],
-	const S extends Record<string, RouterTag> = {}
->(middlewares: T, handlers: HandlerTag<T extends [] ? {} : UnionToIntersection<T[number][1]>>[], children?: S) => RouterTag<S[keyof S][typeof _] | T[number][0]>;
-export default _default;
+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 +1 @@
-export default (middlewares,handlers,children)=>[middlewares,handlers,,children];
+export let routerImpl=(middlewares,handlers,children)=>[middlewares,handlers,,children];

package/core/middleware.d.ts

@@ -2,24 +2,37 @@ import type { ScopeState } from "@mapl/framework";
 import type { InferErr, InferResult } from "@safe-std/error";
 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>;
+declare const _: unique symbol;
+export type MiddlewareHandler<C> = (c: Context & C) => any;
+export interface MiddlewareTypes<
+	Context,
+	Err,
+	State
+> {
+	[_]: [Context, Err, State];
+}
+export type AnyMiddlewareTypes = MiddlewareTypes<any, any, any>;
+export type InferMiddlewareState<T extends AnyMiddlewareTypes> = T[typeof _][1];
+export type InferMiddlewareErr<T extends AnyMiddlewareTypes> = T[typeof _][1];
 export declare const macro: <
+	C,
 	E = never,
 	S = {}
->(f: (scope: ScopeState) => string) => MiddlewareTypes<E, S>;
-export declare const noOpMacro: MiddlewareTypes<never, {}>;
-export declare const tap: (f: MiddlewareHandler) => MiddlewareTypes<never, {}>;
+>(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
->(prop: Prop, f: T) => MiddlewareTypes<never, Record<Prop, AwaitedReturn<T>>>;
-export declare const validate: <const T extends MiddlewareHandler>(f: T) => MiddlewareTypes<InferErr<AwaitedReturn<T>>, {}>;
+	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
->(prop: Prop, f: T) => MiddlewareTypes<InferErr<AwaitedReturn<T>>, Record<Prop, InferResult<AwaitedReturn<T>>>>;
+	const T extends MiddlewareHandler<C>
+>(prop: Prop, f: T) => MiddlewareTypes<C, InferErr<AwaitedReturn<T>>, Record<Prop, InferResult<AwaitedReturn<T>>>>;
+export {};

package/index.d.ts

@@ -1,4 +1,12 @@
-export { default as router } from "./core/index.js";
+import { type ChildRouters, type InferHandlers, type InferRouter } from "./core/index.js";
+import type { MiddlewareTypes } from "./core/middleware.js";
+export interface GenericContext {
+	readonly req: Request;
+}
+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";

package/index.js

@@ -1 +1 @@
-export{default as router}from"./core/index.js";export*as layer from"./core/middleware.js";export*as handle from"./core/handler.js";export*as cors from"./utils/cors.js";export{default as staticHeaders}from"./utils/static-headers.js";
+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{default as staticHeaders}from"./utils/static-headers.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "@mapl/web",
-"version": "0.3.11",
+"version": "0.3.12",
 "description": "A compiled web framework for all runtimes",
 "keywords": ["fast", "lightweight", "cross-runtime", "framework", "web", "backend"],
 "repository": {
@@ -19,21 +19,22 @@
 "runtime-compiler": "^1.2.6"
 },
 "exports": {
-"./constants": "./constants.js",
 "./core/handler": "./core/handler.js",
 "./core": "./core/index.js",
 "./core/utils": "./core/utils.js",
 ".": "./index.js",
-"./core/context": "./core/context.js",
+"./constants": "./constants.js",
 "./core/middleware": "./core/middleware.js",
-"./build/utils": "./build/utils.js",
+"./core/context": "./core/context.js",
+"./utils/cors": "./utils/cors.js",
 "./utils/static-headers": "./utils/static-headers.js",
-"./compiler/jit": "./compiler/jit.js",
+"./bun": "./bun/index.js",
+"./bun/compiler/jit": "./bun/compiler/jit.js",
+"./bun/compiler/aot": "./bun/compiler/aot.js",
+"./bun/compiler/router": "./bun/compiler/router.js",
+"./build/utils": "./build/utils.js",
 "./build/rolldown": "./build/rolldown.js",
-"./compiler/bun/jit": "./compiler/bun/jit.js",
-"./compiler/bun/router": "./compiler/bun/router.js",
-"./utils/cors": "./utils/cors.js",
 "./compiler/aot": "./compiler/aot.js",
-"./compiler/bun/aot": "./compiler/bun/aot.js"
+"./compiler/jit": "./compiler/jit.js"
 }
 }

package/compiler/bun/aot.d.ts

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

package/compiler/bun/aot.js

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

package/compiler/bun/jit.d.ts

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

package/compiler/bun/jit.js

@@ -1 +0,0 @@
-import{compileGroup,AsyncFunction,contextInit,setContextInit,hooks}from"@mapl/framework";import{countParams}from"@mapl/router/path";import{exportDependency,getDependency,injectDependency,injectExternalDependency}from"runtime-compiler";import{evaluate,evaluateSync}from"runtime-compiler/jit";import{compileErrorHandler,compileReturn,paramArgs,RES400}from"../jit.js";import{insertRoute,resetRouter,routerToString}from"./router.js";let compileToState=router=>{resetRouter();hooks.compileHandler=(handler,prevContent,path,scope)=>{let fn=handler[2];let call=injectExternalDependency(fn)+`(`;let paramCount=countParams(handler[1]);paramCount>0&&(call+=paramArgs[paramCount]);if(fn.length>paramCount){call+=paramCount===0?`c`:`,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/compiler/bun/router.js

@@ -1 +0,0 @@
-import{injectDependency}from"runtime-compiler";import{RES404}from"../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+`}`};