@diagrammo/dgmo 0.45.0 → 0.47.0

package/dist/chunk-L3UHP6TD.js

@@ -0,0 +1,101 @@
+import {
+  formatDateKey,
+  parseGanttDate
+} from "./chunk-USZW2HHU.js";
+
+// src/pert/internal.ts
+var CONFIDENCE_TABLE = {
+  high: { oFactor: 0.9, pFactor: 1.5 },
+  medium: { oFactor: 0.75, pFactor: 3 },
+  low: { oFactor: 0.5, pFactor: 4 }
+};
+function resolveConfidence(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed in CONFIDENCE_TABLE) {
+    return CONFIDENCE_TABLE[trimmed];
+  }
+  const factorMatch = trimmed.match(/^(\d+(?:\.\d+)?)\s*\/\s*(\d+(?:\.\d+)?)$/);
+  if (factorMatch) {
+    const oFactor = parseFloat(factorMatch[1]);
+    const pFactor = parseFloat(factorMatch[2]);
+    if (oFactor > 0 && pFactor > 0) return { oFactor, pFactor };
+  }
+  return null;
+}
+var UNIT_TO_DAYS_LOCAL = {
+  min: 1 / (60 * 24),
+  h: 1 / 24,
+  d: 1,
+  bd: 1,
+  // PERT has no calendar; bd ≈ d for analytical purposes
+  w: 7,
+  m: 30,
+  q: 90,
+  y: 365,
+  s: 14
+  // sprint (14 calendar days) — not seconds
+};
+function unitToDays(unit) {
+  return UNIT_TO_DAYS_LOCAL[unit];
+}
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+function parseLocalISODate(iso) {
+  if (!ISO_DATE_RE.test(iso)) return null;
+  const date = parseGanttDate(iso);
+  if (formatDateKey(date) !== iso) return null;
+  return date;
+}
+function formatLocalISODate(date) {
+  return formatDateKey(date);
+}
+function addCalendarDays(iso, days) {
+  const start = parseLocalISODate(iso);
+  if (!start) return iso;
+  const whole = Math.sign(days) * Math.round(Math.abs(days));
+  const result = new Date(
+    start.getFullYear(),
+    start.getMonth(),
+    start.getDate() + whole,
+    start.getHours(),
+    start.getMinutes()
+  );
+  return formatLocalISODate(result);
+}
+function formatDuration(value, unit, nullLabel) {
+  if (value === null) return nullLabel ?? "?";
+  const rounded = Math.round(value * 100) / 100;
+  const display = rounded.toFixed(2).replace(/\.?0+$/, "");
+  return `${display}${unit}`;
+}
+function formatScheduleValue(value, projectStart, unit, nullLabel) {
+  if (value === null) return nullLabel ?? "?";
+  if (projectStart === null) return formatDuration(value, unit, nullLabel);
+  return addCalendarDays(projectStart, value * unitToDays(unit));
+}
+function formatSprintCell(value, sprintNumber, nullLabel) {
+  if (value === null) return nullLabel ?? "?";
+  const rounded = Math.round(value);
+  return `S${sprintNumber + rounded}`;
+}
+function formatSlackValue(value, projectStart, unit, nullLabel) {
+  if (value === null) return nullLabel ?? "?";
+  if (projectStart === null) return formatDuration(value, unit, nullLabel);
+  const days = value * unitToDays(unit);
+  const rounded = Math.round(days * 100) / 100;
+  const display = rounded.toFixed(2).replace(/\.?0+$/, "");
+  return `${display}d`;
+}
+
+export {
+  CONFIDENCE_TABLE,
+  resolveConfidence,
+  unitToDays,
+  parseLocalISODate,
+  formatLocalISODate,
+  addCalendarDays,
+  formatDuration,
+  formatScheduleValue,
+  formatSprintCell,
+  formatSlackValue
+};
+//# sourceMappingURL=chunk-L3UHP6TD.js.map

package/dist/chunk-L66GEFB6.js

@@ -0,0 +1,524 @@
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  tryCollectNote
+} from "./chunk-5MLYVTYM.js";
+import {
+  resolveNotes
+} from "./chunk-FMDSF3OV.js";
+import {
+  validateLabelCharacters
+} from "./chunk-FFUN5D66.js";
+import {
+  displayName,
+  normalizeName
+} from "./chunk-NOTA6TEI.js";
+import {
+  ER_REGISTRY,
+  OPTION_NOCOLON_RE,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  stripQuotes,
+  tokenizeQuoteAware,
+  tryParseSharedOption,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  resolveColorWithDiagnostic
+} from "./chunk-TLVIHFRO.js";
+import {
+  NAME_DIAGNOSTIC_CODES,
+  formatDgmoError,
+  makeDgmoError,
+  nameMergedMessage,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/er/parser.ts
+function tableId(name) {
+  return normalizeName(name);
+}
+var TABLE_DECL_RE = /^(?:"([^"]+)"|([a-zA-Z_][^|":(]*?))(?:\s+(red|orange|yellow|green|blue|purple|teal|cyan|gray|black|white))?(?:\s*\|(.+))?$/;
+var INDENT_REL_RE = /^([1*?])-{1,2}(?:(.+?)-{1,2})?([1*?])\s+(?:"([^"]+)"|([a-zA-Z_][^":]*?))\s*$/;
+var CONSTRAINT_MAP = {
+  pk: "pk",
+  fk: "fk",
+  unique: "unique",
+  nullable: "nullable"
+};
+var KNOWN_OPTIONS = /* @__PURE__ */ new Set(["notation", "active-tag"]);
+function parseCardSide(token) {
+  if (token === "1" || token === "*" || token === "?") return token;
+  return null;
+}
+var REL_SYMBOLIC_RE = /^(?:"([^"]+)"|([a-zA-Z_][^":]*?))\s+([1*?])\s*-{1,2}\s*([1*?])\s+(?:"([^"]+)"|([a-zA-Z_][^":]*?))(?:\s+(.+))?$/;
+var REL_KEYWORD_RE = /^(?:"([^"]+)"|([a-zA-Z_][^":]*?))\s+(one|many|zero)[- ]to[- ](one|many|zero)\s+(?:"([^"]+)"|([a-zA-Z_][^":]*?))(?:\s+(.+))?$/i;
+var KEYWORD_TO_SYMBOL = {
+  one: "1",
+  many: "*",
+  zero: "?"
+};
+function parseRelationship(trimmed, lineNumber, pushError) {
+  const sym = trimmed.match(REL_SYMBOLIC_RE);
+  if (sym) {
+    const fromCard = parseCardSide(sym[3]);
+    const toCard = parseCardSide(sym[4]);
+    if (fromCard && toCard) {
+      const sourceName = (sym[1] ?? sym[2] ?? "").trim();
+      const targetName = (sym[5] ?? sym[6] ?? "").trim();
+      const label = sym[7]?.trim();
+      if (label) {
+        validateLabelCharacters(label, lineNumber).forEach(
+          (d) => pushError(d.line, d.message)
+        );
+      }
+      return {
+        source: tableId(sourceName),
+        target: tableId(targetName),
+        from: fromCard,
+        to: toCard,
+        ...label !== void 0 && { label }
+      };
+    }
+  }
+  const kw = trimmed.match(REL_KEYWORD_RE);
+  if (kw) {
+    const sourceName = (kw[1] ?? kw[2] ?? "").trim();
+    const targetName = (kw[5] ?? kw[6] ?? "").trim();
+    const fromKw = kw[3];
+    const toKw = kw[4];
+    const fromSym = KEYWORD_TO_SYMBOL[fromKw.toLowerCase()] ?? fromKw;
+    const toSym = KEYWORD_TO_SYMBOL[toKw.toLowerCase()] ?? toKw;
+    pushError(
+      lineNumber,
+      `Use symbolic cardinality (1--*, ?--1, *--*) instead of "${fromKw}-to-${toKw}". Example: ${sourceName} ${fromSym}--${toSym} ${targetName}`
+    );
+    return null;
+  }
+  return null;
+}
+function parseColumn(trimmed) {
+  const rawTokens = tokenizeQuoteAware(trimmed);
+  if (rawTokens.length === 0) return null;
+  const firstRaw = rawTokens[0];
+  const wasQuoted = firstRaw.startsWith('"') || firstRaw.startsWith("'");
+  const name = stripQuotes(firstRaw);
+  if (!wasQuoted && !/^\w+$/.test(name)) return null;
+  const constraints = [];
+  let type;
+  for (let i = 1; i < rawTokens.length; i++) {
+    const tok = stripQuotes(rawTokens[i]);
+    const lower = tok.toLowerCase();
+    const constraint = CONSTRAINT_MAP[lower];
+    if (constraint) {
+      constraints.push(constraint);
+    } else if (type === void 0) {
+      type = tok;
+    } else {
+      return null;
+    }
+  }
+  return { name, ...type !== void 0 && { type }, constraints };
+}
+function parseERDiagram(content, palette) {
+  const lines = content.split("\n");
+  const options = {};
+  const result = {
+    type: "er",
+    options,
+    tables: [],
+    relationships: [],
+    tagGroups: [],
+    diagnostics: [],
+    error: null
+  };
+  const pushError = (line, message) => {
+    const diag = makeDgmoError(line, message);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  const tableMap = /* @__PURE__ */ new Map();
+  const tableMetadataMap = /* @__PURE__ */ new Map();
+  let currentTable = null;
+  const notes = [];
+  let contentStarted = false;
+  let currentTagGroup = null;
+  const metaAliasMap = /* @__PURE__ */ new Map();
+  const nameAliasMap = /* @__PURE__ */ new Map();
+  function peelAlias(label) {
+    const trimmed = label.trim();
+    const m = trimmed.match(/^(.*?)\s+as\s+([A-Za-z][A-Za-z0-9_]{0,11})\s*$/);
+    if (!m) return { label: trimmed };
+    return { label: m[1].trim(), alias: m[2] };
+  }
+  function resolveAliasName(token) {
+    return nameAliasMap.get(token.trim()) ?? token;
+  }
+  let firstLineParsed = false;
+  function getOrCreateTable(name, lineNumber) {
+    const key = tableId(name);
+    const existing = tableMap.get(key);
+    if (existing) {
+      const incomingDisplay = displayName(name);
+      const existingDisplay = displayName(existing.name);
+      if (incomingDisplay !== existingDisplay) {
+        result.diagnostics.push(
+          makeDgmoError(
+            lineNumber,
+            nameMergedMessage({
+              incomingDisplay,
+              incomingLine: lineNumber,
+              existingDisplay,
+              existingLine: existing.lineNumber
+            }),
+            "warning",
+            NAME_DIAGNOSTIC_CODES.NAME_MERGED
+          )
+        );
+      }
+      return existing;
+    }
+    const metadata = {};
+    const table = {
+      id: key,
+      name,
+      columns: [],
+      metadata,
+      lineNumber
+    };
+    tableMap.set(key, table);
+    tableMetadataMap.set(key, metadata);
+    result.tables.push(table);
+    return table;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    const lineNumber = i + 1;
+    const indent = measureIndent(raw);
+    if (!trimmed) {
+      if (indent === 0) currentTable = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    if (!firstLineParsed && indent === 0) {
+      const firstLineResult = parseFirstLine(trimmed);
+      if (firstLineResult?.chartType === "er") {
+        firstLineParsed = true;
+        if (firstLineResult.title) {
+          result.title = firstLineResult.title;
+          result.titleLineNumber = lineNumber;
+        }
+        continue;
+      }
+      firstLineParsed = true;
+    }
+    if (!contentStarted && indent === 0) {
+      const tagBlockMatch = matchTagBlockHeading(trimmed);
+      if (tagBlockMatch) {
+        currentTagGroup = {
+          name: tagBlockMatch.name,
+          ...tagBlockMatch.alias !== void 0 && {
+            alias: tagBlockMatch.alias
+          },
+          entries: [],
+          lineNumber
+        };
+        if (tagBlockMatch.alias) {
+          metaAliasMap.set(
+            normalizeName(tagBlockMatch.alias),
+            tagBlockMatch.name.toLowerCase()
+          );
+        }
+        metaAliasMap.set(
+          normalizeName(tagBlockMatch.name),
+          tagBlockMatch.name.toLowerCase()
+        );
+        result.tagGroups.push(currentTagGroup);
+        continue;
+      }
+    }
+    if (currentTagGroup && !contentStarted && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      if (isDefault) {
+        currentTagGroup.defaultValue = label;
+      } else if (currentTagGroup.entries.length === 0) {
+        currentTagGroup.defaultValue = label;
+      }
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber
+      });
+      continue;
+    }
+    if (currentTagGroup && indent === 0) {
+      currentTagGroup = null;
+    }
+    if (!contentStarted && indent === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].toLowerCase();
+        const value = optMatch[2].trim();
+        if (KNOWN_OPTIONS.has(key)) {
+          options[key] = value.toLowerCase();
+          continue;
+        }
+      }
+      if (trimmed.toLowerCase() === "no-semantic-colors") {
+        options["no-semantic-colors"] = "on";
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, options)) {
+        continue;
+      }
+    }
+    if (indent > 0 && currentTable) {
+      const indentRel = trimmed.match(INDENT_REL_RE);
+      if (indentRel) {
+        const fromCard = parseCardSide(indentRel[1]);
+        const toCard = parseCardSide(indentRel[3]);
+        if (fromCard && toCard) {
+          const rawTarget = (indentRel[4] ?? indentRel[5] ?? "").trim();
+          const targetName = resolveAliasName(rawTarget);
+          getOrCreateTable(targetName, lineNumber);
+          const rawLabel = indentRel[2]?.trim();
+          if (rawLabel) {
+            result.diagnostics.push(
+              ...validateLabelCharacters(rawLabel, lineNumber)
+            );
+          }
+          result.relationships.push({
+            source: currentTable.id,
+            target: tableId(targetName),
+            cardinality: { from: fromCard, to: toCard },
+            ...rawLabel && { label: rawLabel },
+            lineNumber
+          });
+        }
+        continue;
+      }
+      const colResult = parseColumn(trimmed);
+      if (colResult) {
+        currentTable.columns.push({
+          name: colResult.name,
+          ...colResult.type && { type: colResult.type },
+          constraints: colResult.constraints,
+          lineNumber
+        });
+      }
+      continue;
+    }
+    currentTable = null;
+    contentStarted = true;
+    const noteResult = tryCollectNote(
+      lines,
+      i,
+      indent,
+      palette,
+      result.diagnostics
+    );
+    if (noteResult) {
+      if (noteResult.note) notes.push(noteResult.note);
+      i = noteResult.lastIndex;
+      continue;
+    }
+    const rel = parseRelationship(trimmed, lineNumber, pushError);
+    if (rel) {
+      result.diagnostics.push(
+        makeDgmoError(
+          lineNumber,
+          `Relationship "${rel.source} \u2192 ${rel.target}" must be indented under the source table "${rel.source}"`,
+          "warning"
+        )
+      );
+      continue;
+    }
+    const registry = withTagAliases(ER_REGISTRY, new Set(metaAliasMap.keys()));
+    const split = splitNameAndMeta(
+      trimmed,
+      registry,
+      metaAliasMap,
+      void 0,
+      result.diagnostics,
+      lineNumber
+    );
+    warnUnknownMetaKeys(
+      split.meta,
+      registry,
+      (msg) => result.diagnostics.push(makeDgmoError(lineNumber, msg, "warning")),
+      split.name
+    );
+    const tableDecl = split.name.match(TABLE_DECL_RE);
+    if (tableDecl) {
+      const rawName = (tableDecl[1] ?? tableDecl[2] ?? "").trim();
+      const peeled = peelAlias(rawName);
+      const name = peeled.label;
+      if (peeled.alias) nameAliasMap.set(peeled.alias, name);
+      const colorName = split.color ?? tableDecl[3]?.trim();
+      const color = colorName ? resolveColorWithDiagnostic(
+        colorName,
+        lineNumber,
+        result.diagnostics,
+        palette
+      ) : void 0;
+      const table = getOrCreateTable(name, lineNumber);
+      if (color) table.color = color;
+      table.lineNumber = lineNumber;
+      if (Object.keys(split.meta).length > 0) {
+        const mutableMeta = tableMetadataMap.get(table.id);
+        if (mutableMeta) Object.assign(mutableMeta, split.meta);
+      }
+      currentTable = table;
+      continue;
+    }
+    result.diagnostics.push(
+      makeDgmoError(
+        lineNumber,
+        `Unexpected line: '${trimmed}'. A table is a bare name at indent 0 ('users'); columns are indented and SPACE-separated, no colon ('id int pk'); relationships are indented ('1--* orders'). (\xA79)`,
+        "warning"
+      )
+    );
+  }
+  if (result.tables.length === 0 && !result.error) {
+    const diag = makeDgmoError(
+      1,
+      'No tables found. Add table declarations like "users" or "orders blue".'
+    );
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  finalizeAutoTagColors(result.tagGroups, palette);
+  if (result.tagGroups.length > 0) {
+    const tagEntities = result.tables.map((t) => ({
+      metadata: t.metadata,
+      lineNumber: t.lineNumber
+    }));
+    validateTagValues(
+      tagEntities,
+      result.tagGroups,
+      (line, msg) => result.diagnostics.push(makeDgmoError(line, msg, "warning")),
+      suggest
+    );
+    validateTagGroupNames(
+      result.tagGroups,
+      (line, msg) => result.diagnostics.push(makeDgmoError(line, msg, "warning"))
+    );
+    for (const group of result.tagGroups) {
+      if (!group.defaultValue) continue;
+      const key = tagAttrKey(group.name);
+      for (const table of result.tables) {
+        if (!table.metadata[key]) {
+          const mutableMeta = tableMetadataMap.get(table.id);
+          if (mutableMeta) mutableMeta[key] = group.defaultValue;
+        }
+      }
+    }
+  }
+  if (notes.length > 0) {
+    result.notes = notes;
+    resolveNotes(
+      notes,
+      result.tables.map((t) => ({ id: t.id, label: t.name })),
+      result.diagnostics
+    );
+  }
+  if (result.tables.length >= 2 && result.relationships.length >= 1 && !result.error) {
+    const connectedIds = /* @__PURE__ */ new Set();
+    for (const rel of result.relationships) {
+      connectedIds.add(rel.source);
+      connectedIds.add(rel.target);
+    }
+    for (const table of result.tables) {
+      if (!connectedIds.has(table.id)) {
+        result.diagnostics.push(
+          makeDgmoError(
+            table.lineNumber,
+            `Table "${table.name}" is not connected to any other table`,
+            "warning"
+          )
+        );
+      }
+    }
+  }
+  return result;
+}
+var CONSTRAINT_KEYWORD_RE = /\b(pk|fk)\b/i;
+function looksLikeERDiagram(content) {
+  const lines = content.split("\n");
+  let hasConstraint = false;
+  let hasTableDecl = false;
+  let hasRelationship = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) continue;
+    if (/^(er|notation)\s/i.test(trimmed) || /^er$/i.test(trimmed)) continue;
+    const indent = measureIndent(line);
+    if (indent > 0) {
+      if (CONSTRAINT_KEYWORD_RE.test(trimmed)) {
+        hasConstraint = true;
+      }
+      if (INDENT_REL_RE.test(trimmed)) {
+        hasRelationship = true;
+      }
+    } else {
+      if (TABLE_DECL_RE.test(trimmed)) {
+        hasTableDecl = true;
+      }
+      if (REL_SYMBOLIC_RE.test(trimmed)) {
+        hasRelationship = true;
+      }
+    }
+  }
+  if (hasConstraint && hasTableDecl) return true;
+  if (hasRelationship && hasTableDecl) return true;
+  return false;
+}
+function extractSymbols(docText) {
+  const entities = [];
+  let inMetadata = true;
+  for (const rawLine of docText.split("\n")) {
+    const line = rawLine.trim();
+    if (inMetadata && /^er(\s|$)/i.test(line)) continue;
+    if (/^\s/.test(rawLine)) continue;
+    if (line.length === 0) continue;
+    const m = TABLE_DECL_RE.exec(line);
+    if (m) {
+      const name = (m[1] ?? m[2] ?? "").trim();
+      if (name) {
+        inMetadata = false;
+        entities.push(name);
+        continue;
+      }
+    }
+    if (inMetadata && OPTION_NOCOLON_RE.test(line)) continue;
+    inMetadata = false;
+  }
+  return {
+    kind: "er",
+    entities
+  };
+}
+
+export {
+  parseERDiagram,
+  looksLikeERDiagram,
+  extractSymbols
+};
+//# sourceMappingURL=chunk-L66GEFB6.js.map