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

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

@@ -0,0 +1,199 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,58 @@
+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

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