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

package/dist/cli.js

@@ -13748,6 +13748,105 @@ function validateRealtimeConfig(config) {
 // modules/build/bundler/server.ts
 init_globals();
 var SERVER_FILES = [INIT_FILE_NAME, CONFIG_FILE_NAME];
+function createPathAliasPlugin(projectRoot, outDir) {
+  const aliases = loadAliasesFromTsconfig(projectRoot);
+  const tsconfigPath = path21.join(projectRoot, "tsconfig.json");
+  let baseUrl = ".";
+  if (fs16.existsSync(tsconfigPath)) {
+    try {
+      const tsconfig = JSON.parse(fs16.readFileSync(tsconfigPath, "utf-8"));
+      baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+    } 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.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;
+        }
+        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;
+      });
+    }
+  };
+}
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
@@ -13791,6 +13890,7 @@ async function buildServerApp(projectRoot, appDir) {
     tsconfig: path21.join(projectRoot, "tsconfig.json"),
     packages: "external"
   });
+  const pathAliasPlugin = createPathAliasPlugin(projectRoot, outDir);
   for (const fileName of SERVER_FILES) {
     const initTS = path21.join(projectRoot, `${fileName}.ts`);
     const initJS = path21.join(outDir, `${fileName}.js`);
@@ -13805,7 +13905,8 @@ async function buildServerApp(projectRoot, appDir) {
         sourcemap: true,
         bundle: false,
         logLevel: "info",
-        tsconfig: path21.join(projectRoot, "tsconfig.json")
+        tsconfig: path21.join(projectRoot, "tsconfig.json"),
+        plugins: [pathAliasPlugin]
       });
     }
   }
@@ -14042,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 = {}) {
@@ -14092,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";
@@ -15939,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() {
@@ -17503,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();
@@ -17525,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,