@ecopages/lit 0.2.0-beta.4 → 0.2.0-beta.41

package/src/lit-renderer.js

@@ -1,236 +1,227 @@
-import "./dom-shim.js";
-import { IntegrationRenderer } from "@ecopages/core/route-renderer/integration-renderer";
-import { LitSsrLazyPreloader } from "./lit-ssr-lazy-preloader.js";
-import { LIT_PLUGIN_NAME } from "./lit.constants.js";
-import {
-  injectLitRenderedChildren,
-  LIT_COMPONENT_CHILDREN_SLOT_MARKER,
-  normalizeLitHtml,
-  renderLitValueToString
-} from "./utils/lit-html-rendering.js";
-class LitRenderer extends IntegrationRenderer {
-  name = LIT_PLUGIN_NAME;
-  isFunctionComponent(component) {
-    return typeof component === "function";
-  }
-  async resolveQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken) {
-    if (children === void 0) {
-      return void 0;
+/**
+ * This module contains the Lit renderer
+ * @module
+ */
+import './dom-shim.js';
+import { IntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/integration-renderer';
+import { getForeignSubtreeResolutionContextKey, resolveOwningIntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/foreign-child/owning-renderer-resolution';
+import { LitSsrLazyPreloader } from './lit-ssr-lazy-preloader.js';
+import { LIT_PLUGIN_NAME } from './lit.constants.js';
+import { injectLitRenderedChildren, LIT_COMPONENT_CHILDREN_SLOT_MARKER, normalizeLitHtml, renderLitValueToString, } from './utils/lit-html-rendering.js';
+/**
+ * A renderer for the Lit integration.
+ */
+export class LitRenderer extends IntegrationRenderer {
+    name = LIT_PLUGIN_NAME;
+    getRenderSession;
+    constructor(options) {
+        const { getRenderSession, ...rendererOptions } = options;
+        super(rendererOptions);
+        this.getRenderSession = getRenderSession;
     }
-    if (typeof children !== "string") {
-      return children;
+    /**
+     * Renders a Lit page route, preferring the plugin worker when available.
+     *
+     * @remarks
+     * Activates the integration runtime before reading {@link getRenderSession}
+     * so a renderer constructed before plugin setup still sees the session.
+     * When `options.locals` is present, rendering stays in-process: request locals
+     * are not structured-cloned across the worker boundary.
+     */
+    async execute(options) {
+        await this.ensureIntegrationRuntimeActivated();
+        const renderSession = this.getRenderSession?.();
+        if (renderSession && options.locals === undefined) {
+            const params = options.params ?? {};
+            const result = await renderSession.renderPageInWorker({
+                filePath: options.file,
+                params,
+                query: options.query,
+            });
+            return {
+                body: result.html,
+                cacheStrategy: result.cacheStrategy,
+            };
+        }
+        return super.execute(options);
     }
-    let renderedChildren = children;
-    renderedChildren = await this.foreignSubtreeExecutionService.resolveQueuedTokens(
-      renderedChildren,
-      queuedResolutionsByToken,
-      resolveToken
-    );
-    return renderedChildren;
-  }
-  async resolveQueuedForeignSubtreeHtml(html, runtimeContext) {
-    const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveQueuedHtml({
-      currentIntegrationName: this.name,
-      html,
-      runtimeContext,
-      queueLabel: "Lit",
-      getOwningRenderer: (integrationName, rendererCache) => this.getIntegrationRendererForName(integrationName, rendererCache),
-      applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
-      dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
-        const renderedChildren = await this.resolveQueuedForeignSubtreeChildren(
-          children,
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        if (typeof renderedChildren !== "string") {
-          return {
-            assets: [],
-            children: renderedChildren
-          };
+    isFunctionComponent(component) {
+        return typeof component === 'function';
+    }
+    async resolveQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken) {
+        if (children === undefined) {
+            return undefined;
+        }
+        if (typeof children !== 'string') {
+            return children;
+        }
+        let renderedChildren = children;
+        renderedChildren = await this.foreignSubtreeExecutionService.resolveQueuedTokens(renderedChildren, queuedResolutionsByToken, resolveToken);
+        return renderedChildren;
+    }
+    async renderLitQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken) {
+        const renderedChildren = await this.resolveQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken);
+        if (typeof renderedChildren !== 'string') {
+            return {
+                assets: [],
+                children: renderedChildren,
+            };
         }
         return {
-          assets: [],
-          html: renderedChildren
+            assets: [],
+            html: renderedChildren,
         };
-      }
+    }
+    /**
+     * Renders a Lit component for component-level orchestration.
+     *
+     * SSR-eligible lazy scripts are preloaded first so custom elements registered
+     * by the component can render their server markup even when the Lit renderer is
+     * entered through cross-integration foreign-child handoff.
+     *
+     * Includes component-scoped dependency assets when declared.
+     */
+    async renderComponent(input) {
+        await this.preloadSsrLazyScripts([input.component]);
+        if (!this.isFunctionComponent(input.component)) {
+            throw new TypeError('Lit renderer expected a callable component.');
+        }
+        const component = input.component;
+        let renderedChildren;
+        if (input.children !== undefined) {
+            renderedChildren =
+                typeof input.children === 'string' ? input.children : await renderLitValueToString(input.children);
+        }
+        let props = input.props;
+        if (renderedChildren !== undefined) {
+            props = {
+                ...input.props,
+                children: LIT_COMPONENT_CHILDREN_SLOT_MARKER,
+            };
+        }
+        const content = await component(props);
+        const renderedHtml = await renderLitValueToString(content);
+        const html = renderedChildren === undefined ? renderedHtml : injectLitRenderedChildren(renderedHtml, renderedChildren);
+        const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveQueuedHtml({
+            currentIntegrationName: this.name,
+            html,
+            runtimeContext: this.foreignSubtreeExecutionService.getQueuedRuntimeContext(input, getForeignSubtreeResolutionContextKey(this.name)),
+            queueLabel: 'Lit',
+            getOwningRenderer: (integrationName, rendererCache) => resolveOwningIntegrationRenderer({
+                appConfig: this.appConfig,
+                runtimeOrigin: this.runtimeOrigin,
+                currentIntegrationName: this.name,
+                currentRenderer: this,
+                integrationName,
+                cache: rendererCache,
+            }),
+            applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
+            dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
+            renderQueuedChildren: (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.renderLitQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken),
+        });
+        const hasDependencies = Boolean(input.component.config?.dependencies);
+        const canResolveAssets = typeof this.assetProcessingService?.processDependencies === 'function';
+        const assets = hasDependencies && canResolveAssets
+            ? await this.processComponentDependencies([input.component])
+            : undefined;
+        return this.finalizeIslandComponentRender(input, {
+            html: queuedForeignSubtreeResolution.html,
+            canAttachAttributes: true,
+            rootTag: this.getRootTagName(queuedForeignSubtreeResolution.html),
+            integrationName: this.name,
+            assets: this.htmlTransformer.dedupeProcessedAssets([
+                ...(assets ?? []),
+                ...queuedForeignSubtreeResolution.assets,
+            ]),
+        });
+    }
+    ssrLazyPreloader = new LitSsrLazyPreloader({
+        resolveDependencyPath: this.resolveDependencyPath.bind(this),
+        processDependencies: this.assetProcessingService?.processDependencies?.bind(this.assetProcessingService),
     });
-    return {
-      html: queuedForeignSubtreeResolution.html,
-      assets: queuedForeignSubtreeResolution.assets.length > 0 ? queuedForeignSubtreeResolution.assets : void 0
-    };
-  }
-  shouldRenderPageComponent() {
-    return false;
-  }
-  isLitManagedComponent(component) {
-    return component?.config?.integration === this.name || component?.config?.__eco?.integration === this.name;
-  }
-  /**
-   * Renders a Lit component for component-level orchestration.
-   *
-   * SSR-eligible lazy scripts are preloaded first so custom elements registered
-   * by the component can render their server markup even when the Lit renderer is
-   * entered through cross-integration foreign-child handoff.
-   *
-   * Includes component-scoped dependency assets when declared.
-   */
-  async renderComponent(input) {
-    await this.preloadSsrLazyScripts([input.component]);
-    if (!this.isFunctionComponent(input.component)) {
-      throw new TypeError("Lit renderer expected a callable component.");
+    /**
+     * Detects preload failures that are expected for browser-only modules.
+     *
+     * These errors are treated as non-fatal during SSR preload because some
+     * lazy client scripts intentionally depend on browser globals.
+     */
+    isExpectedSsrPreloadError(error) {
+        return this.ssrLazyPreloader.isExpectedSsrPreloadError(error);
     }
-    const component = input.component;
-    let renderedChildren;
-    if (input.children !== void 0) {
-      renderedChildren = typeof input.children === "string" ? input.children : await renderLitValueToString(input.children);
+    /**
+     * Collects lazy script file paths eligible for SSR preloading.
+     *
+     * Only per-entry lazy script dependencies with `ssr: true` are collected.
+     * File-backed entries are required (`src` must be present);
+     * inline content lazy entries are intentionally skipped.
+     */
+    collectSsrPreloadScripts(components) {
+        return this.ssrLazyPreloader.collectSsrPreloadScripts(components);
     }
-    let props = input.props;
-    if (renderedChildren !== void 0) {
-      props = {
-        ...input.props,
-        children: LIT_COMPONENT_CHILDREN_SLOT_MARKER
-      };
+    /**
+     * Preloads SSR-eligible lazy scripts to register custom elements before render.
+     */
+    async preloadSsrLazyScripts(components) {
+        const renderSession = this.getRenderSession?.();
+        if (renderSession) {
+            await renderSession.preloadSsrLazyScripts(components);
+            return;
+        }
+        await this.ssrLazyPreloader.preloadSsrLazyScripts(components);
     }
-    const content = await component(props);
-    const renderedHtml = await renderLitValueToString(content);
-    const html = renderedChildren === void 0 ? renderedHtml : injectLitRenderedChildren(renderedHtml, renderedChildren);
-    const queuedForeignSubtreeResolution = await this.resolveQueuedForeignSubtreeHtml(
-      html,
-      this.getQueuedForeignSubtreeResolutionContext(input)
-    );
-    const hasDependencies = Boolean(input.component.config?.dependencies);
-    const canResolveAssets = typeof this.assetProcessingService?.processDependencies === "function";
-    const assets = hasDependencies && canResolveAssets ? await this.processComponentDependencies([input.component]) : void 0;
-    return {
-      html: queuedForeignSubtreeResolution.html,
-      canAttachAttributes: true,
-      rootTag: this.getRootTagName(queuedForeignSubtreeResolution.html),
-      integrationName: this.name,
-      assets: this.htmlTransformer.dedupeProcessedAssets([
-        ...assets ?? [],
-        ...queuedForeignSubtreeResolution.assets ?? []
-      ])
-    };
-  }
-  ssrLazyPreloader = new LitSsrLazyPreloader({
-    resolveDependencyPath: this.resolveDependencyPath.bind(this),
-    processDependencies: this.assetProcessingService?.processDependencies?.bind(this.assetProcessingService)
-  });
-  /**
-   * Detects preload failures that are expected for browser-only modules.
-   *
-   * These errors are treated as non-fatal during SSR preload because some
-   * lazy client scripts intentionally depend on browser globals.
-   */
-  isExpectedSsrPreloadError(error) {
-    return this.ssrLazyPreloader.isExpectedSsrPreloadError(error);
-  }
-  /**
-   * Collects lazy script file paths eligible for SSR preloading.
-   *
-   * Only per-entry lazy script dependencies with `ssr: true` are collected.
-   * File-backed entries are required (`src` must be present);
-   * inline content lazy entries are intentionally skipped.
-   */
-  collectSsrPreloadScripts(components) {
-    return this.ssrLazyPreloader.collectSsrPreloadScripts(components);
-  }
-  /**
-   * Preloads SSR-eligible lazy scripts to register custom elements before render.
-   */
-  async preloadSsrLazyScripts(components) {
-    await this.ssrLazyPreloader.preloadSsrLazyScripts(components);
-  }
-  /**
-   * Resolves the concrete JS entrypoint used for SSR preloading.
-   *
-   * Scripts are passed through the asset pipeline so preload imports can use
-   * the same processed output shape as runtime dependencies.
-   */
-  async resolveSsrPreloadEntrypoint(scriptPath) {
-    return this.ssrLazyPreloader.resolveSsrPreloadEntrypoint(scriptPath);
-  }
-  async render({
-    params,
-    query,
-    props,
-    locals,
-    metadata,
-    Page,
-    Layout,
-    HtmlTemplate
-  }) {
-    try {
-      await this.preloadSsrLazyScripts([Page, Layout]);
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: Page,
-          props: {
-            params,
-            query,
-            ...props,
-            locals
-          }
-        },
-        layout: Layout ? {
-          component: Layout,
-          props: locals ? { locals } : {}
-        } : void 0,
-        htmlTemplate: HtmlTemplate,
-        metadata,
-        pageProps: props || {},
-        transformDocumentHtml: normalizeLitHtml
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
+    /**
+     * Resolves the concrete JS entrypoint used for SSR preloading.
+     *
+     * Scripts are passed through the asset pipeline so preload imports can use
+     * the same processed output shape as runtime dependencies.
+     */
+    async resolveSsrPreloadEntrypoint(scriptPath) {
+        return this.ssrLazyPreloader.resolveSsrPreloadEntrypoint(scriptPath);
     }
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      if (ctx.partial) {
-        return this.renderPartialViewResponse({
-          view,
-          props,
-          ctx,
-          transformHtml: normalizeLitHtml
-        });
-      }
-      const viewConfig = view.config;
-      const Layout = viewConfig?.layout;
-      const HtmlTemplate = await this.getHtmlTemplate();
-      const metadata = await this.resolveViewMetadata(view, props);
-      const normalizedProps = props ?? {};
-      await this.preloadSsrLazyScripts([view, Layout]);
-      await this.prepareViewDependencies(view, Layout);
-      const pageRender = await this.renderComponentWithForeignChildren({
-        component: view,
-        props: normalizedProps
-      });
-      const layoutRender = Layout ? await this.renderComponentWithForeignChildren({
-        component: Layout,
-        props: {},
-        children: pageRender.html
-      }) : void 0;
-      const documentRender = await this.renderComponentWithForeignChildren({
-        component: HtmlTemplate,
-        props: {
-          metadata,
-          pageProps: normalizedProps
-        },
-        children: layoutRender?.html ?? pageRender.html
-      });
-      this.appendProcessedDependencies(pageRender.assets, layoutRender?.assets, documentRender.assets);
-      const body = await this.finalizeResolvedHtml({
-        html: `${this.DOC_TYPE}${normalizeLitHtml(documentRender.html)}`,
-        partial: false
-      });
-      return this.createHtmlResponse(body, ctx);
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
+    async render({ params, query, props, locals, metadata, Page, Layout, HtmlTemplate, }) {
+        try {
+            await this.preloadSsrLazyScripts([Page, Layout]);
+            return await this.renderPageWithDocumentShell({
+                page: {
+                    component: Page,
+                    props: {
+                        params,
+                        query,
+                        ...props,
+                        locals,
+                    },
+                },
+                layout: Layout
+                    ? {
+                        component: Layout,
+                        props: locals ? { locals } : {},
+                    }
+                    : undefined,
+                htmlTemplate: HtmlTemplate,
+                metadata,
+                pageProps: props || {},
+                transformDocumentHtml: normalizeLitHtml,
+            });
+        }
+        catch (error) {
+            throw this.createRenderError('Error rendering page', error);
+        }
+    }
+    async renderToResponse(view, props, ctx) {
+        try {
+            const layouts = view.config?.layouts;
+            const Layout = layouts?.[layouts.length - 1];
+            await this.preloadSsrLazyScripts([view, Layout]);
+            return await this.renderViewWithDocumentShell({
+                view,
+                props,
+                ctx,
+                layout: Layout,
+                transformDocumentHtml: normalizeLitHtml,
+            });
+        }
+        catch (error) {
+            throw this.createRenderError('Error rendering view', error);
+        }
     }
-  }
 }
-export {
-  LitRenderer
-};

package/src/lit-ssr-lazy-preloader.d.ts

@@ -1,4 +1,4 @@
-import type { EcoComponent } from '@ecopages/core';
+import { type EcoComponent } from '@ecopages/core';
 import type { AssetDefinition } from '@ecopages/core/services/asset-processing-service';
 type ProcessDependencies = (dependencies: AssetDefinition[], integrationName: string) => Promise<Array<{
     filepath?: string;