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

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

@@ -1,53 +1,218 @@
-import type { GlobalAttributesT, XstyledProps, DSPropTypesSchema } from '@elliemae/ds-props-helpers';
+/// <reference types="react" />
+import type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
 import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
-import type { WeakValidationMap } from 'react';
-export declare namespace MenuButtonT {
-    interface RequiredProps<T> {
-        items: Item[];
-        TriggerElement: React.ComponentType<TriggerElementProps<T>>;
-    }
-    interface DefaultProps {
-        selectedKeys: string[];
-        onSelectionChange: (selectedKeys: string[], parentId: string, item: MenuButtonT.Item) => void;
-    }
-    interface OptionalProps<T extends object> {
-        triggerElementProps?: T;
-        selectionMode?: 'single' | 'multiple';
-        menuMinWidth?: string | number;
-        ItemRenderer?: ItemRendererT;
+import type { DSButtonV3T } from '@elliemae/ds-button-v2';
+import type { UseDSTreeT } from '@elliemae/ds-tree-model';
+import { DSMenuButtonName, MENU_BUTTON_SLOTS, type MENU_ITEMS_TYPES } from './constants/index.js';
+export declare namespace DSMenuButtonT {
+    interface RootItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: 'ROOT_ITEM';
+        dsId: string;
+        label?: undefined;
+        secondaryLabel?: undefined;
+        leftDecoration?: undefined;
+        minWidth?: undefined;
+        disabled?: undefined;
+        onClick?: undefined;
+        onKeyDown?: undefined;
+    }
+    interface SeparatorItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['SEPARATOR'];
+        dsId: string;
+        label?: undefined;
+        secondaryLabel?: undefined;
+        leftDecoration?: undefined;
+        minWidth?: undefined;
+        disabled?: undefined;
+        onClick?: undefined;
+        onKeyDown?: undefined;
+    }
+    interface ActivableItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['ACTIVABLE_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
+    }
+    interface ActionableWithSubmenuItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['ACTIVABLE_WITH_SUBMENU_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
+    }
+    interface SkeletonItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['SKELETON_ITEM'];
+        dsId: string;
+        minWidth?: string | number;
+        label?: undefined;
+        secondaryLabel?: undefined;
+        leftDecoration?: undefined;
+        disabled?: undefined;
+        onClick?: undefined;
+        onKeyDown?: undefined;
     }
-    interface Props<T extends object = object> extends Partial<DefaultProps>, OptionalProps<T>, Omit<GlobalAttributesT<HTMLButtonElement>, keyof OptionalProps<T> | keyof XstyledProps>, XstyledProps, RequiredProps<T> {
+    interface MultipleSelectItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['MULTIPLE_SELECT_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
     }
-    interface InternalProps<T extends object = object> extends DefaultProps, OptionalProps<T>, Omit<GlobalAttributesT<HTMLButtonElement>, keyof OptionalProps<T> | keyof XstyledProps>, XstyledProps, RequiredProps<T> {
+    interface MultiSelectWithSubmenuItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['MULTIPLE_SELECT_WITH_SUBMENU_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
+    }
+    interface WithSubmenuItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['WITH_SUBMENU_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
     }
-    type Item = {
+    interface SingleSelectItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['SINGLE_SELECT_ITEM'];
         dsId: string;
         label: string;
-        type?: 'separator' | 'section';
-        childrens?: Item[];
-        subitems?: Item[];
-        selectionMode?: 'single' | 'multiple';
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
         minWidth?: string | number;
         disabled?: boolean;
-    };
-    interface TriggerElementProps<T2> {
-        isOpen: boolean;
-        innerRef: TypescriptHelpersT.AnyRef<HTMLButtonElement | null>;
-        setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
-        attributes: {
-            'aria-haspopup'?: boolean | 'true' | 'false' | 'dialog' | 'grid' | 'listbox' | 'menu' | 'tree';
-            'aria-expanded': boolean;
-        };
-        listeners: {
-            onKeyDown: (e: React.KeyboardEvent) => void;
-        };
-        triggerElementProps: T2;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
     }
+    interface SingleSelectWithSubmenuItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['SINGLE_SELECT_WITH_SUBMENU_ITEM'];
+        dsId: string;
+        label: string;
+        secondaryLabel?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+        disabled?: boolean;
+        onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+        onKeyDown?: (e: React.KeyboardEvent) => null;
+    }
+    interface GroupItem extends UseDSTreeT.AnyObjectWithoutReservedKeys {
+        type: (typeof MENU_ITEMS_TYPES)['GROUP'];
+        dsId: string;
+        label?: string;
+        leftDecoration?: React.ComponentType;
+        minWidth?: string | number;
+    }
+    type MenuItemInterface = SeparatorItem | ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | GroupItem;
+    type PseudoFocusableItemInterface = ActivableItem | ActionableWithSubmenuItem | SkeletonItem | MultipleSelectItem | MultiSelectWithSubmenuItem | WithSubmenuItem | SingleSelectItem | SingleSelectWithSubmenuItem;
+    type MenuNodeRootItem = UseDSTreeT.TreeNode<RootItem>;
+    type MenuNodeSeparatorItem = UseDSTreeT.TreeNode<SeparatorItem>;
+    type MenuNodeActivableItem = UseDSTreeT.TreeNode<ActivableItem>;
+    type MenuNodeActivableWithSubmenuItem = UseDSTreeT.TreeNode<ActionableWithSubmenuItem>;
+    type MenuNodeSkeletonItem = UseDSTreeT.TreeNode<SkeletonItem>;
+    type MenuNodeMultipleSelectItem = UseDSTreeT.TreeNode<MultipleSelectItem>;
+    type MenuNodeMultipleSelectWithSubmenuItem = UseDSTreeT.TreeNode<MultiSelectWithSubmenuItem>;
+    type MenuNodeWithSubmenuItem = UseDSTreeT.TreeNode<WithSubmenuItem>;
+    type MenuNodeSingleSelectItem = UseDSTreeT.TreeNode<SingleSelectItem>;
+    type MenuNodeSingleSelectWithSubmenuItem = UseDSTreeT.TreeNode<SingleSelectWithSubmenuItem>;
+    type MenuNodeGroupItem = UseDSTreeT.TreeNode<GroupItem>;
+    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<{
-        item: Item;
-        isSelected: boolean;
+        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;
+    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 {
+    }
+    interface ButtonInheritedRequiredProps extends Omit<DSButtonV3T.RequiredProps, keyof MenuSpecificRequiredProps> {
+    }
+    interface RequiredProps extends MenuSpecificRequiredProps, ButtonInheritedRequiredProps, MenuBehaviouralLayerRequiredProps {
+        options: MenuItemInterface[] | MenuNode;
+    }
+    interface MenuBehaviouralLayerDefaultProps {
+    }
+    interface MenuSpecifiDefaultProps {
+        onClickOutside: (e: MouseEvent | React.KeyboardEvent | TouchEvent) => void;
+        onOptionClick: (nextSelectedOptions: Record<string, boolean>, clickedOption: MenuItemInterface, e: React.MouseEvent | React.KeyboardEvent) => void;
+        openedSubmenus: Record<string, boolean>;
+        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 {
+        onOpen?: () => void;
+        onClose?: () => void;
+        onDisplayedSubmenuChange?: (newOpenedItems: DSMenuButtonT.WithSubmenuMenuNodes[], metainfo: {
+            itemNode: DSMenuButtonT.PseudoFocusableMenuNodes | null;
+            event?: React.SyntheticEvent | FocusEvent | TouchEvent;
+        }) => void | TypescriptHelpersT.StateSetter<DSMenuButtonT.WithSubmenuMenuNodes[]>;
+    }
+    interface MenuSpecificOptionalProps {
+        ItemRenderer?: ItemRendererT;
+    }
+    interface ButtonInheritedOptionalProps extends Omit<DSButtonV3T.OptionalProps, keyof MenuSpecificOptionalProps> {
+    }
+    interface OptionalProps extends MenuSpecificOptionalProps, ButtonInheritedOptionalProps, MenuBehaviouralLayerOptionalProps, TypescriptHelpersT.PropsForGlobalOnSlots<typeof DSMenuButtonName, typeof MENU_BUTTON_SLOTS> {
+    }
+    interface MenuBehaviouralLayerProps extends Partial<MenuBehaviouralLayerDefaultProps>, MenuBehaviouralLayerOptionalProps, MenuBehaviouralLayerRequiredProps {
+    }
+    interface MenuSpecificProps extends Partial<MenuSpecifiDefaultProps>, MenuSpecificOptionalProps, MenuSpecificRequiredProps {
+    }
+    interface ButtonInheritedProps extends Omit<DSButtonV3T.Props, keyof MenuSpecificProps> {
+    }
+    interface Props extends RequiredProps, Partial<DefaultProps>, OptionalProps {
+    }
+    interface MenuBehaviouralLayerInternalProps extends MenuBehaviouralLayerDefaultProps, MenuBehaviouralLayerOptionalProps, MenuBehaviouralLayerRequiredProps {
+    }
+    interface MenuSpecificInternalProps extends MenuSpecifiDefaultProps, MenuSpecificOptionalProps, MenuSpecificRequiredProps {
+    }
+    interface ButtonInheritedInternalProps extends Omit<DSButtonV3T.InternalProps, keyof MenuSpecificInternalProps> {
+    }
+    interface InternalProps extends RequiredProps, DefaultProps, OptionalProps {
+    }
 }
-export declare const defaultProps: MenuButtonT.DefaultProps;
-export declare const DSDMenuButtonPropTypes: DSPropTypesSchema<MenuButtonT.Props<object>>;
-export declare const DSDMenuButtonPropTypesSchema: WeakValidationMap<MenuButtonT.Props<object>>;
+export declare const defaultProps: DSMenuButtonT.MenuSpecifiDefaultProps;
+export declare const MenuBehaviouralLayerPropTypes: DSPropTypesSchema<DSMenuButtonT.MenuBehaviouralLayerProps>;
+export declare const DSMenuSpecificPropTypes: DSPropTypesSchema<DSMenuButtonT.MenuSpecificProps>;
+export declare const DSMenuButtonPropTypes: DSPropTypesSchema<DSMenuButtonT.Props>;
+export declare const DSMenuButtonPropTypesSchema: ValidationMap<DSMenuButtonT.Props>;

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

@@ -0,0 +1,22 @@
+import { type DSMenuButtonT } from '../react-desc-prop-types.js';
+export declare const isActivableNode: (item: unknown) => item is DSMenuButtonT.MenuNodeActivableItem;
+export declare const isActivableWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.MenuNodeActivableWithSubmenuItem;
+export declare const isSkeletonNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSkeletonItem;
+export declare const isMultipleSelectOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeMultipleSelectItem;
+export declare const isMultipleSelectWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;
+export declare const isMultipleSelectNode: (item: unknown) => item is DSMenuButtonT.MultipleSelectionableMenuNodes;
+export declare const isSingleSelectOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSingleSelectItem;
+export declare const isSingleSelectNodeWithSubmenu: (item: unknown) => item is DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
+export declare const isSingleSelectNode: (item: unknown) => item is DSMenuButtonT.SingleSelectionableMenuNodes;
+export declare const isSelectionableNode: (item: unknown) => item is DSMenuButtonT.SelectionableMenuNodes;
+export declare const getSelectionableNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.SelectionableMenuNodes[];
+export declare const isWithSubmenuOnlyNode: (item: unknown) => item is DSMenuButtonT.MenuNodeWithSubmenuItem;
+export declare const isSelectionableWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.SelectionablesWithSubmenuMenuNodes;
+export declare const isWithSubmenuNode: (item: unknown) => item is DSMenuButtonT.WithSubmenuMenuNodes;
+export declare const getWithSubmenuNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.PseudoFocusableMenuNodes[];
+export declare const isFocusableNode: (item: unknown) => item is DSMenuButtonT.PseudoFocusableMenuNodes;
+export declare const getFocusableNodes: (tree: DSMenuButtonT.MenuNode) => DSMenuButtonT.PseudoFocusableMenuNodes[];
+export declare const isSeparatorNode: (item: unknown) => item is DSMenuButtonT.MenuNodeSeparatorItem;
+export declare const isGroup: (item: unknown) => item is DSMenuButtonT.MenuNodeGroupItem;
+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

@@ -0,0 +1,8 @@
+import type { UseDSTreeT } from '@elliemae/ds-tree-model';
+import { type DSMenuButtonT } from '../react-desc-prop-types.js';
+type UseOptionsArrayToDsTreeRootNodeConfig = {
+    options: DSMenuButtonT.MenuItemInterface[];
+    instanceUid: string;
+};
+export declare const useOptionsArrayToDsTree: ({ options, instanceUid }: UseOptionsArrayToDsTreeRootNodeConfig) => UseDSTreeT.OutputT<DSMenuButtonT.MenuItemInterface>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elliemae/ds-menu-button",
-  "version": "3.45.0-rc.1",
+  "version": "3.45.0-rc.3",
   "license": "MIT",
   "description": "ICE MT - Dimsum - Menu Button",
   "files": [
@@ -37,32 +37,34 @@
   },
   "dependencies": {
     "@xstyled/styled-components": "~3.6.0",
-    "uid": "^2.0.2",
-    "@elliemae/ds-button-v2": "3.45.0-rc.1",
-    "@elliemae/ds-icons": "3.45.0-rc.1",
-    "@elliemae/ds-grid": "3.45.0-rc.1",
-    "@elliemae/ds-system": "3.45.0-rc.1",
-    "@elliemae/ds-typescript-helpers": "3.45.0-rc.1",
-    "@elliemae/ds-hooks-keyboard-navigation": "3.45.0-rc.1",
-    "@elliemae/ds-props-helpers": "3.45.0-rc.1",
-    "@elliemae/ds-typography": "3.45.0-rc.1"
+    "@elliemae/ds-button-v2": "3.45.0-rc.3",
+    "@elliemae/ds-floating-context": "3.45.0-rc.3",
+    "@elliemae/ds-grid": "3.45.0-rc.3",
+    "@elliemae/ds-hooks-on-blur-out": "3.45.0-rc.3",
+    "@elliemae/ds-icons": "3.45.0-rc.3",
+    "@elliemae/ds-menu-items-commons": "3.45.0-rc.3",
+    "@elliemae/ds-props-helpers": "3.45.0-rc.3",
+    "@elliemae/ds-system": "3.45.0-rc.3",
+    "@elliemae/ds-tree-model": "3.45.0-rc.3"
   },
   "devDependencies": {
     "@elliemae/pui-cli": "9.0.0-next.50",
-    "@xstyled/system": "3.7.0",
-    "lodash": "^4.17.21",
     "styled-components": "~5.3.9",
-    "@elliemae/ds-monorepo-devops": "3.45.0-rc.1"
+    "@elliemae/ds-dropdownmenu-v2": "3.45.0-rc.3",
+    "@elliemae/ds-monorepo-devops": "3.45.0-rc.3",
+    "@elliemae/ds-typescript-helpers": "3.45.0-rc.3"
   },
   "peerDependencies": {
-    "lodash": "^4.17.21",
+    "@testing-library/jest-dom": "~5.16.4",
+    "@testing-library/react": "~12.1.3",
+    "@testing-library/user-event": "~13.5.0",
     "react": "^17.0.2",
     "react-dom": "^17.0.2",
     "styled-components": "~5.3.9"
   },
   "publishConfig": {
     "access": "public",
-    "typeSafety": false
+    "typeSafety": true
   },
   "scripts": {
     "dev": "cross-env NODE_ENV=development node ../../../scripts/build/build.mjs --watch",
@@ -71,6 +73,6 @@
     "lint:strict": "node ../../../scripts/lint-strict.mjs",
     "dts": "node ../../../scripts/dts.mjs",
     "build": "cross-env NODE_ENV=production node ../../../scripts/build/build.mjs",
-    "checkDeps": "npm exec ../../util/ds-codemods -- check-missing-packages --projectFolderPath=\"./\" --ignorePackagesGlobPattern=\"\" --ignoreFilesGlobPattern=\"**/test-ables/*,**/tests/*\""
+    "checkDeps": "npx -yes ../../util/ds-codemods check-missing-packages --projectFolderPath=\"./\" --ignorePackagesGlobPattern=\"\" --ignoreFilesGlobPattern=\"**/test-ables/*,**/tests/*\""
   }
 }

package/dist/cjs/DSMenuButtonCTX.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/DSMenuButtonCTX.ts", "../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["import React from 'react';\nimport type { MenuButtonT } from './react-desc-prop-types.js';\ninterface MenuButtonContextProps<T extends object = object> {\n  focusedOption: string | null;\n  setFocusedOption: React.Dispatch<React.SetStateAction<string | null>>;\n  selectedKeys: string[];\n  onSelectionChange: (selectedKeys: string[], parentId: string, item: MenuButtonT.Item) => void;\n  triggerElementRef: HTMLElement | null;\n  setTriggerElementRef: React.Dispatch<React.SetStateAction<HTMLElement | null>>;\n  isOpen: boolean;\n  setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;\n  propsWithDefault: MenuButtonT.InternalProps<T>;\n}\n\nconst defaultContext = {} as MenuButtonContextProps<object>;\n\nexport const MenuButtonContext = React.createContext(defaultContext);\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkB;AAclB,MAAM,iBAAiB,CAAC;AAEjB,MAAM,oBAAoB,aAAAA,QAAM,cAAc,cAAc;",
-  "names": ["React"]
-}

package/dist/cjs/parts/ItemFactory.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/parts/ItemFactory.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable import/no-cycle */\n/* eslint-disable arrow-body-style */\nimport React from 'react';\nimport { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';\nimport { MenuItem, Section, Separator } from './MenuItem.js';\n\nimport type { MenuButtonT } from '../react-desc-prop-types.js';\ninterface ItemFactoryProps {\n  item: MenuButtonT.Item;\n  level: number;\n  selectionMode?: 'single' | 'multiple';\n  parentId?: string;\n  tabIndex: TypescriptHelpersT.WCAGTabIndex;\n  onFocus: React.FocusEventHandler;\n  innerRef: TypescriptHelpersT.AnyRef<HTMLElement>;\n}\n\nexport const ItemFactory: React.FC<ItemFactoryProps> = ({\n  item,\n  innerRef,\n  onFocus,\n  tabIndex,\n  level,\n  selectionMode,\n  parentId,\n}) => {\n  if (item.type === 'separator') {\n    return <Separator />;\n  }\n  if (item.type === 'section') {\n    return <Section item={item} />;\n  }\n  return (\n    <MenuItem\n      key={item.dsId}\n      item={item}\n      innerRef={innerRef}\n      onFocus={onFocus}\n      tabIndex={tabIndex}\n      level={level}\n      parentId={parentId}\n      selectionMode={selectionMode || item.type}\n    />\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;AD2BZ;AAvBX,sBAA6C;AAatC,MAAM,cAA0C,CAAC;AAAA,EACtD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,MAAI,KAAK,SAAS,aAAa;AAC7B,WAAO,4CAAC,6BAAU;AAAA,EACpB;AACA,MAAI,KAAK,SAAS,WAAW;AAC3B,WAAO,4CAAC,2BAAQ,MAAY;AAAA,EAC9B;AACA,SACE;AAAA,IAAC;AAAA;AAAA,MAEC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,eAAe,iBAAiB,KAAK;AAAA;AAAA,IAPhC,KAAK;AAAA,EAQZ;AAEJ;",
-  "names": []
-}

package/dist/cjs/parts/Menu.js

@@ -1,125 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Menu_exports = {};
-__export(Menu_exports, {
-  Menu: () => Menu
-});
-module.exports = __toCommonJS(Menu_exports);
-var React = __toESM(require("react"));
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_react = __toESM(require("react"));
-var import_ds_hooks_keyboard_navigation = require("@elliemae/ds-hooks-keyboard-navigation");
-var import_DSMenuButtonCTX = require("../DSMenuButtonCTX.js");
-var import_styled = require("../styled.js");
-var import_ItemFactory = require("./ItemFactory.js");
-const Menu = (props) => {
-  const { referenceElement, showSubMenu, selectionMode, setShowSubMenu, parentId, level, items, minWidth } = props;
-  const { focusedOption, setFocusedOption } = (0, import_react.useContext)(import_DSMenuButtonCTX.MenuButtonContext);
-  const listRef = import_react.default.useRef(null);
-  const rect = referenceElement?.getBoundingClientRect();
-  const [coords, setCoords] = (0, import_react.useState)({ x: rect?.width ?? 0, y: 0 });
-  import_react.default.useLayoutEffect(() => {
-    const listRect = listRef?.current?.getBoundingClientRect();
-    if (!listRect) return;
-    if (level === 1) {
-      if (listRect.bottom < window.innerHeight) {
-        setCoords({ x: 0, y: rect?.height || 0 });
-      } else {
-        setCoords({ x: 0, y: -listRect.height });
-      }
-      return;
-    }
-    if (listRect.right > window.innerWidth) {
-      setCoords({ x: -(minWidth || rect?.width || 0), y: 0 });
-    } else {
-      setCoords({ x: rect?.width || 0, y: 0 });
-    }
-  }, [level, minWidth, rect?.height, rect?.width, referenceElement]);
-  const config = {
-    options: items.filter((item) => item.type !== "separator" && item.type !== "section").map((item) => item.dsId),
-    direction: import_ds_hooks_keyboard_navigation.DIRECTIONS.VERTICAL,
-    focusedOption,
-    setFocusedOption
-  };
-  const { getWrapperProps, getItemProps } = (0, import_ds_hooks_keyboard_navigation.useKeyboardNavigation)(config);
-  const { onKeyDown, onBlur } = getWrapperProps();
-  const handleOnMenuKeyDown = (0, import_react.useCallback)(
-    (event) => {
-      if (event.key === "ArrowDown" || event.key === "ArrowUp") {
-        event.stopPropagation();
-      }
-      onKeyDown(event);
-    },
-    [onKeyDown]
-  );
-  const handleOnBlur = (0, import_react.useCallback)(
-    (e) => {
-      setTimeout(() => {
-        if (!listRef.current?.contains(document.activeElement)) {
-          setShowSubMenu(false);
-        }
-      });
-      onBlur(e);
-    },
-    [onBlur, setShowSubMenu]
-  );
-  const subMenuStyles = (0, import_react.useMemo)(
-    () => ({
-      position: "absolute",
-      top: coords.y,
-      left: coords.x,
-      zIndex: 1001 + level,
-      minWidth
-    }),
-    [coords, level, minWidth]
-  );
-  if (!referenceElement || !showSubMenu) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_styled.StyledMenu,
-    {
-      innerRef: listRef,
-      role: "menu",
-      onKeyDown: handleOnMenuKeyDown,
-      onBlur: handleOnBlur,
-      style: subMenuStyles,
-      children: items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-        import_ItemFactory.ItemFactory,
-        {
-          item,
-          selectionMode,
-          level,
-          parentId,
-          ...getItemProps(item.dsId)
-        },
-        item.dsId
-      ))
-    }
-  );
-};
-//# sourceMappingURL=Menu.js.map

package/dist/cjs/parts/Menu.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/parts/Menu.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
-  "sourcesContent": ["/* eslint-disable import/no-cycle */\nimport React, { useState, useMemo, useCallback, useContext } from 'react';\nimport { useKeyboardNavigation, DIRECTIONS } from '@elliemae/ds-hooks-keyboard-navigation';\nimport { MenuButtonContext } from '../DSMenuButtonCTX.js';\nimport type { MenuButtonT } from '../react-desc-prop-types.js';\nimport { StyledMenu } from '../styled.js';\nimport { ItemFactory } from './ItemFactory.js';\n\ninterface SubMenuProps {\n  referenceElement: HTMLElement | null;\n  showSubMenu: boolean;\n  selectionMode?: 'single' | 'multiple';\n  setShowSubMenu: React.Dispatch<React.SetStateAction<boolean>>;\n  parentId?: string;\n  level: number;\n  items: MenuButtonT.Item[];\n  minWidth?: string | number;\n}\n\nexport const Menu: React.FC<SubMenuProps> = (props) => {\n  const { referenceElement, showSubMenu, selectionMode, setShowSubMenu, parentId, level, items, minWidth } = props;\n  const { focusedOption, setFocusedOption } = useContext(MenuButtonContext);\n  const listRef = React.useRef<HTMLDivElement>(null);\n  const rect = referenceElement?.getBoundingClientRect();\n  const [coords, setCoords] = useState<{ x: number; y: number }>({ x: rect?.width ?? 0, y: 0 });\n\n  // this logic will be part of the new popper custom hook\n  React.useLayoutEffect(() => {\n    const listRect = listRef?.current?.getBoundingClientRect();\n    if (!listRect) return;\n    if (level === 1) {\n      if (listRect.bottom < window.innerHeight) {\n        setCoords({ x: 0, y: rect?.height || 0 });\n      } else {\n        setCoords({ x: 0, y: -listRect.height });\n      }\n      return;\n    }\n    if (listRect.right > window.innerWidth) {\n      setCoords({ x: -(minWidth || rect?.width || 0), y: 0 });\n    } else {\n      setCoords({ x: rect?.width || 0, y: 0 });\n    }\n  }, [level, minWidth, rect?.height, rect?.width, referenceElement]);\n\n  const config = {\n    options: items.filter((item) => item.type !== 'separator' && item.type !== 'section').map((item) => item.dsId),\n    direction: DIRECTIONS.VERTICAL,\n    focusedOption,\n    setFocusedOption,\n  };\n\n  const { getWrapperProps, getItemProps } = useKeyboardNavigation(config);\n\n  const { onKeyDown, onBlur } = getWrapperProps();\n\n  const handleOnMenuKeyDown = useCallback(\n    (event: React.KeyboardEvent) => {\n      if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {\n        event.stopPropagation();\n      }\n      onKeyDown(event);\n    },\n    [onKeyDown],\n  );\n\n  const handleOnBlur: React.FocusEventHandler<HTMLDivElement> = useCallback(\n    (e) => {\n      setTimeout(() => {\n        if (!listRef.current?.contains(document.activeElement)) {\n          setShowSubMenu(false);\n        }\n      });\n      onBlur(e);\n    },\n    [onBlur, setShowSubMenu],\n  );\n\n  const subMenuStyles = useMemo(\n    () => ({\n      position: 'absolute',\n      top: coords.y,\n      left: coords.x,\n      zIndex: 1001 + level,\n      minWidth,\n    }),\n    [coords, level, minWidth],\n  );\n\n  if (!referenceElement || !showSubMenu) return null;\n\n  return (\n    <StyledMenu\n      innerRef={listRef}\n      role=\"menu\"\n      onKeyDown={handleOnMenuKeyDown}\n      onBlur={handleOnBlur}\n      style={subMenuStyles}\n    >\n      {items.map((item) => (\n        <ItemFactory\n          key={item.dsId}\n          item={item}\n          selectionMode={selectionMode}\n          level={level}\n          parentId={parentId}\n          {...getItemProps(item.dsId)}\n        />\n      ))}\n    </StyledMenu>\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
-  "mappings": "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",
-  "names": ["React"]
-}