@svgrid/grid 2.1.21 → 2.1.23

package/src/dock-manager-model.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from 'vitest'
+import { pane, tabs, group, allPaneIds, type DockNode, type DockTabs } from './dock-model'
+import {
+  floatPane,
+  dockPaneOnto,
+  dockWindowOnto,
+  reorderTab,
+  autoHideLeaf,
+  autoHidePaneToSide,
+  pinAutoHidden,
+  closePane,
+  moveWindow,
+  resizeWindow,
+  bringToFront,
+  setWindowMinimized,
+  toggleWindowMaximized,
+  closeWindow,
+  autoHideWindow,
+  toggleMaximizeLeaf,
+  findLeafById,
+  addPaneToMain,
+  locatePane,
+  surfaceOfTabs,
+  allManagerPaneIds,
+  allManagerIds,
+  dedupeManagerNodeIds,
+  setManagerActive,
+  type DockManagerState,
+} from './dock-manager-model'
+
+function counter() {
+  let n = 0
+  return () => `m${n++}`
+}
+const rect = { x: 100, y: 100, width: 320, height: 240 }
+
+/** main = [A | B], no floats, no auto-hide. Returns the SHARED id generator so
+ *  follow-up ops mint ids from the same sequence (no collisions - mirrors how
+ *  SvDockManager uses a single genId). */
+function base(): { state: DockManagerState; A: DockTabs; B: DockTabs; g: () => string } {
+  const g = counter()
+  const A = tabs(g, [pane('a', 'A')])
+  const B = tabs(g, [pane('b', 'B')])
+  return { state: { main: group(g, 'row', [A, B]) as DockNode, floating: [], autoHide: [] }, A, B, g }
+}
+
+describe('floatPane', () => {
+  it('pops a pane into a floating window and collapses its old leaf', () => {
+    const { state, g } = base()
+    const next = floatPane(state, 'a', rect, g)
+    expect(next.floating).toHaveLength(1)
+    expect(next.floating[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+    // main collapsed to the bare B leaf.
+    expect(next.main?.type).toBe('tabs')
+    expect(allPaneIds(next.main!)).toEqual(['b'])
+    expect(locatePane(next, 'a')).toEqual({ kind: 'floating', windowId: next.floating[0]!.id })
+  })
+
+  it('is a no-op for a pane already alone in its float', () => {
+    const { state, g } = base()
+    const once = floatPane(state, 'a', rect, g)
+    const twice = floatPane(once, 'a', rect, g)
+    expect(twice).toBe(once)
+  })
+})
+
+describe('dockPaneOnto - cross surface', () => {
+  it('docks a floating pane back into a main leaf as a tab', () => {
+    const { state, B, g } = base()
+    const floated = floatPane(state, 'a', rect, g)
+    const docked = dockPaneOnto(floated, 'a', B.id, 'center', g)
+    expect(docked.floating).toHaveLength(0)
+    const leaf = docked.main as DockTabs
+    expect(leaf.panes.map((p) => p.id)).toEqual(['b', 'a'])
+  })
+
+  it('edge-docks within main', () => {
+    const { state, A, g } = base()
+    const floated = floatPane(state, 'a', rect, g) // main is now just B
+    // Re-dock A to the LEFT of B (A's old leaf id is gone; target B).
+    const bId = surfaceOfTabs(floated, (floated.main as DockTabs).id) === 'main' ? (floated.main as DockTabs).id : ''
+    const docked = dockPaneOnto(floated, 'a', bId, 'left', g)
+    expect(allPaneIds(docked.main!)).toEqual(['a', 'b'])
+    void A
+  })
+})
+
+describe('reorderTab', () => {
+  it('reorders tabs inside a leaf (main)', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B'), pane('c', 'C')], 0)
+    const state: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    const next = reorderTab(state, leaf.id, 0, 2)
+    expect((next.main as DockTabs).panes.map((p) => p.id)).toEqual(['b', 'c', 'a'])
+    // active followed pane A.
+    expect((next.main as DockTabs).active).toBe(2)
+  })
+
+  it('reorders tabs inside a floating window', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    s = dockPaneOnto(s, 'b', s.floating[0]!.leaf.id, 'center', g) // float now [a, b]
+    const wid = s.floating[0]!.leaf.id
+    const next = reorderTab(s, wid, 0, 1)
+    expect(next.floating[0]!.leaf.panes.map((p) => p.id)).toEqual(['b', 'a'])
+  })
+})
+
+describe('auto-hide + pin', () => {
+  it('collapses a main leaf to an edge, then pins it back', () => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, 'right')
+    expect(hidden.autoHide).toHaveLength(1)
+    expect(hidden.autoHide[0]!.side).toBe('right')
+    expect(allPaneIds(hidden.main!)).toEqual(['a']) // only A left tiled
+    expect(allManagerPaneIds(hidden)).toEqual(['a', 'b']) // B still exists, hidden
+
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g)
+    expect(pinned.autoHide).toHaveLength(0)
+    expect(pinned.main?.type).toBe('group')
+    expect(allPaneIds(pinned.main!)).toEqual(['a', 'b']) // B re-docked on the right
+  })
+})
+
+describe('auto-hide to any of the 4 sides', () => {
+  it.each(['left', 'right', 'top', 'bottom'] as const)('collapses + pins back on the %s edge', (side) => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, side)
+    expect(hidden.autoHide[0]!.side).toBe(side)
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g)
+    const root = pinned.main as Extract<DockNode, { type: 'group' }>
+    expect(root.type).toBe('group')
+    // Row for left/right, column for top/bottom.
+    expect(root.direction).toBe(side === 'left' || side === 'right' ? 'row' : 'column')
+    expect(allPaneIds(pinned.main!).sort()).toEqual(['a', 'b'])
+  })
+
+  it('pins back with the requested size fraction (not 50/50)', () => {
+    const { state, B, g } = base()
+    const hidden = autoHideLeaf(state, B.id, 'right')
+    const pinned = pinAutoHidden(hidden, hidden.autoHide[0]!.id, g, 0.2)
+    const root = pinned.main as Extract<DockNode, { type: 'group' }>
+    // Right side => [content, pinnedLeaf]; the pinned leaf takes ~0.2.
+    expect(root.sizes[1]).toBeCloseTo(0.2, 1)
+    expect(root.sizes[0]).toBeCloseTo(0.8, 1)
+  })
+})
+
+describe('autoHidePaneToSide (drag a tab to an edge)', () => {
+  it('pulls a single pane out to an edge as its own entry', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B')])
+    const s: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    const next = autoHidePaneToSide(s, 'a', 'bottom', g)
+    expect(next.autoHide).toHaveLength(1)
+    expect(next.autoHide[0]!.side).toBe('bottom')
+    expect(next.autoHide[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+    // 'b' stays in the tiled leaf.
+    expect(allPaneIds(next.main!)).toEqual(['b'])
+  })
+})
+
+describe('dockWindowOnto', () => {
+  it('docks a whole window edge-wise into main', () => {
+    const { state, A, g } = base()
+    const floated = floatPane(state, 'b', rect, g) // main = A, float = [B]
+    const wid = floated.floating[0]!.id
+    const next = dockWindowOnto(floated, wid, A.id, 'right', g)
+    expect(next.floating).toHaveLength(0)
+    expect(allPaneIds(next.main!)).toEqual(['a', 'b'])
+  })
+})
+
+describe('maximize a tiled leaf + addPaneToMain', () => {
+  it('toggles maximizedLeaf and finds a leaf by id', () => {
+    const { state, A } = base()
+    expect(findLeafById(state, A.id)?.id).toBe(A.id)
+    const on = toggleMaximizeLeaf(state, A.id)
+    expect(on.maximizedLeaf).toBe(A.id)
+    expect(toggleMaximizeLeaf(on, A.id).maximizedLeaf).toBeNull()
+  })
+
+  it('adds a pane into the first main leaf (or as main when empty)', () => {
+    const { state } = base()
+    const next = addPaneToMain(state, pane('z', 'Z'), counter())
+    expect(allManagerPaneIds(next)).toContain('z')
+    const empty: DockManagerState = { main: null, floating: [], autoHide: [] }
+    const filled = addPaneToMain(empty, pane('z', 'Z'), counter())
+    expect(filled.main?.type).toBe('tabs')
+    expect(allManagerPaneIds(filled)).toEqual(['z'])
+  })
+})
+
+describe('window controls', () => {
+  it('minimizes, maximizes (toggle), closes, and auto-hides a window', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    const wid = s.floating[0]!.id
+    s = setWindowMinimized(s, wid, true)
+    expect(s.floating[0]!.minimized).toBe(true)
+    s = toggleWindowMaximized(s, wid)
+    expect(s.floating[0]!.maximized).toBe(true)
+    expect(s.floating[0]!.minimized).toBe(false) // max clears min
+    s = toggleWindowMaximized(s, wid)
+    expect(s.floating[0]!.maximized).toBe(false)
+    // auto-hide the window to the left edge
+    s = autoHideWindow(s, wid, 'left', g)
+    expect(s.floating).toHaveLength(0)
+    expect(s.autoHide[0]!.side).toBe('left')
+    expect(s.autoHide[0]!.leaf.panes.map((p) => p.id)).toEqual(['a'])
+  })
+
+  it('closeWindow drops the window and its panes', () => {
+    const { state, g } = base()
+    const s = floatPane(state, 'a', rect, g)
+    const next = closeWindow(s, s.floating[0]!.id)
+    expect(next.floating).toHaveLength(0)
+    expect(allManagerPaneIds(next)).toEqual(['b'])
+  })
+})
+
+describe('window ops + close', () => {
+  it('moves, resizes, and restacks windows; closes a pane anywhere', () => {
+    const { state, g } = base()
+    let s = floatPane(state, 'a', rect, g)
+    const wid = s.floating[0]!.id
+    s = moveWindow(s, wid, 40, 60)
+    s = resizeWindow(s, wid, 500, 400)
+    expect(s.floating[0]).toMatchObject({ x: 40, y: 60, width: 500, height: 400 })
+    const z0 = s.floating[0]!.z
+    s = bringToFront(s, wid)
+    expect(s.floating[0]!.z).toBeGreaterThan(z0)
+    s = closePane(s, 'a')
+    expect(s.floating).toHaveLength(0)
+    expect(allManagerPaneIds(s)).toEqual(['b'])
+  })
+})
+
+describe('setManagerActive', () => {
+  it('sets active in a main leaf and in a float', () => {
+    const g = counter()
+    const leaf = tabs(g, [pane('a', 'A'), pane('b', 'B')], 0)
+    const s: DockManagerState = { main: leaf, floating: [], autoHide: [] }
+    expect((setManagerActive(s, leaf.id, 1).main as DockTabs).active).toBe(1)
+  })
+})
+
+describe('dedupeManagerNodeIds', () => {
+  it('reassigns duplicate node ids so keyed sibling lists never collide', () => {
+    // A restored workspace where two sibling leaves share a generated id (the id
+    // counter had reset across reloads) - the shape that threw each_key_duplicate.
+    const dup: DockManagerState = {
+      main: {
+        type: 'group', id: 'dm-1000000', direction: 'row', sizes: [0.5, 0.5],
+        children: [
+          { type: 'tabs', id: 'dm-1000000', panes: [pane('rail', 'Pages')], active: 0 },
+          { type: 'tabs', id: 'dm-1000000', panes: [pane('main', 'Canvas')], active: 0 },
+        ],
+      } as DockNode,
+      floating: [], autoHide: [],
+    }
+    const fixed = dedupeManagerNodeIds(dup)
+    const ids = allManagerIds(fixed)
+    // Every node id is now unique...
+    const nodeIds = ids.filter((i) => i.startsWith('dm-'))
+    expect(new Set(nodeIds).size).toBe(nodeIds.length)
+    // ...while pane ids (which key content) are preserved.
+    expect(allManagerPaneIds(fixed).sort()).toEqual(['main', 'rail'])
+  })
+
+  it('is value-equal on an already-unique workspace', () => {
+    const { state } = base()
+    expect(dedupeManagerNodeIds(state)).toBe(state)
+  })
+})