@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

package/src/route-renderer/page-loading/component-dependency-collection.js

@@ -1,132 +1,132 @@
-import path from "node:path";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { extractEcopagesVirtualImports } from "./ecopages-virtual-imports.js";
-import { collectDeclaredAssetEntries } from "./declared-asset-collection.js";
-import { getLazyTriggerKey } from "./lazy-trigger-planning.js";
-import { collectLazyScriptEntries } from "./lazy-entry-collection.js";
-import {
-  createModuleScriptName,
-  createNamedImportModuleSource,
-  createNamespaceImportModuleSource
-} from "./module-declaration-scripts.js";
-import { collectModuleDeclarations } from "./module-declaration-aggregation.js";
+import path from 'node:path';
+import { assertEcoDeclaredComponent } from '../../eco/eco-declared-component.js';
+import { getComponentIdentity } from '../../eco/component-identity.js';
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
+import { extractEcopagesVirtualImports } from './ecopages-virtual-imports.js';
+import { collectDeclaredAssetEntries } from './declared-asset-collection.js';
+import { getLazyTriggerKey } from './lazy-trigger-planning.js';
+import { collectLazyScriptEntries } from './lazy-entry-collection.js';
+import { createModuleScriptName, createNamedImportModuleSource, createNamespaceImportModuleSource, } from './module-declaration-scripts.js';
+import { collectModuleDeclarations } from './module-declaration-aggregation.js';
 const MODULE_SCRIPT_ATTRIBUTES = {
-  type: "module",
-  defer: ""
+    type: 'module',
+    defer: '',
 };
 function createModuleScriptAttributes(attributes) {
-  return {
-    ...MODULE_SCRIPT_ATTRIBUTES,
-    ...attributes
-  };
+    return {
+        ...MODULE_SCRIPT_ATTRIBUTES,
+        ...attributes,
+    };
 }
 function pushUniqueDependency(keys, key, dependencies, dependency) {
-  if (keys.has(key)) {
-    return false;
-  }
-  keys.add(key);
-  dependencies.push(dependency);
-  return true;
+    if (keys.has(key)) {
+        return false;
+    }
+    keys.add(key);
+    dependencies.push(dependency);
+    return true;
 }
 function resolveDependencyPath(componentDir, pathUrl) {
-  return path.join(componentDir, pathUrl);
+    return path.join(componentDir, pathUrl);
 }
-function collectComponentDependencies(options) {
-  const {
-    components,
-    integrationName,
-    resolveLazyScripts,
-    createEcopagesJsxLazyEntryName,
-    isEcopagesJsxIntegration,
-    errors
-  } = options;
-  const dependencies = [];
-  const lazyScriptsByConfig = /* @__PURE__ */ new Map();
-  const lazyDependencyKeys = /* @__PURE__ */ new Set();
-  for (const component of components) {
-    if (!component) continue;
-    const componentFile = component.config?.__eco?.file;
-    if (!componentFile) continue;
-    const stylesheetDependencyKeys = /* @__PURE__ */ new Set();
-    const scriptDependencyKeys = /* @__PURE__ */ new Set();
-    const modulesMap = /* @__PURE__ */ new Map();
-    const collect = (config) => {
-      if (!config) return;
-      const file = config.__eco?.file;
-      if (!file) return;
-      const dir = path.dirname(file);
-      const dependenciesConfig = config.dependencies;
-      const registerLazyScript = ({
-        lazy,
-        lazyKey,
-        fallbackUrl
-      }) => {
-        let grouped = lazyScriptsByConfig.get(config);
-        if (!grouped) {
-          grouped = /* @__PURE__ */ new Map();
-          lazyScriptsByConfig.set(config, grouped);
-        }
-        const triggerKey = getLazyTriggerKey(lazy);
-        const existing = grouped.get(triggerKey) ?? { lazy, scripts: [] };
-        existing.scripts.push({ lazyKey, fallbackUrl });
-        grouped.set(triggerKey, existing);
-      };
-      collectDeclaredAssetEntries({
-        stylesheetEntries: dependenciesConfig?.stylesheets ?? [],
-        scriptEntries: dependenciesConfig?.scripts ?? [],
-        componentDir: dir,
-        dependencies,
-        stylesheetDependencyKeys,
-        scriptDependencyKeys,
-        resolveDependencyPath,
-        createModuleScriptAttributes,
-        pushUniqueDependency,
-        getInvalidStylesheetEntryMessage: () => errors.invalidStylesheetEntry,
-        getInvalidScriptEntryMessage: () => errors.invalidScriptEntry
-      });
-      collectModuleDeclarations(modulesMap, dependenciesConfig?.modules, extractEcopagesVirtualImports(file));
-      collectLazyScriptEntries({
-        scriptEntries: dependenciesConfig?.scripts ?? [],
-        componentFile: file,
-        componentDir: dir,
-        integrationName,
+/**
+ * Walks component dependency trees and collects declared assets, module declarations,
+ * and lazy-script group metadata in one pass.
+ *
+ * The returned structures intentionally preserve both the flat asset list used by
+ * asset processing and the grouped lazy-trigger data used later during render output.
+ */
+export function collectComponentDependencies(options) {
+    const { components, integrationName, resolveLazyScripts, createEcopagesJsxLazyEntryName, isEcopagesJsxIntegration, errors, } = options;
+    const dependencies = [];
+    const lazyScriptsByConfig = new Map();
+    const lazyDependencyKeys = new Set();
+    for (const component of components) {
+        if (!component)
+            continue;
+        const componentFile = getComponentIdentity(component)?.file;
+        if (!componentFile)
+            continue;
+        const stylesheetDependencyKeys = new Set();
+        const scriptDependencyKeys = new Set();
+        const modulesMap = new Map();
+        /**
+         * Recursively visits one component config and its declared child dependencies.
+         */
+        const collect = (config) => {
+            if (!config)
+                return;
+            const file = getComponentIdentity(config)?.file;
+            if (!file)
+                return;
+            const dir = path.dirname(file);
+            const dependenciesConfig = config.dependencies;
+            const registerLazyScript = ({ lazy, lazyKey, fallbackUrl, }) => {
+                let grouped = lazyScriptsByConfig.get(config);
+                if (!grouped) {
+                    grouped = new Map();
+                    lazyScriptsByConfig.set(config, grouped);
+                }
+                const triggerKey = getLazyTriggerKey(lazy);
+                const existing = grouped.get(triggerKey) ?? { lazy, scripts: [] };
+                existing.scripts.push({ lazyKey, fallbackUrl });
+                grouped.set(triggerKey, existing);
+            };
+            collectDeclaredAssetEntries({
+                stylesheetEntries: dependenciesConfig?.stylesheets ?? [],
+                scriptEntries: dependenciesConfig?.scripts ?? [],
+                componentDir: dir,
+                dependencies,
+                stylesheetDependencyKeys,
+                scriptDependencyKeys,
+                resolveDependencyPath,
+                createModuleScriptAttributes,
+                pushUniqueDependency,
+                getInvalidStylesheetEntryMessage: () => errors.invalidStylesheetEntry,
+                getInvalidScriptEntryMessage: () => errors.invalidScriptEntry,
+            });
+            collectModuleDeclarations(modulesMap, dependenciesConfig?.modules, extractEcopagesVirtualImports(file));
+            collectLazyScriptEntries({
+                scriptEntries: dependenciesConfig?.scripts ?? [],
+                componentFile: file,
+                componentDir: dir,
+                integrationName,
+                dependencies,
+                lazyDependencyKeys,
+                registerLazyScript,
+                resolveDependencyPath,
+                resolveLazyScripts,
+                createModuleScriptAttributes,
+                createEcopagesJsxLazyEntryName,
+                pushUniqueDependency,
+                getLazyScriptMissingSrcMessage: () => errors.lazyScriptMissingSrc,
+                isEcopagesJsxIntegration,
+            });
+            if (dependenciesConfig?.components) {
+                for (const nestedComponent of dependenciesConfig.components) {
+                    if (!nestedComponent) {
+                        continue;
+                    }
+                    assertEcoDeclaredComponent(nestedComponent, { parentComponentFile: file });
+                    collect(nestedComponent.config);
+                }
+            }
+        };
+        collect(component.config);
+        dependencies.push(...Array.from(modulesMap.entries()).map(([from, importsSet]) => {
+            const imports = importsSet ? Array.from(importsSet) : undefined;
+            return AssetFactory.createContentScript({
+                position: 'head',
+                name: createModuleScriptName(from, imports),
+                content: imports && imports.length > 0
+                    ? createNamedImportModuleSource(from, imports)
+                    : createNamespaceImportModuleSource(from),
+                attributes: createModuleScriptAttributes(),
+            });
+        }));
+    }
+    return {
         dependencies,
-        lazyDependencyKeys,
-        registerLazyScript,
-        resolveDependencyPath,
-        resolveLazyScripts,
-        createModuleScriptAttributes,
-        createEcopagesJsxLazyEntryName,
-        pushUniqueDependency,
-        getLazyScriptMissingSrcMessage: () => errors.lazyScriptMissingSrc,
-        isEcopagesJsxIntegration
-      });
-      if (dependenciesConfig?.components) {
-        for (const nestedComponent of dependenciesConfig.components) {
-          if (nestedComponent?.config) {
-            collect(nestedComponent.config);
-          }
-        }
-      }
+        lazyScriptsByConfig,
     };
-    collect(component.config);
-    dependencies.push(
-      ...Array.from(modulesMap.entries()).map(([from, importsSet]) => {
-        const imports = importsSet ? Array.from(importsSet) : void 0;
-        return AssetFactory.createContentScript({
-          position: "head",
-          name: createModuleScriptName(from, imports),
-          content: imports && imports.length > 0 ? createNamedImportModuleSource(from, imports) : createNamespaceImportModuleSource(from),
-          attributes: createModuleScriptAttributes()
-        });
-      })
-    );
-  }
-  return {
-    dependencies,
-    lazyScriptsByConfig
-  };
 }
-export {
-  collectComponentDependencies
-};

package/src/route-renderer/page-loading/declared-asset-collection.js

@@ -1,106 +1,78 @@
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
 function isDependencyEntryObject(entry) {
-  return typeof entry === "object" && entry !== null;
+    return typeof entry === 'object' && entry !== null;
 }
 function getDependencyEntrySrc(entry) {
-  return isDependencyEntryObject(entry) ? entry.src : entry;
+    return isDependencyEntryObject(entry) ? entry.src : entry;
 }
 function getDependencyEntryContent(entry) {
-  return isDependencyEntryObject(entry) ? entry.content : void 0;
+    return isDependencyEntryObject(entry) ? entry.content : undefined;
 }
 function getDependencyEntryAttributes(entry) {
-  return isDependencyEntryObject(entry) ? entry.attributes : void 0;
+    return isDependencyEntryObject(entry) ? entry.attributes : undefined;
 }
-function collectDeclaredAssetEntries(options) {
-  const {
-    stylesheetEntries,
-    scriptEntries,
-    componentDir,
-    dependencies,
-    stylesheetDependencyKeys,
-    scriptDependencyKeys,
-    resolveDependencyPath,
-    createModuleScriptAttributes,
-    pushUniqueDependency,
-    getInvalidStylesheetEntryMessage,
-    getInvalidScriptEntryMessage
-  } = options;
-  for (const style of stylesheetEntries) {
-    const content = getDependencyEntryContent(style);
-    const src = getDependencyEntrySrc(style);
-    const attributes = getDependencyEntryAttributes(style);
-    if (content) {
-      const depKey2 = `style:content:${content}:${JSON.stringify(attributes ?? {})}`;
-      pushUniqueDependency(
-        stylesheetDependencyKeys,
-        depKey2,
-        dependencies,
-        AssetFactory.createContentStylesheet({
-          content,
-          position: "head",
-          attributes
-        })
-      );
-      continue;
-    }
-    if (!src) {
-      throw new Error(getInvalidStylesheetEntryMessage());
-    }
-    const resolvedPath = resolveDependencyPath(componentDir, src);
-    const depKey = `style:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-    pushUniqueDependency(
-      stylesheetDependencyKeys,
-      depKey,
-      dependencies,
-      AssetFactory.createFileStylesheet({
-        filepath: resolvedPath,
-        position: "head",
-        attributes: {
-          rel: "stylesheet",
-          ...attributes
+/**
+ * Normalizes non-lazy stylesheet and script declarations into asset definitions.
+ *
+ * Duplicate declarations are filtered through the provided key sets so callers can
+ * compose this helper into larger recursive collection passes without re-emitting
+ * the same asset multiple times.
+ */
+export function collectDeclaredAssetEntries(options) {
+    const { stylesheetEntries, scriptEntries, componentDir, dependencies, stylesheetDependencyKeys, scriptDependencyKeys, resolveDependencyPath, createModuleScriptAttributes, pushUniqueDependency, getInvalidStylesheetEntryMessage, getInvalidScriptEntryMessage, } = options;
+    for (const style of stylesheetEntries) {
+        const content = getDependencyEntryContent(style);
+        const src = getDependencyEntrySrc(style);
+        const attributes = getDependencyEntryAttributes(style);
+        if (content) {
+            const depKey = `style:content:${content}:${JSON.stringify(attributes ?? {})}`;
+            pushUniqueDependency(stylesheetDependencyKeys, depKey, dependencies, AssetFactory.createContentStylesheet({
+                content,
+                position: 'head',
+                attributes,
+            }));
+            continue;
         }
-      })
-    );
-  }
-  for (const script of scriptEntries) {
-    if (isDependencyEntryObject(script) && "lazy" in script && script.lazy) {
-      continue;
-    }
-    const content = getDependencyEntryContent(script);
-    const src = getDependencyEntrySrc(script);
-    const attributes = getDependencyEntryAttributes(script);
-    if (content) {
-      const depKey2 = `script:content:${content}:${JSON.stringify(attributes ?? {})}`;
-      pushUniqueDependency(
-        scriptDependencyKeys,
-        depKey2,
-        dependencies,
-        AssetFactory.createInlineContentScript({
-          position: "head",
-          content,
-          bundle: false,
-          attributes
-        })
-      );
-      continue;
+        if (!src) {
+            throw new Error(getInvalidStylesheetEntryMessage());
+        }
+        const resolvedPath = resolveDependencyPath(componentDir, src);
+        const depKey = `style:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
+        pushUniqueDependency(stylesheetDependencyKeys, depKey, dependencies, AssetFactory.createFileStylesheet({
+            filepath: resolvedPath,
+            position: 'head',
+            attributes: {
+                rel: 'stylesheet',
+                ...attributes,
+            },
+        }));
     }
-    if (!src) {
-      throw new Error(getInvalidScriptEntryMessage());
+    for (const script of scriptEntries) {
+        if (isDependencyEntryObject(script) && 'lazy' in script && script.lazy) {
+            continue;
+        }
+        const content = getDependencyEntryContent(script);
+        const src = getDependencyEntrySrc(script);
+        const attributes = getDependencyEntryAttributes(script);
+        if (content) {
+            const depKey = `script:content:${content}:${JSON.stringify(attributes ?? {})}`;
+            pushUniqueDependency(scriptDependencyKeys, depKey, dependencies, AssetFactory.createInlineContentScript({
+                position: 'head',
+                content,
+                bundle: false,
+                attributes,
+            }));
+            continue;
+        }
+        if (!src) {
+            throw new Error(getInvalidScriptEntryMessage());
+        }
+        const resolvedPath = resolveDependencyPath(componentDir, src);
+        const depKey = `script:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
+        pushUniqueDependency(scriptDependencyKeys, depKey, dependencies, AssetFactory.createFileScript({
+            filepath: resolvedPath,
+            position: 'head',
+            attributes: createModuleScriptAttributes(attributes),
+        }));
     }
-    const resolvedPath = resolveDependencyPath(componentDir, src);
-    const depKey = `script:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-    pushUniqueDependency(
-      scriptDependencyKeys,
-      depKey,
-      dependencies,
-      AssetFactory.createFileScript({
-        filepath: resolvedPath,
-        position: "head",
-        attributes: createModuleScriptAttributes(attributes)
-      })
-    );
-  }
 }
-export {
-  collectDeclaredAssetEntries
-};

package/src/route-renderer/page-loading/dependency-resolver.js

@@ -1,115 +1,112 @@
-import path from "node:path";
-import { rapidhash } from "../../utils/hash.js";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { buildResolvedLazyTriggers } from "./lazy-trigger-planning.js";
-import { collectComponentDependencies } from "./component-dependency-collection.js";
-import { packagePageDependencies } from "./page-dependency-bundling.js";
-const DEPENDENCY_ERRORS = {
-  INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content",
-  INVALID_SCRIPT_ENTRY: "Invalid script dependency entry: expected src or content",
-  LAZY_SCRIPT_MISSING_SRC: "Lazy script dependency entry in dependencies.scripts requires a src value"
+import path from 'node:path';
+import { rapidhash } from '../../utils/hash.js';
+import { AssetFactory } from '../../services/assets/asset-processing-service/index.js';
+import { buildResolvedLazyTriggers } from './lazy-trigger-planning.js';
+import { collectComponentDependencies } from './component-dependency-collection.js';
+import { packagePageDependencies } from './page-dependency-bundling.js';
+export const DEPENDENCY_ERRORS = {
+    INVALID_STYLESHEET_ENTRY: 'Invalid stylesheet dependency entry: expected src or content',
+    INVALID_SCRIPT_ENTRY: 'Invalid script dependency entry: expected src or content',
+    LAZY_SCRIPT_MISSING_SRC: 'Lazy script dependency entry in dependencies.scripts requires a src value',
 };
 function resolveLazyScripts(appConfig, componentDir, scripts) {
-  const getSafeFileName = (filepath) => {
-    const EXTENSIONS_TO_JS = ["ts", "tsx"];
-    const safe = filepath.replace(new RegExp(`\\.(${EXTENSIONS_TO_JS.join("|")})$`), ".js");
-    return safe.startsWith("./") ? safe.slice(2) : safe;
-  };
-  const baseDir = componentDir.split(appConfig.srcDir)[1] ?? "";
-  const resolvedPaths = scripts.map((script) => {
-    const relativePath = [AssetFactory.RESOLVED_ASSETS_DIR, baseDir, getSafeFileName(script)].filter(Boolean).join("/").replace(/\/+/g, "/");
-    return `/${relativePath.replace(/^\/+/, "")}`;
-  });
-  return resolvedPaths.join(",");
+    const getSafeFileName = (filepath) => {
+        const EXTENSIONS_TO_JS = ['ts', 'tsx'];
+        const safe = filepath.replace(new RegExp(`\\.(${EXTENSIONS_TO_JS.join('|')})$`), '.js');
+        return safe.startsWith('./') ? safe.slice(2) : safe;
+    };
+    const baseDir = componentDir.split(appConfig.srcDir)[1] ?? '';
+    const resolvedPaths = scripts.map((script) => {
+        const relativePath = [AssetFactory.RESOLVED_ASSETS_DIR, baseDir, getSafeFileName(script)]
+            .filter(Boolean)
+            .join('/')
+            .replace(/\/+/g, '/');
+        return `/${relativePath.replace(/^\/+/, '')}`;
+    });
+    return resolvedPaths.join(',');
 }
-const ECOPAGES_JSX_INTEGRATION_NAME = "ecopages-jsx";
+const ECOPAGES_JSX_INTEGRATION_NAME = 'ecopages-jsx';
 function isEcopagesJsxIntegration(integrationName) {
-  return integrationName === ECOPAGES_JSX_INTEGRATION_NAME;
+    return integrationName === ECOPAGES_JSX_INTEGRATION_NAME;
 }
 function createEcopagesJsxLazyEntryName(integrationName, key) {
-  return `ecopages-${integrationName}-lazy-${rapidhash(key).toString(16)}`;
+    return `ecopages-${integrationName}-lazy-${rapidhash(key).toString(16)}`;
 }
-class DependencyResolverService {
-  appConfig;
-  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, assetProcessingService) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-  }
-  /**
-   * Resolves one dependency path relative to the component that declared it.
-   */
-  resolveDependencyPath(componentDir, pathUrl) {
-    return path.join(componentDir, pathUrl);
-  }
-  /**
-   * Maps lazy script source entries to deterministic fallback public URLs
-   * used when bundling output URLs are unavailable.
-   */
-  resolveLazyScripts(componentDir, scripts) {
-    return resolveLazyScripts(this.appConfig, componentDir, scripts);
-  }
-  /**
-   * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
-   * Lazy dependencies are always resolved into global-injector trigger maps.
-   */
-  async processComponentDependencies(components, integrationName) {
-    if (!this.assetProcessingService?.processDependencies) return [];
-    const { dependencies, lazyScriptsByConfig } = collectComponentDependencies({
-      components,
-      integrationName,
-      resolveLazyScripts: (componentDir, scripts) => this.resolveLazyScripts(componentDir, scripts),
-      createEcopagesJsxLazyEntryName,
-      isEcopagesJsxIntegration,
-      errors: {
-        invalidStylesheetEntry: DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY,
-        invalidScriptEntry: DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY,
-        lazyScriptMissingSrc: DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC
-      }
-    });
-    const packagedDependencies = packagePageDependencies(dependencies, integrationName);
-    const hasLazyDependencies = packagedDependencies.some(
-      (dep) => dep.kind === "script" && dep.excludeFromHtml === true
-    );
-    const processedDependencies = await this.assetProcessingService.processDependencies(
-      packagedDependencies,
-      integrationName
-    );
-    const lazyKeyToOutputUrl = /* @__PURE__ */ new Map();
-    for (const dependency of processedDependencies) {
-      if (dependency.kind === "script" && dependency.srcUrl) {
-        const lazyKey = dependency.attributes?.["data-eco-lazy-key"];
-        if (lazyKey) {
-          lazyKeyToOutputUrl.set(lazyKey, dependency.srcUrl);
-        }
-      }
+export class DependencyResolverService {
+    appConfig;
+    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, assetProcessingService) {
+        this.appConfig = appConfig;
+        this.assetProcessingService = assetProcessingService;
+    }
+    /**
+     * Resolves one dependency path relative to the component that declared it.
+     */
+    resolveDependencyPath(componentDir, pathUrl) {
+        return path.join(componentDir, pathUrl);
     }
-    for (const [config, lazyGroupsMap] of lazyScriptsByConfig.entries()) {
-      const rawGroups = [];
-      for (const group of lazyGroupsMap.values()) {
-        const resolvedUrls = group.scripts.map(({ lazyKey, fallbackUrl }) => lazyKeyToOutputUrl.get(lazyKey) ?? fallbackUrl).filter((url) => Boolean(url && url.length > 0));
-        if (resolvedUrls.length === 0) {
-          continue;
+    /**
+     * Maps lazy script source entries to deterministic fallback public URLs
+     * used when bundling output URLs are unavailable.
+     */
+    resolveLazyScripts(componentDir, scripts) {
+        return resolveLazyScripts(this.appConfig, componentDir, scripts);
+    }
+    /**
+     * Collects and processes component dependencies (styles, scripts, modules, lazy scripts).
+     * Lazy dependencies are always resolved into global-injector trigger maps.
+     */
+    async processComponentDependencies(components, integrationName) {
+        if (!this.assetProcessingService?.processDependencies)
+            return [];
+        const { dependencies, lazyScriptsByConfig } = collectComponentDependencies({
+            components,
+            integrationName,
+            resolveLazyScripts: (componentDir, scripts) => this.resolveLazyScripts(componentDir, scripts),
+            createEcopagesJsxLazyEntryName,
+            isEcopagesJsxIntegration,
+            errors: {
+                invalidStylesheetEntry: DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY,
+                invalidScriptEntry: DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY,
+                lazyScriptMissingSrc: DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC,
+            },
+        });
+        const packagedDependencies = packagePageDependencies(dependencies, integrationName);
+        const hasLazyDependencies = packagedDependencies.some((dep) => dep.kind === 'script' && dep.excludeFromHtml === true);
+        const processedDependencies = await this.assetProcessingService.processDependencies(packagedDependencies, integrationName);
+        const lazyKeyToOutputUrl = new Map();
+        for (const dependency of processedDependencies) {
+            if (dependency.kind === 'script' && dependency.srcUrl) {
+                const lazyKey = dependency.attributes?.['data-eco-lazy-key'];
+                if (lazyKey) {
+                    lazyKeyToOutputUrl.set(lazyKey, dependency.srcUrl);
+                }
+            }
+        }
+        for (const [config, lazyGroupsMap] of lazyScriptsByConfig.entries()) {
+            const rawGroups = [];
+            for (const group of lazyGroupsMap.values()) {
+                const resolvedUrls = group.scripts
+                    .map(({ lazyKey, fallbackUrl }) => lazyKeyToOutputUrl.get(lazyKey) ?? fallbackUrl)
+                    .filter((url) => Boolean(url && url.length > 0));
+                if (resolvedUrls.length === 0) {
+                    continue;
+                }
+                rawGroups.push({ lazy: group.lazy, scripts: Array.from(new Set(resolvedUrls)) });
+            }
+            if (hasLazyDependencies) {
+                config._resolvedLazyTriggers = buildResolvedLazyTriggers(config, rawGroups);
+                config._resolvedLazyScripts = undefined;
+            }
         }
-        rawGroups.push({ lazy: group.lazy, scripts: Array.from(new Set(resolvedUrls)) });
-      }
-      if (hasLazyDependencies) {
-        config._resolvedLazyTriggers = buildResolvedLazyTriggers(config, rawGroups);
-        config._resolvedLazyScripts = void 0;
-      }
+        return processedDependencies;
     }
-    return processedDependencies;
-  }
 }
-export {
-  DEPENDENCY_ERRORS,
-  DependencyResolverService
-};

package/src/route-renderer/page-loading/ecopages-virtual-imports.d.ts

@@ -2,6 +2,7 @@ export type EcopagesVirtualImport = {
     from: string;
     imports: string[] | undefined;
 };
+export declare function isBrowserEcopagesVirtualImport(specifier: string): boolean;
 /**
  * Extracts runtime `ecopages:` virtual-module imports from a component source file.
  *