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

package/README.md

@@ -392,6 +392,64 @@ export default function Dashboard() {
 }
 ```
 
+### 📄 Static Files & Assets
+
+Loly serves static files from the `public/` directory at the root of your application. This is perfect for SEO files like `sitemap.xml`, `robots.txt`, favicons, and other static assets.
+
+**How it works:**
+- Files in `public/` are served at the root URL (e.g., `public/sitemap.xml` → `/sitemap.xml`)
+- Static files have **priority over dynamic routes** - if a file exists in `public/`, it will be served instead of matching a route
+- Perfect for SEO: Google automatically finds `sitemap.xml` and `robots.txt` at the root
+- Works in both development and production environments
+- Subdirectories are supported: `public/assets/logo.png` → `/assets/logo.png`
+
+**Directory Structure:**
+```
+public/
+├── sitemap.xml      # Available at /sitemap.xml
+├── robots.txt       # Available at /robots.txt
+├── favicon.ico      # Available at /favicon.ico
+└── assets/
+    ├── logo.png     # Available at /assets/logo.png
+    └── images/      # Available at /assets/images/*
+        └── hero.jpg
+```
+
+**SEO Example:**
+
+Create `public/sitemap.xml`:
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <url>
+    <loc>https://example.com/</loc>
+    <lastmod>2024-01-01</lastmod>
+    <changefreq>daily</changefreq>
+    <priority>1.0</priority>
+  </url>
+</urlset>
+```
+
+Create `public/robots.txt`:
+```
+User-agent: *
+Allow: /
+
+Sitemap: https://example.com/sitemap.xml
+```
+
+Both files will be automatically available at `/sitemap.xml` and `/robots.txt` respectively, and search engines will find them at the standard locations.
+
+**Configuration:**
+The static directory can be customized in `loly.config.ts`:
+```tsx
+export default {
+  directories: {
+    static: "public",  // Default: "public"
+  },
+} satisfies FrameworkConfig;
+```
+
 ### 🔌 API Routes
 
 Create RESTful APIs with flexible middleware support:
@@ -667,7 +725,7 @@ your-app/
 │           └── events.ts       # WebSocket namespace /chat
 ├── components/                 # React components
 ├── lib/                        # Utilities
-├── public/                     # Static files
+├── public/                     # Static files (served at root: /sitemap.xml, /robots.txt, etc.)
 ├── loly.config.ts              # Framework configuration
 ├── init.server.ts              # Server initialization (DB, services, etc.)
 └── package.json

package/dist/cli.cjs

@@ -13743,6 +13743,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 = import_path25.default.join(projectRoot, "tsconfig.json");
+  let baseUrl = ".";
+  if (import_fs16.default.existsSync(tsconfigPath)) {
+    try {
+      const tsconfig = JSON.parse(import_fs16.default.readFileSync(tsconfigPath, "utf-8"));
+      baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+    } catch {
+    }
+  }
+  function resolveAliasToRelative(importPath, sourceFile) {
+    if (importPath.startsWith(".") || importPath.startsWith("/") || import_path25.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_path25.default.join(aliasPath, restPath) : aliasPath;
+        let actualPath = null;
+        const extensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
+        if (import_fs16.default.existsSync(resolvedPath) && import_fs16.default.statSync(resolvedPath).isDirectory()) {
+          for (const ext of extensions) {
+            const indexPath = import_path25.default.join(resolvedPath, `index${ext}`);
+            if (import_fs16.default.existsSync(indexPath)) {
+              actualPath = indexPath;
+              break;
+            }
+          }
+        } else {
+          for (const ext of extensions) {
+            const filePath = resolvedPath + ext;
+            if (import_fs16.default.existsSync(filePath)) {
+              actualPath = filePath;
+              break;
+            }
+          }
+          if (!actualPath && import_fs16.default.existsSync(resolvedPath)) {
+            actualPath = resolvedPath;
+          }
+        }
+        if (actualPath) {
+          const relativePath = import_path25.default.relative(outDir, actualPath);
+          const normalizedPath = relativePath.replace(/\\/g, "/");
+          const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
+          const ext = import_path25.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.onLoad({ filter: /\.(ts|tsx|js|jsx)$/ }, (args) => {
+        const fileName = import_path25.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_path25.default.dirname(args.path) === projectRoot;
+        if (!isServerFile || !isInProjectRoot) {
+          return null;
+        }
+        const contents = import_fs16.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_path25.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;
+      });
+    }
+  };
+}
 function collectAppSources(appDir) {
   const entries = [];
   function walk(dir) {
@@ -13786,6 +13885,7 @@ async function buildServerApp(projectRoot, appDir) {
     tsconfig: import_path25.default.join(projectRoot, "tsconfig.json"),
     packages: "external"
   });
+  const pathAliasPlugin = createPathAliasPlugin(projectRoot, outDir);
   for (const fileName of SERVER_FILES) {
     const initTS = import_path25.default.join(projectRoot, `${fileName}.ts`);
     const initJS = import_path25.default.join(outDir, `${fileName}.js`);
@@ -13800,7 +13900,8 @@ async function buildServerApp(projectRoot, appDir) {
         sourcemap: true,
         bundle: false,
         logLevel: "info",
-        tsconfig: import_path25.default.join(projectRoot, "tsconfig.json")
+        tsconfig: import_path25.default.join(projectRoot, "tsconfig.json"),
+        plugins: [pathAliasPlugin]
       });
     }
   }
@@ -14037,6 +14138,9 @@ function getAppDir(projectRoot, config) {
 function getBuildDir(projectRoot, config) {
   return import_path26.default.join(projectRoot, config.directories.build);
 }
+function getStaticDir(projectRoot, config) {
+  return import_path26.default.resolve(projectRoot, config.directories.static);
+}
 
 // modules/build/index.ts
 async function buildApp(options = {}) {
@@ -14087,12 +14191,13 @@ async function buildApp(options = {}) {
 }
 
 // src/server.ts
-var import_fs20 = __toESM(require("fs"));
+var import_fs21 = __toESM(require("fs"));
 var import_path31 = __toESM(require("path"));
 
 // modules/server/setup.ts
 var import_express = __toESM(require("express"));
 var import_path29 = __toESM(require("path"));
+var import_fs20 = __toESM(require("fs"));
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 var import_fs19 = require("fs");
@@ -15934,8 +16039,22 @@ function clearAppRequireCache(appDir) {
 
 // modules/server/setup.ts
 init_globals();
+function setupStaticFiles(app, projectRoot, config) {
+  if (!config) return;
+  const staticDir = getStaticDir(projectRoot, config);
+  if (import_fs20.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() {
@@ -17498,7 +17617,7 @@ var setupApplication = async ({
 // src/server.ts
 var import_dotenv2 = __toESM(require("dotenv"));
 var envPath = import_path31.default.join(process.cwd(), ".env");
-if (import_fs20.default.existsSync(envPath)) {
+if (import_fs21.default.existsSync(envPath)) {
   import_dotenv2.default.config({ path: envPath });
 } else {
   import_dotenv2.default.config();
@@ -17520,7 +17639,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_path31.default.join(getBuildDir(projectRoot, config), "server"));
-  if (!isDev && !import_fs20.default.existsSync(appDir)) {
+  if (!isDev && !import_fs21.default.existsSync(appDir)) {
     logger4.error("Compiled directory not found", void 0, {
       buildDir: config.directories.build,
       appDir,