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

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

@@ -0,0 +1,109 @@
+import { getEcoNavigationRuntime } from "../../router/client/navigation-coordinator.js";
+(function() {
+  const WS_URL = "ws://" + location.host + "/_hmr";
+  let socket;
+  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 = JSON.parse(event.data);
+        handleMessage(payload);
+      } catch (e) {
+        console.error("[ecopages] Invalid HMR message:", e);
+      }
+    });
+    socket.addEventListener("close", () => {
+      if (reconnectAttempts < 10) {
+        setTimeout(connect, 1e3 * 2 ** reconnectAttempts);
+        reconnectAttempts++;
+      }
+    });
+  }
+  async function handleMessage(payload) {
+    const navigationRuntime = getEcoNavigationRuntime(window);
+    switch (payload.type) {
+      case "reload":
+        await waitForNavigationToSettle(navigationRuntime);
+        location.reload();
+        break;
+      case "layout-update": {
+        await waitForNavigationToSettle(navigationRuntime);
+        if (await navigationRuntime.reloadCurrentPage({ 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;
+    }
+  }
+  async function applyUpdate(path, timestamp) {
+    try {
+      const url = path + "?t=" + (timestamp || Date.now());
+      const handlers = window.__ECO_PAGES__?.hmrHandlers;
+      const navigationRuntime = getEcoNavigationRuntime(window);
+      await waitForNavigationToSettle(navigationRuntime);
+      if (handlers?.[path]) {
+        await handlers[path](url);
+        return;
+      }
+      await import(url);
+      if (await navigationRuntime.reloadCurrentPage({ clearCache: false })) {
+      }
+    } catch (e) {
+      console.error("[ecopages] Failed to apply HMR update:", e);
+    }
+  }
+  async function waitForNavigationToSettle(navigationRuntime) {
+    if (!navigationRuntime.hasPendingNavigationTransaction()) {
+      return;
+    }
+    await new Promise((resolve) => {
+      const startedAt = performance.now();
+      const timeoutMs = 2e3;
+      const poll = () => {
+        if (!navigationRuntime.hasPendingNavigationTransaction()) {
+          resolve();
+          return;
+        }
+        if (performance.now() - startedAt >= timeoutMs) {
+          resolve();
+          return;
+        }
+        requestAnimationFrame(poll);
+      };
+      requestAnimationFrame(poll);
+    });
+  }
+  function refreshStylesheet(path) {
+    const filename = path.split("/").pop() || "";
+    const links = document.querySelectorAll('link[rel="stylesheet"]');
+    links.forEach((link) => {
+      const href = link.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.href = url.toString();
+        console.log("[ecopages] CSS updated:", filename);
+      }
+    });
+  }
+  connect();
+})();

package/src/hmr/hmr-strategy.d.ts

@@ -0,0 +1,159 @@
+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 declare 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 declare 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;
+    /**
+     * Computed priority for strategy selection.
+     * Higher values are evaluated first.
+     *
+     * @returns The sum of the strategy type and priority offset
+     */
+    get priority(): number;
+    /**
+     * 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-strategy.js

@@ -0,0 +1,29 @@
+var HmrStrategyType = /* @__PURE__ */ ((HmrStrategyType2) => {
+  HmrStrategyType2[HmrStrategyType2["INTEGRATION"] = 100] = "INTEGRATION";
+  HmrStrategyType2[HmrStrategyType2["ASSET"] = 50] = "ASSET";
+  HmrStrategyType2[HmrStrategyType2["SCRIPT"] = 25] = "SCRIPT";
+  HmrStrategyType2[HmrStrategyType2["FALLBACK"] = 0] = "FALLBACK";
+  return HmrStrategyType2;
+})(HmrStrategyType || {});
+class HmrStrategy {
+  /**
+   * Optional offset to fine-tune priority within the same category.
+   * Useful when multiple strategies share the same type.
+   *
+   * @defaultValue 0
+   */
+  priorityOffset = 0;
+  /**
+   * Computed priority for strategy selection.
+   * Higher values are evaluated first.
+   *
+   * @returns The sum of the strategy type and priority offset
+   */
+  get priority() {
+    return this.type + this.priorityOffset;
+  }
+}
+export {
+  HmrStrategy,
+  HmrStrategyType
+};

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

@@ -0,0 +1 @@
+export {};

package/src/hmr/hmr.postcss.test.e2e.js

@@ -0,0 +1,31 @@
+import { test, expect } from "@playwright/test";
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
+const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/postcss-hmr.css");
+test.describe("HMR E2E PostCSS", () => {
+  test("should hot-update processor-owned CSS without a full page reload", async ({ page }) => {
+    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
+    const title = page.locator(".postcss-title").first();
+    try {
+      await page.goto("/postcss-hmr", { waitUntil: "networkidle" });
+      await expect(title).toBeVisible();
+      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
+      expect(initialColor).toBeTruthy();
+      await page.evaluate(() => {
+        window.__postcssReloadProbe = "before-change";
+      });
+      const modifiedCss = originalCss.replace(".postcss-title {", ".postcss-title {\n	color: rgb(255, 0, 0);");
+      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
+      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
+      await expect(
+        page.evaluate(
+          () => window.__postcssReloadProbe ?? null
+        )
+      ).resolves.toBe("before-change");
+    } finally {
+      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
+    }
+  });
+});

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

@@ -0,0 +1 @@
+export {};

package/src/hmr/hmr.test.e2e.js

@@ -0,0 +1,43 @@
+import { test, expect } from "@playwright/test";
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
+const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/index.css");
+test.describe("HMR E2E", () => {
+  test("should load page with .main-title element", async ({ page }) => {
+    await page.goto("/", { waitUntil: "networkidle" });
+    const title = page.locator(".main-title").first();
+    await expect(title).toBeVisible();
+  });
+  test("should connect to HMR WebSocket", async ({ page }) => {
+    const socketPromise = page.waitForEvent("websocket", {
+      predicate: (socket2) => socket2.url().endsWith("/_hmr"),
+      timeout: 1e4
+    });
+    await page.goto("/", { waitUntil: "networkidle" });
+    const socket = await socketPromise;
+    expect(socket.url()).toMatch(/\/_hmr$/);
+  });
+  test("should fall back to a full page reload when raw CSS file changes", async ({ page }) => {
+    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
+    const title = page.locator(".main-title").first();
+    try {
+      await page.goto("/", { waitUntil: "networkidle" });
+      await expect(title).toBeVisible();
+      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
+      expect(initialColor).toBeTruthy();
+      const modifiedCss = originalCss.replace(".main-title {", ".main-title {\n	color: rgb(255, 0, 0);");
+      const reloadPromise = page.waitForEvent("framenavigated", {
+        predicate: (frame) => frame === page.mainFrame(),
+        timeout: 1e4
+      });
+      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
+      await reloadPromise;
+      await page.waitForLoadState("networkidle");
+      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
+    } finally {
+      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
+    }
+  });
+});

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

@@ -0,0 +1,43 @@
+/**
+ * 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 declare 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;
+    /**
+     * 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
+     */
+    process(filePath: string): Promise<HmrAction>;
+}

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

@@ -0,0 +1,34 @@
+import { HmrStrategy, HmrStrategyType } from "../hmr-strategy";
+class DefaultHmrStrategy extends HmrStrategy {
+  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) {
+    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) {
+    return {
+      type: "broadcast",
+      events: [
+        {
+          type: "reload",
+          path: filePath,
+          message: "fallback-strategy"
+        }
+      ]
+    };
+  }
+}
+export {
+  DefaultHmrStrategy
+};

package/src/hmr/strategies/js-hmr-strategy.d.ts

@@ -0,0 +1,139 @@
+/**
+ * JavaScript HMR Strategy
+ *
+ * Handles hot module replacement for JavaScript and TypeScript entrypoints.
+ * Bundles files, inspects the emitted output, and decides whether the browser
+ * can hot-accept the change or must reload.
+ *
+ * @module
+ */
+import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
+import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.js';
+import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
+/**
+ * Context interface providing access to HmrManager state.
+ * Required for JsHmrStrategy to access registered entrypoints and configuration.
+ */
+export interface JsHmrContext {
+    /**
+     * Map of registered entrypoints to their output URLs.
+     */
+    getWatchedFiles(): Map<string, string>;
+    /**
+     * Map of bare specifiers to vendor URLs for import resolution.
+     */
+    getSpecifierMap(): Map<string, string>;
+    getEntrypointDependencyGraph(): EntrypointDependencyGraph;
+    /**
+     * Directory where HMR bundles are written.
+     */
+    getDistDir(): string;
+    /**
+     * Build plugins to use during bundling.
+     */
+    getPlugins(): EcoBuildPlugin[];
+    /**
+     * Absolute path to the source directory.
+     */
+    getSrcDir(): string;
+    /**
+     * Absolute path to the pages directory.
+     */
+    getPagesDir(): string;
+    /**
+     * Absolute path to the layouts directory.
+     */
+    getLayoutsDir(): string;
+    /**
+     * All configured route-template extensions across integrations.
+     */
+    getTemplateExtensions(): string[];
+    /**
+     * Browser bundler used to rebuild changed entrypoints.
+     */
+    getBrowserBundleService(): BrowserBundleExecutor;
+    /**
+     * Returns whether a watched entrypoint should be rebuilt by the generic JS strategy.
+     *
+     * @remarks
+     * Integrations with higher-priority HMR strategies can use this to keep the
+     * generic JS strategy from overwriting their emitted entrypoints when a shared
+     * dependency changes.
+     */
+    shouldProcessEntrypoint?(entrypointPath: string): boolean;
+}
+/**
+ * Strategy for handling JavaScript/TypeScript file changes with hot reloading.
+ *
+ * The processing steps are:
+ * 1. Check if any entrypoints are registered
+ * 2. Rebuild impacted entrypoints, or all watched entrypoints when no runtime
+ *    dependency graph is available
+ * 3. Emit rebuilt entrypoint bundles for browser delivery
+ * 4. Inject generic HMR boilerplate
+ * 5. Broadcast update events for each rebuilt entrypoint
+ *
+ * @remarks
+ * Node can provide dependency-graph metadata, so this strategy can rebuild only
+ * the entrypoints impacted by a changed dependency. Runtimes that do not expose
+ * that metadata intentionally keep the rebuild-all fallback.
+ *
+ * @see https://bun.sh/docs/runtime/transpiler
+ *
+ * @example
+ * ```typescript
+ * const context = {
+ *   getWatchedFiles: () => watchedFilesMap,
+ *   getSpecifierMap: () => specifierMap,
+ *   getDistDir: () => '/path/to/dist/_hmr',
+ *   getPlugins: () => [],
+ *   getSrcDir: () => '/path/to/src'
+ * };
+ * const strategy = new JsHmrStrategy(context);
+ * ```
+ */
+export declare class JsHmrStrategy extends HmrStrategy {
+    readonly type = HmrStrategyType.SCRIPT;
+    private context;
+    constructor(context: JsHmrContext);
+    /**
+     * Determines if the file is a JS/TS file that could affect registered entrypoints.
+     *
+     * Matches if:
+     * 1. There are registered entrypoints to rebuild
+     * 2. The changed file is a JS/TS file in the src directory
+     *
+     * @param filePath - Absolute path to the changed file
+     * @returns True if this file should trigger entrypoint rebuilds
+     */
+    matches(filePath: string): boolean;
+    /**
+     * Processes a file change by rebuilding affected entrypoints.
+     *
+     * @param filePath - Absolute path to the changed file
+     *
+     * @remarks
+     * If runtime-specific dependency graph hooks are unavailable, this strategy
+     * falls back to rebuilding all watched entrypoints.
+     * When multiple entrypoints are impacted they are bundled in a single esbuild
+     * invocation to share AST parsing and chunk deduplication.
+     * @returns Action to broadcast update events
+     */
+    process(filePath: string): Promise<HmrAction>;
+    /**
+     * Bundles one or more entrypoints in a single esbuild invocation.
+     * Uses the source directory as the output base so that the directory structure
+     * is preserved under the HMR dist folder.
+     */
+    private bundleEntrypoints;
+    /**
+     * Processes bundled output and determines whether the browser can hot-accept
+     * the update or must fall back to a full reload.
+     *
+     * @param filepath - Path to the bundled output file
+     * @param url - URL path for the bundled file
+     * @returns True if processing was successful and update should be broadcast
+     */
+    private processOutput;
+}