@atlaskit/table-tree 9.0.9 → 9.0.13

package/dist/esm/components/{Chevron.js → internal/chevron.js}

@@ -9,14 +9,16 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/* eslint-disable @repo/internal/react/consistent-props-definitions */
 
 /* eslint-disable react/prop-types */
 import React, { Component } from 'react';
 import Button from '@atlaskit/button';
 import ChevronDownIcon from '@atlaskit/icon/glyph/chevron-down';
 import ChevronRightIcon from '@atlaskit/icon/glyph/chevron-right';
-import { ChevronContainer, ChevronIconContainer, iconColor } from '../styled';
+import { ChevronContainer, ChevronIconContainer, iconColor } from './styled';
 
 var Chevron = /*#__PURE__*/function (_Component) {
   _inherits(Chevron, _Component);

package/dist/esm/components/internal/common-cell.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+
+/** @jsx jsx */
+import { css, jsx } from '@emotion/core';
+import { N800 } from '@atlaskit/theme/colors';
+var commonStyles = css({
+  display: 'flex',
+  boxSizing: 'border-box',
+  minHeight: 40,
+  padding: '10px 25px 10px var(--indent, 25px)',
+  position: 'relative',
+  alignItems: 'flex-start',
+  color: "var(--ds-text-highEmphasis, ".concat(N800, ")"),
+  lineHeight: '20px'
+});
+
+/**
+ * __Common cell__
+ */
+var CommonCell = function CommonCell(_ref) {
+  var indent = _ref.indent,
+      props = _objectWithoutProperties(_ref, ["indent"]);
+
+  return jsx("div", _extends({
+    style: {
+      '--indent': indent
+    },
+    css: commonStyles
+  }, props));
+};
+
+export default CommonCell;

package/dist/esm/components/{Item.js → internal/item.js}

@@ -7,11 +7,15 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-import React, { Component } from 'react';
-import toItemId from '../utils/toItemId';
-import Items from './Items';
+/** @jsx jsx */
+
+/* eslint-disable @repo/internal/react/no-clone-element */
+import { cloneElement, Component } from 'react';
+import { jsx } from '@emotion/core';
+import toItemId from '../../utils/to-item-id';
+import Items from './items';
 
 var Item = /*#__PURE__*/function (_Component) {
   _inherits(Item, _Component);
@@ -41,13 +45,13 @@ var Item = /*#__PURE__*/function (_Component) {
       var _renderedRow$props = renderedRow.props,
           itemId = _renderedRow$props.itemId,
           items = _renderedRow$props.items;
-      return /*#__PURE__*/React.cloneElement(renderedRow, {
+      return /*#__PURE__*/cloneElement(renderedRow, {
         depth: depth,
         data: data,
         renderChildren: function renderChildren() {
-          return /*#__PURE__*/React.createElement("div", {
+          return jsx("div", {
             id: toItemId(itemId)
-          }, /*#__PURE__*/React.createElement(Items, {
+          }, jsx(Items, {
             parentData: data,
             depth: depth,
             items: items,

package/dist/esm/components/{Items.js → internal/items.js}

@@ -9,12 +9,12 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 /* eslint-disable react/prop-types */
 import React, { Component } from 'react';
-import Item from './Item';
-import LoaderItem from './LoaderItem';
+import Item from './item';
+import LoaderItem from './loader-item';
 
 var Items = /*#__PURE__*/function (_Component) {
   _inherits(Items, _Component);

package/dist/esm/components/{LoaderItem.js → internal/loader-item.js}

@@ -8,12 +8,15 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/* eslint-disable @atlaskit/design-system/ensure-design-token-usage */
 
 /* eslint-disable react/prop-types */
 import React, { Component } from 'react';
 import Spinner from '@atlaskit/spinner';
-import { Cell, LoaderItemContainer, TreeRowContainer } from '../styled';
+import CommonCell from './common-cell';
+import { LoaderItemContainer, TreeRowContainer } from './styled';
 
 var LoaderItem = /*#__PURE__*/function (_Component) {
   _inherits(LoaderItem, _Component);
@@ -50,19 +53,17 @@ var LoaderItem = /*#__PURE__*/function (_Component) {
   }, {
     key: "render",
     value: function render() {
-      var _this$props = this.props,
-          isCompleting = _this$props.isCompleting,
-          depth = _this$props.depth;
+      var depth = this.props.depth;
       var phase = this.state.phase;
-      return phase === 'loading' ? /*#__PURE__*/React.createElement(TreeRowContainer, null, /*#__PURE__*/React.createElement(Cell, {
-        indentLevel: depth,
-        width: "100%"
+      return phase === 'loading' ? /*#__PURE__*/React.createElement(TreeRowContainer, null, /*#__PURE__*/React.createElement(CommonCell, {
+        style: {
+          paddingLeft: 25 * depth,
+          width: '100%'
+        }
       }, /*#__PURE__*/React.createElement(LoaderItemContainer, {
         isRoot: depth === 1
       }, /*#__PURE__*/React.createElement(Spinner, {
-        isCompleting: isCompleting,
-        size: "small",
-        invertColor: false
+        size: "small"
       })))) : null;
     }
   }], [{

package/dist/esm/components/internal/overflow-container.js

@@ -0,0 +1,24 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+
+/** @jsx jsx */
+import { css, jsx } from '@emotion/core';
+var overflowContainerStyles = css({
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  whiteSpace: 'nowrap'
+});
+/**
+ * __Overflow container__
+ */
+
+var OverflowContainer = function OverflowContainer(_ref) {
+  var isSingleLine = _ref.isSingleLine,
+      props = _objectWithoutProperties(_ref, ["isSingleLine"]);
+
+  return jsx("span", _extends({
+    css: isSingleLine && overflowContainerStyles
+  }, props));
+};
+
+export default OverflowContainer;

package/dist/esm/components/internal/styled.js

@@ -0,0 +1,72 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _extends from "@babel/runtime/helpers/extends";
+
+/** @jsx jsx */
+import { css, jsx } from '@emotion/core';
+import { N30, N800 } from '@atlaskit/theme/colors';
+export var iconColor = "var(--ds-text-highEmphasis, ".concat(N800, ")");
+var treeRowContainerStyles = css({
+  display: 'flex',
+  borderBottom: "1px solid ".concat("var(--ds-border-neutral, ".concat(N30, ")"))
+});
+/**
+ * __Tree row container__
+ */
+
+export var TreeRowContainer = function TreeRowContainer(props) {
+  return jsx("div", _extends({
+    css: treeRowContainerStyles
+  }, props));
+};
+var commonChevronContainerStyles = css({
+  display: 'flex',
+  marginLeft: -25,
+  position: 'absolute',
+  top: 7,
+  alignItems: 'center'
+});
+/**
+ * __Chevron container__
+ */
+
+export var ChevronContainer = function ChevronContainer(props) {
+  return jsx("span", _extends({}, props, {
+    css: commonChevronContainerStyles
+  }));
+};
+var chevronIconContainerStyles = css({
+  position: 'relative',
+  top: 1
+});
+/**
+ * __Chevron icon container__
+ *
+ * A chevron icon container.
+ */
+
+export var ChevronIconContainer = function ChevronIconContainer(props) {
+  return jsx("span", _extends({}, props, {
+    css: chevronIconContainerStyles
+  }));
+};
+var loadingItemContainerStyles = css({
+  width: '100%',
+  paddingTop: 5
+});
+var paddingLeftStyles = css({
+  paddingLeft: '50%'
+});
+/**
+ * __Loader item container__
+ *
+ * A loader item container.
+ */
+
+export var LoaderItemContainer = function LoaderItemContainer(_ref) {
+  var isRoot = _ref.isRoot,
+      props = _objectWithoutProperties(_ref, ["isRoot"]);
+
+  return jsx("span", _extends({
+    css: [commonChevronContainerStyles, loadingItemContainerStyles, isRoot && paddingLeftStyles]
+  }, props));
+};

package/dist/esm/components/{withColumnWidth.js → internal/with-column-width.js}

@@ -1,4 +1,5 @@
 import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _inherits from "@babel/runtime/helpers/inherits";
@@ -8,7 +9,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 /* eslint-disable react/prop-types */
 import React, { Component } from 'react';
@@ -49,11 +50,13 @@ export default function withColumnWidth(Cell) {
       value: function render() {
         var _this$props = this.props,
             width = _this$props.width,
-            columnIndex = _this$props.columnIndex;
+            columnIndex = _this$props.columnIndex,
+            other = _objectWithoutProperties(_this$props, ["width", "columnIndex"]);
+
         var columnWidth = width !== null && width !== undefined ? width : this.context.tableTree.getColumnWidth(columnIndex);
-        return /*#__PURE__*/React.createElement(Cell, _extends({}, this.props, {
+        return /*#__PURE__*/React.createElement(Cell, _extends({
           width: columnWidth
-        }));
+        }, other));
       }
     }]);
 

package/dist/esm/components/{Row.js → row.js}

@@ -9,16 +9,16 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-/* eslint-disable react/prop-types */
+/* eslint-disable @repo/internal/react/no-clone-element */
 import React, { Component, Fragment } from 'react';
 import { createAndFireEvent, withAnalyticsContext, withAnalyticsEvents } from '@atlaskit/analytics-next';
-import { TreeRowContainer } from '../styled';
-import toItemId from '../utils/toItemId';
-import Chevron from './Chevron';
+import toItemId from '../utils/to-item-id';
+import Chevron from './internal/chevron';
+import { TreeRowContainer } from './internal/styled';
 var packageName = "@atlaskit/table-tree";
-var packageVersion = "9.0.9";
+var packageVersion = "9.0.13";
 
 var Row = /*#__PURE__*/function (_Component) {
   _inherits(Row, _Component);

package/dist/esm/components/{Rows.js → rows.js}

@@ -6,10 +6,10 @@ import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 import React, { Component } from 'react';
-import Items from './Items';
+import Items from './internal/items';
 
 var Rows = /*#__PURE__*/function (_Component) {
   _inherits(Rows, _Component);
@@ -25,7 +25,6 @@ var Rows = /*#__PURE__*/function (_Component) {
   _createClass(Rows, [{
     key: "render",
     value: function render() {
-      // eslint-disable-next-line react/prop-types
       var _this$props = this.props,
           items = _this$props.items,
           render = _this$props.render;

package/dist/esm/components/{TableTree.js → table-tree.js}

@@ -8,17 +8,16 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 /* eslint-disable react/prop-types */
 import React, { Component } from 'react';
 import PropTypes from 'prop-types';
-import { TableTreeContainer } from '../styled';
-import Cell from './Cell';
-import Header from './Header';
-import Headers from './Headers';
-import Row from './Row';
-import Rows from './Rows';
+import Cell from './cell';
+import Header from './header';
+import Headers from './headers';
+import Row from './row';
+import Rows from './rows';
 
 var TableTree = /*#__PURE__*/function (_Component) {
   _inherits(TableTree, _Component);
@@ -129,7 +128,7 @@ var TableTree = /*#__PURE__*/function (_Component) {
         });
       }
 
-      return /*#__PURE__*/React.createElement(TableTreeContainer, {
+      return /*#__PURE__*/React.createElement("div", {
         role: "treegrid",
         "aria-readonly": true
       }, heads, rows, this.props.children);

package/dist/esm/index.js

@@ -1,7 +1,7 @@
-export { default } from './components/TableTree';
-export { default as Headers } from './components/Headers';
-export { default as Header } from './components/Header';
-export { default as Cell } from './components/Cell';
-export { default as Rows } from './components/Rows';
-export { default as Row } from './components/Row';
-export { default as TableTreeDataHelper } from './utils/TableTreeDataHelper';
+export { default } from './components/table-tree';
+export { default as Headers } from './components/headers';
+export { default as Header } from './components/header';
+export { default as Cell } from './components/cell';
+export { default as Rows } from './components/rows';
+export { default as Row } from './components/row';
+export { default as TableTreeDataHelper } from './utils/table-tree-data-helper';

package/dist/esm/utils/{TableTreeDataHelper.js → table-tree-data-helper.js}

@@ -3,7 +3,7 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
@@ -93,10 +93,6 @@ var TableTreeDataHelper = /*#__PURE__*/function () {
 
     _classCallCheck(this, TableTreeDataHelper);
 
-    _defineProperty(this, "key", void 0);
-
-    _defineProperty(this, "keysCache", void 0);
-
     this.key = key;
     this.keysCache = {};
   }

package/dist/esm/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/table-tree",
-	"version": "9.0.9",
+	"version": "9.0.13",
 	"sideEffects": false
 }

package/dist/types/components/cell.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+export interface CellProps {
+    singleLine?: boolean;
+    indentLevel?: number;
+    width?: number | string;
+    className?: string;
+}
+declare const _default: {
+    new (props: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>): {
+        UNSAFE_componentWillMount(): void;
+        setColumnWidth(width?: string | number | undefined): void;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./internal/with-column-width").CellWithColumnWidthProps): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: CellProps & import("./internal/with-column-width").CellWithColumnWidthProps, context?: any): {
+        UNSAFE_componentWillMount(): void;
+        setColumnWidth(width?: string | number | undefined): void;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./internal/with-column-width").CellWithColumnWidthProps): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<CellProps & import("./internal/with-column-width").CellWithColumnWidthProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextTypes: {
+        tableTree: import("prop-types").Validator<any>;
+    };
+    contextType?: React.Context<any> | undefined;
+};
+export default _default;

package/dist/types/components/header.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="react" />
+declare const _default: {
+    new (props: Readonly<any>): {
+        UNSAFE_componentWillMount(): void;
+        setColumnWidth(width?: string | number | undefined): void;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./internal/with-column-width").CellWithColumnWidthProps): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<any>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: any, context?: any): {
+        UNSAFE_componentWillMount(): void;
+        setColumnWidth(width?: string | number | undefined): void;
+        UNSAFE_componentWillReceiveProps(nextProps: import("./internal/with-column-width").CellWithColumnWidthProps): void;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<any>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callBack?: (() => void) | undefined): void;
+        readonly props: Readonly<any> & Readonly<{
+            children?: import("react").ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<any>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<any>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<any>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<any>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextTypes: {
+        tableTree: import("prop-types").Validator<any>;
+    };
+    contextType?: import("react").Context<any> | undefined;
+};
+export default _default;

package/dist/types/components/headers.d.ts

@@ -0,0 +1,5 @@
+/** @jsx jsx */
+import { Component } from 'react';
+export default class Headers extends Component<any> {
+    render(): JSX.Element;
+}

package/dist/types/components/internal/chevron.d.ts

@@ -0,0 +1,17 @@
+import { Component } from 'react';
+interface ChevronProps {
+    expandLabel: string;
+    collapseLabel: string;
+    isExpanded?: boolean;
+    ariaControls?: string;
+    onExpandToggle?: Function;
+}
+export default class Chevron extends Component<ChevronProps> {
+    static defaultProps: {
+        expandLabel: string;
+        collapseLabel: string;
+    };
+    handleClick: () => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/types/components/internal/common-cell.d.ts

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import { FC, HTMLAttributes } from 'react';
+interface CommonCellProps {
+    indent?: string;
+}
+/**
+ * __Common cell__
+ */
+declare const CommonCell: FC<HTMLAttributes<HTMLDivElement> & CommonCellProps>;
+export default CommonCell;

package/dist/types/components/internal/item.d.ts

@@ -0,0 +1,12 @@
+/** @jsx jsx */
+import { Component } from 'react';
+export default class Item extends Component<any> {
+    static defaultProps: {
+        depth: number;
+    };
+    render(): import("react").FunctionComponentElement<{
+        depth: any;
+        data: any;
+        renderChildren: () => JSX.Element;
+    }> | null;
+}

package/dist/types/components/internal/items.d.ts

@@ -0,0 +1,24 @@
+import React, { Component } from 'react';
+interface ItemsProps<Item = any> {
+    parentData?: any;
+    depth: number;
+    items?: Item[];
+    render: (arg: Item) => React.ReactNode;
+}
+interface State {
+    isLoaderShown: boolean;
+}
+export default class Items<Item> extends Component<ItemsProps<Item>, State> {
+    static defaultProps: {
+        depth: number;
+    };
+    state: State;
+    static getDerivedStateFromProps(nextProps: any, prevState: any): {
+        isLoaderShown: boolean;
+    } | null;
+    handleLoaderComplete: () => void;
+    renderLoader(): JSX.Element;
+    renderItems(): JSX.Element[] | undefined;
+    render(): JSX.Element;
+}
+export {};