superdesk-ui-framework 2.4.21 → 3.0.0-rc12

package/react/components/Tooltip.js

@@ -3,10 +3,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());
@@ -38,7 +40,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 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.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    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;
 };
@@ -61,18 +63,20 @@ exports.Tooltip = void 0;
 var React = __importStar(require("react"));
 var react_id_generator_1 = __importDefault(require("react-id-generator"));
 var tooltip_1 = require("@superdesk/primereact/tooltip");
-exports.Tooltip = function (_a) {
-    var appendToBody = _a.appendToBody, children = _a.children, otherProps = __rest(_a, ["appendToBody", "children"]);
-    return appendToBody ?
-        React.createElement(TooltipAppended, __assign({}, otherProps), children)
-        :
-            React.createElement(TooltipBasic, __assign({}, otherProps), children);
+var Tooltip = function (_a) {
+    var appendToBody = _a.appendToBody, children = _a.children, disabled = _a.disabled, otherProps = __rest(_a, ["appendToBody", "children", "disabled"]);
+    return disabled
+        ? React.createElement(React.Fragment, null, children)
+        : appendToBody
+            ? React.createElement(TooltipAppended, __assign({}, otherProps), children)
+            : React.createElement(TooltipBasic, __assign({}, otherProps), children);
 };
+exports.Tooltip = Tooltip;
 var TooltipBasic = /** @class */ (function (_super) {
     __extends(TooltipBasic, _super);
     function TooltipBasic() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.htmlId = react_id_generator_1.default();
+        _this.htmlId = (0, react_id_generator_1.default)();
         return _this;
     }
     TooltipBasic.prototype.componentDidMount = function () {
@@ -94,7 +98,7 @@ var TooltipBasic = /** @class */ (function (_super) {
 }(React.PureComponent));
 var TooltipAppended = function (_a) {
     var children = _a.children, flow = _a.flow, text = _a.text;
-    var htmlId = react_id_generator_1.default();
+    var htmlId = (0, react_id_generator_1.default)();
     var triggerId = "t" + htmlId;
     var position = flow === "down" ? "bottom" : flow;
     return (React.createElement(React.Fragment, null,

package/react/components/TreeSelect.d.ts

@@ -0,0 +1,82 @@
+import * as React from "react";
+interface IState<T> {
+    value: Array<T>;
+    options: Array<ITreeNode<T>>;
+    firstBranchOptions: Array<any>;
+    openDropdown: boolean;
+    activeTree: Array<any>;
+    filterArr: Array<any>;
+    searchFieldValue: string;
+    buttonTree: Array<any>;
+    buttonValue: any;
+    buttonMouseEvent: boolean;
+    loading: boolean;
+}
+interface IPropsBase<T> {
+    value?: Array<T>;
+    selectBranchWithChildren?: boolean;
+    readOnly?: boolean;
+    width?: string;
+    allowMultiple?: boolean;
+    loading?: boolean;
+    singleLevelSearch?: boolean;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    invalid?: boolean;
+    inlineLabel?: boolean;
+    labelHidden?: boolean;
+    tabindex?: number;
+    fullWidth?: boolean;
+    info?: string;
+    error?: string;
+    required?: boolean;
+    label?: string;
+    disabled?: boolean;
+    getLabel(item: T): string;
+    getId(item: T): string;
+    getBackgroundColor?(item: T): string;
+    getBorderColor?(item: T): string;
+    optionTemplate?(item: T): React.ComponentType<T> | JSX.Element;
+    valueTemplate?(item: T, Wrapper: any): React.ComponentType<T> | JSX.Element;
+    onChange(e: Array<T>): void;
+}
+interface IPropsSync<T> extends IPropsBase<T> {
+    kind: 'synchronous';
+    getOptions(): Array<ITreeNode<T>>;
+}
+interface IPropsAsync<T> extends IPropsBase<T> {
+    kind: 'asynchronous';
+    getOptions?(): Array<ITreeNode<T>>;
+    searchOptions(term: string, callback?: (options: Array<ITreeNode<T>>) => void): any;
+}
+declare type IProps<T> = IPropsSync<T> | IPropsAsync<T>;
+export interface ITreeNode<T> {
+    value: T;
+    children?: Array<ITreeNode<T>>;
+}
+export declare class TreeSelect<T> extends React.Component<IProps<T>, IState<T>> {
+    private dropdownRef;
+    private openDropdownRef;
+    private htmlId;
+    private popperInstance;
+    constructor(props: IProps<T>);
+    componentDidMount: () => void;
+    componentDidUpdate(prevProps: Readonly<IProps<T>>, prevState: Readonly<IState<T>>): void;
+    toggleMenu(): void;
+    removeClick(i: number): void;
+    handleMultiLevel(item: ITreeNode<T>): void;
+    handleButton(item: ITreeNode<T>): void;
+    handleValue(event: React.MouseEvent<HTMLLIElement, MouseEvent>, item: ITreeNode<T>): void;
+    handleBranchValue(event: React.MouseEvent<HTMLButtonElement, MouseEvent>, item: ITreeNode<T>): void;
+    handleTree(event: React.MouseEvent<HTMLLIElement, MouseEvent>, option: ITreeNode<T>): void;
+    backButton: () => false | undefined;
+    backButtonValue: () => void;
+    recursion(arr: Array<ITreeNode<T>>): void;
+    filteredItem(arr: Array<ITreeNode<T>>): JSX.Element | JSX.Element[] | undefined;
+    banchButton(): JSX.Element;
+    private debounceFn;
+    private ICancelFn;
+    handleDebounce(): void;
+    render(): JSX.Element;
+}
+export {};

package/react/components/TreeSelect.js

@@ -0,0 +1,521 @@
+"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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSelect = void 0;
+var React = __importStar(require("react"));
+var Icon_1 = require("./Icon");
+var Loader_1 = require("./Loader");
+var react_id_generator_1 = __importDefault(require("react-id-generator"));
+var debounce_1 = __importDefault(require("lodash/debounce"));
+var Form_1 = require("./Form");
+var core_1 = require("@popperjs/core");
+var lodash_1 = require("lodash");
+var Label_1 = require("./Label");
+var TreeSelect = /** @class */ (function (_super) {
+    __extends(TreeSelect, _super);
+    function TreeSelect(props) {
+        var _this = _super.call(this, props) || this;
+        _this.htmlId = (0, react_id_generator_1.default)();
+        _this.componentDidMount = function () {
+            _this.recursion(_this.state.options);
+            document.addEventListener("mousedown", function (event) {
+                if ((_this.dropdownRef.current && !_this.dropdownRef.current.contains(event.target))
+                    && (_this.openDropdownRef.current && !_this.openDropdownRef.current.contains(event.target))) {
+                    _this.setState({ openDropdown: false });
+                }
+            });
+        };
+        _this.backButton = function () {
+            if (_this.state.activeTree.length > 0) {
+                _this.setState({
+                    options: _this.state.activeTree.pop(),
+                });
+                return;
+            }
+            else {
+                return false;
+            }
+        };
+        _this.backButtonValue = function () {
+            _this.setState({
+                buttonValue: _this.state.buttonTree.pop(),
+            });
+        };
+        _this.debounceFn = (0, debounce_1.default)(_this.handleDebounce, 500);
+        _this.state = {
+            value: _this.props.value ? _this.props.value : [],
+            options: _this.props.getOptions ? _this.props.getOptions() : [],
+            firstBranchOptions: _this.props.getOptions ? _this.props.getOptions() : [],
+            activeTree: [],
+            filterArr: [],
+            searchFieldValue: '',
+            buttonTree: [],
+            buttonValue: [],
+            buttonMouseEvent: false,
+            openDropdown: false,
+            loading: false,
+            // provera: false
+        };
+        _this.removeClick = _this.removeClick.bind(_this);
+        _this.handleMultiLevel = _this.handleMultiLevel.bind(_this);
+        _this.backButton = _this.backButton.bind(_this);
+        _this.handleButton = _this.handleButton.bind(_this);
+        _this.backButtonValue = _this.backButtonValue.bind(_this);
+        _this.handleTree = _this.handleTree.bind(_this);
+        _this.filteredItem = _this.filteredItem.bind(_this);
+        _this.banchButton = _this.banchButton.bind(_this);
+        _this.handleDebounce = _this.handleDebounce.bind(_this);
+        _this.toggleMenu = _this.toggleMenu.bind(_this);
+        _this.dropdownRef = React.createRef();
+        _this.openDropdownRef = React.createRef();
+        return _this;
+    }
+    TreeSelect.prototype.componentDidUpdate = function (prevProps, prevState) {
+        if (!(0, lodash_1.isEqual)(prevState.value, this.state.value)) {
+            this.props.onChange(this.state.value);
+        }
+        else if (!(0, lodash_1.isEqual)(prevProps.value, this.props.value)) {
+            this.props.onChange(this.state.value);
+        }
+        if (prevState.openDropdown !== this.state.openDropdown) {
+            this.toggleMenu();
+        }
+        if (this.props.kind === 'synchronous') {
+            if ((prevState.activeTree !== this.state.activeTree)
+                || (prevState.filterArr !== this.state.filterArr)
+                || (prevState.options !== this.state.options)) {
+                this.popperInstance.update();
+            }
+        }
+    };
+    TreeSelect.prototype.toggleMenu = function () {
+        if (this.state.openDropdown) {
+            if (this.openDropdownRef.current && this.dropdownRef.current) {
+                this.popperInstance = (0, core_1.createPopper)(this.openDropdownRef.current, this.dropdownRef.current, {
+                    placement: 'bottom-start',
+                    modifiers: [
+                        {
+                            name: 'offset',
+                            options: {
+                                offset: [-4, 4],
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+    };
+    TreeSelect.prototype.removeClick = function (i) {
+        var newTags = this.state.value;
+        newTags === null || newTags === void 0 ? void 0 : newTags.splice(i, 1);
+        this.setState({
+            value: newTags,
+        });
+        this.props.onChange(this.state.value);
+    };
+    TreeSelect.prototype.handleMultiLevel = function (item) {
+        if (item.children) {
+            this.setState({
+                activeTree: __spreadArray(__spreadArray([], this.state.activeTree, true), [this.state.options], false),
+                options: item.children,
+            });
+        }
+    };
+    TreeSelect.prototype.handleButton = function (item) {
+        this.setState({
+            buttonTree: __spreadArray(__spreadArray([], this.state.buttonTree, true), [this.state.buttonValue], false),
+            buttonValue: item,
+        });
+    };
+    TreeSelect.prototype.handleValue = function (event, item) {
+        var _this = this;
+        if (this.props.allowMultiple) {
+            var checkItem = this.state.value.find(function (valueItem) {
+                return _this.props.getId(valueItem) === _this.props.getId(item.value);
+            });
+            if (!checkItem) {
+                this.setState({ value: __spreadArray(__spreadArray([], this.state.value, true), [item.value], false) });
+            }
+            if (!event.ctrlKey) {
+                if (this.props.getOptions) {
+                    this.setState({ options: this.state.firstBranchOptions, activeTree: [], openDropdown: false });
+                }
+                else {
+                    this.setState({ activeTree: [], openDropdown: false });
+                }
+            }
+            this.setState({ buttonMouseEvent: false });
+        }
+        else {
+            var checkItem = this.state.value.find(function (valueItem) {
+                return _this.props.getId(valueItem) === _this.props.getId(item.value);
+            });
+            if (!checkItem) {
+                this.setState({ value: [item.value] });
+            }
+            if (!event.ctrlKey) {
+                this.setState({ options: this.state.firstBranchOptions, activeTree: [], openDropdown: false });
+            }
+            this.setState({ buttonMouseEvent: false });
+        }
+    };
+    TreeSelect.prototype.handleBranchValue = function (event, item) {
+        var _this = this;
+        if (this.props.allowMultiple) {
+            if (this.props.selectBranchWithChildren) {
+                var checkItem = this.state.value.find(function (valueItem) {
+                    return _this.props.getId(valueItem) === _this.props.getId(item.value);
+                });
+                if (!checkItem) {
+                    this.setState({ value: __spreadArray(__spreadArray([], this.state.value, true), [item.value], false) });
+                }
+                if (!event.ctrlKey) {
+                    this.setState({ options: this.state.firstBranchOptions, activeTree: [], openDropdown: false });
+                }
+                this.setState({ buttonMouseEvent: false });
+            }
+        }
+        else {
+            if (this.props.selectBranchWithChildren) {
+                var checkItem = this.state.value.find(function (valueItem) {
+                    return _this.props.getId(valueItem) === _this.props.getId(item.value);
+                });
+                if (!checkItem) {
+                    this.setState({ value: [item.value] });
+                }
+                if (!event.ctrlKey) {
+                    this.setState({ options: this.state.firstBranchOptions, activeTree: [], openDropdown: false });
+                }
+                this.setState({ buttonMouseEvent: false });
+            }
+        }
+    };
+    TreeSelect.prototype.handleTree = function (event, option) {
+        var _this = this;
+        if (option.children) {
+            this.handleButton(option);
+            this.handleMultiLevel(option);
+            if (event.altKey && this.props.allowMultiple) {
+                if (this.props.selectBranchWithChildren) {
+                    var filteredItems_1 = [];
+                    option.children.forEach(function (item) {
+                        if (!_this.state.value.includes(item.value)) {
+                            filteredItems_1.push(item.value);
+                        }
+                    });
+                    this.setState({
+                        value: __spreadArray(__spreadArray([], this.state.value, true), filteredItems_1, true),
+                        options: this.state.firstBranchOptions,
+                        openDropdown: false,
+                        activeTree: [],
+                    });
+                }
+                else {
+                    var filteredItems_2 = [];
+                    option.children.forEach(function (item) {
+                        if (!_this.state.value.includes(item.value)
+                            && !item.children) {
+                            filteredItems_2.push(item.value);
+                        }
+                    });
+                    if (filteredItems_2.length > 0) {
+                        this.setState({
+                            value: __spreadArray(__spreadArray([], this.state.value, true), filteredItems_2, true),
+                            options: this.state.firstBranchOptions,
+                            openDropdown: false,
+                            activeTree: [],
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            this.handleValue(event, option);
+            if (!event.ctrlKey) {
+                this.setState({ openDropdown: false });
+            }
+        }
+    };
+    TreeSelect.prototype.recursion = function (arr) {
+        var _this = this;
+        arr.map(function (item) {
+            _this.state.filterArr.push(item);
+            if (item.children) {
+                _this.recursion(item.children);
+            }
+        });
+    };
+    TreeSelect.prototype.filteredItem = function (arr) {
+        var _this = this;
+        if (this.props.kind === 'synchronous') {
+            var filteredArr = arr.filter(function (item) {
+                if (_this.state.searchFieldValue) {
+                    if (_this.props.getLabel(item.value)
+                        .toLowerCase().includes(_this.state.searchFieldValue.toLowerCase())) {
+                        return item.value;
+                    }
+                    else {
+                        return;
+                    }
+                }
+                else {
+                    return item.value;
+                }
+            });
+            if (filteredArr.length === 0) {
+                return React.createElement("li", { className: "suggestion-item--nothing-found" }, "Nothing fonud");
+            }
+            else {
+                return filteredArr.map(function (option, i) {
+                    var selectedItem = _this.state.value.some(function (obj) {
+                        return _this.props.getId(obj) === _this.props.getId(option.value);
+                    });
+                    return React.createElement("li", { key: i, className: "suggestion-item suggestion-item--multi-select", onClick: function (event) {
+                            _this.setState({
+                                searchFieldValue: '',
+                            }),
+                                event.preventDefault();
+                            event.stopPropagation();
+                            _this.handleTree(event, option);
+                        } },
+                        _this.props.getBorderColor
+                            && React.createElement("div", { className: "item-border", style: { backgroundColor: _this.props.getBorderColor(option.value) } }),
+                        React.createElement("span", { style: _this.props.getBackgroundColor
+                                ? { backgroundColor: _this.props.getBackgroundColor(option.value),
+                                    color: (0, Label_1.getTextColor)(_this.props.getBackgroundColor(option.value)) }
+                                : undefined, className: 'suggestion-item--bgcolor'
+                                + (selectedItem ? ' suggestion-item--disabled' : '') }, _this.props.optionTemplate
+                            ? _this.props.optionTemplate(option.value)
+                            : _this.props.getLabel(option.value)),
+                        option.children && React.createElement("span", { className: "suggestion-item__icon" },
+                            React.createElement(Icon_1.Icon, { name: "chevron-right-thin" })));
+                });
+            }
+        }
+        else if (this.props.kind === 'asynchronous') {
+            return this.state.options.map(function (item, i) {
+                var selectedItem = _this.state.value.some(function (obj) {
+                    return _this.props.getId(obj) === _this.props.getId(item.value);
+                });
+                return (React.createElement("li", { key: i, className: "suggestion-item suggestion-item--multi-select", onClick: function (event) {
+                        _this.handleValue(event, item);
+                    } }, _this.props.optionTemplate
+                    ? _this.props.optionTemplate(item.value)
+                    : React.createElement("span", { className: selectedItem
+                            ? 'suggestion-item--disabled' : undefined }, _this.props.getLabel(item.value))));
+            });
+        }
+        else {
+            return;
+        }
+    };
+    TreeSelect.prototype.banchButton = function () {
+        var _this = this;
+        var selectedButton = this.state.value.some(function (obj) {
+            return _this.props.getId(obj) === _this.props.getId(_this.state.buttonValue.value);
+        });
+        if (!selectedButton) {
+            return React.createElement("button", { className: 'autocomplete__button' + (this.props.selectBranchWithChildren ? ' autocomplete__button--multi-select' : ''), onMouseOver: function () { return _this.setState({ buttonMouseEvent: true }); }, onMouseOut: function () { return _this.setState({ buttonMouseEvent: false }); }, value: this.state.buttonValue, onClick: function (event) { return _this.handleBranchValue(event, _this.state.buttonValue); } }, "Choose entire category");
+        }
+        else {
+            return React.createElement("button", { className: 'autocomplete__button' + (this.props.selectBranchWithChildren ? ' autocomplete__button--multi-select' : '') + ' autocomplete__button--disabled', value: this.state.buttonValue }, "Category selected");
+        }
+    };
+    TreeSelect.prototype.handleDebounce = function () {
+        var _this = this;
+        this.setState({ options: [] });
+        if (this.props.kind === 'asynchronous') {
+            if (this.state.searchFieldValue) {
+                this.setState({
+                    loading: true,
+                    // provera: false
+                });
+                this.ICancelFn = this.props.searchOptions(this.state.searchFieldValue, function (items) {
+                    // if (items.length === 0) {
+                    //     this.setState({provera: true, loading: false})
+                    // } else {
+                    _this.setState({ options: items, loading: false });
+                    _this.popperInstance.update();
+                    // }
+                });
+            }
+        }
+    };
+    TreeSelect.prototype.render = function () {
+        var _this = this;
+        return (React.createElement(Form_1.InputWrapper, { label: this.props.label, error: this.props.error, required: this.props.required, disabled: this.props.disabled, invalid: this.props.invalid, info: this.props.info, inlineLabel: this.props.inlineLabel, labelHidden: this.props.labelHidden, fullWidth: this.props.fullWidth, htmlId: this.htmlId, tabindex: this.props.tabindex },
+            React.createElement("div", { className: "tags-input tags-input--".concat(this.props.allowMultiple ? 'multi-select' : 'single-select', " sd-input__input") },
+                this.props.allowMultiple
+                    ? React.createElement("div", { className: "tags-input__tags" },
+                        this.props.readOnly
+                            || React.createElement("button", { ref: this.openDropdownRef, className: "tags-input__add-button", onClick: function () { return _this.setState({ openDropdown: !_this.state.openDropdown }); } },
+                                React.createElement("i", { className: "icon-plus-large" })),
+                        React.createElement("ul", { className: "tags-input__tag-list" }, this.state.value.map(function (item, i) {
+                            var Wrapper = function (_a) {
+                                var backgroundColor = _a.backgroundColor, children = _a.children;
+                                return (React.createElement("li", { className: "tags-input__tag-item tags-input__tag-item--multi-select"
+                                        + (_this.props.readOnly ? ' tags-input__tag-item--readonly' : ''), onClick: function () { return !_this.props.readOnly && _this.removeClick(i); }, style: _this.props.valueTemplate
+                                        ? { backgroundColor: backgroundColor }
+                                        : _this.props.getBackgroundColor
+                                            && { backgroundColor: _this.props.getBackgroundColor(item) } },
+                                    React.createElement("span", { style: { color: backgroundColor
+                                                ? (0, Label_1.getTextColor)(backgroundColor)
+                                                : _this.props.getBackgroundColor
+                                                    && (0, Label_1.getTextColor)(_this.props.getBackgroundColor(item)) }, className: "tags-input__helper-box" },
+                                        children,
+                                        !_this.props.readOnly && React.createElement("span", { className: "tags-input__remove-button" },
+                                            React.createElement(Icon_1.Icon, { name: "close-small" })))));
+                            };
+                            return (React.createElement(React.Fragment, { key: i }, _this.props.valueTemplate
+                                ? _this.props.valueTemplate(item, Wrapper)
+                                : React.createElement(Wrapper, null,
+                                    React.createElement("span", null, _this.props.getLabel(item)))));
+                        })),
+                        this.state.value.length > 0
+                            ? this.props.readOnly
+                                || React.createElement("button", { className: "tags-input__remove-value", style: { position: 'relative', bottom: '2px' }, onClick: function () { return _this.setState({ value: [] }); } },
+                                    React.createElement(Icon_1.Icon, { name: 'remove-sign' })) : null)
+                    : React.createElement("div", { className: "tags-input__tags" },
+                        this.props.readOnly
+                            || React.createElement("button", { className: "tags-input__overlay-button", ref: this.openDropdownRef, onClick: function () { return _this.setState({ openDropdown: !_this.state.openDropdown }); } }),
+                        this.state.value.length < 1 && React.createElement("span", { className: 'tags-input__single-item'
+                                + (this.props.readOnly ? ' tags-input__tag-item--readonly' : '') },
+                            React.createElement("span", { className: "tags-input__placeholder" }, this.props.placeholder)),
+                        this.state.value.map(function (item, i) {
+                            var Wrapper = function (_a) {
+                                var backgroundColor = _a.backgroundColor, borderColor = _a.borderColor, children = _a.children;
+                                return (React.createElement("span", { className: 'tags-input__single-item'
+                                        + (_this.props.readOnly ? ' tags-input__tag-item--readonly' : ''), onClick: function () { return _this.props.readOnly || _this.removeClick(i); } },
+                                    _this.props.getBorderColor
+                                        && React.createElement("div", { className: "item-border item-border-selected", style: borderColor
+                                                ? { backgroundColor: borderColor }
+                                                : { backgroundColor: _this.props.getBorderColor(item) } }),
+                                    React.createElement("span", { style: { color: backgroundColor && (0, Label_1.getTextColor)(backgroundColor) }, className: "tags-input__helper-box" },
+                                        React.createElement("span", { className: backgroundColor && "tags-input__tag-item", style: { backgroundColor: backgroundColor, margin: 0 } }, children),
+                                        _this.props.readOnly
+                                            || React.createElement("span", { className: "tags-input__remove-button" },
+                                                React.createElement(Icon_1.Icon, { name: 'remove-sign' })))));
+                            };
+                            return React.createElement(React.Fragment, { key: i }, _this.props.valueTemplate
+                                ? _this.props.valueTemplate(item, Wrapper)
+                                : React.createElement(Wrapper, null,
+                                    React.createElement("span", null, _this.props.getLabel(item))));
+                        })),
+                this.state.openDropdown
+                    && React.createElement("div", { className: "autocomplete autocomplete--multi-select" + (this.props.width === 'medium' ? ' autocomplete--fixed-width' : ''), ref: this.dropdownRef },
+                        React.createElement("div", { className: 'autocomplete__header' },
+                            React.createElement("div", { className: "autocomplete__icon", onClick: function () {
+                                    _this.backButtonValue();
+                                    _this.backButton();
+                                } },
+                                React.createElement(Icon_1.Icon, { name: "search", className: "search" })),
+                            React.createElement("div", { className: 'autocomplete__filter' },
+                                React.createElement("input", { placeholder: this.props.searchPlaceholder, type: "text", className: "autocomplete__input", ref: function (input) { return input && input.focus(); }, value: this.state.searchFieldValue, onChange: function (event) {
+                                        if (_this.props.kind === 'synchronous') {
+                                            _this.setState({ searchFieldValue: event.target.value });
+                                            _this.popperInstance.update();
+                                        }
+                                        else if (_this.props.kind === 'asynchronous') {
+                                            if (_this.ICancelFn) {
+                                                _this.ICancelFn();
+                                            }
+                                            _this.setState({ searchFieldValue: event.target.value, options: [] });
+                                            _this.popperInstance.update();
+                                            _this.debounceFn();
+                                        }
+                                        else {
+                                            return;
+                                        }
+                                        // if(!this.state.searchFieldValue) {
+                                        //     this.setState({provera: false});
+                                        // }
+                                    } }))),
+                        this.state.activeTree.length > 0
+                            && React.createElement("div", { className: 'autocomplete__category-header' },
+                                React.createElement("div", { className: "autocomplete__icon", onClick: function () {
+                                        _this.backButtonValue();
+                                        _this.backButton();
+                                    } },
+                                    React.createElement(Icon_1.Icon, { name: "arrow-left", className: "arrow-left" })),
+                                React.createElement("div", { className: 'autocomplete__filter' },
+                                    React.createElement("button", { className: 'autocomplete__category-title', value: this.state.buttonValue }, this.props.optionTemplate
+                                        ? this.props.optionTemplate(this.state.buttonValue.value)
+                                        : this.props.getLabel(this.state.buttonValue.value)),
+                                    this.props.selectBranchWithChildren && this.banchButton())),
+                        this.state.loading
+                            ? React.createElement("ul", { className: "suggestion-list--loader" },
+                                React.createElement(Loader_1.Loader, { overlay: true }))
+                            : this.state.searchFieldValue === ''
+                                ? this.props.getOptions
+                                    ? React.createElement("ul", { className: "suggestion-list suggestion-list--multi-select" }, this.state.options
+                                        .map(function (option, i) {
+                                        var selectedItem = _this.state.value.some(function (obj) {
+                                            return _this.props.getId(obj) === _this.props.getLabel(option.value);
+                                        });
+                                        return (React.createElement("li", { key: i, className: "suggestion-item suggestion-item--multi-select", onClick: function (event) {
+                                                event.preventDefault();
+                                                event.stopPropagation();
+                                                _this.handleTree(event, option);
+                                            } },
+                                            (_this.props.getBorderColor && !_this.props.allowMultiple) && React.createElement("div", { className: "item-border", style: { backgroundColor: _this.props.getBorderColor(option.value) } }),
+                                            React.createElement("span", { style: (_this.props.getBackgroundColor && option.value)
+                                                    ? { backgroundColor: _this.props.getBackgroundColor(option.value),
+                                                        color: (0, Label_1.getTextColor)(_this.props.getBackgroundColor(option.value)) }
+                                                    : undefined, className: 'suggestion-item--bgcolor'
+                                                    + (selectedItem ? ' suggestion-item--disabled' : '') }, _this.props.optionTemplate
+                                                ? _this.props.optionTemplate(option.value)
+                                                : _this.props.getLabel(option.value)),
+                                            option.children && React.createElement("span", { className: "suggestion-item__icon" },
+                                                React.createElement(Icon_1.Icon, { name: "chevron-right-thin" }))));
+                                    })) : null
+                                : React.createElement("ul", { className: "suggestion-list suggestion-list--multi-select" }, this.filteredItem(this.props.singleLevelSearch
+                                    ? this.state.options : this.state.filterArr))))));
+    };
+    return TreeSelect;
+}(React.Component));
+exports.TreeSelect = TreeSelect;