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

package/src/plugins/eco-component-meta-plugin.test.ts

@@ -1,380 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createEcoComponentMetaPlugin } from './eco-component-meta-plugin';
-import type { EcoPagesAppConfig } from '../internal-types';
-import { fileSystem } from '@ecopages/file-system';
-
-/**
- * Creates a regex pattern to match __eco injection with any id hash.
- * The id is a base36 hash that varies, so we match it with a pattern.
- */
-function ecoMetaPattern(file: string, integration: string): RegExp {
-	const escapedFile = file.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-	return new RegExp(`__eco: \\{ id: "[a-z0-9]+", file: "${escapedFile}", integration: "${integration}" \\}`);
-}
-
-describe('eco-component-meta-plugin', () => {
-	const Config = {
-		integrations: [
-			{
-				name: 'kitajs',
-				extensions: ['.kita.tsx'],
-			},
-			{
-				name: 'react',
-				extensions: ['.tsx'],
-			},
-			{
-				name: 'ghtml',
-				extensions: ['.ts', '.ghtml.ts'],
-			},
-		],
-	} as EcoPagesAppConfig;
-
-	const plugin = createEcoComponentMetaPlugin({ config: Config });
-
-	async function runPluginOnContent(content: string, filePath: string) {
-		let regexFilter: RegExp | undefined;
-		let onLoadCallback: any;
-
-		const buildMock = {
-			onLoad: (options: { filter: RegExp }, callback: any) => {
-				regexFilter = options.filter;
-				onLoadCallback = callback;
-			},
-		};
-
-		plugin.setup(buildMock as any);
-
-		if (!onLoadCallback || !regexFilter) {
-			throw new Error('Plugin did not register onLoad handler');
-		}
-
-		if (!regexFilter.test(filePath)) {
-			throw new Error(`File path ${filePath} does not match plugin filter ${regexFilter}`);
-		}
-
-		const fileSpy = vi.spyOn(fileSystem, 'readFileSync').mockImplementation(() => content);
-
-		try {
-			return await onLoadCallback({ path: filePath });
-		} finally {
-			fileSpy.mockRestore();
-		}
-	}
-
-	it('should inject __eco into X.config assignment in TSX files', async () => {
-		const content = `
-            MyComponent.config = {
-                dependencies: {}
-            };
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/component.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/component.tsx', 'react'));
-	});
-
-	it('should NOT inject __eco into config patterns in non-EcoComponent files', async () => {
-		const content = `
-            export const config = {
-                apiUrl: 'https://api.example.com',
-                theme: 'dark'
-            };
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/settings.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).not.toContain('__eco:');
-	});
-
-	it('should inject __eco into EcoComponent-typed object with config property', async () => {
-		const content = `
-            import type { EcoComponent } from '@ecopages/core';
-
-            export const LitCounter: EcoComponent = {
-                config: {
-                    dependencies: {
-                        scripts: ['lit-counter.script.ts'] } } };
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/lit-counter.ts');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/lit-counter.ts', 'ghtml'));
-	});
-
-	it('should inject __eco into eco.component() call', async () => {
-		const content = `
-            import { eco } from '@ecopages/core';
-            export const Counter = eco.component${'<CounterProps>'}({
-                dependencies: {
-                    scripts: ['./counter.ts'] },
-                render: () => '${'<div>'}Counter${'</div>'}' });
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/counter.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/counter.tsx', 'react'));
-		expect(result.contents).toContain('eco.component' + '<CounterProps>({');
-	});
-
-	it('should inject __eco into eco.page call', async () => {
-		const content = `
-            import { eco } from '@ecopages/core';
-            export default eco.page({
-                dependencies: {
-                    components: [] },
-                render: () => '${'<main>'}Page${'</main>'}' });
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/pages/index.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/pages/index.tsx', 'react'));
-	});
-
-	it('should inject __eco into eco.layout call', async () => {
-		const content = `
-            import { eco } from '@ecopages/core';
-            export const MainLayout = eco.layout({
-                render: ({ children }) => '${'<main>'}' + children + '${'</main>'}' });
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/layouts/main-layout.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/layouts/main-layout.tsx', 'react'));
-	});
-
-	it('should inject __eco into eco.html call', async () => {
-		const content = `
-            import { eco } from '@ecopages/core';
-            export default eco.html({
-                render: ({ children }) => '${'<html><body>'}' + children + '${'</body></html>'}' });
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/html.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/html.tsx', 'react'));
-	});
-
-	it('should inject __eco into eco.component() with lazy dependencies', async () => {
-		const content = `
-            export const LazyCounter = eco.component({
-                dependencies: {
-					scripts: [{ src: './counter.ts', lazy: { 'on:interaction': 'click' } }] },
-                render: () => '${'<div>'}Lazy${'</div>'}' });
-        `;
-
-		const result = await runPluginOnContent(content, '/path/to/lazy-counter.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/lazy-counter.tsx', 'react'));
-	});
-
-	it('should detect kitajs integration from .kita.tsx extension', async () => {
-		const content = `import { eco } from '@ecopages/core';
-import type { PageHeadProps } from '@ecopages/core';
-
-export const Head = eco.component<PageHeadProps<string>>({
-	dependencies: {
-		stylesheets: ['../styles/global.css'] },
-	render: ({ metadata, children }) => (
-		<head>
-			<meta charset="UTF-8" />
-			{children}
-		</head>
-	) });`;
-
-		const result = await runPluginOnContent(content, '/path/to/includes/head.kita.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/includes/head.kita.tsx', 'kitajs'));
-	});
-
-	it('should handle eco.page with complex generic types', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export default eco.page<{ title: string; callback: (arg: string) => void }>({
-	staticProps: async () => ({ props: { title: 'Hello', callback: () => {} } }),
-	render: (props) => '<div>' + props.title + '</div>' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/pages/complex.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/pages/complex.tsx', 'react'));
-	});
-
-	it('should handle multiple eco.component calls in same file', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export const Button = eco.component({
-	render: () => '<button>Click</button>' });
-
-export const Input = eco.component({
-	render: () => '<input type="text" />' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/components.tsx');
-
-		expect(result).toBeDefined();
-		const matches = result.contents.match(
-			/__eco: \{ id: "[a-z0-9]+", file: "\/path\/to\/components\.tsx", integration: "react" \},/g,
-		);
-		expect(matches).toHaveLength(2);
-	});
-
-	it('should handle eco.component with empty config object', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export const Simple = eco.component({});
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/simple.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/simple.tsx', 'react'));
-	});
-
-	it('should not inject into non-eco call expressions', async () => {
-		const content = `
-import { other } from 'some-lib';
-
-export const Thing = other.component({
-	render: () => '<div>Thing</div>' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/thing.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).not.toContain('__eco:');
-	});
-
-	it('should not inject into non-config variable declarations', async () => {
-		const content = `
-const settings = {
-	theme: 'dark',
-	locale: 'en' };
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/settings.ts');
-
-		expect(result).toBeDefined();
-		expect(result.contents).not.toContain('__eco:');
-	});
-
-	it('should handle file paths with special characters in directory', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export default eco.page({
-	render: () => '<div>Page</div>' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/my-app/pages/index.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/my-app/pages/index.tsx', 'react'));
-	});
-
-	it('should handle eco.component with nested object in dependencies', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export const LazyComponent = eco.component({
-	dependencies: {
-		stylesheets: ['./style.css'],
-		scripts: [{ src: './script.ts', lazy: { 'on:interaction': 'click' } }],
-		components: [] },
-	render: () => '<div>Lazy</div>' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/lazy.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/lazy.tsx', 'react'));
-	});
-
-	it('should preserve original code structure after injection', async () => {
-		const content = `import { eco } from '@ecopages/core';
-
-export const Counter = eco.component({
-	dependencies: {
-		scripts: ['./counter.ts'] },
-	render: () => '<button>0</button>' });`;
-
-		const result = await runPluginOnContent(content, '/path/to/counter.tsx');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toContain("import { eco } from '@ecopages/core';");
-		expect(result.contents).toContain("scripts: ['./counter.ts']");
-		expect(result.contents).toContain("render: () => '<button>0</button>'");
-	});
-
-	it('should handle query string in file path for cache busting', async () => {
-		const content = `
-import { eco } from '@ecopages/core';
-
-export default eco.page({
-	render: () => '<div>Page</div>' });
-`;
-
-		const result = await runPluginOnContent(content, '/path/to/pages/index.tsx?update=123456');
-
-		expect(result).toBeDefined();
-		expect(result.contents).toMatch(ecoMetaPattern('/path/to/pages/index.tsx', 'react'));
-	});
-
-	describe('Regression: eco-blog views failure', () => {
-		it('should inject __eco into a kitajs page with complex props and no manual __eco', async () => {
-			const content = `import { eco } from '@ecopages/core';
-import { MainLayout } from '@/layouts/main-layout.kita';
-import type { Post } from '@/lib/db';
-
-export interface BlogListProps {
-	posts: Post[];
-}
-
-export const BlogList = eco.page<BlogListProps>({
-	layout: MainLayout,
-	metadata: () => ({
-		title: 'EcoBlog | Home',
-		description: 'A blog about sustainability and technology' }),
-	render: ({ posts }) => {
-		return (
-			<div class="max-w-3xl mx-auto space-y-12">
-                {/* content */}
-			</div>
-		);
-	} });`;
-
-			const result = await runPluginOnContent(
-				content,
-				'/path/to/playground/eco-blog/src/views/blog-list.kita.tsx',
-			);
-
-			expect(result).toBeDefined();
-			expect(result.contents).toMatch(
-				ecoMetaPattern('/path/to/playground/eco-blog/src/views/blog-list.kita.tsx', 'kitajs'),
-			);
-		});
-
-		it('should inject __eco even if the eco call is not at the top level', async () => {
-			const content = `
-                import { eco } from '@ecopages/core';
-                const createPage = () => eco.page({ render: () => 'hi' });
-                export default createPage();
-            `;
-			const result = await runPluginOnContent(content, '/path/to/nested.tsx');
-			expect(result.contents).toMatch(ecoMetaPattern('/path/to/nested.tsx', 'react'));
-		});
-	});
-});

package/src/plugins/integration-plugin.test.ts

@@ -1,111 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { IntegrationPlugin, type IntegrationPluginConfig } from './integration-plugin';
-import type { IHmrManager } from '../public-types';
-import type { AssetDefinition } from '../services/assets/asset-processing-service';
-
-class TestIntegrationPlugin extends IntegrationPlugin {
-	renderer = vi.fn() as any;
-	override setup(): Promise<void> {
-		return Promise.resolve();
-	}
-
-	override teardown(): Promise<void> {
-		return Promise.resolve();
-	}
-}
-
-describe('IntegrationPlugin', () => {
-	let plugin: TestIntegrationPlugin;
-	const config: IntegrationPluginConfig = {
-		name: 'test-plugin',
-		extensions: ['.test'],
-		integrationDependencies: [],
-	};
-
-	beforeEach(() => {
-		plugin = new TestIntegrationPlugin(config);
-	});
-
-	it('should initialize with correct config values', () => {
-		expect(plugin.name).toBe(config.name);
-		expect(plugin.extensions).toEqual(config.extensions);
-		expect(plugin.runtimeCapability).toBeUndefined();
-		expect(plugin.getResolvedIntegrationDependencies()).toEqual(
-			config.integrationDependencies as AssetDefinition[],
-		);
-	});
-
-	it('should retain runtime capability declarations', () => {
-		const pluginWithRuntimeCapability = new TestIntegrationPlugin({
-			name: 'runtime-capable',
-			extensions: ['.test'],
-			runtimeCapability: {
-				tags: ['bun-only'],
-				minRuntimeVersion: '1.0.0',
-			},
-		});
-
-		expect(pluginWithRuntimeCapability.runtimeCapability).toEqual({
-			tags: ['bun-only'],
-			minRuntimeVersion: '1.0.0',
-		});
-	});
-
-	it('should initialize with empty dependencies if not provided', () => {
-		const pluginWithoutDeps = new TestIntegrationPlugin({
-			name: 'test',
-			extensions: [],
-		});
-		expect(pluginWithoutDeps.getResolvedIntegrationDependencies()).toEqual([]);
-	});
-
-	it('should implement setup and teardown methods', async () => {
-		await expect(plugin.setup()).resolves.toBeUndefined();
-		await expect(plugin.teardown()).resolves.toBeUndefined();
-	});
-
-	it('should not defer component boundaries by default', () => {
-		expect(
-			plugin.shouldDeferComponentBoundary({
-				currentIntegration: 'ghtml',
-				targetIntegration: 'react',
-				component: () => '<div></div>',
-			}),
-		).toBe(false);
-	});
-
-	it('should register runtime specifier maps through the base HMR setup', () => {
-		const registerSpecifierMap = vi.fn();
-		const hmrManager = {
-			registerSpecifierMap,
-			registerStrategy: vi.fn(),
-			registerEntrypoint: vi.fn(),
-			registerScriptEntrypoint: vi.fn(),
-			setPlugins: vi.fn(),
-			setEnabled: vi.fn(),
-			isEnabled: vi.fn(() => true),
-			broadcast: vi.fn(),
-			getOutputUrl: vi.fn(),
-			getWatchedFiles: vi.fn(() => new Map()),
-			getSpecifierMap: vi.fn(() => new Map()),
-			getDistDir: vi.fn(() => ''),
-			getPlugins: vi.fn(() => []),
-			getDefaultContext: vi.fn(),
-			handleFileChange: vi.fn(),
-		} satisfies IHmrManager;
-
-		const pluginWithRuntimeSpecifiers = new (class extends TestIntegrationPlugin {
-			override getRuntimeSpecifierMap(): Record<string, string> {
-				return {
-					'test-runtime': '/assets/vendors/test-runtime.js',
-				};
-			}
-		})(config);
-
-		pluginWithRuntimeSpecifiers.setHmrManager(hmrManager);
-
-		expect(registerSpecifierMap).toHaveBeenCalledWith({
-			'test-runtime': '/assets/vendors/test-runtime.js',
-		});
-	});
-});

package/src/plugins/processor.test.ts

@@ -1,148 +0,0 @@
-import { afterAll, beforeEach, describe, expect, test } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import type { EcoBuildPlugin } from '../build/build-types.ts';
-import type { EcoPagesAppConfig } from '../internal-types';
-import { Processor, type ProcessorConfig } from './processor.ts';
-
-class TestProcessor extends Processor {
-	override buildPlugins?: EcoBuildPlugin[] = [];
-	override plugins?: EcoBuildPlugin[] = [];
-
-	override async setup(): Promise<void> {}
-
-	override async process(input: unknown, _filePath?: string): Promise<unknown> {
-		return input;
-	}
-
-	override async teardown(): Promise<void> {}
-}
-
-describe('Processor', () => {
-	let processor: TestProcessor;
-	let config: ProcessorConfig;
-	let appConfig: EcoPagesAppConfig;
-
-	beforeEach(() => {
-		config = {
-			name: 'test-processor',
-			options: { test: true },
-			watch: {
-				paths: ['/test'],
-			},
-		};
-
-		const testRoot = path.join(process.cwd(), '.test-tmp', 'processor-test');
-
-		if (fs.existsSync(testRoot)) {
-			fs.rmSync(testRoot, { recursive: true, force: true });
-		}
-
-		appConfig = {
-			rootDir: testRoot,
-			absolutePaths: {
-				srcDir: path.join(testRoot, 'src'),
-				distDir: path.join(testRoot, 'dist'),
-			},
-		} as EcoPagesAppConfig;
-
-		processor = new TestProcessor(config);
-		processor.setContext(appConfig);
-	});
-
-	afterAll(() => {
-		fs.rmSync(path.join(process.cwd(), '.test-tmp'), { recursive: true, force: true });
-	});
-
-	test('should initialize with correct name', () => {
-		expect(processor.getName()).toBe('test-processor');
-	});
-
-	test('should retain runtime capability declarations', () => {
-		const runtimeProcessor = new TestProcessor({
-			name: 'runtime-processor',
-			runtimeCapability: {
-				tags: ['requires-node-builtins'],
-				minRuntimeVersion: '18.0.0',
-			},
-		});
-
-		expect(runtimeProcessor.runtimeCapability).toEqual({
-			tags: ['requires-node-builtins'],
-			minRuntimeVersion: '18.0.0',
-		});
-	});
-
-	test('should return watch config', () => {
-		expect(processor.getWatchConfig()).toEqual({
-			paths: ['/test'],
-		});
-	});
-});
-
-describe('Processor capability matching', () => {
-	test('matches all extensions with * pattern', () => {
-		const processor = new TestProcessor({
-			name: 'wildcard-all',
-			capabilities: [{ kind: 'stylesheet', extensions: ['*'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.scss')).toBe(true);
-	});
-
-	test('matches explicit *.ext patterns', () => {
-		const processor = new TestProcessor({
-			name: 'wildcard-explicit',
-			capabilities: [{ kind: 'stylesheet', extensions: ['*.css'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.scss')).toBe(false);
-	});
-
-	test('matches grouped extension patterns', () => {
-		const processor = new TestProcessor({
-			name: 'wildcard-group',
-			capabilities: [{ kind: 'stylesheet', extensions: ['*.{css,scss,sass}'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.scss')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.sass')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.less')).toBe(false);
-	});
-
-	test('matches grouped patterns with mixed case and spacing', () => {
-		const processor = new TestProcessor({
-			name: 'wildcard-group-normalized',
-			capabilities: [{ kind: 'stylesheet', extensions: ['*.{ CSS, ScSs , .SASS }'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.scss')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.sass')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.less')).toBe(false);
-	});
-
-	test('matches plain extension and dotted extension forms', () => {
-		const processor = new TestProcessor({
-			name: 'plain-ext',
-			capabilities: [{ kind: 'stylesheet', extensions: ['css', '.scss'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.scss')).toBe(true);
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.sass')).toBe(false);
-	});
-
-	test('respects capability kind filtering', () => {
-		const processor = new TestProcessor({
-			name: 'kind-filter',
-			capabilities: [{ kind: 'image', extensions: ['*.png'] }],
-		});
-
-		expect(processor.canProcessAsset('stylesheet', '/src/styles/app.css')).toBe(false);
-		expect(processor.canProcessAsset('image', '/src/assets/logo.png')).toBe(true);
-	});
-});

package/src/route-renderer/component-graph/component-graph-executor.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createComponentMarker } from './component-marker.ts';
-import { extractComponentGraph } from './component-graph.ts';
-import { resolveComponentGraph } from './component-graph-executor.ts';
-
-describe('component graph executor', () => {
-	it('resolves markers bottom-up using graph levels', async () => {
-		const html = [
-			'<main>',
-			createComponentMarker({
-				nodeId: 'n_1',
-				integration: 'lit',
-				componentRef: 'c_parent',
-				propsRef: 'p_parent',
-				slotRef: 's_parent',
-			}),
-			createComponentMarker({
-				nodeId: 'n_2',
-				integration: 'react',
-				componentRef: 'c_child',
-				propsRef: 'p_child',
-			}),
-			'</main>',
-		].join('');
-
-		const graph = extractComponentGraph(html, {
-			s_parent: ['n_2'],
-		});
-
-		const resolved = await resolveComponentGraph(html, graph, async (marker) => {
-			if (marker.nodeId === 'n_2') {
-				return { html: '<section>child</section>' };
-			}
-			return { html: '<article>parent</article>' };
-		});
-
-		expect(resolved).toContain('<article>parent</article>');
-		expect(resolved).toContain('<section>child</section>');
-		expect(resolved).not.toContain('<eco-marker');
-	});
-});