@chr33s/solarflare 0.0.2

package/src/build.scan.ts

@@ -0,0 +1,182 @@
+import { glob, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { exists } from "./fs.ts";
+
+export interface BuildScanContext {
+  rootDir: string;
+  appDir: string;
+}
+
+export function createScanner(ctx: BuildScanContext) {
+  const { rootDir, appDir } = ctx;
+  let packageImportsCache: Record<string, string> | null = null;
+
+  async function scanFiles(pattern: string, cwd: string) {
+    const files: string[] = [];
+    for await (const file of glob(pattern, { cwd, withFileTypes: false })) {
+      files.push(file as string);
+    }
+    return files.sort();
+  }
+
+  async function getPackageImports() {
+    if (packageImportsCache) return packageImportsCache;
+
+    const pkgPath = join(rootDir, "package.json");
+    try {
+      const content = await readFile(pkgPath, "utf-8");
+      const pkg = JSON.parse(content) as { imports?: Record<string, string> };
+      const imports = pkg.imports ?? {};
+
+      packageImportsCache = {};
+      for (const [key, value] of Object.entries(imports)) {
+        const aliasKey = key.replace(/\/\*$/, "");
+        const aliasValue = value.replace(/\/\*$/, "");
+        packageImportsCache[aliasKey] = aliasValue.startsWith(".")
+          ? join(rootDir, aliasValue)
+          : aliasValue;
+      }
+      return packageImportsCache;
+    } catch {
+      packageImportsCache = { "#app": appDir };
+      return packageImportsCache;
+    }
+  }
+
+  async function findRouteModules() {
+    return scanFiles("**/*.{client,server}.{ts,tsx}", appDir);
+  }
+
+  async function findLayouts() {
+    return scanFiles("**/_layout.tsx", appDir);
+  }
+
+  async function findErrorFile() {
+    const files = await scanFiles("_error.tsx", appDir);
+    return files.length > 0 ? files[0] : null;
+  }
+
+  async function findClientComponents() {
+    return scanFiles("**/*.client.tsx", appDir);
+  }
+
+  async function extractCssImports(filePath: string) {
+    const content = await readFile(filePath, "utf-8");
+    const cssImports: string[] = [];
+
+    const importRegex = /import\s+['"](.+\.css)['"]|import\s+['"](.+\.css)['"]\s*;/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const cssPath = match[1] || match[2];
+      if (cssPath) {
+        cssImports.push(cssPath);
+      }
+    }
+
+    return cssImports;
+  }
+
+  async function extractComponentImports(filePath: string) {
+    const content = await readFile(filePath, "utf-8");
+    const imports: string[] = [];
+
+    const importRegex = /import\s+(?:{[^}]+}|\w+)\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (
+        importPath.startsWith("./") ||
+        importPath.startsWith("../") ||
+        importPath.startsWith("#")
+      ) {
+        imports.push(importPath);
+      }
+    }
+
+    return imports;
+  }
+
+  async function resolveImportPath(importPath: string, fromFile: string) {
+    const fromDir = fromFile.split("/").slice(0, -1).join("/");
+
+    if (importPath.startsWith("#")) {
+      const imports = await getPackageImports();
+      for (const [alias, target] of Object.entries(imports)) {
+        if (importPath === alias || importPath.startsWith(alias + "/")) {
+          const relativePath = importPath.slice(alias.length + 1);
+          const baseDir = target;
+          const extensions = [".tsx", ".ts", "/index.tsx", "/index.ts"];
+          for (const ext of extensions) {
+            const fullPath = relativePath ? join(baseDir, relativePath + ext) : baseDir + ext;
+            if (await exists(fullPath)) {
+              return fullPath;
+            }
+          }
+          const fullPath = relativePath ? join(baseDir, relativePath) : baseDir;
+          if (await exists(fullPath)) {
+            return fullPath;
+          }
+          return null;
+        }
+      }
+      return null;
+    }
+
+    if (importPath.startsWith("./") || importPath.startsWith("../")) {
+      const extensions = [".tsx", ".ts", "/index.tsx", "/index.ts", ""];
+      for (const ext of extensions) {
+        const fullPath = join(fromDir, importPath + ext);
+        if (await exists(fullPath)) {
+          return fullPath;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  async function extractAllCssImports(filePath: string, visited: Set<string> = new Set()) {
+    if (visited.has(filePath)) {
+      return [];
+    }
+    visited.add(filePath);
+
+    const allCss: string[] = [];
+    const fileDir = filePath.split("/").slice(0, -1).join("/");
+
+    const cssImports = await extractCssImports(filePath);
+    for (const cssImport of cssImports) {
+      const cssPath = join(fileDir, cssImport);
+      if (cssPath.startsWith(appDir)) {
+        allCss.push(cssPath.replace(appDir + "/", "./"));
+      } else {
+        allCss.push(cssImport);
+      }
+    }
+
+    const componentImports = await extractComponentImports(filePath);
+    for (const importPath of componentImports) {
+      const resolvedPath = await resolveImportPath(importPath, filePath);
+      if (resolvedPath && (await exists(resolvedPath))) {
+        const nestedCss = await extractAllCssImports(resolvedPath, visited);
+        allCss.push(...nestedCss);
+      }
+    }
+
+    return allCss;
+  }
+
+  return {
+    scanFiles,
+    getPackageImports,
+    findRouteModules,
+    findLayouts,
+    findErrorFile,
+    findClientComponents,
+    extractCssImports,
+    extractComponentImports,
+    resolveImportPath,
+    extractAllCssImports,
+  };
+}

package/src/build.ts

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import { spawn, type ChildProcess } from "node:child_process";
+import { watch } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { argv, env } from "node:process";
+import { parseArgs } from "node:util";
+import { buildClient } from "./build.bundle-client.ts";
+import { buildServer } from "./build.bundle-server.ts";
+import { exists } from "./fs.ts";
+
+/** Resolve paths relative to the current working directory. */
+const ROOT_DIR = process.cwd();
+const APP_DIR = join(ROOT_DIR, "src");
+const DIST_DIR = join(ROOT_DIR, "dist");
+const DIST_CLIENT = join(DIST_DIR, "client");
+const DIST_SERVER = join(DIST_DIR, "server");
+const PUBLIC_DIR = join(ROOT_DIR, "public");
+
+/** Generated file paths. */
+const MODULES_PATH = join(DIST_DIR, ".modules.generated.ts");
+const CHUNKS_PATH = join(DIST_DIR, ".chunks.generated.json");
+const ROUTES_TYPE_PATH = join(DIST_DIR, "routes.d.ts");
+
+/** CLI entry point: parse args early so they're available. */
+const { values: args, positionals } = parseArgs({
+  allowPositionals: true,
+  args: argv.slice(2),
+  options: {
+    production: {
+      type: "boolean",
+      short: "p",
+      default: env.NODE_ENV === "production",
+    },
+    serve: { type: "boolean", short: "s", default: false },
+    watch: { type: "boolean", short: "w", default: false },
+    clean: { type: "boolean", short: "c", default: false },
+    debug: { type: "boolean", short: "d", default: false },
+    sourcemap: { type: "boolean", default: false },
+    codemod: { type: "boolean", default: false },
+    dry: { type: "boolean", default: false },
+  },
+});
+
+/** Auto-scaffolds missing template files. */
+async function scaffoldTemplates() {
+  const templates: Record<string, string> = {
+    "index.ts": /* tsx */ `import worker from "@chr33s/solarflare";
+export default { fetch: worker };
+`,
+    "_error.tsx": /* tsx */ `export default function ErrorPage({ error }: { error: Error }) {
+  return <div><h1>Error</h1><p>{error.message}</p></div>;
+}
+`,
+    "_layout.tsx": /* tsx */ `import type { VNode } from "preact";
+import { Head, Body } from "@chr33s/solarflare/server";
+
+export default function Layout({ children }: { children: VNode }) {
+  return <html><head><Head /></head><body>{children}<Body /></body></html>;
+}
+`,
+  };
+
+  const rootTemplates: Record<string, string> = {
+    "wrangler.json": /* json */ `
+      {
+        "assets": { "directory": "./dist/client" },
+        "compatibility_date": "2025-12-10",
+        "compatibility_flags": ["nodejs_compat"],
+        "dev": { "port": 8080 },
+        "main": "./dist/server/index.js",
+        "name": "solarflare"
+      }
+    `,
+  };
+
+  for (const [filename, content] of Object.entries(templates)) {
+    const filepath = join(APP_DIR, filename);
+    if (!(await exists(filepath))) {
+      await writeFile(filepath, content);
+    }
+  }
+
+  for (const [filename, content] of Object.entries(rootTemplates)) {
+    const filepath = join(ROOT_DIR, filename);
+    if (!(await exists(filepath))) {
+      await writeFile(filepath, content);
+    }
+  }
+}
+
+/** Cleans the dist directory. */
+async function clean() {
+  const { rm } = await import("fs/promises");
+  try {
+    await rm(DIST_DIR, { recursive: true, force: true });
+    console.log("🧹 Cleaned dist directory");
+  } catch {}
+}
+
+/** Main build function. */
+async function build() {
+  const startTime = performance.now();
+
+  console.log("\n⚡ Solarflare Build\n");
+
+  if (args.clean) {
+    await clean();
+  }
+
+  await scaffoldTemplates();
+
+  await buildClient({
+    args,
+    rootDir: ROOT_DIR,
+    appDir: APP_DIR,
+    distDir: DIST_DIR,
+    distClient: DIST_CLIENT,
+    publicDir: PUBLIC_DIR,
+    chunksPath: CHUNKS_PATH,
+  });
+
+  await buildServer({
+    args,
+    rootDir: ROOT_DIR,
+    appDir: APP_DIR,
+    distServer: DIST_SERVER,
+    modulesPath: MODULES_PATH,
+    chunksPath: CHUNKS_PATH,
+    routesTypePath: ROUTES_TYPE_PATH,
+  });
+
+  const duration = ((performance.now() - startTime) / 1000).toFixed(2);
+  console.log(`\n🚀 Build completed in ${duration}s\n`);
+}
+
+/** Watch mode - rebuilds on file changes and optionally starts dev server. */
+async function watchBuild() {
+  console.log("\n⚡ Solarflare Dev Mode\n");
+
+  try {
+    await build();
+  } catch (err) {
+    console.error("❌ Initial build failed:", err);
+  }
+
+  let wranglerProc: ChildProcess | null = null;
+
+  if (args.serve) {
+    console.log("🌐 Starting wrangler dev server...\n");
+    wranglerProc = spawn("npx", ["wrangler", "dev"], {
+      stdio: "inherit",
+      env: { ...env },
+    });
+  }
+
+  console.log("\n👀 Watching for changes...\n");
+
+  let debounceTimer: NodeJS.Timeout | null = null;
+  let isBuilding = false;
+  let pendingBuild = false;
+  const DEBOUNCE_MS = 150;
+
+  async function doBuild(filename: string) {
+    if (isBuilding) {
+      pendingBuild = true;
+      return;
+    }
+
+    isBuilding = true;
+    console.log(`\n🔄 Change detected: ${filename}\n`);
+    try {
+      await build();
+      console.log("\n👀 Watching for changes...\n");
+    } catch (err) {
+      console.error("❌ Build failed:", err);
+      console.log("\n👀 Watching for changes...\n");
+    } finally {
+      isBuilding = false;
+      if (pendingBuild) {
+        pendingBuild = false;
+        await doBuild("(queued changes)");
+      }
+    }
+  }
+
+  const watcher = watch(APP_DIR, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+
+    if (filename.endsWith(".generated.ts") || filename.endsWith(".generated.json")) {
+      return;
+    }
+
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    debounceTimer = setTimeout(() => {
+      void doBuild(filename);
+    }, DEBOUNCE_MS);
+  });
+
+  let isExiting = false;
+  process.on("SIGINT", () => {
+    if (isExiting) return;
+    isExiting = true;
+    console.log("\n\n👋 Stopping dev server...\n");
+    watcher.close();
+    if (wranglerProc) {
+      wranglerProc.kill("SIGTERM");
+    }
+    process.exit(0);
+  });
+
+  await new Promise(() => {});
+}
+
+if (import.meta.main) {
+  if (args.codemod) {
+    const { codemod } = await import("./codemod.ts");
+    codemod(positionals, args);
+  } else if (args.watch) {
+    void watchBuild();
+  } else {
+    void build();
+  }
+}

package/src/build.validate.ts

@@ -0,0 +1,63 @@
+import { join } from "node:path";
+import { createProgram, validateModule, type ValidationResult } from "./ast.ts";
+import { parsePath } from "./paths.ts";
+
+export async function validateRoutes(routeFiles: string[], layoutFiles: string[], appDir: string) {
+  const allFiles = [
+    ...routeFiles.map((f) => join(appDir, f)),
+    ...layoutFiles.map((f) => join(appDir, f)),
+  ];
+
+  if (allFiles.length === 0) return true;
+
+  const program = createProgram(allFiles);
+  const results: ValidationResult[] = [];
+
+  for (const file of [...routeFiles, ...layoutFiles]) {
+    const result = validateModule(program, file, appDir);
+    results.push(result);
+  }
+
+  let hasErrors = false;
+  for (const result of results) {
+    for (const error of result.errors) {
+      console.error(`   ❌ ${result.file}: ${error}`);
+      hasErrors = true;
+    }
+    for (const warning of result.warnings) {
+      console.warn(`   ⚠️  ${result.file}: ${warning}`);
+    }
+  }
+
+  return !hasErrors;
+}
+
+export function generateRoutesTypeFile(routeFiles: string[]) {
+  const clientRoutes = routeFiles.filter((f) => f.includes(".client."));
+
+  const routeTypes = clientRoutes
+    .map((file) => {
+      const parsed = parsePath(file);
+      const paramsType =
+        parsed.params.length > 0
+          ? `{ ${parsed.params.map((p) => `${p}: string`).join("; ")} }`
+          : "Record<string, never>";
+      return `  '${parsed.pattern}': { params: ${paramsType} }`;
+    })
+    .join("\n");
+
+  return /* ts */ `
+    /**
+     * Auto-generated Route Types
+     * Provides type-safe route definitions
+     */
+
+    export interface Routes {
+      ${routeTypes}
+    }
+
+    export type RoutePath = keyof Routes;
+
+    export type RouteParams<T extends RoutePath> = Routes[T]['params'];
+  `;
+}

package/src/client.hmr.ts

@@ -0,0 +1,78 @@
+/** Callback type for HMR events. */
+export type HmrCallback<T = unknown> = (data: T) => void;
+
+/** HMR API interface for SSE-based hot module replacement. */
+export interface HmrApi {
+  /** Listen to an HMR event. */
+  on<T = unknown>(event: string, cb: HmrCallback<T>): void;
+  /** Remove an HMR event listener. */
+  off<T = unknown>(event: string, cb: HmrCallback<T>): void;
+  /** Register cleanup callback before module disposal. */
+  dispose(cb: () => void): void;
+  /** Persistent data across HMR updates. */
+  data: Record<string, unknown>;
+}
+
+/** No-op HMR implementation for production - tree-shakes to nothing. */
+const noopHmr: HmrApi = {
+  on() {},
+  off() {},
+  dispose() {},
+  data: {},
+};
+
+/** Creates the development HMR client with SSE connection. */
+function createDevHmr() {
+  const listeners = new Map<string, Set<HmrCallback>>();
+  const disposeCallbacks: Array<() => void> = [];
+  const data: Record<string, unknown> = {};
+
+  if (typeof EventSource !== "undefined" && typeof location !== "undefined") {
+    const es = new EventSource(`${location.origin}/_hmr`);
+
+    es.onopen = () => {
+      console.log("[HMR] Connected to dev server");
+    };
+
+    es.onmessage = (e) => {
+      try {
+        const { type, ...payload } = JSON.parse(e.data);
+        const cbs = listeners.get(type);
+        if (cbs) {
+          for (const cb of cbs) {
+            try {
+              cb(payload);
+            } catch (err) {
+              console.error(`[HMR] Error in handler for ${type}:`, err);
+            }
+          }
+        }
+      } catch (err) {
+        console.error("[HMR] Failed to parse message:", err);
+      }
+    };
+
+    es.onerror = () => {
+      console.log("[HMR] Connection lost, reconnecting...");
+    };
+  }
+
+  return {
+    on<T = unknown>(event: string, cb: HmrCallback<T>) {
+      if (!listeners.has(event)) listeners.set(event, new Set());
+      listeners.get(event)!.add(cb as HmrCallback);
+    },
+    off<T = unknown>(event: string, cb: HmrCallback<T>) {
+      listeners.get(event)?.delete(cb as HmrCallback);
+    },
+    dispose(cb: () => void) {
+      disposeCallbacks.push(cb);
+    },
+    data,
+  };
+}
+
+/** HMR instance - dev in dev mode, no-op in production. */
+export const hmr: HmrApi = (globalThis as unknown as { __SF_DEV__?: boolean }).__SF_DEV__
+  ? createDevHmr()
+  : noopHmr;

package/src/client.styles.ts

@@ -0,0 +1,68 @@
+import { stylesheets, supportsConstructableStylesheets } from "./stylesheets.ts";
+
+/** Style loading state for a component. */
+interface StyleState {
+  loaded: boolean;
+  sheets: CSSStyleSheet[];
+}
+
+/** Component style states. */
+const componentStyles = new Map<string, StyleState>();
+
+/** Loads and applies styles for a component. */
+export async function loadComponentStyles(tag: string, cssUrls: string[]) {
+  const existing = componentStyles.get(tag);
+  if (existing?.loaded) {
+    return existing.sheets;
+  }
+
+  const sheets: CSSStyleSheet[] = [];
+
+  for (const url of cssUrls) {
+    let sheet = stylesheets.get(url);
+
+    if (!sheet) {
+      try {
+        const response = await fetch(url);
+        const css = await response.text();
+        sheet = stylesheets.register(url, css, { consumer: tag });
+      } catch (e) {
+        console.warn(`[styles] Failed to load ${url}:`, e);
+        continue;
+      }
+    }
+
+    if (sheet) {
+      sheets.push(sheet);
+    }
+  }
+
+  componentStyles.set(tag, { loaded: true, sheets });
+  return sheets;
+}
+
+/** Applies stylesheets to a custom element. */
+export function applyStyles(element: HTMLElement, sheets: CSSStyleSheet[]) {
+  if (!supportsConstructableStylesheets()) {
+    // Fallback handled by StylesheetManager
+    return;
+  }
+
+  const shadowRoot = element.shadowRoot;
+
+  if (shadowRoot) {
+    shadowRoot.adoptedStyleSheets = [...shadowRoot.adoptedStyleSheets, ...sheets];
+  } else {
+    for (const sheet of sheets) {
+      if (!document.adoptedStyleSheets.includes(sheet)) {
+        document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+      }
+    }
+  }
+}
+
+/** Cleans up styles when a component is disconnected. */
+export function cleanupStyles(tag: string) {
+  stylesheets.removeConsumer(tag);
+  componentStyles.delete(tag);
+}