@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

package/src/route-renderer/orchestration/foreign-subtree-execution.service.js

@@ -0,0 +1,233 @@
+import {
+  getComponentRenderContext,
+  runWithComponentRenderContext
+} from "./component-render-context.js";
+import {
+  QueuedForeignSubtreeResolutionService
+} from "./queued-foreign-subtree-resolution.service.js";
+function isMarkupNodeLike(value) {
+  return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number" && (!("outerHTML" in value) || typeof value.outerHTML === "string");
+}
+class ForeignSubtreeExecutionService {
+  queuedForeignSubtreeResolutionService;
+  constructor(queuedForeignSubtreeResolutionService = new QueuedForeignSubtreeResolutionService()) {
+    this.queuedForeignSubtreeResolutionService = queuedForeignSubtreeResolutionService;
+  }
+  requiresForeignChildRuntime(input) {
+    const children = input.children ?? input.props.children;
+    if (children === void 0 || children === null) {
+      return false;
+    }
+    if (typeof children === "string") {
+      return false;
+    }
+    if (typeof children !== "object") {
+      return false;
+    }
+    return !isMarkupNodeLike(children);
+  }
+  /**
+   * Returns whether the current render pass must hand the child off to a foreign owner.
+   */
+  shouldDelegateForeignChild(input) {
+    return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
+  }
+  /**
+   * Creates the base runtime used when a renderer has not supplied its own queueing runtime.
+   *
+   * The runtime allows same-integration children to continue inline and fails fast
+   * when execution crosses into a foreign owner without a renderer-owned handoff.
+   */
+  createFailFastRuntime(rendererName) {
+    const interceptForeignChild = (input) => {
+      if (!this.shouldDelegateForeignChild(input)) {
+        return {
+          kind: "inline",
+          props: "props" in input && input.props ? { ...input.props } : void 0
+        };
+      }
+      throw new Error(
+        `[ecopages] ${rendererName} renderer crossed into ${input.targetIntegration} without a renderer-owned foreign-child runtime. Override createForeignChildRuntime() to resolve foreign children inside the owning renderer.`
+      );
+    };
+    return {
+      interceptForeignChild,
+      interceptForeignChildSync: interceptForeignChild
+    };
+  }
+  getQueuedRuntimeContext(input, runtimeContextKey) {
+    return this.queuedForeignSubtreeResolutionService.getRuntimeContext(input, runtimeContextKey);
+  }
+  createQueuedRuntime(options) {
+    return this.queuedForeignSubtreeResolutionService.createRuntime({
+      renderInput: options.renderInput,
+      rendererCache: options.rendererCache,
+      runtimeContextKey: options.runtimeContextKey,
+      tokenPrefix: options.tokenPrefix,
+      shouldQueueForeignChild: (input) => this.shouldDelegateForeignChild(input),
+      createRuntimeContext: options.createRuntimeContext
+    });
+  }
+  /**
+   * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
+   */
+  async resolveStringQueuedHtml(options) {
+    const runtimeContext = this.getQueuedRuntimeContext(options.renderInput, options.runtimeContextKey);
+    return this.resolveQueuedHtml({
+      currentIntegrationName: options.currentIntegrationName,
+      html: options.html,
+      runtimeContext,
+      queueLabel: options.queueLabel,
+      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+        if (children === void 0) {
+          return { assets: [], html: void 0 };
+        }
+        if (typeof children !== "string" && !isMarkupNodeLike(children)) {
+          return { assets: [], children };
+        }
+        const html = await this.resolveQueuedTokens(
+          typeof children === "string" ? children : children.outerHTML ?? String(children ?? ""),
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        return { assets: [], html };
+      },
+      getOwningRenderer: options.getOwningRenderer,
+      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+      dedupeProcessedAssets: options.dedupeProcessedAssets
+    });
+  }
+  async resolveQueuedHtml(options) {
+    return this.queuedForeignSubtreeResolutionService.resolveQueuedHtml({
+      html: options.html,
+      runtimeContext: options.runtimeContext,
+      queueLabel: options.queueLabel,
+      renderQueuedChildren: options.renderQueuedChildren,
+      resolveForeignSubtree: (input, rendererCache) => this.resolveForeignSubtreeInOwningRenderer({
+        currentIntegrationName: options.currentIntegrationName,
+        input,
+        rendererCache,
+        getOwningRenderer: options.getOwningRenderer
+      }),
+      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+      dedupeProcessedAssets: options.dedupeProcessedAssets
+    });
+  }
+  /**
+   * Executes one component render with Foreign Child support under the current integration.
+   */
+  async executeComponentRender(options) {
+    const rendererCache = this.getRendererCache(options.input.integrationContext) ?? /* @__PURE__ */ new Map();
+    const delegatedForeignChildRender = await this.resolveForeignChildInOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache,
+      getOwningRenderer: options.getOwningRenderer
+    });
+    if (delegatedForeignChildRender) {
+      return delegatedForeignChildRender;
+    }
+    const hasForeignChildren = options.hasForeignChildDescendants(options.input.component) || this.requiresForeignChildRuntime(options.input);
+    const activeRenderContext = getComponentRenderContext();
+    if (!hasForeignChildren) {
+      if (!activeRenderContext || activeRenderContext.currentIntegration === options.currentIntegrationName) {
+        return options.normalizeComponentRenderOutput(await options.renderComponent(options.input));
+      }
+      const sameIntegrationExecution = await runWithComponentRenderContext(
+        {
+          currentIntegration: options.currentIntegrationName
+        },
+        async () => options.renderComponent(options.input)
+      );
+      return options.normalizeComponentRenderOutput(sameIntegrationExecution.value);
+    }
+    const execution = await runWithComponentRenderContext(
+      {
+        currentIntegration: options.currentIntegrationName,
+        foreignChildRuntime: options.createForeignChildRuntime({
+          renderInput: options.input,
+          rendererCache
+        })
+      },
+      async () => options.renderComponent(options.input)
+    );
+    return options.normalizeComponentRenderOutput(execution.value);
+  }
+  getRendererCache(integrationContext) {
+    if (integrationContext?.rendererCache instanceof Map) {
+      return integrationContext.rendererCache;
+    }
+    return void 0;
+  }
+  withRendererCache(input, rendererCache) {
+    const integrationContext = input.integrationContext;
+    const sharedRendererCache = rendererCache;
+    return {
+      ...input,
+      integrationContext: integrationContext ? { ...integrationContext, rendererCache: sharedRendererCache } : { rendererCache: sharedRendererCache }
+    };
+  }
+  /**
+   * Returns the delegatable owning renderer integration for one component.
+   *
+   * The pseudo `html` integration marks document-shell ownership only and does
+   * not participate in component-level foreign subtree execution.
+   */
+  getForeignOwnerIntegrationName(component, currentIntegrationName) {
+    const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
+    if (!integrationName || integrationName === "html" || integrationName === currentIntegrationName) {
+      return void 0;
+    }
+    return integrationName;
+  }
+  async resolveForeignChildInOwningRenderer(options) {
+    return await this.runInForeignOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache: options.rendererCache,
+      getOwningRenderer: options.getOwningRenderer,
+      run: (owningRenderer, delegatedInput) => owningRenderer.renderComponentWithForeignChildren(delegatedInput)
+    });
+  }
+  async resolveForeignSubtreeInOwningRenderer(options) {
+    return await this.runInForeignOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache: options.rendererCache,
+      getOwningRenderer: options.getOwningRenderer,
+      run: (owningRenderer, delegatedInput) => owningRenderer.renderForeignSubtree(delegatedInput)
+    });
+  }
+  async runInForeignOwningRenderer(options) {
+    const foreignOwnerIntegrationName = this.getForeignOwnerIntegrationName(
+      options.input.component,
+      options.currentIntegrationName
+    );
+    if (!foreignOwnerIntegrationName) {
+      return void 0;
+    }
+    const owningRenderer = options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
+    if (owningRenderer.name === options.currentIntegrationName) {
+      return void 0;
+    }
+    const delegatedInputWithCache = this.withRendererCache(options.input, options.rendererCache);
+    const delegatedChildren = delegatedInputWithCache.children ?? delegatedInputWithCache.props.children;
+    return await options.run(owningRenderer, {
+      ...delegatedInputWithCache,
+      children: delegatedChildren
+    });
+  }
+  async resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken) {
+    let resolvedHtml = html;
+    for (const token of queuedResolutionsByToken.keys()) {
+      if (!resolvedHtml.includes(token)) {
+        continue;
+      }
+      resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
+    }
+    return resolvedHtml;
+  }
+}
+export {
+  ForeignSubtreeExecutionService
+};