@ecopages/core 0.2.0-beta.1 → 0.2.0-beta.10

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

@@ -1,170 +0,0 @@
-class QueuedForeignSubtreeResolutionService {
-  /**
-   * Reads the queued foreign-subtree runtime state previously attached to one render.
-   */
-  getRuntimeContext(input, runtimeContextKey) {
-    const integrationContext = input.integrationContext;
-    const runtimeContext = integrationContext?.[runtimeContextKey];
-    if (typeof runtimeContext !== "object" || runtimeContext === null) {
-      return void 0;
-    }
-    return runtimeContext;
-  }
-  /**
-   * Creates the runtime hook used by `runWithComponentRenderContext()` for one
-   * renderer-owned queue.
-   *
-   * When the renderer decides a foreign child must be handed off, the runtime returns
-   * a resolved transport token instead of rendering the foreign component inline.
-   */
-  createRuntime(options) {
-    const runtimeContext = this.ensureRuntimeContext(options);
-    const interceptForeignChild = (input) => {
-      if (!options.shouldQueueForeignChild(input)) {
-        return {
-          kind: "inline",
-          props: { ...input.props }
-        };
-      }
-      runtimeContext.nextForeignSubtreeId += 1;
-      const foreignSubtreeId = runtimeContext.nextForeignSubtreeId;
-      const token = this.createForeignSubtreeToken(options.tokenPrefix, runtimeContext, foreignSubtreeId);
-      runtimeContext.queuedResolutions.push({
-        token,
-        component: input.component,
-        props: { ...input.props },
-        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${foreignSubtreeId}` : `n_${foreignSubtreeId}`
-      });
-      return {
-        kind: "resolved",
-        value: token
-      };
-    };
-    return {
-      interceptForeignChild,
-      interceptForeignChildSync: interceptForeignChild
-    };
-  }
-  /**
-   * Resolves every queued transport token in one renderer-owned HTML fragment.
-   *
-   * The caller supplies framework-specific child rendering, while this service
-   * handles recursive token replacement, cycle detection, root-attribute
-   * application, and merged asset collection.
-   */
-  async resolveQueuedHtml(options) {
-    if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
-      return { assets: [], html: options.html };
-    }
-    const runtimeContext = options.runtimeContext;
-    const queuedResolutionsByToken = /* @__PURE__ */ new Map();
-    const resolvedHtmlByToken = /* @__PURE__ */ new Map();
-    const resolvingTokens = /* @__PURE__ */ new Set();
-    const collectedAssets = [];
-    const syncQueuedResolutions = () => {
-      for (const resolution of runtimeContext.queuedResolutions) {
-        if (!queuedResolutionsByToken.has(resolution.token)) {
-          queuedResolutionsByToken.set(resolution.token, resolution);
-        }
-      }
-    };
-    const resolveToken = async (token) => {
-      syncQueuedResolutions();
-      const cachedHtml = resolvedHtmlByToken.get(token);
-      if (cachedHtml) {
-        return cachedHtml;
-      }
-      const resolution = queuedResolutionsByToken.get(token);
-      if (!resolution) {
-        return token;
-      }
-      if (resolvingTokens.has(token)) {
-        throw new Error(
-          `[ecopages] ${options.queueLabel} foreign-subtree queue contains a cycle or unresolved dependency links.`
-        );
-      }
-      resolvingTokens.add(token);
-      try {
-        const renderedChildren = await options.renderQueuedChildren(
-          resolution.props.children,
-          runtimeContext,
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        syncQueuedResolutions();
-        if (renderedChildren.assets.length > 0) {
-          collectedAssets.push(...renderedChildren.assets);
-        }
-        const foreignSubtreeRender = await options.resolveForeignSubtree(
-          {
-            component: resolution.component,
-            props: { ...resolution.props },
-            children: renderedChildren.html ?? renderedChildren.children,
-            integrationContext: {
-              rendererCache: runtimeContext.rendererCache,
-              componentInstanceId: resolution.componentInstanceId
-            }
-          },
-          runtimeContext.rendererCache
-        );
-        if (!foreignSubtreeRender) {
-          throw new Error(
-            `[ecopages] ${options.queueLabel} queued foreign subtree could not resolve its owning renderer.`
-          );
-        }
-        if ((foreignSubtreeRender.assets?.length ?? 0) > 0) {
-          collectedAssets.push(...foreignSubtreeRender.assets ?? []);
-        }
-        const resolvedHtml2 = foreignSubtreeRender.attachmentPolicy.kind === "first-element" && foreignSubtreeRender.rootAttributes ? options.applyAttributesToFirstElement(
-          foreignSubtreeRender.html,
-          foreignSubtreeRender.rootAttributes
-        ) : foreignSubtreeRender.html;
-        resolvedHtmlByToken.set(token, resolvedHtml2);
-        return resolvedHtml2;
-      } finally {
-        resolvingTokens.delete(token);
-      }
-    };
-    let resolvedHtml = options.html;
-    for (let index = 0; index < runtimeContext.queuedResolutions.length; index += 1) {
-      syncQueuedResolutions();
-      const resolution = runtimeContext.queuedResolutions[index];
-      if (!resolvedHtml.includes(resolution.token)) {
-        continue;
-      }
-      resolvedHtml = resolvedHtml.split(resolution.token).join(await resolveToken(resolution.token));
-    }
-    return {
-      assets: options.dedupeProcessedAssets(collectedAssets),
-      html: resolvedHtml
-    };
-  }
-  createForeignSubtreeToken(tokenPrefix, runtimeContext, foreignSubtreeId) {
-    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${foreignSubtreeId}__`;
-  }
-  ensureRuntimeContext(options) {
-    let integrationContext;
-    if (typeof options.renderInput.integrationContext === "object" && options.renderInput.integrationContext !== null) {
-      integrationContext = options.renderInput.integrationContext;
-    } else {
-      integrationContext = {};
-    }
-    const existingRuntimeContext = integrationContext[options.runtimeContextKey];
-    if (typeof existingRuntimeContext !== "object" || existingRuntimeContext === null) {
-      integrationContext[options.runtimeContextKey] = options.createRuntimeContext?.(integrationContext, options.rendererCache) ?? {
-        rendererCache: options.rendererCache,
-        componentInstanceScope: integrationContext.componentInstanceId,
-        nextForeignSubtreeId: 0,
-        queuedResolutions: []
-      };
-    } else {
-      existingRuntimeContext.rendererCache = options.rendererCache;
-    }
-    integrationContext.rendererCache = options.rendererCache;
-    options.renderInput.integrationContext = integrationContext;
-    return integrationContext[options.runtimeContextKey];
-  }
-}
-export {
-  QueuedForeignSubtreeResolutionService
-};