@draftably/editor 0.1.0 → 0.2.0

package/dist/chunks/mermaid-importer-Cgx1IhmR.js

@@ -1,478 +0,0 @@
-import { c as x } from "./mount-C1Xk_GQz.js";
-import { b as C, I as v, f as P, h as B, a as G } from "./import-core-C-I1wGfw.js";
-import { MERMAID_VERSION as N } from "./mermaid-facade-BoLWBerE.js";
-const j = {
-  SOLID: {},
-  DOTTED: { dashed: !0 },
-  SOLID_OPEN: { head: "none" },
-  DOTTED_OPEN: { head: "none", dashed: !0 },
-  SOLID_CROSS: { head: "cross" },
-  DOTTED_CROSS: { head: "cross", dashed: !0 },
-  SOLID_POINT: {},
-  DOTTED_POINT: { dashed: !0 },
-  BIDIRECTIONAL_SOLID: { tail: "arrow" },
-  BIDIRECTIONAL_DOTTED: { tail: "arrow", dashed: !0 }
-}, k = {
-  LOOP_START: "loop",
-  ALT_START: "alt",
-  OPT_START: "opt",
-  PAR_START: "par",
-  PAR_OVER_START: "par",
-  CRITICAL_START: "critical",
-  BREAK_START: "break"
-}, L = {
-  ALT_ELSE: "else",
-  PAR_AND: "and",
-  CRITICAL_OPTION: "option"
-}, V = ["LOOP_END", "ALT_END", "OPT_END", "PAR_END", "CRITICAL_END", "BREAK_END"];
-function K(m, f, D, p) {
-  const l = C(m.title ? f(m.title) : D), h = new v(), s = /* @__PURE__ */ new Set(), E = (r, t, a = "semantics") => {
-    s.has(r) || (s.add(r), p.push({ code: r, severity: "warning", impact: a, message: t }));
-  }, c = m.boxes.map((r, t) => {
-    const a = h.get("group", "box_" + (t + 1));
-    return l.objects.push({ id: a, kind: "group", label: f(r.name ?? "") }), r.fill && r.fill !== "transparent" && E("MERMAID_SEQUENCE_BOX_COLOR", "Box colors are omitted.", "appearance"), a;
-  }), M = /* @__PURE__ */ new Map();
-  for (const r of m.actors) {
-    const t = h.get("node", r.id);
-    M.set(r.id, t), l.objects.push({
-      id: t,
-      kind: "node",
-      // `participant p as "Name"` keeps its quotes in the DB.
-      label: f(r.name).replace(/^"(.*)"$/s, "$1"),
-      ...r.box != null && r.box >= 0 ? { parent: c[r.box] } : {}
-    }), r.type !== "participant" && E(
-      "MERMAID_SEQUENCE_ACTOR_TYPE",
-      "Participant symbols such as actor or database become ordinary boxes.",
-      "appearance"
-    ), r.links.length && E(
-      "MERMAID_LINK_OMITTED",
-      "Participant link menus are omitted; native participants have no menu.",
-      "security"
-    );
-  }
-  (m.created.length || m.destroyed.length) && E(
-    "MERMAID_SEQUENCE_LIFELINE",
-    "create and destroy are omitted: native participants span the whole diagram."
-  ), l.layouts.push({ scope: "root", kind: "sequence" });
-  const R = [], b = [];
-  let _ = 0, I, T;
-  const O = (r, t) => {
-    const a = f(t).trim();
-    I = {
-      id: h.get("phase", String(R.length + 1), "phase_" + (R.length + 1)),
-      label: a ? `${r}: ${a}` : r,
-      members: []
-    }, R.push(I);
-  }, n = (r) => {
-    const t = [r.from, r.to].filter((o) => o != null), a = T && t.every((o) => T.ends.includes(o)), d = r.placement === "left" ? "left" : r.placement === "right" ? "right" : void 0;
-    b.push({
-      text: f(r.text),
-      near: a ? T.id : M.get(t[0]),
-      side: d ?? (a ? "right" : "below")
-    });
-  };
-  for (const [r, t] of m.events.entries())
-    if (k[t.kind])
-      _++, _ === 1 ? O(k[t.kind], t.text) : E(
-        "MERMAID_SEQUENCE_NESTED_BLOCK",
-        "A nested block has no band of its own; its messages stay in the outer band."
-      ), E(
-        "MERMAID_SEQUENCE_BLOCK",
-        "Native sequences have no fragments. Each block branch becomes a phase band, so the branch logic is only in its label."
-      );
-    else if (L[t.kind])
-      _ === 1 && O(L[t.kind], t.text);
-    else if (V.includes(t.kind))
-      _--, _ || (I = void 0);
-    else if (t.kind === "NOTE") n(t);
-    else if (t.kind === "ACTIVE_START" || t.kind === "ACTIVE_END")
-      E("MERMAID_SEQUENCE_ACTIVATION", "Activation bars are omitted.", "appearance");
-    else if (t.kind === "AUTONUMBER")
-      E("MERMAID_SEQUENCE_AUTONUMBER", "Message numbers are omitted.", "appearance");
-    else if (t.kind === "RECT_START" || t.kind === "RECT_END")
-      E("MERMAID_SEQUENCE_RECT", "Background rectangles are omitted.", "appearance");
-    else {
-      const a = j[t.kind], d = M.get(t.from ?? ""), o = M.get(t.to ?? "");
-      if (!a || !d || !o || t.central) {
-        p.push({
-          code: "MERMAID_SEQUENCE_ARROW_UNSUPPORTED",
-          severity: "error",
-          impact: "semantics",
-          message: "Message line type is unsupported: " + (t.central ? "central connection" : t.kind) + ". The import is blocked rather than replacing it with an ordinary arrow."
-        });
-        continue;
-      }
-      t.kind === "SOLID_POINT" && E(
-        "MERMAID_SEQUENCE_ASYNC_ARROW",
-        "The open async arrow `-)` becomes an ordinary solid message, because native async draws dashed."
-      );
-      const g = h.get("edge-occurrence", String(r + 1), "m" + (l.edges.length + 1));
-      l.edges.push({ id: g, from: d, to: o, label: f(t.text), directed: !0, ...a }), I?.members.push(g), T = { id: g, ends: [t.from, t.to] };
-    }
-  return l.phases = R.filter((r) => r.members.length), l.notes = b, P("mermaid", "sequence", l, p, h);
-}
-const H = {
-  arrow_point: {},
-  arrow_open: {},
-  arrow_circle: { head: "circle" },
-  arrow_cross: { head: "cross" },
-  double_arrow_point: { tail: "arrow" },
-  double_arrow_circle: { head: "circle", tail: "circle" },
-  double_arrow_cross: { head: "cross", tail: "cross" }
-};
-function $(m, f, D = "Imported Mermaid") {
-  const p = C(D), l = new v(), h = m.diagnostics.map((n) => ({
-    code: n.code,
-    severity: n.severity,
-    impact: n.code.includes("LIMIT") || n.code.includes("TIMEOUT") ? "limit" : n.code.includes("CONFIGURATION") || n.code.includes("INTERACTION") ? "security" : "syntax",
-    message: n.message + (n.locationKind === "parser-relative" && n.line != null ? ` (Parser-relative line ${n.line}, column ${n.column ?? 1}; original-source mapping is unavailable.)` : ""),
-    ...n.locationKind === "source" && n.line != null ? { line: n.line, column: n.column } : {}
-  })), s = (n, r, t = "appearance", a = "warning", d) => h.push({ code: n, message: r, impact: t, severity: a, ...d ? { foreignIds: d } : {} }), E = () => P("mermaid", "flowchart", p, h, l);
-  if (!m.ok) return E();
-  const c = m.snapshot;
-  if (c.parserVersion !== N)
-    return s(
-      "MERMAID_VERSION_MISMATCH",
-      "This adapter is verified only against Mermaid " + N + ".",
-      "syntax",
-      "error"
-    ), E();
-  if (c.family === "sequence")
-    return K(c, f, D, h);
-  const M = (n, r, t) => (/<\/?[a-z][\s\S]*?>/i.test(n) && s(
-    "MERMAID_HTML_LABEL",
-    "HTML label formatting was reduced to plain text; line breaks are retained and no HTML is inserted into the diagram.",
-    "appearance",
-    "warning",
-    [t]
-  ), r === "markdown" && s(
-    "MERMAID_MARKDOWN_LABEL",
-    "Markdown label markers remain literal text in this profile.",
-    "appearance",
-    "warning",
-    [t]
-  ), f(n)), R = (n, r) => {
-    if (n) {
-      if (n === "LR") return "right";
-      if (n === "TB" || n === "TD") return "down";
-      if (n === "RL" || n === "BT")
-        return s(
-          "MERMAID_REVERSED_LAYOUT",
-          `${n} layout is normalized to ${n === "RL" ? "right" : "down"}; edge endpoints keep their semantic order.`,
-          "layout",
-          "warning",
-          [r]
-        ), n === "RL" ? "right" : "down";
-      s("MERMAID_DIRECTION", "Unsupported Mermaid layout direction: " + n, "layout", "error", [
-        r
-      ]);
-    }
-  }, b = new Map(c.classes.map((n) => [n.id, n])), _ = (n, r, t, a) => {
-    const d = [];
-    for (const o of [...t ? ["default", "node"] : [], ...n]) {
-      const g = b.get(o);
-      g ? d.push(g) : ["default", "node", "clickable"].includes(o) || s(
-        "MERMAID_CLASS_UNRESOLVED",
-        "CSS class has no in-diagram definition and was not imported: " + o,
-        "appearance",
-        "warning",
-        [a]
-      );
-    }
-    return [...d.flatMap((o) => [...o.styles, ...o.textStyles]), ...r];
-  }, I = (n, r, t) => {
-    const a = /* @__PURE__ */ new Map();
-    for (const d of r.flatMap((o) => o.split(";"))) {
-      if (!d.trim()) continue;
-      const o = /^\s*([a-z-]+)\s*:\s*(.*?)\s*$/i.exec(d), g = o?.[1]?.toLowerCase(), e = o?.[2];
-      if (!g || !["fill", "stroke", "color"].includes(g)) {
-        s(
-          "MERMAID_STYLE_PROPERTY",
-          "Unsupported style declaration was omitted: " + d,
-          /url\s*\(|javascript:|expression\s*\(/i.test(d) ? "security" : "appearance",
-          "warning",
-          [t]
-        );
-        continue;
-      }
-      const i = B(e);
-      if (!i) {
-        s(
-          "MERMAID_COLOR_VALUE",
-          "Only #RGB or #RRGGBB colors are imported: " + d,
-          "appearance",
-          "warning",
-          [t]
-        );
-        continue;
-      }
-      a.set(g, i);
-    }
-    G(p, n, a.get("fill"), a.get("stroke"), a.get("color"));
-  }, T = {
-    square: "box",
-    rect: "box",
-    rectangle: "box",
-    box: "box",
-    stadium: "pill",
-    circle: "circle",
-    diamond: "diamond",
-    text: "text"
-  }, O = (n, r) => {
-    if (!n) return "box";
-    if (Object.hasOwn(T, n)) return T[n];
-    const t = n === "doublecircle" || n === "ellipse" ? "circle" : n === "round" ? "pill" : "box";
-    return s(
-      "MERMAID_SHAPE_APPROXIMATION",
-      `Mermaid shape ${n} becomes native ${t}; the shape-specific visual meaning is not fully preserved.`,
-      "semantics",
-      "warning",
-      [r]
-    ), t;
-  };
-  try {
-    const n = new Map(c.groups.map((e) => [e.id, e])), r = new Map(c.vertices.map((e) => [e.id, e]));
-    if (n.size !== c.groups.length || r.size !== c.vertices.length)
-      return s(
-        "MERMAID_DUPLICATE_DB_ID",
-        "The parser snapshot contains duplicate group or node identities.",
-        "semantics",
-        "error"
-      ), E();
-    const t = /* @__PURE__ */ new Map();
-    for (const e of c.groups)
-      t.set(e.id, {
-        id: l.get("group", e.id),
-        kind: "group",
-        label: M(e.title, e.labelType, e.id)
-      });
-    for (const e of c.vertices)
-      n.has(e.id) || t.set(e.id, {
-        id: l.get("node", e.id),
-        kind: "node",
-        label: M(e.text, e.labelType, e.id),
-        shape: O(e.type, e.id)
-      });
-    const a = /* @__PURE__ */ new Map();
-    for (const e of c.groups)
-      for (const i of e.nodes) {
-        if (!t.has(i)) {
-          s(
-            "MERMAID_UNKNOWN_MEMBER",
-            "Subgraph references an absent member: " + i,
-            "semantics",
-            "error",
-            [e.id, i]
-          );
-          continue;
-        }
-        const u = a.get(i);
-        if (u && u !== e.id) {
-          s(
-            "MERMAID_MULTIPLE_PARENTS",
-            "A member belongs to multiple native parents; containment was not guessed.",
-            "semantics",
-            "error",
-            [i, u, e.id]
-          );
-          continue;
-        }
-        a.set(i, e.id), t.get(i).parent = t.get(e.id).id;
-      }
-    const d = R(c.direction, "root");
-    d && p.layouts.push({ scope: "root", kind: "flow", direction: d });
-    const o = /* @__PURE__ */ new Map();
-    for (const e of c.groups) {
-      const i = R(e.dir, e.id);
-      i && o.set(e.id, i);
-    }
-    const g = (e) => {
-      const i = /* @__PURE__ */ new Set();
-      let u = e;
-      for (; u && !i.has(u); ) {
-        i.add(u);
-        const S = o.get(u);
-        if (S) return S;
-        u = a.get(u);
-      }
-      return d ?? "down";
-    };
-    for (const e of c.groups) {
-      const i = t.get(e.id), u = r.get(e.id);
-      I(
-        i,
-        _([...e.classes, ...u?.classes ?? []], u?.styles ?? [], !1, e.id),
-        e.id
-      ), p.layouts.push({
-        scope: i.id,
-        kind: "flow",
-        direction: g(e.id)
-      }), e.dir ? s(
-        "MERMAID_SUBGRAPH_LAYOUT",
-        "The native group retains its declared direction. Mermaid can ignore a subgraph direction when its members connect outside, so the resulting layout may differ.",
-        "layout",
-        "warning",
-        [e.id]
-      ) : s(
-        "MERMAID_INHERITED_LAYOUT",
-        "This group has no declared direction. Native flow layout uses the nearest declared ancestor/root direction; Mermaid can use another direction depending on its layout engine and external connections.",
-        "layout",
-        "warning",
-        [e.id]
-      ), e.metadata && Object.keys(e.metadata).length && s(
-        "MERMAID_GROUP_METADATA",
-        "Group metadata (including collapsed view and engine hints) is omitted: " + Object.keys(e.metadata).join(", "),
-        "layout",
-        "warning",
-        [e.id]
-      );
-    }
-    for (const e of c.vertices) {
-      const i = t.get(e.id);
-      n.has(e.id) || I(i, _(e.classes, e.styles, !0, e.id), e.id), e.link && s(
-        "MERMAID_LINK_OMITTED",
-        "External link was omitted; the native object has no active link.",
-        "security",
-        "warning",
-        [e.id]
-      ), (e.img || e.icon) && s(
-        "MERMAID_ASSET_OMITTED",
-        "Image/icon references are not fetched or embedded; the object remains a labeled native shape.",
-        "security",
-        "warning",
-        [e.id]
-      ), e.props && Object.keys(e.props).length && s(
-        "MERMAID_NODE_METADATA",
-        "Node properties are omitted: " + Object.keys(e.props).join(", "),
-        "semantics",
-        "warning",
-        [e.id]
-      );
-    }
-    p.objects.push(...t.values());
-    for (const [e, i] of c.edges.entries()) {
-      const u = H[String(i.type)];
-      if (!u) {
-        s(
-          "MERMAID_ARROW_UNSUPPORTED",
-          "Edge terminal semantics are unsupported: " + String(i.type) + ". The import is blocked rather than replacing them with ordinary arrows.",
-          "semantics",
-          "error",
-          [i.id ?? String(e + 1)]
-        );
-        continue;
-      }
-      if (i.stroke === "invisible") {
-        s(
-          "MERMAID_INVISIBLE_EDGE",
-          "Invisible links express layout constraints, not visible relationships; this profile cannot preserve them.",
-          "layout",
-          "error",
-          [i.id ?? String(e + 1)]
-        );
-        continue;
-      }
-      if (!["normal", "thick", "dotted"].includes(i.stroke ?? "normal")) {
-        s(
-          "MERMAID_EDGE_STROKE",
-          "Unsupported edge stroke: " + String(i.stroke),
-          "appearance",
-          "error",
-          [i.id ?? String(e + 1)]
-        );
-        continue;
-      }
-      const S = t.get(i.start), y = t.get(i.end);
-      if (!S || !y) {
-        s("MERMAID_ENDPOINT", "A parsed edge has a missing endpoint.", "semantics", "error", [
-          i.start,
-          i.end
-        ]);
-        continue;
-      }
-      const U = i.isUserDefinedId && i.id ? l.get("edge-id", i.id, i.id) : l.get("edge-occurrence", String(e + 1), "edge_" + (e + 1)), A = i.id ?? String(e + 1);
-      p.edges.push({
-        id: U,
-        from: S.id,
-        to: y.id,
-        label: M(i.text, i.labelType, A),
-        directed: i.type !== "arrow_open",
-        ...u,
-        ...i.stroke === "dotted" ? { dashed: !0 } : {}
-      }), i.stroke === "dotted" && s(
-        "MERMAID_DASH_STYLE",
-        "Dotted Mermaid stroke uses native kind=async only for its dashed visual treatment; no asynchronous execution semantics are inferred.",
-        "appearance",
-        "info",
-        [A]
-      ), i.stroke === "thick" && s(
-        "MERMAID_THICK_EDGE",
-        "Thick edge emphasis is omitted by this native-source profile.",
-        "appearance",
-        "warning",
-        [A]
-      ), (i.length ?? 1) > 1 && s(
-        "MERMAID_MIN_RANK_LENGTH",
-        "Minimum rank-length hint is omitted; native layout chooses spacing.",
-        "layout",
-        "warning",
-        [A]
-      ), (i.animate || i.animation) && s("MERMAID_EDGE_ANIMATION", "Edge animation is omitted.", "appearance", "warning", [
-        A
-      ]), (i.interpolate || c.defaultEdgeInterpolate) && s(
-        "MERMAID_EDGE_CURVE",
-        "Mermaid curve hints are omitted; native routing is used.",
-        "layout",
-        "warning",
-        [A]
-      );
-      const w = _(
-        i.classes,
-        [...c.defaultEdgeStyle, ...i.style],
-        !1,
-        A
-      );
-      w.length && s(
-        "MERMAID_EDGE_STYLE",
-        "Per-edge CSS is omitted because native edge appearance is not a general CSS style map: " + w.join("; "),
-        "appearance",
-        "warning",
-        [A]
-      );
-    }
-    return E();
-  } catch (n) {
-    return s(
-      "MERMAID_MAPPING_ERROR",
-      "Could not map the parser snapshot: " + (n instanceof Error ? n.message : String(n)),
-      "semantics",
-      "error"
-    ), E();
-  }
-}
-function z(m, f, D) {
-  const p = $(m, f, D);
-  if (!p.nativeSource) return p;
-  try {
-    return x(p.nativeSource), p;
-  } catch (l) {
-    return {
-      ...p,
-      status: "failed",
-      nativeSource: void 0,
-      facts: void 0,
-      diagnostics: [
-        ...p.diagnostics,
-        {
-          code: "IMPORT_NATIVE_INVALID",
-          severity: "error",
-          impact: "semantics",
-          message: "The converted diagram cannot be represented in native source: " + (l instanceof Error ? l.message : String(l))
-        }
-      ]
-    };
-  }
-}
-export {
-  z as importMermaidFlow
-};