@ecopages/core 0.2.0-alpha.1

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

@@ -0,0 +1,250 @@
+import path from "node:path";
+import { RESOLVED_ASSETS_DIR } from "../../constants";
+import { appLogger } from "../../global/app-logger";
+import { rapidhash } from "../../utils/hash";
+import { fileSystem } from "@ecopages/file-system";
+import { isHmrAware } from "./processor.interface";
+import { ProcessorRegistry } from "./processor.registry";
+import {
+  ContentScriptProcessor,
+  ContentStylesheetProcessor,
+  FileScriptProcessor,
+  FileStylesheetProcessor,
+  NodeModuleScriptProcessor
+} from "./processors";
+class AssetProcessingService {
+  constructor(config) {
+    this.config = config;
+  }
+  static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
+  registry = new ProcessorRegistry();
+  hmrManager;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Set the HMR manager for the asset processing service.
+   * @param hmrManager The HMR manager to set.
+   */
+  setHmrManager(hmrManager) {
+    this.hmrManager = hmrManager;
+    for (const processor of this.registry.getAllProcessors().values()) {
+      if (isHmrAware(processor)) {
+        processor.setHmrManager(hmrManager);
+      }
+    }
+  }
+  getHmrManager() {
+    return this.hmrManager;
+  }
+  /**
+   * Register a processor for a specific asset kind and source.
+   * @param kind The asset kind.
+   * @param variant The asset source.
+   * @param processor The processor to register.
+   */
+  registerProcessor(kind, variant, processor) {
+    if (this.hmrManager && isHmrAware(processor)) {
+      processor.setHmrManager(this.hmrManager);
+    }
+    this.registry.register(kind, variant, processor);
+  }
+  async processDependencies(deps, key) {
+    const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
+    fileSystem.ensureDir(depsDir);
+    const dedupedDeps = this.deduplicateDependencies(deps);
+    const results = await this.processDependenciesParallel(dedupedDeps, key);
+    await this.optimizeDependencies(results);
+    return results;
+  }
+  deduplicateDependencies(deps) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const dep of deps) {
+      const key = this.getDependencyKey(dep);
+      if (!seen.has(key)) {
+        seen.set(key, dep);
+      }
+    }
+    return Array.from(seen.values());
+  }
+  getScriptDependencyBuildSignature(dep) {
+    if (dep.kind !== "script") {
+      return void 0;
+    }
+    const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
+    const signature = {
+      bundle: dep.bundle,
+      inline: dep.inline,
+      excludeFromHtml: dep.excludeFromHtml,
+      naming: dep.bundleOptions?.naming,
+      external: dep.bundleOptions?.external,
+      minify: dep.bundleOptions?.minify,
+      plugins: pluginNames
+    };
+    return this.generateHash(JSON.stringify(signature));
+  }
+  getDependencyKey(dep) {
+    const parts = [dep.kind, dep.source];
+    if ("filepath" in dep) {
+      parts.push(dep.filepath);
+    } else if ("content" in dep) {
+      parts.push(`content:${this.generateHash(dep.content)}`);
+    } else if ("importPath" in dep) {
+      parts.push(dep.importPath);
+    }
+    if ("position" in dep && dep.position) {
+      parts.push(dep.position);
+    }
+    const scriptBuildSignature = this.getScriptDependencyBuildSignature(dep);
+    if (scriptBuildSignature) {
+      parts.push(`build:${scriptBuildSignature}`);
+    }
+    return parts.join(":");
+  }
+  generateHash(content) {
+    return rapidhash(content).toString();
+  }
+  async processDependenciesParallel(deps, key) {
+    const grouped = this.groupDependenciesByType(deps);
+    const groupPromises = Object.entries(grouped).map(async ([, typeDeps]) => {
+      const typePromises = typeDeps.map(async (dep) => {
+        const depKey = this.getDependencyKey(dep);
+        const cached = this.getCachedAsset(dep, depKey);
+        if (cached) {
+          return { key, ...cached };
+        }
+        const processor = this.registry.getProcessor(dep.kind, dep.source);
+        if (!processor) {
+          appLogger.error(`No processor found for ${dep.kind}/${dep.source}`);
+          return null;
+        }
+        if (dep.source === "file" && "filepath" in dep) {
+          const fileExists = fileSystem.exists(dep.filepath);
+          if (!fileExists) {
+            appLogger.warn(`Skipping missing ${dep.kind} file: ${dep.filepath}`);
+            return null;
+          }
+        }
+        try {
+          const processed = await processor.process(dep);
+          const srcUrl = this.resolveProcessedAssetSrcUrl(processed);
+          const processedWithKey = {
+            key,
+            ...processed,
+            srcUrl
+          };
+          this.setCachedAsset(dep, depKey, processedWithKey);
+          return processedWithKey;
+        } catch (error) {
+          appLogger.error(
+            `Failed to process dependency: ${error instanceof Error ? error.message : String(error)} for ${dep.kind}/${dep.source}`
+          );
+          appLogger.debug(error);
+          return null;
+        }
+      });
+      const typeResults = await Promise.all(typePromises);
+      return typeResults.filter((result) => result !== null);
+    });
+    const allTypeResults = await Promise.all(groupPromises);
+    return allTypeResults.flat();
+  }
+  groupDependenciesByType(deps) {
+    return deps.reduce(
+      (acc, dep) => {
+        const key = `${dep.kind}_${dep.source}`;
+        if (!acc[key]) acc[key] = [];
+        acc[key].push(dep);
+        return acc;
+      },
+      {}
+    );
+  }
+  getSrcUrl(filepath) {
+    const distDir = this.config.absolutePaths.distDir;
+    if (!filepath.startsWith(distDir)) return void 0;
+    const relativePath = filepath.slice(distDir.length);
+    const urlPath = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
+    return urlPath.replace(/\\/g, "/");
+  }
+  resolveProcessedAssetSrcUrl(processed) {
+    if (processed.srcUrl) {
+      if (this.isFilesystemPath(processed.srcUrl)) {
+        const srcUrlFromPath = this.getSrcUrl(processed.srcUrl);
+        if (srcUrlFromPath) return srcUrlFromPath;
+      } else {
+        return processed.srcUrl;
+      }
+    }
+    if (processed.filepath) {
+      return this.getSrcUrl(processed.filepath);
+    }
+    return void 0;
+  }
+  isFilesystemPath(value) {
+    if (value.startsWith("http://") || value.startsWith("https://") || value.startsWith("//")) {
+      return false;
+    }
+    if (value.startsWith(this.config.absolutePaths.distDir)) {
+      return true;
+    }
+    const rootDir = this.config.rootDir;
+    if (rootDir && value.startsWith(rootDir)) {
+      return true;
+    }
+    return /^[A-Za-z]:\\/.test(value);
+  }
+  async optimizeDependencies(processedAssets) {
+    if (process.env.NODE_ENV !== "production") {
+      return;
+    }
+    const filesToGzip = /* @__PURE__ */ new Set();
+    for (const asset of processedAssets) {
+      if (!asset.filepath) {
+        continue;
+      }
+      if (!asset.filepath.startsWith(this.config.absolutePaths.distDir)) {
+        continue;
+      }
+      const extension = path.extname(asset.filepath).slice(1);
+      if (extension === "css" || extension === "js") {
+        filesToGzip.add(asset.filepath);
+      }
+    }
+    for (const filePath of filesToGzip) {
+      if (fileSystem.exists(filePath)) {
+        fileSystem.gzipFile(filePath);
+      }
+    }
+  }
+  getCachedAsset(dep, depKey) {
+    const cached = this.cache.get(depKey);
+    return cached?.asset ?? null;
+  }
+  setCachedAsset(dep, depKey, asset) {
+    this.cache.set(depKey, { asset });
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  invalidateCacheForFile(filepath) {
+    for (const [key, value] of this.cache.entries()) {
+      if (value.asset.filepath === filepath) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  static createWithDefaultProcessors(appConfig) {
+    const service = new AssetProcessingService(appConfig);
+    service.registerProcessor("script", "content", new ContentScriptProcessor({ appConfig }));
+    service.registerProcessor("script", "file", new FileScriptProcessor({ appConfig }));
+    service.registerProcessor("script", "node-module", new NodeModuleScriptProcessor({ appConfig }));
+    service.registerProcessor("stylesheet", "content", new ContentStylesheetProcessor({ appConfig }));
+    service.registerProcessor("stylesheet", "file", new FileStylesheetProcessor({ appConfig }));
+    return service;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+}
+export {
+  AssetProcessingService
+};

package/src/services/asset-processing-service/asset-processing.service.ts

@@ -0,0 +1,306 @@
+import path from 'node:path';
+import { RESOLVED_ASSETS_DIR } from '../../constants';
+import { appLogger } from '../../global/app-logger';
+import type { EcoPagesAppConfig, IHmrManager } from '../../internal-types';
+import { rapidhash } from '../../utils/hash';
+import { fileSystem } from '@ecopages/file-system';
+import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types';
+import { isHmrAware } from './processor.interface';
+import { ProcessorRegistry } from './processor.registry';
+import {
+	ContentScriptProcessor,
+	ContentStylesheetProcessor,
+	FileScriptProcessor,
+	FileStylesheetProcessor,
+	NodeModuleScriptProcessor,
+} from './processors';
+
+export class AssetProcessingService {
+	static readonly RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
+	private registry = new ProcessorRegistry();
+	private hmrManager?: IHmrManager;
+	private cache = new Map<string, { asset: ProcessedAsset }>();
+
+	constructor(private readonly config: EcoPagesAppConfig) {}
+
+	/**
+	 * Set the HMR manager for the asset processing service.
+	 * @param hmrManager The HMR manager to set.
+	 */
+	setHmrManager(hmrManager: IHmrManager) {
+		this.hmrManager = hmrManager;
+
+		for (const processor of this.registry.getAllProcessors().values()) {
+			if (isHmrAware(processor)) {
+				processor.setHmrManager(hmrManager);
+			}
+		}
+	}
+
+	getHmrManager(): IHmrManager | undefined {
+		return this.hmrManager;
+	}
+
+	/**
+	 * Register a processor for a specific asset kind and source.
+	 * @param kind The asset kind.
+	 * @param variant The asset source.
+	 * @param processor The processor to register.
+	 */
+	registerProcessor(kind: AssetKind, variant: AssetSource, processor: any): void {
+		if (this.hmrManager && isHmrAware(processor)) {
+			processor.setHmrManager(this.hmrManager);
+		}
+		this.registry.register(kind, variant, processor);
+	}
+
+	async processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]> {
+		const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
+		fileSystem.ensureDir(depsDir);
+
+		const dedupedDeps = this.deduplicateDependencies(deps);
+		const results = await this.processDependenciesParallel(dedupedDeps, key);
+
+		await this.optimizeDependencies(results);
+		return results;
+	}
+
+	private deduplicateDependencies(deps: AssetDefinition[]): AssetDefinition[] {
+		const seen = new Map<string, AssetDefinition>();
+
+		for (const dep of deps) {
+			const key = this.getDependencyKey(dep);
+			if (!seen.has(key)) {
+				seen.set(key, dep);
+			}
+		}
+
+		return Array.from(seen.values());
+	}
+
+	private getScriptDependencyBuildSignature(dep: AssetDefinition): string | undefined {
+		if (dep.kind !== 'script') {
+			return undefined;
+		}
+
+		const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
+		const signature = {
+			bundle: dep.bundle,
+			inline: dep.inline,
+			excludeFromHtml: dep.excludeFromHtml,
+			naming: dep.bundleOptions?.naming,
+			external: dep.bundleOptions?.external,
+			minify: dep.bundleOptions?.minify,
+			plugins: pluginNames,
+		};
+
+		return this.generateHash(JSON.stringify(signature));
+	}
+
+	private getDependencyKey(dep: AssetDefinition): string {
+		const parts: string[] = [dep.kind, dep.source];
+
+		if ('filepath' in dep) {
+			parts.push(dep.filepath);
+		} else if ('content' in dep) {
+			parts.push(`content:${this.generateHash(dep.content)}`);
+		} else if ('importPath' in dep) {
+			parts.push(dep.importPath);
+		}
+
+		if ('position' in dep && dep.position) {
+			parts.push(dep.position);
+		}
+
+		const scriptBuildSignature = this.getScriptDependencyBuildSignature(dep);
+		if (scriptBuildSignature) {
+			parts.push(`build:${scriptBuildSignature}`);
+		}
+
+		return parts.join(':');
+	}
+
+	private generateHash(content: string): string {
+		return rapidhash(content).toString();
+	}
+
+	private async processDependenciesParallel(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]> {
+		const grouped = this.groupDependenciesByType(deps);
+
+		const groupPromises = Object.entries(grouped).map(async ([, typeDeps]) => {
+			const typePromises = typeDeps.map(async (dep) => {
+				const depKey = this.getDependencyKey(dep);
+				const cached = this.getCachedAsset(dep, depKey);
+
+				if (cached) {
+					return { key, ...cached };
+				}
+
+				const processor = this.registry.getProcessor(dep.kind, dep.source);
+				if (!processor) {
+					appLogger.error(`No processor found for ${dep.kind}/${dep.source}`);
+					return null;
+				}
+
+				if (dep.source === 'file' && 'filepath' in dep) {
+					const fileExists = fileSystem.exists(dep.filepath);
+					if (!fileExists) {
+						appLogger.warn(`Skipping missing ${dep.kind} file: ${dep.filepath}`);
+						return null;
+					}
+				}
+
+				try {
+					const processed = await processor.process(dep);
+					const srcUrl = this.resolveProcessedAssetSrcUrl(processed);
+
+					const processedWithKey = {
+						key,
+						...processed,
+						srcUrl,
+					};
+
+					this.setCachedAsset(dep, depKey, processedWithKey);
+
+					return processedWithKey as ProcessedAsset;
+				} catch (error) {
+					appLogger.error(
+						`Failed to process dependency: ${
+							error instanceof Error ? error.message : String(error)
+						} for ${dep.kind}/${dep.source}`,
+					);
+					appLogger.debug(error as Error);
+					return null;
+				}
+			});
+
+			const typeResults = await Promise.all(typePromises);
+			return typeResults.filter((result) => result !== null);
+		});
+
+		const allTypeResults = await Promise.all(groupPromises);
+		return allTypeResults.flat();
+	}
+
+	private groupDependenciesByType(deps: AssetDefinition[]): Record<string, AssetDefinition[]> {
+		return deps.reduce(
+			(acc, dep) => {
+				const key = `${dep.kind}_${dep.source}`;
+				if (!acc[key]) acc[key] = [];
+				acc[key].push(dep);
+				return acc;
+			},
+			{} as Record<string, AssetDefinition[]>,
+		);
+	}
+
+	private getSrcUrl(filepath: string): string | undefined {
+		const distDir = this.config.absolutePaths.distDir;
+		if (!filepath.startsWith(distDir)) return undefined;
+
+		const relativePath = filepath.slice(distDir.length);
+		const urlPath = relativePath.startsWith('/') ? relativePath : `/${relativePath}`;
+		return urlPath.replace(/\\/g, '/');
+	}
+
+	private resolveProcessedAssetSrcUrl(processed: ProcessedAsset): string | undefined {
+		if (processed.srcUrl) {
+			if (this.isFilesystemPath(processed.srcUrl)) {
+				const srcUrlFromPath = this.getSrcUrl(processed.srcUrl);
+				if (srcUrlFromPath) return srcUrlFromPath;
+			} else {
+				return processed.srcUrl;
+			}
+		}
+
+		if (processed.filepath) {
+			return this.getSrcUrl(processed.filepath);
+		}
+
+		return undefined;
+	}
+
+	private isFilesystemPath(value: string): boolean {
+		if (value.startsWith('http://') || value.startsWith('https://') || value.startsWith('//')) {
+			return false;
+		}
+
+		if (value.startsWith(this.config.absolutePaths.distDir)) {
+			return true;
+		}
+
+		const rootDir = this.config.rootDir;
+		if (rootDir && value.startsWith(rootDir)) {
+			return true;
+		}
+
+		return /^[A-Za-z]:\\/.test(value);
+	}
+
+	private async optimizeDependencies(processedAssets: ProcessedAsset[]): Promise<void> {
+		if (process.env.NODE_ENV !== 'production') {
+			return;
+		}
+
+		const filesToGzip = new Set<string>();
+
+		for (const asset of processedAssets) {
+			if (!asset.filepath) {
+				continue;
+			}
+
+			if (!asset.filepath.startsWith(this.config.absolutePaths.distDir)) {
+				continue;
+			}
+
+			const extension = path.extname(asset.filepath).slice(1);
+			if (extension === 'css' || extension === 'js') {
+				filesToGzip.add(asset.filepath);
+			}
+		}
+
+		for (const filePath of filesToGzip) {
+			if (fileSystem.exists(filePath)) {
+				fileSystem.gzipFile(filePath);
+			}
+		}
+	}
+
+	private getCachedAsset(dep: AssetDefinition, depKey: string): ProcessedAsset | null {
+		const cached = this.cache.get(depKey);
+		return cached?.asset ?? null;
+	}
+
+	private setCachedAsset(dep: AssetDefinition, depKey: string, asset: ProcessedAsset): void {
+		this.cache.set(depKey, { asset });
+	}
+
+	clearCache(): void {
+		this.cache.clear();
+	}
+
+	invalidateCacheForFile(filepath: string): void {
+		for (const [key, value] of this.cache.entries()) {
+			if (value.asset.filepath === filepath) {
+				this.cache.delete(key);
+			}
+		}
+	}
+
+	static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService {
+		const service = new AssetProcessingService(appConfig);
+
+		service.registerProcessor('script', 'content', new ContentScriptProcessor({ appConfig }));
+		service.registerProcessor('script', 'file', new FileScriptProcessor({ appConfig }));
+		service.registerProcessor('script', 'node-module', new NodeModuleScriptProcessor({ appConfig }));
+
+		service.registerProcessor('stylesheet', 'content', new ContentStylesheetProcessor({ appConfig }));
+		service.registerProcessor('stylesheet', 'file', new FileStylesheetProcessor({ appConfig }));
+
+		return service;
+	}
+
+	getRegistry(): ProcessorRegistry {
+		return this.registry;
+	}
+}

package/src/services/asset-processing-service/asset.factory.d.ts

@@ -0,0 +1,17 @@
+import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types';
+type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
+export declare class AssetFactory {
+    static readonly RESOLVED_ASSETS_DIR = "assets";
+    static readonly RESOLVED_ASSETS_VENDORS_DIR: string;
+    static createContentScript(options: CreateAssetOptions<ContentScriptAsset>): ContentScriptAsset;
+    static createInlineContentScript(options: CreateAssetOptions<InlineContentScriptAsset>): InlineContentScriptAsset;
+    static createFileScript(options: CreateAssetOptions<FileScriptAsset>): FileScriptAsset;
+    static createInlineFileScript(options: CreateAssetOptions<InlineFileScriptAsset>): InlineFileScriptAsset;
+    static createNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset;
+    static createInlineNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset;
+    static createJsonScript(options: CreateAssetOptions<JsonScriptAsset>): JsonScriptAsset;
+    static createContentStylesheet(options: CreateAssetOptions<ContentStylesheetAsset>): ContentStylesheetAsset;
+    static createInlineContentStylesheet(options: CreateAssetOptions<InlineContentStylesheetAsset>): InlineContentStylesheetAsset;
+    static createFileStylesheet(options: CreateAssetOptions<FileStylesheetAsset>): FileStylesheetAsset;
+}
+export {};

package/src/services/asset-processing-service/asset.factory.js

@@ -0,0 +1,82 @@
+import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from "../../constants";
+import { deepMerge } from "../../utils/deep-merge";
+class AssetFactory {
+  static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
+  static RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;
+  static createContentScript(options) {
+    return {
+      kind: "script",
+      source: "content",
+      position: options.position || "body",
+      ...options
+    };
+  }
+  static createInlineContentScript(options) {
+    return {
+      ...AssetFactory.createContentScript(options),
+      inline: true
+    };
+  }
+  static createFileScript(options) {
+    return {
+      kind: "script",
+      source: "file",
+      position: options.position || "body",
+      ...options
+    };
+  }
+  static createInlineFileScript(options) {
+    return {
+      ...AssetFactory.createFileScript(options),
+      inline: true
+    };
+  }
+  static createNodeModuleScript(options) {
+    return {
+      kind: "script",
+      source: "node-module",
+      position: options.position || "body",
+      ...options
+    };
+  }
+  static createInlineNodeModuleScript(options) {
+    return {
+      ...AssetFactory.createNodeModuleScript(options),
+      inline: true
+    };
+  }
+  static createJsonScript(options) {
+    return {
+      kind: "script",
+      source: "content",
+      attributes: deepMerge(options.attributes, { type: "application/json" }),
+      position: options.position || "body",
+      ...options
+    };
+  }
+  static createContentStylesheet(options) {
+    return {
+      kind: "stylesheet",
+      source: "content",
+      position: "head",
+      ...options
+    };
+  }
+  static createInlineContentStylesheet(options) {
+    return {
+      ...AssetFactory.createContentStylesheet(options),
+      inline: true
+    };
+  }
+  static createFileStylesheet(options) {
+    return {
+      kind: "stylesheet",
+      source: "file",
+      position: options.position || "head",
+      ...options
+    };
+  }
+}
+export {
+  AssetFactory
+};