dareway-rui/build/taglib/collapsibleTree/utils/generator.js

'use strict';

var _interopRequireDefault = require('@babel/runtime/helpers/interopRequireDefault');

Object.defineProperty(exports, '__esModule', {
    value: true
});
exports.generateTreeNodeContents = generateTreeNodeContents;
exports.generateTreeNodes = generateTreeNodes;
exports.generateBreadCrumb = generateBreadCrumb;

var _react = _interopRequireDefault(require('react'));

var _antd = require('antd');

var _ruiIcon = _interopRequireDefault(require('rui-icon'));

var _VMPathContext = _interopRequireDefault(require('../../vmPath/VMPathContext'));

var _WrapContentWrapperWithFocus = _interopRequireDefault(require('../view/WrapContentWrapperWithFocus'));

function generateTreeNodeContent(node, selectedTreeNodeName) {
    var name = node.name,
        isLoaded = node.isLoaded,
        component = node.component,
        vmPath = node.vmPath,
        params = node.params;
    return _react.default.createElement(
        _VMPathContext.default.Provider,
        {
            value: vmPath,
            key: 'vm_provider_'.concat(name)
        },
        _react.default.createElement(_WrapContentWrapperWithFocus.default, {
            key: name,
            name: name,
            load: isLoaded,
            hidden: name != selectedTreeNodeName,
            component: component,
            params: params
        })
    );
}

function generateTreeNodeContents(treeNodes, selectedTreeNodeName) {
    var contents = [];

    for (var i = 0; i < treeNodes.length; i++) {
        contents.push(generateTreeNodeContent(treeNodes[i], selectedTreeNodeName));

        if ('children' in treeNodes[i] && treeNodes[i].children) {
            contents = contents.concat(generateTreeNodeContents(treeNodes[i].children, selectedTreeNodeName));
        }
    }

    return contents;
}

function generateTreeNode(node, laneId, showVMPath) {
    var name = node.name,
        title = node.title,
        iconId = node.iconId,
        vmPath = node.vmPath;
    return _react.default.createElement(
        _antd.Menu.Item,
        {
            key: name,
            className: 'dw-collapsible-tree-item'
        },
        _react.default.createElement(
            'span',
            {
                onContextMenu: function onContextMenu(e) {
                    showVMPath(e, vmPath, laneId);
                },
                title: title
            },
            _react.default.createElement(_ruiIcon.default, {
                type: iconId,
                style: {
                    fontSize: 14,
                    lineHeight: '14px',
                    color: '#ccc'
                },
                theme: 'filled'
            }),
            _react.default.createElement('span', null, title)
        )
    );
}

function generateTreeNodeGroup(node, children) {
    var name = node.name,
        title = node.title,
        iconId = node.iconId;
    return _react.default.createElement(
        _antd.Menu.SubMenu,
        {
            key: name,
            className: 'dw-collapsible-tree-item-group',
            title: _react.default.createElement(
                'span',
                {
                    title: title
                },
                _react.default.createElement(_ruiIcon.default, {
                    type: iconId,
                    style: {
                        fontSize: 14,
                        lineHeight: '14px',
                        color: '#ccc'
                    },
                    theme: 'outlined'
                }),
                _react.default.createElement('span', null, title)
            )
        },
        children
    );
}

function generateTreeNodes(treeNodes, laneId, showVMPath) {
    var nodeJsx = [];

    for (var i = 0; i < treeNodes.length; i++) {
        var node = treeNodes[i];

        if ('children' in node && node.children) {
            nodeJsx.push(generateTreeNodeGroup(node, generateTreeNodes(node.children, laneId, showVMPath)));
        } else {
            nodeJsx.push(generateTreeNode(node, laneId, showVMPath));
        }
    }

    return nodeJsx;
}

function generateBreadCrumbItem(title) {
    return _react.default.createElement(_antd.Breadcrumb.Item, null, title);
}

function generateBreadCrumbItems(treeNodes, selectedTreeNodeName) {
    var breadCrumbItems = [];

    for (var i = 0; i < treeNodes.length; i++) {
        var node = treeNodes[i];

        if (node.name == selectedTreeNodeName) {
            breadCrumbItems.push(generateBreadCrumbItem(node.title));
            break;
        }

        if ('children' in node && node.children) {
            var items = generateBreadCrumbItems(node.children, selectedTreeNodeName);

            if (items.length > 0) {
                breadCrumbItems.push(generateBreadCrumbItem(node.title));
                breadCrumbItems = breadCrumbItems.concat(items);
                break;
            }
        }
    }

    return breadCrumbItems;
}

function generateBreadCrumb(treeNodes, selectedTreeNodeName) {
    return _react.default.createElement(
        _antd.Breadcrumb,
        {
            style: {
                margin: '5px 0px'
            }
        },
        generateBreadCrumbItems(treeNodes, selectedTreeNodeName)
    );
}

//@ sourceMappingURL=generator.js.map