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

package/src/adapters/shared/hmr-manager.contract.test.ts

@@ -1,232 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, test, vi } from 'vitest';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import { resolveInternalWorkDir } from '../../utils/resolve-work-dir.ts';
-import { NodeHmrManager } from '../node/node-hmr-manager.ts';
-import { HmrManager as BunHmrManager } from '../bun/hmr-manager.ts';
-
-type SharedHmrManager = {
-	handleFileChange(filePath: string, options?: { broadcast?: boolean }): Promise<void>;
-	registerEntrypoint(entrypointPath: string): Promise<string>;
-	registerScriptEntrypoint(entrypointPath: string): Promise<string>;
-	registerSpecifierMap(map: Record<string, string>): void;
-	getWatchedFiles(): Map<string, string>;
-	getSpecifierMap(): Map<string, string>;
-	stop(): void;
-	appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
-};
-
-const tempRoots: string[] = [];
-
-function createTempRoot(prefix: string): string {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-	tempRoots.push(root);
-	return root;
-}
-
-afterEach(() => {
-	for (const root of tempRoots.splice(0)) {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-	vi.restoreAllMocks();
-});
-
-const runtimes = [
-	{
-		name: 'node',
-		async create(rootDir: string): Promise<SharedHmrManager> {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new NodeHmrManager({
-				appConfig: config,
-				bridge: {
-					subscriberCount: 0,
-					broadcast: () => {},
-				} as any,
-			});
-		},
-	},
-	{
-		name: 'bun',
-		async create(rootDir: string): Promise<SharedHmrManager> {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new BunHmrManager({
-				appConfig: config,
-				bridge: {
-					subscriberCount: 0,
-					broadcast: () => {},
-					subscribe: () => {},
-					unsubscribe: () => {},
-				} as any,
-			});
-		},
-	},
-] as const;
-
-function getEntrypointOutputPath(manager: SharedHmrManager, entrypointPath: string): string {
-	const relativePathJs = path
-		.relative(manager.appConfig.absolutePaths.srcDir, entrypointPath)
-		.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
-	const encodedPathJs = relativePathJs.replace(/\[([^\]]+)\]/g, '_$1_');
-	return path.join(resolveInternalWorkDir(manager.appConfig), 'assets', '_hmr', encodedPathJs);
-}
-
-describe.each(runtimes)('shared HMR manager contract: $name', ({ create }) => {
-	test('shares one in-flight entrypoint registration across concurrent callers', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-register');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-lab.tsx');
-		fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = getEntrypointOutputPath(manager, entrypointPath);
-
-		const handleFileChange = vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {
-			await new Promise((resolve) => setTimeout(resolve, 25));
-			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-			fs.writeFileSync(outputPath, 'export default 1;', 'utf8');
-		});
-
-		const [firstUrl, secondUrl] = await Promise.all([
-			manager.registerEntrypoint(entrypointPath),
-			manager.registerEntrypoint(entrypointPath),
-		]);
-
-		assert.equal(firstUrl, '/assets/_hmr/pages/react-lab.js');
-		assert.equal(secondUrl, '/assets/_hmr/pages/react-lab.js');
-		assert.equal(handleFileChange.mock.calls.length, 1);
-
-		manager.stop();
-	});
-
-	test('fails strict page registration when no integration emits output', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-strict-fail');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-content.mdx');
-		fs.writeFileSync(entrypointPath, '# Hello', 'utf8');
-
-		const manager = await create(rootDir);
-		vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {});
-
-		await assert.rejects(() => manager.registerEntrypoint(entrypointPath), /Integration failed to emit entrypoint/);
-		assert.equal(manager.getWatchedFiles().has(path.resolve(entrypointPath)), false);
-
-		manager.stop();
-	});
-
-	test('uses the generic build path for explicit script entrypoints', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-script-register');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const entrypointPath = path.join(srcDir, 'script.ts');
-		fs.writeFileSync(entrypointPath, 'console.log("hello");', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = path.join(resolveInternalWorkDir(manager.appConfig), 'assets', '_hmr', 'script.js');
-		const buildCalls: string[] = [];
-		manager.appConfig.runtime!.buildExecutor = {
-			build: vi.fn(async (options) => {
-				buildCalls.push(options.entrypoints[0] as string);
-				fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-				fs.writeFileSync(outputPath, 'fresh-output', 'utf8');
-				return {
-					success: true,
-					logs: [],
-					outputs: [{ path: outputPath }],
-				};
-			}),
-		};
-
-		const outputUrl = await manager.registerScriptEntrypoint(entrypointPath);
-
-		assert.equal(outputUrl, '/assets/_hmr/script.js');
-		assert.deepEqual(buildCalls, [entrypointPath]);
-		assert.equal(fs.readFileSync(outputPath, 'utf8'), 'fresh-output');
-
-		manager.stop();
-	});
-
-	test('registering one script entrypoint does not rebuild previously watched script entrypoints', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-script-targeted-register');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-
-		const firstEntrypoint = path.join(srcDir, 'first.script.ts');
-		const secondEntrypoint = path.join(srcDir, 'second.script.ts');
-		fs.writeFileSync(firstEntrypoint, 'console.log("first");', 'utf8');
-		fs.writeFileSync(secondEntrypoint, 'console.log("second");', 'utf8');
-
-		const manager = await create(rootDir);
-		const buildCalls: string[][] = [];
-		manager.appConfig.runtime!.buildExecutor = {
-			build: vi.fn(async (options) => {
-				const entrypoints = (options.entrypoints as string[]).map(String);
-				buildCalls.push(entrypoints);
-				for (const entrypoint of entrypoints) {
-					const relativePathJs = path
-						.relative(path.join(rootDir, 'src'), entrypoint)
-						.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
-					const outputPath = path.join(
-						resolveInternalWorkDir(manager.appConfig),
-						'assets',
-						'_hmr',
-						relativePathJs,
-					);
-					fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-					fs.writeFileSync(outputPath, `output:${path.basename(entrypoint)}`, 'utf8');
-				}
-				return {
-					success: true,
-					logs: [],
-					outputs: entrypoints.map((entrypoint) => ({
-						path: path.join(
-							resolveInternalWorkDir(manager.appConfig),
-							'assets',
-							'_hmr',
-							path.relative(path.join(rootDir, 'src'), entrypoint).replace(/\.(tsx?|jsx?|mdx?)$/, '.js'),
-						),
-					})),
-				};
-			}),
-		};
-
-		await manager.registerScriptEntrypoint(firstEntrypoint);
-		await manager.registerScriptEntrypoint(secondEntrypoint);
-
-		assert.deepEqual(buildCalls, [[firstEntrypoint], [secondEntrypoint]]);
-
-		manager.stop();
-	});
-
-	test('stop clears retained registration state', async () => {
-		const rootDir = createTempRoot('ecopages-hmr-contract-stop');
-		const pagesDir = path.join(rootDir, 'src', 'pages');
-		fs.mkdirSync(pagesDir, { recursive: true });
-
-		const entrypointPath = path.join(pagesDir, 'react-content.tsx');
-		fs.writeFileSync(entrypointPath, 'export default function Page() { return null; }', 'utf8');
-
-		const manager = await create(rootDir);
-		const outputPath = getEntrypointOutputPath(manager, entrypointPath);
-
-		vi.spyOn(manager, 'handleFileChange').mockImplementation(async () => {
-			fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-			fs.writeFileSync(outputPath, 'export default 1;', 'utf8');
-		});
-
-		manager.registerSpecifierMap({ react: '/assets/vendors/react.js' });
-		await manager.registerEntrypoint(entrypointPath);
-
-		manager.stop();
-
-		assert.equal(manager.getWatchedFiles().size, 0);
-		assert.equal(manager.getSpecifierMap().size, 0);
-	});
-});

package/src/adapters/shared/hmr-manager.dispatch.test.ts

@@ -1,220 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, test } from 'vitest';
-import { ConfigBuilder } from '../../config/config-builder.ts';
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../../hmr/hmr-strategy.ts';
-import type { ClientBridgeEvent } from '../../types/public-types.ts';
-import { HmrManager as BunHmrManager } from '../bun/hmr-manager.ts';
-import { NodeHmrManager } from '../node/node-hmr-manager.ts';
-
-class FakeHmrStrategy extends HmrStrategy {
-	readonly type: HmrStrategyType;
-	private readonly _matches: (filePath: string) => boolean;
-	private readonly _action: HmrAction;
-
-	constructor(type: HmrStrategyType, matchFn: (f: string) => boolean, action: HmrAction) {
-		super();
-		this.type = type;
-		this._matches = matchFn;
-		this._action = action;
-	}
-
-	matches(filePath: string): boolean {
-		return this._matches(filePath);
-	}
-
-	async process(_filePath: string): Promise<HmrAction> {
-		return this._action;
-	}
-}
-
-type BridgeSpy = {
-	broadcasts: ClientBridgeEvent[];
-	bridge: {
-		subscriberCount: number;
-		broadcast(event: ClientBridgeEvent): void;
-		subscribe(): void;
-		unsubscribe(): void;
-	};
-};
-
-function createBridgeSpy(): BridgeSpy {
-	const broadcasts: ClientBridgeEvent[] = [];
-	const bridge = {
-		subscriberCount: 0,
-		broadcast(event: ClientBridgeEvent) {
-			broadcasts.push(event);
-		},
-		subscribe() {},
-		unsubscribe() {},
-	};
-	return { broadcasts, bridge };
-}
-
-const tempRoots: string[] = [];
-
-function createTempRoot(prefix: string): string {
-	const root = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
-	tempRoots.push(root);
-	return root;
-}
-
-afterEach(() => {
-	for (const root of tempRoots.splice(0)) {
-		fs.rmSync(root, { recursive: true, force: true });
-	}
-});
-
-const runtimes = [
-	{
-		name: 'node',
-		async create(rootDir: string, bridgeSpy: BridgeSpy) {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new NodeHmrManager({ appConfig: config, bridge: bridgeSpy.bridge as any });
-		},
-	},
-	{
-		name: 'bun',
-		async create(rootDir: string, bridgeSpy: BridgeSpy) {
-			const config = await new ConfigBuilder().setRootDir(rootDir).build();
-			return new BunHmrManager({ appConfig: config, bridge: bridgeSpy.bridge as any });
-		},
-	},
-] as const;
-
-describe.each(runtimes)('handleFileChange dispatch: $name', ({ create }) => {
-	test('CSS file change routes to DefaultHmrStrategy and broadcasts reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-css');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const cssFile = path.join(rootDir, 'src', 'styles', 'main.css');
-		await manager.handleFileChange(cssFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-		assert.equal(spy.broadcasts[0].path, cssFile);
-
-		manager.stop();
-	});
-
-	test('HTML file change routes to DefaultHmrStrategy and broadcasts reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-html');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const htmlFile = path.join(rootDir, 'src', 'pages', 'index.html');
-		await manager.handleFileChange(htmlFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-		assert.equal(spy.broadcasts[0].path, htmlFile);
-
-		manager.stop();
-	});
-
-	test('TS file with no registered entrypoints falls back to DefaultHmrStrategy reload', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-ts-fallback');
-		const srcDir = path.join(rootDir, 'src');
-		fs.mkdirSync(srcDir, { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const tsFile = path.join(srcDir, 'component.ts');
-		await manager.handleFileChange(tsFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.equal(spy.broadcasts[0].type, 'reload');
-
-		manager.stop();
-	});
-
-	test('broadcast:false suppresses events even when the strategy returns a broadcast action', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-no-broadcast');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const cssFile = path.join(rootDir, 'src', 'main.css');
-		await manager.handleFileChange(cssFile, { broadcast: false });
-
-		assert.equal(spy.broadcasts.length, 0);
-
-		manager.stop();
-	});
-
-	test('INTEGRATION strategy wins over DefaultHmrStrategy for matched files', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-integration-priority');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'component.jsx');
-		const integrationEvent: ClientBridgeEvent = {
-			type: 'update',
-			path: '/assets/_hmr/component.js',
-			timestamp: 1,
-		};
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, {
-				type: 'broadcast',
-				events: [integrationEvent],
-			}),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 1);
-		assert.deepEqual(spy.broadcasts[0], integrationEvent);
-
-		manager.stop();
-	});
-
-	test('action.type none suppresses broadcast even when shouldBroadcast is true', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-none-action');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'silent.ts');
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, { type: 'none' }),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 0);
-
-		manager.stop();
-	});
-
-	test('all events returned by a strategy are each broadcast individually', async () => {
-		const rootDir = createTempRoot('ecopages-dispatch-multi-event');
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-		const spy = createBridgeSpy();
-		const manager = await create(rootDir, spy);
-
-		const customFile = path.join(rootDir, 'src', 'multi.ts');
-		const events: ClientBridgeEvent[] = [
-			{ type: 'update', path: '/assets/_hmr/a.js', timestamp: 1 },
-			{ type: 'update', path: '/assets/_hmr/b.js', timestamp: 2 },
-		];
-		manager.registerStrategy(
-			new FakeHmrStrategy(HmrStrategyType.INTEGRATION, (f) => f === customFile, {
-				type: 'broadcast',
-				events,
-			}),
-		);
-
-		await manager.handleFileChange(customFile);
-
-		assert.equal(spy.broadcasts.length, 2);
-		assert.deepEqual(spy.broadcasts, events);
-
-		manager.stop();
-	});
-});

package/src/adapters/shared/render-context.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createRenderContext } from './render-context.ts';
-import type { IntegrationPlugin } from '../../plugins/integration-plugin.ts';
-import type { IntegrationRenderer } from '../../route-renderer/orchestration/integration-renderer.ts';
-import type { EcoFunctionComponent } from '../../types/public-types.ts';
-
-describe('createRenderContext', () => {
-	const RenderToResponse = vi.fn(() => Promise.resolve(new Response('rendered')));
-	const rendererModules = {
-		integrationManifestModuleId: 'virtual:ecopages/integration-manifest.ts',
-	};
-
-	const Renderer = {
-		name: '-renderer',
-		renderToResponse: RenderToResponse,
-	} as unknown as IntegrationRenderer;
-
-	const ExplicitRenderer = {
-		name: 'explicit-renderer',
-		renderToResponse: RenderToResponse,
-	} as unknown as IntegrationRenderer;
-
-	const InitializeRenderer = vi.fn(() => Renderer);
-
-	const Plugin = {
-		name: '-integration',
-		initializeRenderer: InitializeRenderer,
-	} as unknown as IntegrationPlugin;
-
-	const ExplicitInitializeRenderer = vi.fn(() => ExplicitRenderer);
-
-	const ExplicitPlugin = {
-		name: 'explicit-renderer',
-		initializeRenderer: ExplicitInitializeRenderer,
-	} as unknown as IntegrationPlugin;
-
-	const ViewFn = ((props: { foo: string }) => `<div>${props.foo}</div>`) as EcoFunctionComponent<
-		{ foo: string },
-		string
-	>;
-	ViewFn.config = {
-		__eco: {
-			id: 'test',
-			file: '/some/dir/-view.ts',
-			integration: '-integration',
-		},
-	};
-
-	const renderContext = createRenderContext({
-		integrations: [Plugin, ExplicitPlugin],
-		rendererModules,
-	});
-
-	it('should create a render context with methods', () => {
-		expect(renderContext.render).toBeDefined();
-		expect(renderContext.renderPartial).toBeDefined();
-		expect(renderContext.json).toBeDefined();
-		expect(renderContext.html).toBeDefined();
-	});
-
-	describe('render', () => {
-		it('should call renderer.renderToResponse with partial: false', async () => {
-			RenderToResponse.mockClear();
-			InitializeRenderer.mockClear();
-			ExplicitInitializeRenderer.mockClear();
-			const props = { foo: 'bar' };
-			const options = { status: 201, headers: { 'X-Custom': '1' } };
-
-			const response = await renderContext.render(ViewFn, props, options);
-
-			expect(InitializeRenderer).toHaveBeenCalledWith({ rendererModules });
-			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
-				partial: false,
-				status: 201,
-				headers: { 'X-Custom': '1' },
-			});
-			expect(response instanceof Response).toBe(true);
-		});
-
-		it('should throw if view integration is unknown', async () => {
-			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			badViewFn.config = { __eco: { id: 'test', file: '/bad-view.ts', integration: 'unknown' } };
-			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('No integration found for: unknown');
-		});
-
-		it('should throw if view integration is missing', async () => {
-			const badViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			badViewFn.config = { __eco: undefined };
-			await expect(renderContext.render(badViewFn, {})).rejects.toThrow('Cannot determine integration for view');
-		});
-
-		it('should prefer explicit config.integration over injected metadata', async () => {
-			RenderToResponse.mockClear();
-			InitializeRenderer.mockClear();
-			ExplicitInitializeRenderer.mockClear();
-
-			const explicitViewFn = (() => '<div></div>') as EcoFunctionComponent<{}, string>;
-			explicitViewFn.config = {
-				integration: 'explicit-renderer',
-				__eco: { id: 'test', file: '/some/file.tsx', integration: '-integration' },
-			};
-
-			await renderContext.render(explicitViewFn, {});
-
-			expect(ExplicitInitializeRenderer).toHaveBeenCalled();
-			expect(InitializeRenderer).not.toHaveBeenCalled();
-		});
-	});
-
-	describe('renderPartial', () => {
-		it('should call renderer.renderToResponse with partial: true', async () => {
-			RenderToResponse.mockClear();
-			const props = { foo: 'bar' };
-			const options = { status: 200 };
-
-			await renderContext.renderPartial(ViewFn, props, options);
-
-			expect(InitializeRenderer).toHaveBeenCalled();
-			expect(RenderToResponse).toHaveBeenCalledWith(ViewFn, props, {
-				partial: true,
-				status: 200,
-				headers: undefined,
-			});
-		});
-	});
-
-	describe('json', () => {
-		it('should return a JSON response', async () => {
-			const data = { hello: 'world' };
-			const response = renderContext.json(data);
-			expect(response.headers.get('Content-Type')).toContain('application/json');
-			expect(await response.json()).toEqual(data);
-		});
-
-		it('should support custom status and headers', async () => {
-			const response = renderContext.json({}, { status: 201, headers: { 'X-Test': 'true' } });
-			expect(response.status).toBe(201);
-			expect(response.headers.get('X-Test')).toBe('true');
-		});
-	});
-
-	describe('html', () => {
-		it('should return an HTML response', async () => {
-			const html = '<div>hello</div>';
-			const response = renderContext.html(html);
-			expect(response.headers.get('Content-Type')).toContain('text/html');
-			expect(await response.text()).toBe(html);
-		});
-	});
-});