@transitrix/diagrams 1.8.6 → 1.8.8

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

@@ -1,263 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computeGanttLayout, isGanttUnavailable } from '../gantt.js';
-function assertRenders(result) {
-    if (isGanttUnavailable(result)) {
-        throw new Error(`Expected Gantt to render but got unavailable: ${result.reason}`);
-    }
-    return result;
-}
-describe('computeGanttLayout — mode detection', () => {
-    it('returns unavailable when neither project.start_date nor pinned dates exist', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'A', duration: 3 },
-                { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
-            ],
-        };
-        const r = computeGanttLayout(doc);
-        expect(isGanttUnavailable(r)).toBe(true);
-    });
-    it('selects computed mode when project.start_date + every leaf has duration', () => {
-        const doc = {
-            notation: 'activities',
-            project: { start_date: '2026-06-01' },
-            activities: [
-                { id: 'A', name: 'A', duration: 3 },
-                { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.mode).toBe('computed');
-    });
-    it('selects pinned mode when every leaf has start_date + end_date', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'A', start_date: '2026-06-01', end_date: '2026-06-03' },
-                { id: 'B', name: 'B', start_date: '2026-06-04', end_date: '2026-06-06' },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.mode).toBe('pinned');
-    });
-    it('unavailable when only some leaves have pinned dates and no project.start_date', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'A', start_date: '2026-06-01', end_date: '2026-06-03' },
-                { id: 'B', name: 'B', duration: 3 }, // no pinned dates, no project.start_date
-            ],
-        };
-        const r = computeGanttLayout(doc);
-        expect(isGanttUnavailable(r)).toBe(true);
-    });
-    it('unavailable when the document has no activities', () => {
-        const r = computeGanttLayout({ notation: 'activities', activities: [] });
-        expect(isGanttUnavailable(r)).toBe(true);
-    });
-});
-describe('computeGanttLayout — computed mode (CPM + calendar projection)', () => {
-    const doc = {
-        notation: 'activities',
-        project: { start_date: '2026-06-01' }, // Monday
-        activities: [
-            { id: 'A', name: 'A', duration: 3 },
-            { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
-        ],
-    };
-    it('places the first bar at project.start_date and spans its duration', () => {
-        const r = assertRenders(computeGanttLayout(doc));
-        const a = r.bars.find(b => b.id === 'A');
-        expect(a.startDate).toBe('2026-06-01');
-        // 7-day default calendar: day 0 = start_date, last day = 2026-06-03 (start + 2)
-        expect(a.endDate).toBe('2026-06-03');
-    });
-    it('places successor bars after their predecessor finishes', () => {
-        const r = assertRenders(computeGanttLayout(doc));
-        const b = r.bars.find(b => b.id === 'B');
-        // B has ES = EF(A) = 3 working days, so it starts at 2026-06-04
-        expect(b.startDate).toBe('2026-06-04');
-        expect(b.endDate).toBe('2026-06-05');
-    });
-    it('marks critical-path bars on a linear chain', () => {
-        const r = assertRenders(computeGanttLayout(doc));
-        const a = r.bars.find(b => b.id === 'A');
-        const bbar = r.bars.find(b => b.id === 'B');
-        expect(a.isCritical).toBe(true);
-        expect(bbar.isCritical).toBe(true);
-    });
-    it('emits predecessor → successor links with critical flag carried over', () => {
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.links).toHaveLength(1);
-        expect(r.links[0]).toMatchObject({ sourceId: 'A', targetId: 'B', isCritical: true });
-    });
-    it('timeline bounds span min(start) to max(end)', () => {
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.timelineStart).toBe('2026-06-01');
-        expect(r.timelineEnd).toBe('2026-06-05');
-    });
-});
-describe('computeGanttLayout — calendar (working_days, holidays)', () => {
-    it('skips weekend days when working_days excludes them', () => {
-        // 2026-06-01 is a Monday. Duration 7 days, only Mon–Fri working.
-        // Day 0 = Mon 06-01, days 1..4 = Tue-Fri, day 5 = next Mon 06-08, day 6 = Tue 06-09.
-        const doc = {
-            notation: 'activities',
-            project: {
-                start_date: '2026-06-01',
-                calendar: { working_days: ['mon', 'tue', 'wed', 'thu', 'fri'] },
-            },
-            activities: [{ id: 'A', name: 'A', duration: 7 }],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const a = r.bars.find(b => b.id === 'A');
-        expect(a.startDate).toBe('2026-06-01');
-        expect(a.endDate).toBe('2026-06-09');
-    });
-    it('skips dates listed under holidays', () => {
-        // 7-day week, but 2026-06-02 is a holiday → 3-day activity ends on 2026-06-04.
-        const doc = {
-            notation: 'activities',
-            project: {
-                start_date: '2026-06-01',
-                calendar: { holidays: ['2026-06-02'] },
-            },
-            activities: [{ id: 'A', name: 'A', duration: 3 }],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const a = r.bars.find(b => b.id === 'A');
-        expect(a.startDate).toBe('2026-06-01');
-        expect(a.endDate).toBe('2026-06-04');
-    });
-});
-describe('computeGanttLayout — milestones', () => {
-    it('renders zero-duration leaves as milestones with start == end', () => {
-        const doc = {
-            notation: 'activities',
-            project: { start_date: '2026-06-01' },
-            activities: [
-                { id: 'A', name: 'A', duration: 3 },
-                { id: 'M', name: 'Launch', duration: 0, predecessors: ['A'] },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const m = r.bars.find(b => b.id === 'M');
-        expect(m.kind).toBe('milestone');
-        expect(m.startDate).toBe(m.endDate);
-        // M lives at the working day immediately after A finishes (ES = 3).
-        expect(m.startDate).toBe('2026-06-04');
-    });
-    it('pinned mode treats start==end activities as milestones', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'M', name: 'Launch', duration: 0, start_date: '2026-06-15', end_date: '2026-06-15' },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const m = r.bars.find(b => b.id === 'M');
-        expect(m.kind).toBe('milestone');
-    });
-});
-describe('computeGanttLayout — phases (parent activities)', () => {
-    it('rolls up phase span from children', () => {
-        const doc = {
-            notation: 'activities',
-            project: { start_date: '2026-06-01' },
-            activities: [
-                { id: 'PHASE-1', name: 'Design' },
-                { id: 'A', name: 'A', duration: 3, parent: 'PHASE-1' },
-                { id: 'B', name: 'B', duration: 5, parent: 'PHASE-1', predecessors: ['A'] },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const phase = r.bars.find(b => b.id === 'PHASE-1');
-        expect(phase.kind).toBe('phase');
-        expect(phase.startDate).toBe('2026-06-01'); // earliest child = A start
-        expect(phase.endDate).toBe('2026-06-08'); // latest child = B end (ES=3 + 5 days)
-    });
-    it('marks the phase critical if any child is on the critical path', () => {
-        const doc = {
-            notation: 'activities',
-            project: { start_date: '2026-06-01' },
-            activities: [
-                { id: 'PHASE-1', name: 'Design' },
-                { id: 'A', name: 'A', duration: 3, parent: 'PHASE-1' },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        const phase = r.bars.find(b => b.id === 'PHASE-1');
-        expect(phase.isCritical).toBe(true);
-    });
-});
-describe('computeGanttLayout — pinned mode', () => {
-    it('places bars at pinned dates without computing CPM', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'A', start_date: '2026-08-01', end_date: '2026-08-10' },
-                { id: 'B', name: 'B', start_date: '2026-08-12', end_date: '2026-08-20', predecessors: ['A'] },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.mode).toBe('pinned');
-        expect(r.bars.find(b => b.id === 'A')?.startDate).toBe('2026-08-01');
-        expect(r.bars.find(b => b.id === 'A')?.endDate).toBe('2026-08-10');
-        expect(r.bars.find(b => b.id === 'B')?.startDate).toBe('2026-08-12');
-        // Pinned mode does not compute CPM → critical flag is false.
-        expect(r.bars.find(b => b.id === 'A')?.isCritical).toBe(false);
-    });
-    it('still emits links between pinned leaves', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'A', start_date: '2026-08-01', end_date: '2026-08-10' },
-                { id: 'B', name: 'B', start_date: '2026-08-12', end_date: '2026-08-20', predecessors: ['A'] },
-            ],
-        };
-        const r = assertRenders(computeGanttLayout(doc));
-        expect(r.links).toHaveLength(1);
-        expect(r.links[0].sourceId).toBe('A');
-        expect(r.links[0].targetId).toBe('B');
-    });
-});
-describe('computeGanttLayout — project-type activity suppression (regression for follow-up to #421)', () => {
-    // A project-type container activity is classified as a phase and rolls up into
-    // a bar spanning the full timeline. buildActivityViews filters project-type
-    // activities before calling computeGanttLayout so this bar never reaches the
-    // rendered Gantt. These tests confirm: (a) the container bar exists when NOT
-    // filtered, and (b) filtering it out still yields correct leaf/phase bars.
-    const docWithProjectContainer = {
-        notation: 'action',
-        title: 'Platform Launch Action',
-        project: { start_date: '2026-06-01' },
-        activities: [
-            { id: 'PROJ-1', name: 'Platform Launch', activity_type: 'project' },
-            { id: 'TASK-1', name: 'Design', activity_type: 'task', duration: 3, parent: 'PROJ-1' },
-            { id: 'TASK-2', name: 'Implement', activity_type: 'task', duration: 5, parent: 'PROJ-1', predecessors: ['TASK-1'] },
-        ],
-    };
-    it('includes the project container as a phase bar when not pre-filtered', () => {
-        const r = assertRenders(computeGanttLayout(docWithProjectContainer));
-        const projBar = r.bars.find(b => b.id === 'PROJ-1');
-        expect(projBar).toBeDefined();
-        expect(projBar.kind).toBe('phase');
-    });
-    it('still renders leaf tasks correctly when project-type activity is pre-filtered', () => {
-        const filteredDoc = {
-            ...docWithProjectContainer,
-            activities: docWithProjectContainer.activities.filter((a) => a.activity_type?.toLowerCase() !== 'project'),
-        };
-        const r = assertRenders(computeGanttLayout(filteredDoc));
-        // Project container bar must not appear.
-        expect(r.bars.find(b => b.id === 'PROJ-1')).toBeUndefined();
-        // Leaf tasks must still render with correct dates.
-        const t1 = r.bars.find(b => b.id === 'TASK-1');
-        const t2 = r.bars.find(b => b.id === 'TASK-2');
-        expect(t1).toBeDefined();
-        expect(t2).toBeDefined();
-        expect(t1.startDate).toBe('2026-06-01');
-        expect(t2.startDate).toBe('2026-06-04'); // ES = 3 (after TASK-1)
-    });
-});

package/dist/activities/__tests__/layout.test.d.ts

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

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

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutActivities } from '../layout.js';
-const diamondDoc = {
-    notation: 'activities',
-    activities: [
-        { id: 'A', name: 'Start', duration: 3 },
-        { id: 'B', name: 'Left', duration: 5, predecessors: ['A'] },
-        { id: 'C', name: 'Right', duration: 2, predecessors: ['A'] },
-        { id: 'D', name: 'Merge', duration: 4, predecessors: ['B', 'C'] },
-    ],
-};
-describe('layoutActivities', () => {
-    it('returns empty layout for empty activities', () => {
-        const layout = layoutActivities({ notation: 'activities', activities: [] });
-        expect(layout.nodes).toHaveLength(0);
-        expect(layout.edges).toHaveLength(0);
-    });
-    it('assigns each node a unique position', () => {
-        const layout = layoutActivities(diamondDoc);
-        const positions = layout.nodes.map(n => `${n.x},${n.y}`);
-        const unique = new Set(positions);
-        expect(unique.size).toBe(layout.nodes.length);
-    });
-    it('assigns predecessors to strictly lower column indices than successors', () => {
-        const layout = layoutActivities(diamondDoc);
-        const colOf = new Map(layout.nodes.map(n => [n.id, Math.round(n.x / 280)]));
-        // A is in col 0; B and C are in col 1; D is in col 2
-        expect(colOf.get('A')).toBeLessThan(colOf.get('B'));
-        expect(colOf.get('A')).toBeLessThan(colOf.get('C'));
-        expect(colOf.get('B')).toBeLessThan(colOf.get('D'));
-        expect(colOf.get('C')).toBeLessThan(colOf.get('D'));
-    });
-    it('produces edges connecting predecessors to successors', () => {
-        const layout = layoutActivities(diamondDoc);
-        const edgePairs = layout.edges.map(e => `${e.sourceId}->${e.targetId}`);
-        expect(edgePairs).toContain('A->B');
-        expect(edgePairs).toContain('A->C');
-        expect(edgePairs).toContain('B->D');
-        expect(edgePairs).toContain('C->D');
-    });
-    it('marks critical edges correctly', () => {
-        // A(3)→B(5)→D(4): critical path = 3+5+4=12; C(2) has slack
-        const layout = layoutActivities(diamondDoc);
-        const edgeMap = new Map(layout.edges.map(e => [`${e.sourceId}->${e.targetId}`, e.isCritical]));
-        expect(edgeMap.get('A->B')).toBe(true);
-        expect(edgeMap.get('B->D')).toBe(true);
-        expect(edgeMap.get('A->C')).toBe(false);
-        expect(edgeMap.get('C->D')).toBe(false);
-    });
-    it('attaches CPM values to nodes', () => {
-        const layout = layoutActivities(diamondDoc);
-        const nodeA = layout.nodes.find(n => n.id === 'A');
-        expect(nodeA.cpm).toBeDefined();
-        expect(nodeA.cpm.es).toBe(0);
-        expect(nodeA.cpm.ef).toBe(3);
-        expect(nodeA.cpm.isCritical).toBe(true);
-    });
-    it('respects sort field for ordering within a column', () => {
-        const doc = {
-            notation: 'activities',
-            activities: [
-                { id: 'A', name: 'Root', duration: 1 },
-                { id: 'B', name: 'Second', duration: 1, predecessors: ['A'], sort: 20 },
-                { id: 'C', name: 'First', duration: 1, predecessors: ['A'], sort: 10 },
-            ],
-        };
-        const layout = layoutActivities(doc);
-        const col1Nodes = layout.nodes.filter(n => n.id === 'B' || n.id === 'C').sort((a, b) => a.y - b.y);
-        // C (sort=10) should appear above B (sort=20)
-        expect(col1Nodes[0].id).toBe('C');
-        expect(col1Nodes[1].id).toBe('B');
-    });
-    it('computes non-empty bounds for non-empty activities', () => {
-        const layout = layoutActivities(diamondDoc);
-        expect(layout.bounds.width).toBeGreaterThan(0);
-        expect(layout.bounds.height).toBeGreaterThan(0);
-    });
-    // vkgeorgia/strategy#75 — configurable spacing.
-    it('empty options reproduce the default no-arg layout', () => {
-        const a = layoutActivities(diamondDoc);
-        const b = layoutActivities(diamondDoc, {});
-        expect(b.nodes.map(n => `${n.id}:${n.x},${n.y}`)).toEqual(a.nodes.map(n => `${n.id}:${n.x},${n.y}`));
-    });
-    it('larger horizontalGap pushes downstream columns further right', () => {
-        const xOfD = (h) => layoutActivities(diamondDoc, { horizontalGap: h }).nodes.find(n => n.id === 'D').x;
-        expect(xOfD(200)).toBeGreaterThan(xOfD(80));
-    });
-    it('larger verticalGap increases the gap between stacked column nodes', () => {
-        const gapOf = (v) => {
-            const ys = layoutActivities(diamondDoc, { verticalGap: v })
-                .nodes.filter(n => n.id === 'B' || n.id === 'C')
-                .map(n => n.y)
-                .sort((a, b) => a - b);
-            return ys[1] - ys[0];
-        };
-        expect(gapOf(100)).toBeGreaterThan(gapOf(24));
-    });
-});

package/dist/activities/__tests__/validate.test.d.ts

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