@elliemae/ds-legacy-dropdownmenu 1.0.0-rc.1

package/dist/cjs/deprecated/index.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 deprecated_exports = {};
+__export(deprecated_exports, {
+  CustomPhoneRenderer: () => import_CustomPhoneRenderer.CustomPhoneRenderer,
+  DSDropdownMenu: () => import_DSDropdownMenu.DSDropdownMenu,
+  DropdownMenuWithSchema: () => import_DSDropdownMenu.DropdownMenuWithSchema,
+  default: () => import_DSDropdownMenu.default
+});
+module.exports = __toCommonJS(deprecated_exports);
+var React = __toESM(require("react"));
+var import_DSDropdownMenu = __toESM(require("./DSDropdownMenu.js"));
+var import_CustomPhoneRenderer = require("./CustomPhoneRenderer.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/deprecated/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/deprecated/index.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["// @ts-nocheck\nexport { default, DropdownMenuWithSchema, DSDropdownMenu } from './DSDropdownMenu.js';\nexport { CustomPhoneRenderer } from './CustomPhoneRenderer.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,4BAAgE;AAChE,iCAAoC;",
+  "names": []
+}

package/dist/cjs/exported-related/constants.js

@@ -0,0 +1,45 @@
+"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, {
+  DSDropdownMenuName: () => DSDropdownMenuName,
+  DSDropdownMenuSlots: () => DSDropdownMenuSlots
+});
+module.exports = __toCommonJS(constants_exports);
+var React = __toESM(require("react"));
+const DSDropdownMenuName = "DSDropdownMenu";
+const DSDropdownMenuSlots = {
+  ROOT: "root",
+  LOADING_WRAPPER: "loading-wrapper",
+  LISTBOX_WRAPPER: "listbox-wrapper",
+  HEADER_WRAPPER: "header-wrapper",
+  OPTION_LIST_WRAPPER: "option-list-wrapper",
+  EMPTY_STATE_WRAPPER: "empty-state-wrapper"
+};
+//# sourceMappingURL=constants.js.map

package/dist/cjs/exported-related/constants.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/exported-related/constants.ts", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const DSDropdownMenuName = 'DSDropdownMenu';\n\nexport const DSDropdownMenuSlots = {\n  ROOT: 'root',\n  LOADING_WRAPPER: 'loading-wrapper',\n  LISTBOX_WRAPPER: 'listbox-wrapper',\n  HEADER_WRAPPER: 'header-wrapper',\n  OPTION_LIST_WRAPPER: 'option-list-wrapper',\n  EMPTY_STATE_WRAPPER: 'empty-state-wrapper',\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,qBAAqB;AAE3B,MAAM,sBAAsB;AAAA,EACjC,MAAM;AAAA,EACN,iBAAiB;AAAA,EACjB,iBAAiB;AAAA,EACjB,gBAAgB;AAAA,EAChB,qBAAqB;AAAA,EACrB,qBAAqB;AACvB;",
+  "names": []
+}

package/dist/cjs/exported-related/index.js

@@ -0,0 +1,30 @@
+"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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 exported_related_exports = {};
+module.exports = __toCommonJS(exported_related_exports);
+var React = __toESM(require("react"));
+__reExport(exported_related_exports, require("./constants.js"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/exported-related/index.js.map

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

package/dist/cjs/hooks/index.js

@@ -0,0 +1,32 @@
+"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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);
+var React = __toESM(require("react"));
+__reExport(hooks_exports, require("./useAutofocusContainerOnOpen.js"), module.exports);
+__reExport(hooks_exports, require("./useDropdownMenuItemHandlers.js"), module.exports);
+__reExport(hooks_exports, require("./useGetOptionSpecialAttributes.js"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/hooks/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/index.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export * from './useAutofocusContainerOnOpen.js';\nexport * from './useDropdownMenuItemHandlers.js';\nexport * from './useGetOptionSpecialAttributes.js';\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;ACAA,YAAuB;ADAvB,0BAAc,6CAAd;AACA,0BAAc,6CADd;AAEA,0BAAc,+CAFd;",
+  "names": []
+}

package/dist/cjs/hooks/useAutofocusContainerOnOpen.js

@@ -0,0 +1,49 @@
+"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 useAutofocusContainerOnOpen_exports = {};
+__export(useAutofocusContainerOnOpen_exports, {
+  useAutofocusContainerOnOpen: () => useAutofocusContainerOnOpen
+});
+module.exports = __toCommonJS(useAutofocusContainerOnOpen_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_DropdownMenuContext = require("../DropdownMenuContext.js");
+const useAutofocusContainerOnOpen = () => {
+  const { listboxReference, inputReference } = (0, import_react.useContext)(import_DropdownMenuContext.DSDropdownMenuContext);
+  (0, import_react.useLayoutEffect)(() => {
+    requestAnimationFrame(() => {
+      if (inputReference.current) {
+        inputReference.current.focus();
+      } else if (listboxReference.current) {
+        listboxReference.current.focus();
+      }
+    });
+  }, [inputReference, listboxReference]);
+};
+//# sourceMappingURL=useAutofocusContainerOnOpen.js.map

package/dist/cjs/hooks/useAutofocusContainerOnOpen.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useAutofocusContainerOnOpen.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useContext, useLayoutEffect } from 'react';\nimport { DSDropdownMenuContext } from '../DropdownMenuContext.js';\n\nexport const useAutofocusContainerOnOpen = () => {\n  const { listboxReference, inputReference } = useContext(DSDropdownMenuContext);\n\n  useLayoutEffect(() => {\n    requestAnimationFrame(() => {\n      if (inputReference.current) {\n        inputReference.current.focus();\n      } else if (listboxReference.current) {\n        listboxReference.current.focus();\n      }\n    });\n  }, [inputReference, listboxReference]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA4C;AAC5C,iCAAsC;AAE/B,MAAM,8BAA8B,MAAM;AAC/C,QAAM,EAAE,kBAAkB,eAAe,QAAI,yBAAW,gDAAqB;AAE7E,oCAAgB,MAAM;AACpB,0BAAsB,MAAM;AAC1B,UAAI,eAAe,SAAS;AAC1B,uBAAe,QAAQ,MAAM;AAAA,MAC/B,WAAW,iBAAiB,SAAS;AACnC,yBAAiB,QAAQ,MAAM;AAAA,MACjC;AAAA,IACF,CAAC;AAAA,EACH,GAAG,CAAC,gBAAgB,gBAAgB,CAAC;AACvC;",
+  "names": []
+}

package/dist/cjs/hooks/useDropdownListboxHandlers.js

@@ -0,0 +1,126 @@
+"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 useDropdownListboxHandlers_exports = {};
+__export(useDropdownListboxHandlers_exports, {
+  useDropdownListboxHandlers: () => useDropdownListboxHandlers
+});
+module.exports = __toCommonJS(useDropdownListboxHandlers_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_DropdownMenuContext = require("../DropdownMenuContext.js");
+var import_utils = require("../utils/index.js");
+const useDropdownListboxHandlers = () => {
+  const {
+    props: {
+      options,
+      onOptionClick,
+      openedSubmenus,
+      onSubmenuToggle,
+      onKeyDown: userOnKeyDown,
+      selectedOptions,
+      onClickOutside,
+      onMouseEnter: userOnMouseEnter,
+      onMouseLeave
+    },
+    activeDescendant,
+    setActiveDescendant,
+    scrollOptionIntoView,
+    listboxReference,
+    inputReference
+  } = (0, import_react.useContext)(import_DropdownMenuContext.DSDropdownMenuContext);
+  const onKeyDown = (0, import_react.useCallback)(
+    (e) => {
+      const currentItemIndex = options.findIndex((opt) => opt.dsId === activeDescendant);
+      if (currentItemIndex === -1)
+        return;
+      const option = options[currentItemIndex];
+      e.stopPropagation();
+      if (e.code === "ArrowDown") {
+        e.preventDefault();
+        const nextItemIndex = (0, import_utils.findInCircularList)(options, currentItemIndex, import_utils.isOptionFocuseable);
+        setActiveDescendant(options[nextItemIndex].dsId);
+        scrollOptionIntoView(options[nextItemIndex].dsId);
+      } else if (e.code === "ArrowUp") {
+        e.preventDefault();
+        const nextItemIndex = (0, import_utils.findInCircularList)(options, currentItemIndex, import_utils.isOptionFocuseable, -1);
+        setActiveDescendant(options[nextItemIndex].dsId);
+        scrollOptionIntoView(options[nextItemIndex].dsId);
+      } else if (e.code === "ArrowRight" && ["submenu", "singleWithSubmenu"].includes(option.type) && !openedSubmenus[option.dsId]) {
+        e.preventDefault();
+        onSubmenuToggle((0, import_utils.manageOpenedSubmenus)(options, { ...openedSubmenus, [option.dsId]: true }, option), option, e);
+      } else if (["Space", "Enter"].includes(e.code)) {
+        e.preventDefault();
+        const nextSelectedOptions = { ...selectedOptions };
+        nextSelectedOptions[option.dsId] = !selectedOptions[option.dsId];
+        if (option?.disabled)
+          return;
+        onOptionClick(nextSelectedOptions, option, e);
+        if (option.onClick)
+          option.onClick(e);
+      } else if (e.code === "Escape") {
+        onClickOutside(e);
+      } else if (e.code === "Home") {
+        const nextItemIndex = (0, import_utils.findInCircularList)(options, options.length - 1, import_utils.isOptionFocuseable);
+        setActiveDescendant(options[nextItemIndex].dsId);
+        scrollOptionIntoView(options[nextItemIndex].dsId);
+      } else if (e.code === "End") {
+        const nextItemIndex = (0, import_utils.findInCircularList)(options, 0, import_utils.isOptionFocuseable, -1);
+        setActiveDescendant(options[nextItemIndex].dsId);
+        scrollOptionIntoView(options[nextItemIndex].dsId);
+      }
+      if (option.onKeyDown)
+        option.onKeyDown(e);
+      userOnKeyDown(e);
+    },
+    [
+      options,
+      openedSubmenus,
+      userOnKeyDown,
+      activeDescendant,
+      setActiveDescendant,
+      scrollOptionIntoView,
+      onSubmenuToggle,
+      selectedOptions,
+      onOptionClick,
+      onClickOutside
+    ]
+  );
+  const onMouseEnter = (0, import_react.useCallback)(
+    (e) => {
+      if (inputReference.current)
+        inputReference.current.focus();
+      else
+        listboxReference.current?.focus();
+      userOnMouseEnter(e);
+    },
+    [inputReference, listboxReference, userOnMouseEnter]
+  );
+  return { onKeyDown, onMouseEnter, onMouseLeave };
+};
+//# sourceMappingURL=useDropdownListboxHandlers.js.map

package/dist/cjs/hooks/useDropdownListboxHandlers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useDropdownListboxHandlers.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\n/* eslint-disable max-statements */\n/* eslint-disable complexity */\nimport type React from 'react';\nimport { useCallback, useContext } from 'react';\nimport { DSDropdownMenuContext } from '../DropdownMenuContext.js';\nimport type { DSDropdownMenuT } from '../react-desc-prop-types.js';\nimport { findInCircularList, isOptionFocuseable, manageOpenedSubmenus } from '../utils/index.js';\n\ntype UseDropdownListboxHandlersType = () => {\n  onKeyDown: React.KeyboardEventHandler;\n  onMouseEnter: React.MouseEventHandler;\n  onMouseLeave?: React.MouseEventHandler;\n};\n\nexport const useDropdownListboxHandlers: UseDropdownListboxHandlersType = () => {\n  const {\n    props: {\n      options,\n      onOptionClick,\n      openedSubmenus,\n      onSubmenuToggle,\n      onKeyDown: userOnKeyDown,\n      selectedOptions,\n      onClickOutside,\n      onMouseEnter: userOnMouseEnter,\n      onMouseLeave,\n    },\n    activeDescendant,\n    setActiveDescendant,\n    scrollOptionIntoView,\n    listboxReference,\n    inputReference,\n  } = useContext(DSDropdownMenuContext);\n\n  const onKeyDown: React.KeyboardEventHandler = useCallback(\n    (e) => {\n      const currentItemIndex = options.findIndex((opt) => opt.dsId === activeDescendant);\n      if (currentItemIndex === -1) return;\n\n      const option = options[currentItemIndex];\n\n      e.stopPropagation();\n\n      if (e.code === 'ArrowDown') {\n        e.preventDefault();\n        const nextItemIndex = findInCircularList(options, currentItemIndex, isOptionFocuseable);\n        setActiveDescendant(options[nextItemIndex].dsId);\n        scrollOptionIntoView(options[nextItemIndex].dsId);\n      } else if (e.code === 'ArrowUp') {\n        e.preventDefault();\n        const nextItemIndex = findInCircularList(options, currentItemIndex, isOptionFocuseable, -1);\n        setActiveDescendant(options[nextItemIndex].dsId);\n        scrollOptionIntoView(options[nextItemIndex].dsId);\n      } else if (\n        e.code === 'ArrowRight' &&\n        ['submenu', 'singleWithSubmenu'].includes(option.type) &&\n        !openedSubmenus[option.dsId]\n      ) {\n        e.preventDefault();\n        onSubmenuToggle(manageOpenedSubmenus(options, { ...openedSubmenus, [option.dsId]: true }, option), option, e);\n      } else if (['Space', 'Enter'].includes(e.code)) {\n        e.preventDefault();\n        const nextSelectedOptions = { ...selectedOptions };\n        nextSelectedOptions[option.dsId] = !selectedOptions[option.dsId];\n        if ((option as DSDropdownMenuT.ItemActionOptions)?.disabled) return; // prevent click when is disabled\n        onOptionClick(nextSelectedOptions, option, e);\n        if (option.onClick) option.onClick(e);\n      } else if (e.code === 'Escape') {\n        onClickOutside(e);\n      } else if (e.code === 'Home') {\n        const nextItemIndex = findInCircularList(options, options.length - 1, isOptionFocuseable);\n        setActiveDescendant(options[nextItemIndex].dsId);\n        scrollOptionIntoView(options[nextItemIndex].dsId);\n      } else if (e.code === 'End') {\n        const nextItemIndex = findInCircularList(options, 0, isOptionFocuseable, -1);\n        setActiveDescendant(options[nextItemIndex].dsId);\n        scrollOptionIntoView(options[nextItemIndex].dsId);\n      }\n      if (option.onKeyDown) option.onKeyDown(e);\n      userOnKeyDown(e);\n    },\n    [\n      options,\n      openedSubmenus,\n      userOnKeyDown,\n      activeDescendant,\n      setActiveDescendant,\n      scrollOptionIntoView,\n      onSubmenuToggle,\n      selectedOptions,\n      onOptionClick,\n      onClickOutside,\n    ],\n  );\n\n  const onMouseEnter: React.MouseEventHandler = useCallback(\n    (e: React.MouseEvent) => {\n      if (inputReference.current) inputReference.current.focus();\n      else listboxReference.current?.focus();\n      userOnMouseEnter(e);\n    },\n    [inputReference, listboxReference, userOnMouseEnter],\n  );\n  return { onKeyDown, onMouseEnter, onMouseLeave };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/hooks/useDropdownMenuItemHandlers.js

@@ -0,0 +1,128 @@
+"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 useDropdownMenuItemHandlers_exports = {};
+__export(useDropdownMenuItemHandlers_exports, {
+  useDropdownMenuItemHandlers: () => useDropdownMenuItemHandlers
+});
+module.exports = __toCommonJS(useDropdownMenuItemHandlers_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_ds_legacy_utilities = require("@elliemae/ds-legacy-utilities");
+var import_DropdownMenuContext = require("../DropdownMenuContext.js");
+var import_utils = require("../utils/index.js");
+const useDropdownMenuItemHandlers = (option) => {
+  const {
+    props: {
+      options,
+      selectedOptions,
+      onOptionClick,
+      openedSubmenus,
+      onSubmenuToggle,
+      onMouseEnter,
+      onMouseLeave,
+      onMouseDown
+    },
+    listboxReference,
+    inputReference
+  } = (0, import_react.useContext)(import_DropdownMenuContext.DSDropdownMenuContext);
+  const mutableOption = (0, import_ds_legacy_utilities.useMakeMutable)(option);
+  const mutableOptions = (0, import_ds_legacy_utilities.useMakeMutable)(options);
+  const mutableOpenedSubmenus = (0, import_ds_legacy_utilities.useMakeMutable)(openedSubmenus);
+  const mutableOnSubmenuToggle = (0, import_ds_legacy_utilities.useMakeMutable)(onSubmenuToggle);
+  const mutableOnOptionClick = (0, import_ds_legacy_utilities.useMakeMutable)(onOptionClick);
+  const mutableSelectedOptions = (0, import_ds_legacy_utilities.useMakeMutable)(selectedOptions);
+  const onClick = (0, import_react.useCallback)(
+    (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+      const nextSelectedOptions = { ...mutableSelectedOptions.current };
+      nextSelectedOptions[mutableOption.current.dsId] = !mutableSelectedOptions.current[mutableOption.current.dsId];
+      if (mutableOption?.current?.disabled)
+        return;
+      mutableOnOptionClick?.current?.(nextSelectedOptions, mutableOption.current, e);
+      if (e.type === "click")
+        mutableOption?.current?.onClick?.(e);
+    },
+    [mutableOnOptionClick, mutableOption, mutableSelectedOptions]
+  );
+  const onSubmenuOpen = (0, import_react.useCallback)(
+    (e) => {
+      mutableOnSubmenuToggle?.current?.(
+        (0, import_utils.manageOpenedSubmenus)(
+          mutableOptions.current,
+          { ...mutableOpenedSubmenus?.current || {}, [mutableOption.current.dsId]: true },
+          mutableOption.current
+        ),
+        mutableOption.current,
+        e
+      );
+    },
+    [mutableOnSubmenuToggle, mutableOpenedSubmenus, mutableOption, mutableOptions]
+  );
+  const onSubmenuClose = (0, import_react.useCallback)(
+    (e) => {
+      mutableOnSubmenuToggle?.current?.(
+        (0, import_utils.manageOpenedSubmenus)(
+          mutableOptions.current,
+          { ...mutableOpenedSubmenus?.current || {}, [mutableOption.current.dsId]: false },
+          mutableOption.current
+        ),
+        mutableOption.current,
+        e
+      );
+      if (inputReference.current)
+        inputReference.current.focus();
+      else
+        listboxReference.current?.focus();
+    },
+    [inputReference, listboxReference, mutableOnSubmenuToggle, mutableOpenedSubmenus, mutableOption, mutableOptions]
+  );
+  const onDropdownKeyDown = (0, import_react.useCallback)(
+    (e) => {
+      if (e.code === "ArrowLeft") {
+        onSubmenuClose(e);
+        e.preventDefault();
+      }
+    },
+    [onSubmenuClose]
+  );
+  return (0, import_react.useMemo)(
+    () => ({
+      onClick,
+      onSubmenuOpen,
+      onSubmenuClose,
+      onDropdownKeyDown,
+      onMouseEnter,
+      onMouseLeave,
+      onMouseDown
+    }),
+    [onClick, onSubmenuOpen, onSubmenuClose, onDropdownKeyDown, onMouseEnter, onMouseLeave, onMouseDown]
+  );
+};
+//# sourceMappingURL=useDropdownMenuItemHandlers.js.map

package/dist/cjs/hooks/useDropdownMenuItemHandlers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useDropdownMenuItemHandlers.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type React from 'react';\nimport { useCallback, useContext, useMemo } from 'react';\nimport { useMakeMutable } from '@elliemae/ds-legacy-utilities';\nimport { DSDropdownMenuContext } from '../DropdownMenuContext.js';\nimport { manageOpenedSubmenus } from '../utils/index.js';\nimport type { DSDropdownMenuT } from '../react-desc-prop-types.js';\n\ntype UseDropdownMenuItemHandlersType = (option: DSDropdownMenuT.Item) => {\n  onClick: (e: React.MouseEvent | React.KeyboardEvent) => void;\n  onSubmenuOpen: (e: React.MouseEvent | React.KeyboardEvent) => void;\n  onSubmenuClose: (e: React.MouseEvent | React.KeyboardEvent) => void;\n  onDropdownKeyDown: React.KeyboardEventHandler;\n  onMouseEnter: React.MouseEventHandler;\n  onMouseLeave: React.MouseEventHandler;\n};\n\nexport const useDropdownMenuItemHandlers: UseDropdownMenuItemHandlersType = (option) => {\n  const {\n    props: {\n      options,\n      selectedOptions,\n      onOptionClick,\n      openedSubmenus,\n      onSubmenuToggle,\n      onMouseEnter,\n      onMouseLeave,\n      onMouseDown,\n    },\n    listboxReference,\n    inputReference,\n  } = useContext(DSDropdownMenuContext);\n\n  // it's vital for the opinionated onSubmenuOpen / onSubmenuClose to\n  //   - have access to the latest information about openedSubmenus\n  //   - be as \"pure\" as possible to guarantee that usage with the \"bridge\" pattern\n  //       will be as \"transparent\" as possible (if nested inside async code, redefing the callback may invoke a stale closure)\n  // the whole component is kind of messy so I'm going to implement a quick and dirty solution\n  // I'm going to make all the arguments for the callbacks \"mutable\",\n  //    this is sub-optimal on a performance level but will have to do for now\n  const mutableOption = useMakeMutable(option);\n  const mutableOptions = useMakeMutable(options);\n  const mutableOpenedSubmenus = useMakeMutable(openedSubmenus);\n  const mutableOnSubmenuToggle = useMakeMutable(onSubmenuToggle);\n  const mutableOnOptionClick = useMakeMutable(onOptionClick);\n  const mutableSelectedOptions = useMakeMutable(selectedOptions);\n\n  // This callback is used on single / multi items to toggle the selection\n  const onClick = useCallback(\n    (e: React.MouseEvent | React.KeyboardEvent) => {\n      e.stopPropagation();\n      e.preventDefault();\n      const nextSelectedOptions = { ...mutableSelectedOptions.current };\n      nextSelectedOptions[mutableOption.current.dsId] = !mutableSelectedOptions.current[mutableOption.current.dsId];\n      if ((mutableOption?.current as DSDropdownMenuT.ItemActionOptions)?.disabled) return; // prevent click when is disabled\n      mutableOnOptionClick?.current?.(nextSelectedOptions, mutableOption.current, e);\n      // we avoid invoking \"onClick\" twice when the users \"key-down - enter\" on the item by checking if the event is keyboard related\n      if (e.type === 'click') mutableOption?.current?.onClick?.(e);\n    },\n    [mutableOnOptionClick, mutableOption, mutableSelectedOptions],\n  );\n\n  // This callback is used on submenu items to open it onMouseEnter\n  const onSubmenuOpen = useCallback(\n    (e: React.MouseEvent | React.KeyboardEvent) => {\n      mutableOnSubmenuToggle?.current?.(\n        manageOpenedSubmenus(\n          mutableOptions.current,\n          { ...(mutableOpenedSubmenus?.current || {}), [mutableOption.current.dsId]: true },\n          mutableOption.current,\n        ),\n        mutableOption.current,\n        e,\n      );\n    },\n    [mutableOnSubmenuToggle, mutableOpenedSubmenus, mutableOption, mutableOptions],\n  );\n\n  // This callback is used on submenu to close it onMouseLeave\n  const onSubmenuClose = useCallback(\n    (e: React.MouseEvent | React.KeyboardEvent) => {\n      mutableOnSubmenuToggle?.current?.(\n        manageOpenedSubmenus(\n          mutableOptions.current,\n          { ...(mutableOpenedSubmenus?.current || {}), [mutableOption.current.dsId]: false },\n          mutableOption.current,\n        ),\n        mutableOption.current,\n        e,\n      );\n      if (inputReference.current) inputReference.current.focus();\n      else listboxReference.current?.focus();\n    },\n    [inputReference, listboxReference, mutableOnSubmenuToggle, mutableOpenedSubmenus, mutableOption, mutableOptions],\n  );\n\n  // This callback is used on child dropdown to close the current opened submenu (which spawned it)\n  const onDropdownKeyDown: React.KeyboardEventHandler = useCallback(\n    (e) => {\n      if (e.code === 'ArrowLeft') {\n        onSubmenuClose(e);\n        e.preventDefault();\n      }\n    },\n    [onSubmenuClose],\n  );\n\n  return useMemo(\n    () => ({\n      onClick,\n      onSubmenuOpen,\n      onSubmenuClose,\n      onDropdownKeyDown,\n      onMouseEnter,\n      onMouseLeave,\n      onMouseDown,\n    }),\n    [onClick, onSubmenuOpen, onSubmenuClose, onDropdownKeyDown, onMouseEnter, onMouseLeave, onMouseDown],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAiD;AACjD,iCAA+B;AAC/B,iCAAsC;AACtC,mBAAqC;AAY9B,MAAM,8BAA+D,CAAC,WAAW;AACtF,QAAM;AAAA,IACJ,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,QAAI,yBAAW,gDAAqB;AASpC,QAAM,oBAAgB,2CAAe,MAAM;AAC3C,QAAM,qBAAiB,2CAAe,OAAO;AAC7C,QAAM,4BAAwB,2CAAe,cAAc;AAC3D,QAAM,6BAAyB,2CAAe,eAAe;AAC7D,QAAM,2BAAuB,2CAAe,aAAa;AACzD,QAAM,6BAAyB,2CAAe,eAAe;AAG7D,QAAM,cAAU;AAAA,IACd,CAAC,MAA8C;AAC7C,QAAE,gBAAgB;AAClB,QAAE,eAAe;AACjB,YAAM,sBAAsB,EAAE,GAAG,uBAAuB,QAAQ;AAChE,0BAAoB,cAAc,QAAQ,IAAI,IAAI,CAAC,uBAAuB,QAAQ,cAAc,QAAQ,IAAI;AAC5G,UAAK,eAAe,SAA+C;AAAU;AAC7E,4BAAsB,UAAU,qBAAqB,cAAc,SAAS,CAAC;AAE7E,UAAI,EAAE,SAAS;AAAS,uBAAe,SAAS,UAAU,CAAC;AAAA,IAC7D;AAAA,IACA,CAAC,sBAAsB,eAAe,sBAAsB;AAAA,EAC9D;AAGA,QAAM,oBAAgB;AAAA,IACpB,CAAC,MAA8C;AAC7C,8BAAwB;AAAA,YACtB;AAAA,UACE,eAAe;AAAA,UACf,EAAE,GAAI,uBAAuB,WAAW,CAAC,GAAI,CAAC,cAAc,QAAQ,IAAI,GAAG,KAAK;AAAA,UAChF,cAAc;AAAA,QAChB;AAAA,QACA,cAAc;AAAA,QACd;AAAA,MACF;AAAA,IACF;AAAA,IACA,CAAC,wBAAwB,uBAAuB,eAAe,cAAc;AAAA,EAC/E;AAGA,QAAM,qBAAiB;AAAA,IACrB,CAAC,MAA8C;AAC7C,8BAAwB;AAAA,YACtB;AAAA,UACE,eAAe;AAAA,UACf,EAAE,GAAI,uBAAuB,WAAW,CAAC,GAAI,CAAC,cAAc,QAAQ,IAAI,GAAG,MAAM;AAAA,UACjF,cAAc;AAAA,QAChB;AAAA,QACA,cAAc;AAAA,QACd;AAAA,MACF;AACA,UAAI,eAAe;AAAS,uBAAe,QAAQ,MAAM;AAAA;AACpD,yBAAiB,SAAS,MAAM;AAAA,IACvC;AAAA,IACA,CAAC,gBAAgB,kBAAkB,wBAAwB,uBAAuB,eAAe,cAAc;AAAA,EACjH;AAGA,QAAM,wBAAgD;AAAA,IACpD,CAAC,MAAM;AACL,UAAI,EAAE,SAAS,aAAa;AAC1B,uBAAe,CAAC;AAChB,UAAE,eAAe;AAAA,MACnB;AAAA,IACF;AAAA,IACA,CAAC,cAAc;AAAA,EACjB;AAEA,aAAO;AAAA,IACL,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA,CAAC,SAAS,eAAe,gBAAgB,mBAAmB,cAAc,cAAc,WAAW;AAAA,EACrG;AACF;",
+  "names": []
+}

package/dist/cjs/hooks/useGetOptionSpecialAttributes.js

@@ -0,0 +1,47 @@
+"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 useGetOptionSpecialAttributes_exports = {};
+__export(useGetOptionSpecialAttributes_exports, {
+  useGetOptionSpecialAttributes: () => useGetOptionSpecialAttributes
+});
+module.exports = __toCommonJS(useGetOptionSpecialAttributes_exports);
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_DropdownMenuContext = require("../DropdownMenuContext.js");
+const useGetOptionSpecialAttributes = () => {
+  const {
+    props: { options }
+  } = (0, import_react.useContext)(import_DropdownMenuContext.DSDropdownMenuContext);
+  const optionsShouldHavePadding = (0, import_react.useMemo)(
+    () => options.some((option) => ["single", "checkbox", "singleWithSubmenu"].includes(option.type)),
+    [options]
+  );
+  return { optionsShouldHavePadding };
+};
+//# sourceMappingURL=useGetOptionSpecialAttributes.js.map

package/dist/cjs/hooks/useGetOptionSpecialAttributes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hooks/useGetOptionSpecialAttributes.tsx", "../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useContext, useMemo } from 'react';\nimport { DSDropdownMenuContext } from '../DropdownMenuContext.js';\n\nexport const useGetOptionSpecialAttributes = () => {\n  const {\n    props: { options },\n  } = useContext(DSDropdownMenuContext);\n\n  const optionsShouldHavePadding = useMemo(\n    () => options.some((option) => ['single', 'checkbox', 'singleWithSubmenu'].includes(option.type)),\n    [options],\n  );\n\n  return { optionsShouldHavePadding };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAoC;AACpC,iCAAsC;AAE/B,MAAM,gCAAgC,MAAM;AACjD,QAAM;AAAA,IACJ,OAAO,EAAE,QAAQ;AAAA,EACnB,QAAI,yBAAW,gDAAqB;AAEpC,QAAM,+BAA2B;AAAA,IAC/B,MAAM,QAAQ,KAAK,CAAC,WAAW,CAAC,UAAU,YAAY,mBAAmB,EAAE,SAAS,OAAO,IAAI,CAAC;AAAA,IAChG,CAAC,OAAO;AAAA,EACV;AAEA,SAAO,EAAE,yBAAyB;AACpC;",
+  "names": []
+}

package/dist/cjs/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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  CustomPhoneRenderer: () => import_deprecated2.CustomPhoneRenderer,
+  DSDropdownMenu: () => import_deprecated2.DSDropdownMenu,
+  DropdownMenuDataTestId: () => import_DropdownMenuDataTestId.DropdownMenuDataTestId,
+  DropdownMenuWithSchema: () => import_deprecated2.DropdownMenuWithSchema,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var React = __toESM(require("react"));
+var import_deprecated = __toESM(require("./deprecated/index.js"));
+__reExport(src_exports, require("./DSDropdownMenu.js"), module.exports);
+__reExport(src_exports, require("./exported-related/index.js"), module.exports);
+var import_DropdownMenuDataTestId = require("./DropdownMenuDataTestId.js");
+var import_deprecated2 = require("./deprecated/index.js");
+var src_default = import_deprecated.default;
+//# sourceMappingURL=index.js.map