@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.31

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

@@ -0,0 +1,10 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import { type RouteModuleStaticRenderCacheContext } from '../services/module-loading/route-module-build-manifest.js';
+export type { BuildInputChangeContributor, IntegrationPlugin, Processor, } from '../build/cache/build-input-fingerprint.js';
+export { collectBuildInputContributors, createBuildInputsFingerprint, didBuildInputContributorChange, hashAppConfigFile, haveBuildInputsChanged, } from '../build/cache/build-input-fingerprint.js';
+/** Builds the static-render invalidation context for one app config. */
+export declare function createRouteModuleStaticRenderCacheContext(appConfig: EcoPagesAppConfig): RouteModuleStaticRenderCacheContext;
+/** Returns whether `dist/` should be wiped before the next static export. */
+export declare function shouldResetStaticExportDirectory(appConfig: EcoPagesAppConfig, force?: boolean): boolean;
+/** Removes persisted production build caches so the next build recomputes everything. */
+export declare function clearProductionBuildCaches(appConfig: EcoPagesAppConfig): void;

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

@@ -0,0 +1,59 @@
+import {
+  createBuildInputsFingerprint,
+  hashAppConfigFile,
+  haveBuildInputsChanged
+} from "../build/cache/build-input-fingerprint.js";
+import { clearPersistedProductionBuildCacheManifests } from "../build/cache/production-build-cache.js";
+import {} from "../services/module-loading/route-module-build-manifest.js";
+import {
+  getSharedRouteModuleBuildCache,
+  getServerModuleBuildCacheOutdir
+} from "../services/module-loading/route-module-build-cache-registry.js";
+import {
+  collectBuildInputContributors,
+  createBuildInputsFingerprint as createBuildInputsFingerprint2,
+  didBuildInputContributorChange,
+  hashAppConfigFile as hashAppConfigFile2,
+  haveBuildInputsChanged as haveBuildInputsChanged2
+} from "../build/cache/build-input-fingerprint.js";
+function createRouteModuleStaticRenderCacheContext(appConfig) {
+  return {
+    configHash: hashAppConfigFile(appConfig),
+    buildInputsFingerprint: createBuildInputsFingerprint(appConfig)
+  };
+}
+function shouldResetStaticExportDirectory(appConfig, force = false) {
+  if (force) {
+    return true;
+  }
+  if (haveBuildInputsChanged(appConfig)) {
+    return true;
+  }
+  const routeModuleCache = getSharedRouteModuleBuildCache(getServerModuleBuildCacheOutdir(appConfig), appConfig);
+  return !routeModuleCache.isIncrementalStaticGenerationAvailable(
+    createRouteModuleStaticRenderCacheContext(appConfig)
+  );
+}
+function clearProductionBuildCaches(appConfig) {
+  if (process.env.NODE_ENV !== "production") {
+    return;
+  }
+  clearPersistedProductionBuildCacheManifests(appConfig);
+  for (const cache of appConfig.runtime?.routeModuleBuildCaches?.values() ?? []) {
+    cache.resetMemory();
+  }
+  appConfig.runtime?.routeModuleBuildCaches?.clear();
+  if (appConfig.runtime) {
+    appConfig.runtime.buildRuntime = void 0;
+  }
+}
+export {
+  clearProductionBuildCaches,
+  collectBuildInputContributors,
+  createBuildInputsFingerprint2 as createBuildInputsFingerprint,
+  createRouteModuleStaticRenderCacheContext,
+  didBuildInputContributorChange,
+  hashAppConfigFile2 as hashAppConfigFile,
+  haveBuildInputsChanged2 as haveBuildInputsChanged,
+  shouldResetStaticExportDirectory
+};

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

@@ -0,0 +1,30 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import type { EcopagesRouteInfo, StaticRoute } from '../types/public-types.js';
+import type { 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[]>;
+};
+/**
+ * Context passed to integration plugins during static export lifecycle hooks.
+ */
+export interface StaticExportContext {
+    appConfig: EcoPagesAppConfig;
+    router: StaticGenerationRouteSource;
+    baseUrl: string;
+    routeRendererFactory?: StaticGenerationRendererResolver;
+    staticRoutes?: StaticRoute[];
+    force: boolean;
+    preserveExportDirectory: boolean;
+    /**
+     * Unfiltered static-generation routes (exact + expanded dynamic).
+     *
+     * @remarks
+     * Sitemap filtering is applied separately; integrations that build custom
+     * artifacts should start from this full list.
+     */
+    routes: EcopagesRouteInfo[];
+}
+export {};

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

@@ -1,7 +1,8 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import type { StaticRoute } from '../types/public-types.js';
+import type { SitemapConfig, StaticRoute } from '../types/public-types.js';
 import type { PageRendererResolver, StaticGenerationRendererResolver } from '../route-renderer/route-renderer.js';
 import type { StaticGenerationRoute } from '../router/server/route-registry.js';
+import type { RouteModuleBuildCache } from '../services/module-loading/route-module-build-cache.store.js';
 type StaticGenerationRouteSource = {
     listStaticGenerationRoutes(input: {
         runtimeOrigin: string;
@@ -27,31 +28,29 @@ export declare const STATIC_SITE_GENERATOR_ERRORS: {
  */
 export declare class StaticSiteGenerator {
     appConfig: EcoPagesAppConfig;
+    private readonly routeModuleBuildCacheOverride?;
+    private staticRenderCacheContext;
+    private forceFullStaticGeneration;
+    private pageModuleLoader?;
     /**
      * Creates the static-site generator for one app config.
      */
-    constructor({ appConfig }: {
+    constructor({ appConfig, routeModuleBuildCache, }: {
         appConfig: EcoPagesAppConfig;
+        routeModuleBuildCache?: RouteModuleBuildCache;
     });
+    private getRouteModuleBuildCache;
     private getExportDir;
-    /**
-     * Logs the standardized warning emitted when a dynamic-cache page is skipped.
-     */
-    private warnDynamicPageSkipped;
-    /**
-     * Determines whether one filesystem-discovered page should be excluded from
-     * static generation.
-     */
     private shouldSkipStaticPageFile;
-    /**
-     * Determines whether one explicit static route view should be excluded from
-     * static generation.
-     */
     private shouldSkipStaticView;
     /**
      * Writes the robots.txt file declared by the app config.
      */
     generateRobotsTxt(): void;
+    /**
+     * Writes the configured sitemap file to the export directory.
+     */
+    generateSitemap(locations: readonly string[], sitemap: SitemapConfig): void;
     /**
      * Returns whether the input path points at the root directory.
      */
@@ -61,32 +60,51 @@ export declare class StaticSiteGenerator {
      */
     getDirectories(routes: string[]): string[];
     private writeStaticOutput;
-    private getStaticBuildStrategy;
+    private writeStaticPageArtifact;
+    /**
+     * Marks a successfully exported pathname as sitemap-eligible when robots allow indexing.
+     *
+     * @remarks
+     * Fail-closed: metadata resolution errors omit the URL. `robots.index === false`
+     * also omits it. Eligibility is decided during generation, not by reloading modules
+     * after `afterStaticExport`.
+     */
+    private considerSitemapEligibility;
+    private getPageModuleLoader;
+    private resolveFilesystemPageMetadata;
+    private resolveExplicitViewMetadata;
+    private pruneStaleStaticOutputs;
     private createFilesystemStaticContents;
     /**
      * Generates static output for all filesystem-discovered routes.
      *
      * @remarks
-     * Routes whose integrations opt into fetch-based static builds are rendered by
-     * issuing a request against the running server origin. Render-strategy routes
-     * go through the normal route renderer directly.
+     * Routes are rendered through the normal route renderer directly.
      */
-    generateStaticPages(router: StaticGenerationRouteSource, baseUrl: string, routeRendererFactory?: StaticPageRouteRendererFactory): Promise<void>;
-    private resolveStaticFetchUrl;
+    generateStaticPages(input: {
+        router: StaticGenerationRouteSource;
+        baseUrl: string;
+        routeRendererFactory?: StaticPageRouteRendererFactory;
+        skipped?: string[];
+        activeStaticPathnames?: Set<string>;
+        preloadedRoutes?: readonly StaticGenerationRoute[];
+        sitemapEligiblePathnames?: Set<string>;
+    }): Promise<void>;
+    private createStaticExportContext;
+    private invokeStaticExportHook;
     /**
      * Executes the full static-generation workflow for one app run.
      */
-    run({ router, baseUrl, routeRendererFactory, staticRoutes, }: {
+    run({ router, baseUrl, routeRendererFactory, staticRoutes, force, preserveExportDirectory, }: {
         router: StaticGenerationRouteSource;
         baseUrl: string;
         routeRendererFactory?: StaticGenerationRendererFactory;
         staticRoutes?: StaticRoute[];
+        force?: boolean;
+        preserveExportDirectory?: boolean;
     }): 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;
+    private resolveExplicitViewSourceFile;
     private generateExplicitStaticRoute;
     private planExplicitStaticRoute;
     private createExplicitStaticContents;