contextmenu_helpers.ts

Constrains the menu's x coordinate to the layout, shifting left to fit the right edge. Clamps at 0 so a menu wider than the layout pins its left edge - the start of each item stays visible.

Constrains the menu's y coordinate to the layout, shifting up to fit the bottom edge. Clamps at 0 so a menu taller than the layout pins its top edge - the first items stay visible.

Calculates a submenu flyout's translation so it fits the layout.

Preference order on the x axis: fly out to the right of the parent menu, else flip fully to the left of it, else shift to pin whichever side overflows less. The y axis shifts up only as far as needed to fit the bottom edge.

Used by ContextmenuSubmenu.svelte.

Creates a mousedown handler that closes the contextmenu when pressing outside of the menu element, deferring to open_guard for presses that belong to the gesture that opened the menu: gesture presses outside don't close, and gesture presses on the menu arm the click blocker instead of activating the entry under the pointer.

Secondary-button presses outside the menu never close here - their own contextmenu event resolves the menu in the roots' handlers (reopening it elsewhere, or closing it when there's nothing to open) - with one exception: shift+rightclick, an explicit native-menu request whose contextmenu event Firefox suppresses entirely, closes on the press itself.

Registered on the window during the bubble phase deliberately - consumers keep the menu open through a press by swallowing the event (e.g. menu controller buttons that use onmousedowncapture + swallow).

Returns true if valid and narrows the type to HTMLElement | SVGElement.

Handles a contextmenu event by opening the contextmenu from the event target, unless the target is invalid or inside the open menu element. Swallows the event when the menu opens.

Creates an attachment that shows the contextmenu element as a manual popover, promoting it into the top layer so it paints above modal <dialog> elements (e.g. Dialog.svelte) - top-layer elements paint in insertion order.

Painting is only half of it: a modal dialog also makes everything outside its subtree inert. When the menu opens from inside a modal dialog, the menu element is reparented into that dialog (see contextmenu_resolve_popover_host) so it escapes the inert-ness and stays interactive - top-layer positioning is relative to the viewport regardless of ancestors, so the menu's fixed coordinates are unaffected. The host dialog's close also closes the menu, since the menu's DOM node vanishes with the dialog.

No-ops where the Popover API is unavailable (older browsers, jsdom), falling back to --contextmenu_z_index stacking - the menu then renders beneath and inert to any open modal dialog.

Used with the popover="manual" attribute - "manual" rather than "auto" so opening, closing, and keyboard handling stay fully owned by ContextmenuState.

Resolves a contextmenu event: opens the menu from the event target when possible (arming open_guard against the gesture's residual events), otherwise lets the native contextmenu show - closing ours unless the press was on the menu itself.

Shared by ContextmenuRoot.svelte and ContextmenuRootForSafariCompatibility.svelte, after their root-specific bypass and longpress handling.

Resolves the element that must host the contextmenu popover for it to stay interactive: the modal <dialog> containing target, if any.

A modal dialog makes every element outside its subtree inert, and the top layer fixes painting order, not inertness - so a popover shown from outside the dialog paints above it but receives no pointer or focus events (hit-testing skips inert elements). Only the topmost modal dialog's subtree is interactive, so the dialog containing the menu's open target is by construction the one the menu must join.

Tracks the tap-then-longpress gesture that bypasses the Fuz contextmenu, letting users reach the system contextmenu by tapping once then longpressing/rightclicking within a time window.

Plain DOM-event bookkeeping with no reactive state - used only inside event handlers by ContextmenuRoot.svelte and ContextmenuRootForSafariCompatibility.svelte.

Guards the menu from the residual events of the gesture that opened it, using exact gesture causality - no timing heuristics or tunable windows.

Touch: when the menu opens during a touch (the native longpress contextmenu event, or the Safari-compat custom longpress), the release of that same gesture must not interact with the menu - an unprevented touchend lets the browser synthesize compatibility mouse events (mousedown/mouseup/click) at the touch point, and the open offsets place the first menu item exactly there, activating it immediately. touchend swallows the release to stop the synthesis, and consume_blocked_click blocks the next click on the menu as belt and braces (iOS can synthesize the click regardless).

Mouse: tap-style input devices (e.g. some touchpads) can register an overlapping primary-button press during the right-click gesture that opened the menu - the compositor serializes the event stream, but the press's hardware timeStamp falls inside the gesture, and its delivery can lag long after the menu opened. Because the open offsets place the first menu item under the pointer, that press's click would activate the entry. press_belongs_to_open_gesture identifies overlap presses exactly: the press's own buttons bitmask shows the secondary button still down at generation time, or its timeStamp predates the release tracked by track_mouseup. No pressed-state is tracked across events deliberately: the native contextmenu's pointer grab swallows the secondary mouseup whenever it opens (right-click on our menu, shift+rightclick - which in Firefox doesn't even fire the contextmenu event), so a tracked flag wedges stuck, while the judged press's own buttons self-corrects. A deliberate right-then-left click - however fast - is sequential in hardware time and is never blocked.

Plain DOM-event bookkeeping with no reactive state - used only inside event handlers by ContextmenuRoot.svelte and ContextmenuRootForSafariCompatibility.svelte.

Props shared by ContextmenuRoot.svelte and ContextmenuRootForSafariCompatibility.svelte. Defaults are applied identically by both roots.