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

package/dist/index.cjs

@@ -9904,7 +9904,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/server.ts
-var import_fs18 = __toESM(require("fs"));
+var import_fs19 = __toESM(require("fs"));
 var import_path25 = __toESM(require("path"));
 
 // modules/server/utils/server-dir.ts
@@ -9946,6 +9946,7 @@ async function runInitIfExists(projectRoot, serverData) {
 // modules/server/setup.ts
 var import_express = __toESM(require("express"));
 var import_path19 = __toESM(require("path"));
+var import_fs17 = __toESM(require("fs"));
 
 // modules/router/loader-pages.ts
 var import_fs4 = __toESM(require("fs"));
@@ -14036,8 +14037,22 @@ function getStaticDir(projectRoot, config) {
 }
 
 // modules/server/setup.ts
+function setupStaticFiles(app, projectRoot, config) {
+  if (!config) return;
+  const staticDir = getStaticDir(projectRoot, config);
+  if (import_fs17.default.existsSync(staticDir)) {
+    app.use(
+      import_express.default.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() {
@@ -15141,7 +15156,7 @@ function handleNotFound(res, urlPath) {
 }
 
 // modules/server/handlers/ssg.ts
-var import_fs17 = __toESM(require("fs"));
+var import_fs18 = __toESM(require("fs"));
 var import_path22 = __toESM(require("path"));
 var logger3 = createModuleLogger("ssg");
 function getSsgDirForPath(baseDir, urlPath) {
@@ -15158,7 +15173,7 @@ function getSsgDataPath(baseDir, urlPath) {
 }
 function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   const ssgHtmlPath = getSsgHtmlPath(ssgOutDir, urlPath);
-  if (!import_fs17.default.existsSync(ssgHtmlPath)) {
+  if (!import_fs18.default.existsSync(ssgHtmlPath)) {
     return false;
   }
   logger3.info("Serving SSG HTML", { urlPath, ssgHtmlPath });
@@ -15168,17 +15183,17 @@ function tryServeSsgHtml(res, ssgOutDir, urlPath) {
   );
   res.statusCode = 200;
   res.setHeader("Content-Type", "text/html; charset=utf-8");
-  const stream = import_fs17.default.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
+  const stream = import_fs18.default.createReadStream(ssgHtmlPath, { encoding: "utf-8" });
   stream.pipe(res);
   return true;
 }
 function tryServeSsgData(res, ssgOutDir, urlPath) {
   const ssgDataPath = getSsgDataPath(ssgOutDir, urlPath);
-  if (!import_fs17.default.existsSync(ssgDataPath)) {
+  if (!import_fs18.default.existsSync(ssgDataPath)) {
     return false;
   }
   try {
-    const raw = import_fs17.default.readFileSync(ssgDataPath, "utf-8");
+    const raw = import_fs18.default.readFileSync(ssgDataPath, "utf-8");
     res.setHeader("Content-Type", "application/json; charset=utf-8");
     res.status(200).end(raw);
     return true;
@@ -17194,7 +17209,7 @@ var setupApplication = async ({
 // src/server.ts
 var import_dotenv2 = __toESM(require("dotenv"));
 var envPath = import_path25.default.join(process.cwd(), ".env");
-if (import_fs18.default.existsSync(envPath)) {
+if (import_fs19.default.existsSync(envPath)) {
   import_dotenv2.default.config({ path: envPath });
 } else {
   import_dotenv2.default.config();
@@ -17216,7 +17231,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) : import_path25.default.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !import_fs18.default.existsSync(appDir)) {
+  if (!isDev && !import_fs19.default.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,
@@ -17323,7 +17338,7 @@ function pathToOutDir(baseDir, urlPath) {
 }
 
 // modules/build/ssg/renderer.ts
-var import_fs19 = __toESM(require("fs"));
+var import_fs20 = __toESM(require("fs"));
 var import_path27 = __toESM(require("path"));
 var import_server3 = require("react-dom/server");
 init_globals();
@@ -17447,8 +17462,8 @@ async function renderStaticRoute(projectRoot, ssgOutDir, route, urlPath, params)
   ensureDir(dir);
   const htmlFile = import_path27.default.join(dir, "index.html");
   const dataFile = import_path27.default.join(dir, "data.json");
-  import_fs19.default.writeFileSync(htmlFile, html, "utf-8");
-  import_fs19.default.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
+  import_fs20.default.writeFileSync(htmlFile, html, "utf-8");
+  import_fs20.default.writeFileSync(dataFile, JSON.stringify(initialData, null, 2), "utf-8");
 }
 
 // modules/build/ssg/builder.ts
@@ -17510,7 +17525,7 @@ async function buildStaticPages(projectRoot, routes) {
 
 // modules/build/bundler/server.ts
 var import_path31 = __toESM(require("path"));
-var import_fs20 = __toESM(require("fs"));
+var import_fs21 = __toESM(require("fs"));
 var import_esbuild = __toESM(require("esbuild"));
 init_globals();
 var SERVER_FILES = [INIT_FILE_NAME, CONFIG_FILE_NAME];
@@ -17518,58 +17533,95 @@ function createPathAliasPlugin(projectRoot, outDir) {
   const aliases = loadAliasesFromTsconfig(projectRoot);
   const tsconfigPath = import_path31.default.join(projectRoot, "tsconfig.json");
   let baseUrl = ".";
-  if (import_fs20.default.existsSync(tsconfigPath)) {
+  if (import_fs21.default.existsSync(tsconfigPath)) {
     try {
-      const tsconfig = JSON.parse(import_fs20.default.readFileSync(tsconfigPath, "utf-8"));
+      const tsconfig = JSON.parse(import_fs21.default.readFileSync(tsconfigPath, "utf-8"));
       baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
     } catch {
     }
   }
+  function resolveAliasToRelative(importPath, sourceFile) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path31.default.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 ? import_path31.default.join(aliasPath, restPath) : aliasPath;
+        let actualPath = null;
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+        if (import_fs21.default.existsSync(resolvedPath) && import_fs21.default.statSync(resolvedPath).isDirectory()) {
+          for (const ext of extensions) {
+            const indexPath = import_path31.default.join(resolvedPath, `index${ext}`);
+            if (import_fs21.default.existsSync(indexPath)) {
+              actualPath = indexPath;
+              break;
+            }
+          }
+        } else {
+          for (const ext of extensions) {
+            const filePath = resolvedPath + ext;
+            if (import_fs21.default.existsSync(filePath)) {
+              actualPath = filePath;
+              break;
+            }
+          }
+          if (!actualPath && import_fs21.default.existsSync(resolvedPath)) {
+            actualPath = resolvedPath;
+          }
+        }
+        if (actualPath) {
+          const relativePath = import_path31.default.relative(outDir, actualPath);
+          const normalizedPath = relativePath.replace(/\\/g, "/");
+          const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+          const ext = import_path31.default.extname(finalPath);
+          const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
+          return pathWithoutExt;
+        }
+      }
+    }
+    return null;
+  }
   return {
     name: "path-alias-resolver",
     setup(build) {
-      build.onResolve({ filter: /.*/ }, (args) => {
-        if (args.path.startsWith(".") || args.path.startsWith("/") || import_path31.default.isAbsolute(args.path) || args.path.includes("node_modules")) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
+        const fileName = import_path31.default.basename(args.path);
+        const isServerFile = SERVER_FILES.some((f) => fileName === `${f}.ts` || fileName === `${f}.tsx` || fileName === `${f}.js` || fileName === `${f}.jsx`);
+        const isInProjectRoot = import_path31.default.dirname(args.path) === projectRoot;
+        if (!isServerFile || !isInProjectRoot) {
           return null;
         }
-        for (const [aliasKey, aliasPath] of Object.entries(aliases)) {
-          if (args.path.startsWith(aliasKey + "/") || args.path === aliasKey) {
-            const restPath = args.path.startsWith(aliasKey + "/") ? args.path.slice(aliasKey.length + 1) : "";
-            const resolvedPath = restPath ? import_path31.default.join(aliasPath, restPath) : aliasPath;
-            let actualPath = null;
-            const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-            if (import_fs20.default.existsSync(resolvedPath) && import_fs20.default.statSync(resolvedPath).isDirectory()) {
-              for (const ext of extensions) {
-                const indexPath = import_path31.default.join(resolvedPath, `index${ext}`);
-                if (import_fs20.default.existsSync(indexPath)) {
-                  actualPath = indexPath;
-                  break;
-                }
-              }
-            } else {
-              for (const ext of extensions) {
-                const filePath = resolvedPath + ext;
-                if (import_fs20.default.existsSync(filePath)) {
-                  actualPath = filePath;
-                  break;
-                }
-              }
-              if (!actualPath && import_fs20.default.existsSync(resolvedPath)) {
-                actualPath = resolvedPath;
-              }
-            }
-            if (actualPath) {
-              const relativePath = import_path31.default.relative(outDir, actualPath);
-              const normalizedPath = relativePath.replace(/\\/g, "/");
-              const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-              const ext = import_path31.default.extname(finalPath);
-              const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
-              return {
-                path: pathWithoutExt,
-                namespace: "file"
-              };
+        const contents = import_fs21.default.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: import_path31.default.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;
       });
@@ -17579,7 +17631,7 @@ function createPathAliasPlugin(projectRoot, outDir) {
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
-    const items = import_fs20.default.readdirSync(dir, { withFileTypes: true });
+    const items = import_fs21.default.readdirSync(dir, { withFileTypes: true });
     for (const item of items) {
       const full = import_path31.default.join(dir, item.name);
       if (item.isDirectory()) {
@@ -17623,7 +17675,7 @@ async function buildServerApp(projectRoot, appDir) {
   for (const fileName of SERVER_FILES) {
     const initTS = import_path31.default.join(projectRoot, `${fileName}.ts`);
     const initJS = import_path31.default.join(outDir, `${fileName}.js`);
-    if (import_fs20.default.existsSync(initTS)) {
+    if (import_fs21.default.existsSync(initTS)) {
       await import_esbuild.default.build({
         entryPoints: [initTS],
         outfile: initJS,