@diagrammo/dgmo 0.47.0 → 0.48.1

package/src/sequence/tag-resolution.ts

@@ -1,164 +0,0 @@
-// ============================================================
-// Sequence Diagram Tag Resolution
-// ============================================================
-//
-// Resolves effective tag values for participants and messages
-// using the priority chain: explicit > group > receiver-inherit > default > neutral
-
-import { tagAttrKey } from '../utils/tag-groups';
-import type {
-  ParsedSequenceDgmo,
-  SequenceParticipant,
-  SequenceMessage,
-  SequenceGroup,
-} from './parser';
-
-/**
- * Resolved tag values for all sequence elements.
- * Used by the renderer to look up colors via tag group entries.
- */
-export interface ResolvedTagMap {
-  /** participantId → resolved tag value for the active group */
-  participants: Map<string, string | undefined>;
-  /** message lineNumber → tag value from explicit metadata */
-  messages: Map<number, string | undefined>;
-}
-
-/**
- * Propagate group-level tag metadata to contained participants.
- * Only sets values for keys not already present on the participant.
- *
- * Mutates `participantMeta` in-place.
- */
-export function propagateGroupTags(
-  participantMeta: Map<string, Record<string, string>>,
-  groups: ReadonlyArray<SequenceGroup>
-): void {
-  for (const group of groups) {
-    if (!group.metadata) continue;
-    for (const id of group.participantIds) {
-      const meta = participantMeta.get(id);
-      if (!meta) continue;
-      for (const [key, value] of Object.entries(group.metadata)) {
-        if (!(key in meta)) {
-          meta[key] = value;
-        }
-      }
-    }
-  }
-}
-
-/**
- * Compute receiver inheritance for a specific tag group key.
- *
- * For each participant without an explicit value for `groupKey`,
- * collect values from all incoming tagged messages. If exactly one
- * unique value exists, the participant inherits it.
- *
- * Returns a map of participantId → inherited value.
- */
-export function computeReceiverInheritance(
-  participants: ReadonlyArray<SequenceParticipant>,
-  messages: ReadonlyArray<SequenceMessage>,
-  groupKey: string,
-  participantMeta: Map<string, Record<string, string>>
-): Map<string, string> {
-  const inheritance = new Map<string, string>();
-
-  for (const p of participants) {
-    const meta = participantMeta.get(p.id);
-    // Skip if already has a value for this group key
-    if (meta?.[groupKey]) continue;
-
-    const incomingValues = new Set<string>();
-    for (const msg of messages) {
-      if (msg.to === p.id && msg.metadata?.[groupKey]) {
-        incomingValues.add(msg.metadata[groupKey]);
-      }
-    }
-
-    if (incomingValues.size === 1) {
-      // In-bounds: size === 1 guarantees [0] exists.
-      inheritance.set(p.id, [...incomingValues][0]!);
-    }
-  }
-
-  return inheritance;
-}
-
-/**
- * Full tag resolution for sequence diagrams.
- *
- * Priority: explicit metadata > group propagation > receiver inheritance > default > neutral
- *
- * Pure function — does not mutate `parsed`.
- */
-export function resolveSequenceTags(
-  parsed: ParsedSequenceDgmo,
-  activeTagGroup: string
-): ResolvedTagMap {
-  const result: ResolvedTagMap = {
-    participants: new Map(),
-    messages: new Map(),
-  };
-
-  // Find the active tag group
-  const group = parsed.tagGroups.find(
-    (g) => g.name.toLowerCase() === activeTagGroup.toLowerCase()
-  );
-  if (!group) {
-    // No matching group — all neutral
-    for (const p of parsed.participants) {
-      result.participants.set(p.id, undefined);
-    }
-    for (const m of parsed.messages) {
-      result.messages.set(m.lineNumber, undefined);
-    }
-    return result;
-  }
-
-  const groupKey = tagAttrKey(group.name);
-
-  // Clone participant metadata (don't mutate parsed data)
-  const participantMeta = new Map<string, Record<string, string>>();
-  for (const p of parsed.participants) {
-    participantMeta.set(p.id, { ...(p.metadata || {}) });
-  }
-
-  // Step 1: Group propagation
-  propagateGroupTags(participantMeta, parsed.groups);
-
-  // Step 2: Receiver inheritance
-  const inherited = computeReceiverInheritance(
-    parsed.participants,
-    parsed.messages,
-    groupKey,
-    participantMeta
-  );
-  for (const [id, value] of inherited) {
-    const meta = participantMeta.get(id)!;
-    meta[groupKey] = value;
-  }
-
-  // Step 3: Default value injection
-  if (group.defaultValue) {
-    for (const p of parsed.participants) {
-      const meta = participantMeta.get(p.id)!;
-      if (!(groupKey in meta)) {
-        meta[groupKey] = group.defaultValue;
-      }
-    }
-  }
-
-  // Build result maps
-  for (const p of parsed.participants) {
-    const meta = participantMeta.get(p.id)!;
-    result.participants.set(p.id, meta[groupKey] || undefined);
-  }
-
-  for (const msg of parsed.messages) {
-    result.messages.set(msg.lineNumber, msg.metadata?.[groupKey] || undefined);
-  }
-
-  return result;
-}

package/src/sharing.ts

@@ -1,211 +0,0 @@
-import {
-  compressToEncodedURIComponent,
-  decompressFromEncodedURIComponent,
-} from 'lz-string';
-
-const DEFAULT_BASE_URL = 'https://online.diagrammo.app';
-const COMPRESSED_SIZE_LIMIT = 8192; // 8 KB
-
-/**
- * Compact view state schema (ADR-6).
- * All fields optional. Only non-default values are encoded.
- * `tag: null` means "user chose none"; absent `tag` means "use DSL default" (ADR-5).
- */
-export interface CompactViewState {
-  tag?: string | null; // active tag override (null = "none")
-  cs?: number[]; // collapsed sections (sequence line numbers)
-  cg?: string[]; // collapsed groups/nodes (IDs or names)
-  swim?: string | null; // swimlane tag group
-  cl?: string[]; // collapsed lanes
-  cc?: string[]; // collapsed columns (kanban)
-  rm?: string; // render mode override
-  htv?: Record<string, string[]>; // hidden tag values
-  ha?: string[]; // hidden attributes
-  sem?: boolean; // semantic colors (ER)
-  cm?: boolean; // compact meta (kanban)
-  c4l?: string; // C4 level
-  c4s?: string; // C4 system
-  c4c?: string; // C4 container
-  rps?: number; // RPS multiplier (infra)
-  spd?: number; // playback speed (infra)
-  io?: Record<string, number>; // instance overrides (infra)
-  hd?: boolean; // hide descriptions (mindmap)
-  cbd?: boolean; // color by depth (mindmap)
-  rq?: string; // radar quadrant focus (tech-radar position)
-  an?: boolean; // analysis layer on (PERT: tornado + S-curve)
-  fl?: boolean; // field-labels reference card included (PERT)
-}
-
-export interface DecodedDiagramUrl {
-  dsl: string;
-  viewState: CompactViewState;
-  palette?: string;
-  theme?: 'light' | 'dark';
-  filename?: string;
-}
-
-export interface EncodeDiagramUrlOptions {
-  baseUrl?: string;
-  viewState?: CompactViewState;
-  palette?: string;
-  theme?: 'light' | 'dark';
-  filename?: string;
-}
-
-export type EncodeDiagramUrlResult =
-  | { url: string; error?: undefined }
-  | {
-      url?: undefined;
-      error: 'too-large';
-      compressedSize: number;
-      limit: number;
-    };
-
-/**
- * Encode a CompactViewState to a compressed string for URL embedding.
- * Returns empty string if state has no keys (ADR-4).
- */
-export function encodeViewState(state: CompactViewState): string {
-  const keys = Object.keys(state);
-  if (keys.length === 0) return '';
-  return compressToEncodedURIComponent(JSON.stringify(state));
-}
-
-/**
- * Decode a compressed view state string back to CompactViewState.
- * Returns empty object on failure (no crash).
- */
-export function decodeViewState(encoded: string): CompactViewState {
-  if (!encoded) return {};
-  try {
-    const json = decompressFromEncodedURIComponent(encoded);
-    if (!json) return {};
-    const parsed = JSON.parse(json);
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
-      return {};
-    return parsed as CompactViewState;
-  } catch {
-    return {};
-  }
-}
-
-/**
- * Compress a DGMO DSL string into a shareable URL.
- * Returns `{ url }` on success, or `{ error: 'too-large', compressedSize, limit }` if the
- * compressed payload exceeds the 8 KB limit.
- */
-export function encodeDiagramUrl(
-  dsl: string,
-  options?: EncodeDiagramUrlOptions
-): EncodeDiagramUrlResult {
-  const baseUrl = options?.baseUrl ?? DEFAULT_BASE_URL;
-  const compressed = compressToEncodedURIComponent(dsl);
-  const byteSize = new TextEncoder().encode(compressed).byteLength;
-
-  if (byteSize > COMPRESSED_SIZE_LIMIT) {
-    return {
-      error: 'too-large',
-      compressedSize: byteSize,
-      limit: COMPRESSED_SIZE_LIMIT,
-    };
-  }
-
-  let hash = `dgmo=${compressed}`;
-
-  // View state as single compressed blob (ADR-1)
-  if (options?.viewState) {
-    const vsEncoded = encodeViewState(options.viewState);
-    if (vsEncoded) {
-      hash += `&vs=${vsEncoded}`;
-    }
-  }
-
-  // Palette and theme are app-level, kept as separate params
-  if (options?.palette && options.palette !== 'nord') {
-    hash += `&pal=${encodeURIComponent(options.palette)}`;
-  }
-
-  if (options?.theme && options.theme !== 'dark') {
-    hash += `&th=${encodeURIComponent(options.theme)}`;
-  }
-
-  if (options?.filename) {
-    hash += `&fn=${encodeURIComponent(options.filename)}`;
-  }
-
-  // Encode in both query param AND hash fragment — some share mechanisms
-  // strip one or the other (iOS share sheet strips #, AirDrop strips ?)
-  return { url: `${baseUrl}?${hash}#${hash}` };
-}
-
-/**
- * Decode a DGMO DSL string and view state from a URL query string or hash.
- * Accepts any of:
- *   - `?dgmo=<payload>&vs=<state>`
- *   - `#dgmo=<payload>&vs=<state>` (backwards compat)
- *   - `dgmo=<payload>`
- *   - `<bare payload>`
- *
- * Returns `{ dsl, viewState }`. The DSL is empty string on invalid input.
- */
-export function decodeDiagramUrl(hash: string): DecodedDiagramUrl {
-  const empty: DecodedDiagramUrl = { dsl: '', viewState: {} };
-  let filename: string | undefined;
-  let palette: string | undefined;
-  let theme: 'light' | 'dark' | undefined;
-  if (!hash) return empty;
-
-  let raw = hash;
-
-  // Strip leading '#' or '?'
-  if (raw.startsWith('#') || raw.startsWith('?')) {
-    raw = raw.slice(1);
-  }
-
-  // Split on '&' to separate dgmo payload from extra params.
-  // lz-string's compressToEncodedURIComponent alphabet (A-Za-z0-9+-$) never
-  // produces '&', so this split is safe.
-  const parts = raw.split('&');
-  // In-bounds: split() always returns at least one element.
-  let payload = parts[0]!;
-
-  // Parse extra params
-  let viewState: CompactViewState = {};
-  for (let i = 1; i < parts.length; i++) {
-    // In-bounds by loop guard (i < parts.length).
-    const part = parts[i]!;
-    const eq = part.indexOf('=');
-    if (eq === -1) continue;
-    const key = part.slice(0, eq);
-    const val = part.slice(eq + 1);
-    if (key === 'vs' && val) {
-      viewState = decodeViewState(val);
-    }
-    if (key === 'pal' && val) palette = decodeURIComponent(val);
-    if (key === 'th') {
-      const decoded = decodeURIComponent(val);
-      if (decoded === 'light' || decoded === 'dark') theme = decoded;
-    }
-    if (key === 'fn' && val) filename = decodeURIComponent(val);
-  }
-
-  // Strip 'dgmo=' prefix
-  if (payload.startsWith('dgmo=')) {
-    payload = payload.slice(5);
-  }
-
-  const extras = {
-    ...(palette !== undefined && { palette }),
-    ...(theme !== undefined && { theme }),
-    ...(filename !== undefined && { filename }),
-  };
-
-  if (!payload) return { dsl: '', viewState, ...extras };
-
-  try {
-    const result = decompressFromEncodedURIComponent(payload);
-    return { dsl: result ?? '', viewState, ...extras };
-  } catch {
-    return { dsl: '', viewState, ...extras };
-  }
-}

package/src/sitemap/collapse.ts

@@ -1,100 +0,0 @@
-// ============================================================
-// Sitemap Collapse/Expand — prune subtrees + re-terminate arrows
-// ============================================================
-
-import type { SitemapNode, SitemapEdge, ParsedSitemap } from './types';
-import type { Writable } from '../utils/brand';
-import {
-  collapseTree,
-  type TreeCollapseShape,
-} from '../utils/collapse-engine/tree';
-import {
-  reterminateEdges,
-  type EdgeEndpointShape,
-} from '../utils/collapse-engine/tree-edges';
-
-// ============================================================
-// Types
-// ============================================================
-
-export interface CollapsedSitemapResult {
-  /** ParsedSitemap with collapsed subtrees pruned (deep-cloned, never mutates original) */
-  parsed: ParsedSitemap;
-  /** nodeId → count of hidden descendants */
-  hiddenCounts: Map<string, number>;
-}
-
-// ============================================================
-// Helpers
-// ============================================================
-
-function cloneNode(node: SitemapNode): Writable<SitemapNode> {
-  return {
-    id: node.id,
-    label: node.label,
-    metadata: { ...node.metadata },
-    children: node.children.map(cloneNode),
-    parentId: node.parentId,
-    isContainer: node.isContainer,
-    lineNumber: node.lineNumber,
-    ...(node.color !== undefined && { color: node.color }),
-  };
-}
-
-/** Sitemap shape: containers don't count toward an ancestor's hidden tally. */
-const SITEMAP_SHAPE: TreeCollapseShape<SitemapNode> = {
-  getId: (node) => node.id,
-  getChildren: (node) => node.children,
-  clone: cloneNode,
-  setChildren: (node, children) => {
-    (node as Writable<SitemapNode>).children = children as SitemapNode[];
-  },
-  countsAsHidden: (node) => !node.isContainer,
-};
-
-const SITEMAP_EDGE_SHAPE: EdgeEndpointShape<SitemapEdge> = {
-  getSource: (edge) => edge.sourceId,
-  getTarget: (edge) => edge.targetId,
-  withEndpoints: (edge, sourceId, targetId) => ({
-    ...edge,
-    sourceId,
-    targetId,
-  }),
-};
-
-// ============================================================
-// Main
-// ============================================================
-
-export function collapseSitemapTree(
-  original: ParsedSitemap,
-  collapsedIds: Set<string>
-): CollapsedSitemapResult {
-  if (collapsedIds.size === 0) {
-    return { parsed: original, hiddenCounts: new Map() };
-  }
-
-  // Walk · filter · tally via the shared engine.
-  const { roots, hiddenCounts } = collapseTree(
-    original.roots,
-    collapsedIds,
-    SITEMAP_SHAPE
-  );
-
-  // Remap: re-terminate edges that reference pruned nodes to their visible
-  // collapsed-container ancestor (parent-walk; no dedup — parallel edges keep
-  // distinct labels for dagre multigraph routing).
-  const edges = reterminateEdges(
-    original.roots,
-    roots,
-    original.edges,
-    collapsedIds,
-    SITEMAP_SHAPE,
-    SITEMAP_EDGE_SHAPE
-  );
-
-  return {
-    parsed: { ...original, roots, edges },
-    hiddenCounts,
-  };
-}