@reltio/components 1.4.876 → 1.4.880

package/components/ReactSortableTree/react-sortable-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 var __extends = (this && this.__extends) || (function () {
     var extendStatics = function (d, b) {
         extendStatics = Object.setPrototypeOf ||
@@ -25,60 +24,36 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SortableTreeWithoutDndContext = void 0;
-var react_1 = __importStar(require("react"));
-var prop_types_1 = __importDefault(require("prop-types"));
-var react_virtualized_1 = require("react-virtualized");
-var ramda_1 = require("ramda");
-var frontend_collective_react_dnd_scrollzone_1 = __importStar(require("frontend-collective-react-dnd-scrollzone"));
-var react_dnd_1 = require("react-dnd");
-var react_dnd_html5_backend_1 = __importDefault(require("react-dnd-html5-backend"));
-var react_lifecycles_compat_1 = require("react-lifecycles-compat");
-var styles_1 = require("@material-ui/core/styles");
-var tree_node_1 = __importDefault(require("./tree-node"));
-var node_renderer_default_1 = __importDefault(require("./node-renderer-default"));
-var tree_placeholder_1 = __importDefault(require("./tree-placeholder"));
-var placeholder_renderer_default_1 = __importDefault(require("./placeholder-renderer-default"));
-var tree_data_utils_1 = require("./utils/tree-data-utils");
-var memoized_tree_data_utils_1 = require("./utils/memoized-tree-data-utils");
-var generic_utils_1 = require("./utils/generic-utils");
-var default_handlers_1 = require("./utils/default-handlers");
-var dnd_manager_1 = __importDefault(require("./utils/dnd-manager"));
-var classnames_1 = __importDefault(require("./utils/classnames"));
-var reactSortableTreeStyles_1 = require("./reactSortableTreeStyles");
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { AutoSizer, List } from 'react-virtualized';
+import { equals, append, when, always, gt, uniqWith, eqBy, pipe } from 'ramda';
+import withScrolling, { createScrollingComponent, createVerticalStrength, createHorizontalStrength } from 'frontend-collective-react-dnd-scrollzone';
+import { DndProvider, DndContext } from 'react-dnd';
+import HTML5Backend from 'react-dnd-html5-backend';
+import { polyfill } from 'react-lifecycles-compat';
+import { withStyles } from '@material-ui/core/styles';
+import TreeNode from './tree-node';
+import NodeRendererDefault from './node-renderer-default';
+import TreePlaceholder from './tree-placeholder';
+import PlaceholderRendererDefault from './placeholder-renderer-default';
+import { walk, changeNodeAtPath, removeNode, insertNode, find, toggleExpandedForAll } from './utils/tree-data-utils';
+import { memoizedInsertNode, memoizedGetFlatDataFromTree, memoizedGetDescendantCount } from './utils/memoized-tree-data-utils';
+import { slideRows } from './utils/generic-utils';
+import { defaultGetNodeKey, defaultSearchMethod } from './utils/default-handlers';
+import DndManager from './utils/dnd-manager';
+import classnames from './utils/classnames';
+import { styles } from './reactSortableTreeStyles';
 var treeIdCounter = 1;
 var mergeTheme = function (props) {
     var merged = __assign(__assign({}, props), { style: __assign(__assign({}, props.theme.style), props.style), innerStyle: __assign(__assign({}, props.theme.innerStyle), props.innerStyle), reactVirtualizedListProps: __assign(__assign({}, props.theme.reactVirtualizedListProps), props.reactVirtualizedListProps) });
     var overridableDefaults = {
-        nodeContentRenderer: node_renderer_default_1.default,
-        placeholderRenderer: placeholder_renderer_default_1.default,
+        nodeContentRenderer: NodeRendererDefault,
+        placeholderRenderer: PlaceholderRendererDefault,
         rowHeight: 62,
         scaffoldBlockPxWidth: 44,
         slideRegionSize: 100,
-        treeNodeRenderer: tree_node_1.default
+        treeNodeRenderer: TreeNode
     };
     Object.keys(overridableDefaults).forEach(function (propKey) {
         // If prop has been specified, do not change it
@@ -96,19 +71,19 @@ var ReactSortableTree = /** @class */ (function (_super) {
     function ReactSortableTree(props) {
         var _this = _super.call(this, props) || this;
         var _a = mergeTheme(props), dndType = _a.dndType, nodeContentRenderer = _a.nodeContentRenderer, treeNodeRenderer = _a.treeNodeRenderer, isVirtualized = _a.isVirtualized, slideRegionSize = _a.slideRegionSize;
-        _this.dndManager = new dnd_manager_1.default(_this);
+        _this.dndManager = new DndManager(_this);
         // Wrapping classes for use with react-dnd
         _this.treeId = "rst__" + treeIdCounter;
         treeIdCounter += 1;
         _this.dndType = dndType || _this.treeId;
         _this.nodeContentRenderer = _this.dndManager.wrapSource(nodeContentRenderer);
-        _this.treePlaceholderRenderer = _this.dndManager.wrapPlaceholder(tree_placeholder_1.default);
+        _this.treePlaceholderRenderer = _this.dndManager.wrapPlaceholder(TreePlaceholder);
         _this.treeNodeRenderer = _this.dndManager.wrapTarget(treeNodeRenderer);
         // Prepare scroll-on-drag options for this list
         if (isVirtualized) {
-            _this.scrollZoneVirtualList = (frontend_collective_react_dnd_scrollzone_1.createScrollingComponent || frontend_collective_react_dnd_scrollzone_1.default)(react_virtualized_1.List);
-            _this.vStrength = frontend_collective_react_dnd_scrollzone_1.createVerticalStrength(slideRegionSize);
-            _this.hStrength = frontend_collective_react_dnd_scrollzone_1.createHorizontalStrength(slideRegionSize);
+            _this.scrollZoneVirtualList = (createScrollingComponent || withScrolling)(List);
+            _this.vStrength = createVerticalStrength(slideRegionSize);
+            _this.hStrength = createHorizontalStrength(slideRegionSize);
         }
         _this.state = {
             draggingTreeData: null,
@@ -151,7 +126,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
     ReactSortableTree.getDerivedStateFromProps = function (nextProps, prevState) {
         var instanceProps = prevState.instanceProps;
         var newState = {};
-        if (!ramda_1.equals(instanceProps.searchQuery, nextProps.searchQuery)) {
+        if (!equals(instanceProps.searchQuery, nextProps.searchQuery)) {
             Object.assign(newState, ReactSortableTree.search(nextProps, prevState, true, true, false));
         }
         else if (instanceProps.searchFocusOffset !== nextProps.searchFocusOffset) {
@@ -175,9 +150,9 @@ var ReactSortableTree = /** @class */ (function (_super) {
             }
         }
         if (this.state.dragging) {
-            var isTreeDataEqual = ramda_1.equals(this.props.treeData, prevProps.treeData);
+            var isTreeDataEqual = equals(this.props.treeData, prevProps.treeData);
             if (!isTreeDataEqual) {
-                var draggingTreeData_1 = tree_data_utils_1.removeNode({
+                var draggingTreeData_1 = removeNode({
                     treeData: this.props.treeData,
                     path: prevState.draggedPath,
                     getNodeKey: this.props.getNodeKey
@@ -188,7 +163,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
                         draggingTreeData: draggingExpandedPaths.reduce(function (treeData, path) {
                             var newTree;
                             try {
-                                newTree = tree_data_utils_1.changeNodeAtPath({
+                                newTree = changeNodeAtPath({
                                     treeData: treeData,
                                     path: path,
                                     newNode: function (_a) {
@@ -207,7 +182,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
                 });
             }
             else if (this.state.draggingTreeData && prevState.draggingTreeData !== this.state.draggingTreeData) {
-                tree_data_utils_1.walk({
+                walk({
                     treeData: this.state.draggingTreeData,
                     getNodeKey: this.props.getNodeKey,
                     callback: function (_a) {
@@ -225,7 +200,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
             }
         }
         else if (this.props.treeData !== prevProps.treeData) {
-            var isTreeDataEqual = ramda_1.equals(this.props.treeData, prevProps.treeData);
+            var isTreeDataEqual = equals(this.props.treeData, prevProps.treeData);
             var _a = this.state, ignoreOneTreeUpdate = _a.ignoreOneTreeUpdate, instanceProps = _a.instanceProps;
             var newState = {};
             if (!isTreeDataEqual) {
@@ -252,7 +227,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
         this.clearMonitorSubscription();
     };
     ReactSortableTree.prototype.getRows = function (treeData) {
-        return memoized_tree_data_utils_1.memoizedGetFlatDataFromTree({
+        return memoizedGetFlatDataFromTree({
             ignoreCollapsed: true,
             getNodeKey: this.props.getNodeKey,
             treeData: treeData
@@ -270,7 +245,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
     ReactSortableTree.prototype.toggleChildrenVisibility = function (_a) {
         var targetNode = _a.node, path = _a.path;
         var instanceProps = this.state.instanceProps;
-        var treeData = tree_data_utils_1.changeNodeAtPath({
+        var treeData = changeNodeAtPath({
             treeData: instanceProps.treeData,
             path: path,
             newNode: function (_a) {
@@ -290,7 +265,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
     ReactSortableTree.prototype.moveNode = function (_a) {
         var _this = this;
         var node = _a.node, prevPath = _a.path, prevTreeIndex = _a.treeIndex, depth = _a.depth, minimumTreeIndex = _a.minimumTreeIndex;
-        var _b = tree_data_utils_1.insertNode({
+        var _b = insertNode({
             treeData: this.state.draggingTreeData,
             newNode: node,
             depth: depth,
@@ -333,16 +308,16 @@ var ReactSortableTree = /** @class */ (function (_super) {
         }
         var newState = {};
         // if onlyExpandSearchedNodes collapse the tree and search
-        var _a = tree_data_utils_1.find({
+        var _a = find({
             getNodeKey: getNodeKey,
             treeData: onlyExpandSearchedNodes
-                ? tree_data_utils_1.toggleExpandedForAll({
+                ? toggleExpandedForAll({
                     treeData: instanceProps.treeData,
                     expanded: false
                 })
                 : instanceProps.treeData,
             searchQuery: searchQuery,
-            searchMethod: searchMethod || default_handlers_1.defaultSearchMethod,
+            searchMethod: searchMethod || defaultSearchMethod,
             searchFocusOffset: searchFocusOffset,
             expandAllMatchPaths: expand && !singleSearch,
             expandFocusMatchPaths: !!expand
@@ -367,7 +342,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
         var _this = this;
         var path = _a.path;
         this.setState(function (prevState) {
-            var _a = tree_data_utils_1.removeNode({
+            var _a = removeNode({
                 treeData: prevState.instanceProps.treeData,
                 path: path,
                 getNodeKey: _this.props.getNodeKey
@@ -395,7 +370,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
             // Fall back to the tree data if something is being dragged in from
             //  an external element
             var newDraggingTreeData = draggingTreeData || instanceProps.treeData;
-            var addedResult = memoized_tree_data_utils_1.memoizedInsertNode({
+            var addedResult = memoizedInsertNode({
                 treeData: newDraggingTreeData,
                 newNode: draggedNode,
                 depth: draggedDepth,
@@ -406,12 +381,12 @@ var ReactSortableTree = /** @class */ (function (_super) {
             var rows = _this.getRows(addedResult.treeData);
             var expandedParentPath = rows[addedResult.treeIndex].path;
             var nodePath = expandedParentPath.slice(0, -1);
-            var newDraggingExpandedPaths = ramda_1.pipe(ramda_1.when(ramda_1.always(ramda_1.gt(nodePath.length, 0)), ramda_1.append(nodePath)), ramda_1.uniqWith(ramda_1.eqBy(String)))(draggingExpandedPaths);
+            var newDraggingExpandedPaths = pipe(when(always(gt(nodePath.length, 0)), append(nodePath)), uniqWith(eqBy(String)))(draggingExpandedPaths);
             return {
                 draggedNode: draggedNode,
                 draggedDepth: draggedDepth,
                 draggedMinimumTreeIndex: draggedMinimumTreeIndex,
-                draggingTreeData: tree_data_utils_1.changeNodeAtPath({
+                draggingTreeData: changeNodeAtPath({
                     treeData: newDraggingTreeData,
                     path: nodePath,
                     newNode: function (_a) {
@@ -459,7 +434,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
             // If copying is enabled, a drop outside leaves behind a copy in the
             //  source tree
             if (shouldCopy) {
-                treeData = tree_data_utils_1.changeNodeAtPath({
+                treeData = changeNodeAtPath({
                     treeData: instanceProps.treeData,
                     path: path,
                     newNode: function (_a) {
@@ -495,7 +470,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
     // Load any children in the tree that are given by a function
     // calls the onChange callback on the new treeData
     ReactSortableTree.loadLazyChildren = function (props) {
-        tree_data_utils_1.walk({
+        walk({
             treeData: props.treeData,
             getNodeKey: props.getNodeKey,
             callback: function (_a) {
@@ -511,7 +486,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
                         treeIndex: treeIndex,
                         // Provide a helper to append the new data when it is received
                         done: function (childrenArray) {
-                            return props.onChange(tree_data_utils_1.changeNodeAtPath({
+                            return props.onChange(changeNodeAtPath({
                                 treeData: props.treeData,
                                 path: path,
                                 newNode: function (_a) {
@@ -557,8 +532,8 @@ var ReactSortableTree = /** @class */ (function (_super) {
             treeId: this.treeId,
             rowDirection: rowDirection
         };
-        return (react_1.default.createElement(TreeNodeRenderer, __assign({ style: style, key: nodeKey, listIndex: listIndex, getPrevRow: getPrevRow, lowerSiblingCounts: lowerSiblingCounts, swapFrom: swapFrom, swapLength: swapLength, swapDepth: swapDepth }, sharedProps),
-            react_1.default.createElement(NodeContentRenderer, __assign({ parentNode: parentNode, isSearchMatch: isSearchMatch, isSearchFocus: isSearchFocus, canDrag: rowCanDrag, toggleChildrenVisibility: this.toggleChildrenVisibility }, sharedProps, nodeProps))));
+        return (React.createElement(TreeNodeRenderer, __assign({ style: style, key: nodeKey, listIndex: listIndex, getPrevRow: getPrevRow, lowerSiblingCounts: lowerSiblingCounts, swapFrom: swapFrom, swapLength: swapLength, swapDepth: swapDepth }, sharedProps),
+            React.createElement(NodeContentRenderer, __assign({ parentNode: parentNode, isSearchMatch: isSearchMatch, isSearchFocus: isSearchFocus, canDrag: rowCanDrag, toggleChildrenVisibility: this.toggleChildrenVisibility }, sharedProps, nodeProps))));
     };
     ReactSortableTree.prototype.render = function () {
         var _this = this;
@@ -570,7 +545,7 @@ var ReactSortableTree = /** @class */ (function (_super) {
         var swapFrom = null;
         var swapLength = null;
         if (draggedNode && draggedMinimumTreeIndex !== null) {
-            var addedResult = memoized_tree_data_utils_1.memoizedInsertNode({
+            var addedResult = memoizedInsertNode({
                 treeData: treeData,
                 newNode: draggedNode,
                 depth: draggedDepth,
@@ -580,8 +555,8 @@ var ReactSortableTree = /** @class */ (function (_super) {
             });
             var swapTo = draggedMinimumTreeIndex;
             swapFrom = addedResult.treeIndex;
-            swapLength = 1 + memoized_tree_data_utils_1.memoizedGetDescendantCount({ node: draggedNode });
-            rows = generic_utils_1.slideRows(this.getRows(addedResult.treeData), swapFrom, swapTo, swapLength);
+            swapLength = 1 + memoizedGetDescendantCount({ node: draggedNode });
+            rows = slideRows(this.getRows(addedResult.treeData), swapFrom, swapTo, swapLength);
         }
         else {
             rows = this.getRows(treeData);
@@ -599,16 +574,16 @@ var ReactSortableTree = /** @class */ (function (_super) {
         if (rows.length < 1) {
             var Placeholder = this.treePlaceholderRenderer;
             var PlaceholderContent = placeholderRenderer;
-            list = (react_1.default.createElement(Placeholder, { treeId: this.treeId, drop: this.drop },
-                react_1.default.createElement(PlaceholderContent, null)));
+            list = (React.createElement(Placeholder, { treeId: this.treeId, drop: this.drop },
+                React.createElement(PlaceholderContent, null)));
         }
         else if (isVirtualized) {
             containerStyle = __assign({ height: '100%' }, containerStyle);
             var ScrollZoneVirtualList_1 = this.scrollZoneVirtualList;
             // Render list with react-virtualized
-            list = (react_1.default.createElement(react_virtualized_1.AutoSizer, null, function (_a) {
+            list = (React.createElement(AutoSizer, null, function (_a) {
                 var height = _a.height, width = _a.width;
-                return (react_1.default.createElement(ScrollZoneVirtualList_1, __assign({}, scrollToInfo, { dragDropManager: dragDropManager, verticalStrength: _this.vStrength, horizontalStrength: _this.hStrength, speed: 30, scrollToAlignment: "start", className: _this.props.classes.rst__virtualScrollOverride, width: width, onScroll: function (_a) {
+                return (React.createElement(ScrollZoneVirtualList_1, __assign({}, scrollToInfo, { dragDropManager: dragDropManager, verticalStrength: _this.vStrength, horizontalStrength: _this.hStrength, speed: 30, scrollToAlignment: "start", className: _this.props.classes.rst__virtualScrollOverride, width: width, onScroll: function (_a) {
                         var scrollTop = _a.scrollTop;
                         _this.scrollTop = scrollTop;
                     }, height: height, style: innerStyle, rowCount: rows.length, estimatedRowSize: typeof rowHeight !== 'function' ? rowHeight : undefined, rowHeight: typeof rowHeight !== 'function'
@@ -658,14 +633,14 @@ var ReactSortableTree = /** @class */ (function (_super) {
                 });
             });
         }
-        return (react_1.default.createElement("div", { className: classnames_1.default('rst__tree', className, rowDirectionClass), style: containerStyle }, list));
+        return (React.createElement("div", { className: classnames('rst__tree', className, rowDirectionClass), style: containerStyle }, list));
     };
     return ReactSortableTree;
-}(react_1.Component));
+}(Component));
 ReactSortableTree.propTypes = {
-    classes: prop_types_1.default.object,
-    dragDropManager: prop_types_1.default.shape({
-        getMonitor: prop_types_1.default.func
+    classes: PropTypes.object,
+    dragDropManager: PropTypes.shape({
+        getMonitor: PropTypes.func
     }).isRequired,
     // Tree data in the following format:
     // [{title: 'main', subtitle: 'sub'}, { title: 'value2', expanded: true, children: [{ title: 'value3') }] }]
@@ -673,96 +648,96 @@ ReactSortableTree.propTypes = {
     // `subtitle` is a secondary label for the node
     // `expanded` shows children of the node if true, or hides them if false. Defaults to false.
     // `children` is an array of child nodes belonging to the node.
-    treeData: prop_types_1.default.arrayOf(prop_types_1.default.object).isRequired,
+    treeData: PropTypes.arrayOf(PropTypes.object).isRequired,
     // Style applied to the container wrapping the tree (style defaults to {height: '100%'})
-    style: prop_types_1.default.shape({}),
+    style: PropTypes.shape({}),
     // Class name for the container wrapping the tree
-    className: prop_types_1.default.string,
+    className: PropTypes.string,
     // Style applied to the inner, scrollable container (for padding, etc.)
-    innerStyle: prop_types_1.default.shape({}),
+    innerStyle: PropTypes.shape({}),
     // Used by react-virtualized
     // Either a fixed row height (number) or a function that returns the
     // height of a row given its index: `({ index: number }): number`
-    rowHeight: prop_types_1.default.oneOfType([prop_types_1.default.number, prop_types_1.default.func]),
+    rowHeight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
     // Size in px of the region near the edges that initiates scrolling on dragover
-    slideRegionSize: prop_types_1.default.number,
+    slideRegionSize: PropTypes.number,
     // Custom properties to hand to the react-virtualized list
     // https://github.com/bvaughn/react-virtualized/blob/master/docs/List.md#prop-types
-    reactVirtualizedListProps: prop_types_1.default.shape({}),
+    reactVirtualizedListProps: PropTypes.shape({}),
     // The width of the blocks containing the lines representing the structure of the tree.
-    scaffoldBlockPxWidth: prop_types_1.default.number,
+    scaffoldBlockPxWidth: PropTypes.number,
     // Maximum depth nodes can be inserted at. Defaults to infinite.
-    maxDepth: prop_types_1.default.number,
+    maxDepth: PropTypes.number,
     // The method used to search nodes.
     // Defaults to a function that uses the `searchQuery` string to search for nodes with
     // matching `title` or `subtitle` values.
     // NOTE: Changing `searchMethod` will not update the search, but changing the `searchQuery` will.
-    searchMethod: prop_types_1.default.func,
+    searchMethod: PropTypes.func,
     // Used by the `searchMethod` to highlight and scroll to matched nodes.
     // Should be a string for the default `searchMethod`, but can be anything when using a custom search.
-    searchQuery: prop_types_1.default.any,
+    searchQuery: PropTypes.any,
     // Outline the <`searchFocusOffset`>th node and scroll to it.
-    searchFocusOffset: prop_types_1.default.number,
+    searchFocusOffset: PropTypes.number,
     // Get the nodes that match the search criteria. Used for counting total matches, etc.
-    searchFinishCallback: prop_types_1.default.func,
+    searchFinishCallback: PropTypes.func,
     // Generate an object with additional props to be passed to the node renderer.
     // Use this for adding buttons via the `buttons` key,
     // or additional `style` / `className` settings.
-    generateNodeProps: prop_types_1.default.func,
+    generateNodeProps: PropTypes.func,
     // Set to false to disable virtualization.
     // NOTE: Auto-scrolling while dragging, and scrolling to the `searchFocusOffset` will be disabled.
-    isVirtualized: prop_types_1.default.bool,
-    treeNodeRenderer: prop_types_1.default.func,
+    isVirtualized: PropTypes.bool,
+    treeNodeRenderer: PropTypes.func,
     // Override the default component for rendering nodes (but keep the scaffolding generator)
     // This is an advanced option for complete customization of the appearance.
     // It is best to copy the component in `node-renderer-default.js` to use as a base, and customize as needed.
-    nodeContentRenderer: prop_types_1.default.func,
+    nodeContentRenderer: PropTypes.func,
     // Override the default component for rendering an empty tree
     // This is an advanced option for complete customization of the appearance.
     // It is best to copy the component in `placeholder-renderer-default.js` to use as a base,
     // and customize as needed.
-    placeholderRenderer: prop_types_1.default.func,
-    theme: prop_types_1.default.shape({
-        style: prop_types_1.default.shape({}),
-        innerStyle: prop_types_1.default.shape({}),
-        reactVirtualizedListProps: prop_types_1.default.shape({}),
-        scaffoldBlockPxWidth: prop_types_1.default.number,
-        slideRegionSize: prop_types_1.default.number,
-        rowHeight: prop_types_1.default.oneOfType([prop_types_1.default.number, prop_types_1.default.func]),
-        treeNodeRenderer: prop_types_1.default.func,
-        nodeContentRenderer: prop_types_1.default.func,
-        placeholderRenderer: prop_types_1.default.func
+    placeholderRenderer: PropTypes.func,
+    theme: PropTypes.shape({
+        style: PropTypes.shape({}),
+        innerStyle: PropTypes.shape({}),
+        reactVirtualizedListProps: PropTypes.shape({}),
+        scaffoldBlockPxWidth: PropTypes.number,
+        slideRegionSize: PropTypes.number,
+        rowHeight: PropTypes.oneOfType([PropTypes.number, PropTypes.func]),
+        treeNodeRenderer: PropTypes.func,
+        nodeContentRenderer: PropTypes.func,
+        placeholderRenderer: PropTypes.func
     }),
     // Determine the unique key used to identify each node and
     // generate the `path` array passed in callbacks.
     // By default, returns the index in the tree (omitting hidden nodes).
-    getNodeKey: prop_types_1.default.func,
+    getNodeKey: PropTypes.func,
     // Called whenever tree data changed.
     // Just like with React input elements, you have to update your
     // own component's data to see the changes reflected.
-    onChange: prop_types_1.default.func.isRequired,
+    onChange: PropTypes.func.isRequired,
     // Called after node move operation.
-    onMoveNode: prop_types_1.default.func,
+    onMoveNode: PropTypes.func,
     // Determine whether a node can be dragged. Set to false to disable dragging on all nodes.
-    canDrag: prop_types_1.default.oneOfType([prop_types_1.default.func, prop_types_1.default.bool]),
+    canDrag: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
     // Determine whether a node can be dropped based on its path and parents'.
-    canDrop: prop_types_1.default.func,
+    canDrop: PropTypes.func,
     // Determine whether a node can have children
-    canNodeHaveChildren: prop_types_1.default.func,
+    canNodeHaveChildren: PropTypes.func,
     // When true, or a callback returning true, dropping nodes to react-dnd
     // drop targets outside of this tree will not remove them from this tree
-    shouldCopyOnOutsideDrop: prop_types_1.default.oneOfType([prop_types_1.default.func, prop_types_1.default.bool]),
+    shouldCopyOnOutsideDrop: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),
     // Called after children nodes collapsed or expanded.
-    onVisibilityToggle: prop_types_1.default.func,
-    dndType: prop_types_1.default.string,
+    onVisibilityToggle: PropTypes.func,
+    dndType: PropTypes.string,
     // Called to track between dropped and dragging
-    onDragStateChanged: prop_types_1.default.func,
+    onDragStateChanged: PropTypes.func,
     // Specify that nodes that do not match search will be collapsed
-    onlyExpandSearchedNodes: prop_types_1.default.bool,
+    onlyExpandSearchedNodes: PropTypes.bool,
     // rtl support
-    rowDirection: prop_types_1.default.string,
-    onLazyLoadChildren: prop_types_1.default.func,
-    ignoreTreeChanges: prop_types_1.default.bool
+    rowDirection: PropTypes.string,
+    onLazyLoadChildren: PropTypes.func,
+    ignoreTreeChanges: PropTypes.bool
 };
 ReactSortableTree.defaultProps = {
     canDrag: true,
@@ -771,7 +746,7 @@ ReactSortableTree.defaultProps = {
     className: '',
     dndType: null,
     generateNodeProps: null,
-    getNodeKey: default_handlers_1.defaultGetNodeKey,
+    getNodeKey: defaultGetNodeKey,
     innerStyle: {},
     isVirtualized: true,
     maxDepth: null,
@@ -797,13 +772,16 @@ ReactSortableTree.defaultProps = {
     onLazyLoadChildren: function () { },
     ignoreTreeChanges: false
 };
-react_lifecycles_compat_1.polyfill(ReactSortableTree);
-var StyledReactSortableTree = styles_1.withStyles(reactSortableTreeStyles_1.styles)(ReactSortableTree);
-var SortableTreeWithoutDndContext = function (props) { return (react_1.default.createElement(react_dnd_1.DndContext.Consumer, null, function (_a) {
+polyfill(ReactSortableTree);
+var StyledReactSortableTree = withStyles(styles)(ReactSortableTree);
+var SortableTreeWithoutDndContext = function (props) { return (React.createElement(DndContext.Consumer, null, function (_a) {
     var dragDropManager = _a.dragDropManager;
-    return dragDropManager === undefined ? null : (react_1.default.createElement(StyledReactSortableTree, __assign({}, props, { dragDropManager: dragDropManager })));
+    return dragDropManager === undefined ? null : (React.createElement(StyledReactSortableTree, __assign({}, props, { dragDropManager: dragDropManager })));
 })); };
-exports.SortableTreeWithoutDndContext = SortableTreeWithoutDndContext;
-var SortableTree = function (props) { return (react_1.default.createElement(react_dnd_1.DndProvider, { backend: react_dnd_html5_backend_1.default },
-    react_1.default.createElement(SortableTreeWithoutDndContext, __assign({}, props)))); };
-exports.default = SortableTree;
+var SortableTree = function (props) { return (React.createElement(DndProvider, { backend: HTML5Backend },
+    React.createElement(SortableTreeWithoutDndContext, __assign({}, props)))); };
+// Export the tree component without the react-dnd DragDropContext,
+// for when component is used with other components using react-dnd.
+// see: https://github.com/gaearon/react-dnd/issues/186
+export { SortableTreeWithoutDndContext };
+export default SortableTree;

package/components/ReactSortableTree/reactSortableTreeStyles.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.styles = void 0;
-var styles = function () { return ({
+export var styles = function () { return ({
     /* import styles from react-virtualized/styles.css */
     /* Grid default theme */
     '@global .ReactVirtualized__Grid__innerScrollContainer': {
@@ -20,4 +17,3 @@ var styles = function () { return ({
         direction: 'rtl'
     }
 }); };
-exports.styles = styles;