@transitrix/diagrams 1.0.0 → 1.1.0

package/src/fgca/__tests__/preview-layout.test.ts

@@ -1,124 +1,124 @@
-import { describe, it, expect } from 'vitest';
-import {
-  layoutFGCAPreview,
-  FGCA_PAD,
-  FGCA_NODE_W,
-  type FGCAPreviewDoc,
-} from '../preview-layout.js';
-
-const doc: FGCAPreviewDoc = {
-  factors: [
-    { id: 1, name: 'F1' },
-    { id: 2, name: 'F2' },
-  ],
-  goals: [
-    { id: 10, name: 'G1', factor: [{ id: 1 }] },
-    { id: 11, name: 'G2', factor: [{ id: 2 }] },
-  ],
-  changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
-  activities: [
-    { id: 30, name: 'A1', goal_id: 10 },
-    { id: 31, name: 'A2', goal_id: 11 },
-  ],
-};
-
-describe('layoutFGCAPreview', () => {
-  it('lays out all four columns in order (FGCA)', () => {
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.columns.map(c => c.col)).toEqual(['factor', 'goal', 'change', 'activity']);
-    // 2 factors + 2 goals + 1 change + 2 activities
-    expect(layout.nodes).toHaveLength(7);
-    expect(layout.width).toBeGreaterThan(0);
-    expect(layout.height).toBeGreaterThan(0);
-  });
-
-  it('produces the expected FGCA edge set', () => {
-    // F1→G1, F2→G2 (2), G1→C1 (1), C1→A1 (1), G2→A2 direct (1) = 5
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.edges).toHaveLength(5);
-  });
-
-  it('hideChanges (FGA) drops the Changes column and links goals to activities', () => {
-    const layout = layoutFGCAPreview(doc, { hideChanges: true });
-    expect(layout.columns.map(c => c.col)).toEqual(['factor', 'goal', 'activity']);
-    // 2 factors + 2 goals + 2 activities
-    expect(layout.nodes).toHaveLength(6);
-    // F1→G1, F2→G2 (2), G1→A1, G2→A2 (2) = 4
-    expect(layout.edges).toHaveLength(4);
-  });
-
-  it('first column sits at the pad origin', () => {
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.columns[0].x).toBe(FGCA_PAD);
-  });
-
-  it('empty options reproduce the default layout', () => {
-    const a = layoutFGCAPreview(doc);
-    const b = layoutFGCAPreview(doc, {});
-    expect(b.nodes.map(n => `${n.id}:${n.x},${n.y}`)).toEqual(a.nodes.map(n => `${n.id}:${n.x},${n.y}`));
-  });
-
-  it('larger colGap widens the column step', () => {
-    const stepOf = (colGap: number) => {
-      const cols = layoutFGCAPreview(doc, { colGap }).columns;
-      return cols[1].x - cols[0].x;
-    };
-    expect(stepOf(80)).toBe(FGCA_NODE_W + 80);
-    expect(stepOf(240)).toBe(FGCA_NODE_W + 240);
-    expect(stepOf(240)).toBeGreaterThan(stepOf(80));
-  });
-
-  it('larger rowGap increases the gap between stacked nodes', () => {
-    const gapOf = (rowGap: number) => {
-      const factors = layoutFGCAPreview(doc, { rowGap }).nodes.filter(n => n.col === 'factor');
-      return factors[1].y - factors[0].y;
-    };
-    expect(gapOf(120)).toBeGreaterThan(gapOf(20));
-  });
-
-  // vkgeorgia/strategy#77 — scope filtering. FGCA goals are flat, so 'root'
-  // selects the single matching goal plus the factors/changes/activities that
-  // touch it.
-  describe('scope', () => {
-    const idsOf = (layout: ReturnType<typeof layoutFGCAPreview>) => new Set(layout.nodes.map(n => n.id));
-
-    it("mode 'root' keeps only the root goal and what connects to it", () => {
-      // root 10 → factor 1 (referenced by G10), change 20 (goal_id 10),
-      // activity 30 (via change 20). G11/F2/A31 are dropped.
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '10' } });
-      expect(idsOf(layout)).toEqual(new Set(['factor_1', 'goal_10', 'change_20', 'activity_30']));
-    });
-
-    it("mode 'root' filters factors and activities to those touching the visible goal", () => {
-      // root 11 → factor 2, activity 31 (direct goal link); no change touches G11.
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '11' } });
-      expect(idsOf(layout)).toEqual(new Set(['factor_2', 'goal_11', 'activity_31']));
-      // F1, A30, C20 (which only touch the hidden G10) are excluded.
-      expect(layout.nodes.some(n => n.id === 'factor_1')).toBe(false);
-      expect(layout.nodes.some(n => n.id === 'activity_30')).toBe(false);
-    });
-
-    it("mode 'level' trims goals above the cap and their connections", () => {
-      const leveled: FGCAPreviewDoc = {
-        factors: [{ id: 1, name: 'F1' }, { id: 2, name: 'F2' }],
-        goals: [
-          { id: 10, name: 'G1', level: 0, factor: [{ id: 1 }] },
-          { id: 11, name: 'G2', level: 1, factor: [{ id: 2 }] },
-        ],
-        changes: [],
-        activities: [
-          { id: 30, name: 'A1', goal_id: 10 },
-          { id: 31, name: 'A2', goal_id: 11 },
-        ],
-      };
-      const layout = layoutFGCAPreview(leveled, { scope: { mode: 'level', maxLevel: 0 } });
-      expect(idsOf(layout)).toEqual(new Set(['factor_1', 'goal_10', 'activity_30']));
-    });
-
-    it("mode 'root' returns an empty layout when the root is absent", () => {
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '999' } });
-      expect(layout.nodes).toHaveLength(0);
-      expect(layout.edges).toHaveLength(0);
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import {
+  layoutFGCAPreview,
+  FGCA_PAD,
+  FGCA_NODE_W,
+  type FGCAPreviewDoc,
+} from '../preview-layout.js';
+
+const doc: FGCAPreviewDoc = {
+  factors: [
+    { id: 1, name: 'F1' },
+    { id: 2, name: 'F2' },
+  ],
+  goals: [
+    { id: 10, name: 'G1', factor: [{ id: 1 }] },
+    { id: 11, name: 'G2', factor: [{ id: 2 }] },
+  ],
+  changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
+  activities: [
+    { id: 30, name: 'A1', goal_id: 10 },
+    { id: 31, name: 'A2', goal_id: 11 },
+  ],
+};
+
+describe('layoutFGCAPreview', () => {
+  it('lays out all four columns in order (FGCA)', () => {
+    const layout = layoutFGCAPreview(doc);
+    expect(layout.columns.map(c => c.col)).toEqual(['driver', 'goal', 'change', 'activity']);
+    // 2 factors + 2 goals + 1 change + 2 activities
+    expect(layout.nodes).toHaveLength(7);
+    expect(layout.width).toBeGreaterThan(0);
+    expect(layout.height).toBeGreaterThan(0);
+  });
+
+  it('produces the expected FGCA edge set', () => {
+    // F1→G1, F2→G2 (2), G1→C1 (1), C1→A1 (1), G2→A2 direct (1) = 5
+    const layout = layoutFGCAPreview(doc);
+    expect(layout.edges).toHaveLength(5);
+  });
+
+  it('hideChanges (FGA) drops the Changes column and links goals to activities', () => {
+    const layout = layoutFGCAPreview(doc, { hideChanges: true });
+    expect(layout.columns.map(c => c.col)).toEqual(['driver', 'goal', 'activity']);
+    // 2 factors + 2 goals + 2 activities
+    expect(layout.nodes).toHaveLength(6);
+    // F1→G1, F2→G2 (2), G1→A1, G2→A2 (2) = 4
+    expect(layout.edges).toHaveLength(4);
+  });
+
+  it('first column sits at the pad origin', () => {
+    const layout = layoutFGCAPreview(doc);
+    expect(layout.columns[0].x).toBe(FGCA_PAD);
+  });
+
+  it('empty options reproduce the default layout', () => {
+    const a = layoutFGCAPreview(doc);
+    const b = layoutFGCAPreview(doc, {});
+    expect(b.nodes.map(n => `${n.id}:${n.x},${n.y}`)).toEqual(a.nodes.map(n => `${n.id}:${n.x},${n.y}`));
+  });
+
+  it('larger colGap widens the column step', () => {
+    const stepOf = (colGap: number) => {
+      const cols = layoutFGCAPreview(doc, { colGap }).columns;
+      return cols[1].x - cols[0].x;
+    };
+    expect(stepOf(80)).toBe(FGCA_NODE_W + 80);
+    expect(stepOf(240)).toBe(FGCA_NODE_W + 240);
+    expect(stepOf(240)).toBeGreaterThan(stepOf(80));
+  });
+
+  it('larger rowGap increases the gap between stacked nodes', () => {
+    const gapOf = (rowGap: number) => {
+      const factors = layoutFGCAPreview(doc, { rowGap }).nodes.filter(n => n.col === 'driver');
+      return factors[1].y - factors[0].y;
+    };
+    expect(gapOf(120)).toBeGreaterThan(gapOf(20));
+  });
+
+  // vkgeorgia/strategy#77 — scope filtering. FGCA goals are flat, so 'root'
+  // selects the single matching goal plus the factors/changes/activities that
+  // touch it.
+  describe('scope', () => {
+    const idsOf = (layout: ReturnType<typeof layoutFGCAPreview>) => new Set(layout.nodes.map(n => n.id));
+
+    it("mode 'root' keeps only the root goal and what connects to it", () => {
+      // root 10 → factor 1 (referenced by G10), change 20 (goal_id 10),
+      // activity 30 (via change 20). G11/F2/A31 are dropped.
+      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '10' } });
+      expect(idsOf(layout)).toEqual(new Set(['driver_1', 'goal_10', 'change_20', 'activity_30']));
+    });
+
+    it("mode 'root' filters factors and activities to those touching the visible goal", () => {
+      // root 11 → factor 2, activity 31 (direct goal link); no change touches G11.
+      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '11' } });
+      expect(idsOf(layout)).toEqual(new Set(['driver_2', 'goal_11', 'activity_31']));
+      // F1, A30, C20 (which only touch the hidden G10) are excluded.
+      expect(layout.nodes.some(n => n.id === 'driver_1')).toBe(false);
+      expect(layout.nodes.some(n => n.id === 'activity_30')).toBe(false);
+    });
+
+    it("mode 'level' trims goals above the cap and their connections", () => {
+      const leveled: FGCAPreviewDoc = {
+        factors: [{ id: 1, name: 'F1' }, { id: 2, name: 'F2' }],
+        goals: [
+          { id: 10, name: 'G1', level: 0, factor: [{ id: 1 }] },
+          { id: 11, name: 'G2', level: 1, factor: [{ id: 2 }] },
+        ],
+        changes: [],
+        activities: [
+          { id: 30, name: 'A1', goal_id: 10 },
+          { id: 31, name: 'A2', goal_id: 11 },
+        ],
+      };
+      const layout = layoutFGCAPreview(leveled, { scope: { mode: 'level', maxLevel: 0 } });
+      expect(idsOf(layout)).toEqual(new Set(['driver_1', 'goal_10', 'activity_30']));
+    });
+
+    it("mode 'root' returns an empty layout when the root is absent", () => {
+      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '999' } });
+      expect(layout.nodes).toHaveLength(0);
+      expect(layout.edges).toHaveLength(0);
+    });
+  });
+});

package/src/fgca/__tests__/resolver.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import yaml from 'js-yaml';
+import { resolveFGCA, isFGCAViewDoc } from '../resolver.js';
+import { parseCanonicalFGCA } from '../parse-canonical.js';
+
+// ── Inline canon element store (mirrors strategy-2026 data split into per-element form) ─
+
+const ELEMENTS = [
+  { notation: 'driver', id: 'FACTOR-1', name: 'Competitive market pressure', type: 'external' },
+  { notation: 'driver', id: 'FACTOR-2', name: 'Digital adoption acceleration', type: 'external' },
+  { notation: 'goal', id: 'GOAL-1', name: 'Grow revenue by 20%', factors: ['FACTOR-1', 'FACTOR-2'] },
+  { notation: 'goal', id: 'GOAL-2', name: 'Reduce operational costs', factors: ['FACTOR-2'] },
+  { notation: 'goal', id: 'GOAL-3', name: 'Improve customer retention', factors: ['FACTOR-1'] },
+  { notation: 'change', id: 'CHANGE-1', name: 'Launch new product line', goals: ['GOAL-1'] },
+  { notation: 'change', id: 'CHANGE-2', name: 'Automate manual processes', goals: ['GOAL-2'] },
+  { notation: 'change', id: 'CHANGE-3', name: 'Enhance support platform', goals: ['GOAL-3'] },
+  { notation: 'activity', id: 'ACTIVITY-1', name: 'Market research', changes: ['CHANGE-1'] },
+  { notation: 'activity', id: 'ACTIVITY-2', name: 'MVP development', changes: ['CHANGE-1'] },
+  { notation: 'activity', id: 'ACTIVITY-3', name: 'Process audit', changes: ['CHANGE-2'] },
+  { notation: 'activity', id: 'ACTIVITY-4', name: 'RPA tooling rollout', changes: ['CHANGE-2'] },
+  { notation: 'activity', id: 'ACTIVITY-5', name: 'CRM implementation', changes: ['CHANGE-3'] },
+];
+
+const SOURCES = { elements: ELEMENTS, relations: [] };
+
+const VIEW_DOC = {
+  notation: 'fgca',
+  id: 'FGCA-STRAT-1',
+  name: 'Strategy 2026 — FGCA chain',
+  spec_version: '0.1',
+  view_config: {
+    goals: { filter: 'all' },
+    factors: { surface: 'derived' },
+    changes: { surface: 'derived' },
+    activities: { surface: 'derived' },
+  },
+};
+
+// ── isFGCAViewDoc ─────────────────────────────────────────────────────────────
+
+describe('isFGCAViewDoc', () => {
+  it('returns true for a view_config-based doc', () => {
+    expect(isFGCAViewDoc(VIEW_DOC)).toBe(true);
+  });
+
+  it('returns false for an inline doc with factors/goals arrays', () => {
+    expect(isFGCAViewDoc({
+      notation: 'fgca', id: 'FGCA-1', name: 'x',
+      factors: [], goals: [], changes: [], activities: [],
+    })).toBe(false);
+  });
+
+  it('returns false for non-objects', () => {
+    expect(isFGCAViewDoc(null)).toBe(false);
+    expect(isFGCAViewDoc('string')).toBe(false);
+    expect(isFGCAViewDoc(42)).toBe(false);
+  });
+});
+
+// ── resolveFGCA — goals.filter=all (default) ──────────────────────────────────
+
+describe('resolveFGCA — goals.filter=all', () => {
+  it('includes all goals, changes, and activities', () => {
+    const doc = resolveFGCA(VIEW_DOC, SOURCES);
+    expect((doc['goals'] as unknown[]).length).toBe(3);
+    expect((doc['changes'] as unknown[]).length).toBe(3);
+    expect((doc['activities'] as unknown[]).length).toBe(5);
+  });
+
+  it('derives factors from all goal.factors[] refs', () => {
+    const doc = resolveFGCA(VIEW_DOC, SOURCES);
+    const factorIds = (doc['factors'] as Array<{ id: string }>).map((f) => f.id);
+    expect(factorIds).toContain('FACTOR-1');
+    expect(factorIds).toContain('FACTOR-2');
+    expect(factorIds.length).toBe(2);
+  });
+
+  it('passes parseCanonicalFGCA and produces a fully valid internal doc', () => {
+    const doc = resolveFGCA(VIEW_DOC, SOURCES);
+    const r = parseCanonicalFGCA(doc);
+    expect(r.valid).toBe(true);
+    expect(r.errors).toEqual([]);
+    expect(r.parsed?.goals).toHaveLength(3);
+    expect(r.parsed?.factors).toHaveLength(2);
+    expect(r.parsed?.changes).toHaveLength(3);
+    expect(r.parsed?.activities).toHaveLength(5);
+  });
+
+  it('carries view doc metadata (id, name, spec_version)', () => {
+    const doc = resolveFGCA(VIEW_DOC, SOURCES);
+    expect(doc['notation']).toBe('fgca');
+    expect(doc['id']).toBe('FGCA-STRAT-1');
+    expect(doc['name']).toBe('Strategy 2026 — FGCA chain');
+    expect(doc['spec_version']).toBe('0.1');
+  });
+});
+
+// ── resolveFGCA — goals.filter=ids ────────────────────────────────────────────
+
+describe('resolveFGCA — goals.filter=ids', () => {
+  it('narrows to the specified goal and its derived changes + activities', () => {
+    const viewDoc = {
+      ...VIEW_DOC,
+      view_config: { goals: { filter: 'ids', ids: ['GOAL-1'] }, factors: { surface: 'derived' }, changes: { surface: 'derived' }, activities: { surface: 'derived' } },
+    };
+    const doc = resolveFGCA(viewDoc, SOURCES);
+    const goalIds = (doc['goals'] as Array<{ id: string }>).map((g) => g.id);
+    expect(goalIds).toEqual(['GOAL-1']);
+    const changeIds = (doc['changes'] as Array<{ id: string }>).map((c) => c.id);
+    expect(changeIds).toEqual(['CHANGE-1']);
+    const actIds = (doc['activities'] as Array<{ id: string }>).map((a) => a.id).sort();
+    expect(actIds).toEqual(['ACTIVITY-1', 'ACTIVITY-2']);
+    const r = parseCanonicalFGCA(doc);
+    expect(r.valid).toBe(true);
+  });
+
+  it('returns empty arrays when none of the requested ids exist in canon', () => {
+    const viewDoc = {
+      ...VIEW_DOC,
+      view_config: { goals: { filter: 'ids', ids: ['GOAL-NONEXISTENT-1'] }, factors: { surface: 'derived' }, changes: { surface: 'derived' }, activities: { surface: 'derived' } },
+    };
+    const doc = resolveFGCA(viewDoc, SOURCES);
+    expect((doc['goals'] as unknown[]).length).toBe(0);
+    expect((doc['changes'] as unknown[]).length).toBe(0);
+    expect((doc['factors'] as unknown[]).length).toBe(0);
+  });
+});
+
+// ── resolveFGCA — surface=all ─────────────────────────────────────────────────
+
+describe('resolveFGCA — surface=all', () => {
+  it('factors.surface=all includes every factor even when only some are referenced', () => {
+    const viewDoc = {
+      ...VIEW_DOC,
+      view_config: { goals: { filter: 'ids', ids: ['GOAL-3'] }, factors: { surface: 'all' }, changes: { surface: 'derived' }, activities: { surface: 'derived' } },
+    };
+    const doc = resolveFGCA(viewDoc, SOURCES);
+    // GOAL-3 only references FACTOR-1, but surface=all → both factors
+    expect((doc['factors'] as unknown[]).length).toBe(2);
+  });
+
+  it('changes.surface=all includes every change', () => {
+    const viewDoc = {
+      ...VIEW_DOC,
+      view_config: { goals: { filter: 'ids', ids: ['GOAL-1'] }, factors: { surface: 'derived' }, changes: { surface: 'all' }, activities: { surface: 'derived' } },
+    };
+    const doc = resolveFGCA(viewDoc, SOURCES);
+    expect((doc['changes'] as unknown[]).length).toBe(3);
+  });
+});
+
+// ── resolveFGCA — empty / degenerate inputs ───────────────────────────────────
+
+describe('resolveFGCA — empty sources', () => {
+  it('returns empty arrays when canon has no elements', () => {
+    const doc = resolveFGCA(VIEW_DOC, { elements: [], relations: [] });
+    expect((doc['goals'] as unknown[]).length).toBe(0);
+    expect((doc['factors'] as unknown[]).length).toBe(0);
+    expect((doc['changes'] as unknown[]).length).toBe(0);
+    expect((doc['activities'] as unknown[]).length).toBe(0);
+  });
+
+  it('returns empty arrays for a non-object viewDoc', () => {
+    const doc = resolveFGCA(null, SOURCES);
+    expect((doc['goals'] as unknown[]).length).toBe(0);
+  });
+});
+
+// ── File-based regression — resolver + canon fixture + parseCanonicalFGCA ─────
+
+describe('resolveFGCA — file-based regression against canon fixture', () => {
+  const CANON_ROOT = path.resolve(
+    process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca', 'canon',
+  );
+  const VIEW_DIR = path.join(CANON_ROOT, 'views');
+  const ELEM_DIR = path.join(CANON_ROOT, 'elements');
+
+  function loadYamlsUnder(dir: string): unknown[] {
+    if (!fs.existsSync(dir)) return [];
+    const out: unknown[] = [];
+    function walk(d: string) {
+      for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+        const full = path.join(d, entry.name);
+        if (entry.isDirectory()) { walk(full); }
+        else if (entry.name.endsWith('.yaml')) { out.push(yaml.load(fs.readFileSync(full, 'utf8'))); }
+      }
+    }
+    walk(dir);
+    return out;
+  }
+
+  const viewFiles = fs.existsSync(VIEW_DIR)
+    ? fs.readdirSync(VIEW_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
+    : [];
+
+  for (const file of viewFiles) {
+    it(`resolves ${file} against canon fixtures and passes parseCanonicalFGCA`, () => {
+      const viewDoc = yaml.load(fs.readFileSync(path.join(VIEW_DIR, file), 'utf8'));
+      expect(isFGCAViewDoc(viewDoc)).toBe(true);
+      const elements = loadYamlsUnder(ELEM_DIR);
+      const doc = resolveFGCA(viewDoc, { elements, relations: [] });
+      const r = parseCanonicalFGCA(doc);
+      expect(r.valid).toBe(true);
+      expect(r.errors).toEqual([]);
+    });
+  }
+});