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

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/react-desc-prop-types.d.ts

@@ -124,6 +124,7 @@ export declare namespace DSMenuButtonT {
     }
     type MenuItemInterface = SeparatorItem | ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | GroupItem;
     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 +139,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 +165,20 @@ 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>;
     }
     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 +192,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 +200,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,7 +208,7 @@ 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;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-menu-button",
-  "version": "3.46.0-rc.1",
+  "version": "3.46.0-rc.3",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Menu Button",
   "files": [
@@ -37,22 +37,22 @@
   },
   "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.3",
+    "@elliemae/ds-floating-context": "3.46.0-rc.3",
+    "@elliemae/ds-grid": "3.46.0-rc.3",
+    "@elliemae/ds-hooks-on-blur-out": "3.46.0-rc.3",
+    "@elliemae/ds-icons": "3.46.0-rc.3",
+    "@elliemae/ds-menu-items-commons": "3.46.0-rc.3",
+    "@elliemae/ds-props-helpers": "3.46.0-rc.3",
+    "@elliemae/ds-system": "3.46.0-rc.3",
+    "@elliemae/ds-tree-model": "3.46.0-rc.3"
   },
   "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-dropdownmenu-v2": "3.46.0-rc.3",
+    "@elliemae/ds-monorepo-devops": "3.46.0-rc.3",
+    "@elliemae/ds-typescript-helpers": "3.46.0-rc.3"
   },
   "peerDependencies": {
     "@testing-library/jest-dom": "~5.16.4",