@fuzdev/fuz_ui 0.202.0 → 0.203.0

package/dist/contextmenu_helpers.js

@@ -1,4 +1,6 @@
 import { is_editable, swallow, inside_editable } from '@fuzdev/fuz_util/dom.js';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+import { contextmenu_open, } from './contextmenu_state.svelte.js';
 // Constants for default prop values
 export const CONTEXTMENU_DEFAULT_OPEN_OFFSET_X = -2;
 export const CONTEXTMENU_DEFAULT_OPEN_OFFSET_Y = -2;
@@ -33,5 +35,404 @@ export const contextmenu_create_keydown_handler = (keyboard_handlers) => (e) =>
     swallow(e);
     handler();
 };
-export const contextmenu_calculate_constrained_x = (menu_x, menu_width, layout_width) => menu_x + Math.min(0, layout_width - (menu_x + menu_width));
-export const contextmenu_calculate_constrained_y = (menu_y, menu_height, layout_height) => menu_y + Math.min(0, layout_height - (menu_y + menu_height));
+/**
+ * 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.
+ */
+export const contextmenu_calculate_constrained_x = (menu_x, menu_width, layout_width) => Math.max(0, menu_x + Math.min(0, layout_width - (menu_x + menu_width)));
+/**
+ * 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.
+ */
+export const contextmenu_calculate_constrained_y = (menu_y, menu_height, layout_height) => Math.max(0, menu_y + Math.min(0, layout_height - (menu_y + menu_height)));
+/**
+ * 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`.
+ */
+export const contextmenu_calculate_submenu_translate = (options) => {
+    const { base_x, base_y, width, height, parent_width, layout_width, layout_height } = options;
+    let x;
+    const overflow_right = base_x + width + parent_width - layout_width;
+    if (overflow_right <= 0) {
+        x = parent_width;
+    }
+    else {
+        const overflow_left = width - base_x;
+        if (overflow_left <= 0) {
+            x = -width;
+        }
+        else if (overflow_left > overflow_right) {
+            x = parent_width - overflow_right;
+        }
+        else {
+            x = overflow_left - width;
+        }
+    }
+    const y = Math.min(0, layout_height - (base_y + height));
+    return { x, y };
+};
+/**
+ * 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.
+ *
+ * @param e - the `contextmenu` event
+ * @param contextmenu - the contextmenu state
+ * @param menu_el - the open menu element, if any, so events inside it are ignored
+ * @param options - offsets and entry filtering forwarded to `contextmenu_open`
+ * @returns whether the contextmenu was opened
+ */
+export const contextmenu_open_from_event = (e, contextmenu, menu_el, options) => {
+    const { open_offset_x = CONTEXTMENU_DEFAULT_OPEN_OFFSET_X, open_offset_y = CONTEXTMENU_DEFAULT_OPEN_OFFSET_Y, } = options ?? EMPTY_OBJECT;
+    const { target } = e;
+    if (!contextmenu_is_valid_target(target, e.shiftKey))
+        return false;
+    // don't open the contextmenu when clicking on the menu itself
+    if (menu_el?.contains(target))
+        return false;
+    if (!contextmenu_open(target, e.clientX + open_offset_x, e.clientY + open_offset_y, contextmenu, options)) {
+        return false;
+    }
+    swallow(e);
+    return true;
+};
+/**
+ * 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.
+ *
+ * @param e - the `contextmenu` event
+ * @param contextmenu - the contextmenu state
+ * @param menu_el - the open menu element, if any
+ * @param open_guard - guard that identifies presses belonging to the gesture that opened the menu
+ * @param options - offsets and entry filtering forwarded to `contextmenu_open`
+ * @returns whether the contextmenu was opened
+ */
+export const contextmenu_resolve_contextmenu_event = (e, contextmenu, menu_el, open_guard, options) => {
+    if (contextmenu_open_from_event(e, contextmenu, menu_el, options)) {
+        // guard the menu from the residual events of the gesture that opened it
+        open_guard.opened();
+        return true;
+    }
+    // The right-click didn't (re)open the menu - a press on the menu itself, an invalid
+    // target, shift bypass, or no entries - so the native contextmenu shows.
+    if (contextmenu.opened && menu_el && !menu_el.contains(e.target)) {
+        // Close ours and let the native contextmenu show. Unmodified secondary-button
+        // presses never close via the mousedown handler; this is where their gesture
+        // resolves (shift+rightclick closes on the press - Firefox suppresses its
+        // `contextmenu` event entirely).
+        contextmenu.close();
+    }
+    return false;
+};
+/**
+ * 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`).
+ *
+ * @param contextmenu - the contextmenu state
+ * @param get_menu_el - getter for the open menu element, if any
+ * @param open_guard - guard that identifies presses belonging to the gesture that opened the menu
+ */
+// TODO consider `popover="auto"` instead of `"manual"` (see `contextmenu_popover_attachment`) -
+// its light dismiss would replace this handler and fix Escape ordering over dialogs
+// via close watchers, but it would break consumers that swallow `mousedown` to keep
+// the menu open through presses on their own controls
+export const contextmenu_create_mousedown_handler = (contextmenu, get_menu_el, open_guard) => (e) => {
+    const menu_el = get_menu_el();
+    if (!menu_el)
+        return;
+    if (menu_el.contains(e.target)) {
+        // a press on the menu belonging to the opening gesture must not click-activate
+        open_guard?.mousedown_on_menu(e);
+        return;
+    }
+    // A shift+rightclick is an explicit native-menu request that our handlers may
+    // never see resolve - Firefox suppresses its `contextmenu` event entirely - so
+    // close on the press itself, matching the unsuppressed outcome in other browsers.
+    if (e.button === 2 && e.shiftKey) {
+        contextmenu.close();
+        return;
+    }
+    // Presses belonging to the opening gesture must not close the menu. This includes
+    // all secondary-button presses - their own `contextmenu` event resolves the menu
+    // (reopening it elsewhere, or closing it when there's nothing to open).
+    if (open_guard?.press_belongs_to_open_gesture(e))
+        return;
+    contextmenu.close();
+};
+/**
+ * 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.
+ *
+ * @param target - the element the menu was opened from
+ * @returns the modal dialog to reparent the menu into, or `null` when the menu
+ * doesn't need a host
+ */
+export const contextmenu_resolve_popover_host = (target) => target?.closest('dialog:modal') ?? null;
+/**
+ * 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`.
+ */
+export const contextmenu_popover_attachment = (contextmenu) => (el) => {
+    if (!el.showPopover)
+        return;
+    const host = contextmenu_resolve_popover_host(contextmenu.target);
+    // reparent before showing - moving a shown popover would hide it
+    if (host)
+        host.appendChild(el);
+    // guard the reactive re-run when the `contextmenu` prop changes identity -
+    // `showPopover()` throws on an already-shown popover
+    if (!el.matches(':popover-open'))
+        el.showPopover();
+    if (!host)
+        return;
+    const onclose = () => {
+        contextmenu.close();
+    };
+    host.addEventListener('close', onclose);
+    return () => {
+        host.removeEventListener('close', onclose);
+    };
+};
+/**
+ * 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`.
+ */
+export class ContextmenuOpenGuard {
+    #touch_active = false;
+    #opened_by_touch = false;
+    #block_next_click = false;
+    #last_secondary_up_time = -Infinity;
+    #last_touch_end_time = -Infinity;
+    /**
+     * Begins a new gesture on `touchstart`, clearing stale flags from the previous one.
+     */
+    touchstart() {
+        this.#touch_active = true;
+        this.#opened_by_touch = false;
+        this.#block_next_click = false;
+    }
+    /**
+     * Arms the touch release guard for the gesture that just opened the menu.
+     * Call after a successful open.
+     */
+    opened() {
+        if (this.#touch_active)
+            this.#opened_by_touch = true;
+    }
+    /**
+     * Tracks the physical secondary button's release - call from an always-on
+     * window `mouseup` capture listener. The release may never be delivered
+     * (the native contextmenu's pointer grab eats it), which is why
+     * `press_belongs_to_open_gesture` never depends on it alone.
+     */
+    track_mouseup(e) {
+        if (e.button === 2) {
+            this.#last_secondary_up_time = e.timeStamp;
+        }
+    }
+    /**
+     * Returns `true` when a press belongs to the gesture that opened the menu
+     * rather than being a deliberate response to it:
+     * secondary-button presses (their own `contextmenu` event resolves them),
+     * presses during or predating an active touch (synthesized compatibility events),
+     * and presses overlapping the secondary button in hardware time - 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`.
+     */
+    press_belongs_to_open_gesture(e) {
+        if (e.button === 2)
+            return true;
+        if (this.#touch_active || e.timeStamp <= this.#last_touch_end_time)
+            return true;
+        return (e.buttons & 2) !== 0 || e.timeStamp <= this.#last_secondary_up_time;
+    }
+    /**
+     * Handles a `mousedown` that landed on the menu element: when a primary-button
+     * press belongs to the opening gesture, its `click` is blocked from activating the
+     * entry that the open offsets placed under the pointer. Non-primary presses never
+     * arm the blocker - they produce no `click`, so an armed blocker would linger and
+     * eat the next deliberate click on the menu.
+     */
+    mousedown_on_menu(e) {
+        if (e.button === 0 && this.press_belongs_to_open_gesture(e)) {
+            this.#block_next_click = true;
+        }
+    }
+    /**
+     * Handles `touchend`: when the release belongs to the gesture that opened the menu,
+     * swallows it (stopping mouse event synthesis) and arms the click blocker,
+     * returning `true`.
+     */
+    touchend(e) {
+        this.#touch_active = e.touches.length > 0;
+        this.#last_touch_end_time = e.timeStamp;
+        if (!this.#opened_by_touch)
+            return false;
+        this.#opened_by_touch = false;
+        swallow(e);
+        this.#block_next_click = true;
+        return true;
+    }
+    /**
+     * Clears gesture state, including any armed click blocker. Call on `touchcancel`.
+     * The secondary release timestamp persists - it mirrors hardware history,
+     * not gesture state.
+     */
+    reset() {
+        this.#touch_active = false;
+        this.#opened_by_touch = false;
+        this.#block_next_click = false;
+    }
+    /**
+     * Consumes an armed click blocker, returning `true` if the click should be swallowed.
+     * Call from the menu element's `click` capture handler.
+     */
+    consume_blocked_click() {
+        if (!this.#block_next_click)
+            return false;
+        this.#block_next_click = false;
+        return true;
+    }
+}
+/**
+ * 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`.
+ */
+export class ContextmenuBypassTracker {
+    #first_tap_time = null;
+    #touch_x = 0;
+    #touch_y = 0;
+    #timeout = null;
+    /**
+     * Set when a tap-then-longpress is detected,
+     * telling the next `contextmenu` event handler to let the system contextmenu through.
+     */
+    bypassed = false;
+    /**
+     * Records a single-touch `touchstart` at the given coordinates.
+     * Detects a tap-then-longpress when the previous tap happened within `bypass_window`
+     * milliseconds and moved less than `bypass_move_tolerance` pixels,
+     * setting `bypassed` and returning `true`.
+     * Otherwise records the tap for future detection and returns `false`.
+     */
+    track(x, y, bypass_window, bypass_move_tolerance) {
+        if (this.#first_tap_time !== null &&
+            performance.now() - this.#first_tap_time < bypass_window &&
+            Math.hypot(x - this.#touch_x, y - this.#touch_y) < bypass_move_tolerance) {
+            this.bypassed = true;
+            this.#clear_tap_tracking();
+            return true;
+        }
+        this.#first_tap_time = performance.now();
+        this.#touch_x = x;
+        this.#touch_y = y;
+        // clear stale tap tracking after the detection window expires
+        if (this.#timeout !== null)
+            clearTimeout(this.#timeout);
+        this.#timeout = setTimeout(() => {
+            this.reset();
+        }, bypass_window);
+        return false;
+    }
+    /**
+     * Consumes a pending bypass, returning `true` and resetting all state if `bypassed` was set,
+     * otherwise returning `false` with no effect so tap tracking is preserved.
+     */
+    consume() {
+        if (!this.bypassed)
+            return false;
+        this.reset();
+        return true;
+    }
+    /**
+     * Clears all tracking state including any pending bypass.
+     */
+    reset() {
+        this.bypassed = false;
+        this.#clear_tap_tracking();
+    }
+    #clear_tap_tracking() {
+        this.#first_tap_time = null;
+        if (this.#timeout !== null) {
+            clearTimeout(this.#timeout);
+            this.#timeout = null;
+        }
+    }
+}

package/dist/contextmenu_state.svelte.d.ts

@@ -3,6 +3,7 @@ import type { Result } from '@fuzdev/fuz_util/result.js';
 import type { SvelteHTMLElements } from 'svelte/elements';
 import type { Attachment } from 'svelte/attachments';
 import { Dimensions } from './dimensions.svelte.js';
+import type { SvgData } from './svg.js';
 export declare const contextmenu_context: {
     get: (error_message?: string) => () => ContextmenuState;
     get_maybe: () => (() => ContextmenuState) | undefined;
@@ -27,7 +28,7 @@ export type ContextmenuParams = Snippet | {
     snippet: 'text';
     props: {
         content: string;
-        icon: string;
+        icon: SvgData | string;
         run: ContextmenuRun;
     };
 } | {
@@ -51,31 +52,54 @@ export declare class EntryState {
     promise: Promise<ContextmenuActivateResult> | null;
     constructor(menu: SubmenuState | RootMenuState, run: () => ContextmenuRun, disabled?: () => boolean);
 }
-export declare class SubmenuState {
+/**
+ * Shared `items` state for `SubmenuState` and `RootMenuState`.
+ *
+ * The source of truth is a plain non-reactive array because items register and
+ * unregister from component lifecycles that can interleave within a single batch -
+ * effect teardowns can observe stale signal values mid-batch, so read-copy-write
+ * against the reactive array can lose concurrent registrations (e.g. reopening the
+ * menu while it's open). Every mutation publishes an immutable snapshot, preserving
+ * the reassignment (not mutation) contract for readers.
+ */
+export declare class ContextmenuItemsState {
+    #private;
+    get items(): ReadonlyArray<ItemState>;
+    set items(value: ReadonlyArray<ItemState>);
+    /**
+     * Appends `item`, publishing a new immutable `items`.
+     */
+    add_item(item: ItemState): void;
+    /**
+     * Removes `item` if present, publishing a new immutable `items`.
+     * Safe to call from effect teardown - it reads only the non-reactive source array.
+     */
+    remove_item(item: ItemState): void;
+}
+export declare class SubmenuState extends ContextmenuItemsState {
     readonly is_menu = true;
     readonly menu: SubmenuState | RootMenuState;
     readonly depth: number;
     selected: boolean;
-    items: ReadonlyArray<ItemState>;
     constructor(menu: SubmenuState | RootMenuState, depth: number);
 }
-export declare class RootMenuState {
+export declare class RootMenuState extends ContextmenuItemsState {
     readonly is_menu = true;
     readonly menu: null;
     readonly depth = 1;
-    items: ReadonlyArray<ItemState>;
 }
 export type ContextmenuRun = () => ContextmenuActivateResult | Promise<ContextmenuActivateResult>;
 export interface ContextmenuStateOptions {
     layout?: Dimensions;
 }
 /**
- * Creates a contextmenu store.
+ * Manages contextmenu state.
  * See usage with `ContextmenuRoot.svelte` and `Contextmenu.svelte`.
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Element/contextmenu_event}
  */
 export declare class ContextmenuState {
+    #private;
     layout: Dimensions;
     /**
      * If an initial layout is provided, control is deferred externally.
@@ -87,21 +111,42 @@ export declare class ContextmenuState {
     y: number;
     params: ReadonlyArray<ContextmenuParams>;
     error: string | undefined;
+    /**
+     * The element the menu was opened from, while opened, else `undefined`.
+     * Resolves the popover host when the menu opens inside a modal `<dialog>` -
+     * see `contextmenu_resolve_popover_host`. Deliberately not reactive -
+     * read it in event handlers and attachments, not in templates.
+     */
+    target: HTMLElement | SVGElement | undefined;
     readonly root_menu: RootMenuState;
     selections: ReadonlyArray<ItemState>;
     can_collapse: boolean;
     can_expand: boolean;
-    can_select_next: boolean;
-    can_select_previous: boolean;
+    /**
+     * Whether `select_next` and `select_previous` can move the selection -
+     * the selected menu has more than one item.
+     */
+    can_select_sibling: boolean;
     can_activate: boolean;
     constructor(options?: ContextmenuStateOptions);
-    open(params: Array<ContextmenuParams>, x: number, y: number): void;
+    open(params: Array<ContextmenuParams>, x: number, y: number, target?: HTMLElement | SVGElement): void;
     close(): void;
     reset_items(items: ReadonlyArray<ItemState>): void;
+    /**
+     * Activates `item` - expanding submenus, running entries.
+     *
+     * @returns for async runs, the activation promise; for sync runs, `false` when the
+     * activation didn't run (disabled) or failed (a throw or `{ok: false}`), else `true`
+     */
     activate(item: ItemState): boolean | Promise<ContextmenuActivateResult>;
+    /**
+     * Activates the selected item, or if none is selected, selects the first.
+     * Returns `false` without activating when the selected item has unregistered
+     * out from under the selection (e.g. its component unmounted).
+     */
     activate_selected(): void | boolean | Promise<ContextmenuActivateResult>;
     /**
-     * Activates the selected entry, or if none, selects the first.
+     * Selects `item` and its ancestor menus, deselecting everything else.
      */
     select(item: ItemState): void;
     collapse_selected(): void;
@@ -124,7 +169,7 @@ export declare class ContextmenuState {
  * Creates an attachment that sets up contextmenu behavior on an element.
  * @param params - contextmenu parameters or nullish to disable
  */
-export declare const contextmenu_attachment: <T extends ContextmenuParams, U extends T | Array<T>>(params: U | null | undefined) => Attachment<HTMLElement | SVGElement>;
+export declare const contextmenu_attachment: (params: ContextmenuParams | Array<ContextmenuParams> | null | undefined) => Attachment<HTMLElement | SVGElement>;
 export interface ContextmenuOpenOptions {
     link_enabled?: boolean;
     text_enabled?: boolean;
@@ -135,16 +180,17 @@ export interface ContextmenuOpenOptions {
  * Opens the contextmenu, if appropriate,
  * querying the menu items from the DOM starting at the event target.
  * @param target - the leaf element from which to open the contextmenu
- * @param x - the page X coordinate at which to open the contextmenu, typically the mouse `pageX`
- * @param y - the page Y coordinate at which to open the contextmenu, typically the mouse `pageY`
- * @param contextmenu - the contextmenu store
+ * @param x - the client (viewport) X coordinate at which to open the contextmenu, typically the mouse `clientX` - the menu positions with `fixed`
+ * @param y - the client (viewport) Y coordinate at which to open the contextmenu, typically the mouse `clientY` - the menu positions with `fixed`
+ * @param contextmenu - the contextmenu state
  * @param options - optional configuration for filtering entries and haptic feedback
  * @returns a boolean indicating if the menu was opened or not
  */
 export declare const contextmenu_open: (target: HTMLElement | SVGElement, x: number, y: number, contextmenu: ContextmenuState, options?: ContextmenuOpenOptions) => boolean;
 /**
  * Registers a contextmenu root and warns if multiple non-scoped roots are detected.
- * Only active in development mode. Automatically handles cleanup on unmount.
+ * Only active in development mode - `DEV` is a build-time constant, so production
+ * bundles eliminate the check. Automatically handles cleanup on unmount.
  *
  * @param get_scoped - getter function that returns the current scoped value
  */

package/dist/contextmenu_state.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextmenu_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/contextmenu_state.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,OAAO,EAAC,MAAM,QAAQ,CAAC;AAC/C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAGvD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAIlD,eAAO,MAAM,mBAAmB;2CAAwB,gBAAgB;4BAAhB,gBAAgB;uBAAhB,gBAAgB,WAAhB,gBAAgB;CAAG,CAAC;AAE5E,eAAO,MAAM,2BAA2B;;;;CAAiC,CAAC;AAE1E,eAAO,MAAM,8BAA8B;;;CAAyC,CAAC;AAErF,MAAM,MAAM,iBAAiB,GAC1B,OAAO,GAEP;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,CAAA;CAAC,GACvD;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,cAAc,CAAA;KAAC,CAAA;CAAC,GAC9E;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAC,IAAI,CAAC,CAAA;CAAC,CAAC;AAE3D,MAAM,MAAM,yBAAyB,GAClC,IAAI,GACJ,SAAS,GACT,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAC,EAAE;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAEjD,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;AAElD,qBAAa,UAAU;IACtB,QAAQ,CAAC,OAAO,SAAS;IACzB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC;IAE5C,QAAQ,CAAC,GAAG,EAAE,MAAM,cAAc,CAAC;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC;IAEjC,QAAQ,EAAE,OAAO,CAAqB;IACtC,OAAO,EAAE,OAAO,CAAqB;IACrC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAoB;IAChD,OAAO,EAAE,OAAO,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAAoB;gBAGrE,IAAI,EAAE,YAAY,GAAG,aAAa,EAClC,GAAG,EAAE,MAAM,cAAc,EACzB,QAAQ,GAAE,MAAM,OAAqB;CAMtC;AAED,qBAAa,YAAY;IACxB,QAAQ,CAAC,OAAO,QAAQ;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,QAAQ,EAAE,OAAO,CAAqB;IACtC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAkB;gBAErC,IAAI,EAAE,YAAY,GAAG,aAAa,EAAE,KAAK,EAAE,MAAM;CAI7D;AAED,qBAAa,aAAa;IACzB,QAAQ,CAAC,OAAO,QAAQ;IACxB,QAAQ,CAAC,IAAI,OAAQ;IACrB,QAAQ,CAAC,KAAK,KAAK;IAEnB,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAkB;CACjD;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAC;AAElG,MAAM,WAAW,uBAAuB;IACvC,MAAM,CAAC,EAAE,UAAU,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IAGpC,MAAM,EAAE,OAAO,CAAqB;IACpC,CAAC,EAAE,MAAM,CAAiB;IAC1B,CAAC,EAAE,MAAM,CAAiB;IAC1B,MAAM,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAkB;IAC1D,KAAK,EAAE,MAAM,GAAG,SAAS,CAAgB;IAMzC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAuB;IACxD,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,CAAkB;IAEtD,YAAY,UAAwC;IAEpD,UAAU,UAGP;IAEH,eAAe,UAGZ;IAEH,mBAAmB,UAGhB;IAEH,YAAY,UAKT;gBAES,OAAO,GAAE,uBAAsC;IAO3D,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAQlE,KAAK,IAAI,IAAI;IAMb,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI;IAYlD,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAqEvE,iBAAiB,IAAI,IAAI,GAAG,OAAO,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAYxE;;OAEG;IAEH,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAY7B,iBAAiB,IAAI,IAAI;IAOzB,eAAe,IAAI,IAAI;IASvB,WAAW,IAAI,IAAI;IAUnB,eAAe,IAAI,IAAI;IAUvB,YAAY,IAAI,IAAI;IAMpB,WAAW,IAAI,IAAI;IAMnB;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,cAAc,EAAE,QAAQ,GAAE,MAAM,OAAqB,GAAG,UAAU;IAWvF;;OAEG;IACH,WAAW,IAAI,YAAY;CAW3B;AASD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GACjC,CAAC,SAAS,iBAAiB,EAAE,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,EACnD,QAAQ,CAAC,GAAG,IAAI,GAAG,SAAS,KAC1B,UAAU,CAAC,WAAW,GAAG,UAAU,CAiBrC,CAAC;AAIH,MAAM,WAAW,sBAAsB;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAC5B,QAAQ,WAAW,GAAG,UAAU,EAChC,GAAG,MAAM,EACT,GAAG,MAAM,EACT,aAAa,gBAAgB,EAC7B,UAAU,sBAAsB,KAC9B,OA8BF,CAAC;AAsDF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,YAAY,MAAM,OAAO,KAAG,IAuBzE,CAAC"}
+{"version":3,"file":"contextmenu_state.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/contextmenu_state.svelte.ts"],"names":[],"mappings":"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"}