@kubb/ui/dist/index.js

User interface components and web dashboard for Kubb, providing a visual interface for managing and monitoring code generation.

import { z, createRoute, OpenAPIHono } from '@hono/zod-openapi';
import { serve } from '@hono/node-server';
import { cors } from 'hono/cors';
import fs from 'fs';
import { Hono } from 'hono';
import { createServer } from 'http2';
import path from 'path';
import { fileURLToPath } from 'url';

// src/server.ts
var statusSchema = z.object({
  name: z.string().optional(),
  percentages: z.record(z.string(), z.number()),
  executed: z.array(z.any())
}).openapi("Status");

// package.json
var version = "3.16.1";

// src/server.ts
var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
var distPath = path.join(__dirname2, "../static");
var statusRoute = createRoute({
  method: "get",
  path: "/status",
  response: {},
  responses: {
    200: {
      content: {
        "application/json": {
          schema: statusSchema
        }
      },
      description: "Retrieve the status"
    }
  }
});
var restartRoute = createRoute({
  method: "post",
  path: "/restart",
  response: {},
  responses: {
    200: {
      content: {
        "application/json": {
          schema: z.object({})
        }
      },
      description: "Restart creation"
    }
  }
});
var stopRoute = createRoute({
  method: "post",
  path: "/stop",
  response: {},
  responses: {
    200: {
      content: {
        "application/json": {
          schema: z.object({})
        }
      },
      description: "Stop creation"
    }
  }
});
function findOpenPort(preferredPort) {
  return new Promise((resolve, reject) => {
    const server = createServer();
    server.listen(preferredPort, () => {
      server.close(() => resolve(preferredPort));
    });
    server.on("error", async (err) => {
      if (err.code === "EADDRINUSE") {
        resolve(findOpenPort(preferredPort + 1));
      } else {
        reject(err);
      }
    });
  });
}
async function startServer(options, listeningListener) {
  const { stop, restart, getMeta } = options;
  const app = new Hono();
  const api = new OpenAPIHono();
  api.use("*", cors());
  api.openapi(statusRoute, (c) => {
    const meta = getMeta();
    return c.json(
      {
        name: meta.name,
        percentages: meta.percentages,
        executed: []
      },
      200
    );
  });
  api.openapi(stopRoute, (c) => {
    stop();
    return c.json({}, 200);
  });
  api.openapi(restartRoute, (c) => {
    restart();
    return c.json({}, 200);
  });
  api.doc("/doc", {
    openapi: "3.0.0",
    info: {
      version,
      title: "Kubb ui"
    }
  });
  app.route("/api", api);
  app.get("/*", async (c) => {
    const filePath = path.join(distPath, c.req.path);
    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
      return new Response(fs.readFileSync(filePath), {
        headers: { "Content-Type": getMimeType(filePath) }
      });
    }
    return new Response(fs.readFileSync(path.join(distPath, "index.html")), {
      headers: { "Content-Type": "text/html" }
    });
  });
  const getMimeType = (filePath) => {
    const ext = path.extname(filePath).toLowerCase();
    const mimeTypes = {
      ".html": "text/html",
      ".js": "text/javascript",
      ".css": "text/css",
      ".json": "application/json",
      ".png": "image/png",
      ".jpg": "image/jpeg",
      ".gif": "image/gif",
      ".svg": "image/svg+xml",
      ".ico": "image/x-icon"
    };
    return mimeTypes[ext] || "application/octet-stream";
  };
  const port = await findOpenPort(5822);
  return serve(
    {
      fetch: app.fetch,
      port
    },
    listeningListener
  );
}

export { startServer };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map