@elliemae/ds-menu-button 3.45.0-rc.0 → 3.45.0-rc.2

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSMenuBehaviouralContextProviderT } from './react-desc-prop-types.js';
+declare const DSMenuBehaviouralContextProvider: React.ComponentType<DSMenuBehaviouralContextProviderT.Props>;
+declare const DSMenuBehaviouralContextProviderWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<DSMenuBehaviouralContextProviderT.Props>;
+export { DSMenuBehaviouralContextProvider, DSMenuBehaviouralContextProviderWithSchema };

package/dist/types/parts/DSMenuBehaviouralContextProvider/MenuBehaviouralContextProviderCTX.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { MenuBehaviouralContextProviderCTX } from './config/useMenuBehaviouralContextProvider.js';
+/** Context for cross component communication */
+export declare const MenuBehaviouralContextProviderContext: import("react").Context<MenuBehaviouralContextProviderCTX>;
+export default MenuBehaviouralContextProviderContext;

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';
+export declare const useFocusTracker: () => {
+    preventBlurReset: React.MutableRefObject<boolean>;
+    focusRegion: "" | "trigger" | `item-dsid-${string}` | `item-dsid-${number}`;
+    focusedElementItemNode: React.MutableRefObject<DSMenuButtonT.PseudoFocusableMenuNodes | null>;
+    trackFocusTrigger: () => 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;
+    trackFocusParentItem: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => DSMenuButtonT.PseudoFocusableMenuNodes | null;
+};

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

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';
+import type { useMenuOpenStatus } from './useMenuOpenStatus.js';
+import type { DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+type UseGlobalEventsConfig = {
+    menuOpenStatus: ReturnType<typeof useMenuOpenStatus>;
+    handleChangeOpenedSubItems: Required<DSMenuButtonT.MenuBehaviouralLayerOptionalProps>['onDisplayedSubmenuChange'];
+    propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;
+};
+export declare const useGlobalEvents: ({ menuOpenStatus, handleChangeOpenedSubItems, propsWithDefault, }: UseGlobalEventsConfig) => {
+    mainMenuRef: React.MutableRefObject<HTMLDivElement | null>;
+    submenusRefs: React.MutableRefObject<Record<string | number, HTMLElement>>;
+    handleSubmenusRefChange: (htmlNode: HTMLElement | null, dsId: DSMenuButtonT.WithSubmenuMenuNodes['dsId']) => void;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';
+import { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+import { useFocusTracker } from './useFocusTracker.js';
+import { useMenuItemEventsHandlers } from './useMenuItemEventsHandlers.js';
+import { useMenuOpenStatus } from './useMenuOpenStatus.js';
+import { useGlobalEvents } from './useGlobalEvents.js';
+export interface MenuBehaviouralContextProviderCTX extends ReturnType<typeof useFocusTracker>, ReturnType<typeof useMenuOpenStatus> {
+    propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;
+    instanceUid: string;
+    menuItemEventsHandlers: ReturnType<typeof useMenuItemEventsHandlers>;
+    openedSubItems: DSMenuButtonT.WithSubmenuMenuNodes[];
+    handleChangeOpenedSubItems: Required<DSMenuButtonT.MenuBehaviouralLayerOptionalProps>['onDisplayedSubmenuChange'];
+    globalEventsHelpers: ReturnType<typeof useGlobalEvents>;
+}
+export declare const useMenuBehaviouralContextProvider: (propsFromUser: DSMenuBehaviouralContextProviderT.Props) => MenuBehaviouralContextProviderCTX;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import { type DSMenuButtonT } from '../../../react-desc-prop-types.js';
+import { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+import type { useFocusTracker } from './useFocusTracker.js';
+import type { useMenuOpenStatus } from './useMenuOpenStatus.js';
+type UseMenuItemEventsHandlersConfig = {
+    propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;
+    focusTrackers: ReturnType<typeof useFocusTracker>;
+    menuOpenStatus: ReturnType<typeof useMenuOpenStatus>;
+    handleChangeOpenedSubItems: Required<DSMenuButtonT.MenuBehaviouralLayerOptionalProps>['onDisplayedSubmenuChange'];
+};
+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;
+    handleMenuItemFocusReconciliation: (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => void;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+import type { useFocusTracker } from './useFocusTracker.js';
+type UseMenuOpenStatusConfig = {
+    propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;
+    focusTrackers: ReturnType<typeof useFocusTracker>;
+};
+type OnOpinionatedOpenConfig = {
+    focusLastChild?: boolean;
+};
+export declare const useMenuOpenStatus: ({ propsWithDefault, focusTrackers }: UseMenuOpenStatusConfig) => {
+    isMenuOpen: boolean;
+    onOpinionatedClose: ({ skipFocus }?: {
+        skipFocus: boolean;
+    }) => void;
+    onOpinionatedOpen: (config?: OnOpinionatedOpenConfig) => void;
+};
+export {};

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

@@ -0,0 +1,3 @@
+import type { ValidationMap } from '@elliemae/ds-props-helpers';
+import { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSMenuBehaviouralContextProviderT.InternalProps, propTypes: ValidationMap<DSMenuBehaviouralContextProviderT.Props>) => void;

package/dist/types/parts/DSMenuBehaviouralContextProvider/constants/Errors.d.ts

@@ -0,0 +1,15 @@
+export declare const TREE_STRUCTURE_ERRORS: {
+    PARENT_NOT_GROUP: Error;
+    GROUP_WITHOUT_PARENT: Error;
+    NODE_CANNOT_HAVE_CHILDREN: Error;
+};
+export declare const FORBIDDEN_BEHAVIOURS: {
+    TRYING_TO_FOCUS_NON_FOCUSABLE_NODE: Error;
+    TRYING_TO_OPEN_SUBMENU_OF_NODE_WITHOUT_SUBMENU: Error;
+};
+export declare const UNEXPECTED_INTERNAL_ERRORS: {
+    FOCUSED_ITEM_NODE_NOT_SET: Error;
+    FOCUSED_ITEM_HAS_NO_PARENT: Error;
+    NODE_WITHOUT_PARENT: Error;
+    CALCULATING_MULTI_SELECTION_OF_NON_MULTI_SELECTION_NODE: Error;
+};

package/dist/types/parts/DSMenuBehaviouralContextProvider/constants/index.d.ts

@@ -0,0 +1,7 @@
+import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';
+export declare const DSMenuBehaviouralContextProviderName = "DSMenuBehaviouralContextProvider";
+export declare const MENU_FOCUS_REGIONS: {
+    readonly TRIGGER: "trigger";
+    readonly ITEM_BY_DSID: (dsId: DSMenuButtonT.MenuNode['dsId']) => `item-dsid-${string}` | `item-dsid-${number}`;
+    readonly RESET: "";
+};

package/dist/types/parts/DSMenuBehaviouralContextProvider/index.d.ts

@@ -0,0 +1 @@
+export { DSMenuBehaviouralContextProvider, DSMenuBehaviouralContextProviderWithSchema, } from './DSMenuBehaviouralContextProvider.js';

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
+import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
+import { type DSMenuButtonT } from '../../react-desc-prop-types.js';
+export declare namespace DSMenuBehaviouralContextProviderT {
+    interface RequiredProps extends DSMenuButtonT.MenuBehaviouralLayerRequiredProps {
+        buttonDOMNode: HTMLElement | null;
+        buttonDOMNodeRef: React.MutableRefObject<HTMLElement | null>;
+        optionsTree: DSMenuButtonT.MenuNode;
+        children: TypescriptHelpersT.ReactChildrenComplete;
+        focusableNodes: DSMenuButtonT.PseudoFocusableMenuNodes[];
+    }
+    interface DefaultProps extends DSMenuButtonT.MenuBehaviouralLayerDefaultProps {
+    }
+    interface OptionalProps extends DSMenuButtonT.MenuBehaviouralLayerOptionalProps {
+    }
+    interface Props extends Partial<DefaultProps>, OptionalProps, RequiredProps {
+    }
+    interface InternalProps extends DefaultProps, OptionalProps, RequiredProps {
+    }
+}
+export declare const defaultProps: DSMenuBehaviouralContextProviderT.DefaultProps;
+export declare const DSMenuBehaviouralContextProviderPropTypes: DSPropTypesSchema<DSMenuBehaviouralContextProviderT.Props>;
+export declare const DSMenuBehaviouralContextProviderPropTypesSchema: ValidationMap<DSMenuBehaviouralContextProviderT.Props>;

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

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

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

@@ -0,0 +1,35 @@
+import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';
+export declare const getSubMenusPath: (itemNode: DSMenuButtonT.MenuNode) => DSMenuButtonT.WithSubmenuMenuNodes[];
+export declare const getFocusableSiblingsList: (itemNode: DSMenuButtonT.MenuNode) => DSMenuButtonT.PseudoFocusableMenuNodes[];
+/**
+ * This functions walks the tree downwards starting from the oldest shared parent and returns all the single-selectable items ids
+ * @param oldestParent - the oldest parent to start the walk from
+ * @returns string | number[] - the list of all the single-selectable items ids starting from the oldest shared group
+ */
+export declare const getAllSingleSelectIdsFromParent: (oldestParent: DSMenuButtonT.MenuNodesAllowedToHaveChildren) => (string | number)[];
+/**
+ * walk all parents from a given node and gives back multiple supporting datastructures by different criterias
+ *
+ * @param menuNode
+ * @returns {object} - an object holding different datastructures and information about the parents
+ * @property {Object} oldestGroup - the oldest shared group
+ * @property {Object[]} selectionableParentsWithSubmenu - the single/multiple selection parents with submenu
+ * @property {Object[]} groupParents - all the 'groups' encountered while traversing the tree upwards
+ */
+export declare const getParentsByCriterias: (menuNode: DSMenuButtonT.MenuNode) => {
+    oldestGroup: DSMenuButtonT.MenuNodeGroupItem;
+    selectionableParentsWithSubmenu: DSMenuButtonT.SelectionablesWithSubmenuMenuNodes[];
+    groupParents: DSMenuButtonT.MenuNodeGroupItem[];
+};
+/**
+ * walk all childrens from a given node and gives back multiple supporting datastructures by different criterias
+ *
+ * @param menuNode
+ * @returns {object} - an object holding different datastructures and information about the children
+ * @property {Object[]} selectionableChilrens - the single/multiple selection children (regardless of the presence of a submenu)
+ * @property {Object[]} multiSelectionableChilrens - the multiple selection children (regardless of the presence of a submenu)
+ */
+export declare const getChildrenByCriterias: (menuNode: DSMenuButtonT.MenuNode) => {
+    selectionableChilrens: DSMenuButtonT.SelectionableMenuNodes[];
+    multiSelectionableChilrens: DSMenuButtonT.MultipleSelectionableMenuNodes[];
+};

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

@@ -0,0 +1,13 @@
+import { type DSMenuButtonT } from '../../../react-desc-prop-types.js';
+/**
+ * When a single-selectable item is selected, all other single-selectable items in the same group are deselected;
+ *
+ * If the (visual) parent is a single-select-with-submenu,
+ *  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 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[];

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

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
+import { type DSMenuItemRendererFactoryT } from './react-desc-prop-types.js';
+export declare const ActivableWithSubmenuMenuItem: React.ComponentType<{
+    itemNode: DSMenuButtonT.MenuNodeActivableWithSubmenuItem;
+    FlyoutMenuCircularDepInject: DSMenuItemRendererFactoryT.RequiredProps['FlyoutMenuCircularDepInject'];
+}>;

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSMenuItemRendererFactoryT } from './react-desc-prop-types.js';
+declare const DSMenuItemRendererFactory: React.ComponentType<DSMenuItemRendererFactoryT.Props>;
+declare const DSMenuItemRendererFactoryWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<DSMenuItemRendererFactoryT.Props>;
+export { DSMenuItemRendererFactory, DSMenuItemRendererFactoryWithSchema };

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

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
+import { type DSMenuItemRendererFactoryT } from './react-desc-prop-types.js';
+export declare const MultipleSelectWithSubmenuMenuItem: React.ComponentType<{
+    itemNode: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;
+    FlyoutMenuCircularDepInject: DSMenuItemRendererFactoryT.RequiredProps['FlyoutMenuCircularDepInject'];
+}>;

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

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

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
+import { type DSMenuItemRendererFactoryT } from './react-desc-prop-types.js';
+export declare const SingleSelectWithSubmenuMenuItem: React.ComponentType<{
+    itemNode: DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem;
+    FlyoutMenuCircularDepInject: DSMenuItemRendererFactoryT.RequiredProps['FlyoutMenuCircularDepInject'];
+}>;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { DSMenuButtonT } from '../../react-desc-prop-types.js';
+import { type DSMenuItemRendererFactoryT } from './react-desc-prop-types.js';
+export declare const WithSubmenuMenuItem: React.ComponentType<{
+    itemNode: DSMenuButtonT.MenuNodeWithSubmenuItem;
+    FlyoutMenuCircularDepInject: DSMenuItemRendererFactoryT.RequiredProps['FlyoutMenuCircularDepInject'];
+}>;

package/dist/types/parts/DSMenuItemRendererFactory/config/useMenuItemRendererFactory.d.ts

@@ -0,0 +1,6 @@
+import { type DSMenuItemRendererFactoryT } from '../react-desc-prop-types.js';
+export declare const useMenuItemRendererFactory: (propsFromUser: DSMenuItemRendererFactoryT.Props) => {
+    propsWithDefault: DSMenuItemRendererFactoryT.InternalProps;
+    xstyledProps: import("@elliemae/ds-props-helpers").XstyledProps;
+    instanceUid: string;
+};

package/dist/types/parts/DSMenuItemRendererFactory/config/useValidateProps.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationMap } from '@elliemae/ds-props-helpers';
+import { type DSMenuItemRendererFactoryT } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSMenuItemRendererFactoryT.InternalProps, propTypes: ValidationMap<DSMenuItemRendererFactoryT.Props>) => void;

package/dist/types/parts/DSMenuItemRendererFactory/constants/index.d.ts

@@ -0,0 +1,6 @@
+export declare const DSMenuItemRendererFactoryName = "DSMenuItemRendererFactory";
+export declare const EXAMPLE_CONSTANTS: {};
+export declare const MENU_ITEM_RENDERER_FACTORY_SLOTS: {
+    readonly ROOT: "root";
+};
+export declare const MENU_ITEM_RENDERER_FACTORY_DATA_TESTID: Record<string, string>;

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

@@ -0,0 +1 @@
+export { DSMenuItemRendererFactory, DSMenuItemRendererFactoryWithSchema } from './DSMenuItemRendererFactory.js';

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

@@ -0,0 +1,24 @@
+/// <reference types="react" />
+import type { GlobalAttributesT, XstyledProps, DSPropTypesSchema, ValidationMap } 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';
+export declare namespace DSMenuItemRendererFactoryT {
+    interface RequiredProps {
+        itemNode: DSMenuButtonT.MenuNode;
+        FlyoutMenuCircularDepInject: React.ComponentType<DSFlyoutMenuT.Props>;
+    }
+    interface DefaultProps {
+    }
+    interface OptionalProps extends TypescriptHelpersT.PropsForGlobalOnSlots<typeof DSMenuItemRendererFactoryName, typeof MENU_ITEM_RENDERER_FACTORY_SLOTS> {
+        ItemRenderer?: DSMenuButtonT.ItemRendererT;
+    }
+    interface Props extends Partial<DefaultProps>, OptionalProps, Omit<GlobalAttributesT<HTMLLIElement>, keyof OptionalProps | keyof XstyledProps>, XstyledProps, RequiredProps {
+    }
+    interface InternalProps extends DefaultProps, OptionalProps, Omit<GlobalAttributesT<HTMLLIElement>, keyof OptionalProps | keyof XstyledProps>, XstyledProps, RequiredProps {
+    }
+}
+export declare const defaultProps: DSMenuItemRendererFactoryT.DefaultProps;
+export declare const DSMenuItemRendererFactoryPropTypes: DSPropTypesSchema<DSMenuItemRendererFactoryT.Props>;
+export declare const DSMenuItemRendererFactoryPropTypesSchema: ValidationMap<DSMenuItemRendererFactoryT.Props>;

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

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const useMenuItemHighlightState: ({ focusableItemEl, onMouseLeave, onMouseEnter, }: {
+    focusableItemEl: HTMLElement | null;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement>;
+}) => {
+    isFocused: boolean;
+    isHovered: boolean;
+    handleMouseEnter: (e: React.MouseEvent<HTMLElement>) => void;
+    handleMouseLeave: (e: React.MouseEvent<HTMLElement>) => void;
+    shouldHighlight: boolean;
+};

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type DSOpinionatedButtonT } from './react-desc-prop-types.js';
+declare const DSOpinionatedButton: React.ComponentType<DSOpinionatedButtonT.Props>;
+declare const DSOpinionatedButtonWithSchema: import("@elliemae/ds-props-helpers/dist/types/propTypes/types.js").DocumentedReactComponent<DSOpinionatedButtonT.Props>;
+export { DSOpinionatedButton, DSOpinionatedButtonWithSchema };

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

@@ -0,0 +1,38 @@
+import React from 'react';
+import { type DSOpinionatedButtonT } from '../react-desc-prop-types.js';
+export declare const useOpinionatedButton: (propsFromUser: DSOpinionatedButtonT.Props) => {
+    propsWithDefault: DSOpinionatedButtonT.InternalProps;
+    instanceUid: string;
+    eventsHandlers: {
+        handleTriggerKeyDown: React.KeyboardEventHandler<HTMLButtonElement>;
+        handleOnClick: (e: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+        handleOnFocus: React.FocusEventHandler<HTMLButtonElement>;
+        handleFocusIfTriggerIsFocusRegion: (instance: HTMLButtonElement | null) => void;
+    };
+    floatingContext: {
+        refs: {
+            setReference: (node: HTMLElement | null) => void;
+            setFloating: React.Dispatch<React.SetStateAction<HTMLElement | null>>;
+        };
+        floatingStyles: import("styled-components").CSSProperties;
+        handlers: {
+            onMouseEnter: () => void;
+            onMouseLeave: () => void;
+            onFocus: () => void;
+            onBlur: () => void;
+        };
+        isOpen: boolean;
+        arrowStyles: {
+            style: import("styled-components").CSSProperties;
+            placement: string;
+        };
+        hideTooltip: () => void;
+        showTooltip: () => void;
+        context: {
+            withoutPortal: boolean;
+            withoutAnimation: boolean;
+            portalDOMContainer: HTMLElement;
+            animationDuration: number;
+        };
+    };
+};

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

@@ -0,0 +1,14 @@
+import { type useFloatingContext } from '@elliemae/ds-floating-context';
+import React from 'react';
+import { type DSOpinionatedButtonT } from '../react-desc-prop-types.js';
+type UseTriggerEventsHandlersConfig = {
+    propsWithDefault: DSOpinionatedButtonT.InternalProps;
+    floatingContext: ReturnType<typeof useFloatingContext>;
+};
+export declare const useTriggerEventsHandlers: ({ propsWithDefault, floatingContext }: UseTriggerEventsHandlersConfig) => {
+    handleTriggerKeyDown: React.KeyboardEventHandler<HTMLButtonElement>;
+    handleOnClick: (e: React.KeyboardEvent<HTMLButtonElement> | React.MouseEvent<HTMLButtonElement, MouseEvent>) => void;
+    handleOnFocus: React.FocusEventHandler<HTMLButtonElement>;
+    handleFocusIfTriggerIsFocusRegion: (instance: HTMLButtonElement | null) => void;
+};
+export {};

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

@@ -0,0 +1,3 @@
+import type { ValidationMap } from '@elliemae/ds-props-helpers';
+import { type DSOpinionatedButtonT } from '../react-desc-prop-types.js';
+export declare const useValidateProps: (props: DSOpinionatedButtonT.InternalProps, propTypes: ValidationMap<DSOpinionatedButtonT.Props>) => void;

package/dist/types/parts/DSOpinionatedButton/constants/index.d.ts

@@ -0,0 +1,6 @@
+export declare const DSOpinionatedButtonName = "DSOpinionatedButton";
+export declare const EXAMPLE_CONSTANTS: {};
+export declare const OPINIONATED_BUTTON_SLOTS: {
+    readonly ROOT: "root";
+};
+export declare const OPINIONATED_BUTTON_DATA_TESTID: Record<string, string>;

package/dist/types/parts/DSOpinionatedButton/index.d.ts

@@ -0,0 +1 @@
+export { DSOpinionatedButton, DSOpinionatedButtonWithSchema } from './DSOpinionatedButton.js';

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

@@ -0,0 +1,23 @@
+import React from 'react';
+import type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';
+import { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';
+import { type DSMenuButtonT } from '../../react-desc-prop-types.js';
+import { DSOpinionatedButtonName, OPINIONATED_BUTTON_SLOTS } from './constants/index.js';
+export declare namespace DSOpinionatedButtonT {
+    interface RequiredProps extends DSMenuButtonT.ButtonInheritedRequiredProps {
+        menuSpecificProps: DSMenuButtonT.MenuSpecificProps;
+    }
+    interface DefaultProps extends DSMenuButtonT.ButtonInheiredDefaultProps {
+    }
+    interface OptionalProps extends TypescriptHelpersT.PropsForGlobalOnSlots<typeof DSOpinionatedButtonName, typeof OPINIONATED_BUTTON_SLOTS>, DSMenuButtonT.ButtonInheritedOptionalProps {
+    }
+    interface Props extends RequiredProps, Partial<DefaultProps>, OptionalProps, DSMenuButtonT.ButtonInheritedProps {
+        innerRef: React.RefCallback<HTMLButtonElement>;
+    }
+    interface InternalProps extends RequiredProps, DefaultProps, OptionalProps, DSMenuButtonT.ButtonInheritedInternalProps {
+        innerRef: React.RefCallback<HTMLButtonElement>;
+    }
+}
+export declare const defaultProps: DSOpinionatedButtonT.DefaultProps;
+export declare const DSOpinionatedButtonPropTypes: DSPropTypesSchema<DSOpinionatedButtonT.Props>;
+export declare const DSOpinionatedButtonPropTypesSchema: ValidationMap<DSOpinionatedButtonT.Props>;