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

package/dist/cjs/parts/{ItemFactory.js → DSFlyoutMenu/config/useValidateProps.js}

@@ -26,41 +26,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ItemFactory_exports = {};
-__export(ItemFactory_exports, {
-  ItemFactory: () => ItemFactory
+var useValidateProps_exports = {};
+__export(useValidateProps_exports, {
+  useValidateProps: () => useValidateProps
 });
-module.exports = __toCommonJS(ItemFactory_exports);
+module.exports = __toCommonJS(useValidateProps_exports);
 var React = __toESM(require("react"));
-var import_jsx_runtime = require("react/jsx-runtime");
-var import_MenuItem = require("./MenuItem.js");
-const ItemFactory = ({
-  item,
-  innerRef,
-  onFocus,
-  tabIndex,
-  level,
-  selectionMode,
-  parentId
-}) => {
-  if (item.type === "separator") {
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_MenuItem.Separator, {});
-  }
-  if (item.type === "section") {
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_MenuItem.Section, { item });
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_MenuItem.MenuItem,
-    {
-      item,
-      innerRef,
-      onFocus,
-      tabIndex,
-      level,
-      parentId,
-      selectionMode: selectionMode || item.type
-    },
-    item.dsId
-  );
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_constants = require("../constants/index.js");
+const useValidateProps = (props, propTypes) => {
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(props, propTypes, import_constants.DSFlyoutMenuName);
 };
-//# sourceMappingURL=ItemFactory.js.map
+//# sourceMappingURL=useValidateProps.js.map

package/dist/cjs/parts/DSFlyoutMenu/config/useValidateProps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSFlyoutMenu/config/useValidateProps.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useValidateTypescriptPropTypes } from '@elliemae/ds-props-helpers';\nimport type { ValidationMap } from '@elliemae/ds-props-helpers';\nimport { type DSFlyoutMenuT } from '../react-desc-prop-types.js';\nimport { DSFlyoutMenuName } from '../constants/index.js';\n\nexport const useValidateProps = (\n  props: DSFlyoutMenuT.InternalProps,\n  propTypes: ValidationMap<DSFlyoutMenuT.Props>,\n): void => {\n  // we validate the \"required if\" via 'isRequiredIf from our custom PropTypes\n  useValidateTypescriptPropTypes(props, propTypes, DSFlyoutMenuName);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAA+C;AAG/C,uBAAiC;AAE1B,MAAM,mBAAmB,CAC9B,OACA,cACS;AAET,8DAA+B,OAAO,WAAW,iCAAgB;AACnE;",
+  "names": []
+}

package/dist/cjs/parts/DSFlyoutMenu/constants/index.js

@@ -0,0 +1,46 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  DSFlyoutMenuName: () => DSFlyoutMenuName,
+  EXAMPLE_CONSTANTS: () => EXAMPLE_CONSTANTS,
+  FLYOUT_MENU_DATA_TESTID: () => FLYOUT_MENU_DATA_TESTID,
+  FLYOUT_MENU_SLOTS: () => FLYOUT_MENU_SLOTS
+});
+module.exports = __toCommonJS(constants_exports);
+var React = __toESM(require("react"));
+var import_ds_system = require("@elliemae/ds-system");
+const DSFlyoutMenuName = "DSFlyoutMenu";
+const EXAMPLE_CONSTANTS = {};
+const FLYOUT_MENU_SLOTS = {
+  ROOT: "root",
+  LIST_WRAPPER: "list-wrapper"
+};
+const FLYOUT_MENU_DATA_TESTID = (0, import_ds_system.slotObjectToDataTestIds)(DSFlyoutMenuName, FLYOUT_MENU_SLOTS);
+//# sourceMappingURL=index.js.map

package/dist/cjs/parts/DSFlyoutMenu/constants/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSFlyoutMenu/constants/index.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { slotObjectToDataTestIds } from '@elliemae/ds-system';\n\nexport const DSFlyoutMenuName = 'DSFlyoutMenu';\n\nexport const EXAMPLE_CONSTANTS = {} as const;\n\n// we are naming this with the ${component_name}_slots convention to namespace & avoid errors on duplicate exports variables in aggregators\nexport const FLYOUT_MENU_SLOTS = {\n  ROOT: 'root',\n  LIST_WRAPPER: 'list-wrapper',\n} as const;\n\n// we are naming this with the ${component_name}_data_testid convention to namespace & avoid errors on duplicate exports variables in aggregators\nexport const FLYOUT_MENU_DATA_TESTID = slotObjectToDataTestIds(DSFlyoutMenuName, FLYOUT_MENU_SLOTS);\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,uBAAwC;AAEjC,MAAM,mBAAmB;AAEzB,MAAM,oBAAoB,CAAC;AAG3B,MAAM,oBAAoB;AAAA,EAC/B,MAAM;AAAA,EACN,cAAc;AAChB;AAGO,MAAM,8BAA0B,0CAAwB,kBAAkB,iBAAiB;",
+  "names": []
+}

package/dist/cjs/{DSMenuButtonCTX.js → parts/DSFlyoutMenu/index.js}

@@ -26,13 +26,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var DSMenuButtonCTX_exports = {};
-__export(DSMenuButtonCTX_exports, {
-  MenuButtonContext: () => MenuButtonContext
+var DSFlyoutMenu_exports = {};
+__export(DSFlyoutMenu_exports, {
+  DSFlyoutMenu: () => import_DSFlyoutMenu.DSFlyoutMenu,
+  DSFlyoutMenuWithSchema: () => import_DSFlyoutMenu.DSFlyoutMenuWithSchema
 });
-module.exports = __toCommonJS(DSMenuButtonCTX_exports);
+module.exports = __toCommonJS(DSFlyoutMenu_exports);
 var React = __toESM(require("react"));
-var import_react = __toESM(require("react"));
-const defaultContext = {};
-const MenuButtonContext = import_react.default.createContext(defaultContext);
-//# sourceMappingURL=DSMenuButtonCTX.js.map
+var import_DSFlyoutMenu = require("./DSFlyoutMenu.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/parts/DSFlyoutMenu/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/DSFlyoutMenu/index.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export { DSFlyoutMenu, DSFlyoutMenuWithSchema } from './DSFlyoutMenu.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,0BAAqD;",
+  "names": []
+}

package/dist/cjs/parts/DSFlyoutMenu/react-desc-prop-types.js

@@ -0,0 +1,62 @@
+"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 react_desc_prop_types_exports = {};
+__export(react_desc_prop_types_exports, {
+  DSFlyoutMenuPropTypes: () => DSFlyoutMenuPropTypes,
+  DSFlyoutMenuPropTypesSchema: () => DSFlyoutMenuPropTypesSchema,
+  defaultProps: () => defaultProps
+});
+module.exports = __toCommonJS(react_desc_prop_types_exports);
+var React = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_react_desc_prop_types = require("../../react-desc-prop-types.js");
+var import_constants = require("./constants/index.js");
+const defaultProps = { ...import_react_desc_prop_types.defaultProps };
+const DSFlyoutMenuPropTypes = {
+  itemNode: import_ds_props_helpers.PropTypes.object.description("The parent menu node to render the menu from").isRequired,
+  setFloatingRef: import_ds_props_helpers.PropTypes.func.description(
+    "The function to set the ref of the floating element (from useFloatingContext.refs.setFloating)"
+  ).isRequired,
+  floatingStyles: import_ds_props_helpers.PropTypes.object.description(
+    "The styles to apply to the floating element to correctly position it (from useFloatingContext.floatingStyles)"
+  ).isRequired,
+  floatingContext: import_ds_props_helpers.PropTypes.object.description(
+    "The context object from useFloatingContext, used to allow FloatingWrapper correct functionality"
+  ).isRequired,
+  // anchorNode: PropTypes.instanceOf(HTMLElement).isRequired,
+  isMenuOpen: import_ds_props_helpers.PropTypes.bool.description("Wheter or not this particular instance of the flyout menu is open").isRequired,
+  ...(0, import_ds_props_helpers.getPropsPerSlotPropTypes)(import_constants.DSFlyoutMenuName, import_constants.FLYOUT_MENU_SLOTS),
+  ...import_ds_props_helpers.globalAttributesPropTypes,
+  // this component is meant to be used from a ds-menu-button compliant API,
+  //  for this reason we want to inherit the DSMenuButton props interface that relates to the menu and not the button...
+  ...import_react_desc_prop_types.DSMenuSpecificPropTypes,
+  ...import_ds_props_helpers.xstyledPropTypes
+};
+const DSFlyoutMenuPropTypesSchema = DSFlyoutMenuPropTypes;
+//# sourceMappingURL=react-desc-prop-types.js.map

package/dist/cjs/parts/DSFlyoutMenu/react-desc-prop-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/DSFlyoutMenu/react-desc-prop-types.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable @typescript-eslint/no-empty-interface */\nimport type { DSPropTypesSchema, ValidationMap } from '@elliemae/ds-props-helpers';\nimport {\n  PropTypes,\n  getPropsPerSlotPropTypes,\n  globalAttributesPropTypes,\n  xstyledPropTypes,\n} from '@elliemae/ds-props-helpers';\nimport { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';\nimport { type useFloatingContext } from '@elliemae/ds-floating-context';\nimport {\n  DSMenuSpecificPropTypes,\n  defaultProps as menuSpecificDefaultProps,\n  type DSMenuButtonT,\n} from '../../react-desc-prop-types.js';\nimport { DSFlyoutMenuName, FLYOUT_MENU_SLOTS } from './constants/index.js';\n\nexport declare namespace DSFlyoutMenuT {\n  /*\n   * everything that is specifically added in this namespace declaration and is not part of the original component\n   * is because the original component is an \"opinionated widget\" that offloads a chunk of responsibilities from dev to dimsum\n   * as such, the widget generates those interfaces,\n   *  but the app developer is not supposed to know about them\n   *    untill they go atomic composition (this namespace)\n   */\n  export interface RequiredProps extends DSMenuButtonT.MenuSpecificRequiredProps {\n    // anchorNode: HTMLElement | null;\n    isMenuOpen: boolean;\n    itemNode:\n      | DSMenuButtonT.MenuNodeWithSubmenuItem\n      | DSMenuButtonT.MenuNodeSingleSelectWithSubmenuItem\n      | DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem\n      | DSMenuButtonT.MenuNodeActivableWithSubmenuItem\n      | DSMenuButtonT.MenuNodeRootItem;\n    setFloatingRef: ReturnType<typeof useFloatingContext>['refs']['setFloating'];\n    floatingStyles: ReturnType<typeof useFloatingContext>['floatingStyles'];\n    floatingContext: ReturnType<typeof useFloatingContext>['context'];\n  }\n\n  export interface DefaultProps extends DSMenuButtonT.MenuSpecifiDefaultProps {}\n\n  export interface OptionalProps\n    extends TypescriptHelpersT.PropsForGlobalOnSlots<typeof DSFlyoutMenuName, typeof FLYOUT_MENU_SLOTS>,\n      DSMenuButtonT.MenuSpecificOptionalProps {}\n\n  export interface Props extends RequiredProps, Partial<DefaultProps>, OptionalProps {}\n\n  export interface InternalProps extends RequiredProps, DefaultProps, OptionalProps {}\n}\n\nexport const defaultProps: DSFlyoutMenuT.DefaultProps = { ...menuSpecificDefaultProps };\n\nexport const DSFlyoutMenuPropTypes: DSPropTypesSchema<DSFlyoutMenuT.Props> = {\n  itemNode: PropTypes.object.description('The parent menu node to render the menu from').isRequired,\n  setFloatingRef: PropTypes.func.description(\n    'The function to set the ref of the floating element (from useFloatingContext.refs.setFloating)',\n  ).isRequired,\n  floatingStyles: PropTypes.object.description(\n    'The styles to apply to the floating element to correctly position it (from useFloatingContext.floatingStyles)',\n  ).isRequired,\n  floatingContext: PropTypes.object.description(\n    'The context object from useFloatingContext, used to allow FloatingWrapper correct functionality',\n  ).isRequired,\n  // anchorNode: PropTypes.instanceOf(HTMLElement).isRequired,\n  isMenuOpen: PropTypes.bool.description('Wheter or not this particular instance of the flyout menu is open')\n    .isRequired,\n  ...getPropsPerSlotPropTypes(DSFlyoutMenuName, FLYOUT_MENU_SLOTS),\n  ...globalAttributesPropTypes,\n  // this component is meant to be used from a ds-menu-button compliant API,\n  //  for this reason we want to inherit the DSMenuButton props interface that relates to the menu and not the button...\n  ...DSMenuSpecificPropTypes,\n  ...xstyledPropTypes,\n};\n\nexport const DSFlyoutMenuPropTypesSchema = DSFlyoutMenuPropTypes as unknown as ValidationMap<DSFlyoutMenuT.Props>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,8BAKO;AAGP,mCAIO;AACP,uBAAoD;AAmC7C,MAAM,eAA2C,EAAE,GAAG,6BAAAA,aAAyB;AAE/E,MAAM,wBAAgE;AAAA,EAC3E,UAAU,kCAAU,OAAO,YAAY,8CAA8C,EAAE;AAAA,EACvF,gBAAgB,kCAAU,KAAK;AAAA,IAC7B;AAAA,EACF,EAAE;AAAA,EACF,gBAAgB,kCAAU,OAAO;AAAA,IAC/B;AAAA,EACF,EAAE;AAAA,EACF,iBAAiB,kCAAU,OAAO;AAAA,IAChC;AAAA,EACF,EAAE;AAAA;AAAA,EAEF,YAAY,kCAAU,KAAK,YAAY,mEAAmE,EACvG;AAAA,EACH,OAAG,kDAAyB,mCAAkB,kCAAiB;AAAA,EAC/D,GAAG;AAAA;AAAA;AAAA,EAGH,GAAG;AAAA,EACH,GAAG;AACL;AAEO,MAAM,8BAA8B;",
+  "names": ["menuSpecificDefaultProps"]
+}

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/DSMenuBehaviouralContextProvider.js

@@ -0,0 +1,70 @@
+"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 DSMenuBehaviouralContextProvider_exports = {};
+__export(DSMenuBehaviouralContextProvider_exports, {
+  DSMenuBehaviouralContextProvider: () => DSMenuBehaviouralContextProvider,
+  DSMenuBehaviouralContextProviderWithSchema: () => DSMenuBehaviouralContextProviderWithSchema
+});
+module.exports = __toCommonJS(DSMenuBehaviouralContextProvider_exports);
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_ds_hooks_on_blur_out = require("@elliemae/ds-hooks-on-blur-out");
+var import_react_desc_prop_types = require("./react-desc-prop-types.js");
+var import_useMenuBehaviouralContextProvider = require("./config/useMenuBehaviouralContextProvider.js");
+var import_MenuBehaviouralContextProviderCTX = require("./MenuBehaviouralContextProviderCTX.js");
+var import_constants = require("./constants/index.js");
+const DSMenuBehaviouralContextProvider = (props) => {
+  const ctx = (0, import_useMenuBehaviouralContextProvider.useMenuBehaviouralContextProvider)(props);
+  const {
+    trackFocusRegionReset,
+    propsWithDefault: { children },
+    preventBlurReset
+  } = ctx;
+  const config = import_react.default.useMemo(
+    () => ({
+      onBlur: () => {
+        if (!preventBlurReset.current) {
+          trackFocusRegionReset();
+          setTimeout(() => {
+            preventBlurReset.current = false;
+          });
+        }
+      }
+    }),
+    [preventBlurReset, trackFocusRegionReset]
+  );
+  const handleOnBlurOut = (0, import_ds_hooks_on_blur_out.useOnBlurOut)(config);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_MenuBehaviouralContextProviderCTX.MenuBehaviouralContextProviderContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { onBlur: handleOnBlurOut, children }) });
+};
+DSMenuBehaviouralContextProvider.displayName = import_constants.DSMenuBehaviouralContextProviderName;
+const DSMenuBehaviouralContextProviderWithSchema = (0, import_ds_props_helpers.describe)(DSMenuBehaviouralContextProvider);
+DSMenuBehaviouralContextProviderWithSchema.propTypes = import_react_desc_prop_types.DSMenuBehaviouralContextProviderPropTypesSchema;
+//# sourceMappingURL=DSMenuBehaviouralContextProvider.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/DSMenuBehaviouralContextProvider/DSMenuBehaviouralContextProvider.tsx", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["// this not interactive per se, the implementation is listening the bubble phase of the events\n// from the children, this is the MVC pattern in action\n/* eslint-disable jsx-a11y/no-static-element-interactions */\nimport React from 'react';\nimport { describe } from '@elliemae/ds-props-helpers';\nimport { useOnBlurOut } from '@elliemae/ds-hooks-on-blur-out';\nimport {\n  type DSMenuBehaviouralContextProviderT,\n  DSMenuBehaviouralContextProviderPropTypesSchema,\n} from './react-desc-prop-types.js';\nimport { useMenuBehaviouralContextProvider } from './config/useMenuBehaviouralContextProvider.js';\nimport { MenuBehaviouralContextProviderContext } from './MenuBehaviouralContextProviderCTX.js';\nimport { DSMenuBehaviouralContextProviderName } from './constants/index.js';\n\nconst DSMenuBehaviouralContextProvider: React.ComponentType<DSMenuBehaviouralContextProviderT.Props> = (props) => {\n  const ctx = useMenuBehaviouralContextProvider(props);\n  const {\n    trackFocusRegionReset,\n    propsWithDefault: { children },\n    preventBlurReset,\n  } = ctx;\n\n  const config = React.useMemo(\n    () => ({\n      onBlur: () => {\n        // we have a portal, the portal temporarily steals the focus\n        //  invoking the blur event\n        // when the blur event is invoked because the focus is stolen we do not want to reset the focus\n        // any other blur event should reset the focus\n        if (!preventBlurReset.current) {\n          trackFocusRegionReset();\n          setTimeout(() => {\n            preventBlurReset.current = false;\n          });\n        }\n      },\n    }),\n    [preventBlurReset, trackFocusRegionReset],\n  );\n  const handleOnBlurOut = useOnBlurOut(config);\n  return (\n    <MenuBehaviouralContextProviderContext.Provider value={ctx}>\n      <div onBlur={handleOnBlurOut}>{children}</div>\n    </MenuBehaviouralContextProviderContext.Provider>\n  );\n};\n\nDSMenuBehaviouralContextProvider.displayName = DSMenuBehaviouralContextProviderName;\nconst DSMenuBehaviouralContextProviderWithSchema = describe(DSMenuBehaviouralContextProvider);\nDSMenuBehaviouralContextProviderWithSchema.propTypes = DSMenuBehaviouralContextProviderPropTypesSchema;\n\nexport { DSMenuBehaviouralContextProvider, DSMenuBehaviouralContextProviderWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;AD0CjB;AAvCN,mBAAkB;AAClB,8BAAyB;AACzB,kCAA6B;AAC7B,mCAGO;AACP,+CAAkD;AAClD,+CAAsD;AACtD,uBAAqD;AAErD,MAAM,mCAAiG,CAAC,UAAU;AAChH,QAAM,UAAM,4EAAkC,KAAK;AACnD,QAAM;AAAA,IACJ;AAAA,IACA,kBAAkB,EAAE,SAAS;AAAA,IAC7B;AAAA,EACF,IAAI;AAEJ,QAAM,SAAS,aAAAA,QAAM;AAAA,IACnB,OAAO;AAAA,MACL,QAAQ,MAAM;AAKZ,YAAI,CAAC,iBAAiB,SAAS;AAC7B,gCAAsB;AACtB,qBAAW,MAAM;AACf,6BAAiB,UAAU;AAAA,UAC7B,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAAA,IACA,CAAC,kBAAkB,qBAAqB;AAAA,EAC1C;AACA,QAAM,sBAAkB,0CAAa,MAAM;AAC3C,SACE,4CAAC,+EAAsC,UAAtC,EAA+C,OAAO,KACrD,sDAAC,SAAI,QAAQ,iBAAkB,UAAS,GAC1C;AAEJ;AAEA,iCAAiC,cAAc;AAC/C,MAAM,iDAA6C,kCAAS,gCAAgC;AAC5F,2CAA2C,YAAY;",
+  "names": ["React"]
+}

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/MenuBehaviouralContextProviderCTX.js

@@ -0,0 +1,40 @@
+"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 MenuBehaviouralContextProviderCTX_exports = {};
+__export(MenuBehaviouralContextProviderCTX_exports, {
+  MenuBehaviouralContextProviderContext: () => MenuBehaviouralContextProviderContext,
+  default: () => MenuBehaviouralContextProviderCTX_default
+});
+module.exports = __toCommonJS(MenuBehaviouralContextProviderCTX_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+const defaultContext = {};
+const MenuBehaviouralContextProviderContext = (0, import_react.createContext)(defaultContext);
+var MenuBehaviouralContextProviderCTX_default = MenuBehaviouralContextProviderContext;
+//# sourceMappingURL=MenuBehaviouralContextProviderCTX.js.map

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/MenuBehaviouralContextProviderCTX.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/DSMenuBehaviouralContextProvider/MenuBehaviouralContextProviderCTX.ts", "../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { createContext } from 'react';\nimport type { MenuBehaviouralContextProviderCTX } from './config/useMenuBehaviouralContextProvider.js';\n\nconst defaultContext = {} as MenuBehaviouralContextProviderCTX;\n\n/** Context for cross component communication */\nexport const MenuBehaviouralContextProviderContext = createContext<MenuBehaviouralContextProviderCTX>(defaultContext);\n\nexport default MenuBehaviouralContextProviderContext;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA8B;AAG9B,MAAM,iBAAiB,CAAC;AAGjB,MAAM,4CAAwC,4BAAiD,cAAc;AAEpH,IAAO,4CAAQ;",
+  "names": []
+}

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/config/useFocusTracker.js

@@ -0,0 +1,186 @@
+"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 useFocusTracker_exports = {};
+__export(useFocusTracker_exports, {
+  useFocusTracker: () => useFocusTracker
+});
+module.exports = __toCommonJS(useFocusTracker_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_nodesTypeguardsAndGetters = require("../../../utils/nodesTypeguardsAndGetters.js");
+var import_Errors = require("../constants/Errors.js");
+var import_constants = require("../constants/index.js");
+var import_nodeGettersByCriterias = require("../utils/nodeGettersByCriterias.js");
+const useFocusTracker = () => {
+  const [focusRegion, setFocusRegion] = import_react.default.useState("");
+  const focusedRegionPerformanceHelper = import_react.default.useRef("");
+  const preventBlurReset = import_react.default.useRef(false);
+  const focusedElementItemNode = import_react.default.useRef(
+    null
+  );
+  const trackFocusTrigger = import_react.default.useCallback(() => {
+    setTimeout(() => {
+      setFocusRegion(import_constants.MENU_FOCUS_REGIONS.TRIGGER);
+      focusedRegionPerformanceHelper.current = import_constants.MENU_FOCUS_REGIONS.TRIGGER;
+      focusedElementItemNode.current = null;
+    });
+    return null;
+  }, []);
+  const trackFocusNode = import_react.default.useCallback((nodeToFocus) => {
+    const newFocusRegion = import_constants.MENU_FOCUS_REGIONS.ITEM_BY_DSID(nodeToFocus.dsId);
+    setTimeout(() => {
+      setFocusRegion(newFocusRegion);
+      focusedRegionPerformanceHelper.current = newFocusRegion;
+      focusedElementItemNode.current = nodeToFocus;
+    });
+  }, []);
+  const trackFocusRegionReset = import_react.default.useCallback(() => {
+    setTimeout(() => {
+      setFocusRegion(import_constants.MENU_FOCUS_REGIONS.RESET);
+      focusedRegionPerformanceHelper.current = import_constants.MENU_FOCUS_REGIONS.RESET;
+      focusedElementItemNode.current = null;
+    });
+    return null;
+  }, []);
+  const trackFocusFirstChildItem = import_react.default.useCallback(
+    (itemNode) => {
+      if (!(0, import_nodesTypeguardsAndGetters.isMenuNodeAllowedToHaveChildren)(itemNode)) {
+        console.log("focus first child item > itemNode", itemNode);
+        throw import_Errors.TREE_STRUCTURE_ERRORS.NODE_CANNOT_HAVE_CHILDREN;
+      }
+      if (itemNode.children.length === 0) {
+        console.log(itemNode);
+        throw new Error("No children found in the item node");
+      }
+      const focusableChildrenNodes = (0, import_nodeGettersByCriterias.getFocusableSiblingsList)(itemNode.children[0]);
+      if (focusableChildrenNodes.length === 0) {
+        console.log("focus first child item > itemNode", itemNode);
+        throw new Error("No focusable nodes found in the children of the item node");
+      }
+      const newFocusedNode = focusableChildrenNodes[0];
+      trackFocusNode(newFocusedNode);
+      return newFocusedNode;
+    },
+    [trackFocusNode]
+  );
+  const trackFocusLastChildItem = import_react.default.useCallback(
+    (itemNode) => {
+      if (!(0, import_nodesTypeguardsAndGetters.isMenuNodeAllowedToHaveChildren)(itemNode)) {
+        console.log("focus last child item > itemNode", itemNode);
+        throw new Error("Item node is not allowed to have children");
+      }
+      if (itemNode.children.length === 0) {
+        console.log(itemNode);
+        throw new Error("No children found in the item node");
+      }
+      const focusableChildrenNodes = (0, import_nodeGettersByCriterias.getFocusableSiblingsList)(itemNode.children[0]);
+      if (focusableChildrenNodes.length === 0) {
+        console.log("focus last child item > itemNode", itemNode);
+        throw new Error("No focusable nodes found in the children of the item node");
+      }
+      trackFocusNode(focusableChildrenNodes[focusableChildrenNodes.length - 1]);
+      return focusableChildrenNodes[focusableChildrenNodes.length - 1];
+    },
+    [trackFocusNode]
+  );
+  const trackFocusNextItem = import_react.default.useCallback(
+    (itemNode) => {
+      const focusableSiblingsNodes = (0, import_nodeGettersByCriterias.getFocusableSiblingsList)(itemNode);
+      const currIndex = focusableSiblingsNodes.findIndex((node) => node.dsId === itemNode.dsId);
+      const nextIndex = currIndex + 1 < focusableSiblingsNodes.length ? currIndex + 1 : 0;
+      const newFocusedNode = focusableSiblingsNodes[nextIndex];
+      trackFocusNode(newFocusedNode);
+      return newFocusedNode;
+    },
+    [trackFocusNode]
+  );
+  const trackFocusPreviousItem = import_react.default.useCallback(
+    (itemNode) => {
+      const focusableSiblingsNodes = (0, import_nodeGettersByCriterias.getFocusableSiblingsList)(itemNode);
+      const currIndex = focusableSiblingsNodes.findIndex((node) => node.dsId === itemNode.dsId);
+      const previousIndex = currIndex - 1 >= 0 ? currIndex - 1 : focusableSiblingsNodes.length - 1;
+      const newFocusNode = focusableSiblingsNodes[previousIndex];
+      trackFocusNode(newFocusNode);
+      return newFocusNode;
+    },
+    [trackFocusNode]
+  );
+  const trackFocusParentItem = import_react.default.useCallback(
+    (itemNode) => {
+      const { parent } = itemNode;
+      const parentNode = parent;
+      if (!parentNode) {
+        console.log("focus parent item", { itemNode, parentNode });
+        throw new Error(`No parent node found for the item node`);
+      }
+      let nodeToFocus = parentNode;
+      if ((0, import_nodesTypeguardsAndGetters.isGroup)(parentNode)) {
+        const groupParent = parentNode.parent;
+        if (!(0, import_nodesTypeguardsAndGetters.isFocusableNode)(groupParent) && !(0, import_nodesTypeguardsAndGetters.isRootNode)(groupParent)) {
+          console.log("focus parent item", { itemNode, parentNode, groupParent });
+          throw new Error("No focusable parent node found for the item node");
+        }
+        nodeToFocus = groupParent;
+      }
+      const focusableNode = (0, import_nodesTypeguardsAndGetters.isRootNode)(nodeToFocus) ? null : nodeToFocus;
+      const newFocusNode = focusableNode;
+      if (!newFocusNode) trackFocusTrigger();
+      else trackFocusNode(newFocusNode);
+      return focusableNode;
+    },
+    [trackFocusNode, trackFocusTrigger]
+  );
+  return import_react.default.useMemo(
+    () => ({
+      preventBlurReset,
+      focusRegion,
+      focusedElementItemNode,
+      trackFocusTrigger,
+      trackFocusNode,
+      trackFocusRegionReset,
+      trackFocusFirstChildItem,
+      trackFocusLastChildItem,
+      trackFocusNextItem,
+      trackFocusPreviousItem,
+      trackFocusParentItem
+    }),
+    [
+      focusRegion,
+      trackFocusFirstChildItem,
+      trackFocusLastChildItem,
+      trackFocusNextItem,
+      trackFocusNode,
+      trackFocusParentItem,
+      trackFocusPreviousItem,
+      trackFocusRegionReset,
+      trackFocusTrigger
+    ]
+  );
+};
+//# sourceMappingURL=useFocusTracker.js.map

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/config/useFocusTracker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/config/useFocusTracker.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable no-console */\n/* eslint-disable max-lines */\n/* eslint-disable max-statements */\n/* eslint-disable complexity */\nimport React from 'react';\nimport type { DSMenuButtonT } from '../../../react-desc-prop-types.js';\nimport {\n  isFocusableNode,\n  isGroup,\n  isMenuNodeAllowedToHaveChildren,\n  isRootNode,\n} from '../../../utils/nodesTypeguardsAndGetters.js';\nimport { TREE_STRUCTURE_ERRORS } from '../constants/Errors.js';\nimport { MENU_FOCUS_REGIONS } from '../constants/index.js';\nimport { getFocusableSiblingsList } from '../utils/nodeGettersByCriterias.js';\n\ntype MenuFocusRegionsValues = (typeof MENU_FOCUS_REGIONS)[keyof typeof MENU_FOCUS_REGIONS];\n// if MenuFocusRegionsValues may be a string or a function that returns a string, we want only the resolved strings\ntype ValidRegionsValues<T extends MenuFocusRegionsValues = MenuFocusRegionsValues> = T extends string\n  ? T\n  : // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends (...args: any) => any\n  ? ReturnType<T>\n  : never;\n\nexport const useFocusTracker = () => {\n  const [focusRegion, setFocusRegion] = React.useState<ValidRegionsValues>('');\n  // we want to keep the focus region trackers as stable as possible to avoid unnecessary re-renders\n  //  there is no need to change the trackers reference when the focus region changes,\n  //   since changing the focus region is always triggered by a final user interaction (so after reacts reconciliation)\n  const focusedRegionPerformanceHelper = React.useRef('') as React.MutableRefObject<ValidRegionsValues>;\n  const preventBlurReset = React.useRef(false);\n\n  const focusedElementItemNode = React.useRef(\n    null,\n  ) as React.MutableRefObject<DSMenuButtonT.PseudoFocusableMenuNodes | null>;\n  const trackFocusTrigger = React.useCallback(() => {\n    // we need to guarantee that the focus is set after the current event loop or else bubbling events will trigger on the new focused element\n    setTimeout(() => {\n      setFocusRegion(MENU_FOCUS_REGIONS.TRIGGER);\n      focusedRegionPerformanceHelper.current = MENU_FOCUS_REGIONS.TRIGGER;\n      focusedElementItemNode.current = null;\n    });\n    return null;\n  }, []);\n  const trackFocusNode = React.useCallback((nodeToFocus: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n    const newFocusRegion = MENU_FOCUS_REGIONS.ITEM_BY_DSID(nodeToFocus.dsId);\n    // we need to guarantee that the focus is set after the current event loop or else bubbling events will trigger on the new focused element\n    setTimeout(() => {\n      setFocusRegion(newFocusRegion);\n      focusedRegionPerformanceHelper.current = newFocusRegion;\n      // eslint-disable-next-line prefer-destructuring\n      focusedElementItemNode.current = nodeToFocus;\n    });\n  }, []);\n\n  const trackFocusRegionReset = React.useCallback(() => {\n    // we need to guarantee that the focus is set after the current event loop or else bubbling events will trigger on the new focused element\n    setTimeout(() => {\n      setFocusRegion(MENU_FOCUS_REGIONS.RESET);\n      focusedRegionPerformanceHelper.current = MENU_FOCUS_REGIONS.RESET;\n      focusedElementItemNode.current = null;\n    });\n    return null;\n  }, []);\n\n  const trackFocusFirstChildItem = React.useCallback(\n    (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n      if (!isMenuNodeAllowedToHaveChildren(itemNode)) {\n        console.log('focus first child item > itemNode', itemNode);\n        throw TREE_STRUCTURE_ERRORS.NODE_CANNOT_HAVE_CHILDREN;\n      }\n      if (itemNode.children.length === 0) {\n        console.log(itemNode);\n        throw new Error('No children found in the item node');\n      }\n      const focusableChildrenNodes = getFocusableSiblingsList(itemNode.children[0]);\n      if (focusableChildrenNodes.length === 0) {\n        console.log('focus first child item > itemNode', itemNode);\n        throw new Error('No focusable nodes found in the children of the item node');\n      }\n\n      const newFocusedNode = focusableChildrenNodes[0];\n      trackFocusNode(newFocusedNode);\n      return newFocusedNode;\n    },\n    [trackFocusNode],\n  );\n\n  const trackFocusLastChildItem = React.useCallback(\n    (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n      if (!isMenuNodeAllowedToHaveChildren(itemNode)) {\n        console.log('focus last child item > itemNode', itemNode);\n        throw new Error('Item node is not allowed to have children');\n      }\n      if (itemNode.children.length === 0) {\n        console.log(itemNode);\n        throw new Error('No children found in the item node');\n      }\n      const focusableChildrenNodes = getFocusableSiblingsList(itemNode.children[0]);\n      if (focusableChildrenNodes.length === 0) {\n        console.log('focus last child item > itemNode', itemNode);\n        throw new Error('No focusable nodes found in the children of the item node');\n      }\n      trackFocusNode(focusableChildrenNodes[focusableChildrenNodes.length - 1]);\n      return focusableChildrenNodes[focusableChildrenNodes.length - 1];\n    },\n    [trackFocusNode],\n  );\n\n  const trackFocusNextItem = React.useCallback(\n    (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n      const focusableSiblingsNodes = getFocusableSiblingsList(itemNode);\n      // we find the current item node index in the focusableSiblingsNodes array\n      const currIndex = focusableSiblingsNodes.findIndex((node) => node.dsId === itemNode.dsId);\n\n      const nextIndex = currIndex + 1 < focusableSiblingsNodes.length ? currIndex + 1 : 0;\n      const newFocusedNode = focusableSiblingsNodes[nextIndex];\n      trackFocusNode(newFocusedNode);\n\n      return newFocusedNode;\n    },\n    [trackFocusNode],\n  );\n\n  const trackFocusPreviousItem = React.useCallback(\n    (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n      const focusableSiblingsNodes = getFocusableSiblingsList(itemNode);\n      // we find the current item node index in the focusableSiblingsNodes array\n      const currIndex = focusableSiblingsNodes.findIndex((node) => node.dsId === itemNode.dsId);\n\n      const previousIndex = currIndex - 1 >= 0 ? currIndex - 1 : focusableSiblingsNodes.length - 1;\n      const newFocusNode = focusableSiblingsNodes[previousIndex];\n      trackFocusNode(newFocusNode);\n      return newFocusNode;\n    },\n    [trackFocusNode],\n  );\n\n  const trackFocusParentItem = React.useCallback(\n    (itemNode: DSMenuButtonT.PseudoFocusableMenuNodes) => {\n      const { parent } = itemNode;\n      // this typecast is required because we are reading the parent property from the itemNode\n      // while this function can receive any PseudoFocusableMenuNodes,\n      //   the parent property may be a non-pseudo focusable node (specifically when the parent property is group node)\n      const parentNode = parent;\n      if (!parentNode) {\n        console.log('focus parent item', { itemNode, parentNode });\n        throw new Error(`No parent node found for the item node`);\n      }\n\n      let nodeToFocus: DSMenuButtonT.PseudoFocusableMenuNodes | null = parentNode;\n      // if parent is SingleSelectGroupNode then we can't focus it\n      if (isGroup(parentNode)) {\n        const groupParent = parentNode.parent;\n        if (!isFocusableNode(groupParent) && !isRootNode(groupParent)) {\n          console.log('focus parent item', { itemNode, parentNode, groupParent });\n          throw new Error('No focusable parent node found for the item node');\n        }\n        nodeToFocus = groupParent;\n      }\n\n      const focusableNode = isRootNode(nodeToFocus) ? null : nodeToFocus;\n      const newFocusNode = focusableNode;\n      if (!newFocusNode) trackFocusTrigger();\n      else trackFocusNode(newFocusNode);\n\n      return focusableNode;\n    },\n    [trackFocusNode, trackFocusTrigger],\n  );\n\n  return React.useMemo(\n    () => ({\n      preventBlurReset,\n      focusRegion,\n      focusedElementItemNode,\n      trackFocusTrigger,\n      trackFocusNode,\n      trackFocusRegionReset,\n      trackFocusFirstChildItem,\n      trackFocusLastChildItem,\n      trackFocusNextItem,\n      trackFocusPreviousItem,\n      trackFocusParentItem,\n    }),\n    [\n      focusRegion,\n      trackFocusFirstChildItem,\n      trackFocusLastChildItem,\n      trackFocusNextItem,\n      trackFocusNode,\n      trackFocusParentItem,\n      trackFocusPreviousItem,\n      trackFocusRegionReset,\n      trackFocusTrigger,\n    ],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": ["React"]
+}