@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

package/src/route-renderer/page-loading/page-module-loader.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { PageModuleLoaderService } from './page-module-loader.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import type { EcoPageFile } from '../../public-types.ts';
-import type { EcoPageComponent } from '../../eco/eco.types.ts';
-
-describe('PageModuleLoaderService', () => {
-	const appConfig = {
-		defaultMetadata: {
-			title: 'Default title',
-			description: 'Default description',
-		},
-	} as EcoPagesAppConfig;
-
-	it('should resolve static props via getStaticPropsForPage', async () => {
-		const service = new PageModuleLoaderService(appConfig, 'http://localhost:3000');
-		const result = await service.getStaticPropsForPage({
-			getStaticProps: async () => ({
-				props: { title: 'Page title' },
-			}),
-			params: { slug: 'a' },
-		});
-
-		expect(result.props).toEqual({ title: 'Page title' });
-	});
-
-	it('should merge default and dynamic metadata', async () => {
-		const service = new PageModuleLoaderService(appConfig, 'http://localhost:3000');
-		const metadata = await service.getMetadataPropsForPage({
-			getMetadata: async ({ props }) => ({
-				title: String(props.title),
-				description: 'Dynamic description',
-			}),
-			context: {
-				props: { title: 'Dynamic title' },
-				appConfig,
-				params: {},
-				query: {},
-			},
-		});
-
-		expect(metadata).toEqual({
-			title: 'Dynamic title',
-			description: 'Dynamic description',
-		});
-	});
-
-	it('should resolve page module using provided importer and prefer component static exports', async () => {
-		const service = new PageModuleLoaderService(appConfig, 'http://localhost:3000');
-		const Page = (() => 'ok') as EcoPageComponent<any>;
-		Page.staticProps = async () => ({ props: { from: 'component-static' } });
-		Page.metadata = async () => ({
-			title: 'component-metadata',
-			description: 'component-description',
-		});
-
-		const module = {
-			default: Page,
-			getStaticProps: async () => ({ props: { from: 'module-static' } }),
-			getMetadata: async () => ({ title: 'module-metadata' }),
-			extra: 'integration-value',
-		} as unknown as EcoPageFile;
-
-		const result = await service.resolvePageModule({
-			file: '/app/pages/index.tsx',
-			importPageFileFn: async () => module,
-		});
-
-		expect(result.getStaticProps).toBe(Page.staticProps);
-		expect(result.getMetadata).toBe(Page.metadata);
-		expect(result.integrationSpecificProps).toEqual({ extra: 'integration-value' });
-	});
-
-	it('should resolve page data end-to-end', async () => {
-		const service = new PageModuleLoaderService(appConfig, 'http://localhost:3000');
-		const result = await service.resolvePageData({
-			pageModule: {
-				getStaticProps: async () => ({ props: { title: 'From props' } }),
-				getMetadata: async ({ props }) => ({
-					title: String(props.title),
-					description: 'From metadata',
-				}),
-			},
-			routeOptions: {
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-			},
-		});
-
-		expect(result).toEqual({
-			props: { title: 'From props' },
-			metadata: { title: 'From props', description: 'From metadata' },
-		});
-	});
-});

package/src/router/client/navigation-coordinator.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getEcoNavigationRuntime } from './navigation-coordinator.ts';
-
-function createWindowLike() {
-	return {} as Window &
-		typeof globalThis & {
-			__ECO_PAGES__?: { navigation?: ReturnType<typeof getEcoNavigationRuntime> };
-		};
-}
-
-describe('getEcoNavigationRuntime', () => {
-	it('returns the same coordinator instance for the same window', () => {
-		const windowLike = createWindowLike();
-		const first = getEcoNavigationRuntime(windowLike);
-		const second = getEcoNavigationRuntime(windowLike);
-
-		expect(first).toBe(second);
-	});
-
-	it('tracks explicit ownership claims', () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-
-		runtime.claimOwnership('react-router');
-
-		expect(runtime.getOwnerState()).toEqual({
-			owner: 'react-router',
-			canHandleSpaNavigation: false,
-		});
-	});
-
-	it('shares one navigation transaction sequence across runtimes', () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-
-		const first = runtime.beginNavigationTransaction();
-		expect(runtime.hasPendingNavigationTransaction()).toBe(true);
-		expect(first.isCurrent()).toBe(true);
-		expect(first.signal.aborted).toBe(false);
-
-		const second = runtime.beginNavigationTransaction();
-
-		expect(first.isCurrent()).toBe(false);
-		expect(first.signal.aborted).toBe(true);
-		expect(second.isCurrent()).toBe(true);
-		expect(second.signal.aborted).toBe(false);
-		second.complete();
-		expect(runtime.hasPendingNavigationTransaction()).toBe(false);
-	});
-
-	it('cancels only the current navigation transaction', () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-
-		const first = runtime.beginNavigationTransaction();
-		const second = runtime.beginNavigationTransaction();
-
-		first.cancel();
-		expect(second.isCurrent()).toBe(true);
-		expect(second.signal.aborted).toBe(false);
-
-		second.cancel();
-		expect(second.isCurrent()).toBe(false);
-		expect(second.signal.aborted).toBe(true);
-		expect(runtime.hasPendingNavigationTransaction()).toBe(false);
-	});
-
-	it('adopts ownership from the rendered document marker', () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const documentLike = {
-			documentElement: {
-				getAttribute: vi.fn(() => 'custom-router'),
-			},
-		} as unknown as Document;
-
-		expect(runtime.adoptDocumentOwner(documentLike, 'browser-router')).toBe('custom-router');
-		expect(runtime.getOwnerState().owner).toBe('custom-router');
-	});
-
-	it('delegates navigation to another registered runtime when the source cannot handle it', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const navigateSpy = vi.fn(async () => true);
-
-		runtime.register({ owner: 'browser-router', navigate: navigateSpy });
-		runtime.register({ owner: 'react-router', navigate: vi.fn(async () => true) });
-		runtime.claimOwnership('react-router');
-
-		const handled = await runtime.requestNavigation({
-			href: '/docs',
-			direction: 'forward',
-			source: 'react-router',
-		});
-
-		expect(handled).toBe(true);
-		expect(navigateSpy).toHaveBeenCalledWith({
-			href: '/docs',
-			direction: 'forward',
-			source: 'react-router',
-		});
-	});
-
-	it('delegates a fetched document handoff to the targeted runtime without forcing source cleanup first', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const cleanupSpy = vi.fn(async () => undefined);
-		const handoffSpy = vi.fn(async () => true);
-		const documentLike = {
-			documentElement: {
-				getAttribute: vi.fn(() => null),
-			},
-		} as unknown as Document;
-
-		runtime.register({ owner: 'react-router', cleanupBeforeHandoff: cleanupSpy });
-		runtime.register({ owner: 'browser-router', handoffNavigation: handoffSpy });
-		runtime.claimOwnership('react-router');
-
-		const handled = await runtime.requestHandoff({
-			href: '/docs',
-			finalHref: '/docs',
-			direction: 'forward',
-			source: 'react-router',
-			targetOwner: 'browser-router',
-			document: documentLike,
-		});
-
-		expect(handled).toBe(true);
-		expect(cleanupSpy).not.toHaveBeenCalled();
-		expect(handoffSpy).toHaveBeenCalledWith({
-			href: '/docs',
-			finalHref: '/docs',
-			direction: 'forward',
-			source: 'react-router',
-			targetOwner: 'browser-router',
-			document: documentLike,
-		});
-	});
-
-	it('ignores stale handoff requests before cleaning up the active owner', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const cleanupSpy = vi.fn(async () => undefined);
-		const handoffSpy = vi.fn(async () => true);
-		const documentLike = {
-			documentElement: {
-				getAttribute: vi.fn(() => null),
-			},
-		} as unknown as Document;
-
-		runtime.register({ owner: 'react-router', cleanupBeforeHandoff: cleanupSpy });
-		runtime.register({ owner: 'browser-router', handoffNavigation: handoffSpy });
-		runtime.claimOwnership('react-router');
-
-		const handled = await runtime.requestHandoff({
-			href: '/docs',
-			finalHref: '/docs',
-			direction: 'forward',
-			source: 'react-router',
-			targetOwner: 'browser-router',
-			document: documentLike,
-			isStaleSourceNavigation: () => true,
-		});
-
-		expect(handled).toBe(true);
-		expect(cleanupSpy).not.toHaveBeenCalled();
-		expect(handoffSpy).not.toHaveBeenCalled();
-		expect(runtime.getOwnerState().owner).toBe('react-router');
-	});
-
-	it('reloads the current owner through its registration', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const reloadSpy = vi.fn(async () => undefined);
-
-		runtime.register({ owner: 'react-router', reloadCurrentPage: reloadSpy });
-		runtime.claimOwnership('react-router');
-
-		const handled = await runtime.reloadCurrentPage({ clearCache: true, source: 'browser-router' });
-
-		expect(handled).toBe(true);
-		expect(reloadSpy).toHaveBeenCalledWith({ clearCache: true, source: 'browser-router' });
-	});
-
-	it('reloads the current owner even when the request source matches that owner', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const reloadSpy = vi.fn(async () => undefined);
-
-		runtime.register({ owner: 'react-router', reloadCurrentPage: reloadSpy });
-		runtime.claimOwnership('react-router');
-
-		const handled = await runtime.reloadCurrentPage({ clearCache: false, source: 'react-router' });
-
-		expect(handled).toBe(true);
-		expect(reloadSpy).toHaveBeenCalledWith({ clearCache: false, source: 'react-router' });
-	});
-
-	it('cleans up an explicit owner via its registration', async () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const cleanupSpy = vi.fn();
-
-		runtime.register({ owner: 'react-router', cleanupBeforeHandoff: cleanupSpy });
-		runtime.claimOwnership('react-router');
-
-		await runtime.cleanupOwner('react-router');
-
-		expect(cleanupSpy).toHaveBeenCalledTimes(1);
-		expect(runtime.getOwnerState().owner).toBe('none');
-	});
-
-	it('emits events for registrations and ownership changes', () => {
-		const windowLike = createWindowLike();
-		const runtime = getEcoNavigationRuntime(windowLike);
-		const listener = vi.fn();
-		const unsubscribe = runtime.subscribe(listener);
-
-		const unregister = runtime.register({ owner: 'custom-router' });
-		runtime.claimOwnership('custom-router');
-		runtime.releaseOwnership('custom-router');
-		unregister();
-		unsubscribe();
-
-		expect(listener).toHaveBeenCalledWith({
-			type: 'registration-change',
-			owner: 'custom-router',
-			status: 'registered',
-		});
-		expect(listener).toHaveBeenCalledWith({
-			type: 'owner-change',
-			owner: 'custom-router',
-			previousOwner: 'none',
-			reason: 'claim',
-		});
-	});
-});

package/src/router/server/fs-router-scanner.test.ts

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'vitest';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import { FSRouterScanner } from './fs-router-scanner.ts';
-
-test('FSRouterScanner scans dynamic routes in Node when module graph needs transpilation', async () => {
-	if (typeof Bun !== 'undefined') {
-		// This test expects Node's missing Bun global to trigger Esbuild transpilation. Skip in Bun runner.
-		return;
-	}
-
-	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ecopages-fs-router-scanner-node-'));
-	const pagesDir = path.join(rootDir, 'src', 'pages');
-	const dynamicDir = path.join(pagesDir, 'dynamic');
-	const distDir = path.join(rootDir, 'dist');
-	const workDir = path.join(rootDir, '.eco');
-
-	try {
-		fs.mkdirSync(dynamicDir, { recursive: true });
-		fs.mkdirSync(path.join(rootDir, 'src'), { recursive: true });
-
-		fs.writeFileSync(
-			path.join(rootDir, 'src', 'decorated.ts'),
-			[
-				'function sealed<T extends new (...args: never[]) => object>(target: T) {',
-				'\treturn target;',
-				'}',
-				'@sealed',
-				'export class DecoratedModule {}',
-			].join('\n'),
-		);
-
-		fs.writeFileSync(
-			path.join(dynamicDir, '[slug].kita.tsx'),
-			[
-				"import '../../decorated.ts';",
-				'',
-				'export const getStaticPaths = async () => ({',
-				"\tpaths: [{ params: { slug: 'hello-world' } }],",
-				'});',
-				'',
-				'export const getStaticProps = async () => ({ props: {} });',
-				'',
-				'export default async function Page() {',
-				"\treturn '<div>Hello</div>';",
-				'}',
-			].join('\n'),
-		);
-
-		const scanner = new FSRouterScanner({
-			dir: pagesDir,
-			origin: 'http://localhost:3000',
-			templatesExt: ['.kita.tsx'],
-			options: {
-				buildMode: false,
-			},
-			appConfig: {
-				rootDir,
-				workDir: '.eco',
-				absolutePaths: {
-					distDir,
-					workDir,
-				},
-			} as unknown as EcoPagesAppConfig,
-		});
-
-		const routes = await scanner.scan();
-
-		assert.equal(routes['http://localhost:3000/dynamic/hello-world']?.kind, 'dynamic');
-		assert.equal(routes['http://localhost:3000/dynamic/hello-world']?.pathname, '/dynamic/[slug]');
-
-		const transpiledModulesDir = path.join(workDir, '.server-route-modules');
-		assert.equal(fs.existsSync(transpiledModulesDir), true);
-
-		const transpiledFiles = fs.readdirSync(transpiledModulesDir).filter((file) => file.endsWith('.js'));
-		assert.ok(transpiledFiles.length > 0);
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});

package/src/router/server/fs-router.test.ts

@@ -1,214 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import { FIXTURE_APP_PROJECT_DIR } from '../../../__fixtures__/constants.js';
-import { ConfigBuilder } from '../../config/config-builder.js';
-import type { Route, Routes } from '../../internal-types.js';
-import { FSRouter } from './fs-router.ts';
-import { FSRouterScanner } from './fs-router-scanner.ts';
-
-const {
-	templatesExt,
-	absolutePaths: { pagesDir, distDir },
-} = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
-
-const scanner = new FSRouterScanner({
-	dir: pagesDir,
-	appConfig: {
-		absolutePaths: {
-			distDir,
-		},
-	} as any,
-	origin: 'http://localhost:3000',
-	templatesExt,
-	options: {
-		buildMode: false,
-	},
-});
-
-const router = new FSRouter({
-	origin: 'http://localhost:3000',
-	assetPrefix: distDir,
-	scanner,
-});
-
-await router.init();
-
-describe('FSRouter', async () => {
-	describe('init', async () => {
-		test('should scan and return routes', async () => {
-			expect(Object.keys(router.routes).sort()).toEqual([
-				'http://localhost:3000/',
-				'http://localhost:3000/404',
-				'http://localhost:3000/catch-all/[...path]',
-				'http://localhost:3000/dynamic/another-blog-post',
-				'http://localhost:3000/dynamic/blog-post',
-				'http://localhost:3000/postcss-hmr',
-			]);
-		});
-	});
-
-	describe('getDynamicParams', async () => {
-		test.each([
-			['/products/[id]', '/products/123', { id: '123' }],
-			['/products/[id]', '/products/123/456', { id: '123' }],
-			['/products/[id]', '/products/123/456/789', { id: '123' }],
-		])(
-			'dynamic route %p with URL %p should have dynamic params %p',
-			async (dynamicPathname, pathname, expected) => {
-				const route: Route = {
-					filePath: '',
-					kind: 'dynamic',
-					pathname: dynamicPathname,
-				};
-				const params = router.getDynamicParams(route, pathname);
-
-				expect(params).toEqual(expected);
-			},
-		);
-
-		test.each([
-			['/products/[...id]', '/products/123/456/789', { id: ['123', '456', '789'] }],
-			['/products/[...id]', '/products/123', { id: ['123'] }],
-			['/products/[...id]', '/products', { id: [] }],
-		])(
-			'catch-all route %p with URL %p should have dynamic params %p',
-			async (catchAllRoute, pathname, expected) => {
-				const route: Route = {
-					filePath: '',
-					kind: 'dynamic',
-					pathname: catchAllRoute,
-				};
-				const params = router.getDynamicParams(route, pathname);
-
-				expect(params).toEqual(expected);
-			},
-		);
-	});
-
-	describe('getSearchParams', () => {
-		test('should extract query parameters from URL', () => {
-			const url = new URL('http://localhost:3000/page?foo=bar&baz=qux');
-			const params = router.getSearchParams(url);
-
-			expect(params).toEqual({ foo: 'bar', baz: 'qux' });
-		});
-
-		test('should return empty object for URL without query params', () => {
-			const url = new URL('http://localhost:3000/page');
-			const params = router.getSearchParams(url);
-
-			expect(params).toEqual({});
-		});
-	});
-
-	describe('match', () => {
-		const createRouterWithRoutes = (routes: Routes) => {
-			const Scanner = { scan: async () => routes } as unknown as FSRouterScanner;
-			const testRouter = new FSRouter({
-				origin: 'http://localhost:3000',
-				assetPrefix: '/dist',
-				scanner: Scanner,
-			});
-			testRouter.routes = routes;
-			return testRouter;
-		};
-
-		test('should match exact route', () => {
-			const testRouter = createRouterWithRoutes({
-				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/about');
-
-			expect(result).not.toBeNull();
-			expect(result?.kind).toBe('exact');
-			expect(result?.pathname).toBe('/about');
-		});
-
-		test('should match exact route with trailing slash', () => {
-			const testRouter = createRouterWithRoutes({
-				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/about/');
-
-			expect(result).not.toBeNull();
-			expect(result?.kind).toBe('exact');
-		});
-
-		test('should match dynamic route', () => {
-			const testRouter = createRouterWithRoutes({
-				'/dynamic/[id]': { filePath: '/pages/dynamic/[id].ts', kind: 'dynamic', pathname: '/dynamic/[id]' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/dynamic/123');
-
-			expect(result).not.toBeNull();
-			expect(result?.kind).toBe('dynamic');
-			expect(result?.params).toEqual({ id: '123' });
-		});
-
-		test('should match catch-all route', () => {
-			const testRouter = createRouterWithRoutes({
-				'/catch-all/[...slug]': {
-					filePath: '/pages/catch-all/[...slug].ts',
-					kind: 'catch-all',
-					pathname: '/catch-all/[...slug]',
-				},
-			});
-
-			const result = testRouter.match('http://localhost:3000/catch-all/a/b/c');
-
-			expect(result).not.toBeNull();
-			expect(result?.kind).toBe('catch-all');
-			expect(result?.params).toEqual({ slug: ['a', 'b', 'c'] });
-		});
-
-		test('should include query params in match result', () => {
-			const testRouter = createRouterWithRoutes({
-				'/page': { filePath: '/pages/page.ts', kind: 'exact', pathname: '/page' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/page?sort=asc&page=2');
-
-			expect(result?.query).toEqual({ sort: 'asc', page: '2' });
-		});
-
-		test('should return null for non-matching route', () => {
-			const testRouter = createRouterWithRoutes({
-				'/about': { filePath: '/pages/about.ts', kind: 'exact', pathname: '/about' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/contact');
-
-			expect(result).toBeNull();
-		});
-
-		test('should prefer exact match over dynamic', () => {
-			const testRouter = createRouterWithRoutes({
-				'/blog/latest': { filePath: '/pages/blog/latest.ts', kind: 'exact', pathname: '/blog/latest' },
-				'/blog/[slug]': { filePath: '/pages/blog/[slug].ts', kind: 'dynamic', pathname: '/blog/[slug]' },
-			});
-
-			const result = testRouter.match('http://localhost:3000/blog/latest');
-
-			expect(result?.kind).toBe('exact');
-		});
-	});
-
-	describe('setOnReload and reload', () => {
-		test('should set and call onReload callback', async () => {
-			const Scanner = { scan: async () => ({}) } as unknown as FSRouterScanner;
-			const testRouter = new FSRouter({
-				origin: 'http://localhost:3000',
-				assetPrefix: '/dist',
-				scanner: Scanner,
-			});
-
-			const callback = vi.fn(() => {});
-			testRouter.setOnReload(callback);
-			testRouter.reload();
-
-			expect(callback).toHaveBeenCalledTimes(1);
-		});
-	});
-});