@transitrix/diagrams 1.8.6 → 1.8.8

package/dist/activities/__tests__/validate.test.js

@@ -1,397 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import yaml from 'js-yaml';
-import { validateActivities } from '../validate.js';
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'action');
-const minimalValid = {
-    notation: 'action',
-    actions: [
-        { id: 'A-001', name: 'Start', duration: 3 },
-        { id: 'A-002', name: 'End', duration: 2, predecessors: ['A-001'] },
-    ],
-};
-describe('validateActivities', () => {
-    it('ACT-001 — accepts notation: action (canonical)', () => {
-        const r = validateActivities(minimalValid);
-        expect(r.valid).toBe(true);
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
-    });
-    it('ACT-001 — rejects notation: activities (no longer accepted)', () => {
-        const r = validateActivities({
-            notation: 'activities',
-            activities: [
-                { id: 'A-001', name: 'Start', duration: 3 },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-001')).toBe(true);
-    });
-    it('ACT-001 — rejects activities: root key (only actions: accepted)', () => {
-        const r = validateActivities({
-            notation: 'action',
-            activities: [{ id: 'ACTION-001', name: 'Foo', duration: 1 }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-    it('ACT-001 — normalises action_type to activity_type for downstream layout', () => {
-        const input = {
-            notation: 'action',
-            actions: [{ id: 'ACTION-001', name: 'Foo', duration: 1, action_type: 'project' }],
-        };
-        const r = validateActivities(input);
-        expect(r.valid).toBe(true);
-        const entry = input.actions[0];
-        expect(entry['activity_type']).toBe('project');
-    });
-    it('ACT-001 — rejects missing notation', () => {
-        const r = validateActivities({ activities: [] });
-        expect(r.valid).toBe(false);
-        expect(r.errors[0].code).toBe('ACT-001');
-    });
-    it('ACT-001 — rejects wrong notation value', () => {
-        const r = validateActivities({ notation: 'bpmn', activities: [] });
-        expect(r.valid).toBe(false);
-        expect(r.errors[0].code).toBe('ACT-001');
-        expect(r.errors[0].message).toContain('"bpmn"');
-    });
-    it('ACT-002 — rejects activity with missing id', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ name: 'No ID', duration: 1 }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
-    });
-    it('ACT-002 — rejects activity with empty id', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: '  ', name: 'Empty ID', duration: 1 }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
-    });
-    it('ACT-003 — rejects activity with missing name', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', duration: 1 }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-003')).toBe(true);
-    });
-    it('ACT-004 — rejects duplicate ids', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'First', duration: 1 },
-                { id: 'A-001', name: 'Duplicate', duration: 2 },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-004')).toBe(true);
-    });
-    it('ACT-005 — rejects unknown predecessor reference', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['MISSING'] }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-005')).toBe(true);
-    });
-    it('ACT-005 — passes when predecessor exists', () => {
-        const r = validateActivities(minimalValid);
-        expect(r.valid).toBe(true);
-        expect(r.errors.some(e => e.code === 'ACT-005')).toBe(false);
-    });
-    it('ACT-006 — rejects cyclic dependency', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task A', duration: 1, predecessors: ['A-002'] },
-                { id: 'A-002', name: 'Task B', duration: 1, predecessors: ['A-001'] },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-006')).toBe(true);
-    });
-    it('ACT-007 — rejects self-loop', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['A-001'] }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-007')).toBe(true);
-    });
-    it('ACT-008 — rejects end_date before start_date', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task', duration: 5, start_date: '2026-06-10', end_date: '2026-06-01' },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-008')).toBe(true);
-    });
-    it('ACT-008 — accepts end_date equal to start_date', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
-            ],
-        });
-        expect(r.errors.some(e => e.code === 'ACT-008')).toBe(false);
-    });
-    it('ACT-008 — rejects non-ISO start_date format', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task', duration: 5, start_date: 'June 1 2026' },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-008' && /start_date/.test(e.message))).toBe(true);
-    });
-    it('ACT-008 — rejects non-ISO end_date format', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task', duration: 5, end_date: '2026/06/30' },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-008' && /end_date/.test(e.message))).toBe(true);
-    });
-    it('ACT-008 — does not raise the order-compare error when dates are malformed', () => {
-        // If start_date and end_date are both wrongly formatted, the file already
-        // has two ACT-008 format errors — adding a third "end < start" complaint
-        // on top would be misleading because the lexicographic compare is
-        // meaningless on non-ISO strings.
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Task', duration: 5, start_date: 'tomorrow', end_date: 'yesterday' },
-            ],
-        });
-        expect(r.errors.filter(e => e.code === 'ACT-008').length).toBe(2);
-        expect(r.errors.every(e => /must be ISO 8601 YYYY-MM-DD/.test(e.message))).toBe(true);
-    });
-    it('ACT-009 — rejects negative duration', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Task', duration: -1 }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-009')).toBe(true);
-    });
-    it('ACT-009 — accepts zero duration', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Milestone', duration: 0 }],
-        });
-        expect(r.errors.some(e => e.code === 'ACT-009')).toBe(false);
-    });
-    it('ACT-010 — rejects singular "goal:" field', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
-    });
-    it('ACT-010 — rejects singular "predecessor:" field', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'First', duration: 1 },
-                { id: 'A-002', name: 'Task', duration: 1, predecessor: 'A-001' },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
-    });
-    it('ACT-010 — rejects singular "tag:" field', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' }],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
-    });
-    it('ACT-011 — warns when duration is absent', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [{ id: 'A-001', name: 'No duration' }],
-        });
-        expect(r.valid).toBe(true);
-        expect(r.warnings.some(w => w.code === 'ACT-011')).toBe(true);
-    });
-    it('ACT-013 — warns on structurally orphan activity', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-001', name: 'Connected', duration: 1 },
-                { id: 'A-002', name: 'Orphan', duration: 1 },
-                { id: 'A-003', name: 'End', duration: 1, predecessors: ['A-001'] },
-            ],
-        });
-        expect(r.valid).toBe(true);
-        const orphanWarnings = r.warnings.filter(w => w.code === 'ACT-013');
-        expect(orphanWarnings.some(w => w.message.includes('A-002'))).toBe(true);
-    });
-    it('full valid example passes with no errors', () => {
-        const r = validateActivities({
-            notation: 'action',
-            title: 'Test Project',
-            actions: [
-                { id: 'A', name: 'Start', duration: 3 },
-                { id: 'B', name: 'Middle', duration: 5, predecessors: ['A'] },
-                { id: 'C', name: 'End', duration: 2, predecessors: ['B'] },
-            ],
-        });
-        expect(r.valid).toBe(true);
-        expect(r.errors).toHaveLength(0);
-    });
-    // ── Project block + calendar (ACT-014, ACT-015) ───────────────────────────
-    it('ACT-014 — rejects unknown weekday in working_days', () => {
-        const r = validateActivities({
-            ...minimalValid,
-            project: { start_date: '2026-06-01', calendar: { working_days: ['mon', 'funday'] } },
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-014' && /funday/.test(e.message))).toBe(true);
-    });
-    it('ACT-014 — rejects duplicate weekday entries', () => {
-        const r = validateActivities({
-            ...minimalValid,
-            project: { calendar: { working_days: ['mon', 'tue', 'mon'] } },
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-014' && /duplicate/i.test(e.message))).toBe(true);
-    });
-    it('ACT-014 — accepts mixed-case weekday names', () => {
-        const r = validateActivities({
-            ...minimalValid,
-            project: { start_date: '2026-06-01', calendar: { working_days: ['MON', 'Tue', 'wed', 'thu', 'fri'] } },
-        });
-        expect(r.errors.some(e => e.code === 'ACT-014')).toBe(false);
-    });
-    it('ACT-015 — rejects non-ISO holiday date', () => {
-        const r = validateActivities({
-            ...minimalValid,
-            project: { start_date: '2026-06-01', calendar: { holidays: ['2026-07-04', 'July 4 2026'] } },
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-015' && /July 4 2026/.test(e.message))).toBe(true);
-    });
-    it('ACT-015 — accepts an array of ISO dates', () => {
-        const r = validateActivities({
-            ...minimalValid,
-            project: { start_date: '2026-06-01', calendar: { holidays: ['2026-07-04', '2026-12-25'] } },
-        });
-        expect(r.errors.some(e => e.code === 'ACT-015')).toBe(false);
-    });
-    // ── Milestone date equality (ACT-016) ─────────────────────────────────────
-    it('ACT-016 — rejects milestone with mismatched start/end dates', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-02' },
-            ],
-        });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'ACT-016')).toBe(true);
-    });
-    it('ACT-016 — accepts milestone with equal start/end dates', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
-            ],
-        });
-        expect(r.errors.some(e => e.code === 'ACT-016')).toBe(false);
-    });
-    // ── Phase warnings (ACT-017, ACT-018) ─────────────────────────────────────
-    it('ACT-017 — warns when a referenced-as-parent activity carries its own duration', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'PHASE-1', name: 'Design', duration: 5 },
-                { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
-            ],
-        });
-        expect(r.valid).toBe(true);
-        expect(r.warnings.some(w => w.code === 'ACT-017' && /PHASE-1/.test(w.message))).toBe(true);
-    });
-    it('ACT-017 — no warning when phase omits duration/dates and rolls up from children', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'PHASE-1', name: 'Design' },
-                { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
-            ],
-        });
-        expect(r.warnings.some(w => w.code === 'ACT-017')).toBe(false);
-    });
-    it('ACT-018 — warns when an activity with no duration is not referenced as parent', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-1', name: 'Has duration', duration: 3 },
-                { id: 'P-EMPTY', name: 'Looks like phase but no children' },
-            ],
-        });
-        expect(r.warnings.some(w => w.code === 'ACT-018' && /P-EMPTY/.test(w.message))).toBe(true);
-    });
-    it('ACT-018 — no warning when the no-duration activity has at least one child', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'PHASE-1', name: 'Phase' },
-                { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
-            ],
-        });
-        expect(r.warnings.some(w => w.code === 'ACT-018')).toBe(false);
-    });
-    // ── Gantt-renderability notice (ACT-019) ──────────────────────────────────
-    it('ACT-019 — warns when neither project.start_date nor pinned dates exist', () => {
-        const r = validateActivities(minimalValid);
-        expect(r.warnings.some(w => w.code === 'ACT-019')).toBe(true);
-    });
-    it('ACT-019 — no warning when project.start_date is set', () => {
-        const r = validateActivities({ ...minimalValid, project: { start_date: '2026-06-01' } });
-        expect(r.warnings.some(w => w.code === 'ACT-019')).toBe(false);
-    });
-    it('ACT-019 — no warning when every activity has pinned dates', () => {
-        const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'A-1', name: 'A', duration: 3, start_date: '2026-06-01', end_date: '2026-06-04' },
-            ],
-        });
-        expect(r.warnings.some(w => w.code === 'ACT-019')).toBe(false);
-    });
-    it('[blocker] tolerates a null element in actions[] without throwing', () => {
-        // Do NOT spread minimalValid here: validateActivities mutates its input
-        // to normalise raw.activities, so a previously-called test that passed
-        // minimalValid directly would have set minimalValid.activities. Spreading
-        // that mutated object would cause the actions:[null] override to be masked
-        // by the pre-existing activities array.
-        const r = validateActivities({ notation: 'action', actions: [null] });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-});
-describe('action examples (regression)', () => {
-    const files = fs.readdirSync(EXAMPLES_DIR).filter(f => f.endsWith('.yaml'));
-    expect(files.length).toBeGreaterThan(0);
-    for (const file of files) {
-        it(`validates tests/fixtures/notation-corpus/action/${file}`, () => {
-            const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-            const parsed = yaml.load(text);
-            const r = validateActivities(parsed);
-            expect(r.errors).toEqual([]);
-            expect(r.valid).toBe(true);
-        });
-    }
-});

package/dist/activity-card/__tests__/example.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/activity-card/__tests__/example.test.js

@@ -1,73 +0,0 @@
-// Conformance test for the shipped worked example. Exercises the full
-// validate → resolve → layout pipeline against the real co-located example
-// files under `tests/fixtures/notation-corpus/activity-card/`, so the success signal of #134 is
-// pinned and any drift in the example or the resolver is caught by CI.
-import { describe, it, expect } from 'vitest';
-import { readFileSync, readdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import yaml from 'js-yaml';
-import { validateActivityCard } from '../validate.js';
-import { resolveActivityCard } from '../resolver.js';
-import { layoutActivityCard } from '../layout.js';
-const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/action-card');
-const load = (f) => yaml.load(readFileSync(path.join(dir, f), 'utf-8'));
-/** Recursively load every `*.yaml` doc under a canon subtree (mirrors the
- *  extension's element/relation walk). */
-function loadYamlTree(root) {
-    const out = [];
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
-        const full = path.join(root, entry.name);
-        if (entry.isDirectory())
-            out.push(...loadYamlTree(full));
-        else if (entry.name.endsWith('.yaml'))
-            out.push(yaml.load(readFileSync(full, 'utf-8')));
-    }
-    return out;
-}
-describe('activity-card worked example (eu-programme)', () => {
-    it('validates, resolves, and lays out the success-signal card', () => {
-        const card = load('eu-programme.action-card.transitrix.yaml');
-        const elements = loadYamlTree(path.join(dir, 'canon', 'elements'));
-        const relations = loadYamlTree(path.join(dir, 'canon', 'relations'));
-        const v = validateActivityCard(card);
-        expect(v.valid, JSON.stringify(v.errors)).toBe(true);
-        const r = resolveActivityCard(card, { elements, relations });
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-        expect(r.warnings, JSON.stringify(r.warnings)).toHaveLength(0);
-        const c = r.resolved;
-        expect(c.project.name).toBe('EU MDR conformity programme');
-        expect(c.project.valid_from).toBe('2026-04-01');
-        expect(c.project.start_date).toBe('2026-04-15');
-        expect(c.project.end_date).toBe('2027-03-15');
-        expect(c.milestones.map((m) => m.id)).toEqual([
-            'MILESTONE-EU-CONFORMITY-CERT-1',
-            'MILESTONE-EU-MARKET-LAUNCH-1',
-        ]);
-        expect(c.motivation.drivers.map((d) => d.id)).toEqual(['FACTOR-EU-MDR-1']);
-        expect(c.motivation.goals.map((g) => g.id)).toEqual(['GOAL-EU-MARKET-1']);
-        expect(c.motivation.changes.map((x) => x.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
-        expect(c.childActivities).toHaveLength(4);
-        // Project goal text field resolves to the directly-served goal name; the
-        // example links no stakeholders, so the card shows the field empty.
-        expect(c.goalNames).toEqual(['Maintain EU market access under MDR']);
-        expect(c.stakeholders).toEqual([]);
-        const layout = layoutActivityCard(c);
-        expect(layout.bounds.height).toBeGreaterThan(0);
-        // Header
-        expect(layout.titleRow.name).toBe('EU MDR conformity programme');
-        expect(layout.dateFields[0]).toMatchObject({ label: 'Initiation', value: '2026-04-01' });
-        expect(layout.stakeholderRoleSlots).toHaveLength(4);
-        // Description row
-        expect(layout.descriptionRow?.label).toBe('Description');
-        // Chain sections
-        expect(layout.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
-        const driversSection = layout.chainSections.find((s) => s.type === 'drivers');
-        const goalsSection = layout.chainSections.find((s) => s.type === 'goals');
-        expect(driversSection.nodes.map((n) => n.id)).toContain('FACTOR-EU-MDR-1');
-        expect(goalsSection.nodes.map((n) => n.id)).toContain('GOAL-EU-MARKET-1');
-        // Chain edges
-        expect(layout.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'GOAL-EU-MARKET-1' });
-        expect(layout.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });
-    });
-});

package/dist/activity-card/__tests__/layout.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/activity-card/__tests__/layout.test.js

@@ -1,141 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutActivityCard, ARCHIMATE_CLASS } from '../layout.js';
-const RESOLVED = {
-    cardId: 'ACTIVITY_CARD-EU-PROGRAMME-1',
-    cardDescription: 'Summary',
-    project: {
-        id: 'ACTIVITY-EU-PROGRAMME-1',
-        name: 'EU MDR conformity programme',
-        activity_type: 'programme',
-        status: 'in_progress',
-        valid_from: '2026-04-01',
-        start_date: '2026-04-15',
-        end_date: '2027-03-15',
-    },
-    milestones: [
-        { id: 'MILESTONE-CERT-1', name: 'Cert', date: '2027-01-31', deliversChanges: ['CHANGE-EU-COMPLIANCE-1'] },
-    ],
-    motivation: {
-        drivers: [{ id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' }],
-        goals: [{ id: 'GOAL-EU-MARKET-1', name: 'Access EU market', driverIds: ['FACTOR-EU-MDR-1'] }],
-        changes: [{ id: 'CHANGE-EU-COMPLIANCE-1', name: 'Achieve MDR compliance', goalIds: ['GOAL-EU-MARKET-1'] }],
-    },
-    assessments: [
-        { id: 'ASSESSMENT-MDR-1', name: 'NB capacity constrained', driverId: 'FACTOR-EU-MDR-1', observed_at: '2026-03-01' },
-    ],
-    childActivities: [
-        { id: 'ACTIVITY-EU-CHILD-1', name: 'Notified-body engagement', start_date: '2026-05-01', end_date: '2026-12-01', owner: 'UNIT-REGULATORY' },
-    ],
-    goalNames: ['Access EU market'],
-    stakeholders: [
-        { id: 'STAKEHOLDER-OPS-1', name: 'Operations', role: 'owner' },
-        { id: 'STAKEHOLDER-CEO-1', name: 'CEO', role: 'sponsor' },
-    ],
-    notes: 'Pre-audit scheduled for October 2026.',
-};
-describe('layoutActivityCard', () => {
-    it('produces positive bounds', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.bounds.width).toBeGreaterThan(0);
-        expect(l.bounds.height).toBeGreaterThan(0);
-    });
-    it('title row carries the project name', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.titleRow.name).toBe('EU MDR conformity programme');
-    });
-    it('renders activity type and status badges when present', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.activityTypeBadge?.label).toBe('programme');
-        expect(l.statusBadge?.label).toBe('in progress');
-    });
-    it('badges are absent when project fields are unset', () => {
-        const l = layoutActivityCard({ ...RESOLVED, project: { id: 'A', name: 'n' } });
-        expect(l.activityTypeBadge).toBeUndefined();
-        expect(l.statusBadge).toBeUndefined();
-    });
-    it('three date fields with correct labels and values', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.dateFields).toHaveLength(3);
-        expect(l.dateFields[0]).toMatchObject({ label: 'Initiation', value: '2026-04-01' });
-        expect(l.dateFields[1]).toMatchObject({ label: 'Planned start', value: '2026-04-15' });
-        expect(l.dateFields[2]).toMatchObject({ label: 'Planned end', value: '2027-03-15' });
-    });
-    it('renders "—" for absent dates', () => {
-        const l = layoutActivityCard({ ...RESOLVED, project: { id: 'A', name: 'n' } });
-        expect(l.dateFields.map((d) => d.value)).toEqual(['—', '—', '—']);
-    });
-    it('four stakeholder role slots always rendered', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.stakeholderRoleSlots).toHaveLength(4);
-        expect(l.stakeholderRoleSlots.map((s) => s.role)).toEqual(['Initiator', 'Owner', 'Sponsor', 'PM']);
-        expect(l.stakeholderRoleSlots[0].name).toBe('—'); // no initiator
-        expect(l.stakeholderRoleSlots[1].name).toBe('Operations'); // owner
-        expect(l.stakeholderRoleSlots[2].name).toBe('CEO'); // sponsor
-        expect(l.stakeholderRoleSlots[3].name).toBe('—'); // no PM
-    });
-    it('description row present when cardDescription is set', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.descriptionRow?.label).toBe('Description');
-        expect(l.descriptionRow?.valueLines.join(' ')).toContain('Summary');
-    });
-    it('description row absent when cardDescription is empty', () => {
-        const l = layoutActivityCard({ ...RESOLVED, cardDescription: undefined });
-        expect(l.descriptionRow).toBeUndefined();
-    });
-    it('three chain sections in order: drivers, goals, changes', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
-    });
-    it('chain sections carry the resolved nodes', () => {
-        const l = layoutActivityCard(RESOLVED);
-        const drivers = l.chainSections.find((s) => s.type === 'drivers');
-        const goals = l.chainSections.find((s) => s.type === 'goals');
-        const changes = l.chainSections.find((s) => s.type === 'changes');
-        expect(drivers.nodes.map((n) => n.id)).toEqual(['FACTOR-EU-MDR-1']);
-        expect(goals.nodes.map((n) => n.id)).toEqual(['GOAL-EU-MARKET-1']);
-        expect(changes.nodes.map((n) => n.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
-    });
-    it('empty chain sections have isEmpty=true', () => {
-        const l = layoutActivityCard({
-            ...RESOLVED,
-            motivation: { drivers: [], goals: [], changes: [] },
-            assessments: [],
-        });
-        expect(l.chainSections.every((s) => s.isEmpty)).toBe(true);
-    });
-    it('builds driver→goal and goal→change edges', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'GOAL-EU-MARKET-1' });
-        expect(l.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });
-    });
-    it('milestone ArchiMate class is set', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.milestones).toHaveLength(1);
-        expect(l.milestones[0].archimateClass).toBe(ARCHIMATE_CLASS.MILESTONE);
-    });
-    it('child activity ArchiMate class is set', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.childActivities[0].archimateClass).toBe(ARCHIMATE_CLASS.ACTIVITY);
-    });
-    it('footer row present when notes is set', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.footerRow?.label).toBe('Notes');
-        expect(l.footerRow?.valueLines.join(' ')).toContain('Pre-audit');
-    });
-    it('footer row absent when notes is empty', () => {
-        const l = layoutActivityCard({ ...RESOLVED, notes: undefined });
-        expect(l.footerRow).toBeUndefined();
-    });
-    it('handles an empty card without throwing', () => {
-        const l = layoutActivityCard({
-            cardId: 'ACTIVITY_CARD-X-1',
-            project: { id: 'ACTIVITY-X-1', name: 'Empty' },
-            milestones: [],
-            motivation: { drivers: [], goals: [], changes: [] },
-            assessments: [],
-            childActivities: [],
-        });
-        expect(l.milestones).toHaveLength(0);
-        expect(l.bounds.height).toBeGreaterThan(0);
-    });
-});

package/dist/activity-card/__tests__/resolver.test.d.ts

@@ -1 +0,0 @@
-export {};