@pascal-app/editor 1.0.3 → 1.0.5

package/src/components/editor/group-rotate-handle.tsx

@@ -19,6 +19,7 @@ import { isHistoryShortcut } from '../../lib/history'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import { intersectSpatialDragPlane } from '../../lib/spatial-drag-plane'
 import { getSpatialPointerId, spatialPointerInput } from '../../lib/spatial-pointer-input'
+import { isTypingTarget } from '../../lib/typing-target'
 import useEditor, { isAngleSnapActive } from '../../store/use-editor'
 import useInteractionScope, {
   useActiveHandleDrag,
@@ -377,6 +378,7 @@ function GroupRotateHandleInner({ ids, meshEpoch }: { ids: string[]; meshEpoch:
     // Escape / ⌘Z abort the rotate — capture phase so they win over the global
     // use-keyboard arms (⌘Z must never history-jump under a live pointer).
     const onKeyDown = (e: KeyboardEvent) => {
+      if (isTypingTarget(e.target)) return
       if (e.key === 'Alt') {
         altKey = true
         return

package/src/components/editor/group-transform-shared.test.ts

@@ -4,16 +4,26 @@ import {
   type AnyNodeDefinition,
   type AnyNodeId,
   CeilingNode,
+  clearSceneHistory,
+  getSceneHistoryPauseDepth,
   LevelNode,
   nodeRegistry,
   registerNode,
   SlabNode,
   sceneRegistry,
+  useLiveNodeOverrides,
+  useLiveTransforms,
   useScene,
   WallNode,
 } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
 import { BoxGeometry, Group, Mesh } from 'three'
 import { z } from 'zod'
+import { getEditorClipboardSnapshot } from '../../lib/scene-clipboard'
+import useEditor from '../../store/use-editor'
+import useInteractionScope from '../../store/use-interaction-scope'
+import { startFloorplanGroupRotate, useFloorplanGroupDrag } from '../editor-2d/floorplan-group-move'
+import { startGroupPickUp } from './group-actions'
 import {
   classifyParticipant,
   collectParticipants,
@@ -597,3 +607,453 @@ describe('group plan bounds', () => {
     })
   })
 })
+
+// Ownership comes from the editable-focus contract, not the rotation helper.
+// Exercise the actual carry's registered listener and real scene/preview stores.
+// These CPU targets model ownership only, not native focus, propagation or undo.
+describe('group keyboard editable ownership', () => {
+  function withCarry(
+    run: (fixture: {
+      press: (
+        key: string,
+        target?: object,
+        modifiers?: { ctrlKey?: boolean; metaKey?: boolean },
+      ) => Event
+      snapshot: () => unknown
+      cancellations: () => number
+    }) => void,
+  ) {
+    const windowDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'window')
+    const documentDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'document')
+    const rafDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'requestAnimationFrame')
+    const cancelRafDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'cancelAnimationFrame')
+    const frames = new Map<number, FrameRequestCallback>()
+    let frameId = 0
+    const savedScene = useScene.getState()
+    const savedViewer = useViewer.getState()
+    const savedEditor = useEditor.getState()
+    const savedScope = useInteractionScope.getState()
+    const savedOverrides = useLiveNodeOverrides.getState()
+    const savedTransforms = useLiveTransforms.getState()
+    const history = useScene.temporal.getState()
+    const savedHistory = {
+      pastStates: history.pastStates,
+      futureStates: history.futureStates,
+      isTracking: history.isTracking,
+    }
+    const host = Object.assign(new EventTarget(), { location: { search: '' } })
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: host })
+    Object.defineProperty(globalThis, 'document', {
+      configurable: true,
+      value: { body: { style: { cursor: '' } }, querySelector: () => null },
+    })
+    Object.defineProperty(globalThis, 'requestAnimationFrame', {
+      configurable: true,
+      value: (callback: FrameRequestCallback) => {
+        frames.set(++frameId, callback)
+        return frameId
+      },
+    })
+    Object.defineProperty(globalThis, 'cancelAnimationFrame', {
+      configurable: true,
+      value: (id: number) => frames.delete(id),
+    })
+    const canvasTarget = { isContentEditable: false, closest: () => null }
+    let cancellations = 0
+    const press = (
+      key: string,
+      target: object = canvasTarget,
+      modifiers: { ctrlKey?: boolean; metaKey?: boolean } = {},
+    ) => {
+      const event = Object.assign(new Event('keydown', { bubbles: true, cancelable: true }), {
+        key,
+        ctrlKey: false,
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        ...modifiers,
+      })
+      Object.defineProperty(event, 'target', { value: target })
+      host.dispatchEvent(event)
+      return event
+    }
+    const snapshot = () =>
+      structuredClone({
+        nodes: useScene.getState().nodes,
+        selection: useViewer.getState().selection,
+        scope: useInteractionScope.getState().scope,
+        overrides: [...useLiveNodeOverrides.getState().overrides],
+        transforms: [...useLiveTransforms.getState().transforms],
+        clipboard: getEditorClipboardSnapshot(),
+        history: {
+          past: useScene.temporal.getState().pastStates.length,
+          future: useScene.temporal.getState().futureStates.length,
+          tracking: useScene.temporal.getState().isTracking,
+        },
+      })
+    try {
+      useScene.temporal.getState().pause()
+      useScene.setState({
+        nodes: placedNodes() as Record<AnyNodeId, AnyNode>,
+        rootNodeIds: ['building_test' as AnyNodeId],
+        dirtyNodes: new Set<AnyNodeId>(),
+        readOnly: false,
+      })
+      useScene.temporal.getState().resume()
+      clearSceneHistory()
+      useScene.getState().updateNode('item_chair' as AnyNodeId, { name: 'undo sentinel' })
+      expect(useScene.temporal.getState().pastStates.length).toBeGreaterThan(0)
+      useLiveNodeOverrides.getState().clearAll()
+      useLiveTransforms.getState().clearAll()
+      useInteractionScope.getState().end()
+      useEditor.getState().armToolMode({ mode: 'select' })
+      useViewer.getState().setSelection({
+        buildingId: 'building_test',
+        levelId: 'level_test',
+        selectedIds: ['item_chair', 'column_post'],
+      })
+      expect(
+        startGroupPickUp({
+          onCancel: () => {
+            cancellations += 1
+          },
+        }),
+      ).toBe(true)
+      run({ press, snapshot, cancellations: () => cancellations })
+    } finally {
+      // Use the controller's own teardown before restoring shared globals/state.
+      press('Escape')
+      useScene.temporal.getState().pause()
+      useScene.setState(savedScene)
+      useScene.temporal.setState({
+        pastStates: savedHistory.pastStates,
+        futureStates: savedHistory.futureStates,
+      })
+      if (savedHistory.isTracking) useScene.temporal.getState().resume()
+      useViewer.setState(savedViewer)
+      useEditor.setState(savedEditor)
+      useInteractionScope.setState(savedScope)
+      useLiveNodeOverrides.setState(savedOverrides)
+      useLiveTransforms.setState(savedTransforms)
+      frames.clear()
+      for (const [name, descriptor] of [
+        ['window', windowDescriptor],
+        ['document', documentDescriptor],
+        ['requestAnimationFrame', rafDescriptor],
+        ['cancelAnimationFrame', cancelRafDescriptor],
+      ] as const) {
+        if (descriptor) Object.defineProperty(globalThis, name, descriptor)
+        else Reflect.deleteProperty(globalThis, name)
+      }
+    }
+  }
+
+  for (const kind of ['input', 'textarea', 'select', 'contenteditable descendant']) {
+    test(`${kind} leaves an actual carried preview and its history untouched`, () => {
+      withCarry(({ press, snapshot, cancellations }) => {
+        expect(press('r').defaultPrevented).toBe(true)
+        expect(useLiveNodeOverrides.getState().overrides.size).toBeGreaterThan(0)
+        const before = snapshot()
+        const owner = { kind }
+        const target = {
+          isContentEditable: kind === 'contenteditable descendant',
+          closest: () => owner,
+        }
+        for (const key of ['r', 't', 'Escape', 'Backspace', 'Delete']) {
+          expect(press(key, target).defaultPrevented).toBe(false)
+          expect(snapshot()).toEqual(before)
+          expect(cancellations()).toBe(0)
+        }
+        for (const modifier of [{ ctrlKey: true }, { metaKey: true }]) {
+          for (const key of ['c', 'x', 'v', 'z']) {
+            expect(press(key, target, modifier).defaultPrevented).toBe(false)
+            expect(snapshot()).toEqual(before)
+            expect(cancellations()).toBe(0)
+          }
+        }
+      })
+    })
+  }
+
+  test('outside R/T still rotate the real preview and Escape restores the carry', () => {
+    withCarry(({ press, cancellations }) => {
+      const before = structuredClone(useScene.getState().nodes)
+      const initialYaw = 0.5
+      expect(press('r').defaultPrevented).toBe(true)
+      const rotated = useLiveNodeOverrides.getState().get('item_chair')
+      expect(rotated).toBeDefined()
+      expect((rotated!.rotation as number[])[1]).not.toBeCloseTo(initialYaw)
+      expect(useScene.getState().nodes).toEqual(before)
+      expect(press('t').defaultPrevented).toBe(true)
+      const restored = useLiveNodeOverrides.getState().get('item_chair')
+      expect((restored!.rotation as number[])[1]).toBeCloseTo(initialYaw)
+      expect(press('Escape').defaultPrevented).toBe(true)
+      expect(cancellations()).toBe(1)
+      expect(useInteractionScope.getState().scope.kind).toBe('idle')
+      expect(useLiveNodeOverrides.getState().overrides.size).toBe(0)
+      expect(useLiveTransforms.getState().transforms.size).toBe(0)
+      expect(useScene.getState().nodes).toEqual(before)
+      expect(useScene.temporal.getState().isTracking).toBe(true)
+      expect(useViewer.getState().selection.selectedIds).toEqual(['item_chair', 'column_post'])
+    })
+  })
+})
+
+// The editable-focus contract owns these expectations: a live rotation is a
+// preview, not a scene/history edit, until an outside release commits it.
+// Real package stores/controller and CPU geometry; the DOM below supplies only
+// identity screen coordinates and event dispatch, not browser focus/native undo.
+describe('floorplan group rotation keyboard ownership', () => {
+  function snapshot() {
+    const history = useScene.temporal.getState()
+    return structuredClone({
+      nodes: useScene.getState().nodes,
+      selection: useViewer.getState().selection,
+      scope: useInteractionScope.getState().scope,
+      overrides: [...useLiveNodeOverrides.getState().overrides],
+      transforms: [...useLiveTransforms.getState().transforms],
+      rotation: useFloorplanGroupDrag.getState().rotation,
+      inputDragging: useViewer.getState().inputDragging,
+      history: {
+        past: history.pastStates,
+        future: history.futureStates,
+        tracking: history.isTracking,
+        pauseDepth: getSceneHistoryPauseDepth(),
+      },
+    })
+  }
+
+  function withRotation(
+    run: (fixture: {
+      press: (key: string, target?: object, modifiers?: object) => Event
+      pointer: (type: string) => void
+      snapshot: () => ReturnType<typeof snapshot>
+    }) => void,
+  ) {
+    const names = [
+      'window',
+      'document',
+      'setTimeout',
+      'clearTimeout',
+      'queueMicrotask',
+      'requestAnimationFrame',
+      'cancelAnimationFrame',
+    ] as const
+    const descriptors = names.map(
+      (name) => [name, Object.getOwnPropertyDescriptor(globalThis, name)] as const,
+    )
+    const savedStores = [
+      [useScene, useScene.getState()],
+      [useViewer, useViewer.getState()],
+      [useEditor, useEditor.getState()],
+      [useInteractionScope, useInteractionScope.getState()],
+      [useLiveNodeOverrides, useLiveNodeOverrides.getState()],
+      [useLiveTransforms, useLiveTransforms.getState()],
+      [useFloorplanGroupDrag, useFloorplanGroupDrag.getState()],
+    ] as const
+    const savedHistory = useScene.temporal.getState()
+    const pauseDepth = getSceneHistoryPauseDepth()
+    const savedRegistry = new Map(sceneRegistry.nodes)
+    const host = Object.assign(new EventTarget(), { location: { search: '' } })
+    const timers = new Map<number, () => void>()
+    const microtasks: (() => void)[] = []
+    let timerId = 0
+    const sceneElement = {
+      getScreenCTM: () => ({ inverse: () => ({}) }),
+      ownerSVGElement: {
+        createSVGPoint: () => ({
+          x: 0,
+          y: 0,
+          matrixTransform() {
+            return { x: this.x, y: this.y }
+          },
+        }),
+      },
+    }
+    const globals = {
+      window: host,
+      document: {
+        body: { style: { cursor: '' } },
+        querySelector: (selector: string) =>
+          selector === 'g[data-floorplan-scene]' ? sceneElement : null,
+      },
+      setTimeout: (callback: () => void) => {
+        timers.set(++timerId, callback)
+        return timerId
+      },
+      clearTimeout: (id: number) => {
+        timers.delete(id)
+      },
+      queueMicrotask: (callback: () => void) => {
+        microtasks.push(callback)
+      },
+      requestAnimationFrame: (callback: FrameRequestCallback) => {
+        timers.set(++timerId, () => callback(0))
+        return timerId
+      },
+      cancelAnimationFrame: (id: number) => {
+        timers.delete(id)
+      },
+    }
+    const canvas = { isContentEditable: false, closest: () => null }
+    const press = (key: string, target: object = canvas, modifiers: object = {}) => {
+      const event = Object.assign(new Event('keydown', { cancelable: true }), {
+        key,
+        ctrlKey: false,
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        ...modifiers,
+      })
+      Object.defineProperty(event, 'target', { value: target })
+      host.dispatchEvent(event)
+      return event
+    }
+    const pointer = (type: string) => {
+      host.dispatchEvent(
+        Object.assign(new Event(type), {
+          pointerId: 7,
+          clientX: 2.5,
+          clientY: 4,
+        }),
+      )
+    }
+    const meshes: Mesh[] = []
+    try {
+      // No shared gesture may already own a history pause in this isolated test.
+      expect(pauseDepth).toBe(0)
+      for (const name of names) {
+        Object.defineProperty(globalThis, name, { configurable: true, value: globals[name] })
+      }
+      useScene.temporal.getState().pause()
+      useScene.setState({
+        nodes: placedNodes() as Record<AnyNodeId, AnyNode>,
+        rootNodeIds: ['building_test' as AnyNodeId],
+        dirtyNodes: new Set<AnyNodeId>(),
+        readOnly: false,
+      })
+      useScene.temporal.getState().resume()
+      // Clear only this temporal stack, never the process-wide draft registry.
+      useScene.temporal.getState().clear()
+      useScene.getState().updateNode('item_chair' as AnyNodeId, { name: 'rotation undo sentinel' })
+      useLiveNodeOverrides.getState().clearAll()
+      useLiveTransforms.getState().clearAll()
+      useFloorplanGroupDrag.setState({ delta: null, rotation: null })
+      useInteractionScope.getState().end()
+      useEditor.getState().armToolMode({ mode: 'select' })
+      useViewer.getState().setSelection({
+        buildingId: 'building_test',
+        levelId: 'level_test',
+        selectedIds: ['item_chair', 'column_post'],
+      })
+      sceneRegistry.nodes.clear()
+      for (const id of ['item_chair', 'column_post'] as const) {
+        const mesh = new Mesh(new BoxGeometry(1, 1, 1))
+        mesh.position.fromArray(
+          (useScene.getState().nodes[id as AnyNodeId] as unknown as { position: number[] })
+            .position,
+        )
+        mesh.updateMatrixWorld(true)
+        meshes.push(mesh)
+        sceneRegistry.nodes.set(id as AnyNodeId, mesh)
+      }
+      expect(startFloorplanGroupRotate({ clientX: 5.5, clientY: 1, pointerId: 7 })).toBe(true)
+      pointer('pointermove')
+      expect(useFloorplanGroupDrag.getState().rotation?.angle).toBeCloseTo(Math.PI / 2)
+      expect(useLiveNodeOverrides.getState().overrides.size).toBe(2)
+      expect(useInteractionScope.getState().scope.kind).toBe('handle-drag')
+      expect(useScene.temporal.getState().pastStates.length).toBeGreaterThan(0)
+      expect(useScene.temporal.getState().isTracking).toBe(false)
+      run({ press, pointer, snapshot })
+    } finally {
+      // Controller teardown balances its own history pause even after an assertion
+      // fails. Drain its deferred input/click cleanup before restoring shared state.
+      pointer('pointercancel')
+      while (microtasks.length) microtasks.shift()!()
+      for (const callback of timers.values()) {
+        callback()
+        while (microtasks.length) microtasks.shift()!()
+      }
+      timers.clear()
+      useScene.temporal.getState().pause()
+      for (const [store, state] of savedStores)
+        (store.setState as (snapshot: unknown) => void)(state)
+      useScene.temporal.setState(savedHistory)
+      sceneRegistry.nodes.clear()
+      for (const [id, object] of savedRegistry) sceneRegistry.nodes.set(id, object)
+      for (const mesh of meshes) {
+        mesh.geometry.dispose()
+        if (Array.isArray(mesh.material))
+          mesh.material.forEach((material) => {
+            material.dispose()
+          })
+        else mesh.material.dispose()
+      }
+      for (const [name, descriptor] of descriptors) {
+        if (descriptor) Object.defineProperty(globalThis, name, descriptor)
+        else Reflect.deleteProperty(globalThis, name)
+      }
+      expect(getSceneHistoryPauseDepth()).toBe(pauseDepth)
+    }
+  }
+
+  test('editable undo and cancel keys preserve the actual active rotation', () => {
+    withRotation(({ press, snapshot }) => {
+      const before = snapshot()
+      const targets = [
+        { isContentEditable: false, closest: () => ({ tagName: 'TEXTAREA' }) },
+        { isContentEditable: true, closest: () => null },
+      ]
+      for (const target of targets) {
+        for (const modifiers of [{ ctrlKey: true }, { metaKey: true }]) {
+          expect(press('z', target, modifiers).defaultPrevented).toBe(false)
+          expect(snapshot()).toEqual(before)
+        }
+        for (const key of ['Backspace', 'Delete', 'Escape']) {
+          expect(press(key, target).defaultPrevented).toBe(false)
+          expect(snapshot()).toEqual(before)
+        }
+      }
+    })
+  })
+
+  test('outside history and Escape still cancel without consuming a scene undo', () => {
+    for (const [key, modifiers] of [
+      ['Escape', {}],
+      ['z', { ctrlKey: true }],
+      ['z', { metaKey: true }],
+    ] as const) {
+      withRotation(({ press, snapshot }) => {
+        const before = snapshot()
+        expect(press(key, undefined, modifiers).defaultPrevented).toBe(true)
+        const after = snapshot()
+        expect(after.nodes).toEqual(before.nodes)
+        expect(after.history.past).toEqual(before.history.past)
+        expect(after.history.future).toEqual(before.history.future)
+        expect(after.history.tracking).toBe(true)
+        expect(after.history.pauseDepth).toBe(0)
+        expect(after.scope.kind).toBe('idle')
+        expect(after.overrides).toEqual([])
+        expect(after.transforms).toEqual([])
+        expect(after.rotation).toBeNull()
+      })
+    }
+  })
+
+  test('outside pointer release commits one undoable rotation', () => {
+    withRotation(({ pointer, snapshot }) => {
+      const before = snapshot()
+      pointer('pointerup')
+      const after = snapshot()
+      expect(after.nodes).not.toEqual(before.nodes)
+      expect(after.history.past).toHaveLength(before.history.past.length + 1)
+      expect(after.history.tracking).toBe(true)
+      expect(after.scope.kind).toBe('idle')
+      expect(after.overrides).toEqual([])
+      expect(after.transforms).toEqual([])
+      expect(after.rotation).toBeNull()
+      useScene.temporal.getState().undo()
+      expect(useScene.getState().nodes).toEqual(before.nodes)
+    })
+  })
+})

package/src/components/editor/handles/handle-hit-priority.test.tsx

@@ -0,0 +1,63 @@
+import { expect, test } from 'bun:test'
+import { type RootState, useThree } from '@react-three/fiber'
+import { create } from '@react-three/test-renderer'
+import { useLayoutEffect } from 'react'
+import { type Intersection, Object3D } from 'three'
+import { EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY } from '../../../lib/direct-manipulation'
+import { EditorHandleHitPriority, prioritizeEditorHandleHits } from './handle-hit-priority'
+
+function hit(name: string, distance: number, handle = false): Intersection {
+  const object = new Object3D()
+  object.name = name
+  if (handle) object.userData[EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY] = true
+  return { object, distance, point: undefined as never }
+}
+const names = (hits: Intersection[]) => hits.map((entry) => entry.object.name)
+
+test('a handle behind a wall comes first, so the hover goes where the press goes', () => {
+  const hits = [hit('wall', 3), hit('floor', 5), hit('up', 6, true), hit('cube', 6.2, true)]
+  expect(names(prioritizeEditorHandleHits(hits))).toEqual(['up', 'cube', 'wall', 'floor'])
+})
+
+test('without a handle on the ray the order is untouched', () => {
+  const hits = [hit('wall', 3), hit('floor', 5)]
+  expect(prioritizeEditorHandleHits(hits)).toBe(hits)
+})
+
+test('mounted, it is the canvas event filter; unmounted, the previous one comes back', async () => {
+  let state: RootState | null = null
+  const Probe = () => {
+    state = useThree((root) => root)
+    return null
+  }
+  const previous = (hits: Intersection[]) => hits.filter((entry) => entry.object.name !== 'grid')
+  const Previous = () => {
+    const setEvents = useThree((root) => root.setEvents)
+    useLayoutEffect(() => setEvents({ filter: previous }), [setEvents])
+    return null
+  }
+  const before = await create(
+    <>
+      <Probe />
+      <Previous />
+    </>,
+  )
+  await before.update(
+    <>
+      <Probe />
+      <Previous />
+      <EditorHandleHitPriority />
+    </>,
+  )
+  const hits = [hit('grid', 1), hit('wall', 3), hit('cube', 6, true)]
+  const filter = (state as RootState | null)?.events.filter
+  expect(names(filter!(hits, state!))).toEqual(['cube', 'wall'])
+  await before.update(
+    <>
+      <Probe />
+      <Previous />
+    </>,
+  )
+  expect((state as RootState | null)?.events.filter).toBe(previous)
+  await before.unmount()
+})

package/src/components/editor/handles/handle-hit-priority.tsx

@@ -0,0 +1,37 @@
+'use client'
+
+import { useThree } from '@react-three/fiber'
+import { useEffect } from 'react'
+import type { Intersection, Object3D } from 'three'
+import { EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY } from '../../../lib/direct-manipulation'
+
+const isHandleHit = (hit: { object: Object3D }) =>
+  hit.object.userData?.[EDITOR_HANDLE_HIT_AREA_USER_DATA_KEY] === true
+
+/**
+ * Editor handles first, everything else after, each in distance order. Handles
+ * draw on top of walls and a handle anywhere along the ray already owns the
+ * press; ordering them first gives them the hover too. Distance order alone
+ * lets a wall in front win the hover for good: once its enter stops
+ * propagation, R3F keeps stopping every later move at it, so a handle behind
+ * it never hears its enter however the pointer reaches it.
+ */
+export function prioritizeEditorHandleHits<T extends { object: Object3D }>(hits: T[]): T[] {
+  if (!hits.some(isHandleHit)) return hits
+  return [...hits.filter(isHandleHit), ...hits.filter((hit) => !isHandleHit(hit))]
+}
+
+/** Installs `prioritizeEditorHandleHits` as the canvas's pointer-event filter while mounted. */
+export function EditorHandleHitPriority() {
+  const get = useThree((state) => state.get)
+  const setEvents = useThree((state) => state.setEvents)
+  useEffect(() => {
+    const previous = get().events.filter
+    setEvents({
+      filter: (hits: Intersection[], state) =>
+        prioritizeEditorHandleHits(previous ? previous(hits, state) : hits),
+    })
+    return () => setEvents({ filter: previous })
+  }, [get, setEvents])
+  return null
+}

package/src/components/editor/handles/swallow-next-click.test.ts

@@ -0,0 +1,28 @@
+import { expect, spyOn, test } from 'bun:test'
+import { swallowNextClick } from './use-handle-drag'
+
+test('deferred click cleanup removes the listener from its original window', () => {
+  const originalWindow = Object.getOwnPropertyDescriptor(globalThis, 'window')
+  const target = new EventTarget()
+  const remove = spyOn(target, 'removeEventListener')
+  let cleanup: (() => void) | undefined
+  const timer = spyOn(globalThis, 'setTimeout').mockImplementation(((
+    callback: Parameters<typeof setTimeout>[0],
+  ) => {
+    cleanup = callback as () => void
+    return undefined as unknown as ReturnType<typeof setTimeout>
+  }) as typeof setTimeout)
+  try {
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: target })
+    swallowNextClick()
+    Reflect.deleteProperty(globalThis, 'window')
+    expect(cleanup).toBeDefined()
+    expect(() => cleanup?.()).not.toThrow()
+    expect(remove).toHaveBeenCalledTimes(1)
+  } finally {
+    timer.mockRestore()
+    remove.mockRestore()
+    if (originalWindow) Object.defineProperty(globalThis, 'window', originalWindow)
+    else Reflect.deleteProperty(globalThis, 'window')
+  }
+})