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

package/src/services/assets/asset-processing-service/processors/base/base-script-processor.js

@@ -1,5 +1,4 @@
 import { appLogger } from "../../../../../global/app-logger.js";
-import { getAppBrowserBuildPlugins } from "../../../../../build/build-adapter.js";
 import { fileSystem } from "@ecopages/file-system";
 import path from "node:path";
 import { BaseProcessor } from "./base-processor.js";
@@ -22,14 +21,6 @@ class BaseScriptProcessor extends BaseProcessor {
     }
     return dep.bundleOptions || {};
   }
-  collectBuildPlugins(excludePluginNames) {
-    const buildPlugins = getAppBrowserBuildPlugins(this.appConfig);
-    if (!excludePluginNames || excludePluginNames.length === 0) {
-      return buildPlugins;
-    }
-    const excluded = new Set(excludePluginNames);
-    return buildPlugins.filter((plugin) => !excluded.has(plugin.name));
-  }
   async bundleScript({
     entrypoint,
     outdir,
@@ -37,8 +28,6 @@ class BaseScriptProcessor extends BaseProcessor {
     plugins: additionalPlugins,
     ...rest
   }) {
-    const buildPlugins = this.collectBuildPlugins(excludeAppBuildPlugins);
-    const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
     const buildResult = await this.browserBundleService.bundle({
       profile: "browser-script",
       entrypoints: [entrypoint],
@@ -47,7 +36,7 @@ class BaseScriptProcessor extends BaseProcessor {
       excludeAppBuildPlugins,
       splitting: true,
       naming: "[name]-[hash].[ext]",
-      plugins: allPlugins,
+      plugins: additionalPlugins,
       ...rest
     });
     if (!buildResult.success) {
@@ -86,8 +75,6 @@ class BaseScriptProcessor extends BaseProcessor {
     plugins: additionalPlugins,
     ...rest
   }) {
-    const buildPlugins = this.collectBuildPlugins(excludeAppBuildPlugins);
-    const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
     const buildResult = await this.browserBundleService.bundleGroupedEntries(entries, {
       profile: "browser-script",
       outdir,
@@ -96,7 +83,7 @@ class BaseScriptProcessor extends BaseProcessor {
       ...rest,
       splitting: true,
       naming: "[name]-[hash].[ext]",
-      plugins: allPlugins
+      plugins: additionalPlugins
     });
     if (!buildResult.success) {
       for (const log of buildResult.logs) {

package/src/services/assets/asset-processing-service/processors/script/content-script.processor.d.ts

@@ -1,6 +1,14 @@
 import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
+    private getContentScriptEntryDir;
+    private getContentScriptEntryPath;
+    private toProcessedAsset;
+    private removeContentScriptEntry;
     processGrouped(deps: ContentScriptAsset[]): Promise<ProcessedAsset[]>;
+    private getGroupedBundlerOptions;
+    /**
+     * Emits one content script asset. Cache reuse is owned by {@link AssetProcessingService}.
+     */
     process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/script/content-script.processor.js

@@ -1,7 +1,37 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
+import { resolveInlineContentScriptBody } from "../../inline-content-script-body.js";
+import { shouldUseDevBrowserScriptCache } from "../../../../../build/cache/dev-browser-script-cache.js";
 import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class ContentScriptProcessor extends BaseScriptProcessor {
+  getContentScriptEntryDir() {
+    const dir = path.join(this.appConfig.absolutePaths.workDir, "content-script-entries");
+    fileSystem.ensureDir(dir);
+    return dir;
+  }
+  getContentScriptEntryPath(contentHash) {
+    return path.join(this.getContentScriptEntryDir(), `${contentHash}.js`);
+  }
+  toProcessedAsset(dep, filepath) {
+    return {
+      filepath,
+      content: resolveInlineContentScriptBody(dep, filepath),
+      kind: "script",
+      position: dep.position,
+      attributes: dep.attributes,
+      inline: dep.inline,
+      excludeFromHtml: dep.excludeFromHtml,
+      packageRole: dep.packageRole,
+      groupedBundle: dep.groupedBundle,
+      bundledSourceFilepaths: dep.bundledSourceFilepaths
+    };
+  }
+  removeContentScriptEntry(contentHash) {
+    if (shouldUseDevBrowserScriptCache()) {
+      return;
+    }
+    fileSystem.remove(this.getContentScriptEntryPath(contentHash));
+  }
   async processGrouped(deps) {
     if (deps.length === 0) {
       return [];
@@ -10,109 +40,84 @@ class ContentScriptProcessor extends BaseScriptProcessor {
     if (!shouldBundle || deps.some((dep) => dep.inline)) {
       return Promise.all(deps.map((dep) => this.process(dep)));
     }
-    const tempDir = path.join(
-      this.appConfig.absolutePaths.distDir,
-      `grouped-script-entries-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    );
-    fileSystem.ensureDir(tempDir);
+    let tempEntries = [];
     try {
-      const tempEntries = deps.map((dep, index) => {
-        const entryName = dep.groupedBundle?.entryName ?? dep.name ?? `grouped-script-${index}`;
-        const tempFilepath = path.join(tempDir, `${entryName}.js`);
+      tempEntries = deps.map((dep) => {
+        const contentHash = this.generateHash(dep.content);
+        const tempFilepath = this.getContentScriptEntryPath(contentHash);
         fileSystem.write(tempFilepath, dep.content);
         return {
           dep,
-          entryName,
+          contentHash,
           tempFilepath
         };
       });
-      const primaryDep = deps[0];
       const outputPaths = await this.bundleScripts({
-        ...this.getBundlerOptions(primaryDep),
-        entries: tempEntries.map(({ entryName, tempFilepath }) => ({
-          entryName,
+        ...this.getGroupedBundlerOptions(deps),
+        entries: tempEntries.map(({ dep, contentHash, tempFilepath }) => ({
+          entryName: dep.groupedBundle?.entryName ?? dep.name ?? contentHash,
           entrypoint: tempFilepath
         })),
         outdir: this.getAssetsDir(),
         minify: this.isProduction,
         naming: "[name]-[hash].[ext]"
       });
-      return tempEntries.map(({ dep, entryName }) => {
+      return tempEntries.map(({ dep, contentHash }) => {
+        const entryName = dep.groupedBundle?.entryName ?? dep.name ?? contentHash;
         const bundledFilePath = outputPaths.get(entryName);
         if (!bundledFilePath) {
           throw new Error(`Missing grouped bundle output for ${entryName}`);
         }
-        return {
-          filepath: bundledFilePath,
-          content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
-          kind: "script",
-          position: dep.position,
-          attributes: dep.attributes,
-          inline: dep.inline,
-          excludeFromHtml: dep.excludeFromHtml,
-          packageRole: dep.packageRole,
-          groupedBundle: dep.groupedBundle,
-          bundledSourceFilepaths: dep.bundledSourceFilepaths
-        };
+        return this.toProcessedAsset(dep, bundledFilePath);
       });
     } finally {
-      fileSystem.remove(tempDir);
+      for (const { contentHash } of tempEntries) {
+        this.removeContentScriptEntry(contentHash);
+      }
     }
   }
+  getGroupedBundlerOptions(deps) {
+    const primaryDep = deps[0];
+    const options = this.getBundlerOptions(primaryDep);
+    if (deps.some((dep) => dep.bundleOptions?.splitting === false)) {
+      return {
+        ...options,
+        splitting: false
+      };
+    }
+    return options;
+  }
+  /**
+   * Emits one content script asset. Cache reuse is owned by {@link AssetProcessingService}.
+   */
   async process(dep) {
+    const shouldBundle = this.shouldBundle(dep);
     const hash = this.generateHash(dep.content);
     const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
-    const shouldBundle = this.shouldBundle(dep);
     const filepath = path.join(this.getAssetsDir(), "scripts", filename);
     if (!shouldBundle) {
-      if (!dep.inline) fileSystem.write(filepath, dep.content);
-      const unbundledProcessedAsset = {
-        filepath,
-        content: dep.inline ? dep.content : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        groupedBundle: dep.groupedBundle,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-      this.writeCacheFile(filename, unbundledProcessedAsset);
-      return unbundledProcessedAsset;
+      if (!dep.inline) {
+        fileSystem.write(filepath, dep.content);
+      }
+      return this.toProcessedAsset(dep, filepath);
     }
-    if (dep.content) {
-      const tempDir = this.appConfig.absolutePaths.distDir;
-      fileSystem.ensureDir(tempDir);
-      const tempFileName = path.join(
-        tempDir,
-        `${path.parse(filename).name}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp.js`
-      );
-      fileSystem.write(tempFileName, dep.content);
+    if (!dep.content) {
+      throw new Error("No content found for script asset");
+    }
+    const entryPath = this.getContentScriptEntryPath(hash);
+    fileSystem.write(entryPath, dep.content);
+    try {
       const bundledFilePath = await this.bundleScript({
-        entrypoint: tempFileName,
+        entrypoint: entryPath,
         outdir: this.getAssetsDir(),
         minify: this.isProduction,
         naming: `${path.parse(filename).name}-[hash].[ext]`,
         ...this.getBundlerOptions(dep)
       });
-      const processedAsset = {
-        filepath: bundledFilePath,
-        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        groupedBundle: dep.groupedBundle,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-      fileSystem.remove(tempFileName);
-      this.writeCacheFile(filename, processedAsset);
-      return processedAsset;
+      return this.toProcessedAsset(dep, bundledFilePath);
+    } finally {
+      this.removeContentScriptEntry(hash);
     }
-    throw new Error("No content found for script asset");
   }
 }
 export {

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.d.ts

@@ -3,7 +3,6 @@ import type { FileScriptAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
     private hmrManager?;
-    private resolveHmrOutputFilepath;
     setHmrManager(hmrManager: IHmrManager): void;
     process(dep: FileScriptAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.js

@@ -4,28 +4,31 @@ import { fileSystem } from "@ecopages/file-system";
 import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class FileScriptProcessor extends BaseScriptProcessor {
   hmrManager;
-  resolveHmrOutputFilepath(entrypointPath) {
-    if (!this.hmrManager || !("getDistDir" in this.hmrManager)) {
-      return void 0;
-    }
-    const getDistDir = this.hmrManager.getDistDir;
-    if (typeof getDistDir !== "function") {
-      return void 0;
-    }
-    const relativePathJs = path.relative(this.appConfig.absolutePaths.srcDir, entrypointPath).replace(/\.(tsx?|jsx?|mdx?)$/, ".js").replace(/\[([^\]]+)\]/g, "_$1_");
-    return path.join(getDistDir.call(this.hmrManager), relativePathJs);
-  }
   setHmrManager(hmrManager) {
     this.hmrManager = hmrManager;
   }
   async process(dep) {
     if (this.hmrManager?.isEnabled() && !dep.inline) {
-      const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
-      const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
+      const resolvedOutput = this.hmrManager.getResolvedScriptOutput?.(dep.filepath);
+      if (resolvedOutput) {
+        return {
+          filepath: resolvedOutput.outputPath,
+          sourceFilepath: dep.filepath,
+          srcUrl: resolvedOutput.outputUrl,
+          kind: "script",
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: false,
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
+        };
+      }
+      const registered = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
       return {
-        filepath: outputFilepath ?? dep.filepath,
+        filepath: registered.outputPath,
         sourceFilepath: dep.filepath,
-        srcUrl: outputUrl,
+        srcUrl: registered.outputUrl,
         kind: "script",
         position: dep.position,
         attributes: dep.attributes,

package/src/services/assets/asset-processing-service/processors/script/node-module-script.processor.js

@@ -8,19 +8,33 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
     const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
     const moduleName = path.basename(modulePath);
     const filename = dep.name ?? `nm-${moduleName}`;
+    const shouldBundle = this.shouldBundle(dep);
     const configHash = this.generateHash(
-      JSON.stringify({ inline: dep.inline, minify: !dep.inline && this.isProduction, opts: dep.bundleOptions })
+      JSON.stringify({
+        bundle: shouldBundle,
+        inline: dep.inline,
+        minify: shouldBundle && !dep.inline && this.isProduction,
+        opts: dep.bundleOptions
+      })
     );
     const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
     return this.getOrProcess(cachekey, async () => {
-      if (dep.inline) {
+      if (dep.inline || !shouldBundle) {
         const content = fileSystem.readFileAsBuffer(modulePath).toString();
+        const filepath = dep.inline ? void 0 : path.join(this.getAssetsDir(), "vendors", filename);
+        if (filepath) {
+          fileSystem.ensureDir(path.dirname(filepath));
+          if (!fileSystem.exists(filepath) || fileSystem.readFileAsBuffer(filepath).toString() !== content) {
+            fileSystem.copyFile(modulePath, filepath);
+          }
+        }
         return {
+          filepath,
           content,
           kind: dep.kind,
           position: dep.position,
           attributes: dep.attributes,
-          inline: true,
+          inline: dep.inline,
           excludeFromHtml: dep.excludeFromHtml,
           packageRole: dep.packageRole,
           bundledSourceFilepaths: dep.bundledSourceFilepaths

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.d.ts

@@ -1,8 +1,5 @@
 import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -1,40 +1,11 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { BaseProcessor } from "../base/base-processor.js";
+import { applyStylesheetProcessors } from "./stylesheet-processor-pipeline.js";
 class ContentStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
-  isProcessableStylesheet(filepath) {
-    return ContentStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
-    }
-    let transformedContent = content;
-    const processors = this.appConfig.processors ? Array.from(this.appConfig.processors.values()) : [];
-    for (const processor of processors) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
   async process(dep) {
     const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, "styles", "page-bundle.css");
-    const processedContent = await this.applyStylesheetProcessors(dep.content, virtualFilepath);
+    const processedContent = await applyStylesheetProcessors(this.appConfig, dep.content, virtualFilepath);
     const hash = this.generateHash(processedContent);
     const filename = `style-${hash}.css`;
     const cachekey = this.buildCacheKey(filename, hash, dep);

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.d.ts

@@ -1,9 +1,6 @@
 import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
     getStyleContent: (srcUrl: string) => Buffer;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: FileStylesheetAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.js

@@ -1,43 +1,15 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import { BaseProcessor } from "../base/base-processor.js";
+import { applyStylesheetProcessors } from "./stylesheet-processor-pipeline.js";
 class FileStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
   getStyleContent = (srcUrl) => {
     return fileSystem.readFileAsBuffer(srcUrl);
   };
-  isProcessableStylesheet(filepath) {
-    return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
-    }
-    let transformedContent = content;
-    for (const processor of this.appConfig.processors.values()) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
   async process(dep) {
     const buffer = this.getStyleContent(dep.filepath);
     const rawContent = buffer.toString();
-    const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
+    const processedContent = await applyStylesheetProcessors(this.appConfig, rawContent, dep.filepath);
     const hash = this.generateHash(processedContent);
     const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
     return this.getOrProcess(cachekey, () => {

package/src/services/assets/asset-processing-service/processors/stylesheet/stylesheet-processor-pipeline.d.ts

@@ -0,0 +1,2 @@
+import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
+export declare function applyStylesheetProcessors(appConfig: EcoPagesAppConfig, content: string, filepath: string): Promise<string>;

package/src/services/assets/asset-processing-service/processors/stylesheet/stylesheet-processor-pipeline.js

@@ -0,0 +1,43 @@
+import path from "node:path";
+const PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+function isProcessableStylesheet(filepath) {
+  return PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+}
+function shouldRunStylesheetProcessor(processor, filepath) {
+  const hasCapabilities = processor.getAssetCapabilities().length > 0;
+  const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
+  if (canProcessStylesheet) {
+    return true;
+  }
+  if (hasCapabilities) {
+    return false;
+  }
+  return processor.getName().includes("postcss");
+}
+async function applyStylesheetProcessors(appConfig, content, filepath) {
+  if (!isProcessableStylesheet(filepath)) {
+    return content;
+  }
+  let transformedContent = content;
+  const processors = appConfig.processors ? Array.from(appConfig.processors.values()) : [];
+  for (const processor of processors) {
+    if (!shouldRunStylesheetProcessor(processor, filepath)) {
+      continue;
+    }
+    if (!processor.matchesFileFilter(filepath)) {
+      continue;
+    }
+    const result = await processor.process(transformedContent, filepath);
+    if (typeof result === "string") {
+      transformedContent = result;
+      continue;
+    }
+    if (result instanceof Buffer) {
+      transformedContent = result.toString();
+    }
+  }
+  return transformedContent;
+}
+export {
+  applyStylesheetProcessors
+};

package/src/services/assets/asset-processing-service/resolve-integration-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { AnyIntegrationPlugin } from '../../../plugins/integration-plugin.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+/** Resolves the integration plugin that owns one asset-processing batch key. */
+export declare function resolveIntegrationPluginForProcessingKey(appConfig: EcoPagesAppConfig, processingKey: string): AnyIntegrationPlugin | undefined;

package/src/services/assets/asset-processing-service/resolve-integration-plugin.js

@@ -0,0 +1,17 @@
+function resolveIntegrationPluginForProcessingKey(appConfig, processingKey) {
+  if (!appConfig.integrations?.length) {
+    return void 0;
+  }
+  const exactMatch = appConfig.integrations.find((integration) => integration.name === processingKey);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const baseName = processingKey.split(":")[0];
+  if (!baseName || baseName === processingKey) {
+    return void 0;
+  }
+  return appConfig.integrations.find((integration) => integration.name === baseName);
+}
+export {
+  resolveIntegrationPluginForProcessingKey
+};

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.d.ts

@@ -2,7 +2,6 @@ import type { AssetProcessor } from './processor.interface.js';
 import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
 type ProcessUngroupedDependencyOptions = {
     dep: AssetDefinition;
-    key: string;
     depKey: string;
     getCachedAsset: (dep: AssetDefinition, depKey: string) => ProcessedAsset | null;
     getProcessor: (dep: AssetDefinition) => AssetProcessor | undefined;

package/src/services/assets/asset-processing-service/ungrouped-dependency-processing.js

@@ -1,8 +1,8 @@
 import { fileSystem } from "@ecopages/file-system";
+import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
 async function processUngroupedDependency(options) {
   const {
     dep,
-    key,
     depKey,
     getCachedAsset,
     getProcessor,
@@ -14,7 +14,7 @@ async function processUngroupedDependency(options) {
   } = options;
   const cached = getCachedAsset(dep, depKey);
   if (cached) {
-    return { key, ...cached };
+    return finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl);
   }
   const processor = getProcessor(dep);
   if (!processor) {
@@ -27,14 +27,9 @@ async function processUngroupedDependency(options) {
   }
   try {
     const processed = await processor.process(dep);
-    const srcUrl = resolveProcessedAssetSrcUrl(processed);
-    const processedWithKey = {
-      key,
-      ...processed,
-      srcUrl
-    };
-    setCachedAsset(dep, depKey, processedWithKey);
-    return processedWithKey;
+    const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+    setCachedAsset(dep, depKey, finalized);
+    return finalized;
   } catch (error) {
     logProcessingError(dep, error);
     return null;