hexagon-editor 0.1.0-alpha.0

package/dist/diagram-UB23O5K3-B7z2Lj3K.js

@@ -0,0 +1,219 @@
+import { p as I } from "./chunk-JWPE2WC7-DAjx3Kjr.js";
+import { s as _, g as E, o as D, n as F, a as P, b as z, _ as c, D as G, p as B, A as w, y as C, B as W, l as b, E as V, e as H } from "./mermaid.core-CR0bA2Wa.js";
+import { p as j } from "./cynefin-VYW2F7L2-Bkk-F_Js.js";
+var m = {
+  showLegend: !0,
+  ticks: 5,
+  max: null,
+  min: 0,
+  graticule: "circle"
+}, y = 32, A = {
+  axes: [],
+  curves: [],
+  options: m
+}, x = structuredClone(A), U = W.radar, X = /* @__PURE__ */ c(() => w({
+  ...U,
+  ...C().radar
+}), "getConfig"), M = /* @__PURE__ */ c(() => x.axes, "getAxes"), K = /* @__PURE__ */ c(() => x.curves, "getCurves"), N = /* @__PURE__ */ c(() => x.options, "getOptions"), Y = /* @__PURE__ */ c((a) => {
+  x.axes = a.map((t) => ({
+    name: t.name,
+    label: t.label ?? t.name
+  }));
+}, "setAxes"), Z = /* @__PURE__ */ c((a) => {
+  x.curves = a.map((t) => ({
+    name: t.name,
+    label: t.label ?? t.name,
+    entries: q(t.entries)
+  }));
+}, "setCurves"), q = /* @__PURE__ */ c((a) => {
+  if (a[0].axis == null)
+    return a.map((e) => e.value);
+  const t = M();
+  if (t.length === 0)
+    throw new Error("Axes must be populated before curves for reference entries");
+  return t.map((e) => {
+    const r = a.find((s) => s.axis?.$refText === e.name);
+    if (r === void 0)
+      throw new Error("Missing entry for axis " + e.label);
+    return r.value;
+  });
+}, "computeCurveEntries"), J = /* @__PURE__ */ c((a) => {
+  const t = a.reduce(
+    (e, r) => (e[r.name] = r, e),
+    {}
+  );
+  x.options = {
+    showLegend: t.showLegend?.value ?? m.showLegend,
+    ticks: t.ticks?.value ?? m.ticks,
+    max: t.max?.value ?? m.max,
+    min: t.min?.value ?? m.min,
+    graticule: t.graticule?.value ?? m.graticule
+  }, x.options.ticks > y && (b.warn(
+    `Radar diagram ticks (${x.options.ticks}) exceeds maximum allowed (${y}). Using ${y} instead.`
+  ), x.options.ticks = y);
+}, "setOptions"), Q = /* @__PURE__ */ c(() => {
+  B(), x = structuredClone(A);
+}, "clear"), $ = {
+  getAxes: M,
+  getCurves: K,
+  getOptions: N,
+  setAxes: Y,
+  setCurves: Z,
+  setOptions: J,
+  getConfig: X,
+  clear: Q,
+  setAccTitle: z,
+  getAccTitle: P,
+  setDiagramTitle: F,
+  getDiagramTitle: D,
+  getAccDescription: E,
+  setAccDescription: _
+}, tt = /* @__PURE__ */ c((a) => {
+  I(a, $);
+  const { axes: t, curves: e, options: r } = a;
+  $.setAxes(t), $.setCurves(e), $.setOptions(r);
+}, "populate"), et = {
+  parse: /* @__PURE__ */ c(async (a) => {
+    const t = await j("radar", a);
+    b.debug(t), tt(t);
+  }, "parse")
+}, at = /* @__PURE__ */ c((a, t, e, r) => {
+  const s = r.db, i = s.getAxes(), l = s.getCurves(), n = s.getOptions(), o = s.getConfig(), d = s.getDiagramTitle(), p = G(t), u = rt(p, o), g = n.max ?? Math.max(...l.map((f) => Math.max(...f.entries))), h = n.min, v = Math.min(o.width, o.height) / 2;
+  st(u, i, v, n.ticks, n.graticule), nt(u, i, v, o), L(u, i, l, h, g, n.graticule, o), k(u, l, n.showLegend, o), u.append("text").attr("class", "radarTitle").text(d).attr("x", 0).attr("y", -o.height / 2 - o.marginTop);
+}, "draw"), rt = /* @__PURE__ */ c((a, t) => {
+  const e = t.width + t.marginLeft + t.marginRight, r = t.height + t.marginTop + t.marginBottom, s = {
+    x: t.marginLeft + t.width / 2,
+    y: t.marginTop + t.height / 2
+  };
+  return H(a, r, e, t.useMaxWidth ?? !0), a.attr("viewBox", `0 0 ${e} ${r}`).attr("overflow", "visible"), a.append("g").attr("transform", `translate(${s.x}, ${s.y})`);
+}, "drawFrame"), st = /* @__PURE__ */ c((a, t, e, r, s) => {
+  if (s === "circle")
+    for (let i = 0; i < r; i++) {
+      const l = e * (i + 1) / r;
+      a.append("circle").attr("r", l).attr("class", "radarGraticule");
+    }
+  else if (s === "polygon") {
+    const i = t.length;
+    for (let l = 0; l < r; l++) {
+      const n = e * (l + 1) / r, o = t.map((d, p) => {
+        const u = 2 * p * Math.PI / i - Math.PI / 2, g = n * Math.cos(u), h = n * Math.sin(u);
+        return `${g},${h}`;
+      }).join(" ");
+      a.append("polygon").attr("points", o).attr("class", "radarGraticule");
+    }
+  }
+}, "drawGraticule"), nt = /* @__PURE__ */ c((a, t, e, r) => {
+  const s = t.length;
+  for (let i = 0; i < s; i++) {
+    const l = t[i].label, n = 2 * i * Math.PI / s - Math.PI / 2, o = Math.cos(n), d = Math.sin(n);
+    a.append("line").attr("x1", 0).attr("y1", 0).attr("x2", e * r.axisScaleFactor * o).attr("y2", e * r.axisScaleFactor * d).attr("class", "radarAxisLine");
+    const p = o > 0.01 ? "start" : o < -0.01 ? "end" : "middle", u = d > 0.01 ? "hanging" : d < -0.01 ? "auto" : "central", g = 4;
+    a.append("text").text(l).attr("x", e * r.axisLabelFactor * o + g * o).attr("y", e * r.axisLabelFactor * d + g * d).attr("text-anchor", p).attr("dominant-baseline", u).attr("class", "radarAxisLabel");
+  }
+}, "drawAxes");
+function L(a, t, e, r, s, i, l) {
+  const n = t.length, o = Math.min(l.width, l.height) / 2;
+  e.forEach((d, p) => {
+    if (d.entries.length !== n)
+      return;
+    const u = d.entries.map((g, h) => {
+      const v = 2 * Math.PI * h / n - Math.PI / 2, f = T(g, r, s, o), O = f * Math.cos(v), R = f * Math.sin(v);
+      return { x: O, y: R };
+    });
+    i === "circle" ? a.append("path").attr("d", S(u, l.curveTension)).attr("class", `radarCurve-${p}`) : i === "polygon" && a.append("polygon").attr("points", u.map((g) => `${g.x},${g.y}`).join(" ")).attr("class", `radarCurve-${p}`);
+  });
+}
+c(L, "drawCurves");
+function T(a, t, e, r) {
+  const s = Math.min(Math.max(a, t), e);
+  return r * (s - t) / (e - t);
+}
+c(T, "relativeRadius");
+function S(a, t) {
+  const e = a.length;
+  let r = `M${a[0].x},${a[0].y}`;
+  for (let s = 0; s < e; s++) {
+    const i = a[(s - 1 + e) % e], l = a[s], n = a[(s + 1) % e], o = a[(s + 2) % e], d = {
+      x: l.x + (n.x - i.x) * t,
+      y: l.y + (n.y - i.y) * t
+    }, p = {
+      x: n.x - (o.x - l.x) * t,
+      y: n.y - (o.y - l.y) * t
+    };
+    r += ` C${d.x},${d.y} ${p.x},${p.y} ${n.x},${n.y}`;
+  }
+  return `${r} Z`;
+}
+c(S, "closedRoundCurve");
+function k(a, t, e, r) {
+  if (!e)
+    return;
+  const s = (r.width / 2 + r.marginRight) * 3 / 4, i = -(r.height / 2 + r.marginTop) * 3 / 4, l = 20;
+  t.forEach((n, o) => {
+    const d = a.append("g").attr("transform", `translate(${s}, ${i + o * l})`);
+    d.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${o}`), d.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(n.label);
+  });
+}
+c(k, "drawLegend");
+var ot = { draw: at }, it = /* @__PURE__ */ c((a, t) => {
+  let e = "";
+  for (let r = 0; r < a.THEME_COLOR_LIMIT; r++) {
+    const s = a[`cScale${r}`];
+    e += `
+		.radarCurve-${r} {
+			color: ${s};
+			fill: ${s};
+			fill-opacity: ${t.curveOpacity};
+			stroke: ${s};
+			stroke-width: ${t.curveStrokeWidth};
+		}
+		.radarLegendBox-${r} {
+			fill: ${s};
+			fill-opacity: ${t.curveOpacity};
+			stroke: ${s};
+		}
+		`;
+  }
+  return e;
+}, "genIndexStyles"), lt = /* @__PURE__ */ c((a) => {
+  const t = V(), e = C(), r = w(t, e.themeVariables), s = w(r.radar, a);
+  return { themeVariables: r, radarOptions: s };
+}, "buildRadarStyleOptions"), ct = /* @__PURE__ */ c(({ radar: a } = {}) => {
+  const { themeVariables: t, radarOptions: e } = lt(a);
+  return `
+	.radarTitle {
+		font-size: ${t.fontSize};
+		color: ${t.titleColor};
+		dominant-baseline: hanging;
+		text-anchor: middle;
+	}
+	.radarAxisLine {
+		stroke: ${e.axisColor};
+		stroke-width: ${e.axisStrokeWidth};
+	}
+	.radarAxisLabel {
+		font-size: ${e.axisLabelFontSize}px;
+		color: ${e.axisColor};
+	}
+	.radarGraticule {
+		fill: ${e.graticuleColor};
+		fill-opacity: ${e.graticuleOpacity};
+		stroke: ${e.graticuleColor};
+		stroke-width: ${e.graticuleStrokeWidth};
+	}
+	.radarLegendText {
+		text-anchor: start;
+		font-size: ${e.legendFontSize}px;
+		dominant-baseline: hanging;
+	}
+	${it(t, e)}
+	`;
+}, "styles"), gt = {
+  parser: et,
+  db: $,
+  renderer: ot,
+  styles: ct
+};
+export {
+  gt as diagram
+};

package/dist/directives.d.ts

@@ -0,0 +1,10 @@
+import { Component } from 'vue';
+export interface MarkdownDirectiveComponentProps {
+    content: string;
+    name: string;
+    readonly: boolean;
+    updateContent(content: string): void;
+}
+/** Vue components keyed by the name in a `::: name` Markdown block. */
+export type MarkdownDirectiveComponents = Readonly<Record<string, Component>>;
+//# sourceMappingURL=directives.d.ts.map

package/dist/directives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directives.d.ts","sourceRoot":"","sources":["../src/directives.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,KAAK,CAAC;AAEnC,MAAM,WAAW,+BAA+B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,uEAAuE;AACvE,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC"}

package/dist/ebnfDiagram-BXEA7PRR-CYgE6z_2.js

@@ -0,0 +1,109 @@
+import { g as l, r as m, d as n } from "./chunk-6Q2QTUOP-DNiML-50.js";
+import { p } from "./chunk-JWPE2WC7-DAjx3Kjr.js";
+import { _ as t, l as o } from "./mermaid.core-CR0bA2Wa.js";
+import { M as u, a as f } from "./cynefin-VYW2F7L2-Bkk-F_Js.js";
+var c = f().RailroadEbnf.parser.LangiumParser, s = /* @__PURE__ */ t((e) => {
+  const r = e.alternatives.map(E);
+  return r.length === 1 ? r[0] : {
+    type: "choice",
+    alternatives: r
+  };
+}, "transformChoice"), E = /* @__PURE__ */ t((e) => {
+  const r = e.elements.map(d);
+  return r.length === 1 ? r[0] : {
+    type: "sequence",
+    elements: r
+  };
+}, "transformSequence"), i = /* @__PURE__ */ t((e) => {
+  switch (e.$type) {
+    case "EbnfTerminal":
+      return {
+        type: "terminal",
+        value: e.value
+      };
+    case "EbnfNonTerminal":
+      return {
+        type: "nonterminal",
+        name: e.name
+      };
+    case "EbnfSpecial":
+      return {
+        type: "special",
+        text: e.text
+      };
+    case "EbnfGroup":
+      return s(e.element);
+    case "EbnfOptional":
+      return {
+        type: "optional",
+        element: s(e.element)
+      };
+    case "EbnfRepetition":
+      return {
+        type: "repetition",
+        element: s(e.element),
+        min: 0,
+        max: 1 / 0
+      };
+    default:
+      throw new Error(`Unsupported EBNF primary node: ${e.$type}`);
+  }
+}, "transformPrimary"), b = /* @__PURE__ */ t((e, r) => {
+  switch (r.$type) {
+    case "EbnfOptionalPostfix":
+      return {
+        type: "optional",
+        element: e
+      };
+    case "EbnfZeroOrMorePostfix":
+      return {
+        type: "repetition",
+        element: e,
+        min: 0,
+        max: 1 / 0
+      };
+    case "EbnfOneOrMorePostfix":
+      return {
+        type: "repetition",
+        element: e,
+        min: 1,
+        max: 1 / 0
+      };
+    case "EbnfExceptionPostfix":
+      return {
+        type: "sequence",
+        elements: [
+          e,
+          { type: "terminal", value: "-" },
+          i(r.except)
+        ]
+      };
+    default:
+      throw new Error(`Unsupported EBNF postfix node: ${r.$type}`);
+  }
+}, "transformPostfix"), d = /* @__PURE__ */ t((e) => e.postfixes.reduce((r, a) => b(r, a), i(e.base)), "transformTerm"), y = /* @__PURE__ */ t((e) => ({
+  name: e.name,
+  definition: s(e.definition)
+}), "transformRule"), v = /* @__PURE__ */ t((e) => {
+  p(e, n), e.title && n.setTitle(e.title), e.rules.map((r) => n.addRule(y(r)));
+}, "populateDb"), g = {
+  parse: /* @__PURE__ */ t((e) => {
+    n.clear(), o.debug("[EBNF Parser] Starting Langium parse");
+    const r = c.parse(e);
+    if (r.lexerErrors.length > 0 || r.parserErrors.length > 0)
+      throw new u(r);
+    const a = r.value;
+    o.debug("[EBNF Parser] Parsed rules:", a.rules.length), v(a), o.debug("[EBNF Parser] Parse complete");
+  }, "parse"),
+  parser: {
+    yy: n
+  }
+}, N = {
+  parser: g,
+  db: n,
+  renderer: m,
+  styles: l
+};
+export {
+  N as diagram
+};