@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.28

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -48,7 +48,8 @@ class ContentStylesheetProcessor extends BaseProcessor {
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        packageRole: dep.packageRole
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.js

@@ -52,12 +52,14 @@ class FileStylesheetProcessor extends BaseProcessor {
       }
       return {
         filepath,
+        sourceFilepath: dep.filepath,
         content: dep.inline ? processedContent : void 0,
         kind: "stylesheet",
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        packageRole: dep.packageRole
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

package/src/services/module-loading/node-bootstrap-plugin.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
@@ -51,7 +51,7 @@ function ensureRuntimePackageLink(nodeModulesDir, specifier, resolvedPath) {
     if (linkPointsToPackage(linkPath, packageRoot)) {
       return;
     }
-    rmSync(linkPath, { recursive: true, force: true });
+    removeRuntimePackageLink(linkPath);
   }
   try {
     symlinkSync(packageRoot, linkPath, "dir");
@@ -62,10 +62,22 @@ function ensureRuntimePackageLink(nodeModulesDir, specifier, resolvedPath) {
     if (linkPointsToPackage(linkPath, packageRoot)) {
       return;
     }
-    rmSync(linkPath, { recursive: true, force: true });
+    removeRuntimePackageLink(linkPath);
     symlinkSync(packageRoot, linkPath, "dir");
   }
 }
+function removeRuntimePackageLink(linkPath) {
+  try {
+    const stats = lstatSync(linkPath);
+    if (stats.isSymbolicLink()) {
+      unlinkSync(linkPath);
+      return;
+    }
+  } catch {
+    return;
+  }
+  rmSync(linkPath, { recursive: true, force: true });
+}
 function getNodeUnsupportedBuiltinError(specifier, importer) {
   return `Node bootstrap transpilation does not support Bun builtin specifier ${JSON.stringify(specifier)}${importer ? ` imported from ${importer}` : ""}.`;
 }

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

@@ -1,7 +1,14 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import type { StaticRoute } from '../types/public-types.js';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer.js';
-import type { FSRouter } from '../router/server/fs-router.js';
+import type { PageRendererResolver, StaticGenerationRendererResolver } from '../route-renderer/route-renderer.js';
+import type { StaticGenerationRoute } from '../router/server/route-registry.js';
+type StaticGenerationRouteSource = {
+    listStaticGenerationRoutes(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticGenerationRoute[]>;
+};
+type StaticPageRouteRendererFactory = PageRendererResolver;
+type StaticGenerationRendererFactory = StaticGenerationRendererResolver;
 export declare const STATIC_SITE_GENERATOR_ERRORS: {
     readonly ROUTE_RENDERER_FACTORY_REQUIRED: "RouteRendererFactory is required for render strategy";
     readonly unsupportedBodyType: (bodyType: string) => string;
@@ -53,14 +60,9 @@ export declare class StaticSiteGenerator {
      * Collects parent directories that must exist for the generated route set.
      */
     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;
+    private writeStaticOutput;
+    private getStaticBuildStrategy;
+    private createFilesystemStaticContents;
     /**
      * Generates static output for all filesystem-discovered routes.
      *
@@ -69,15 +71,15 @@ export declare class StaticSiteGenerator {
      * issuing a request against the running server origin. Render-strategy routes
      * go through the normal route renderer directly.
      */
-    generateStaticPages(router: FSRouter, baseUrl: string, routeRendererFactory?: RouteRendererFactory): Promise<void>;
+    generateStaticPages(router: StaticGenerationRouteSource, baseUrl: string, routeRendererFactory?: StaticPageRouteRendererFactory): Promise<void>;
     private resolveStaticFetchUrl;
     /**
      * Executes the full static-generation workflow for one app run.
      */
     run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
-        router: FSRouter;
+        router: StaticGenerationRouteSource;
         baseUrl: string;
-        routeRendererFactory?: RouteRendererFactory;
+        routeRendererFactory?: StaticGenerationRendererFactory;
         staticRoutes?: StaticRoute[];
     }): Promise<void>;
     /**
@@ -85,14 +87,10 @@ export declare class StaticSiteGenerator {
      * 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;
+    private generateExplicitStaticRoute;
+    private planExplicitStaticRoute;
+    private createExplicitStaticContents;
+    private listExplicitStaticRouteEntries;
     /**
      * Resolve a route path template with actual params.
      * Supports both :param and [param] syntax.
@@ -103,3 +101,4 @@ export declare class StaticSiteGenerator {
      */
     private getOutputPath;
 }
+export {};

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

@@ -2,6 +2,7 @@ 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";
+import { prepareExplicitStaticRender } from "../adapters/shared/explicit-static-render-preparation.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}`,
@@ -34,7 +35,7 @@ class StaticSiteGenerator {
    * static generation.
    */
   async shouldSkipStaticPageFile(filePath, routeRendererFactory) {
-    const module = await routeRendererFactory.createRenderer(filePath).loadPageModule(filePath, {
+    const module = await routeRendererFactory.getPageRenderer(filePath).loadPageModule(filePath, {
       cacheScope: "static-page-probe"
     });
     if (module.default?.cache !== "dynamic") {
@@ -93,25 +94,50 @@ class StaticSiteGenerator {
     }
     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];
+  writeStaticOutput(routePath, contents, directories = []) {
+    const outputPath = this.getOutputPath(routePath, directories);
+    fileSystem.ensureDir(path.dirname(outputPath));
+    fileSystem.write(outputPath, contents);
+    return outputPath;
+  }
+  getStaticBuildStrategy(filePath) {
+    const ext = PathUtils.getEcoTemplateExtension(filePath);
+    const integration = this.appConfig.integrations.find((plugin) => plugin.extensions.includes(ext));
+    return integration?.staticBuildStep || "render";
+  }
+  async createFilesystemStaticContents(route, baseUrl, routeRendererFactory) {
+    const {
+      templateRoute: { filePath },
+      params
+    } = route;
+    if (this.getStaticBuildStrategy(filePath) === "fetch") {
+      const fetchUrl = this.resolveStaticFetchUrl(route.requestUrl, baseUrl);
+      const response = await fetch(fetchUrl);
+      if (!response.ok) {
+        appLogger.error(`Failed to fetch ${fetchUrl}. Status: ${response.status}`);
+        return null;
       }
+      return response.text();
+    }
+    if (!routeRendererFactory) {
+      throw new Error(STATIC_SITE_GENERATOR_ERRORS.ROUTE_RENDERER_FACTORY_REQUIRED);
+    }
+    if (await this.shouldSkipStaticPageFile(filePath, routeRendererFactory)) {
+      return null;
     }
-    return params;
+    const renderer = routeRendererFactory.getPageRenderer(filePath);
+    const result = await renderer.execute({
+      file: filePath,
+      params
+    });
+    const body = result.body;
+    if (typeof body === "string" || Buffer.isBuffer(body)) {
+      return body;
+    }
+    if (body instanceof ReadableStream) {
+      return new Response(body).text();
+    }
+    throw new Error(STATIC_SITE_GENERATOR_ERRORS.unsupportedBodyType(typeof body));
   }
   /**
    * Generates static output for all filesystem-discovered routes.
@@ -122,76 +148,22 @@ class StaticSiteGenerator {
    * go through the normal route renderer directly.
    */
   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.getExportDir(), directory));
-    }
+    const routes = await router.listStaticGenerationRoutes({ runtimeOrigin: baseUrl });
+    appLogger.debug(
+      "Static Pages",
+      routes.map((route) => route.requestUrl)
+    );
+    const directories = this.getDirectories(routes.map((route) => route.requestUrl));
     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 = this.resolveStaticFetchUrl(route, baseUrl);
-          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);
-          }
-          if (await this.shouldSkipStaticPageFile(filePath, routeRendererFactory)) {
-            continue;
-          }
-          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 contents = await this.createFilesystemStaticContents(route, baseUrl, routeRendererFactory);
+        if (contents === null) {
+          continue;
         }
-        const outputPath = path.join(this.getExportDir(), pathname);
-        fileSystem.write(outputPath, contents);
+        this.writeStaticOutput(route.pathname, contents, directories);
       } catch (error) {
         appLogger.error(
-          `Error generating static page for ${route}:`,
+          `Error generating static page for ${route.requestUrl}:`,
           error instanceof Error ? error : String(error)
         );
       }
@@ -239,12 +211,7 @@ class StaticSiteGenerator {
         if (this.shouldSkipStaticView(route.path, view)) {
           continue;
         }
-        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);
-        }
+        await this.generateExplicitStaticRoute(route.path, view, routeRendererFactory);
       } catch (error) {
         appLogger.error(
           `Error generating explicit static page for ${route.path}:`,
@@ -253,63 +220,64 @@ class StaticSiteGenerator {
       }
     }
   }
-  /**
-   * 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));
+  async generateExplicitStaticRoute(routePath, view, routeRendererFactory) {
+    const { renderer, routeEntries } = await this.planExplicitStaticRoute(routePath, view, routeRendererFactory);
+    for (const { pathname, params } of routeEntries) {
+      const contents = await this.createExplicitStaticContents(
+        routePath,
+        view,
+        params,
+        routeRendererFactory,
+        renderer
+      );
+      const outputPath = this.writeStaticOutput(pathname, contents);
+      appLogger.debug(`Generated static page: ${pathname} -> ${outputPath}`);
     }
-    const props = view.staticProps ? (await view.staticProps({
-      pathname: { params: {} },
+  }
+  async planExplicitStaticRoute(routePath, view, routeRendererFactory) {
+    const { renderer } = await prepareExplicitStaticRender({
+      routePath,
+      view,
+      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}`);
+      runtimeOrigin: this.appConfig.baseUrl,
+      routeRendererFactory,
+      errors: STATIC_SITE_GENERATOR_ERRORS
+    });
+    return {
+      renderer,
+      routeEntries: await this.listExplicitStaticRouteEntries(routePath, view)
+    };
   }
-  /**
-   * Generate static pages for a dynamic route using staticPaths.
-   */
-  async generateDynamicStaticRoute(routePath, view, routeRendererFactory) {
+  async createExplicitStaticContents(routePath, view, params, routeRendererFactory, renderer) {
+    const { props, view: renderableView } = await prepareExplicitStaticRender({
+      routePath,
+      view,
+      params,
+      appConfig: this.appConfig,
+      runtimeOrigin: this.appConfig.baseUrl,
+      routeRendererFactory,
+      errors: STATIC_SITE_GENERATOR_ERRORS
+    });
+    const response = await renderer.renderToResponse(renderableView, props, {});
+    return response.text();
+  }
+  async listExplicitStaticRouteEntries(routePath, view) {
+    const isDynamic = routePath.includes(":") || routePath.includes("[");
+    if (!isDynamic) {
+      return [{ pathname: routePath, params: {} }];
+    }
     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}`);
-    }
+    return paths.map(({ params }) => ({
+      pathname: this.resolveRoutePath(routePath, params),
+      params
+    }));
   }
   /**
    * Resolve a route path template with actual params.
@@ -328,10 +296,12 @@ class StaticSiteGenerator {
   /**
    * Get the output file path for a given route.
    */
-  getOutputPath(routePath) {
+  getOutputPath(routePath, directories = []) {
     let outputName;
     if (routePath === "/") {
       outputName = "index.html";
+    } else if (directories.includes(routePath)) {
+      outputName = `${routePath}/index.html`;
     } else if (routePath.endsWith("/")) {
       outputName = `${routePath}index.html`;
     } else {
@@ -340,9 +310,6 @@ class StaticSiteGenerator {
     return path.join(this.getExportDir(), outputName);
   }
 }
-function templateSegmentsFromPath(path2) {
-  return path2.split("/").filter(Boolean);
-}
 export {
   STATIC_SITE_GENERATOR_ERRORS,
   StaticSiteGenerator

package/src/types/internal-types.d.ts

@@ -1,17 +1,16 @@
 import type { EcoBuildPlugin } from '../build/build-types.js';
 import type { AppBuildManifest } from '../build/build-manifest.js';
 import type { BuildAdapter, BuildExecutor, BuildOwnership } from '../build/build-adapter.js';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
+import type { AnyIntegrationPlugin } from '../plugins/integration-plugin.js';
 import type { Processor } from '../plugins/processor.js';
 import type { EcoSourceTransform } from '../plugins/source-transform.js';
 import type { PageMetadataProps } from './public-types.js';
-import type { FSRouter } from '../router/server/fs-router.js';
+import type { RouteRegistry } from '../router/server/route-registry.js';
 import type { CacheConfig } from '../services/cache/cache.types.js';
 import type { DevGraphService } from '../services/runtime-state/dev-graph.service.js';
 import type { AppModuleLoader } from '../services/module-loading/app-module-loader.service.js';
 import type { SourceModuleLoader } from '../services/module-loading/module-loading-types.js';
 import type { EntrypointDependencyGraph } from '../services/runtime-state/entrypoint-dependency-graph.service.js';
-import type { RuntimeSpecifierRegistry } from '../services/runtime-state/runtime-specifier-registry.service.js';
 import type { ServerInvalidationState } from '../services/runtime-state/server-invalidation-state.service.js';
 import type { ServerModuleTranspiler } from '../services/module-loading/server-module-transpiler.service.js';
 export interface RobotsPreference {
@@ -102,7 +101,7 @@ export type EcoPagesAppConfig = {
      */
     defaultMetadata: PageMetadataProps;
     /** Integrations plugins */
-    integrations: IntegrationPlugin[];
+    integrations: AnyIntegrationPlugin[];
     /** Integrations dependencies */
     integrationsDependencies: IntegrationDependencyConfig[];
     /** Derived Paths */
@@ -155,7 +154,6 @@ export type EcoPagesAppConfig = {
         entrypointDependencyGraph?: EntrypointDependencyGraph;
         hostModuleLoader?: SourceModuleLoader;
         rendererModuleContext?: unknown;
-        runtimeSpecifierRegistry?: RuntimeSpecifierRegistry;
         serverInvalidationState?: ServerInvalidationState;
         serverModuleTranspiler?: ServerModuleTranspiler;
     };
@@ -184,11 +182,14 @@ export type RouteKind = 'exact' | 'catch-all' | 'dynamic';
  * Represents the result of a route match.
  */
 export type MatchResult = {
-    filePath: string;
-    kind: RouteKind;
-    pathname: string;
-    query?: Record<string, string>;
-    params?: Record<string, string | string[]>;
+    requestedPathname: string;
+    templateRoute: {
+        filePath: string;
+        kind: RouteKind;
+        pathname: string;
+    };
+    query: Record<string, string>;
+    params: Record<string, string | string[]>;
 };
 /**
  * Represents a route in EcoPages.
@@ -214,10 +215,10 @@ export type FileSystemServerOptions = {
  */
 export interface EcoPagesFileSystemServerAdapter<ServerInstanceOptions = unknown> {
     startServer(serverOptions: ServerInstanceOptions): {
-        router: FSRouter;
+        router: RouteRegistry;
         server: unknown;
     } | Promise<{
-        router: FSRouter;
+        router: RouteRegistry;
         server: unknown;
     }>;
 }