@fuzdev/fuz_ui 0.202.0 → 0.203.1

package/dist/contextmenu_helpers.d.ts

@@ -1,16 +1,339 @@
-import type { ContextmenuState } from './contextmenu_state.svelte.js';
+import type { Attachment } from 'svelte/attachments';
+import type { ComponentProps, Snippet } from 'svelte';
+import { type ContextmenuOpenOptions, type ContextmenuState } from './contextmenu_state.svelte.js';
+import type ContextmenuLinkEntry from './ContextmenuLinkEntry.svelte';
+import type ContextmenuTextEntry from './ContextmenuTextEntry.svelte';
+import type ContextmenuSeparator from './ContextmenuSeparator.svelte';
 export declare const CONTEXTMENU_DEFAULT_OPEN_OFFSET_X = -2;
 export declare const CONTEXTMENU_DEFAULT_OPEN_OFFSET_Y = -2;
 export declare const CONTEXTMENU_DEFAULT_BYPASS_WINDOW = 750;
 export declare const CONTEXTMENU_DEFAULT_BYPASS_MOVE_TOLERANCE = 11;
 export declare const CONTEXTMENU_DEFAULT_LONGPRESS_DURATION = 633;
 export declare const CONTEXTMENU_DEFAULT_LONGPRESS_MOVE_TOLERANCE = 21;
+/**
+ * Props shared by `ContextmenuRoot.svelte` and `ContextmenuRootForSafariCompatibility.svelte`.
+ * Defaults are applied identically by both roots.
+ */
+export interface ContextmenuRootBaseProps {
+    /**
+     * The contextmenu state. Each root defaults to its own new instance -
+     * pass one to control or observe the menu externally.
+     */
+    contextmenu?: ContextmenuState;
+    /**
+     * The number of pixels to offset from the pointer X position when opened.
+     * Useful to ensure the first menu item is immediately under the pointer.
+     */
+    open_offset_x?: number;
+    /**
+     * The number of pixels to offset from the pointer Y position when opened.
+     * Useful to ensure the first menu item is immediately under the pointer.
+     */
+    open_offset_y?: number;
+    /**
+     * Whether to detect tap-then-longpress to bypass the Fuz contextmenu.
+     * This allows access to the system contextmenu by tapping once then rightclicking/long-pressing.
+     * Setting to `false` disables the gesture.
+     */
+    bypass_with_tap_then_longpress?: boolean;
+    /**
+     * The number of milliseconds between taps to detect a gesture that bypasses the Fuz contextmenu.
+     * Used only when `bypass_with_tap_then_longpress` is true.
+     * If the duration is too long, it'll detect more false positives and interrupt normal usage,
+     * but too short and some people will have difficulty performing the gesture.
+     */
+    bypass_window?: number;
+    /**
+     * The number of pixels the pointer can be moved between taps to detect a tap-then-longpress.
+     * Used only when `bypass_with_tap_then_longpress` is true.
+     */
+    bypass_move_tolerance?: number;
+    /**
+     * If `true`, wraps `children` with a div and listens to events on it instead of the window.
+     */
+    scoped?: boolean;
+    /**
+     * Snippet for rendering link entries.
+     * Set to `null` to disable automatic link detection.
+     * Defaults to `link_entry_default` which renders `ContextmenuLinkEntry`.
+     */
+    link_entry?: Snippet<[ComponentProps<typeof ContextmenuLinkEntry>]> | null;
+    /**
+     * Snippet for rendering copy text entries.
+     * Set to `null` to disable automatic copy text detection.
+     * Defaults to `text_entry_default` which renders `ContextmenuTextEntry`.
+     */
+    text_entry?: Snippet<[ComponentProps<typeof ContextmenuTextEntry>]> | null;
+    /**
+     * Snippet for rendering separator entries.
+     * Set to `null` to disable automatic separator rendering.
+     * Defaults to `separator_entry_default` which renders `ContextmenuSeparator`.
+     */
+    separator_entry?: Snippet<[ComponentProps<typeof ContextmenuSeparator>]> | null;
+    /**
+     * The content the root listens over for contextmenu gestures.
+     */
+    children: Snippet;
+}
 /**
  * Returns true if valid and narrows the type to HTMLElement | SVGElement.
  */
 export declare const contextmenu_is_valid_target: (target: EventTarget | null, shiftKey: boolean) => target is HTMLElement | SVGElement;
 export declare const contextmenu_create_keyboard_handlers: (contextmenu: ContextmenuState) => Map<string, () => void>;
 export declare const contextmenu_create_keydown_handler: (keyboard_handlers: Map<string, () => void>) => ((e: KeyboardEvent) => void);
+/**
+ * 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 declare const contextmenu_calculate_constrained_x: (menu_x: number, menu_width: number, layout_width: number) => number;
+/**
+ * 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 declare const contextmenu_calculate_constrained_y: (menu_y: number, menu_height: number, layout_height: number) => number;
+export interface ContextmenuSubmenuTranslateOptions {
+    /** The submenu's untranslated viewport x - the parent menu's left edge. */
+    base_x: number;
+    /** The submenu's untranslated viewport y. */
+    base_y: number;
+    /** The submenu's width. */
+    width: number;
+    /** The submenu's height. */
+    height: number;
+    /** The parent menu's width. */
+    parent_width: number;
+    /** The layout's width. */
+    layout_width: number;
+    /** The layout's height. */
+    layout_height: number;
+}
+/**
+ * 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 declare const contextmenu_calculate_submenu_translate: (options: ContextmenuSubmenuTranslateOptions) => {
+    x: number;
+    y: number;
+};
+export interface ContextmenuOpenFromEventOptions extends ContextmenuOpenOptions {
+    /**
+     * The number of pixels to offset from the pointer X position when opened.
+     */
+    open_offset_x?: number;
+    /**
+     * The number of pixels to offset from the pointer Y position when opened.
+     */
+    open_offset_y?: number;
+}
+/**
+ * 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 declare const contextmenu_open_from_event: (e: MouseEvent, contextmenu: ContextmenuState, menu_el: HTMLElement | undefined, options?: ContextmenuOpenFromEventOptions) => boolean;
+/**
+ * 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 declare const contextmenu_resolve_contextmenu_event: (e: MouseEvent, contextmenu: ContextmenuState, menu_el: HTMLElement | undefined, open_guard: ContextmenuOpenGuard, options?: ContextmenuOpenFromEventOptions) => boolean;
+/**
+ * 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
+ */
+export declare const contextmenu_create_mousedown_handler: (contextmenu: ContextmenuState, get_menu_el: () => HTMLElement | undefined, open_guard?: ContextmenuOpenGuard) => (e: MouseEvent) => void;
+/**
+ * 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 declare const contextmenu_resolve_popover_host: (target: HTMLElement | SVGElement | undefined) => HTMLDialogElement | 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 declare const contextmenu_popover_attachment: (contextmenu: ContextmenuState) => Attachment<HTMLElement>;
+/**
+ * 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 declare class ContextmenuOpenGuard {
+    #private;
+    /**
+     * Begins a new gesture on `touchstart`, clearing stale flags from the previous one.
+     */
+    touchstart(): void;
+    /**
+     * Arms the touch release guard for the gesture that just opened the menu.
+     * Call after a successful open.
+     */
+    opened(): void;
+    /**
+     * 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: MouseEvent): void;
+    /**
+     * 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: MouseEvent): boolean;
+    /**
+     * 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: MouseEvent): void;
+    /**
+     * 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: TouchEvent): boolean;
+    /**
+     * Clears gesture state, including any armed click blocker. Call on `touchcancel`.
+     * The secondary release timestamp persists - it mirrors hardware history,
+     * not gesture state.
+     */
+    reset(): void;
+    /**
+     * 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(): boolean;
+}
+/**
+ * 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 declare class ContextmenuBypassTracker {
+    #private;
+    /**
+     * Set when a tap-then-longpress is detected,
+     * telling the next `contextmenu` event handler to let the system contextmenu through.
+     */
+    bypassed: boolean;
+    /**
+     * 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: number, y: number, bypass_window: number, bypass_move_tolerance: number): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * Clears all tracking state including any pending bypass.
+     */
+    reset(): void;
+}
 //# sourceMappingURL=contextmenu_helpers.d.ts.map

package/dist/contextmenu_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextmenu_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/contextmenu_helpers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,+BAA+B,CAAC;AAGpE,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,iCAAiC,KAAK,CAAC;AACpD,eAAO,MAAM,iCAAiC,MAAM,CAAC;AACrD,eAAO,MAAM,yCAAyC,KAAK,CAAC;AAC5D,eAAO,MAAM,sCAAsC,MAAM,CAAC;AAC1D,eAAO,MAAM,4CAA4C,KAAK,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACvC,QAAQ,WAAW,GAAG,IAAI,EAC1B,UAAU,OAAO,KACf,MAAM,IAAI,WAAW,GAAG,UAIF,CAAC;AAI1B,eAAO,MAAM,oCAAoC,GAChD,aAAa,gBAAgB,KAC3B,GAAG,CAAC,MAAM,EAAE,MAAM,IAAI,CAWtB,CAAC;AAEJ,eAAO,MAAM,kCAAkC,GAC7C,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,KAAG,CAAC,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAMxE,CAAC;AAEH,eAAO,MAAM,mCAAmC,GAC/C,QAAQ,MAAM,EACd,YAAY,MAAM,EAClB,cAAc,MAAM,KAClB,MAAoE,CAAC;AAExE,eAAO,MAAM,mCAAmC,GAC/C,QAAQ,MAAM,EACd,aAAa,MAAM,EACnB,eAAe,MAAM,KACnB,MAAsE,CAAC"}
+{"version":3,"file":"contextmenu_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/contextmenu_helpers.ts"],"names":[],"mappings":"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"}