@diagrammo/dgmo 0.52.0 → 0.54.0

package/dist/chunk-BEOAKGNA.js

@@ -0,0 +1,484 @@
+import {
+  emit
+} from "./chunk-4W2PE66Q.js";
+
+// src/raci/diagnostics.ts
+var RACI_DX = {
+  // ── Errors ──────────────────────────────────────────────────
+  MULTI_ACCOUNTABLE: {
+    code: "E_RACI_MULTI_ACCOUNTABLE",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Accountable",
+    // variants.ts › multiAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Accountable \u2014 RACI requires exactly one.`,
+    hint: "Assign the A marker to exactly one role per task; make the others Responsible or Consulted.",
+    example: `raci
+
+Task
+  Cap: A
+  QM: A`
+  },
+  DACI_MULTI_DRIVER: {
+    code: "E_DACI_MULTI_DRIVER",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Driver (DACI)",
+    // variants.ts › daciMultiDriverRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Driver \u2014 DACI requires exactly one.`,
+    hint: "A DACI decision has a single Driver; give the extra D roles another marker.",
+    example: `raci
+
+Decision
+  PM: D
+  Cap: D`
+  },
+  DACI_MULTI_ACCOUNTABLE: {
+    code: "E_DACI_MULTI_ACCOUNTABLE",
+    severity: "error",
+    chartType: "raci",
+    title: "Multiple Approver (DACI)",
+    // variants.ts › daciMultiAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has more than one Approver \u2014 DACI requires exactly one.`,
+    hint: "A DACI decision has a single Approver (A); reduce to one.",
+    example: `raci
+
+Decision
+  Lead: D
+  PM: A
+  Cap: A`
+  },
+  INVALID_MARKER: {
+    code: "E_RACI_INVALID_MARKER",
+    severity: "error",
+    chartType: "raci",
+    // Two emit sites share this code: parser.ts first-pass (default form,
+    // rejects letters outside the union alphabet) and parser.ts post-pass
+    // (variant-aware form, passed `variant`+`alphabet`, rejects union
+    // letters outside the resolved variant). The `{}` default renders the
+    // first-pass wording.
+    title: "Invalid marker",
+    // parser.ts first-pass tokenizer
+    message: (p) => p.variant !== void 0 && p.variant !== null ? `Marker '${p.marker ?? "X"}' is not in the ${p.variant} alphabet (${p.alphabet}).` : `Marker '${p.marker ?? "X"}' is not a recognized RACI marker (R A S C I D).`,
+    hint: "Use only R, A, S, C, I (or D for DACI). Wrong-variant letters (e.g. S in a DACI chart) trigger the variant-alphabet form of this diagnostic.",
+    example: `raci
+
+Task
+  Cap: X`
+  },
+  UNEXPECTED_LINE: {
+    code: "E_RACI_UNEXPECTED_LINE",
+    severity: "error",
+    chartType: "raci",
+    title: "Unexpected line under task",
+    // parser.ts — free-text after first role assignment
+    message: (p) => `Unexpected line after role assignments under task '${p.task ?? "Task"}'. Lines under a task must be either a description (before the first 'Role: markers' line) or another role assignment.`,
+    hint: "Put all description text before the first role assignment; nothing but assignments may follow.",
+    example: `raci
+
+Task
+  Cap: A
+  This is an unexpected description.`
+  },
+  MIXED_VARIANTS: {
+    code: "E_RACI_MIXED_VARIANTS",
+    severity: "error",
+    chartType: "raci",
+    title: "Mixed RASCI/DACI markers",
+    // parser.ts — variant resolution, inferVariant() returned null
+    message: "Chart uses both 'D' and 'S' markers but neither RASCI nor DACI covers both. Use only RACI/RASCI markers (R, A, S, C, I) or only DACI markers (D, A, C, I).",
+    hint: "Pick one convention: R/A/S/C/I (RACI/RASCI) or D/A/C/I (DACI). Do not mix D and S in one chart.",
+    example: `raci
+
+Task
+  Cap: D
+  Crew: S`
+  },
+  // ── Warnings ────────────────────────────────────────────────
+  MISSING_ACCOUNTABLE: {
+    code: "W_RACI_MISSING_ACCOUNTABLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Accountable",
+    // variants.ts › missingAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Accountable assigned.`,
+    hint: "Every RACI task should have exactly one Accountable (A).",
+    example: `raci
+
+Task
+  Cap: R`
+  },
+  MISSING_RESPONSIBLE: {
+    code: "W_RACI_MISSING_RESPONSIBLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Responsible",
+    // variants.ts › missingResponsibleRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Responsible assigned.`,
+    hint: "Assign at least one Responsible (R) \u2014 someone has to do the work.",
+    example: `raci
+
+Task
+  Cap: A`
+  },
+  DACI_MISSING_DRIVER: {
+    code: "W_DACI_MISSING_DRIVER",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Driver (DACI)",
+    // variants.ts › daciMissingDriverRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Driver assigned.`,
+    hint: "A DACI decision needs a Driver (D) to move it forward.",
+    example: `raci
+
+Pick Vendor
+  Lead: D
+  PM: A
+Sign Off
+  Cap: C`
+  },
+  DACI_MISSING_ACCOUNTABLE: {
+    code: "W_DACI_MISSING_ACCOUNTABLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Missing Approver (DACI)",
+    // variants.ts › daciMissingAccountableRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no Approver assigned.`,
+    hint: "A DACI decision needs an Approver (A) to sign off.",
+    example: `raci
+
+Pick Vendor
+  Lead: D
+  PM: A
+Sign Off
+  Cap: C`
+  },
+  UNKNOWN_ROLE: {
+    code: "W_RACI_UNKNOWN_ROLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Undeclared role",
+    // parser.ts — only when `roles:` is declared. Live message appends a
+    // ` Did you mean 'X'?` suggestion when a near match exists.
+    message: (p) => {
+      const role = p.role ?? "Role";
+      const hint = p.hint ?? "";
+      return `Role '${role}' is not declared in the 'roles:' directive.${hint ? " " + hint : ""}`;
+    },
+    hint: "Add the role to the `roles` directive, or fix the typo to match a declared role.",
+    example: `raci
+roles Cap, QM
+
+Task
+  Cap: A
+  Stranger: R`
+  },
+  EMPTY_TASK: {
+    code: "W_RACI_EMPTY_TASK",
+    severity: "warning",
+    chartType: "raci",
+    title: "Empty task",
+    // variants.ts › emptyTaskRule
+    message: (p) => `Task '${p.task ?? "Task"}' has no role assignments.`,
+    hint: "Add at least one `Role: markers` line, or remove the empty task.",
+    example: `raci
+
+Task
+  Just a description with no assignments`
+  },
+  CONFLICTING_MARKERS: {
+    code: "W_RACI_CONFLICTING_MARKERS",
+    severity: "warning",
+    chartType: "raci",
+    title: "Conflicting markers",
+    // variants.ts › conflictingMarkersRule
+    message: (p) => {
+      const role = p.role ?? "Role";
+      const task = p.task ?? "Task";
+      const markers = p.markers ?? "A C";
+      return `Role '${role}' on task '${task}' has conflicting markers (${markers}). A role can be either active (R/A/D) or passive (C/I), not both.`;
+    },
+    hint: "Give the role either an active marker (R/A/D) or a passive one (C/I), not both.",
+    example: `raci
+
+Task
+  Cap: A C`
+  },
+  TOO_MANY_RESPONSIBLE: {
+    code: "W_RACI_TOO_MANY_RESPONSIBLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Too many Responsible",
+    // variants.ts › tooManyResponsibleRule (threshold = 3)
+    message: (p) => {
+      const task = p.task ?? "Task";
+      const count = p.count ?? 4;
+      const threshold = p.threshold ?? 3;
+      return `Task '${task}' has ${count} Responsibles \u2014 more than ${threshold} dilutes ownership. Consider splitting the task or marking some as Consulted.`;
+    },
+    hint: "Keep Responsibles at or below 3 \u2014 split the task or downgrade some roles to Consulted.",
+    example: `raci
+
+Task
+  W: R
+  X: R
+  Y: R
+  Z: R
+  Lead: A`
+  },
+  ORPHAN_ROLE: {
+    code: "W_RACI_ORPHAN_ROLE",
+    severity: "warning",
+    chartType: "raci",
+    title: "Orphan role",
+    // parser.ts — role declared/seen but never assigned any marker
+    message: (p) => `Role '${p.role ?? "Role"}' is declared but never assigned to any task.`,
+    hint: "Assign the role a marker somewhere, or remove it from the `roles` directive.",
+    example: `raci
+roles Cap, Ghost
+
+Task
+  Cap: A R`
+  }
+};
+var RACI_DIAGNOSTICS = Object.values(RACI_DX);
+
+// src/raci/variants.ts
+var RACI_ERROR_CODES = {
+  MULTI_ACCOUNTABLE: "E_RACI_MULTI_ACCOUNTABLE",
+  DACI_MULTI_DRIVER: "E_DACI_MULTI_DRIVER",
+  DACI_MULTI_ACCOUNTABLE: "E_DACI_MULTI_ACCOUNTABLE",
+  INVALID_MARKER: "E_RACI_INVALID_MARKER",
+  UNEXPECTED_LINE: "E_RACI_UNEXPECTED_LINE",
+  MIXED_VARIANTS: "E_RACI_MIXED_VARIANTS"
+};
+var ALL_MARKERS = /* @__PURE__ */ new Set([
+  "R",
+  "A",
+  "S",
+  "C",
+  "I",
+  "D"
+]);
+function inferVariant(markers) {
+  let hasD = false;
+  let hasS = false;
+  for (const m of markers) {
+    if (m === "D") hasD = true;
+    else if (m === "S") hasS = true;
+  }
+  if (hasD && hasS) return null;
+  if (hasD) return "daci";
+  if (hasS) return "rasci";
+  return "raci";
+}
+var RACI_WARNING_CODES = {
+  MISSING_ACCOUNTABLE: "W_RACI_MISSING_ACCOUNTABLE",
+  MISSING_RESPONSIBLE: "W_RACI_MISSING_RESPONSIBLE",
+  DACI_MISSING_DRIVER: "W_DACI_MISSING_DRIVER",
+  DACI_MISSING_ACCOUNTABLE: "W_DACI_MISSING_ACCOUNTABLE",
+  UNKNOWN_ROLE: "W_RACI_UNKNOWN_ROLE",
+  EMPTY_TASK: "W_RACI_EMPTY_TASK",
+  CONFLICTING_MARKERS: "W_RACI_CONFLICTING_MARKERS",
+  TOO_MANY_RESPONSIBLE: "W_RACI_TOO_MANY_RESPONSIBLE",
+  ORPHAN_ROLE: "W_RACI_ORPHAN_ROLE"
+};
+var TOO_MANY_RESPONSIBLE_THRESHOLD = 3;
+function countMarker(task, marker) {
+  let count = 0;
+  for (const assignment of task.roleAssignments) {
+    for (const m of assignment.markers) if (m === marker) count++;
+  }
+  return count;
+}
+function totalMarkerCount(task) {
+  let n = 0;
+  for (const a of task.roleAssignments) n += a.markers.length;
+  return n;
+}
+function findFirstAssignmentLineWithMarker(task, marker, skipFirst) {
+  let seen = 0;
+  for (const assignment of task.roleAssignments) {
+    if (assignment.markers.includes(marker)) {
+      seen++;
+      if (skipFirst && seen === 1) continue;
+      return assignment.lineNumber;
+    }
+  }
+  return task.lineNumber;
+}
+var multiAccountableRule = (task) => {
+  if (countMarker(task, "A") > 1) {
+    return [
+      emit(
+        RACI_DX.MULTI_ACCOUNTABLE,
+        findFirstAssignmentLineWithMarker(task, "A", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var daciMultiDriverRule = (task) => {
+  if (countMarker(task, "D") > 1) {
+    return [
+      emit(
+        RACI_DX.DACI_MULTI_DRIVER,
+        findFirstAssignmentLineWithMarker(task, "D", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var daciMultiAccountableRule = (task) => {
+  if (countMarker(task, "A") > 1) {
+    return [
+      emit(
+        RACI_DX.DACI_MULTI_ACCOUNTABLE,
+        findFirstAssignmentLineWithMarker(task, "A", true),
+        {
+          task: task.displayName
+        }
+      )
+    ];
+  }
+  return [];
+};
+var emptyTaskRule = (task) => {
+  if (totalMarkerCount(task) === 0) {
+    return [
+      emit(RACI_DX.EMPTY_TASK, task.lineNumber, { task: task.displayName })
+    ];
+  }
+  return [];
+};
+var missingAccountableRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "A") === 0) {
+    return [
+      emit(RACI_DX.MISSING_ACCOUNTABLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var missingResponsibleRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "R") === 0) {
+    return [
+      emit(RACI_DX.MISSING_RESPONSIBLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var daciMissingDriverRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "D") === 0) {
+    return [
+      emit(RACI_DX.DACI_MISSING_DRIVER, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var daciMissingAccountableRule = (task) => {
+  if (totalMarkerCount(task) === 0) return [];
+  if (countMarker(task, "A") === 0) {
+    return [
+      emit(RACI_DX.DACI_MISSING_ACCOUNTABLE, task.lineNumber, {
+        task: task.displayName
+      })
+    ];
+  }
+  return [];
+};
+var ACTIVE_MARKERS = /* @__PURE__ */ new Set(["R", "A", "D"]);
+var PASSIVE_MARKERS = /* @__PURE__ */ new Set(["C", "I"]);
+var conflictingMarkersRule = (task) => {
+  const out = [];
+  for (const a of task.roleAssignments) {
+    let hasActive = false;
+    let hasPassive = false;
+    for (const m of a.markers) {
+      if (ACTIVE_MARKERS.has(m)) hasActive = true;
+      if (PASSIVE_MARKERS.has(m)) hasPassive = true;
+    }
+    if (hasActive && hasPassive) {
+      out.push(
+        emit(RACI_DX.CONFLICTING_MARKERS, a.lineNumber, {
+          role: a.displayName,
+          task: task.displayName,
+          markers: a.markers.join(" ")
+        })
+      );
+    }
+  }
+  return out;
+};
+var tooManyResponsibleRule = (task) => {
+  const n = countMarker(task, "R");
+  if (n > TOO_MANY_RESPONSIBLE_THRESHOLD) {
+    return [
+      emit(RACI_DX.TOO_MANY_RESPONSIBLE, task.lineNumber, {
+        task: task.displayName,
+        count: n,
+        threshold: TOO_MANY_RESPONSIBLE_THRESHOLD
+      })
+    ];
+  }
+  return [];
+};
+var VARIANTS = {
+  raci: {
+    alphabet: ["R", "A", "C", "I"],
+    errorRules: [multiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      missingAccountableRule,
+      missingResponsibleRule,
+      conflictingMarkersRule,
+      tooManyResponsibleRule
+    ]
+  },
+  rasci: {
+    alphabet: ["R", "A", "S", "C", "I"],
+    errorRules: [multiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      missingAccountableRule,
+      missingResponsibleRule,
+      conflictingMarkersRule,
+      tooManyResponsibleRule
+    ]
+  },
+  daci: {
+    alphabet: ["D", "A", "C", "I"],
+    errorRules: [daciMultiDriverRule, daciMultiAccountableRule],
+    warningRules: [
+      emptyTaskRule,
+      daciMissingDriverRule,
+      daciMissingAccountableRule,
+      conflictingMarkersRule
+    ]
+  }
+};
+
+export {
+  RACI_DX,
+  RACI_DIAGNOSTICS,
+  RACI_ERROR_CODES,
+  ALL_MARKERS,
+  inferVariant,
+  RACI_WARNING_CODES,
+  VARIANTS
+};
+//# sourceMappingURL=chunk-BEOAKGNA.js.map

package/dist/{chunk-SMRFPVLQ.js → chunk-BM7MG6HT.js}

@@ -5,18 +5,18 @@ import {
   matchTagBlockHeading,
   stripDefaultModifier,
   validateTagGroupNames
-} from "./chunk-HHKO6SKY.js";
+} from "./chunk-AHTTKERF.js";
 import {
   OPTION_NOCOLON_RE,
   extractColor,
   measureIndent,
   parseFirstLine,
   tryParseSharedOption
-} from "./chunk-BRENJ2BQ.js";
+} from "./chunk-3FRO35WW.js";
 import {
   formatDgmoError,
   makeDgmoError
-} from "./chunk-CXK4DZH3.js";
+} from "./chunk-4W2PE66Q.js";
 
 // src/wireframe/parser.ts
 var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["palette", "theme", "active-tag"]);
@@ -729,4 +729,4 @@ export {
   resetWireframeIds,
   parseWireframe
 };
-//# sourceMappingURL=chunk-SMRFPVLQ.js.map
+//# sourceMappingURL=chunk-BM7MG6HT.js.map

package/dist/{chunk-P3NRSSUU.js → chunk-BULHGPHK.js}

@@ -6,7 +6,7 @@ import {
   fold,
   regionAt,
   unionExtent
-} from "./chunk-I5IGB56C.js";
+} from "./chunk-4QV26TEG.js";
 import {
   MAP_DX
 } from "./chunk-4B5YISOR.js";
@@ -19,7 +19,7 @@ import {
   emit,
   formatDgmoError,
   suggest
-} from "./chunk-CXK4DZH3.js";
+} from "./chunk-4W2PE66Q.js";
 
 // src/map/resolver.ts
 var WORLD_SPAN = 90;
@@ -775,4 +775,4 @@ export {
   isSubNationalUsExtent,
   resolveMap
 };
-//# sourceMappingURL=chunk-P3NRSSUU.js.map
+//# sourceMappingURL=chunk-BULHGPHK.js.map