mintiljs 0.1.0

package/src/cli/cli.ts

@@ -0,0 +1,142 @@
+#!/usr/bin/env bun
+import path from "node:path";
+import fs from "node:fs/promises";
+import { start } from "../core/runtime.ts";
+import { resolveConfig } from "../core/config.ts";
+import { generate } from "./generate.ts";
+import type { MintilConfig } from "../types/config.ts";
+
+const args = process.argv.slice(2);
+const cmd = args[0] ?? "dev";
+
+async function main() {
+  switch (cmd) {
+    case "init":
+      await initProject(args[1]);
+      break;
+    case "dev":
+    case "start":
+      await runProject(cmd);
+      break;
+    case "generate":
+    case "g":
+      await generate(args[1], args[2]);
+      break;
+    case "--help":
+    case "-h":
+    case "help":
+      showHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+function showHelp() {
+  console.log(`Usage: mintil <command>
+
+Commands:
+  init <name>       Create a new Mintil project in the <name> directory
+  dev               Run the project in development mode (forces mode: development)
+  start             Run the project (uses config mode or defaults to production)
+  generate <t> <n>  Scaffold a page, api, component, or island (alias: g)
+  help              Show this help message
+
+Run \`mintil generate help\` for scaffold type options.
+`);
+}
+
+async function initProject(name?: string) {
+  if (!name) {
+    console.error("Please provide a project name: mintil init <name>");
+    process.exit(1);
+  }
+
+  const target = path.resolve(process.cwd(), name);
+  const template = path.resolve(import.meta.dir, "..", "..", "templates", "default");
+
+  try {
+    await fs.access(target);
+    console.error(`Directory already exists: ${target}`);
+    process.exit(1);
+  } catch {
+    // expected: directory does not exist
+  }
+
+  await fs.cp(template, target, { recursive: true });
+
+  // Update package.json project name
+  const pkgPath = path.join(target, "package.json");
+  try {
+    const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8")) as Record<string, unknown>;
+    pkg.name = name;
+    await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  } catch {
+    // ignore if no package.json
+  }
+
+  console.log(`Created Mintil project at ${target}`);
+  console.log(`\nNext steps:\n  cd ${name}\n  bun install\n  mintil dev`);
+}
+
+async function runProject(command: "dev" | "start") {
+  const root = process.cwd();
+  const userConfig = await loadEntryConfig(root);
+
+  const config: MintilConfig = {
+    ...userConfig,
+    root: userConfig?.root ?? root,
+    mode:
+      command === "dev"
+        ? "development"
+        : (userConfig?.mode ?? (process.env.NODE_ENV as MintilConfig["mode"]) ?? "production"),
+  };
+
+  const resolved = resolveConfig(config.root as string, config);
+  console.log(
+    `[mintil] running in ${resolved.mode} mode from ${resolved.root} on port ${resolved.port}`,
+  );
+
+  const server = await start(config);
+
+  for (const signal of ["SIGINT", "SIGTERM"] as const) {
+    process.on(signal, () => {
+      console.log(`\n[mintil] received ${signal}, shutting down...`);
+      try {
+        server.stop();
+      } catch {
+        // ignore
+      }
+      // Bun can keep the process alive when a local tsconfig.json is present,
+      // so we force an immediate exit with SIGKILL.
+      console.log("[mintil] force kill");
+      process.kill(process.pid, "SIGKILL");
+    });
+  }
+}
+
+async function loadEntryConfig(root: string): Promise<Partial<MintilConfig>> {
+  // Prefer mintil.config.ts, fall back to index.ts for legacy projects
+  const candidates = ["mintil.config.ts", "mintil.config.tsx", "mintil.config.js", "index.ts", "index.tsx", "index.js"];
+  for (const file of candidates) {
+    const entry = path.join(root, file);
+    try {
+      await fs.access(entry);
+      const mod: any = await import(entry);
+      if (mod.default && typeof mod.default === "object" && !Array.isArray(mod.default)) {
+        return mod.default as Partial<MintilConfig>;
+      }
+      return {};
+    } catch {
+      // try next candidate
+    }
+  }
+  return {};
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/cli/generate.ts

@@ -0,0 +1,142 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+const TEMPLATES: Record<string, (name: string) => string> = {
+  page(name) {
+    const comp = pascal(name);
+    return `import React from "react";
+
+export default function ${comp}() {
+  return (
+    <div>
+      <h1>${comp}</h1>
+    </div>
+  );
+}
+`;
+  },
+
+  "page:client"(name) {
+    const comp = pascal(name);
+    return `import React from "react";
+
+export const useClient = true;
+
+export default function ${comp}() {
+  const [count, setCount] = React.useState(0);
+  return (
+    <div>
+      <h1>${comp}</h1>
+      <p>Count: {count}</p>
+      <button onClick={() => setCount(c => c + 1)}>+</button>
+    </div>
+  );
+}
+`;
+  },
+
+  api(name) {
+    const route = name.toLowerCase().replace(/\s+/g, "-");
+    return `import type { ApiMethodHandler } from "mintiljs";
+
+export const GET: ApiMethodHandler = (request, response) => {
+  return response.json({ message: "Hello from ${route}" });
+};
+`;
+  },
+
+  component(name) {
+    const comp = pascal(name);
+    return `import React from "react";
+
+interface ${comp}Props {
+  children?: React.ReactNode;
+}
+
+export default function ${comp}({ children }: ${comp}Props) {
+  return <div className="mintil-component">{children}</div>;
+}
+`;
+  },
+
+  island(name) {
+    const comp = pascal(name);
+    return `import React from "react";
+
+export default function ${comp}({ greeting = "Hello" }: { greeting?: string }) {
+  const [count, setCount] = React.useState(0);
+  return (
+    <div>
+      <p>{greeting} from ${comp}! Count: {count}</p>
+      <button onClick={() => setCount(c => c + 1)}>+</button>
+    </div>
+  );
+}
+`;
+  },
+};
+
+function pascal(name: string): string {
+  return name
+    .split(/[-_\s]+/)
+    .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+    .join("");
+}
+
+function fileName(name: string, ext: string = ".tsx"): string {
+  return name.toLowerCase().replace(/\s+/g, "-") + ext;
+}
+
+function help(): string {
+  return `Usage: mintil generate <type> <name>
+
+Types:
+  page <name>       Scaffold a new page in pages/
+  page:client <name> Scaffold a client-side page in pages/
+  api <name>        Scaffold a new API route in api/
+  component <name>  Scaffold a new component in components/
+  island <name>     Scaffold a new island in islands/
+`;
+}
+
+export async function generate(type: string, name?: string) {
+  if (!type || type === "help" || !name) {
+    console.log(help());
+    return;
+  }
+
+  const root = process.cwd();
+  const template = TEMPLATES[type];
+  if (!template) {
+    console.error(`Unknown type: ${type}`);
+    console.log(help());
+    process.exit(1);
+  }
+
+  const dirMap: Record<string, string> = {
+    page: "pages",
+    "page:client": "pages",
+    api: "api",
+    component: "components",
+    island: "islands",
+  };
+
+  const subdir = dirMap[type];
+  const targetDir = path.join(root, subdir);
+  const fname = fileName(name);
+  const targetFile = path.join(targetDir, fname);
+
+  await fs.mkdir(targetDir, { recursive: true });
+
+  try {
+    await fs.access(targetFile);
+    console.error(`File already exists: ${targetFile}`);
+    process.exit(1);
+  } catch {
+    // ok
+  }
+
+  const content = template(name);
+  await fs.writeFile(targetFile, content);
+  console.log(`Created ${type}: ${targetFile}`);
+}

package/src/core/client.ts

@@ -0,0 +1,157 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+const tmpDir = path.join(process.cwd(), "node_modules", ".mintil-client");
+let entryCounter = 0;
+const bundleCache = new Map<string, string>();
+let frameworkCache: string | null = null;
+const FRAMEWORK_ROUTE = "/_mintil/framework.js";
+
+async function ensureTmp() {
+  await fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
+}
+
+export function clearClientCache() {
+  bundleCache.clear();
+  frameworkCache = null;
+}
+
+export async function getFrameworkRoute(): Promise<string> {
+  await ensureFrameworkBundle();
+  return FRAMEWORK_ROUTE;
+}
+
+export async function getFrameworkBundle(): Promise<string | null> {
+  await ensureFrameworkBundle();
+  return frameworkCache;
+}
+
+async function ensureFrameworkBundle() {
+  if (frameworkCache) return;
+  frameworkCache = await buildFrameworkBundle();
+}
+
+async function buildFrameworkBundle(): Promise<string | null> {
+  await ensureTmp();
+  entryCounter++;
+
+  const frameworkEntry = [
+    `import React from "react";`,
+    `import { hydrateRoot } from "react-dom/client";`,
+    `import { jsxDEV } from "react/jsx-dev-runtime";`,
+    ``,
+    `export default React;`,
+    `export { hydrateRoot, jsxDEV };`,
+  ].join("\n");
+
+  const entryFile = path.join(tmpDir, `framework-${entryCounter}.tsx`);
+  await fs.writeFile(entryFile, frameworkEntry);
+
+  try {
+    const result = await Bun.build({
+      entrypoints: [entryFile],
+      target: "browser",
+      format: "esm",
+      jsx: { runtime: "automatic" } as any,
+      jsxImportSource: "react",
+      minify: true,
+    } as any);
+
+    if (!result.success || !result.outputs[0]) {
+      for (const log of result.logs) {
+        console.error("[mintil] framework build:", log);
+      }
+      return null;
+    }
+
+    const js = await result.outputs[0].text();
+    await fs.rm(entryFile).catch(() => {});
+    return js;
+  } catch (err) {
+    console.error("[mintil] framework build error:", err);
+    return null;
+  }
+}
+
+export interface BuildOptions {
+  mode?: "development" | "production";
+}
+
+export async function buildClientBundle(
+  pageFile: string,
+  pageRoute: string,
+  buildOpts?: BuildOptions,
+): Promise<string | null> {
+  await ensureTmp();
+  entryCounter++;
+
+  const encodedRoute = encodeURIComponent(pageRoute).replace(/%2F/g, "_").replace(/%3A/g, "_");
+  const cacheKey = `${encodedRoute}-${entryCounter}`;
+
+  if (bundleCache.has(cacheKey)) {
+    return bundleCache.get(cacheKey)!;
+  }
+
+  const isDev = buildOpts?.mode !== "production";
+
+  const entryContent = [
+    `import { hydrateRoot } from "react-dom/client";`,
+    `import Page from "${pageFile}";`,
+    ``,
+    `const el = document.getElementById("__mintil-root");`,
+    `if (el) {`,
+    `  const props = JSON.parse(document.getElementById("__PAGE_PROPS__")?.textContent ?? "{}");`,
+    `  hydrateRoot(el, <Page {...props} />);`,
+    `}`,
+  ].join("\n");
+
+  const entryFile = path.join(tmpDir, `${cacheKey}.tsx`);
+  await fs.writeFile(entryFile, entryContent);
+
+  try {
+    const result = await Bun.build({
+      entrypoints: [entryFile],
+      target: "browser",
+      format: "esm",
+      external: ["react", "react-dom"],
+      jsx: { runtime: "automatic" } as any,
+      jsxImportSource: "react",
+      minify: !isDev,
+      sourcemap: isDev ? "external" : undefined,
+    } as any);
+
+    if (!result.success || !result.outputs[0]) {
+      for (const log of result.logs) {
+        console.error("[mintil] client build:", log);
+      }
+      return null;
+    }
+
+    const js = await result.outputs[0].text();
+    bundleCache.set(cacheKey, js);
+
+    await fs.rm(entryFile).catch(() => {});
+
+    // Store source map reference in a separate map for serving
+    if (isDev && result.outputs[0].sourcemap) {
+      const sm = await result.outputs[0].sourcemap.text().catch(() => null);
+      if (sm) sourceMapCache.set(cacheKey, sm);
+    }
+
+    return js;
+  } catch (err) {
+    console.error("[mintil] client build error:", err);
+    return null;
+  }
+}
+
+const sourceMapCache = new Map<string, string>();
+
+export function getSourceMap(cacheKey: string): string | undefined {
+  return sourceMapCache.get(cacheKey);
+}
+
+export function getClientCacheKey(pageRoute: string): string {
+  const encodedRoute = encodeURIComponent(pageRoute).replace(/%2F/g, "_").replace(/%3A/g, "_");
+  return `${encodedRoute}-${entryCounter}`;
+}

package/src/core/config.ts

@@ -0,0 +1,16 @@
+import type { MintilConfig, ResolvedConfig } from "../types/config.ts";
+import type { MintilPlugin } from "../types/plugin.ts";
+
+export function resolveConfig(root: string, userConfig?: MintilConfig): ResolvedConfig {
+  const envPort = process.env.PORT ? Number(process.env.PORT) : undefined;
+  const envMode = process.env.NODE_ENV === "production" ? "production" : "development";
+
+  return {
+    root,
+    port: userConfig?.port ?? envPort ?? 3456,
+    hosts: userConfig?.hosts ?? [],
+    mode: userConfig?.mode ?? (envMode as ResolvedConfig["mode"]),
+    host: userConfig?.host ?? false,
+    plugins: userConfig?.plugins ?? [],
+  };
+}

package/src/core/css.ts

@@ -0,0 +1,72 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+
+let cached: { root: string; css: string; mode: string } | null = null;
+
+export function clearCssCache() {
+  cached = null;
+}
+
+function minifyCss(css: string): string {
+  return css
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/\s*([{}:;,])\s*/g, "$1")
+    .replace(/\s+/g, " ")
+    .replace(/;\}/g, "}")
+    .trim();
+}
+
+export async function processCss(
+  root: string,
+  mode?: "development" | "production",
+): Promise<string> {
+  if (cached?.root === root && cached?.mode === mode) return cached.css;
+
+  const cssPath = path.join(root, "styles.css");
+  let rawCss: string;
+  try {
+    rawCss = await fs.readFile(cssPath, "utf-8");
+  } catch {
+    cached = { root, css: "", mode: mode ?? "development" };
+    return "";
+  }
+
+  try {
+    const postcssMod: any = await import("postcss");
+    const tailwindMod: any = await import("@tailwindcss/postcss");
+    const postcss = postcssMod.default ?? postcssMod;
+    const tailwind = tailwindMod.default ?? tailwindMod;
+    const result = await postcss([tailwind()]).process(rawCss, {
+      from: cssPath,
+    });
+    let css = result.css;
+
+    if (mode === "production") {
+      try {
+        const cssnanoMod: any = await import("cssnano");
+        const cssnano = cssnanoMod.default ?? cssnanoMod;
+        const nanoResult = await postcss([cssnano()]).process(css, { from: cssPath });
+        css = nanoResult.css;
+      } catch {
+        css = minifyCss(css);
+      }
+    }
+
+    cached = { root, css, mode: mode ?? "development" };
+    return css;
+  } catch {
+    let css = rawCss;
+    if (mode === "production") {
+      css = minifyCss(css);
+    }
+    cached = { root, css, mode: mode ?? "development" };
+    return css;
+  }
+}
+
+export async function getCss(
+  root: string,
+  mode?: "development" | "production",
+): Promise<string> {
+  return processCss(root, mode);
+}

package/src/core/islands.ts

@@ -0,0 +1,90 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { pathExists, walkFiles, fileToRoutePath } from "../utils/fs.ts";
+import { registerIsland } from "../render/island.tsx";
+
+const tmpDir = path.join(process.cwd(), "node_modules", ".mintil-client");
+let buildCounter = 0;
+const bundleCache = new Map<string, string>();
+
+async function ensureTmp() {
+  await fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
+}
+
+export function clearIslandCache() {
+  bundleCache.clear();
+}
+
+export async function loadAndRegisterIslands(root: string) {
+  const islandsDir = path.join(root, "islands");
+  if (!(await pathExists(islandsDir))) return;
+
+  for await (const file of walkFiles(islandsDir)) {
+    const ext = path.extname(file);
+    if (ext !== ".tsx" && ext !== ".jsx" && ext !== ".ts" && ext !== ".js") continue;
+
+    const name = path.basename(file, ext);
+    const mod: any = await import(file);
+    const component = mod.default ?? null;
+    if (typeof component !== "function") continue;
+
+    registerIsland(name, { component, file });
+  }
+}
+
+export async function buildIslandBundle(
+  name: string,
+  islandFile: string,
+  buildOpts?: { mode?: "development" | "production" },
+): Promise<string | null> {
+  await ensureTmp();
+  buildCounter++;
+
+  const cacheKey = `island-${name}`;
+  if (bundleCache.has(cacheKey)) return bundleCache.get(cacheKey)!;
+
+  const isDev = buildOpts?.mode !== "production";
+
+  const entryContent = [
+    `import React from "react";`,
+    `import { hydrateRoot } from "react-dom/client";`,
+    `import Component from "${islandFile}";`,
+    ``,
+    `const el = document.querySelector('[data-island="${name}"]');`,
+    `if (el) {`,
+    `  const props = JSON.parse(el.getAttribute("data-props") || "{}");`,
+    `  hydrateRoot(el, React.createElement(Component, props));`,
+    `}`,
+  ].join("\n");
+
+  const entryFile = path.join(tmpDir, `${cacheKey}-${buildCounter}.tsx`);
+  await fs.writeFile(entryFile, entryContent);
+
+  try {
+    const result = await Bun.build({
+      entrypoints: [entryFile],
+      target: "browser",
+      format: "esm",
+      external: ["react", "react-dom"],
+      jsx: { runtime: "automatic" } as any,
+      jsxImportSource: "react",
+      minify: !isDev,
+      sourcemap: isDev ? "external" : undefined,
+    } as any);
+
+    if (!result.success || !result.outputs[0]) {
+      for (const log of result.logs) {
+        console.error("[mintil] island build:", log);
+      }
+      return null;
+    }
+
+    const js = await result.outputs[0].text();
+    bundleCache.set(cacheKey, js);
+    await fs.rm(entryFile).catch(() => {});
+    return js;
+  } catch (err) {
+    console.error("[mintil] island build error:", err);
+    return null;
+  }
+}

package/src/core/logger.ts

@@ -0,0 +1,37 @@
+import { color, formatDuration, statusColorFor } from "../utils/logger.ts";
+
+export function logMiddleware(serverRef?: { current: ReturnType<typeof Bun.serve> | null }) {
+  return async function (c: any, next: () => Promise<void>) {
+    const startTime = performance.now();
+    const method = c.req.method;
+    const pathname = c.req.path;
+
+    await next();
+
+    const status = c.res.status;
+    const durationMs = performance.now() - startTime;
+    const duration = formatDuration(durationMs);
+    const ip = getClientIp(c, serverRef);
+    const date = new Date().toLocaleString("pt-BR");
+    const reset = color.reset;
+
+    console.log(
+      `${date} ${color.green}${method.padEnd(7)}${reset} ${pathname} ${statusColorFor(status)}${status}${reset} - ${duration} - ${ip}`,
+    );
+  };
+}
+
+function getClientIp(
+  c: any,
+  serverRef?: { current: ReturnType<typeof Bun.serve> | null },
+): string {
+  const forwarded = c.req.header("x-forwarded-for") || c.req.header("x-real-ip");
+  if (forwarded) {
+    return String(forwarded).split(",")[0]?.trim() ?? "-";
+  }
+  if (serverRef?.current) {
+    const info = (serverRef.current as any).requestIP?.(c.req.raw);
+    if (info) return info.address;
+  }
+  return "-";
+}