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

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

@@ -1,136 +1,108 @@
-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";
-import { BrowserBundleService } from "../../../browser-bundle.service.js";
-class BaseScriptProcessor extends BaseProcessor {
-  browserBundleService;
-  constructor({ appConfig }) {
-    super({ appConfig });
-    this.browserBundleService = new BrowserBundleService(appConfig);
-  }
-  shouldBundle(dep) {
-    return dep.bundle !== false;
-  }
-  getBundlerOptions(dep) {
-    if (dep.packageRole === "page-script" && dep.bundleOptions?.splitting === void 0) {
-      return {
-        ...dep.bundleOptions,
-        splitting: false
-      };
+import { appLogger } from '../../../../../global/app-logger.js';
+import { fileSystem } from '@ecopages/file-system';
+import path from 'node:path';
+import { BaseProcessor } from './base-processor.js';
+import { BrowserBundleService } from '../../../browser-bundle.service.js';
+export class BaseScriptProcessor extends BaseProcessor {
+    browserBundleService;
+    constructor({ appConfig }) {
+        super({ appConfig });
+        this.browserBundleService = new BrowserBundleService(appConfig);
     }
-    return dep.bundleOptions || {};
-  }
-  collectBuildPlugins(excludePluginNames) {
-    const buildPlugins = getAppBrowserBuildPlugins(this.appConfig);
-    if (!excludePluginNames || excludePluginNames.length === 0) {
-      return buildPlugins;
+    shouldBundle(dep) {
+        return dep.bundle !== false;
     }
-    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(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,
-      ...rest
-    });
-    if (!buildResult.success) {
-      for (const log of buildResult.logs) {
-        appLogger.debug(log.message, log);
-      }
+    getBundlerOptions(dep) {
+        if (dep.packageRole === 'page-script' && dep.bundleOptions?.splitting === undefined) {
+            return {
+                ...dep.bundleOptions,
+                splitting: false,
+            };
+        }
+        return dep.bundleOptions || {};
     }
-    const entryBaseName = path.parse(entrypoint).name;
-    const entryOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
-    if (entryOutput) {
-      return entryOutput;
+    async bundleScript({ entrypoint, outdir, excludeAppBuildPlugins, plugins: additionalPlugins, ...rest }) {
+        const buildResult = await this.browserBundleService.bundle({
+            profile: 'browser-script',
+            entrypoints: [entrypoint],
+            outdir,
+            root: this.appConfig.rootDir,
+            excludeAppBuildPlugins,
+            splitting: true,
+            naming: '[name]-[hash].[ext]',
+            plugins: additionalPlugins,
+            ...rest,
+        });
+        if (!buildResult.success) {
+            for (const log of buildResult.logs) {
+                appLogger.debug(log.message, log);
+            }
+        }
+        const entryBaseName = path.parse(entrypoint).name;
+        const entryOutput = buildResult.outputs
+            .map((output) => output.path)
+            .find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
+        if (entryOutput) {
+            return entryOutput;
+        }
+        const nonVendorOutput = buildResult.outputs
+            .map((output) => output.path)
+            .find((outputPath) => !path.basename(outputPath).startsWith('vendors'));
+        if (nonVendorOutput) {
+            return nonVendorOutput;
+        }
+        const primaryOutput = buildResult.outputs[0]?.path;
+        if (primaryOutput) {
+            return primaryOutput;
+        }
+        const namedFallbackOutput = path.join(outdir, `${entryBaseName}.js`);
+        if (fileSystem.exists(namedFallbackOutput)) {
+            return namedFallbackOutput;
+        }
+        const fallbackOutput = path.join(outdir, 'entry_0.js');
+        if (fileSystem.exists(fallbackOutput)) {
+            return fallbackOutput;
+        }
+        const logMessage = buildResult.logs.map((log) => log.message).join(' | ');
+        throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ''}`);
     }
-    const nonVendorOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
-    if (nonVendorOutput) {
-      return nonVendorOutput;
+    async bundleScripts({ entries, outdir, excludeAppBuildPlugins, plugins: additionalPlugins, ...rest }) {
+        const buildResult = await this.browserBundleService.bundleGroupedEntries(entries, {
+            profile: 'browser-script',
+            outdir,
+            root: this.appConfig.rootDir,
+            excludeAppBuildPlugins,
+            ...rest,
+            splitting: true,
+            naming: '[name]-[hash].[ext]',
+            plugins: additionalPlugins,
+        });
+        if (!buildResult.success) {
+            for (const log of buildResult.logs) {
+                appLogger.debug(log.message, log);
+            }
+        }
+        const outputs = buildResult.outputs.map((output) => output.path);
+        const entryOutputs = 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;
     }
-    const primaryOutput = buildResult.outputs[0]?.path;
-    if (primaryOutput) {
-      return primaryOutput;
-    }
-    const namedFallbackOutput = path.join(outdir, `${entryBaseName}.js`);
-    if (fileSystem.exists(namedFallbackOutput)) {
-      return namedFallbackOutput;
-    }
-    const fallbackOutput = path.join(outdir, "entry_0.js");
-    if (fileSystem.exists(fallbackOutput)) {
-      return fallbackOutput;
-    }
-    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.js

@@ -1,5 +1,5 @@
-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";
+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,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,120 +1,120 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor.js";
-class ContentScriptProcessor extends BaseScriptProcessor {
-  async processGrouped(deps) {
-    if (deps.length === 0) {
-      return [];
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { resolveInlineContentScriptBody } from '../../inline-content-script-body.js';
+import { BaseScriptProcessor } from '../base/base-script-processor.js';
+export class ContentScriptProcessor extends BaseScriptProcessor {
+    getContentScriptEntryDir() {
+        const dir = path.join(this.appConfig.absolutePaths.workDir, 'content-script-entries');
+        fileSystem.ensureDir(dir);
+        return dir;
     }
-    const shouldBundle = deps.every((dep) => this.shouldBundle(dep));
-    if (!shouldBundle || deps.some((dep) => dep.inline)) {
-      return Promise.all(deps.map((dep) => this.process(dep)));
+    getContentScriptEntryPath(contentHash) {
+        return path.join(this.getContentScriptEntryDir(), `${contentHash}.js`);
     }
-    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);
+    toProcessedAsset(dep, filepath) {
         return {
-          dep,
-          entryName,
-          tempFilepath
+            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,
         };
-      });
-      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}`);
+    }
+    removeContentScriptEntry(contentHash) {
+        fileSystem.remove(this.getContentScriptEntryPath(contentHash));
+    }
+    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)));
+        }
+        let tempEntries = [];
+        try {
+            tempEntries = deps.map((dep) => {
+                const contentHash = this.generateHash(dep.content);
+                const tempFilepath = this.getContentScriptEntryPath(contentHash);
+                fileSystem.write(tempFilepath, dep.content);
+                return {
+                    dep,
+                    contentHash,
+                    tempFilepath,
+                };
+            });
+            const outputPaths = await this.bundleScripts({
+                ...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, 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 this.toProcessedAsset(dep, bundledFilePath);
+            });
+        }
+        finally {
+            for (const { contentHash } of tempEntries) {
+                this.removeContentScriptEntry(contentHash);
+            }
         }
-        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`;
-    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;
+    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;
     }
-    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);
-      const bundledFilePath = await this.bundleScript({
-        entrypoint: tempFileName,
-        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;
+    /**
+     * 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 filepath = path.join(this.getAssetsDir(), 'scripts', filename);
+        if (!shouldBundle) {
+            if (!dep.inline) {
+                fileSystem.write(filepath, dep.content);
+            }
+            return this.toProcessedAsset(dep, filepath);
+        }
+        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: entryPath,
+                outdir: this.getAssetsDir(),
+                minify: this.isProduction,
+                naming: `${path.parse(filename).name}-[hash].[ext]`,
+                ...this.getBundlerOptions(dep),
+            });
+            return this.toProcessedAsset(dep, bundledFilePath);
+        }
+        finally {
+            this.removeContentScriptEntry(hash);
+        }
     }
-    throw new Error("No content found for script asset");
-  }
 }
-export {
-  ContentScriptProcessor
-};

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>;
 }