abret 0.1.2 → 0.1.4

package/dist/chunk-m2mdqvmd.js

@@ -0,0 +1,82 @@
+// @bun
+import {
+  runWithContext
+} from "./chunk-xw5b0251.js";
+
+// src/index.ts
+var wrapWithMiddleware = (handler, middlewares) => {
+  return (req, server) => {
+    return runWithContext(() => {
+      if (middlewares.length === 0) {
+        return handler(req, server);
+      }
+      let index = 0;
+      const next = () => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          if (middleware)
+            return middleware(req, server, next);
+        }
+        return handler(req, server);
+      };
+      return next();
+    });
+  };
+};
+var wrapRouteValue = (value, middlewares) => {
+  if (middlewares.length === 0) {
+    return value;
+  }
+  if (value instanceof Response) {
+    return wrapWithMiddleware(() => value, middlewares);
+  }
+  if (typeof value === "function") {
+    return wrapWithMiddleware(value, middlewares);
+  }
+  if (typeof value === "object" && value !== null) {
+    const wrappedMethods = {};
+    for (const [method, methodHandler] of Object.entries(value)) {
+      if (methodHandler instanceof Response) {
+        wrappedMethods[method] = wrapWithMiddleware(() => methodHandler, middlewares);
+      } else if (typeof methodHandler === "function") {
+        wrappedMethods[method] = wrapWithMiddleware(methodHandler, middlewares);
+      }
+    }
+    return wrappedMethods;
+  }
+  return value;
+};
+var createRoute = (path, value, ...middlewares) => {
+  const wrappedValue = wrapRouteValue(value, middlewares);
+  return { [path]: wrappedValue };
+};
+var createMiddleware = (fn) => fn;
+var composeMiddlewares = (...middlewares) => {
+  return (req, server, finalNext) => {
+    let index = 0;
+    const next = () => {
+      if (index < middlewares.length) {
+        const middleware = middlewares[index++];
+        if (middleware)
+          return middleware(req, server, next);
+      }
+      return finalNext();
+    };
+    return next();
+  };
+};
+var mergeRoutes = (...routes) => {
+  return Object.assign({}, ...routes);
+};
+var createRouteGroup = (prefix, middlewares = []) => {
+  return (path, value) => {
+    let fullPath = `/${prefix}/${path}`.replace(/\/+/g, "/");
+    if (fullPath.length > 1 && fullPath.endsWith("/")) {
+      fullPath = fullPath.slice(0, -1);
+    }
+    const normalizedPath = fullPath || "/";
+    return createRoute(normalizedPath, value, ...middlewares);
+  };
+};
+
+export { createRoute, createMiddleware, composeMiddlewares, mergeRoutes, createRouteGroup };

package/dist/html.js

@@ -1,13 +1,13 @@
 // @bun
-import {
-  getContextStore
-} from "./chunk-xw5b0251.js";
 import {
   AsyncBuffer,
   Fragment,
   SafeString,
   VNode
 } from "./chunk-m9t91z6h.js";
+import {
+  getContextStore
+} from "./chunk-xw5b0251.js";
 
 // src/html.ts
 class HTMLResponse extends Response {

package/dist/index.d.ts

@@ -33,7 +33,7 @@ export type RouteValue<P extends string = string, S = undefined> = Bun.Serve.Bas
  * );
  * ```
  */
-export declare const createRoute: <P extends string, S = undefined>(path: P, value: RouteValue<P, S>, ...middlewares: Middleware<P, S>[]) => Record<P, RouteValue<P, S>>;
+export declare const createRoute: <P extends `/${string}`, S = undefined>(path: P, value: RouteValue<P, S>, ...middlewares: Middleware<P, S>[]) => Record<P, RouteValue<P, S>>;
 /**
  * Helper to create a middleware function with proper typing
  *
@@ -100,4 +100,4 @@ type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) exten
  * );
  * ```
  */
-export declare const createRouteGroup: <Prefix extends string, S = undefined>(prefix: Prefix, middlewares?: Middleware<string, S>[]) => <P extends string>(path: P, value: RouteValue<`${Prefix}${P}`, S>) => Record<`${Prefix}${P}`, RouteValue<`${Prefix}${P}`, S>>;
+export declare const createRouteGroup: <Prefix extends `/${string}`, S = undefined>(prefix: Prefix, middlewares?: Middleware<string, S>[]) => <P extends `/${string}` | "">(path: P, value: RouteValue<string, S>) => Record<`/${string}`, RouteValue<`/${string}`, S>>;

package/dist/index.js

@@ -1,82 +1,17 @@
 // @bun
+import {
+  composeMiddlewares,
+  createMiddleware,
+  createRoute,
+  createRouteGroup,
+  mergeRoutes
+} from "./chunk-m2mdqvmd.js";
 import {
   createContext,
   runWithContext,
   runWithContextValue,
   useContext
 } from "./chunk-xw5b0251.js";
-
-// src/index.ts
-var wrapWithMiddleware = (handler, middlewares) => {
-  return (req, server) => {
-    return runWithContext(() => {
-      if (middlewares.length === 0) {
-        return handler(req, server);
-      }
-      let index = 0;
-      const next = () => {
-        if (index < middlewares.length) {
-          const middleware = middlewares[index++];
-          if (middleware)
-            return middleware(req, server, next);
-        }
-        return handler(req, server);
-      };
-      return next();
-    });
-  };
-};
-var wrapRouteValue = (value, middlewares) => {
-  if (middlewares.length === 0) {
-    return value;
-  }
-  if (value instanceof Response) {
-    return wrapWithMiddleware(() => value, middlewares);
-  }
-  if (typeof value === "function") {
-    return wrapWithMiddleware(value, middlewares);
-  }
-  if (typeof value === "object" && value !== null) {
-    const wrappedMethods = {};
-    for (const [method, methodHandler] of Object.entries(value)) {
-      if (methodHandler instanceof Response) {
-        wrappedMethods[method] = wrapWithMiddleware(() => methodHandler, middlewares);
-      } else if (typeof methodHandler === "function") {
-        wrappedMethods[method] = wrapWithMiddleware(methodHandler, middlewares);
-      }
-    }
-    return wrappedMethods;
-  }
-  return value;
-};
-var createRoute = (path, value, ...middlewares) => {
-  const wrappedValue = wrapRouteValue(value, middlewares);
-  return { [path]: wrappedValue };
-};
-var createMiddleware = (fn) => fn;
-var composeMiddlewares = (...middlewares) => {
-  return (req, server, finalNext) => {
-    let index = 0;
-    const next = () => {
-      if (index < middlewares.length) {
-        const middleware = middlewares[index++];
-        if (middleware)
-          return middleware(req, server, next);
-      }
-      return finalNext();
-    };
-    return next();
-  };
-};
-var mergeRoutes = (...routes) => {
-  return Object.assign({}, ...routes);
-};
-var createRouteGroup = (prefix, middlewares = []) => {
-  return (path, value) => {
-    const fullPath = `${prefix}${path}`;
-    return createRoute(fullPath, value, ...middlewares);
-  };
-};
 export {
   useContext,
   runWithContextValue,

package/dist/middleware/static/index.d.ts

@@ -19,10 +19,6 @@ export type ServeStaticOptions = {
      * Extension (without dot) -> Mime Type
      */
     mimes?: Record<string, string>;
-    /**
-     * Callback when file is not found.
-     */
-    onNotFound?: (path: string, req: Request) => void;
 };
 /**
  * Middleware to serve static files using Bun.file

package/dist/middleware/static/index.js

@@ -29,9 +29,6 @@ var serveStatic = (options = {}) => {
       }
       return response;
     }
-    if (options.onNotFound) {
-      options.onNotFound(filePath, req);
-    }
     return next();
   };
 };

package/dist/middleware/transpiler/index.d.ts

@@ -0,0 +1,28 @@
+interface TranspilerOptions {
+    /** Directory where source files (.ts, .tsx) are located */
+    sourcePath: string;
+    /** URL prefix to intercept (e.g., "/_modules") */
+    staticBasePath: string;
+    /** Optional sub-path for vendor modules. Defaults to 'vendor' */
+    vendorPath?: string;
+    /** Optional list of modules to bundle on startup */
+    prewarm?: string[];
+    /** Minify local modules. Defaults to false (recommended for dev) */
+    minify?: boolean;
+    /** Browser cache TTL for local modules in seconds. Defaults to 0 */
+    localMaxAge?: number;
+    /** Global identifier replacements */
+    define?: Record<string, string>;
+    /** Map modules to global variables (e.g., { 'react': 'React' }) */
+    globals?: Record<string, string>;
+    /** Automatically fallback to esm.sh if package is not found locally */
+    cdnFallback?: boolean;
+    /** Additional Bun plugins */
+    plugins?: any[];
+}
+/**
+ * Transpiler middleware that handles on-the-fly TS/TSX transpilation
+ * and automatic npm module bundling (vendor modules).
+ */
+export declare const transpiler: (options: TranspilerOptions) => import("../..").Middleware<string, undefined>;
+export {};

package/dist/middleware/transpiler/index.js

@@ -0,0 +1,298 @@
+// @bun
+import {
+  createMiddleware
+} from "../../chunk-m2mdqvmd.js";
+import"../../chunk-xw5b0251.js";
+
+// src/middleware/transpiler/index.ts
+import { existsSync, mkdirSync, statSync } from "fs";
+import path from "path";
+var transpiler = (options) => {
+  const {
+    sourcePath,
+    staticBasePath,
+    vendorPath = "vendor",
+    prewarm = [],
+    minify = false,
+    localMaxAge = 0,
+    define = {},
+    globals = {},
+    cdnFallback = false,
+    plugins = []
+  } = options;
+  const cacheDir = path.resolve(process.cwd(), "node_modules", ".transpiler");
+  const basePrefix = staticBasePath.endsWith("/") ? staticBasePath : `${staticBasePath}/`;
+  const vendorPrefix = `${basePrefix}${vendorPath.replace(/^\/|\/$/g, "")}/`;
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+  const publicEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("PUBLIC_")) {
+      publicEnv[`process.env.${key}`] = JSON.stringify(value);
+    }
+  }
+  const defaultDefine = {
+    "process.env.NODE_ENV": JSON.stringify("development"),
+    ...publicEnv,
+    ...define
+  };
+  const activeBundles = new Map;
+  function resolveModulePath(moduleName) {
+    if (globals[moduleName])
+      return moduleName;
+    try {
+      Bun.resolveSync(moduleName, process.cwd());
+      return `${basePrefix}${vendorPath.replace(/^\/|\/$/g, "")}/${moduleName}`;
+    } catch {
+      if (cdnFallback) {
+        return `https://esm.sh/${moduleName}`;
+      }
+      return `${basePrefix}${vendorPath.replace(/^\/|\/$/g, "")}/${moduleName}`;
+    }
+  }
+  async function bundleVendorModule(moduleName) {
+    const cacheKey = moduleName.replace(/\//g, "__");
+    const cachedFile = path.join(cacheDir, `${cacheKey}.js`);
+    if (existsSync(cachedFile))
+      return;
+    if (activeBundles.has(cacheKey)) {
+      return activeBundles.get(cacheKey);
+    }
+    const promise = (async () => {
+      if (existsSync(cachedFile))
+        return;
+      try {
+        const entryPoint = Bun.resolveSync(moduleName, process.cwd());
+        const globalsPlugin = {
+          name: "abret-globals",
+          setup(build) {
+            for (const moduleName2 of Object.keys(globals)) {
+              build.onResolve({ filter: new RegExp(`^${moduleName2}$`) }, () => ({
+                path: moduleName2,
+                namespace: "abret-globals"
+              }));
+            }
+            build.onLoad({ filter: /.*/, namespace: "abret-globals" }, (args) => {
+              const gName = globals[args.path];
+              return {
+                contents: `export default globalThis.${gName}; export const ${gName} = globalThis.${gName};`,
+                loader: "js"
+              };
+            });
+          }
+        };
+        const result = await Bun.build({
+          entrypoints: [entryPoint],
+          target: "browser",
+          format: "esm",
+          minify: true,
+          define: defaultDefine,
+          plugins: [
+            globalsPlugin,
+            {
+              name: "abret-external-vendor",
+              setup(build) {
+                build.onResolve({ filter: /^[^./]/ }, (args) => {
+                  if (args.path === moduleName || globals[args.path])
+                    return null;
+                  return { path: args.path, external: true };
+                });
+              }
+            },
+            ...plugins
+          ]
+        });
+        if (!result.success || result.outputs.length === 0) {
+          console.error(`[Abret] Failed to bundle vendor module: ${moduleName}`, result.logs);
+          return;
+        }
+        const output = result.outputs[0];
+        if (!output)
+          return;
+        const rawContent = await output.text();
+        const content = rawContent.replace(/((?:import|export)\s*[\s\S]*?from\s*['"]|import\s*\(['"])([^'"]+)(['"]\)?)/g, (match, prefix, path2, suffix) => {
+          if (/^(https?:|(?:\/\/))/.test(path2))
+            return match;
+          if (!path2.startsWith(".") && !path2.startsWith("/")) {
+            return `${prefix}${resolveModulePath(path2)}${suffix}`;
+          }
+          return match;
+        });
+        await Bun.write(cachedFile, content);
+        console.log(`[Abret] Pre-bundled: ${moduleName}`);
+      } catch (err) {
+        console.error(`[Abret] Error bundling ${moduleName}:`, err);
+      } finally {
+        activeBundles.delete(cacheKey);
+      }
+    })();
+    activeBundles.set(cacheKey, promise);
+    return promise;
+  }
+  if (prewarm.length > 0) {
+    for (const moduleName of prewarm) {
+      bundleVendorModule(moduleName);
+    }
+  }
+  return createMiddleware(async (req, _server, next) => {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    if (!pathname.startsWith(basePrefix) && pathname !== staticBasePath) {
+      return next();
+    }
+    if (pathname.startsWith(vendorPrefix)) {
+      const moduleName = pathname.slice(vendorPrefix.length);
+      const cacheKey = moduleName.replace(/\//g, "__");
+      const cachedFile = path.join(cacheDir, `${cacheKey}.js`);
+      if (existsSync(cachedFile)) {
+        return new Response(Bun.file(cachedFile), {
+          headers: {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        });
+      }
+      await bundleVendorModule(moduleName);
+      if (existsSync(cachedFile)) {
+        return new Response(Bun.file(cachedFile), {
+          headers: {
+            "Content-Type": "application/javascript",
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        });
+      }
+      return next();
+    }
+    const internalPath = pathname.slice(basePrefix.length);
+    const extname = path.extname(internalPath);
+    let sourceFile = "";
+    let contentType = "application/javascript";
+    if (extname === ".css") {
+      const p = path.join(path.resolve(sourcePath), internalPath);
+      if (existsSync(p)) {
+        sourceFile = p;
+        contentType = "text/css";
+      }
+    } else {
+      const baseFileName = internalPath.endsWith(".js") ? internalPath.slice(0, -3) : internalPath;
+      const possibleExtensions = [".tsx", ".ts", ".jsx", ".js"];
+      for (const ext of possibleExtensions) {
+        const p = path.join(path.resolve(sourcePath), (baseFileName.startsWith("/") ? baseFileName.slice(1) : baseFileName) + ext);
+        if (existsSync(p)) {
+          sourceFile = p;
+          break;
+        }
+      }
+    }
+    if (sourceFile) {
+      const sourceStat = statSync(sourceFile);
+      const fastEtag = `W/"${sourceStat.size}-${sourceStat.mtimeMs}-${minify}"`;
+      if (req.headers.get("if-none-match") === fastEtag) {
+        return new Response(null, { status: 304 });
+      }
+      const lockKey = `local:${sourceFile}:${fastEtag}`;
+      if (activeBundles.has(lockKey)) {
+        const result = await activeBundles.get(lockKey);
+        return new Response(result.content, {
+          headers: {
+            "Content-Type": result.contentType,
+            ETag: fastEtag,
+            "Cache-Control": localMaxAge > 0 ? `public, max-age=${localMaxAge}` : "no-cache"
+          }
+        });
+      }
+      const buildPromise = (async () => {
+        try {
+          const buildResult = await Bun.build({
+            entrypoints: [sourceFile],
+            target: "browser",
+            format: "esm",
+            minify,
+            define: defaultDefine,
+            external: ["*"],
+            plugins: [
+              {
+                name: "abret-globals-local",
+                setup(build) {
+                  for (const moduleName of Object.keys(globals)) {
+                    build.onResolve({ filter: new RegExp(`^${moduleName}$`) }, () => ({
+                      path: moduleName,
+                      namespace: "abret-globals"
+                    }));
+                  }
+                  build.onLoad({ filter: /.*/, namespace: "abret-globals" }, (args) => {
+                    const gName = globals[args.path];
+                    return {
+                      contents: `export default globalThis.${gName};`,
+                      loader: "js"
+                    };
+                  });
+                }
+              },
+              ...plugins
+            ]
+          });
+          if (!buildResult.success || buildResult.outputs.length === 0) {
+            throw new Error(`Build failed: ${buildResult.logs.map((l) => l.message).join(", ")}`);
+          }
+          const output = buildResult.outputs[0];
+          if (!output)
+            throw new Error("No output generated");
+          const transpiledCode = await output.text();
+          if (contentType === "text/css") {
+            return { content: transpiledCode, contentType };
+          }
+          const finalCode = transpiledCode.replace(/((?:import|export)\s*[\s\S]*?from\s*['"]|import\s*\(['"])([^'"]+)(['"]\)?)/g, (match, prefix, path2, suffix) => {
+            if (/^(https?:|(?:\/\/))/.test(path2))
+              return match;
+            if (!path2.startsWith(".") && !path2.startsWith("/")) {
+              return `${prefix}${resolveModulePath(path2)}${suffix}`;
+            }
+            if (path2.startsWith(".") && !path2.split("/").pop()?.includes(".")) {
+              return `${prefix}${path2}.js${suffix}`;
+            }
+            return match;
+          });
+          return { content: finalCode, contentType };
+        } finally {
+          activeBundles.delete(lockKey);
+        }
+      })();
+      activeBundles.set(lockKey, buildPromise);
+      try {
+        const finalResult = await buildPromise;
+        return new Response(finalResult.content, {
+          headers: {
+            "Content-Type": finalResult.contentType,
+            ETag: fastEtag,
+            "Cache-Control": localMaxAge > 0 ? `public, max-age=${localMaxAge}` : "no-cache"
+          }
+        });
+      } catch (err) {
+        const errorMessage = err.message || "Unknown transpilation error";
+        console.error(`[Abret] ${errorMessage} for ${sourceFile}`);
+        return new Response(`console.error("[Abret] Build Error in ${sourceFile}:", ${JSON.stringify(errorMessage)});
+        if (typeof document !== 'undefined') {
+          const div = document.createElement('div');
+          div.style.position = 'fixed';
+          div.style.top = '0';
+          div.style.left = '0';
+          div.style.width = '100%';
+          div.style.padding = '1rem';
+          div.style.background = '#fee2e2';
+          div.style.color = '#991b1b';
+          div.style.borderBottom = '1px solid #ef4444';
+          div.style.zIndex = '999999';
+          div.style.fontFamily = 'monospace';
+          div.innerText = "[Abret] Build Error in ${sourceFile.split("/").pop()}: " + ${JSON.stringify(errorMessage)};
+          document.body.appendChild(div);
+        }`, { headers: { "Content-Type": "application/javascript" } });
+      }
+    }
+    return next();
+  });
+};
+export {
+  transpiler
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abret",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Fast, type-safe web framework for Bun with built-in JSX and middleware support.",
   "license": "MIT",
   "author": "Arisris",
@@ -52,6 +52,10 @@
     "./middleware/static": {
       "types": "./dist/middleware/static/index.d.ts",
       "import": "./dist/middleware/static/index.js"
+    },
+    "./middleware/transpiler": {
+      "types": "./dist/middleware/transpiler/index.d.ts",
+      "import": "./dist/middleware/transpiler/index.js"
     }
   },
   "scripts": {
@@ -63,7 +67,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.12",
+    "@preact/signals": "^2.6.2",
     "@types/bun": "latest",
+    "preact": "^10.28.3",
     "typescript": "^5"
   }
 }