@kubb/ui/dist/index.cjs

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

//#region rolldown:runtime
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
		key = keys[i];
		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: ((k) => from[k]).bind(null, key),
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));

//#endregion
let __hono_zod_openapi = require("@hono/zod-openapi");
__hono_zod_openapi = __toESM(__hono_zod_openapi);
let __hono_node_server = require("@hono/node-server");
__hono_node_server = __toESM(__hono_node_server);
let hono_cors = require("hono/cors");
hono_cors = __toESM(hono_cors);
let node_fs = require("node:fs");
node_fs = __toESM(node_fs);
let hono = require("hono");
hono = __toESM(hono);
let node_http2 = require("node:http2");
node_http2 = __toESM(node_http2);
let node_path = require("node:path");
node_path = __toESM(node_path);
let node_url = require("node:url");
node_url = __toESM(node_url);

//#region src/models/StatusSchema.ts
const statusSchema = __hono_zod_openapi.z.object({
	name: __hono_zod_openapi.z.string().optional(),
	percentages: __hono_zod_openapi.z.record(__hono_zod_openapi.z.string(), __hono_zod_openapi.z.number()),
	executed: __hono_zod_openapi.z.array(__hono_zod_openapi.z.any())
}).openapi("Status");

//#endregion
//#region package.json
var version = "4.0.0";

//#endregion
//#region src/server.ts
const __dirname$1 = node_path.default.dirname((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
const distPath = node_path.default.join(__dirname$1, "../static");
const statusRoute = (0, __hono_zod_openapi.createRoute)({
	method: "get",
	path: "/status",
	response: {},
	responses: { 200: {
		content: { "application/json": { schema: statusSchema } },
		description: "Retrieve the status"
	} }
});
const restartRoute = (0, __hono_zod_openapi.createRoute)({
	method: "post",
	path: "/restart",
	response: {},
	responses: { 200: {
		content: { "application/json": { schema: __hono_zod_openapi.z.object({}) } },
		description: "Restart creation"
	} }
});
const stopRoute = (0, __hono_zod_openapi.createRoute)({
	method: "post",
	path: "/stop",
	response: {},
	responses: { 200: {
		content: { "application/json": { schema: __hono_zod_openapi.z.object({}) } },
		description: "Stop creation"
	} }
});
function findOpenPort(preferredPort) {
	return new Promise((resolve, reject) => {
		const server = (0, node_http2.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.Hono();
	const api = new __hono_zod_openapi.OpenAPIHono();
	api.use("*", (0, hono_cors.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 = node_path.default.join(distPath, c.req.path);
		if (node_fs.default.existsSync(filePath) && node_fs.default.statSync(filePath).isFile()) return new Response(node_fs.default.readFileSync(filePath), { headers: { "Content-Type": getMimeType(filePath) } });
		return new Response(node_fs.default.readFileSync(node_path.default.join(distPath, "index.html")), { headers: { "Content-Type": "text/html" } });
	});
	const getMimeType = (filePath) => {
		const ext = node_path.default.extname(filePath).toLowerCase();
		return {
			".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"
		}[ext] || "application/octet-stream";
	};
	const port = await findOpenPort(5822);
	return (0, __hono_node_server.serve)({
		fetch: app.fetch,
		port
	}, listeningListener);
}

//#endregion
exports.startServer = startServer;
//# sourceMappingURL=index.cjs.map