@kithinji/pod 1.0.0

package/src/config/config.ts

@@ -0,0 +1,141 @@
+import * as path from "path";
+import { pathToFileURL } from "url";
+import * as fs from "fs/promises";
+import { Store } from "@/store";
+import type { Plugin } from "esbuild";
+
+export type PodPlugin = (store: Store) => Plugin;
+
+export interface PodConfig {
+  name: string;
+  build?: {
+    outDir?: string;
+    sourcemap?: boolean;
+    minify?: boolean;
+  };
+  plugins?: Array<PodPlugin>;
+  client_plugins?: Array<PodPlugin>;
+  server_plugins?: Array<PodPlugin>;
+}
+
+const CONFIG_FILES = [
+  "pod.config.js",
+  "pod.config.mjs",
+  "pod.config.ts",
+  "pod.config.mts",
+];
+
+export async function loadConfig(
+  root: string = process.cwd()
+): Promise<PodConfig> {
+  for (const configFile of CONFIG_FILES) {
+    const configPath = path.resolve(root, configFile);
+
+    try {
+      await fs.access(configPath);
+
+      if (configFile.endsWith(".ts") || configFile.endsWith(".mts")) {
+        return await loadTsConfig(configPath);
+      }
+
+      return await loadJsConfig(configPath);
+    } catch (error) {
+      continue;
+    }
+  }
+
+  return getDefaultConfig();
+}
+
+async function loadJsConfig(configPath: string): Promise<PodConfig> {
+  try {
+    const fileUrl = pathToFileURL(configPath).href;
+
+    const configModule = await import(`${fileUrl}?t=${Date.now()}`);
+
+    const config = configModule.default || configModule;
+
+    if (typeof config === "function") {
+      return await config();
+    }
+
+    return config;
+  } catch (error) {
+    console.error(`❌ Failed to load config from ${configPath}:`, error);
+    throw error;
+  }
+}
+
+async function loadTsConfig(configPath: string): Promise<PodConfig> {
+  try {
+    const esbuild = await import("esbuild");
+
+    const result = await esbuild.build({
+      entryPoints: [configPath],
+      bundle: true,
+      platform: "node",
+      format: "esm",
+      write: false,
+      sourcemap: "inline",
+      packages: "external",
+    });
+
+    const tempFile = `${configPath}.${Date.now()}.mjs`;
+    await fs.writeFile(tempFile, result.outputFiles[0].text);
+
+    try {
+      const fileUrl = pathToFileURL(tempFile).href;
+
+      const configModule = await import(fileUrl);
+
+      const config = configModule.default || configModule;
+
+      if (typeof config === "function") {
+        return await config();
+      }
+
+      return config;
+    } finally {
+      await fs.unlink(tempFile).catch(() => {});
+    }
+  } catch (error) {
+    console.error(
+      `❌ Failed to load TypeScript config from ${configPath}:`,
+      error
+    );
+    throw error;
+  }
+}
+
+export function getDefaultConfig(): PodConfig {
+  return {
+    name: "app",
+    build: {
+      outDir: "dist",
+      sourcemap: true,
+      minify: false,
+    },
+    plugins: [],
+    client_plugins: [],
+    server_plugins: [],
+  };
+}
+
+export function mergeConfig(
+  defaults: PodConfig,
+  userConfig: PodConfig
+): PodConfig {
+  return {
+    name: userConfig.name,
+    build: { ...defaults.build, ...userConfig.build },
+    plugins: [...(defaults.plugins || []), ...(userConfig.plugins || [])],
+    client_plugins: [
+      ...(defaults.client_plugins || []),
+      ...(userConfig.client_plugins || []),
+    ],
+    server_plugins: [
+      ...(defaults.server_plugins || []),
+      ...(userConfig.server_plugins || []),
+    ],
+  };
+}

package/src/config/index.ts

@@ -0,0 +1 @@
+export * from "./config"

package/src/dev/index.ts

@@ -0,0 +1 @@
+export * from "./server";

package/src/dev/project.ts

@@ -0,0 +1,45 @@
+import * as ts from "typescript";
+
+export class Project {
+  public program: ts.Program;
+  public checker: ts.TypeChecker;
+
+  constructor(entryPoints: string[]) {
+    this.program = ts.createProgram(entryPoints, {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      allowJs: true,
+      jsx: ts.JsxEmit.ReactJSX,
+    });
+    this.checker = this.program.getTypeChecker();
+  }
+
+  isPublicFile(sourceFile: ts.SourceFile): boolean {
+    for (const stmt of sourceFile.statements) {
+      if (
+        ts.isExpressionStatement(stmt) &&
+        ts.isStringLiteral(stmt.expression)
+      ) {
+        if (stmt.expression.text === "use public") return true;
+      } else {
+        break;
+      }
+    }
+    return false;
+  }
+
+  isInteractiveFile(sourceFile: ts.SourceFile): boolean {
+    for (const stmt of sourceFile.statements) {
+      if (
+        ts.isExpressionStatement(stmt) &&
+        ts.isStringLiteral(stmt.expression)
+      ) {
+        if (stmt.expression.text === "use interactive") return true;
+      } else {
+        break;
+      }
+    }
+    return false;
+  }
+}

package/src/dev/server.ts

@@ -0,0 +1,190 @@
+import * as esbuild from "esbuild";
+import { spawn, ChildProcess } from "child_process";
+import * as fs from "fs/promises";
+import { loadConfig, mergeConfig, getDefaultConfig } from "../config/config";
+import { buildGraph, useMyPlugin } from "@/plugins";
+import { Store } from "@/store";
+
+async function copyFile(): Promise<void> {
+  try {
+    await fs.mkdir("public", { recursive: true });
+    await fs.copyFile("./src/client/index.html", "./public/index.html");
+  } catch (error) {
+    console.error("❌ Failed to copy index.html:", error);
+    throw error;
+  }
+}
+
+async function cleanDirectories(): Promise<void> {
+  await Promise.all([
+    fs.rm("dist", { recursive: true, force: true }),
+    fs.rm("public", { recursive: true, force: true }),
+  ]);
+}
+
+function createRestartServerPlugin(
+  serverProcess: { current: ChildProcess | null },
+  onServerBuildComplete: () => void
+): esbuild.Plugin {
+  return {
+    name: "restart-server",
+    setup(build) {
+      build.onEnd((result) => {
+        if (result.errors.length > 0) {
+          console.error(
+            `❌ Server build failed with ${result.errors.length} error(s)`
+          );
+          return;
+        }
+
+        if (serverProcess.current) {
+          serverProcess.current.kill("SIGTERM");
+        }
+
+        serverProcess.current = spawn("node", ["dist/main.js"], {
+          stdio: "inherit",
+        });
+
+        serverProcess.current.on("error", (err) => {
+          console.error("❌ Server process error:", err);
+        });
+
+        onServerBuildComplete();
+      });
+    },
+  };
+}
+
+export async function startDevServer(): Promise<void> {
+  const store = Store.getInstance();
+  const userConfig = await loadConfig();
+  const config = mergeConfig(getDefaultConfig(), userConfig);
+
+  await cleanDirectories();
+  await copyFile();
+
+  const entryPoints = ["src/main.ts"];
+  const clientFiles = new Set<string>(["src/client/client.tsx"]);
+  const serverProcessRef = { current: null as ChildProcess | null };
+  let clientCtx: esbuild.BuildContext | null = null;
+  let isShuttingDown = false;
+
+  let pendingClientFiles = new Set<string>();
+  let needsClientRebuild = false;
+
+  async function rebuildClient(): Promise<void> {
+    if (isShuttingDown) return;
+
+    try {
+      if (clientCtx) {
+        await clientCtx.dispose();
+        clientCtx = null;
+      }
+
+      if (clientFiles.size === 0) return;
+
+      const entryPoints = Array.from(clientFiles);
+      const graph = buildGraph(entryPoints);
+
+      clientCtx = await esbuild.context({
+        entryPoints,
+        bundle: true,
+        outdir: "public",
+        outbase: ".",
+        platform: "browser",
+        format: "esm",
+        sourcemap: config.build?.sourcemap ?? true,
+        splitting: true,
+        minify: config.build?.minify ?? false,
+        plugins: [
+          ...(config.plugins?.map((cb) => cb(store)) || []),
+          ...(config.client_plugins?.map((cb) => cb(store)) || []),
+          useMyPlugin({
+            graph,
+            isServerBuild: false,
+            onClientFound: () => {},
+          }),
+          {
+            name: "client-build-logger",
+            setup(build: any) {
+              build.onEnd((result: any) => {
+                if (result.errors.length > 0) {
+                  console.error(
+                    `❌ Client build failed with ${result.errors.length} error(s)`
+                  );
+                }
+              });
+            },
+          },
+        ],
+        write: true,
+      });
+
+      await clientCtx.watch();
+      pendingClientFiles.clear();
+      needsClientRebuild = false;
+    } catch (error) {
+      console.error("❌ Failed to rebuild client:", error);
+      throw error;
+    }
+  }
+
+  async function onServerBuildComplete(): Promise<void> {
+    if (needsClientRebuild && pendingClientFiles.size > 0) {
+      await rebuildClient();
+    }
+  }
+
+  const serverCtx = await esbuild.context({
+    entryPoints,
+    bundle: true,
+    outdir: config.build?.outDir || "dist",
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    sourcemap: config.build?.sourcemap ?? true,
+    minify: config.build?.minify ?? false,
+    plugins: [
+      ...(config.plugins?.map((cb) => cb(store)) || []),
+      useMyPlugin({
+        isServerBuild: true,
+        onClientFound: async (filePath) => {
+          const isNewFile = !clientFiles.has(filePath);
+
+          if (isNewFile) {
+            clientFiles.add(filePath);
+            pendingClientFiles.add(filePath);
+            needsClientRebuild = true;
+          }
+        },
+      }),
+      createRestartServerPlugin(serverProcessRef, onServerBuildComplete),
+    ],
+    write: true,
+  });
+
+  async function shutdown(): Promise<void> {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    try {
+      if (serverProcessRef.current) {
+        serverProcessRef.current.kill("SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+
+      await serverCtx.dispose();
+      if (clientCtx) await clientCtx.dispose();
+
+      process.exit(0);
+    } catch (error) {
+      console.error("❌ Error during shutdown:", error);
+      process.exit(1);
+    }
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  await serverCtx.watch();
+}