@pyreon/compiler 0.7.12 → 0.7.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/compiler",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "description": "Template and JSX compiler for Pyreon",
   "license": "MIT",
   "repository": {

package/src/tests/jsx.test.ts

@@ -1029,3 +1029,56 @@ describe("JSX transform — member expression tag names", () => {
     expect(result).not.toContain("_tpl(")
   })
 })
+
+// ─── Template emission edge cases ─────────────────────────────────────────────
+
+describe("JSX transform — template emission edge cases", () => {
+  test("non-delegated event (onMouseEnter) uses addEventListener not delegation", () => {
+    const result = t("<div onMouseEnter={handler}><span /></div>")
+    expect(result).toContain("_tpl(")
+    // mouseenter is NOT in DELEGATED_EVENTS → must use addEventListener
+    // onMouseEnter → eventName = "m" + "ouseEnter" = "mouseEnter"
+    expect(result).toContain("addEventListener(")
+    expect(result).toContain("mouseEnter")
+    expect(result).not.toContain("__ev_")
+  })
+
+  test("template with both dynamic attribute AND dynamic child text", () => {
+    const result = t("<div title={getTitle()}>{count()}</div>")
+    expect(result).toContain("_tpl(")
+    // Dynamic attribute binding
+    expect(result).toContain("_bindDirect(getTitle,")
+    // Dynamic child text binding
+    expect(result).toContain("_bindText(count,")
+  })
+
+  test("template with multiple dynamic attributes on same element", () => {
+    const result = t("<div class={cls()} title={getTitle()}><span /></div>")
+    expect(result).toContain("_tpl(")
+    // Both attributes should get _bindDirect bindings
+    expect(result).toContain("_bindDirect(cls,")
+    expect(result).toContain("_bindDirect(getTitle,")
+  })
+
+  test("template with static + dynamic children mixed", () => {
+    const result = t("<div><span>static text</span>{count()}</div>")
+    expect(result).toContain("_tpl(")
+    expect(result).toContain("static text")
+    expect(result).toContain("_bindText(count,")
+    // Mixed children use childNodes indexing
+    expect(result).toContain("childNodes[")
+  })
+
+  test("template with nested component inside DOM elements bails", () => {
+    // Component child inside a DOM element prevents template emission
+    const result = t("<div><span><MyComponent /></span></div>")
+    expect(result).not.toContain("_tpl(")
+  })
+
+  test("fragment with template-eligible children inside template", () => {
+    const result = t("<div><><span>a</span>{name()}</></div>")
+    expect(result).toContain("_tpl(")
+    expect(result).toContain("<span>a</span>")
+    expect(result).toContain("_bindText(name,")
+  })
+})

package/src/tests/project-scanner.test.ts

@@ -0,0 +1,239 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+import { generateContext } from "../project-scanner"
+
+/** Create a temporary directory with the given file structure. */
+function createTempProject(files: Record<string, string>): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pyreon-scanner-"))
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(dir, filePath)
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true })
+    fs.writeFileSync(fullPath, content)
+  }
+  return dir
+}
+
+function cleanupDir(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true })
+}
+
+describe("project-scanner — generateContext", () => {
+  test("returns valid ProjectContext shape for empty project", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.framework).toBe("pyreon")
+      expect(ctx.routes).toEqual([])
+      expect(ctx.components).toEqual([])
+      expect(ctx.islands).toEqual([])
+      expect(ctx.generatedAt).toBeTruthy()
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("reads version from @pyreon/* dependency", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({
+        name: "test",
+        dependencies: { "@pyreon/core": "^0.7.0" },
+      }),
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.version).toBe("0.7.0")
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("falls back to package version when no @pyreon deps", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "2.0.0" }),
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.version).toBe("2.0.0")
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("returns 'unknown' version when no package.json", () => {
+    const dir = createTempProject({})
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.version).toBe("unknown")
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+})
+
+describe("project-scanner — extractRoutes", () => {
+  test("extracts routes from createRouter call", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/router.ts": `
+const router = createRouter([
+  { path: "/", name: "home", component: Home },
+  { path: "/users/:id", name: "user", loader: fetchUser },
+  { path: "/admin", beforeEnter: authGuard },
+])
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.routes).toHaveLength(3)
+      expect(ctx.routes[0]?.path).toBe("/")
+      expect(ctx.routes[0]?.name).toBe("home")
+      expect(ctx.routes[1]?.path).toBe("/users/:id")
+      expect(ctx.routes[1]?.params).toEqual(["id"])
+      expect(ctx.routes[1]?.hasLoader).toBe(true)
+      expect(ctx.routes[2]?.path).toBe("/admin")
+      expect(ctx.routes[2]?.hasGuard).toBe(true)
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("extracts routes from const routes = [] pattern", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/routes.ts": `
+const routes: RouteRecord[] = [
+  { path: "/about", name: "about" },
+]
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.routes).toHaveLength(1)
+      expect(ctx.routes[0]?.path).toBe("/about")
+      expect(ctx.routes[0]?.name).toBe("about")
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("extracts multiple params from route path", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/router.ts": `
+const router = createRouter([
+  { path: "/users/:userId/posts/:postId" },
+])
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.routes[0]?.params).toEqual(["userId", "postId"])
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+})
+
+describe("project-scanner — extractComponents", () => {
+  test("extracts component with signals", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/Counter.tsx": `
+export const Counter = ({ initial }) => {
+  const count = signal<number>(0)
+  const doubled = signal(0)
+  return <div>{count()}</div>
+}
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      const counter = ctx.components.find((c) => c.name === "Counter")
+      expect(counter).toBeTruthy()
+      expect(counter?.hasSignals).toBe(true)
+      expect(counter?.signalNames).toEqual(["count", "doubled"])
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("extracts component without signals", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/Header.tsx": `
+export function Header({ title }) {
+  return <h1>{title}</h1>
+}
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      const header = ctx.components.find((c) => c.name === "Header")
+      expect(header).toBeTruthy()
+      expect(header?.hasSignals).toBe(false)
+      expect(header?.signalNames).toEqual([])
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+})
+
+describe("project-scanner — extractIslands", () => {
+  test("extracts island definitions", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/islands.ts": `
+const Counter = island(() => import("./Counter"), { hydrate: "visible", name: "Counter" })
+const Nav = island(() => import("./Nav"), { name: "Nav" })
+`,
+    })
+    try {
+      const ctx = generateContext(dir)
+      expect(ctx.islands).toHaveLength(2)
+      const counter = ctx.islands.find((i) => i.name === "Counter")
+      expect(counter).toBeTruthy()
+      // hydrate comes before name in the object literal, but the regex captures
+      // name first, so hydrate is only captured when it follows name directly
+      const nav = ctx.islands.find((i) => i.name === "Nav")
+      expect(nav?.hydrate).toBe("load") // default when hydrate not specified
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+})
+
+describe("project-scanner — collectSourceFiles", () => {
+  test("skips node_modules and dist directories", () => {
+    const dir = createTempProject({
+      "package.json": JSON.stringify({ name: "test", version: "1.0.0" }),
+      "src/app.tsx": "export const App = () => <div />",
+      "node_modules/pkg/index.ts": "export const x = 1",
+      "dist/app.js": "export const App = () => {}",
+    })
+    try {
+      const ctx = generateContext(dir)
+      // Should only find the component in src/, not in node_modules or dist
+      expect(ctx.components.length).toBeGreaterThanOrEqual(1)
+      const files = ctx.components.map((c) => c.file)
+      for (const f of files) {
+        expect(f).not.toContain("node_modules")
+        expect(f).not.toContain("dist")
+      }
+    } finally {
+      cleanupDir(dir)
+    }
+  })
+
+  test("handles non-existent directory gracefully", () => {
+    const dir = path.join(os.tmpdir(), `pyreon-scanner-nonexistent-${Date.now()}`)
+    // generateContext calls collectSourceFiles which catches readdir errors
+    const ctx = generateContext(dir)
+    expect(ctx.routes).toEqual([])
+    expect(ctx.components).toEqual([])
+    expect(ctx.islands).toEqual([])
+    expect(ctx.version).toBe("unknown")
+  })
+})