@ecopages/core 0.2.0-alpha.52 → 0.2.0-alpha.54

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

@@ -0,0 +1,138 @@
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types.ts';
+import { BaseScriptProcessor } from '../base/base-script-processor.ts';
+
+export class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
+	async processGrouped(deps: ContentScriptAsset[]): Promise<ProcessedAsset[]> {
+		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() : undefined,
+					kind: 'script' as const,
+					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: ContentScriptAsset): Promise<ProcessedAsset> {
+		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: ProcessedAsset = {
+				filepath,
+				content: dep.inline ? dep.content : undefined,
+				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;
+		}
+
+		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: ProcessedAsset = {
+				filepath: bundledFilePath,
+				content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : undefined,
+				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;
+		}
+
+		throw new Error('No content found for script asset');
+	}
+}

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

@@ -0,0 +1,326 @@
+import { describe, expect, test, beforeEach, afterEach, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import { FileScriptProcessor } from './file-script.processor';
+import type { EcoPagesAppConfig, IHmrManager } from '../../../../../types/internal-types';
+import type { FileScriptAsset } from '../../assets.types';
+
+const originalReadFileSync = fileSystem.readFileSync;
+const originalCopyFile = fileSystem.copyFile;
+const originalExists = fileSystem.exists;
+
+const createMockConfig = (): EcoPagesAppConfig =>
+	({
+		rootDir: '/test/project',
+		srcDir: 'src',
+		distDir: '.eco/public',
+		absolutePaths: {
+			distDir: '/test/project/.eco/public',
+			srcDir: '/test/project/src',
+		},
+		processors: new Map(),
+		loaders: new Map(),
+	}) as unknown as EcoPagesAppConfig;
+
+describe('FileScriptProcessor', () => {
+	let readFileSyncMock: any;
+	let copyFileMock: any;
+	let existsMock: any;
+
+	beforeEach(() => {
+		readFileSyncMock = vi.fn(() => 'console.log("test");');
+		copyFileMock = vi.fn(() => {});
+		existsMock = vi.fn(() => false);
+		fileSystem.readFileSync = readFileSyncMock;
+		fileSystem.copyFile = copyFileMock;
+		fileSystem.exists = existsMock;
+	});
+
+	afterEach(() => {
+		fileSystem.readFileSync = originalReadFileSync;
+		fileSystem.copyFile = originalCopyFile;
+		fileSystem.exists = originalExists;
+		vi.restoreAllMocks();
+	});
+
+	describe('setHmrManager', () => {
+		test('should accept an HMR manager', () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const HmrManager = {
+				isEnabled: () => true,
+				registerScriptEntrypoint: async () => '/hmr/script.js',
+			} as unknown as IHmrManager;
+
+			expect(() => processor.setHmrManager(HmrManager)).not.toThrow();
+		});
+	});
+
+	describe('process', () => {
+		test('should delegate to HMR manager when enabled and not inline and preserve excludeFromHtml', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const HmrManager = {
+				isEnabled: () => true,
+				registerScriptEntrypoint: vi.fn(async () => '/hmr/script.js'),
+				getDistDir: () => '/test/project/.eco/public/assets/_hmr',
+			} as unknown as IHmrManager;
+			processor.setHmrManager(HmrManager);
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.ts',
+				inline: false,
+				excludeFromHtml: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(HmrManager.registerScriptEntrypoint).toHaveBeenCalledWith('/test/project/src/script.ts');
+			expect(result.srcUrl).toBe('/hmr/script.js');
+			expect(result.filepath).toBe('/test/project/.eco/public/assets/_hmr/script.js');
+			expect(result.inline).toBe(false);
+			expect(result.excludeFromHtml).toBe(true);
+		});
+
+		test('should preserve excludeFromHtml: false when delegating to HMR manager', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const HmrManager = {
+				isEnabled: () => true,
+				registerScriptEntrypoint: vi.fn(async () => '/hmr/script.js'),
+			} as unknown as IHmrManager;
+			processor.setHmrManager(HmrManager);
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.ts',
+				inline: false,
+				excludeFromHtml: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(HmrManager.registerScriptEntrypoint).toHaveBeenCalledWith('/test/project/src/script.ts');
+			expect(result.srcUrl).toBe('/hmr/script.js');
+			expect(result.inline).toBe(false);
+			expect(result.excludeFromHtml).toBe(false);
+		});
+
+		test('should fall back to the source filepath when the HMR manager does not expose a dist directory', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const HmrManager = {
+				isEnabled: () => true,
+				registerScriptEntrypoint: vi.fn(async () => '/hmr/script.js'),
+			} as unknown as IHmrManager;
+			processor.setHmrManager(HmrManager);
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.ts',
+				inline: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.filepath).toBe('/test/project/src/script.ts');
+		});
+
+		test('should not use HMR when inline is true', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const HmrManager = {
+				isEnabled: () => true,
+				registerScriptEntrypoint: vi.fn(async () => '/hmr/script.js'),
+			} as unknown as IHmrManager;
+			processor.setHmrManager(HmrManager);
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.ts',
+				inline: true,
+				bundle: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(HmrManager.registerScriptEntrypoint).not.toHaveBeenCalled();
+			expect(result.inline).toBe(true);
+			expect(result.content).toBeDefined();
+		});
+
+		test('should copy file without bundling when bundle is false', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/scripts/app.js',
+				bundle: false,
+				inline: false,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(copyFileMock).toHaveBeenCalled();
+			expect(result.kind).toBe('script');
+			expect(result.inline).toBe(false);
+		});
+
+		test('should return consistent result when called multiple times with same file', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/scripts/cached.js',
+				bundle: false,
+				inline: false,
+			};
+
+			const result1 = await processor.process(dep);
+			const result2 = await processor.process(dep);
+
+			expect(result1).toEqual(result2);
+		});
+
+		test('should include content when inline is true and bundle is false', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/inline.js',
+				bundle: false,
+				inline: true,
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.inline).toBe(true);
+			expect(result.content).toBe('console.log("test");');
+			expect(result.filepath).toBeUndefined();
+		});
+
+		test('should preserve attributes from dependency', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.js',
+				bundle: false,
+				attributes: { defer: 'true', 'data-custom': 'value' },
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.attributes).toEqual({ defer: 'true', 'data-custom': 'value' });
+		});
+
+		test('should preserve position from dependency', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.js',
+				bundle: false,
+				position: 'head',
+			};
+
+			const result = await processor.process(dep);
+
+			expect(result.position).toBe('head');
+		});
+
+		test('should pass bundle plugins through when bundling', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const bundleScriptSpy = vi.spyOn(processor as any, 'bundleScript').mockResolvedValue('/tmp/out.js');
+			const customPlugin = {
+				name: 'custom-plugin',
+				setup() {},
+			};
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/script.tsx',
+				bundle: true,
+				bundleOptions: {
+					plugins: [customPlugin],
+				},
+			};
+
+			await processor.process(dep);
+
+			expect(bundleScriptSpy).toHaveBeenCalled();
+			const buildArgs = bundleScriptSpy.mock.calls[0]?.[0] as { plugins?: Array<{ name?: string }> };
+			expect(buildArgs.plugins?.some((plugin) => plugin.name === 'custom-plugin')).toBe(true);
+		});
+
+		test('should bundle nested source files into dist assets subdirectories', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const bundleScriptSpy = vi.spyOn(processor as any, 'bundleScript').mockResolvedValue('/tmp/out.js');
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/pages/index.tsx',
+				bundle: true,
+			};
+
+			await processor.process(dep);
+
+			const buildArgs = bundleScriptSpy.mock.calls[0]?.[0] as { outdir?: string };
+			expect(buildArgs.outdir).toBe('/test/project/.eco/public/assets/pages');
+		});
+
+		test('should disable splitting for page-owned script bundles by default', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+			const bundleScriptSpy = vi.spyOn(processor as any, 'bundleScript').mockResolvedValue('/tmp/out.js');
+
+			const dep: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/pages/index.tsx',
+				bundle: true,
+				packageRole: 'page-script',
+			};
+
+			await processor.process(dep);
+
+			const buildArgs = bundleScriptSpy.mock.calls[0]?.[0] as { splitting?: boolean };
+			expect(buildArgs.splitting).toBe(false);
+		});
+
+		test('should return updated attributes when cached asset is retrieved with different attributes', async () => {
+			const processor = new FileScriptProcessor({ appConfig: createMockConfig() });
+
+			const depWithDefer: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/cached-attrs.js',
+				bundle: false,
+				attributes: { defer: '' },
+				position: 'head',
+			};
+
+			const depWithAsync: FileScriptAsset = {
+				kind: 'script',
+				source: 'file',
+				filepath: '/test/project/src/cached-attrs.js',
+				bundle: false,
+				attributes: { async: '' },
+				position: 'body',
+			};
+
+			const result1 = await processor.process(depWithDefer);
+			const result2 = await processor.process(depWithAsync);
+
+			expect(result1.attributes).toEqual({ defer: '' });
+			expect(result1.position).toBe('head');
+			expect(result2.attributes).toEqual({ async: '' });
+			expect(result2.position).toBe('body');
+		});
+	});
+});

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

@@ -0,0 +1,116 @@
+import path from 'node:path';
+import { RESOLVED_ASSETS_DIR } from '../../../../../config/constants.ts';
+import { fileSystem } from '@ecopages/file-system';
+import type { IHmrManager } from '../../../../../types/internal-types.ts';
+import type { FileScriptAsset, ProcessedAsset } from '../../assets.types.ts';
+import { BaseScriptProcessor } from '../base/base-script-processor.ts';
+
+export class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
+	private hmrManager?: IHmrManager;
+
+	private resolveHmrOutputFilepath(entrypointPath: string): string | undefined {
+		if (!this.hmrManager || !('getDistDir' in this.hmrManager)) {
+			return undefined;
+		}
+
+		const getDistDir = this.hmrManager.getDistDir;
+		if (typeof getDistDir !== 'function') {
+			return undefined;
+		}
+
+		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: IHmrManager) {
+		this.hmrManager = hmrManager;
+	}
+
+	async process(dep: FileScriptAsset): Promise<ProcessedAsset> {
+		/**
+		 * If HMR Manager is active, delegate build/watch to it.
+		 */
+		if (this.hmrManager?.isEnabled() && !dep.inline) {
+			const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
+			const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
+			return {
+				filepath: outputFilepath ?? dep.filepath,
+				sourceFilepath: dep.filepath,
+				srcUrl: outputUrl,
+				kind: 'script',
+				position: dep.position,
+				attributes: dep.attributes,
+				inline: false,
+				excludeFromHtml: dep.excludeFromHtml,
+				packageRole: dep.packageRole,
+				bundledSourceFilepaths: dep.bundledSourceFilepaths,
+			};
+		}
+
+		const content = fileSystem.readFileSync(dep.filepath);
+		const shouldBundle = this.shouldBundle(dep);
+		const configHash = this.generateHash(
+			JSON.stringify({
+				bundle: shouldBundle,
+				minify: shouldBundle && this.isProduction,
+				opts: dep.bundleOptions,
+			}),
+		);
+		const cachekey = `${this.buildCacheKey(dep.filepath, this.generateHash(content), dep)}:${configHash}`;
+
+		return this.getOrProcess(cachekey, async () => {
+			if (!shouldBundle) {
+				const outFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
+				let filepath: string | undefined;
+
+				if (!dep.inline) {
+					filepath = path.join(this.getAssetsDir(), outFilepath);
+					fileSystem.copyFile(dep.filepath, filepath);
+				}
+
+				return {
+					filepath,
+					sourceFilepath: dep.filepath,
+					content,
+					kind: 'script',
+					position: dep.position,
+					attributes: dep.attributes,
+					inline: dep.inline,
+					excludeFromHtml: dep.excludeFromHtml,
+					packageRole: dep.packageRole,
+					bundledSourceFilepaths: dep.bundledSourceFilepaths,
+				};
+			}
+
+			const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
+			const outdirPath = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, relativeFilepath);
+			const outdirDirname = path.dirname(outdirPath);
+			const bundlerOptions = this.getBundlerOptions(dep);
+
+			const bundledFilePath = await this.bundleScript({
+				entrypoint: dep.filepath,
+				outdir: outdirDirname,
+				minify: this.isProduction,
+				...bundlerOptions,
+				plugins: bundlerOptions.plugins,
+			});
+
+			return {
+				filepath: bundledFilePath,
+				sourceFilepath: dep.filepath,
+				content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : undefined,
+				kind: 'script',
+				position: dep.position,
+				attributes: dep.attributes,
+				inline: dep.inline,
+				excludeFromHtml: dep.excludeFromHtml,
+				packageRole: dep.packageRole,
+				bundledSourceFilepaths: dep.bundledSourceFilepaths,
+			};
+		});
+	}
+}