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

package/src/eco/eco.test.ts

@@ -1,781 +0,0 @@
-/**
- * Unit tests for the eco namespace API
- */
-
-import { describe, expect, test } from 'vitest';
-import { eco } from './eco.ts';
-import type {
-	EcoComponent,
-	GetMetadataContext,
-	HtmlTemplateProps,
-	LayoutProps,
-	StaticPath,
-} from '../types/public-types.ts';
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-import {
-	type ForeignChildRuntime,
-	getComponentRenderContext,
-	runWithComponentRenderContext,
-} from '../route-renderer/orchestration/component-render-context.ts';
-
-const mockAppConfig = {} as EcoPagesAppConfig;
-
-function createResolvedForeignChildRuntime(targetIntegrations: string[], value: string): ForeignChildRuntime {
-	return {
-		interceptForeignChild: async ({ targetIntegration }: { targetIntegration?: string }) =>
-			targetIntegration !== undefined && targetIntegrations.includes(targetIntegration)
-				? ({ kind: 'resolved', value } as const)
-				: ({ kind: 'inline' } as const),
-	};
-}
-
-describe('eco namespace', () => {
-	describe('eco.component()', () => {
-		test('should create a component with basic dependencies', () => {
-			type Props = { count: number };
-			const Counter = eco.component<Props>({
-				dependencies: {
-					stylesheets: ['./counter.css'],
-					scripts: ['./counter.script.ts'],
-				},
-				render: ({ count }) => `<my-counter count="${count}"></my-counter>`,
-			});
-
-			expect(Counter).toBeDefined();
-			expect(typeof Counter).toBe('function');
-			expect(Counter.config).toBeDefined();
-			expect(Counter.config?.dependencies?.stylesheets).toEqual(['./counter.css']);
-			expect(Counter.config?.dependencies?.scripts).toEqual(['./counter.script.ts']);
-		});
-
-		test('should render component without lazy dependencies', () => {
-			const Component = eco.component({
-				render: () => '<div>Hello</div>',
-			});
-
-			const result = Component({});
-			expect(result).toBe('<div>Hello</div>');
-		});
-
-		test('should create component with lazy dependencies', () => {
-			const Counter = eco.component({
-				dependencies: {
-					stylesheets: ['./counter.css'],
-					scripts: [{ src: './counter.script.ts', lazy: { 'on:interaction': 'mouseenter,focusin' } }],
-				},
-				render: () => '<my-counter></my-counter>',
-			});
-
-			expect(Counter.config?.dependencies?.scripts).toEqual([
-				{ src: './counter.script.ts', lazy: { 'on:interaction': 'mouseenter,focusin' } },
-			]);
-		});
-
-		test('should auto-wrap component with scripts-injector when lazy scripts are resolved', () => {
-			const Counter = eco.component({
-				dependencies: {
-					scripts: [{ src: './counter.script.ts', lazy: { 'on:interaction': 'mouseenter,focusin' } }],
-				},
-				render: () => '<my-counter></my-counter>',
-			});
-
-			if (Counter.config) {
-				Counter.config._resolvedLazyScripts = [
-					{ lazy: { 'on:interaction': 'mouseenter,focusin' }, scripts: '/_assets/counter.js' },
-				];
-			}
-
-			const result = Counter({});
-			expect(result).toContain('<scripts-injector');
-			expect(result).toContain('<script type="ecopages/injector-map">');
-			expect(result).toContain(
-				'"on:interaction":{"value":"mouseenter,focusin","scripts":["/_assets/counter.js"]}',
-			);
-			expect(result).toContain('<my-counter></my-counter>');
-			expect(result).toContain('</scripts-injector>');
-		});
-
-		test('should handle on:idle trigger', () => {
-			const Component = eco.component({
-				dependencies: {
-					scripts: [{ src: './script.ts', lazy: { 'on:idle': true } }],
-				},
-				render: () => '<div>Content</div>',
-			});
-
-			if (Component.config) {
-				Component.config._resolvedLazyScripts = [{ lazy: { 'on:idle': true }, scripts: '/_assets/script.js' }];
-			}
-
-			const result = Component({});
-			expect(result).toContain('"on:idle":{"scripts":["/_assets/script.js"]}');
-		});
-
-		test('should handle on:visible trigger with boolean', () => {
-			const Component = eco.component({
-				dependencies: {
-					scripts: [{ src: './script.ts', lazy: { 'on:visible': true } }],
-				},
-				render: () => '<div>Content</div>',
-			});
-
-			if (Component.config) {
-				Component.config._resolvedLazyScripts = [
-					{ lazy: { 'on:visible': true }, scripts: '/_assets/script.js' },
-				];
-			}
-
-			const result = Component({});
-			expect(result).toContain('"on:visible":{"scripts":["/_assets/script.js"]}');
-		});
-
-		test('should handle on:visible trigger with threshold value', () => {
-			const Component = eco.component({
-				dependencies: {
-					scripts: [{ src: './script.ts', lazy: { 'on:visible': '0.5' } }],
-				},
-				render: () => '<div>Content</div>',
-			});
-
-			if (Component.config) {
-				Component.config._resolvedLazyScripts = [
-					{ lazy: { 'on:visible': '0.5' }, scripts: '/_assets/script.js' },
-				];
-			}
-
-			const result = Component({});
-			expect(result).toContain('"on:visible":{"value":"0.5","scripts":["/_assets/script.js"]}');
-		});
-
-		test('should not wrap when lazy script entries exist but _resolvedLazyScripts is not set', () => {
-			const Component = eco.component({
-				dependencies: {
-					scripts: [{ src: './script.ts', lazy: { 'on:interaction': 'mouseenter' } }],
-				},
-				render: () => '<div>Content</div>',
-			});
-
-			const result = Component({});
-			expect(result).toBe('<div>Content</div>');
-			expect(result).not.toContain('scripts-injector');
-		});
-
-		test('should pass props to render function', () => {
-			type Props = { name: string; count: number };
-			const Component = eco.component<Props>({
-				render: ({ name, count }) => `<div>${name}: ${count}</div>`,
-			});
-
-			const result = Component({ name: 'Counter', count: 5 });
-			expect(result).toBe('<div>Counter: 5</div>');
-		});
-
-		test('should support multiple lazy triggers in dependencies.scripts', () => {
-			const Component = eco.component({
-				dependencies: {
-					scripts: [
-						{ src: './idle.ts', lazy: { 'on:idle': true } },
-						{ src: './visible.ts', lazy: { 'on:visible': '0.5' } },
-					],
-				},
-				render: () => '<section>Content</section>',
-			});
-
-			if (Component.config) {
-				Component.config._resolvedLazyScripts = [
-					{ lazy: { 'on:idle': true }, scripts: '/_assets/idle.js' },
-					{ lazy: { 'on:visible': '0.5' }, scripts: '/_assets/visible.js' },
-				];
-			}
-
-			const result = Component({});
-			expect(result).toContain('"on:idle":{"scripts":["/_assets/idle.js"]}');
-			expect(result).toContain('"on:visible":{"value":"0.5","scripts":["/_assets/visible.js"]}');
-			expect(result).toContain('<section>Content</section>');
-			expect((result.match(/<scripts-injector/g) ?? []).length).toBe(1);
-		});
-
-		test('should set explicit integration on component config', () => {
-			const Component = eco.component({
-				integration: 'lit',
-				render: () => '<div>Content</div>',
-			});
-
-			expect(Component.config?.integration).toBe('lit');
-		});
-
-		test('should render inline when the foreign-child runtime returns inline for a React component', async () => {
-			const ReactButton = eco.component({
-				integration: 'react',
-				__eco: {
-					id: 'react-button',
-					file: '/app/components/react-button.react.tsx',
-					integration: 'react',
-				},
-				render: () => '<button type="button">Click</button>',
-			});
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'lit',
-				},
-				async () => ReactButton({}),
-			);
-
-			expect(execution.value).toBe('<button type="button">Click</button>');
-		});
-
-		test('should resolve foreign children immediately when the runtime returns resolved output', async () => {
-			const ReactButton = eco.component({
-				integration: 'react',
-				__eco: {
-					id: 'react-button-resolved-runtime',
-					file: '/app/components/react-button-resolved-runtime.react.tsx',
-					integration: 'react',
-				},
-				render: () => '<button type="button">Click</button>',
-			});
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'lit',
-					foreignChildRuntime: createResolvedForeignChildRuntime(
-						['react'],
-						'<aside>Resolved in owning renderer</aside>',
-					),
-				},
-				async () => ReactButton({}),
-			);
-
-			expect(execution.value).toBe('<aside>Resolved in owning renderer</aside>');
-		});
-
-		test('should render inline with runtime-normalized props', async () => {
-			const KitaShell = eco.component<{ children?: string }>({
-				integration: 'kitajs',
-				__eco: {
-					id: 'kitajs-shell-inline-props',
-					file: '/app/components/kitajs-shell-inline-props.kita.tsx',
-					integration: 'kitajs',
-				},
-				render: ({ children }) => `<section>${children ?? ''}</section>`,
-			});
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'ecopages-jsx',
-					foreignChildRuntime: {
-						interceptForeignChild: async ({ targetIntegration, props }) =>
-							targetIntegration === 'kitajs'
-								? {
-										kind: 'inline',
-										props: {
-											...props,
-											children: '<span data-serialized="true">Leaf</span>',
-										},
-									}
-								: { kind: 'inline' },
-					},
-				},
-				async () => KitaShell({ children: { nodeType: 1, outerHTML: '<span>Leaf</span>' } as never }),
-			);
-
-			expect(execution.value).toBe('<section><span data-serialized="true">Leaf</span></section>');
-		});
-
-		test('should share render context across duplicated module instances', async () => {
-			const duplicateModule = (await import(
-				'../route-renderer/orchestration/component-render-context.ts?duplicate-instance' as string
-			)) as typeof import('../route-renderer/orchestration/component-render-context.ts');
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'kitajs',
-				},
-				async () => {
-					expect(getComponentRenderContext()?.currentIntegration).toBe('kitajs');
-					expect(duplicateModule.getComponentRenderContext()?.currentIntegration).toBe('kitajs');
-					return 'shared-context';
-				},
-			);
-
-			expect(execution.value).toBe('shared-context');
-		});
-
-		test('should embed children through a third argument without manual prop merging', () => {
-			const Shell = eco.component<{ id: string; children?: string }>({
-				render: ({ id, children }) => `<section data-shell="${id}">${children ?? ''}</section>`,
-			});
-
-			const result = eco.embed(Shell, { id: 'kita' }, '<span>Leaf</span>');
-
-			expect(result).toBe('<section data-shell="kita"><span>Leaf</span></section>');
-		});
-
-		test('should accept foreign child values without constraining the authoring surface to the target children type', () => {
-			const Shell = eco.component<{ id: string; children?: string }>({
-				render: ({ id, children }) => `<section data-shell="${id}">${children ?? ''}</section>`,
-			});
-
-			const result = eco.embed(Shell, { id: 'kita' }, { foreign: true });
-
-			expect(result).toBe('<section data-shell="kita">[object Object]</section>');
-		});
-
-		test('should let the foreign-child runtime replace embedded output when the target integration is delegated', async () => {
-			const ReactButton = eco.component<{ label: string }>({
-				integration: 'react',
-				__eco: {
-					id: 'react-button-embedded-runtime',
-					file: '/app/components/react-button-embedded-runtime.react.tsx',
-					integration: 'react',
-				},
-				render: ({ label }) => `<button type="button">${label}</button>`,
-			});
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'lit',
-					foreignChildRuntime: createResolvedForeignChildRuntime(
-						['react'],
-						'<aside>Resolved in owning renderer</aside>',
-					),
-				},
-				async () => eco.embed(ReactButton, { label: 'Click' }),
-			);
-
-			expect(execution.value).toBe('<aside>Resolved in owning renderer</aside>');
-		});
-
-		test('should render embedded component output inline when the foreign-child runtime does not delegate the target integration', async () => {
-			const ReactButton = eco.component<{ label: string }>({
-				integration: 'react',
-				__eco: {
-					id: 'react-button-embedded-inline-runtime',
-					file: '/app/components/react-button-embedded-inline-runtime.react.tsx',
-					integration: 'react',
-				},
-				render: ({ label }) => `<button type="button">${label}</button>`,
-			});
-
-			const execution = await runWithComponentRenderContext(
-				{
-					currentIntegration: 'lit',
-					foreignChildRuntime: createResolvedForeignChildRuntime(
-						['kitajs'],
-						'<aside>Resolved elsewhere</aside>',
-					),
-				},
-				async () => eco.embed(ReactButton, { label: 'Click' }),
-			);
-
-			expect(execution.value).toBe('<button type="button">Click</button>');
-		});
-
-		test('should surface an eco.embed-specific error when the active integration misses foreign-child handoff', async () => {
-			const ReactButton = eco.component<{ label: string }>({
-				integration: 'react',
-				__eco: {
-					id: 'react-button-missing-runtime-handoff',
-					file: '/app/components/react-button-missing-runtime-handoff.react.tsx',
-					integration: 'react',
-				},
-				render: ({ label }) => `<button type="button">${label}</button>`,
-			});
-
-			await expect(
-				runWithComponentRenderContext(
-					{
-						currentIntegration: 'lit',
-						foreignChildRuntime: {},
-					},
-					async () => eco.embed(ReactButton, { label: 'Click' }),
-				),
-			).rejects.toThrowError(
-				'[ecopages] eco.embed() could not hand off the Foreign Child from lit to react for /app/components/react-button-missing-runtime-handoff.react.tsx.',
-			);
-		});
-	});
-
-	describe('eco.html()', () => {
-		test('should create a document shell component with html props', () => {
-			const Html = eco.html({
-				render: ({ children, language = 'en' }: HtmlTemplateProps) =>
-					`<html lang="${language}"><body>${children}</body></html>`,
-			});
-
-			const result = Html({
-				children: '<main>Hello</main>',
-				metadata: { title: 'Home', description: 'Welcome' },
-				pageProps: {},
-			});
-
-			expect(typeof Html).toBe('function');
-			expect(result).toBe('<html lang="en"><body><main>Hello</main></body></html>');
-		});
-	});
-
-	describe('eco.layout()', () => {
-		test('should create a route layout component with layout props', () => {
-			const Layout = eco.layout({
-				render: ({ children, locals }: LayoutProps<string>) =>
-					`<main data-user="${locals?.user ?? 'guest'}">${children}</main>`,
-			});
-
-			const result = Layout({ children: '<h1>Page</h1>', locals: { user: '123' } });
-
-			expect(typeof Layout).toBe('function');
-			expect(result).toBe('<main data-user="123"><h1>Page</h1></main>');
-		});
-
-		test('should work when used as page layout', () => {
-			const Layout = eco.layout<string>({
-				render: ({ children }) => `<main>${children}</main>`,
-			});
-
-			const Page = eco.page({
-				layout: Layout,
-				render: () => '<h1>Page Content</h1>',
-			});
-
-			expect(Page.config?.layout).toBe(Layout);
-			expect(Page.config?.dependencies?.components).toContain(Layout);
-		});
-	});
-
-	describe('eco.page()', () => {
-		test('should create a page without staticProps', () => {
-			const Page = eco.page({
-				dependencies: {
-					components: [],
-				},
-				render: () => '<h1>Welcome</h1>',
-			});
-
-			expect(Page).toBeDefined();
-			expect(typeof Page).toBe('function');
-			expect(Page.config).toBeDefined();
-		});
-
-		test('should create a page with typed props', () => {
-			type PageProps = { params?: { slug?: string }; query?: Record<string, string> };
-			const Page = eco.page<PageProps>({
-				render: ({ params }) => `<h1>${params?.slug || 'Home'}</h1>`,
-			});
-
-			const result = Page({ params: { slug: 'test-post' } });
-			expect(result).toBe('<h1>test-post</h1>');
-		});
-
-		test('should work with lazy dependencies on pages', () => {
-			const Page = eco.page({
-				dependencies: {
-					scripts: [{ src: './page.script.ts', lazy: { 'on:interaction': 'click' } }],
-				},
-				render: () => '<div>Page Content</div>',
-			});
-
-			if (Page.config) {
-				Page.config._resolvedLazyScripts = [
-					{ lazy: { 'on:interaction': 'click' }, scripts: '/_assets/page.js' },
-				];
-			}
-
-			const result = Page({});
-			expect(result).toContain('<scripts-injector');
-			expect(result).toContain('"on:interaction":{"value":"click","scripts":["/_assets/page.js"]}');
-		});
-
-		test('should store layout in config and include in dependencies', async () => {
-			const Layout = eco.component<{ children: string }>({
-				render: ({ children }) => `<main class="layout">${children}</main>`,
-			});
-
-			const Page = eco.page({
-				layout: Layout,
-				render: () => '<h1>Page Content</h1>',
-			});
-
-			expect(Page.config?.layout).toBe(Layout);
-			expect(Page.config?.dependencies?.components).toContain(Layout);
-			const result = await Page({});
-			expect(result).toBe('<h1>Page Content</h1>');
-		});
-
-		test('should render raw content (layout wrapping happens at render time)', async () => {
-			const Layout = eco.component<{ children: string }>({
-				render: ({ children }) => `<main class="layout">${children}</main>`,
-			});
-
-			const Page = eco.page({
-				layout: Layout,
-				render: async () => {
-					await Promise.resolve();
-					return '<h1>Async Content</h1>';
-				},
-			});
-
-			expect(Page.config?.layout).toBe(Layout);
-			const result = await Page({});
-			expect(result).toBe('<h1>Async Content</h1>');
-		});
-
-		test('should include layout in dependencies when provided', () => {
-			const Layout = eco.component<{ children: string }>({
-				dependencies: {
-					stylesheets: ['./layout.css'],
-				},
-				render: ({ children }) => `<main>${children}</main>`,
-			});
-
-			const Page = eco.page({
-				layout: Layout,
-				dependencies: {
-					stylesheets: ['./page.css'],
-				},
-				render: () => '<h1>Content</h1>',
-			});
-
-			expect(Page.config?.dependencies?.components).toContain(Layout);
-			expect(Page.config?.dependencies?.stylesheets).toEqual(['./page.css']);
-		});
-
-		test('should set explicit integration on page config', () => {
-			const Page = eco.page({
-				integration: 'react',
-				render: () => '<h1>Page</h1>',
-			});
-
-			expect(Page.config?.integration).toBe('react');
-		});
-	});
-
-	describe('eco.metadata()', () => {
-		test('should be an identity function', () => {
-			const metadataFn = () => ({
-				title: 'Home',
-				description: 'Welcome',
-			});
-
-			const wrapped = eco.metadata(metadataFn);
-			expect(wrapped).toBe(metadataFn);
-		});
-
-		test('should work with async metadata function', async () => {
-			const metadataFn = async () => ({
-				title: 'Home',
-				description: 'Welcome',
-			});
-
-			const wrapped = eco.metadata(metadataFn);
-			const result = await wrapped({ props: {}, params: {}, query: {}, appConfig: mockAppConfig });
-			expect(result.title).toBe('Home');
-		});
-
-		test('should work with props-based metadata', () => {
-			const metadataFn = async () => ({ title: 'My Post', description: 'Post excerpt' });
-			const wrapped = eco.metadata(metadataFn);
-			expect(wrapped).toBe(metadataFn);
-		});
-	});
-
-	describe('eco.staticPaths()', () => {
-		test('should be an identity function', () => {
-			const staticPathsFn = async () => ({
-				paths: [{ params: { slug: 'post-1' } }, { params: { slug: 'post-2' } }],
-			});
-
-			const wrapped = eco.staticPaths(staticPathsFn);
-			expect(wrapped).toBe(staticPathsFn);
-		});
-
-		test('should preserve function behavior', async () => {
-			const staticPathsFn = async () => ({
-				paths: [{ params: { slug: 'post-1' } }, { params: { slug: 'post-2' } }],
-			});
-
-			const wrapped = eco.staticPaths(staticPathsFn);
-			const result = await wrapped({ appConfig: mockAppConfig, runtimeOrigin: '' });
-			expect(result.paths).toHaveLength(2);
-			expect(result.paths[0].params.slug).toBe('post-1');
-		});
-	});
-
-	describe('eco.staticProps()', () => {
-		test('should be an identity function', () => {
-			const staticPropsFn = async ({ pathname }: any) => ({
-				props: { slug: pathname.params.slug },
-			});
-
-			const wrapped = eco.staticProps(staticPropsFn);
-			expect(wrapped).toBe(staticPropsFn);
-		});
-
-		test('should preserve function behavior', async () => {
-			const staticPropsFn = async ({ pathname }: any) => ({
-				props: { post: { title: 'Test Post', slug: pathname.params.slug } },
-			});
-
-			const wrapped = eco.staticProps(staticPropsFn);
-			const result = await wrapped({
-				pathname: { params: { slug: 'my-post' } },
-				appConfig: mockAppConfig,
-				runtimeOrigin: '',
-			});
-			expect(result.props.post.title).toBe('Test Post');
-			expect(result.props.post.slug).toBe('my-post');
-		});
-	});
-
-	describe('integration', () => {
-		test('should work with nested components', () => {
-			const Button = eco.component<{ label: string }>({
-				dependencies: {
-					scripts: [
-						{
-							src: './button.script.ts',
-							lazy: {
-								'on:interaction': 'click',
-							},
-						},
-					],
-				},
-				render: ({ label }) => `<button>${label}</button>`,
-			});
-
-			const Card = eco.component<{ title: string; children: string }>({
-				dependencies: {
-					components: [Button as EcoComponent],
-				},
-				render: ({ title, children }) => `<div class="card"><h2>${title}</h2>${children}</div>`,
-			});
-
-			expect(Card.config?.dependencies?.components).toContain(Button);
-		});
-	});
-
-	test('should attach staticPaths when provided (consolidated API)', () => {
-		const staticPathsFn = async () => ({
-			paths: [{ params: { slug: 'post-1' } }, { params: { slug: 'post-2' } }],
-		});
-
-		const Page = eco.page({
-			staticPaths: staticPathsFn,
-			render: () => '<h1>Page</h1>',
-		});
-
-		expect(Page.staticPaths).toBe(staticPathsFn);
-	});
-
-	test('should attach staticProps when provided (consolidated API)', () => {
-		type Props = { title: string; slug: string };
-
-		const staticPropsFn = async ({ pathname }: { pathname: StaticPath }) => ({
-			props: { title: 'Test', slug: pathname.params.slug as string },
-		});
-
-		const Page = eco.page<Props>({
-			staticProps: staticPropsFn,
-			render: ({ title }) => `<h1>${title}</h1>`,
-		});
-
-		expect(Page.staticProps).toBe(staticPropsFn);
-	});
-
-	test('should attach metadata when provided (consolidated API)', () => {
-		type Props = { title: string };
-
-		const metadataFn = ({ props: { title } }: GetMetadataContext<Props>) => ({
-			title,
-			description: `Page: ${title}`,
-		});
-
-		const Page = eco.page<Props>({
-			metadata: metadataFn,
-			render: ({ title }) => `<h1>${title}</h1>`,
-		});
-
-		expect(Page.metadata).toBe(metadataFn);
-	});
-
-	test('should attach all static functions together (consolidated API)', async () => {
-		type Props = { title: string; slug: string };
-
-		const Page = eco.page<Props>({
-			staticPaths: async () => ({
-				paths: [{ params: { slug: 'hello' } }],
-			}),
-			staticProps: async ({ pathname }) => ({
-				props: { title: 'Hello World', slug: pathname.params.slug as string },
-			}),
-			metadata: ({ props: { title } }) => ({
-				title,
-				description: `Page: ${title}`,
-			}),
-			render: ({ title }) => `<h1>${title}</h1>`,
-		});
-
-		expect(Page.staticPaths).toBeDefined();
-		expect(Page.staticProps).toBeDefined();
-		expect(Page.metadata).toBeDefined();
-
-		// Verify they work correctly
-		const paths = await Page.staticPaths!({ appConfig: mockAppConfig, runtimeOrigin: '' });
-		expect(paths.paths).toHaveLength(1);
-
-		const props = await Page.staticProps!({
-			pathname: { params: { slug: 'hello' } },
-			appConfig: mockAppConfig,
-			runtimeOrigin: '',
-		});
-		expect(props.props.title).toBe('Hello World');
-
-		const result = Page({ title: 'Hello World', slug: 'hello' });
-		expect(result).toBe('<h1>Hello World</h1>');
-	});
-
-	test('should not have static functions when not provided', () => {
-		const Page = eco.page({
-			render: () => '<h1>Simple Page</h1>',
-		});
-
-		expect(Page.staticPaths).toBeUndefined();
-		expect(Page.staticProps).toBeUndefined();
-		expect(Page.metadata).toBeUndefined();
-	});
-
-	test('should attach cache strategy "static" when provided', () => {
-		const Page = eco.page({
-			cache: 'static',
-			render: () => '<h1>Static Page</h1>',
-		});
-
-		expect(Page.cache).toBe('static');
-	});
-
-	test('should attach cache strategy "dynamic" when provided', () => {
-		const Page = eco.page({
-			cache: 'dynamic',
-			render: () => '<h1>Dynamic Page</h1>',
-		});
-
-		expect(Page.cache).toBe('dynamic');
-	});
-
-	test('should attach cache strategy with revalidation when provided', () => {
-		const Page = eco.page({
-			cache: { revalidate: 3600, tags: ['blog'] },
-			render: () => '<h1>Blog Page</h1>',
-		});
-
-		expect(Page.cache).toEqual({ revalidate: 3600, tags: ['blog'] });
-	});
-
-	test('should not have cache when not provided', () => {
-		const Page = eco.page({
-			render: () => '<h1>Page Without Cache</h1>',
-		});
-
-		expect(Page.cache).toBeUndefined();
-	});
-});