@atlaskit/table-tree 9.0.12 → 9.0.13

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

@@ -10,10 +10,13 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 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";
@@ -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}

@@ -11,14 +11,14 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 
 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.12";
+var packageVersion = "9.0.13";
 
 var Row = /*#__PURE__*/function (_Component) {
   _inherits(Row, _Component);

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

@@ -9,7 +9,7 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 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}

@@ -13,12 +13,11 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 /* 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}

@@ -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.12",
+	"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 {};

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

@@ -0,0 +1,20 @@
+import { Component } from 'react';
+interface LoaderItemProps {
+    depth: number;
+    onComplete: (...args: any[]) => void;
+    isCompleting?: boolean;
+}
+export default class LoaderItem extends Component<LoaderItemProps, any> {
+    static defaultProps: {
+        depth: number;
+    };
+    state: {
+        phase: string;
+    };
+    static getDerivedStateFromProps(nextProps: any, prevState: any): {
+        phase: string;
+    } | null;
+    componentDidUpdate(prevProps: any, prevState: any): void;
+    render(): JSX.Element | null;
+}
+export {};

package/dist/types/components/internal/overflow-container.d.ts

@@ -0,0 +1,10 @@
+/** @jsx jsx */
+import { FC, HTMLAttributes } from 'react';
+interface OverflowContainerProps {
+    isSingleLine?: boolean;
+}
+/**
+ * __Overflow container__
+ */
+declare const OverflowContainer: FC<OverflowContainerProps & HTMLAttributes<HTMLSpanElement>>;
+export default OverflowContainer;

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

@@ -0,0 +1,25 @@
+/** @jsx jsx */
+import { FC, HTMLAttributes } from 'react';
+export declare const iconColor: "var(--ds-text-highEmphasis)";
+/**
+ * __Tree row container__
+ */
+export declare const TreeRowContainer: FC<HTMLAttributes<HTMLDivElement>>;
+/**
+ * __Chevron container__
+ */
+export declare const ChevronContainer: FC<HTMLAttributes<HTMLSpanElement>>;
+/**
+ * __Chevron icon container__
+ *
+ * A chevron icon container.
+ */
+export declare const ChevronIconContainer: FC<HTMLAttributes<HTMLSpanElement>>;
+/**
+ * __Loader item container__
+ *
+ * A loader item container.
+ */
+export declare const LoaderItemContainer: FC<{
+    isRoot?: boolean;
+}>;

package/dist/types/components/internal/with-column-width.d.ts

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

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

@@ -0,0 +1,19 @@
+import React, { Component } from 'react';
+declare class Row extends Component<any, any> {
+    state: {
+        isExpanded: any;
+    };
+    componentDidUpdate(prevProps: any): void;
+    onExpandStateChange(isExpanded: boolean): void;
+    onExpandToggle: () => void;
+    isExpanded(): any;
+    renderCell(cell: any, cellIndex: number): React.FunctionComponentElement<{
+        key: number;
+        columnIndex: number;
+        indentLevel: any;
+    }>;
+    render(): JSX.Element;
+}
+export { Row as RowWithoutAnalytics };
+declare const _default: React.ForwardRefExoticComponent<Pick<Pick<Pick<any, string | number | symbol>, string | number | symbol> & React.RefAttributes<any> & import("@atlaskit/analytics-next").WithContextProps, string | number | symbol> & React.RefAttributes<any>>;
+export default _default;

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

@@ -0,0 +1,12 @@
+import React, { Component } from 'react';
+declare type WithChildren<T> = T & {
+    children?: T[] | null;
+};
+export interface RowsProps<T> {
+    items?: WithChildren<T>[];
+    render: (args: WithChildren<T>) => React.ReactNode;
+}
+export default class Rows<T> extends Component<RowsProps<T>> {
+    render(): JSX.Element;
+}
+export {};