npm - @ecopages/core - Versions diffs - 0.2.0-alpha.7 → 0.2.0-alpha.8 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (354) hide show

package/src/route-renderer/orchestration/render-execution.service.test.ts DELETED Viewed

@@ -1,97 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getComponentRenderContext } from '../../eco/component-render-context.ts';
-import type { EcoComponent, IntegrationRendererRenderOptions, RouteRendererOptions } from '../../public-types.ts';
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.ts';
-import { createComponentMarker } from '../component-graph/component-marker.ts';
-import { RenderExecutionService } from './render-execution.service.ts';
-describe('RenderExecutionService', () => {
-	it('should execute render flow, merge graph context, resolve markers, and apply root attributes', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-		const asset = { kind: 'script', srcUrl: '/assets/nested.js', position: 'head' } as ProcessedAsset;
-		const setProcessedDependencies = vi.fn();
-		const dedupeProcessedAssets = vi.fn((assets: ProcessedAsset[]) => {
-			const seen = new Set<string>();
-			return assets.filter((entry) => {
-				const key = `${entry.kind}:${entry.srcUrl ?? ''}:${entry.position ?? ''}`;
-				if (seen.has(key)) {
-					return false;
-				}
-				seen.add(key);
-				return true;
-			});
-		});
-		const resolveMarkerGraphHtml = vi.fn(async (input) => {
-			expect(input.componentsToResolve).toEqual([HtmlTemplate, Page]);
-			expect(input.graphContext.propsByRef).toEqual({
-				captured: { count: 1 },
-				explicit: { count: 2 },
-			});
-			return {
-				html: '<html><body><main>Resolved</main></body></html>',
-				assets: [asset, asset],
-			};
-		});
-		const result = await service.execute(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-			} as unknown as RouteRendererOptions,
-			'ghtml',
-			{
-				prepareRenderOptions: async () =>
-					({
-						HtmlTemplate,
-						Page,
-						cacheStrategy: { revalidate: 60 },
-						componentRender: {
-							canAttachAttributes: true,
-							rootAttributes: { 'data-eco-component-id': 'eco-page-root' },
-						},
-						componentGraphContext: {
-							propsByRef: {
-								explicit: { count: 2 },
-							},
-						},
-					}) as unknown as IntegrationRendererRenderOptions<unknown>,
-				render: async () => {
-					const context = getComponentRenderContext();
-					if (context) {
-						context.propsByRef.captured = { count: 1 };
-					}
-					return `<html><body>${createComponentMarker({
-						nodeId: 'n_1',
-						integration: 'react',
-						componentRef: 'nested-component',
-						propsRef: 'captured',
-					})}</body></html>`;
-				},
-				getComponentRenderBoundaryContext: () => ({
-					decideBoundaryRender: () => 'inline',
-				}),
-				getDocumentAttributes: () => ({ 'data-eco-document-owner': 'react-router' }),
-				resolveMarkerGraphHtml,
-				dedupeProcessedAssets,
-				getProcessedDependencies: () => [asset],
-				setProcessedDependencies,
-				applyAttributesToHtmlElement: (html, attributes) =>
-					html.replace('<html', `<html data-eco-document-owner="${attributes['data-eco-document-owner']}"`),
-				applyAttributesToFirstBodyElement: (html, attributes) =>
-					html.replace('<main', `<main data-eco-component-id="${attributes['data-eco-component-id']}"`),
-				transformHtml: async (html) => html,
-			},
-		);
-		expect(result.cacheStrategy).toEqual({ revalidate: 60 });
-		expect(result.body).toContain('<html data-eco-document-owner="react-router"><body>');
-		expect(result.body).toContain('<main data-eco-component-id="eco-page-root">Resolved</main>');
-		expect(setProcessedDependencies).toHaveBeenCalledWith([asset]);
-		expect(dedupeProcessedAssets).toHaveBeenCalled();
-		expect(resolveMarkerGraphHtml).toHaveBeenCalledTimes(1);
-	});
-});

package/src/route-renderer/orchestration/render-preparation.service.test.ts DELETED Viewed

@@ -1,235 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import type { EcoComponent, EcoPageComponent, HtmlTemplateProps, RouteRendererOptions } from '../../public-types.ts';
-import type {
-	AssetDefinition,
-	AssetProcessingService,
-	ProcessedAsset,
-} from '../../services/assets/asset-processing-service/index.ts';
-import { RenderPreparationService } from './render-preparation.service.ts';
-declare module '../../public-types.ts' {
-	interface RequestLocals {
-		user?: string;
-		guarded?: boolean;
-	}
-}
-describe('RenderPreparationService', () => {
-	it('should prepare dynamic render options and merge renderer-owned assets', async () => {
-		const integrationDependency = {
-			kind: 'script',
-			srcUrl: '/assets/react-runtime.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const componentAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page-root.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const resolvedDependency = {
-			kind: 'stylesheet',
-			srcUrl: '/assets/page.css',
-			position: 'head',
-		} as ProcessedAsset;
-		const pageDependency = {
-			kind: 'script',
-			srcUrl: '/assets/page-entry.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [integrationDependency],
-				},
-			],
-		} as unknown as EcoPagesAppConfig;
-		const service = new RenderPreparationService(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Nested = (() => '<aside>Nested</aside>') as EcoComponent<Record<string, unknown>>;
-		Nested.config = {
-			integration: 'react',
-			__eco: { id: 'nested', file: '/app/components/nested.tsx', integration: 'react' },
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.cache = 'dynamic';
-		Page.config = {
-			dependencies: {
-				components: [Nested],
-			},
-		};
-		const routeOptions = {
-			file: '/app/pages/index.tsx',
-			params: { slug: 'hello' },
-			query: { preview: '1' },
-			locals: { user: 'andee' },
-		} as unknown as RouteRendererOptions;
-		const setProcessedDependencies = vi.fn();
-		const result = await service.prepare(routeOptions, 'ghtml', {
-			resolvePageModule: async () => ({
-				Page,
-				integrationSpecificProps: { layoutMode: 'full' },
-			}),
-			getHtmlTemplate: async () => HtmlTemplate,
-			resolvePageData: async () => ({
-				props: { title: 'Hello' },
-				metadata: { title: 'Hello', description: 'Hello description' },
-			}),
-			resolveDependencies: async () => [resolvedDependency],
-			buildRouteRenderAssets: async () => [pageDependency],
-			shouldRenderPageComponent: () => true,
-			renderPageComponent: async () => ({
-				html: '<main>Page</main>',
-				canAttachAttributes: true,
-				rootTag: 'main',
-				integrationName: 'ghtml',
-				assets: [componentAsset],
-			}),
-			getComponentRenderBoundaryContext: () => ({
-				decideBoundaryRender: () => 'inline',
-			}),
-			setProcessedDependencies,
-			dedupeProcessedAssets: (assets) => assets,
-			createPageLocalsProxy: () => ({ guarded: true }),
-		});
-		expect(result.locals).toEqual({ user: 'andee' });
-		expect(result.pageLocals).toEqual({ user: 'andee' });
-		expect(result.pageProps).toEqual({ title: 'Hello', params: { slug: 'hello' }, query: { preview: '1' } });
-		expect((result as typeof result & { layoutMode?: string }).layoutMode).toBe('full');
-		expect(result.componentRender?.assets).toEqual([componentAsset]);
-		expect(setProcessedDependencies).toHaveBeenCalledWith([
-			resolvedDependency,
-			integrationDependency,
-			pageDependency,
-			componentAsset,
-		]);
-	});
-	it('should guard page locals for static pages and skip page-root rendering when disabled', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const service = new RenderPreparationService(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const renderPageComponent = vi.fn();
-		const result = await service.prepare(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-				locals: { hidden: true },
-			} as unknown as RouteRendererOptions,
-			'ghtml',
-			{
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Static page', description: 'Static page description' },
-				}),
-				resolveDependencies: async () => [],
-				buildRouteRenderAssets: async () => [],
-				shouldRenderPageComponent: () => false,
-				renderPageComponent,
-				getComponentRenderBoundaryContext: () => ({
-					decideBoundaryRender: () => 'inline',
-				}),
-				setProcessedDependencies: vi.fn(),
-				dedupeProcessedAssets: (assets) => assets,
-				createPageLocalsProxy: () => ({ guarded: true }),
-			},
-		);
-		expect(result.locals).toBeUndefined();
-		expect(result.pageLocals).toEqual({ guarded: true });
-		expect(result.componentRender).toBeUndefined();
-		expect(renderPageComponent).not.toHaveBeenCalled();
-	});
-	it('eagerly emits lazy SSR component scripts for shared non-owning routes', async () => {
-		const eagerSsrLazyAsset = {
-			kind: 'script',
-			srcUrl: '/assets/components/lit-counter.script.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (dependencies: AssetDefinition[]) => {
-				const hasEagerSsrLazyDependency = dependencies.some((dependency) => {
-					if (dependency.kind !== 'script' || dependency.source !== 'file') {
-						return false;
-					}
-					return String(dependency.filepath).endsWith('/lit-counter.script.ts');
-				});
-				return hasEagerSsrLazyDependency ? [eagerSsrLazyAsset] : [];
-			}),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const service = new RenderPreparationService(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const LitCounter = (() => '<lit-counter count="0"></lit-counter>') as unknown as EcoComponent<object>;
-		LitCounter.config = {
-			__eco: { id: 'lit-counter', file: '/app/components/lit-counter.lit.tsx', integration: 'lit' },
-			dependencies: {
-				scripts: [{ src: './lit-counter.script.ts', lazy: { 'on:interaction': 'click' }, ssr: true }],
-			},
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.config = {
-			dependencies: {
-				components: [LitCounter],
-			},
-		};
-		const setProcessedDependencies = vi.fn();
-		await service.prepare(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			'ghtml',
-			{
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Static page', description: 'Static page description' },
-				}),
-				resolveDependencies: async () => [],
-				buildRouteRenderAssets: async () => [],
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-				getComponentRenderBoundaryContext: () => ({
-					decideBoundaryRender: () => 'inline',
-				}),
-				setProcessedDependencies,
-				dedupeProcessedAssets: (assets) => assets,
-				createPageLocalsProxy: () => ({}),
-			},
-		);
-		expect(setProcessedDependencies).toHaveBeenCalledWith([eagerSsrLazyAsset]);
-	});
-});

package/src/route-renderer/page-loading/dependency-resolver.test.ts DELETED Viewed

@@ -1,345 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { DEPENDENCY_ERRORS, DependencyResolverService } from './dependency-resolver.ts';
-import type { EcoPagesAppConfig } from '../../internal-types.ts';
-import type {
-	AssetDefinition,
-	AssetProcessingService,
-	ProcessedAsset,
-	ContentScriptAsset,
-} from '../../services/assets/asset-processing-service/index.ts';
-import type { EcoComponent } from '../../public-types.ts';
-describe('DependencyResolverService', () => {
-	const appConfig = {
-		srcDir: '/app',
-	} as EcoPagesAppConfig;
-	it('should resolve dependency and lazy script paths', () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		expect(service.resolveDependencyPath('/app/components/card', './style.css')).toBe(
-			'/app/components/card/style.css',
-		);
-		expect(service.resolveLazyScripts('/app/components/card', ['./client.ts', './widget.tsx'])).toBe(
-			'/assets/components/card/client.js,/assets/components/card/widget.js',
-		);
-	});
-	it('should emit module dependencies as content scripts and resolve lazy triggers by default', async () => {
-		let capturedDeps: AssetDefinition[] = [];
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (deps: AssetDefinition[]) => {
-				capturedDeps = deps;
-				return [
-					{
-						kind: 'script',
-						filepath: '/app/components/table/table.client.ts',
-						srcUrl: '/assets/components/table/table.client.js',
-					},
-				] as ProcessedAsset[];
-			}),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const component = ((_) => '<table></table>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'table',
-				integration: 'react',
-				file: '/app/components/table/table.tsx',
-			},
-			dependencies: {
-				modules: ['react-aria-components{Table,Button}', './client-utils'],
-				scripts: [{ src: './table.client.ts', lazy: { 'on:interaction': 'click' } }],
-			},
-		};
-		await service.processComponentDependencies([component], 'react');
-		const contentScripts = capturedDeps.filter(
-			(dep): dep is ContentScriptAsset => dep.kind === 'script' && dep.source === 'content',
-		);
-		expect(
-			contentScripts.some((script) =>
-				script.content.includes("export { Table, Button } from 'react-aria-components';"),
-			),
-		).toBe(true);
-		expect(contentScripts.some((script) => script.content.includes("export * from './client-utils';"))).toBe(true);
-		expect(contentScripts.every((script) => /^module-[a-f0-9]+$/.test(script.name ?? ''))).toBe(true);
-		const hasInjector = capturedDeps.some(
-			(dep) =>
-				dep.kind === 'script' &&
-				dep.source === 'node-module' &&
-				dep.importPath === '@ecopages/scripts-injector',
-		);
-		expect(hasInjector).toBe(false);
-		expect(component.config._resolvedLazyScripts).toBeUndefined();
-		expect(component.config._resolvedLazyTriggers).toHaveLength(1);
-		expect(component.config._resolvedLazyTriggers?.[0]?.rules).toEqual([
-			{
-				'on:interaction': {
-					value: 'click',
-					scripts: ['/assets/components/table/table.client.js'],
-				},
-			},
-		]);
-	});
-	it('should detect ecopages virtual imports via parser', async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), 'ecopages-dependency-resolver-'));
-		const componentFile = join(tempDir, 'component.tsx');
-		writeFileSync(
-			componentFile,
-			"import { heroImage as imageAsset } from 'ecopages:images';\nexport const ok = imageAsset.src;\n",
-			'utf-8',
-		);
-		let capturedDeps: AssetDefinition[] = [];
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (deps: AssetDefinition[]) => {
-				capturedDeps = deps;
-				return [] as ProcessedAsset[];
-			}),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const component = ((_) => '<div></div>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'component',
-				integration: 'react',
-				file: componentFile,
-			},
-		};
-		try {
-			await service.processComponentDependencies([component], 'react');
-			const contentScripts = capturedDeps.filter(
-				(dep): dep is ContentScriptAsset => dep.kind === 'script' && dep.source === 'content',
-			);
-			expect(contentScripts.some((script) => script.content.includes("from 'ecopages:images';"))).toBe(true);
-		} finally {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-	it('should pass entry attributes and support inline stylesheet content', async () => {
-		let capturedDeps: AssetDefinition[] = [];
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (deps: AssetDefinition[]) => {
-				capturedDeps = deps;
-				return [] as ProcessedAsset[];
-			}),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const component = ((_) => '<div></div>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'attrs-inline',
-				integration: 'react',
-				file: '/app/components/attrs-inline/component.tsx',
-			},
-			dependencies: {
-				scripts: [
-					{
-						src: './client.ts',
-						attributes: {
-							async: '',
-							'data-script-id': 'main-client',
-						},
-					},
-				],
-				stylesheets: [
-					{
-						src: './styles.css',
-						attributes: {
-							media: 'print',
-						},
-					},
-					{
-						content: 'body { background: red; }',
-						attributes: {
-							media: 'screen',
-						},
-					},
-				],
-			},
-		};
-		await service.processComponentDependencies([component], 'react');
-		expect(
-			capturedDeps.some((dep) => {
-				if (dep.kind !== 'script' || dep.source !== 'file') return false;
-				return (
-					dep.filepath === '/app/components/attrs-inline/client.ts' &&
-					dep.attributes?.type === 'module' &&
-					dep.attributes?.defer === '' &&
-					dep.attributes?.async === '' &&
-					dep.attributes?.['data-script-id'] === 'main-client'
-				);
-			}),
-		).toBe(true);
-		expect(
-			capturedDeps.some((dep) => {
-				if (dep.kind !== 'stylesheet' || dep.source !== 'file') return false;
-				return (
-					dep.filepath === '/app/components/attrs-inline/styles.css' &&
-					dep.attributes?.rel === 'stylesheet' &&
-					dep.attributes?.media === 'print'
-				);
-			}),
-		).toBe(true);
-		expect(
-			capturedDeps.some((dep) => {
-				if (dep.kind !== 'stylesheet' || dep.source !== 'content') return false;
-				return dep.content === 'body { background: red; }' && dep.attributes?.media === 'screen';
-			}),
-		).toBe(true);
-	});
-	it('should reject lazy script entry without src or content', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => [] as ProcessedAsset[]),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const component = ((_) => '<div></div>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'invalid-lazy-entry',
-				integration: 'react',
-				file: '/app/components/invalid-lazy-entry/component.tsx',
-			},
-			dependencies: {
-				scripts: [
-					{
-						lazy: { 'on:idle': true },
-					},
-				],
-			},
-		};
-		await expect(service.processComponentDependencies([component], 'react')).rejects.toThrow(
-			DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC,
-		);
-	});
-	it('should resolve lazy triggers by group, including lazy content entries', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (deps: AssetDefinition[]) => {
-				return deps.map((dep, index) => {
-					const lazyKey = dep.attributes?.['data-eco-lazy-key'];
-					const hasContent = dep.source === 'content' && typeof (dep as any).content === 'string';
-					const isLazyScript = dep.kind === 'script' && Boolean(lazyKey);
-					const srcUrl = isLazyScript
-						? hasContent
-							? `/assets/lazy/content-${index}.js`
-							: `/assets/lazy/file-${index}.js`
-						: undefined;
-					return {
-						kind: dep.kind ?? 'script',
-						filepath: (dep as Record<string, any>).filepath,
-						attributes: dep.attributes,
-						srcUrl,
-					} as ProcessedAsset;
-				});
-			}),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const component = ((_) => '<div></div>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'multi-lazy-groups',
-				integration: 'lit',
-				file: '/app/components/multi-lazy-groups/component.tsx',
-			},
-			dependencies: {
-				scripts: [
-					{ src: './idle.ts', lazy: { 'on:idle': true } },
-					{ content: 'console.log("visible")', lazy: { 'on:visible': '0.25' } },
-				],
-			},
-		};
-		await service.processComponentDependencies([component], 'lit');
-		expect(component.config._resolvedLazyScripts).toBeUndefined();
-		expect(component.config._resolvedLazyTriggers).toHaveLength(1);
-		const rules = component.config._resolvedLazyTriggers?.[0]?.rules ?? [];
-		const idleRule = rules.find((rule) => 'on:idle' in rule);
-		const visibleRule = rules.find((rule) => 'on:visible' in rule);
-		expect(idleRule && 'on:idle' in idleRule ? idleRule['on:idle'].scripts[0] : undefined).toMatch(
-			/^\/assets\/lazy\/file-\d+\.js$/,
-		);
-		expect(visibleRule && 'on:visible' in visibleRule ? visibleRule['on:visible'].scripts[0] : undefined).toMatch(
-			/^\/assets\/lazy\/content-\d+\.js$/,
-		);
-	});
-	it('should ignore undefined component entries when collecting nested dependencies', async () => {
-		let capturedDeps: AssetDefinition[] = [];
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (deps: AssetDefinition[]) => {
-				capturedDeps = deps;
-				return [] as ProcessedAsset[];
-			}),
-		} as unknown as AssetProcessingService;
-		const service = new DependencyResolverService(appConfig, assetProcessingService);
-		const nestedComponent = ((_) => '<button></button>') as EcoComponent<Record<string, unknown>>;
-		nestedComponent.config = {
-			__eco: {
-				id: 'theme-toggle',
-				integration: 'react',
-				file: '/app/components/theme-toggle.tsx',
-			},
-			dependencies: {
-				scripts: ['./theme-toggle.client.ts'],
-			},
-		};
-		const component = ((_) => '<div></div>') as EcoComponent<Record<string, unknown>>;
-		component.config = {
-			__eco: {
-				id: 'page',
-				integration: 'kitajs',
-				file: '/app/views/page.tsx',
-			},
-			dependencies: {
-				components: [undefined, nestedComponent] as unknown as EcoComponent[],
-			},
-		};
-		await expect(
-			service.processComponentDependencies([undefined as unknown as EcoComponent, component], 'kitajs'),
-		).resolves.toEqual([]);
-		expect(capturedDeps).toEqual([
-			expect.objectContaining({
-				kind: 'script',
-				source: 'file',
-				filepath: '/app/components/theme-toggle.client.ts',
-			}),
-		]);
-	});
-});