@devlusoft/devix 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/vite/codegen/entry-client.ts
+function generateEntryClient({ cssUrls }) {
+  const cssImports = cssUrls.map((u) => `import '${u}'`).join("\n");
+  return `
+${cssImports}
+import "@vitejs/plugin-react/preamble"
+import React from "react"
+import {hydrateRoot, createRoot} from 'react-dom/client'
+import {matchClientRoute, loadErrorPage, getDefaultErrorPage} from 'virtual:devix/client-routes'
+import {RouterProvider} from '@devlusoft/devix'
+
+const root = document.getElementById('devix-root')
+
+if (!window.__DEVIX__) {
+    const ErrorPage = getDefaultErrorPage()
+    createRoot(root).render(React.createElement(ErrorPage, {statusCode: 500, message: 'Server error'}))
+} else {
+    const {metadata, viewport, clientEntry} = window.__DEVIX__
+    const loaderData = window.__LOADER_DATA__
+    const layoutsData = window.__LAYOUTS_DATA__ ?? []
+
+    const matched = matchClientRoute(window.location.pathname)
+
+    if (matched) {
+        const [pageMod, ...layoutMods] = await Promise.all([
+            matched.load(),
+            ...matched.loadLayouts.map(l => l()),
+        ])
+        hydrateRoot(
+            root,
+            React.createElement(RouterProvider, {
+                clientEntry,
+                initialData: loaderData,
+                initialParams: matched.params,
+                initialPage: pageMod.default,
+                initialLayouts: layoutMods.map(m => m.default),
+                initialLayoutsData: layoutsData,
+                initialMeta: metadata,
+                initialViewport: viewport,
+            })
+        )
+    } else {
+        const ErrorPage = await loadErrorPage() ?? getDefaultErrorPage()
+        createRoot(root).render(
+            React.createElement(RouterProvider, {
+                clientEntry,
+                initialData: null,
+                initialParams: {},
+                initialPage: () => null,
+                initialLayouts: [],
+                initialLayoutsData: [],
+                initialMeta: null,
+                initialError: {statusCode: 404, message: 'Not found'},
+                initialErrorPage: ErrorPage,
+            })
+        )
+    }
+}
+`;
+}
+var init_entry_client = __esm({
+  "src/vite/codegen/entry-client.ts"() {
+    "use strict";
+  }
+});
+
+// src/vite/codegen/client-routes.ts
+function generateClientRoutes({ pagesDir, matcherPath }) {
+  return `
+import React from 'react'
+import { createMatcher } from '${matcherPath}'
+const pageFiles = import.meta.glob(['/${pagesDir}/**/*.tsx', '!**/error.tsx', '!**/layout.tsx'])
+const layoutFiles = import.meta.glob('/${pagesDir}/**/layout.tsx')
+const errorFiles = import.meta.glob('/${pagesDir}/**/error.tsx')
+
+export const matchClientRoute = createMatcher(pageFiles, layoutFiles)
+
+export async function loadErrorPage() {
+    const key = Object.keys(errorFiles)[0]
+    if (!key) return null
+    const mod = await errorFiles[key]()
+    return mod?.default ?? null
+}
+
+export function getDefaultErrorPage() {
+    return function DefaultError({ statusCode, message }) {
+        return React.createElement('main', {
+            style: { minHeight: '100dvh', display: 'flex', flexDirection: 'column', 
+                     alignItems: 'center', justifyContent: 'center', gap: '8px',
+                     fontFamily: 'system-ui, sans-serif' }
+        },
+            React.createElement('h1', {style: {fontSize: '4rem', fontWeight: 700}}, statusCode),
+            React.createElement('p', {style: {color: '#666'}}, message ?? 'An unexpected error occurred'),
+        )
+    }
+}
+`;
+}
+var init_client_routes = __esm({
+  "src/vite/codegen/client-routes.ts"() {
+    "use strict";
+  }
+});
+
+// src/vite/codegen/render.ts
+function generateRender({ pagesDir, renderPath }) {
+  return `
+import { render as _render, runLoader as _runLoader, getStaticRoutes as _getStaticRoutes } from '${renderPath}'
+
+const _pages = import.meta.glob(['/${pagesDir}/**/*.tsx', '!**/error.tsx', '!**/layout.tsx'])
+const _layouts = import.meta.glob('/${pagesDir}/**/layout.tsx')
+
+const _glob = {
+    pages: _pages,
+    layouts: _layouts,
+    pagesDir: '/${pagesDir}',
+}
+
+export function render(url, request, options) {
+    return _render(url, request, _glob, options)
+}
+
+export function runLoader(url, request, options) {
+    return _runLoader(url, request, _glob, options)
+}
+
+export function getStaticRoutes() {
+    return _getStaticRoutes(_glob)
+}
+`;
+}
+var init_render = __esm({
+  "src/vite/codegen/render.ts"() {
+    "use strict";
+  }
+});
+
+// src/vite/codegen/api.ts
+function generateApi({ apiPath, appDir }) {
+  return `
+import { handleApiRequest as _handleApiRequest } from '${apiPath}'
+
+const _routes = import.meta.glob(['/${appDir}/api/**/*.ts', '!**/middleware.ts'])
+const _middlewares = import.meta.glob('/${appDir}/api/**/middleware.ts')
+
+const _glob = {
+    routes: _routes,
+    middlewares: _middlewares,
+    apiDir: '/${appDir}/api',
+}
+
+export function handleApiRequest(url, request) {
+    return _handleApiRequest(url, request, _glob)
+}
+`;
+}
+var init_api = __esm({
+  "src/vite/codegen/api.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/patterns.ts
+var init_patterns = __esm({
+  "src/utils/patterns.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/pages-router.ts
+function invalidatePagesCache() {
+  cache = null;
+}
+var cache;
+var init_pages_router = __esm({
+  "src/server/pages-router.ts"() {
+    "use strict";
+    init_patterns();
+    cache = null;
+  }
+});
+
+// src/server/api-router.ts
+function invalidateApiCache() {
+  cache2 = null;
+}
+var cache2;
+var init_api_router = __esm({
+  "src/server/api-router.ts"() {
+    "use strict";
+    init_patterns();
+    cache2 = null;
+  }
+});
+
+// src/vite/codegen/context.ts
+function generateContext() {
+  return `
+export {RouterContext} from '@devlusoft/devix/runtime/context'
+`;
+}
+var init_context = __esm({
+  "src/vite/codegen/context.ts"() {
+    "use strict";
+  }
+});
+
+// src/vite/index.ts
+import { mergeConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+function devix(config3) {
+  const appDir = config3.appDir ?? "app";
+  const pagesDir = `${appDir}/pages`;
+  const cssUrls = (config3.css ?? []).map((u) => u.startsWith("/") ? u : `/${u.replace(/^\.\//, "")}`);
+  const renderPath = resolve(__dirname, "../server/render.js").replace(/\\/g, "/");
+  const apiPath = resolve(__dirname, "../server/api.js").replace(/\\/g, "/");
+  const matcherPath = resolve(__dirname, "../runtime/client-router.js").replace(/\\/g, "/");
+  const virtualPlugin = {
+    name: "devix",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_ENTRY_CLIENT) return `\0${VIRTUAL_ENTRY_CLIENT}`;
+      if (id === VIRTUAL_CLIENT_ROUTES) return `\0${VIRTUAL_CLIENT_ROUTES}`;
+      if (id === VIRTUAL_RENDER) return `\0${VIRTUAL_RENDER}`;
+      if (id === VIRTUAL_API) return `\0${VIRTUAL_API}`;
+      if (id === VIRTUAL_CONTEXT) return `\0${VIRTUAL_CONTEXT}`;
+    },
+    load(id) {
+      if (id === `\0${VIRTUAL_ENTRY_CLIENT}`)
+        return generateEntryClient({ cssUrls });
+      if (id === `\0${VIRTUAL_CLIENT_ROUTES}`)
+        return generateClientRoutes({ pagesDir, matcherPath });
+      if (id === `\0${VIRTUAL_RENDER}`)
+        return generateRender({ pagesDir, renderPath });
+      if (id === `\0${VIRTUAL_API}`)
+        return generateApi({ apiPath, appDir });
+      if (id === `\0${VIRTUAL_CONTEXT}`)
+        return generateContext();
+    },
+    configureServer(server) {
+      server.watcher.on("add", (file) => {
+        if (file.startsWith(resolve(process.cwd(), pagesDir))) invalidatePagesCache();
+        if (file.includes(`${appDir}/api`)) invalidateApiCache();
+      });
+      server.watcher.on("unlink", (file) => {
+        if (file.startsWith(resolve(process.cwd(), pagesDir))) invalidatePagesCache();
+        if (file.includes(`${appDir}/api`)) invalidateApiCache();
+      });
+    }
+  };
+  const base = {
+    plugins: [react(), virtualPlugin],
+    ssr: { noExternal: ["@devlusoft/devix"] },
+    ...config3.envPrefix ? { envPrefix: config3.envPrefix } : {}
+  };
+  return mergeConfig(base, config3.vite ?? {});
+}
+var __dirname, VIRTUAL_ENTRY_CLIENT, VIRTUAL_CLIENT_ROUTES, VIRTUAL_RENDER, VIRTUAL_API, VIRTUAL_CONTEXT;
+var init_vite = __esm({
+  "src/vite/index.ts"() {
+    "use strict";
+    init_entry_client();
+    init_client_routes();
+    init_render();
+    init_api();
+    init_pages_router();
+    init_api_router();
+    init_context();
+    __dirname = dirname(fileURLToPath(import.meta.url));
+    VIRTUAL_ENTRY_CLIENT = "virtual:devix/entry-client";
+    VIRTUAL_CLIENT_ROUTES = "virtual:devix/client-routes";
+    VIRTUAL_RENDER = "virtual:devix/render";
+    VIRTUAL_API = "virtual:devix/api";
+    VIRTUAL_CONTEXT = "virtual:devix/context";
+  }
+});
+
+// src/server/routes.ts
+function registerApiRoutes(app3, { apiModule: apiModule3, renderModule: renderModule4, loaderTimeout }) {
+  app3.all("/api/*", async (c) => {
+    try {
+      return await apiModule3.handleApiRequest(c.req.url, c.req.raw);
+    } catch (e) {
+      console.error(e);
+      return c.json({ error: "internal error" }, 500);
+    }
+  });
+  app3.get("/_data/*", async (c) => {
+    try {
+      const { pathname, search } = new URL(c.req.url, "http://localhost");
+      const url = pathname.replace(/^\/_data/, "") + search;
+      const data = await renderModule4.runLoader(url, c.req.raw, { loaderTimeout });
+      return c.json(data);
+    } catch (e) {
+      console.error(e);
+      return c.json({ error: "internal error" }, 500);
+    }
+  });
+}
+function registerSsrRoute(app3, { renderModule: renderModule4, manifest: manifest3, loaderTimeout }) {
+  app3.get("*", async (c) => {
+    try {
+      const { html, statusCode, headers } = await renderModule4.render(c.req.url, c.req.raw, { manifest: manifest3, loaderTimeout });
+      const res = c.html(`<!DOCTYPE html>${html}`, statusCode);
+      for (const [key, value] of Object.entries(headers)) {
+        res.headers.set(key, value);
+      }
+      return res;
+    } catch (e) {
+      console.error(e);
+      return c.text("Internal Server Error", 500);
+    }
+  });
+}
+var init_routes = __esm({
+  "src/server/routes.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/banner.ts
+import pc from "picocolors";
+import { networkInterfaces } from "node:os";
+import { createRequire } from "node:module";
+function getNetworkUrl(port3) {
+  const nets = networkInterfaces();
+  for (const interfaces of Object.values(nets)) {
+    for (const net of interfaces ?? []) {
+      if (net.family === "IPv4" && !net.internal) {
+        return `http://${net.address}:${port3}/`;
+      }
+    }
+  }
+  return null;
+}
+function printDevBanner(port3) {
+  const req = createRequire(import.meta.url);
+  const version = req("../../package.json").version;
+  const networkUrl = getNetworkUrl(port3);
+  console.log();
+  console.log(`  ${pc.bold(pc.yellow("devix"))} ${pc.dim(`v${version}`)}`);
+  console.log();
+  console.log(`  ${pc.green("\u279C")}  ${pc.bold("Local:")}   ${pc.cyan(`http://localhost:${port3}/`)}`);
+  if (networkUrl) {
+    console.log(`  ${pc.green("\u279C")}  ${pc.bold("Network:")} ${pc.cyan(networkUrl)}`);
+  } else {
+    console.log(`  ${pc.green("\u279C")}  ${pc.bold("Network:")} ${pc.dim("use --host to expose")}`);
+  }
+  console.log();
+}
+var init_banner = __esm({
+  "src/utils/banner.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/collect-css.ts
+async function collectCss(vite2) {
+  const cssUrls = /* @__PURE__ */ new Set();
+  for (const [, mod] of vite2.moduleGraph.idToModuleMap) {
+    if (!mod.id) continue;
+    if (mod.id.endsWith(".css") || mod.id.includes(".css?")) {
+      cssUrls.add(mod.url);
+    }
+  }
+  return [...cssUrls];
+}
+var init_collect_css = __esm({
+  "src/server/collect-css.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/duration.ts
+function parseDuration(value) {
+  if (typeof value === "number") return value;
+  const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/);
+  if (!match) throw new Error(`[devix] Invalid duration: "${value}". Use a number (ms) or a string like "5s", "2m", "500ms".`);
+  const n = parseFloat(match[1]);
+  switch (match[2]) {
+    case "h":
+      return n * 36e5;
+    case "m":
+      return n * 6e4;
+    case "s":
+      return n * 1e3;
+    case "ms":
+    default:
+      return n;
+  }
+}
+var init_duration = __esm({
+  "src/utils/duration.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/dev.ts
+var dev_exports = {};
+import { createServer } from "node:http";
+import { createServer as createViteServer } from "vite";
+import { getRequestListener } from "@hono/node-server";
+import { Hono } from "hono";
+var VIRTUAL_RENDER2, VIRTUAL_API2, config, port, host, vite, renderModule, apiModule, app, honoHandler;
+var init_dev = __esm({
+  async "src/cli/dev.ts"() {
+    "use strict";
+    init_vite();
+    init_routes();
+    init_banner();
+    init_collect_css();
+    init_duration();
+    VIRTUAL_RENDER2 = "virtual:devix/render";
+    VIRTUAL_API2 = "virtual:devix/api";
+    config = (await import(`${process.cwd()}/devix.config.ts`)).default;
+    port = Number(process.env.PORT) || config.port || 3e3;
+    host = typeof config.host === "string" ? config.host : config.host ? "0.0.0.0" : "localhost";
+    vite = await createViteServer({
+      ...devix(config),
+      configFile: false,
+      appType: "custom",
+      server: { middlewareMode: true }
+    });
+    renderModule = {
+      render: async (...args) => (await vite.ssrLoadModule(VIRTUAL_RENDER2)).render(...args),
+      runLoader: async (...args) => (await vite.ssrLoadModule(VIRTUAL_RENDER2)).runLoader(...args)
+    };
+    apiModule = {
+      handleApiRequest: async (...args) => (await vite.ssrLoadModule(VIRTUAL_API2)).handleApiRequest(...args)
+    };
+    app = new Hono();
+    registerApiRoutes(app, { renderModule, apiModule });
+    app.get("*", async (c) => {
+      try {
+        const { html, statusCode, headers } = await renderModule.render(c.req.url, c.req.raw, { loaderTimeout: parseDuration(config.loaderTimeout ?? 1e4) });
+        const cssUrls = await collectCss(vite);
+        const cssLinks = cssUrls.map((url) => `<link rel="stylesheet" href="${url}">`).join("\n");
+        const htmlWithCss = cssLinks ? html.replace("</head>", `${cssLinks}
+</head>`) : html;
+        const transformed = await vite.transformIndexHtml(c.req.url, `<!DOCTYPE html>${htmlWithCss}`);
+        const res = c.html(transformed, statusCode);
+        for (const [key, value] of Object.entries(headers)) {
+          res.headers.set(key, value);
+        }
+        return res;
+      } catch (e) {
+        vite.ssrFixStacktrace(e);
+        console.error(e);
+        return c.text("Internal Server Error", 500);
+      }
+    });
+    honoHandler = getRequestListener(app.fetch);
+    createServer(async (req, res) => {
+      await new Promise((resolve5) => vite.middlewares(req, res, resolve5));
+      if (!res.writableEnded) await honoHandler(req, res);
+    }).listen(port, host, () => {
+      printDevBanner(port);
+    });
+  }
+});
+
+// src/cli/build.ts
+var build_exports = {};
+import { writeFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { build } from "vite";
+var config2, baseConfig, runtimeConfig;
+var init_build = __esm({
+  async "src/cli/build.ts"() {
+    "use strict";
+    init_vite();
+    init_duration();
+    config2 = (await import(`${process.cwd()}/devix.config.ts`)).default;
+    baseConfig = devix(config2);
+    await build({
+      ...baseConfig,
+      configFile: false,
+      build: {
+        outDir: "dist/client",
+        manifest: true,
+        rolldownOptions: {
+          input: "virtual:devix/entry-client"
+        }
+      }
+    });
+    await build({
+      ...baseConfig,
+      configFile: false,
+      build: {
+        ssr: true,
+        outDir: "dist/server",
+        rolldownOptions: {
+          input: {
+            render: "virtual:devix/render",
+            api: "virtual:devix/api"
+          }
+        }
+      }
+    });
+    runtimeConfig = {
+      port: config2.port ?? 3e3,
+      host: config2.host ?? false,
+      loaderTimeout: parseDuration(config2.loaderTimeout ?? 1e4),
+      output: config2.output ?? "server"
+    };
+    writeFileSync(
+      resolve2(process.cwd(), "dist/devix.config.json"),
+      JSON.stringify(runtimeConfig, null, 2),
+      "utf-8"
+    );
+  }
+});
+
+// src/cli/generate.ts
+var generate_exports = {};
+import { readFileSync, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve3, join } from "node:path";
+var userConfig, t, renderModule2, manifest, urls;
+var init_generate = __esm({
+  async "src/cli/generate.ts"() {
+    "use strict";
+    userConfig = (await import(`${process.cwd()}/devix.config.ts`)).default;
+    if (userConfig.output !== "static") {
+      console.warn('[devix] Tip: set output: "static" in devix.config.ts to skip the SSR server at runtime.');
+    }
+    await init_build().then(() => build_exports);
+    t = Date.now();
+    renderModule2 = await import(resolve3(process.cwd(), "dist/server/render.js") + `?t=${t}`);
+    manifest = JSON.parse(
+      readFileSync(resolve3(process.cwd(), "dist/client/.vite/manifest.json"), "utf-8")
+    );
+    urls = await renderModule2.getStaticRoutes();
+    console.log(`[devix] Generating ${urls.length} static page${urls.length === 1 ? "" : "s"}...`);
+    for (const url of urls) {
+      const fullUrl = `http://localhost${url}`;
+      const { html, statusCode } = await renderModule2.render(fullUrl, new Request(fullUrl), { manifest });
+      if (statusCode !== 200) {
+        console.warn(`[devix] Skipping ${url} \u2014 status ${statusCode}`);
+        continue;
+      }
+      const outPath = url === "/" ? join(process.cwd(), "dist/client/index.html") : join(process.cwd(), "dist/client", url, "index.html");
+      mkdirSync(join(outPath, ".."), { recursive: true });
+      writeFileSync2(outPath, `<!DOCTYPE html>${html}`, "utf-8");
+      console.log(`  \u2713 ${url}`);
+    }
+    console.log("[devix] Generation complete.");
+  }
+});
+
+// src/cli/start.ts
+var start_exports = {};
+import { readFileSync as readFileSync2 } from "node:fs";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono as Hono2 } from "hono";
+import { resolve as resolve4 } from "node:path";
+var renderModule3, apiModule2, manifest2, runtimeConfig2, port2, host2, app2;
+var init_start = __esm({
+  async "src/cli/start.ts"() {
+    "use strict";
+    init_routes();
+    try {
+      runtimeConfig2 = JSON.parse(readFileSync2(resolve4(process.cwd(), "dist/devix.config.json"), "utf-8"));
+      if (runtimeConfig2.output !== "static") {
+        renderModule3 = await import(resolve4(process.cwd(), "dist/server/render.js"));
+        apiModule2 = await import(resolve4(process.cwd(), "dist/server/api.js"));
+      }
+      manifest2 = JSON.parse(readFileSync2(resolve4(process.cwd(), "dist/client/.vite/manifest.json"), "utf-8"));
+    } catch {
+      console.error('[devix] Build not found. Run "devix build" first.');
+      process.exit(1);
+    }
+    port2 = Number(process.env.PORT) || runtimeConfig2.port || 3e3;
+    host2 = typeof runtimeConfig2.host === "string" ? runtimeConfig2.host : runtimeConfig2.host ? "0.0.0.0" : process.env.HOST || "0.0.0.0";
+    app2 = new Hono2();
+    app2.use("/*", serveStatic({
+      root: "./dist/client",
+      onFound: (_path, c) => {
+        c.header("Cache-Control", _path.includes("/assets/") ? "public, immutable, max-age=31536000" : "no-cache");
+      }
+    }));
+    if (runtimeConfig2.output === "static") {
+      console.log("[devix] Static mode \u2014 serving pre-generated files from dist/client");
+    } else {
+      registerApiRoutes(app2, { renderModule: renderModule3, apiModule: apiModule2, manifest: manifest2 });
+      registerSsrRoute(app2, { renderModule: renderModule3, apiModule: apiModule2, manifest: manifest2, loaderTimeout: runtimeConfig2.loaderTimeout });
+    }
+    serve({ fetch: app2.fetch, port: port2, hostname: host2 }, (info) => console.log(`http://${info.address}:${info.port}`));
+  }
+});
+
+// src/cli/index.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var command = process.argv[2];
+switch (command) {
+  case "dev":
+    await init_dev().then(() => dev_exports);
+    break;
+  case "build":
+    await init_build().then(() => build_exports);
+    break;
+  case "generate":
+    await init_generate().then(() => generate_exports);
+    break;
+  case "start":
+    await init_start().then(() => start_exports);
+    break;
+  case "--version":
+  case "-v": {
+    const pkg = JSON.parse(readFileSync3(join2(dirname2(fileURLToPath2(import.meta.url)), "../../package.json"), "utf-8"));
+    console.log(pkg.version);
+    break;
+  }
+  case "--help":
+  case "-h":
+    console.log(`
+devix \u2014 a lightweight SSR framework
+
+Usage:
+  devix dev        Start development server
+  devix build      Build for production
+  devix generate   Build and generate static HTML (SSG)
+  devix start      Start production server
+
+Options:
+  -v, --version  Show version
+  -h, --help     Show this help
+
+Output modes (set in devix.config.ts):
+  output: "server"   SSR mode \u2014 devix start handles requests dynamically (default)
+  output: "static"   SSG mode \u2014 devix generate pre-renders all pages; devix start serves static files only
+        `.trim());
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error("Usage: devix <dev|build|generate|start>");
+    process.exit(1);
+}
+//# sourceMappingURL=index.js.map