@diagrammo/dgmo 0.8.5 → 0.8.7

package/src/utils/tag-groups.ts

@@ -16,7 +16,7 @@ export interface TagGroup {
   name: string;
   alias?: string;
   entries: TagEntry[];
-  /** First value in the tag declaration is the default (nodes without metadata get this) */
+  /** Default value for nodes without explicit metadata. First entry unless another is marked `default`. */
   defaultValue?: string;
   lineNumber: number;
 }
@@ -30,6 +30,26 @@ export interface TagBlockMatch {
   inlineValues?: string[];
 }
 
+// ── Default Modifier ────────────────────────────────────────
+
+/**
+ * Strip trailing `default` keyword from a tag entry string.
+ * Returns the cleaned text and whether the keyword was present.
+ *
+ * Examples:
+ *   "NA(gray) default" → { text: "NA(gray)", isDefault: true }
+ *   "Done(green)"      → { text: "Done(green)", isDefault: false }
+ */
+export function stripDefaultModifier(text: string): {
+  text: string;
+  isDefault: boolean;
+} {
+  if (/\bdefault\s*$/.test(text)) {
+    return { text: text.replace(/\s+default\s*$/, '').trim(), isDefault: true };
+  }
+  return { text, isDefault: false };
+}
+
 // ── Regexes ─────────────────────────────────────────────────
 
 /** Canonical syntax: line starting with `tag` keyword (no colon). */
@@ -89,10 +109,15 @@ export function parseTagDeclaration(line: string): TagBlockMatch | null {
     // BEFORE any value tokens (values have `(color)` suffixes or appear after we see a comma).
 
     // First check for explicit `alias` keyword: `tag Name alias X`
-    const aliasKeywordIdx = tokens.findIndex((t, i) => i > 0 && t.toLowerCase() === 'alias');
+    const aliasKeywordIdx = tokens.findIndex(
+      (t, i) => i > 0 && t.toLowerCase() === 'alias'
+    );
     if (aliasKeywordIdx > 0 && aliasKeywordIdx + 1 < tokens.length) {
       // Everything before `alias` is the name, the token after `alias` is the alias
-      name = tokens.slice(0, aliasKeywordIdx).map(t => stripQuotes(t)).join(' ');
+      name = tokens
+        .slice(0, aliasKeywordIdx)
+        .map((t) => stripQuotes(t))
+        .join(' ');
       alias = tokens[aliasKeywordIdx + 1];
       restStartIdx = aliasKeywordIdx + 2;
     } else {
@@ -103,7 +128,11 @@ export function parseTagDeclaration(line: string): TagBlockMatch | null {
 
       if (tokens.length === 1) {
         // Just `tag Name` — no alias, no values
-      } else if (tokens.length === 2 && isAliasToken(tokens[1]) && !commaInRemaining) {
+      } else if (
+        tokens.length === 2 &&
+        isAliasToken(tokens[1]) &&
+        !commaInRemaining
+      ) {
         // `tag Priority p` — alias only, no values
         alias = tokens[1];
         restStartIdx = 2;
@@ -130,11 +159,17 @@ export function parseTagDeclaration(line: string): TagBlockMatch | null {
           if (valueStart > 1 && isAliasToken(tokens[valueStart - 1])) {
             alias = tokens[valueStart - 1];
             // Name is everything from token[0] to token[valueStart-2]
-            name = tokens.slice(0, valueStart - 1).map(t => stripQuotes(t)).join(' ');
+            name = tokens
+              .slice(0, valueStart - 1)
+              .map((t) => stripQuotes(t))
+              .join(' ');
             restStartIdx = valueStart;
           } else {
             // No alias — name is everything before values
-            name = tokens.slice(0, valueStart).map(t => stripQuotes(t)).join(' ');
+            name = tokens
+              .slice(0, valueStart)
+              .map((t) => stripQuotes(t))
+              .join(' ');
             restStartIdx = valueStart;
           }
         }
@@ -146,7 +181,10 @@ export function parseTagDeclaration(line: string): TagBlockMatch | null {
   if (restStartIdx < tokens.length) {
     // Rejoin and split by comma for inline values
     const valueStr = tokens.slice(restStartIdx).join(' ');
-    inlineValues = valueStr.split(',').map(v => v.trim()).filter(Boolean);
+    inlineValues = valueStr
+      .split(',')
+      .map((v) => v.trim())
+      .filter(Boolean);
   }
 
   // Check for trailing color hint on name (without inline values)
@@ -163,7 +201,8 @@ export function parseTagDeclaration(line: string): TagBlockMatch | null {
     name,
     alias,
     colorHint,
-    inlineValues: inlineValues && inlineValues.length > 0 ? inlineValues : undefined,
+    inlineValues:
+      inlineValues && inlineValues.length > 0 ? inlineValues : undefined,
   };
 }
 
@@ -204,9 +243,8 @@ export function resolveTagColor(
   if (!metaValue) return '#999999';
 
   return (
-    group.entries.find(
-      (e) => e.value.toLowerCase() === metaValue.toLowerCase()
-    )?.color ?? '#999999'
+    group.entries.find((e) => e.value.toLowerCase() === metaValue.toLowerCase())
+      ?.color ?? '#999999'
   );
 }
 
@@ -223,7 +261,10 @@ export function resolveTagColor(
  * @param suggestFn Optional did-you-mean suggestion function
  */
 export function validateTagValues(
-  entities: ReadonlyArray<{ metadata: Record<string, string>; lineNumber: number }>,
+  entities: ReadonlyArray<{
+    metadata: Record<string, string>;
+    lineNumber: number;
+  }>,
   tagGroups: ReadonlyArray<TagGroup>,
   pushWarning: (lineNumber: number, message: string) => void,
   suggestFn?: (input: string, candidates: readonly string[]) => string | null
@@ -244,8 +285,8 @@ export function validateTagValues(
         // Suppress warning if the value is a prefix of any valid entry —
         // the user is likely still typing (live parse during editing).
         const valueLower = value.toLowerCase();
-        const isPrefix = group.entries.some(
-          (e) => e.value.toLowerCase().startsWith(valueLower)
+        const isPrefix = group.entries.some((e) =>
+          e.value.toLowerCase().startsWith(valueLower)
         );
         if (!isPrefix) {
           const defined = group.entries.map((e) => e.value);
@@ -281,7 +322,10 @@ export function injectDefaultTagMetadata(
   const defaults: { key: string; value: string }[] = [];
   for (const group of tagGroups) {
     if (group.defaultValue) {
-      defaults.push({ key: group.name.toLowerCase(), value: group.defaultValue });
+      defaults.push({
+        key: group.name.toLowerCase(),
+        value: group.defaultValue,
+      });
     }
   }
   if (defaults.length === 0) return;

package/gallery/fixtures/initiative-status-full.dgmo

@@ -1,46 +0,0 @@
-initiative-status Platform Modernization — Full Status
-
-tag Phase alias p
-  Discovery(green) default
-  Build(blue)
-  Launch(orange)
-  Maintenance(purple)
-
-tag Team alias t
-  Frontend(blue)
-  Backend(green)
-  Platform(teal)
-  Data(purple)
-
-[Identity] | t: Backend
-  Auth Service | done, p: Build
-  SSO Integration | doing, p: Build
-    -> Auth Service | done
-  MFA Rollout | blocked, p: Launch
-    -> SSO Integration | doing
-
-[Payments] | t: Platform
-  Payment Gateway | doing, p: Build
-  Billing UI | todo, p: Build, t: Frontend
-    -> Payment Gateway | doing
-  Invoice API | todo, p: Launch
-    -> Payment Gateway | doing
-    -> Billing UI | todo
-
-[Search] | t: Backend
-  Search API | done, p: Build
-  Search UI | doing, p: Build, t: Frontend
-    -> Search API | done
-  Search Analytics | na, p: Maintenance, t: Data
-
-[Observability] | t: Platform
-  Metrics Pipeline | done, p: Discovery
-  Alert Rules | done, p: Build
-    -> Metrics Pipeline | done
-  Dashboard | doing, p: Build, t: Frontend
-    -> Metrics Pipeline | done
-    -> Alert Rules | done
-
-Auth Service -> Payment Gateway: validates | done
-SSO Integration -> Search API: provides identity | done
-Metrics Pipeline -> Search API: monitors | done

package/gallery/fixtures/initiative-status-phases.dgmo

@@ -1,29 +0,0 @@
-initiative-status Platform Migration
-
-tag Phase alias p
-  Discovery default
-  Build
-  Launch
-
-tag Team alias t
-  Frontend
-  Backend
-  Platform
-
-[Identity]
-  Auth Service | done, p: Discovery, t: Backend
-  SSO Integration | doing, p: Build, t: Backend
-    -> Auth Service | done
-
-[Payments]
-  Payment Gateway | doing, p: Build, t: Platform
-  Billing UI | todo, p: Build, t: Frontend
-    -> Payment Gateway | doing
-
-[Search]
-  Search API | todo, p: Launch, t: Backend
-  Search UI | todo, p: Launch, t: Frontend
-    -> Search API
-
-Auth Service -> Payment Gateway: validates | done
-SSO Integration -> Search API: provides identity | todo

package/gallery/fixtures/initiative-status.dgmo

@@ -1,9 +0,0 @@
-initiative-status Q2 Platform Roadmap
-
-Auth Service | done
-Payment Gateway | doing
-  -> Auth Service | done
-Search API | todo
-  -> Auth Service | done
-Billing UI | blocked
-  -> Payment Gateway | doing

package/src/initiative-status/collapse.ts

@@ -1,76 +0,0 @@
-import type { ParsedInitiativeStatus, InitiativeStatus, ISGroup } from './types';
-import { rollUpStatus } from './layout';
-
-// ============================================================
-// CollapseResult — returned by collapseInitiativeStatus
-// ============================================================
-
-export interface CollapseResult {
-  parsed: ParsedInitiativeStatus;
-  collapsedGroupStatuses: Map<string, InitiativeStatus>;
-  originalGroups: ISGroup[];
-}
-
-// ============================================================
-// collapseInitiativeStatus — pure transform
-//
-// Returns a new ParsedInitiativeStatus with:
-//   - Children of collapsed groups removed from nodes
-//   - Edges redirected: source/target pointing to hidden nodes
-//     → point to the group label
-//   - Internal edges (both endpoints in same collapsed group) dropped
-//   - Duplicate edges (same source, target, label) deduplicated
-//     (first occurrence kept)
-//   - Collapsed groups removed from groups[] (layout handles them
-//     as regular nodes)
-//   - collapsedGroupStatuses: worst-case status per collapsed group
-// ============================================================
-
-export function collapseInitiativeStatus(
-  parsed: ParsedInitiativeStatus,
-  collapsedGroups: Set<string>
-): CollapseResult {
-  const originalGroups = parsed.groups;
-
-  if (collapsedGroups.size === 0) {
-    return { parsed, collapsedGroupStatuses: new Map(), originalGroups };
-  }
-
-  // Build node → collapsed group lookup
-  const nodeToGroup = new Map<string, string>();
-  const collapsedGroupStatuses = new Map<string, InitiativeStatus>();
-
-  for (const group of parsed.groups) {
-    if (!collapsedGroups.has(group.label)) continue;
-    const children = group.nodeLabels
-      .map((l) => parsed.nodes.find((n) => n.label === l))
-      .filter((n): n is (typeof parsed.nodes)[0] => n !== undefined);
-    for (const node of children) nodeToGroup.set(node.label, group.label);
-    collapsedGroupStatuses.set(group.label, rollUpStatus(children));
-  }
-
-  // Filter nodes: remove children of collapsed groups
-  const nodes = parsed.nodes.filter((n) => !nodeToGroup.has(n.label));
-
-  // Remap and deduplicate edges
-  const edgeKeys = new Set<string>();
-  const edges: typeof parsed.edges = [];
-  for (const edge of parsed.edges) {
-    const src = nodeToGroup.get(edge.source) ?? edge.source;
-    const tgt = nodeToGroup.get(edge.target) ?? edge.target;
-    if (src === tgt) continue; // internal edge → drop
-    const key = `${src}|${tgt}|${edge.label ?? ''}`;
-    if (edgeKeys.has(key)) continue; // duplicate → drop
-    edgeKeys.add(key);
-    edges.push({ ...edge, source: src, target: tgt });
-  }
-
-  // Keep only expanded groups in groups[]
-  const groups = parsed.groups.filter((g) => !collapsedGroups.has(g.label));
-
-  return {
-    parsed: { ...parsed, nodes, edges, groups },
-    collapsedGroupStatuses,
-    originalGroups,
-  };
-}

package/src/initiative-status/filter.ts

@@ -1,63 +0,0 @@
-// ============================================================
-// Initiative Status — Tag-Based Filter
-//
-// Immutable graph transform: returns a new ParsedInitiativeStatus
-// with hidden-value nodes removed, their edges dropped,
-// and group.nodeLabels cleaned.
-// ============================================================
-
-import type { ParsedInitiativeStatus } from './types';
-
-/**
- * Filter an initiative-status graph by hiding nodes whose tag metadata
- * matches any hidden value. Returns a new (immutable copy) ParsedInitiativeStatus.
- *
- * @param parsed  Fully-resolved parsed result (defaults already injected)
- * @param hiddenTagValues  Map<groupKey, Set<hiddenValues>> — all keys/values lowercase
- * @returns Filtered copy; original is not mutated
- */
-export function filterInitiativeStatusByTags(
-  parsed: ParsedInitiativeStatus,
-  hiddenTagValues: Map<string, Set<string>>
-): ParsedInitiativeStatus {
-  // Fast path: no filtering
-  if (hiddenTagValues.size === 0) return parsed;
-
-  // Build set of hidden node labels
-  const hiddenNodeLabels = new Set<string>();
-  for (const node of parsed.nodes) {
-    for (const [groupKey, hiddenValues] of hiddenTagValues) {
-      const nodeValue = node.metadata[groupKey];
-      if (nodeValue && hiddenValues.has(nodeValue.toLowerCase())) {
-        hiddenNodeLabels.add(node.label);
-        break;
-      }
-    }
-  }
-
-  // No nodes hidden — return input unchanged
-  if (hiddenNodeLabels.size === 0) return parsed;
-
-  // Filter nodes
-  const nodes = parsed.nodes.filter((n) => !hiddenNodeLabels.has(n.label));
-
-  // Filter edges: remove edges where source OR target is hidden
-  const edges = parsed.edges.filter(
-    (e) => !hiddenNodeLabels.has(e.source) && !hiddenNodeLabels.has(e.target)
-  );
-
-  // Clean group nodeLabels; remove empty groups
-  const groups = parsed.groups
-    .map((g) => ({
-      ...g,
-      nodeLabels: g.nodeLabels.filter((l) => !hiddenNodeLabels.has(l)),
-    }))
-    .filter((g) => g.nodeLabels.length > 0);
-
-  return {
-    ...parsed,
-    nodes,
-    edges,
-    groups,
-  };
-}