@anaemia/core 0.0.1

package/test/integration/hmr.test.mjs

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { chromium } from "playwright";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { createJiti } = require("jiti");
+const jiti = createJiti(import.meta.url);
+
+function resolveConfigPort() {
+  const configPath = path.resolve(projectRoot, "anaemia.config.ts");
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      const userConfigModule = jiti(configPath);
+      const userConfig = userConfigModule.default || userConfigModule;
+      
+      if (userConfig && typeof userConfig.port === "number") {
+        return userConfig.port;
+      }
+    } catch (err) {
+      console.warn(`[HMR test warning]: failed parsing anaemia.config.ts, falling back to port 3000. Error: ${err.message}`);
+    }
+  }
+
+  return 3000;
+}
+
+const TARGET_PORT = resolveConfigPort();
+const BASE_URL = `http://localhost:${TARGET_PORT}`;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "../../../../templates/base-app");
+const componentPath = path.resolve(projectRoot, "src/features/welcome-hero/components/WelcomeHero.tsx");
+
+test("integration - dev server HMR & hydration lifecycle", async (t) => {
+  let devProcess = null;
+  let browser = null;
+  let page = null;
+  let consoleErrors = [];
+  const originalComponentContent = fs.readFileSync(componentPath, "utf-8");
+
+  t.after(async () => {
+    fs.writeFileSync(componentPath, originalComponentContent, "utf-8");
+    if (browser) await browser.close();
+
+    if (devProcess && devProcess.pid) {
+      try {
+        process.kill(-devProcess.pid, "SIGKILL");
+      } catch (e) {}
+    }
+  });
+
+  t.beforeEach(() => {
+    consoleErrors = [];
+  });
+
+  await t.test("should start dev server without errors", async () => {
+    devProcess = spawn("pnpm", ["dev"], {
+      cwd: projectRoot,
+      stdio: "pipe",
+      detached: true,
+    });
+
+    await new Promise((resolve, reject) => {
+      let output = "";
+
+      const timeout = setTimeout(() => {
+        reject(new Error(`Dev server startup timed out. Current output:\n${output}`));
+      }, 15000);
+
+      const checkPortReady = async () => {
+        for (let i = 0; i < 20; i++) {
+          try {
+            // Dynamic URL Check
+            const res = await fetch(BASE_URL);
+            if (res.status === 200 || res.status === 404) {
+              clearTimeout(timeout);
+              resolve();
+              return;
+            }
+          } catch (e) {}
+          await new Promise((r) => setTimeout(r, 200));
+        }
+        reject(new Error(`Server process started but port ${TARGET_PORT} never responded to HTTP requests.`));
+      };
+
+      devProcess.stdout.on("data", (data) => {
+        output += data.toString();
+
+        if (output.includes("server live at") || output.includes(BASE_URL)) {
+          checkPortReady();
+        }
+      });
+
+      devProcess.stderr.on("data", (data) => {
+        const msg = data.toString();
+        if (!msg.includes("ExperimentalWarning") && !msg.includes("sync error")) {
+          console.error(`[Server Stderr]: ${msg}`);
+        }
+      });
+
+      devProcess.on("error", reject);
+    });
+  });
+
+  await t.test("should render initial server state & connect HMR", async () => {
+    browser = await chromium.launch({ headless: true });
+    page = await browser.newPage();
+    page.on("pageerror", (err) => consoleErrors.push(err));
+
+    await page.goto(BASE_URL, { waitUntil: "networkidle" });
+
+    const titleText = await page.textContent("h1");
+    assert.equal(titleText.trim(), "anaemia");
+    assert.equal(consoleErrors.length, 0, `Errors during initial render: ${consoleErrors.map((e) => e.message).join(", ")}`);
+  });
+
+  await t.test("should push hot module updates to browser when files change", async () => {
+    const updatedContent = originalComponentContent.replace(`<h1 class={styles.title}>anaemia</h1>`, `<h1 class={styles.title}>anaemia updated!</h1>`);
+
+    assert.notEqual(originalComponentContent, updatedContent, "Regex failed to modify component text.");
+    fs.writeFileSync(componentPath, updatedContent, "utf-8");
+
+    await page.waitForFunction(
+      () => {
+        const h1 = document.querySelector("h1");
+        return h1 && h1.textContent.trim() === "anaemia updated!";
+      },
+      { timeout: 10000 }
+    );
+  });
+
+  await t.test("should refresh page without throwing runtime errors", async () => {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    await page.reload({ waitUntil: "networkidle" });
+
+    const titleText = await page.textContent("h1");
+    assert.equal(titleText.trim(), "anaemia updated!");
+    assert.equal(
+      consoleErrors.length, 
+      0, 
+      `Errors detected after page refresh: ${consoleErrors.map(e => e.message).join(", ")}`
+    );
+  });
+});

package/test/run-on-server.test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  runOnServer,
+  serverFunctionsRegistry,
+  ssrStorage,
+} from "../dist/runtime/context.js";
+import { createRouteRequest } from "../dist/runtime/route-request.js";
+
+test("runOnServer returns a callable function and registers the original implementation", async () => {
+  const add = runOnServer((a, b) => a + b, "add");
+
+  assert.equal(typeof add, "function");
+  assert.equal(add.id, "add");
+  assert.equal(add.urlId, "add");
+  assert.equal(await add(2, 3), 5);
+  assert.equal(await serverFunctionsRegistry.get("add")(4, 6), 10);
+});
+
+test("runOnServer records SSR results by id and argument list for hydration", async () => {
+  const greet = runOnServer((name) => `hello ${name}`, "greet");
+  const store = new Map();
+
+  await ssrStorage.run(store, async () => {
+    assert.equal(await greet("Ada"), "hello Ada");
+  });
+
+  assert.deepEqual(store.get("__SERVER_FUNCTION_DATA__"), {
+    greet: {
+      "[\"Ada\"]": "hello Ada",
+    },
+  });
+});
+
+test("createRouteRequest creates a valid request for relative route paths", () => {
+  const request = createRouteRequest("/");
+
+  assert.equal(request.url, "http://localhost/");
+});
+
+test("createRouteRequest reuses the active server request when one exists", async () => {
+  const raw = new Request("http://example.test/dashboard");
+  const store = new Map([["honoContext", { req: { raw } }]]);
+
+  await ssrStorage.run(store, async () => {
+    assert.equal(createRouteRequest("/dashboard"), raw);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}