@elliemae/ds-treeview 2.3.0-next.3 → 3.0.0-alpha.0

package/dist/cjs/TreeView.js

@@ -0,0 +1,50 @@
+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 TreeView_exports = {};
+__export(TreeView_exports, {
+  TreeView: () => TreeView,
+  TreeViewWithSchema: () => TreeViewWithSchema
+});
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_react_desc = require("react-desc");
+var import_react_desc_prop_types = require("./react-desc-prop-types");
+var import_TreeViewContext = __toESM(require("./TreeViewContext"));
+var import_useTreeview = require("./config/useTreeview");
+var import_TreeList = require("./parts/TreeList");
+function TreeView(props) {
+  const { ctx } = (0, import_useTreeview.useTreeview)(props);
+  return /* @__PURE__ */ import_react.default.createElement(import_TreeViewContext.default.Provider, {
+    value: ctx
+  }, /* @__PURE__ */ import_react.default.createElement(import_TreeList.TreeList, null));
+}
+TreeView.propTypes = import_react_desc_prop_types.TreeViewPropTypes;
+const TreeViewWithSchema = (0, import_react_desc.describe)(TreeView);
+TreeViewWithSchema.propTypes = import_react_desc_prop_types.TreeViewPropTypes;
+module.exports = __toCommonJS(TreeView_exports);
+//# sourceMappingURL=TreeView.js.map

package/dist/cjs/TreeView.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/TreeView.tsx", "../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import React, { WeakValidationMap } from 'react';\n\nimport { describe } from 'react-desc';\nimport { TreeViewPropTypes } from './react-desc-prop-types';\nimport TreeViewContext from './TreeViewContext';\nimport { useTreeview } from './config/useTreeview';\nimport { TreeList } from './parts/TreeList';\nimport type { DSTreeviewT } from './react-desc-prop-types';\nexport function TreeView(props: DSTreeviewT.Props) {\n  const { ctx } = useTreeview(props);\n\n  return (\n    <TreeViewContext.Provider value={ctx}>\n      <TreeList />\n    </TreeViewContext.Provider>\n  );\n}\n\nTreeView.propTypes = TreeViewPropTypes as WeakValidationMap<unknown>;\nconst TreeViewWithSchema = describe(TreeView);\nTreeViewWithSchema.propTypes = TreeViewPropTypes;\n\nexport { TreeViewWithSchema };\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAAyC;AAEzC,wBAAyB;AACzB,mCAAkC;AAClC,6BAA4B;AAC5B,yBAA4B;AAC5B,sBAAyB;AAElB,kBAAkB,OAA0B;AACjD,QAAM,EAAE,QAAQ,oCAAY;AAE5B,SACE,mDAAC,+BAAgB,UAAjB;AAAA,IAA0B,OAAO;AAAA,KAC/B,mDAAC,0BAAD;AAAA;AAKN,SAAS,YAAY;AACrB,MAAM,qBAAqB,gCAAS;AACpC,mBAAmB,YAAY;",
+  "names": []
+}

package/dist/cjs/TreeViewContext.js

@@ -0,0 +1,116 @@
+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 TreeViewContext_exports = {};
+__export(TreeViewContext_exports, {
+  default: () => TreeViewContext_default,
+  defaultProps: () => defaultProps,
+  defaultRelativeMouseCoord: () => defaultRelativeMouseCoord
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+function noop(..._args) {
+}
+const defaultProps = {
+  plugins: [],
+  selection: {},
+  instanceRef: (0, import_react.createRef)(),
+  isItemDisabled: () => false,
+  disableIcons: false,
+  fluid: false,
+  isMultiSelect: false,
+  isSingleSelect: false,
+  getIsDropValid: () => true,
+  restrictDragAndDrop: false,
+  showChildrenAmount: false,
+  sortable: false,
+  isLoading: false,
+  highlightOnlyQuery: false,
+  onItemClick: noop,
+  onItemFocus: noop,
+  onVisibleItemsChange: noop,
+  onOrderChange: noop,
+  onSelectionChange: noop,
+  onExpandChange: noop,
+  onInstanceRefInitialized: noop,
+  rowSize: "normal",
+  labelOverflow: "wrap",
+  noItemsPlaceholder: "No items found",
+  nameKey: "name",
+  width: "100%",
+  height: "100%",
+  groupIcon: null,
+  itemIcon: null,
+  searchQuery: ""
+};
+const defaultRelativeMouseCoord = {
+  isBefore: false,
+  isAfter: false,
+  isValid: true,
+  item: null,
+  x: null,
+  y: null,
+  relativeElementDOMRect: null,
+  relativeElementIndex: null
+};
+const defaultContext = {
+  props: defaultProps,
+  visibleItems: [],
+  flattenedItems: [],
+  withRadioChecks: false,
+  withCheckboxChecks: false,
+  withDragAndDrop: false,
+  triggerTreeRerender: noop,
+  tree: void 0,
+  treeRoot: void 0,
+  virtualListHelpers: {
+    virtualItems: [],
+    totalSize: 0,
+    scrollToOffset: noop,
+    scrollToIndex: noop
+  },
+  virtualListRef: void 0,
+  uniqueTreeViewUUID: "",
+  selectedItem: null,
+  setSelectedItem: noop,
+  focusedItem: null,
+  setFocusedItem: noop,
+  selectedCheckboxes: {},
+  setSelectedCheckboxes: noop,
+  expandedGroups: {},
+  setExpandedGroups: noop,
+  latestToggledItem: null,
+  setLatestToggledItem: noop,
+  hoverItem: null,
+  setHoverItem: noop,
+  handleExpandGroup: noop,
+  updateUserExpandedState: noop
+};
+const TreeViewContext = (0, import_react.createContext)(defaultContext);
+var TreeViewContext_default = TreeViewContext;
+module.exports = __toCommonJS(TreeViewContext_exports);
+//# sourceMappingURL=TreeViewContext.js.map

package/dist/cjs/TreeViewContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/TreeViewContext.tsx", "../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable no-unused-vars */\nimport { createContext, createRef } from 'react';\nimport type { DSTreeviewT } from './react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from './sharedTypes';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction noop<T extends unknown[]>(..._args: T): void {}\n\nexport const defaultProps = {\n  plugins: [],\n  selection: {},\n  instanceRef: createRef(),\n  isItemDisabled: () => false,\n  disableIcons: false,\n  fluid: false,\n  isMultiSelect: false,\n  isSingleSelect: false,\n  getIsDropValid: () => true,\n  restrictDragAndDrop: false,\n  showChildrenAmount: false,\n  sortable: false,\n  isLoading: false,\n  highlightOnlyQuery: false,\n  onItemClick: noop,\n  onItemFocus: noop,\n  onVisibleItemsChange: noop,\n  onOrderChange: noop,\n  onSelectionChange: noop,\n  onExpandChange: noop,\n  onInstanceRefInitialized: noop,\n  rowSize: 'normal',\n  labelOverflow: 'wrap',\n  noItemsPlaceholder: 'No items found',\n  nameKey: 'name',\n  width: '100%',\n  height: '100%',\n  groupIcon: null,\n  itemIcon: null,\n  searchQuery: '',\n  // workaround on the typings over the fact that\n  // when we instantiate the context we can't have all the props\n  // we only have a part of them but the final typings will include missing props\n  // this is safe to do because\n  // we will \"mergeWithDefaults\" + \"validatePropTypes\" when we do instantiate the context\n} as unknown as DSTreeviewT.Props;\n\nexport const defaultRelativeMouseCoord = {\n  isBefore: false,\n  isAfter: false,\n  isValid: true,\n  item: null,\n  x: null,\n  y: null,\n  relativeElementDOMRect: null,\n  relativeElementIndex: null,\n};\n\nconst defaultContext: DSTreeviewInternalsT.CTX = {\n  props: defaultProps,\n  visibleItems: [],\n  flattenedItems: [],\n  withRadioChecks: false,\n  withCheckboxChecks: false,\n  withDragAndDrop: false,\n  triggerTreeRerender: noop,\n  tree: undefined,\n  treeRoot: undefined,\n  virtualListHelpers: {\n    virtualItems: [],\n    totalSize: 0,\n    scrollToOffset: noop,\n    scrollToIndex: noop,\n  },\n  virtualListRef: undefined,\n  uniqueTreeViewUUID: '',\n  selectedItem: null,\n  setSelectedItem: noop,\n  focusedItem: null,\n  setFocusedItem: noop,\n  selectedCheckboxes: {},\n  setSelectedCheckboxes: noop,\n  expandedGroups: {},\n  setExpandedGroups: noop,\n  latestToggledItem: null,\n  setLatestToggledItem: noop,\n  hoverItem: null,\n  setHoverItem: noop,\n  handleExpandGroup: noop,\n  updateUserExpandedState: noop,\n};\n\n/** Context for cross component communication */\nconst TreeViewContext = createContext(defaultContext);\n\nexport default TreeViewContext;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAAyC;AAKzC,iBAAsC,OAAgB;AAAA;AAE/C,MAAM,eAAe;AAAA,EAC1B,SAAS;AAAA,EACT,WAAW;AAAA,EACX,aAAa;AAAA,EACb,gBAAgB,MAAM;AAAA,EACtB,cAAc;AAAA,EACd,OAAO;AAAA,EACP,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,gBAAgB,MAAM;AAAA,EACtB,qBAAqB;AAAA,EACrB,oBAAoB;AAAA,EACpB,UAAU;AAAA,EACV,WAAW;AAAA,EACX,oBAAoB;AAAA,EACpB,aAAa;AAAA,EACb,aAAa;AAAA,EACb,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,mBAAmB;AAAA,EACnB,gBAAgB;AAAA,EAChB,0BAA0B;AAAA,EAC1B,SAAS;AAAA,EACT,eAAe;AAAA,EACf,oBAAoB;AAAA,EACpB,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,WAAW;AAAA,EACX,UAAU;AAAA,EACV,aAAa;AAAA;AAQR,MAAM,4BAA4B;AAAA,EACvC,UAAU;AAAA,EACV,SAAS;AAAA,EACT,SAAS;AAAA,EACT,MAAM;AAAA,EACN,GAAG;AAAA,EACH,GAAG;AAAA,EACH,wBAAwB;AAAA,EACxB,sBAAsB;AAAA;AAGxB,MAAM,iBAA2C;AAAA,EAC/C,OAAO;AAAA,EACP,cAAc;AAAA,EACd,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,iBAAiB;AAAA,EACjB,qBAAqB;AAAA,EACrB,MAAM;AAAA,EACN,UAAU;AAAA,EACV,oBAAoB;AAAA,IAClB,cAAc;AAAA,IACd,WAAW;AAAA,IACX,gBAAgB;AAAA,IAChB,eAAe;AAAA;AAAA,EAEjB,gBAAgB;AAAA,EAChB,oBAAoB;AAAA,EACpB,cAAc;AAAA,EACd,iBAAiB;AAAA,EACjB,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,oBAAoB;AAAA,EACpB,uBAAuB;AAAA,EACvB,gBAAgB;AAAA,EAChB,mBAAmB;AAAA,EACnB,mBAAmB;AAAA,EACnB,sBAAsB;AAAA,EACtB,WAAW;AAAA,EACX,cAAc;AAAA,EACd,mBAAmB;AAAA,EACnB,yBAAyB;AAAA;AAI3B,MAAM,kBAAkB,gCAAc;AAEtC,IAAO,0BAAQ;",
+  "names": []
+}

package/dist/cjs/config/cssClassesConstants.js

@@ -0,0 +1,41 @@
+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 cssClassesConstants_exports = {};
+__export(cssClassesConstants_exports, {
+  DSTreeViewPrefix: () => DSTreeViewPrefix,
+  treeItemBlockName: () => treeItemBlockName,
+  treeListBlockName: () => treeListBlockName,
+  treeListNoItemsBn: () => treeListNoItemsBn
+});
+var React = __toESM(require("react"));
+const DSTreeViewPrefix = "em-ds";
+const treeItemBlockName = "tree-item";
+const treeListBlockName = "tree-list";
+const treeListNoItemsBn = `${treeListBlockName}-no-items`;
+module.exports = __toCommonJS(cssClassesConstants_exports);
+//# sourceMappingURL=cssClassesConstants.js.map

package/dist/cjs/config/cssClassesConstants.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/cssClassesConstants.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["export const DSTreeViewPrefix = 'em-ds';\nexport const treeItemBlockName = 'tree-item';\nexport const treeListBlockName = 'tree-list';\nexport const treeListNoItemsBn = `${treeListBlockName}-no-items`;\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAhB,MAAM,mBAAmB;AACzB,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB;AAC1B,MAAM,oBAAoB,GAAG;",
+  "names": []
+}

package/dist/cjs/config/useTreeview.js

@@ -0,0 +1,151 @@
+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 useTreeview_exports = {};
+__export(useTreeview_exports, {
+  useTreeview: () => useTreeview
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_react_virtual = require("react-virtual");
+var import_ds_props_helpers = require("@elliemae/ds-props-helpers");
+var import_uuid = require("uuid");
+var import_react_desc_prop_types = require("../react-desc-prop-types");
+var import_TreeViewContext = require("../TreeViewContext");
+var import_dnd = require("../plugins/dnd");
+var import_useTree = require("../utils/useTree");
+var import_group_expands_helpers = require("../utils/group-expands-helpers");
+var import_useInstanceRefActions = require("../utils/useInstanceRefActions");
+var import_keyboard_helpers = require("../utils/keyboard-helpers");
+const useTreeview = (props) => {
+  const propsWithDefault = (0, import_ds_props_helpers.useMemoMergePropsWithDefault)(props, import_TreeViewContext.defaultProps);
+  (0, import_ds_props_helpers.useValidateTypescriptPropTypes)(propsWithDefault, import_react_desc_prop_types.TreeViewPropTypes);
+  const defaultActions = {
+    actions: {
+      toggleExpandAll: () => {
+      },
+      scrollTo: () => {
+      },
+      setSelectedItemByVirtualIndex: () => {
+      },
+      setFocusedItemByVirtualIndex: () => {
+      }
+    }
+  };
+  const treeRef = (0, import_react.useRef)(defaultActions);
+  const {
+    data,
+    plugins,
+    onOrderChange,
+    isMultiSelect,
+    isSingleSelect,
+    instanceRef,
+    selection,
+    onInstanceRefInitialized
+  } = propsWithDefault;
+  const [uniqueTreeViewUUID] = (0, import_react.useState)((0, import_uuid.v4)());
+  const [hoverItem, setHoverItem] = (0, import_react.useState)(null);
+  const [latestToggledItem, setLatestToggledItem] = (0, import_react.useState)(null);
+  const [selectedItem, setSelectedItem] = (0, import_react.useState)(null);
+  const [focusedItem, setFocusedItem] = (0, import_react.useState)(null);
+  const [selectedCheckboxes, setSelectedCheckboxes] = (0, import_react.useState)({
+    ...selection
+  });
+  const [expandedGroups, setExpandedGroups] = (0, import_react.useState)({});
+  const { visibleItems, flattenedItems, tree, treeRoot, triggerTreeRerender, updateUserExpandedState } = (0, import_useTree.useTree)(data, propsWithDefault, {
+    setExpandedGroups
+  });
+  const virtualListRef = (0, import_react.useRef)();
+  const virtualListHelpers = (0, import_react_virtual.useVirtual)({
+    size: visibleItems.length,
+    parentRef: virtualListRef,
+    overscan: 15
+  });
+  const withDragAndDrop = !!(plugins?.includes(import_dnd.TreeDndPlugin) && onOrderChange);
+  const withRadioChecks = isSingleSelect && !isMultiSelect;
+  const withCheckboxChecks = !isSingleSelect && isMultiSelect;
+  const handleExpandGroup = (0, import_react.useCallback)(import_group_expands_helpers.toggleItemExpand, []);
+  const ctx = (0, import_react.useMemo)(() => ({
+    props: propsWithDefault,
+    virtualListHelpers,
+    virtualListRef,
+    tree,
+    treeRoot,
+    visibleItems,
+    flattenedItems,
+    triggerTreeRerender,
+    withRadioChecks,
+    withCheckboxChecks,
+    withDragAndDrop,
+    uniqueTreeViewUUID,
+    selectedCheckboxes,
+    setSelectedCheckboxes,
+    selectedItem,
+    setSelectedItem,
+    expandedGroups,
+    setExpandedGroups,
+    latestToggledItem,
+    setLatestToggledItem,
+    focusedItem,
+    setFocusedItem,
+    hoverItem,
+    setHoverItem,
+    handleExpandGroup,
+    updateUserExpandedState
+  }), [
+    propsWithDefault,
+    virtualListHelpers,
+    tree,
+    treeRoot,
+    visibleItems,
+    flattenedItems,
+    triggerTreeRerender,
+    withRadioChecks,
+    withCheckboxChecks,
+    withDragAndDrop,
+    uniqueTreeViewUUID,
+    selectedCheckboxes,
+    selectedItem,
+    expandedGroups,
+    latestToggledItem,
+    focusedItem,
+    hoverItem,
+    handleExpandGroup,
+    updateUserExpandedState
+  ]);
+  if (instanceRef)
+    instanceRef.current = treeRef.current;
+  (0, import_useInstanceRefActions.useInstanceRefActions)(treeRef.current, ctx);
+  (0, import_keyboard_helpers.useGlobalToggleAllExpandShortcut)(treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);
+  (0, import_group_expands_helpers.useNotifyExpandedChange)(propsWithDefault, ctx);
+  (0, import_react.useEffect)(() => {
+    setTimeout(() => onInstanceRefInitialized(treeRef), 100);
+  }, []);
+  return (0, import_react.useMemo)(() => ({ ctx }), [ctx]);
+};
+module.exports = __toCommonJS(useTreeview_exports);
+//# sourceMappingURL=useTreeview.js.map

package/dist/cjs/config/useTreeview.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/config/useTreeview.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["/* eslint-disable max-lines */\n/* eslint-disable max-statements */\nimport { useState, useRef, useEffect, useMemo, useCallback } from 'react';\nimport { useVirtual } from 'react-virtual';\nimport { useMemoMergePropsWithDefault, useValidateTypescriptPropTypes } from '@elliemae/ds-props-helpers';\nimport { v4 as uuidv4 } from 'uuid';\n\nimport { TreeViewPropTypes } from '../react-desc-prop-types';\nimport { defaultProps } from '../TreeViewContext';\nimport { TreeDndPlugin } from '../plugins/dnd';\nimport { useTree } from '../utils/useTree';\nimport { useNotifyExpandedChange, toggleItemExpand } from '../utils/group-expands-helpers';\nimport { useInstanceRefActions } from '../utils/useInstanceRefActions';\nimport { useGlobalToggleAllExpandShortcut } from '../utils/keyboard-helpers';\nimport type { DSTreeviewT } from '../react-desc-prop-types';\nimport type { DSTreeviewInternalsT } from '../sharedTypes';\n\ntype UseTreeviewT = (props: DSTreeviewT.Props) => { ctx: DSTreeviewInternalsT.CTX };\n\nexport const useTreeview: UseTreeviewT = (props) => {\n  const propsWithDefault = useMemoMergePropsWithDefault<DSTreeviewT.Props>(props, defaultProps);\n  useValidateTypescriptPropTypes<DSTreeviewT.Props>(propsWithDefault, TreeViewPropTypes);\n  const defaultActions = {\n    actions: {\n      toggleExpandAll: () => {},\n      scrollTo: () => {},\n      setSelectedItemByVirtualIndex: () => {},\n      setFocusedItemByVirtualIndex: () => {},\n    },\n  } as unknown as DSTreeviewT.InstanceRef;\n  const treeRef = useRef(defaultActions);\n  const {\n    data,\n    plugins,\n    onOrderChange,\n    isMultiSelect,\n    isSingleSelect,\n    instanceRef,\n    selection,\n    onInstanceRefInitialized,\n  } = propsWithDefault;\n  const [uniqueTreeViewUUID] = useState(uuidv4());\n  const [hoverItem, setHoverItem] = useState<DSTreeviewT.Item | null>(null);\n  const [latestToggledItem, setLatestToggledItem] = useState<DSTreeviewT.Item | null>(null);\n  const [selectedItem, setSelectedItem] = useState<DSTreeviewT.Item | null>(null);\n  const [focusedItem, setFocusedItem] = useState<DSTreeviewT.Item | null>(null);\n  const [selectedCheckboxes, setSelectedCheckboxes] = useState({\n    ...selection,\n  });\n  const [expandedGroups, setExpandedGroups] = useState<DSTreeviewT.ExpandedItems>({});\n  const { visibleItems, flattenedItems, tree, treeRoot, triggerTreeRerender, updateUserExpandedState } = useTree(\n    data,\n    propsWithDefault,\n    {\n      setExpandedGroups,\n    },\n  );\n\n  const virtualListRef = useRef<HTMLUListElement>();\n  // estimateSize should not be really required given what was stated on\n  // https://github.com/tannerlinsley/react-virtual/issues/23\n\n  const virtualListHelpers = useVirtual({\n    size: visibleItems.length,\n    parentRef: virtualListRef,\n    overscan: 15,\n  });\n\n  const withDragAndDrop = !!(plugins?.includes(TreeDndPlugin) && onOrderChange);\n  const withRadioChecks = isSingleSelect && !isMultiSelect;\n  const withCheckboxChecks = !isSingleSelect && isMultiSelect;\n\n  const handleExpandGroup = useCallback(toggleItemExpand, []);\n\n  const ctx: DSTreeviewInternalsT.CTX = useMemo(\n    () => ({\n      props: propsWithDefault,\n      virtualListHelpers,\n      virtualListRef,\n      tree,\n      treeRoot,\n      visibleItems,\n      flattenedItems,\n      triggerTreeRerender,\n      withRadioChecks,\n      withCheckboxChecks,\n      withDragAndDrop,\n      uniqueTreeViewUUID,\n      selectedCheckboxes,\n      setSelectedCheckboxes,\n      selectedItem,\n      setSelectedItem,\n      expandedGroups,\n      setExpandedGroups,\n      latestToggledItem,\n      setLatestToggledItem,\n      focusedItem,\n      setFocusedItem,\n      hoverItem,\n      setHoverItem,\n      handleExpandGroup,\n      updateUserExpandedState,\n    }),\n    [\n      propsWithDefault,\n      virtualListHelpers,\n      tree,\n      treeRoot,\n      visibleItems,\n      flattenedItems,\n      triggerTreeRerender,\n      withRadioChecks,\n      withCheckboxChecks,\n      withDragAndDrop,\n      uniqueTreeViewUUID,\n      selectedCheckboxes,\n      selectedItem,\n      expandedGroups,\n      latestToggledItem,\n      focusedItem,\n      hoverItem,\n      handleExpandGroup,\n      updateUserExpandedState,\n    ],\n  );\n  // this hooks can't use the context because the context provider doesn't wrap this\n  // as such we manually pass the second parameter as fit\n  if (instanceRef) instanceRef.current = treeRef.current;\n  useInstanceRefActions(treeRef.current, ctx);\n  useGlobalToggleAllExpandShortcut(treeRoot, triggerTreeRerender, setLatestToggledItem, updateUserExpandedState);\n  useNotifyExpandedChange(propsWithDefault, ctx);\n\n  // this is an horrible hack.\n  // this is required because there is no \"on rendered\" react-way to check if every children has finished rendering\n  // this should be working for now, in the future we may want to review this for a better solution\n  useEffect(() => {\n    setTimeout(() => onInstanceRefInitialized(treeRef), 100);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return useMemo(() => ({ ctx }), [ctx]);\n};\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADEvB,mBAAkE;AAClE,2BAA2B;AAC3B,8BAA6E;AAC7E,kBAA6B;AAE7B,mCAAkC;AAClC,6BAA6B;AAC7B,iBAA8B;AAC9B,qBAAwB;AACxB,mCAA0D;AAC1D,mCAAsC;AACtC,8BAAiD;AAM1C,MAAM,cAA4B,CAAC,UAAU;AAClD,QAAM,mBAAmB,0DAAgD,OAAO;AAChF,8DAAkD,kBAAkB;AACpE,QAAM,iBAAiB;AAAA,IACrB,SAAS;AAAA,MACP,iBAAiB,MAAM;AAAA;AAAA,MACvB,UAAU,MAAM;AAAA;AAAA,MAChB,+BAA+B,MAAM;AAAA;AAAA,MACrC,8BAA8B,MAAM;AAAA;AAAA;AAAA;AAGxC,QAAM,UAAU,yBAAO;AACvB,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,MACE;AACJ,QAAM,CAAC,sBAAsB,2BAAS;AACtC,QAAM,CAAC,WAAW,gBAAgB,2BAAkC;AACpE,QAAM,CAAC,mBAAmB,wBAAwB,2BAAkC;AACpF,QAAM,CAAC,cAAc,mBAAmB,2BAAkC;AAC1E,QAAM,CAAC,aAAa,kBAAkB,2BAAkC;AACxE,QAAM,CAAC,oBAAoB,yBAAyB,2BAAS;AAAA,OACxD;AAAA;AAEL,QAAM,CAAC,gBAAgB,qBAAqB,2BAAoC;AAChF,QAAM,EAAE,cAAc,gBAAgB,MAAM,UAAU,qBAAqB,4BAA4B,4BACrG,MACA,kBACA;AAAA,IACE;AAAA;AAIJ,QAAM,iBAAiB;AAIvB,QAAM,qBAAqB,qCAAW;AAAA,IACpC,MAAM,aAAa;AAAA,IACnB,WAAW;AAAA,IACX,UAAU;AAAA;AAGZ,QAAM,kBAAkB,CAAC,CAAE,UAAS,SAAS,6BAAkB;AAC/D,QAAM,kBAAkB,kBAAkB,CAAC;AAC3C,QAAM,qBAAqB,CAAC,kBAAkB;AAE9C,QAAM,oBAAoB,8BAAY,+CAAkB;AAExD,QAAM,MAAgC,0BACpC,MAAO;AAAA,IACL,OAAO;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,MAEF;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAKJ,MAAI;AAAa,gBAAY,UAAU,QAAQ;AAC/C,0DAAsB,QAAQ,SAAS;AACvC,gEAAiC,UAAU,qBAAqB,sBAAsB;AACtF,4DAAwB,kBAAkB;AAK1C,8BAAU,MAAM;AACd,eAAW,MAAM,yBAAyB,UAAU;AAAA,KAEnD;AAEH,SAAO,0BAAQ,MAAO,GAAE,QAAQ,CAAC;AAAA;",
+  "names": []
+}

package/dist/cjs/hoc/DnDTreeContext.js

@@ -0,0 +1,45 @@
+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 DnDTreeContext_exports = {};
+__export(DnDTreeContext_exports, {
+  DnDTreeContext: () => DnDTreeContext
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var import_SortableItemContext = require("./SortableItemContext");
+const DnDTreeContext = (0, import_react.createContext)({
+  depth: void 0,
+  activeIndex: void 0,
+  visibleItems: void 0,
+  dropIndicatorPosition: import_SortableItemContext.DropIndicatorPosition.None,
+  lastActiveId: void 0,
+  setLastActiveId: void 0,
+  isDropValid: false
+});
+module.exports = __toCommonJS(DnDTreeContext_exports);
+//# sourceMappingURL=DnDTreeContext.js.map

package/dist/cjs/hoc/DnDTreeContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/DnDTreeContext.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { createContext } from 'react';\nimport { DSTreeviewT } from '../react-desc-prop-types';\nimport { DropIndicatorPosition } from './SortableItemContext';\n\ntype DnDTreeContextType = {\n  depth: number | undefined;\n  activeIndex: number | undefined;\n  visibleItems: DSTreeviewT.Item[] | undefined;\n  dropIndicatorPosition: DropIndicatorPosition;\n  lastActiveId: string | undefined;\n  setLastActiveId: React.Dispatch<React.SetStateAction<string>> | undefined;\n  isDropValid: boolean;\n};\n\nexport const DnDTreeContext = createContext<DnDTreeContextType>({\n  depth: undefined,\n  activeIndex: undefined,\n  visibleItems: undefined,\n  dropIndicatorPosition: DropIndicatorPosition.None,\n  lastActiveId: undefined,\n  setLastActiveId: undefined,\n  isDropValid: false,\n});\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADAvB,mBAA8B;AAE9B,iCAAsC;AAY/B,MAAM,iBAAiB,gCAAkC;AAAA,EAC9D,OAAO;AAAA,EACP,aAAa;AAAA,EACb,cAAc;AAAA,EACd,uBAAuB,iDAAsB;AAAA,EAC7C,cAAc;AAAA,EACd,iBAAiB;AAAA,EACjB,aAAa;AAAA;",
+  "names": []
+}

package/dist/cjs/hoc/SortableItemContext.js

@@ -0,0 +1,46 @@
+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 SortableItemContext_exports = {};
+__export(SortableItemContext_exports, {
+  DropIndicatorPosition: () => DropIndicatorPosition,
+  SortableItemContext: () => SortableItemContext
+});
+var React = __toESM(require("react"));
+var import_react = require("react");
+var DropIndicatorPosition = /* @__PURE__ */ ((DropIndicatorPosition2) => {
+  DropIndicatorPosition2[DropIndicatorPosition2["None"] = 0] = "None";
+  DropIndicatorPosition2[DropIndicatorPosition2["Before"] = 1] = "Before";
+  DropIndicatorPosition2[DropIndicatorPosition2["After"] = 2] = "After";
+  DropIndicatorPosition2[DropIndicatorPosition2["Inside"] = 3] = "Inside";
+  return DropIndicatorPosition2;
+})(DropIndicatorPosition || {});
+const SortableItemContext = (0, import_react.createContext)({
+  draggableProps: false
+});
+module.exports = __toCommonJS(SortableItemContext_exports);
+//# sourceMappingURL=SortableItemContext.js.map

package/dist/cjs/hoc/SortableItemContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/hoc/SortableItemContext.tsx", "../../../../../scripts/build/transpile/react-shim.js"],
+  "sourcesContent": ["import { useSortable } from '@dnd-kit/sortable';\nimport { createContext } from 'react';\n\nexport enum DropIndicatorPosition {\n  None = 0,\n  Before = 1,\n  After = 2,\n  Inside = 3,\n}\n\nexport type SortableItemContextType = {\n  draggableProps:\n    | false\n    | (ReturnType<typeof useSortable> & {\n        dropIndicatorPosition: DropIndicatorPosition;\n        shouldShowDropIndicatorPosition: boolean;\n        lastActiveId?: string;\n        setLastActiveId?: React.Dispatch<React.SetStateAction<string>>;\n        isDropValid: boolean;\n      });\n};\n\n/** Context for cross component communication */\nexport const SortableItemContext = createContext<SortableItemContextType>({\n  draggableProps: false,\n});\n", "import * as React from 'react';\nexport { React };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;ACAA,YAAuB;ADCvB,mBAA8B;AAEvB,IAAK,wBAAL,kBAAK,2BAAL;AACL,0DAAO,KAAP;AACA,4DAAS,KAAT;AACA,2DAAQ,KAAR;AACA,4DAAS,KAAT;AAJU;AAAA;AAoBL,MAAM,sBAAsB,gCAAuC;AAAA,EACxE,gBAAgB;AAAA;",
+  "names": []
+}

package/dist/cjs/hoc/WithConditionalDnDContext.js

@@ -0,0 +1,128 @@
+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 WithConditionalDnDContext_exports = {};
+__export(WithConditionalDnDContext_exports, {
+  withConditionalDnDRowContext: () => withConditionalDnDRowContext
+});
+var React = __toESM(require("react"));
+var import_react = __toESM(require("react"));
+var import_core = require("@dnd-kit/core");
+var import_sortable = require("@dnd-kit/sortable");
+var import_ds_drag_and_drop = require("@elliemae/ds-drag-and-drop");
+var import_TreeViewContext = __toESM(require("../TreeViewContext"));
+var import_TreeItem = require("../parts/TreeItem");
+var import_DnDTreeContext = require("./DnDTreeContext");
+const ensure = (argument, message = "This should never happen") => {
+  if (argument === void 0 || argument === null) {
+    throw new TypeError(message);
+  }
+  return argument;
+};
+const withConditionalDnDRowContext = (Component) => (props) => {
+  const [lastActiveId, setLastActiveId] = import_react.default.useState("");
+  const {
+    props: { data, onOrderChange, getIsDropValid },
+    flattenedItems,
+    visibleItems: flattenedVisibleTree,
+    withDragAndDrop
+  } = (0, import_react.useContext)(import_TreeViewContext.default);
+  const flattenedVisibleTreeForDnD = (0, import_react.useMemo)(() => flattenedVisibleTree.map((item, index) => ({
+    uid: item.id.toString(),
+    depth: (item.treeDepth ?? 1) - 1,
+    realIndex: index,
+    childrenCount: item.children?.length ?? 0,
+    parentId: item.node.parent?.model?.id?.toString() ?? null,
+    original: item
+  })), [flattenedVisibleTree]);
+  const onReorder = (0, import_react.useCallback)((tree, indexes) => {
+    const nodes = {};
+    tree.forEach((item) => {
+      const originalItem = item.original;
+      originalItem.children = [];
+      nodes[item.uid] = item.original;
+    });
+    const newUserTree = [];
+    tree.forEach((item) => {
+      if (item.parentId !== null && item.parentId !== void 0 && item.parentId !== "__ds_tree_root") {
+        const parentNode = nodes[item.parentId];
+        parentNode.children?.push(item.original);
+      } else if (item.uid !== "__ds_tree_root")
+        newUserTree.push(item.original);
+    });
+    onOrderChange(newUserTree, data, flattenedItems[indexes.fromIndex]);
+  }, [onOrderChange, data, flattenedItems]);
+  const {
+    dndContextProps,
+    sortableContextProps,
+    activeId,
+    activeIndex,
+    depth,
+    dropIndicatorPosition,
+    visibleItems,
+    isDropValid
+  } = (0, import_ds_drag_and_drop.useTreeDndkitConfig)({
+    flattenedItems,
+    visibleItems: flattenedVisibleTreeForDnD,
+    isHorizontalDnD: false,
+    isExpandable: true,
+    onReorder,
+    getIsDropValid,
+    maxDragAndDropLevel: Infinity
+  });
+  if (lastActiveId !== activeId && activeId)
+    setLastActiveId(activeId);
+  if (withDragAndDrop)
+    return /* @__PURE__ */ import_react.default.createElement(import_core.DndContext, {
+      ...dndContextProps
+    }, /* @__PURE__ */ import_react.default.createElement(import_sortable.SortableContext, {
+      ...sortableContextProps
+    }, /* @__PURE__ */ import_react.default.createElement(import_DnDTreeContext.DnDTreeContext.Provider, {
+      value: {
+        activeIndex,
+        depth,
+        visibleItems: visibleItems.map((item) => item.original),
+        dropIndicatorPosition,
+        lastActiveId,
+        setLastActiveId,
+        isDropValid
+      }
+    }, /* @__PURE__ */ import_react.default.createElement(Component, {
+      ...props
+    }))), /* @__PURE__ */ import_react.default.createElement(import_core.DragOverlay, {
+      style: { width: "auto" }
+    }, activeId ? /* @__PURE__ */ import_react.default.createElement(import_TreeItem.TreeItem, {
+      itemIndex: activeIndex,
+      item: ensure(flattenedVisibleTree.find((item) => item.id.toString() === activeId)),
+      isDragOverlay: true
+    }) : null));
+  return /* @__PURE__ */ import_react.default.createElement(Component, {
+    ...props
+  });
+};
+module.exports = __toCommonJS(WithConditionalDnDContext_exports);
+//# sourceMappingURL=WithConditionalDnDContext.js.map