@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-ERLBPDGU.js

@@ -0,0 +1,510 @@
+import {
+  extractColor,
+  measureIndent,
+  parseFirstLine
+} from "./chunk-Y3J7VR52.js";
+import {
+  emit,
+  formatDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/version-control/diagnostics.ts
+var VERSION_CONTROL_DX = {
+  NO_COMMITS: {
+    code: "E_VERSION_CONTROL_NO_COMMITS",
+    severity: "error",
+    chartType: "version-control",
+    title: "No commits",
+    message: "version-control has no commits.",
+    hint: "Add at least one indented commit line under a branch.",
+    example: "version-control Empty"
+  },
+  UNKNOWN_BRANCH: {
+    code: "E_VERSION_CONTROL_UNKNOWN_BRANCH",
+    severity: "warning",
+    chartType: "version-control",
+    title: "Unknown branch reference",
+    message: (p) => {
+      const op = p.op ?? "merge";
+      const branch = p.branch ?? "ghostbranch";
+      const section = p.section ?? "\xA729.4";
+      return `${op} references unknown branch "${branch}". (${section})`;
+    },
+    hint: "Declare the branch (a bare top-level line) before referencing it in merge/rebase/reset.",
+    example: "version-control U\n\nmain\n  A\n  merge ghostbranch"
+  },
+  AMBIGUOUS_REF: {
+    code: "E_VERSION_CONTROL_AMBIGUOUS_REF",
+    severity: "warning",
+    chartType: "version-control",
+    title: "Ambiguous commit reference",
+    message: (p) => {
+      const ref = p.ref ?? "Fix";
+      const count = p.count ?? 2;
+      return `Commit reference "${ref}" matches ${count} commits \u2014 use an explicit id:. (\xA729.10)`;
+    },
+    hint: "Give the target commit an `id:` and reference that id, or make the message unique.",
+    example: "version-control A\n\nmain\n  Fix\n  Fix\n  cherry-pick Fix"
+  }
+};
+var VERSION_CONTROL_DIAGNOSTICS = Object.values(VERSION_CONTROL_DX);
+
+// src/version-control/parser.ts
+function parseVersionControl(content, palette) {
+  const options = {
+    direction: "LR",
+    noLabels: false,
+    noLanes: false,
+    noHead: false
+  };
+  const result = {
+    type: "version-control",
+    title: null,
+    titleLineNumber: null,
+    nodes: [],
+    branches: [],
+    refs: [],
+    notes: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  if (!content?.trim()) return fail(0, "No content provided");
+  const nodes = result.nodes;
+  const branches = /* @__PURE__ */ new Map();
+  const order = [];
+  const refs = result.refs;
+  const notes = result.notes;
+  let active = null;
+  let seq = 0;
+  let laneCounter = 0;
+  let headerParsed = false;
+  const makeBranch = (name, parentName, colorToken, ord) => {
+    const existing = branches.get(name);
+    if (existing) return existing;
+    const b = {
+      name,
+      creationLane: laneCounter++,
+      colorToken,
+      order: ord,
+      tip: null,
+      pendingParent: null,
+      ab: null
+    };
+    if (parentName != null) {
+      const par = branches.get(parentName);
+      b.pendingParent = par ? par.tip : null;
+    }
+    branches.set(name, b);
+    order.push(name);
+    return b;
+  };
+  const matchesRef = (ref) => nodes.filter((n) => n.message === ref || n.id === ref);
+  const findByRef = (ref, lineNumber) => {
+    const m = matchesRef(ref);
+    if (m.length === 0) return null;
+    if (m.length > 1 && !/^[0-9a-f]{4,}$/.test(ref)) {
+      result.diagnostics.push(
+        emit(VERSION_CONTROL_DX.AMBIGUOUS_REF, lineNumber, {
+          ref,
+          count: m.length
+        })
+      );
+    }
+    return m[m.length - 1];
+  };
+  const addNode = (fields) => {
+    const b = branches.get(active);
+    const id = fields.id ?? null;
+    const node = {
+      key: nodes.length,
+      branch: active,
+      lane: b.creationLane,
+      seq: seq++,
+      kind: fields.kind,
+      message: fields.message,
+      type: fields.type,
+      id,
+      tag: fields.tag,
+      lineNumber: fields.lineNumber,
+      prev: b.tip,
+      parent: null,
+      mergeFrom: null,
+      cherryFrom: null,
+      revertFrom: null,
+      squashFrom: null,
+      movedTo: null,
+      ghost: false
+    };
+    if (b.pendingParent != null && node.prev === null) {
+      node.parent = b.pendingParent;
+      b.pendingParent = null;
+    }
+    b.tip = node.key;
+    nodes.push(node);
+    return node;
+  };
+  const ensureActive = (lineNumber) => {
+    if (!active) {
+      makeBranch("main", null, null, null);
+      active = "main";
+    }
+    void lineNumber;
+  };
+  const doRebase = (fb, tb, lineNumber) => {
+    const fbr = branches.get(fb);
+    const tbr = branches.get(tb);
+    if (!fbr || !tbr) {
+      result.diagnostics.push(
+        emit(VERSION_CONTROL_DX.UNKNOWN_BRANCH, lineNumber, {
+          op: "rebase",
+          branch: !fbr ? fb : tb,
+          section: "\xA729.8"
+        })
+      );
+      return;
+    }
+    const feats = nodes.filter((n) => n.branch === fb).sort((a, b) => a.seq - b.seq);
+    let prev = null;
+    const first = tbr.tip;
+    for (const o of feats) {
+      o.ghost = true;
+      const copy = {
+        key: nodes.length,
+        branch: fb,
+        lane: fbr.creationLane,
+        seq: seq++,
+        kind: "commit",
+        message: o.message,
+        type: o.type,
+        id: o.id,
+        tag: o.tag,
+        lineNumber: o.lineNumber,
+        prev,
+        parent: prev == null ? first : null,
+        mergeFrom: null,
+        cherryFrom: null,
+        revertFrom: null,
+        squashFrom: null,
+        movedTo: null,
+        ghost: false
+      };
+      o.movedTo = copy.key;
+      nodes.push(copy);
+      prev = copy.key;
+    }
+    fbr.tip = prev;
+    active = fb;
+  };
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    const indent = measureIndent(line);
+    if (!headerParsed) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine?.chartType === "version-control") {
+        result.title = firstLine.title ?? null;
+        result.titleLineNumber = lineNumber;
+        headerParsed = true;
+        continue;
+      }
+      let msg2 = 'Expected "version-control [Title]" as the first line.';
+      const hint = suggest(firstLine?.chartType ?? trimmed, [
+        "version-control"
+      ]);
+      if (hint) msg2 += ` ${hint}`;
+      return fail(lineNumber, msg2);
+    }
+    const dir = /^direction\s+(LR|TB|BT)$/i.exec(trimmed);
+    if (dir) {
+      options.direction = dir[1].toUpperCase();
+      continue;
+    }
+    if (trimmed === "no-labels") {
+      options.noLabels = true;
+      continue;
+    }
+    if (trimmed === "no-lanes") {
+      options.noLanes = true;
+      continue;
+    }
+    if (trimmed === "no-head") {
+      options.noHead = true;
+      continue;
+    }
+    if (indent === 0) {
+      let m2;
+      if (m2 = /^ref\s+(.+?)\s+at\s+(.+?)(?:\s+(remote))?$/.exec(trimmed)) {
+        const nm = m2[1].trim();
+        const tgt = findByRef(m2[2].trim(), lineNumber);
+        refs.push({
+          name: nm,
+          atKey: tgt ? tgt.key : null,
+          remote: !!m2[3] || /^(origin|upstream)\//.test(nm),
+          head: nm === "HEAD",
+          lineNumber
+        });
+        continue;
+      }
+      if (m2 = /^rebase\s+(.+?)\s+onto\s+(.+)$/.exec(trimmed)) {
+        doRebase(m2[1].trim(), m2[2].trim(), lineNumber);
+        continue;
+      }
+      if (m2 = /^reset\s+(.+?)\s+to\s+(.+)$/.exec(trimmed)) {
+        const br = branches.get(m2[1].trim());
+        const tgt = findByRef(m2[2].trim(), lineNumber);
+        if (!br) {
+          result.diagnostics.push(
+            emit(VERSION_CONTROL_DX.UNKNOWN_BRANCH, lineNumber, {
+              op: "reset",
+              branch: m2[1].trim(),
+              section: "\xA729.8"
+            })
+          );
+        } else if (tgt) {
+          for (const n of nodes) {
+            if (n.branch === br.name && n.seq > tgt.seq) n.ghost = true;
+          }
+          br.tip = tgt.key;
+          active = br.name;
+        }
+        continue;
+      }
+      const lastWord = trimmed.split(/\s+/).pop() ?? "";
+      const colored = extractColor(
+        trimmed,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      let rest = colored.label;
+      const colorToken = colored.color !== void 0 ? lastWord : null;
+      let ord = null;
+      const om = /\s+order:\s*(\d+)\s*$/.exec(rest);
+      if (om) {
+        ord = Number(om[1]);
+        rest = rest.replace(/\s+order:\s*\d+\s*$/, "");
+      }
+      let name = rest.trim();
+      let parent = null;
+      const fm = rest.split(/\s+from\s+/);
+      if (fm.length === 2) {
+        name = fm[0].trim();
+        parent = fm[1].trim();
+      }
+      const existing = branches.get(name);
+      if (existing) {
+        active = name;
+      } else {
+        makeBranch(name, parent != null ? parent : active, colorToken, ord);
+        active = name;
+      }
+      continue;
+    }
+    ensureActive(lineNumber);
+    let m;
+    if (/^merge\b/.test(trimmed)) {
+      const { msg: msg2, tag: tag2, id: id2, type: type2 } = peelMeta(trimmed.slice(5).trim());
+      let src = msg2.trim();
+      let strat = null;
+      const sm = /^(.*?)\s+(squash|ff|no-ff)$/.exec(src);
+      if (sm) {
+        src = sm[1].trim();
+        strat = sm[2];
+      }
+      const sb = branches.get(src);
+      if (!sb) {
+        result.diagnostics.push(
+          emit(VERSION_CONTROL_DX.UNKNOWN_BRANCH, lineNumber, {
+            op: "merge",
+            branch: src,
+            section: "\xA729.4"
+          })
+        );
+      }
+      if (strat === "squash") {
+        if (sb) {
+          for (const n of nodes) if (n.branch === src) n.ghost = true;
+        }
+        const node = addNode({
+          kind: "commit",
+          message: `Squash ${src}`,
+          type: "normal",
+          tag: tag2 ?? null,
+          id: id2 ?? null,
+          lineNumber
+        });
+        node.squashFrom = sb ? sb.tip : null;
+      } else {
+        const node = addNode({
+          kind: "merge",
+          message: src,
+          type: type2 ?? "normal",
+          tag: tag2 ?? null,
+          id: id2 ?? null,
+          lineNumber
+        });
+        node.mergeFrom = sb ? sb.tip : null;
+      }
+      continue;
+    }
+    if (/^cherry-pick\b/.test(trimmed)) {
+      const ref = trimmed.slice(11).trim();
+      const s = findByRef(ref, lineNumber);
+      const node = addNode({
+        kind: "cherry",
+        message: ref,
+        type: "normal",
+        tag: null,
+        id: null,
+        lineNumber
+      });
+      node.cherryFrom = s ? s.key : null;
+      continue;
+    }
+    if (/^revert\b/.test(trimmed)) {
+      const ref = trimmed.slice(6).trim();
+      const s = findByRef(ref, lineNumber);
+      const node = addNode({
+        kind: "commit",
+        message: s ? `Revert ${s.message}` : "Revert",
+        type: "reverse",
+        tag: null,
+        id: null,
+        lineNumber
+      });
+      node.revertFrom = s ? s.key : null;
+      continue;
+    }
+    if (m = /^note\b\s*(.*)$/.exec(trimmed)) {
+      const b = branches.get(active);
+      notes.push({
+        num: notes.length + 1,
+        anchorKey: b.tip,
+        text: m[1].trim(),
+        lineNumber
+      });
+      continue;
+    }
+    const body = trimmed.replace(/^commit\b\s*/, "");
+    const { msg, tag, id, type } = peelMeta(body);
+    addNode({
+      kind: "commit",
+      message: msg || null,
+      type: type ?? "normal",
+      tag: tag ?? null,
+      id: id ?? null,
+      lineNumber
+    });
+  }
+  if (!options.noHead && active) {
+    const tip = branches.get(active).tip;
+    if (tip != null && !refs.some((r) => r.head)) {
+      refs.push({
+        name: "HEAD",
+        atKey: tip,
+        remote: false,
+        head: true,
+        lineNumber: 0
+      });
+    }
+  }
+  const ancestors = (key) => {
+    const seen = /* @__PURE__ */ new Set();
+    const st = [key];
+    while (st.length) {
+      const k = st.pop();
+      if (seen.has(k)) continue;
+      seen.add(k);
+      const n = nodes[k];
+      if (n) {
+        if (n.prev != null) st.push(n.prev);
+        if (n.parent != null) st.push(n.parent);
+        if (n.mergeFrom != null) st.push(n.mergeFrom);
+      }
+    }
+    return seen;
+  };
+  for (const bn of order) {
+    const b = branches.get(bn);
+    if (b.tip == null) continue;
+    const rr = refs.find(
+      (r) => r.remote && (r.name === `origin/${bn}` || r.name.endsWith(`/${bn}`))
+    );
+    if (rr?.atKey != null) {
+      const A = ancestors(b.tip);
+      const B = ancestors(rr.atKey);
+      let ahead = 0;
+      let behind = 0;
+      A.forEach((k) => {
+        if (!B.has(k)) ahead++;
+      });
+      B.forEach((k) => {
+        if (!A.has(k)) behind++;
+      });
+      b.ab = { ahead, behind };
+    }
+  }
+  const ordered = [...order].sort((a, b) => {
+    const ba = branches.get(a);
+    const bb = branches.get(b);
+    const ka = ba.order ?? ba.creationLane;
+    const kb = bb.order ?? bb.creationLane;
+    return ka - kb || ba.creationLane - bb.creationLane;
+  });
+  const laneOf = /* @__PURE__ */ new Map();
+  ordered.forEach((nm, idx) => laneOf.set(nm, idx));
+  for (const n of nodes) n.lane = laneOf.get(n.branch);
+  result.branches = order.map((nm) => {
+    const b = branches.get(nm);
+    return {
+      name: nm,
+      lane: laneOf.get(nm),
+      colorToken: b.colorToken,
+      order: b.order,
+      tip: b.tip,
+      ab: b.ab
+    };
+  });
+  if (nodes.length === 0 && !result.error) {
+    const diag = emit(
+      VERSION_CONTROL_DX.NO_COMMITS,
+      result.titleLineNumber ?? 1
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  return result;
+}
+function peelMeta(s) {
+  const out = {
+    msg: s,
+    tag: null,
+    type: null,
+    id: null
+  };
+  const idx = s.search(/\b(tag|type|id)\s*:/);
+  if (idx >= 0) {
+    out.msg = s.slice(0, idx).trim();
+    const re = /(tag|type|id)\s*:\s*([^,]+)/g;
+    let m;
+    const rest = s.slice(idx);
+    while ((m = re.exec(rest)) !== null) {
+      const k = m[1];
+      out[k] = m[2].trim();
+    }
+  }
+  return out;
+}
+
+export {
+  VERSION_CONTROL_DIAGNOSTICS,
+  parseVersionControl
+};
+//# sourceMappingURL=chunk-ERLBPDGU.js.map