@zenuml/core 4.2.0 → 4.2.1

package/dist/cli/zenuml.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import antlr4 from 'antlr4';
 import { marked } from 'marked';
-import { mkdirSync, writeFileSync, readFileSync, statSync, watch } from 'node:fs';
-import { resolve, dirname, extname, basename, join } from 'node:path';
+import { readFileSync, statSync, mkdirSync, writeFileSync, watch } from 'node:fs';
+import { resolve, join, dirname, basename, extname } from 'node:path';
 
 // Generated from java-escape by ANTLR 4.11.1
 // jshint ignore: start
@@ -10877,10 +10877,22 @@ class FragmentAltVM extends FragmentVM {
   }
 }
 
+class FragmentRefVM extends FragmentVM {
+  kind = "ref";
+  measure(top) {
+    const context = this.context?.ref?.() || this.context;
+    const commentHeight = this.measureComment(context);
+    const headerHeight = this.metrics.fragmentHeaderHeight;
+    const height = commentHeight + headerHeight + this.metrics.fragmentPaddingBottom;
+    return { top, height, kind: this.kind };
+  }
+}
+
 class FragmentSingleBlockVM extends FragmentVM {
-  constructor(statement, fragment, runtime) {
+  constructor(statement, fragment, runtime, kind) {
     super(statement, runtime);
     this.fragment = fragment;
+    this.kind = kind;
   }
   measure(top, origin) {
     const commentHeight = this.measureComment(this.fragment);
@@ -10901,37 +10913,6 @@ class FragmentSingleBlockVM extends FragmentVM {
   }
 }
 
-class FragmentCriticalVM extends FragmentSingleBlockVM {
-  kind = "critical";
-}
-
-class FragmentLoopVM extends FragmentSingleBlockVM {
-  kind = "loop";
-}
-
-class FragmentOptVM extends FragmentSingleBlockVM {
-  kind = "opt";
-}
-
-class FragmentParVM extends FragmentSingleBlockVM {
-  kind = "par";
-}
-
-class FragmentRefVM extends FragmentVM {
-  kind = "ref";
-  measure(top) {
-    const context = this.context?.ref?.() || this.context;
-    const commentHeight = this.measureComment(context);
-    const headerHeight = this.metrics.fragmentHeaderHeight;
-    const height = commentHeight + headerHeight + this.metrics.fragmentPaddingBottom;
-    return { top, height, kind: this.kind };
-  }
-}
-
-class FragmentSectionVM extends FragmentSingleBlockVM {
-  kind = "section";
-}
-
 class FragmentTryCatchVM extends FragmentVM {
   constructor(statement, tcf, runtime) {
     super(statement, runtime);
@@ -11061,25 +11042,11 @@ const createStatementVM = (statement, runtime) => {
   if (statement.divider?.()) {
     return new DividerStatementVM(statement, runtime);
   }
-  const loop = statement.loop?.();
-  if (loop) {
-    return new FragmentLoopVM(statement, loop, runtime);
-  }
-  const opt = statement.opt?.();
-  if (opt) {
-    return new FragmentOptVM(statement, opt, runtime);
-  }
-  const par = statement.par?.();
-  if (par) {
-    return new FragmentParVM(statement, par, runtime);
-  }
-  const section = statement.section?.();
-  if (section) {
-    return new FragmentSectionVM(statement, section, runtime);
-  }
-  const critical = statement.critical?.();
-  if (critical) {
-    return new FragmentCriticalVM(statement, critical, runtime);
+  for (const kind of ["loop", "opt", "par", "section", "critical"]) {
+    const fragment = statement[kind]?.();
+    if (fragment) {
+      return new FragmentSingleBlockVM(statement, fragment, runtime, kind);
+    }
   }
   const tcf = statement.tcf?.();
   if (tcf) {
@@ -13657,6 +13624,69 @@ async function checkOne(input) {
     errors
   };
 }
+async function renderMarkdownFile(inputArg, args, config) {
+  const mdContent = await readCode(inputArg);
+  const effectiveFormat = args.outputFormat ?? config.configOutputFormat ?? "svg";
+  if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
+    throw new Error(
+      `Unsupported output format: "${effectiveFormat}". Use "svg" or "png".`
+    );
+  }
+  const inputPath = inputArg === "-" ? void 0 : resolve(inputArg);
+  const outputPath = args.output === "-" ? "-" : args.output ? resolve(args.output) : inputPath ? join(
+    dirname(inputPath),
+    `${basename(inputArg, extname(inputArg))}-rendered.md`
+  ) : "-";
+  const imageDir = outputPath !== "-" ? dirname(outputPath) : inputPath ? dirname(inputPath) : process.cwd();
+  const imageStem = inputPath ? basename(inputArg, extname(inputArg)) : outputPath !== "-" ? basename(outputPath, extname(outputPath)) : "diagram";
+  const renderOptions = {};
+  const effectiveTheme = args.theme ?? config.configTheme;
+  if (effectiveTheme) {
+    renderOptions.theme = effectiveTheme;
+  }
+  const blocks = extractZenumlBlocks(mdContent);
+  const imageFiles = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    if (block.empty) continue;
+    const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
+    const imageFilePath = join(imageDir, imageFilename);
+    let result;
+    try {
+      result = renderToSvg(block.code, renderOptions);
+    } catch (err) {
+      throw new Error(
+        `Failed to render zenuml block ${block.index}: ${err.message}`
+      );
+    }
+    mkdirSync(imageDir, { recursive: true });
+    const image = effectiveFormat === "png" ? await rasterizeToPng(
+      result.svg,
+      result.width,
+      result.height,
+      args.scale ?? config.configScale ?? 2
+    ) : result.svg;
+    writeFileSync(imageFilePath, image);
+    imageFiles.set(block.index, imageFilename);
+    if (!args.quiet && !args.watch) {
+      process.stderr.write(`Wrote ${imageFilePath}
+`);
+    }
+  }
+  const outputMd = [...blocks].reverse().reduce((markdown, block) => {
+    const replacement = block.empty ? "" : `![${block.title || `diagram ${block.index + 1}`}](${imageFiles.get(block.index)})`;
+    return markdown.replace(block.raw, replacement);
+  }, mdContent);
+  if (outputPath === "-") {
+    process.stdout.write(outputMd);
+    return;
+  }
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, outputMd, "utf-8");
+  if (!args.quiet && !args.watch) {
+    process.stderr.write(`Wrote ${outputPath}
+`);
+  }
+}
 async function main() {
   if (!globalThis.OffscreenCanvas && typeof document === "undefined") {
     try {
@@ -13760,146 +13790,6 @@ async function main() {
     process.stdout.write(JSON.stringify(ast, null, 2) + "\n");
     process.exit(0);
   }
-  const isMdMode = args.md || expandedInputs.some((f) => f !== "-" && /\.(?:md|markdown)$/i.test(f));
-  if (isMdMode) {
-    if (expandedInputs.length > 1) {
-      process.stderr.write(
-        "Error: --md mode supports only a single input file.\n"
-      );
-      process.exit(1);
-    }
-    const inputArg = expandedInputs[0];
-    if (args.md && inputArg !== "-") {
-      const ext = extname(inputArg).toLowerCase();
-      if (ext !== ".md" && ext !== ".markdown") {
-        process.stderr.write(
-          `Error: --md flag requires a .md or .markdown input file, got: ${inputArg}
-`
-        );
-        process.exit(1);
-      }
-    }
-    let mdContent;
-    try {
-      mdContent = await readCode(inputArg);
-    } catch (err) {
-      process.stderr.write(`Error: ${err.message}
-`);
-      process.exit(1);
-    }
-    const effectiveFormat = args.outputFormat ?? "svg";
-    if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
-      process.stderr.write(
-        `Error: Unsupported output format: "${effectiveFormat}". Use "svg" or "png".
-`
-      );
-      process.exit(1);
-    }
-    let imageDir;
-    let mdOutputPath;
-    if (args.output && args.output !== "-") {
-      const resolvedOutput = resolve(args.output);
-      imageDir = dirname(resolvedOutput);
-      mdOutputPath = resolvedOutput;
-    } else if (args.output === "-") {
-      if (inputArg !== "-") {
-        imageDir = dirname(resolve(inputArg));
-      } else {
-        imageDir = process.cwd();
-      }
-      mdOutputPath = "-";
-    } else {
-      if (inputArg !== "-") {
-        const resolvedInput = resolve(inputArg);
-        const inputDir = dirname(resolvedInput);
-        const ext = extname(inputArg);
-        const stem = basename(inputArg, ext);
-        imageDir = inputDir;
-        mdOutputPath = join(inputDir, `${stem}-rendered.md`);
-      } else {
-        imageDir = process.cwd();
-        mdOutputPath = "-";
-      }
-    }
-    let imageStem;
-    if (inputArg !== "-") {
-      const ext = extname(inputArg);
-      imageStem = basename(inputArg, ext);
-    } else if (mdOutputPath !== "-") {
-      const ext = extname(mdOutputPath);
-      imageStem = basename(mdOutputPath, ext);
-    } else {
-      imageStem = "diagram";
-    }
-    const blocks = extractZenumlBlocks(mdContent);
-    const effectiveScale = args.scale ?? 2;
-    const effectiveTheme = args.theme;
-    const renderOptions = {};
-    if (effectiveTheme) {
-      renderOptions.theme = effectiveTheme;
-    }
-    const imageFiles = /* @__PURE__ */ new Map();
-    for (const block of blocks) {
-      if (block.empty) continue;
-      const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
-      const imageFilePath = join(imageDir, imageFilename);
-      let svg;
-      let svgWidth;
-      let svgHeight;
-      try {
-        const result = renderToSvg(block.code, renderOptions);
-        svg = result.svg;
-        svgWidth = result.width;
-        svgHeight = result.height;
-      } catch (err) {
-        process.stderr.write(
-          `Error: Failed to render zenuml block ${block.index}: ${err.message}
-`
-        );
-        process.exit(1);
-      }
-      mkdirSync(imageDir, { recursive: true });
-      if (effectiveFormat === "png") {
-        const pngBuffer = await rasterizeToPng(
-          svg,
-          svgWidth,
-          svgHeight,
-          effectiveScale
-        );
-        writeFileSync(imageFilePath, pngBuffer);
-      } else {
-        writeFileSync(imageFilePath, svg, "utf-8");
-      }
-      if (!args.quiet) {
-        process.stderr.write(`Wrote ${imageFilePath}
-`);
-      }
-      imageFiles.set(block.index, imageFilename);
-    }
-    let outputMd = mdContent;
-    const sortedBlocks = [...blocks].reverse();
-    for (const block of sortedBlocks) {
-      const altText = block.title || `diagram ${block.index + 1}`;
-      if (block.empty) {
-        outputMd = outputMd.replace(block.raw, "");
-      } else {
-        const imageFilename = imageFiles.get(block.index);
-        const replacement = `![${altText}](${imageFilename})`;
-        outputMd = outputMd.replace(block.raw, replacement);
-      }
-    }
-    if (mdOutputPath === "-") {
-      process.stdout.write(outputMd);
-    } else {
-      mkdirSync(dirname(mdOutputPath), { recursive: true });
-      writeFileSync(mdOutputPath, outputMd, "utf-8");
-      if (!args.quiet) {
-        process.stderr.write(`Wrote ${mdOutputPath}
-`);
-      }
-    }
-    process.exit(0);
-  }
   let configScale;
   let configTheme;
   let configOutputFormat;
@@ -13917,99 +13807,30 @@ async function main() {
     );
     process.exit(1);
   }
-  if (args.watch) {
-    const renderForWatch = async (inputArg) => {
-      await renderOneFile(inputArg, args, {
-        configScale,
-        configTheme,
-        configOutputFormat});
-    };
-    const renderMdForWatch = async (inputArg) => {
-      let mdContent;
-      try {
-        mdContent = readFileSync(resolve(inputArg), "utf-8");
-      } catch {
-        throw new Error(`Cannot read input file: ${resolve(inputArg)}`);
-      }
-      const effectiveFormat = args.outputFormat ?? "svg";
-      if (effectiveFormat !== "svg" && effectiveFormat !== "png") {
-        throw new Error(
-          `Unsupported output format: "${effectiveFormat}". Use "svg" or "png".`
-        );
-      }
-      let mdOutputPath;
-      let imageDir;
-      if (args.output && args.output !== "-") {
-        const resolvedOutput = resolve(args.output);
-        imageDir = dirname(resolvedOutput);
-        mdOutputPath = resolvedOutput;
-      } else if (args.output === "-") {
-        imageDir = dirname(resolve(inputArg));
-        mdOutputPath = "-";
-      } else {
-        const resolvedInput = resolve(inputArg);
-        const inputDir = dirname(resolvedInput);
-        const ext2 = extname(inputArg);
-        const stem = basename(inputArg, ext2);
-        imageDir = inputDir;
-        mdOutputPath = join(inputDir, `${stem}-rendered.md`);
-      }
-      const ext = extname(inputArg);
-      const imageStem = basename(inputArg, ext);
-      const blocks = extractZenumlBlocks(mdContent);
-      const effectiveScale = args.scale ?? configScale ?? 2;
-      const imageFiles = /* @__PURE__ */ new Map();
-      for (const block of blocks) {
-        if (block.empty) continue;
-        const imageFilename = `${imageStem}-zenuml-${block.index}.${effectiveFormat}`;
-        const imageFilePath = join(imageDir, imageFilename);
-        const result = renderToSvg(block.code);
-        const { svg, width: svgWidth, height: svgHeight } = result;
-        mkdirSync(imageDir, { recursive: true });
-        if (effectiveFormat === "png") {
-          const pngBuffer = await rasterizeToPng(
-            svg,
-            svgWidth,
-            svgHeight,
-            effectiveScale
-          );
-          writeFileSync(imageFilePath, pngBuffer);
-        } else {
-          writeFileSync(imageFilePath, svg, "utf-8");
-        }
-        imageFiles.set(block.index, imageFilename);
-      }
-      let outputMd = mdContent;
-      const sortedBlocks = [...blocks].reverse();
-      for (const block of sortedBlocks) {
-        const altText = block.title || `diagram ${block.index + 1}`;
-        if (block.empty) {
-          outputMd = outputMd.replace(block.raw, "");
-        } else {
-          const imageFilename = imageFiles.get(block.index);
-          const replacement = `![${altText}](${imageFilename})`;
-          outputMd = outputMd.replace(block.raw, replacement);
-        }
-      }
-      if (mdOutputPath === "-") {
-        process.stdout.write(outputMd);
-      } else {
-        mkdirSync(dirname(mdOutputPath), { recursive: true });
-        writeFileSync(mdOutputPath, outputMd, "utf-8");
-      }
-    };
-    const hasMdInputs = expandedInputs.some(
-      (f) => /\.(?:md|markdown)$/i.test(f)
+  const config = {
+    configScale,
+    configTheme,
+    configOutputFormat,
+    multipleInputs
+  };
+  const isMdMode = args.md || expandedInputs.some((f) => f !== "-" && /\.(?:md|markdown)$/i.test(f));
+  if (isMdMode && multipleInputs) {
+    process.stderr.write(
+      "Error: --md mode supports only a single input file.\n"
     );
-    const renderMdFnForWatch = hasMdInputs ? renderMdForWatch : void 0;
-    const watchHandle = await startWatchMode(
-      expandedInputs,
-      renderForWatch,
-      void 0,
-      void 0,
-      void 0,
-      renderMdFnForWatch
+    process.exit(1);
+  }
+  const inputArg = expandedInputs[0];
+  if (args.md && inputArg !== "-" && !/\.(?:md|markdown)$/i.test(inputArg)) {
+    process.stderr.write(
+      `Error: --md flag requires a .md or .markdown input file, got: ${inputArg}
+`
     );
+    process.exit(1);
+  }
+  if (args.watch) {
+    const renderForWatch = (input) => isMdMode ? renderMarkdownFile(input, args, config) : renderOneFile(input, args, config);
+    const watchHandle = await startWatchMode(expandedInputs, renderForWatch);
     process.on("SIGINT", () => {
       watchHandle.shutdown();
       process.exit(0);
@@ -14018,16 +13839,26 @@ async function main() {
     });
     return;
   }
+  if (isMdMode) {
+    try {
+      await renderMarkdownFile(inputArg, args, config);
+      process.exit(0);
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  }
   let rendered = 0;
   let errors = 0;
-  for (const inputArg of expandedInputs) {
+  for (const inputArg2 of expandedInputs) {
     if (!args.quiet) {
-      const displayName = inputArg === "-" ? "<stdin>" : inputArg;
+      const displayName = inputArg2 === "-" ? "<stdin>" : inputArg2;
       process.stderr.write(`Rendering ${displayName}...
 `);
     }
     try {
-      await renderOneFile(inputArg, args, {
+      await renderOneFile(inputArg2, args, {
         configScale,
         configTheme,
         configOutputFormat,
@@ -14036,7 +13867,7 @@ async function main() {
       rendered++;
     } catch (err) {
       errors++;
-      process.stderr.write(`Error: ${inputArg}: ${err.message}
+      process.stderr.write(`Error: ${inputArg2}: ${err.message}
 `);
     }
   }