@salt-ds/core 1.73.0 → 1.74.0

package/dist-types/drawer/internal/useDrawerResize.d.ts

@@ -0,0 +1,34 @@
+import type { AriaAttributes, CSSProperties, KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, PointerEvent as ReactPointerEvent } from "react";
+import type { DrawerProps } from "../Drawer";
+type DrawerPosition = NonNullable<DrawerProps["position"]>;
+export interface SeparatorProps extends Pick<AriaAttributes, "aria-orientation" | "aria-valuenow" | "aria-valuemin" | "aria-valuemax"> {
+    role: "separator";
+    tabIndex: number;
+    ref: (element: HTMLElement | null) => void;
+    onKeyDown: (event: ReactKeyboardEvent<HTMLElement>) => void;
+    onFocus: () => void;
+}
+export interface GuideProps {
+    ref: (element: HTMLElement | null) => void;
+    onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;
+    onPointerMove: (event: ReactPointerEvent<HTMLElement>) => void;
+    onClick: (event: ReactMouseEvent<HTMLElement>) => void;
+    onContextMenu: () => void;
+}
+export interface UseDrawerResizeProps {
+    enabled: boolean;
+    position: DrawerPosition;
+    element: HTMLElement | null | undefined;
+}
+export interface UseDrawerResizeResult {
+    sizeStyle: CSSProperties | undefined;
+    isResizing: boolean;
+    isHovered: boolean;
+    isPlacing: boolean;
+    /** Whether the event is the Escape that cancelled a resize, so it shouldn't close the drawer. */
+    isCancelResizeEvent: (event?: Event) => boolean;
+    separatorProps: SeparatorProps;
+    guideProps: GuideProps;
+}
+export declare function useDrawerResize({ enabled, position, element, }: UseDrawerResizeProps): UseDrawerResizeResult;
+export {};

package/dist-types/menu/MenuAlignmentContext.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The leading slots that items in one alignment scope reserve for each other.
+ * Each `MenuGroup` is a scope, and items outside a group share their `MenuPanel`'s scope.
+ */
+export interface MenuAlignmentContextValue {
+    reserveIconSpace: boolean;
+    reserveSelectionIconSpace: boolean;
+    registerIcon: () => () => void;
+    registerSelectionIcon: () => () => void;
+}
+export declare const MenuAlignmentContext: import("react").Context<MenuAlignmentContextValue>;
+export declare function useSlotRegistry(): readonly [boolean, () => () => void];
+export declare function useMenuAlignmentScope(): MenuAlignmentContextValue;
+export declare function useMenuAlignment(): MenuAlignmentContextValue;

package/dist-types/menu/MenuGroup.d.ts

@@ -1,12 +1,34 @@
-import { type ComponentPropsWithoutRef, type ReactNode } from "react";
-export interface MenuGroupProps extends ComponentPropsWithoutRef<"div"> {
+import { type ComponentPropsWithoutRef, type ReactNode, type SyntheticEvent } from "react";
+interface BaseMenuGroupProps extends ComponentPropsWithoutRef<"div"> {
+    /**
+     * Menus to be rendered inside the menu group.
+     */
+    children?: ReactNode;
     /**
      * The label of the menu group.
      */
     label?: string;
     /**
-     * Menus to be rendered inside the menu group.
+     * Selection variant of the menu group. If "single", the menu items inside behave like radio buttons. If "multiple", they behave like checkboxes. Each selectable menu item needs a `value`. When omitted, the menu items are not selectable.
      */
-    children?: ReactNode;
+    selectionVariant?: "single" | "multiple";
+}
+interface SelectableMenuGroupProps extends BaseMenuGroupProps {
+    /**
+     * Callback fired when the selection changes.
+     * @param event
+     * @param newSelected The new selected values.
+     */
+    onSelectionChange?: (event: SyntheticEvent, newSelected: string[]) => void;
+    /**
+     * The values of the selected menu items. Required when `selectionVariant` is "single" or "multiple". The menu's content unmounts when it closes, so keep the selection in state and update it in `onSelectionChange`.
+     */
+    selected: string[];
+    selectionVariant: "single" | "multiple";
+}
+interface NonSelectableMenuGroupProps extends BaseMenuGroupProps {
+    selectionVariant?: undefined;
 }
+export type MenuGroupProps = SelectableMenuGroupProps | NonSelectableMenuGroupProps;
 export declare const MenuGroup: import("react").ForwardRefExoticComponent<MenuGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist-types/menu/MenuGroupContext.d.ts

@@ -0,0 +1,10 @@
+import { type SyntheticEvent } from "react";
+import type { MenuGroupProps } from "./MenuGroup";
+export interface MenuGroupContextValue {
+    isSelected: (value: string) => boolean;
+    select: (event: SyntheticEvent, value: string) => void;
+    selectionVariant?: MenuGroupProps["selectionVariant"];
+}
+export declare const defaultMenuGroupContextValue: MenuGroupContextValue;
+export declare const MenuGroupContext: import("react").Context<MenuGroupContextValue>;
+export declare function useMenuGroup(): MenuGroupContextValue;

package/dist-types/menu/MenuItem.d.ts

@@ -4,5 +4,9 @@ export interface MenuItemProps extends ComponentPropsWithoutRef<"div"> {
      * If `true`, the item will be disabled.
      */
     disabled?: boolean;
+    /**
+     * The value of the item. Identifies the item inside a `MenuGroup` whose `selectionVariant` is "single" or "multiple".
+     */
+    value?: string;
 }
 export declare const MenuItem: import("react").ForwardRefExoticComponent<MenuItemProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist-types/menu/MenuPanelContext.d.ts

@@ -1,5 +1,7 @@
 import type { MenuContextValue } from "./MenuContext";
 export interface MenuPanelContextValue extends Pick<MenuContextValue, "getItemProps" | "activeIndex" | "setFocusInside"> {
+    hasSelectionIcon: boolean;
+    registerPanelSelectionIcon: () => () => void;
 }
 export declare const MenuPanelContext: import("react").Context<MenuPanelContextValue>;
 export declare function useMenuPanelContext(): MenuPanelContextValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salt-ds/core",
-  "version": "1.73.0",
+  "version": "1.74.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",