@ecopages/core 0.2.0-alpha.24 → 0.2.0-alpha.26

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

@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import { ContentScriptProcessor } from './content-script.processor';
-import type { EcoPagesAppConfig } from '../../../../../types/internal-types.ts';
-import type { ContentScriptAsset } from '../../assets.types.ts';
-import type { BrowserBundleGroupedEntry } from '../../../browser-bundle.service.ts';
-
-function createMockConfig(): EcoPagesAppConfig {
-	return {
-		baseUrl: 'http://localhost:3000',
-		rootDir: '/test/project',
-		srcDir: 'src',
-		publicDir: 'public',
-		pagesDir: 'pages',
-		includesDir: 'includes',
-		layoutsDir: 'layouts',
-		distDir: '.eco/public',
-		workDir: '.eco',
-		templatesExt: [],
-		componentsDir: 'components',
-		robotsTxt: { preferences: { '*': [] } },
-		additionalWatchPaths: [],
-		defaultMetadata: { title: 'Test', description: 'Test' },
-		integrations: [],
-		integrationsDependencies: [],
-		absolutePaths: {
-			config: '/test/project/eco.config.ts',
-			componentsDir: '/test/project/src/components',
-			distDir: '/test/project/.eco/public',
-			workDir: '/test/project/.eco',
-			includesDir: '/test/project/src/includes',
-			layoutsDir: '/test/project/src/layouts',
-			pagesDir: '/test/project/src/pages',
-			projectDir: '/test/project',
-			publicDir: '/test/project/public',
-			srcDir: '/test/project/src',
-			htmlTemplatePath: '/test/project/src/html.tsx',
-			error404TemplatePath: '/test/project/src/404.tsx',
-		},
-		processors: new Map(),
-		loaders: new Map(),
-		sourceTransforms: new Map(),
-	};
-}
-
-class TestContentScriptProcessor extends ContentScriptProcessor {
-	readonly bundleScriptsCalls: Array<{
-		entries: BrowserBundleGroupedEntry[];
-		outdir: string;
-		naming?: string;
-	}> = [];
-	bundleScriptsResult = new Map<string, string>();
-	bundleScriptsError?: Error;
-
-	protected override async bundleScripts({
-		entries,
-		outdir,
-		naming,
-	}: {
-		entries: BrowserBundleGroupedEntry[];
-		outdir: string;
-		naming?: string;
-	}): Promise<Map<string, string>> {
-		this.bundleScriptsCalls.push({ entries, outdir, naming });
-
-		if (this.bundleScriptsError) {
-			throw this.bundleScriptsError;
-		}
-
-		return this.bundleScriptsResult;
-	}
-}
-
-describe('ContentScriptProcessor', () => {
-	beforeEach(() => {
-		vi.spyOn(fileSystem, 'ensureDir').mockImplementation(() => {});
-		vi.spyOn(fileSystem, 'write').mockImplementation(() => {});
-		vi.spyOn(fileSystem, 'remove').mockImplementation(() => {});
-		vi.spyOn(fileSystem, 'readFileSync').mockImplementation(() => '');
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	test('processGrouped should bundle grouped entries together and preserve logical entry mapping', async () => {
-		const processor = new TestContentScriptProcessor({ appConfig: createMockConfig() });
-		processor.bundleScriptsResult = new Map([
-			['page-entry', '/test/project/.eco/public/assets/page-entry-abc123.js'],
-			['lazy-entry', '/test/project/.eco/public/assets/lazy-entry-def456.js'],
-		]);
-
-		const deps: ContentScriptAsset[] = [
-			{
-				kind: 'script',
-				source: 'content',
-				content: 'import "/test/project/src/page.ts";',
-				position: 'head',
-				attributes: { type: 'module', defer: '' },
-				packageRole: 'page-script',
-				groupedBundle: { id: 'bundle-1', entryName: 'page-entry' },
-			},
-			{
-				kind: 'script',
-				source: 'content',
-				content: 'import "/test/project/src/lazy.ts";',
-				position: 'head',
-				attributes: { type: 'module', defer: '', 'data-eco-lazy-key': 'lazy-key' },
-				excludeFromHtml: true,
-				groupedBundle: { id: 'bundle-1', entryName: 'lazy-entry' },
-			},
-		];
-
-		const results = await processor.processGrouped(deps);
-
-		expect(processor.bundleScriptsCalls).toHaveLength(1);
-		expect(processor.bundleScriptsCalls[0]).toEqual(
-			expect.objectContaining({
-				entries: expect.arrayContaining([
-					expect.objectContaining({ entryName: 'page-entry' }),
-					expect.objectContaining({ entryName: 'lazy-entry' }),
-				]),
-				naming: '[name]-[hash].[ext]',
-			}),
-		);
-
-		expect(results).toEqual([
-			expect.objectContaining({
-				filepath: '/test/project/.eco/public/assets/page-entry-abc123.js',
-				packageRole: 'page-script',
-				groupedBundle: { id: 'bundle-1', entryName: 'page-entry' },
-			}),
-			expect.objectContaining({
-				filepath: '/test/project/.eco/public/assets/lazy-entry-def456.js',
-				excludeFromHtml: true,
-				groupedBundle: { id: 'bundle-1', entryName: 'lazy-entry' },
-			}),
-		]);
-
-		expect(fileSystem.write).toHaveBeenCalledTimes(2);
-		expect(fileSystem.remove).toHaveBeenCalledTimes(1);
-	});
-
-	test('processGrouped should fall back to per-entry processing when bundling is disabled', async () => {
-		const processor = new ContentScriptProcessor({ appConfig: createMockConfig() });
-		const processSpy = vi.spyOn(processor, 'process').mockResolvedValueOnce({
-			kind: 'script',
-			inline: false,
-			filepath: '/tmp/first.js',
-		}).mockResolvedValueOnce({
-			kind: 'script',
-			inline: false,
-			filepath: '/tmp/second.js',
-		});
-
-		const results = await processor.processGrouped([
-			{
-				kind: 'script',
-				source: 'content',
-				content: 'console.log("first")',
-				bundle: false,
-			},
-			{
-				kind: 'script',
-				source: 'content',
-				content: 'console.log("second")',
-				bundle: false,
-			},
-		]);
-
-		expect(processSpy).toHaveBeenCalledTimes(2);
-		expect(results).toHaveLength(2);
-	});
-
-	test('processGrouped should remove temporary entries when bundling fails', async () => {
-		const processor = new TestContentScriptProcessor({ appConfig: createMockConfig() });
-		processor.bundleScriptsError = new Error('bundle failed');
-
-		await expect(
-			processor.processGrouped([
-				{
-					kind: 'script',
-					source: 'content',
-					content: 'console.log("grouped")',
-					groupedBundle: { id: 'bundle-1', entryName: 'page-entry' },
-				},
-			]),
-		).rejects.toThrow('bundle failed');
-
-		expect(fileSystem.remove).toHaveBeenCalledTimes(1);
-	});
-});

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

@@ -1,134 +0,0 @@
-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,
-				};
-			});
-		} 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,
-			};
-
-			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,
-			};
-
-			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

@@ -1,326 +0,0 @@
-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');
-		});
-	});
-});