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

package/src/route-renderer/render-execution.service.js

@@ -1,91 +0,0 @@
-import {
-  runWithComponentRenderContext
-} from "../eco/component-render-context.js";
-class RenderExecutionService {
-  /**
-   * Executes one integration render pass and returns the final route render
-   * result.
-   *
-   * @typeParam C Integration render output element type.
-   * @param options Route-level render options.
-   * @param currentIntegrationName Active integration name for this render pass.
-   * @param callbacks Renderer-specific hooks required during execution.
-   * @returns Final route render output with body and cache strategy.
-   */
-  async execute(options, currentIntegrationName, callbacks) {
-    const renderOptions = await callbacks.prepareRenderOptions(options);
-    const shouldApplyComponentRootAttributes = renderOptions.componentRender?.canAttachAttributes && renderOptions.componentRender.rootAttributes && Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
-    const renderExecution = await runWithComponentRenderContext(
-      {
-        currentIntegration: currentIntegrationName,
-        boundaryContext: callbacks.getComponentRenderBoundaryContext()
-      },
-      async () => callbacks.render(renderOptions)
-    );
-    let renderedHtml = await new Response(renderExecution.value).text();
-    const componentGraphContext = this.mergeGraphContext(
-      renderExecution.graphContext,
-      renderOptions.componentGraphContext
-    );
-    if (renderedHtml.includes("<eco-marker")) {
-      const markerResolution = await callbacks.resolveMarkerGraphHtml({
-        html: renderedHtml,
-        componentsToResolve: this.getComponentsToResolve(renderOptions),
-        graphContext: componentGraphContext
-      });
-      renderedHtml = markerResolution.html;
-      if (markerResolution.assets.length > 0) {
-        const mergedDependencies = callbacks.dedupeProcessedAssets([
-          ...callbacks.getProcessedDependencies(),
-          ...markerResolution.assets
-        ]);
-        callbacks.setProcessedDependencies(mergedDependencies);
-      }
-    }
-    if (shouldApplyComponentRootAttributes) {
-      renderedHtml = callbacks.applyAttributesToFirstBodyElement(
-        renderedHtml,
-        renderOptions.componentRender?.rootAttributes
-      );
-    }
-    const body = await callbacks.transformHtml(renderedHtml);
-    return {
-      body,
-      cacheStrategy: renderOptions.cacheStrategy
-    };
-  }
-  /**
-   * Merges captured render-time graph references with any explicit graph context
-   * provided by the page module.
-   *
-   * @param capturedGraphContext Graph context captured from the first render pass.
-   * @param explicitGraphContext Optional page-module graph metadata.
-   * @returns Merged graph context used during marker resolution.
-   */
-  mergeGraphContext(capturedGraphContext, explicitGraphContext) {
-    return {
-      propsByRef: {
-        ...capturedGraphContext.propsByRef ?? {},
-        ...explicitGraphContext?.propsByRef ?? {}
-      },
-      slotChildrenByRef: {
-        ...capturedGraphContext.slotChildrenByRef ?? {},
-        ...explicitGraphContext?.slotChildrenByRef ?? {}
-      }
-    };
-  }
-  /**
-   * Returns the component set that participates in marker graph resolution for a
-   * render pass.
-   *
-   * @typeParam C Integration render output element type.
-   * @param renderOptions Normalized render options for the pass.
-   * @returns Ordered component list for graph registry construction.
-   */
-  getComponentsToResolve(renderOptions) {
-    return renderOptions.Layout ? [renderOptions.HtmlTemplate, renderOptions.Layout, renderOptions.Page] : [renderOptions.HtmlTemplate, renderOptions.Page];
-  }
-}
-export {
-  RenderExecutionService
-};

package/src/route-renderer/render-execution.service.ts

@@ -1,158 +0,0 @@
-import {
-	runWithComponentRenderContext,
-	type ComponentRenderBoundaryContext,
-	type ComponentGraphContext as CapturedComponentGraphContext,
-} from '../eco/component-render-context.ts';
-import type {
-	EcoComponent,
-	IntegrationRendererRenderOptions,
-	RouteRendererBody,
-	RouteRendererOptions,
-	RouteRenderResult,
-} from '../public-types.ts';
-import type { ProcessedAsset } from '../services/asset-processing-service/index.ts';
-import type { MarkerGraphContext } from './marker-graph-resolver.ts';
-
-/**
- * Serializable graph context merged from render-time captured references and
- * optional explicit page-module graph metadata.
- */
-export type RenderExecutionGraphContext = {
-	propsByRef?: Record<string, Record<string, unknown>>;
-	slotChildrenByRef?: MarkerGraphContext['slotChildrenByRef'];
-};
-
-export interface RenderExecutionCallbacks<C> {
-	prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
-	render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-	getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
-	resolveMarkerGraphHtml(input: {
-		html: string;
-		componentsToResolve: EcoComponent[];
-		graphContext: RenderExecutionGraphContext;
-	}): Promise<{ html: string; assets: ProcessedAsset[] }>;
-	dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
-	getProcessedDependencies(): ProcessedAsset[];
-	setProcessedDependencies(dependencies: ProcessedAsset[]): void;
-	applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
-	transformHtml(html: string): Promise<RouteRendererBody>;
-}
-
-/**
- * Executes the main post-preparation rendering flow for integration renderers.
- *
- * This service owns the orchestration that happens after normalized render
- * options have been prepared: the first render pass, graph-context capture,
- * deferred marker resolution, root-attribute application, and final HTML
- * transformation into a response body stream.
- */
-export class RenderExecutionService {
-	/**
-	 * Executes one integration render pass and returns the final route render
-	 * result.
-	 *
-	 * @typeParam C Integration render output element type.
-	 * @param options Route-level render options.
-	 * @param currentIntegrationName Active integration name for this render pass.
-	 * @param callbacks Renderer-specific hooks required during execution.
-	 * @returns Final route render output with body and cache strategy.
-	 */
-	async execute<C = unknown>(
-		options: RouteRendererOptions,
-		currentIntegrationName: string,
-		callbacks: RenderExecutionCallbacks<C>,
-	): Promise<RouteRenderResult> {
-		const renderOptions = await callbacks.prepareRenderOptions(options);
-		const shouldApplyComponentRootAttributes =
-			renderOptions.componentRender?.canAttachAttributes &&
-			renderOptions.componentRender.rootAttributes &&
-			Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
-
-		const renderExecution = await runWithComponentRenderContext(
-			{
-				currentIntegration: currentIntegrationName,
-				boundaryContext: callbacks.getComponentRenderBoundaryContext(),
-			},
-			async () => callbacks.render(renderOptions),
-		);
-
-		let renderedHtml = await new Response(renderExecution.value as BodyInit).text();
-		const componentGraphContext = this.mergeGraphContext(
-			renderExecution.graphContext,
-			(
-				renderOptions as IntegrationRendererRenderOptions<C> & {
-					componentGraphContext?: RenderExecutionGraphContext;
-				}
-			).componentGraphContext,
-		);
-
-		if (renderedHtml.includes('<eco-marker')) {
-			const markerResolution = await callbacks.resolveMarkerGraphHtml({
-				html: renderedHtml,
-				componentsToResolve: this.getComponentsToResolve(renderOptions),
-				graphContext: componentGraphContext,
-			});
-			renderedHtml = markerResolution.html;
-
-			if (markerResolution.assets.length > 0) {
-				const mergedDependencies = callbacks.dedupeProcessedAssets([
-					...callbacks.getProcessedDependencies(),
-					...markerResolution.assets,
-				]);
-				callbacks.setProcessedDependencies(mergedDependencies);
-			}
-		}
-
-		if (shouldApplyComponentRootAttributes) {
-			renderedHtml = callbacks.applyAttributesToFirstBodyElement(
-				renderedHtml,
-				renderOptions.componentRender?.rootAttributes as Record<string, string>,
-			);
-		}
-
-		const body = await callbacks.transformHtml(renderedHtml);
-
-		return {
-			body,
-			cacheStrategy: renderOptions.cacheStrategy,
-		};
-	}
-
-	/**
-	 * Merges captured render-time graph references with any explicit graph context
-	 * provided by the page module.
-	 *
-	 * @param capturedGraphContext Graph context captured from the first render pass.
-	 * @param explicitGraphContext Optional page-module graph metadata.
-	 * @returns Merged graph context used during marker resolution.
-	 */
-	private mergeGraphContext(
-		capturedGraphContext: CapturedComponentGraphContext,
-		explicitGraphContext?: RenderExecutionGraphContext,
-	): RenderExecutionGraphContext {
-		return {
-			propsByRef: {
-				...(capturedGraphContext.propsByRef ?? {}),
-				...(explicitGraphContext?.propsByRef ?? {}),
-			},
-			slotChildrenByRef: {
-				...(capturedGraphContext.slotChildrenByRef ?? {}),
-				...(explicitGraphContext?.slotChildrenByRef ?? {}),
-			},
-		};
-	}
-
-	/**
-	 * Returns the component set that participates in marker graph resolution for a
-	 * render pass.
-	 *
-	 * @typeParam C Integration render output element type.
-	 * @param renderOptions Normalized render options for the pass.
-	 * @returns Ordered component list for graph registry construction.
-	 */
-	private getComponentsToResolve<C>(renderOptions: IntegrationRendererRenderOptions<C>): EcoComponent[] {
-		return renderOptions.Layout
-			? [renderOptions.HtmlTemplate as EcoComponent, renderOptions.Layout as EcoComponent, renderOptions.Page]
-			: [renderOptions.HtmlTemplate as EcoComponent, renderOptions.Page];
-	}
-}

package/src/route-renderer/render-preparation.service.d.ts

@@ -1,112 +0,0 @@
-import type { EcoPagesAppConfig } from '../internal-types.js';
-import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../public-types.js';
-import { type AssetProcessingService, type ProcessedAsset } from '../services/asset-processing-service/index.js';
-import { type ComponentRenderBoundaryContext } from '../eco/component-render-context.js';
-type ResolvedPageModule = {
-    Page: EcoPageFile['default'] | EcoPageComponent<any>;
-    getStaticProps?: GetStaticProps<Record<string, unknown>>;
-    getMetadata?: GetMetadata;
-    integrationSpecificProps: Record<string, unknown>;
-};
-export interface RenderPreparationCallbacks {
-    resolvePageModule(file: string): Promise<ResolvedPageModule>;
-    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-    resolvePageData(pageModule: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-    }, routeOptions: RouteRendererOptions): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
-    resolveDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
-    buildRouteRenderAssets(file: string): Promise<ProcessedAsset[]> | undefined;
-    shouldRenderPageComponent(input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        options: RouteRendererOptions;
-    }): boolean;
-    renderPageComponent(input: {
-        component: EcoComponent;
-        props: Record<string, unknown>;
-    }): Promise<ComponentRenderResult>;
-    /**
-     * Returns the boundary policy context that should be active while rendering
-     * page-root component output during preparation.
-     */
-    getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
-    setProcessedDependencies(dependencies: ProcessedAsset[]): void;
-    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
-    createPageLocalsProxy(filePath: string): RouteRendererOptions['locals'];
-}
-/**
- * Prepares the normalized render inputs consumed by `IntegrationRenderer.execute()`.
- *
- * This service owns the orchestration that happens before the main HTML render:
- * page module resolution, data loading, dependency aggregation, page-root
- * component artifact capture, lazy trigger bootstrap generation, and request
- * locals policy.
- */
-export declare class RenderPreparationService {
-    private appConfig;
-    private assetProcessingService;
-    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService);
-    /**
-     * Builds the final render options object used by the integration-specific
-     * renderer.
-     *
-     * The returned object contains normalized page data, processed dependency
-     * state, component render artifacts, and the locals contract expected by the
-     * rest of the pipeline.
-     *
-     * @typeParam C Integration render output element type.
-     * @param routeOptions Route-level render inputs.
-     * @param currentIntegrationName Active integration name for this preparation pass.
-     * @param callbacks Renderer-specific hooks used during preparation.
-     * @returns Normalized render options.
-     */
-    prepare<C = EcoPagesElement>(routeOptions: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderPreparationCallbacks): Promise<IntegrationRendererRenderOptions<C>>;
-    /**
-     * Collects resolved lazy trigger metadata from the component tree.
-     *
-     * Traversal is depth-first and deduplicated by component identity so shared
-     * component dependencies do not emit duplicate trigger sets.
-     *
-     * @param components Root component set.
-     * @param seen Internal visited set for shared graphs.
-     * @returns All resolved lazy triggers reachable from the root set.
-     */
-    private collectResolvedTriggers;
-    /**
-     * Collects global integration dependencies used by nested components belonging
-     * to integrations other than the current renderer.
-     *
-     * @param components Root component set.
-     * @returns Processed integration dependencies contributed by nested integrations.
-     */
-    private collectUsedIntegrationDependencies;
-    /**
-     * Discovers integration names referenced by the component dependency graph.
-     *
-     * @param components Root component set.
-     * @param seen Internal visited set for shared graphs.
-     * @returns Set of integration names found in the graph.
-     */
-    private collectIntegrationNames;
-    /**
-     * Renders the page root through the component-level render contract so any
-     * integration-specific assets and root attributes are available before the main
-     * document render.
-     *
-     * @param input Page root render inputs.
-     * @returns Structured component render result.
-     */
-    private renderPageRoot;
-    /**
-     * Builds the runtime assets needed to bootstrap global lazy trigger execution.
-     *
-     * @param triggers Fully resolved lazy trigger definitions.
-     * @returns Processed assets that should be merged into the final dependency set.
-     */
-    private buildGlobalInjectorAssets;
-}
-export {};

package/src/route-renderer/render-preparation.service.js

@@ -1,243 +0,0 @@
-import { createRequire } from "node:module";
-import {
-  AssetFactory
-} from "../services/asset-processing-service/index.js";
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../eco/global-injector-map.js";
-import { runWithComponentRenderContext } from "../eco/component-render-context.js";
-const coreRequire = createRequire(import.meta.url);
-class RenderPreparationService {
-  constructor(appConfig, assetProcessingService) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-  }
-  /**
-   * Builds the final render options object used by the integration-specific
-   * renderer.
-   *
-   * The returned object contains normalized page data, processed dependency
-   * state, component render artifacts, and the locals contract expected by the
-   * rest of the pipeline.
-   *
-   * @typeParam C Integration render output element type.
-   * @param routeOptions Route-level render inputs.
-   * @param currentIntegrationName Active integration name for this preparation pass.
-   * @param callbacks Renderer-specific hooks used during preparation.
-   * @returns Normalized render options.
-   */
-  async prepare(routeOptions, currentIntegrationName, callbacks) {
-    const pageModule = await callbacks.resolvePageModule(routeOptions.file);
-    const { Page, integrationSpecificProps } = pageModule;
-    const HtmlTemplate = await callbacks.getHtmlTemplate();
-    const { props, metadata } = await callbacks.resolvePageData(pageModule, routeOptions);
-    const Layout = Page.config?.layout;
-    const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
-    const resolvedDependencies = await callbacks.resolveDependencies(componentsToResolve);
-    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(
-      componentsToResolve,
-      currentIntegrationName
-    );
-    const pageDeps = await callbacks.buildRouteRenderAssets(routeOptions.file) || [];
-    const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
-    let componentRender;
-    if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
-      componentRender = await this.renderPageRoot({
-        currentIntegrationName,
-        Page,
-        props,
-        routeOptions,
-        callbacks
-      });
-      if (componentRender.assets?.length) {
-        allDependencies.push(...componentRender.assets);
-      }
-    }
-    const triggers = this.collectResolvedTriggers(componentsToResolve);
-    if (triggers.length > 0) {
-      const globalAssets = await this.buildGlobalInjectorAssets(triggers, currentIntegrationName);
-      allDependencies.push(...globalAssets);
-    }
-    callbacks.setProcessedDependencies(callbacks.dedupeProcessedAssets(allDependencies));
-    const pageProps = {
-      ...props,
-      params: routeOptions.params || {},
-      query: routeOptions.query || {}
-    };
-    const cacheStrategy = Page.cache;
-    const defaultCacheStrategy = this.appConfig.cache?.defaultStrategy ?? "static";
-    const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
-    const localsAvailable = effectiveCacheStrategy === "dynamic" && routeOptions.locals !== void 0;
-    const pageLocals = localsAvailable ? routeOptions.locals : callbacks.createPageLocalsProxy(routeOptions.file);
-    const locals = localsAvailable ? routeOptions.locals : void 0;
-    const preparedOptions = {
-      ...routeOptions,
-      resolvedDependencies,
-      componentRender,
-      HtmlTemplate,
-      Layout,
-      props,
-      Page,
-      metadata,
-      params: routeOptions.params || {},
-      query: routeOptions.query || {},
-      pageProps,
-      locals,
-      pageLocals,
-      cacheStrategy
-    };
-    return {
-      ...integrationSpecificProps,
-      ...preparedOptions
-    };
-  }
-  /**
-   * Collects resolved lazy trigger metadata from the component tree.
-   *
-   * Traversal is depth-first and deduplicated by component identity so shared
-   * component dependencies do not emit duplicate trigger sets.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns All resolved lazy triggers reachable from the root set.
-   */
-  collectResolvedTriggers(components, seen = /* @__PURE__ */ new Set()) {
-    const triggers = [];
-    for (const comp of components) {
-      const ecoComp = comp;
-      if (seen.has(ecoComp)) {
-        continue;
-      }
-      seen.add(ecoComp);
-      const ownTriggers = ecoComp.config?._resolvedLazyTriggers;
-      if (ownTriggers?.length) {
-        triggers.push(...ownTriggers);
-      }
-      const nested = ecoComp.config?.dependencies?.components;
-      if (nested?.length) {
-        triggers.push(...this.collectResolvedTriggers(nested, seen));
-      }
-    }
-    return triggers;
-  }
-  /**
-   * Collects global integration dependencies used by nested components belonging
-   * to integrations other than the current renderer.
-   *
-   * @param components Root component set.
-   * @returns Processed integration dependencies contributed by nested integrations.
-   */
-  collectUsedIntegrationDependencies(components, currentIntegrationName) {
-    const integrationNames = this.collectIntegrationNames(components);
-    const dependencies = [];
-    for (const integrationName of integrationNames) {
-      if (integrationName === currentIntegrationName) {
-        continue;
-      }
-      const integrationPlugin = this.appConfig.integrations.find(
-        (integration) => integration.name === integrationName
-      );
-      if (!integrationPlugin || typeof integrationPlugin.getResolvedIntegrationDependencies !== "function") {
-        continue;
-      }
-      dependencies.push(...integrationPlugin.getResolvedIntegrationDependencies());
-    }
-    return dependencies;
-  }
-  /**
-   * Discovers integration names referenced by the component dependency graph.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns Set of integration names found in the graph.
-   */
-  collectIntegrationNames(components, seen = /* @__PURE__ */ new Set()) {
-    const integrationNames = /* @__PURE__ */ new Set();
-    for (const comp of components) {
-      const ecoComp = comp;
-      if (seen.has(ecoComp)) {
-        continue;
-      }
-      seen.add(ecoComp);
-      const integrationName = ecoComp.config?.integration ?? ecoComp.config?.__eco?.integration;
-      if (integrationName) {
-        integrationNames.add(integrationName);
-      }
-      const nested = ecoComp.config?.dependencies?.components;
-      if (nested?.length) {
-        const nestedNames = this.collectIntegrationNames(nested, seen);
-        for (const nestedName of nestedNames) {
-          integrationNames.add(nestedName);
-        }
-      }
-    }
-    return integrationNames;
-  }
-  /**
-   * Renders the page root through the component-level render contract so any
-   * integration-specific assets and root attributes are available before the main
-   * document render.
-   *
-   * @param input Page root render inputs.
-   * @returns Structured component render result.
-   */
-  async renderPageRoot(input) {
-    const execution = await runWithComponentRenderContext(
-      {
-        currentIntegration: input.currentIntegrationName,
-        boundaryContext: input.callbacks.getComponentRenderBoundaryContext()
-      },
-      async () => input.callbacks.renderPageComponent({
-        component: input.Page,
-        props: {
-          ...input.props,
-          params: input.routeOptions.params || {},
-          query: input.routeOptions.query || {}
-        }
-      })
-    );
-    return execution.value;
-  }
-  /**
-   * Builds the runtime assets needed to bootstrap global lazy trigger execution.
-   *
-   * @param triggers Fully resolved lazy trigger definitions.
-   * @returns Processed assets that should be merged into the final dependency set.
-   */
-  async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
-    const globalInjectorImportPath = coreRequire.resolve("@ecopages/scripts-injector/global");
-    const globalInjectorRuntimeAsset = AssetFactory.createNodeModuleScript({
-      position: "head",
-      name: "ecopages-scripts-injector-global",
-      importPath: globalInjectorImportPath,
-      excludeFromHtml: true
-    });
-    const [globalInjectorRuntimeProcessed] = await this.assetProcessingService.processDependencies(
-      [globalInjectorRuntimeAsset],
-      currentIntegrationName
-    );
-    const globalInjectorModuleUrl = globalInjectorRuntimeProcessed?.srcUrl;
-    if (!globalInjectorModuleUrl) {
-      throw new Error("[ecopages] Failed to resolve global injector runtime asset URL.");
-    }
-    const mapScript = AssetFactory.createInlineContentScript({
-      position: "head",
-      name: "ecopages-global-injector-map",
-      content: buildGlobalInjectorMapScript(triggers),
-      attributes: { type: "ecopages/global-injector-map" },
-      bundle: false
-    });
-    const bootstrapScript = AssetFactory.createContentScript({
-      position: "head",
-      name: "ecopages-global-injector-bootstrap",
-      content: buildGlobalInjectorBootstrapContent(globalInjectorModuleUrl),
-      attributes: { type: "module" },
-      bundle: false
-    });
-    return this.assetProcessingService.processDependencies(
-      [mapScript, bootstrapScript, globalInjectorRuntimeAsset],
-      currentIntegrationName
-    );
-  }
-}
-export {
-  RenderPreparationService
-};