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

package/src/services/assets/asset-processing-service/grouped-content-bundles.js

@@ -1,65 +1,90 @@
-function partitionGroupedContentScriptDependencies(typeDeps) {
-  const groupedBundleDeps = /* @__PURE__ */ new Map();
-  const ungroupedDeps = [];
-  for (const dep of typeDeps) {
-    if (dep.kind === "script" && dep.source === "content" && dep.groupedBundle?.id) {
-      const existing = groupedBundleDeps.get(dep.groupedBundle.id) ?? [];
-      existing.push(dep);
-      groupedBundleDeps.set(dep.groupedBundle.id, existing);
-      continue;
-    }
-    ungroupedDeps.push(dep);
-  }
-  return {
-    groupedBundleDeps,
-    ungroupedDeps
-  };
+import { isDevelopmentRuntime } from '../../../utils/runtime.js';
+import { finalizeProcessedAsset } from './finalize-processed-asset.js';
+function getGroupedBundleAssetKey(groupedBundle) {
+    return `${groupedBundle.id}:${groupedBundle.entryName}`;
 }
-async function processGroupedDependencyBundles(options) {
-  const {
-    bundles,
-    key,
-    getCachedAsset,
-    getDependencyKey,
-    getGroupedProcessor,
-    resolveProcessedAssetSrcUrl,
-    setCachedAsset,
-    logError
-  } = options;
-  const groupedPromises = bundles.map(async (bundleDeps) => {
-    const cachedResults = bundleDeps.map((dep) => {
-      const cached = getCachedAsset(dep, getDependencyKey(dep));
-      return cached ? { key, ...cached } : null;
-    });
-    if (cachedResults.every((result) => result !== null)) {
-      return cachedResults.filter((result) => result !== null);
+/** Forces grouped content scripts to run through the bundler in production builds. */
+export function ensureGroupedContentScriptsBundle(dependencies) {
+    if (isDevelopmentRuntime()) {
+        return;
     }
-    const processor = getGroupedProcessor();
-    if (!processor?.processGrouped) {
-      return [];
+    for (const dependency of dependencies) {
+        if (dependency.kind !== 'script' || dependency.source !== 'content' || !dependency.groupedBundle?.id) {
+            continue;
+        }
+        if (dependency.bundle === false) {
+            dependency.bundle = true;
+        }
     }
-    try {
-      const processedResults = await processor.processGrouped(bundleDeps);
-      return processedResults.map((processed, index) => {
-        const dep = bundleDeps[index];
-        const depKey = getDependencyKey(dep);
-        const srcUrl = resolveProcessedAssetSrcUrl(processed);
-        const processedWithKey = {
-          key,
-          ...processed,
-          srcUrl
-        };
-        setCachedAsset(dep, depKey, processedWithKey);
-        return processedWithKey;
-      });
-    } catch (error) {
-      logError(error);
-      return [];
+}
+/**
+ * Splits grouped content-script dependencies from ordinary dependencies so callers can
+ * route them through `processGrouped` without changing ordering for the remaining assets.
+ */
+export function partitionGroupedContentScriptDependencies(typeDeps) {
+    const groupedBundleDeps = new Map();
+    const ungroupedDeps = [];
+    for (const dep of typeDeps) {
+        if (dep.kind === 'script' && dep.source === 'content' && dep.groupedBundle?.id) {
+            const existing = groupedBundleDeps.get(dep.groupedBundle.id) ?? [];
+            existing.push(dep);
+            groupedBundleDeps.set(dep.groupedBundle.id, existing);
+            continue;
+        }
+        ungroupedDeps.push(dep);
     }
-  });
-  return (await Promise.all(groupedPromises)).flat();
+    return {
+        groupedBundleDeps,
+        ungroupedDeps,
+    };
+}
+/**
+ * Processes grouped content-script bundles while preserving per-entry cache keys.
+ *
+ * When every dependency in a bundle already has a cached processed asset, the cached
+ * entries are returned directly and the grouped processor is skipped.
+ */
+export async function processGroupedDependencyBundles(options) {
+    const { bundles, getCachedAsset, getDependencyKey, getGroupedProcessor, resolveProcessedAssetSrcUrl, setCachedAsset, logError, } = options;
+    const groupedPromises = bundles.map(async (bundleDeps) => {
+        const cachedResults = bundleDeps.map((dep) => {
+            const cached = getCachedAsset(dep, getDependencyKey(dep));
+            return cached ? finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl) : null;
+        });
+        if (cachedResults.every((result) => result !== null)) {
+            return cachedResults.filter((result) => result !== null);
+        }
+        const processor = getGroupedProcessor();
+        if (!processor?.processGrouped) {
+            return [];
+        }
+        try {
+            const processedResults = await processor.processGrouped(bundleDeps);
+            const processedByEntryKey = new Map();
+            for (const processed of processedResults) {
+                if (!processed.groupedBundle) {
+                    continue;
+                }
+                processedByEntryKey.set(getGroupedBundleAssetKey(processed.groupedBundle), processed);
+            }
+            return bundleDeps.flatMap((dep) => {
+                if (dep.kind !== 'script' || dep.source !== 'content' || !dep.groupedBundle) {
+                    return [];
+                }
+                const processed = processedByEntryKey.get(getGroupedBundleAssetKey(dep.groupedBundle));
+                if (!processed) {
+                    return [];
+                }
+                const depKey = getDependencyKey(dep);
+                const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+                setCachedAsset(dep, depKey, finalized);
+                return [finalized];
+            });
+        }
+        catch (error) {
+            logError(error);
+            return [];
+        }
+    });
+    return (await Promise.all(groupedPromises)).flat();
 }
-export {
-  partitionGroupedContentScriptDependencies,
-  processGroupedDependencyBundles
-};

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

@@ -1,6 +1,8 @@
 export * from './asset.factory.js';
+export * from './grouped-content-bundles.js';
 export * from './page-package.js';
 export * from './asset-processing.service.js';
 export * from './assets.types.js';
 export * from './browser-runtime-asset.factory.js';
 export * from './browser-runtime-entry.factory.js';
+export * from './browser-runtime-entry-resolution.js';

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

@@ -1,6 +1,8 @@
-export * from "./asset.factory.js";
-export * from "./page-package.js";
-export * from "./asset-processing.service.js";
-export * from "./assets.types.js";
-export * from "./browser-runtime-asset.factory.js";
-export * from "./browser-runtime-entry.factory.js";
+export * from './asset.factory.js';
+export * from './grouped-content-bundles.js';
+export * from './page-package.js';
+export * from './asset-processing.service.js';
+export * from './assets.types.js';
+export * from './browser-runtime-asset.factory.js';
+export * from './browser-runtime-entry.factory.js';
+export * from './browser-runtime-entry-resolution.js';

package/src/services/assets/asset-processing-service/inline-content-script-body.d.ts

@@ -0,0 +1,11 @@
+import type { ContentScriptAsset } from './assets.types.js';
+/**
+ * Resolves the script body to embed when a content script is marked inline.
+ *
+ * @remarks
+ * `inline` means embed in HTML, not "use declaration source." When bundling has
+ * already run, only the output file is valid browser script; `dep.content` may
+ * still contain build-time import paths. Processor emission and cache
+ * materialization must share this rule so they cannot drift.
+ */
+export declare function resolveInlineContentScriptBody(dep: Pick<ContentScriptAsset, 'inline' | 'bundle' | 'content'>, filepath: string): string | undefined;

package/src/services/assets/asset-processing-service/inline-content-script-body.js

@@ -0,0 +1,23 @@
+import { fileSystem } from '@ecopages/file-system';
+import { appLogger } from '../../../global/app-logger.js';
+/**
+ * Resolves the script body to embed when a content script is marked inline.
+ *
+ * @remarks
+ * `inline` means embed in HTML, not "use declaration source." When bundling has
+ * already run, only the output file is valid browser script; `dep.content` may
+ * still contain build-time import paths. Processor emission and cache
+ * materialization must share this rule so they cannot drift.
+ */
+export function resolveInlineContentScriptBody(dep, filepath) {
+    if (!dep.inline) {
+        return undefined;
+    }
+    if (dep.bundle !== false && fileSystem.exists(filepath)) {
+        return fileSystem.readFileSync(filepath);
+    }
+    if (dep.bundle !== false) {
+        appLogger.warn(`Missing bundled inline script output at ${filepath}; falling back to declaration source.`);
+    }
+    return dep.content;
+}

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

@@ -0,0 +1,9 @@
+import type { ContentScriptAsset, ProcessedAsset } from './assets.types.js';
+/**
+ * @remarks
+ * {@link AssetProcessingService} cache and dev disk cache entries usually keep
+ * only an output path. Dependency declarations still carry the metadata HTML and
+ * page-browser graph assembly need (`groupedBundle`, attributes, roles), so cache
+ * hits must be rehydrated from both sources rather than returned verbatim.
+ */
+export declare function materializeContentScriptAsset(dep: ContentScriptAsset, filepath: string): ProcessedAsset;

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

@@ -0,0 +1,22 @@
+import { resolveInlineContentScriptBody } from './inline-content-script-body.js';
+/**
+ * @remarks
+ * {@link AssetProcessingService} cache and dev disk cache entries usually keep
+ * only an output path. Dependency declarations still carry the metadata HTML and
+ * page-browser graph assembly need (`groupedBundle`, attributes, roles), so cache
+ * hits must be rehydrated from both sources rather than returned verbatim.
+ */
+export function materializeContentScriptAsset(dep, filepath) {
+    return {
+        filepath,
+        kind: 'script',
+        inline: dep.inline ?? false,
+        content: resolveInlineContentScriptBody(dep, filepath),
+        position: dep.position,
+        attributes: dep.attributes,
+        excludeFromHtml: dep.excludeFromHtml,
+        packageRole: dep.packageRole,
+        groupedBundle: dep.groupedBundle,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths,
+    };
+}

package/src/services/assets/asset-processing-service/page-package.js

@@ -1,80 +1,78 @@
 function getSuppressedSourceFilepaths(assets) {
-  const suppressed = /* @__PURE__ */ new Set();
-  for (const asset of assets) {
-    if ((asset.packageRole === "page-style" || asset.packageRole === "page-script") && Array.isArray(asset.bundledSourceFilepaths)) {
-      for (const filepath of asset.bundledSourceFilepaths) {
-        suppressed.add(filepath);
-      }
+    const suppressed = new Set();
+    for (const asset of assets) {
+        if ((asset.packageRole === 'page-style' || asset.packageRole === 'page-script') &&
+            Array.isArray(asset.bundledSourceFilepaths)) {
+            for (const filepath of asset.bundledSourceFilepaths) {
+                suppressed.add(filepath);
+            }
+        }
     }
-  }
-  return suppressed;
+    return suppressed;
 }
-function createPagePackage(assets, options = {}) {
-  const allAssets = [
-    ...assets,
-    ...options.pageBrowserGraph?.entryAssets ?? [],
-    ...options.pageBrowserGraph?.chunkAssets ?? []
-  ];
-  const inlineAssets = [];
-  const separateAssets = [];
-  const dynamicChunks = [];
-  let pageScript;
-  let pageStylesheet;
-  const suppressedSourceFilepaths = getSuppressedSourceFilepaths(allAssets);
-  for (const asset of allAssets) {
-    if (asset.inline) {
-      inlineAssets.push(asset);
-      continue;
+export function createPagePackage(assets, options = {}) {
+    const allAssets = [
+        ...assets,
+        ...(options.pageBrowserGraph?.entryAssets ?? []),
+        ...(options.pageBrowserGraph?.chunkAssets ?? []),
+    ];
+    const inlineAssets = [];
+    const separateAssets = [];
+    const dynamicChunks = [];
+    let pageScript;
+    let pageStylesheet;
+    const suppressedSourceFilepaths = getSuppressedSourceFilepaths(allAssets);
+    for (const asset of allAssets) {
+        if (asset.inline) {
+            inlineAssets.push(asset);
+            continue;
+        }
+        if (asset.packageRole === 'dynamic-chunk') {
+            dynamicChunks.push(asset);
+            continue;
+        }
+        if (!pageScript && asset.packageRole === 'page-script') {
+            pageScript = asset;
+            continue;
+        }
+        if (!pageStylesheet && asset.packageRole === 'page-style') {
+            pageStylesheet = asset;
+            continue;
+        }
+        if (asset.packageRole === 'keep-separate' || asset.packageRole === 'runtime') {
+            separateAssets.push(asset);
+            continue;
+        }
+        if (!pageScript && asset.kind === 'script' && !asset.excludeFromHtml) {
+            pageScript = asset;
+            continue;
+        }
+        if (!pageStylesheet && asset.kind === 'stylesheet') {
+            pageStylesheet = asset;
+            continue;
+        }
+        separateAssets.push(asset);
     }
-    if (asset.packageRole === "dynamic-chunk") {
-      dynamicChunks.push(asset);
-      continue;
-    }
-    if (!pageScript && asset.packageRole === "page-script") {
-      pageScript = asset;
-      continue;
-    }
-    if (!pageStylesheet && asset.packageRole === "page-style") {
-      pageStylesheet = asset;
-      continue;
-    }
-    if (asset.packageRole === "keep-separate" || asset.packageRole === "runtime") {
-      separateAssets.push(asset);
-      continue;
+    return {
+        assets: allAssets,
+        pageBrowserGraph: options.pageBrowserGraph,
+        htmlAssets: allAssets.filter((asset) => shouldIncludeInHtml(asset, suppressedSourceFilepaths)),
+        pageScript,
+        pageStylesheet,
+        inlineAssets,
+        separateAssets,
+        dynamicChunks,
+    };
+}
+function shouldIncludeInHtml(asset, suppressedSourceFilepaths) {
+    if (asset.excludeFromHtml) {
+        return false;
     }
-    if (!pageScript && asset.kind === "script" && !asset.excludeFromHtml) {
-      pageScript = asset;
-      continue;
+    if (asset.packageRole === 'runtime') {
+        return false;
     }
-    if (!pageStylesheet && asset.kind === "stylesheet") {
-      pageStylesheet = asset;
-      continue;
+    if (asset.sourceFilepath && suppressedSourceFilepaths.has(asset.sourceFilepath)) {
+        return false;
     }
-    separateAssets.push(asset);
-  }
-  return {
-    assets: allAssets,
-    pageBrowserGraph: options.pageBrowserGraph,
-    htmlAssets: allAssets.filter((asset) => shouldIncludeInHtml(asset, suppressedSourceFilepaths)),
-    pageScript,
-    pageStylesheet,
-    inlineAssets,
-    separateAssets,
-    dynamicChunks
-  };
-}
-function shouldIncludeInHtml(asset, suppressedSourceFilepaths) {
-  if (asset.excludeFromHtml) {
-    return false;
-  }
-  if (asset.packageRole === "runtime") {
-    return false;
-  }
-  if (asset.sourceFilepath && suppressedSourceFilepaths.has(asset.sourceFilepath)) {
-    return false;
-  }
-  return true;
+    return true;
 }
-export {
-  createPagePackage
-};

package/src/services/assets/asset-processing-service/processor.interface.js

@@ -1,6 +1,8 @@
-function isHmrAware(processor) {
-  return "setHmrManager" in processor && typeof processor.setHmrManager === "function";
+/**
+ * Type guard to check if a processor supports HMR.
+ * @param processor - The processor to check
+ * @returns True if the processor implements HmrAwareProcessor
+ */
+export function isHmrAware(processor) {
+    return 'setHmrManager' in processor && typeof processor.setHmrManager === 'function';
 }
-export {
-  isHmrAware
-};

package/src/services/assets/asset-processing-service/processor.registry.js

@@ -1,15 +1,12 @@
-class ProcessorRegistry {
-  processors = /* @__PURE__ */ new Map();
-  register(kind, variant, processor) {
-    this.processors.set(`${kind}-${variant}`, processor);
-  }
-  getProcessor(kind, variant) {
-    return this.processors.get(`${kind}-${variant}`);
-  }
-  getAllProcessors() {
-    return this.processors;
-  }
+export class ProcessorRegistry {
+    processors = new Map();
+    register(kind, variant, processor) {
+        this.processors.set(`${kind}-${variant}`, processor);
+    }
+    getProcessor(kind, variant) {
+        return this.processors.get(`${kind}-${variant}`);
+    }
+    getAllProcessors() {
+        return this.processors;
+    }
 }
-export {
-  ProcessorRegistry
-};

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

@@ -1,65 +1,62 @@
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
-import { rapidhash } from "../../../../../utils/hash.js";
-import { isDevelopmentRuntime, isProductionRuntime } from "../../../../../utils/runtime.js";
-import { fileSystem } from "@ecopages/file-system";
-class BaseProcessor {
-  appConfig;
-  /**
-   * Cache for processed assets to avoid reprocessing the same asset multiple times.
-   * The cache key is a combination of the asset name and its hash.
-   * The cache value is the processed asset.
-   */
-  cache = /* @__PURE__ */ new Map();
-  constructor({ appConfig }) {
-    this.appConfig = appConfig;
-  }
-  get isDevelopment() {
-    return isDevelopmentRuntime();
-  }
-  get isProduction() {
-    return isProductionRuntime();
-  }
-  getAssetsDir() {
-    return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
-  }
-  writeCacheFile(key, path2) {
-    this.cache.set(key, path2);
-  }
-  getCacheFile(key) {
-    return this.cache.get(key);
-  }
-  hasCacheFile(key) {
-    return this.cache.has(key);
-  }
-  generateHash(content) {
-    return rapidhash(content).toString();
-  }
-  buildCacheKey(identifier, contentHash, dep) {
-    const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : "";
-    const position = dep.position ?? "";
-    const packageRole = dep.packageRole ?? "";
-    return `${identifier}:${contentHash}:${position}:${attrsHash}:${packageRole}`;
-  }
-  getOrProcess(cacheKey, processFn) {
-    if (this.hasCacheFile(cacheKey)) {
-      const cached = this.getCacheFile(cacheKey);
-      if (!cached.filepath || fileSystem.exists(cached.filepath)) {
-        return Promise.resolve(cached);
-      }
-      this.cache.delete(cacheKey);
+import path from 'node:path';
+import { RESOLVED_ASSETS_DIR } from '../../../../../config/constants.js';
+import { rapidhash } from '../../../../../utils/hash.js';
+import { isDevelopmentRuntime, isProductionRuntime } from '../../../../../utils/runtime.js';
+import { fileSystem } from '@ecopages/file-system';
+export class BaseProcessor {
+    appConfig;
+    /**
+     * Cache for processed assets to avoid reprocessing the same asset multiple times.
+     * The cache key is a combination of the asset name and its hash.
+     * The cache value is the processed asset.
+     */
+    cache = new Map();
+    constructor({ appConfig }) {
+        this.appConfig = appConfig;
     }
-    const result = processFn();
-    if (result instanceof Promise) {
-      return result.then((asset) => {
-        this.writeCacheFile(cacheKey, asset);
-        return asset;
-      });
+    get isDevelopment() {
+        return isDevelopmentRuntime();
+    }
+    get isProduction() {
+        return isProductionRuntime();
+    }
+    getAssetsDir() {
+        return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
+    }
+    writeCacheFile(key, path) {
+        this.cache.set(key, path);
+    }
+    getCacheFile(key) {
+        return this.cache.get(key);
+    }
+    hasCacheFile(key) {
+        return this.cache.has(key);
+    }
+    generateHash(content) {
+        return rapidhash(content).toString();
+    }
+    buildCacheKey(identifier, contentHash, dep) {
+        const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : '';
+        const position = dep.position ?? '';
+        const packageRole = dep.packageRole ?? '';
+        return `${identifier}:${contentHash}:${position}:${attrsHash}:${packageRole}`;
+    }
+    getOrProcess(cacheKey, processFn) {
+        if (this.hasCacheFile(cacheKey)) {
+            const cached = this.getCacheFile(cacheKey);
+            if (!cached.filepath || fileSystem.exists(cached.filepath)) {
+                return Promise.resolve(cached);
+            }
+            this.cache.delete(cacheKey);
+        }
+        const result = processFn();
+        if (result instanceof Promise) {
+            return result.then((asset) => {
+                this.writeCacheFile(cacheKey, asset);
+                return asset;
+            });
+        }
+        this.writeCacheFile(cacheKey, result);
+        return Promise.resolve(result);
     }
-    this.writeCacheFile(cacheKey, result);
-    return Promise.resolve(result);
-  }
 }
-export {
-  BaseProcessor
-};

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

@@ -1,5 +1,4 @@
 import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
-import type { EcoBuildPlugin } from '../../../../../build/build-types.js';
 import type { ScriptAsset } from '../../assets.types.js';
 import { BaseProcessor } from './base-processor.js';
 import { type BrowserBundleGroupedEntry } from '../../../browser-bundle.service.js';
@@ -10,7 +9,6 @@ export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends
     });
     protected shouldBundle(dep: T): boolean;
     protected getBundlerOptions(dep: T): Record<string, any>;
-    protected collectBuildPlugins(excludePluginNames?: string[]): EcoBuildPlugin[];
     protected bundleScript({ entrypoint, outdir, excludeAppBuildPlugins, plugins: additionalPlugins, ...rest }: {
         entrypoint: string;
         outdir: string;