@ecopages/core 0.2.0-alpha.1

package/src/static-site-generator/static-site-generator.d.ts

@@ -0,0 +1,57 @@
+import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { StaticRoute } from '../public-types.js';
+import type { RouteRendererFactory } from '../route-renderer/route-renderer.js';
+import type { FSRouter } from '../router/fs-router.js';
+export declare const STATIC_SITE_GENERATOR_ERRORS: {
+    readonly ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy";
+    readonly unsupportedBodyType: (bodyType: string) => string;
+    readonly missingIntegration: (routePath: string) => string;
+    readonly noRendererForIntegration: (integrationName: string) => string;
+    readonly dynamicRouteRequiresStaticPaths: (routePath: string) => string;
+};
+export declare class StaticSiteGenerator {
+    appConfig: EcoPagesAppConfig;
+    constructor({ appConfig }: {
+        appConfig: EcoPagesAppConfig;
+    });
+    generateRobotsTxt(): void;
+    isRootDir(path: string): boolean | null;
+    getDirectories(routes: string[]): string[];
+    /**
+     * Extracts dynamic parameters from the actual path based on the template path.
+     *
+     * @param templatePath - The template path (e.g., "/blog/[slug]")
+     * @param actualPath - The actual path (e.g., "/blog/my-post")
+     * @returns A record of extracted parameters (e.g., { slug: "my-post" })
+     */
+    private extractParams;
+    generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory): Promise<void>;
+    run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
+        router: FSRouter;
+        baseUrl: string;
+        routeRendererFactory?: RouteRendererFactory;
+        staticRoutes?: StaticRoute[];
+    }): Promise<void>;
+    /**
+     * Generates static pages from explicit static routes registered via app.static().
+     * These routes use eco.page views via loader functions for HMR support.
+     */
+    private generateExplicitStaticPages;
+    /**
+     * Generate a single static page for a non-dynamic route.
+     */
+    private generateSingleStaticRoute;
+    /**
+     * Generate static pages for a dynamic route using staticPaths.
+     */
+    private generateDynamicStaticRoute;
+    /**
+     * Resolve a route path template with actual params.
+     * Supports both :param and [param] syntax.
+     */
+    private resolveRoutePath;
+    /**
+     * Get the output file path for a given route.
+     */
+    private getOutputPath;
+}

package/src/static-site-generator/static-site-generator.js

@@ -0,0 +1,272 @@
+import path from "node:path";
+import { appLogger } from "../global/app-logger.js";
+import { fileSystem } from "@ecopages/file-system";
+import { PathUtils } from "../utils/path-utils.module.js";
+const STATIC_SITE_GENERATOR_ERRORS = {
+  ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy",
+  unsupportedBodyType: (bodyType) => `Unsupported body type for static generation: ${bodyType}`,
+  missingIntegration: (routePath) => `View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page().`,
+  noRendererForIntegration: (integrationName) => `No renderer found for integration: ${integrationName}`,
+  dynamicRouteRequiresStaticPaths: (routePath) => `Dynamic route ${routePath} requires staticPaths to be defined on the view.`
+};
+class StaticSiteGenerator {
+  appConfig;
+  constructor({ appConfig }) {
+    this.appConfig = appConfig;
+  }
+  generateRobotsTxt() {
+    let data = "";
+    const preferences = this.appConfig.robotsTxt.preferences;
+    for (const userAgent in preferences) {
+      data += `user-agent: ${userAgent}
+`;
+      for (const path2 of preferences[userAgent]) {
+        data += `disallow: ${path2}
+`;
+      }
+      data += "\n";
+    }
+    fileSystem.ensureDir(this.appConfig.distDir);
+    fileSystem.write(`${this.appConfig.distDir}/robots.txt`, data);
+  }
+  isRootDir(path2) {
+    const slashes = path2.match(/\//g);
+    return slashes && slashes.length === 1;
+  }
+  getDirectories(routes) {
+    const directories = /* @__PURE__ */ new Set();
+    for (const route of routes) {
+      const path2 = route.startsWith("http") ? new URL(route).pathname : route;
+      const segments = path2.split("/");
+      if (segments.length > 2) {
+        directories.add(segments.slice(0, segments.length - 1).join("/"));
+      }
+    }
+    return Array.from(directories);
+  }
+  /**
+   * Extracts dynamic parameters from the actual path based on the template path.
+   *
+   * @param templatePath - The template path (e.g., "/blog/[slug]")
+   * @param actualPath - The actual path (e.g., "/blog/my-post")
+   * @returns A record of extracted parameters (e.g., { slug: "my-post" })
+   */
+  extractParams(templatePath, actualPath) {
+    const templateSegments = templateSegmentsFromPath(templatePath);
+    const actualSegments = templateSegmentsFromPath(actualPath);
+    const params = {};
+    for (let i = 0; i < templateSegments.length; i++) {
+      const segment = templateSegments[i];
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        const paramName = segment.slice(1, -1).replace("...", "");
+        params[paramName] = actualSegments[i];
+      }
+    }
+    return params;
+  }
+  async generateStaticPages(router, baseUrl, routeRendererFactory) {
+    const routes = Object.keys(router.routes).filter((route) => !route.includes("["));
+    appLogger.debug("Static Pages", routes);
+    const directories = this.getDirectories(routes);
+    for (const directory of directories) {
+      fileSystem.ensureDir(path.join(this.appConfig.rootDir, this.appConfig.distDir, directory));
+    }
+    for (const route of routes) {
+      try {
+        const { filePath, pathname: routePathname } = router.routes[route];
+        const ext = PathUtils.getEcoTemplateExtension(filePath);
+        const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
+        const strategy = integration?.staticBuildStep || "render";
+        let contents;
+        if (strategy === "fetch") {
+          const fetchUrl = route.startsWith("http") ? route : `${baseUrl}${route}`;
+          const response = await fetch(fetchUrl);
+          if (!response.ok) {
+            appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
+            continue;
+          }
+          contents = await response.text();
+        } else {
+          if (!routeRendererFactory) {
+            throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+          }
+          let pathname2 = routePathname;
+          const pathnameSegments2 = pathname2.split("/").filter(Boolean);
+          if (pathname2 === "/") {
+            pathname2 = "/index.html";
+          } else if (pathnameSegments2.join("/").includes("[")) {
+            pathname2 = `${route.replace(router.origin, "")}.html`;
+          } else if (pathnameSegments2.length >= 1 && directories.includes(`/${pathnameSegments2.join("/")}`)) {
+            pathname2 = `${pathname2.endsWith("/") ? pathname2 : `${pathname2}/`}index.html`;
+          } else {
+            pathname2 += ".html";
+          }
+          const renderer = routeRendererFactory.createRenderer(filePath);
+          const params = this.extractParams(routePathname, pathname2.replace(".html", ""));
+          const result = await renderer.createRoute({
+            file: filePath,
+            params
+          });
+          const body = result.body;
+          if (typeof body === "string" || Buffer.isBuffer(body)) {
+            contents = body;
+          } else if (body instanceof ReadableStream) {
+            contents = await new Response(body).text();
+          } else {
+            throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
+          }
+        }
+        let pathname = routePathname;
+        const pathnameSegments = pathname.split("/").filter(Boolean);
+        if (pathname === "/") {
+          pathname = "/index.html";
+        } else if (pathnameSegments.join("/").includes("[")) {
+          pathname = `${route.replace(router.origin, "")}.html`;
+        } else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join("/")}`)) {
+          pathname = `${pathname.endsWith("/") ? pathname : `${pathname}/`}index.html`;
+        } else {
+          pathname += ".html";
+        }
+        const outputPath = path.join(this.appConfig.rootDir, this.appConfig.distDir, pathname);
+        fileSystem.write(outputPath, contents);
+      } catch (error) {
+        appLogger.error(
+          `Error generating static page for ${route}:`,
+          error instanceof Error ? error : String(error)
+        );
+      }
+    }
+  }
+  async run({
+    router,
+    baseUrl,
+    routeRendererFactory,
+    staticRoutes
+  }) {
+    this.generateRobotsTxt();
+    await this.generateStaticPages(router, baseUrl, routeRendererFactory);
+    if (staticRoutes && staticRoutes.length > 0 && routeRendererFactory) {
+      await this.generateExplicitStaticPages(staticRoutes, routeRendererFactory);
+    }
+  }
+  /**
+   * Generates static pages from explicit static routes registered via app.static().
+   * These routes use eco.page views via loader functions for HMR support.
+   */
+  async generateExplicitStaticPages(staticRoutes, routeRendererFactory) {
+    appLogger.debug(
+      "Generating explicit static routes",
+      staticRoutes.map((r) => r.path)
+    );
+    for (const route of staticRoutes) {
+      try {
+        const mod = await route.loader();
+        const view = mod.default;
+        const isDynamic = route.path.includes(":") || route.path.includes("[");
+        if (isDynamic) {
+          await this.generateDynamicStaticRoute(route.path, view, routeRendererFactory);
+        } else {
+          await this.generateSingleStaticRoute(route.path, view, routeRendererFactory);
+        }
+      } catch (error) {
+        appLogger.error(
+          `Error generating explicit static page for ${route.path}:`,
+          error instanceof Error ? error : String(error)
+        );
+      }
+    }
+  }
+  /**
+   * Generate a single static page for a non-dynamic route.
+   */
+  async generateSingleStaticRoute(routePath, view, routeRendererFactory) {
+    const integrationName = view.config?.__eco?.integration;
+    if (!integrationName) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+    }
+    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+    if (!renderer) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+    }
+    const props = view.staticProps ? (await view.staticProps({
+      pathname: { params: {} },
+      appConfig: this.appConfig,
+      runtimeOrigin: this.appConfig.baseUrl
+    })).props : {};
+    const response = await renderer.renderToResponse(view, props, {});
+    const contents = await response.text();
+    const outputPath = this.getOutputPath(routePath);
+    fileSystem.ensureDir(path.dirname(outputPath));
+    fileSystem.write(outputPath, contents);
+    appLogger.debug(`Generated static page: ${routePath} -> ${outputPath}`);
+  }
+  /**
+   * Generate static pages for a dynamic route using staticPaths.
+   */
+  async generateDynamicStaticRoute(routePath, view, routeRendererFactory) {
+    if (!view.staticPaths) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
+    }
+    const integrationName = view.config?.__eco?.integration;
+    if (!integrationName) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+    }
+    const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+    if (!renderer) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+    }
+    const { paths } = await view.staticPaths({
+      appConfig: this.appConfig,
+      runtimeOrigin: this.appConfig.baseUrl
+    });
+    for (const { params } of paths) {
+      const resolvedPath = this.resolveRoutePath(routePath, params);
+      const props = view.staticProps ? (await view.staticProps({
+        pathname: { params },
+        appConfig: this.appConfig,
+        runtimeOrigin: this.appConfig.baseUrl
+      })).props : {};
+      const response = await renderer.renderToResponse(view, props, {});
+      const contents = await response.text();
+      const outputPath = this.getOutputPath(resolvedPath);
+      fileSystem.ensureDir(path.dirname(outputPath));
+      fileSystem.write(outputPath, contents);
+      appLogger.debug(`Generated static page: ${resolvedPath} -> ${outputPath}`);
+    }
+  }
+  /**
+   * Resolve a route path template with actual params.
+   * Supports both :param and [param] syntax.
+   */
+  resolveRoutePath(routePath, params) {
+    let resolved = routePath;
+    for (const [key, value] of Object.entries(params)) {
+      const paramValue = Array.isArray(value) ? value.join("/") : value;
+      resolved = resolved.replace(`:${key}`, paramValue);
+      resolved = resolved.replace(`[${key}]`, paramValue);
+      resolved = resolved.replace(`[...${key}]`, paramValue);
+    }
+    return resolved;
+  }
+  /**
+   * Get the output file path for a given route.
+   */
+  getOutputPath(routePath) {
+    let outputName;
+    if (routePath === "/") {
+      outputName = "index.html";
+    } else if (routePath.endsWith("/")) {
+      outputName = `${routePath}index.html`;
+    } else {
+      outputName = `${routePath}.html`;
+    }
+    return path.join(this.appConfig.rootDir, this.appConfig.distDir, outputName);
+  }
+}
+function templateSegmentsFromPath(path2) {
+  return path2.split("/").filter(Boolean);
+}
+export {
+  STATIC_SITE_GENERATOR_ERRORS,
+  StaticSiteGenerator
+};

package/src/static-site-generator/static-site-generator.ts

@@ -0,0 +1,359 @@
+import path from 'node:path';
+import { appLogger } from '../global/app-logger.ts';
+import type { EcoPagesAppConfig } from '../internal-types.ts';
+import type { EcoPageComponent, StaticRoute } from '../public-types.ts';
+import type { RouteRendererFactory } from '../route-renderer/route-renderer.ts';
+import type { FSRouter } from '../router/fs-router.ts';
+import { fileSystem } from '@ecopages/file-system';
+import { PathUtils } from '../utils/path-utils.module.ts';
+
+export const STATIC_SITE_GENERATOR_ERRORS = {
+	ROUTE_RENDERER_FACTORY_REQUIRED: 'RouteRendererFactory is required for render strategy',
+	unsupportedBodyType: (bodyType: string) => `Unsupported body type for static generation: ${bodyType}`,
+	missingIntegration: (routePath: string) =>
+		`View at ${routePath} is missing __eco.integration. Ensure it's defined with eco.page().`,
+	noRendererForIntegration: (integrationName: string) => `No renderer found for integration: ${integrationName}`,
+	dynamicRouteRequiresStaticPaths: (routePath: string) =>
+		`Dynamic route ${routePath} requires staticPaths to be defined on the view.`,
+} as const;
+
+export class StaticSiteGenerator {
+	appConfig: EcoPagesAppConfig;
+
+	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
+		this.appConfig = appConfig;
+	}
+
+	generateRobotsTxt(): void {
+		let data = '';
+		const preferences = this.appConfig.robotsTxt.preferences;
+
+		for (const userAgent in preferences) {
+			data += `user-agent: ${userAgent}\n`;
+			for (const path of preferences[userAgent]) {
+				data += `disallow: ${path}\n`;
+			}
+			data += '\n';
+		}
+
+		fileSystem.ensureDir(this.appConfig.distDir);
+		fileSystem.write(`${this.appConfig.distDir}/robots.txt`, data);
+	}
+
+	isRootDir(path: string) {
+		const slashes = path.match(/\//g);
+		return slashes && slashes.length === 1;
+	}
+
+	getDirectories(routes: string[]) {
+		const directories = new Set<string>();
+
+		for (const route of routes) {
+			const path = route.startsWith('http') ? new URL(route).pathname : route;
+
+			const segments = path.split('/');
+
+			if (segments.length > 2) {
+				directories.add(segments.slice(0, segments.length - 1).join('/'));
+			}
+		}
+
+		return Array.from(directories);
+	}
+
+	/**
+	 * Extracts dynamic parameters from the actual path based on the template path.
+	 *
+	 * @param templatePath - The template path (e.g., "/blog/[slug]")
+	 * @param actualPath - The actual path (e.g., "/blog/my-post")
+	 * @returns A record of extracted parameters (e.g., { slug: "my-post" })
+	 */
+	private extractParams(templatePath: string, actualPath: string): Record<string, string> {
+		const templateSegments = templateSegmentsFromPath(templatePath);
+		const actualSegments = templateSegmentsFromPath(actualPath);
+		const params: Record<string, string> = {};
+
+		for (let i = 0; i < templateSegments.length; i++) {
+			const segment = templateSegments[i];
+			if (segment.startsWith('[') && segment.endsWith(']')) {
+				const paramName = segment.slice(1, -1).replace('...', '');
+				params[paramName] = actualSegments[i];
+			}
+		}
+
+		return params;
+	}
+
+	async generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory) {
+		const routes = Object.keys(router.routes).filter((route) => !route.includes('['));
+
+		appLogger.debug('Static Pages', routes);
+
+		const directories = this.getDirectories(routes);
+
+		for (const directory of directories) {
+			fileSystem.ensureDir(path.join(this.appConfig.rootDir, this.appConfig.distDir, directory));
+		}
+
+		for (const route of routes) {
+			try {
+				const { filePath, pathname: routePathname } = router.routes[route];
+				const ext = PathUtils.getEcoTemplateExtension(filePath);
+				const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
+				const strategy = integration?.staticBuildStep || 'render';
+
+				let contents: string | Buffer;
+
+				if (strategy === 'fetch') {
+					const fetchUrl = route.startsWith('http') ? route : `${baseUrl}${route}`;
+					const response = await fetch(fetchUrl);
+
+					if (!response.ok) {
+						appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
+						continue;
+					}
+					contents = await response.text();
+				} else {
+					if (!routeRendererFactory) {
+						throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+					}
+
+					let pathname = routePathname;
+					const pathnameSegments = pathname.split('/').filter(Boolean);
+
+					if (pathname === '/') {
+						pathname = '/index.html';
+					} else if (pathnameSegments.join('/').includes('[')) {
+						pathname = `${route.replace(router.origin, '')}.html`;
+					} else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join('/')}`)) {
+						pathname = `${pathname.endsWith('/') ? pathname : `${pathname}/`}index.html`;
+					} else {
+						pathname += '.html';
+					}
+
+					const renderer = routeRendererFactory.createRenderer(filePath);
+					const params = this.extractParams(routePathname, pathname.replace('.html', ''));
+
+					const result = await renderer.createRoute({
+						file: filePath,
+						params,
+					});
+
+					const body = result.body;
+
+					if (typeof body === 'string' || Buffer.isBuffer(body)) {
+						contents = body;
+					} else if (body instanceof ReadableStream) {
+						contents = await new Response(body).text();
+					} else {
+						throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
+					}
+				}
+
+				let pathname = routePathname;
+				const pathnameSegments = pathname.split('/').filter(Boolean);
+
+				if (pathname === '/') {
+					pathname = '/index.html';
+				} else if (pathnameSegments.join('/').includes('[')) {
+					pathname = `${route.replace(router.origin, '')}.html`;
+				} else if (pathnameSegments.length >= 1 && directories.includes(`/${pathnameSegments.join('/')}`)) {
+					pathname = `${pathname.endsWith('/') ? pathname : `${pathname}/`}index.html`;
+				} else {
+					pathname += '.html';
+				}
+
+				const outputPath = path.join(this.appConfig.rootDir, this.appConfig.distDir, pathname);
+				fileSystem.write(outputPath, contents);
+			} catch (error) {
+				appLogger.error(
+					`Error generating static page for ${route}:`,
+					error instanceof Error ? error : String(error),
+				);
+			}
+		}
+	}
+
+	async run({
+		router,
+		baseUrl,
+		routeRendererFactory,
+		staticRoutes,
+	}: {
+		router: FSRouter;
+		baseUrl: string;
+		routeRendererFactory?: RouteRendererFactory;
+		staticRoutes?: StaticRoute[];
+	}) {
+		this.generateRobotsTxt();
+		await this.generateStaticPages(router, baseUrl, routeRendererFactory);
+
+		if (staticRoutes && staticRoutes.length > 0 && routeRendererFactory) {
+			await this.generateExplicitStaticPages(staticRoutes, routeRendererFactory);
+		}
+	}
+
+	/**
+	 * Generates static pages from explicit static routes registered via app.static().
+	 * These routes use eco.page views via loader functions for HMR support.
+	 */
+	private async generateExplicitStaticPages(
+		staticRoutes: StaticRoute[],
+		routeRendererFactory: RouteRendererFactory,
+	): Promise<void> {
+		appLogger.debug(
+			'Generating explicit static routes',
+			staticRoutes.map((r) => r.path),
+		);
+
+		for (const route of staticRoutes) {
+			try {
+				const mod = await route.loader();
+				const view = mod.default;
+
+				const isDynamic = route.path.includes(':') || route.path.includes('[');
+
+				if (isDynamic) {
+					await this.generateDynamicStaticRoute(route.path, view, routeRendererFactory);
+				} else {
+					await this.generateSingleStaticRoute(route.path, view, routeRendererFactory);
+				}
+			} catch (error) {
+				appLogger.error(
+					`Error generating explicit static page for ${route.path}:`,
+					error instanceof Error ? error : String(error),
+				);
+			}
+		}
+	}
+
+	/**
+	 * Generate a single static page for a non-dynamic route.
+	 */
+	private async generateSingleStaticRoute(
+		routePath: string,
+		view: EcoPageComponent<any>,
+		routeRendererFactory: RouteRendererFactory,
+	): Promise<void> {
+		const integrationName = view.config?.__eco?.integration;
+		if (!integrationName) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+		}
+
+		const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+		if (!renderer) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+		}
+
+		const props = view.staticProps
+			? (
+					await view.staticProps({
+						pathname: { params: {} },
+						appConfig: this.appConfig,
+						runtimeOrigin: this.appConfig.baseUrl,
+					})
+				).props
+			: {};
+
+		const response = await renderer.renderToResponse(view, props, {});
+		const contents = await response.text();
+
+		const outputPath = this.getOutputPath(routePath);
+		fileSystem.ensureDir(path.dirname(outputPath));
+		fileSystem.write(outputPath, contents);
+
+		appLogger.debug(`Generated static page: ${routePath} -> ${outputPath}`);
+	}
+
+	/**
+	 * Generate static pages for a dynamic route using staticPaths.
+	 */
+	private async generateDynamicStaticRoute(
+		routePath: string,
+		view: EcoPageComponent<any>,
+		routeRendererFactory: RouteRendererFactory,
+	): Promise<void> {
+		if (!view.staticPaths) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.dynamicRouteRequiresStaticPaths(routePath));
+		}
+
+		const integrationName = view.config?.__eco?.integration;
+		if (!integrationName) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.missingIntegration(routePath));
+		}
+
+		const renderer = routeRendererFactory.getRendererByIntegration(integrationName);
+		if (!renderer) {
+			throw new Error(STATIC_SITE_GENERATOR_ERRORS.noRendererForIntegration(integrationName));
+		}
+
+		const { paths } = await view.staticPaths({
+			appConfig: this.appConfig,
+			runtimeOrigin: this.appConfig.baseUrl,
+		});
+
+		for (const { params } of paths) {
+			const resolvedPath = this.resolveRoutePath(routePath, params);
+
+			const props = view.staticProps
+				? (
+						await view.staticProps({
+							pathname: { params },
+							appConfig: this.appConfig,
+							runtimeOrigin: this.appConfig.baseUrl,
+						})
+					).props
+				: {};
+
+			const response = await renderer.renderToResponse(view, props, {});
+			const contents = await response.text();
+
+			const outputPath = this.getOutputPath(resolvedPath);
+			fileSystem.ensureDir(path.dirname(outputPath));
+			fileSystem.write(outputPath, contents);
+
+			appLogger.debug(`Generated static page: ${resolvedPath} -> ${outputPath}`);
+		}
+	}
+
+	/**
+	 * Resolve a route path template with actual params.
+	 * Supports both :param and [param] syntax.
+	 */
+	private resolveRoutePath(routePath: string, params: Record<string, string | string[]>): string {
+		let resolved = routePath;
+
+		for (const [key, value] of Object.entries(params)) {
+			const paramValue = Array.isArray(value) ? value.join('/') : value;
+			resolved = resolved.replace(`:${key}`, paramValue);
+			resolved = resolved.replace(`[${key}]`, paramValue);
+			resolved = resolved.replace(`[...${key}]`, paramValue);
+		}
+
+		return resolved;
+	}
+
+	/**
+	 * Get the output file path for a given route.
+	 */
+	private getOutputPath(routePath: string): string {
+		let outputName: string;
+
+		if (routePath === '/') {
+			outputName = 'index.html';
+		} else if (routePath.endsWith('/')) {
+			outputName = `${routePath}index.html`;
+		} else {
+			outputName = `${routePath}.html`;
+		}
+
+		return path.join(this.appConfig.rootDir, this.appConfig.distDir, outputName);
+	}
+}
+
+/**
+ * Splits a path into segments, filtering out empty strings.
+ */
+function templateSegmentsFromPath(path: string) {
+	return path.split('/').filter(Boolean);
+}

package/src/utils/css.d.ts

@@ -0,0 +1 @@
+export declare const css: (strings: TemplateStringsArray, ...values: any[]) => Promise<string>;

package/src/utils/css.js

@@ -0,0 +1,7 @@
+const css = async (strings, ...values) => {
+  const css2 = strings.reduce((acc, str, i) => acc + str + (values[i] || ""), "");
+  return css2;
+};
+export {
+  css
+};