@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.27

package/src/route-renderer/orchestration/render-output.utils.js

@@ -1,171 +0,0 @@
-import { buildInjectorMapScript } from "../../eco/lazy-injector-map.js";
-function cloneTemplateStrings(strings, firstString) {
-  const nextStrings = [...strings];
-  nextStrings[0] = firstString;
-  const rawDescriptor = Object.getOwnPropertyDescriptor(strings, "raw");
-  if (rawDescriptor && Array.isArray(rawDescriptor.value)) {
-    const rawStrings = [...rawDescriptor.value];
-    rawStrings[0] = firstString;
-    Object.defineProperty(nextStrings, "raw", {
-      ...rawDescriptor,
-      value: rawStrings
-    });
-  }
-  return nextStrings;
-}
-function cloneTemplateContentWithUpdatedFirstString(content, firstString) {
-  const descriptors = Object.getOwnPropertyDescriptors(content);
-  const clonedContent = Object.create(Object.getPrototypeOf(content));
-  const stringsDescriptor = descriptors.strings;
-  Object.defineProperties(clonedContent, {
-    ...descriptors,
-    strings: {
-      ...stringsDescriptor,
-      value: cloneTemplateStrings(content.strings, firstString)
-    }
-  });
-  return clonedContent;
-}
-function cloneMarkupNodeLikeWithUpdatedOuterHtml(content, outerHTML) {
-  const descriptors = Object.getOwnPropertyDescriptors(content);
-  const clonedContent = Object.create(Object.getPrototypeOf(content));
-  const outerHTMLDescriptor = descriptors.outerHTML;
-  Object.defineProperties(clonedContent, {
-    ...descriptors,
-    outerHTML: {
-      configurable: outerHTMLDescriptor?.configurable ?? true,
-      enumerable: outerHTMLDescriptor?.enumerable ?? true,
-      writable: true,
-      value: outerHTML
-    }
-  });
-  return clonedContent;
-}
-function wrapWithScriptsInjectorMarkup(content, injectorMapScript) {
-  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${content}<\/scripts-injector>`;
-}
-function cloneTemplateContentWithWrappedInjector(content, injectorMapScript) {
-  if (content.strings.length === 0) {
-    return wrapWithScriptsInjectorMarkup(String(content), injectorMapScript);
-  }
-  const nextStrings = [...content.strings];
-  nextStrings[0] = wrapWithScriptsInjectorMarkup(nextStrings[0] ?? "", injectorMapScript);
-  nextStrings[nextStrings.length - 1] = `${nextStrings[nextStrings.length - 1] ?? ""}<\/scripts-injector>`;
-  const rawDescriptor = Object.getOwnPropertyDescriptor(content.strings, "raw");
-  if (rawDescriptor && Array.isArray(rawDescriptor.value)) {
-    const rawStrings = [...rawDescriptor.value];
-    rawStrings[0] = wrapWithScriptsInjectorMarkup(rawStrings[0] ?? "", injectorMapScript);
-    rawStrings[rawStrings.length - 1] = `${rawStrings[rawStrings.length - 1] ?? ""}<\/scripts-injector>`;
-    Object.defineProperty(nextStrings, "raw", {
-      ...rawDescriptor,
-      value: rawStrings
-    });
-  }
-  const descriptors = Object.getOwnPropertyDescriptors(content);
-  const clonedContent = Object.create(Object.getPrototypeOf(content));
-  const stringsDescriptor = descriptors.strings;
-  Object.defineProperties(clonedContent, {
-    ...descriptors,
-    strings: {
-      ...stringsDescriptor,
-      value: nextStrings
-    }
-  });
-  return clonedContent;
-}
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function isTemplateContentShape(value) {
-  return typeof value === "object" && value !== null && Array.isArray(value.strings) && ((value.values ?? void 0) === void 0 || Array.isArray(value.values));
-}
-function isMarkupNodeLikeShape(value) {
-  return typeof value === "object" && value !== null && typeof value.nodeType === "number";
-}
-function injectTriggerAttributeIntoString(content, triggerId) {
-  const str = content;
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== "<") {
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === "!" || next === "?") {
-      const end = str.indexOf(">", i);
-      if (end === -1) break;
-      i = end + 1;
-      continue;
-    }
-    if (next && /[a-zA-Z]/.test(next)) {
-      const tagSlice = str.slice(i + 1);
-      const nameEnd = tagSlice.search(/[\s/>]/);
-      if (nameEnd === -1) break;
-      const insertAt = i + 1 + nameEnd;
-      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
-    }
-    break;
-  }
-  return str;
-}
-function addTriggerAttribute(content, triggerId) {
-  if (isTemplateContentShape(content)) {
-    if (content.strings.length === 0) {
-      return String(content);
-    }
-    return cloneTemplateContentWithUpdatedFirstString(
-      content,
-      injectTriggerAttributeIntoString(content.strings[0] ?? "", triggerId)
-    );
-  }
-  if (isMarkupNodeLikeShape(content) && typeof content.outerHTML === "string") {
-    return cloneMarkupNodeLikeWithUpdatedOuterHtml(
-      content,
-      injectTriggerAttributeIntoString(content.outerHTML, triggerId)
-    );
-  }
-  return injectTriggerAttributeIntoString(String(content), triggerId);
-}
-function wrapWithScriptsInjector(content, lazyGroups) {
-  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
-  if (isTemplateContentShape(content)) {
-    return cloneTemplateContentWithWrappedInjector(content, injectorMapScript);
-  }
-  if (isMarkupNodeLikeShape(content) && typeof content.outerHTML === "string") {
-    return cloneMarkupNodeLikeWithUpdatedOuterHtml(
-      content,
-      wrapWithScriptsInjectorMarkup(content.outerHTML, injectorMapScript)
-    );
-  }
-  return wrapWithScriptsInjectorMarkup(String(content), injectorMapScript);
-}
-function decodeHtmlEntities(value) {
-  let decoded = value;
-  let previous;
-  do {
-    previous = decoded;
-    decoded = decoded.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&#x27;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
-  } while (decoded !== previous);
-  return decoded;
-}
-function normalizeBoundaryArtifactHtml(html) {
-  return html.replace(
-    /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
-    (marker) => decodeHtmlEntities(marker)
-  );
-}
-function inspectBoundaryArtifactHtml(html) {
-  const normalizedHtml = normalizeBoundaryArtifactHtml(html);
-  return {
-    normalizedHtml,
-    hasUnresolvedBoundaryArtifacts: normalizedHtml.includes("<eco-marker")
-  };
-}
-export {
-  addTriggerAttribute,
-  decodeHtmlEntities,
-  inspectBoundaryArtifactHtml,
-  isThenable,
-  normalizeBoundaryArtifactHtml,
-  wrapWithScriptsInjector
-};

package/src/route-renderer/orchestration/render-preparation.service.d.ts

@@ -1,120 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../../types/public-types.js';
-import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import { BoundaryPlanningService } from './boundary-planning.service.js';
-import { PagePackagingService } from './page-packaging.service.js';
-type ResolvedPageModule = {
-    Page: EcoPageFile['default'] | EcoPageComponent<any>;
-    getStaticProps?: GetStaticProps<Record<string, unknown>>;
-    getMetadata?: GetMetadata;
-    integrationSpecificProps: Record<string, unknown>;
-};
-export interface RenderPreparationCallbacks {
-    resolvePageModule(file: string): Promise<ResolvedPageModule>;
-    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-    resolvePageData(pageModule: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-    }, routeOptions: RouteRendererOptions): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
-    resolveDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
-    buildRouteRenderAssets(file: string): Promise<ProcessedAsset[]> | undefined;
-    shouldRenderPageComponent(input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        options: RouteRendererOptions;
-    }): boolean;
-    renderPageComponent(input: {
-        component: EcoComponent;
-        props: Record<string, unknown>;
-    }): Promise<ComponentRenderResult>;
-}
-export interface RenderPreparationServiceDependencies {
-    boundaryPlanningService?: BoundaryPlanningService;
-    pagePackagingService?: PagePackagingService;
-}
-/**
- * Prepares the normalized render inputs consumed by `IntegrationRenderer.execute()`.
- *
- * This service owns the orchestration that happens before the main HTML render:
- * page module resolution, data loading, dependency aggregation, page-root
- * component artifact capture, lazy trigger bootstrap generation, and request
- * locals policy.
- */
-export declare class RenderPreparationService {
-    private appConfig;
-    private assetProcessingService;
-    private readonly boundaryPlanningService;
-    private readonly pagePackagingService;
-    /**
-     * Creates the render-preparation orchestrator for one app instance.
-     *
-     * @remarks
-     * The service is app-scoped because it depends on finalized config defaults and
-     * the app-owned asset-processing pipeline while remaining renderer-agnostic.
-     */
-    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RenderPreparationServiceDependencies);
-    /**
-     * Builds the final render options object used by the integration-specific
-     * renderer.
-     *
-     * The returned object contains normalized page data, processed dependency
-     * state, component render artifacts, and the locals contract expected by the
-     * rest of the pipeline.
-     *
-     * @typeParam C Integration render output element type.
-     * @param routeOptions Route-level render inputs.
-     * @param currentIntegrationName Active integration name for this preparation pass.
-     * @param callbacks Renderer-specific hooks used during preparation.
-     * @returns Normalized render options.
-     */
-    prepare<C = EcoPagesElement>(routeOptions: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderPreparationCallbacks): Promise<IntegrationRendererRenderOptions<C>>;
-    /**
-     * Collects resolved lazy trigger metadata from the component tree.
-     *
-     * Traversal is depth-first and deduplicated by component identity so shared
-     * component dependencies do not emit duplicate trigger sets.
-     *
-     * @param components Root component set.
-     * @param seen Internal visited set for shared graphs.
-     * @returns All resolved lazy triggers reachable from the root set.
-     */
-    private collectResolvedTriggers;
-    /**
-     * Collects global integration dependencies used by nested components belonging
-     * to integrations other than the current renderer.
-     *
-     * @param components Root component set.
-     * @returns Processed integration dependencies contributed by nested integrations.
-     */
-    private collectUsedIntegrationDependencies;
-    /**
-     * Discovers integration names referenced by the component dependency graph.
-     *
-     * @param components Root component set.
-     * @param seen Internal visited set for shared graphs.
-     * @returns Set of integration names found in the graph.
-     */
-    private collectIntegrationNames;
-    /**
-     * Renders the page root through the component-level render contract so any
-     * integration-specific assets and root attributes are available before the main
-     * document render.
-     *
-     * @param input Page root render inputs.
-     * @returns Structured component render result.
-     */
-    private renderPageRoot;
-    /**
-     * Builds the runtime assets needed to bootstrap global lazy trigger execution.
-     *
-     * @param triggers Fully resolved lazy trigger definitions.
-     * @returns Processed assets that should be merged into the final dependency set.
-     */
-    private buildGlobalInjectorAssets;
-    private buildEagerSsrLazyAssets;
-    private collectEagerSsrLazyDependencies;
-}
-export {};

package/src/route-renderer/orchestration/render-preparation.service.js

@@ -1,364 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import {
-  AssetFactory
-} from "../../services/assets/asset-processing-service/index.js";
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
-import { LocalsAccessError } from "../../errors/locals-access-error.js";
-import { BoundaryPlanningService } from "./boundary-planning.service.js";
-import { PagePackagingService } from "./page-packaging.service.js";
-import { dedupeProcessedAssets } from "./processed-asset-dedupe.js";
-function createPageLocalsProxy(filePath) {
-  const errorMessage = `[ecopages] Request locals are only available during request-time rendering with cache: 'dynamic'. Page: ${filePath}. If you meant to use locals here, set cache: 'dynamic' and provide locals from route middleware/handlers.`;
-  return new Proxy(
-    {},
-    {
-      get: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      set: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      has: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      ownKeys: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      deleteProperty: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      defineProperty: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      getOwnPropertyDescriptor: () => {
-        throw new LocalsAccessError(errorMessage);
-      }
-    }
-  );
-}
-class RenderPreparationService {
-  appConfig;
-  assetProcessingService;
-  boundaryPlanningService;
-  pagePackagingService;
-  /**
-   * Creates the render-preparation orchestrator for one app instance.
-   *
-   * @remarks
-   * The service is app-scoped because it depends on finalized config defaults and
-   * the app-owned asset-processing pipeline while remaining renderer-agnostic.
-   */
-  constructor(appConfig, assetProcessingService, dependencies = {}) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-    this.boundaryPlanningService = dependencies.boundaryPlanningService ?? new BoundaryPlanningService(appConfig);
-    this.pagePackagingService = dependencies.pagePackagingService ?? new PagePackagingService();
-  }
-  /**
-   * Builds the final render options object used by the integration-specific
-   * renderer.
-   *
-   * The returned object contains normalized page data, processed dependency
-   * state, component render artifacts, and the locals contract expected by the
-   * rest of the pipeline.
-   *
-   * @typeParam C Integration render output element type.
-   * @param routeOptions Route-level render inputs.
-   * @param currentIntegrationName Active integration name for this preparation pass.
-   * @param callbacks Renderer-specific hooks used during preparation.
-   * @returns Normalized render options.
-   */
-  async prepare(routeOptions, currentIntegrationName, callbacks) {
-    const pageModule = await callbacks.resolvePageModule(routeOptions.file);
-    const { Page, integrationSpecificProps } = pageModule;
-    const HtmlTemplate = await callbacks.getHtmlTemplate();
-    const { props, metadata } = await callbacks.resolvePageData(pageModule, routeOptions);
-    const Layout = Page.config?.layout;
-    const boundaryPlan = this.boundaryPlanningService.buildPlan({
-      routeFile: routeOptions.file,
-      currentIntegrationName,
-      HtmlTemplate,
-      Layout,
-      Page
-    });
-    const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
-    const resolvedDependencies = await callbacks.resolveDependencies(componentsToResolve);
-    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(
-      componentsToResolve,
-      currentIntegrationName
-    );
-    const pageDeps = await callbacks.buildRouteRenderAssets(routeOptions.file) || [];
-    const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
-    let componentRender;
-    if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
-      const pageRootRender = await this.renderPageRoot({
-        Page,
-        props,
-        routeOptions,
-        callbacks
-      });
-      componentRender = pageRootRender.componentRender;
-      if (componentRender.assets?.length) {
-        allDependencies.push(...componentRender.assets);
-      }
-    }
-    const triggers = this.collectResolvedTriggers(componentsToResolve);
-    if (triggers.length > 0) {
-      const globalAssets = await this.buildGlobalInjectorAssets(triggers, currentIntegrationName);
-      allDependencies.push(...globalAssets);
-    }
-    const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, currentIntegrationName);
-    if (eagerSsrLazyAssets.length > 0) {
-      allDependencies.push(...eagerSsrLazyAssets);
-    }
-    const dedupedDependencies = dedupeProcessedAssets(allDependencies);
-    const pagePackage = this.pagePackagingService.createPagePackage(dedupedDependencies);
-    const pageProps = {
-      ...props,
-      params: routeOptions.params || {},
-      query: routeOptions.query || {}
-    };
-    const cacheStrategy = Page.cache;
-    const defaultCacheStrategy = this.appConfig.cache?.defaultStrategy ?? "static";
-    const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
-    const localsAvailable = effectiveCacheStrategy === "dynamic" && routeOptions.locals !== void 0;
-    const pageLocals = localsAvailable ? routeOptions.locals : createPageLocalsProxy(routeOptions.file);
-    const locals = localsAvailable ? routeOptions.locals : void 0;
-    const preparedOptions = {
-      ...routeOptions,
-      resolvedDependencies,
-      pagePackage,
-      componentRender,
-      HtmlTemplate,
-      Layout,
-      props,
-      Page,
-      metadata,
-      params: routeOptions.params || {},
-      query: routeOptions.query || {},
-      pageProps,
-      locals,
-      pageLocals,
-      cacheStrategy,
-      boundaryPlan
-    };
-    return {
-      ...integrationSpecificProps,
-      ...preparedOptions
-    };
-  }
-  /**
-   * Collects resolved lazy trigger metadata from the component tree.
-   *
-   * Traversal is depth-first and deduplicated by component identity so shared
-   * component dependencies do not emit duplicate trigger sets.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns All resolved lazy triggers reachable from the root set.
-   */
-  collectResolvedTriggers(components, seen = /* @__PURE__ */ new Set()) {
-    const triggers = [];
-    for (const comp of components) {
-      if (!comp) {
-        continue;
-      }
-      const ecoComp = comp;
-      if (seen.has(ecoComp)) {
-        continue;
-      }
-      seen.add(ecoComp);
-      const ownTriggers = ecoComp.config?._resolvedLazyTriggers;
-      if (ownTriggers?.length) {
-        triggers.push(...ownTriggers);
-      }
-      const nested = ecoComp.config?.dependencies?.components;
-      if (nested?.length) {
-        triggers.push(...this.collectResolvedTriggers(nested, seen));
-      }
-    }
-    return triggers;
-  }
-  /**
-   * Collects global integration dependencies used by nested components belonging
-   * to integrations other than the current renderer.
-   *
-   * @param components Root component set.
-   * @returns Processed integration dependencies contributed by nested integrations.
-   */
-  collectUsedIntegrationDependencies(components, currentIntegrationName) {
-    const integrationNames = this.collectIntegrationNames(components);
-    const dependencies = [];
-    for (const integrationName of integrationNames) {
-      if (integrationName === currentIntegrationName) {
-        continue;
-      }
-      const integrationPlugin = this.appConfig.integrations.find(
-        (integration) => integration.name === integrationName
-      );
-      if (!integrationPlugin || typeof integrationPlugin.getResolvedIntegrationDependencies !== "function") {
-        continue;
-      }
-      dependencies.push(...integrationPlugin.getResolvedIntegrationDependencies());
-    }
-    return dependencies;
-  }
-  /**
-   * Discovers integration names referenced by the component dependency graph.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns Set of integration names found in the graph.
-   */
-  collectIntegrationNames(components, seen = /* @__PURE__ */ new Set()) {
-    const integrationNames = /* @__PURE__ */ new Set();
-    for (const comp of components) {
-      if (!comp) {
-        continue;
-      }
-      const ecoComp = comp;
-      if (seen.has(ecoComp)) {
-        continue;
-      }
-      seen.add(ecoComp);
-      const integrationName = ecoComp.config?.integration ?? ecoComp.config?.__eco?.integration;
-      if (integrationName) {
-        integrationNames.add(integrationName);
-      }
-      const nested = ecoComp.config?.dependencies?.components;
-      if (nested?.length) {
-        const nestedNames = this.collectIntegrationNames(nested, seen);
-        for (const nestedName of nestedNames) {
-          integrationNames.add(nestedName);
-        }
-      }
-    }
-    return integrationNames;
-  }
-  /**
-   * Renders the page root through the component-level render contract so any
-   * integration-specific assets and root attributes are available before the main
-   * document render.
-   *
-   * @param input Page root render inputs.
-   * @returns Structured component render result.
-   */
-  async renderPageRoot(input) {
-    return {
-      componentRender: await input.callbacks.renderPageComponent({
-        component: input.Page,
-        props: {
-          ...input.props,
-          params: input.routeOptions.params || {},
-          query: input.routeOptions.query || {}
-        }
-      })
-    };
-  }
-  /**
-   * Builds the runtime assets needed to bootstrap global lazy trigger execution.
-   *
-   * @param triggers Fully resolved lazy trigger definitions.
-   * @returns Processed assets that should be merged into the final dependency set.
-   */
-  async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
-    const globalInjectorImportPath = createRequire(import.meta.url).resolve("@ecopages/scripts-injector/global");
-    const mapScript = AssetFactory.createInlineContentScript({
-      position: "head",
-      name: "ecopages-global-injector-map",
-      content: buildGlobalInjectorMapScript(triggers),
-      attributes: { type: "ecopages/global-injector-map" },
-      packageRole: "keep-separate",
-      bundle: false
-    });
-    const bootstrapInlineScript = AssetFactory.createInlineContentScript({
-      position: "head",
-      name: "ecopages-global-injector-bootstrap",
-      content: buildGlobalInjectorBootstrapContent(globalInjectorImportPath),
-      attributes: { type: "module" },
-      packageRole: "keep-separate",
-      bundle: true
-    });
-    return this.assetProcessingService.processDependencies([mapScript, bootstrapInlineScript], currentIntegrationName);
-  }
-  async buildEagerSsrLazyAssets(components, currentIntegrationName) {
-    const dependencies = this.collectEagerSsrLazyDependencies(components);
-    if (dependencies.length === 0) {
-      return [];
-    }
-    return this.assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
-  }
-  collectEagerSsrLazyDependencies(components) {
-    const dependencies = [];
-    const visitedConfigs = /* @__PURE__ */ new Set();
-    const seenKeys = /* @__PURE__ */ new Set();
-    const normalizeAttributes = (attributes) => ({
-      type: "module",
-      defer: "",
-      ...attributes ?? {}
-    });
-    const collect = (config) => {
-      if (!config || visitedConfigs.has(config)) {
-        return;
-      }
-      visitedConfigs.add(config);
-      const componentFile = config.__eco?.file;
-      if (componentFile) {
-        const componentDir = path.dirname(componentFile);
-        for (const script of config.dependencies?.scripts ?? []) {
-          if (typeof script === "string" || !script.lazy || script.ssr !== true) {
-            continue;
-          }
-          const attributes = normalizeAttributes(script.attributes);
-          if (script.content) {
-            const key2 = `content:${script.content}:${JSON.stringify(attributes)}`;
-            if (seenKeys.has(key2)) {
-              continue;
-            }
-            seenKeys.add(key2);
-            dependencies.push(
-              AssetFactory.createContentScript({
-                position: "head",
-                content: script.content,
-                attributes,
-                packageRole: "dynamic-chunk"
-              })
-            );
-            continue;
-          }
-          if (!script.src) {
-            continue;
-          }
-          const resolvedPath = path.resolve(componentDir, script.src);
-          const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
-          if (seenKeys.has(key)) {
-            continue;
-          }
-          seenKeys.add(key);
-          dependencies.push(
-            AssetFactory.createFileScript({
-              filepath: resolvedPath,
-              position: "head",
-              attributes,
-              packageRole: "dynamic-chunk"
-            })
-          );
-        }
-      }
-      if (config.layout?.config) {
-        collect(config.layout.config);
-      }
-      for (const nestedComponent of config.dependencies?.components ?? []) {
-        collect(nestedComponent?.config);
-      }
-    };
-    for (const component of components) {
-      collect(component.config);
-    }
-    return dependencies;
-  }
-}
-export {
-  RenderPreparationService
-};