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

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

@@ -1,8 +1,8 @@
-import { appLogger } from "../../../../../global/app-logger";
+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";
+import { BaseProcessor } from "./base-processor.js";
 import { BrowserBundleService } from "../../../browser-bundle.service.js";
 class BaseScriptProcessor extends BaseProcessor {
   browserBundleService;
@@ -14,24 +14,37 @@ class BaseScriptProcessor extends BaseProcessor {
     return dep.bundle !== false;
   }
   getBundlerOptions(dep) {
+    if (dep.packageRole === "page-script" && dep.bundleOptions?.splitting === void 0) {
+      return {
+        ...dep.bundleOptions,
+        splitting: false
+      };
+    }
     return dep.bundleOptions || {};
   }
-  collectBuildPlugins() {
-    return getAppBrowserBuildPlugins(this.appConfig);
+  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,
+    excludeAppBuildPlugins,
     plugins: additionalPlugins,
     ...rest
   }) {
-    const buildPlugins = this.collectBuildPlugins();
+    const buildPlugins = this.collectBuildPlugins(excludeAppBuildPlugins);
     const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
     const buildResult = await this.browserBundleService.bundle({
       profile: "browser-script",
       entrypoints: [entrypoint],
       outdir,
       root: this.appConfig.rootDir,
+      excludeAppBuildPlugins,
       splitting: true,
       naming: "[name]-[hash].[ext]",
       plugins: allPlugins,
@@ -66,6 +79,57 @@ class BaseScriptProcessor extends BaseProcessor {
     const logMessage = buildResult.logs.map((log) => log.message).join(" | ");
     throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ""}`);
   }
+  async bundleScripts({
+    entries,
+    outdir,
+    excludeAppBuildPlugins,
+    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,
+      root: this.appConfig.rootDir,
+      excludeAppBuildPlugins,
+      ...rest,
+      splitting: true,
+      naming: "[name]-[hash].[ext]",
+      plugins: allPlugins
+    });
+    if (!buildResult.success) {
+      for (const log of buildResult.logs) {
+        appLogger.debug(log.message, log);
+      }
+    }
+    const outputs = buildResult.outputs.map((output) => output.path);
+    const entryOutputs = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      const exactOutput = outputs.find((outputPath) => path.basename(outputPath) === `${entry.entryName}.js`);
+      if (exactOutput) {
+        entryOutputs.set(entry.entryName, exactOutput);
+        continue;
+      }
+      const hashedOutput = outputs.find(
+        (outputPath) => path.basename(outputPath).startsWith(`${entry.entryName}-`)
+      );
+      if (hashedOutput) {
+        entryOutputs.set(entry.entryName, hashedOutput);
+        continue;
+      }
+      const fallbackOutput = path.join(outdir, `${entry.entryName}.js`);
+      if (fileSystem.exists(fallbackOutput)) {
+        entryOutputs.set(entry.entryName, fallbackOutput);
+        continue;
+      }
+      const logMessage = buildResult.logs.map((log) => log.message).join(" | ");
+      throw new Error(
+        `No build output generated for grouped entry ${entry.entryName}${logMessage ? `: ${logMessage}` : ""}`
+      );
+    }
+    return entryOutputs;
+  }
 }
 export {
   BaseScriptProcessor

package/src/services/assets/asset-processing-service/processors/index.d.ts

@@ -1,5 +1,5 @@
-export * from './script/content-script.processor';
-export * from './script/file-script.processor';
-export * from './script/node-module-script.processor';
-export * from './stylesheet/content-stylesheet.processor';
-export * from './stylesheet/file-stylesheet.processor';
+export * from './script/content-script.processor.js';
+export * from './script/file-script.processor.js';
+export * from './script/node-module-script.processor.js';
+export * from './stylesheet/content-stylesheet.processor.js';
+export * from './stylesheet/file-stylesheet.processor.js';

package/src/services/assets/asset-processing-service/processors/index.js

@@ -1,5 +1,5 @@
-export * from "./script/content-script.processor";
-export * from "./script/file-script.processor";
-export * from "./script/node-module-script.processor";
-export * from "./stylesheet/content-stylesheet.processor";
-export * from "./stylesheet/file-stylesheet.processor";
+export * from "./script/content-script.processor.js";
+export * from "./script/file-script.processor.js";
+export * from "./script/node-module-script.processor.js";
+export * from "./stylesheet/content-stylesheet.processor.js";
+export * from "./stylesheet/file-stylesheet.processor.js";

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

@@ -1,5 +1,6 @@
-import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
+import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types.js';
+import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
+    processGrouped(deps: ContentScriptAsset[]): Promise<ProcessedAsset[]>;
     process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
 }

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

@@ -1,7 +1,64 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class ContentScriptProcessor extends BaseScriptProcessor {
+  async processGrouped(deps) {
+    if (deps.length === 0) {
+      return [];
+    }
+    const shouldBundle = deps.every((dep) => this.shouldBundle(dep));
+    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);
+    try {
+      const tempEntries = deps.map((dep, index) => {
+        const entryName = dep.groupedBundle?.entryName ?? dep.name ?? `grouped-script-${index}`;
+        const tempFilepath = path.join(tempDir, `${entryName}.js`);
+        fileSystem.write(tempFilepath, dep.content);
+        return {
+          dep,
+          entryName,
+          tempFilepath
+        };
+      });
+      const primaryDep = deps[0];
+      const outputPaths = await this.bundleScripts({
+        ...this.getBundlerOptions(primaryDep),
+        entries: tempEntries.map(({ entryName, tempFilepath }) => ({
+          entryName,
+          entrypoint: tempFilepath
+        })),
+        outdir: this.getAssetsDir(),
+        minify: this.isProduction,
+        naming: "[name]-[hash].[ext]"
+      });
+      return tempEntries.map(({ dep, entryName }) => {
+        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
+        };
+      });
+    } finally {
+      fileSystem.remove(tempDir);
+    }
+  }
   async process(dep) {
     const hash = this.generateHash(dep.content);
     const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
@@ -16,7 +73,10 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        groupedBundle: dep.groupedBundle,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       this.writeCacheFile(filename, unbundledProcessedAsset);
       return unbundledProcessedAsset;
@@ -43,7 +103,10 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        groupedBundle: dep.groupedBundle,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       fileSystem.remove(tempFileName);
       this.writeCacheFile(filename, processedAsset);

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

@@ -1,8 +1,9 @@
-import type { IHmrManager } from '../../../../../internal-types';
-import type { FileScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
+import type { IHmrManager } from '../../../../../types/internal-types.js';
+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

@@ -1,23 +1,38 @@
 import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../../constants";
+import { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+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);
       return {
-        filepath: dep.filepath,
+        filepath: outputFilepath ?? dep.filepath,
+        sourceFilepath: dep.filepath,
         srcUrl: outputUrl,
         kind: "script",
         position: dep.position,
         attributes: dep.attributes,
         inline: false,
-        excludeFromHtml: dep.excludeFromHtml
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     }
     const content = fileSystem.readFileSync(dep.filepath);
@@ -40,12 +55,15 @@ class FileScriptProcessor extends BaseScriptProcessor {
         }
         return {
           filepath,
+          sourceFilepath: dep.filepath,
           content,
           kind: "script",
           position: dep.position,
           attributes: dep.attributes,
           inline: dep.inline,
-          excludeFromHtml: dep.excludeFromHtml
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
         };
       }
       const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
@@ -61,12 +79,15 @@ class FileScriptProcessor extends BaseScriptProcessor {
       });
       return {
         filepath: bundledFilePath,
+        sourceFilepath: dep.filepath,
         content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
         kind: "script",
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

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

@@ -1,7 +1,42 @@
-import type { NodeModuleScriptAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
+import type { NodeModuleScriptAsset } from '../../assets.types.js';
+import { BaseScriptProcessor } from '../base/base-script-processor.js';
+/**
+ * Processes browser script assets whose entrypoint is referenced by package specifier.
+ *
+ * @remarks
+ * Resolution stays app-boundary-first: prefer the active build adapter, then fall back
+ * to ESM export-map resolution, and only then probe a small set of literal file paths.
+ */
 export declare class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScriptAsset> {
-    process(dep: NodeModuleScriptAsset): Promise<import("../../assets.types").ProcessedAsset>;
+    process(dep: NodeModuleScriptAsset): Promise<import("../../assets.types.js").ProcessedAsset>;
+    /**
+     * Resolves a node-module script entry from the current app boundary.
+     *
+     * @remarks
+     * The build adapter remains the primary resolution surface because Bun/native
+     * host-owned builds may have a more accurate view of aliases and package
+     * ownership than core does. The local fallback only runs when that adapter
+     * resolution is unavailable.
+     */
     private resolveModulePath;
+    /**
+     * Resolves browser-owned script specifiers without relying on CommonJS resolution.
+     *
+     * @remarks
+     * This path intentionally stays ESM-first because these assets are emitted as
+     * browser scripts. We first ask Node's ESM resolver to evaluate the package
+     * export map from the app boundary. If that still fails, we fall back to a
+     * bounded filesystem probe so direct file installs and package subpaths like
+     * `pkg/client/entry` still resolve when the export map does not cover them.
+     */
     private resolveModulePathFallback;
+    /**
+     * Returns the file candidates we accept during the final literal filesystem probe.
+     *
+     * @remarks
+     * This is intentionally small and browser-entry-oriented: direct files, common
+     * JS extensions, and `index.*` entrypoints. If a package needs anything more
+     * exotic, it should resolve through the adapter or ESM export-map path above.
+     */
+    private getFallbackCandidatePaths;
 }

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

@@ -1,7 +1,8 @@
 import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { fileSystem } from "@ecopages/file-system";
 import { getAppBuildAdapter } from "../../../../../build/build-adapter.js";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class NodeModuleScriptProcessor extends BaseScriptProcessor {
   async process(dep) {
     const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
@@ -20,7 +21,9 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
           position: dep.position,
           attributes: dep.attributes,
           inline: true,
-          excludeFromHtml: dep.excludeFromHtml
+          excludeFromHtml: dep.excludeFromHtml,
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
         };
       }
       const outdir = path.join(this.getAssetsDir(), "vendors");
@@ -38,10 +41,21 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
         position: dep.position,
         attributes: dep.attributes,
         inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }
+  /**
+   * Resolves a node-module script entry from the current app boundary.
+   *
+   * @remarks
+   * The build adapter remains the primary resolution surface because Bun/native
+   * host-owned builds may have a more accurate view of aliases and package
+   * ownership than core does. The local fallback only runs when that adapter
+   * resolution is unavailable.
+   */
   resolveModulePath(importPath, rootDir) {
     if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
       return importPath;
@@ -52,13 +66,30 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
       return this.resolveModulePathFallback(importPath, rootDir);
     }
   }
+  /**
+   * Resolves browser-owned script specifiers without relying on CommonJS resolution.
+   *
+   * @remarks
+   * This path intentionally stays ESM-first because these assets are emitted as
+   * browser scripts. We first ask Node's ESM resolver to evaluate the package
+   * export map from the app boundary. If that still fails, we fall back to a
+   * bounded filesystem probe so direct file installs and package subpaths like
+   * `pkg/client/entry` still resolve when the export map does not cover them.
+   */
   resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
+    try {
+      return fileURLToPath(
+        import.meta.resolve(importPath, pathToFileURL(path.join(rootDir, "package.json")).href)
+      );
+    } catch {
+    }
     let currentDir = rootDir;
     let remainingDepth = maxDepth;
     while (remainingDepth >= 0) {
-      const modulePath = path.join(currentDir, "node_modules", importPath);
-      if (fileSystem.exists(modulePath)) {
-        return modulePath;
+      for (const candidatePath of this.getFallbackCandidatePaths(currentDir, importPath)) {
+        if (fileSystem.exists(candidatePath)) {
+          return candidatePath;
+        }
       }
       const parentDir = path.dirname(currentDir);
       if (parentDir === currentDir) {
@@ -69,6 +100,26 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
     }
     throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
   }
+  /**
+   * Returns the file candidates we accept during the final literal filesystem probe.
+   *
+   * @remarks
+   * This is intentionally small and browser-entry-oriented: direct files, common
+   * JS extensions, and `index.*` entrypoints. If a package needs anything more
+   * exotic, it should resolve through the adapter or ESM export-map path above.
+   */
+  getFallbackCandidatePaths(rootDir, importPath) {
+    const moduleBasePath = path.join(rootDir, "node_modules", importPath);
+    return [
+      moduleBasePath,
+      `${moduleBasePath}.js`,
+      `${moduleBasePath}.mjs`,
+      `${moduleBasePath}.cjs`,
+      path.join(moduleBasePath, "index.js"),
+      path.join(moduleBasePath, "index.mjs"),
+      path.join(moduleBasePath, "index.cjs")
+    ];
+  }
 }
 export {
   NodeModuleScriptProcessor

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

@@ -1,5 +1,8 @@
-import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
+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,21 +1,55 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
+import { BaseProcessor } from "../base/base-processor.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 hash = this.generateHash(dep.content);
+    const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, "styles", "page-bundle.css");
+    const processedContent = await this.applyStylesheetProcessors(dep.content, virtualFilepath);
+    const hash = this.generateHash(processedContent);
     const filename = `style-${hash}.css`;
     const cachekey = this.buildCacheKey(filename, hash, dep);
     return this.getOrProcess(cachekey, () => {
       const filepath = path.join(this.getAssetsDir(), "styles", filename);
-      if (!dep.inline) fileSystem.write(filepath, dep.content);
+      if (!dep.inline) fileSystem.write(filepath, processedContent);
       return {
         filepath: dep.inline ? void 0 : filepath,
-        content: dep.inline ? dep.content : void 0,
+        content: dep.inline ? processedContent : void 0,
         kind: "stylesheet",
         position: dep.position,
         attributes: dep.attributes,
-        inline: dep.inline
+        inline: dep.inline,
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

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

@@ -1,5 +1,5 @@
-import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
+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;

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
+import { BaseProcessor } from "../base/base-processor.js";
 class FileStylesheetProcessor extends BaseProcessor {
   static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
   getStyleContent = (srcUrl) => {
@@ -52,11 +52,14 @@ class FileStylesheetProcessor extends BaseProcessor {
       }
       return {
         filepath,
+        sourceFilepath: dep.filepath,
         content: dep.inline ? processedContent : void 0,
         kind: "stylesheet",
         position: dep.position,
         attributes: dep.attributes,
-        inline: dep.inline
+        inline: dep.inline,
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

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

@@ -0,0 +1,18 @@
+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;
+    resolveProcessedAssetSrcUrl: (processed: ProcessedAsset) => string | undefined;
+    setCachedAsset: (dep: AssetDefinition, depKey: string, processed: ProcessedAsset) => void;
+    logMissingProcessor: (dep: AssetDefinition) => void;
+    logMissingFile: (dep: AssetDefinition & {
+        filepath: string;
+    }) => void;
+    logProcessingError: (dep: AssetDefinition, error: unknown) => void;
+};
+export declare function processUngroupedDependency(options: ProcessUngroupedDependencyOptions): Promise<ProcessedAsset | null>;
+export {};

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

@@ -0,0 +1,45 @@
+import { fileSystem } from "@ecopages/file-system";
+async function processUngroupedDependency(options) {
+  const {
+    dep,
+    key,
+    depKey,
+    getCachedAsset,
+    getProcessor,
+    resolveProcessedAssetSrcUrl,
+    setCachedAsset,
+    logMissingProcessor,
+    logMissingFile,
+    logProcessingError
+  } = options;
+  const cached = getCachedAsset(dep, depKey);
+  if (cached) {
+    return { key, ...cached };
+  }
+  const processor = getProcessor(dep);
+  if (!processor) {
+    logMissingProcessor(dep);
+    return null;
+  }
+  if (dep.source === "file" && "filepath" in dep && !fileSystem.exists(dep.filepath)) {
+    logMissingFile(dep);
+    return null;
+  }
+  try {
+    const processed = await processor.process(dep);
+    const srcUrl = resolveProcessedAssetSrcUrl(processed);
+    const processedWithKey = {
+      key,
+      ...processed,
+      srcUrl
+    };
+    setCachedAsset(dep, depKey, processedWithKey);
+    return processedWithKey;
+  } catch (error) {
+    logProcessingError(dep, error);
+    return null;
+  }
+}
+export {
+  processUngroupedDependency
+};