:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
import type { MouseEvent as ReactMouseEvent } from 'react'
import { EditModeEdge } from 'lib/components/Cards/InsightCard/EditModeEdgeOverlay'
/** Matches the 2rem corner handle hit areas in DashboardItems.scss, so the replayed press lands on the handle that would be under the cursor. */
const CORNER_THRESHOLD_PX = 32
/** How many animation frames to wait for edit mode to render before giving up on continuing the gesture. */
const MAX_FRAMES_TO_WAIT = 10
/** Above react-grid-layout's own 3px drag threshold, because entering edit mode costs more to undo than a stray drag. */
export const EDIT_MODE_GESTURE_THRESHOLD_PX = 8
/** `onDragStarted` receives the move that crossed the threshold, which react-grid-layout needs to resume the gesture. */
export function whenPressBecomesDrag(event: ReactMouseEvent, onDragStarted: (moveEvent: MouseEvent) => void): void {
const { clientX, clientY } = event
function stopWatching(): void {
window.removeEventListener('mousemove', handleMove, { capture: true })
window.removeEventListener('mouseup', stopWatching, { capture: true })
}
function handleMove(moveEvent: MouseEvent): void {
// A release outside the browser window never delivers mouseup here, so trust what the move
// reports is still held rather than the release we may never see.
if (!(moveEvent.buttons & 1)) {
stopWatching()
return
}
const travelled = Math.hypot(moveEvent.clientX - clientX, moveEvent.clientY - clientY)
if (travelled < EDIT_MODE_GESTURE_THRESHOLD_PX) {
return
}
stopWatching()
onDragStarted(moveEvent)
}
window.addEventListener('mousemove', handleMove, { capture: true })
window.addEventListener('mouseup', stopWatching, { capture: true })
}
/** Pick the resize handle direction for a press on a tile edge, upgrading presses near a corner to the corner handle. */
export function resolveResizeHandleDirection(
edge: EditModeEdge,
rect: { left: number; right: number; top: number; bottom: number },
clientX: number,
clientY: number
): string {
// Corner presses already name the diagonal handle directly.
if (edge === 'sw' || edge === 'se') {
return edge
}
if (edge === 's') {
if (clientX - rect.left <= CORNER_THRESHOLD_PX) {
return `${edge}w`
}
if (rect.right - clientX <= CORNER_THRESHOLD_PX) {
return `${edge}e`
}
return edge
}
if (rect.bottom - clientY <= CORNER_THRESHOLD_PX) {
return `s${edge}`
}
return edge
}
/**
* Re-dispatch the pressed-down mouse event on `findTarget()` once it becomes available, so a gesture started
* before edit mode rendered continues without the user having to release and press again. react-grid-layout
* only listens for mousedown while drag/resize is enabled, so the original press never reaches it.
*/
function replayMouseDown(
event: ReactMouseEvent,
gridItem: Element,
findTarget: () => Element | null,
activeClass: 'resizing' | 'react-draggable-dragging',
pointerNow: MouseEvent
): void {
const { clientX, clientY, button } = event
let cancelled = false
let latestPointer = pointerNow
let frame: number | undefined
let observer: MutationObserver | undefined
let framesLeft = MAX_FRAMES_TO_WAIT
let pressedTarget: Element | null = null
const cleanup = (): void => {
if (frame !== undefined) {
cancelAnimationFrame(frame)
}
observer?.disconnect()
window.removeEventListener('mousemove', trackPointer, { capture: true })
window.removeEventListener('mouseup', cancel, { capture: true })
}
const cancel = (): void => {
cancelled = true
cleanup()
}
const trackPointer = (moveEvent: MouseEvent): void => {
latestPointer = moveEvent
if (!(moveEvent.buttons & 1)) {
cancel()
pressedTarget?.ownerDocument.dispatchEvent(
new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window, button })
)
}
}
const replayMove = (): void => {
if (cancelled || !pressedTarget) {
return
}
if (!pressedTarget.isConnected) {
cancel()
return
}
if (!gridItem.classList.contains(activeClass)) {
return
}
cleanup()
cancelled = true
pressedTarget.ownerDocument.dispatchEvent(
new MouseEvent('mousemove', {
bubbles: true,
cancelable: true,
view: window,
clientX: latestPointer.clientX,
clientY: latestPointer.clientY,
button,
buttons: 1,
})
)
}
const tryReplay = (): void => {
if (cancelled) {
return
}
if (!pressedTarget) {
pressedTarget = findTarget()
if (pressedTarget) {
observer = new MutationObserver(replayMove)
observer.observe(gridItem, { attributes: true, attributeFilter: ['class'] })
pressedTarget.dispatchEvent(
new MouseEvent('mousedown', {
bubbles: true,
cancelable: true,
view: window,
clientX,
clientY,
button,
buttons: 1,
})
)
}
}
replayMove()
if (cancelled) {
return
}
framesLeft -= 1
if (framesLeft > 0) {
frame = requestAnimationFrame(tryReplay)
} else {
cleanup()
pressedTarget?.ownerDocument.dispatchEvent(
new MouseEvent('mouseup', { bubbles: true, cancelable: true, view: window, button })
)
}
}
window.addEventListener('mouseup', cancel, { capture: true, once: true })
window.addEventListener('mousemove', trackPointer, { capture: true })
frame = requestAnimationFrame(tryReplay)
}
/** Continue a press on a tile edge into a live resize once edit mode's resize handles have rendered. */
export function continueResizeGestureInEditMode(
event: ReactMouseEvent,
edge: EditModeEdge,
pointerNow: MouseEvent
): void {
const gridItem = (event.target as Element | null)?.closest('.react-grid-item')
if (!gridItem) {
return
}
const rect = gridItem.getBoundingClientRect()
const direction = resolveResizeHandleDirection(edge, rect, event.clientX, event.clientY)
replayMouseDown(
event,
gridItem,
() =>
gridItem.closest('.react-grid-layout.dashboard-edit-mode')
? gridItem.querySelector(`.react-resizable-handle-${direction}`)
: null,
'resizing',
pointerNow
)
}
/** Continue a press on a tile's drag handle into a live drag once edit mode has enabled dragging. */
export function continueDragGestureInEditMode(event: ReactMouseEvent, pointerNow: MouseEvent): void {
const target = event.target as Element | null
const gridItem = target?.closest('.react-grid-item')
if (!target || !gridItem) {
return
}
replayMouseDown(
event,
gridItem,
() =>
// the grid signals that dragging is live by swapping to the edit-mode class
target.isConnected && gridItem.closest('.react-grid-layout.dashboard-edit-mode') ? target : null,
'react-draggable-dragging',
pointerNow
)
}