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

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

@@ -0,0 +1,66 @@
+"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 useMenuOpenStatus_exports = {};
+__export(useMenuOpenStatus_exports, {
+  useMenuOpenStatus: () => useMenuOpenStatus
+});
+module.exports = __toCommonJS(useMenuOpenStatus_exports);
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+const useMenuOpenStatus = ({ propsWithDefault, focusTrackers }) => {
+  const { trackFocusTrigger, trackFocusFirstChildItem, trackFocusLastChildItem, preventBlurReset } = focusTrackers;
+  const { onClose, onOpen, optionsTree } = propsWithDefault;
+  const [isMenuOpen, setIsMenuOpen] = import_react.default.useState(false);
+  const onOpinionatedClose = import_react.default.useCallback(
+    ({ skipFocus } = { skipFocus: false }) => {
+      setIsMenuOpen(false);
+      if (onClose) onClose();
+      if (!skipFocus) trackFocusTrigger();
+      preventBlurReset.current = false;
+    },
+    [onClose, preventBlurReset, trackFocusTrigger]
+  );
+  const onOpinionatedOpen = import_react.default.useCallback(
+    (config) => {
+      const { focusLastChild = false } = config || {};
+      setIsMenuOpen(true);
+      if (onOpen) onOpen();
+      const typeCastedOptionsTree = optionsTree;
+      if (focusLastChild) trackFocusLastChildItem(typeCastedOptionsTree);
+      else trackFocusFirstChildItem(typeCastedOptionsTree);
+      preventBlurReset.current = true;
+    },
+    [onOpen, optionsTree, preventBlurReset, trackFocusFirstChildItem, trackFocusLastChildItem]
+  );
+  return import_react.default.useMemo(
+    () => ({ isMenuOpen, onOpinionatedClose, onOpinionatedOpen }),
+    [isMenuOpen, onOpinionatedClose, onOpinionatedOpen]
+  );
+};
+//# sourceMappingURL=useMenuOpenStatus.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/config/useMenuOpenStatus.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React from 'react';\nimport { type DSMenuButtonT } from '../../../react-desc-prop-types.js';\nimport { type DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';\nimport type { useFocusTracker } from './useFocusTracker.js';\n\ntype UseMenuOpenStatusConfig = {\n  propsWithDefault: DSMenuBehaviouralContextProviderT.InternalProps;\n  focusTrackers: ReturnType<typeof useFocusTracker>;\n};\n\ntype OnOpinionatedOpenConfig = {\n  focusLastChild?: boolean;\n};\n\nexport const useMenuOpenStatus = ({ propsWithDefault, focusTrackers }: UseMenuOpenStatusConfig) => {\n  // when the menu closes the focus must be returned to the trigger\n  const { trackFocusTrigger, trackFocusFirstChildItem, trackFocusLastChildItem, preventBlurReset } = focusTrackers;\n  const { onClose, onOpen, optionsTree } = propsWithDefault;\n  const [isMenuOpen, setIsMenuOpen] = React.useState(false);\n\n  const onOpinionatedClose = React.useCallback(\n    ({ skipFocus } = { skipFocus: false }) => {\n      setIsMenuOpen(false);\n      if (onClose) onClose();\n      if (!skipFocus) trackFocusTrigger();\n      preventBlurReset.current = false;\n    },\n    [onClose, preventBlurReset, trackFocusTrigger],\n  );\n\n  const onOpinionatedOpen = React.useCallback(\n    (config?: OnOpinionatedOpenConfig) => {\n      const { focusLastChild = false } = config || {};\n      setIsMenuOpen(true);\n      if (onOpen) onOpen();\n      // Focus on the first item\n      // this conversion is a unsafe but that's because we are handling the treeroot node\n      //  and DSTree doesn't have direct support for typescript tree-root interfaces being different from the rest of the tree\n      // the function trackFocusLastChildItem takes any MenuNode and generates the list from subitems autonomously\n      // except for the \"trigger\" scenario, we always expect to invoke this function with a PseudoFocusableMenuNodes\n      //  so we typecast here instead of losing the type safety in the rest of the code\n      const typeCastedOptionsTree = optionsTree as DSMenuButtonT.PseudoFocusableMenuNodes;\n      if (focusLastChild) trackFocusLastChildItem(typeCastedOptionsTree);\n      else trackFocusFirstChildItem(typeCastedOptionsTree);\n      preventBlurReset.current = true;\n    },\n    [onOpen, optionsTree, preventBlurReset, trackFocusFirstChildItem, trackFocusLastChildItem],\n  );\n\n  return React.useMemo(\n    () => ({ isMenuOpen, onOpinionatedClose, onOpinionatedOpen }),\n    [isMenuOpen, onOpinionatedClose, onOpinionatedOpen],\n  );\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAkB;AAcX,MAAM,oBAAoB,CAAC,EAAE,kBAAkB,cAAc,MAA+B;AAEjG,QAAM,EAAE,mBAAmB,0BAA0B,yBAAyB,iBAAiB,IAAI;AACnG,QAAM,EAAE,SAAS,QAAQ,YAAY,IAAI;AACzC,QAAM,CAAC,YAAY,aAAa,IAAI,aAAAA,QAAM,SAAS,KAAK;AAExD,QAAM,qBAAqB,aAAAA,QAAM;AAAA,IAC/B,CAAC,EAAE,UAAU,IAAI,EAAE,WAAW,MAAM,MAAM;AACxC,oBAAc,KAAK;AACnB,UAAI,QAAS,SAAQ;AACrB,UAAI,CAAC,UAAW,mBAAkB;AAClC,uBAAiB,UAAU;AAAA,IAC7B;AAAA,IACA,CAAC,SAAS,kBAAkB,iBAAiB;AAAA,EAC/C;AAEA,QAAM,oBAAoB,aAAAA,QAAM;AAAA,IAC9B,CAAC,WAAqC;AACpC,YAAM,EAAE,iBAAiB,MAAM,IAAI,UAAU,CAAC;AAC9C,oBAAc,IAAI;AAClB,UAAI,OAAQ,QAAO;AAOnB,YAAM,wBAAwB;AAC9B,UAAI,eAAgB,yBAAwB,qBAAqB;AAAA,UAC5D,0BAAyB,qBAAqB;AACnD,uBAAiB,UAAU;AAAA,IAC7B;AAAA,IACA,CAAC,QAAQ,aAAa,kBAAkB,0BAA0B,uBAAuB;AAAA,EAC3F;AAEA,SAAO,aAAAA,QAAM;AAAA,IACX,OAAO,EAAE,YAAY,oBAAoB,kBAAkB;AAAA,IAC3D,CAAC,YAAY,oBAAoB,iBAAiB;AAAA,EACpD;AACF;",
+  "names": ["React"]
+}

package/dist/cjs/parts/DSMenuBehaviouralContextProvider/config/useValidateProps.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 useValidateProps_exports = {};
+__export(useValidateProps_exports, {
+  useValidateProps: () => useValidateProps
+});
+module.exports = __toCommonJS(useValidateProps_exports);
+var React = __toESM(require("react"));
+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.DSMenuBehaviouralContextProviderName);
+};
+//# sourceMappingURL=useValidateProps.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/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 DSMenuBehaviouralContextProviderT } from '../react-desc-prop-types.js';\nimport { DSMenuBehaviouralContextProviderName } from '../constants/index.js';\n\nexport const useValidateProps = (\n  props: DSMenuBehaviouralContextProviderT.InternalProps,\n  propTypes: ValidationMap<DSMenuBehaviouralContextProviderT.Props>,\n): void => {\n  // we validate the \"required if\" via 'isRequiredIf from our custom PropTypes\n  useValidateTypescriptPropTypes(props, propTypes, DSMenuBehaviouralContextProviderName);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,8BAA+C;AAG/C,uBAAqD;AAE9C,MAAM,mBAAmB,CAC9B,OACA,cACS;AAET,8DAA+B,OAAO,WAAW,qDAAoC;AACvF;",
+  "names": []
+}

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

@@ -0,0 +1,58 @@
+"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 Errors_exports = {};
+__export(Errors_exports, {
+  FORBIDDEN_BEHAVIOURS: () => FORBIDDEN_BEHAVIOURS,
+  TREE_STRUCTURE_ERRORS: () => TREE_STRUCTURE_ERRORS,
+  UNEXPECTED_INTERNAL_ERRORS: () => UNEXPECTED_INTERNAL_ERRORS
+});
+module.exports = __toCommonJS(Errors_exports);
+var React = __toESM(require("react"));
+const TREE_STRUCTURE_ERRORS = {
+  PARENT_NOT_GROUP: new Error(
+    "Tree structure violation: parent node of single-selectionable node MUST ALWAYS be a single select group node"
+  ),
+  GROUP_WITHOUT_PARENT: new Error("Tree structure violation: single select group node has no parent"),
+  NODE_CANNOT_HAVE_CHILDREN: new Error("Tree structure violation: node cannot have children")
+};
+const FORBIDDEN_BEHAVIOURS = {
+  TRYING_TO_FOCUS_NON_FOCUSABLE_NODE: new Error("Behavioural violation: trying to focus a non-focusable node"),
+  TRYING_TO_OPEN_SUBMENU_OF_NODE_WITHOUT_SUBMENU: new Error(
+    "Behavioural violation: trying to open submenu of node without submenu"
+  )
+};
+const UNEXPECTED_INTERNAL_ERRORS = {
+  FOCUSED_ITEM_NODE_NOT_SET: new Error("Internal error: focused item node not set"),
+  FOCUSED_ITEM_HAS_NO_PARENT: new Error("Internal error: focused item has no parent node (is root?)"),
+  NODE_WITHOUT_PARENT: new Error("Internal error: the node has no parent"),
+  CALCULATING_MULTI_SELECTION_OF_NON_MULTI_SELECTION_NODE: new Error(
+    "Internal error: the node is not multi-selectable or wrongly recognized as non-multi-selectable"
+  )
+};
+//# sourceMappingURL=Errors.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/constants/Errors.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const TREE_STRUCTURE_ERRORS = {\n  PARENT_NOT_GROUP: new Error(\n    'Tree structure violation: parent node of single-selectionable node MUST ALWAYS be a single select group node',\n  ),\n  GROUP_WITHOUT_PARENT: new Error('Tree structure violation: single select group node has no parent'),\n  NODE_CANNOT_HAVE_CHILDREN: new Error('Tree structure violation: node cannot have children'),\n};\n\nexport const FORBIDDEN_BEHAVIOURS = {\n  TRYING_TO_FOCUS_NON_FOCUSABLE_NODE: new Error('Behavioural violation: trying to focus a non-focusable node'),\n  TRYING_TO_OPEN_SUBMENU_OF_NODE_WITHOUT_SUBMENU: new Error(\n    'Behavioural violation: trying to open submenu of node without submenu',\n  ),\n};\n\nexport const UNEXPECTED_INTERNAL_ERRORS = {\n  FOCUSED_ITEM_NODE_NOT_SET: new Error('Internal error: focused item node not set'),\n  FOCUSED_ITEM_HAS_NO_PARENT: new Error('Internal error: focused item has no parent node (is root?)'),\n  NODE_WITHOUT_PARENT: new Error('Internal error: the node has no parent'),\n  CALCULATING_MULTI_SELECTION_OF_NON_MULTI_SELECTION_NODE: new Error(\n    'Internal error: the node is not multi-selectable or wrongly recognized as non-multi-selectable',\n  ),\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,wBAAwB;AAAA,EACnC,kBAAkB,IAAI;AAAA,IACpB;AAAA,EACF;AAAA,EACA,sBAAsB,IAAI,MAAM,kEAAkE;AAAA,EAClG,2BAA2B,IAAI,MAAM,qDAAqD;AAC5F;AAEO,MAAM,uBAAuB;AAAA,EAClC,oCAAoC,IAAI,MAAM,6DAA6D;AAAA,EAC3G,gDAAgD,IAAI;AAAA,IAClD;AAAA,EACF;AACF;AAEO,MAAM,6BAA6B;AAAA,EACxC,2BAA2B,IAAI,MAAM,2CAA2C;AAAA,EAChF,4BAA4B,IAAI,MAAM,4DAA4D;AAAA,EAClG,qBAAqB,IAAI,MAAM,wCAAwC;AAAA,EACvE,yDAAyD,IAAI;AAAA,IAC3D;AAAA,EACF;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,44 @@
+"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, {
+  DSMenuBehaviouralContextProviderName: () => DSMenuBehaviouralContextProviderName,
+  MENU_FOCUS_REGIONS: () => MENU_FOCUS_REGIONS
+});
+module.exports = __toCommonJS(constants_exports);
+var React = __toESM(require("react"));
+const DSMenuBehaviouralContextProviderName = "DSMenuBehaviouralContextProvider";
+const MENU_FOCUS_REGIONS = {
+  TRIGGER: "trigger",
+  // eslint thinks this is unnecceary, but this forces the string format, without it, it would be a generic string
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+  ITEM_BY_DSID: (dsId) => `item-${dsId}`,
+  RESET: ""
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/constants/index.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import type { DSMenuButtonT } from '../../../react-desc-prop-types.js';\nexport const DSMenuBehaviouralContextProviderName = 'DSMenuBehaviouralContextProvider';\n\nexport const MENU_FOCUS_REGIONS = {\n  TRIGGER: 'trigger',\n  // eslint thinks this is unnecceary, but this forces the string format, without it, it would be a generic string\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n  ITEM_BY_DSID: (dsId: DSMenuButtonT.MenuNode['dsId']) =>\n    `item-${dsId}` as `item-dsid-${DSMenuButtonT.MenuNode['dsId']}`,\n  RESET: '',\n} as const;\n\n/* **************************************************************** */\n// THIS HAS NO STYLES/SLOTS/DOM, IT'S A PURE LOGIC CONTEXT PROVIDER\n/* **************************************************************** */\n\n// we are naming this with the ${component_name}_slots convention to namespace & avoid errors on duplicate exports variables in aggregators\n// export const MENU_BEHAVIOURAL_CONTEXT_PROVIDER_SLOTS = {\n//   ROOT: 'root',\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\n// export const MENU_BEHAVIOURAL_CONTEXT_PROVIDER_DATA_TESTID = slotObjectToDataTestIds(DSMenuBehaviouralContextProviderName, MENU_BEHAVIOURAL_CONTEXT_PROVIDER_SLOTS)\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADChB,MAAM,uCAAuC;AAE7C,MAAM,qBAAqB;AAAA,EAChC,SAAS;AAAA;AAAA;AAAA,EAGT,cAAc,CAAC,SACb,QAAQ,IAAI;AAAA,EACd,OAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,37 @@
+"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: () => import_DSMenuBehaviouralContextProvider.DSMenuBehaviouralContextProvider,
+  DSMenuBehaviouralContextProviderWithSchema: () => import_DSMenuBehaviouralContextProvider.DSMenuBehaviouralContextProviderWithSchema
+});
+module.exports = __toCommonJS(DSMenuBehaviouralContextProvider_exports);
+var React = __toESM(require("react"));
+var import_DSMenuBehaviouralContextProvider = require("./DSMenuBehaviouralContextProvider.js");
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,53 @@
+"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, {
+  DSMenuBehaviouralContextProviderPropTypes: () => DSMenuBehaviouralContextProviderPropTypes,
+  DSMenuBehaviouralContextProviderPropTypesSchema: () => DSMenuBehaviouralContextProviderPropTypesSchema,
+  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");
+const defaultProps = {};
+const DSMenuBehaviouralContextProviderPropTypes = {
+  buttonDOMNode: import_ds_props_helpers.PropTypes.object.description("The DOM node of the button (on close -> return focus to)").isRequired,
+  buttonDOMNodeRef: import_ds_props_helpers.PropTypes.object.description(
+    "The DOM node of the button as a mutable Refs (required for performance reasons)"
+  ).isRequired,
+  children: import_ds_props_helpers.PropTypes.node.description("the menu trigger and the menu components").isRequired,
+  optionsTree: import_ds_props_helpers.PropTypes.object.description("DSTree node to build branches from").isRequired,
+  focusableNodes: import_ds_props_helpers.PropTypes.arrayOf(import_ds_props_helpers.PropTypes.object).description(
+    "an array of nodes that can receive pseudoFocus, obtainable via ds-tree flatten + filter(isFocusable)"
+  ).isRequired,
+  ...import_react_desc_prop_types.MenuBehaviouralLayerPropTypes
+};
+const DSMenuBehaviouralContextProviderPropTypesSchema = DSMenuBehaviouralContextProviderPropTypes;
+//# sourceMappingURL=react-desc-prop-types.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/parts/DSMenuBehaviouralContextProvider/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 { PropTypes } from '@elliemae/ds-props-helpers';\nimport { type TypescriptHelpersT } from '@elliemae/ds-typescript-helpers';\nimport { type DSMenuButtonT, MenuBehaviouralLayerPropTypes } from '../../react-desc-prop-types.js';\n\nexport declare namespace DSMenuBehaviouralContextProviderT {\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.MenuBehaviouralLayerRequiredProps {\n    buttonDOMNode: HTMLElement | null;\n    buttonDOMNodeRef: React.MutableRefObject<HTMLElement | null>;\n    optionsTree: DSMenuButtonT.MenuNode;\n    children: TypescriptHelpersT.ReactChildrenComplete;\n    focusableNodes: DSMenuButtonT.PseudoFocusableMenuNodes[];\n  }\n\n  export interface DefaultProps extends DSMenuButtonT.MenuBehaviouralLayerDefaultProps {}\n\n  export interface OptionalProps extends DSMenuButtonT.MenuBehaviouralLayerOptionalProps {}\n  export interface Props extends Partial<DefaultProps>, OptionalProps, RequiredProps {}\n\n  export interface InternalProps extends DefaultProps, OptionalProps, RequiredProps {}\n}\n\nexport const defaultProps: DSMenuBehaviouralContextProviderT.DefaultProps = {};\n\nexport const DSMenuBehaviouralContextProviderPropTypes: DSPropTypesSchema<DSMenuBehaviouralContextProviderT.Props> = {\n  buttonDOMNode: PropTypes.object.description('The DOM node of the button (on close -> return focus to)').isRequired,\n  buttonDOMNodeRef: PropTypes.object.description(\n    'The DOM node of the button as a mutable Refs (required for performance reasons)',\n  ).isRequired,\n  children: PropTypes.node.description('the menu trigger and the menu components').isRequired,\n  optionsTree: PropTypes.object.description('DSTree node to build branches from').isRequired,\n  focusableNodes: PropTypes.arrayOf(PropTypes.object).description(\n    'an array of nodes that can receive pseudoFocus, obtainable via ds-tree flatten + filter(isFocusable)',\n  ).isRequired,\n  ...MenuBehaviouralLayerPropTypes,\n};\n\nexport const DSMenuBehaviouralContextProviderPropTypesSchema =\n  DSMenuBehaviouralContextProviderPropTypes as unknown as ValidationMap<DSMenuBehaviouralContextProviderT.Props>;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,8BAA0B;AAE1B,mCAAkE;AA0B3D,MAAM,eAA+D,CAAC;AAEtE,MAAM,4CAAwG;AAAA,EACnH,eAAe,kCAAU,OAAO,YAAY,0DAA0D,EAAE;AAAA,EACxG,kBAAkB,kCAAU,OAAO;AAAA,IACjC;AAAA,EACF,EAAE;AAAA,EACF,UAAU,kCAAU,KAAK,YAAY,0CAA0C,EAAE;AAAA,EACjF,aAAa,kCAAU,OAAO,YAAY,oCAAoC,EAAE;AAAA,EAChF,gBAAgB,kCAAU,QAAQ,kCAAU,MAAM,EAAE;AAAA,IAClD;AAAA,EACF,EAAE;AAAA,EACF,GAAG;AACL;AAEO,MAAM,kDACX;",
+  "names": []
+}

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

@@ -0,0 +1,139 @@
+"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 multipleSelectionHelpers_exports = {};
+__export(multipleSelectionHelpers_exports, {
+  getIsMultipleSelectNodeWithSubmenuSelected: () => getIsMultipleSelectNodeWithSubmenuSelected,
+  getNewSelectionMultipleSelect: () => getNewSelectionMultipleSelect
+});
+module.exports = __toCommonJS(multipleSelectionHelpers_exports);
+var React = __toESM(require("react"));
+var import_nodesTypeguardsAndGetters = require("../../../utils/nodesTypeguardsAndGetters.js");
+var import_Errors = require("../constants/Errors.js");
+var import_nodeGettersByCriterias = require("./nodeGettersByCriterias.js");
+const getIsMultipleSelectNodeWithSubmenuSelected = ({
+  itemNode,
+  selectedItems
+}) => {
+  if (selectedItems.length === 0) return false;
+  const { multiSelectionableChilrens } = (0, import_nodeGettersByCriterias.getChildrenByCriterias)(itemNode);
+  const selectedMultiChildren = [];
+  let isSelectedItself = false;
+  selectedItems.forEach((itemMarkesAsSelected) => {
+    if (itemMarkesAsSelected.dsId === itemNode.dsId) isSelectedItself = true;
+    if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectNode)(itemMarkesAsSelected)) {
+      if (multiSelectionableChilrens.some((child) => child.dsId === itemMarkesAsSelected.dsId))
+        selectedMultiChildren.push(itemMarkesAsSelected);
+    }
+  });
+  if (!isSelectedItself) return false;
+  if (multiSelectionableChilrens.length === 0) return true;
+  if (selectedMultiChildren.length === 0) return false;
+  if (selectedMultiChildren.length !== multiSelectionableChilrens.length) return "mixed";
+  return true;
+};
+const getNewSelectionForMultipleSelectOnlyNode = (selectedItems, selectedItem) => {
+  const isDeselectingItem = selectedItems.find((item) => item.dsId === selectedItem.dsId) ?? false;
+  let newSelection = isDeselectingItem ? selectedItems.filter(({ dsId }) => dsId !== selectedItem.dsId) : [...selectedItems, selectedItem];
+  const notSelectedMultiParents = [];
+  const selectedMultiParents = [];
+  const multiParentsToDeselect = [];
+  selectedItem.walkParents((parent) => {
+    if (parent.dsId === selectedItem.dsId) return true;
+    const typedParent = parent;
+    if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectWithSubmenuNode)(typedParent)) {
+      const isAlreadySelected = newSelection.find((item) => item.dsId === typedParent.dsId);
+      if (isAlreadySelected) {
+        selectedMultiParents.push(typedParent);
+        const isParentSelected = getIsMultipleSelectNodeWithSubmenuSelected({
+          itemNode: typedParent,
+          selectedItems: newSelection
+        });
+        if (isParentSelected === false) multiParentsToDeselect.push(typedParent);
+      } else notSelectedMultiParents.push(typedParent);
+    }
+    return true;
+  });
+  if (isDeselectingItem) {
+    newSelection = newSelection.filter(({ dsId }) => !multiParentsToDeselect.some((parent) => parent.dsId === dsId));
+  } else {
+    newSelection.push(...notSelectedMultiParents);
+  }
+  return newSelection;
+};
+const getNewSelectionForMultipleSelectionWithSubmenuNode = (selectedItems, selectedItem) => {
+  const currentStatus = getIsMultipleSelectNodeWithSubmenuSelected({
+    itemNode: selectedItem,
+    selectedItems
+  });
+  const isDeselectingItem = currentStatus === true;
+  let newSelection = isDeselectingItem ? selectedItems.filter(({ dsId }) => dsId !== selectedItem.dsId) : [...selectedItems, selectedItem];
+  selectedItem.walk((child) => {
+    const typedChild = child;
+    if (isDeselectingItem) {
+      newSelection = newSelection.filter(({ dsId }) => dsId !== typedChild.dsId);
+    } else if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectNode)(typedChild) && !newSelection.find((item) => item.dsId === typedChild.dsId)) {
+      newSelection.push(typedChild);
+    }
+    return true;
+  });
+  const notSelectedMultiParents = [];
+  const selectedMultiParents = [];
+  const multiParentsToDeselect = [];
+  selectedItem.walkParents((parent) => {
+    if (parent.dsId === selectedItem.dsId) return true;
+    const typedParent = parent;
+    if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectWithSubmenuNode)(typedParent)) {
+      const isAlreadySelected = newSelection.find((item) => item.dsId === typedParent.dsId);
+      if (isAlreadySelected) {
+        selectedMultiParents.push(typedParent);
+        const isParentSelected = getIsMultipleSelectNodeWithSubmenuSelected({
+          itemNode: typedParent,
+          selectedItems: newSelection
+        });
+        if (isParentSelected === false) multiParentsToDeselect.push(typedParent);
+      } else notSelectedMultiParents.push(typedParent);
+    }
+    return true;
+  });
+  if (isDeselectingItem) {
+    newSelection = newSelection.filter(({ dsId }) => !multiParentsToDeselect.some((parent) => parent.dsId === dsId));
+  } else {
+    newSelection.push(...notSelectedMultiParents);
+  }
+  return newSelection;
+};
+const getNewSelectionMultipleSelect = (selectedItems, selectedItem) => {
+  if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectOnlyNode)(selectedItem))
+    return getNewSelectionForMultipleSelectOnlyNode(selectedItems, selectedItem);
+  if ((0, import_nodesTypeguardsAndGetters.isMultipleSelectWithSubmenuNode)(selectedItem))
+    return getNewSelectionForMultipleSelectionWithSubmenuNode(selectedItems, selectedItem);
+  console.log(selectedItem);
+  throw import_Errors.UNEXPECTED_INTERNAL_ERRORS.CALCULATING_MULTI_SELECTION_OF_NON_MULTI_SELECTION_NODE;
+};
+//# sourceMappingURL=multipleSelectionHelpers.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/parts/DSMenuBehaviouralContextProvider/utils/multipleSelectionHelpers.ts", "../../../../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable no-console */\n/* eslint-disable max-statements */\nimport { type DSMenuButtonT } from '../../../react-desc-prop-types.js';\nimport {\n  isMultipleSelectNode,\n  isMultipleSelectOnlyNode,\n  isMultipleSelectWithSubmenuNode,\n} from '../../../utils/nodesTypeguardsAndGetters.js';\nimport { UNEXPECTED_INTERNAL_ERRORS } from '../constants/Errors.js';\nimport { getChildrenByCriterias } from './nodeGettersByCriterias.js';\n\nexport const getIsMultipleSelectNodeWithSubmenuSelected = ({\n  itemNode,\n  selectedItems,\n}: {\n  itemNode: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem;\n  selectedItems: DSMenuButtonT.SelectionableMenuNodes[];\n}) => {\n  // no selected items, nothing is selected <- this is not selected neither, nothing else to check\n  if (selectedItems.length === 0) return false;\n\n  const { multiSelectionableChilrens } = getChildrenByCriterias(itemNode);\n  const selectedMultiChildren: DSMenuButtonT.MultipleSelectionableMenuNodes[] = [];\n  let isSelectedItself = false;\n  selectedItems.forEach((itemMarkesAsSelected) => {\n    if (itemMarkesAsSelected.dsId === itemNode.dsId) isSelectedItself = true;\n    if (isMultipleSelectNode(itemMarkesAsSelected)) {\n      // we reduce scenarios of O(n*m), if the node is not a multi-selectable node, we don't iterate the multiSelectionable childrens\n      if (multiSelectionableChilrens.some((child) => child.dsId === itemMarkesAsSelected.dsId))\n        selectedMultiChildren.push(itemMarkesAsSelected);\n    }\n  });\n  // console.group(`${itemNode.dsId} > getting \"selected\" (true/false/mixed) status`);\n  // console.log({\n  //   itemNode: itemNode.dsId,\n  //   selectedItems: selectedItems.map((itm) => itm.dsId),\n  //   multiSelectionableChilrens: multiSelectionableChilrens.map((itm) => itm.dsId),\n  //   selectedMultiChildren: selectedMultiChildren.map((itm) => itm.dsId),\n  //   isSelectedItself,\n  // });\n  // console.groupEnd();\n  // if it's not marked as selected, it's not selected.\n  if (!isSelectedItself) return false;\n  // if the node doesn't even have multi children, to calculate 'mixed' status upon (it may still have radios)\n  //  (and is selected itself), it's selected\n  if (multiSelectionableChilrens.length === 0) return true;\n\n  // multi children exist and the node is selected\n  //  it can be\n  //    true if all the multi children are selected\n  //    mixed if not all the multi children are selected\n  //    false if all the multi children are not selected\n\n  // multi children exist but none are selected at all?\n  if (selectedMultiChildren.length === 0) return false;\n  // any multi children is not selected?\n  if (selectedMultiChildren.length !== multiSelectionableChilrens.length) return 'mixed';\n  // there is a multi selection, and everything is selected\n  return true;\n};\n\nconst getNewSelectionForMultipleSelectOnlyNode = (\n  selectedItems: DSMenuButtonT.SelectionableMenuNodes[],\n  selectedItem: DSMenuButtonT.MenuNodeMultipleSelectItem,\n) => {\n  const isDeselectingItem = selectedItems.find((item) => item.dsId === selectedItem.dsId) ?? false;\n\n  let newSelection = isDeselectingItem\n    ? selectedItems.filter(({ dsId }) => dsId !== selectedItem.dsId)\n    : [...selectedItems, selectedItem];\n  const notSelectedMultiParents: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n  const selectedMultiParents: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n  const multiParentsToDeselect: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n\n  // we walk the parents and track info about them\n  selectedItem.walkParents((parent) => {\n    // discard ourself, only interested in the parents\n    if (parent.dsId === selectedItem.dsId) return true;\n    // DSTree typescripst doesn't understand ethereogenic nodes, so we need to typecast\n    const typedParent = parent as unknown as DSMenuButtonT.MenuNode;\n    if (isMultipleSelectWithSubmenuNode(typedParent)) {\n      // before we add the parent, we need to check if it's already in the selection\n      const isAlreadySelected = newSelection.find((item) => item.dsId === typedParent.dsId);\n      if (isAlreadySelected) {\n        selectedMultiParents.push(typedParent);\n        // we check if the parent is mixed or should be false (so we can deselect it)\n        const isParentSelected = getIsMultipleSelectNodeWithSubmenuSelected({\n          itemNode: typedParent,\n          selectedItems: newSelection,\n        });\n        if (isParentSelected === false) multiParentsToDeselect.push(typedParent);\n      } else notSelectedMultiParents.push(typedParent);\n    }\n    return true;\n  });\n\n  if (isDeselectingItem) {\n    // if we are deselecting:\n    //  we need to remove the parent nodes that are not selected anymore\n    //   (they transition from mixed to not selected because of this item deselection)\n    newSelection = newSelection.filter(({ dsId }) => !multiParentsToDeselect.some((parent) => parent.dsId === dsId));\n  } else {\n    // if we are selecting:\n    //  we need to add the parent nodes that are not selected yet\n    //   (they transition from not selected to mixed because of this item selection)\n    newSelection.push(...notSelectedMultiParents);\n  }\n\n  return newSelection;\n};\n\nconst getNewSelectionForMultipleSelectionWithSubmenuNode = (\n  selectedItems: DSMenuButtonT.SelectionableMenuNodes[],\n  selectedItem: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem,\n) => {\n  // when selecting/deselecting a node with a submenu, we need to consider the hierarchy of the selection starting from here\n  //  both upwards and downwards\n  // - upwards\n  //   we have to check if any multi-selectable-with-submenu parent transition from not selected to mixed || mixed to selected\n  // - downwards\n  //   - Deselect\n  //     we have to deselect all the selectable children (regarless of the depth of the children and kind of selection)\n  //   - Select\n  //     we have to select all the multi-selectable children that are not selected yet (both with and without submenu)\n\n  // console.group(`${selectedItem.dsId} > getting new selection`);\n  const currentStatus = getIsMultipleSelectNodeWithSubmenuSelected({\n    itemNode: selectedItem,\n    selectedItems,\n  });\n  const isDeselectingItem = currentStatus === true;\n\n  let newSelection = isDeselectingItem\n    ? selectedItems.filter(({ dsId }) => dsId !== selectedItem.dsId)\n    : [...selectedItems, selectedItem];\n\n  // console.log(\n  //   'starting newSelection',\n  //   newSelection.map(({ dsId }) => dsId),\n  // );\n\n  // we walk the children first and update the new selection accordingly\n  //  (it's important we first traverse the children, so we can update the selection of the parents accordingly to the new selection)\n  selectedItem.walk((child) => {\n    // DSTree typescripst doesn't understand ethereogenic nodes, so we need to typecast\n    const typedChild = child as unknown as DSMenuButtonT.SelectionableMenuNodes;\n    if (isDeselectingItem) {\n      // if we are deselecting, we need to remove the children from the selection\n      newSelection = newSelection.filter(({ dsId }) => dsId !== typedChild.dsId);\n    } else if (isMultipleSelectNode(typedChild) && !newSelection.find((item) => item.dsId === typedChild.dsId)) {\n      // if we are selecting, we need to add all the multi children to the selection (if they are not already there)\n      // (we don't do anything with single-selectable nodes, they are not affected by this operation by definition)\n      newSelection.push(typedChild);\n    }\n    return true;\n  });\n\n  // console.log(\n  //   'newSelection after applying logic to children, pre parents traversal',\n  //   newSelection.map(({ dsId }) => dsId),\n  // );\n\n  // now newSelection has the correct information about the node itself and its children\n  // we need to update the parents accordingly\n\n  const notSelectedMultiParents: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n  const selectedMultiParents: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n  const multiParentsToDeselect: DSMenuButtonT.MenuNodeMultipleSelectWithSubmenuItem[] = [];\n  // we walk the parents and track info about them\n  selectedItem.walkParents((parent) => {\n    // discard ourself, only interested in the parents\n    if (parent.dsId === selectedItem.dsId) return true;\n    // DSTree typescripst doesn't understand ethereogenic nodes, so we need to typecast\n    const typedParent = parent as unknown as DSMenuButtonT.MenuNode;\n    if (isMultipleSelectWithSubmenuNode(typedParent)) {\n      // before we add the parent, we need to check if it's already in the selection\n      const isAlreadySelected = newSelection.find((item) => item.dsId === typedParent.dsId);\n      if (isAlreadySelected) {\n        selectedMultiParents.push(typedParent);\n        // we check if the parent is mixed or should be false (so we can deselect it)\n        const isParentSelected = getIsMultipleSelectNodeWithSubmenuSelected({\n          itemNode: typedParent,\n          selectedItems: newSelection,\n        });\n        if (isParentSelected === false) multiParentsToDeselect.push(typedParent);\n      } else notSelectedMultiParents.push(typedParent);\n    }\n    return true;\n  });\n\n  // console.log(\n  //   'parents info > notSelectedMultiParents',\n  //   notSelectedMultiParents.map(({ dsId }) => dsId),\n  // );\n  // console.log(\n  //   'parents info > selectedMultiParents',\n  //   selectedMultiParents.map(({ dsId }) => dsId),\n  // );\n  // console.log(\n  //   'parents info > multiParentsToDeselect',\n  //   multiParentsToDeselect.map(({ dsId }) => dsId),\n  // );\n\n  // finally we use the info we gathered to update the selection\n  if (isDeselectingItem) {\n    // if we are deselecting:\n    //  we need to remove the parent nodes that are not selected anymore\n    //   (they transition from mixed to not selected because of this item deselection)\n    newSelection = newSelection.filter(({ dsId }) => !multiParentsToDeselect.some((parent) => parent.dsId === dsId));\n  } else {\n    // if we are selecting:\n    //  we need to add the parent nodes that are not selected yet\n    //   (they transition from not selected to mixed because of this item selection)\n    newSelection.push(...notSelectedMultiParents);\n  }\n\n  // console.log(\n  //   'final newSelection',\n  //   newSelection.map(({ dsId }) => dsId),\n  // );\n\n  // console.groupEnd();\n  return newSelection;\n};\n\nexport const getNewSelectionMultipleSelect = (\n  selectedItems: DSMenuButtonT.SelectionableMenuNodes[],\n  selectedItem: DSMenuButtonT.MultipleSelectionableMenuNodes,\n) => {\n  // depending on if we are selecting/deselecting an item with/without submenu, we need to handle the selection differently\n  if (isMultipleSelectOnlyNode(selectedItem))\n    return getNewSelectionForMultipleSelectOnlyNode(selectedItems, selectedItem);\n\n  if (isMultipleSelectWithSubmenuNode(selectedItem))\n    return getNewSelectionForMultipleSelectionWithSubmenuNode(selectedItems, selectedItem);\n\n  // if we reach this point, we are in an invalid state, we should never reach here\n  console.log(selectedItem);\n  throw UNEXPECTED_INTERNAL_ERRORS.CALCULATING_MULTI_SELECTION_OF_NON_MULTI_SELECTION_NODE;\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}