@transitrix/diagrams 1.8.6 → 1.8.8

package/src/goals/__tests__/GoalTreeView.test.tsx

@@ -1,361 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import React from 'react';
-import { render, screen, cleanup, waitFor } from '@testing-library/react';
-import { GoalTreeView, computeDragOutcome } from '../GoalTreeView.js';
-import type { GoalTree } from '../types.js';
-import type { GoalTreeChange } 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 {
-  #callback: ResizeObserverCallback;
-  constructor(callback: ResizeObserverCallback) {
-    this.#callback = callback;
-  }
-  observe(target: Element) {
-    queueMicrotask(() => {
-      const rect = target.getBoundingClientRect();
-      this.#callback(
-        [{ target, contentRect: rect } as ResizeObserverEntry],
-        this as unknown as ResizeObserver,
-      );
-    });
-  }
-  unobserve() {}
-  disconnect() {}
-}
-
-// 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 {
-  m41 = 0;
-  m42 = 0;
-  constructor(transform?: string) {
-    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(): GoalTree {
-  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 as unknown as { ResizeObserver: unknown }).ResizeObserver = MockResizeObserver;
-  (window as unknown as { DOMMatrixReadOnly: unknown }).DOMMatrixReadOnly = MockDOMMatrixReadOnly;
-  vi.spyOn(Element.prototype, 'getBoundingClientRect').mockImplementation(function (this: Element) {
-    // 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; },
-    } as DOMRect;
-  });
-});
-
-afterEach(() => {
-  cleanup();
-  vi.restoreAllMocks();
-});
-
-describe('GoalTreeView', () => {
-  it('renders without crashing and shows every canvas goal', async () => {
-    render(<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(<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: GoalTree = {
-      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(<GoalTreeView tree={tree} showBacklog />);
-    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(<GoalTreeView tree={makeTree()} readOnly />);
-    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<(e: GoalTreeChange) => void>();
-    render(<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<(e: GoalTreeChange) => void>();
-    render(<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: GoalTree = {
-      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<(e: GoalTreeChange) => void>();
-    render(<GoalTreeView tree={tree} onChange={onChange} showBacklog />);
-    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<string, string>();
-    const dataTransfer = {
-      setData: (k: string, v: string) => store.set(k, v),
-      getData: (k: string) => store.get(k) ?? '',
-      effectAllowed: 'move',
-    };
-    function fireDnd(el: Element, type: string, coords: { clientX: number; clientY: number }) {
-      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: GoalTree = {
-      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: GoalTree = {
-        ...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(<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: GoalTree = {
-      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(<GoalTreeView tree={tree} showBacklog />);
-    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(<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/src/goals/__tests__/layout.test.ts

@@ -1,175 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutGoalTree } from '../layout.js';
-import type { GoalTree } from '../types.js';
-
-const TREE: GoalTree = {
-  goal_types: [
-    { name: 'Strategy', level: 0 },
-    { name: 'Business Goal', level: 1 },
-    { name: 'Project', level: 2 },
-  ],
-  goals: [
-    { id: 1, name: 'North Star', type: 'Strategy', level: 0, parent_id: 0 },
-    { id: 2, name: 'EU Expansion', type: 'Business Goal', level: 1, parent_id: 1 },
-    { id: 3, name: 'Berlin Office', type: 'Project', level: 2, parent_id: 2 },
-    { id: 4, name: 'London Office', type: 'Project', level: 2, parent_id: 2 },
-  ],
-};
-
-describe('layoutGoalTree', () => {
-  it('returns nodes for all goals', () => {
-    const layout = layoutGoalTree(TREE);
-    expect(layout.nodes).toHaveLength(4);
-  });
-
-  it('returns edges for parent-child pairs', () => {
-    const layout = layoutGoalTree(TREE);
-    expect(layout.edges).toHaveLength(3); // 1→2, 2→3, 2→4
-  });
-
-  it('levels map to increasing x positions', () => {
-    const layout = layoutGoalTree(TREE);
-    const byId = new Map(layout.nodes.map(n => [n.id, n]));
-    expect(byId.get(1)!.x).toBeLessThan(byId.get(2)!.x);
-    expect(byId.get(2)!.x).toBeLessThan(byId.get(3)!.x);
-  });
-
-  it('siblings at same level have different y positions', () => {
-    const layout = layoutGoalTree(TREE);
-    const byId = new Map(layout.nodes.map(n => [n.id, n]));
-    expect(byId.get(3)!.y).not.toBe(byId.get(4)!.y);
-  });
-
-  it('returns non-zero bounds for non-empty tree', () => {
-    const layout = layoutGoalTree(TREE);
-    expect(layout.bounds.width).toBeGreaterThan(0);
-    expect(layout.bounds.height).toBeGreaterThan(0);
-  });
-
-  it('returns empty layout for empty goals', () => {
-    const layout = layoutGoalTree({ goal_types: [], goals: [] });
-    expect(layout.nodes).toHaveLength(0);
-    expect(layout.edges).toHaveLength(0);
-  });
-
-  it('nodes have default 250×80 size', () => {
-    const layout = layoutGoalTree(TREE);
-    expect(layout.nodes[0].width).toBe(250);
-    expect(layout.nodes[0].height).toBe(80);
-  });
-
-  it('respects custom nodeWidth/nodeHeight', () => {
-    const layout = layoutGoalTree(TREE, { nodeWidth: 200, nodeHeight: 60 });
-    expect(layout.nodes[0].width).toBe(200);
-    expect(layout.nodes[0].height).toBe(60);
-  });
-
-  // vkgeorgia/strategy#75 — configurable spacing. The preview maps
-  // horizontalGap → rankSep and verticalGap → nodeSep.
-  it('larger rankSep widens the column step', () => {
-    const tight = layoutGoalTree(TREE, { rankSep: 80 });
-    const wide = layoutGoalTree(TREE, { rankSep: 200 });
-    const stepOf = (l: ReturnType<typeof layoutGoalTree>) => {
-      const byId = new Map(l.nodes.map(n => [n.id, n]));
-      return byId.get(2)!.x - byId.get(1)!.x;
-    };
-    expect(stepOf(wide)).toBeGreaterThan(stepOf(tight));
-  });
-
-  it('larger nodeSep increases the gap between stacked siblings', () => {
-    const gapOf = (sep: number) => {
-      const l = layoutGoalTree(TREE, { nodeSep: sep });
-      const byId = new Map(l.nodes.map(n => [n.id, n]));
-      return Math.abs(byId.get(4)!.y - byId.get(3)!.y);
-    };
-    expect(gapOf(120)).toBeGreaterThan(gapOf(24));
-  });
-
-  it('each node carries original goal data', () => {
-    const layout = layoutGoalTree(TREE);
-    const node1 = layout.nodes.find(n => n.id === 1)!;
-    expect(node1.data.name).toBe('North Star');
-  });
-
-  it('viewDepth hides nodes beyond depth', () => {
-    const layout = layoutGoalTree(TREE, { viewDepth: 1 });
-    // Level 2 nodes (id 3, 4) should be hidden
-    expect(layout.nodes.every(n => n.data.level <= 1)).toBe(true);
-  });
-
-  it('compresses non-contiguous levels into adjacent columns (no phantom empty columns)', () => {
-    // Legacy / non-canonical input: goal_types skip levels 1 and 3, so
-    // goals sit at levels 0, 2, 4. Column x must advance by exactly one
-    // step per used level, not per absolute level value — otherwise the
-    // skipped levels open empty columns and double the horizontal spacing.
-    const gapped: GoalTree = {
-      goal_types: [
-        { name: 'Strategy', level: 0 },
-        { name: 'Strategic Goal', level: 2 },
-        { name: 'Project Goal', level: 4 },
-      ],
-      goals: [
-        { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 2, name: 'Mid', type: 'Strategic Goal', level: 2, parent_id: 1 },
-        { id: 3, name: 'Leaf', type: 'Project Goal', level: 4, parent_id: 2 },
-      ],
-    };
-    const layout = layoutGoalTree(gapped);
-    const byId = new Map(layout.nodes.map(n => [n.id, n]));
-    const step = byId.get(2)!.x - byId.get(1)!.x;
-    // Root→Mid and Mid→Leaf must use the same single-column step despite
-    // the level numbers jumping by 2 each time.
-    expect(byId.get(3)!.x - byId.get(2)!.x).toBe(step);
-    // And that step is one node width + one rank separator (250 + 80).
-    expect(step).toBe(250 + 80);
-  });
-
-  // Pre-release blocker regression (orchestrator review 2026-05-21).
-  it('[blocker] does not stack-overflow on a self-parent cycle', () => {
-    const cyclic: GoalTree = {
-      goal_types: [{ name: 'X', level: 0 }],
-      goals: [{ id: 1, name: 'self-parent', type: 'X', level: 0, parent_id: 1 }],
-    };
-    // Without a visited-set inside placeSubtree, this recurses forever.
-    expect(() => layoutGoalTree(cyclic)).not.toThrow();
-  });
-
-  it('[blocker] does not stack-overflow on a 2-node mutual cycle', () => {
-    const cyclic: GoalTree = {
-      goal_types: [{ name: 'X', level: 0 }, { name: 'Y', level: 1 }],
-      goals: [
-        { id: 1, name: 'A', type: 'X', level: 0, parent_id: 2 },
-        { id: 2, name: 'B', type: 'Y', level: 1, parent_id: 1 },
-      ],
-    };
-    expect(() => layoutGoalTree(cyclic)).not.toThrow();
-  });
-
-  // vkgeorgia/strategy#77 — scope filtering.
-  describe('scope', () => {
-    const ids = (l: ReturnType<typeof layoutGoalTree>) => l.nodes.map(n => n.id).sort((a, b) => a - b);
-
-    it("mode 'all' matches the baseline", () => {
-      expect(ids(layoutGoalTree(TREE, { scope: { mode: 'all' } }))).toEqual(ids(layoutGoalTree(TREE)));
-    });
-
-    it("mode 'level' trims goals strictly above the cap", () => {
-      // TREE: id1 level0, id2 level1, id3/id4 level2.
-      const layout = layoutGoalTree(TREE, { scope: { mode: 'level', maxLevel: 1 } });
-      expect(ids(layout)).toEqual([1, 2]);
-      expect(layout.nodes.every(n => n.data.level <= 1)).toBe(true);
-    });
-
-    it("mode 'root' keeps the chosen goal and its descendants", () => {
-      // root id2 → itself + children id3, id4.
-      const layout = layoutGoalTree(TREE, { scope: { mode: 'root', rootGoalId: '2' } });
-      expect(ids(layout)).toEqual([2, 3, 4]);
-    });
-
-    it("mode 'root' returns an empty layout when the root is absent", () => {
-      const layout = layoutGoalTree(TREE, { scope: { mode: 'root', rootGoalId: '999' } });
-      expect(layout.nodes).toHaveLength(0);
-      expect(layout.edges).toHaveLength(0);
-    });
-  });
-});

package/src/goals/__tests__/mutations.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { reparent, addChild, deleteWithDescendants, moveToBacklog, restoreFromBacklog } from '../mutations.js';
-import type { GoalTree } from '../types.js';
-
-const TREE: GoalTree = {
-  goal_types: [
-    { name: 'Strategy', level: 0 },
-    { name: 'Business Goal', level: 1 },
-    { name: 'Project', level: 2 },
-  ],
-  goals: [
-    { id: 1, name: 'North Star', type: 'Strategy', level: 0, parent_id: 0 },
-    { id: 2, name: 'EU Expansion', type: 'Business Goal', level: 1, parent_id: 1 },
-    { id: 3, name: 'Berlin Office', type: 'Project', level: 2, parent_id: 2 },
-  ],
-};
-
-describe('reparent', () => {
-  it('moves a goal to a new parent', () => {
-    const r = reparent(TREE, 3, 1);
-    expect(r.ok).toBe(true);
-    const moved = r.result!.goals.find(g => g.id === 3)!;
-    expect(moved.parent_id).toBe(1);
-    expect(moved.level).toBe(1);
-  });
-
-  it('refuses to create a cycle', () => {
-    const r = reparent(TREE, 1, 3);
-    expect(r.ok).toBe(false);
-    expect(r.error?.code).toBe('MUTATION_REFUSED');
-  });
-
-  it('refuses self-reparent', () => {
-    expect(reparent(TREE, 1, 1).ok).toBe(false);
-  });
-
-  it('refuses reparent that would exceed max level', () => {
-    const r = reparent(TREE, 1, 3); // would make level 3 which exceeds max 2
-    expect(r.ok).toBe(false);
-  });
-
-  it('preserves immutability — original tree unchanged', () => {
-    reparent(TREE, 3, 1);
-    expect(TREE.goals.find(g => g.id === 3)!.parent_id).toBe(2);
-  });
-});
-
-describe('addChild', () => {
-  it('adds a child with auto-assigned id and level', () => {
-    const r = addChild(TREE, 2, { name: 'Warsaw Office', type: 'Project', level: 2, parent_id: 2 });
-    expect(r.ok).toBe(true);
-    const newGoal = r.result!.goals.find(g => g.name === 'Warsaw Office')!;
-    expect(newGoal.id).toBeGreaterThan(3);
-    expect(newGoal.parent_id).toBe(2);
-    expect(newGoal.level).toBe(2);
-  });
-
-  it('adds root-level child when parentId is 0', () => {
-    const r = addChild(TREE, 0, { name: 'Second Strategy', type: 'Strategy', level: 0, parent_id: 0 });
-    expect(r.ok).toBe(true);
-    expect(r.result!.goals.find(g => g.name === 'Second Strategy')!.level).toBe(0);
-  });
-
-  it('refuses when parent not found', () => {
-    const r = addChild(TREE, 99, { name: 'X', type: 'Project', level: 2, parent_id: 99 });
-    expect(r.ok).toBe(false);
-  });
-
-  it('preserves immutability', () => {
-    const before = TREE.goals.length;
-    addChild(TREE, 1, { name: 'New', type: 'Business Goal', level: 1, parent_id: 1 });
-    expect(TREE.goals.length).toBe(before);
-  });
-});
-
-describe('deleteWithDescendants', () => {
-  it('deletes goal and all descendants', () => {
-    const r = deleteWithDescendants(TREE, 2);
-    expect(r.ok).toBe(true);
-    const ids = r.result!.goals.map(g => g.id);
-    expect(ids).not.toContain(2);
-    expect(ids).not.toContain(3);
-    expect(ids).toContain(1);
-  });
-
-  it('refuses when goal not found', () => {
-    expect(deleteWithDescendants(TREE, 99).ok).toBe(false);
-  });
-
-  it('preserves immutability', () => {
-    deleteWithDescendants(TREE, 2);
-    expect(TREE.goals.length).toBe(3);
-  });
-});
-
-describe('moveToBacklog', () => {
-  it('sets parent_id to 0', () => {
-    const r = moveToBacklog(TREE, 3);
-    expect(r.ok).toBe(true);
-    expect(r.result!.goals.find(g => g.id === 3)!.parent_id).toBe(0);
-  });
-});
-
-describe('restoreFromBacklog', () => {
-  it('reparents the goal to the new parent', () => {
-    const backlogged = moveToBacklog(TREE, 3).result!;
-    const r = restoreFromBacklog(backlogged, 3, 1);
-    expect(r.ok).toBe(true);
-    expect(r.result!.goals.find(g => g.id === 3)!.parent_id).toBe(1);
-  });
-});
-
-describe('reparent — descendant type relabeling and level cap', () => {
-  const DEEP: GoalTree = {
-    goal_types: [
-      { name: 'Strategy', level: 0 },
-      { name: 'Business Goal', level: 1 },
-      { name: 'Project', level: 2 },
-      { name: 'Task', level: 3 },
-    ],
-    goals: [
-      { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-      { id: 2, name: 'BG1', type: 'Business Goal', level: 1, parent_id: 1 },
-      { id: 3, name: 'Proj1', type: 'Project', level: 2, parent_id: 2 },
-      { id: 4, name: 'Task1', type: 'Task', level: 3, parent_id: 3 },
-    ],
-  };
-
-  it('relabels descendant types via getTypeForLevel when reparenting shifts levels', () => {
-    // Move Proj1 (id=3, level=2) directly under Root (id=1, level=0); delta = -1
-    // Task1 (child of Proj1, level=3): new level = 2, type should be 'Project'
-    const r = reparent(DEEP, 3, 1);
-    expect(r.ok).toBe(true);
-    const proj = r.result!.goals.find(g => g.id === 3)!;
-    const task = r.result!.goals.find(g => g.id === 4)!;
-    expect(proj.level).toBe(1);
-    expect(proj.type).toBe('Business Goal');
-    expect(task.level).toBe(2);
-    expect(task.type).toBe('Project');
-  });
-
-  it('caps descendant level at maxLevel and refuses when that violates GOALS-012', () => {
-    // Move Root (id=1, level=0) under Root2 (id=5, level=0); delta = +1
-    // BG1: 1→2, Proj1: 2→3 (maxLevel), Task1: 3→4, capped at 3
-    // Task1 (capped level=3) under Proj1 (level=3) violates GOALS-012 → refused
-    const tree: GoalTree = {
-      ...DEEP,
-      goals: [...DEEP.goals, { id: 5, name: 'Root2', type: 'Strategy', level: 0, parent_id: 0 }],
-    };
-    const r = reparent(tree, 1, 5);
-    expect(r.ok).toBe(false);
-  });
-});