mirror of
https://github.com/JimLiu/baoyu-skills.git
synced 2026-07-12 05:51:44 +08:00
Jim Liu 宝玉
730 lines
25 KiB
JavaScript
730 lines
25 KiB
JavaScript
var __create = Object.create;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
function __accessProp(key) {
|
|
return this[key];
|
|
}
|
|
var __toESMCache_node;
|
|
var __toESMCache_esm;
|
|
var __toESM = (mod, isNodeMode, target) => {
|
|
var canCache = mod != null && typeof mod === "object";
|
|
if (canCache) {
|
|
var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
|
|
var cached = cache.get(mod);
|
|
if (cached)
|
|
return cached;
|
|
}
|
|
target = mod != null ? __create(__getProtoOf(mod)) : {};
|
|
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
|
|
for (let key of __getOwnPropNames(mod))
|
|
if (!__hasOwnProp.call(to, key))
|
|
__defProp(to, key, {
|
|
get: __accessProp.bind(mod, key),
|
|
enumerable: true
|
|
});
|
|
if (canCache)
|
|
cache.set(mod, to);
|
|
return to;
|
|
};
|
|
var __toCommonJS = (from) => {
|
|
var entry = (__moduleCache ??= new WeakMap).get(from), desc;
|
|
if (entry)
|
|
return entry;
|
|
entry = __defProp({}, "__esModule", { value: true });
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (var key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(entry, key))
|
|
__defProp(entry, key, {
|
|
get: __accessProp.bind(from, key),
|
|
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
});
|
|
}
|
|
__moduleCache.set(from, entry);
|
|
return entry;
|
|
};
|
|
var __moduleCache;
|
|
var __returnValue = (v) => v;
|
|
function __exportSetter(name, newValue) {
|
|
this[name] = __returnValue.bind(null, newValue);
|
|
}
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, {
|
|
get: all[name],
|
|
enumerable: true,
|
|
configurable: true,
|
|
set: __exportSetter.bind(all, name)
|
|
});
|
|
};
|
|
|
|
// src/mermaid.ts
|
|
var exports_mermaid = {};
|
|
__export(exports_mermaid, {
|
|
renderMermaidToPng: () => renderMermaidToPng,
|
|
closeRenderer: () => closeRenderer,
|
|
MermaidRenderError: () => MermaidRenderError
|
|
});
|
|
module.exports = __toCommonJS(exports_mermaid);
|
|
var import_node_child_process2 = require("node:child_process");
|
|
var import_node_fs2 = __toESM(require("node:fs"));
|
|
var import_node_path2 = __toESM(require("node:path"));
|
|
var import_node_process2 = __toESM(require("node:process"));
|
|
var import_node_url = require("node:url");
|
|
|
|
// src/index.ts
|
|
var import_node_child_process = require("node:child_process");
|
|
var import_node_fs = __toESM(require("node:fs"));
|
|
var import_node_net = __toESM(require("node:net"));
|
|
var import_node_os = __toESM(require("node:os"));
|
|
var import_node_path = __toESM(require("node:path"));
|
|
var import_node_process = __toESM(require("node:process"));
|
|
function sleep(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
async function getFreePort(fixedEnvName) {
|
|
const fixed = fixedEnvName ? Number.parseInt(import_node_process.default.env[fixedEnvName] ?? "", 10) : NaN;
|
|
if (Number.isInteger(fixed) && fixed > 0)
|
|
return fixed;
|
|
return await new Promise((resolve, reject) => {
|
|
const server = import_node_net.default.createServer();
|
|
server.unref();
|
|
server.on("error", reject);
|
|
server.listen(0, "127.0.0.1", () => {
|
|
const address = server.address();
|
|
if (!address || typeof address === "string") {
|
|
server.close(() => reject(new Error("Unable to allocate a free TCP port.")));
|
|
return;
|
|
}
|
|
const port = address.port;
|
|
server.close((err) => {
|
|
if (err)
|
|
reject(err);
|
|
else
|
|
resolve(port);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
function findChromeExecutable(options) {
|
|
for (const envName of options.envNames ?? []) {
|
|
const override = import_node_process.default.env[envName]?.trim();
|
|
if (override && import_node_fs.default.existsSync(override))
|
|
return override;
|
|
}
|
|
const candidates = import_node_process.default.platform === "darwin" ? options.candidates.darwin ?? options.candidates.default : import_node_process.default.platform === "win32" ? options.candidates.win32 ?? options.candidates.default : options.candidates.default;
|
|
for (const candidate of candidates) {
|
|
if (import_node_fs.default.existsSync(candidate))
|
|
return candidate;
|
|
}
|
|
return;
|
|
}
|
|
function resolveSharedChromeProfileDir(options = {}) {
|
|
for (const envName of options.envNames ?? []) {
|
|
const override = import_node_process.default.env[envName]?.trim();
|
|
if (override)
|
|
return import_node_path.default.resolve(override);
|
|
}
|
|
const appDataDirName = options.appDataDirName ?? "baoyu-skills";
|
|
const profileDirName = options.profileDirName ?? "chrome-profile";
|
|
if (options.wslWindowsHome) {
|
|
return import_node_path.default.join(options.wslWindowsHome, ".local", "share", appDataDirName, profileDirName);
|
|
}
|
|
const base = import_node_process.default.platform === "darwin" ? import_node_path.default.join(import_node_os.default.homedir(), "Library", "Application Support") : import_node_process.default.platform === "win32" ? import_node_process.default.env.APPDATA ?? import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Roaming") : import_node_process.default.env.XDG_DATA_HOME ?? import_node_path.default.join(import_node_os.default.homedir(), ".local", "share");
|
|
return import_node_path.default.join(base, appDataDirName, profileDirName);
|
|
}
|
|
async function fetchWithTimeout(url, timeoutMs) {
|
|
if (!timeoutMs || timeoutMs <= 0)
|
|
return await fetch(url, { redirect: "follow" });
|
|
const ctl = new AbortController;
|
|
const timer = setTimeout(() => ctl.abort(), timeoutMs);
|
|
try {
|
|
return await fetch(url, { redirect: "follow", signal: ctl.signal });
|
|
} finally {
|
|
clearTimeout(timer);
|
|
}
|
|
}
|
|
async function fetchJson(url, options = {}) {
|
|
const response = await fetchWithTimeout(url, options.timeoutMs);
|
|
if (!response.ok) {
|
|
throw new Error(`Request failed: ${response.status} ${response.statusText}`);
|
|
}
|
|
return await response.json();
|
|
}
|
|
async function isDebugPortReady(port, timeoutMs = 3000) {
|
|
try {
|
|
const version = await fetchJson(`http://127.0.0.1:${port}/json/version`, { timeoutMs });
|
|
return !!version.webSocketDebuggerUrl;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
function parseDevToolsActivePort(filePath) {
|
|
try {
|
|
const content = import_node_fs.default.readFileSync(filePath, "utf-8");
|
|
const lines = content.split(/\r?\n/);
|
|
const port = Number.parseInt(lines[0]?.trim() ?? "", 10);
|
|
const wsPath = lines[1]?.trim();
|
|
if (port > 0 && wsPath)
|
|
return { port, wsPath };
|
|
} catch {}
|
|
return null;
|
|
}
|
|
async function findExistingChromeDebugPort(options) {
|
|
const timeoutMs = options.timeoutMs ?? 3000;
|
|
const parsed = parseDevToolsActivePort(import_node_path.default.join(options.profileDir, "DevToolsActivePort"));
|
|
if (parsed && parsed.port > 0 && await isDebugPortReady(parsed.port, timeoutMs))
|
|
return parsed.port;
|
|
if (import_node_process.default.platform === "win32")
|
|
return null;
|
|
try {
|
|
const result = import_node_child_process.spawnSync("ps", ["aux"], { encoding: "utf-8", timeout: 5000 });
|
|
if (result.status !== 0 || !result.stdout)
|
|
return null;
|
|
const lines = result.stdout.split(`
|
|
`).filter((line) => line.includes(options.profileDir) && line.includes("--remote-debugging-port="));
|
|
for (const line of lines) {
|
|
const portMatch = line.match(/--remote-debugging-port=(\d+)/);
|
|
const port = Number.parseInt(portMatch?.[1] ?? "", 10);
|
|
if (port > 0 && await isDebugPortReady(port, timeoutMs))
|
|
return port;
|
|
}
|
|
} catch {}
|
|
return null;
|
|
}
|
|
async function waitForChromeDebugPort(port, timeoutMs, options) {
|
|
const start = Date.now();
|
|
let lastError = null;
|
|
while (Date.now() - start < timeoutMs) {
|
|
try {
|
|
const version = await fetchJson(`http://127.0.0.1:${port}/json/version`, { timeoutMs: 5000 });
|
|
if (version.webSocketDebuggerUrl)
|
|
return version.webSocketDebuggerUrl;
|
|
lastError = new Error("Missing webSocketDebuggerUrl");
|
|
} catch (error) {
|
|
lastError = error;
|
|
}
|
|
await sleep(200);
|
|
}
|
|
if (options?.includeLastError && lastError) {
|
|
throw new Error(`Chrome debug port not ready: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
|
|
}
|
|
throw new Error("Chrome debug port not ready");
|
|
}
|
|
|
|
class CdpConnection {
|
|
ws;
|
|
nextId = 0;
|
|
pending = new Map;
|
|
eventHandlers = new Map;
|
|
defaultTimeoutMs;
|
|
constructor(ws, defaultTimeoutMs = 15000) {
|
|
this.ws = ws;
|
|
this.defaultTimeoutMs = defaultTimeoutMs;
|
|
this.ws.addEventListener("message", (event) => {
|
|
try {
|
|
const data = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
|
|
const msg = JSON.parse(data);
|
|
if (msg.method) {
|
|
const handlers = this.eventHandlers.get(msg.method);
|
|
if (handlers) {
|
|
handlers.forEach((handler) => handler(msg.params));
|
|
}
|
|
}
|
|
if (msg.id) {
|
|
const pending = this.pending.get(msg.id);
|
|
if (pending) {
|
|
this.pending.delete(msg.id);
|
|
if (pending.timer)
|
|
clearTimeout(pending.timer);
|
|
if (msg.error?.message)
|
|
pending.reject(new Error(msg.error.message));
|
|
else
|
|
pending.resolve(msg.result);
|
|
}
|
|
}
|
|
} catch {}
|
|
});
|
|
this.ws.addEventListener("close", () => {
|
|
for (const [id, pending] of this.pending.entries()) {
|
|
this.pending.delete(id);
|
|
if (pending.timer)
|
|
clearTimeout(pending.timer);
|
|
pending.reject(new Error("CDP connection closed."));
|
|
}
|
|
});
|
|
}
|
|
static async connect(url, timeoutMs, options) {
|
|
const ws = new WebSocket(url);
|
|
await new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => reject(new Error("CDP connection timeout.")), timeoutMs);
|
|
ws.addEventListener("open", () => {
|
|
clearTimeout(timer);
|
|
resolve();
|
|
});
|
|
ws.addEventListener("error", () => {
|
|
clearTimeout(timer);
|
|
reject(new Error("CDP connection failed."));
|
|
});
|
|
});
|
|
return new CdpConnection(ws, options?.defaultTimeoutMs ?? 15000);
|
|
}
|
|
on(method, handler) {
|
|
if (!this.eventHandlers.has(method)) {
|
|
this.eventHandlers.set(method, new Set);
|
|
}
|
|
this.eventHandlers.get(method)?.add(handler);
|
|
}
|
|
off(method, handler) {
|
|
this.eventHandlers.get(method)?.delete(handler);
|
|
}
|
|
async send(method, params, options) {
|
|
const id = ++this.nextId;
|
|
const message = { id, method };
|
|
if (params)
|
|
message.params = params;
|
|
if (options?.sessionId)
|
|
message.sessionId = options.sessionId;
|
|
const timeoutMs = options?.timeoutMs ?? this.defaultTimeoutMs;
|
|
const result = await new Promise((resolve, reject) => {
|
|
const timer = timeoutMs > 0 ? setTimeout(() => {
|
|
this.pending.delete(id);
|
|
reject(new Error(`CDP timeout: ${method}`));
|
|
}, timeoutMs) : null;
|
|
this.pending.set(id, { resolve, reject, timer });
|
|
this.ws.send(JSON.stringify(message));
|
|
});
|
|
return result;
|
|
}
|
|
close() {
|
|
try {
|
|
this.ws.close();
|
|
} catch {}
|
|
}
|
|
}
|
|
async function launchChrome(options) {
|
|
await import_node_fs.default.promises.mkdir(options.profileDir, { recursive: true });
|
|
const args = [
|
|
`--remote-debugging-port=${options.port}`,
|
|
`--user-data-dir=${options.profileDir}`,
|
|
"--no-first-run",
|
|
"--no-default-browser-check",
|
|
...options.extraArgs ?? []
|
|
];
|
|
if (options.headless)
|
|
args.push("--headless=new");
|
|
if (options.url)
|
|
args.push(options.url);
|
|
return import_node_child_process.spawn(options.chromePath, args, { stdio: "ignore" });
|
|
}
|
|
async function openPageSession(options) {
|
|
let targetId;
|
|
let createdTarget = false;
|
|
if (options.reusing) {
|
|
const created = await options.cdp.send("Target.createTarget", { url: options.url });
|
|
targetId = created.targetId;
|
|
createdTarget = true;
|
|
} else {
|
|
const targets = await options.cdp.send("Target.getTargets");
|
|
const existing = targets.targetInfos.find(options.matchTarget);
|
|
if (existing) {
|
|
targetId = existing.targetId;
|
|
} else {
|
|
const created = await options.cdp.send("Target.createTarget", { url: options.url });
|
|
targetId = created.targetId;
|
|
createdTarget = true;
|
|
}
|
|
}
|
|
const { sessionId } = await options.cdp.send("Target.attachToTarget", { targetId, flatten: true });
|
|
if (options.activateTarget ?? true) {
|
|
await options.cdp.send("Target.activateTarget", { targetId });
|
|
}
|
|
if (options.enablePage)
|
|
await options.cdp.send("Page.enable", {}, { sessionId });
|
|
if (options.enableRuntime)
|
|
await options.cdp.send("Runtime.enable", {}, { sessionId });
|
|
if (options.enableDom)
|
|
await options.cdp.send("DOM.enable", {}, { sessionId });
|
|
if (options.enableNetwork)
|
|
await options.cdp.send("Network.enable", {}, { sessionId });
|
|
return { sessionId, targetId, createdTarget };
|
|
}
|
|
|
|
// src/mermaid.ts
|
|
class MermaidRenderError extends Error {
|
|
constructor(message, options) {
|
|
super(message);
|
|
this.name = "MermaidRenderError";
|
|
if (options?.cause !== undefined) {
|
|
this.cause = options.cause;
|
|
}
|
|
}
|
|
}
|
|
function resolveRenderScale(scale) {
|
|
const resolved = scale ?? 2;
|
|
if (!Number.isFinite(resolved) || resolved <= 0) {
|
|
throw new MermaidRenderError(`Invalid Mermaid render scale: ${scale}`);
|
|
}
|
|
return resolved;
|
|
}
|
|
function resolveMinWidth(minWidth) {
|
|
if (minWidth === undefined)
|
|
return;
|
|
if (!Number.isFinite(minWidth) || minWidth <= 0) {
|
|
throw new MermaidRenderError(`Invalid Mermaid render minWidth: ${minWidth}`);
|
|
}
|
|
return minWidth;
|
|
}
|
|
var CHROME_CANDIDATES = {
|
|
darwin: [
|
|
"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
|
|
"/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
|
|
"/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
|
|
"/Applications/Chromium.app/Contents/MacOS/Chromium",
|
|
"/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
|
|
],
|
|
win32: [
|
|
"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
|
|
"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
|
|
"C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
|
|
"C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
|
|
],
|
|
default: [
|
|
"/usr/bin/google-chrome",
|
|
"/usr/bin/google-chrome-stable",
|
|
"/usr/bin/chromium",
|
|
"/usr/bin/chromium-browser",
|
|
"/snap/bin/chromium",
|
|
"/usr/bin/microsoft-edge"
|
|
]
|
|
};
|
|
var wslHome;
|
|
function getWslWindowsHome() {
|
|
if (wslHome !== undefined)
|
|
return wslHome;
|
|
if (!import_node_process2.default.env.WSL_DISTRO_NAME) {
|
|
wslHome = null;
|
|
return null;
|
|
}
|
|
try {
|
|
const raw = import_node_child_process2.execSync('cmd.exe /C "echo %USERPROFILE%"', {
|
|
encoding: "utf-8",
|
|
timeout: 5000
|
|
}).trim().replace(/\r/g, "");
|
|
wslHome = import_node_child_process2.execSync(`wslpath -u "${raw}"`, {
|
|
encoding: "utf-8",
|
|
timeout: 5000
|
|
}).trim() || null;
|
|
} catch {
|
|
wslHome = null;
|
|
}
|
|
return wslHome;
|
|
}
|
|
function getProfileDir() {
|
|
return resolveSharedChromeProfileDir({
|
|
envNames: ["BAOYU_CHROME_PROFILE_DIR", "MERMAID_RENDER_PROFILE_DIR"],
|
|
wslWindowsHome: getWslWindowsHome()
|
|
});
|
|
}
|
|
function resolveAssetsDir() {
|
|
const here = import_node_url.fileURLToPath(undefined);
|
|
const dir = import_node_path2.default.dirname(here);
|
|
const candidates = [
|
|
import_node_path2.default.resolve(dir, "..", "assets"),
|
|
import_node_path2.default.resolve(dir, "assets")
|
|
];
|
|
for (const candidate of candidates) {
|
|
if (import_node_fs2.default.existsSync(import_node_path2.default.join(candidate, "mermaid.min.js")))
|
|
return candidate;
|
|
}
|
|
throw new MermaidRenderError(`Cannot locate mermaid.min.js. Looked in: ${candidates.join(", ")}`);
|
|
}
|
|
var cachedMermaidScript = null;
|
|
function loadMermaidScript() {
|
|
if (cachedMermaidScript)
|
|
return cachedMermaidScript;
|
|
const assetsDir = resolveAssetsDir();
|
|
cachedMermaidScript = import_node_fs2.default.readFileSync(import_node_path2.default.join(assetsDir, "mermaid.min.js"), "utf-8");
|
|
return cachedMermaidScript;
|
|
}
|
|
var rendererState = null;
|
|
var connectingPromise = null;
|
|
var exitHookInstalled = false;
|
|
function installExitHook() {
|
|
if (exitHookInstalled)
|
|
return;
|
|
exitHookInstalled = true;
|
|
const cleanup = () => {
|
|
const state = rendererState;
|
|
rendererState = null;
|
|
if (!state)
|
|
return;
|
|
try {
|
|
state.cdp.close();
|
|
} catch {}
|
|
if (state.ownsChrome && state.chrome) {
|
|
try {
|
|
state.chrome.kill("SIGTERM");
|
|
} catch {}
|
|
}
|
|
};
|
|
import_node_process2.default.on("exit", cleanup);
|
|
import_node_process2.default.on("beforeExit", cleanup);
|
|
}
|
|
async function tryConnectExisting(port) {
|
|
try {
|
|
const wsUrl = await waitForChromeDebugPort(port, 5000, { includeLastError: true });
|
|
return await CdpConnection.connect(wsUrl, 5000);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
async function ensureRenderer() {
|
|
if (rendererState)
|
|
return rendererState;
|
|
if (connectingPromise)
|
|
return await connectingPromise;
|
|
connectingPromise = (async () => {
|
|
const profileDir = getProfileDir();
|
|
const existingPort = await findExistingChromeDebugPort({ profileDir });
|
|
if (existingPort) {
|
|
const cdp2 = await tryConnectExisting(existingPort);
|
|
if (cdp2) {
|
|
const state2 = {
|
|
cdp: cdp2,
|
|
chrome: null,
|
|
port: existingPort,
|
|
ownsChrome: false
|
|
};
|
|
rendererState = state2;
|
|
installExitHook();
|
|
return state2;
|
|
}
|
|
}
|
|
const chromePath = findChromeExecutable({
|
|
candidates: CHROME_CANDIDATES,
|
|
envNames: ["BAOYU_CHROME_PATH", "MERMAID_RENDER_CHROME_PATH"]
|
|
});
|
|
if (!chromePath) {
|
|
throw new MermaidRenderError("Chrome not found. Install Google Chrome / Chromium / Edge, or set BAOYU_CHROME_PATH.");
|
|
}
|
|
const port = await getFreePort("MERMAID_RENDER_DEBUG_PORT");
|
|
const chrome = await launchChrome({
|
|
chromePath,
|
|
profileDir,
|
|
port,
|
|
headless: true,
|
|
extraArgs: [
|
|
"--disable-blink-features=AutomationControlled",
|
|
"--disable-gpu",
|
|
"--hide-scrollbars"
|
|
]
|
|
});
|
|
const wsUrl = await waitForChromeDebugPort(port, 30000, { includeLastError: true });
|
|
const cdp = await CdpConnection.connect(wsUrl, 30000);
|
|
const state = { cdp, chrome, port, ownsChrome: true };
|
|
rendererState = state;
|
|
installExitHook();
|
|
return state;
|
|
})();
|
|
try {
|
|
return await connectingPromise;
|
|
} finally {
|
|
connectingPromise = null;
|
|
}
|
|
}
|
|
function buildHostHtml(code, theme, background) {
|
|
const script = loadMermaidScript();
|
|
const safeCode = code.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">");
|
|
const safeTheme = JSON.stringify(theme);
|
|
const cssBackground = background === "transparent" ? "transparent" : background;
|
|
return `<!doctype html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<style>
|
|
html, body {
|
|
margin: 0;
|
|
padding: 0;
|
|
background: ${cssBackground};
|
|
font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", "Hiragino Sans GB", "Noto Sans CJK SC", sans-serif;
|
|
}
|
|
#host {
|
|
display: inline-block;
|
|
padding: 16px;
|
|
}
|
|
#host svg {
|
|
max-width: none !important;
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div id="host"><div class="mermaid">${safeCode}</div></div>
|
|
<script>${script}</script>
|
|
<script>
|
|
window.__mermaidReady = false;
|
|
window.__mermaidError = null;
|
|
try {
|
|
mermaid.initialize({ startOnLoad: false, theme: ${safeTheme}, securityLevel: "loose" });
|
|
mermaid.run({ querySelector: ".mermaid" })
|
|
.then(function () { window.__mermaidReady = true; })
|
|
.catch(function (err) { window.__mermaidError = String(err && err.message || err); });
|
|
} catch (err) {
|
|
window.__mermaidError = String(err && err.message || err);
|
|
}
|
|
</script>
|
|
</body>
|
|
</html>`;
|
|
}
|
|
async function evaluate(cdp, sessionId, expression) {
|
|
const result = await cdp.send("Runtime.evaluate", {
|
|
expression,
|
|
returnByValue: true,
|
|
awaitPromise: false
|
|
}, { sessionId });
|
|
const exception = result.exceptionDetails;
|
|
if (exception) {
|
|
return {
|
|
value: undefined,
|
|
exceptionText: exception.exception?.description ?? exception.text ?? "evaluation failed"
|
|
};
|
|
}
|
|
return { value: result.result.value };
|
|
}
|
|
async function waitForMermaidSvg(cdp, sessionId, timeoutMs) {
|
|
const start = Date.now();
|
|
while (Date.now() - start < timeoutMs) {
|
|
const status = await evaluate(cdp, sessionId, `(function () {
|
|
if (window.__mermaidError) {
|
|
return { ready: false, error: window.__mermaidError, rect: null };
|
|
}
|
|
var svg = document.querySelector(".mermaid svg");
|
|
if (!svg) return { ready: false, error: null, rect: null };
|
|
var bbox = svg.getBoundingClientRect();
|
|
return {
|
|
ready: window.__mermaidReady === true,
|
|
error: null,
|
|
rect: {
|
|
x: bbox.x,
|
|
y: bbox.y,
|
|
width: bbox.width,
|
|
height: bbox.height,
|
|
},
|
|
};
|
|
})()`);
|
|
if (status.exceptionText) {
|
|
throw new MermaidRenderError(`Mermaid evaluation failed: ${status.exceptionText}`);
|
|
}
|
|
const value = status.value;
|
|
if (value?.error) {
|
|
throw new MermaidRenderError(`Mermaid render failed: ${value.error}`);
|
|
}
|
|
if (value?.ready && value.rect && value.rect.width > 0 && value.rect.height > 0) {
|
|
const host = await evaluate(cdp, sessionId, `(function () {
|
|
var host = document.getElementById("host");
|
|
if (!host) return null;
|
|
var rect = host.getBoundingClientRect();
|
|
return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
|
|
})()`);
|
|
if (host.value)
|
|
return host.value;
|
|
return value.rect;
|
|
}
|
|
await sleep(80);
|
|
}
|
|
throw new MermaidRenderError(`Mermaid render timed out after ${timeoutMs}ms`);
|
|
}
|
|
async function withPageSession(state, fn) {
|
|
let session = null;
|
|
try {
|
|
session = await openPageSession({
|
|
cdp: state.cdp,
|
|
reusing: !state.ownsChrome,
|
|
url: "about:blank",
|
|
matchTarget: () => false,
|
|
enablePage: true,
|
|
enableRuntime: true
|
|
});
|
|
return await fn(session.sessionId, session.targetId);
|
|
} finally {
|
|
if (session?.createdTarget) {
|
|
try {
|
|
await state.cdp.send("Target.closeTarget", { targetId: session.targetId });
|
|
} catch {}
|
|
}
|
|
}
|
|
}
|
|
async function renderMermaidToPng(code, outputPath, options = {}) {
|
|
const theme = options.theme ?? "default";
|
|
const scale = resolveRenderScale(options.scale);
|
|
const minWidth = resolveMinWidth(options.minWidth);
|
|
const background = options.background ?? "white";
|
|
const timeoutMs = options.timeoutMs ?? 15000;
|
|
if (!code.trim()) {
|
|
throw new MermaidRenderError("Mermaid code is empty");
|
|
}
|
|
await import_node_fs2.default.promises.mkdir(import_node_path2.default.dirname(outputPath), { recursive: true });
|
|
const state = await ensureRenderer();
|
|
const html = buildHostHtml(code, theme, background);
|
|
return await withPageSession(state, async (sessionId) => {
|
|
await state.cdp.send("Emulation.setDeviceMetricsOverride", {
|
|
width: 1280,
|
|
height: 800,
|
|
deviceScaleFactor: 1,
|
|
mobile: false
|
|
}, { sessionId });
|
|
await state.cdp.send("Page.setDocumentContent", { frameId: await getFrameId(state.cdp, sessionId), html }, { sessionId });
|
|
const rect = await waitForMermaidSvg(state.cdp, sessionId, timeoutMs);
|
|
const cssWidth = Math.max(1, Math.ceil(rect.width));
|
|
const cssHeight = Math.max(1, Math.ceil(rect.height));
|
|
const targetCssWidth = Math.max(cssWidth, Math.ceil(minWidth ?? cssWidth));
|
|
const captureScale = scale * (targetCssWidth / cssWidth);
|
|
const bitmapWidth = Math.max(1, Math.ceil(cssWidth * captureScale));
|
|
const bitmapHeight = Math.max(1, Math.ceil(cssHeight * captureScale));
|
|
await state.cdp.send("Emulation.setDeviceMetricsOverride", {
|
|
width: cssWidth,
|
|
height: cssHeight,
|
|
deviceScaleFactor: 1,
|
|
mobile: false
|
|
}, { sessionId });
|
|
const shot = await state.cdp.send("Page.captureScreenshot", {
|
|
format: "png",
|
|
clip: {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
width: cssWidth,
|
|
height: cssHeight,
|
|
scale: captureScale
|
|
},
|
|
captureBeyondViewport: true
|
|
}, { sessionId });
|
|
const buffer = Buffer.from(shot.data, "base64");
|
|
await import_node_fs2.default.promises.writeFile(outputPath, buffer);
|
|
return {
|
|
width: bitmapWidth,
|
|
height: bitmapHeight,
|
|
bytes: buffer.length
|
|
};
|
|
});
|
|
}
|
|
async function getFrameId(cdp, sessionId) {
|
|
const result = await cdp.send("Page.getFrameTree", {}, { sessionId });
|
|
return result.frameTree.frame.id;
|
|
}
|
|
async function closeRenderer() {
|
|
const state = rendererState;
|
|
rendererState = null;
|
|
if (!state)
|
|
return;
|
|
try {
|
|
state.cdp.close();
|
|
} catch {}
|
|
if (state.ownsChrome && state.chrome) {
|
|
try {
|
|
state.chrome.kill("SIGTERM");
|
|
} catch {}
|
|
}
|
|
}
|