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

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

@@ -0,0 +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";
+const MODULE_SCRIPT_ATTRIBUTES = {
+  type: "module",
+  defer: ""
+};
+function createModuleScriptAttributes(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;
+}
+function resolveDependencyPath(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,
+        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);
+          }
+        }
+      }
+    };
+    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.d.ts

@@ -0,0 +1,24 @@
+import type { EcoComponentScriptEntry, EcoComponentStylesheetEntry } from '../../types/public-types.js';
+import type { AssetDefinition } from '../../services/assets/asset-processing-service/index.js';
+type CollectDeclaredAssetEntriesOptions = {
+    stylesheetEntries: Array<string | EcoComponentStylesheetEntry>;
+    scriptEntries: Array<string | EcoComponentScriptEntry>;
+    componentDir: string;
+    dependencies: AssetDefinition[];
+    stylesheetDependencyKeys: Set<string>;
+    scriptDependencyKeys: Set<string>;
+    resolveDependencyPath: (componentDir: string, pathUrl: string) => string;
+    createModuleScriptAttributes: (attributes?: Record<string, string>) => Record<string, string>;
+    pushUniqueDependency: (keys: Set<string>, key: string, dependencies: AssetDefinition[], dependency: AssetDefinition) => boolean;
+    getInvalidStylesheetEntryMessage: () => string;
+    getInvalidScriptEntryMessage: () => string;
+};
+/**
+ * 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 declare function collectDeclaredAssetEntries(options: CollectDeclaredAssetEntriesOptions): void;
+export {};

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

@@ -0,0 +1,106 @@
+import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
+function isDependencyEntryObject(entry) {
+  return typeof entry === "object" && entry !== null;
+}
+function getDependencyEntrySrc(entry) {
+  return isDependencyEntryObject(entry) ? entry.src : entry;
+}
+function getDependencyEntryContent(entry) {
+  return isDependencyEntryObject(entry) ? entry.content : void 0;
+}
+function getDependencyEntryAttributes(entry) {
+  return isDependencyEntryObject(entry) ? entry.attributes : void 0;
+}
+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
+        }
+      })
+    );
+  }
+  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(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)
+      })
+    );
+  }
+}
+export {
+  collectDeclaredAssetEntries
+};

package/src/route-renderer/page-loading/dependency-resolver.d.ts

@@ -1,5 +1,5 @@
-import type { EcoComponent } from '../../public-types.js';
-import type { EcoPagesAppConfig } from '../../internal-types.js';
+import type { EcoComponent } from '../../types/public-types.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 export declare const DEPENDENCY_ERRORS: {
     readonly INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content";

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

@@ -1,108 +1,14 @@
 import path from "node:path";
-import { readFileSync } from "node:fs";
 import { rapidhash } from "../../utils/hash.js";
 import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import { normalizeModuleDeclarations } from "../../eco/module-dependencies.js";
-import { parseSync } from "oxc-parser";
+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"
 };
-function extractEcopagesVirtualImports(file) {
-  let source;
-  try {
-    source = readFileSync(file, "utf-8");
-  } catch {
-    return [];
-  }
-  let result;
-  try {
-    result = parseSync(file, source, { sourceType: "module" });
-  } catch {
-    return [];
-  }
-  const found = /* @__PURE__ */ new Map();
-  for (const node of result.program.body ?? []) {
-    if (node.type !== "ImportDeclaration") continue;
-    if (node.importKind === "type") continue;
-    const specifier = node.source?.value ?? "";
-    if (!specifier.startsWith("ecopages:")) continue;
-    if (found.get(specifier) === null) {
-      continue;
-    }
-    const namedImports = [];
-    for (const spec of node.specifiers ?? []) {
-      if (spec.type === "ImportSpecifier") {
-        const importedName = spec.imported?.type === "Identifier" ? spec.imported.name : spec.imported?.type === "Literal" ? spec.imported.value : spec.local?.name;
-        namedImports.push(importedName);
-      }
-    }
-    if (namedImports.length === 0) {
-      found.set(specifier, null);
-      continue;
-    }
-    const existing = found.get(specifier);
-    if (!existing) {
-      found.set(specifier, new Set(namedImports));
-      continue;
-    }
-    for (const imported of namedImports) {
-      existing.add(imported);
-    }
-  }
-  return Array.from(found.entries()).map(([from, importsSet]) => ({
-    from,
-    imports: importsSet ? Array.from(importsSet) : void 0
-  }));
-}
-function createModuleScriptName(from, imports) {
-  const normalizedImports = imports ? [...imports].sort().join(",") : "*";
-  const hash = rapidhash(`${from}|${normalizedImports}`).toString(16);
-  return `module-${hash}`;
-}
-function createNamedImportModuleSource(from, imports) {
-  const namedImports = imports.join(", ");
-  return `export { ${namedImports} } from '${from}';`;
-}
-function createNamespaceImportModuleSource(from) {
-  return `export * from '${from}';`;
-}
-function resolveDependencyPath(componentDir, pathUrl) {
-  return path.join(componentDir, pathUrl);
-}
-function isDependencyEntryObject(entry) {
-  return typeof entry === "object" && entry !== null;
-}
-function getDependencyEntrySrc(entry) {
-  return isDependencyEntryObject(entry) ? entry.src : entry;
-}
-function getDependencyEntryContent(entry) {
-  return isDependencyEntryObject(entry) ? entry.content : void 0;
-}
-function getDependencyEntryAttributes(entry) {
-  return isDependencyEntryObject(entry) ? entry.attributes : void 0;
-}
-function getDependencyEntrySrcOrThrow(entry, errorMessage) {
-  const src = getDependencyEntrySrc(entry);
-  if (!src) {
-    throw new Error(errorMessage);
-  }
-  return src;
-}
-function getLazyTriggerKey(lazy) {
-  if ("on:idle" in lazy) {
-    return "on:idle";
-  }
-  if ("on:interaction" in lazy) {
-    return `on:interaction:${lazy["on:interaction"]}`;
-  }
-  if ("on:visible" in lazy) {
-    const value = lazy["on:visible"];
-    return `on:visible:${value === true ? "true" : value}`;
-  }
-  return JSON.stringify(lazy);
-}
 function resolveLazyScripts(appConfig, componentDir, scripts) {
   const getSafeFileName = (filepath) => {
     const EXTENSIONS_TO_JS = ["ts", "tsx"];
@@ -116,27 +22,12 @@ function resolveLazyScripts(appConfig, componentDir, scripts) {
   });
   return resolvedPaths.join(",");
 }
-function buildResolvedLazyTriggers(config, groups) {
-  if (groups.length === 0) return [];
-  const componentFile = config.__eco?.file ?? "";
-  const sortedUrls = groups.flatMap((group) => group.scripts).sort().join(",");
-  const triggerId = `eco-trigger-${rapidhash(`${componentFile}:${sortedUrls}`).toString(16)}`;
-  const rules = groups.map((group) => {
-    const { scripts, lazy } = group;
-    if ("on:idle" in lazy) {
-      return { "on:idle": { scripts } };
-    }
-    if ("on:interaction" in lazy) {
-      return { "on:interaction": { value: lazy["on:interaction"], scripts } };
-    }
-    if ("on:visible" in lazy) {
-      const visibleSelector = lazy["on:visible"];
-      if (visibleSelector === true) return { "on:visible": { scripts } };
-      return { "on:visible": { value: String(visibleSelector), scripts } };
-    }
-    throw new Error(`Unknown lazy trigger kind: ${JSON.stringify(lazy)}`);
-  });
-  return [{ triggerId, rules }];
+const ECOPAGES_JSX_INTEGRATION_NAME = "ecopages-jsx";
+function isEcopagesJsxIntegration(integrationName) {
+  return integrationName === ECOPAGES_JSX_INTEGRATION_NAME;
+}
+function createEcopagesJsxLazyEntryName(integrationName, key) {
+  return `ecopages-${integrationName}-lazy-${rapidhash(key).toString(16)}`;
 }
 class DependencyResolverService {
   appConfig;
@@ -157,7 +48,7 @@ class DependencyResolverService {
    * Resolves one dependency path relative to the component that declared it.
    */
   resolveDependencyPath(componentDir, pathUrl) {
-    return resolveDependencyPath(componentDir, pathUrl);
+    return path.join(componentDir, pathUrl);
   }
   /**
    * Maps lazy script source entries to deterministic fallback public URLs
@@ -172,242 +63,24 @@ class DependencyResolverService {
    */
   async processComponentDependencies(components, integrationName) {
     if (!this.assetProcessingService?.processDependencies) return [];
-    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);
-        };
-        if (dependenciesConfig?.stylesheets) {
-          for (const style of dependenciesConfig.stylesheets) {
-            const content = getDependencyEntryContent(style);
-            const src = getDependencyEntrySrc(style);
-            const attributes = getDependencyEntryAttributes(style);
-            if (content) {
-              const depKey2 = `style:content:${content}:${JSON.stringify(attributes ?? {})}`;
-              if (stylesheetDependencyKeys.has(depKey2)) {
-                continue;
-              }
-              stylesheetDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createContentStylesheet({
-                  content,
-                  position: "head",
-                  attributes
-                })
-              );
-              continue;
-            }
-            if (!src) {
-              throw new Error(DEPENDENCY_ERRORS.INVALID_STYLESHEET_ENTRY);
-            }
-            const resolvedPath = resolveDependencyPath(dir, src);
-            const depKey = `style:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-            if (stylesheetDependencyKeys.has(depKey)) {
-              continue;
-            }
-            stylesheetDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileStylesheet({
-                filepath: resolvedPath,
-                position: "head",
-                attributes: {
-                  rel: "stylesheet",
-                  ...attributes
-                }
-              })
-            );
-          }
-        }
-        if (dependenciesConfig?.scripts) {
-          for (const script of dependenciesConfig.scripts) {
-            if (isDependencyEntryObject(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 ?? {})}`;
-              if (scriptDependencyKeys.has(depKey2)) {
-                continue;
-              }
-              scriptDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createContentScript({
-                  position: "head",
-                  content,
-                  attributes: {
-                    type: "module",
-                    defer: "",
-                    ...attributes
-                  }
-                })
-              );
-              continue;
-            }
-            if (!src) {
-              throw new Error(DEPENDENCY_ERRORS.INVALID_SCRIPT_ENTRY);
-            }
-            const resolvedPath = resolveDependencyPath(dir, src);
-            const depKey = `script:file:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-            if (scriptDependencyKeys.has(depKey)) {
-              continue;
-            }
-            scriptDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileScript({
-                filepath: resolvedPath,
-                position: "head",
-                attributes: {
-                  type: "module",
-                  defer: "",
-                  ...attributes
-                }
-              })
-            );
-          }
-        }
-        const normalizedModules = normalizeModuleDeclarations(dependenciesConfig?.modules);
-        for (const declaration of normalizedModules) {
-          const existing = modulesMap.get(declaration.from);
-          if (!declaration.imports || declaration.imports.length === 0) {
-            modulesMap.set(declaration.from, null);
-            continue;
-          }
-          if (existing === null) {
-            continue;
-          }
-          const merged = existing ?? /* @__PURE__ */ new Set();
-          for (const imported of declaration.imports) {
-            merged.add(imported);
-          }
-          modulesMap.set(declaration.from, merged);
-        }
-        for (const [index, scriptEntry] of (dependenciesConfig?.scripts ?? []).entries()) {
-          if (!isDependencyEntryObject(scriptEntry) || !scriptEntry.lazy) {
-            continue;
-          }
-          const lazy = scriptEntry.lazy;
-          const content = scriptEntry.content;
-          const src = scriptEntry.src;
-          const attributes = scriptEntry.attributes;
-          if (content) {
-            const lazyKey2 = `lazy:${rapidhash(`${file}:entry:${index}:${content}`).toString(16)}`;
-            const depKey2 = `lazy:entry:content:${getLazyTriggerKey(lazy)}:${content}:${JSON.stringify(attributes ?? {})}`;
-            if (!lazyDependencyKeys.has(depKey2)) {
-              lazyDependencyKeys.add(depKey2);
-              dependencies.push(
-                AssetFactory.createContentScript({
-                  position: "head",
-                  content,
-                  excludeFromHtml: true,
-                  attributes: {
-                    type: "module",
-                    defer: "",
-                    "data-eco-lazy-key": lazyKey2,
-                    ...attributes
-                  }
-                })
-              );
-            }
-            registerLazyScript({
-              lazy,
-              lazyKey: lazyKey2
-            });
-            continue;
-          }
-          const script = src ?? getDependencyEntrySrcOrThrow(scriptEntry, DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC);
-          const resolvedPath = this.resolveDependencyPath(dir, script);
-          const fallbackUrl = this.resolveLazyScripts(dir, [script]).split(",")[0] ?? "";
-          const lazyKey = `lazy:${rapidhash(`${resolvedPath}:${getLazyTriggerKey(lazy)}`).toString(16)}`;
-          const depKey = `lazy:entry:file:${getLazyTriggerKey(lazy)}:${resolvedPath}:${JSON.stringify(attributes ?? {})}`;
-          if (!lazyDependencyKeys.has(depKey)) {
-            lazyDependencyKeys.add(depKey);
-            dependencies.push(
-              AssetFactory.createFileScript({
-                filepath: resolvedPath,
-                position: "head",
-                excludeFromHtml: true,
-                attributes: {
-                  type: "module",
-                  defer: "",
-                  "data-eco-lazy-key": lazyKey,
-                  ...attributes
-                }
-              })
-            );
-          }
-          registerLazyScript({
-            lazy,
-            lazyKey,
-            fallbackUrl
-          });
-        }
-        if (dependenciesConfig?.components) {
-          for (const nestedComponent of dependenciesConfig.components) {
-            if (nestedComponent?.config) {
-              collect(nestedComponent.config);
-            }
-          }
-        }
-        const autoVirtualImports = extractEcopagesVirtualImports(file);
-        for (const { from, imports } of autoVirtualImports) {
-          const existing = modulesMap.get(from);
-          if (!imports || imports.length === 0) {
-            if (existing !== null) modulesMap.set(from, null);
-            continue;
-          }
-          if (existing === null) continue;
-          const merged = existing ?? /* @__PURE__ */ new Set();
-          for (const imported of imports) merged.add(imported);
-          modulesMap.set(from, merged);
-        }
-      };
-      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: {
-              type: "module",
-              defer: ""
-            }
-          });
-        })
-      );
-    }
-    const hasLazyDependencies = dependencies.some((dep) => dep.kind === "script" && dep.excludeFromHtml === true);
+    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(
-      dependencies,
+      packagedDependencies,
       integrationName
     );
     const lazyKeyToOutputUrl = /* @__PURE__ */ new Map();