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

package/dist/resolve-BYm41YfG.d.ts

@@ -0,0 +1,406 @@
+import * as React from 'react';
+import { C as ComponentProps } from './types-DT4FOOa2.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { aT as RadioValueChangeEventDetails, M as AsyncLoaderConfig, R as AsyncLoaderResult, N as NodeDef, X as AsyncState, a0 as DataListChildrenState, a1 as DeepSearchConfig, ad as IncludeInDeepSearch, a3 as DisplayNode, r as PopupMenuNode, aJ as UnresolvedMenuNode, j as PopupMenuIdScope } from './events-DOGItflK.js';
+
+interface PopupMenuCheckboxItemIndicatorState extends Record<string, unknown> {
+    /**
+     * Whether the parent checkbox item is currently checked.
+     */
+    checked: boolean;
+    /**
+     * Whether the parent checkbox item is currently highlighted.
+     */
+    highlighted: boolean;
+    /**
+     * Whether the parent checkbox item is disabled.
+     */
+    disabled: boolean;
+    /**
+     * Toggle the checked state without triggering closeOnClick.
+     * Useful when you want clicking directly on the indicator to toggle
+     * without closing the menu.
+     */
+    toggle: () => void;
+}
+interface PopupMenuCheckboxItemIndicatorProps extends ComponentProps<'span', PopupMenuCheckboxItemIndicator.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 CheckboxItem is checked.
+ * Must be used within a CheckboxItem component.
+ * Renders a `<span>` element with aria-hidden="true".
+ */
+declare const PopupMenuCheckboxItemIndicator: React.ForwardRefExoticComponent<Omit<PopupMenuCheckboxItemIndicator.Props, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+declare namespace PopupMenuCheckboxItemIndicator {
+    type State = PopupMenuCheckboxItemIndicatorState;
+    interface Props extends PopupMenuCheckboxItemIndicatorProps {
+    }
+}
+
+interface PopupMenuRadioGroupValueProps {
+    /**
+     * The controlled selected value.
+     */
+    value: string | undefined;
+    /**
+     * Callback fired when the selected value changes.
+     * The second parameter contains event details including the reason for the change.
+     */
+    onValueChange?: (value: string, eventDetails: RadioValueChangeEventDetails) => void;
+    /**
+     * Whether all items in this group are disabled.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Children to render within the radio group context.
+     */
+    children: React.ReactNode;
+}
+/**
+ * Headless provider for radio group state.
+ * Use this to wrap DataSurface when using RadioItems in deep search.
+ * Does not render any DOM element - only provides context.
+ *
+ * @example
+ * ```tsx
+ * const [theme, setTheme] = useState('light')
+ *
+ * <DropdownMenu.RadioGroupValue value={theme} onValueChange={setTheme}>
+ *   <DropdownMenu.Surface content={content}>
+ *     ...
+ *   </DropdownMenu.Surface>
+ * </DropdownMenu.RadioGroupValue>
+ * ```
+ */
+declare function PopupMenuRadioGroupValue(props: PopupMenuRadioGroupValueProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuRadioGroupValue {
+    interface Props extends PopupMenuRadioGroupValueProps {
+    }
+}
+
+/**
+ * Declares its children as tabbable popup content: they join the surface's Tab
+ * cycle instead of Tab closing the menu. A zone with no tabbable children is
+ * treated as absent.
+ */
+interface PopupMenuFocusZoneState extends Record<string, unknown> {
+}
+interface PopupMenuFocusZoneProps extends ComponentProps<'div', PopupMenuFocusZone.State> {
+}
+declare const PopupMenuFocusZone: React.ForwardRefExoticComponent<Omit<PopupMenuFocusZone.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuFocusZone {
+    type State = PopupMenuFocusZoneState;
+    interface Props extends PopupMenuFocusZoneProps {
+    }
+}
+
+/**
+ * Container for tabbable content at the bottom of a menu surface (action rows like Apply/Cancel). Registers as a focus zone: its tabbable children join the surface's Tab cycle.
+ */
+interface PopupMenuFooterState extends Record<string, unknown> {
+}
+interface PopupMenuFooterProps extends ComponentProps<'div', PopupMenuFooter.State> {
+}
+declare const PopupMenuFooter: React.ForwardRefExoticComponent<Omit<PopupMenuFooter.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuFooter {
+    type State = PopupMenuFooterState;
+    interface Props extends PopupMenuFooterProps {
+    }
+}
+
+/**
+ * Container for tabbable content at the top of a menu surface (toolbars, filters). Registers as a focus zone: its tabbable children join the surface's Tab cycle.
+ */
+interface PopupMenuHeaderState extends Record<string, unknown> {
+}
+interface PopupMenuHeaderProps extends ComponentProps<'div', PopupMenuHeader.State> {
+}
+declare const PopupMenuHeader: React.ForwardRefExoticComponent<Omit<PopupMenuHeader.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuHeader {
+    type State = PopupMenuHeaderState;
+    interface Props extends PopupMenuHeaderProps {
+    }
+}
+
+/**
+ * State for the Shortcut component, passed to children render function.
+ */
+interface PopupMenuShortcutState extends Record<string, unknown> {
+    /**
+     * The keyboard shortcut value from the parent Item.
+     */
+    shortcut: string | undefined;
+    /**
+     * Whether the parent item is highlighted.
+     */
+    highlighted: boolean;
+}
+interface PopupMenuShortcutProps extends Omit<ComponentProps<'kbd', PopupMenuShortcut.State>, 'children'> {
+    /**
+     * Content to render inside the shortcut.
+     * Can be a render function that receives the shortcut value.
+     * If not provided, renders the shortcut value from the parent Item.
+     */
+    children?: React.ReactNode | ((state: PopupMenuShortcutState) => React.ReactNode);
+}
+/**
+ * Displays the keyboard shortcut for a menu item.
+ * Must be used within a PopupMenu.Item component.
+ * Renders a `<kbd>` element by default.
+ *
+ * @example
+ * ```tsx
+ * // Auto-renders the shortcut value
+ * <PopupMenu.Item shortcut="1">
+ *   Icebox
+ *   <PopupMenu.Shortcut />
+ * </PopupMenu.Item>
+ *
+ * // Custom rendering with children as function
+ * <PopupMenu.Item shortcut="1">
+ *   Icebox
+ *   <PopupMenu.Shortcut>
+ *     {({ shortcut }) => <span className="key">{shortcut}</span>}
+ *   </PopupMenu.Shortcut>
+ * </PopupMenu.Item>
+ * ```
+ */
+declare const PopupMenuShortcut: React.ForwardRefExoticComponent<Omit<PopupMenuShortcut.Props, "ref"> & React.RefAttributes<HTMLElement>>;
+declare namespace PopupMenuShortcut {
+    type State = PopupMenuShortcutState;
+    interface Props extends PopupMenuShortcutProps {
+    }
+}
+
+interface PopupMenuSubpageProps {
+    /** Unique page ID for stack navigation. */
+    pageId: string;
+    /**
+     * Whether pressing Escape in this page closes the entire menu tree.
+     * When false (default), Escape navigates back one page.
+     * @default false
+     */
+    closeRootOnEsc?: boolean;
+    children: React.ReactNode;
+}
+/**
+ * Groups all parts of a subpage.
+ * Creates an isolated menu surface that renders in the same popup and
+ * participates in push/pop page stack navigation.
+ * Doesn't render its own HTML element.
+ */
+declare function PopupMenuSubpage(props: PopupMenuSubpageProps): react_jsx_runtime.JSX.Element;
+declare namespace PopupMenuSubpage {
+    interface Props extends PopupMenuSubpageProps {
+    }
+}
+
+interface PopupMenuSubpageBackState extends Record<string, unknown> {
+    /** Whether navigating back is currently possible. */
+    canGoBack: boolean;
+    /** Whether the button is disabled. */
+    disabled: boolean;
+}
+interface PopupMenuSubpageBackProps extends ComponentProps<'button', PopupMenuSubpageBack.State> {
+    /** Whether this button is disabled. */
+    disabled?: boolean;
+}
+/**
+ * A button that navigates back one page in the current subpage stack.
+ * Useful for custom headers/toolbars outside of list rows.
+ * Renders a `<button>` element.
+ */
+declare const PopupMenuSubpageBack: React.ForwardRefExoticComponent<Omit<PopupMenuSubpageBack.Props, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare namespace PopupMenuSubpageBack {
+    type State = PopupMenuSubpageBackState;
+    interface Props extends PopupMenuSubpageBackProps {
+    }
+}
+
+interface PopupMenuSubpageBackItemState extends Record<string, unknown> {
+    /** Whether this is a subpage back item (always true). */
+    subpageBackItem: boolean;
+    /** Whether the item is highlighted. */
+    highlighted: boolean;
+    /** Whether the item is disabled. */
+    disabled: boolean;
+    first: boolean;
+    last: boolean;
+    firstInGroup: boolean;
+    lastInGroup: boolean;
+}
+interface PopupMenuSubpageBackItemProps extends ComponentProps<'div', PopupMenuSubpageBackItem.State> {
+    /** Explicit unique identifier for this item in the store. */
+    id?: string;
+    /** Unique value for this item used for filtering. */
+    value?: string;
+    /** Additional keywords to match against when filtering. */
+    keywords?: string[];
+    /** Whether this item is disabled. */
+    disabled?: boolean;
+    /** Whether to force render this item regardless of filter results. */
+    forceMount?: boolean;
+    /** Callback when this item is selected. */
+    onSelect?: () => void;
+    /**
+     * Async callback when this item is selected.
+     *
+     * When provided, this takes precedence over `onSelect`.
+     * If provided, this callback is awaited before navigating back.
+     * Return `false` to prevent automatic navigation.
+     */
+    onSelectAsync?: (context: PopupMenuSubpageBackItem.OnSelectAsyncContext) => Promise<void | boolean>;
+}
+/**
+ * A list row that navigates back one page in the current subpage stack.
+ * Renders a `<div>` element with role="option".
+ */
+declare const PopupMenuSubpageBackItem: React.ForwardRefExoticComponent<Omit<PopupMenuSubpageBackItem.Props, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare namespace PopupMenuSubpageBackItem {
+    type State = PopupMenuSubpageBackItemState;
+    interface OnSelectAsyncContext {
+        /** Navigate back one page manually. */
+        goBack: () => boolean;
+        /** Aborts when a pending async selection is canceled or unmounted. */
+        signal: AbortSignal;
+    }
+    interface Props extends PopupMenuSubpageBackItemProps {
+    }
+}
+
+/**
+ * State for a registered async loader.
+ */
+interface AsyncMenuState {
+    /** Unique identifier for this async menu */
+    id: string;
+    /** The loader configuration */
+    config: AsyncLoaderConfig;
+    /** Current loader result */
+    result: AsyncLoaderResult<NodeDef[]>;
+}
+interface RootAsyncMenuState {
+    config: AsyncLoaderConfig;
+    result: AsyncLoaderResult<NodeDef[]>;
+}
+/**
+ * Context value for the async menu coordinator.
+ */
+interface AsyncMenuCoordinatorValue {
+    /** Register a new async loader */
+    registerLoader: (state: AsyncMenuState) => void;
+    /** Unregister an async loader */
+    unregisterLoader: (id: string) => void;
+    /** Update loader result */
+    updateLoaderResult: (id: string, result: AsyncLoaderResult<NodeDef[]>) => void;
+    registerRootLoader: (state: RootAsyncMenuState) => void;
+    unregisterRootLoader: () => void;
+    updateRootLoaderResult: (result: AsyncLoaderResult<NodeDef[]>) => void;
+    /** Current search query from the store */
+    searchQuery: string;
+    /** All registered loaders */
+    loaders: Map<string, AsyncMenuState>;
+    /** The root surface's own `asyncContent` loader; `null` when none is registered. Never present in `loaders`. */
+    root: RootAsyncMenuState | null;
+    /** Any loader is currently in initial loading phase */
+    isAnyLoading: boolean;
+    /** Any loader is currently fetching (initial or background) */
+    isAnyFetching: boolean;
+    /** Any loader is currently in first-load phase */
+    isAnyInitialLoading: boolean;
+    /** Any loader is currently in background refetch phase */
+    isAnyRefetching: boolean;
+    /** All registered loaders are currently in background refetch phase */
+    isAllRefetching: boolean;
+    /** The root loader is currently in initial loading phase */
+    isRootLoading: boolean;
+    /** Static loaders are currently in initial loading phase */
+    isStaticLoading: boolean;
+    /** Static loaders are currently fetching */
+    isStaticFetching: boolean;
+    /** Static loaders in first-load phase */
+    isStaticInitialLoading: boolean;
+    /** Static loaders in background refetch phase */
+    isStaticRefetching: boolean;
+    /** Query loaders are currently in initial loading phase */
+    isQueryLoading: boolean;
+    /** Query loaders are currently fetching */
+    isQueryFetching: boolean;
+    /** Query loaders in first-load phase */
+    isQueryInitialLoading: boolean;
+    /** Query loaders in background refetch phase */
+    isQueryRefetching: boolean;
+    /** All loaders have resolved (not fetching) */
+    allResolved: boolean;
+    /** Every loader with a usable result: the root entry (if any) and one branch entry per Resolved ID. */
+    getAsyncNodes: () => Array<{
+        kind: 'root';
+        nodes: NodeDef[];
+    } | {
+        kind: 'branch';
+        id: string;
+        nodes: NodeDef[];
+    }>;
+    /** Loaders that errored */
+    erroredLoaders: Map<string, Error>;
+    rootError: Error | null;
+    /** Get the aggregate async state for DataList */
+    getAsyncState: () => AsyncState;
+}
+declare function useAsyncMenuCoordinator(): AsyncMenuCoordinatorValue | null;
+declare function useMaybeAsyncMenuCoordinator(): AsyncMenuCoordinatorValue | null;
+
+interface DataSurfaceContextValue {
+    /** The original node definitions */
+    content: NodeDef[];
+    /** Async content configuration for root-level async loading */
+    asyncContent?: AsyncLoaderConfig;
+    /** Deep search configuration */
+    deepSearchConfig: DeepSearchConfig;
+    /** Default submenu inclusion mode for deep search */
+    includeInDeepSearch: IncludeInDeepSearch;
+    /** List element ID for aria-activedescendant */
+    listId: string;
+}
+declare const DataSurfaceContext: React.Context<DataSurfaceContextValue | null>;
+interface ResolvedNodesSlot {
+    nodes: readonly PopupMenuNode[];
+    graftVersion: number;
+    /** The `content` prop the slot was published for; consumers drop a slot whose content the root surface no longer supplies. */
+    content: NodeDef[];
+}
+interface DataPopupContextValue {
+    /** Latest DataSurface context registered within this popup. */
+    dataSurfaceContext: DataSurfaceContextValue | null;
+    /** Registers/clears DataSurface context for sibling consumers. */
+    setDataSurfaceContext: React.Dispatch<React.SetStateAction<DataSurfaceContextValue | null>>;
+    /**
+     * The resolved-nodes slot: the root list's current Menu Nodes plus the
+     * graft version that changes when loader results are grafted under a
+     * branch (which mutates `children` without changing the outer array).
+     * Null until the root list registers. Retained while a subpage is active
+     * and the root list is unmounted; the Menu Tree persists on the resolver.
+     */
+    resolvedNodes: ResolvedNodesSlot | null;
+    setResolvedNodes: React.Dispatch<React.SetStateAction<ResolvedNodesSlot | null>>;
+}
+declare const DataPopupContext: React.Context<DataPopupContextValue | null>;
+declare function useDataSurfaceContext(): DataSurfaceContextValue;
+declare function useMaybeDataSurfaceContext(): DataSurfaceContextValue | null;
+declare const DataListContext: React.Context<DataListChildrenState | null>;
+declare function useDataList(): DataListChildrenState;
+declare function useMaybeDataList(): DataListChildrenState | null;
+type RenderNodeFn = (displayNode: DisplayNode) => React.ReactNode;
+
+declare function isPopupMenuNode(value: unknown): value is PopupMenuNode;
+/** Default Resolved ID, using surface-scoped encoded paths unless menu scope is selected. */
+declare function defaultGetResolvedId(node: UnresolvedMenuNode, idScope?: PopupMenuIdScope): string;
+
+export { type PopupMenuSubpageProps as A, type AsyncMenuCoordinatorValue as B, type PopupMenuRadioGroupValueProps as C, type DataSurfaceContextValue as D, DataListContext as E, DataSurfaceContext as F, defaultGetResolvedId as G, isPopupMenuNode as H, useDataSurfaceContext as I, useMaybeDataSurfaceContext as J, DataPopupContext as K, PopupMenuCheckboxItemIndicator as P, type RenderNodeFn as R, PopupMenuFocusZone as a, PopupMenuFooter as b, PopupMenuHeader as c, PopupMenuRadioGroupValue as d, PopupMenuShortcut as e, PopupMenuSubpage as f, PopupMenuSubpageBack as g, PopupMenuSubpageBackItem as h, useDataList as i, useMaybeAsyncMenuCoordinator as j, useMaybeDataList as k, type PopupMenuCheckboxItemIndicatorProps as l, type PopupMenuCheckboxItemIndicatorState as m, type PopupMenuFocusZoneProps as n, type PopupMenuFocusZoneState as o, type PopupMenuFooterProps as p, type PopupMenuFooterState as q, type PopupMenuHeaderProps as r, type PopupMenuHeaderState as s, type PopupMenuShortcutProps as t, useAsyncMenuCoordinator as u, type PopupMenuShortcutState as v, type PopupMenuSubpageBackItemProps as w, type PopupMenuSubpageBackItemState as x, type PopupMenuSubpageBackProps as y, type PopupMenuSubpageBackState as z };