@elliemae/ds-treeview 2.3.1 → 3.0.0-alpha.3

package/dist/cjs/utils/group-expands-helpers.js

@@ -0,0 +1,138 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var group_expands_helpers_exports = {};
+__export(group_expands_helpers_exports, {
+  collapseAll: () => collapseAll,
+  collapseItemModel: () => collapseItemModel,
+  expandAll: () => expandAll,
+  expandItemModel: () => expandItemModel,
+  getToggleExpandShouldExpand: () => getToggleExpandShouldExpand,
+  toggleExpandAllHelper: () => toggleExpandAllHelper,
+  toggleItemExpand: () => toggleItemExpand,
+  updateExpandedState: () => updateExpandedState,
+  useNotifyExpandedChange: () => useNotifyExpandedChange
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+const updateExpandedState = (treeRoot, onExpandChange) => {
+  const shouldContinueWalking = true;
+  const newExpandedHashMap = { __ds_tree_root: true };
+  treeRoot.walk((node) => {
+    if (!node.isRoot() && node.model.isGroup && node.model.isExpanded) {
+      newExpandedHashMap[node.model.id] = true;
+    }
+    return shouldContinueWalking;
+  });
+  if (onExpandChange)
+    onExpandChange(newExpandedHashMap, null);
+};
+const toggleItemExpand = (itemToToggle, triggerTreeRerender, updateUserExpandedState, scrollTo = () => {
+}) => {
+  const {
+    node: {
+      model: { isExpanded }
+    },
+    virtualIndex
+  } = itemToToggle;
+  if (itemToToggle.node.model.isGroup) {
+    itemToToggle.node.model.isExpanded = !isExpanded;
+    triggerTreeRerender();
+    updateUserExpandedState();
+    setTimeout(() => {
+      if (typeof virtualIndex === "number")
+        scrollTo(virtualIndex, { align: "start" });
+    });
+  }
+};
+const expandItemModel = (modelToExpand) => {
+  if (modelToExpand.isGroup)
+    modelToExpand.isExpanded = true;
+};
+const collapseItemModel = (modelToCollapse) => {
+  if (modelToCollapse.isGroup)
+    modelToCollapse.isExpanded = false;
+};
+const expandAll = (treeRoot, triggerTreeRerender) => {
+  const shouldContinueWalking = true;
+  treeRoot.walk((node) => {
+    if (!node.isRoot())
+      expandItemModel(node.model);
+    return shouldContinueWalking;
+  });
+  triggerTreeRerender();
+};
+const collapseAll = (treeRoot, triggerTreeRerender) => {
+  const shouldContinueWalking = true;
+  treeRoot.walk((node) => {
+    if (!node.isRoot())
+      collapseItemModel(node.model);
+    return shouldContinueWalking;
+  });
+  triggerTreeRerender();
+};
+const getToggleExpandShouldExpand = (treeRoot) => {
+  let shouldExpand = false;
+  const shouldContinueWalking = true;
+  treeRoot.walk((node) => {
+    if (!node.isRoot()) {
+      if (!node.model.isExpanded && node.model.isGroup) {
+        shouldExpand = true;
+        return shouldContinueWalking;
+      }
+    }
+    return shouldContinueWalking;
+  });
+  return shouldExpand;
+};
+const toggleExpandAllHelper = (isExpand, treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState) => {
+  if (isExpand === true)
+    expandAll(treeRoot, triggerTreeRerender);
+  else if (isExpand === false)
+    collapseAll(treeRoot, triggerTreeRerender);
+  else {
+    const shouldExpand = getToggleExpandShouldExpand(treeRoot);
+    if (shouldExpand === true)
+      expandAll(treeRoot, triggerTreeRerender);
+    else
+      collapseAll(treeRoot, triggerTreeRerender);
+  }
+  setLatestToggledItem(null);
+  updateUserExpandedState();
+};
+const useNotifyExpandedChange = (propsWithDefaults, {
+  latestToggledItem,
+  expandedGroups
+}) => {
+  const notifyExpandedChange = (0, import_react.useCallback)((expandedGroupHashmap) => propsWithDefaults?.onExpandChange(expandedGroupHashmap || {}, latestToggledItem), [propsWithDefaults, latestToggledItem]);
+  (0, import_react.useEffect)(() => {
+    if (!propsWithDefaults.expanded)
+      notifyExpandedChange(expandedGroups);
+  }, [expandedGroups, notifyExpandedChange, propsWithDefaults.expanded]);
+};
+module.exports = __toCommonJS(group_expands_helpers_exports);
+//# sourceMappingURL=group-expands-helpers.js.map

package/dist/cjs/utils/group-expands-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/group-expands-helpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\nimport { useCallback, useEffect } from 'react';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\n\nexport const updateExpandedState = (\n  treeRoot: DSTreeviewT.Item['node'],\n  onExpandChange: DSTreeviewT.Props['onExpandChange'] | null | undefined,\n) => {\n  const shouldContinueWalking = true;\n  const newExpandedHashMap: DSTreeviewT.ExpandedItems = { __ds_tree_root: true };\n  treeRoot.walk((node) => {\n    if (!node.isRoot() && node.model.isGroup && node.model.isExpanded) {\n      newExpandedHashMap[node.model.id] = true;\n    }\n    return shouldContinueWalking;\n  });\n  if (onExpandChange) onExpandChange(newExpandedHashMap, null);\n};\n\nexport const toggleItemExpand = (\n  itemToToggle: DSTreeviewT.Item,\n  triggerTreeRerender: () => void,\n  updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState'],\n  scrollTo: DSTreeviewT.ScrollToFunc = () => {},\n) => {\n  const {\n    node: {\n      model: { isExpanded },\n    },\n    virtualIndex,\n  } = itemToToggle;\n  if (itemToToggle.node.model.isGroup) {\n    itemToToggle.node.model.isExpanded = !isExpanded;\n    triggerTreeRerender();\n    updateUserExpandedState();\n    setTimeout(() => {\n      if (typeof virtualIndex === 'number') scrollTo(virtualIndex, { align: 'start' });\n    });\n  }\n};\n\nexport const expandItemModel = (modelToExpand: DSTreeviewT.Item['model']) => {\n  if (modelToExpand.isGroup) modelToExpand.isExpanded = true;\n};\n\nexport const collapseItemModel = (modelToCollapse: DSTreeviewT.Item['model']) => {\n  if (modelToCollapse.isGroup) modelToCollapse.isExpanded = false;\n};\n\nexport const expandAll = (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => {\n  const shouldContinueWalking = true;\n  treeRoot.walk((node) => {\n    if (!node.isRoot()) expandItemModel(node.model);\n    return shouldContinueWalking;\n  });\n  triggerTreeRerender();\n};\n\nexport const collapseAll = (treeRoot: DSTreeviewT.Item['node'], triggerTreeRerender: () => void) => {\n  const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking\n  treeRoot.walk((node) => {\n    if (!node.isRoot()) collapseItemModel(node.model);\n    return shouldContinueWalking;\n  });\n  triggerTreeRerender();\n};\n\nexport const getToggleExpandShouldExpand = (treeRoot: DSTreeviewT.Item['node']) => {\n  let shouldExpand = false;\n  const shouldContinueWalking = true; // tree-model ask we return true if we want to continue walking\n  treeRoot.walk((node) => {\n    if (!node.isRoot()) {\n      if (!node.model.isExpanded && node.model.isGroup) {\n        shouldExpand = true;\n        // eslint-disable-next-line no-useless-return\n        return shouldContinueWalking;\n      }\n    }\n    return shouldContinueWalking;\n  });\n  return shouldExpand;\n};\n\nexport const toggleExpandAllHelper = (\n  isExpand: boolean | 'toggle',\n  treeRoot: DSTreeviewT.Item['node'],\n  triggerTreeRerender: () => void,\n  setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'],\n  updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState'],\n) => {\n  if (isExpand === true) expandAll(treeRoot, triggerTreeRerender);\n  else if (isExpand === false) collapseAll(treeRoot, triggerTreeRerender);\n  else {\n    const shouldExpand = getToggleExpandShouldExpand(treeRoot);\n    if (shouldExpand === true) expandAll(treeRoot, triggerTreeRerender);\n    else collapseAll(treeRoot, triggerTreeRerender);\n  }\n  setLatestToggledItem(null);\n  updateUserExpandedState();\n};\n\nexport const useNotifyExpandedChange = (\n  propsWithDefaults: DSTreeviewT.Props,\n  {\n    latestToggledItem,\n    expandedGroups,\n  }: {\n    latestToggledItem?: DSTreeviewInternalsT.CTX['latestToggledItem'];\n    expandedGroups?: DSTreeviewInternalsT.CTX['expandedGroups'];\n  },\n) => {\n  const notifyExpandedChange = useCallback(\n    (expandedGroupHashmap?: DSTreeviewInternalsT.CTX['expandedGroups']) =>\n      propsWithDefaults?.onExpandChange(expandedGroupHashmap || {}, latestToggledItem),\n    [propsWithDefaults, latestToggledItem],\n  );\n\n  useEffect(() => {\n    if (!propsWithDefaults.expanded) notifyExpandedChange(expandedGroups);\n  }, [expandedGroups, notifyExpandedChange, propsWithDefaults.expanded]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAuC;AAIhC,MAAM,sBAAsB,CACjC,UACA,mBACG;AACH,QAAM,wBAAwB;AAC9B,QAAM,qBAAgD,EAAE,gBAAgB;AACxE,WAAS,KAAK,CAAC,SAAS;AACtB,QAAI,CAAC,KAAK,YAAY,KAAK,MAAM,WAAW,KAAK,MAAM,YAAY;AACjE,yBAAmB,KAAK,MAAM,MAAM;AAAA;AAEtC,WAAO;AAAA;AAET,MAAI;AAAgB,mBAAe,oBAAoB;AAAA;AAGlD,MAAM,mBAAmB,CAC9B,cACA,qBACA,yBACA,WAAqC,MAAM;AAAA,MACxC;AACH,QAAM;AAAA,IACJ,MAAM;AAAA,MACJ,OAAO,EAAE;AAAA;AAAA,IAEX;AAAA,MACE;AACJ,MAAI,aAAa,KAAK,MAAM,SAAS;AACnC,iBAAa,KAAK,MAAM,aAAa,CAAC;AACtC;AACA;AACA,eAAW,MAAM;AACf,UAAI,OAAO,iBAAiB;AAAU,iBAAS,cAAc,EAAE,OAAO;AAAA;AAAA;AAAA;AAKrE,MAAM,kBAAkB,CAAC,kBAA6C;AAC3E,MAAI,cAAc;AAAS,kBAAc,aAAa;AAAA;AAGjD,MAAM,oBAAoB,CAAC,oBAA+C;AAC/E,MAAI,gBAAgB;AAAS,oBAAgB,aAAa;AAAA;AAGrD,MAAM,YAAY,CAAC,UAAoC,wBAAoC;AAChG,QAAM,wBAAwB;AAC9B,WAAS,KAAK,CAAC,SAAS;AACtB,QAAI,CAAC,KAAK;AAAU,sBAAgB,KAAK;AACzC,WAAO;AAAA;AAET;AAAA;AAGK,MAAM,cAAc,CAAC,UAAoC,wBAAoC;AAClG,QAAM,wBAAwB;AAC9B,WAAS,KAAK,CAAC,SAAS;AACtB,QAAI,CAAC,KAAK;AAAU,wBAAkB,KAAK;AAC3C,WAAO;AAAA;AAET;AAAA;AAGK,MAAM,8BAA8B,CAAC,aAAuC;AACjF,MAAI,eAAe;AACnB,QAAM,wBAAwB;AAC9B,WAAS,KAAK,CAAC,SAAS;AACtB,QAAI,CAAC,KAAK,UAAU;AAClB,UAAI,CAAC,KAAK,MAAM,cAAc,KAAK,MAAM,SAAS;AAChD,uBAAe;AAEf,eAAO;AAAA;AAAA;AAGX,WAAO;AAAA;AAET,SAAO;AAAA;AAGF,MAAM,wBAAwB,CACnC,UACA,UACA,qBACA,sBACA,4BACG;AACH,MAAI,aAAa;AAAM,cAAU,UAAU;AAAA,WAClC,aAAa;AAAO,gBAAY,UAAU;AAAA,OAC9C;AACH,UAAM,eAAe,4BAA4B;AACjD,QAAI,iBAAiB;AAAM,gBAAU,UAAU;AAAA;AAC1C,kBAAY,UAAU;AAAA;AAE7B,uBAAqB;AACrB;AAAA;AAGK,MAAM,0BAA0B,CACrC,mBACA;AAAA,EACE;AAAA,EACA;AAAA,MAKC;AACH,QAAM,uBAAuB,8BAC3B,CAAC,yBACC,mBAAmB,eAAe,wBAAwB,IAAI,oBAChE,CAAC,mBAAmB;AAGtB,8BAAU,MAAM;AACd,QAAI,CAAC,kBAAkB;AAAU,2BAAqB;AAAA,KACrD,CAAC,gBAAgB,sBAAsB,kBAAkB;AAAA;",
+  "names": []
+}

package/dist/cjs/utils/keyboard-helpers.js

@@ -0,0 +1,170 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var keyboard_helpers_exports = {};
+__export(keyboard_helpers_exports, {
+  useGlobalKeyboardListener: () => useGlobalKeyboardListener,
+  useGlobalToggleAllExpandShortcut: () => useGlobalToggleAllExpandShortcut,
+  useOnItemKeyDown: () => useOnItemKeyDown
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_TreeViewContext = __toESM(require("../TreeViewContext"));
+var import_tree_helpers = require("./tree-helpers");
+var import_group_expands_helpers = require("./group-expands-helpers");
+const useOnItemKeyDown = (item, draggableProps) => {
+  const ctx = (0, import_react.useContext)(import_TreeViewContext.default);
+  const {
+    props: { onItemFocus },
+    triggerTreeRerender,
+    visibleItems,
+    setFocusedItem,
+    setSelectedItem,
+    setLatestToggledItem,
+    updateUserExpandedState,
+    virtualListHelpers: { scrollToIndex }
+  } = ctx;
+  const { isGroup, isExpanded } = item;
+  const onItemFocusCurry = (0, import_react.useCallback)((newFocusItem) => onItemFocus({
+    itemIndex: newFocusItem.virtualIndex,
+    scrollToItem: (opts = { align: "start" }) => scrollToIndex(newFocusItem.virtualIndex, opts),
+    item: newFocusItem
+  }), [onItemFocus, scrollToIndex]);
+  const onItemKeyDown = (0, import_react.useCallback)((e) => {
+    const { keyCode } = e;
+    if (!(draggableProps && draggableProps.active)) {
+      if (keyCode !== 9)
+        e.preventDefault();
+      if ((keyCode === 13 || keyCode === 32) && e.target.tagName === "LI") {
+        setSelectedItem(item);
+      }
+      if (keyCode === 37) {
+        if (isGroup && isExpanded) {
+          (0, import_group_expands_helpers.toggleItemExpand)(item, triggerTreeRerender, updateUserExpandedState, scrollToIndex);
+          setLatestToggledItem(item);
+        }
+      }
+      if (keyCode === 39) {
+        if (isGroup && !isExpanded) {
+          (0, import_group_expands_helpers.toggleItemExpand)(item, triggerTreeRerender, updateUserExpandedState, scrollToIndex);
+          setLatestToggledItem(item);
+        }
+      }
+      const { virtualIndex } = item;
+      if (typeof virtualIndex === "number") {
+        const lastItemIndex = visibleItems.length - 1;
+        if (keyCode === 38) {
+          const isLoopedFocus = virtualIndex === 0;
+          const newFocusIndex = isLoopedFocus ? lastItemIndex : virtualIndex - 1;
+          const newFocusItem = visibleItems[newFocusIndex];
+          scrollToIndex(newFocusIndex);
+          if (isLoopedFocus) {
+            setTimeout(() => {
+              setFocusedItem(newFocusItem);
+              (0, import_tree_helpers.focusItem)(newFocusItem);
+              onItemFocusCurry(newFocusItem);
+            }, 300);
+          } else {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            (0, import_tree_helpers.focusItem)(newFocusItem);
+          }
+        }
+        if (keyCode === 40) {
+          const isLoopedFocus = virtualIndex === lastItemIndex;
+          const newFocusIndex = isLoopedFocus ? 0 : virtualIndex + 1;
+          const newFocusItem = visibleItems[newFocusIndex];
+          scrollToIndex(newFocusIndex);
+          if (isLoopedFocus) {
+            setTimeout(() => {
+              setFocusedItem(newFocusItem);
+              onItemFocusCurry(newFocusItem);
+              (0, import_tree_helpers.focusItem)(newFocusItem);
+            }, 300);
+          } else {
+            setFocusedItem(newFocusItem);
+            onItemFocusCurry(newFocusItem);
+            (0, import_tree_helpers.focusItem)(newFocusItem);
+          }
+        }
+        if (keyCode === 35) {
+          if (virtualIndex !== lastItemIndex) {
+            const newFocusItem = visibleItems[lastItemIndex];
+            scrollToIndex(lastItemIndex);
+            setTimeout(() => {
+              setFocusedItem(newFocusItem);
+              onItemFocusCurry(newFocusItem);
+              (0, import_tree_helpers.focusItem)(newFocusItem);
+            }, 300);
+          }
+        }
+        if (keyCode === 36) {
+          if (virtualIndex !== 0) {
+            const newFocusItem = visibleItems[0];
+            scrollToIndex(0);
+            setTimeout(() => {
+              setFocusedItem(newFocusItem);
+              onItemFocusCurry(newFocusItem);
+              (0, import_tree_helpers.focusItem)(newFocusItem);
+            }, 300);
+          }
+        }
+      }
+    }
+  }, [
+    draggableProps,
+    setSelectedItem,
+    item,
+    isGroup,
+    isExpanded,
+    triggerTreeRerender,
+    updateUserExpandedState,
+    scrollToIndex,
+    setLatestToggledItem,
+    visibleItems,
+    setFocusedItem,
+    onItemFocusCurry
+  ]);
+  return onItemKeyDown;
+};
+const useGlobalKeyboardListener = (func) => {
+  (0, import_react.useEffect)(() => {
+    document.addEventListener("keydown", func);
+    return () => document.removeEventListener("keydown", func);
+  }, [func]);
+};
+const useGlobalToggleAllExpandShortcut = (treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState) => {
+  const memoizedToggleAllKeyboardShortcut = (0, import_react.useCallback)((e) => {
+    const { shiftKey, keyCode } = e;
+    if (shiftKey && keyCode === 56) {
+      (0, import_group_expands_helpers.toggleExpandAllHelper)("toggle", treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);
+    }
+  }, [setLatestToggledItem, treeRoot, triggerTreeRerender, updateUserExpandedState]);
+  return useGlobalKeyboardListener(memoizedToggleAllKeyboardShortcut);
+};
+module.exports = __toCommonJS(keyboard_helpers_exports);
+//# sourceMappingURL=keyboard-helpers.js.map

package/dist/cjs/utils/keyboard-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/keyboard-helpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\n/* eslint-disable max-lines */\n/* eslint-disable max-statements */\n/* eslint-disable complexity */\nimport { useCallback, useContext, useEffect } from 'react';\nimport TreeViewContext from '../TreeViewContext';\nimport { focusItem } from './tree-helpers';\nimport { toggleExpandAllHelper, toggleItemExpand } from './group-expands-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\nimport { SortableItemContextType } from '../hoc/SortableItemContext';\n\n// 9 tab\n// 13 enter\n// 32 space\n// 37 left arrow\n// 38 up arrow\n// 39 right arrow\n// 40 down arrow\n// 35 end\n// 36 home\n\n// 56 number 8\n// 106 (NumPad) *\n\nexport const useOnItemKeyDown = (item: DSTreeviewT.Item, draggableProps: SortableItemContextType['draggableProps']) => {\n  const ctx = useContext(TreeViewContext);\n  const {\n    props: { onItemFocus },\n    triggerTreeRerender,\n    visibleItems,\n    setFocusedItem,\n    setSelectedItem,\n    setLatestToggledItem,\n    updateUserExpandedState,\n    virtualListHelpers: { scrollToIndex },\n  } = ctx;\n  const { isGroup, isExpanded } = item;\n  const onItemFocusCurry = useCallback(\n    (newFocusItem: DSTreeviewT.Item) =>\n      onItemFocus({\n        itemIndex: newFocusItem.virtualIndex as number,\n        scrollToItem: (opts = { align: 'start' }) => scrollToIndex(newFocusItem.virtualIndex as number, opts),\n        item: newFocusItem,\n      }),\n    [onItemFocus, scrollToIndex],\n  );\n\n  const onItemKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLLIElement>) => {\n      const { keyCode } = e;\n      if (!(draggableProps && draggableProps.active)) {\n        if (keyCode !== 9) e.preventDefault(); // allow tab/shift+tab\n        if ((keyCode === 13 || keyCode === 32) && (e.target as HTMLElement).tagName === 'LI') {\n          setSelectedItem(item);\n        }\n\n        if (keyCode === 37) {\n          if (isGroup && isExpanded) {\n            toggleItemExpand(item, triggerTreeRerender, updateUserExpandedState, scrollToIndex);\n            setLatestToggledItem(item);\n          }\n        }\n        if (keyCode === 39) {\n          if (isGroup && !isExpanded) {\n            toggleItemExpand(item, triggerTreeRerender, updateUserExpandedState, scrollToIndex);\n            setLatestToggledItem(item);\n          }\n        }\n\n        const { virtualIndex } = item;\n        if (typeof virtualIndex === 'number') {\n          const lastItemIndex = visibleItems.length - 1;\n          if (keyCode === 38) {\n            const isLoopedFocus = virtualIndex === 0;\n            const newFocusIndex = isLoopedFocus ? lastItemIndex : virtualIndex - 1;\n            const newFocusItem = visibleItems[newFocusIndex];\n            scrollToIndex(newFocusIndex);\n            if (isLoopedFocus) {\n              // when looping the list from start to end we need to wait a bit before focusing\n              setTimeout(() => {\n                setFocusedItem(newFocusItem);\n                focusItem(newFocusItem);\n                onItemFocusCurry(newFocusItem);\n              }, 300);\n            } else {\n              setFocusedItem(newFocusItem);\n              onItemFocusCurry(newFocusItem);\n              focusItem(newFocusItem);\n            }\n          }\n          if (keyCode === 40) {\n            const isLoopedFocus = virtualIndex === lastItemIndex;\n            const newFocusIndex = isLoopedFocus ? 0 : virtualIndex + 1;\n            const newFocusItem = visibleItems[newFocusIndex];\n            scrollToIndex(newFocusIndex);\n            if (isLoopedFocus) {\n              // when looping the list from start to end we need to wait a bit before focusing\n              setTimeout(() => {\n                setFocusedItem(newFocusItem);\n                onItemFocusCurry(newFocusItem);\n                focusItem(newFocusItem);\n              }, 300);\n            } else {\n              setFocusedItem(newFocusItem);\n              onItemFocusCurry(newFocusItem);\n              focusItem(newFocusItem);\n            }\n          }\n          if (keyCode === 35) {\n            if (virtualIndex !== lastItemIndex) {\n              const newFocusItem = visibleItems[lastItemIndex];\n              scrollToIndex(lastItemIndex);\n              setTimeout(() => {\n                setFocusedItem(newFocusItem);\n                onItemFocusCurry(newFocusItem);\n                focusItem(newFocusItem);\n              }, 300);\n            }\n          }\n          if (keyCode === 36) {\n            if (virtualIndex !== 0) {\n              const newFocusItem = visibleItems[0];\n              scrollToIndex(0);\n              setTimeout(() => {\n                setFocusedItem(newFocusItem);\n                onItemFocusCurry(newFocusItem);\n                focusItem(newFocusItem);\n              }, 300);\n            }\n          }\n        }\n      }\n    },\n    [\n      draggableProps,\n      setSelectedItem,\n      item,\n      isGroup,\n      isExpanded,\n      triggerTreeRerender,\n      updateUserExpandedState,\n      scrollToIndex,\n      setLatestToggledItem,\n      visibleItems,\n      setFocusedItem,\n      onItemFocusCurry,\n    ],\n  );\n\n  return onItemKeyDown;\n};\n\nexport const useGlobalKeyboardListener = (func: (e: KeyboardEvent) => void) => {\n  useEffect(() => {\n    document.addEventListener('keydown', func);\n    return () => document.removeEventListener('keydown', func);\n  }, [func]);\n};\n\nexport const useGlobalToggleAllExpandShortcut = (\n  treeRoot: DSTreeviewT.Item['node'],\n  triggerTreeRerender: () => void,\n  setLatestToggledItem: DSTreeviewInternalsT.CTX['setLatestToggledItem'],\n  updateUserExpandedState: DSTreeviewInternalsT.CTX['updateUserExpandedState'],\n) => {\n  const memoizedToggleAllKeyboardShortcut = useCallback(\n    (e: KeyboardEvent) => {\n      const { shiftKey, keyCode } = e;\n      if (shiftKey && keyCode === 56) {\n        toggleExpandAllHelper('toggle', treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);\n      }\n    },\n    [setLatestToggledItem, treeRoot, triggerTreeRerender, updateUserExpandedState],\n  );\n\n  return useGlobalKeyboardListener(memoizedToggleAllKeyboardShortcut);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/utils/object-helpers.js

@@ -0,0 +1,76 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var object_helpers_exports = {};
+__export(object_helpers_exports, {
+  filterObject: () => filterObject,
+  unfreeze: () => unfreeze
+});
+var React = __toESM(require("react"));
+function isObjectADate(o) {
+  return o?.constructor?.name === "Date";
+}
+function isObjectAnArray(o) {
+  return Array.isArray(o);
+}
+function isObjectAString(o) {
+  return typeof o === "object";
+}
+const unfreeze = (o) => {
+  let oo;
+  if (o === null) {
+    oo = null;
+  } else if (o === void 0) {
+    oo = void 0;
+  } else if (isObjectADate(o)) {
+    oo = new Date(o);
+  } else if (isObjectAnArray(o)) {
+    oo = [];
+    o.forEach((v) => {
+      oo.push(v);
+    });
+  } else if (isObjectAString(o)) {
+    oo = String(o);
+  } else if (isObjectAString(o)) {
+    oo = {};
+    for (const property in o) {
+      oo[property] = o[property];
+    }
+  } else {
+    oo = o;
+  }
+  return oo;
+};
+function filterObject(obj, predicate) {
+  return Object.keys(obj).reduce((res, key) => {
+    if (predicate(obj[key]))
+      res[key] = obj[key];
+    return res;
+  }, {});
+}
+module.exports = __toCommonJS(object_helpers_exports);
+//# sourceMappingURL=object-helpers.js.map

package/dist/cjs/utils/object-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/object-helpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable no-sequences */\n/* eslint-disable no-return-assign */\n/* eslint-disable no-restricted-syntax */\n/* eslint-disable guard-for-in */\n\nfunction isObjectADate(o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>): o is Date {\n  return o?.constructor?.name === 'Date';\n}\nfunction isObjectAnArray(\n  o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>,\n): o is unknown[] {\n  return Array.isArray(o);\n}\nfunction isObjectAString(\n  o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>,\n): o is Record<string, unknown> {\n  return typeof o === 'object';\n}\n\nexport const unfreeze = (o: string | number | unknown[] | Date | null | undefined | Record<string, unknown>) => {\n  let oo: string | number | unknown[] | Date | null | undefined | Record<string, unknown>;\n  if (o === null) {\n    oo = null;\n  } else if (o === undefined) {\n    oo = undefined;\n  } else if (isObjectADate(o)) {\n    oo = new Date(o);\n  } else if (isObjectAnArray(o)) {\n    oo = [];\n    o.forEach((v) => {\n      (oo as unknown[]).push(v);\n    });\n  } else if (isObjectAString(o)) {\n    oo = String(o);\n  } else if (isObjectAString(o)) {\n    oo = {};\n    for (const property in o) {\n      oo[property] = o[property];\n    }\n  } else {\n    oo = o;\n  }\n  return oo;\n};\n\ntype GenericItemT<T = unknown> = { [key: string]: T };\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function filterObject<T = unknown>(obj: GenericItemT<T>, predicate: (val: T) => boolean) {\n  return Object.keys(obj).reduce<GenericItemT<T>>((res, key) => {\n    if (predicate(obj[key])) res[key] = obj[key];\n    return res;\n  }, {} as GenericItemT<T>);\n}\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADKvB,uBAAuB,GAA+F;AACpH,SAAO,GAAG,aAAa,SAAS;AAAA;AAElC,yBACE,GACgB;AAChB,SAAO,MAAM,QAAQ;AAAA;AAEvB,yBACE,GAC8B;AAC9B,SAAO,OAAO,MAAM;AAAA;AAGf,MAAM,WAAW,CAAC,MAAuF;AAC9G,MAAI;AACJ,MAAI,MAAM,MAAM;AACd,SAAK;AAAA,aACI,MAAM,QAAW;AAC1B,SAAK;AAAA,aACI,cAAc,IAAI;AAC3B,SAAK,IAAI,KAAK;AAAA,aACL,gBAAgB,IAAI;AAC7B,SAAK;AACL,MAAE,QAAQ,CAAC,MAAM;AACf,MAAC,GAAiB,KAAK;AAAA;AAAA,aAEhB,gBAAgB,IAAI;AAC7B,SAAK,OAAO;AAAA,aACH,gBAAgB,IAAI;AAC7B,SAAK;AACL,eAAW,YAAY,GAAG;AACxB,SAAG,YAAY,EAAE;AAAA;AAAA,SAEd;AACL,SAAK;AAAA;AAEP,SAAO;AAAA;AAKF,sBAAmC,KAAsB,WAAgC;AAC9F,SAAO,OAAO,KAAK,KAAK,OAAwB,CAAC,KAAK,QAAQ;AAC5D,QAAI,UAAU,IAAI;AAAO,UAAI,OAAO,IAAI;AACxC,WAAO;AAAA,KACN;AAAA;",
+  "names": []
+}

package/dist/cjs/utils/refs-helpers.js

@@ -0,0 +1,52 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var refs_helpers_exports = {};
+__export(refs_helpers_exports, {
+  setMultipleRefs: () => setMultipleRefs
+});
+var React = __toESM(require("react"));
+const setMultipleRefs = (...refs) => {
+  const filteredRefs = refs.filter(Boolean);
+  if (!filteredRefs.length)
+    return () => {
+    };
+  if (filteredRefs.length === 0)
+    return () => {
+    };
+  return (newRef) => {
+    filteredRefs.forEach((refToBeUpdated) => {
+      if (typeof refToBeUpdated === "function") {
+        refToBeUpdated(newRef);
+      } else if (refToBeUpdated) {
+        refToBeUpdated.current = newRef;
+      }
+    });
+  };
+};
+module.exports = __toCommonJS(refs_helpers_exports);
+//# sourceMappingURL=refs-helpers.js.map

package/dist/cjs/utils/refs-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/refs-helpers.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["// allow multiple refs to be set to point to the same DOM element\ntype GenericMergeableRef = null | undefined | React.MutableRefObject<unknown> | ((ref: HTMLElement) => void) | false;\nexport const setMultipleRefs = (...refs: GenericMergeableRef[]): ((ref: HTMLElement) => void) => {\n  const filteredRefs = refs.filter(Boolean);\n  if (!filteredRefs.length) return () => {};\n  if (filteredRefs.length === 0) return () => {};\n\n  return (newRef) => {\n    filteredRefs.forEach((refToBeUpdated) => {\n      if (typeof refToBeUpdated === 'function') {\n        refToBeUpdated(newRef);\n      } else if (refToBeUpdated) {\n        refToBeUpdated.current = newRef;\n      }\n    });\n  };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEhB,MAAM,kBAAkB,IAAI,SAA8D;AAC/F,QAAM,eAAe,KAAK,OAAO;AACjC,MAAI,CAAC,aAAa;AAAQ,WAAO,MAAM;AAAA;AACvC,MAAI,aAAa,WAAW;AAAG,WAAO,MAAM;AAAA;AAE5C,SAAO,CAAC,WAAW;AACjB,iBAAa,QAAQ,CAAC,mBAAmB;AACvC,UAAI,OAAO,mBAAmB,YAAY;AACxC,uBAAe;AAAA,iBACN,gBAAgB;AACzB,uBAAe,UAAU;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/cjs/utils/selectable-helper.js

@@ -0,0 +1,102 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var selectable_helper_exports = {};
+__export(selectable_helper_exports, {
+  getGroupCheckState: () => getGroupCheckState,
+  selectCheckboxItemModelParentsTillRoot: () => selectCheckboxItemModelParentsTillRoot,
+  toggleCheckboxItem: () => toggleCheckboxItem
+});
+var React = __toESM(require("react"));
+var import_tree_helpers = require("./tree-helpers");
+const getGroupCheckState = (node) => {
+  let childAllChecked = true;
+  let anyChildChecked = false;
+  (0, import_tree_helpers.walkAllNodeChildren)(node, (childNode) => {
+    const {
+      model: { isChecked }
+    } = childNode;
+    if (isChecked === "mixed" || isChecked === true)
+      anyChildChecked = true;
+    else
+      childAllChecked = false;
+  });
+  if (childAllChecked)
+    return true;
+  if (anyChildChecked)
+    return "mixed";
+  return false;
+};
+const selectCheckboxItemModelParentsTillRoot = (modelToCheck, triggerTreeRerender = null) => {
+  const newSelections = {};
+  const { nodePath } = modelToCheck;
+  (0, import_tree_helpers.walkParents)(nodePath, (parentNode) => {
+    const nextState = getGroupCheckState(parentNode);
+    parentNode.model.isChecked = nextState;
+    newSelections[parentNode.model.id] = nextState;
+  });
+  if (triggerTreeRerender)
+    triggerTreeRerender();
+  return newSelections;
+};
+const toggleCheckboxItem = (itemToSelect, triggerTreeRerender = null) => {
+  const {
+    node: {
+      model: { id, isChecked, children = [] }
+    }
+  } = itemToSelect;
+  const newSelections = {};
+  const nextState = isChecked === "mixed" ? true : !isChecked;
+  itemToSelect.node.model.isChecked = nextState;
+  newSelections[id] = nextState;
+  if (children.length > 0 && (nextState === true || nextState === false)) {
+    (0, import_tree_helpers.walkAllNodeChildren)(itemToSelect.node, (childNode) => {
+      childNode.model.isChecked = nextState;
+      newSelections[childNode.model.id] = nextState;
+    });
+  }
+  const parentsNewSelections = selectCheckboxItemModelParentsTillRoot(itemToSelect);
+  if (triggerTreeRerender)
+    triggerTreeRerender();
+  return __spreadValues(__spreadValues({}, parentsNewSelections), newSelections);
+};
+module.exports = __toCommonJS(selectable_helper_exports);
+//# sourceMappingURL=selectable-helper.js.map

package/dist/cjs/utils/selectable-helper.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/utils/selectable-helper.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-params */\nimport { walkParents, walkAllNodeChildren } from './tree-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\n\nexport const getGroupCheckState = (node: DSTreeviewT.Item['node']) => {\n  let childAllChecked = true;\n  let anyChildChecked = false;\n  walkAllNodeChildren(node, (childNode) => {\n    const {\n      model: { isChecked },\n    } = childNode;\n    if (isChecked === 'mixed' || isChecked === true) anyChildChecked = true;\n    else childAllChecked = false;\n  });\n\n  if (childAllChecked) return true;\n  if (anyChildChecked) return 'mixed';\n  return false;\n};\n\nexport const selectCheckboxItemModelParentsTillRoot = (\n  modelToCheck: DSTreeviewT.Item,\n  triggerTreeRerender: (() => void) | null = null,\n) => {\n  const newSelections: DSTreeviewT.SelectionItems = {};\n  const { nodePath } = modelToCheck;\n  walkParents(nodePath, (parentNode) => {\n    const nextState = getGroupCheckState(parentNode);\n    parentNode.model.isChecked = nextState;\n    newSelections[parentNode.model.id] = nextState;\n  });\n  if (triggerTreeRerender) triggerTreeRerender();\n  return newSelections;\n};\n\nexport const toggleCheckboxItem = (itemToSelect: DSTreeviewT.Item, triggerTreeRerender: (() => void) | null = null) => {\n  const {\n    node: {\n      model: { id, isChecked, children = [] },\n    },\n  } = itemToSelect;\n\n  const newSelections: DSTreeviewT.SelectionItems = {};\n  // 'mixed' -> true -> false -> true [...->false -> true]\n  const nextState = isChecked === 'mixed' ? true : !isChecked;\n  itemToSelect.node.model.isChecked = nextState;\n  newSelections[id] = nextState;\n\n  if (children.length > 0 && (nextState === true || nextState === false)) {\n    walkAllNodeChildren(itemToSelect.node, (childNode) => {\n      childNode.model.isChecked = nextState;\n      newSelections[childNode.model.id] = nextState;\n    });\n  }\n\n  const parentsNewSelections = selectCheckboxItemModelParentsTillRoot(itemToSelect);\n\n  if (triggerTreeRerender) triggerTreeRerender();\n  return { ...parentsNewSelections, ...newSelections };\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,0BAAiD;AAG1C,MAAM,qBAAqB,CAAC,SAAmC;AACpE,MAAI,kBAAkB;AACtB,MAAI,kBAAkB;AACtB,+CAAoB,MAAM,CAAC,cAAc;AACvC,UAAM;AAAA,MACJ,OAAO,EAAE;AAAA,QACP;AACJ,QAAI,cAAc,WAAW,cAAc;AAAM,wBAAkB;AAAA;AAC9D,wBAAkB;AAAA;AAGzB,MAAI;AAAiB,WAAO;AAC5B,MAAI;AAAiB,WAAO;AAC5B,SAAO;AAAA;AAGF,MAAM,yCAAyC,CACpD,cACA,sBAA2C,SACxC;AACH,QAAM,gBAA4C;AAClD,QAAM,EAAE,aAAa;AACrB,uCAAY,UAAU,CAAC,eAAe;AACpC,UAAM,YAAY,mBAAmB;AACrC,eAAW,MAAM,YAAY;AAC7B,kBAAc,WAAW,MAAM,MAAM;AAAA;AAEvC,MAAI;AAAqB;AACzB,SAAO;AAAA;AAGF,MAAM,qBAAqB,CAAC,cAAgC,sBAA2C,SAAS;AACrH,QAAM;AAAA,IACJ,MAAM;AAAA,MACJ,OAAO,EAAE,IAAI,WAAW,WAAW;AAAA;AAAA,MAEnC;AAEJ,QAAM,gBAA4C;AAElD,QAAM,YAAY,cAAc,UAAU,OAAO,CAAC;AAClD,eAAa,KAAK,MAAM,YAAY;AACpC,gBAAc,MAAM;AAEpB,MAAI,SAAS,SAAS,KAAM,eAAc,QAAQ,cAAc,QAAQ;AACtE,iDAAoB,aAAa,MAAM,CAAC,cAAc;AACpD,gBAAU,MAAM,YAAY;AAC5B,oBAAc,UAAU,MAAM,MAAM;AAAA;AAAA;AAIxC,QAAM,uBAAuB,uCAAuC;AAEpE,MAAI;AAAqB;AACzB,SAAO,kCAAK,uBAAyB;AAAA;",
+  "names": []
+}

package/dist/cjs/utils/string-helpers.js

@@ -0,0 +1,35 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toESM = (module2, isNodeMode) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var string_helpers_exports = {};
+__export(string_helpers_exports, {
+  standardizeSearchQueryString: () => standardizeSearchQueryString
+});
+var React = __toESM(require("react"));
+const standardizeSearchQueryString = (input) => input.trim().toLowerCase();
+module.exports = __toCommonJS(string_helpers_exports);
+//# sourceMappingURL=string-helpers.js.map