@ecopages/core 0.2.0-alpha.5 → 0.2.0-alpha.51

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

@@ -1,306 +0,0 @@
-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.ts

@@ -1,105 +0,0 @@
-import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from '../../constants';
-import { deepMerge } from '../../utils/deep-merge';
-import type {
-	ContentScriptAsset,
-	ContentStylesheetAsset,
-	FileScriptAsset,
-	FileStylesheetAsset,
-	InlineContentScriptAsset,
-	InlineContentStylesheetAsset,
-	InlineFileScriptAsset,
-	JsonScriptAsset,
-	NodeModuleScriptAsset,
-} from './assets.types';
-
-type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
-
-export class AssetFactory {
-	static readonly RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
-	static readonly RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;
-
-	static createContentScript(options: CreateAssetOptions<ContentScriptAsset>): ContentScriptAsset {
-		return {
-			kind: 'script',
-			source: 'content',
-			position: options.position || 'body',
-			...options,
-		};
-	}
-
-	static createInlineContentScript(options: CreateAssetOptions<InlineContentScriptAsset>): InlineContentScriptAsset {
-		return {
-			...AssetFactory.createContentScript(options),
-			inline: true,
-		};
-	}
-
-	static createFileScript(options: CreateAssetOptions<FileScriptAsset>): FileScriptAsset {
-		return {
-			kind: 'script',
-			source: 'file',
-			position: options.position || 'body',
-			...options,
-		};
-	}
-
-	static createInlineFileScript(options: CreateAssetOptions<InlineFileScriptAsset>): InlineFileScriptAsset {
-		return {
-			...AssetFactory.createFileScript(options),
-			inline: true,
-		};
-	}
-
-	static createNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset {
-		return {
-			kind: 'script',
-			source: 'node-module',
-			position: options.position || 'body',
-			...options,
-		};
-	}
-
-	static createInlineNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset {
-		return {
-			...AssetFactory.createNodeModuleScript(options),
-			inline: true,
-		};
-	}
-
-	static createJsonScript(options: CreateAssetOptions<JsonScriptAsset>): JsonScriptAsset {
-		return {
-			kind: 'script',
-			source: 'content',
-			attributes: deepMerge(options.attributes, { type: 'application/json' }),
-			position: options.position || 'body',
-			...options,
-		};
-	}
-
-	static createContentStylesheet(options: CreateAssetOptions<ContentStylesheetAsset>): ContentStylesheetAsset {
-		return {
-			kind: 'stylesheet',
-			source: 'content',
-			position: 'head',
-			...options,
-		};
-	}
-
-	static createInlineContentStylesheet(
-		options: CreateAssetOptions<InlineContentStylesheetAsset>,
-	): InlineContentStylesheetAsset {
-		return {
-			...AssetFactory.createContentStylesheet(options),
-			inline: true,
-		};
-	}
-
-	static createFileStylesheet(options: CreateAssetOptions<FileStylesheetAsset>): FileStylesheetAsset {
-		return {
-			kind: 'stylesheet',
-			source: 'file',
-			position: options.position || 'head',
-			...options,
-		};
-	}
-}

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

@@ -1,112 +0,0 @@
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
-
-export type AssetSource = 'content' | 'file' | 'node-module';
-export type AssetKind = 'script' | 'stylesheet';
-export type AssetPosition = 'head' | 'body';
-
-export interface BaseAsset {
-	kind: AssetKind;
-	source: AssetSource;
-	attributes?: Record<string, string>;
-	position?: AssetPosition;
-}
-
-export interface ScriptAsset extends BaseAsset {
-	kind: 'script';
-	inline?: boolean;
-	bundle?: boolean;
-	bundleOptions?: {
-		minify?: boolean;
-		external?: string[];
-		naming?: string;
-		plugins?: EcoBuildPlugin[];
-	};
-	/**
-	 * Whether to exclude this asset from the HTML output.
-	 * @default false
-	 */
-	excludeFromHtml?: boolean;
-}
-
-export interface StylesheetAsset extends BaseAsset {
-	kind: 'stylesheet';
-	inline?: boolean;
-}
-
-export interface ContentScriptAsset extends ScriptAsset {
-	source: 'content';
-	content: string;
-	name?: string;
-}
-
-export interface InlineContentScriptAsset extends ContentScriptAsset {
-	inline: true;
-}
-
-export interface ContentStylesheetAsset extends StylesheetAsset {
-	source: 'content';
-	content: string;
-}
-
-export interface InlineContentStylesheetAsset extends ContentStylesheetAsset {
-	inline: true;
-}
-
-export interface FileScriptAsset extends ScriptAsset {
-	source: 'file';
-	filepath: string;
-	name?: string;
-}
-
-export interface InlineFileScriptAsset extends FileScriptAsset {
-	inline: true;
-}
-
-export interface FileStylesheetAsset extends StylesheetAsset {
-	source: 'file';
-	filepath: string;
-	name?: string;
-}
-
-export interface InlineFileStylesheetAsset extends FileStylesheetAsset {
-	inline: true;
-}
-
-export interface NodeModuleScriptAsset extends ScriptAsset {
-	kind: 'script';
-	source: 'node-module';
-	importPath: string;
-	name?: string;
-}
-
-export interface InlineNodeModuleScriptAsset extends NodeModuleScriptAsset {
-	inline: true;
-}
-
-export interface InlineNodeModuleScriptAsset extends NodeModuleScriptAsset {
-	inline: true;
-}
-
-export interface JsonScriptAsset extends ScriptAsset {
-	source: 'content';
-	content: string;
-}
-
-export type ProcessedAsset = {
-	filepath?: string;
-	srcUrl?: string;
-	content?: string;
-	kind: AssetKind;
-	position?: AssetPosition;
-	attributes?: Record<string, string>;
-	inline?: boolean;
-	excludeFromHtml?: boolean;
-};
-
-export type AssetDefinition =
-	| ContentScriptAsset
-	| FileScriptAsset
-	| NodeModuleScriptAsset
-	| JsonScriptAsset
-	| ContentStylesheetAsset
-	| FileStylesheetAsset;

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

@@ -1,3 +0,0 @@
-export * from './asset.factory';
-export * from './asset-processing.service';
-export * from './assets.types';

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

@@ -1,3 +0,0 @@
-export * from "./asset.factory";
-export * from "./asset-processing.service";
-export * from "./assets.types";

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

@@ -1,3 +0,0 @@
-export * from './asset.factory';
-export * from './asset-processing.service';
-export * from './assets.types';

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

@@ -1,27 +0,0 @@
-import type { IHmrManager } from '../../internal-types';
-import type { AssetDefinition, ProcessedAsset } from './assets.types';
-
-/**
- * Base interface for asset processors.
- * Processors transform asset definitions into processed assets.
- */
-export interface AssetProcessor<T extends AssetDefinition = AssetDefinition> {
-	process(asset: T): Promise<ProcessedAsset>;
-}
-
-/**
- * Interface for processors that support HMR (Hot Module Replacement).
- * These processors can receive an HMR manager to enable hot reloading capabilities.
- */
-export interface HmrAwareProcessor extends AssetProcessor {
-	setHmrManager(hmrManager: IHmrManager): void;
-}
-
-/**
- * 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: AssetProcessor): processor is HmrAwareProcessor {
-	return 'setHmrManager' in processor && typeof (processor as HmrAwareProcessor).setHmrManager === 'function';
-}

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

@@ -1,18 +0,0 @@
-import type { AssetKind, AssetSource } from './assets.types';
-import type { BaseProcessor } from './processors/base/base-processor';
-
-export class ProcessorRegistry {
-	private processors = new Map<`${AssetKind}-${AssetSource}`, BaseProcessor<any>>();
-
-	register(kind: AssetKind, variant: AssetSource, processor: BaseProcessor<any>) {
-		this.processors.set(`${kind}-${variant}`, processor);
-	}
-
-	getProcessor(kind: AssetKind, variant: AssetSource): BaseProcessor<any> | undefined {
-		return this.processors.get(`${kind}-${variant}`);
-	}
-
-	getAllProcessors(): Map<`${AssetKind}-${AssetSource}`, BaseProcessor<any>> {
-		return this.processors;
-	}
-}

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

@@ -1,76 +0,0 @@
-import path from 'node:path';
-import { RESOLVED_ASSETS_DIR } from '../../../../constants.ts';
-import type { EcoPagesAppConfig } from '../../../../internal-types.ts';
-import { rapidhash } from '../../../../utils/hash.ts';
-import { isDevelopmentRuntime, isProductionRuntime } from '../../../../utils/runtime.ts';
-import type { BaseAsset, ProcessedAsset } from '../../assets.types.ts';
-
-export abstract class BaseProcessor<T extends BaseAsset> {
-	protected appConfig: EcoPagesAppConfig;
-	/**
-	 * 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.
-	 */
-	protected cache: Map<string, ProcessedAsset> = new Map();
-
-	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
-		this.appConfig = appConfig;
-	}
-
-	get isDevelopment(): boolean {
-		return isDevelopmentRuntime();
-	}
-
-	get isProduction(): boolean {
-		return isProductionRuntime();
-	}
-
-	abstract process(dep: T): Promise<ProcessedAsset>;
-
-	protected getAssetsDir(): string {
-		return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
-	}
-
-	protected writeCacheFile(key: string, path: ProcessedAsset): void {
-		this.cache.set(key, path);
-	}
-
-	protected getCacheFile(key: string): ProcessedAsset | undefined {
-		return this.cache.get(key);
-	}
-
-	protected hasCacheFile(key: string): boolean {
-		return this.cache.has(key);
-	}
-
-	protected generateHash(content: string): string {
-		return rapidhash(content).toString();
-	}
-
-	protected buildCacheKey(identifier: string, contentHash: string, dep: T): string {
-		const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : '';
-		const position = dep.position ?? '';
-		return `${identifier}:${contentHash}:${position}:${attrsHash}`;
-	}
-
-	protected getOrProcess(
-		cacheKey: string,
-		processFn: () => ProcessedAsset | Promise<ProcessedAsset>,
-	): Promise<ProcessedAsset> {
-		if (this.hasCacheFile(cacheKey)) {
-			return Promise.resolve(this.getCacheFile(cacheKey) as ProcessedAsset);
-		}
-
-		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);
-	}
-}

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

@@ -1,16 +0,0 @@
-import type { EcoPagesAppConfig } from '../../../../internal-types';
-import type { EcoBuildPlugin } from '../../../../build/build-types.js';
-import type { ScriptAsset } from '../../assets.types';
-import { BaseProcessor } from './base-processor';
-export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
-    constructor({ appConfig }: {
-        appConfig: EcoPagesAppConfig;
-    });
-    protected shouldBundle(dep: T): boolean;
-    protected getBundlerOptions(dep: T): Record<string, any>;
-    protected collectBuildPlugins(): EcoBuildPlugin[];
-    protected bundleScript({ entrypoint, outdir, plugins: additionalPlugins, ...rest }: {
-        entrypoint: string;
-        outdir: string;
-    } & ScriptAsset['bundleOptions']): Promise<string>;
-}