@elliemae/ds-menu-button 3.46.0-rc.1 → 3.46.0-rc.10

package/dist/esm/utils/useOptionsArrayToDsTree.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../../scripts/build/transpile/react-shim.js", "../../../src/utils/useOptionsArrayToDsTree.ts"],
-  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import React from 'react';\nimport { useDSTree } from '@elliemae/ds-tree-model';\nimport type { UseDSTreeT } from '@elliemae/ds-tree-model';\nimport { type DSMenuButtonT } from '../react-desc-prop-types.js';\n\nconst useDsTreeOpts: UseDSTreeT.SecondParameter<DSMenuButtonT.MenuItemInterface> = {\n  getUniqueId: (item) => item.dsId,\n};\n\ntype UseOptionsArrayToDsTreeRootNodeConfig = {\n  options: DSMenuButtonT.MenuItemInterface[];\n  instanceUid: string;\n};\n\ntype RootNodeType = UseDSTreeT.Item<DSMenuButtonT.MenuItemInterface>;\n\nexport const useOptionsArrayToDsTree = ({ options, instanceUid }: UseOptionsArrayToDsTreeRootNodeConfig) => {\n  // we need to create the root node that the app dev doesn't need to worry about\n  const rootNode = React.useMemo<RootNodeType>(\n    () =>\n      ({\n        dsId: `root-${instanceUid}`,\n        type: 'ROOT_ITEM',\n        subitems: options,\n        // as unknown as RootNodeType is because currently\n        //  the DS tree model doesn't support the type of the root node being different from the subitems\n        //  in practice, this is fine because the root node is never rendered & the subitems are the only thing that matters\n        //  will be addresssed via PUI-XXXX\n      }) as unknown as RootNodeType,\n    [instanceUid, options],\n  );\n  return useDSTree<DSMenuButtonT.MenuItemInterface>(rootNode, useDsTreeOpts);\n};\n"],
-  "mappings": "AAAA,YAAY,WAAW;ACAvB,OAAOA,YAAW;AAClB,SAAS,iBAAiB;AAI1B,MAAM,gBAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AASO,MAAM,0BAA0B,CAAC,EAAE,SAAS,YAAY,MAA6C;AAE1G,QAAM,WAAWA,OAAM;AAAA,IACrB,OACG;AAAA,MACC,MAAM,QAAQ,WAAW;AAAA,MACzB,MAAM;AAAA,MACN,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA,IAKZ;AAAA,IACF,CAAC,aAAa,OAAO;AAAA,EACvB;AACA,SAAO,UAA2C,UAAU,aAAa;AAC3E;",
+  "sourcesContent": ["import * as React from 'react';\nexport { React };\n", "import React from 'react';\nimport { useDSTree } from '@elliemae/ds-tree-model';\nimport type { UseDSTreeT } from '@elliemae/ds-tree-model';\nimport { type DSMenuButtonT, menuSpecificDefaultProps } from '../react-desc-prop-types.js';\n\nconst useDsTreeOpts: UseDSTreeT.SecondParameter<DSMenuButtonT.MenuItemInterface> = {\n  getUniqueId: (item) => item.dsId,\n};\n\ntype UseOptionsArrayToDsTreeRootNodeConfig = {\n  options: DSMenuButtonT.MenuItemInterface[];\n  instanceUid: string;\n  propsWithDefault?: DSMenuButtonT.MenuSpecifiDefaultProps;\n};\n\ntype RootNodeType = UseDSTreeT.Item<DSMenuButtonT.MenuItemInterface>;\n\nexport const useOptionsArrayToDsTree = ({\n  options,\n  instanceUid,\n  propsWithDefault,\n}: UseOptionsArrayToDsTreeRootNodeConfig) => {\n  const { maxHeight } = propsWithDefault || menuSpecificDefaultProps;\n  // we need to create the root node that the app dev doesn't need to worry about\n  const rootNode = React.useMemo<RootNodeType>(\n    () =>\n      ({\n        dsId: `root-${instanceUid}`,\n        type: 'ROOT_ITEM',\n        subitems: options,\n        maxHeight,\n        // as unknown as RootNodeType is because currently\n        //  the DS tree model doesn't support the type of the root node being different from the subitems\n        //  in practice, this is fine because the root node is never rendered & the subitems are the only thing that matters\n        //  will be addresssed via PUI-XXXX\n      }) as unknown as RootNodeType,\n    [instanceUid, maxHeight, options],\n  );\n  return useDSTree<DSMenuButtonT.MenuItemInterface>(rootNode, useDsTreeOpts);\n};\n"],
+  "mappings": "AAAA,YAAY,WAAW;ACAvB,OAAOA,YAAW;AAClB,SAAS,iBAAiB;AAE1B,SAA6B,gCAAgC;AAE7D,MAAM,gBAA6E;AAAA,EACjF,aAAa,CAAC,SAAS,KAAK;AAC9B;AAUO,MAAM,0BAA0B,CAAC;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AACF,MAA6C;AAC3C,QAAM,EAAE,UAAU,IAAI,oBAAoB;AAE1C,QAAM,WAAWA,OAAM;AAAA,IACrB,OACG;AAAA,MACC,MAAM,QAAQ,WAAW;AAAA,MACzB,MAAM;AAAA,MACN,UAAU;AAAA,MACV;AAAA;AAAA;AAAA;AAAA;AAAA,IAKF;AAAA,IACF,CAAC,aAAa,WAAW,OAAO;AAAA,EAClC;AACA,SAAO,UAA2C,UAAU,aAAa;AAC3E;",
   "names": ["React"]
 }

package/dist/types/config/useSplitInherithedProps.d.ts

@@ -8,21 +8,21 @@ type UseSplitInherithedPropsConfig = {
 export declare const useSplitInherithedProps: ({ propsWithDefault, focusableNodes, treeRootNode, }: UseSplitInherithedPropsConfig) => {
     menuBehaviouralLayerProps: {
         buttonDOMNodeRef: React.MutableRefObject<HTMLElement | null>;
-        selectedItems: DSMenuButtonT.SelectionableMenuNodes[];
+        selectedNodes: DSMenuButtonT.SelectionableMenuNodes[];
         focusableNodes: DSMenuButtonT.PseudoFocusableMenuNodes[];
         optionsTree: DSMenuButtonT.MenuNode;
         onDisplayedSubmenuChange: ((newOpenedItems: DSMenuButtonT.WithSubmenuMenuNodes[], metainfo: {
             itemNode: DSMenuButtonT.PseudoFocusableMenuNodes | null;
-            event?: React.SyntheticEvent<Element, Event> | TouchEvent | FocusEvent | undefined;
+            event?: TouchEvent | React.SyntheticEvent<Element, Event> | FocusEvent | undefined;
         }) => void | import("@elliemae/ds-typescript-helpers").TypescriptHelpersT.StateSetter<DSMenuButtonT.WithSubmenuMenuNodes[]>) | undefined;
-        onItemSelected: (newSelection: DSMenuButtonT.SelectionableMenuNodes[], metainfo: {
+        onItemSelected: ((newSelection: DSMenuButtonT.SelectionableMenuNodes[], metainfo: {
             itemNode: DSMenuButtonT.SelectionableMenuNodes;
             event?: React.SyntheticEvent<Element, Event> | undefined;
-        }) => void | import("@elliemae/ds-typescript-helpers").TypescriptHelpersT.StateSetter<DSMenuButtonT.SelectionableMenuNodes[]>;
-        onActivateItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, metainfo: {
+        }) => void | import("@elliemae/ds-typescript-helpers").TypescriptHelpersT.StateSetter<DSMenuButtonT.SelectionableMenuNodes[]>) | undefined;
+        onActivateItem: ((itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, metainfo: {
             itemNode: DSMenuButtonT.PseudoFocusableMenuNodes;
             event?: React.SyntheticEvent<Element, Event> | undefined;
-        }) => void;
+        }) => void) | undefined;
         onOpen: (() => void) | undefined;
         onClose: (() => void) | undefined;
     };
@@ -36,7 +36,6 @@ export declare const useSplitInherithedProps: ({ propsWithDefault, focusableNode
             onSubmenuToggle: (nextOpenedSubmenus: Record<string, boolean>, submenu: DSMenuButtonT.MenuItemInterface, e: React.MouseEvent<Element, MouseEvent> | React.KeyboardEvent<Element>) => void;
             isLoading: boolean;
             isSkeleton: boolean;
-            selectedOptions: Record<string, boolean>;
             ItemRenderer: DSMenuButtonT.ItemRendererT | undefined;
         };
         type?: import("@elliemae/ds-button-v2").DSButtonT.HTMLButtonTypeProp | undefined;
@@ -276,6 +275,7 @@ export declare const useSplitInherithedProps: ({ propsWithDefault, focusableNode
         contextMenu?: string | undefined;
         dir?: string | undefined;
         draggable?: (boolean | "true" | "false") | undefined;
+        enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
         hidden?: boolean | undefined;
         id?: string | undefined;
         lang?: string | undefined;
@@ -311,7 +311,7 @@ export declare const useSplitInherithedProps: ({ propsWithDefault, focusableNode
         results?: number | undefined;
         security?: string | undefined;
         unselectable?: "on" | "off" | undefined;
-        inputMode?: "none" | "search" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+        inputMode?: "search" | "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
         is?: string | undefined;
         accept?: string | undefined;
         acceptCharset?: string | undefined;
@@ -439,7 +439,6 @@ export declare const useSplitInherithedProps: ({ propsWithDefault, focusableNode
         h?: import("@xstyled/system").SystemProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme> | undefined;
         maxWidth?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;
         maxW?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;
-        maxHeight?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;
         maxH?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;
         minHeight?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;
         minH?: (string | number | true | symbol | {} | (string & {}) | import("@xstyled/system").ThemeProp<string | number | true | symbol | {} | (string & {}), import("@xstyled/system").Theme>) | undefined;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export { DSMenuButton, DSMenuButtonWithSchema } from './DSMenuButton.js';
-export { type DSMenuButtonT } from './react-desc-prop-types.js';
+export { type DSMenuButtonT, DSMenuButtonPropTypes } from './react-desc-prop-types.js';
 export { MENU_BUTTON_SLOTS, MENU_BUTTON_DATA_TESTID, MENU_ITEMS_TYPES } from './constants/index.js';
 export { isFocusableNode } from './utils/nodesTypeguardsAndGetters.js';
 export { useOptionsArrayToDsTree } from './utils/useOptionsArrayToDsTree.js';

package/dist/types/parts/DSFlyoutMenu/react-desc-prop-types.d.ts

@@ -1,6 +1,6 @@
+import { type useFloatingContext } from '@elliemae/ds-floating-context';
 import type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
 import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
-import { type useFloatingContext } from '@elliemae/ds-floating-context';
 import { type DSMenuButtonT } from '../../react-desc-prop-types.js';
 import { DSFlyoutMenuName, FLYOUT_MENU_SLOTS } from './constants/index.js';
 export declare namespace DSFlyoutMenuT {

package/dist/types/parts/DSMenuBehaviouralContextProvider/config/useAdvancedValidation.d.ts

@@ -0,0 +1,6 @@
+import { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+type UseAdvancedValidationConfigT = {
+    propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;
+};
+export declare const useAdvancedValidation: ({ propsWithDefault }: UseAdvancedValidationConfigT) => void;
+export {};

package/dist/types/parts/DSMenuBehaviouralContextProvider/config/useFocusTracker.d.ts

@@ -4,12 +4,12 @@ export declare const useFocusTracker: () => {
     preventBlurReset: React.MutableRefObject<boolean>;
     focusRegion: "" | "trigger" | `item-dsid-${string}` | `item-dsid-${number}`;
     focusedElementItemNode: React.MutableRefObject<DSMenuButtonT.PseudoFocusableMenuNodes | null>;
-    trackFocusTrigger: () => null;
+    trackFocusTrigger: () => DSMenuButtonT.PseudoFocusableMenuNodes | null;
     trackFocusNode: (nodeToFocus: DSMenuButtonT.PseudoFocusableMenuNodes) => void;
-    trackFocusRegionReset: () => null;
-    trackFocusFirstChildItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes;
-    trackFocusLastChildItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes;
-    trackFocusNextItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes;
-    trackFocusPreviousItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes;
+    trackFocusRegionReset: () => DSMenuButtonT.PseudoFocusableMenuNodes | null;
+    trackFocusFirstChildItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
+    trackFocusLastChildItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
+    trackFocusNextItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
+    trackFocusPreviousItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
     trackFocusParentItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
 };

package/dist/types/parts/DSMenuBehaviouralContextProvider/config/useMenuItemEventsHandlers.d.ts

@@ -12,6 +12,7 @@ type UseMenuItemEventsHandlersConfig = {
 export declare const useMenuItemEventsHandlers: ({ propsWithDefault, focusTrackers, menuOpenStatus, handleChangeOpenedSubItems, }: UseMenuItemEventsHandlersConfig) => {
     handleFocusableMenuItemKeyDown: React.KeyboardEventHandler<HTMLDivElement>;
     handleFocusableMenuItemClick: (event: React.MouseEvent<HTMLDivElement>) => void;
-    handleFocusableMenuItemOnMouseEnter: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, event: React.MouseEvent) => void;
+    handleFocusableMenuItemOnMouseEnter: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => void;
+    handleFocusableMenuItemNativeFocusEvent: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, event: React.FocusEvent) => void;
 };
 export {};

package/dist/types/parts/DSMenuBehaviouralContextProvider/react-desc-prop-types.d.ts

@@ -12,6 +12,7 @@ export declare namespace DSMenuBehaviouralContextProviderT {
     interface DefaultProps extends DSMenuButtonT.MenuBehaviouralLayerDefaultProps {
     }
     interface OptionalProps extends DSMenuButtonT.MenuBehaviouralLayerOptionalProps {
+        selectedNodes?: DSMenuButtonT.SelectionableMenuNodes[];
     }
     interface Props extends Partial<DefaultProps>, OptionalProps, RequiredProps {
     }

package/dist/types/parts/DSMenuBehaviouralContextProvider/utils/multipleSelectionHelpers.d.ts

@@ -1,6 +1,6 @@
 import { type DSMenuButtonT } from '../../../react-desc-prop-types.js';
-export declare const getIsMultipleSelectNodeWithSubmenuSelected: ({ itemNode, selectedItems, }: {
+export declare const getIsMultipleSelectNodeWithSubmenuSelected: ({ itemNode, selectedNodes, }: {
     itemNode: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;
-    selectedItems: DSMenuButtonT.SelectionableMenuNodes[];
+    selectedNodes: DSMenuButtonT.SelectionableMenuNodes[];
 }) => boolean | "mixed";
-export declare const getNewSelectionMultipleSelect: (selectedItems: DSMenuButtonT.SelectionableMenuNodes[], selectedItem: DSMenuButtonT.MultipleSelectionableMenuNodes) => DSMenuButtonT.SelectionableMenuNodes[];
+export declare const getNewSelectionMultipleSelect: (selectedNodes: DSMenuButtonT.SelectionableMenuNodes[], selectedItem: DSMenuButtonT.MultipleSelectionableMenuNodes) => DSMenuButtonT.SelectionableMenuNodes[];

package/dist/types/parts/DSMenuBehaviouralContextProvider/utils/singleSelectionHelpers.d.ts

@@ -6,8 +6,8 @@ import { type DSMenuButtonT } from '../../../react-desc-prop-types.js';
  *  the selection must be propagated because
  *  a single-select within a single-select-with-submenu can't be selected without implying the selection of the parent single-select-with-submenu
  *
- * @param selectedItems - the current selected items
+ * @param selectedNodes - the current selected items
  * @param selectedItem - the newly selected item
  * @returns DSMenuButtonT.SelectionableMenuNodes[] - the new selection
  */
-export declare const getNewSelectionSingleSelect: (selectedItems: DSMenuButtonT.SelectionableMenuNodes[], selectedItem: DSMenuButtonT.MenuNodeSingleSelectItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem) => DSMenuButtonT.SelectionableMenuNodes[];
+export declare const getNewSelectionSingleSelect: (selectedNodes: DSMenuButtonT.SelectionableMenuNodes[], selectedItem: DSMenuButtonT.MenuNodeSingleSelectItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem) => DSMenuButtonT.SelectionableMenuNodes[];

package/dist/types/parts/DSMenuItemRendererFactory/SkeletonMenuItem.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
+export declare const SkeletonMenuItem: React.ComponentType<{
+    itemNode: DSMenuButtonT.MenuNodeSkeletonItem;
+}>;

package/dist/types/parts/DSMenuItemRendererFactory/focusNodeRacingConditionSolved.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="lodash" />
+export declare const focusNodeRacingConditionSolved: import("lodash").DebouncedFunc<(node: HTMLDivElement) => void>;

package/dist/types/parts/DSMenuItemRendererFactory/react-desc-prop-types.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="react" />
-import type { GlobalAttributesT, XstyledProps, DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
+import type { DSPropTypesSchema, GlobalAttributesT, ValidationMap, XstyledProps } from '@elliemae/ds-props-helpers';
 import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
-import { DSMenuItemRendererFactoryName, MENU_ITEM_RENDERER_FACTORY_SLOTS } from './constants/index.js';
 import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
 import type { DSFlyoutMenuT } from '../DSFlyoutMenu/react-desc-prop-types.js';
+import { DSMenuItemRendererFactoryName, MENU_ITEM_RENDERER_FACTORY_SLOTS } from './constants/index.js';
 export declare namespace DSMenuItemRendererFactoryT {
     interface RequiredProps {
         itemNode: DSMenuButtonT.MenuNode;

package/dist/types/parts/DSOpinionatedButton/config/useOpinionatedButton.d.ts

@@ -31,7 +31,7 @@ export declare const useOpinionatedButton: (propsFromUser: DSOpinionatedButtonT.
         context: {
             withoutPortal: boolean;
             withoutAnimation: boolean;
-            portalDOMContainer: HTMLElement;
+            portalDOMContainer: HTMLElement | undefined;
             animationDuration: number;
         };
     };

package/dist/types/parts/DSOpinionatedButton/react-desc-prop-types.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
 import type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
 import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
+import type React from 'react';
 import { type DSMenuButtonT } from '../../react-desc-prop-types.js';
 import { DSOpinionatedButtonName, OPINIONATED_BUTTON_SLOTS } from './constants/index.js';
 export declare namespace DSOpinionatedButtonT {

package/dist/types/react-desc-prop-types.d.ts

@@ -8,6 +8,7 @@ export declare namespace DSMenuButtonT {
     interface RootItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
         type: 'ROOT_ITEM';
         dsId: string;
+        maxHeight?: string | number;
         label?: undefined;
         secondaryLabel?: undefined;
         leftDecoration?: undefined;
@@ -45,6 +46,7 @@ export declare namespace DSMenuButtonT {
         secondaryLabel?: string;
         leftDecoration?: React.ComponentType;
         minWidth?: string | number;
+        maxHeight?: string | number;
         disabled?: boolean;
         onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
         onKeyDown?: (e: React.KeyboardEvent) => null;
@@ -78,6 +80,7 @@ export declare namespace DSMenuButtonT {
         secondaryLabel?: string;
         leftDecoration?: React.ComponentType;
         minWidth?: string | number;
+        maxHeight?: string | number;
         disabled?: boolean;
         onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
         onKeyDown?: (e: React.KeyboardEvent) => null;
@@ -89,6 +92,7 @@ export declare namespace DSMenuButtonT {
         secondaryLabel?: string;
         leftDecoration?: React.ComponentType;
         minWidth?: string | number;
+        maxHeight?: string | number;
         disabled?: boolean;
         onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
         onKeyDown?: (e: React.KeyboardEvent) => null;
@@ -111,6 +115,7 @@ export declare namespace DSMenuButtonT {
         secondaryLabel?: string;
         leftDecoration?: React.ComponentType;
         minWidth?: string | number;
+        maxHeight: string | number;
         disabled?: boolean;
         onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
         onKeyDown?: (e: React.KeyboardEvent) => null;
@@ -122,8 +127,9 @@ export declare namespace DSMenuButtonT {
         leftDecoration?: React.ComponentType;
         minWidth?: string | number;
     }
-    type MenuItemInterface = SeparatorItem | ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | GroupItem;
+    type MenuItemInterface = SeparatorItem | ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | GroupItem | SingleSelectItem | SingleSelectWithSubmenuItem;
     type PseudoFocusableItemInterface = ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | SingleSelectItem | SingleSelectWithSubmenuItem;
+    type SelectionableMenuItemInterface = MultipleSelectItem | MultiSelectWithSubmenuItem | SingleSelectItem | SingleSelectWithSubmenuItem;
     type MenuNodeRootItem = UseDSTreeT.TreeNode<RootItem>;
     type MenuNodeSeparatorItem = UseDSTreeT.TreeNode<SeparatorItem>;
     type MenuNodeActivableItem = UseDSTreeT.TreeNode<ActivableItem>;
@@ -138,24 +144,15 @@ export declare namespace DSMenuButtonT {
     type MenuNode = MenuNodeSeparatorItem | MenuNodeActivableItem | MenuNodeActivableWithSubmenuItem | MenuNodeSkeletonItem | MenuNodeMultipleSelectItem | MenuNodeMultipleSelectWithSubmenuItem | MenuNodeWithSubmenuItem | MenuNodeSingleSelectItem | MenuNodeSingleSelectWithSubmenuItem | MenuNodeGroupItem;
     type PseudoFocusableMenuNodes = MenuNodeActivableItem | MenuNodeActivableWithSubmenuItem | MenuNodeSkeletonItem | MenuNodeSingleSelectItem | MenuNodeMultipleSelectItem | MenuNodeMultipleSelectWithSubmenuItem | MenuNodeWithSubmenuItem | MenuNodeSingleSelectWithSubmenuItem;
     type MenuNodesAllowedToHaveChildren = MenuNodeRootItem | MenuNodeWithSubmenuItem | MenuNodeGroupItem | MenuNodeActivableWithSubmenuItem | MenuNodeMultipleSelectWithSubmenuItem | MenuNodeSingleSelectWithSubmenuItem;
-    type ItemRendererT = React.ComponentType<{
-        itemNode: MenuNode;
-    }>;
     type SelectionableMenuNodes = DSMenuButtonT.MenuNodeMultipleSelectItem | DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem | DSMenuButtonT.MenuNodeSingleSelectItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
     type MultipleSelectionableMenuNodes = DSMenuButtonT.MenuNodeMultipleSelectItem | DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;
     type SingleSelectionableMenuNodes = DSMenuButtonT.MenuNodeSingleSelectItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
     type WithSubmenuMenuNodes = DSMenuButtonT.MenuNodeWithSubmenuItem | DSMenuButtonT.MenuNodeActivableWithSubmenuItem | DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
     type SelectionablesWithSubmenuMenuNodes = DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
+    type ItemRendererT = React.ComponentType<{
+        itemNode: MenuNode;
+    }>;
     interface MenuBehaviouralLayerRequiredProps {
-        selectedItems: SelectionableMenuNodes[];
-        onItemSelected: (newSelection: SelectionableMenuNodes[], metainfo: {
-            itemNode: DSMenuButtonT.SelectionableMenuNodes;
-            event?: React.SyntheticEvent;
-        }) => void | TypescriptHelpersT.StateSetter<DSMenuButtonT.SelectionableMenuNodes[]>;
-        onActivateItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, metainfo: {
-            itemNode: DSMenuButtonT.PseudoFocusableMenuNodes;
-            event?: React.SyntheticEvent;
-        }) => void;
     }
     interface MenuSpecificRequiredProps {
     }
@@ -173,13 +170,21 @@ export declare namespace DSMenuButtonT {
         onSubmenuToggle: (nextOpenedSubmenus: Record<string, boolean>, submenu: MenuItemInterface, e: React.MouseEvent | React.KeyboardEvent) => void;
         isLoading: boolean;
         isSkeleton: boolean;
-        selectedOptions: Record<string, boolean>;
+        maxHeight: string | number;
     }
     interface ButtonInheiredDefaultProps extends Omit<DSButtonV3T.DefaultProps, keyof MenuSpecifiDefaultProps> {
     }
     interface DefaultProps extends MenuSpecifiDefaultProps, ButtonInheiredDefaultProps, MenuBehaviouralLayerDefaultProps {
     }
     interface MenuBehaviouralLayerOptionalProps {
+        onItemSelected?: (newSelection: SelectionableMenuNodes[], metainfo: {
+            itemNode: DSMenuButtonT.SelectionableMenuNodes;
+            event?: React.SyntheticEvent;
+        }) => void | TypescriptHelpersT.StateSetter<DSMenuButtonT.SelectionableMenuNodes[]>;
+        onActivateItem?: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes, metainfo: {
+            itemNode: DSMenuButtonT.PseudoFocusableMenuNodes;
+            event?: React.SyntheticEvent;
+        }) => void;
         onOpen?: () => void;
         onClose?: () => void;
         onDisplayedSubmenuChange?: (newOpenedItems: DSMenuButtonT.WithSubmenuMenuNodes[], metainfo: {
@@ -193,6 +198,7 @@ export declare namespace DSMenuButtonT {
     interface ButtonInheritedOptionalProps extends Omit<DSButtonV3T.OptionalProps, keyof MenuSpecificOptionalProps> {
     }
     interface OptionalProps extends MenuSpecificOptionalProps, ButtonInheritedOptionalProps, MenuBehaviouralLayerOptionalProps, TypescriptHelpersT.PropsForGlobalOnSlots<typeof DSMenuButtonName, typeof MENU_BUTTON_SLOTS> {
+        selectedItems?: SelectionableMenuNodes[] | SelectionableMenuItemInterface[];
     }
     interface MenuBehaviouralLayerProps extends Partial<MenuBehaviouralLayerDefaultProps>, MenuBehaviouralLayerOptionalProps, MenuBehaviouralLayerRequiredProps {
     }
@@ -200,7 +206,7 @@ export declare namespace DSMenuButtonT {
     }
     interface ButtonInheritedProps extends Omit<DSButtonV3T.Props, keyof MenuSpecificProps> {
     }
-    interface Props extends RequiredProps, Partial<DefaultProps>, OptionalProps {
+    interface Props extends RequiredProps, Partial<DefaultProps>, OptionalProps, Omit<DSButtonV3T.Props, keyof RequiredProps | keyof DefaultProps | keyof OptionalProps> {
     }
     interface MenuBehaviouralLayerInternalProps extends MenuBehaviouralLayerDefaultProps, MenuBehaviouralLayerOptionalProps, MenuBehaviouralLayerRequiredProps {
     }
@@ -208,10 +214,10 @@ export declare namespace DSMenuButtonT {
     }
     interface ButtonInheritedInternalProps extends Omit<DSButtonV3T.InternalProps, keyof MenuSpecificInternalProps> {
     }
-    interface InternalProps extends RequiredProps, DefaultProps, OptionalProps {
+    interface InternalProps extends RequiredProps, DefaultProps, OptionalProps, Omit<DSButtonV3T.Props, keyof RequiredProps | keyof DefaultProps | keyof OptionalProps> {
     }
 }
-export declare const defaultProps: DSMenuButtonT.MenuSpecifiDefaultProps;
+export declare const menuSpecificDefaultProps: DSMenuButtonT.MenuSpecifiDefaultProps;
 export declare const MenuBehaviouralLayerPropTypes: DSPropTypesSchema<DSMenuButtonT.MenuBehaviouralLayerProps>;
 export declare const DSMenuSpecificPropTypes: DSPropTypesSchema<DSMenuButtonT.MenuSpecificProps>;
 export declare const DSMenuButtonPropTypes: DSPropTypesSchema<DSMenuButtonT.Props>;

package/dist/types/utils/nodesTypeguardsAndGetters.d.ts

@@ -1,22 +1,134 @@
 import { type DSMenuButtonT } from '../react-desc-prop-types.js';
+/**
+ * Heuristic to determine if the selected item is an item or a node.
+ * Not perfect because JavaScript is not typed.
+ * If app devs provide an object that matches all of those conditions, it's an edge case the app devs should handle.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is (heuristically) a menu node, false otherwise.
+ */
+export declare const isObjectAMenuNode: (item: unknown) => item is DSMenuButtonT.MenuNode;
+/**
+ * Checks if the item is an activable node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is an activable node, false otherwise.
+ */
 export declare const isActivableNode: (item: unknown) => item is DSMenuButtonT.MenuNodeActivableItem;
-export declare const isActivableWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.MenuNodeActivableWithSubmenuItem;
+/**
+ * Checks if the item is a skeleton node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a skeleton node, false otherwise.
+ */
 export declare const isSkeletonNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSkeletonItem;
+/**
+ * Checks if the item is a multiple select only node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a multiple select only node, false otherwise.
+ */
 export declare const isMultipleSelectOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeMultipleSelectItem;
+/**
+ * Checks if the item is a multiple select node with a submenu.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a multiple select node with a submenu, false otherwise.
+ */
 export declare const isMultipleSelectWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;
+/**
+ * Checks if the item is a multiple select node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a multiple select node, false otherwise.
+ */
 export declare const isMultipleSelectNode: (item: unknown) => item is DSMenuButtonT.MultipleSelectionableMenuNodes;
+/**
+ * Checks if the item is a single select only node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a single select only node, false otherwise.
+ */
 export declare const isSingleSelectOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSingleSelectItem;
+/**
+ * Checks if the item is a single select node with a submenu.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a single select node with a submenu, false otherwise.
+ */
 export declare const isSingleSelectNodeWithSubmenu: (item: unknown) => item is DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
+/**
+ * Checks if the item is a single select node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a single select node, false otherwise.
+ */
 export declare const isSingleSelectNode: (item: unknown) => item is DSMenuButtonT.SingleSelectionableMenuNodes;
+/**
+ * Checks if the item is a selectionable node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a selectionable node, false otherwise.
+ */
 export declare const isSelectionableNode: (item: unknown) => item is DSMenuButtonT.SelectionableMenuNodes;
+/**
+ * Gets all selectionable nodes from the tree.
+ * @param {DSMenuButtonT.MenuNode} tree - The tree to search.
+ * @returns {DSMenuButtonT.SelectionableMenuNodes[]} - An array of selectionable nodes.
+ */
 export declare const getSelectionableNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.SelectionableMenuNodes[];
+/**
+ * Checks if the item is a node with a submenu (and nothing else).
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a node with a submenu, false otherwise.
+ */
 export declare const isWithSubmenuOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeWithSubmenuItem;
+/**
+ * Checks if the item is a selectionable node with a submenu.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a selectionable node with a submenu, false otherwise.
+ */
 export declare const isSelectionableWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.SelectionablesWithSubmenuMenuNodes;
+/**
+ * Checks if the item is an activable node with a submenu.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is an activable node with a submenu, false otherwise.
+ */
+export declare const isActivableWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.MenuNodeActivableWithSubmenuItem;
+/**
+ * Checks if the item is a node with a submenu.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a node with a submenu, false otherwise.
+ */
 export declare const isWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.WithSubmenuMenuNodes;
+/**
+ * Gets all nodes with a submenu from the tree.
+ * @param {DSMenuButtonT.MenuNode} tree - The tree to search.
+ * @returns {DSMenuButtonT.PseudoFocusableMenuNodes[]} - An array of nodes with a submenu.
+ */
 export declare const getWithSubmenuNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.PseudoFocusableMenuNodes[];
+/**
+ * Checks if the item is a node that can be focused.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a node that can be focused, false otherwise.
+ */
 export declare const isFocusableNode: (item: unknown) => item is DSMenuButtonT.PseudoFocusableMenuNodes;
+/**
+ * Gets all nodes that can be focused from the tree.
+ * @param {DSMenuButtonT.MenuNode} tree - The tree to search.
+ * @returns {DSMenuButtonT.PseudoFocusableMenuNodes[]} - An array of nodes that can be focused.
+ */
 export declare const getFocusableNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.PseudoFocusableMenuNodes[];
+/**
+ * Checks if the item is a separator node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a separator node, false otherwise.
+ */
 export declare const isSeparatorNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSeparatorItem;
+/**
+ * Checks if the item is a group node.
+ * @param {unknown} item - The item to check.
+ * @returns {boolean} - True if the item is a group node, false otherwise.
+ */
 export declare const isGroup: (item: unknown) => item is DSMenuButtonT.MenuNodeGroupItem;
+/**
+ * Checks if the given item is a root node of the menu.
+ * @param {DSMenuButtonT.MenuNode} tree - The tree to search.
+ * @returns {DSMenuButtonT.PseudoFocusableMenuNodes[]} - An array of nodes that can be focused.
+ * @remarks
+ * The root item is not a renderable item and must always be treated with special care.
+ *
+ * This function uses a hardcoded string to identify the root item.
+ */
 export declare const isRootNode: (item: unknown) => item is DSMenuButtonT.MenuNodeRootItem;
 export declare const isMenuNodeAllowedToHaveChildren: (item: unknown) => item is DSMenuButtonT.MenuNodesAllowedToHaveChildren;

package/dist/types/utils/useOptionsArrayToDsTree.d.ts

@@ -3,6 +3,7 @@ import { type DSMenuButtonT } from '../react-desc-prop-types.js';
 type UseOptionsArrayToDsTreeRootNodeConfig = {
     options: DSMenuButtonT.MenuItemInterface[];
     instanceUid: string;
+    propsWithDefault?: DSMenuButtonT.MenuSpecifiDefaultProps;
 };
-export declare const useOptionsArrayToDsTree: ({ options, instanceUid }: UseOptionsArrayToDsTreeRootNodeConfig) => UseDSTreeT.OutputT<DSMenuButtonT.MenuItemInterface>;
+export declare const useOptionsArrayToDsTree: ({ options, instanceUid, propsWithDefault, }: UseOptionsArrayToDsTreeRootNodeConfig) => UseDSTreeT.OutputT<DSMenuButtonT.MenuItemInterface>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-menu-button",
-  "version": "3.46.0-rc.1",
+  "version": "3.46.0-rc.10",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Menu Button",
   "files": [
@@ -37,22 +37,21 @@
   },
   "dependencies": {
     "@xstyled/styled-components": "~3.6.0",
-    "@elliemae/ds-button-v2": "3.46.0-rc.1",
-    "@elliemae/ds-hooks-on-blur-out": "3.46.0-rc.1",
-    "@elliemae/ds-grid": "3.46.0-rc.1",
-    "@elliemae/ds-floating-context": "3.46.0-rc.1",
-    "@elliemae/ds-menu-items-commons": "3.46.0-rc.1",
-    "@elliemae/ds-icons": "3.46.0-rc.1",
-    "@elliemae/ds-props-helpers": "3.46.0-rc.1",
-    "@elliemae/ds-system": "3.46.0-rc.1",
-    "@elliemae/ds-tree-model": "3.46.0-rc.1"
+    "@elliemae/ds-button-v2": "3.46.0-rc.10",
+    "@elliemae/ds-floating-context": "3.46.0-rc.10",
+    "@elliemae/ds-grid": "3.46.0-rc.10",
+    "@elliemae/ds-hooks-on-blur-out": "3.46.0-rc.10",
+    "@elliemae/ds-props-helpers": "3.46.0-rc.10",
+    "@elliemae/ds-icons": "3.46.0-rc.10",
+    "@elliemae/ds-system": "3.46.0-rc.10",
+    "@elliemae/ds-menu-items-commons": "3.46.0-rc.10",
+    "@elliemae/ds-tree-model": "3.46.0-rc.10"
   },
   "devDependencies": {
     "@elliemae/pui-cli": "9.0.0-next.50",
     "styled-components": "~5.3.9",
-    "@elliemae/ds-dropdownmenu-v2": "3.46.0-rc.1",
-    "@elliemae/ds-monorepo-devops": "3.46.0-rc.1",
-    "@elliemae/ds-typescript-helpers": "3.46.0-rc.1"
+    "@elliemae/ds-monorepo-devops": "3.46.0-rc.10",
+    "@elliemae/ds-typescript-helpers": "3.46.0-rc.10"
   },
   "peerDependencies": {
     "@testing-library/jest-dom": "~5.16.4",