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

package/src/adapters/shared/application-adapter.ts

@@ -1,199 +0,0 @@
-import type {
-	ApiHandler,
-	ApiHandlerContext,
-	Middleware,
-	RouteGroupBuilder,
-	RouteOptions,
-	RouteSchema,
-} from '../../types/public-types.ts';
-import {
-	AbstractApplicationAdapter,
-	type ApplicationAdapterOptions,
-	type RouteGroupDefinition,
-	type RouteHandler,
-} from '../abstract/application-adapter.ts';
-
-export abstract class SharedApplicationAdapter<
-	TOptions extends ApplicationAdapterOptions = ApplicationAdapterOptions,
-	TServer = any,
-	TRequest extends Request = Request,
-> extends AbstractApplicationAdapter<TOptions, TServer, TRequest> {
-	protected register<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		method: ApiHandler['method'],
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.addRouteHandler(path, method, handler, options?.middleware, options?.schema);
-	}
-
-	get<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'GET', handler, options);
-	}
-
-	post<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'POST', handler, options);
-	}
-
-	put<P extends string, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'PUT', handler, options);
-	}
-
-	delete<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'DELETE', handler, options);
-	}
-
-	patch<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'PATCH', handler, options);
-	}
-
-	options<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'OPTIONS', handler, options);
-	}
-
-	head<
-		P extends string,
-		TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>,
-	>(
-		path: P,
-		handler: RouteHandler<TRequest, TServer, TContext>,
-		options?: RouteOptions<TRequest, TServer, TContext>,
-	): this {
-		return this.register(path, 'HEAD', handler, options);
-	}
-
-	route<P extends string>(
-		path: P,
-		method: ApiHandler['method'],
-		handler: RouteHandler<TRequest, TServer>,
-		options?: RouteOptions<TRequest, TServer>,
-	): this {
-		return this.register(path, method, handler, options);
-	}
-
-	add(handler: ApiHandler<string, TRequest, TServer>): this {
-		return this.addRouteHandler(handler.path, handler.method, handler.handler, handler.middleware, handler.schema);
-	}
-
-	group<TMiddleware extends readonly Middleware<TRequest, TServer, any>[] = []>(
-		prefixOrGroup: string | RouteGroupDefinition<TRequest, TServer>,
-		callback?: (
-			builder: TMiddleware extends readonly Middleware<TRequest, TServer, infer TContext>[]
-				? RouteGroupBuilder<TRequest, TServer, TContext>
-				: RouteGroupBuilder<TRequest, TServer>,
-		) => void,
-		options?: {
-			middleware?: TMiddleware;
-		},
-	): this {
-		if (typeof prefixOrGroup === 'object') {
-			return this.registerGroup(prefixOrGroup);
-		}
-
-		type TContext = TMiddleware extends readonly Middleware<TRequest, TServer, infer TCtx>[]
-			? TCtx
-			: ApiHandlerContext<TRequest, TServer>;
-
-		const normalizedPrefix = prefixOrGroup.endsWith('/') ? prefixOrGroup.slice(0, -1) : prefixOrGroup;
-		const groupMiddleware = (options?.middleware ?? []) as Middleware<TRequest, TServer, TContext>[];
-
-		const createHandler = (
-			method: ApiHandler['method'],
-		): RouteGroupBuilder<TRequest, TServer, TContext>[Lowercase<typeof method>] => {
-			return ((
-				path: string,
-				handler: (context: TContext) => Promise<Response> | Response,
-				routeOptions?: RouteOptions<TRequest, TServer, TContext> & { schema?: RouteSchema },
-			) => {
-				const combinedMiddleware: Middleware<TRequest, TServer, TContext>[] = [
-					...groupMiddleware,
-					...(routeOptions?.middleware ?? []),
-				];
-				const fullPath = path === '/' ? normalizedPrefix : `${normalizedPrefix}${path}`;
-				this.addRouteHandler(
-					fullPath,
-					method,
-					handler as RouteHandler<TRequest, TServer, ApiHandlerContext<TRequest, TServer>>,
-					combinedMiddleware.length > 0
-						? (combinedMiddleware as Middleware<TRequest, TServer, ApiHandlerContext<TRequest, TServer>>[])
-						: undefined,
-					routeOptions?.schema,
-				);
-				return builder;
-			}) as RouteGroupBuilder<TRequest, TServer, TContext>[Lowercase<typeof method>];
-		};
-
-		const builder: RouteGroupBuilder<TRequest, TServer, TContext> = {
-			get: createHandler('GET'),
-			post: createHandler('POST'),
-			put: createHandler('PUT'),
-			delete: createHandler('DELETE'),
-			patch: createHandler('PATCH'),
-			options: createHandler('OPTIONS'),
-			head: createHandler('HEAD'),
-		};
-
-		callback?.(builder as never);
-		return this;
-	}
-
-	private registerGroup(group: RouteGroupDefinition<TRequest, TServer>): this {
-		const normalizedPrefix = group.prefix.endsWith('/') ? group.prefix.slice(0, -1) : group.prefix;
-		const groupMiddleware = group.middleware ?? [];
-
-		for (const route of group.routes) {
-			const normalizedPath = route.path.startsWith('/') ? route.path : `/${route.path}`;
-			const fullPath = route.path === '/' ? normalizedPrefix : `${normalizedPrefix}${normalizedPath}`;
-			const combinedMiddleware = [...groupMiddleware, ...(route.middleware ?? [])];
-
-			this.addRouteHandler(
-				fullPath,
-				route.method,
-				route.handler,
-				combinedMiddleware.length > 0 ? combinedMiddleware : undefined,
-				route.schema,
-			);
-		}
-
-		return this;
-	}
-}

package/src/adapters/shared/define-api-handler.ts

@@ -1,66 +0,0 @@
-import type {
-	ApiHandler,
-	ApiHandlerContext,
-	Middleware,
-	RouteSchema,
-	TypedGroupHandlerContext,
-} from '../../types/public-types.ts';
-
-type UniversalContext = ApiHandlerContext<Request, unknown>;
-
-type SchemaHandlerContext<
-	TSchema extends RouteSchema | undefined,
-	TContext extends UniversalContext,
-> = TSchema extends RouteSchema ? TypedGroupHandlerContext<TSchema, TContext> : TContext;
-
-export function defineApiHandler<
-	TPath extends string,
-	TSchema extends RouteSchema | undefined = undefined,
-	TContext extends UniversalContext = UniversalContext,
->(
-	handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
-		handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
-		middleware?: Middleware<Request, unknown, TContext>[];
-		schema?: TSchema;
-	},
-): ApiHandler<TPath, Request, unknown> {
-	return handler as ApiHandler<TPath, Request, unknown>;
-}
-
-export interface GroupHandler<TPrefix extends string = string> {
-	prefix: TPrefix;
-	middleware?: readonly Middleware<Request, unknown, any>[];
-	routes: readonly ApiHandler<string, Request, unknown>[];
-}
-
-type GroupDefineHandler<TContext extends UniversalContext> = <
-	const TPath extends string,
-	TSchema extends RouteSchema | undefined = undefined,
->(
-	handler: Omit<ApiHandler<TPath, Request, unknown>, 'handler' | 'middleware' | 'schema'> & {
-		path: TPath;
-		handler: (context: SchemaHandlerContext<TSchema, TContext>) => Promise<Response> | Response;
-		middleware?: Middleware<Request, unknown, TContext>[];
-		schema?: TSchema;
-	},
-) => ApiHandler<TPath, Request, unknown>;
-
-export function defineGroupHandler<
-	TPrefix extends string,
-	TMiddleware extends readonly Middleware<Request, unknown, any>[] = [],
-	TContext extends UniversalContext = TMiddleware extends readonly Middleware<Request, unknown, infer TGroupContext>[]
-		? TGroupContext
-		: UniversalContext,
->(config: {
-	prefix: TPrefix;
-	middleware?: TMiddleware;
-	routes: (define: GroupDefineHandler<TContext>) => readonly ApiHandler<string, Request, unknown>[];
-}): GroupHandler<TPrefix> {
-	const define = ((handler) => handler) as GroupDefineHandler<TContext>;
-
-	return {
-		prefix: config.prefix,
-		middleware: config.middleware,
-		routes: config.routes(define),
-	};
-}

package/src/adapters/shared/explicit-static-render-preparation.ts

@@ -1,58 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
-import type { EcoFunctionComponent, EcoPageComponent } from '../../types/public-types.ts';
-import type { ExplicitViewRenderer, ExplicitViewRendererResolver } from '../../route-renderer/route-renderer.ts';
-
-type ExplicitStaticRenderPreparationResult = {
-	renderer: ExplicitViewRenderer;
-	props: Record<string, unknown>;
-	view: EcoFunctionComponent<Record<string, unknown>, any>;
-};
-
-function getViewIntegrationName(view: {
-	config?: { integration?: string; __eco?: { integration?: string } };
-}): string | undefined {
-	return view.config?.integration ?? view.config?.__eco?.integration;
-}
-
-/**
- * Resolves the renderer and static props needed to render one explicit static
- * view at runtime or during static generation.
- */
-export async function prepareExplicitStaticRender(input: {
-	routePath: string;
-	view: EcoPageComponent<any>;
-	params: Record<string, string | string[]>;
-	appConfig: EcoPagesAppConfig;
-	runtimeOrigin: string;
-	routeRendererFactory: ExplicitViewRendererResolver;
-	errors: {
-		missingIntegration(routePath: string): string;
-		noRendererForIntegration(integrationName: string): string;
-	};
-}): Promise<ExplicitStaticRenderPreparationResult> {
-	const integrationName = getViewIntegrationName(input.view);
-	if (!integrationName) {
-		throw new Error(input.errors.missingIntegration(input.routePath));
-	}
-
-	const renderer = input.routeRendererFactory.getExplicitViewRenderer(integrationName);
-	if (!renderer) {
-		throw new Error(input.errors.noRendererForIntegration(integrationName));
-	}
-
-	const props = input.view.staticProps
-		? (
-				await input.view.staticProps({
-					pathname: { params: input.params },
-					appConfig: input.appConfig,
-					runtimeOrigin: input.runtimeOrigin,
-				})
-			).props
-		: {};
-
-	return {
-		renderer,
-		props,
-		view: input.view as EcoFunctionComponent<Record<string, unknown>, any>,
-	};
-}

package/src/adapters/shared/explicit-static-route-matcher.test.ts

@@ -1,381 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-import type { EcoPageComponent, StaticRoute, ViewLoader } from '../../types/public-types.ts';
-import { ExplicitStaticRouteMatcher } from './explicit-static-route-matcher.ts';
-
-function createMockView(integration = 'ghtml'): EcoPageComponent<any> {
-	const view = (() => '<div>Test</div>') as EcoPageComponent<any>;
-	view.config = {
-		integration,
-		__eco: { id: 'test', file: '/test/-view.ts', integration },
-	};
-	return view;
-}
-
-function createMockLoader(view?: EcoPageComponent<any>): ViewLoader<any> {
-	const actualView = view ?? createMockView();
-	return () => Promise.resolve({ default: actualView });
-}
-
-function createMockRoute(path: string, view?: EcoPageComponent<any>): StaticRoute {
-	return {
-		path,
-		loader: createMockLoader(view),
-	};
-}
-
-function createMatcher(staticRoutes: StaticRoute[]) {
-	return new ExplicitStaticRouteMatcher({
-		appConfig: { baseUrl: 'http://localhost:3000' } as any,
-		routeRendererFactory: {} as any,
-		staticRoutes,
-	});
-}
-
-describe('ExplicitStaticRouteMatcher', () => {
-	describe('match', () => {
-		test('should match exact static path', () => {
-			const matcher = createMatcher([createMockRoute('/about')]);
-
-			const result = matcher.match('http://localhost:3000/about');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/about');
-			expect(result?.params).toEqual({});
-		});
-
-		test('should match root path', () => {
-			const matcher = createMatcher([createMockRoute('/')]);
-
-			const result = matcher.match('http://localhost:3000/');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/');
-			expect(result?.params).toEqual({});
-		});
-
-		test('should match nested static path', () => {
-			const matcher = createMatcher([createMockRoute('/docs/getting-started')]);
-
-			const result = matcher.match('http://localhost:3000/docs/getting-started');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/docs/getting-started');
-		});
-
-		test('should return null for non-matching path', () => {
-			const matcher = createMatcher([createMockRoute('/about')]);
-
-			const result = matcher.match('http://localhost:3000/contact');
-
-			expect(result).toBeNull();
-		});
-
-		test('should return null for partial match', () => {
-			const matcher = createMatcher([createMockRoute('/about')]);
-
-			const result = matcher.match('http://localhost:3000/about/team');
-
-			expect(result).toBeNull();
-		});
-	});
-
-	describe('match with :param syntax', () => {
-		test('should match dynamic segment with colon syntax', () => {
-			const matcher = createMatcher([createMockRoute('/blog/:slug')]);
-
-			const result = matcher.match('http://localhost:3000/blog/hello-world');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ slug: 'hello-world' });
-		});
-
-		test('should match multiple dynamic segments', () => {
-			const matcher = createMatcher([createMockRoute('/blog/:year/:month/:slug')]);
-
-			const result = matcher.match('http://localhost:3000/blog/2024/01/hello-world');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({
-				year: '2024',
-				month: '01',
-				slug: 'hello-world',
-			});
-		});
-
-		test('should match mixed static and dynamic segments', () => {
-			const matcher = createMatcher([createMockRoute('/users/:id/posts')]);
-
-			const result = matcher.match('http://localhost:3000/users/123/posts');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ id: '123' });
-		});
-	});
-
-	describe('match with [param] syntax', () => {
-		test('should match dynamic segment with bracket syntax', () => {
-			const matcher = createMatcher([createMockRoute('/blog/[slug]')]);
-
-			const result = matcher.match('http://localhost:3000/blog/hello-world');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ slug: 'hello-world' });
-		});
-
-		test('should match multiple bracket parameters', () => {
-			const matcher = createMatcher([createMockRoute('/products/[category]/[id]')]);
-
-			const result = matcher.match('http://localhost:3000/products/electronics/12345');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({
-				category: 'electronics',
-				id: '12345',
-			});
-		});
-	});
-
-	describe('match with catch-all routes', () => {
-		test('should match catch-all with bracket syntax', () => {
-			const matcher = createMatcher([createMockRoute('/docs/[...path]')]);
-
-			const result = matcher.match('http://localhost:3000/docs/api/reference/components');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ path: 'api/reference/components' });
-		});
-
-		test('should match catch-all with colon syntax', () => {
-			const matcher = createMatcher([createMockRoute('/files/:...path')]);
-
-			const result = matcher.match('http://localhost:3000/files/images/2024/photo.jpg');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ path: 'images/2024/photo.jpg' });
-		});
-
-		test('should match catch-all with single segment', () => {
-			const matcher = createMatcher([createMockRoute('/docs/[...path]')]);
-
-			const result = matcher.match('http://localhost:3000/docs/intro');
-
-			expect(result).not.toBeNull();
-			expect(result?.params).toEqual({ path: 'intro' });
-		});
-	});
-
-	describe('route priority', () => {
-		test('should match first route when multiple routes match', () => {
-			const aboutView = createMockView();
-			const catchAllView = createMockView();
-
-			const matcher = createMatcher([
-				createMockRoute('/about', aboutView),
-				createMockRoute('/[...path]', catchAllView),
-			]);
-
-			const result = matcher.match('http://localhost:3000/about');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/about');
-		});
-
-		test('should match exact route before dynamic route', () => {
-			const exactView = createMockView();
-			const dynamicView = createMockView();
-
-			const matcher = createMatcher([
-				createMockRoute('/blog/featured', exactView),
-				createMockRoute('/blog/:slug', dynamicView),
-			]);
-
-			const result = matcher.match('http://localhost:3000/blog/featured');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/blog/featured');
-		});
-	});
-
-	describe('edge cases', () => {
-		test('should handle URL with query parameters', () => {
-			const matcher = createMatcher([createMockRoute('/search')]);
-
-			const result = matcher.match('http://localhost:3000/search?q=test&page=1');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/search');
-		});
-
-		test('should handle URL with hash', () => {
-			const matcher = createMatcher([createMockRoute('/docs/intro')]);
-
-			const result = matcher.match('http://localhost:3000/docs/intro#section-1');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/docs/intro');
-		});
-
-		test('should handle trailing slash', () => {
-			const matcher = createMatcher([createMockRoute('/about')]);
-
-			const result = matcher.match('http://localhost:3000/about/');
-
-			expect(result).not.toBeNull();
-			expect(result?.route.path).toBe('/about');
-		});
-
-		test('should return null for empty routes array', () => {
-			const matcher = createMatcher([]);
-
-			const result = matcher.match('http://localhost:3000/anything');
-
-			expect(result).toBeNull();
-		});
-	});
-
-	describe('handleMatch', () => {
-		test('should accept integration metadata from view.config.integration', async () => {
-			const view = (() => '<div>Test</div>') as EcoPageComponent<any>;
-			view.config = {
-				integration: 'ghtml',
-				__eco: { id: 'test', file: '/test/-view.ts', integration: 'ghtml' },
-			};
-
-			const mockResponse = new Response('<html>Test</html>');
-			const renderToResponse = vi.fn(() => mockResponse);
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: {
-					getExplicitViewRenderer: vi.fn(() => ({
-						renderToResponse,
-					})),
-				} as any,
-				staticRoutes: [createMockRoute('/about', view)],
-			});
-
-			const match = matcher.match('http://localhost:3000/about');
-			const response = await matcher.handleMatch(match!);
-
-			expect(response).toBe(mockResponse);
-			expect(renderToResponse).toHaveBeenCalledWith(view, {}, {});
-		});
-
-		test('should throw error when view is missing __eco.integration', async () => {
-			const viewWithoutIntegration = (() => '<div>Test</div>') as EcoPageComponent<any>;
-			viewWithoutIntegration.config = {
-				__eco: undefined,
-			};
-
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: {
-					getExplicitViewRenderer: vi.fn(() => null),
-				} as any,
-				staticRoutes: [createMockRoute('/about', viewWithoutIntegration)],
-			});
-			const match = matcher.match('http://localhost:3000/about');
-
-			expect(match).not.toBeNull();
-			await expect(matcher.handleMatch(match!)).rejects.toThrow('missing __eco.integration');
-		});
-
-		test('should throw error when renderer is not found', async () => {
-			const view = createMockView('nonexistent-integration');
-			const RendererFactory = {
-				getExplicitViewRenderer: vi.fn(() => null),
-			};
-
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: RendererFactory as any,
-				staticRoutes: [createMockRoute('/about', view)],
-			});
-
-			const match = matcher.match('http://localhost:3000/about');
-
-			await expect(matcher.handleMatch(match!)).rejects.toThrow(
-				'No renderer found for integration: nonexistent-integration',
-			);
-		});
-
-		test('should call renderer.renderToResponse with correct arguments', async () => {
-			const view = createMockView('ghtml');
-			const mockResponse = new Response('<html>Test</html>');
-			const RenderToResponse = vi.fn(() => mockResponse);
-			const RendererFactory = {
-				getExplicitViewRenderer: vi.fn(() => ({
-					renderToResponse: RenderToResponse,
-				})),
-			};
-
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: RendererFactory as any,
-				staticRoutes: [createMockRoute('/about', view)],
-			});
-
-			const match = matcher.match('http://localhost:3000/about');
-			const response = await matcher.handleMatch(match!);
-
-			expect(response).toBe(mockResponse);
-			expect(RenderToResponse).toHaveBeenCalledTimes(1);
-			expect(RenderToResponse).toHaveBeenCalledWith(view, {}, {});
-		});
-
-		test('should resolve staticProps and pass to renderer', async () => {
-			const view = createMockView('ghtml');
-			view.staticProps = vi.fn(async () => ({
-				props: { title: 'About Page', content: 'Hello' },
-			}));
-
-			const mockResponse = new Response('<html>Test</html>');
-			const RenderToResponse = vi.fn(() => mockResponse);
-			const RendererFactory = {
-				getExplicitViewRenderer: vi.fn(() => ({
-					renderToResponse: RenderToResponse,
-				})),
-			};
-
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: RendererFactory as any,
-				staticRoutes: [createMockRoute('/about', view)],
-			});
-
-			const match = matcher.match('http://localhost:3000/about');
-			await matcher.handleMatch(match!);
-
-			expect(view.staticProps).toHaveBeenCalledTimes(1);
-			expect(RenderToResponse).toHaveBeenCalledWith(view, { title: 'About Page', content: 'Hello' }, {});
-		});
-
-		test('should pass params to staticProps', async () => {
-			const view = createMockView('ghtml');
-			view.staticProps = vi.fn(async ({ pathname }) => ({
-				props: { slug: pathname.params.slug },
-			}));
-
-			const mockResponse = new Response('<html>Test</html>');
-			const RendererFactory = {
-				getExplicitViewRenderer: vi.fn(() => ({
-					renderToResponse: vi.fn(() => mockResponse),
-				})),
-			};
-
-			const matcher = new ExplicitStaticRouteMatcher({
-				appConfig: { baseUrl: 'http://localhost:3000' } as any,
-				routeRendererFactory: RendererFactory as any,
-				staticRoutes: [createMockRoute('/blog/:slug', view)],
-			});
-
-			const match = matcher.match('http://localhost:3000/blog/hello-world');
-			await matcher.handleMatch(match!);
-
-			expect(view.staticProps).toHaveBeenCalledWith(
-				expect.objectContaining({
-					pathname: { params: { slug: 'hello-world' } },
-				}),
-			);
-		});
-	});
-});