@wavemaker/app-runtime-wm-build 11.4.0-next.24577 → 11.4.0-next.24579

app-runtime-wm-build/wmapp/scripts/wm-loader.js

@@ -13440,21 +13440,19 @@
         __proto__: null,
         default: search_build
     });
-    var tagName$1o = "div";
+    var tagName$1o = "ul";
     transpiler.register("wm-tree", (function() {
         return {
             pre: function(attrs) {
-                return "<" + tagName$1o + " wmTree " + transpiler.getAttrMarkup(attrs) + ">";
+                return "<" + tagName$1o + ' wmTree class="ztree" ' + transpiler.getAttrMarkup(attrs) + ">";
             },
             post: function() {
                 return "</" + tagName$1o + ">";
             }
         };
     }));
-    var tree_build = function() {};
-    var tree_build$1 = Object.freeze({
-        __proto__: null,
-        default: tree_build
+    var tree_build = Object.freeze({
+        __proto__: null
     });
     var tagName$1n = "div";
     transpiler.register("wm-card", (function() {
@@ -16435,7 +16433,7 @@
     exports.tileBuild = tile_build$1;
     exports.timeBuild = time_build$1;
     exports.topNavBuild = topNav_build$1;
-    exports.treeBuild = tree_build$1;
+    exports.treeBuild = tree_build;
     exports.videoBuild = video_build$1;
     exports.wizardBuild = wizard_build$1;
     exports.wizardStepBuild = wizardStep_build$1;
@@ -22781,10 +22779,10 @@
 }));
 
 (function(global, factory) {
-    typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@angular/core"), require("@angular/common"), require("@wm/components/base"), require("@wm/core")) : typeof define === "function" && define.amd ? define("@wm/components/basic/tree", [ "exports", "@angular/core", "@angular/common", "@wm/components/base", "@wm/core" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
+    typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@angular/core"), require("@angular/common"), require("@wm/components/base")) : typeof define === "function" && define.amd ? define("@wm/components/basic/tree", [ "exports", "@angular/core", "@angular/common", "@wm/components/base" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
     factory((global.wm = global.wm || {}, global.wm.components = global.wm.components || {}, 
-    global.wm.components.basic = global.wm.components.basic || {}, global.wm.components.basic.tree = {}), global.ng.core, global.ng.common, global.wm.components.base, global.wm.core));
-})(this, (function(exports, core$1, common, base, core) {
+    global.wm.components.basic = global.wm.components.basic || {}, global.wm.components.basic.tree = {}), global.ng.core, global.ng.common, global.wm.components.base));
+})(this, (function(exports, core, common, base) {
     "use strict";
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -23161,352 +23159,333 @@
             value: 0
         }, base.PROP_NUMBER) ], [ "treeicons", base.PROP_STRING ] ]));
     };
-    var defaultTreeIconClass = "plus-minus";
-    var ICON_CLASSES = {
-        folder: {
-            expanded: "wi-folder-open",
-            collapsed: "wi-folder"
-        },
-        "circle-plus-minus": {
-            expanded: "wi-remove-circle-outline",
-            collapsed: "wi-add-circle-outline"
-        },
-        chevron: {
-            expanded: "wi-keyboard-arrow-down",
-            collapsed: "wi-keyboard-arrow-right"
-        },
-        menu: {
-            expanded: "wi-arrow-down",
-            collapsed: "wi-arrow-right"
-        },
-        triangle: {
-            expanded: "wi-arrow-drop-down-circle",
-            collapsed: "wi-play-circle-filled"
-        },
-        "expand-collapse": {
-            expanded: "wi-expand-less",
-            collapsed: "wi-expand-more"
-        },
-        "plus-minus": {
-            expanded: "wi-minus",
-            collapsed: "wi-plus"
-        }
-    };
     var WIDGET_INFO = {
         widgetType: "wm-tree",
         hostClass: "app-tree"
     };
-    var TreeDirective = function(_super) {
-        __extends(TreeDirective, _super);
-        function TreeDirective(inj, binddatavalue, bindnodelabel, bindnodeicon, bindnodechildren, bindnodeid) {
+    var defaultTreeIconClass = "plus-minus";
+    var TreeComponent = function(_super) {
+        __extends(TreeComponent, _super);
+        function TreeComponent(inj) {
             var _this = _super.call(this, inj, WIDGET_INFO) || this;
-            _this.binddatavalue = binddatavalue;
-            _this.bindnodelabel = bindnodelabel;
-            _this.bindnodeicon = bindnodeicon;
-            _this.bindnodechildren = bindnodechildren;
-            _this.bindnodeid = bindnodeid;
+            _this.setting = {
+                data: {
+                    simpleData: {
+                        enable: true
+                    }
+                },
+                view: {
+                    dblClickExpand: false,
+                    fontCss: {
+                        "font-awesome": true
+                    },
+                    switchIcon: {}
+                },
+                check: {},
+                callback: {}
+            };
             base.styler(_this.nativeElement, _this, base.APPLY_STYLES_TYPE.CONTAINER);
-            _this.bindEvents();
             return _this;
         }
-        TreeDirective.prototype.onPropertyChange = function(key, nv, ov) {
+        TreeComponent.prototype.onPropertyChange = function(key, nv, ov) {
             switch (key) {
               case "dataset":
                 this.nodes = this.getNodes(nv);
-                this._selectNode = undefined;
+                if (this.level > 0) {
+                    this.expandTree(this.level, this.nodes, 0);
+                }
                 this.renderTree();
                 break;
 
-              case "nodeicon":
-              case "nodelabel":
-              case "nodechildren":
-              case "orderby":
-                this.renderTree();
+              case "levels":
+                if (nv > 0) {
+                    this.level = nv;
+                }
                 break;
 
               case "treeicons":
-                this.changeTreeIcons(nv, ov);
+                this.treeicon = nv;
                 break;
 
-              case "datavalue":
-                this.selectById(nv);
+              case "nodelabel":
+                this.nodelabel = nv;
+                break;
+
+              case "icon":
+                this.nodeicon = nv;
+
+              case "orderby":
+                this.renderTree();
+                break;
+
+              case "class":
+                this.treeClass = nv;
                 break;
 
               default:
                 _super.prototype.onPropertyChange.call(this, key, nv, ov);
+                break;
             }
         };
-        TreeDirective.prototype.constructNodes = function(nodes, parent, levels, deep, _evalDataValue) {
+        TreeComponent.prototype.expandTree = function(level, node, childLevel) {
             var _this = this;
-            var $ul = $("<ul></ul>");
-            var _iconClses = ICON_CLASSES[this.treeicons || defaultTreeIconClass];
-            var _expr = this.binddatavalue || this.datavalue;
-            var _iconCls, _cls;
-            _cls = levels > 0 ? " expanded " : " collapsed ";
-            _iconCls = _cls + (levels > 0 ? _iconClses.expanded : _iconClses.collapsed);
-            deep = deep || 0;
-            parent.append($ul);
-            nodes.forEach((function(node, idx) {
-                var $li = $("<li></li>"), $iconNode = $("<i></i>"), nodeLabel = base.getEvaluatedData(node, {
-                    field: _this.nodelabel,
-                    bindExpression: _this.bindnodelabel
-                }, _this.viewParent) || node.label, nodeIcon = base.getEvaluatedData(node, {
-                    field: _this.nodeicon,
-                    bindExpression: _this.bindnodeicon
-                }, _this.viewParent) || node.icon, nodeChildren = base.getEvaluatedData(node, {
-                    field: _this.nodechildren,
-                    bindExpression: _this.bindnodechildren
-                }, _this.viewParent) || node.children;
-                var nodeIdValue = base.getEvaluatedData(node, {
-                    field: _this.nodeid,
-                    bindExpression: _this.bindnodeid
-                }, _this.viewParent);
-                if (nodeIdValue === undefined) {
-                    nodeIdValue = node.children;
-                }
-                var isNodeMatched = false, expandCollapseIcon;
-                $li.data("nodedata", node).append($iconNode).append('<span class="title">' + nodeLabel + "</span>").appendTo($ul);
-                if (_this.bindnodeid || _this.nodeid) {
-                    isNodeMatched = _this.binddatavalue ? nodeIdValue === _evalDataValue : nodeIdValue === _expr;
-                    if (nodeIdValue !== undefined) {
-                        $li.attr("id", nodeIdValue);
-                    }
-                } else if (_this.binddatavalue) {
-                    isNodeMatched = !!core.$parseExpr(_expr)(_this, node);
-                }
-                if (!_this._selectNode) {
-                    if (_expr === "FirstNode" && idx === 0 || !deep && _expr === "LastNode" && idx === nodes.length - 1 || isNodeMatched) {
-                        _this._selectNode = $li;
-                        _this.datavalue = nodeIdValue;
-                    }
-                }
-                if (nodeIcon) {
-                    $iconNode.addClass(nodeIcon);
-                }
-                if (nodeChildren && nodeChildren.length) {
-                    $li.addClass("parent-node " + _cls);
-                    expandCollapseIcon = $('<i class="wi ' + _iconCls + '"></i>');
-                    if (nodeIcon) {
-                        $iconNode.addClass(nodeIcon);
-                    }
-                    $li.prepend(expandCollapseIcon);
-                    _this.constructNodes(nodeChildren, $li, levels - 1, deep + 1, _evalDataValue);
+            node.map((function(childNode) {
+                if ("children" in childNode && !("open" in childNode) && childLevel < level) {
+                    childNode["open"] = true;
+                    _this.expandTree(level, childNode.children, childLevel + 1);
                 } else {
-                    if (!nodeIcon) {
-                        $iconNode.addClass("leaf-node");
-                    }
-                    $li.addClass("leaf-node");
+                    childLevel = 0;
+                    return;
                 }
             }));
         };
-        TreeDirective.prototype.getNodesFromString = function(value) {
+        TreeComponent.prototype.setTreeTemplate = function(value) {
+            if (value === "Classic") {
+                this.setting.check["enable"] = false;
+            } else if (value === "Checkbox") {
+                this.setting.check["enable"] = true;
+                this.setting.check["chkStyle"] = "checkbox";
+            } else if (value === "Radio") {
+                this.setting.check["enable"] = true;
+                this.setting.check["chkStyle"] = "radio";
+                this.setting.check["radioType"] = "all";
+            }
+        };
+        TreeComponent.prototype.getNodesFromString = function(value) {
             return value.split(",").map((function(item) {
                 return {
-                    label: item && item.trim()
+                    name: item && item.trim()
                 };
             }));
         };
-        TreeDirective.prototype.getNodes = function(newVal) {
+        TreeComponent.prototype.getNodes = function(newVal) {
             var nodes;
-            if (_.isString(newVal) && !_.isEmpty(newVal)) {
+            if (_.isArray(newVal)) {
+                nodes = base.getOrderedDataset(newVal, this.orderby);
+            } else if (_.isObject(newVal)) {
+                nodes = [ newVal ];
+            } else if (_.isString(newVal) && !_.isEmpty(newVal)) {
                 newVal = newVal.trim();
                 if (newVal) {
                     nodes = this.getNodesFromString(newVal);
                 }
-            } else if (_.isArray(newVal)) {
-                newVal = base.getOrderedDataset(newVal, this.orderby);
-                nodes = newVal;
-            } else if (_.isObject(newVal)) {
-                nodes = [ newVal ];
             }
             return nodes;
         };
-        TreeDirective.prototype.changeTreeIcons = function(nv, ov) {
-            var $el = $(this.nativeElement);
-            nv = nv || defaultTreeIconClass;
-            ov = ov || defaultTreeIconClass;
-            $el.find("i.expanded").removeClass(ICON_CLASSES[ov].expanded).addClass(ICON_CLASSES[nv].expanded);
-            $el.find("i.collapsed").removeClass(ICON_CLASSES[ov].collapsed).addClass(ICON_CLASSES[nv].collapsed);
-        };
-        TreeDirective.prototype.toggleExpandCollapseNode = function($event, $i, $li) {
-            var treeIcons = ICON_CLASSES[this.treeicons || defaultTreeIconClass];
-            var $liPath = this.findSelectedNodeParent($li);
-            var path = "";
-            $liPath.each((function(i, el) {
-                var current = $(el).children(".title").text();
-                path = "/" + (current + path);
-            }));
-            var eventParams = {
-                $event: $event,
-                $item: $li.data("nodedata"),
-                $path: path
-            };
-            if ($i.hasClass("collapsed")) {
-                $i.removeClass("collapsed " + treeIcons.collapsed).addClass("expanded " + treeIcons.expanded);
-                $li.removeClass("collapsed").addClass("expanded");
-                this.invokeEventCallback("expand", eventParams);
-            } else if ($i.hasClass("expanded")) {
-                $i.removeClass("expanded " + treeIcons.expanded).addClass("collapsed " + treeIcons.collapsed);
-                $li.removeClass("expanded").addClass("collapsed");
-                this.invokeEventCallback("collapse", eventParams);
-            }
+        TreeComponent.prototype.setNodeclasses = function(treeId, treeNode) {
+            return treeNode.icon ? {
+                add: [ "" + treeNode.icon ]
+            } : "";
         };
-        TreeDirective.prototype.renderTree = function(forceRender) {
+        TreeComponent.prototype.setNodeData = function(nodes, depth, level, parentNode, type) {
             var _this = this;
-            var docFrag, $li, $liPath, data, path = "";
-            var levels = +this.nativeElement.getAttribute("levels") || 0, $el = $(this.nativeElement);
-            $el.empty();
-            if (forceRender) {
-                this._selectNode = undefined;
-            }
-            if (this.nodes && this.nodes.length) {
-                docFrag = document.createDocumentFragment();
-                this.constructNodes(this.nodes, $(docFrag), levels, 0, this.datavalue);
-                $el.append(docFrag);
-            }
-            if (this._selectNode) {
-                $li = this._selectNode;
-                $li.addClass("selected");
-                data = $li.data("nodedata");
-                $liPath = this.findSelectedNodeParent($li);
-                if (!$liPath.length) {
-                    $liPath = $li;
-                }
-                $liPath.each((function(i, el) {
-                    var $current = $(el), $i = $current.children("i.collapsed"), $title = $current.children(".title");
-                    _this.toggleExpandCollapseNode(undefined, $i, $current);
-                    path = "/" + ($title.text() + path);
+            if (depth === 0) {
+                nodes.map((function(node) {
+                    if (node.children) {
+                        _this.setNodeData(node.children, depth, level, parentNode, type);
+                    }
+                    if (node.icon && _this.nodelabel == "icon") {
+                        node[type] = node.icon;
+                    } else if (node.name && _this.nodelabel == "name") {
+                        node[type] = node.name;
+                    } else {
+                        return;
+                    }
+                }));
+            } else {
+                nodes.map((function(node) {
+                    if (node.children && level > 1) {
+                        if (depth === level) {
+                            parentNode = node;
+                        }
+                        _this.setNodeData(node.children, depth, level - 1, parentNode, type);
+                    }
+                    if (level === 1 && (type === "name" ? _this.nodelabel.includes("label") || _this.nodelabel.includes("name") : _this.nodeicon.includes("label") || _this.nodeicon.includes("name"))) {
+                        parentNode[type] = node.name || node.label;
+                        return;
+                    } else if (level === 1 && node.icon !== undefined && (type === "name" ? _this.nodelabel.includes("icon") : _this.nodeicon.includes("icon"))) {
+                        parentNode[type] = node.icon;
+                        return;
+                    } else {
+                        return;
+                    }
                 }));
-                this.selecteditem = core.getClonedObject(data) || {};
-                this.selecteditem.path = path;
-                this.invokeEventCallback("select", {
-                    $event: undefined,
-                    $item: data,
-                    $path: path
-                });
-                core.$appDigest();
             }
         };
-        TreeDirective.prototype.selectNode = function(evt, value) {
-            var _this = this;
-            var target = evt && $(evt.target), $el = $(this.nativeElement), $li = _.isObject(value) ? value : $el.find('li[id="' + value + '"]').first();
-            var data, path = "", $liPath, nodeAction;
-            $el.find(".selected").removeClass("selected");
-            if (!$li.length) {
-                return;
-            }
-            $li.addClass("selected");
-            data = $li.data("nodedata");
-            nodeAction = data[this.nodeaction || "action"];
-            $liPath = target ? target.parents(".app-tree li") : this.findSelectedNodeParent($li);
-            $liPath.each((function(i, el) {
-                var current = $(el).children(".title").text();
-                path = "/" + (current + path);
-            }));
-            $li.parentsUntil($el, "li.parent-node.collapsed").each((function(index, el) {
-                var $current = $(el), $i = $current.children("i.collapsed");
-                _this.toggleExpandCollapseNode(undefined, $i, $current);
-            }));
-            this.selecteditem = core.getClonedObject(data) || {};
-            this.selecteditem.path = path;
-            if (target) {
-                if (this.nodeid || this.bindnodeid) {
-                    this.datavalue = base.getEvaluatedData(data, {
-                        field: this.nodeid,
-                        bindExpression: this.bindnodeid
-                    }, this.viewParent);
-                } else {
-                    this.datavalue = core.getClonedObject(data) || {};
-                }
+        TreeComponent.prototype.changeTreeIcons = function(nv) {
+            var eleClose = $('ul[name="' + this.name + '"] li span.button.switch');
+            $(eleClose).map((function(idx, ele) {
+                $(ele).addClass(nv);
+                $(ele).on("click", (function(e) {
+                    setTimeout((function() {
+                        $(ele).addClass(nv);
+                    }), 0);
+                }));
+            }));
+        };
+        TreeComponent.prototype.getPath = function(treeNode, path) {
+            if (treeNode.getParentNode() === null) {
+                path = "/" + treeNode.name + path;
             } else {
-                this.datavalue = value;
+                path = this.getPath(treeNode.getParentNode(), path) + "/" + treeNode.name;
             }
-            if (nodeAction) {
-                core.$parseEvent(nodeAction)(this);
+            return path;
+        };
+        TreeComponent.prototype.onClick = function(event, treeId, treeNode, clickFlag) {
+            var treeObj = $.fn.zTree.getZTreeObj("" + this.name);
+            if (this.nodeclick === "expand") {
+                treeObj.expandNode(treeNode, treeNode.open ? false : true, false, true);
+                this.changeTreeIcons(this.treeicon || defaultTreeIconClass);
+                var path = this.getPath(treeNode, "");
+                var eventParams = {
+                    $event: event,
+                    $item: treeNode,
+                    $path: path
+                };
+                this.invokeEventCallback("select", eventParams);
+                if (treeNode.open) {} else {
+                    this.invokeEventCallback("collapse", eventParams);
+                }
             }
-            this.invokeEventCallback("select", {
-                $event: evt,
-                $item: data,
-                $path: path
-            });
-            core.$appDigest();
         };
-        TreeDirective.prototype.bindEvents = function() {
+        TreeComponent.prototype.onExpand = function(event, treeId, treeNode) {
+            var self = this;
+            treeNode.children ? treeNode.children.map((function(el) {
+                if (el.isParent) {
+                    var ele_1 = $("#" + el.tId + "_switch");
+                    $(ele_1).addClass(self.treeicon || defaultTreeIconClass);
+                    $(ele_1).on("click", (function(e) {
+                        setTimeout((function() {
+                            $(ele_1).addClass(self.treeicon || defaultTreeIconClass);
+                        }), 0);
+                    }));
+                }
+            })) : "";
+        };
+        TreeComponent.prototype.modifyObjects = function(array) {
             var _this = this;
-            $(this.nativeElement).on("click", (function(evt) {
-                var target = $(evt.target), li = target.closest("li"), $i = target.is("i") ? target : target.siblings("i.collapsed,i.expanded");
-                evt.stopPropagation();
-                if (target.is("span.title")) {
-                    _this.selecteditem = {};
-                    _this.selectNode(evt, li);
+            array.forEach((function(obj) {
+                if (obj.label !== undefined) {
+                    obj.name = obj.label;
+                    delete obj.label;
                 }
-                if (target.is("i") || target.is("span.title") && _this.nodeclick === "expand") {
-                    _this.toggleExpandCollapseNode(evt, $i, li);
+                if (obj.children !== undefined) {
+                    _this.modifyObjects(obj.children);
                 }
             }));
+            return array;
         };
-        TreeDirective.prototype.findSelectedNodeParent = function($li) {
-            return $li.find("> span.title").parents(".app-tree li");
+        TreeComponent.prototype.setNodeChildren = function(nodes, depth, level, parentNode) {
+            if (depth <= 0) {
+                return nodes;
+            }
+            for (var i = 0; i < nodes.length; i++) {
+                var node = nodes[i];
+                if (depth === level) {
+                    parentNode = nodes[i];
+                }
+                if (node.children && node.children.length > 0) {
+                    if (level === 1) {
+                        parentNode.children = node.children.map((function(child) {
+                            return {
+                                name: child.name,
+                                children: child === null || child === void 0 ? void 0 : child.children
+                            };
+                        }));
+                        return;
+                    } else {
+                        this.setNodeChildren(node.children, depth, level - 1, parentNode);
+                    }
+                }
+            }
+            return nodes;
         };
-        TreeDirective.prototype.selectById = function(value) {
-            this.selectNode(undefined, value);
+        TreeComponent.prototype.countDepth = function(str) {
+            var e_1, _a;
+            var regex = /\[.*?\]/g;
+            var matches = str.match(regex);
+            var count = 1;
+            if (matches === null) return count;
+            try {
+                for (var matches_1 = __values(matches), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
+                    var match = matches_1_1.value;
+                    count++;
+                }
+            } catch (e_1_1) {
+                e_1 = {
+                    error: e_1_1
+                };
+            } finally {
+                try {
+                    if (matches_1_1 && !matches_1_1.done && (_a = matches_1.return)) _a.call(matches_1);
+                } finally {
+                    if (e_1) throw e_1.error;
+                }
+            }
+            return count;
+        };
+        TreeComponent.prototype.renderTree = function() {
+            if (this.nodes) {
+                this.nativeElement.setAttribute("id", this.name);
+                this.nodes = this.modifyObjects(this.nodes);
+                this.setTreeTemplate(this.treeClass);
+                if (this.nodelabel) {
+                    var depth = 0;
+                    if (this.nodelabel.includes("children")) {
+                        depth = this.countDepth(this.nodelabel);
+                    }
+                    this.setNodeData(this.nodes, depth, depth, null, "name");
+                }
+                if (this.nodeicon) {
+                    var depth = 0;
+                    if (this.nodeicon.includes("children")) {
+                        depth = this.countDepth(this.nodeicon);
+                    }
+                    this.setNodeData(this.nodes, depth, depth, null, "icon");
+                }
+                if (this.nodechildren) {
+                    var depth = this.countDepth(this.nodechildren);
+                    if (depth > 1) {
+                        this.nodes = this.setNodeChildren(this.nodes, depth, depth, null);
+                    }
+                }
+            }
+            this.setting.view["nodeClasses"] = this.setNodeclasses;
+            this.setting.callback["onClick"] = this.onClick.bind(this);
+            this.setting.callback["onExpand"] = this.onExpand.bind(this);
+            var zTree = $.fn.zTree.init($('ul[name="' + this.name + '"]'), this.setting, this.nodes);
+            $.fn.zTreeKeyboardNavigation(zTree, $('ul[name="' + this.name + '"]'), null, this.treeicon || defaultTreeIconClass);
         };
-        TreeDirective.prototype.deselectById = function(value) {
-            this.selecteditem = {};
-            this.selectById();
+        TreeComponent.prototype.ngAfterViewInit = function() {
+            var _this = this;
+            setTimeout((function() {
+                _this.changeTreeIcons(_this.treeicon || defaultTreeIconClass);
+            }), 200);
         };
-        return TreeDirective;
+        return TreeComponent;
     }(base.StylableComponent);
-    TreeDirective.initializeProps = registerProps();
-    TreeDirective.decorators = [ {
-        type: core$1.Directive,
+    TreeComponent.initializeProps = registerProps();
+    TreeComponent.decorators = [ {
+        type: core.Component,
         args: [ {
-            selector: "div[wmTree]",
-            providers: [ base.provideAsWidgetRef(TreeDirective) ]
+            selector: "ul[wmTree]",
+            template: '<ul #wmTree class="ztree" id="ztree"></ul>  ',
+            providers: [ base.provideAsWidgetRef(TreeComponent) ],
+            encapsulation: core.ViewEncapsulation.None
         } ]
     } ];
-    TreeDirective.ctorParameters = function() {
+    TreeComponent.ctorParameters = function() {
         return [ {
-            type: core$1.Injector
-        }, {
-            type: undefined,
-            decorators: [ {
-                type: core$1.Attribute,
-                args: [ "datavalue.bind" ]
-            } ]
-        }, {
-            type: undefined,
-            decorators: [ {
-                type: core$1.Attribute,
-                args: [ "nodelabel.bind" ]
-            } ]
-        }, {
-            type: undefined,
-            decorators: [ {
-                type: core$1.Attribute,
-                args: [ "nodeicon.bind" ]
-            } ]
-        }, {
-            type: undefined,
-            decorators: [ {
-                type: core$1.Attribute,
-                args: [ "nodechildren.bind" ]
-            } ]
-        }, {
-            type: undefined,
-            decorators: [ {
-                type: core$1.Attribute,
-                args: [ "nodeid.bind" ]
-            } ]
+            type: core.Injector
         } ];
     };
-    var components = [ TreeDirective ];
+    var components = [ TreeComponent ];
     var TreeModule = function() {
         function TreeModule() {}
         return TreeModule;
     }();
     TreeModule.decorators = [ {
-        type: core$1.NgModule,
+        type: core.NgModule,
         args: [ {
             imports: [ common.CommonModule, base.WmComponentsModule ],
             declarations: __spreadArray([], __read(components)),
@@ -23514,7 +23493,7 @@
             entryComponents: []
         } ]
     } ];
-    exports.TreeDirective = TreeDirective;
+    exports.TreeComponent = TreeComponent;
     exports.TreeModule = TreeModule;
     exports["\u0275a"] = registerProps;
     Object.defineProperty(exports, "__esModule", {