@bazza-ui/react 0.0.0 → 0.1.0-canary.10

package/dist/type-guards-BC2B6bVi.d.cts

@@ -0,0 +1,350 @@
+import * as React from 'react';
+import { PopoverPositionerProps, Popover, PopoverRootProps } from '@base-ui/react/popover';
+import { U as UseListboxItemParams, f as UseListboxItemReturn, b as GroupPositional } from './use-listbox-item-NzZuY34-.cjs';
+import { C as ComponentProps } from './types-DT4FOOa2.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { B as PopupMenuItemState, A as PopupMenuItemProps, P as PopupMenuHighlightChangeHandler, aS as HighlightChangeEventDetails, N as NodeDef, aG as TreeItemDef } from './events-DPsuhBln.cjs';
+import { V as VirtualItem } from './ListboxStore-nmorsoqX.cjs';
+import { a as PopupMenuRootActions } from './scroll-arrow-B81wZTZ2.cjs';
+
+interface SubmenuContextValue {
+    /** Whether the submenu is open */
+    open: boolean;
+    /** Set the submenu open state */
+    setOpen: (open: boolean) => void;
+    /**
+     * Latch set by explicit close actions (keyboard ArrowLeft/Ctrl+H/Escape-in-submenu,
+     * or clicking the open trigger). While set and the trigger remains highlighted,
+     * pointer/keyboard auto-open is suppressed. Reset when highlight leaves the trigger.
+     */
+    suppressAutoOpenRef: React.MutableRefObject<boolean>;
+    /** Reference to the trigger element */
+    triggerRef: React.RefObject<HTMLElement | null>;
+    /** Reference to the submenu content element (for aim guard rect calculations) */
+    contentRef: React.RefObject<HTMLElement | null>;
+    /** Surface ID of the parent menu (for keyboard navigation back) */
+    parentSurfaceId: string;
+    /** Surface ID of this submenu (for keyboard navigation into) */
+    childSurfaceId: string;
+    /**
+     * Whether pressing Escape in this submenu closes the entire menu from the root.
+     * When true, Escape closes the entire menu tree.
+     * When false, Escape only closes this submenu and moves focus to the parent.
+     * @default true
+     */
+    closeRootOnEsc: boolean;
+}
+declare function useSubmenuContext(): SubmenuContextValue;
+declare function useMaybeSubmenuContext(): SubmenuContextValue | null;
+
+interface SubpageContextValue {
+    /** Current page ID. */
+    pageId: string;
+    /** Surface ID for this page. */
+    surfaceId: string;
+    /** Surface ID for the previous page, if available. */
+    parentSurfaceId: string | null;
+    /** Whether this page is currently active. */
+    isActive: boolean;
+    /** Whether Escape should close the entire menu tree from this page. */
+    closeRootOnEsc: boolean;
+    /** Navigate back one page. Returns true when navigation happened. */
+    goBack: () => boolean;
+}
+declare function useSubpageContext(): SubpageContextValue;
+declare function useMaybeSubpageContext(): SubpageContextValue | null;
+
+interface SubpageRegistration {
+    pageId: string;
+    surfaceId: string;
+    closeRootOnEsc: boolean;
+}
+interface SubpageStackContextValue {
+    /** Active page ID; `null` when the root surface is active. */
+    activePageId: string | null;
+    /** Surface ID of the root surface. */
+    rootSurfaceId: string;
+    /** Surface ID for the currently active page. */
+    activeSurfaceId: string;
+    /** Whether there is a previous page to navigate back to. */
+    canGoBack: boolean;
+    /** Whether Escape in the active page should close the entire menu tree. */
+    shouldCloseRootOnEsc: boolean;
+    /** Open page IDs, bottom to top; empty at root. */
+    stack: readonly string[];
+    /** Register a page and return an unregister cleanup. */
+    registerPage: (registration: SubpageRegistration) => () => void;
+    /** Push a page onto the stack. Returns true when navigation happened. */
+    openPage: (pageId: string) => boolean;
+    /** Pop one page from the stack. Returns true when navigation happened. */
+    goBack: () => boolean;
+    /** Resolve a surface ID for a page ID. */
+    getSurfaceId: (pageId: string) => string | null;
+}
+declare const SubpageStackContext: React.Context<SubpageStackContextValue | null>;
+declare function useSubpageStack(): SubpageStackContextValue;
+declare function useMaybeSubpageStack(): SubpageStackContextValue | null;
+
+/**
+ * Extended align options for popup menus.
+ * - 'start' | 'center' | 'end': Standard Base UI alignment
+ * - 'list-start': Align trigger top with the top of the List component (horizontal sides only)
+ */
+type PopupMenuPositionerAlign = PopoverPositionerProps['align'] | 'list-start';
+interface PopupMenuPositionerProps extends Omit<PopoverPositionerProps, 'align' | 'style'> {
+    /**
+     * Override the virtual anchor from context.
+     * Useful for nested menus that need different positioning.
+     */
+    virtualAnchor?: {
+        getBoundingClientRect(): DOMRect;
+    };
+    /**
+     * How to align the popup relative to the specified side.
+     * - 'start': align to start of anchor
+     * - 'center': align to center of anchor
+     * - 'end': align to end of anchor
+     * - 'list-start': align the List component's top with the anchor top (horizontal sides only)
+     * @default 'start' for submenus, 'center' for root dropdowns
+     */
+    align?: PopupMenuPositionerAlign;
+    /**
+     * Custom styles for the positioner.
+     * Note: During list-start alignment measurement, `transition: 'none'` is
+     * temporarily applied to prevent visual flash.
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Positions the popup menu against its anchor.
+ * Wraps Popover.Positioner with:
+ * - Automatic virtualAnchor from PopupMenuContext (for context menus)
+ * - Smart default positioning based on depth and menu type
+ * - Smart collision avoidance: shift for horizontal menus, flip for vertical
+ * - 'list-start' alignment for horizontal submenus
+ *
+ * Renders a `<div>` element.
+ */
+declare const PopupMenuPositioner: React.ForwardRefExoticComponent<Omit<PopupMenuPositionerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuPositioner {
+    type Props = PopupMenuPositionerProps;
+    type State = Popover.Positioner.State;
+}
+
+interface UsePopupMenuItemParams extends Omit<UseListboxItemParams, 'aimGuard' | 'onAfterSelect'> {
+    /**
+     * Whether clicking this item should close the menu.
+     * @default true
+     */
+    closeOnClick?: boolean;
+}
+interface UsePopupMenuItemReturn extends UseListboxItemReturn {
+    /** Whether this item is effectively disabled (item disabled OR menu disabled). */
+    disabled: boolean;
+}
+/**
+ * Hook that provides all shared logic for navigatable/highlightable popup menu items.
+ * This is a thin wrapper around useListboxItem that automatically adds aim-guard
+ * support and handles close-on-click behavior.
+ *
+ * @see useListboxItem for full documentation
+ */
+declare function usePopupMenuItem(params: UsePopupMenuItemParams): UsePopupMenuItemReturn;
+
+interface PopupMenuRadioItemIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the parent radio item is currently selected/checked.
+     */
+    checked: boolean;
+    /**
+     * Whether the parent radio item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the parent radio item is disabled.
+     */
+    disabled: boolean;
+}
+interface PopupMenuRadioItemIndicatorProps extends ComponentProps<'span', PopupMenuRadioItemIndicator.State> {
+    /**
+     * Whether to keep the indicator mounted in the DOM when unchecked.
+     * Useful for animations.
+     * @default false
+     */
+    keepMounted?: boolean;
+}
+/**
+ * A visual indicator that shows when a RadioItem is selected.
+ * Must be used within a RadioItem component.
+ * Renders a `<span>` element with aria-hidden="true".
+ */
+declare const PopupMenuRadioItemIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuRadioItemIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuRadioItemIndicator {
+    type State = PopupMenuRadioItemIndicatorState;
+    interface Props extends PopupMenuRadioItemIndicatorProps {
+    }
+}
+
+interface PopupMenuGroupValueProps {
+    /** Group id items register under. Omit for ungrouped rows that only need positional flags. */
+    groupId?: string;
+    /** Positional flags for this row; each defined flag overrides the store-derived value. */
+    positional?: GroupPositional;
+    children: React.ReactNode;
+}
+/**
+ * Headless provider for group membership and positional state.
+ * Renders no DOM. Use to wrap individual rows in virtualized lists where
+ * the store cannot derive position from mounted order.
+ */
+declare function PopupMenuGroupValue(props: PopupMenuGroupValueProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuGroupValue {
+    interface Props extends PopupMenuGroupValueProps {
+    }
+}
+
+interface PopupMenuTreeState extends Record<string, unknown> {
+    depth: number;
+}
+interface PopupMenuTreeProps extends ComponentProps<'div', PopupMenuTree.State> {
+    children: React.ReactNode;
+}
+declare const PopupMenuTree: React.ForwardRefExoticComponent<Omit<PopupMenuTree.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuTree {
+    type State = PopupMenuTreeState;
+    interface Props extends PopupMenuTreeProps {
+    }
+}
+
+interface PopupMenuTreeConnectorState extends Record<string, unknown> {
+    depth: number;
+}
+interface PopupMenuTreeConnectorProps extends ComponentProps<'span', PopupMenuTreeConnector.State> {
+    depth?: number;
+}
+declare const PopupMenuTreeConnector: React.ForwardRefExoticComponent<Omit<PopupMenuTreeConnector.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuTreeConnector {
+    type State = PopupMenuTreeConnectorState;
+    interface Props extends PopupMenuTreeConnectorProps {
+    }
+}
+
+interface PopupMenuTreeItemProps extends Omit<PopupMenuItemProps, 'activatable'> {
+    /** Whether this tree item can be activated. @default true */
+    selectable?: boolean;
+    /** Explicit tree depth override. */
+    depth?: number;
+}
+declare const PopupMenuTreeItem: React.ForwardRefExoticComponent<Omit<PopupMenuTreeItem.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuTreeItem {
+    type State = PopupMenuItemState;
+    interface Props extends PopupMenuTreeItemProps {
+    }
+}
+
+interface PopupMenuSubmenuRootProps extends Omit<PopoverRootProps, 'open' | 'onOpenChange' | 'defaultOpen' | 'actionsRef'> {
+    /**
+     * Whether the submenu is open.
+     * Use for controlled mode.
+     */
+    open?: boolean;
+    /**
+     * Callback when the open state changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onOpenChange?: (open: boolean, eventDetails: Popover.Root.ChangeEventDetails) => void;
+    /**
+     * Whether the submenu is initially open.
+     * Use for uncontrolled mode.
+     * @default false
+     */
+    defaultOpen?: boolean;
+    /**
+     * Whether pressing Escape in this submenu closes the entire menu from the root.
+     * When true (default), Escape closes the entire menu tree.
+     * When false, Escape only closes this submenu and moves focus to the parent.
+     * @default true
+     */
+    closeRootOnEsc?: boolean;
+    /**
+     * Whether virtualization mode is enabled for this submenu.
+     * When true, items should provide an explicit `index` prop and
+     * the `items` prop should be provided for navigation to work correctly.
+     * @default false
+     */
+    virtualized?: boolean;
+    /**
+     * Pre-registered items for virtualization.
+     * When provided with `virtualized={true}`, this allows navigation to work
+     * for items that aren't currently mounted in the DOM.
+     */
+    items?: VirtualItem[];
+    /**
+     * Callback when the highlighted item changes. `id` is first; `node` is the
+     * resolved menu node enrichment and may be null.
+     * Useful for synchronizing with a virtualizer (e.g., scrollToIndex).
+     */
+    onHighlightChange?: PopupMenuHighlightChangeHandler<HighlightChangeEventDetails>;
+    /**
+     * Event handler called after any open/close animations have completed.
+     * When `clearSearchOnClose="after-exit"` is set on Surface, the search
+     * will be cleared before this callback is invoked.
+     */
+    onOpenChangeComplete?: (open: boolean) => void;
+    /**
+     * Whether this submenu should ignore user interaction.
+     * Also inherits disabled state from its parent menu.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * A ref to imperative actions.
+     * - `close`: closes the submenu imperatively.
+     * - `unmount`: unmounts the popup imperatively (when keep-mounted mode is enabled).
+     * - `setDisabled`: enables/disables the submenu imperatively.
+     */
+    actionsRef?: React.RefObject<PopupMenuSubmenuRoot.Actions | null>;
+    children: React.ReactNode;
+}
+/**
+ * Groups all parts of a submenu.
+ * Manages open state and provides context to children.
+ * Creates its own ListboxStore independent from the parent menu.
+ * Doesn't render its own HTML element.
+ */
+declare function PopupMenuSubmenuRoot(props: PopupMenuSubmenuRootProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuSubmenuRoot {
+    interface Props extends PopupMenuSubmenuRootProps {
+    }
+    type ChangeEventDetails = Popover.Root.ChangeEventDetails;
+    type Actions = PopupMenuRootActions;
+}
+
+interface PopupMenuSubmenuTriggerIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the submenu popup is open.
+     */
+    popupOpen: boolean;
+    /**
+     * Whether the submenu owns keyboard focus.
+     */
+    popupFocused: boolean;
+}
+interface PopupMenuSubmenuTriggerIndicatorProps extends ComponentProps<'span', PopupMenuSubmenuTriggerIndicator.State> {
+}
+/**
+ * An indicator element for submenu triggers that reflects the submenu's open and focus state.
+ * Typically used to render a chevron or arrow icon.
+ * Must be used within PopupMenu.SubmenuTrigger.
+ * Renders a `<span>` element.
+ */
+declare const PopupMenuSubmenuTriggerIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuSubmenuTriggerIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuSubmenuTriggerIndicator {
+    type State = PopupMenuSubmenuTriggerIndicatorState;
+    interface Props extends PopupMenuSubmenuTriggerIndicatorProps {
+    }
+}
+
+declare function isTreeItemDef(node: NodeDef): node is TreeItemDef;
+
+export { PopupMenuGroupValue as P, type SubmenuContextValue as S, type UsePopupMenuItemParams as U, PopupMenuPositioner as a, PopupMenuRadioItemIndicator as b, PopupMenuSubmenuRoot as c, PopupMenuSubmenuTriggerIndicator as d, PopupMenuTree as e, PopupMenuTreeConnector as f, PopupMenuTreeItem as g, type PopupMenuPositionerAlign as h, type PopupMenuPositionerProps as i, type PopupMenuRadioItemIndicatorProps as j, type PopupMenuRadioItemIndicatorState as k, type PopupMenuSubmenuRootProps as l, type PopupMenuSubmenuTriggerIndicatorProps as m, type PopupMenuSubmenuTriggerIndicatorState as n, type SubpageContextValue as o, type SubpageStackContextValue as p, useMaybeSubpageContext as q, useMaybeSubpageStack as r, useSubmenuContext as s, useSubpageContext as t, useMaybeSubmenuContext as u, useSubpageStack as v, type UsePopupMenuItemReturn as w, usePopupMenuItem as x, isTreeItemDef as y, SubpageStackContext as z };