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

package/dist/cli.js

@@ -13759,51 +13759,88 @@ function createPathAliasPlugin(projectRoot, outDir) {
     } catch {
     }
   }
+  function resolveAliasToRelative(importPath, sourceFile) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || path21.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 ? path21.join(aliasPath, restPath) : aliasPath;
+        let actualPath = null;
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+        if (fs16.existsSync(resolvedPath) && fs16.statSync(resolvedPath).isDirectory()) {
+          for (const ext of extensions) {
+            const indexPath = path21.join(resolvedPath, `index${ext}`);
+            if (fs16.existsSync(indexPath)) {
+              actualPath = indexPath;
+              break;
+            }
+          }
+        } else {
+          for (const ext of extensions) {
+            const filePath = resolvedPath + ext;
+            if (fs16.existsSync(filePath)) {
+              actualPath = filePath;
+              break;
+            }
+          }
+          if (!actualPath && fs16.existsSync(resolvedPath)) {
+            actualPath = resolvedPath;
+          }
+        }
+        if (actualPath) {
+          const relativePath = path21.relative(outDir, actualPath);
+          const normalizedPath = relativePath.replace(/\\/g, "/");
+          const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+          const ext = path21.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("/") || path21.isAbsolute(args.path) || args.path.includes("node_modules")) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
+        const fileName = path21.basename(args.path);
+        const isServerFile = SERVER_FILES.some((f) => fileName === `${f}.ts` || fileName === `${f}.tsx` || fileName === `${f}.js` || fileName === `${f}.jsx`);
+        const isInProjectRoot = path21.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 ? path21.join(aliasPath, restPath) : aliasPath;
-            let actualPath = null;
-            const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
-            if (fs16.existsSync(resolvedPath) && fs16.statSync(resolvedPath).isDirectory()) {
-              for (const ext of extensions) {
-                const indexPath = path21.join(resolvedPath, `index${ext}`);
-                if (fs16.existsSync(indexPath)) {
-                  actualPath = indexPath;
-                  break;
-                }
-              }
-            } else {
-              for (const ext of extensions) {
-                const filePath = resolvedPath + ext;
-                if (fs16.existsSync(filePath)) {
-                  actualPath = filePath;
-                  break;
-                }
-              }
-              if (!actualPath && fs16.existsSync(resolvedPath)) {
-                actualPath = resolvedPath;
-              }
-            }
-            if (actualPath) {
-              const relativePath = path21.relative(outDir, actualPath);
-              const normalizedPath = relativePath.replace(/\\/g, "/");
-              const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
-              const ext = path21.extname(finalPath);
-              const pathWithoutExt = ext === ".json" ? finalPath : finalPath.slice(0, -ext.length);
-              return {
-                path: pathWithoutExt,
-                namespace: "file"
-              };
+        const contents = fs16.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: path21.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;
       });
@@ -14106,6 +14143,9 @@ function getAppDir(projectRoot, config) {
 function getBuildDir(projectRoot, config) {
   return path22.join(projectRoot, config.directories.build);
 }
+function getStaticDir(projectRoot, config) {
+  return path22.resolve(projectRoot, config.directories.static);
+}
 
 // modules/build/index.ts
 async function buildApp(options = {}) {
@@ -14156,12 +14196,13 @@ async function buildApp(options = {}) {
 }
 
 // src/server.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path27 from "path";
 
 // modules/server/setup.ts
 import express from "express";
 import path25 from "path";
+import fs18 from "fs";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -16003,8 +16044,22 @@ function clearAppRequireCache(appDir) {
 
 // modules/server/setup.ts
 init_globals();
+function setupStaticFiles(app, projectRoot, config) {
+  if (!config) return;
+  const staticDir = getStaticDir(projectRoot, config);
+  if (fs18.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() {
@@ -17567,7 +17622,7 @@ var setupApplication = async ({
 // src/server.ts
 import dotenv2 from "dotenv";
 var envPath = path27.join(process.cwd(), ".env");
-if (fs18.existsSync(envPath)) {
+if (fs19.existsSync(envPath)) {
   dotenv2.config({ path: envPath });
 } else {
   dotenv2.config();
@@ -17589,7 +17644,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) : path27.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !fs18.existsSync(appDir)) {
+  if (!isDev && !fs19.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,