@ecopages/core 0.2.0-alpha.23 → 0.2.0-alpha.24

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

@@ -1,341 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import {
-  AssetFactory
-} from "../../services/assets/asset-processing-service/index.js";
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
-import { BoundaryPlanningService } from "./boundary-planning.service.js";
-class RenderPreparationService {
-  appConfig;
-  assetProcessingService;
-  boundaryPlanningService;
-  /**
-   * Creates the render-preparation orchestrator for one app instance.
-   *
-   * @remarks
-   * The service is app-scoped because it depends on finalized config defaults and
-   * the app-owned asset-processing pipeline while remaining renderer-agnostic.
-   */
-  constructor(appConfig, assetProcessingService, dependencies = {}) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-    this.boundaryPlanningService = dependencies.boundaryPlanningService ?? new BoundaryPlanningService(appConfig);
-  }
-  /**
-   * 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 boundaryPlan = this.boundaryPlanningService.buildPlan({
-      routeFile: routeOptions.file,
-      currentIntegrationName,
-      HtmlTemplate,
-      Layout,
-      Page
-    });
-    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 })) {
-      const pageRootRender = await this.renderPageRoot({
-        Page,
-        props,
-        routeOptions,
-        callbacks
-      });
-      componentRender = pageRootRender.componentRender;
-      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);
-    }
-    const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, currentIntegrationName);
-    if (eagerSsrLazyAssets.length > 0) {
-      allDependencies.push(...eagerSsrLazyAssets);
-    }
-    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,
-      boundaryPlan
-    };
-    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) {
-      if (!comp) {
-        continue;
-      }
-      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) {
-      if (!comp) {
-        continue;
-      }
-      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) {
-    return {
-      componentRender: await input.callbacks.renderPageComponent({
-        component: input.Page,
-        props: {
-          ...input.props,
-          params: input.routeOptions.params || {},
-          query: input.routeOptions.query || {}
-        }
-      })
-    };
-  }
-  /**
-   * 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 = createRequire(import.meta.url).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
-    );
-  }
-  async buildEagerSsrLazyAssets(components, currentIntegrationName) {
-    const dependencies = this.collectEagerSsrLazyDependencies(components);
-    if (dependencies.length === 0) {
-      return [];
-    }
-    return this.assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
-  }
-  collectEagerSsrLazyDependencies(components) {
-    const dependencies = [];
-    const visitedConfigs = /* @__PURE__ */ new Set();
-    const seenKeys = /* @__PURE__ */ new Set();
-    const normalizeAttributes = (attributes) => ({
-      type: "module",
-      defer: "",
-      ...attributes ?? {}
-    });
-    const collect = (config) => {
-      if (!config || visitedConfigs.has(config)) {
-        return;
-      }
-      visitedConfigs.add(config);
-      const componentFile = config.__eco?.file;
-      if (componentFile) {
-        const componentDir = path.dirname(componentFile);
-        for (const script of config.dependencies?.scripts ?? []) {
-          if (typeof script === "string" || !script.lazy || script.ssr !== true) {
-            continue;
-          }
-          const attributes = normalizeAttributes(script.attributes);
-          if (script.content) {
-            const key2 = `content:${script.content}:${JSON.stringify(attributes)}`;
-            if (seenKeys.has(key2)) {
-              continue;
-            }
-            seenKeys.add(key2);
-            dependencies.push(
-              AssetFactory.createContentScript({
-                position: "head",
-                content: script.content,
-                attributes
-              })
-            );
-            continue;
-          }
-          if (!script.src) {
-            continue;
-          }
-          const resolvedPath = path.resolve(componentDir, script.src);
-          const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
-          if (seenKeys.has(key)) {
-            continue;
-          }
-          seenKeys.add(key);
-          dependencies.push(
-            AssetFactory.createFileScript({
-              filepath: resolvedPath,
-              position: "head",
-              attributes
-            })
-          );
-        }
-      }
-      if (config.layout?.config) {
-        collect(config.layout.config);
-      }
-      for (const nestedComponent of config.dependencies?.components ?? []) {
-        collect(nestedComponent?.config);
-      }
-    };
-    for (const component of components) {
-      collect(component.config);
-    }
-    return dependencies;
-  }
-}
-export {
-  RenderPreparationService
-};

package/src/route-renderer/orchestration/route-shell-composer.service.d.ts

@@ -1,50 +0,0 @@
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, HtmlTemplateProps, PageMetadataProps } from '../../types/public-types.js';
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import type { RenderToResponseContext } from './integration-renderer.js';
-export interface RouteShellComposerCallbacks {
-    hasForeignBoundaryDescendants(component: EcoComponent): boolean;
-    createHtmlResponse(body: BodyInit, ctx: RenderToResponseContext): Response;
-    renderComponentBoundary(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    prepareViewDependencies(view: EcoComponent, layout?: EcoComponent): Promise<ProcessedAsset[]>;
-    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-    resolveViewMetadata<P>(view: EcoComponent<P>, props: P): Promise<PageMetadataProps>;
-    appendProcessedDependencies(...assetGroups: Array<readonly ProcessedAsset[] | undefined>): ProcessedAsset[];
-    finalizeResolvedHtml(options: {
-        html: string;
-        partial?: boolean;
-        componentRootAttributes?: Record<string, string>;
-        documentAttributes?: Record<string, string>;
-        transformHtml?: boolean;
-    }): Promise<string>;
-    docType: string;
-}
-export declare class RouteShellComposer {
-    renderPartialViewResponse<P>(input: {
-        view: EcoComponent<P>;
-        props: P;
-        ctx: RenderToResponseContext;
-        renderInline?: () => Promise<BodyInit>;
-        transformHtml?: (html: string) => string;
-    }, callbacks: RouteShellComposerCallbacks): Promise<Response>;
-    renderViewWithDocumentShell<P>(input: {
-        view: EcoComponent<P>;
-        props: P;
-        ctx: RenderToResponseContext;
-        layout?: EcoComponent;
-    }, callbacks: RouteShellComposerCallbacks): Promise<Response>;
-    renderPageWithDocumentShell(input: {
-        page: {
-            component: EcoComponent;
-            props: Record<string, unknown>;
-        };
-        layout?: {
-            component: EcoComponent;
-            props?: Record<string, unknown>;
-        };
-        htmlTemplate: EcoComponent;
-        metadata: PageMetadataProps;
-        pageProps: Record<string, unknown>;
-        documentProps?: Record<string, unknown>;
-        transformDocumentHtml?: (html: string) => string;
-    }, callbacks: RouteShellComposerCallbacks): Promise<string>;
-}

package/src/route-renderer/orchestration/route-shell-composer.service.js

@@ -1,81 +0,0 @@
-class RouteShellComposer {
-  async renderPartialViewResponse(input, callbacks) {
-    if (input.renderInline && !callbacks.hasForeignBoundaryDescendants(input.view)) {
-      return callbacks.createHtmlResponse(await input.renderInline(), input.ctx);
-    }
-    const rendererCache = /* @__PURE__ */ new Map();
-    const viewRender = await callbacks.renderComponentBoundary({
-      component: input.view,
-      props: input.props ?? {},
-      integrationContext: { rendererCache }
-    });
-    const html = input.transformHtml ? input.transformHtml(viewRender.html) : viewRender.html;
-    return callbacks.createHtmlResponse(html, input.ctx);
-  }
-  async renderViewWithDocumentShell(input, callbacks) {
-    const normalizedProps = input.props ?? {};
-    if (input.ctx.partial) {
-      return this.renderPartialViewResponse(input, callbacks);
-    }
-    await callbacks.prepareViewDependencies(input.view, input.layout);
-    const HtmlTemplate = await callbacks.getHtmlTemplate();
-    const metadata = await callbacks.resolveViewMetadata(input.view, input.props);
-    const rendererCache = /* @__PURE__ */ new Map();
-    const viewRender = await callbacks.renderComponentBoundary({
-      component: input.view,
-      props: normalizedProps,
-      integrationContext: { rendererCache }
-    });
-    const layoutRender = input.layout ? await callbacks.renderComponentBoundary({
-      component: input.layout,
-      props: {},
-      children: viewRender.html,
-      integrationContext: { rendererCache }
-    }) : void 0;
-    const documentRender = await callbacks.renderComponentBoundary({
-      component: HtmlTemplate,
-      props: {
-        metadata,
-        pageProps: normalizedProps
-      },
-      children: layoutRender?.html ?? viewRender.html,
-      integrationContext: { rendererCache }
-    });
-    callbacks.appendProcessedDependencies(viewRender.assets, layoutRender?.assets, documentRender.assets);
-    const html = await callbacks.finalizeResolvedHtml({
-      html: `${callbacks.docType}${documentRender.html}`,
-      partial: false
-    });
-    return callbacks.createHtmlResponse(html, input.ctx);
-  }
-  async renderPageWithDocumentShell(input, callbacks) {
-    const rendererCache = /* @__PURE__ */ new Map();
-    const pageRender = await callbacks.renderComponentBoundary({
-      component: input.page.component,
-      props: input.page.props,
-      integrationContext: { rendererCache }
-    });
-    const layoutRender = input.layout ? await callbacks.renderComponentBoundary({
-      component: input.layout.component,
-      props: input.layout.props ?? {},
-      children: pageRender.html,
-      integrationContext: { rendererCache }
-    }) : void 0;
-    const documentRender = await callbacks.renderComponentBoundary({
-      component: input.htmlTemplate,
-      props: {
-        metadata: input.metadata,
-        pageProps: input.pageProps,
-        ...input.documentProps ?? {}
-      },
-      children: layoutRender?.html ?? pageRender.html,
-      integrationContext: { rendererCache }
-    });
-    callbacks.appendProcessedDependencies(pageRender.assets, layoutRender?.assets, documentRender.assets);
-    const documentHtml = input.transformDocumentHtml ? input.transformDocumentHtml(documentRender.html) : documentRender.html;
-    return `${callbacks.docType}${documentHtml}`;
-  }
-}
-export {
-  RouteShellComposer
-};

package/src/route-renderer/orchestration/template-serialization.d.ts

@@ -1,38 +0,0 @@
-/**
- * Minimal template-result shape that core can serialize generically.
- *
- * @remarks
- * Core intentionally models only the transport shape used during deferred
- * cross-integration child passing: alternating static string segments plus
- * interpolated runtime values. Concrete runtime markers that identify a given
- * framework's template payload must stay outside core and be registered by the
- * owning integration package.
- */
-export type SerializableTemplateShape = {
-    strings: readonly string[];
-    values?: readonly unknown[];
-};
-/**
- * Integration-owned adapter that teaches core how to serialize one deferred
- * template payload shape.
- *
- * @remarks
- * The separation here is intentional: core owns the HTML serialization logic,
- * but integrations own runtime-shape detection. That keeps package-specific
- * markers such as framework template sentinels out of core while still letting
- * deferred children round-trip through mixed renderer boundaries.
- */
-export type DeferredTemplateSerializer<TTemplate extends SerializableTemplateShape = SerializableTemplateShape> = {
-    matches(value: unknown): value is TTemplate;
-    serialize(template: TTemplate, serializeValue: (value: unknown) => string | undefined): string;
-};
-/**
- * Serializes a generic template shape into HTML.
- *
- * @remarks
- * This handles only HTML reconstruction semantics: quoted attribute values,
- * boolean attributes, and omission of client-only event or property bindings.
- * It does not decide whether an arbitrary value belongs to a framework-specific
- * template runtime; integrations must make that decision before delegating here.
- */
-export declare function serializeTemplateShape(template: SerializableTemplateShape, serializeValue: (value: unknown) => string | undefined): string;

package/src/route-renderer/orchestration/template-serialization.js

@@ -1,45 +0,0 @@
-import { escapeHtmlAttribute } from "../../utils/html-escaping.js";
-const ATTRIBUTE_TAIL_PATTERN = /(\s+)([@.?!]?)([^\s"'<>/=`@.?!]+)=$/;
-function getSerializableTemplateAttribute(stringPart) {
-  const match = ATTRIBUTE_TAIL_PATTERN.exec(stringPart);
-  if (!match) return void 0;
-  return {
-    leading: stringPart.slice(0, match.index),
-    whitespace: match[1],
-    prefix: match[2],
-    name: match[3]
-  };
-}
-function serializeTemplateShape(template, serializeValue) {
-  const values = template.values ?? [];
-  let html = "";
-  for (let index = 0; index < values.length; index += 1) {
-    const stringPart = template.strings[index] ?? "";
-    const serializedValue = serializeValue(values[index]);
-    const attribute = getSerializableTemplateAttribute(stringPart);
-    if (!attribute) {
-      html += stringPart;
-      html += serializedValue ?? "";
-      continue;
-    }
-    html += attribute.leading;
-    if (attribute.prefix === "@" || attribute.prefix === "!" || attribute.prefix === ".") {
-      continue;
-    }
-    if (attribute.prefix === "?") {
-      if (serializedValue) {
-        html += `${attribute.whitespace}${attribute.name}`;
-      }
-      continue;
-    }
-    if (serializedValue === void 0) {
-      continue;
-    }
-    html += `${attribute.whitespace}${attribute.name}="${escapeHtmlAttribute(serializedValue)}"`;
-  }
-  html += template.strings[values.length] ?? "";
-  return html;
-}
-export {
-  serializeTemplateShape
-};

package/src/route-renderer/page-loading/dependency-resolver.d.ts

@@ -1,35 +0,0 @@
-import type { EcoComponent } from '../../types/public-types.js';
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-export declare const DEPENDENCY_ERRORS: {
-    readonly INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content";
-    readonly INVALID_SCRIPT_ENTRY: "Invalid script dependency entry: expected src or content";
-    readonly LAZY_SCRIPT_MISSING_SRC: "Lazy script dependency entry in dependencies.scripts requires a src value";
-};
-export declare class DependencyResolverService {
-    private appConfig;
-    private assetProcessingService;
-    /**
-     * Creates the dependency resolver used by route and component rendering.
-     *
-     * @remarks
-     * The resolver stays intentionally separate from HTML rendering so component
-     * dependency collection, lazy trigger grouping, and processed-asset generation
-     * can evolve without changing renderer implementations.
-     */
-    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService);
-    /**
-     * Resolves one dependency path relative to the component that declared it.
-     */
-    resolveDependencyPath(componentDir: string, pathUrl: string): string;
-    /**
-     * Maps lazy script source entries to deterministic fallback public URLs
-     * used when bundling output URLs are unavailable.
-     */
-    resolveLazyScripts(componentDir: string, scripts: string[]): string;
-    /**
-     * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
-     * Lazy dependencies are always resolved into global-injector trigger maps.
-     */
-    processComponentDependencies(components: Array<EcoComponent | Partial<EcoComponent> | undefined | null>, integrationName: string): Promise<ProcessedAsset[]>;
-}