@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

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

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
+import type { BaseAsset, ProcessedAsset } from '../../assets.types.ts';
+import { BaseProcessor } from './base-processor.ts';
+
+type TestAsset = BaseAsset & {
+	name: string;
+};
+
+class TestProcessor extends BaseProcessor<TestAsset> {
+	processCalls = 0;
+
+	async process(dep: TestAsset): Promise<ProcessedAsset> {
+		return this.getOrProcess(dep.name, async () => {
+			this.processCalls += 1;
+			return {
+				filepath: `/test/dist/assets/${dep.name}.js`,
+				kind: dep.kind,
+				inline: false,
+			};
+		});
+	}
+}
+
+const originalExists = fileSystem.exists;
+
+beforeEach(() => {
+	fileSystem.exists = vi.fn(() => true);
+});
+
+afterEach(() => {
+	fileSystem.exists = originalExists;
+	vi.restoreAllMocks();
+});
+
+test('BaseProcessor - rebuilds cached outputs when emitted file was deleted', async () => {
+	const existsMock = vi
+		.fn()
+		.mockImplementationOnce(() => false)
+		.mockImplementation(() => true);
+	fileSystem.exists = existsMock;
+
+	const processor = new TestProcessor({
+		appConfig: {
+			absolutePaths: { distDir: '/test/dist' },
+		} as any,
+	});
+
+	const asset: TestAsset = {
+		kind: 'script',
+		source: 'file',
+		name: 'runtime-vendor',
+	};
+
+	await processor.process(asset);
+	await processor.process(asset);
+
+	expect(processor.processCalls).toBe(2);
+});

package/src/services/{asset-processing-service → assets/asset-processing-service}/processors/base/base-processor.ts

@@ -1,9 +1,10 @@
 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 { 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';
+import { fileSystem } from '@ecopages/file-system';
 
 export abstract class BaseProcessor<T extends BaseAsset> {
 	protected appConfig: EcoPagesAppConfig;
@@ -59,7 +60,12 @@ export abstract class BaseProcessor<T extends BaseAsset> {
 		processFn: () => ProcessedAsset | Promise<ProcessedAsset>,
 	): Promise<ProcessedAsset> {
 		if (this.hasCacheFile(cacheKey)) {
-			return Promise.resolve(this.getCacheFile(cacheKey) as ProcessedAsset);
+			const cached = this.getCacheFile(cacheKey) as ProcessedAsset;
+			if (!cached.filepath || fileSystem.exists(cached.filepath)) {
+				return Promise.resolve(cached);
+			}
+
+			this.cache.delete(cacheKey);
 		}
 
 		const result = processFn();

package/src/services/{asset-processing-service → assets/asset-processing-service}/processors/base/base-script-processor.ts

@@ -1,15 +1,19 @@
-import { appLogger } from '../../../../global/app-logger';
-import type { EcoPagesAppConfig } from '../../../../internal-types';
-import { defaultBuildAdapter } from '../../../../build/build-adapter.ts';
-import type { EcoBuildPlugin } from '../../../../build/build-types.ts';
+import { appLogger } from '../../../../../global/app-logger';
+import type { EcoPagesAppConfig } from '../../../../../internal-types';
+import { getAppBrowserBuildPlugins } from '../../../../../build/build-adapter.ts';
+import type { EcoBuildPlugin } from '../../../../../build/build-types.ts';
 import { fileSystem } from '@ecopages/file-system';
 import path from 'node:path';
 import type { ScriptAsset } from '../../assets.types';
 import { BaseProcessor } from './base-processor';
+import { BrowserBundleService } from '../../../browser-bundle.service.ts';
 
 export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
+	private readonly browserBundleService: BrowserBundleService;
+
 	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
 		super({ appConfig });
+		this.browserBundleService = new BrowserBundleService(appConfig);
 	}
 
 	protected shouldBundle(dep: T): boolean {
@@ -21,21 +25,7 @@ export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BasePro
 	}
 
 	protected collectBuildPlugins(): EcoBuildPlugin[] {
-		const plugins: EcoBuildPlugin[] = [];
-
-		if (this.appConfig.processors?.size) {
-			for (const processor of this.appConfig.processors.values()) {
-				if (processor.buildPlugins) {
-					plugins.push(...processor.buildPlugins);
-				}
-			}
-		}
-
-		if (this.appConfig.loaders?.size) {
-			plugins.push(...this.appConfig.loaders.values());
-		}
-
-		return plugins;
+		return getAppBrowserBuildPlugins(this.appConfig);
 	}
 
 	protected async bundleScript({
@@ -50,25 +40,25 @@ export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BasePro
 		const buildPlugins = this.collectBuildPlugins();
 		const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
 
-		const build = await defaultBuildAdapter.build({
+		const buildResult = await this.browserBundleService.bundle({
+			profile: 'browser-script',
 			entrypoints: [entrypoint],
 			outdir,
 			root: this.appConfig.rootDir,
-			...defaultBuildAdapter.getTranspileOptions('browser-script'),
 			splitting: true,
 			naming: '[name]-[hash].[ext]',
 			plugins: allPlugins,
 			...rest,
 		});
 
-		if (!build.success) {
-			for (const log of build.logs) {
+		if (!buildResult.success) {
+			for (const log of buildResult.logs) {
 				appLogger.debug(log.message, log);
 			}
 		}
 
 		const entryBaseName = path.parse(entrypoint).name;
-		const entryOutput = build.outputs
+		const entryOutput = buildResult.outputs
 			.map((output) => output.path)
 			.find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
 
@@ -76,7 +66,7 @@ export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BasePro
 			return entryOutput;
 		}
 
-		const nonVendorOutput = build.outputs
+		const nonVendorOutput = buildResult.outputs
 			.map((output) => output.path)
 			.find((outputPath) => !path.basename(outputPath).startsWith('vendors'));
 
@@ -84,7 +74,7 @@ export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BasePro
 			return nonVendorOutput;
 		}
 
-		const primaryOutput = build.outputs[0]?.path;
+		const primaryOutput = buildResult.outputs[0]?.path;
 		if (primaryOutput) {
 			return primaryOutput;
 		}
@@ -99,7 +89,7 @@ export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BasePro
 			return fallbackOutput;
 		}
 
-		const logMessage = build.logs.map((log) => log.message).join(' | ');
+		const logMessage = buildResult.logs.map((log) => log.message).join(' | ');
 		throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ''}`);
 	}
 }

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

@@ -0,0 +1,286 @@
+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 '../../../../../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'),
+			} 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.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 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 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/{asset-processing-service → assets/asset-processing-service}/processors/script/file-script.processor.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import { RESOLVED_ASSETS_DIR } from '../../../../constants';
+import { RESOLVED_ASSETS_DIR } from '../../../../../constants';
 import { fileSystem } from '@ecopages/file-system';
-import type { IHmrManager } from '../../../../internal-types';
+import type { IHmrManager } from '../../../../../internal-types';
 import type { FileScriptAsset, ProcessedAsset } from '../../assets.types';
 import { BaseScriptProcessor } from '../base/base-script-processor';
 
@@ -17,7 +17,7 @@ export class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
 		 * If HMR Manager is active, delegate build/watch to it.
 		 */
 		if (this.hmrManager?.isEnabled() && !dep.inline) {
-			const outputUrl = await this.hmrManager.registerEntrypoint(dep.filepath);
+			const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
 			return {
 				filepath: dep.filepath,
 				srcUrl: outputUrl,