@lolyjs/core 0.2.0-alpha.20 → 0.2.0-alpha.22

package/dist/index.js

@@ -9871,7 +9871,7 @@ var require_built3 = __commonJS({
 });
 
 // src/server.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path23 from "path";
 
 // modules/server/utils/server-dir.ts
@@ -9913,6 +9913,7 @@ async function runInitIfExists(projectRoot, serverData) {
 // modules/server/setup.ts
 import express from "express";
 import path17 from "path";
+import fs15 from "fs";
 
 // modules/router/loader-pages.ts
 import fs4 from "fs";
@@ -14003,8 +14004,22 @@ function getStaticDir(projectRoot, config) {
 }
 
 // modules/server/setup.ts
+function setupStaticFiles(app, projectRoot, config) {
+  if (!config) return;
+  const staticDir = getStaticDir(projectRoot, config);
+  if (fs15.existsSync(staticDir)) {
+    app.use(
+      express.static(staticDir, {
+        // In production, add caching headers for better performance
+        maxAge: process.env.NODE_ENV === "production" ? "1y" : 0,
+        immutable: process.env.NODE_ENV === "production"
+      })
+    );
+  }
+}
 function setupServer(app, options) {
   const { projectRoot, appDir, isDev, config } = options;
+  setupStaticFiles(app, projectRoot, config);
   const routeLoader = isDev ? new FilesystemRouteLoader(appDir, projectRoot) : new ManifestRouteLoader(projectRoot);
   if (isDev) {
     let getRoutes2 = function() {
@@ -15108,7 +15123,7 @@ function handleNotFound(res, urlPath) {
 }
 
 // modules/server/handlers/ssg.ts
-import fs15 from "fs";
+import fs16 from "fs";
 import path20 from "path";
 var logger3 = createModuleLogger("ssg");
 function getSsgDirForPath(baseDir, urlPath) {
@@ -15125,7 +15140,7 @@ function getSsgDataPath(baseDir, urlPath) {
 }
 function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   const ssgHtmlPath = getSsgHtmlPath(ssgOutDir, urlPath);
-  if (!fs15.existsSync(ssgHtmlPath)) {
+  if (!fs16.existsSync(ssgHtmlPath)) {
     return false;
   }
   logger3.info("Serving SSG HTML", { urlPath, ssgHtmlPath });
@@ -15135,17 +15150,17 @@ function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   );
   res.statusCode = 200;
   res.setHeader("Content-Type", "text/html; charset=utf-8");
-  const stream = fs15.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
+  const stream = fs16.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
   stream.pipe(res);
   return true;
 }
 function tryServeSsgData(res, ssgOutDir, urlPath) {
   const ssgDataPath = getSsgDataPath(ssgOutDir, urlPath);
-  if (!fs15.existsSync(ssgDataPath)) {
+  if (!fs16.existsSync(ssgDataPath)) {
     return false;
   }
   try {
-    const raw = fs15.readFileSync(ssgDataPath, "utf-8");
+    const raw = fs16.readFileSync(ssgDataPath, "utf-8");
     res.setHeader("Content-Type", "application/json; charset=utf-8");
     res.status(200).end(raw);
     return true;
@@ -17161,7 +17176,7 @@ var setupApplication = async ({
 // src/server.ts
 import dotenv2 from "dotenv";
 var envPath = path23.join(process.cwd(), ".env");
-if (fs16.existsSync(envPath)) {
+if (fs17.existsSync(envPath)) {
   dotenv2.config({ path: envPath });
 } else {
   dotenv2.config();
@@ -17183,7 +17198,7 @@ async function startServer(options = {}) {
   const port = options.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : void 0) ?? config.server.port;
   const host = process.env.HOST ?? (!isDev ? "0.0.0.0" : void 0) ?? config.server.host;
   const appDir = options.appDir ?? (isDev ? getAppDir(projectRoot, config) : path23.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !fs16.existsSync(appDir)) {
+  if (!isDev && !fs17.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,
@@ -17290,7 +17305,7 @@ function pathToOutDir(baseDir, urlPath) {
 }
 
 // modules/build/ssg/renderer.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path25 from "path";
 import { renderToString } from "react-dom/server";
 init_globals();
@@ -17414,8 +17429,8 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params)
   ensureDir(dir);
   const htmlFile = path25.join(dir, "index.html");
   const dataFile = path25.join(dir, "data.json");
-  fs17.writeFileSync(htmlFile, html, "utf-8");
-  fs17.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
+  fs18.writeFileSync(htmlFile, html, "utf-8");
+  fs18.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
 }
 
 // modules/build/ssg/builder.ts
@@ -17477,14 +17492,113 @@ async function buildStaticPages(projectRoot, routes) {
 
 // modules/build/bundler/server.ts
 import path27 from "path";
-import fs18 from "fs";
+import fs19 from "fs";
 import esbuild from "esbuild";
 init_globals();
 var SERVER_FILES = [INIT_FILE_NAME, CONFIG_FILE_NAME];
+function createPathAliasPlugin(projectRoot, outDir) {
+  const aliases = loadAliasesFromTsconfig(projectRoot);
+  const tsconfigPath = path27.join(projectRoot, "tsconfig.json");
+  let baseUrl = ".";
+  if (fs19.existsSync(tsconfigPath)) {
+    try {
+      const tsconfig = JSON.parse(fs19.readFileSync(tsconfigPath, "utf-8"));
+      baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+    } catch {
+    }
+  }
+  function resolveAliasToRelative(importPath, sourceFile) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || path27.isAbsolute(importPath) || importPath.includes("node_modules")) {
+      return null;
+    }
+    for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
+      if (importPath.startsWith(aliasKey + "/") || importPath === aliasKey) {
+        const restPath = importPath.startsWith(aliasKey + "/") ? importPath.slice(aliasKey.length + 1) : "";
+        const resolvedPath = restPath ? path27.join(aliasPath, restPath) : aliasPath;
+        let actualPath = null;
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+        if (fs19.existsSync(resolvedPath) && fs19.statSync(resolvedPath).isDirectory()) {
+          for (const ext of extensions) {
+            const indexPath = path27.join(resolvedPath, `index${ext}`);
+            if (fs19.existsSync(indexPath)) {
+              actualPath = indexPath;
+              break;
+            }
+          }
+        } else {
+          for (const ext of extensions) {
+            const filePath = resolvedPath + ext;
+            if (fs19.existsSync(filePath)) {
+              actualPath = filePath;
+              break;
+            }
+          }
+          if (!actualPath && fs19.existsSync(resolvedPath)) {
+            actualPath = resolvedPath;
+          }
+        }
+        if (actualPath) {
+          const relativePath = path27.relative(outDir, actualPath);
+          const normalizedPath = relativePath.replace(/\\/g, "/");
+          const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+          const ext = path27.extname(finalPath);
+          const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
+          return pathWithoutExt;
+        }
+      }
+    }
+    return null;
+  }
+  return {
+    name: "path-alias-resolver",
+    setup(build) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
+        const fileName = path27.basename(args.path);
+        const isServerFile = SERVER_FILES.some((f) => fileName === `${f}.ts` || fileName === `${f}.tsx` || fileName === `${f}.js` || fileName === `${f}.jsx`);
+        const isInProjectRoot = path27.dirname(args.path) === projectRoot;
+        if (!isServerFile || !isInProjectRoot) {
+          return null;
+        }
+        const contents = fs19.readFileSync(args.path, "utf-8");
+        let transformed = contents;
+        const aliasPatterns = Object.keys(aliases).sort((a, b) => b.length - a.length);
+        for (const aliasKey of aliasPatterns) {
+          const escapedAlias = aliasKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const aliasInQuotesPattern = new RegExp(
+            `(['"\`])${escapedAlias}(/[^'"\`\\s]*)?(['"\`])`,
+            "g"
+          );
+          transformed = transformed.replace(aliasInQuotesPattern, (match, quote1, rest, quote2) => {
+            const fullPath = aliasKey + (rest || "");
+            const resolved = resolveAliasToRelative(fullPath, args.path);
+            if (resolved) {
+              return `${quote1}${resolved}${quote2}`;
+            }
+            return match;
+          });
+        }
+        return {
+          contents: transformed,
+          loader: path27.extname(args.path).slice(1)
+        };
+      });
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const resolved = resolveAliasToRelative(args.path, args.importer || "");
+        if (resolved) {
+          return {
+            path: resolved,
+            namespace: "file"
+          };
+        }
+        return null;
+      });
+    }
+  };
+}
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
-    const items = fs18.readdirSync(dir, { withFileTypes: true });
+    const items = fs19.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
       const full = path27.join(dir, item.name);
       if (item.isDirectory()) {
@@ -17524,10 +17638,11 @@ async function buildServerApp(projectRoot, appDir) {
     tsconfig: path27.join(projectRoot, "tsconfig.json"),
     packages: "external"
   });
+  const pathAliasPlugin = createPathAliasPlugin(projectRoot, outDir);
   for (const fileName of SERVER_FILES) {
     const initTS = path27.join(projectRoot, `${fileName}.ts`);
     const initJS = path27.join(outDir, `${fileName}.js`);
-    if (fs18.existsSync(initTS)) {
+    if (fs19.existsSync(initTS)) {
       await esbuild.build({
         entryPoints: [initTS],
         outfile: initJS,
@@ -17538,7 +17653,8 @@ async function buildServerApp(projectRoot, appDir) {
         sourcemap: true,
         bundle: false,
         logLevel: "info",
-        tsconfig: path27.join(projectRoot, "tsconfig.json")
+        tsconfig: path27.join(projectRoot, "tsconfig.json"),
+        plugins: [pathAliasPlugin]
       });
     }
   }