@ecopages/core 0.2.0-beta.31 → 0.2.0-beta.32

package/src/route-renderer/orchestration/foreign-child/component-render-context.js

@@ -1,149 +1,196 @@
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from "./foreign-child-output.utils.js";
+import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from './foreign-child-output.utils.js';
+/**
+ * Shared output finalization behavior used both inside and outside active render contexts.
+ *
+ * This stage is responsible only for lazy trigger or injector wrapping. Foreign-child
+ * interception stays in `ContextualComponentRenderRuntime`.
+ */
 class ComponentRenderOutputRuntime {
-  finalizeComponentRender(component, content) {
-    const lazyTriggers = component.config?._resolvedLazyTriggers;
-    if (lazyTriggers && lazyTriggers.length > 0) {
-      return this.addTriggerToContent(content, lazyTriggers[0].triggerId);
+    finalizeComponentRender(component, content) {
+        const lazyTriggers = component.config?._resolvedLazyTriggers;
+        if (lazyTriggers && lazyTriggers.length > 0) {
+            return this.addTriggerToContent(content, lazyTriggers[0].triggerId);
+        }
+        const lazyGroups = component.config?._resolvedLazyScripts;
+        if (lazyGroups && lazyGroups.length > 0) {
+            return this.wrapContentWithScriptsInjector(content, lazyGroups);
+        }
+        return content;
     }
-    const lazyGroups = component.config?._resolvedLazyScripts;
-    if (lazyGroups && lazyGroups.length > 0) {
-      return this.wrapContentWithScriptsInjector(content, lazyGroups);
+    addTriggerToContent(content, triggerId) {
+        if (isThenable(content)) {
+            return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
+        }
+        return addTriggerAttribute(content, triggerId);
     }
-    return content;
-  }
-  addTriggerToContent(content, triggerId) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
+    wrapContentWithScriptsInjector(content, lazyGroups) {
+        if (isThenable(content)) {
+            return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
+        }
+        return wrapWithScriptsInjector(content, lazyGroups);
     }
-    return addTriggerAttribute(content, triggerId);
-  }
-  wrapContentWithScriptsInjector(content, lazyGroups) {
-    if (isThenable(content)) {
-      return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
-    }
-    return wrapWithScriptsInjector(content, lazyGroups);
-  }
 }
+/**
+ * Render-context-aware runtime that delegates foreign-child interception.
+ */
 class ContextualComponentRenderRuntime extends ComponentRenderOutputRuntime {
-  context;
-  constructor(context) {
-    super();
-    this.context = context;
-  }
-  applyForeignChildInterceptionResult(result) {
-    if (result.kind === "resolved") {
-      return result;
+    context;
+    constructor(context) {
+        super();
+        this.context = context;
     }
-    return result.props ? result : void 0;
-  }
-  /**
-   * Resolves one foreign-child interception through the active runtime.
-   *
-   * The runtime may choose inline rendering or immediate resolved output.
-   */
-  interceptForeignChild(input) {
-    const foreignChildRuntimeInput = {
-      currentIntegration: this.context.currentIntegration,
-      targetIntegration: input.targetIntegration,
-      component: input.component,
-      props: input.props
-    };
-    const asyncInterception = this.context.foreignChildRuntime?.interceptForeignChild?.(foreignChildRuntimeInput);
-    if (asyncInterception !== void 0) {
-      if (isThenable(asyncInterception)) {
-        return asyncInterception.then(
-          (result) => result === void 0 ? void 0 : this.applyForeignChildInterceptionResult(result)
-        );
-      }
-      return this.applyForeignChildInterceptionResult(asyncInterception);
+    applyForeignChildInterceptionResult(result) {
+        if (result.kind === 'resolved') {
+            return result;
+        }
+        return result.props ? result : undefined;
     }
-    const syncInterception = this.context.foreignChildRuntime?.interceptForeignChildSync?.(foreignChildRuntimeInput);
-    if (syncInterception === void 0) {
-      return void 0;
+    /**
+     * Resolves one foreign-child interception through the active runtime.
+     *
+     * The runtime may choose inline rendering or immediate resolved output.
+     */
+    interceptForeignChild(input) {
+        const foreignChildRuntimeInput = {
+            currentIntegration: this.context.currentIntegration,
+            targetIntegration: input.targetIntegration,
+            component: input.component,
+            props: input.props,
+        };
+        const asyncInterception = this.context.foreignChildRuntime?.interceptForeignChild?.(foreignChildRuntimeInput);
+        if (asyncInterception !== undefined) {
+            if (isThenable(asyncInterception)) {
+                return asyncInterception.then((result) => result === undefined ? undefined : this.applyForeignChildInterceptionResult(result));
+            }
+            return this.applyForeignChildInterceptionResult(asyncInterception);
+        }
+        const syncInterception = this.context.foreignChildRuntime?.interceptForeignChildSync?.(foreignChildRuntimeInput);
+        if (syncInterception === undefined) {
+            return undefined;
+        }
+        return this.applyForeignChildInterceptionResult(syncInterception);
     }
-    return this.applyForeignChildInterceptionResult(syncInterception);
-  }
 }
-const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = "__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__";
+const GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY = '__ECOPAGES_COMPONENT_RENDER_CONTEXT_STATE__';
+/**
+ * Chooses the widest shared global scope available for process-wide state.
+ *
+ * `process` is preferred when present so duplicate bundles or module instances in
+ * the same runtime still converge on one shared context registry.
+ */
 function getSharedContextScope() {
-  const globalProcess = globalThis.process;
-  if (globalProcess && typeof globalProcess === "object") {
-    return globalProcess;
-  }
-  return globalThis;
+    const globalProcess = globalThis.process;
+    if (globalProcess && typeof globalProcess === 'object') {
+        return globalProcess;
+    }
+    return globalThis;
 }
+/**
+ * Returns the singleton mutable state used by component render contexts.
+ */
 function getComponentRenderContextState() {
-  const sharedScope = getSharedContextScope();
-  sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
-    contextStack: [],
-    nodeContextStorage: null,
-    nodeContextStorageLoader: null
-  };
-  return sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
+    const sharedScope = getSharedContextScope();
+    sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY] ??= {
+        contextStack: [],
+        nodeContextStorage: null,
+        nodeContextStorageLoader: null,
+    };
+    return sharedScope[GLOBAL_COMPONENT_RENDER_CONTEXT_STATE_KEY];
 }
+/**
+ * Lazily initializes async context storage for Node runtimes.
+ *
+ * Falls back to in-memory stack mode when async_hooks is unavailable.
+ *
+ * @returns Async context storage when available; otherwise `null`.
+ */
 async function getContextStorage() {
-  const state = getComponentRenderContextState();
-  if (state.nodeContextStorage) {
-    return state.nodeContextStorage;
-  }
-  if (state.nodeContextStorageLoader) {
+    const state = getComponentRenderContextState();
+    if (state.nodeContextStorage) {
+        return state.nodeContextStorage;
+    }
+    if (state.nodeContextStorageLoader) {
+        return state.nodeContextStorageLoader;
+    }
+    state.nodeContextStorageLoader = import('node:async_hooks')
+        .then((module) => {
+        const storage = new module.AsyncLocalStorage();
+        state.nodeContextStorage = {
+            getStore: () => storage.getStore(),
+            run: (store, callback) => storage.run(store, callback),
+        };
+        return state.nodeContextStorage;
+    })
+        .catch(() => {
+        state.nodeContextStorage = null;
+        return null;
+    })
+        .finally(() => {
+        state.nodeContextStorageLoader = null;
+    });
     return state.nodeContextStorageLoader;
-  }
-  state.nodeContextStorageLoader = import("node:async_hooks").then((module) => {
-    const storage = new module.AsyncLocalStorage();
-    state.nodeContextStorage = {
-      getStore: () => storage.getStore(),
-      run: (store, callback) => storage.run(store, callback)
-    };
-    return state.nodeContextStorage;
-  }).catch(() => {
-    state.nodeContextStorage = null;
-    return null;
-  }).finally(() => {
-    state.nodeContextStorageLoader = null;
-  });
-  return state.nodeContextStorageLoader;
 }
-function getComponentRenderContext() {
-  const state = getComponentRenderContextState();
-  return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
+/**
+ * Returns the current component render context, if one is active.
+ *
+ * @returns Active render context or `undefined` outside render execution.
+ */
+export function getComponentRenderContext() {
+    const state = getComponentRenderContextState();
+    return state.nodeContextStorage?.getStore() ?? state.contextStack[state.contextStack.length - 1];
 }
 const componentRenderOutputRuntime = new ComponentRenderOutputRuntime();
-function interceptForeignChild(input) {
-  return getComponentRenderContext()?.interceptForeignChild(input);
+/**
+ * Runs foreign-child interception for one component render step.
+ *
+ * The active runtime may resolve the foreign child immediately or keep it inline.
+ */
+export function interceptForeignChild(input) {
+    return getComponentRenderContext()?.interceptForeignChild(input);
 }
-function finalizeComponentRender(component, content) {
-  const renderContext = getComponentRenderContext();
-  return renderContext?.finalizeComponentRender(component, content) ?? componentRenderOutputRuntime.finalizeComponentRender(component, content);
+/**
+ * Applies lazy trigger or injector wrapping to completed component output.
+ *
+ * This helper works both inside render-context execution and in fallback flows
+ * where no active context exists.
+ */
+export function finalizeComponentRender(component, content) {
+    const renderContext = getComponentRenderContext();
+    return (renderContext?.finalizeComponentRender(component, content) ??
+        componentRenderOutputRuntime.finalizeComponentRender(component, content));
 }
-async function runWithComponentRenderContext(input, render) {
-  const context = {
-    currentIntegration: input.currentIntegration,
-    foreignChildRuntime: input.foreignChildRuntime
-  };
-  const runtime = new ContextualComponentRenderRuntime(context);
-  context.interceptForeignChild = (deferredInput) => runtime.interceptForeignChild(deferredInput);
-  context.finalizeComponentRender = (component, content) => runtime.finalizeComponentRender(component, content);
-  const storage = await getContextStorage();
-  let value;
-  if (storage) {
-    value = await storage.run(context, render);
-  } else {
-    const state = getComponentRenderContextState();
-    state.contextStack.push(context);
-    try {
-      value = await render();
-    } finally {
-      state.contextStack.pop();
+/**
+ * Runs render work under a fresh component render context and returns the
+ * resulting value.
+ *
+ * @param input Execution metadata for current integration and foreign-child policy.
+ * @param render Async render function to execute inside the context.
+ * @returns Render result value.
+ */
+export async function runWithComponentRenderContext(input, render) {
+    const context = {
+        currentIntegration: input.currentIntegration,
+        foreignChildRuntime: input.foreignChildRuntime,
+    };
+    const runtime = new ContextualComponentRenderRuntime(context);
+    context.interceptForeignChild = (deferredInput) => runtime.interceptForeignChild(deferredInput);
+    context.finalizeComponentRender = (component, content) => runtime.finalizeComponentRender(component, content);
+    const storage = await getContextStorage();
+    let value;
+    if (storage) {
+        value = await storage.run(context, render);
+    }
+    else {
+        const state = getComponentRenderContextState();
+        state.contextStack.push(context);
+        try {
+            value = await render();
+        }
+        finally {
+            state.contextStack.pop();
+        }
     }
-  }
-  return {
-    value
-  };
+    return {
+        value,
+    };
 }
-export {
-  finalizeComponentRender,
-  getComponentRenderContext,
-  interceptForeignChild,
-  runWithComponentRenderContext
-};