@yorz/cli 0.1.0

package/dist/diagram-WEI45ONY-B3nx1cYt.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+import { p as populateCommonDb } from "./chunk-JWPE2WC7-XiIefccF.js";
+import { s as setAccDescription, g as getAccDescription, o as getDiagramTitle, n as setDiagramTitle, a as getAccTitle, b as setAccTitle, _ as __name, D as selectSvgElement, p as clear, A as cleanAndMerge, y as getConfig, B as defaultConfig_default, l as log, E as getThemeVariables3, e as configureSvgSize } from "./mermaid.core-Dy_tFRs7.js";
+import { p as parse } from "./cynefin-VYW2F7L2-BwTeE-TI.js";
+var defaultOptions = {
+  showLegend: true,
+  ticks: 5,
+  max: null,
+  min: 0,
+  graticule: "circle"
+};
+var defaultRadarData = {
+  axes: [],
+  curves: [],
+  options: defaultOptions
+};
+var data = structuredClone(defaultRadarData);
+var DEFAULT_RADAR_CONFIG = defaultConfig_default.radar;
+var getConfig2 = /* @__PURE__ */ __name(() => {
+  const config = cleanAndMerge({
+    ...DEFAULT_RADAR_CONFIG,
+    ...getConfig().radar
+  });
+  return config;
+}, "getConfig");
+var getAxes = /* @__PURE__ */ __name(() => data.axes, "getAxes");
+var getCurves = /* @__PURE__ */ __name(() => data.curves, "getCurves");
+var getOptions = /* @__PURE__ */ __name(() => data.options, "getOptions");
+var setAxes = /* @__PURE__ */ __name((axes) => {
+  data.axes = axes.map((axis) => {
+    return {
+      name: axis.name,
+      label: axis.label ?? axis.name
+    };
+  });
+}, "setAxes");
+var setCurves = /* @__PURE__ */ __name((curves) => {
+  data.curves = curves.map((curve) => {
+    return {
+      name: curve.name,
+      label: curve.label ?? curve.name,
+      entries: computeCurveEntries(curve.entries)
+    };
+  });
+}, "setCurves");
+var computeCurveEntries = /* @__PURE__ */ __name((entries) => {
+  if (entries[0].axis == void 0) {
+    return entries.map((entry) => entry.value);
+  }
+  const axes = getAxes();
+  if (axes.length === 0) {
+    throw new Error("Axes must be populated before curves for reference entries");
+  }
+  return axes.map((axis) => {
+    const entry = entries.find((entry2) => entry2.axis?.$refText === axis.name);
+    if (entry === void 0) {
+      throw new Error("Missing entry for axis " + axis.label);
+    }
+    return entry.value;
+  });
+}, "computeCurveEntries");
+var setOptions = /* @__PURE__ */ __name((options) => {
+  const optionMap = options.reduce(
+    (acc, option) => {
+      acc[option.name] = option;
+      return acc;
+    },
+    {}
+  );
+  data.options = {
+    showLegend: optionMap.showLegend?.value ?? defaultOptions.showLegend,
+    ticks: optionMap.ticks?.value ?? defaultOptions.ticks,
+    max: optionMap.max?.value ?? defaultOptions.max,
+    min: optionMap.min?.value ?? defaultOptions.min,
+    graticule: optionMap.graticule?.value ?? defaultOptions.graticule
+  };
+}, "setOptions");
+var clear2 = /* @__PURE__ */ __name(() => {
+  clear();
+  data = structuredClone(defaultRadarData);
+}, "clear");
+var db = {
+  getAxes,
+  getCurves,
+  getOptions,
+  setAxes,
+  setCurves,
+  setOptions,
+  getConfig: getConfig2,
+  clear: clear2,
+  setAccTitle,
+  getAccTitle,
+  setDiagramTitle,
+  getDiagramTitle,
+  getAccDescription,
+  setAccDescription
+};
+var populate = /* @__PURE__ */ __name((ast) => {
+  populateCommonDb(ast, db);
+  const { axes, curves, options } = ast;
+  db.setAxes(axes);
+  db.setCurves(curves);
+  db.setOptions(options);
+}, "populate");
+var parser = {
+  parse: /* @__PURE__ */ __name(async (input) => {
+    const ast = await parse("radar", input);
+    log.debug(ast);
+    populate(ast);
+  }, "parse")
+};
+var draw = /* @__PURE__ */ __name((_text, id, _version, diagram2) => {
+  const db2 = diagram2.db;
+  const axes = db2.getAxes();
+  const curves = db2.getCurves();
+  const options = db2.getOptions();
+  const config = db2.getConfig();
+  const title = db2.getDiagramTitle();
+  const svg = selectSvgElement(id);
+  const g = drawFrame(svg, config);
+  const maxValue = options.max ?? Math.max(...curves.map((curve) => Math.max(...curve.entries)));
+  const minValue = options.min;
+  const radius = Math.min(config.width, config.height) / 2;
+  drawGraticule(g, axes, radius, options.ticks, options.graticule);
+  drawAxes(g, axes, radius, config);
+  drawCurves(g, axes, curves, minValue, maxValue, options.graticule, config);
+  drawLegend(g, curves, options.showLegend, config);
+  g.append("text").attr("class", "radarTitle").text(title).attr("x", 0).attr("y", -config.height / 2 - config.marginTop);
+}, "draw");
+var drawFrame = /* @__PURE__ */ __name((svg, config) => {
+  const totalWidth = config.width + config.marginLeft + config.marginRight;
+  const totalHeight = config.height + config.marginTop + config.marginBottom;
+  const center = {
+    x: config.marginLeft + config.width / 2,
+    y: config.marginTop + config.height / 2
+  };
+  configureSvgSize(svg, totalHeight, totalWidth, config.useMaxWidth ?? true);
+  svg.attr("viewBox", `0 0 ${totalWidth} ${totalHeight}`).attr("overflow", "visible");
+  return svg.append("g").attr("transform", `translate(${center.x}, ${center.y})`);
+}, "drawFrame");
+var drawGraticule = /* @__PURE__ */ __name((g, axes, radius, ticks, graticule) => {
+  if (graticule === "circle") {
+    for (let i = 0; i < ticks; i++) {
+      const r = radius * (i + 1) / ticks;
+      g.append("circle").attr("r", r).attr("class", "radarGraticule");
+    }
+  } else if (graticule === "polygon") {
+    const numAxes = axes.length;
+    for (let i = 0; i < ticks; i++) {
+      const r = radius * (i + 1) / ticks;
+      const points = axes.map((_, j) => {
+        const angle = 2 * j * Math.PI / numAxes - Math.PI / 2;
+        const x = r * Math.cos(angle);
+        const y = r * Math.sin(angle);
+        return `${x},${y}`;
+      }).join(" ");
+      g.append("polygon").attr("points", points).attr("class", "radarGraticule");
+    }
+  }
+}, "drawGraticule");
+var drawAxes = /* @__PURE__ */ __name((g, axes, radius, config) => {
+  const numAxes = axes.length;
+  for (let i = 0; i < numAxes; i++) {
+    const label = axes[i].label;
+    const angle = 2 * i * Math.PI / numAxes - Math.PI / 2;
+    const cosA = Math.cos(angle);
+    const sinA = Math.sin(angle);
+    g.append("line").attr("x1", 0).attr("y1", 0).attr("x2", radius * config.axisScaleFactor * cosA).attr("y2", radius * config.axisScaleFactor * sinA).attr("class", "radarAxisLine");
+    const textAnchor = cosA > 0.01 ? "start" : cosA < -0.01 ? "end" : "middle";
+    const dominantBaseline = sinA > 0.01 ? "hanging" : sinA < -0.01 ? "auto" : "central";
+    const labelPad = 4;
+    g.append("text").text(label).attr("x", radius * config.axisLabelFactor * cosA + labelPad * cosA).attr("y", radius * config.axisLabelFactor * sinA + labelPad * sinA).attr("text-anchor", textAnchor).attr("dominant-baseline", dominantBaseline).attr("class", "radarAxisLabel");
+  }
+}, "drawAxes");
+function drawCurves(g, axes, curves, minValue, maxValue, graticule, config) {
+  const numAxes = axes.length;
+  const radius = Math.min(config.width, config.height) / 2;
+  curves.forEach((curve, index) => {
+    if (curve.entries.length !== numAxes) {
+      return;
+    }
+    const points = curve.entries.map((entry, i) => {
+      const angle = 2 * Math.PI * i / numAxes - Math.PI / 2;
+      const r = relativeRadius(entry, minValue, maxValue, radius);
+      const x = r * Math.cos(angle);
+      const y = r * Math.sin(angle);
+      return { x, y };
+    });
+    if (graticule === "circle") {
+      g.append("path").attr("d", closedRoundCurve(points, config.curveTension)).attr("class", `radarCurve-${index}`);
+    } else if (graticule === "polygon") {
+      g.append("polygon").attr("points", points.map((p) => `${p.x},${p.y}`).join(" ")).attr("class", `radarCurve-${index}`);
+    }
+  });
+}
+__name(drawCurves, "drawCurves");
+function relativeRadius(value, minValue, maxValue, radius) {
+  const clippedValue = Math.min(Math.max(value, minValue), maxValue);
+  return radius * (clippedValue - minValue) / (maxValue - minValue);
+}
+__name(relativeRadius, "relativeRadius");
+function closedRoundCurve(points, tension) {
+  const numPoints = points.length;
+  let d = `M${points[0].x},${points[0].y}`;
+  for (let i = 0; i < numPoints; i++) {
+    const p0 = points[(i - 1 + numPoints) % numPoints];
+    const p1 = points[i];
+    const p2 = points[(i + 1) % numPoints];
+    const p3 = points[(i + 2) % numPoints];
+    const cp1 = {
+      x: p1.x + (p2.x - p0.x) * tension,
+      y: p1.y + (p2.y - p0.y) * tension
+    };
+    const cp2 = {
+      x: p2.x - (p3.x - p1.x) * tension,
+      y: p2.y - (p3.y - p1.y) * tension
+    };
+    d += ` C${cp1.x},${cp1.y} ${cp2.x},${cp2.y} ${p2.x},${p2.y}`;
+  }
+  return `${d} Z`;
+}
+__name(closedRoundCurve, "closedRoundCurve");
+function drawLegend(g, curves, showLegend, config) {
+  if (!showLegend) {
+    return;
+  }
+  const legendX = (config.width / 2 + config.marginRight) * 3 / 4;
+  const legendY = -(config.height / 2 + config.marginTop) * 3 / 4;
+  const lineHeight = 20;
+  curves.forEach((curve, index) => {
+    const itemGroup = g.append("g").attr("transform", `translate(${legendX}, ${legendY + index * lineHeight})`);
+    itemGroup.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${index}`);
+    itemGroup.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(curve.label);
+  });
+}
+__name(drawLegend, "drawLegend");
+var renderer = { draw };
+var genIndexStyles = /* @__PURE__ */ __name((themeVariables, radarOptions) => {
+  let sections = "";
+  for (let i = 0; i < themeVariables.THEME_COLOR_LIMIT; i++) {
+    const indexColor = themeVariables[`cScale${i}`];
+    sections += `
+		.radarCurve-${i} {
+			color: ${indexColor};
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+			stroke-width: ${radarOptions.curveStrokeWidth};
+		}
+		.radarLegendBox-${i} {
+			fill: ${indexColor};
+			fill-opacity: ${radarOptions.curveOpacity};
+			stroke: ${indexColor};
+		}
+		`;
+  }
+  return sections;
+}, "genIndexStyles");
+var buildRadarStyleOptions = /* @__PURE__ */ __name((radar) => {
+  const defaultThemeVariables = getThemeVariables3();
+  const currentConfig = getConfig();
+  const themeVariables = cleanAndMerge(defaultThemeVariables, currentConfig.themeVariables);
+  const radarOptions = cleanAndMerge(themeVariables.radar, radar);
+  return { themeVariables, radarOptions };
+}, "buildRadarStyleOptions");
+var styles = /* @__PURE__ */ __name(({ radar } = {}) => {
+  const { themeVariables, radarOptions } = buildRadarStyleOptions(radar);
+  return `
+	.radarTitle {
+		font-size: ${themeVariables.fontSize};
+		color: ${themeVariables.titleColor};
+		dominant-baseline: hanging;
+		text-anchor: middle;
+	}
+	.radarAxisLine {
+		stroke: ${radarOptions.axisColor};
+		stroke-width: ${radarOptions.axisStrokeWidth};
+	}
+	.radarAxisLabel {
+		font-size: ${radarOptions.axisLabelFontSize}px;
+		color: ${radarOptions.axisColor};
+	}
+	.radarGraticule {
+		fill: ${radarOptions.graticuleColor};
+		fill-opacity: ${radarOptions.graticuleOpacity};
+		stroke: ${radarOptions.graticuleColor};
+		stroke-width: ${radarOptions.graticuleStrokeWidth};
+	}
+	.radarLegendText {
+		text-anchor: start;
+		font-size: ${radarOptions.legendFontSize}px;
+		dominant-baseline: hanging;
+	}
+	${genIndexStyles(themeVariables, radarOptions)}
+	`;
+}, "styles");
+var diagram = {
+  parser,
+  db,
+  renderer,
+  styles
+};
+export {
+  diagram
+};

package/dist/ebnfDiagram-CCIWWBDH-BASj7BoO.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+import { g as getStyles, r as renderer, d as db } from "./chunk-MOJQB5TN-CC5OBDWw.js";
+import { p as populateCommonDb } from "./chunk-JWPE2WC7-XiIefccF.js";
+import { _ as __name, l as log } from "./mermaid.core-Dy_tFRs7.js";
+import { M as MermaidParseError, a as createRailroadEbnfServices } from "./cynefin-VYW2F7L2-BwTeE-TI.js";
+var langiumParser = createRailroadEbnfServices().RailroadEbnf.parser.LangiumParser;
+var transformChoice = /* @__PURE__ */ __name((choice) => {
+  const alternatives = choice.alternatives.map(transformSequence);
+  if (alternatives.length === 1) {
+    return alternatives[0];
+  }
+  return {
+    type: "choice",
+    alternatives
+  };
+}, "transformChoice");
+var transformSequence = /* @__PURE__ */ __name((sequence) => {
+  const elements = sequence.elements.map(transformTerm);
+  if (elements.length === 1) {
+    return elements[0];
+  }
+  return {
+    type: "sequence",
+    elements
+  };
+}, "transformSequence");
+var transformPrimary = /* @__PURE__ */ __name((primary) => {
+  switch (primary.$type) {
+    case "EbnfTerminal":
+      return {
+        type: "terminal",
+        value: primary.value
+      };
+    case "EbnfNonTerminal":
+      return {
+        type: "nonterminal",
+        name: primary.name
+      };
+    case "EbnfSpecial":
+      return {
+        type: "special",
+        text: primary.text
+      };
+    case "EbnfGroup":
+      return transformChoice(primary.element);
+    case "EbnfOptional":
+      return {
+        type: "optional",
+        element: transformChoice(primary.element)
+      };
+    case "EbnfRepetition":
+      return {
+        type: "repetition",
+        element: transformChoice(primary.element),
+        min: 0,
+        max: Infinity
+      };
+    default:
+      throw new Error(`Unsupported EBNF primary node: ${primary.$type}`);
+  }
+}, "transformPrimary");
+var transformPostfix = /* @__PURE__ */ __name((node, postfix) => {
+  switch (postfix.$type) {
+    case "EbnfOptionalPostfix":
+      return {
+        type: "optional",
+        element: node
+      };
+    case "EbnfZeroOrMorePostfix":
+      return {
+        type: "repetition",
+        element: node,
+        min: 0,
+        max: Infinity
+      };
+    case "EbnfOneOrMorePostfix":
+      return {
+        type: "repetition",
+        element: node,
+        min: 1,
+        max: Infinity
+      };
+    case "EbnfExceptionPostfix":
+      return {
+        type: "sequence",
+        elements: [
+          node,
+          { type: "terminal", value: "-" },
+          transformPrimary(postfix.except)
+        ]
+      };
+    default:
+      throw new Error(`Unsupported EBNF postfix node: ${postfix.$type}`);
+  }
+}, "transformPostfix");
+var transformTerm = /* @__PURE__ */ __name((term) => {
+  return term.postfixes.reduce((currentNode, postfix) => {
+    return transformPostfix(currentNode, postfix);
+  }, transformPrimary(term.base));
+}, "transformTerm");
+var transformRule = /* @__PURE__ */ __name((rule) => {
+  return {
+    name: rule.name,
+    definition: transformChoice(rule.definition)
+  };
+}, "transformRule");
+var populateDb = /* @__PURE__ */ __name((ast) => {
+  populateCommonDb(ast, db);
+  if (ast.title) {
+    db.setTitle(ast.title);
+  }
+  ast.rules.map((rule) => db.addRule(transformRule(rule)));
+}, "populateDb");
+var parser = {
+  parse: /* @__PURE__ */ __name((input) => {
+    db.clear();
+    log.debug("[EBNF Parser] Starting Langium parse");
+    const result = langiumParser.parse(input);
+    if (result.lexerErrors.length > 0 || result.parserErrors.length > 0) {
+      throw new MermaidParseError(result);
+    }
+    const ast = result.value;
+    log.debug("[EBNF Parser] Parsed rules:", ast.rules.length);
+    populateDb(ast);
+    log.debug("[EBNF Parser] Parse complete");
+  }, "parse"),
+  parser: {
+    yy: db
+  }
+};
+var diagram = {
+  parser,
+  db,
+  renderer,
+  styles: getStyles
+};
+export {
+  diagram
+};