@transitrix/diagrams 1.8.6 → 1.8.8

package/dist/fgca/__tests__/resolver.test.js

@@ -1,185 +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 { 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: 'dgca',
-    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: 'dgca', 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'].length).toBe(3);
-        expect(doc['changes'].length).toBe(3);
-        expect(doc['actions'].length).toBe(5);
-    });
-    it('derives factors from all goal.factors[] refs', () => {
-        const doc = resolveFGCA(VIEW_DOC, SOURCES);
-        const factorIds = doc['factors'].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('dgca');
-        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'].map((g) => g.id);
-        expect(goalIds).toEqual(['GOAL-1']);
-        const changeIds = doc['changes'].map((c) => c.id);
-        expect(changeIds).toEqual(['CHANGE-1']);
-        const actIds = doc['actions'].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'].length).toBe(0);
-        expect(doc['changes'].length).toBe(0);
-        expect(doc['factors'].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'].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'].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'].length).toBe(0);
-        expect(doc['factors'].length).toBe(0);
-        expect(doc['changes'].length).toBe(0);
-        expect(doc['actions'].length).toBe(0);
-    });
-    it('returns empty arrays for a non-object viewDoc', () => {
-        const doc = resolveFGCA(null, SOURCES);
-        expect(doc['goals'].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', 'dgca', 'canon');
-    const VIEW_DIR = path.join(CANON_ROOT, 'views');
-    const ELEM_DIR = path.join(CANON_ROOT, 'elements');
-    function loadYamlsUnder(dir) {
-        if (!fs.existsSync(dir))
-            return [];
-        const out = [];
-        function walk(d) {
-            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([]);
-        });
-    }
-});

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

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

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

@@ -1,125 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateFGCADoc } from '../validate.js';
-const VALID_DOC = {
-    notation: 'dgca',
-    factors: [{ id: 1, name: 'Market pressure' }],
-    goals: [{ id: 1, name: 'Grow revenue', factor: [{ id: 1 }] }],
-    changes: [{ id: 1, name: 'Launch product', goal_id: 1, activity_ids: [1] }],
-    actions: [{ id: 1, name: 'Market research', goal_id: 1 }],
-};
-describe('validateFGCADoc', () => {
-    it('accepts a valid document', () => {
-        const result = validateFGCADoc(VALID_DOC);
-        expect(result.valid).toBe(true);
-        expect(result.errors).toHaveLength(0);
-    });
-    it('rejects non-object input', () => {
-        expect(validateFGCADoc('string').valid).toBe(false);
-        expect(validateFGCADoc(null).valid).toBe(false);
-        expect(validateFGCADoc(42).valid).toBe(false);
-    });
-    it('errors on missing notation field', () => {
-        const { notation: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc(without);
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].code).toBe('MISSING_NOTATION');
-    });
-    it('errors on wrong notation value', () => {
-        const result = validateFGCADoc({ ...VALID_DOC, notation: 'goals' });
-        expect(result.valid).toBe(false);
-        expect(result.errors[0].code).toBe('WRONG_NOTATION');
-    });
-    it('errors when factors array is missing', () => {
-        const { factors: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'dgca' });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.path === 'factors')).toBe(true);
-    });
-    it('errors when goals array is missing', () => {
-        const { goals: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'dgca' });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.path === 'goals')).toBe(true);
-    });
-    it('errors when changes array is missing', () => {
-        const { changes: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'dgca' });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.path === 'changes')).toBe(true);
-    });
-    it('errors when actions array is missing', () => {
-        const { actions: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'dgca' });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.path === 'actions')).toBe(true);
-    });
-    it('errors on empty factor name', () => {
-        const result = validateFGCADoc({ ...VALID_DOC, factors: [{ id: 1, name: '' }] });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.code === 'EMPTY_NAME')).toBe(true);
-    });
-    it('errors on empty goal name', () => {
-        const result = validateFGCADoc({ ...VALID_DOC, goals: [{ id: 1, name: '  ', factor: [] }] });
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.code === 'EMPTY_NAME')).toBe(true);
-    });
-    it('warns on broken factor reference in goal', () => {
-        const result = validateFGCADoc({
-            ...VALID_DOC,
-            goals: [{ id: 1, name: 'Goal', factor: [{ id: 99 }] }],
-        });
-        expect(result.valid).toBe(true);
-        expect(result.warnings.some(w => w.code === 'BROKEN_REF' && w.message.includes('factor 99'))).toBe(true);
-    });
-    it('warns on broken goal reference in change', () => {
-        const result = validateFGCADoc({
-            ...VALID_DOC,
-            changes: [{ id: 1, name: 'Change', goal_id: 99, activity_ids: [] }],
-        });
-        expect(result.valid).toBe(true);
-        expect(result.warnings.some(w => w.code === 'BROKEN_REF' && w.message.includes('goal 99'))).toBe(true);
-    });
-    it('warns on broken activity reference in change', () => {
-        const result = validateFGCADoc({
-            ...VALID_DOC,
-            changes: [{ id: 1, name: 'Change', goal_id: 1, activity_ids: [99] }],
-        });
-        expect(result.valid).toBe(true);
-        expect(result.warnings.some(w => w.code === 'BROKEN_REF' && w.message.includes('activity 99'))).toBe(true);
-    });
-    it('accepts a document with empty arrays', () => {
-        const result = validateFGCADoc({
-            notation: 'dgca',
-            factors: [],
-            goals: [],
-            changes: [],
-            actions: [],
-        });
-        expect(result.valid).toBe(true);
-    });
-    it('accepts optional spec_version field', () => {
-        const result = validateFGCADoc({ ...VALID_DOC, spec_version: '0.1' });
-        expect(result.valid).toBe(true);
-    });
-    // Pre-release blocker regression (orchestrator review 2026-05-21).
-    it('[blocker] tolerates a null element in goals[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, goals: [null] });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-    it('[blocker] tolerates a string element in factors[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, factors: ['x'] });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-    it('[blocker] tolerates a null element in changes[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, changes: [null] });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-    it('[blocker] tolerates a null element in actions[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, actions: [null] });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-    });
-});

package/dist/goals/__tests__/GoalTreeView.test.d.ts

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

package/dist/goals/__tests__/GoalTreeView.test.js

@@ -1,337 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MockResizeObserver_callback;
-import { jsx as _jsx } from "react/jsx-runtime";
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, cleanup, waitFor } from '@testing-library/react';
-import { GoalTreeView, computeDragOutcome } from '../GoalTreeView.js';
-// jsdom has no ResizeObserver / layout engine. reactflow keeps a node's DOM
-// wrapper `visibility: hidden` and excludes it from drag/intersection logic
-// until it has been "measured" via ResizeObserver — so the mock must
-// actually invoke its callback (with the mocked getBoundingClientRect below)
-// for nodes to become interactive, not just satisfy the constructor call.
-class MockResizeObserver {
-    constructor(callback) {
-        _MockResizeObserver_callback.set(this, void 0);
-        __classPrivateFieldSet(this, _MockResizeObserver_callback, callback, "f");
-    }
-    observe(target) {
-        queueMicrotask(() => {
-            const rect = target.getBoundingClientRect();
-            __classPrivateFieldGet(this, _MockResizeObserver_callback, "f").call(this, [{ target, contentRect: rect }], this);
-        });
-    }
-    unobserve() { }
-    disconnect() { }
-}
-_MockResizeObserver_callback = new WeakMap();
-// jsdom also has no DOMMatrixReadOnly, which reactflow's dimension-tracking
-// uses to read the translateX/Y out of a node's computed transform. Only
-// translate() (no scale/rotate) ever appears in this component's own CSS, so
-// a minimal shim covering that one case is enough.
-class MockDOMMatrixReadOnly {
-    constructor(transform) {
-        this.m41 = 0;
-        this.m42 = 0;
-        if (!transform || transform === 'none')
-            return;
-        const t = /translate\((-?[\d.]+)px,\s*(-?[\d.]+)px\)/.exec(transform);
-        if (t) {
-            this.m41 = Number(t[1]);
-            this.m42 = Number(t[2]);
-            return;
-        }
-        const m = /matrix\(([^)]+)\)/.exec(transform);
-        if (m) {
-            const parts = m[1].split(',').map((p) => Number(p.trim()));
-            this.m41 = parts[4] ?? 0;
-            this.m42 = parts[5] ?? 0;
-        }
-    }
-}
-function makeTree() {
-    return {
-        goal_types: [
-            { name: 'Strategy', level: 0 },
-            { name: 'Business Goal', level: 1 },
-        ],
-        goals: [
-            { id: 1, name: 'Triple revenue', type: 'Strategy', level: 0, parent_id: 0 },
-            { id: 2, name: 'Launch in EU', type: 'Business Goal', level: 1, parent_id: 1 },
-            {
-                id: 3,
-                name: 'Cut churn',
-                type: 'Business Goal',
-                level: 1,
-                parent_id: 1,
-                factors: [
-                    { id: 10, name: 'Support backlog', impact_type: 'risk' },
-                    { id: 11, name: 'New pricing', impact_type: 'opportunity' },
-                ],
-            },
-        ],
-    };
-}
-beforeEach(() => {
-    global.ResizeObserver = MockResizeObserver;
-    window.DOMMatrixReadOnly = MockDOMMatrixReadOnly;
-    vi.spyOn(Element.prototype, 'getBoundingClientRect').mockImplementation(function () {
-        // Individual goal cards report their real 250x80 footprint (matters for
-        // reactflow's own drag/measurement bookkeeping); the flow container and
-        // everything else gets a generously large rect so viewport fitting has
-        // room to work with.
-        const isNode = this.classList?.contains('react-flow__node');
-        const width = isNode ? 250 : 1000;
-        const height = isNode ? 80 : 800;
-        return {
-            width, height, top: 0, left: 0, right: width, bottom: height, x: 0, y: 0,
-            toJSON() { return this; },
-        };
-    });
-});
-afterEach(() => {
-    cleanup();
-    vi.restoreAllMocks();
-});
-describe('GoalTreeView', () => {
-    it('renders without crashing and shows every canvas goal', async () => {
-        render(_jsx(GoalTreeView, { tree: makeTree() }));
-        await waitFor(() => {
-            expect(screen.getByText('Triple revenue')).toBeTruthy();
-            expect(screen.getByText('Launch in EU')).toBeTruthy();
-            expect(screen.getByText('Cut churn')).toBeTruthy();
-        });
-    });
-    it('renders factor indicators from goal.factors', async () => {
-        render(_jsx(GoalTreeView, { tree: makeTree() }));
-        await waitFor(() => {
-            expect(screen.getByText('Triple revenue')).toBeTruthy();
-        });
-        // One up-caret (opportunity) and one down-caret (risk) on "Cut churn".
-        expect(screen.getByLabelText('1 positive factor')).toBeTruthy();
-        expect(screen.getByLabelText('1 negative factor')).toBeTruthy();
-    });
-    it('puts a goal with a broken parent_id in the backlog, not on canvas', async () => {
-        const tree = {
-            goal_types: [
-                { name: 'Strategy', level: 0 },
-                { name: 'Business Goal', level: 1 },
-            ],
-            goals: [
-                { id: 1, name: 'Root goal', type: 'Strategy', level: 0, parent_id: 0 },
-                // level 1 + a parent_id that resolves to nothing — not a root by
-                // either "Roots: level === 0 || parent_id === 0" clause, and
-                // unreachable from goal 1 — must land in the backlog.
-                { id: 2, name: 'Orphaned goal', type: 'Business Goal', level: 1, parent_id: 999 },
-            ],
-        };
-        render(_jsx(GoalTreeView, { tree: tree, showBacklog: true }));
-        await waitFor(() => {
-            expect(screen.getByText('Root goal')).toBeTruthy();
-        });
-        expect(screen.getByText('Orphaned goal')).toBeTruthy();
-        expect(screen.queryByText('Backlog')).toBeTruthy();
-    });
-    it('does not render add/delete affordances when readOnly', async () => {
-        render(_jsx(GoalTreeView, { tree: makeTree(), readOnly: true }));
-        await waitFor(() => {
-            expect(screen.getByText('Triple revenue')).toBeTruthy();
-        });
-        expect(screen.queryByLabelText('Add child goal')).toBeNull();
-        expect(screen.queryByLabelText('Delete goal')).toBeNull();
-    });
-    it('fires onChange with kind "addChild" when the add-child button is clicked', async () => {
-        const onChange = vi.fn();
-        render(_jsx(GoalTreeView, { tree: makeTree(), onChange: onChange }));
-        await waitFor(() => {
-            expect(screen.getByText('Triple revenue')).toBeTruthy();
-        });
-        // Target the root (id 1, level 0) specifically — makeTree()'s goal_types
-        // only go up to level 1, so clicking "add child" on an existing level-1
-        // goal would be correctly refused (would exceed max level) and never
-        // fire onChange at all.
-        const rootNode = document.querySelector('.react-flow__node[data-id="1"]');
-        const addButton = rootNode.querySelector('[aria-label="Add child goal"]');
-        addButton.dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
-        const event = onChange.mock.calls[0][0];
-        expect(event.kind).toBe('addChild');
-        if (event.kind === 'addChild') {
-            expect(event.result.goals.length).toBe(4);
-        }
-    });
-    it('fires onChange with kind "delete" when the delete button is clicked', async () => {
-        const onChange = vi.fn();
-        render(_jsx(GoalTreeView, { tree: makeTree(), onChange: onChange }));
-        await waitFor(() => {
-            expect(screen.getByText('Cut churn')).toBeTruthy();
-        });
-        const deleteButtons = screen.getAllByLabelText('Delete goal');
-        deleteButtons[deleteButtons.length - 1].dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
-        const event = onChange.mock.calls[0][0];
-        expect(event.kind).toBe('delete');
-    });
-    it('fires onChange with kind "restoreFromBacklog" when a backlog card is dropped onto a canvas card', async () => {
-        const tree = {
-            goal_types: [
-                { name: 'Strategy', level: 0 },
-                { name: 'Business Goal', level: 1 },
-            ],
-            goals: [
-                { id: 1, name: 'Root goal', type: 'Strategy', level: 0, parent_id: 0 },
-                { id: 2, name: 'Orphaned goal', type: 'Business Goal', level: 1, parent_id: 999 },
-            ],
-        };
-        const onChange = vi.fn();
-        render(_jsx(GoalTreeView, { tree: tree, onChange: onChange, showBacklog: true }));
-        await waitFor(() => {
-            expect(screen.getByText('Orphaned goal')).toBeTruthy();
-        });
-        // jsdom has no native DataTransfer; stub the minimal setData/getData
-        // surface this component's native (non-reactflow) HTML5 drag path uses
-        // and attach it directly to the dispatched events.
-        const store = new Map();
-        const dataTransfer = {
-            setData: (k, v) => store.set(k, v),
-            getData: (k) => store.get(k) ?? '',
-            effectAllowed: 'move',
-        };
-        function fireDnd(el, type, coords) {
-            const event = new Event(type, { bubbles: true, cancelable: true });
-            Object.defineProperty(event, 'dataTransfer', { value: dataTransfer });
-            Object.assign(event, coords);
-            el.dispatchEvent(event);
-        }
-        const backlogItem = screen.getByText('Orphaned goal').closest('div[draggable]');
-        const rootNode = document.querySelector('.react-flow__node[data-id="1"]');
-        // jsdom doesn't implement elementFromPoint at all (not just "returns null").
-        document.elementFromPoint = vi.fn().mockReturnValue(rootNode);
-        fireDnd(backlogItem, 'dragstart', { clientX: 0, clientY: 0 });
-        fireDnd(rootNode, 'drop', { clientX: 10, clientY: 10 });
-        await waitFor(() => expect(onChange).toHaveBeenCalledTimes(1));
-        const event = onChange.mock.calls[0][0];
-        expect(event.kind).toBe('restoreFromBacklog');
-        if (event.kind === 'restoreFromBacklog') {
-            expect(event.id).toBe(2);
-            expect(event.newParentId).toBe(1);
-            expect(event.result.goals.find((g) => g.id === 2)?.parent_id).toBe(1);
-        }
-    });
-    // Dragging a card is choreographed by reactflow's own pointer/DOM-measurement
-    // machinery (ResizeObserver-gated node "readiness", d3-drag pointer capture,
-    // viewport transform math) — faithfully simulating that in jsdom means
-    // re-implementing reactflow's internals rather than testing this component.
-    // computeDragOutcome() is the pure decision GoalTreeView's onNodeDragStop
-    // calls once reactflow reports a drag: given where a card was dropped, which
-    // mutation fires and what onChange payload it produces. Testing it directly
-    // covers the actual reparent/moveToBacklog logic without that DOM coupling.
-    describe('computeDragOutcome (reparent / moveToBacklog decision logic)', () => {
-        const tree = {
-            goal_types: [
-                { name: 'Strategy', level: 0 },
-                { name: 'Business Goal', level: 1 },
-            ],
-            goals: [
-                { id: 1, name: 'Goal A', type: 'Strategy', level: 0, parent_id: 0 },
-                { id: 2, name: 'Goal C', type: 'Strategy', level: 0, parent_id: 0 },
-                { id: 3, name: 'Goal B', type: 'Business Goal', level: 1, parent_id: 1 },
-            ],
-        };
-        it('fires a "reparent" change when dropped onto another card', () => {
-            const change = computeDragOutcome(tree, 3, { kind: 'node', id: 2 });
-            expect(change?.kind).toBe('reparent');
-            if (change?.kind === 'reparent') {
-                expect(change.sourceId).toBe(3);
-                expect(change.targetId).toBe(2);
-                expect(change.result.goals.find((g) => g.id === 3)?.parent_id).toBe(2);
-            }
-        });
-        it('fires a "moveToBacklog" change when dropped on the backlog zone', () => {
-            const change = computeDragOutcome(tree, 3, { kind: 'backlog' });
-            expect(change?.kind).toBe('moveToBacklog');
-            if (change?.kind === 'moveToBacklog') {
-                expect(change.id).toBe(3);
-                expect(change.result.goals.find((g) => g.id === 3)?.parent_id).toBe(0);
-            }
-        });
-        it('is a no-op when dropped nowhere in particular', () => {
-            expect(computeDragOutcome(tree, 3, null)).toBeNull();
-        });
-        it('is a no-op when dropped on itself', () => {
-            expect(computeDragOutcome(tree, 3, { kind: 'node', id: 3 })).toBeNull();
-        });
-        it('is a no-op when the reparent would exceed the schema max level', () => {
-            // Goal 3 is already level 1 (max); reparenting it under itself-sibling
-            // level-1 goal would push it to level 2.
-            const deeper = {
-                ...tree,
-                goals: [...tree.goals, { id: 4, name: 'Goal D', type: 'Business Goal', level: 1, parent_id: 1 }],
-            };
-            expect(computeDragOutcome(deeper, 3, { kind: 'node', id: 4 })).toBeNull();
-        });
-    });
-    it('fires onFactorClick with the clicked factor when a popover item is clicked', async () => {
-        const onFactorClick = vi.fn();
-        render(_jsx(GoalTreeView, { tree: makeTree(), onFactorClick: onFactorClick }));
-        await waitFor(() => {
-            expect(screen.getByText('Cut churn')).toBeTruthy();
-        });
-        // Open the negative-factor panel on "Cut churn" (id=3, has risk factor "Support backlog")
-        const negativeBadge = screen.getByLabelText('1 negative factor');
-        negativeBadge.dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        // The popover item for the risk factor should now be in the DOM
-        const factorItem = await waitFor(() => screen.getByText('Support backlog'));
-        factorItem.dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        await waitFor(() => expect(onFactorClick).toHaveBeenCalledTimes(1));
-        expect(onFactorClick.mock.calls[0][0]).toMatchObject({ id: 10, name: 'Support backlog', impact_type: 'risk' });
-    });
-    it('backlog panel is collapsible — toggle hides and restores content', async () => {
-        const tree = {
-            goal_types: [
-                { name: 'Strategy', level: 0 },
-                { name: 'Business Goal', level: 1 },
-            ],
-            goals: [
-                { id: 1, name: 'Root goal', type: 'Strategy', level: 0, parent_id: 0 },
-                { id: 2, name: 'Orphaned goal', type: 'Business Goal', level: 1, parent_id: 999 },
-            ],
-        };
-        render(_jsx(GoalTreeView, { tree: tree, showBacklog: true }));
-        await waitFor(() => {
-            expect(screen.getByText('Backlog')).toBeTruthy();
-        });
-        // Collapse
-        screen.getByLabelText('Collapse backlog').dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        await waitFor(() => {
-            expect(screen.queryByText('Backlog')).toBeNull();
-        });
-        // Expand again
-        screen.getByLabelText('Expand backlog').dispatchEvent(new MouseEvent('click', { bubbles: true }));
-        await waitFor(() => {
-            expect(screen.getByText('Backlog')).toBeTruthy();
-        });
-    });
-    it('fires onEditRequest on double-click', async () => {
-        const onEditRequest = vi.fn();
-        render(_jsx(GoalTreeView, { tree: makeTree(), onEditRequest: onEditRequest }));
-        await waitFor(() => {
-            expect(screen.getByText('Triple revenue')).toBeTruthy();
-        });
-        const nodeEl = document.querySelector('.react-flow__node[data-id="1"]');
-        expect(nodeEl).toBeTruthy();
-        nodeEl.dispatchEvent(new MouseEvent('dblclick', { bubbles: true }));
-        await waitFor(() => expect(onEditRequest).toHaveBeenCalledTimes(1));
-        expect(onEditRequest.mock.calls[0][0]).toMatchObject({ id: 1, name: 'Triple revenue' });
-    });
-});

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

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