@gamecrafters/base-ui 0.0.36 → 0.0.38

package/build/components/context-menu/ContextMenu.types.d.ts

@@ -1,14 +1,19 @@
 import type * as React from "react";
-import type { AnchoredOverlayProps } from "../anchored-overlay/AnchoredOverlay.types";
 export type ContextMenuPoint = {
     x: number;
     y: number;
     size: number;
 };
+export type ContextMenuItemVariant = "default" | "danger";
 export type ContextMenuProps = {
-    children: React.ReactNode;
+    children?: React.ReactNode;
     open?: boolean;
+    defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
+    onSelect?: (value: string) => void;
+    closeOnSelect?: boolean;
+    loopFocus?: boolean;
+    typeahead?: boolean;
     disabled?: boolean;
     portalContainerName?: string;
 };
@@ -16,18 +21,84 @@ export type ContextMenuTriggerProps = React.ComponentPropsWithoutRef<"div"> & {
     children?: React.ReactNode;
     className?: string;
 };
-export type ContextMenuOverlayProps = Pick<AnchoredOverlayProps, "align" | "side" | "width" | "height" | "variant" | "preventOverflow" | "className"> & {
-    children: React.ReactNode;
+export type ContextMenuPositionerProps = React.ComponentPropsWithoutRef<"div"> & {
+    children?: React.ReactNode;
+    className?: string;
+};
+export type ContextMenuContentProps = React.ComponentPropsWithoutRef<"div"> & {
     "aria-label"?: string;
     "aria-labelledby"?: string;
-    returnFocusRef?: React.RefObject<HTMLElement | null>;
+    className?: string;
+};
+export type ContextMenuItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+    variant?: ContextMenuItemVariant;
+    className?: string;
+};
+export type ContextMenuCheckboxItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    className?: string;
+};
+export type ContextMenuRadioItemGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+};
+export type ContextMenuRadioItemProps = Omit<React.ComponentPropsWithoutRef<"div">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    className?: string;
+};
+export type ContextMenuItemGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ContextMenuItemGroupLabelProps = React.ComponentPropsWithoutRef<"div"> & {
+    className?: string;
+};
+export type ContextMenuItemTextProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ContextMenuItemIndicatorProps = React.ComponentPropsWithoutRef<"span"> & {
+    className?: string;
+};
+export type ContextMenuSeparatorProps = React.ComponentPropsWithoutRef<"hr"> & {
+    className?: string;
 };
 export type ContextMenuContextValue = {
     triggerRef: React.RefObject<HTMLDivElement | null>;
+    triggerId: string;
+    contentId: string;
     point: ContextMenuPoint;
     open: boolean;
-    disabled?: boolean;
-    onOpen?: (point: ContextMenuPoint) => void;
-    onClose?: () => void;
+    disabled: boolean;
+    closeOnSelect: boolean;
+    loopFocus: boolean;
+    typeahead: boolean;
+    highlightedValue: string | null;
     portalContainerName?: string;
+    onOpen: (point: ContextMenuPoint) => void;
+    onClose: () => void;
+    onSelect: (value: string, closeOnSelect: boolean) => void;
+    setHighlightedValue: (value: string | null) => void;
+};
+export type ContextMenuItemContextValue = {
+    highlighted: boolean;
+    disabled: boolean;
+    checked?: boolean;
+};
+export type ContextMenuItemGroupContextValue = {
+    labelId: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
 };

package/build/components/context-menu/ContextMenuCheckboxItem.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuContent.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuItem.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+    variant?: import("./ContextMenu.types").ContextMenuItemVariant;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuItemContext.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMenuItemContextValue } from "./ContextMenu.types";
+export declare const ContextMenuItemContext: import("react").Context<ContextMenuItemContextValue | undefined>;

package/build/components/{navigation-menu/NavigationMenuSubNavigation.d.ts → context-menu/ContextMenuItemGroup.d.ts}

@@ -1,6 +1,5 @@
 import * as React from "react";
-declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
-    children?: React.ReactNode;
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     className?: string;
 } & React.RefAttributes<any>) => React.ReactNode;
 export default _default;

package/build/components/context-menu/ContextMenuItemGroupContext.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMenuItemGroupContextValue } from "./ContextMenu.types";
+export declare const ContextMenuItemGroupContext: import("react").Context<ContextMenuItemGroupContextValue | undefined>;

package/build/components/context-menu/ContextMenuItemGroupLabel.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuItemIndicator.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuItemText.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/{navigation-list/NavigationListSubNavigation.d.ts → context-menu/ContextMenuPositioner.d.ts}

@@ -1,5 +1,5 @@
 import * as React from "react";
-declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & {
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
     children?: React.ReactNode;
     className?: string;
 } & React.RefAttributes<any>) => React.ReactNode;

package/build/components/context-menu/ContextMenuRadioItem.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+    value: string;
+    valueText?: string;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuRadioItemGroup.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuSeparator.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLHRElement>, HTMLHRElement>, "ref"> & {
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/ContextMenuTrigger.d.ts

@@ -1,7 +1,6 @@
 import * as React from "react";
-import type { ContextMenuTriggerProps } from "./ContextMenu.types";
-declare function ContextMenuTrigger(props: ContextMenuTriggerProps): React.JSX.Element;
-declare namespace ContextMenuTrigger {
-    var displayName: string;
-}
-export default ContextMenuTrigger;
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    children?: React.ReactNode;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/context-menu/index.d.ts

@@ -1,12 +1,81 @@
-import { ActionListDivider } from "../action-list";
 import ContextMenuBase from "./ContextMenu";
-import ContextMenuOverlay from "./ContextMenuOverlay";
+import ContextMenuCheckboxItem from "./ContextMenuCheckboxItem";
+import ContextMenuContent from "./ContextMenuContent";
+import ContextMenuItem from "./ContextMenuItem";
+import ContextMenuItemGroup from "./ContextMenuItemGroup";
+import ContextMenuItemGroupLabel from "./ContextMenuItemGroupLabel";
+import ContextMenuItemIndicator from "./ContextMenuItemIndicator";
+import ContextMenuItemText from "./ContextMenuItemText";
+import ContextMenuPositioner from "./ContextMenuPositioner";
+import ContextMenuRadioItem from "./ContextMenuRadioItem";
+import ContextMenuRadioItemGroup from "./ContextMenuRadioItemGroup";
+import ContextMenuSeparator from "./ContextMenuSeparator";
 import ContextMenuTrigger from "./ContextMenuTrigger";
 export declare const ContextMenu: typeof ContextMenuBase & {
-    Trigger: typeof ContextMenuTrigger;
-    Overlay: typeof ContextMenuOverlay;
-    Divider: typeof ActionListDivider;
+    Trigger: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        children?: React.ReactNode;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Positioner: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        children?: React.ReactNode;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Content: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        "aria-label"?: string;
+        "aria-labelledby"?: string;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+        value: string;
+        valueText?: string;
+        disabled?: boolean;
+        closeOnSelect?: boolean;
+        onSelect?: () => void;
+        variant?: import("./ContextMenu.types").ContextMenuItemVariant;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemText: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemIndicator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroup: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ItemGroupLabel: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Separator: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLHRElement>, HTMLHRElement>, "ref"> & {
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    CheckboxItem: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+        value: string;
+        valueText?: string;
+        checked: boolean;
+        onCheckedChange?: (checked: boolean) => void;
+        disabled?: boolean;
+        closeOnSelect?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    RadioItemGroup: (props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        value?: string;
+        onValueChange?: (value: string) => void;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    RadioItem: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onSelect"> & {
+        value: string;
+        valueText?: string;
+        disabled?: boolean;
+        closeOnSelect?: boolean;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
 };
-export { ContextMenuTrigger, ContextMenuOverlay };
+export { ContextMenuTrigger, ContextMenuPositioner, ContextMenuContent, ContextMenuItem, ContextMenuItemText, ContextMenuItemIndicator, ContextMenuItemGroup, ContextMenuItemGroupLabel, ContextMenuSeparator, ContextMenuCheckboxItem, ContextMenuRadioItemGroup, ContextMenuRadioItem, };
 export { ContextMenuContext } from "./ContextMenuContext";
+export { ContextMenuItemContext } from "./ContextMenuItemContext";
+export { ContextMenuItemGroupContext } from "./ContextMenuItemGroupContext";
+export { useContextMenu } from "./useContextMenu";
+export { useContextMenuItem } from "./useContextMenuItem";
+export type { UseContextMenuItemOptions } from "./useContextMenuItem";
 export * from "./ContextMenu.types";

package/build/components/context-menu/useContextMenu.d.ts

@@ -0,0 +1,2 @@
+import type { ContextMenuContextValue } from "./ContextMenu.types";
+export declare const useContextMenu: () => ContextMenuContextValue;

package/build/components/context-menu/useContextMenuItem.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+export type UseContextMenuItemOptions = {
+    value: string;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    onSelect?: () => void;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    onPointerMove?: React.PointerEventHandler<HTMLElement>;
+    onPointerLeave?: React.PointerEventHandler<HTMLElement>;
+    onPointerDown?: React.PointerEventHandler<HTMLElement>;
+};
+export declare const useContextMenuItem: ({ value, disabled, closeOnSelect, onSelect, onClick, onPointerMove, onPointerLeave, onPointerDown, }: UseContextMenuItemOptions) => {
+    highlighted: boolean;
+    disabled: boolean;
+    select: () => void;
+    itemProps: {
+        tabIndex: number;
+        "aria-disabled": boolean | undefined;
+        "data-disabled": string | undefined;
+        "data-highlighted": string | undefined;
+        "data-value": string;
+        onPointerMove: (event: React.PointerEvent<HTMLElement>) => void;
+        onPointerLeave: (event: React.PointerEvent<HTMLElement>) => void;
+        onPointerDown: (event: React.PointerEvent<HTMLElement>) => void;
+        onClick: (event: React.MouseEvent<HTMLElement>) => void;
+    };
+};

package/build/components/globe/Globe.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import type { GlobeArc, GlobeMarker } from "./Globe.types";
+export declare const DEFAULT_GLOBE_MARKER_SIZE = 0.05;
+export declare const DEFAULT_GLOBE_SPEED = 0.3;
+declare const _default: (props: Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    latitude?: number;
+    longitude?: number;
+    size?: number | string;
+    markers?: readonly GlobeMarker[];
+    arcs?: readonly GlobeArc[];
+    markerSize?: number;
+    spin?: boolean;
+    speed?: number;
+    interactive?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/globe/Globe.types.d.ts

@@ -0,0 +1,20 @@
+import type * as React from "react";
+import type { GlobeArc as GlobeSurfaceArc, GlobeMarker as GlobeSurfaceMarker } from "../../lib/react-globe";
+export type { GlobeColor, GlobeLocation, GlobeOverlayProps } from "../../lib/react-globe";
+export type GlobeMarker = Omit<GlobeSurfaceMarker, "size"> & {
+    size?: number;
+};
+export type GlobeArc = GlobeSurfaceArc;
+export type GlobeProps = React.ComponentPropsWithoutRef<"div"> & {
+    latitude?: number;
+    longitude?: number;
+    size?: number | string;
+    markers?: readonly GlobeMarker[];
+    arcs?: readonly GlobeArc[];
+    markerSize?: number;
+    spin?: boolean;
+    speed?: number;
+    interactive?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+};

package/build/components/globe/globeAppearance.d.ts

@@ -0,0 +1,2 @@
+import type { GlobeState } from "../../lib/react-globe";
+export declare const readGlobeAppearance: (element: HTMLElement) => GlobeState;

package/build/components/globe/index.d.ts

@@ -0,0 +1,20 @@
+import { GlobeOverlay } from "../../lib/react-globe";
+export declare const Globe: ((props: Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    latitude?: number;
+    longitude?: number;
+    size?: number | string;
+    markers?: readonly import("./Globe.types").GlobeMarker[];
+    arcs?: readonly import("./Globe.types").GlobeArc[];
+    markerSize?: number;
+    spin?: boolean;
+    speed?: number;
+    interactive?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Overlay: typeof GlobeOverlay;
+};
+export { GlobeOverlay };
+export { DEFAULT_GLOBE_MARKER_SIZE, DEFAULT_GLOBE_SPEED } from "./Globe";
+export { useGlobe } from "../../lib/react-globe";
+export * from "./Globe.types";

package/build/components/globe/useReducedMotion.d.ts

@@ -0,0 +1 @@
+export declare const useReducedMotion: () => boolean;

package/build/components/index.d.ts

@@ -50,6 +50,7 @@ export * from "./form-control";
 export * from "./format-byte";
 export * from "./format-number";
 export * from "./frame";
+export * from "./globe";
 export * from "./header";
 export * from "./heading";
 export * from "./hidden";
@@ -72,7 +73,6 @@ export * from "./marquee";
 export * from "./message";
 export * from "./meter";
 export * from "./native-select";
-export * from "./navigation-list";
 export * from "./navigation-menu";
 export * from "./number-input";
 export * from "./page-header";
@@ -83,6 +83,7 @@ export * from "./pin-input";
 export * from "./placeholder";
 export * from "./popover";
 export * from "./portal";
+export * from "./presence";
 export * from "./progress-bar";
 export * from "./progress-circle";
 export * from "./qr-code";

package/build/components/navigation-menu/NavigationMenu.d.ts

@@ -1,13 +1,15 @@
 import * as React from "react";
 declare const _default: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "defaultValue"> & {
     children?: React.ReactNode;
-    value?: string | null;
-    defaultValue?: string | null;
-    onValueChange?: (value: string | null) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (details: import("./NavigationMenu.types").NavigationMenuValueChangeDetails) => void;
     orientation?: import("./NavigationMenu.types").NavigationMenuOrientation;
-    openOn?: import("./NavigationMenu.types").NavigationMenuOpenOn;
     openDelay?: number;
     closeDelay?: number;
+    disableClickTrigger?: boolean;
+    disableHoverTrigger?: boolean;
+    disablePointerLeaveClose?: boolean;
     className?: string;
 } & React.RefAttributes<any>>;
 export default _default;

package/build/components/navigation-menu/NavigationMenu.types.d.ts

@@ -1,24 +1,25 @@
 import type * as React from "react";
+import type { TextDirection } from "../../providers/direction/Direction.types";
 import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { CaretProps } from "../caret";
 export type NavigationMenuOrientation = "horizontal" | "vertical";
-export type NavigationMenuOpenOn = "click" | "hover";
-export type NavigationMenuContentAlign = "start" | "center" | "end";
-export type NavigationMenuHeadingLevel = "h2" | "h3";
+export type NavigationMenuViewportAlign = "start" | "center" | "end";
+export type NavigationMenuMotion = "from-start" | "from-end";
+export type NavigationMenuFocusSide = "start" | "end";
+export type NavigationMenuValueChangeDetails = {
+    value: string;
+};
 export type NavigationMenuProps = Omit<React.ComponentPropsWithoutRef<"nav">, "defaultValue"> & {
     children?: React.ReactNode;
-    value?: string | null;
-    defaultValue?: string | null;
-    onValueChange?: (value: string | null) => void;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (details: NavigationMenuValueChangeDetails) => void;
     orientation?: NavigationMenuOrientation;
-    openOn?: NavigationMenuOpenOn;
     openDelay?: number;
     closeDelay?: number;
-    className?: string;
-};
-export type NavigationMenuHeadingProps = Omit<React.ComponentPropsWithoutRef<"h2">, "children"> & {
-    as?: NavigationMenuHeadingLevel;
-    visuallyHidden?: boolean;
-    children?: React.ReactNode;
+    disableClickTrigger?: boolean;
+    disableHoverTrigger?: boolean;
+    disablePointerLeaveClose?: boolean;
     className?: string;
 };
 export type NavigationMenuListProps = React.ComponentPropsWithoutRef<"ul"> & {
@@ -28,6 +29,7 @@ export type NavigationMenuListProps = React.ComponentPropsWithoutRef<"ul"> & {
 export type NavigationMenuItemProps = Omit<React.ComponentPropsWithoutRef<"li">, "value"> & {
     children?: React.ReactNode;
     value?: string;
+    disabled?: boolean;
     className?: string;
 };
 export type NavigationMenuTriggerProps = React.ComponentPropsWithoutRef<"button"> & {
@@ -36,55 +38,96 @@ export type NavigationMenuTriggerProps = React.ComponentPropsWithoutRef<"button"
 };
 export type NavigationMenuContentProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
     children?: React.ReactNode;
-    align?: NavigationMenuContentAlign;
     className?: string;
 }>;
 export type NavigationMenuLinkProps<As extends React.ElementType = "a"> = PolymorphicProps<As, "a", {
     children?: React.ReactNode;
-    active?: boolean;
+    current?: boolean;
+    closeOnClick?: boolean;
     className?: string;
 }>;
-export type NavigationMenuSubNavigationProps = React.ComponentPropsWithoutRef<"ul"> & {
+export type NavigationMenuIndicatorProps = React.ComponentPropsWithoutRef<"div"> & {
     children?: React.ReactNode;
     className?: string;
 };
-export type NavigationMenuGroupProps = React.ComponentPropsWithoutRef<"div"> & {
+export type NavigationMenuItemIndicatorProps = React.ComponentPropsWithoutRef<"div"> & {
     children?: React.ReactNode;
-    title?: string;
-    hideDivider?: boolean;
     className?: string;
 };
-export type NavigationMenuGroupHeadingProps = Omit<React.ComponentPropsWithoutRef<"h3">, "as"> & {
-    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+export type NavigationMenuArrowProps = Omit<CaretProps, "location">;
+export type NavigationMenuPositionerProps = React.ComponentPropsWithoutRef<"div"> & {
     children?: React.ReactNode;
+    align?: NavigationMenuViewportAlign;
     className?: string;
 };
-export type NavigationMenuDescriptionProps = React.ComponentPropsWithoutRef<"span"> & {
+export type NavigationMenuViewportProps = React.ComponentPropsWithoutRef<"div"> & {
     children?: React.ReactNode;
     className?: string;
 };
-export type NavigationMenuVisualProps = React.ComponentPropsWithoutRef<"span"> & {
-    children?: React.ReactNode;
-    className?: string;
+export type NavigationMenuRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
 };
-export type NavigationMenuDividerProps = Omit<React.ComponentPropsWithoutRef<"div">, "children"> & {
-    className?: string;
+export type NavigationMenuSize = {
+    width: number;
+    height: number;
 };
-export type NavigationMenuContextValue = {
-    openValue: string | null;
-    setOpenValue: (value: string | null) => void;
+export type NavigationMenuPoint = {
+    x: number;
+    y: number;
+};
+export type NavigationMenuItemRegistration = {
+    triggerId: string;
+    contentId: string;
+    triggerProxyId: string;
+};
+export type NavigationMenuViewportRegistration = {
+    node: HTMLElement;
+    align: NavigationMenuViewportAlign;
+};
+export type NavigationMenuApi = {
+    value: string;
+    open: boolean;
     orientation: NavigationMenuOrientation;
-    openOn: NavigationMenuOpenOn;
+    setValue: (value: string) => void;
+};
+export type NavigationMenuContextValue = NavigationMenuApi & {
+    direction: TextDirection;
+    motion: NavigationMenuMotion | null;
+    still: boolean;
+    triggerRect: NavigationMenuRect | null;
+    viewportSize: NavigationMenuSize | null;
+    viewportPosition: NavigationMenuPoint | null;
+    viewport: NavigationMenuViewportRegistration | null;
+    disableClickTrigger: boolean;
+    disableHoverTrigger: boolean;
+    disablePointerLeaveClose: boolean;
+    toggle: (value: string) => void;
     openAfterDelay: (value: string) => void;
+    cancelOpen: (value: string) => void;
     closeAfterDelay: () => void;
+    cancelClose: () => void;
+    close: () => void;
+    focusContent: (value: string, side: NavigationMenuFocusSide) => void;
+    registerItem: (value: string, registration: NavigationMenuItemRegistration) => () => void;
+    registerViewport: (registration: NavigationMenuViewportRegistration | null) => void;
+    getTriggerElement: (value: string) => HTMLElement | null;
+    getContentElement: (value: string) => HTMLElement | null;
+    getTriggerProxyElement: (value: string) => HTMLElement | null;
+    getTopLevelElements: () => HTMLElement[];
+    getContentLinks: (value: string) => HTMLElement[];
+    listRef: React.RefObject<HTMLUListElement | null>;
 };
 export type NavigationMenuItemContextValue = {
     value: string;
+    disabled: boolean;
+    isOpen: boolean;
     triggerId: string;
     contentId: string;
-    isOpen: boolean;
+    triggerProxyId: string;
 };
-export type NavigationMenuLinkContextValue = {
-    linkId: string;
-    descriptionId: string;
+export type NavigationMenuPositionerContextValue = {
+    align: NavigationMenuViewportAlign;
 };

package/build/components/navigation-menu/NavigationMenuArrow.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { NavigationMenuArrowProps } from "./NavigationMenu.types";
+declare const _default: (props: NavigationMenuArrowProps & React.RefAttributes<any>) => React.ReactNode;
+export default _default;