@ecopages/core 0.2.0-alpha.1 → 0.2.0-alpha.11

package/src/hmr/client/hmr-runtime.ts

@@ -1,121 +0,0 @@
-/**
- * Ecopages HMR Runtime
- * Injected into the browser to handle Hot Module Replacement updates.
- */
-
-interface HMRPayload {
-	type: 'reload' | 'error' | 'update' | 'css-update' | 'layout-update';
-	path?: string;
-	message?: string;
-	timestamp?: number;
-}
-
-(function () {
-	const WS_URL = 'ws://' + location.host + '/_hmr';
-	let socket: WebSocket;
-	let reconnectAttempts = 0;
-
-	function connect() {
-		socket = new WebSocket(WS_URL);
-
-		socket.addEventListener('open', () => {
-			console.log('[ecopages] HMR Connected');
-			reconnectAttempts = 0;
-		});
-
-		socket.addEventListener('message', async (event) => {
-			try {
-				const payload: HMRPayload = JSON.parse(event.data);
-				handleMessage(payload);
-			} catch (e) {
-				console.error('[ecopages] Invalid HMR message:', e);
-			}
-		});
-
-		socket.addEventListener('close', () => {
-			if (reconnectAttempts < 10) {
-				setTimeout(connect, 1000 * 2 ** reconnectAttempts);
-				reconnectAttempts++;
-			}
-		});
-	}
-
-	async function handleMessage(payload: HMRPayload) {
-		switch (payload.type) {
-			case 'reload':
-				location.reload();
-				break;
-			case 'layout-update': {
-				const reloadFn = window.__ecopages_reload_current_page__;
-				if (typeof reloadFn === 'function') {
-					await reloadFn({ clearCache: true });
-				} else {
-					location.reload();
-				}
-				break;
-			}
-			case 'error':
-				console.error('[ecopages] HMR Error:', payload.message);
-				break;
-			case 'update':
-				if (payload.path) {
-					await applyUpdate(payload.path, payload.timestamp);
-				}
-				break;
-			case 'css-update':
-				if (payload.path) {
-					refreshStylesheet(payload.path);
-				}
-				break;
-		}
-	}
-
-	/**
-	 * Applies a module update by calling registered HMR handlers or re-importing the module.
-	 * @param path - The module path to update
-	 * @param timestamp - Optional timestamp for cache busting
-	 */
-	async function applyUpdate(path: string, timestamp?: number) {
-		try {
-			const url = path + '?t=' + (timestamp || Date.now());
-			const handlers = window.__ecopages_hmr_handlers__;
-
-			if (handlers?.[path]) {
-				await handlers[path](url);
-				return;
-			}
-
-			await import(url);
-
-			// If we're inside the EcoRouter, we need to trigger a router navigation to render the new component.
-			// Passing clearCache: false preserves the persisted layout cache.
-			const reloadFn = window.__ecopages_reload_current_page__;
-			if (typeof reloadFn === 'function') {
-				await reloadFn({ clearCache: false });
-			}
-		} catch (e) {
-			console.error('[ecopages] Failed to apply HMR update:', e);
-		}
-	}
-
-	/**
-	 * Hot-reload CSS by updating stylesheet link href with cache-busting query param.
-	 * This causes the browser to re-fetch the stylesheet without a full page reload.
-	 */
-	function refreshStylesheet(path: string) {
-		const filename = path.split('/').pop() || '';
-		const links = document.querySelectorAll('link[rel="stylesheet"]');
-
-		links.forEach((link) => {
-			const href = (link as HTMLLinkElement).href;
-			if (href.includes(filename) || href.includes(path.replace(/^.*\/src\//, '/assets/'))) {
-				const url = new URL(href, location.origin);
-				url.searchParams.set('t', Date.now().toString());
-				(link as HTMLLinkElement).href = url.toString();
-				console.log('[ecopages] CSS updated:', filename);
-			}
-		});
-	}
-
-	connect();
-})();

package/src/hmr/hmr-strategy.ts

@@ -1,172 +0,0 @@
-import type { ClientBridgeEvent } from '../public-types';
-
-/**
- * HMR Strategy Pattern
- *
- * This module defines the base classes and types for Hot Module Replacement strategies.
- * Each strategy handles a specific type of file change and determines how to process it.
- *
- * @module
- * @example
- * ```typescript
- * class CustomHmrStrategy extends HmrStrategy {
- *   readonly type = HmrStrategyType.INTEGRATION;
- *
- *   matches(filePath: string): boolean {
- *     return filePath.endsWith('.custom');
- *   }
- *
- *   async process(filePath: string): Promise<HmrAction> {
- *     return {
- *       type: 'broadcast',
- *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }]
- *     };
- *   }
- * }
-
- * Defines the category of an HMR strategy, which determines its execution priority.
- * Strategies are evaluated in descending order: INTEGRATION → ASSET → SCRIPT → FALLBACK.
- *
- * @remarks
- * The numeric values represent base priorities. Strategies can fine-tune their priority
- * using the `priorityOffset` property.
- */
-export enum HmrStrategyType {
-	/**
-	 * Integration-specific strategies (React, Lit, etc.)
-	 * Highest priority to allow framework-specific HMR handling.
-	 */
-	INTEGRATION = 100,
-
-	/**
-	 * Asset processing strategies (CSS, images, etc.)
-	 * High priority for specialized asset handling.
-	 */
-	ASSET = 50,
-
-	/**
-	 * Generic script bundling strategies (JS/TS)
-	 * Medium priority for standard script processing.
-	 */
-	SCRIPT = 25,
-
-	/**
-	 * Fallback strategy for unhandled file types.
-	 * Lowest priority, triggers full page reload.
-	 */
-	FALLBACK = 0,
-}
-
-/**
- * Represents an action to be taken after processing a file change.
- */
-export interface HmrAction {
-	/**
-	 * Whether to broadcast an HMR event to connected clients.
-	 */
-	type: 'broadcast' | 'none';
-
-	/**
-	 * The HMR events to broadcast, if type is 'broadcast'.
-	 * capable of broadcasting multiple events at once.
-	 */
-	events?: ClientBridgeEvent[];
-}
-
-/**
- * Base class for HMR strategies.
- *
- * Each strategy handles a specific type of file change and determines how to process it.
- * Strategies are selected based on their priority (higher values are evaluated first) and
- * whether they match the changed file path.
- *
- * @remarks
- * Strategies should be stateless and idempotent. The same file change should always
- * produce the same result when processed by the same strategy.
- *
- * @example
- * ```typescript
- * class MyAssetStrategy extends HmrStrategy {
- *   readonly type = HmrStrategyType.ASSET;
- *   readonly priorityOffset = 5;
- *
- *   matches(filePath: string): boolean {
- *     return /\.(png|jpg|svg)$/.test(filePath);
- *   }
- *
- *   async process(filePath: string): Promise<HmrAction> {
- *     await this.optimizeImage(filePath);
- *     return {
- *       type: 'broadcast',
- *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }]
- *     };
- *   }
- * }
- * ```
- */
-export abstract class HmrStrategy {
-	/**
-	 * The category of this strategy, determining its base priority.
-	 */
-	abstract readonly type: HmrStrategyType;
-
-	/**
-	 * Optional offset to fine-tune priority within the same category.
-	 * Useful when multiple strategies share the same type.
-	 *
-	 * @defaultValue 0
-	 */
-	readonly priorityOffset: number = 0;
-
-	/**
-	 * Computed priority for strategy selection.
-	 * Higher values are evaluated first.
-	 *
-	 * @returns The sum of the strategy type and priority offset
-	 */
-	get priority(): number {
-		return this.type + this.priorityOffset;
-	}
-
-	/**
-	 * Determines if this strategy can handle the given file path.
-	 *
-	 * @param filePath - Absolute path to the changed file
-	 * @returns True if this strategy should process the file
-	 *
-	 * @example
-	 * ```typescript
-	 * matches(filePath: string): boolean {
-	 *   return filePath.endsWith('.css');
-	 * }
-	 * ```
-	 */
-	abstract matches(filePath: string): boolean;
-
-	/**
-	 * Processes a file change and returns the action to take.
-	 *
-	 * This method may perform side effects such as:
-	 * - Rebuilding files
-	 * - Writing to disk
-	 * - Transforming code
-	 * - Updating caches
-	 *
-	 * @param filePath - Absolute path to the changed file
-	 * @returns Action to take (broadcast event or none)
-	 *
-	 * @example
-	 * ```typescript
-	 * async process(filePath: string): Promise<HmrAction> {
-	 *   const processed = await this.transform(filePath);
-	 *   await Bun.write(outputPath, processed);
-	 *
-	 *   return {
-	 *     type: 'broadcast',
-	 *     events: [{ type: 'update', path: outputPath, timestamp: Date.now() }]
-	 *   };
-	 * }
-	 * ```
-	 */
-	abstract process(filePath: string): Promise<HmrAction>;
-}

package/src/hmr/hmr.test.e2e.ts

@@ -1,75 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { readFileSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-
-/**
- * HMR E2E Tests
- *
- * True end-to-end tests for Hot Module Replacement using Playwright.
- * These tests modify actual source files and verify the browser updates.
- *
- * Run with: bunx playwright test packages/core/src/hmr/hmr.e2e.test.ts
- */
-
-const FIXTURE_DIR = resolve(process.cwd(), 'packages/core/__fixtures__/app');
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, 'src/pages/index.css');
-const BUILT_CSS_FILE = resolve(FIXTURE_DIR, '.eco/assets/pages/index.css');
-const TEST_URL = 'http://localhost:3002';
-
-test.describe('HMR E2E', () => {
-	test('should load page with .main-title element', async ({ page }) => {
-		await page.goto(TEST_URL, { waitUntil: 'networkidle' });
-		const title = page.locator('.main-title').first();
-		await expect(title).toBeVisible();
-	});
-
-	test('should connect to HMR WebSocket', async ({ page }) => {
-		await page.goto(TEST_URL);
-
-		const connected = await page.evaluate(async () => {
-			return new Promise<boolean>((resolve) => {
-				const ws = new WebSocket('ws://localhost:3002/_hmr');
-				ws.onopen = () => {
-					ws.close();
-					resolve(true);
-				};
-				ws.onerror = () => resolve(false);
-				setTimeout(() => resolve(false), 5000);
-			});
-		});
-
-		expect(connected).toBe(true);
-	});
-
-	test('should reload page when CSS file changes', async ({ page }) => {
-		const originalCss = readFileSync(TEST_CSS_FILE, 'utf-8');
-
-		await page.goto(TEST_URL, { waitUntil: 'networkidle' });
-
-		const initialColor = await page.evaluate(() => {
-			const el = document.querySelector('.main-title');
-			return el ? getComputedStyle(el).color : null;
-		});
-
-		expect(initialColor).toBeTruthy();
-
-		const modifiedCss = originalCss.replace('.main-title {', '.main-title {\n\tcolor: rgb(255, 0, 0);');
-
-		const loadPromise = page.waitForEvent('load', { timeout: 10000 });
-
-		await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-		await writeFile(BUILT_CSS_FILE, modifiedCss, { flush: true });
-
-		await loadPromise;
-
-		const updatedColor = await page.evaluate(() => {
-			const el = document.querySelector('.main-title');
-			return el ? getComputedStyle(el).color : null;
-		});
-
-		expect(updatedColor).toBe('rgb(255, 0, 0)');
-
-		await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-	});
-});

package/src/hmr/strategies/default-hmr-strategy.ts

@@ -1,60 +0,0 @@
-/**
- * Default HMR Strategy
- *
- * Fallback strategy for file types that don't have specialized handling.
- * Triggers a full page reload to ensure changes are reflected.
- *
- * @module
- */
-
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
-
-/**
- * Default fallback strategy for unhandled file types.
- *
- * This strategy matches all files and triggers a full page reload.
- * It has the lowest priority (FALLBACK) and acts as a catch-all when
- * no other strategy matches the changed file.
- *
- * @remarks
- * This strategy ensures that all file changes result in some action,
- * even if we don't have specialized handling for that file type.
- *
- * @example
- * ```typescript
- * const strategy = new DefaultHmrStrategy();
- * const action = await strategy.process('/path/to/unknown.file');
- * ```
- */
-export class DefaultHmrStrategy extends HmrStrategy {
-	readonly type = HmrStrategyType.FALLBACK;
-
-	/**
-	 * Matches all file paths.
-	 *
-	 * @param _filePath - Absolute path to the changed file (unused)
-	 * @returns Always returns true as this is a catch-all strategy
-	 */
-	matches(_filePath: string): boolean {
-		return true;
-	}
-
-	/**
-	 * Processes a file change by triggering a full page reload.
-	 *
-	 * @param filePath - Absolute path to the changed file
-	 * @returns Action to broadcast a reload event
-	 */
-	async process(filePath: string): Promise<HmrAction> {
-		return {
-			type: 'broadcast',
-			events: [
-				{
-					type: 'reload',
-					path: filePath,
-					message: 'fallback-strategy',
-				},
-			],
-		};
-	}
-}