superdesk-ui-framework 3.0.1-beta.3 → 3.0.1-beta.30

package/react/components/Layouts/AuthoringFrameRightBar.js

@@ -38,11 +38,22 @@ exports.AuthoringFrameRightBar = void 0;
 var React = __importStar(require("react"));
 var AuthoringFrameRightBar = /** @class */ (function (_super) {
     __extends(AuthoringFrameRightBar, _super);
-    function AuthoringFrameRightBar() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function AuthoringFrameRightBar(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            closed: _this.props.closed ? _this.props.closed : false,
+        };
+        return _this;
     }
+    AuthoringFrameRightBar.prototype.componentDidUpdate = function (prevProps) {
+        if (prevProps.closed !== this.props.closed) {
+            this.setState({
+                closed: this.props.closed,
+            });
+        }
+    };
     AuthoringFrameRightBar.prototype.render = function () {
-        return (React.createElement("div", { className: "sd-editor-grid__sidetabs-bar" }, this.props.children));
+        return (!this.state.closed && React.createElement("div", { className: "sd-editor-grid__sidetabs-bar" }, this.props.children));
     };
     return AuthoringFrameRightBar;
 }(React.PureComponent));

package/react/components/Layouts/AuthoringInnerHeader.js

@@ -46,7 +46,7 @@ var AuthoringInnerHeader = /** @class */ (function (_super) {
     function AuthoringInnerHeader(props) {
         var _this = _super.call(this, props) || this;
         _this.state = {
-            collapsed: false,
+            collapsed: _this.props.collapsed ? _this.props.collapsed : false,
         };
         return _this;
     }

package/react/components/Layouts/AuthoringMain.js

@@ -46,7 +46,7 @@ var AuthoringMain = /** @class */ (function (_super) {
         return (React.createElement(_1.AuthoringMainContainer, null,
             this.props.toolBar && (React.createElement(_1.AuthoringMainToolBar, { toolbarCustom: this.props.toolbarCustom }, this.props.toolBar)),
             React.createElement(_1.AuthoringMainContent, null,
-                this.props.authoringHeader && (React.createElement(_1.AuthoringInnerHeader, { headerPadding: this.props.headerPadding }, this.props.authoringHeader)),
+                this.props.authoringHeader && (React.createElement(_1.AuthoringInnerHeader, { headerPadding: this.props.headerPadding, collapsed: this.props.headerCollapsed }, this.props.authoringHeader)),
                 this.props.authoringBookmarks && (React.createElement(_1.AuthorinInnerSideBar, null, this.props.authoringBookmarks)),
                 React.createElement(_1.AuthoringInnerBody, null, this.props.children))));
     };

package/react/components/Layouts/CoreLayout.d.ts

@@ -12,6 +12,7 @@ interface IProps {
     menuId?: string;
     ariaControls?: string;
     buttonAnimation?: 'spin' | 'squeeze' | 'none';
+    editorFullWidth?: boolean;
 }
 export declare class CoreLayout extends React.PureComponent<IProps> {
     render(): JSX.Element;

package/react/components/Layouts/CoreLayout.js

@@ -46,7 +46,7 @@ var CoreLayout = /** @class */ (function (_super) {
         return (React.createElement(_1.CoreLayoutContainer, null,
             this.props.slideInMenu && (React.createElement(_1.CoreLayoutSlideInMenu, { menuId: this.props.menuId, menuOpen: this.props.menuOpen }, this.props.slideInMenu)),
             this.props.topMenu && (React.createElement(_1.CoreLayoutTopMenu, { buttonAnimation: this.props.buttonAnimation, heading: this.props.heading, onClick: this.props.onClick, active: this.props.active, ariaControls: this.props.ariaControls }, this.props.topMenu)),
-            React.createElement(_1.CoreLayoutMain, null, this.props.children),
+            React.createElement(_1.CoreLayoutMain, { editorFullWidth: this.props.editorFullWidth }, this.props.children),
             this.props.footer && (React.createElement(_1.CoreLayoutFooter, null, this.props.footer)),
             this.props.overlay && (React.createElement(_1.CoreLayoutOverlay, null, this.props.overlay))));
     };

package/react/components/Layouts/CoreLayoutMain.d.ts

@@ -2,6 +2,7 @@ import * as React from 'react';
 interface IProps {
     children?: React.ReactNode;
     id?: string;
+    editorFullWidth?: boolean;
 }
 export declare class CoreLayoutMain extends React.PureComponent<IProps> {
     render(): JSX.Element;

package/react/components/Layouts/CoreLayoutMain.js

@@ -33,16 +33,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.CoreLayoutMain = void 0;
 var React = __importStar(require("react"));
+var classnames_1 = __importDefault(require("classnames"));
 var CoreLayoutMain = /** @class */ (function (_super) {
     __extends(CoreLayoutMain, _super);
     function CoreLayoutMain() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     CoreLayoutMain.prototype.render = function () {
-        return (React.createElement("section", { id: this.props.id, className: 'sd-content sd-content-wrapper' }, this.props.children));
+        var classes = (0, classnames_1.default)('sd-content sd-content-wrapper', {
+            'sd-content-wrapper--editor-full': this.props.editorFullWidth,
+        });
+        return (React.createElement("section", { id: this.props.id, className: classes }, this.props.children));
     };
     return CoreLayoutMain;
 }(React.PureComponent));

package/react/components/Layouts/Layout.js

@@ -31,6 +31,6 @@ var Layout = function (_a) {
                 React.createElement("i", { className: 'icon-collapse icon--white' })),
             React.createElement("p", { className: 'sd-top-menu__header' }, header)),
         React.createElement("section", { id: '1', className: 'sd-content sd-content-wrapper' }, children),
-        React.createElement("footer", { className: 'sd-bottom-bar' }, "This is the footer.")));
+        React.createElement("footer", { className: 'sd-bottom-bar' }, "Footer")));
 };
 exports.Layout = Layout;

package/react/components/LeftMenu.d.ts

@@ -13,7 +13,8 @@ interface IMenuGroup {
 interface IMenu {
     className?: string;
     groups: Array<IMenuGroup>;
-    activeItemId: string;
+    activeItemId?: string;
+    scrollTo?: string;
     ariaLabel?: string;
     scrollSpy?: string;
     offset?: number;
@@ -28,6 +29,7 @@ interface IState {
 export declare class LeftMenu extends React.PureComponent<IMenu, IState> {
     constructor(props: IMenu);
     handleClick(item: IMenuItem, event?: React.MouseEvent): void;
+    componentDidMount(): void;
     render(): JSX.Element;
 }
 export {};

package/react/components/LeftMenu.js

@@ -55,7 +55,7 @@ var LeftMenu = /** @class */ (function (_super) {
     function LeftMenu(props) {
         var _this = _super.call(this, props) || this;
         _this.state = {
-            active: "",
+            active: _this.props.activeItemId ? _this.props.activeItemId : '',
         };
         return _this;
     }
@@ -74,6 +74,13 @@ var LeftMenu = /** @class */ (function (_super) {
         }
         this.props.onSelect(item.id, item.route ? item.route : "");
     };
+    LeftMenu.prototype.componentDidMount = function () {
+        var _a;
+        if (this.props.scrollTo) {
+            return (_a = document
+                .getElementById(this.props.scrollTo)) === null || _a === void 0 ? void 0 : _a.scrollIntoView({ block: "nearest", behavior: "smooth" });
+        }
+    };
     LeftMenu.prototype.render = function () {
         var _a;
         var _this = this;

package/react/components/Lists/ContentList.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+interface IPropsItem {
+    action?: React.ReactNode;
+    locked?: boolean;
+    itemColum: Array<{
+        itemRow: Array<{
+            content: any;
+        }>;
+        border?: boolean;
+        fullwidth?: boolean;
+    }>;
+    activated?: boolean;
+    selected?: boolean;
+    archived?: boolean;
+    loading?: boolean;
+    onClick?(): void;
+    onDoubleClick?(): void;
+}
+declare class ContentListItem extends React.PureComponent<IPropsItem> {
+    private timer;
+    private delay;
+    private prevent;
+    onSingleClick: () => void;
+    onDoubleClick: () => void;
+    onActionMenuClick: (event: React.MouseEvent<HTMLElement>) => void;
+    render(): JSX.Element;
+}
+interface IProps {
+    items: Array<{
+        itemColum: Array<IItemArray>;
+        locked?: boolean;
+        action?: React.ReactNode;
+        loading?: boolean;
+        activated?: boolean;
+        selected?: boolean;
+        archived?: boolean;
+        onClick?(): void;
+        onDoubleClick?(): void;
+    }>;
+}
+interface IItemArray {
+    itemRow: Array<{
+        content: React.ReactNode;
+    }>;
+    border?: boolean;
+    fullwidth?: boolean;
+}
+declare class ContentList extends React.PureComponent<IProps> {
+    render(): JSX.Element;
+}
+export { ContentList, ContentListItem };

package/react/components/Lists/ContentList.js

@@ -0,0 +1,110 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.ContentListItem = exports.ContentList = void 0;
+var React = __importStar(require("react"));
+var classnames_1 = __importDefault(require("classnames"));
+var ContentListItem = /** @class */ (function (_super) {
+    __extends(ContentListItem, _super);
+    function ContentListItem() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.delay = 200;
+        _this.prevent = false;
+        _this.onSingleClick = function () {
+            _this.timer = setTimeout(function () {
+                if (!_this.prevent) {
+                    if (_this.props.onClick) {
+                        _this.props.onClick();
+                    }
+                }
+            }, _this.delay);
+        };
+        _this.onDoubleClick = function () {
+            clearTimeout(_this.timer);
+            _this.prevent = true;
+            if (_this.props.onDoubleClick) {
+                _this.props.onDoubleClick();
+            }
+            setTimeout(function () {
+                _this.prevent = false;
+            }, _this.delay);
+        };
+        _this.onActionMenuClick = function (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        };
+        return _this;
+    }
+    ContentListItem.prototype.render = function () {
+        var classes = (0, classnames_1.default)('sd-list-item sd-shadow--z1', {
+            'sd-list-item--activated': this.props.activated,
+            'sd-list-item--selected': this.props.selected,
+            'fetched': this.props.archived,
+            'actioning': this.props.loading,
+        });
+        return (React.createElement("div", { role: 'listitem', className: classes, onClick: this.onSingleClick, onDoubleClick: this.onDoubleClick },
+            this.props.locked
+                ? React.createElement("div", { className: "sd-list-item__border sd-list-item__border--locked" })
+                : React.createElement("div", { className: "sd-list-item__border" }),
+            this.props.itemColum.map(function (item, index) {
+                return React.createElement("div", { className: "sd-list-item__column ".concat(item.fullwidth && 'sd-list-item__column--grow', " ").concat(!item.border && 'sd-list-item__column--no-border'), key: index }, item.itemRow.map(function (e, i) {
+                    return (item.itemRow.length <= 1
+                        ? React.createElement(React.Fragment, { key: i }, e.content)
+                        : React.createElement("div", { className: "sd-list-item__row", key: i }, e.content));
+                }));
+            }),
+            React.createElement("div", { className: "sd-list-item__action-menu", onClick: this.onActionMenuClick }, this.props.action)));
+    };
+    return ContentListItem;
+}(React.PureComponent));
+exports.ContentListItem = ContentListItem;
+var ContentList = /** @class */ (function (_super) {
+    __extends(ContentList, _super);
+    function ContentList() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ContentList.prototype.render = function () {
+        var classes = (0, classnames_1.default)('sd-list-item-group sd-list-item-group--space-between-items');
+        return (React.createElement("div", { role: 'list', className: classes }, this.props.items.map(function (item, index) {
+            return React.createElement(ContentListItem, { key: index, itemColum: item.itemColum, locked: item.locked, action: item.action, loading: item.loading, activated: item.activated, selected: item.selected, archived: item.archived, onClick: item.onClick, onDoubleClick: item.onDoubleClick });
+        })));
+    };
+    return ContentList;
+}(React.PureComponent));
+exports.ContentList = ContentList;

package/react/components/Lists/TableList.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { DropResult } from "react-beautiful-dnd";
+import { IMenuItem, ISubmenu, IMenuGroup } from '../Dropdown';
+export interface IProps {
+    array: Array<IPropsArrayItem>;
+    addItem?: boolean;
+    dragAndDrop?: boolean;
+    className?: string;
+    readOnly?: boolean;
+    showDragHandle?: 'always' | 'onHover' | 'none';
+    append?: boolean;
+    onDrag?(start: number, end: number): void;
+    onAddItem?(index: number, item?: IPropsArrayItem): void;
+    itemsDropdown?(index?: number): Array<IMenuItem | ISubmenu | IMenuGroup | 'divider'>;
+}
+export interface IPropsArrayItem {
+    start?: React.ReactNode;
+    center?: React.ReactNode;
+    end?: React.ReactNode;
+    action?: React.ReactNode;
+    hexColor?: string;
+    onClick?(): void;
+    onDoubleClick?(): void;
+    locked?: boolean;
+    positionLocked?: boolean;
+}
+interface IState {
+    items: Array<IPropsArrayItem>;
+}
+declare class TableList extends React.PureComponent<IProps, IState> {
+    constructor(props: IProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: IProps): void;
+    onDragEnd(result: DropResult): void | null;
+    dropDown(): JSX.Element;
+    render(): JSX.Element | null;
+}
+export interface IPropsItem {
+    start?: React.ReactNode;
+    center?: React.ReactNode;
+    end?: React.ReactNode;
+    action?: React.ReactNode;
+    addItem?: boolean;
+    dragAndDrop?: boolean;
+    hexColor?: string;
+    showDragHandle?: 'always' | 'onHover' | 'none';
+    locked?: boolean;
+    positionLocked?: boolean;
+    onClick?(): void;
+    onDoubleClick?(): void;
+    onSelect?(): void;
+    onAddItem?(e: number): void;
+    itemsDropdown?(index?: number): Array<IMenuItem | ISubmenu | IMenuGroup | 'divider'>;
+}
+declare class TableListItem extends React.PureComponent<IPropsItem> {
+    private timer;
+    private delay;
+    private prevent;
+    onSingleClick: () => void;
+    onDoubleClick: () => void;
+    onActionMenuClick: (event: React.MouseEvent<HTMLElement>) => void;
+    render(): JSX.Element;
+}
+export { TableList, TableListItem };

package/react/components/Lists/TableList.js

@@ -0,0 +1,240 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    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.TableListItem = exports.TableList = void 0;
+var React = __importStar(require("react"));
+var classnames_1 = __importDefault(require("classnames"));
+var react_beautiful_dnd_1 = require("react-beautiful-dnd");
+var Tooltip_1 = require("../Tooltip");
+var Button_1 = require("../Button");
+var Dropdown_1 = require("../Dropdown");
+var react_dom_1 = __importDefault(require("react-dom"));
+var reorder = function (list, startIndex, endIndex) {
+    var result = Array.from(list);
+    var removed = result.splice(startIndex, 1)[0];
+    result.splice(endIndex, 0, removed);
+    return result;
+};
+var TableList = /** @class */ (function (_super) {
+    __extends(TableList, _super);
+    function TableList(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            items: [],
+        };
+        _this.onDragEnd = _this.onDragEnd.bind(_this);
+        _this.dropDown = _this.dropDown.bind(_this);
+        return _this;
+    }
+    TableList.prototype.componentDidMount = function () {
+        if (this.props.array) {
+            this.setState({ items: this.props.array });
+        }
+    };
+    TableList.prototype.componentDidUpdate = function (prevProps) {
+        if (this.props.array) {
+            if (prevProps.array !== this.props.array) {
+                this.setState({
+                    items: this.props.array,
+                });
+            }
+        }
+    };
+    TableList.prototype.onDragEnd = function (result) {
+        if (!result.destination) {
+            return;
+        }
+        var items = reorder(this.state.items, result.source.index, result.destination.index);
+        this.setState({
+            items: items,
+        });
+        return this.props.onDrag ?
+            this.props.onDrag(result.source.index, result.destination.index) : null;
+    };
+    TableList.prototype.dropDown = function () {
+        return (React.createElement(Dropdown_1.Dropdown, { items: this.props.itemsDropdown ? this.props.itemsDropdown() : [] },
+            React.createElement(Button_1.Button, { type: "primary", icon: "plus-large", text: "Add item", size: "small", shape: "round", iconOnly: true, onClick: function () { return false; } })));
+    };
+    TableList.prototype.render = function () {
+        var _a;
+        var _this = this;
+        var classes = (0, classnames_1.default)('', (_a = {
+                'table-list': !this.props.addItem,
+                'table-list--read-only': this.props.readOnly
+            },
+            _a["".concat(this.props.className)] = this.props.className,
+            _a));
+        return (this.state.items.length > 0
+            ? this.props.dragAndDrop
+                ? React.createElement(react_beautiful_dnd_1.DragDropContext, { onDragEnd: this.onDragEnd },
+                    React.createElement(react_beautiful_dnd_1.Droppable, { droppableId: "droppable" }, function (provided, _snapshot) { return (React.createElement("div", __assign({ role: 'list', className: classes, ref: provided.innerRef }, provided.droppableProps),
+                        _this.state.items.map(function (item, index) { return (React.createElement(react_beautiful_dnd_1.Draggable, { key: index, draggableId: "".concat(index), index: index }, function (provided2, snapshot) { return (_this.props.append
+                            ? React.createElement(PortalItem, { provided: provided2, snapshot: snapshot, item: item, index: index, dragAndDrop: _this.props.dragAndDrop, showDragHandle: _this.props.showDragHandle, addItem: _this.props.addItem, onAddItem: function () { return _this.props.onAddItem
+                                    && _this.props.onAddItem(index, item); }, itemsDropdown: function () { return _this.props.itemsDropdown
+                                    ? _this.props.itemsDropdown(index)
+                                    : []; } })
+                            : React.createElement("div", __assign({ ref: provided2.innerRef }, provided2.draggableProps, provided2.dragHandleProps),
+                                React.createElement(TableListItem, { dragAndDrop: _this.props.dragAndDrop, start: item.start, center: item.center, end: item.end, action: item.action, onClick: item.onClick ? item.onClick : undefined, onDoubleClick: item.onDoubleClick
+                                        ? item.onDoubleClick
+                                        : undefined, addItem: _this.props.addItem, itemsDropdown: function () { return _this.props.itemsDropdown
+                                        ? _this.props.itemsDropdown(index)
+                                        : []; }, hexColor: item.hexColor, locked: item.locked, positionLocked: item.positionLocked, onAddItem: function () { return _this.props.onAddItem
+                                        && _this.props.onAddItem(index, item); }, showDragHandle: _this.props.showDragHandle }))); })); }),
+                        provided.placeholder,
+                        (_this.props.addItem && !_this.props.readOnly) &&
+                            React.createElement("div", { className: "table-list__add-item table-list__item--margin" },
+                                React.createElement(Tooltip_1.Tooltip, { text: 'Add item', flow: 'top', appendToBody: true },
+                                    React.createElement("div", { className: 'table-list__add-item--container sd-margin-x--auto' }, _this.dropDown()))))); }))
+                : React.createElement("div", { role: 'list', className: classes },
+                    this.state.items.map(function (item, index) { return (React.createElement(TableListItem, { key: index, start: item.start, center: item.center, end: item.end, action: item.action, onClick: item.onClick ? item.onClick : undefined, onDoubleClick: item.onDoubleClick
+                            ? item.onDoubleClick
+                            : undefined, addItem: _this.props.addItem, itemsDropdown: function () { return _this.props.itemsDropdown ? _this.props.itemsDropdown(index) : []; }, hexColor: item.hexColor, locked: item.locked, positionLocked: item.positionLocked, onAddItem: function () { return _this.props.onAddItem
+                            && _this.props.onAddItem(index, item); } })); }),
+                    (this.props.addItem && !this.props.readOnly) &&
+                        React.createElement("div", { className: "table-list__add-item table-list__item--margin" },
+                            React.createElement(Tooltip_1.Tooltip, { text: 'Add item', flow: 'top', appendToBody: true },
+                                React.createElement("div", { className: 'table-list__add-item--container sd-margin-x--auto' }, this.dropDown()))))
+            : (this.props.addItem && !this.props.readOnly) ? React.createElement("div", { role: 'list', className: classes },
+                React.createElement("div", { className: "table-list__add-item table-list__item--margin" },
+                    React.createElement(Tooltip_1.Tooltip, { text: 'Add item', flow: 'top', appendToBody: true },
+                        React.createElement("div", { className: 'table-list__add-item--container sd-margin-x--auto' }, this.dropDown()))))
+                : null);
+    };
+    return TableList;
+}(React.PureComponent));
+exports.TableList = TableList;
+var TableListItem = /** @class */ (function (_super) {
+    __extends(TableListItem, _super);
+    function TableListItem() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.delay = 200;
+        _this.prevent = false;
+        _this.onSingleClick = function () {
+            _this.timer = setTimeout(function () {
+                if (!_this.prevent) {
+                    if (_this.props.onClick) {
+                        _this.props.onClick();
+                    }
+                }
+            }, _this.delay);
+        };
+        _this.onDoubleClick = function () {
+            clearTimeout(_this.timer);
+            _this.prevent = true;
+            if (_this.props.onDoubleClick) {
+                _this.props.onDoubleClick();
+            }
+            setTimeout(function () {
+                _this.prevent = false;
+            }, _this.delay);
+        };
+        _this.onActionMenuClick = function (event) {
+            event.preventDefault();
+            event.stopPropagation();
+        };
+        return _this;
+    }
+    TableListItem.prototype.render = function () {
+        var _this = this;
+        var classes = (0, classnames_1.default)('table-list__item', {
+            'table-list__item--clickable': this.props.onClick,
+            'table-list__item--draggable': this.props.dragAndDrop,
+            'table-list__item--locked': this.props.locked,
+            'table-list__item--position-locked': this.props.positionLocked,
+            'table-list__item--drag-handles-always': !this.props.showDragHandle,
+            'table-list__item--drag-handles-none': this.props.showDragHandle === 'none',
+        });
+        return (this.props.addItem ?
+            React.createElement("div", { className: 'table-list__item-container' },
+                React.createElement("div", { role: 'listitem', onClick: function () { return _this.onSingleClick(); }, onDoubleClick: function () { return _this.onDoubleClick(); }, className: classes },
+                    React.createElement("div", { className: 'table-list__item-border', style: { backgroundColor: this.props.hexColor } }),
+                    React.createElement("div", { className: 'table-list__item-content' },
+                        React.createElement("div", { className: 'table-list__item-content-block' }, this.props.start && this.props.start),
+                        React.createElement("div", { className: 'table-list__item-content-block table-list__item-content-block--center' }, this.props.center && this.props.center),
+                        React.createElement("div", { className: 'table-list__item-content-block' }, this.props.end && this.props.end)),
+                    this.props.action && React.createElement("div", { className: 'table-list__slide-in-actions', onClick: this.onActionMenuClick }, this.props.action)),
+                React.createElement("div", { className: 'table-list__add-bar-container' },
+                    React.createElement(Tooltip_1.Tooltip, { text: 'Add item', flow: 'top', appendToBody: true },
+                        React.createElement("div", { className: 'table-list__add-bar' },
+                            React.createElement(Dropdown_1.Dropdown, { onChange: this.props.onAddItem, items: this.props.itemsDropdown ? this.props.itemsDropdown() : [] },
+                                React.createElement(Button_1.Button, { type: "primary", icon: "plus-large", text: "Add item", size: "small", shape: "round", iconOnly: true, onClick: function () { return false; } }))))))
+            : React.createElement("div", { role: 'listitem', className: "".concat(classes, " table-list__item--margin"), onClick: function () { return _this.onSingleClick(); }, onDoubleClick: function () { return _this.onDoubleClick(); } },
+                React.createElement("div", { className: 'table-list__item-border', style: { backgroundColor: this.props.hexColor } }),
+                React.createElement("div", { className: 'table-list__item-content' },
+                    React.createElement("div", { className: 'table-list__item-content-block' }, this.props.start && this.props.start),
+                    React.createElement("div", { className: 'table-list__item-content-block table-list__item-content-block--center' }, this.props.center && this.props.center),
+                    React.createElement("div", { className: 'table-list__item-content-block' }, this.props.end && this.props.end)),
+                this.props.action && React.createElement("div", { className: 'table-list__slide-in-actions', onClick: this.onActionMenuClick }, this.props.action)));
+    };
+    return TableListItem;
+}(React.PureComponent));
+exports.TableListItem = TableListItem;
+var PortalItem = /** @class */ (function (_super) {
+    __extends(PortalItem, _super);
+    function PortalItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PortalItem.prototype.render = function () {
+        var _this = this;
+        var provided = this.props.provided;
+        var snapshot = this.props.snapshot;
+        var usePortal = snapshot.isDragging;
+        var child = (React.createElement("div", __assign({ ref: provided.innerRef }, provided.draggableProps, provided.dragHandleProps),
+            React.createElement(TableListItem, { dragAndDrop: this.props.dragAndDrop, start: this.props.item.start, center: this.props.item.center, end: this.props.item.end, action: this.props.item.action, onClick: this.props.item.onClick ? this.props.item.onClick : undefined, onDoubleClick: this.props.item.onDoubleClick
+                    ? this.props.item.onDoubleClick
+                    : undefined, addItem: this.props.addItem, itemsDropdown: this.props.itemsDropdown, hexColor: this.props.item.hexColor, locked: this.props.item.locked, positionLocked: this.props.item.positionLocked, onAddItem: function () { return _this.props.onAddItem; }, showDragHandle: this.props.showDragHandle })));
+        if (!usePortal) {
+            return child;
+        }
+        // if dragging - put the item in a portal
+        return react_dom_1.default.createPortal(child, document.body);
+    };
+    return PortalItem;
+}(React.PureComponent));

package/react/components/Menu.js

@@ -104,7 +104,7 @@ var Menu = /** @class */ (function (_super) {
     Menu.prototype.render = function () {
         var _this = this;
         var _a;
-        return (React.createElement("div", null,
+        return (React.createElement(React.Fragment, null,
             this.props.children(this.toggle),
             React.createElement("div", { onKeyDown: function (event) {
                     if (event.key === 'Escape') {