@mergehez/dokie-node 0.1.2

package/dist/index.mjs

@@ -0,0 +1,242 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+//#region node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+const _coreExports = createDokieServerExports(path.resolve(__dirname, "../assets/dokie.html"), (assetPath) => fs.readFileSync(assetPath, "utf8"));
+function normalizeFetchRequest(req) {
+	const url = new URL(req.url);
+	return {
+		get(name) {
+			return req.headers.get(name) ?? void 0;
+		},
+		header(name) {
+			return req.headers.get(name) ?? void 0;
+		},
+		headers: Object.fromEntries(req.headers.entries()),
+		hostname: url.host,
+		protocol: url.protocol.replace(/:$/, "")
+	};
+}
+function forCustomServer() {
+	return {
+		createDokieHandler: _coreExports.createDokieHandler,
+		createDokieMiddleware: _coreExports.createDokieHandler,
+		getDokieAssetPath: _coreExports.getDokieAssetPath,
+		registerDokieRoute: _coreExports.registerDokieRoute,
+		renderDokieHtml: _coreExports.renderDokieHtml
+	};
+}
+function forFetch() {
+	function renderDokieHtmlForFetch(options = {}, req) {
+		return _coreExports.renderDokieHtml(options, req ? normalizeFetchRequest(req) : void 0);
+	}
+	function createDokieHandlerForFetch(options = {}) {
+		return function dokieFetchHandler(req) {
+			const html = renderDokieHtmlForFetch(options, req);
+			return new Response(html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+		};
+	}
+	return {
+		createDokieHandler: createDokieHandlerForFetch,
+		createDokieMiddleware: createDokieHandlerForFetch,
+		getDokieAssetPath: _coreExports.getDokieAssetPath,
+		renderDokieHtml: renderDokieHtmlForFetch
+	};
+}
+function escapeHtml(value) {
+	return String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+function safeJson(value) {
+	return JSON.stringify(value).replaceAll("<", "\\u003c").replaceAll(">", "\\u003e").replaceAll("&", "\\u0026").replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+}
+function trimTrailingSlash(value) {
+	return typeof value === "string" ? value.replace(/\/+$/, "") : value;
+}
+function getRequestHeader(req, name) {
+	if (!req) return;
+	if (typeof req.get === "function") return req.get(name);
+	if (typeof req.header === "function") return req.header(name);
+	const headers = req.headers ?? {};
+	const value = headers[name.toLowerCase()] ?? headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
+function getOpenApiJsonUrl(currentHostname, options = {}) {
+	const configuredUrl = options.openApiJsonUrl ?? "/openapi.json";
+	if (typeof configuredUrl !== "string" || configuredUrl.length === 0) return "/openapi.json";
+	if (/^[a-z]+:\/\//i.test(configuredUrl)) return configuredUrl;
+	if (configuredUrl.startsWith("/") && currentHostname) return `${currentHostname}${configuredUrl}`;
+	return configuredUrl;
+}
+function buildDokieConfig(options = {}, req) {
+	const getProtocol = () => {
+		if (!req) return "http";
+		if (typeof req.protocol === "string" && req.protocol.length > 0) return req.protocol;
+		const forwardedProto = getRequestHeader(req, "x-forwarded-proto");
+		if (typeof forwardedProto === "string" && forwardedProto.length > 0) return forwardedProto.split(",")[0].trim();
+		if (req.socket?.encrypted || req.connection?.encrypted) return "https";
+		return "http";
+	};
+	const currentHost = (() => {
+		if (!req) return;
+		if (typeof req.hostname === "string" && req.hostname.length > 0) {
+			const port = req.socket?.localPort;
+			return req.hostname.includes(":") || !port ? req.hostname : `${req.hostname}:${port}`;
+		}
+		const forwardedHost = getRequestHeader(req, "x-forwarded-host");
+		if (typeof forwardedHost === "string" && forwardedHost.length > 0) return forwardedHost.split(",")[0].trim();
+		const host = getRequestHeader(req, "host");
+		return typeof host === "string" && host.length > 0 ? host : void 0;
+	})();
+	const currentHostname = typeof options.currentHostname === "string" && options.currentHostname.length > 0 ? trimTrailingSlash(options.currentHostname) ?? "" : currentHost ? `${getProtocol()}://${currentHost}` : "";
+	return {
+		currentHostname,
+		openApiJsonUrl: getOpenApiJsonUrl(currentHostname, options),
+		hostnames: Array.isArray(options.hostnames) && options.hostnames.length > 0 ? options.hostnames : currentHostname ? [currentHostname] : [],
+		variables: options.variables ?? {},
+		headers: options.headers ?? {},
+		postscripts: options.postscripts ?? {},
+		bodies: options.bodies ?? {},
+		favorites: options.favorites ?? []
+	};
+}
+function sendHtml(res, html) {
+	if (!res) throw new TypeError("A response object is required.");
+	if (typeof res.type === "function") res.type("html");
+	if (typeof res.setHeader === "function") res.setHeader("Content-Type", "text/html; charset=utf-8");
+	if (typeof res.send === "function") return res.send(html);
+	if (typeof res.end === "function") return res.end(html);
+	throw new TypeError("The response object must support send() or end().");
+}
+function createDokieServerExports(defaultAssetPath, readAsset) {
+	function getDokieAssetPath() {
+		return defaultAssetPath;
+	}
+	function renderDokieHtml(options = {}, req) {
+		const html = readAsset(options.assetPath ?? defaultAssetPath);
+		const dokieConfig = buildDokieConfig(options, req);
+		const finalHtml = html.replace("/*dokie-inject-area*/", `window.dokie = ${safeJson(dokieConfig)};`);
+		if (typeof options.title === "string" && options.title.trim().length > 0) return finalHtml.replace("<title>Dokie</title>", `<title>${escapeHtml(options.title)}</title>`);
+		return finalHtml;
+	}
+	function createDokieHandler(options = {}) {
+		return function dokieHandler(req, res) {
+			return sendHtml(res, renderDokieHtml(options, req));
+		};
+	}
+	function registerDokieRoute(app, options = {}) {
+		if (!app || typeof app.get !== "function") throw new TypeError("registerDokieRoute expects an app with a get(path, handler) method.");
+		const routePath = options.routePath ?? "/dokie";
+		const handler = createDokieHandler(options);
+		app.get(routePath, handler);
+		return handler;
+	}
+	return {
+		createDokieHandler,
+		createDokieMiddleware: createDokieHandler,
+		getDokieAssetPath,
+		registerDokieRoute,
+		renderDokieHtml
+	};
+}
+//#endregion
+//#region src/express.ts
+function forExpress() {
+	return {
+		createDokieHandler: _coreExports.createDokieHandler,
+		createDokieMiddleware: _coreExports.createDokieHandler,
+		getDokieAssetPath: _coreExports.getDokieAssetPath,
+		registerDokieRoute: _coreExports.registerDokieRoute,
+		renderDokieHtml: _coreExports.renderDokieHtml
+	};
+}
+//#endregion
+//#region src/fastify.ts
+function forFastify() {
+	function normalizeFastifyRequest(req) {
+		const header = (name) => {
+			const rawHeader = req.raw?.header?.(name);
+			if (typeof rawHeader === "string" && rawHeader.length > 0) return rawHeader;
+			const directHeader = req.header?.(name);
+			if (typeof directHeader === "string" && directHeader.length > 0) return directHeader;
+			const headers = req.headers ?? req.raw?.headers;
+			const value = headers?.[name.toLowerCase()] ?? headers?.[name];
+			return Array.isArray(value) ? value[0] : value;
+		};
+		return {
+			connection: req.raw?.connection,
+			get: req.raw?.get?.bind(req.raw),
+			header,
+			headers: req.headers ?? req.raw?.headers,
+			hostname: req.hostname ?? req.raw?.hostname,
+			protocol: req.protocol ?? req.raw?.protocol,
+			socket: req.raw?.socket
+		};
+	}
+	const renderDokieHtmlForFastify = (options = {}, req) => {
+		return _coreExports.renderDokieHtml(options, req ? normalizeFastifyRequest(req) : void 0);
+	};
+	function createDokieHandlerForFastify(options = {}) {
+		return function dokieFastifyHandler(req, reply) {
+			const html = renderDokieHtmlForFastify(options, req);
+			if (typeof reply.type === "function") reply.type("text/html; charset=utf-8");
+			if (typeof reply.header === "function") reply.header("Content-Type", "text/html; charset=utf-8");
+			if (typeof reply.send === "function") return reply.send(html);
+			throw new TypeError("The Fastify reply object must support send().");
+		};
+	}
+	return {
+		createDokieHandler: createDokieHandlerForFastify,
+		createDokieMiddleware: createDokieHandlerForFastify,
+		getDokieAssetPath: _coreExports.getDokieAssetPath,
+		renderDokieHtml: renderDokieHtmlForFastify,
+		registerDokieRoute(app, options = {}) {
+			if (!app || typeof app.get !== "function") throw new TypeError("registerDokieRoute expects a Fastify instance with a get(path, handler) method.");
+			const routePath = options.routePath ?? "/dokie";
+			const handler = createDokieHandlerForFastify(options);
+			app.get(routePath, handler);
+			return handler;
+		}
+	};
+}
+//#endregion
+//#region src/hono.ts
+function forHono() {
+	function normalizeHonoRequest(req) {
+		const url = new URL(req.url);
+		return {
+			get: req.get?.bind(req),
+			header: req.header?.bind(req),
+			headers: req.raw ? Object.fromEntries(req.raw.headers.entries()) : void 0,
+			hostname: url.host,
+			protocol: url.protocol.replace(/:$/, "")
+		};
+	}
+	function renderDokieHtmlForHono(options = {}, req) {
+		return _coreExports.renderDokieHtml(options, req ? normalizeHonoRequest(req) : void 0);
+	}
+	function createDokieHandlerForHono(options = {}) {
+		return function dokieHonoHandler(context) {
+			const html = renderDokieHtmlForHono(options, context.req);
+			if (typeof context.html === "function") return context.html(html);
+			return new Response(html, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+		};
+	}
+	return {
+		createDokieHandler: createDokieHandlerForHono,
+		createDokieMiddleware: createDokieHandlerForHono,
+		getDokieAssetPath: _coreExports.getDokieAssetPath,
+		renderDokieHtml: renderDokieHtmlForHono,
+		registerDokieRoute(app, options = {}) {
+			if (!app || typeof app.get !== "function") throw new TypeError("registerDokieRoute expects a Hono app with a get(path, handler) method.");
+			const routePath = options.routePath ?? "/dokie";
+			const handler = createDokieHandlerForHono(options);
+			app.get(routePath, handler);
+			return handler;
+		}
+	};
+}
+//#endregion
+export { forCustomServer, forExpress, forFastify, forFetch, forHono };

package/package.json

@@ -0,0 +1,72 @@
+{
+    "name": "@mergehez/dokie-node",
+    "version": "0.1.2",
+    "description": "A Node.js package for serving the Dokie API documentation UI across generic servers, Express, Fastify, and Hono.",
+    "license": "MIT",
+    "author": "mergehez",
+    "type": "module",
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "files": [
+        "dist",
+        "assets",
+        "README.md",
+        "LICENSE"
+    ],
+    "sideEffects": false,
+    "engines": {
+        "node": ">=18"
+    },
+    "homepage": "https://github.com/mergehez/dokie/tree/main/packages/node",
+    "bugs": {
+        "url": "https://github.com/mergehez/dokie/issues"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "keywords": [
+        "openapi",
+        "swagger",
+        "swagger-ui",
+        "api",
+        "api-docs",
+        "api-client",
+        "documentation",
+        "dokie",
+        "openapi-ui",
+        "rest-client",
+        "node",
+        "http",
+        "express",
+        "fastify",
+        "hono",
+        "nextjs",
+        "nuxt",
+        "remix",
+        "astro",
+        "fetch"
+    ],
+    "scripts": {
+        "build": "vp check --fix && tsdown",
+        "test": "bun test"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.12",
+        "@types/node": "^25.6.0",
+        "tsdown": "^0.21.7",
+        "typescript": "^6.0.2"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mergehez/dokie.git",
+        "directory": "packages/node"
+    }
+}