abret 0.1.3 → 0.1.4

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

@@ -7,15 +7,22 @@ interface TranspilerOptions {
     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).
- *
- * Usage:
- * ```ts
- * transpiler({ sourcePath: "./src", staticBasePath: "/_modules" })
- * ```
  */
 export declare const transpiler: (options: TranspilerOptions) => import("../..").Middleware<string, undefined>;
 export {};

package/dist/middleware/transpiler/index.js

@@ -5,14 +5,20 @@ import {
 import"../../chunk-xw5b0251.js";
 
 // src/middleware/transpiler/index.ts
-import { existsSync, mkdirSync } from "fs";
+import { existsSync, mkdirSync, statSync } from "fs";
 import path from "path";
 var transpiler = (options) => {
   const {
     sourcePath,
     staticBasePath,
     vendorPath = "vendor",
-    prewarm = []
+    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}/`;
@@ -20,52 +26,109 @@ var transpiler = (options) => {
   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;
-    try {
-      const entryPoint = Bun.resolveSync(moduleName, process.cwd());
-      const result = await Bun.build({
-        entrypoints: [entryPoint],
-        target: "browser",
-        format: "esm",
-        minify: true,
-        plugins: [
-          {
-            name: "abret-external-vendor",
-            setup(build) {
-              build.onResolve({ filter: /^[^./]/ }, (args) => {
-                if (args.path === moduleName)
-                  return null;
-                return { path: args.path, external: true };
-              });
+    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"
+              };
+            });
           }
-        ]
-      });
-      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}${basePrefix}${vendorPath.replace(/^\/|\/$/g, "")}/${path2}${suffix}`;
+        };
+        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;
         }
-        return match;
-      });
-      await Bun.write(cachedFile, content);
-      console.log(`[Abret] Pre-bundled: ${moduleName}`);
-    } catch (err) {
-      console.error(`[Abret] Error bundling ${moduleName}:`, err);
-    }
+        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) {
@@ -102,51 +165,129 @@ var transpiler = (options) => {
       return next();
     }
     const internalPath = pathname.slice(basePrefix.length);
-    const baseFileName = internalPath.endsWith(".js") ? internalPath.slice(0, -3) : internalPath;
-    const possibleExtensions = [".tsx", ".ts", ".jsx", ".js"];
+    const extname = path.extname(internalPath);
     let sourceFile = "";
-    for (const ext of possibleExtensions) {
-      const p = path.join(path.resolve(sourcePath), (baseFileName.startsWith("/") ? baseFileName.slice(1) : baseFileName) + ext);
+    let contentType = "application/javascript";
+    if (extname === ".css") {
+      const p = path.join(path.resolve(sourcePath), internalPath);
       if (existsSync(p)) {
         sourceFile = p;
-        break;
+        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) {
-      try {
-        const buildResult = await Bun.build({
-          entrypoints: [sourceFile],
-          target: "browser",
-          format: "esm",
-          external: ["*"]
+      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"
+          }
         });
-        if (!buildResult.success || buildResult.outputs.length === 0) {
-          console.error(`[Abret] Build error for ${sourceFile}:`, buildResult.logs);
-          return next();
-        }
-        const output = buildResult.outputs[0];
-        if (!output) {
-          console.error(`[Abret] No output files generated for ${sourceFile}`);
-          return next();
-        }
-        const transpiledCode = await output.text();
-        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}${basePrefix}${vendorPath.replace(/^\/|\/$/g, "")}/${path2}${suffix}`;
+      }
+      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(", ")}`);
           }
-          if (path2.startsWith(".") && !path2.split("/").pop()?.includes(".")) {
-            return `${prefix}${path2}.js${suffix}`;
+          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"
           }
-          return match;
-        });
-        return new Response(finalCode, {
-          headers: { "Content-Type": "application/javascript" }
         });
       } catch (err) {
-        console.error(`[Abret] Transpilation error for ${sourceFile}:`, err);
-        return next();
+        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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abret",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Fast, type-safe web framework for Bun with built-in JSX and middleware support.",
   "license": "MIT",
   "author": "Arisris",