@defra/interactive-map 0.0.43-fmp-experimental → 0.0.44-alpha

package/plugins/draw/src/hooks/useSpatialList.test.js

@@ -0,0 +1,339 @@
+import { renderHook, act } from '@testing-library/react'
+import { useSpatialList } from './useSpatialList.js'
+import { createSpatialListRegistry } from '../../../../src/App/registry/spatialListRegistry.js'
+import { ADAPTER_EVENTS } from '../adapterEvents.js'
+
+const SET_FEATURES = 'map:setspatiallist'
+const SET_ACTIVE = 'map:setactiveitem'
+const CONFIRM = 'map:selectitem'
+const MOVE_END = 'map:moveend'
+
+const vertexItem = (overrides) => expect.objectContaining({ isMidpoint: false, ...overrides })
+const midpointItem = (overrides) => expect.objectContaining({ isMidpoint: true, ...overrides })
+
+const makeEventBus = () => {
+  const listeners = {}
+  return {
+    on: jest.fn((eventName, fn) => { listeners[eventName] = fn }),
+    off: jest.fn(),
+    emit: jest.fn((eventName, payload) => listeners[eventName]?.(payload))
+  }
+}
+
+// A minimal stand-in for the adapter surface useSpatialList.js actually calls
+// (getVertexItems/selectVertex/insertVertexAtMidpoint), plus its own on/off/UPDATE bus.
+const makeDrawAdapter = ({ vertices = [], midpoints = [] } = {}) => {
+  const listeners = {}
+  return {
+    getVertexItems: jest.fn(() => ({ vertices, midpoints })),
+    selectVertex: jest.fn(),
+    insertVertexAtMidpoint: jest.fn(),
+    on: jest.fn((eventName, fn) => { listeners[eventName] = fn }),
+    off: jest.fn(),
+    fireUpdate: () => listeners[ADAPTER_EVENTS.UPDATE]?.()
+  }
+}
+
+const makeMapProvider = (draw) => ({
+  draw,
+  mapToScreen: jest.fn(() => ({ x: 10, y: 20 }))
+})
+
+const makeViewportRef = () => ({ current: { focus: jest.fn() } })
+
+const setup = ({ mode = 'edit_vertex', draw, eventBus, mapSize = 'small', registry, viewportRef, announce } = {}) => {
+  const eb = eventBus ?? makeEventBus()
+  const adapter = draw ?? makeDrawAdapter()
+  const mp = makeMapProvider(adapter)
+  const vpRef = viewportRef ?? makeViewportRef()
+  const announceSpy = announce ?? jest.fn()
+  // A real registry, not a mock — spatialListRegistry.test.js already covers its own
+  // aggregation/exclusive-claim behaviour generically; using the real thing here proves this
+  // hook actually drives it correctly, same convention as interact's own useSpatialList.test.js.
+  const spatialListRegistry = registry ?? createSpatialListRegistry({ eventBus: eb })
+  const { result, unmount, rerender } = renderHook(
+    ({ mode }) => useSpatialList({
+      mapState: { mapSize },
+      pluginState: { mode },
+      services: { eventBus: eb, announce: announceSpy },
+      mapProvider: mp,
+      spatialListRegistry,
+      viewportRef: vpRef
+    }),
+    { initialProps: { mode } }
+  )
+  return { eb, mp, adapter, result, unmount, rerender, spatialListRegistry, viewportRef: vpRef, announce: announceSpy }
+}
+
+// ─── useSpatialList — lifecycle ──────────────────────────────────────────
+
+describe('useSpatialList — lifecycle', () => {
+  it('registers a "draw" item provider with spatialListRegistry on mount', () => {
+    const eb = makeEventBus()
+    const spatialListRegistry = createSpatialListRegistry({ eventBus: eb })
+    const registerSpy = jest.spyOn(spatialListRegistry, 'registerItemProvider')
+    const { unmount } = setup({ eventBus: eb, registry: spatialListRegistry })
+    expect(registerSpy).toHaveBeenCalledWith('draw', { getItems: expect.any(Function), exclusive: true })
+    unmount()
+  })
+
+  it('unregisters the "draw" provider on unmount', () => {
+    const eb = makeEventBus()
+    const spatialListRegistry = createSpatialListRegistry({ eventBus: eb })
+    const unregisterSpy = jest.spyOn(spatialListRegistry, 'unregisterItemProvider')
+    const { unmount } = setup({ eventBus: eb, registry: spatialListRegistry })
+    unmount()
+    expect(unregisterSpy).toHaveBeenCalledWith('draw')
+  })
+
+  it('subscribes to the adapter\'s UPDATE event while edit_vertex is active', () => {
+    const { adapter, unmount } = setup({ mode: 'edit_vertex' })
+    expect(adapter.on).toHaveBeenCalledWith(ADAPTER_EVENTS.UPDATE, expect.any(Function))
+    unmount()
+    expect(adapter.off).toHaveBeenCalledWith(ADAPTER_EVENTS.UPDATE, expect.any(Function))
+  })
+
+  it('is safe when mapProvider.draw does not exist yet', () => {
+    const eb = makeEventBus()
+    const mp = { draw: null, mapToScreen: jest.fn() }
+    expect(() => renderHook(() => useSpatialList({
+      mapState: { mapSize: 'small' },
+      pluginState: { mode: 'edit_vertex' },
+      services: { eventBus: eb },
+      mapProvider: mp,
+      spatialListRegistry: createSpatialListRegistry({ eventBus: eb })
+    }))).not.toThrow()
+  })
+})
+
+// ─── useSpatialList — item building ──────────────────────────────────────
+
+describe('useSpatialList — item building', () => {
+  it('emits no items and label "Shape points" is never surfaced (no claim) outside edit_vertex', () => {
+    const eb = makeEventBus()
+    setup({ eventBus: eb, mode: 'draw_polygon' })
+    // Not the exclusive claimant, so its own empty items don't even reach the emit.
+    expect(eb.emit).not.toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({ label: 'Shape points' }))
+  })
+
+  it('builds vertex items — id, "Point N" label, and screen position — on entering edit_vertex', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, {
+      items: [
+        vertexItem({ id: '0', label: 'Point 1', x: 10, y: 20 }),
+        vertexItem({ id: '1', label: 'Point 2', x: 10, y: 20 })
+      ],
+      multiselectable: false,
+      label: 'Shape points',
+      focusable: false
+    })
+  })
+
+  it('interleaves each midpoint after its vertex, with a flat id continuing the vertex index space', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1], [2, 2]], midpoints: [[0.5, 0.5], [1.5, 1.5], [1, 1]] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, {
+      items: [
+        vertexItem({ id: '0' }),
+        midpointItem({ id: '3', label: 'Insert 1-2' }),
+        vertexItem({ id: '1' }),
+        midpointItem({ id: '4', label: 'Insert 2-3' }),
+        vertexItem({ id: '2' }),
+        midpointItem({ id: '5', label: 'Insert 3-1' })
+      ],
+      multiselectable: false,
+      label: 'Shape points',
+      focusable: false
+    })
+  })
+
+  it('declares focusable: false — no item is ever a real Tab stop for this list', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({ focusable: false }))
+  })
+
+  it('rebuilds on the adapter\'s UPDATE event (e.g. a vertex was inserted/moved)', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    eb.emit.mockClear()
+
+    draw.getVertexItems.mockReturnValue({ vertices: [[0, 0], [1, 1]], midpoints: [] })
+    act(() => draw.fireUpdate())
+
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({
+      items: [vertexItem({ id: '0' }), vertexItem({ id: '1' })]
+    }))
+  })
+
+  it('rebuilds on MAP_MOVE_END (pan/zoom) — the underlying coordinate is unchanged but its screen position moves', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    const { mp } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    eb.emit.mockClear()
+
+    mp.mapToScreen.mockReturnValue({ x: 99, y: 88 })
+    act(() => eb.emit(MOVE_END))
+
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({
+      items: [vertexItem({ id: '0', x: 99, y: 88 })]
+    }))
+  })
+
+  it('reports no items when leaving edit_vertex for another mode', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    const { rerender } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    eb.emit.mockClear()
+
+    rerender({ mode: 'disabled' })
+
+    // Once draw releases its exclusive claim (no other provider registered here), the
+    // registry has nothing left to emit for — items are simply gone, not merely empty.
+    expect(eb.emit).not.toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({ label: 'Shape points' }))
+  })
+})
+
+// ─── useSpatialList — exclusive claim ────────────────────────────────────
+
+describe('useSpatialList — exclusive claim', () => {
+  it('claims exclusive ownership on entering edit_vertex, excluding an additive provider\'s own items', () => {
+    const eb = makeEventBus()
+    const registry = createSpatialListRegistry({ eventBus: eb })
+    registry.registerItemProvider('interact', { getItems: () => ({ items: [{ id: 'feature-1' }], label: 'Map features' }) })
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+
+    setup({ eventBus: eb, draw, mode: 'edit_vertex', registry })
+
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, expect.objectContaining({ label: 'Shape points' }))
+    const lastEmit = eb.emit.mock.calls.at(-1)[1]
+    expect(lastEmit.items.some(i => i.id === 'feature-1')).toBe(false)
+  })
+
+  it('releases the claim on leaving edit_vertex, reverting to the additive provider\'s items', () => {
+    const eb = makeEventBus()
+    const registry = createSpatialListRegistry({ eventBus: eb })
+    registry.registerItemProvider('interact', { getItems: () => ({ items: [{ id: 'feature-1' }], label: 'Map features' }) })
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+
+    const { rerender } = setup({ eventBus: eb, draw, mode: 'edit_vertex', registry })
+    eb.emit.mockClear()
+    rerender({ mode: 'disabled' })
+
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, { items: [{ id: 'feature-1' }], multiselectable: false, label: 'Map features' })
+  })
+
+  it('releases the claim on unmount too', () => {
+    const eb = makeEventBus()
+    const registry = createSpatialListRegistry({ eventBus: eb })
+    registry.registerItemProvider('interact', { getItems: () => ({ items: [{ id: 'feature-1' }], label: 'Map features' }) })
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+
+    const { unmount } = setup({ eventBus: eb, draw, mode: 'edit_vertex', registry })
+    eb.emit.mockClear()
+    unmount()
+
+    expect(eb.emit).toHaveBeenCalledWith(SET_FEATURES, { items: [{ id: 'feature-1' }], multiselectable: false, label: 'Map features' })
+  })
+})
+
+// ─── useSpatialList — active item preview (MAP_SET_ACTIVE_ITEM) ─────────
+
+describe('useSpatialList — active item preview', () => {
+  it('previews a real vertex via selectVertex, by numeric index', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '1' }))
+    expect(draw.selectVertex).toHaveBeenCalledWith(1)
+  })
+
+  it('previews a midpoint via selectVertex too — preview alone never inserts', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [[0.5, 0.5]] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '2' }))
+    expect(draw.selectVertex).toHaveBeenCalledWith(2)
+    expect(draw.insertVertexAtMidpoint).not.toHaveBeenCalled()
+  })
+
+  it('a null id (blur) does not call selectVertex — the selection must survive losing listbox focus', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: null }))
+    expect(draw.selectVertex).not.toHaveBeenCalled()
+  })
+
+  it('does nothing outside edit_vertex, even if a stale event arrives', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [] })
+    setup({ eventBus: eb, draw, mode: 'draw_polygon' })
+    act(() => eb.emit(SET_ACTIVE, { id: '0' }))
+    expect(draw.selectVertex).not.toHaveBeenCalled()
+  })
+})
+
+// ─── useSpatialList — confirm (MAP_SELECT_ITEM) ──────────────────────────
+
+describe('useSpatialList — confirm', () => {
+  it('inserts a vertex when the active item is a midpoint, announces it, and hands focus back to the viewport', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [[0.5, 0.5]] })
+    const { viewportRef, announce } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '2' })) // the midpoint
+    act(() => eb.emit(CONFIRM))
+    expect(draw.insertVertexAtMidpoint).toHaveBeenCalledWith(2)
+    expect(announce).toHaveBeenCalledWith('New point inserted', 'action')
+    expect(viewportRef.current.focus).toHaveBeenCalled()
+  })
+
+  it('does not insert anything for a real vertex — already the live selection — but still announces it and hands focus back', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [[0.5, 0.5]] })
+    const { viewportRef, announce } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '0' }))
+    act(() => eb.emit(CONFIRM))
+    expect(draw.insertVertexAtMidpoint).not.toHaveBeenCalled()
+    expect(announce).toHaveBeenCalledWith('Point 1 selected', 'action')
+    expect(viewportRef.current.focus).toHaveBeenCalled()
+  })
+
+  it('is a no-op — no insert, no announce, no refocus — when nothing is active yet', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [[0.5, 0.5]] })
+    const { viewportRef, announce } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(CONFIRM))
+    expect(draw.insertVertexAtMidpoint).not.toHaveBeenCalled()
+    expect(announce).not.toHaveBeenCalled()
+    expect(viewportRef.current.focus).not.toHaveBeenCalled()
+  })
+
+  it('is a no-op when the active id no longer matches any built item (e.g. the geometry changed underneath it)', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0], [1, 1]], midpoints: [] })
+    const { viewportRef, announce } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '99' })) // never a built item
+    act(() => eb.emit(CONFIRM))
+    expect(draw.insertVertexAtMidpoint).not.toHaveBeenCalled()
+    expect(announce).not.toHaveBeenCalled()
+    expect(viewportRef.current.focus).not.toHaveBeenCalled()
+  })
+
+  it('is a no-op outside edit_vertex, even with a stale active id', () => {
+    const eb = makeEventBus()
+    const draw = makeDrawAdapter({ vertices: [[0, 0]], midpoints: [[0.5, 0.5]] })
+    const { rerender, viewportRef, announce } = setup({ eventBus: eb, draw, mode: 'edit_vertex' })
+    act(() => eb.emit(SET_ACTIVE, { id: '1' })) // the midpoint, while still in edit_vertex
+    rerender({ mode: 'disabled' })
+    act(() => eb.emit(CONFIRM))
+    expect(draw.insertVertexAtMidpoint).not.toHaveBeenCalled()
+    expect(announce).not.toHaveBeenCalled()
+    expect(viewportRef.current.focus).not.toHaveBeenCalled()
+  })
+})

package/plugins/draw/src/manifest.js

@@ -20,6 +20,9 @@ const isEditMode = (mode) => EDIT_MODES.has(mode)
 
 // Show the platform-appropriate undo modifier (⌘ on macOS, Ctrl elsewhere).
 const undoCommand = isMac() ? '<kbd>Command</kbd> + <kbd>Z</kbd>' : '<kbd>Ctrl</kbd> + <kbd>Z</kbd>'
+// Show the platform-appropriate label for the Alt modifier — macOS keyboards and
+// menus call it Option, not Alt.
+const altKeyHtml = isMac() ? '<kbd>Option</kbd>' : '<kbd>Alt</kbd>'
 
 const createButtonSlots = (showLabel) => ({
   mobile: { slot: 'actions', showLabel },
@@ -131,7 +134,7 @@ export const manifest = {
     id: 'drawSelectAdjacentPoint',
     group: 'Drawing',
     title: 'Select adjacent point (edit)',
-    command: '<kbd>Alt</kbd> + <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> or <kbd>→</kbd>'
+    command: `${altKeyHtml} + <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> or <kbd>→</kbd>`
   }, {
     id: 'drawMovePoint',
     group: 'Drawing',

package/plugins/draw/src/manifest.test.js

@@ -152,13 +152,13 @@ describe('drawMenu', () => {
   })
 })
 
-describe('drawUndo keyboard shortcut (platform-specific command)', () => {
-  const loadUndoCommand = (mac) => {
+describe('platform-specific keyboard shortcut commands', () => {
+  const loadCommand = (mac, id) => {
     let command
     jest.isolateModules(() => {
       jest.doMock('../../../src/utils/isMac.js', () => ({ isMac: () => mac }))
       const { manifest: reloaded } = require('./manifest.js')
-      command = reloaded.keyboardShortcuts.find((s) => s.id === 'drawUndo').command
+      command = reloaded.keyboardShortcuts.find((s) => s.id === id).command
     })
     return command
   }
@@ -168,11 +168,23 @@ describe('drawUndo keyboard shortcut (platform-specific command)', () => {
     jest.resetModules()
   })
 
-  test('uses Command on macOS', () => {
-    expect(loadUndoCommand(true)).toBe('<kbd>Command</kbd> + <kbd>Z</kbd>')
+  describe('drawUndo', () => {
+    test('uses Command on macOS', () => {
+      expect(loadCommand(true, 'drawUndo')).toBe('<kbd>Command</kbd> + <kbd>Z</kbd>')
+    })
+
+    test('uses Ctrl on non-mac platforms', () => {
+      expect(loadCommand(false, 'drawUndo')).toBe('<kbd>Ctrl</kbd> + <kbd>Z</kbd>')
+    })
   })
 
-  test('uses Ctrl on non-mac platforms', () => {
-    expect(loadUndoCommand(false)).toBe('<kbd>Ctrl</kbd> + <kbd>Z</kbd>')
+  describe('drawSelectAdjacentPoint', () => {
+    test('uses Option on macOS', () => {
+      expect(loadCommand(true, 'drawSelectAdjacentPoint')).toBe('<kbd>Option</kbd> + <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> or <kbd>→</kbd>')
+    })
+
+    test('uses Alt on non-mac platforms', () => {
+      expect(loadCommand(false, 'drawSelectAdjacentPoint')).toBe('<kbd>Alt</kbd> + <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> or <kbd>→</kbd>')
+    })
   })
 })

package/plugins/draw/src/utils/spatial.js

@@ -202,35 +202,6 @@ const isValidClick = (coords) => {
   return coords[0].length <= 1 || isNewCoordinate(coords)
 }
 
-const spatialNavigate = (start, pixels, direction) => {
-  const quadrant = pixels.filter((p) => {
-    const offsetX = Math.abs(p[0] - start[0])
-    const offsetY = Math.abs(p[1] - start[1])
-    let isQuadrant = false
-    if (direction === 'ArrowUp') {
-      isQuadrant = p[1] <= start[1] && offsetY >= offsetX
-    } else if (direction === 'ArrowDown') {
-      isQuadrant = p[1] > start[1] && offsetY >= offsetX
-    } else if (direction === 'ArrowLeft') {
-      isQuadrant = p[0] <= start[0] && offsetY < offsetX
-    } else if (direction === 'ArrowRight') {
-      isQuadrant = p[0] > start[0] && offsetY < offsetX
-    } else {
-      isQuadrant = true
-    }
-    return isQuadrant && (JSON.stringify(p) !== JSON.stringify(start))
-  })
-
-  if (!quadrant.length) {
-    quadrant.push(start)
-  }
-
-  const pythagorean = (a, b) => Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2))
-  const distances = quadrant.map(p => pythagorean(Math.abs(start[0] - p[0]), Math.abs(start[1] - p[1])))
-  const closest = quadrant[distances.indexOf(Math.min(...distances))]
-  return pixels.findIndex(i => JSON.stringify(i) === JSON.stringify(closest))
-}
-
 export {
   toTurfGeometry,
   splitPolygon,
@@ -238,6 +209,5 @@ export {
   extendLine,
   isNewCoordinate,
   isValidClick,
-  isValidLineClick,
-  spatialNavigate
+  isValidLineClick
 }

package/plugins/draw/src/utils/spatial.test.js

@@ -7,8 +7,7 @@ import {
   extendLine,
   isNewCoordinate,
   isValidClick,
-  isValidLineClick,
-  spatialNavigate
+  isValidLineClick
 } from './spatial.js'
 
 jest.mock('polygon-splitter', () => jest.fn())
@@ -219,25 +218,3 @@ describe('isValidLineClick', () => {
     expect(isValidLineClick([[0, 0], [0, 0]])).toBe(false)
   })
 })
-
-describe('spatialNavigate', () => {
-  const start = [0, 0]
-  const pixels = [[0, 0], [0, -10], [0, 10], [-10, 0], [10, 0]]
-
-  test.each([
-    ['ArrowUp', 1],
-    ['ArrowDown', 2],
-    ['ArrowLeft', 3],
-    ['ArrowRight', 4]
-  ])('finds the nearest pixel for %s', (direction, expectedIndex) => {
-    expect(spatialNavigate(start, pixels, direction)).toBe(expectedIndex)
-  })
-
-  test('considers all pixels for an unrecognised direction', () => {
-    expect(spatialNavigate(start, pixels, 'Tab')).toBe(1)
-  })
-
-  test('falls back to the start point when no pixel is in the quadrant', () => {
-    expect(spatialNavigate(start, [[0, 0]], 'ArrowUp')).toBe(0)
-  })
-})