@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/basic/tree/esm2022/tree.component.mjs

@@ -0,0 +1,494 @@
+import { ApplicationRef, Attribute, Component, EnvironmentInjector, Inject, Injector, NgZone, Optional, ViewEncapsulation, createComponent } from '@angular/core';
+import { APPLY_STYLES_TYPE, getEvaluatedData, getOrderedDataset, provideAsWidgetRef, StylableComponent, styler } from '@wm/components/base';
+import { registerProps } from './tree.props';
+import { $parseEvent, getClonedObject } from "@wm/core";
+import { isArray, isEmpty, isObject, isString } from "lodash-es";
+import { TreeNodeTemplateHostComponent } from './tree-node-template-host.component';
+import * as i0 from "@angular/core";
+const WIDGET_INFO = { widgetType: 'wm-tree', hostClass: 'app-tree' };
+const defaultTreeIconClass = 'plus-minus';
+export class TreeComponent extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, binddatavalue, bindnodelabel, bindnodeicon, bindnodechildren, bindnodeid, explicitContext) {
+        super(inj, WIDGET_INFO, explicitContext);
+        this.binddatavalue = binddatavalue;
+        this.bindnodelabel = bindnodelabel;
+        this.bindnodeicon = bindnodeicon;
+        this.bindnodechildren = bindnodechildren;
+        this.bindnodeid = bindnodeid;
+        /** Dynamic hosts for custom node template (cleared on each render). */
+        this.nodeTemplateRefs = [];
+        this.setting = {
+            data: {
+                simpleData: {
+                    enable: false
+                }
+            },
+            view: {
+                dblClickExpand: false,
+                fontCss: {
+                    'font-awesome': true
+                },
+                switchIcon: {},
+            },
+            check: {},
+            callback: {}
+        };
+        this.addDiyDom = (_treeId, treeNode) => {
+            if (!this.template) {
+                return;
+            }
+            const aObj = $('#' + treeNode.tId + '_a');
+            if (!aObj.length || aObj.find('.wm-tree-node-template-host').length) {
+                return;
+            }
+            /** hide default zTree switch & icon and hide the built-in label span when using a custom template. */
+            const switchEl = $('#' + treeNode.tId + '_switch');
+            switchEl.hide();
+            $('#' + treeNode.tId + '_span').hide();
+            const host = document.createElement('span');
+            host.className = 'wm-tree-node-template-host wm-tree-node-item';
+            aObj.append(host);
+            this.mountTreeNodeTemplateHost(host, treeNode);
+        };
+        this.ngZone = inj.get(NgZone);
+        this.applicationRef = inj.get(ApplicationRef);
+        this.environmentInjector = inj.get(EnvironmentInjector);
+        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER);
+        this.setting.view['nodeClasses'] = this.setNodeClasses;
+        this.setting.callback["onClick"] = this.onClick.bind(this);
+        this.setting.callback["onExpand"] = this.onExpand.bind(this);
+        this.setting.callback["onCollapse"] = this.onCollapse.bind(this);
+    }
+    onPropertyChange(key, nv, ov) {
+        switch (key) {
+            case 'dataset':
+                this.nodes = this.getNodes(nv);
+                this.renderTree();
+                break;
+            case 'levels':
+                this.level = nv;
+                this.renderTree();
+                break;
+            case 'nodeicon':
+                this.nodeicon = nv;
+                this.renderTree();
+                break;
+            case 'nodelabel':
+                this.nodelabel = nv;
+                this.renderTree();
+                break;
+            case 'nodechildren':
+                this.nodechildren = nv;
+                this.renderTree();
+                break;
+            case 'orderby':
+                this.orderby = nv;
+                this.renderTree();
+                break;
+            case 'treeicons':
+                this.treeicons = nv;
+                this.renderTree();
+                break;
+            case 'template':
+                this.template = nv;
+                this.renderTree();
+                break;
+            case 'class':
+                this.treeClass = nv;
+                this.setTreeTemplate(this.treeClass);
+                super.onPropertyChange(key, nv, ov);
+                this.renderTree();
+                break;
+            default:
+                super.onPropertyChange(key, nv, ov);
+                break;
+        }
+    }
+    // set tree node template
+    setTemplate(partialName) {
+        this.template = partialName;
+        if (this.viewParent && this.viewParent.prefabName) {
+            this['prefabName'] = this.viewParent.prefabName;
+        }
+        this.renderTree();
+    }
+    destroyNodeTemplateHostRefs() {
+        this.nodeTemplateRefs.forEach(ref => ref.destroy());
+        this.nodeTemplateRefs = [];
+    }
+    /** Re-run change detection on custom node partials after zTree mutates node state (e.g. open). No-op when template is unset or no hosts exist. */
+    refreshTreeNodeTemplateHosts() {
+        if (!this.template || !this.nodeTemplateRefs.length) {
+            return;
+        }
+        this.ngZone.run(() => {
+            for (const ref of this.nodeTemplateRefs) {
+                try {
+                    ref.changeDetectorRef.detectChanges();
+                }
+                catch {
+                    /* host destroyed */
+                }
+            }
+        });
+    }
+    /** Item passed to the custom template: zTree node API + row fields + toggle/select helpers. */
+    buildCustomTemplateItemProxy(treeNode) {
+        const rowData = treeNode.data;
+        const itemPayload = rowData && typeof rowData === 'object' ? getClonedObject(rowData) : rowData;
+        const self = this;
+        const nodeHelperProto = Object.create(treeNode);
+        nodeHelperProto.toggleExpand = (event) => {
+            if (event) {
+                event.preventDefault?.();
+                event.stopPropagation?.();
+            }
+            if (!treeNode.isParent) {
+                return;
+            }
+            self.expandNode(treeNode, !treeNode.open, true);
+        };
+        Object.defineProperty(nodeHelperProto, 'isSelected', {
+            enumerable: true,
+            configurable: true,
+            get: () => !!self.zTree?.isSelectedNode?.(treeNode),
+        });
+        const nodeApi = Object.create(nodeHelperProto);
+        return {
+            ...itemPayload,
+            _node: nodeApi,
+        };
+    }
+    mountTreeNodeTemplateHost(host, treeNode) {
+        const ref = createComponent(TreeNodeTemplateHostComponent, {
+            environmentInjector: this.environmentInjector,
+            elementInjector: this.inj,
+            hostElement: host,
+        });
+        ref.setInput('template', this.template);
+        ref.setInput('userComponentParams', { dataObject: this.buildCustomTemplateItemProxy(treeNode) });
+        this.applicationRef.attachView(ref.hostView);
+        ref.changeDetectorRef.detectChanges();
+        this.nodeTemplateRefs.push(ref);
+    }
+    ngOnDestroy() {
+        this.destroyNodeTemplateHostRefs();
+        super.ngOnDestroy();
+    }
+    // expands the tree nodes if the property is selected.
+    expandTree(level, node, childLevel) {
+        node.map(childNode => {
+            const children = childNode.children;
+            if (children && childLevel < level) {
+                childNode.open = true;
+                this.expandTree(level, children, childLevel + 1);
+            }
+            else {
+                childLevel = 0;
+                return;
+            }
+        });
+    }
+    // sets the template for the tree based on the property selected.
+    setTreeTemplate(value) {
+        const classList = value?.split(" ");
+        if (classList?.length) {
+            if (classList.includes('Classic')) {
+                this.setting.check["enable"] = false;
+            }
+            else if (classList.includes('Checkbox')) {
+                this.setting.check["enable"] = true;
+                this.setting.check["chkStyle"] = 'checkbox';
+            }
+            else if (classList.includes('Radio')) {
+                this.setting.check["enable"] = true;
+                this.setting.check["chkStyle"] = 'radio';
+                this.setting.check["radioType"] = "all";
+            }
+        }
+    }
+    // extracts nodes from string format
+    getNodesFromString(value) {
+        return value.split(',').map((item) => {
+            return {
+                'label': item && item.trim()
+            };
+        });
+    }
+    // gets the nodes and orders the nodes if required
+    getNodes(newVal) {
+        let nodes;
+        if (isArray(newVal)) {
+            nodes = getOrderedDataset(newVal, this.orderby);
+        }
+        else if (isObject(newVal)) {
+            nodes = [newVal];
+        }
+        else if (isString(newVal) && !isEmpty(newVal)) {
+            const trimmed = newVal.trim();
+            if (trimmed) {
+                if (trimmed.startsWith('[') || trimmed.startsWith('{')) {
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        if (isArray(parsed)) {
+                            nodes = getOrderedDataset(parsed, this.orderby);
+                        }
+                        else if (isObject(parsed)) {
+                            nodes = [parsed];
+                        }
+                    }
+                    catch {
+                        // Not valid JSON; treat as comma-separated labels below.
+                    }
+                }
+                if (!nodes) {
+                    nodes = this.getNodesFromString(trimmed);
+                }
+            }
+        }
+        return nodes;
+    }
+    // adds class to the nodes inorder to add icons to respective node.
+    setNodeClasses(treeId, treeNode) {
+        return treeNode.icon ? { add: [`${treeNode.icon}`] } : '';
+    }
+    ;
+    // adds tree icons to the nodes on load of the tree
+    changeTreeIcons(nv) {
+        let eleClose = $('ul[name="' + this.name + '"] li span.button.switch');
+        $(eleClose).map((idx, ele) => {
+            $(ele).addClass(nv);
+            $(ele).on("click", function (e) {
+                setTimeout(() => {
+                    $(ele).addClass(nv);
+                }, 0);
+            });
+        });
+    }
+    // Returns the node path
+    getPath(treeNode, path) {
+        if (treeNode.getParentNode() === null) {
+            path = "/" + treeNode.name + path;
+        }
+        else {
+            path = this.getPath(treeNode.getParentNode(), path) + "/" + treeNode.name;
+        }
+        return path;
+    }
+    // binds the click event to all nodes to open the child nodes
+    onClick(event, treeId, treeNode, clickFlag) {
+        if (this.nodeclick === "expand") {
+            var nodes = this.zTree.getSelectedNodes();
+            if (nodes.length > 0) {
+                this.expandNode(nodes[0], !nodes[0].open, true);
+            }
+        }
+        this.selectNode(event, treeNode);
+    }
+    // Adds tree icon classes to child nodes when expanded
+    onExpand(event, treeId, treeNode) {
+        let self = this;
+        let path = this.getPath(treeNode, "");
+        const eventParams = {
+            '$event': event,
+            "$item": getClonedObject(treeNode.data),
+            "$path": path
+        };
+        this.invokeEventCallback('expand', eventParams);
+        const children = treeNode.children;
+        children?.map((el) => {
+            if (el.isParent) {
+                let ele = $(`#${el.tId}_switch`);
+                $(ele).addClass(self.treeicons || defaultTreeIconClass);
+                $(ele).on("click", function (e) {
+                    setTimeout(() => {
+                        $(ele).addClass(self.treeicons || defaultTreeIconClass);
+                    }, 0);
+                });
+            }
+        });
+        this.refreshTreeNodeTemplateHosts();
+    }
+    onCollapse(event, treeId, treeNode) {
+        let path = this.getPath(treeNode, "");
+        const eventParams = {
+            '$event': event,
+            "$item": getClonedObject(treeNode.data),
+            "$path": path
+        };
+        this.invokeEventCallback('collapse', eventParams);
+        this.refreshTreeNodeTemplateHosts();
+    }
+    // function to support backward compatibility of objects
+    constructZTreeData(data, zTreeData) {
+        data.forEach(node => {
+            const zNode = {};
+            const evaluatedLabel = getEvaluatedData(node, { field: this.nodelabel, bindExpression: this.bindnodelabel }, this.viewParent);
+            // Avoid zTree rendering the literal "undefined" when label field is missing or nodelabel does not match dataset (e.g. data uses "key" only).
+            const name = evaluatedLabel !== undefined && evaluatedLabel !== null && evaluatedLabel !== ''
+                ? evaluatedLabel
+                : (node.label ?? node.key ?? node.name ?? '');
+            const icon = getEvaluatedData(node, { field: this.nodeicon, bindExpression: this.bindnodeicon }, this.viewParent) || node.icon;
+            const nodeId = getEvaluatedData(node, { field: this.nodeid, bindExpression: this.bindnodeid }, this.viewParent);
+            const children = getEvaluatedData(node, { field: this.nodechildren, bindExpression: this.bindnodechildren }, this.viewParent) || node.children;
+            zNode['name'] = name === undefined || name === null ? '' : String(name);
+            if (!this.template) {
+                zNode['icon'] = icon;
+            }
+            zNode['nodeId'] = nodeId;
+            zNode['data'] = getClonedObject(node);
+            if (node.selected) {
+                zNode['selected'] = true;
+            }
+            if (node.iconSkin != null && node.iconSkin !== '') {
+                zNode['iconSkin'] = node.iconSkin;
+            }
+            if (node.iconOpen != null && node.iconOpen !== '') {
+                zNode['iconOpen'] = node.iconOpen;
+            }
+            if (node.iconClose != null && node.iconClose !== '') {
+                zNode['iconClose'] = node.iconClose;
+            }
+            if (isArray(children) && children.length) {
+                zNode['children'] = [];
+                this.constructZTreeData(children, zNode['children']);
+            }
+            zTreeData.push(zNode);
+        });
+    }
+    // Renders the tree on to the dom
+    renderTree() {
+        this.destroyNodeTemplateHostRefs();
+        this.setting.view['addDiyDom'] = this.template ? this.addDiyDom : undefined;
+        this.nativeElement.classList.toggle('app-tree-custom', !!this.template);
+        this.zTreeNodes = [];
+        if (this.nodes?.length) {
+            this.nativeElement.setAttribute('id', this.name);
+            this.constructZTreeData(this.nodes, this.zTreeNodes);
+            if (this.level > 0) {
+                this.expandTree(this.level, this.zTreeNodes, 0);
+            }
+        }
+        this.zTree = $.fn.zTree.init($('ul[name="' + this.name + '"]'), this.setting, this.zTreeNodes);
+        $.fn.zTreeKeyboardNavigation(this.zTree, $('ul[name="' + this.name + '"]'), null, this.treeicons || defaultTreeIconClass);
+        this.postRenderTree();
+    }
+    setChecked(zNode, node) {
+        node.checked = zNode.checked;
+        const children = getEvaluatedData(node, { field: this.nodechildren, bindExpression: this.bindnodechildren }, this.viewParent) || node.children;
+        if (children?.length) {
+            children.forEach((node, index) => {
+                this.setChecked(zNode.children[index], node);
+            });
+        }
+    }
+    selectNode(event, node) {
+        const deSelectElm = $(`.app-tree[name=${this.name}] li[treenode].selected`);
+        deSelectElm.removeClass('selected');
+        if (!node) {
+            this.refreshTreeNodeTemplateHosts();
+            return;
+        }
+        const selectElm = $(`#${node.tId}:has(.curSelectedNode)`);
+        selectElm.addClass('selected');
+        const classList = (this.treeClass || "").split(" ");
+        if (classList.includes('Checkbox') || classList.includes('Radio')) {
+            this.setChecked(node, node.data);
+        }
+        const path = this.getPath(node, "");
+        this.selecteditem = getClonedObject(node.data) || {};
+        this.selecteditem.path = path;
+        const eventParams = {
+            '$event': event,
+            "$item": getClonedObject(node.data),
+            "$path": path
+        };
+        //[Todo-CSP]: this data will be dynamic, can not generate function upfront
+        const nodeAction = node.data[this.nodeaction || 'action'];
+        if (nodeAction) {
+            $parseEvent(nodeAction)(this);
+        }
+        this.invokeEventCallback('select', eventParams);
+        this.refreshTreeNodeTemplateHosts();
+    }
+    expandNode(node, expand, eventFlag) {
+        this.zTree.expandNode(node, expand, false, false, eventFlag);
+        const el = $(`#${node.tId}_switch`);
+        $(el).addClass(this.treeicons || defaultTreeIconClass);
+        this.refreshTreeNodeTemplateHosts();
+    }
+    postRenderTree() {
+        setTimeout(() => {
+            this.changeTreeIcons(this.treeicons || defaultTreeIconClass);
+            const allNodes = this.zTree.transformToArray(this.zTree.getNodes());
+            const selectedNode = allNodes.find(n => n.selected);
+            if (selectedNode) {
+                this.zTree.selectNode(selectedNode, false);
+                this.selectNode(undefined, selectedNode);
+                this.expandNode(selectedNode, true, false);
+                return;
+            }
+            if (this.datavalue && !this.selecteditem) {
+                const nodes = this.zTree.getNodes();
+                let node;
+                if (nodes.length) {
+                    if (this.datavalue === 'FirstNode') {
+                        node = nodes[0];
+                    }
+                    if (this.datavalue === 'LastNode') {
+                        node = nodes[nodes.length - 1];
+                    }
+                }
+                if (node) {
+                    this.zTree.selectNode(node, false);
+                    this.selectNode(undefined, node);
+                    this.expandNode(node, true, false);
+                }
+            }
+        }, 200);
+    }
+    selectById(value) {
+        const simpleNodes = this.zTree?.transformToArray(this.zTree.getNodes());
+        const node = simpleNodes?.find(node => value === node.nodeId);
+        if (node) {
+            this.zTree.selectNode(node, false);
+            this.selectNode(undefined, node);
+        }
+    }
+    deselectById(value) {
+        this.selecteditem = {};
+        this.selectById();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeComponent, deps: [{ token: i0.Injector }, { token: 'datavalue.bind', attribute: true }, { token: 'nodelabel.bind', attribute: true }, { token: 'nodeicon.bind', attribute: true }, { token: 'nodechildren.bind', attribute: true }, { token: 'nodeid.bind', attribute: true }, { token: 'EXPLICIT_CONTEXT', optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TreeComponent, isStandalone: true, selector: "ul[wmTree]", providers: [
+            provideAsWidgetRef(TreeComponent)
+        ], usesInheritance: true, ngImport: i0, template: "<ul #wmTree class=\"ztree\" id=\"ztree\"></ul>  ", encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'ul[wmTree]', providers: [
+                        provideAsWidgetRef(TreeComponent)
+                    ], encapsulation: ViewEncapsulation.None, template: "<ul #wmTree class=\"ztree\" id=\"ztree\"></ul>  " }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['datavalue.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['nodelabel.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['nodeicon.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['nodechildren.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['nodeid.bind']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['EXPLICIT_CONTEXT']
+                }, {
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.component.js","sourceRoot":"","sources":["../../../../../projects/components/widgets/basic/tree/src/tree.component.ts","../../../../../projects/components/widgets/basic/tree/src/tree.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ApplicationRef, Attribute, Component, ComponentRef, EnvironmentInjector, Inject, Injector, NgZone, OnDestroy, Optional, ViewEncapsulation, createComponent } from '@angular/core';\nimport { APPLY_STYLES_TYPE, getEvaluatedData, getOrderedDataset, provideAsWidgetRef, StylableComponent, styler } from '@wm/components/base';\nimport { registerProps } from './tree.props';\nimport { $parseEvent, getClonedObject } from \"@wm/core\";\nimport { isArray, isEmpty, isObject, isString } from \"lodash-es\";\nimport { TreeNodeTemplateHostComponent } from './tree-node-template-host.component';\n\ndeclare const $;\n\nconst WIDGET_INFO = {widgetType: 'wm-tree', hostClass: 'app-tree'};\nconst defaultTreeIconClass = 'plus-minus';\n\n@Component({\n    standalone: true,\n    selector: 'ul[wmTree]',\n    templateUrl: './tree.component.html',\n    providers: [\n        provideAsWidgetRef(TreeComponent)\n    ],\n    encapsulation: ViewEncapsulation.None\n})\nexport class TreeComponent extends StylableComponent implements OnDestroy {\n    static initializeProps = registerProps();\n\n    private nodes: Array<any>;\n    private zTreeNodes: Array<any>;\n    private level;\n    private treeClass;\n    private name;\n    private zTree;\n\n    public datavalue: string;\n    public treeicons: string;\n    public selecteditem: any;\n    public nodeid: string;\n    public nodeaction: string;\n    public nodeclick: string;\n    public nodelabel: string;\n    public nodeicon: string;\n    public nodechildren: string;\n    public orderby: string;\n    /** Partial name for custom tree node UI (set via setTemplate or binding). */\n    public template: string;\n\n    /** Dynamic hosts for custom node template (cleared on each render). */\n    private nodeTemplateRefs: Array<ComponentRef<TreeNodeTemplateHostComponent>> = [];\n    private readonly ngZone: NgZone;\n    private readonly applicationRef: ApplicationRef;\n    private readonly environmentInjector: EnvironmentInjector;\n\n    private setting = {\n        data: {\n            simpleData: {\n                enable: false\n            }\n        },\n        view: {\n            dblClickExpand: false,\n            fontCss: {\n                'font-awesome': true\n              },\n            switchIcon: {},\n        },\n        check: {},\n        callback: {}\n    };\n\n    constructor(\n        inj: Injector,\n        @Attribute('datavalue.bind') private binddatavalue,\n        @Attribute('nodelabel.bind') private bindnodelabel,\n        @Attribute('nodeicon.bind') private bindnodeicon,\n        @Attribute('nodechildren.bind') private bindnodechildren,\n        @Attribute('nodeid.bind') private bindnodeid,\n        @Inject('EXPLICIT_CONTEXT') @Optional() explicitContext: any\n    ) {\n        super(inj, WIDGET_INFO, explicitContext);\n        this.ngZone = inj.get(NgZone);\n        this.applicationRef = inj.get(ApplicationRef);\n        this.environmentInjector = inj.get(EnvironmentInjector);\n        styler(this.nativeElement, this, APPLY_STYLES_TYPE.CONTAINER);\n\n        this.setting.view['nodeClasses']    = this.setNodeClasses;\n        this.setting.callback[\"onClick\"]    = this.onClick.bind(this);\n        this.setting.callback[\"onExpand\"]   = this.onExpand.bind(this);\n        this.setting.callback[\"onCollapse\"] = this.onCollapse.bind(this);\n    }\n\n    public onPropertyChange(key: string, nv: any, ov?: any): void {\n        switch (key) {\n            case 'dataset':\n                this.nodes = this.getNodes(nv);\n                this.renderTree();\n                break;\n            case 'levels':\n                this.level = nv;\n                this.renderTree();\n                break;\n            case 'nodeicon':\n                this.nodeicon = nv;\n                this.renderTree();\n                break;\n            case 'nodelabel':\n                this.nodelabel = nv;\n                this.renderTree();\n                break;\n            case 'nodechildren':\n                this.nodechildren = nv;\n                this.renderTree();\n                break;\n            case 'orderby':\n                this.orderby = nv;\n                this.renderTree();\n                break;\n            case 'treeicons':\n                this.treeicons = nv;\n                this.renderTree();\n                break;\n            case 'template':\n                this.template = nv;\n                this.renderTree();\n                break;\n            case 'class':\n                this.treeClass = nv;\n                this.setTreeTemplate(this.treeClass);\n                super.onPropertyChange(key, nv, ov);\n                this.renderTree();\n                break;\n            default:\n                super.onPropertyChange(key, nv, ov);\n                break;\n        }\n    }\n\n    // set tree node template\n    public setTemplate(partialName: string) {\n        this.template = partialName;\n        if (this.viewParent && this.viewParent.prefabName) {\n            this['prefabName'] = this.viewParent.prefabName;\n        }\n        this.renderTree();\n    }\n\n    private destroyNodeTemplateHostRefs(): void {\n        this.nodeTemplateRefs.forEach(ref => ref.destroy());\n        this.nodeTemplateRefs = [];\n    }\n\n    /** Re-run change detection on custom node partials after zTree mutates node state (e.g. open). No-op when template is unset or no hosts exist. */\n    private refreshTreeNodeTemplateHosts(): void {\n        if (!this.template || !this.nodeTemplateRefs.length) {\n            return;\n        }\n        this.ngZone.run(() => {\n            for (const ref of this.nodeTemplateRefs) {\n                try {\n                    ref.changeDetectorRef.detectChanges();\n                } catch {\n                    /* host destroyed */\n                }\n            }\n        });\n    }\n\n    /** Item passed to the custom template: zTree node API + row fields + toggle/select helpers. */\n    private buildCustomTemplateItemProxy(treeNode: any): any {\n        const rowData = treeNode.data;\n        const itemPayload = rowData && typeof rowData === 'object' ? getClonedObject(rowData) : rowData;\n\n        const self = this;\n        const nodeHelperProto = Object.create(treeNode);\n        nodeHelperProto.toggleExpand = (event?: Event) => {\n            if (event) {\n                event.preventDefault?.();\n                event.stopPropagation?.();\n            }\n            if (!treeNode.isParent) {\n                return;\n            }\n            self.expandNode(treeNode, !treeNode.open, true);\n        };\n        Object.defineProperty(nodeHelperProto, 'isSelected', {\n            enumerable: true,\n            configurable: true,\n            get: () => !!self.zTree?.isSelectedNode?.(treeNode),\n        });\n\n        const nodeApi = Object.create(nodeHelperProto);\n        return {\n            ... itemPayload,\n            _node: nodeApi,\n        };\n    }\n\n    private mountTreeNodeTemplateHost(host: HTMLElement, treeNode: any): void {\n        const ref = createComponent(TreeNodeTemplateHostComponent, {\n            environmentInjector: this.environmentInjector,\n            elementInjector: this.inj,\n            hostElement: host,\n        });\n        ref.setInput('template', this.template);\n        ref.setInput('userComponentParams', { dataObject: this.buildCustomTemplateItemProxy(treeNode) });\n        this.applicationRef.attachView(ref.hostView);\n        ref.changeDetectorRef.detectChanges();\n        this.nodeTemplateRefs.push(ref);\n    }\n\n    private addDiyDom = (_treeId: string, treeNode: any) => {\n        if (!this.template) {\n            return;\n        }\n        const aObj = $('#' + treeNode.tId + '_a');\n        if (!aObj.length || aObj.find('.wm-tree-node-template-host').length) {\n            return;\n        }\n        /** hide default zTree switch & icon and hide the built-in label span when using a custom template. */\n        const switchEl = $('#' + treeNode.tId + '_switch');\n        switchEl.hide();\n        $('#' + treeNode.tId + '_span').hide();\n\n        const host = document.createElement('span');\n        host.className = 'wm-tree-node-template-host wm-tree-node-item';\n        aObj.append(host);\n        this.mountTreeNodeTemplateHost(host, treeNode);\n    };\n\n    ngOnDestroy() {\n        this.destroyNodeTemplateHostRefs();\n        super.ngOnDestroy();\n    }\n\n    // expands the tree nodes if the property is selected.\n    private expandTree(level, node, childLevel) {\n        node.map(childNode => {\n            const children = childNode.children;\n            if (children && childLevel < level) {\n                childNode.open = true;\n                this.expandTree(level, children, childLevel+1);\n            } else {\n                childLevel = 0;\n                return;\n            }\n        });\n    }\n\n    // sets the template for the tree based on the property selected.\n    private setTreeTemplate(value) {\n        const classList = value?.split(\" \");\n        if (classList?.length) {\n            if (classList.includes('Classic')) {\n                this.setting.check[\"enable\"] = false;\n            } else if (classList.includes('Checkbox')) {\n                this.setting.check[\"enable\"] = true;\n                this.setting.check[\"chkStyle\"] = 'checkbox';\n            } else if (classList.includes('Radio')) {\n                this.setting.check[\"enable\"] = true;\n                this.setting.check[\"chkStyle\"] = 'radio';\n                this.setting.check[\"radioType\"] = \"all\";\n            }\n        }\n    }\n\n    // extracts nodes from string format\n    private getNodesFromString(value) {\n        return value.split(',').map((item) => {\n            return {\n                'label': item && item.trim()\n            };\n        });\n    }\n\n    // gets the nodes and orders the nodes if required\n    private getNodes(newVal) {\n        let nodes;\n        if (isArray(newVal)) {\n            nodes = getOrderedDataset(newVal, this.orderby);\n        } else if (isObject(newVal)) {\n            nodes = [newVal];\n        } else if (isString(newVal) && !isEmpty(newVal)) {\n            const trimmed = newVal.trim();\n            if (trimmed) {\n                if (trimmed.startsWith('[') || trimmed.startsWith('{')) {\n                    try {\n                        const parsed = JSON.parse(trimmed);\n                        if (isArray(parsed)) {\n                            nodes = getOrderedDataset(parsed, this.orderby);\n                        } else if (isObject(parsed)) {\n                            nodes = [parsed];\n                        }\n                    } catch {\n                        // Not valid JSON; treat as comma-separated labels below.\n                    }\n                }\n                if (!nodes) {\n                    nodes = this.getNodesFromString(trimmed);\n                }\n            }\n        }\n        return nodes;\n    }\n\n\n    // adds class to the nodes inorder to add icons to respective node.\n    private setNodeClasses(treeId, treeNode) {\n        return treeNode.icon ? {add: [`${treeNode.icon}`]} : '';\n    };\n\n    // adds tree icons to the nodes on load of the tree\n    private changeTreeIcons(nv) {\n        let eleClose = $('ul[name=\"' + this.name + '\"] li span.button.switch');\n\n        $(eleClose).map((idx, ele) => {\n            $(ele).addClass(nv);\n            $(ele).on(\"click\",function(e) {\n                setTimeout(() => {\n                    $(ele).addClass(nv);\n                }, 0);\n            });\n        })\n    }\n\n    // Returns the node path\n    private getPath(treeNode, path) {\n        if(treeNode.getParentNode() === null) {\n            path = \"/\" + treeNode.name + path;\n        } else {\n            path = this.getPath(treeNode.getParentNode(), path) + \"/\" + treeNode.name;\n        }\n        return path;\n    }\n\n    // binds the click event to all nodes to open the child nodes\n    public onClick(event, treeId, treeNode, clickFlag) {\n        if(this.nodeclick === \"expand\") {\n            var nodes = this.zTree.getSelectedNodes();\n            if (nodes.length>0) {\n                this.expandNode(nodes[0], !nodes[0].open, true);\n            }\n        }\n        this.selectNode(event, treeNode);\n    }\n\n    // Adds tree icon classes to child nodes when expanded\n    public onExpand(event, treeId, treeNode) {\n        let self = this;\n        let path = this.getPath(treeNode, \"\");\n\n        const eventParams = {\n            '$event'  : event,\n            \"$item\"   : getClonedObject(treeNode.data),\n            \"$path\" : path\n        };\n        this.invokeEventCallback('expand', eventParams);\n\n        const children = treeNode.children;\n        children?.map((el) => {\n            if (el.isParent) {\n                let ele = $(`#${el.tId}_switch`);\n                $(ele).addClass(self.treeicons || defaultTreeIconClass);\n                $(ele).on(\"click\", function(e) {\n                    setTimeout(() => {\n                        $(ele).addClass(self.treeicons || defaultTreeIconClass);\n                    }, 0);\n                });\n            }\n        });\n        this.refreshTreeNodeTemplateHosts();\n    }\n\n    public onCollapse(event, treeId, treeNode) {\n        let path = this.getPath(treeNode, \"\");\n        const eventParams = {\n            '$event'  : event,\n            \"$item\"   : getClonedObject(treeNode.data),\n            \"$path\" : path\n        };\n        this.invokeEventCallback('collapse', eventParams);\n        this.refreshTreeNodeTemplateHosts();\n    }\n\n    // function to support backward compatibility of objects\n    private constructZTreeData(data, zTreeData) {\n        data.forEach(node => {\n            const zNode = {};\n            const evaluatedLabel = getEvaluatedData(node, { field: this.nodelabel, bindExpression: this.bindnodelabel }, this.viewParent);\n            // Avoid zTree rendering the literal \"undefined\" when label field is missing or nodelabel does not match dataset (e.g. data uses \"key\" only).\n            const name =\n                evaluatedLabel !== undefined && evaluatedLabel !== null && evaluatedLabel !== ''\n                    ? evaluatedLabel\n                    : (node.label ?? node.key ?? node.name ?? '');\n            const icon = getEvaluatedData(node, { field: this.nodeicon, bindExpression: this.bindnodeicon }, this.viewParent) || node.icon;\n            const nodeId = getEvaluatedData(node, { field: this.nodeid, bindExpression: this.bindnodeid }, this.viewParent);\n            const children = getEvaluatedData(node, { field: this.nodechildren, bindExpression: this.bindnodechildren }, this.viewParent) || node.children;\n            zNode['name'] = name === undefined || name === null ? '' : String(name);\n            if(!this.template) {\n                zNode['icon'] = icon;\n            }\n            zNode['nodeId'] = nodeId;\n            zNode['data'] = getClonedObject(node);\n            if (node.selected) {\n                zNode['selected'] = true;\n            }\n            if (node.iconSkin != null && node.iconSkin !== '') {\n                zNode['iconSkin'] = node.iconSkin;\n            }\n            if (node.iconOpen != null && node.iconOpen !== '') {\n                zNode['iconOpen'] = node.iconOpen;\n            }\n            if (node.iconClose != null && node.iconClose !== '') {\n                zNode['iconClose'] = node.iconClose;\n            }\n            if (isArray(children) && children.length) {\n                zNode['children'] = [];\n                this.constructZTreeData(children, zNode['children']);\n            }\n            zTreeData.push(zNode);\n        });\n    }\n\n    // Renders the tree on to the dom\n    public renderTree() {\n        this.destroyNodeTemplateHostRefs();\n        this.setting.view['addDiyDom'] = this.template ? this.addDiyDom : undefined;\n        this.nativeElement.classList.toggle('app-tree-custom', !!this.template);\n        this.zTreeNodes = [];\n        if(this.nodes?.length) {\n            this.nativeElement.setAttribute('id', this.name);\n            this.constructZTreeData(this.nodes, this.zTreeNodes);\n            if(this.level > 0) {\n                this.expandTree(this.level, this.zTreeNodes, 0);\n            }\n        }\n        this.zTree = $.fn.zTree.init($('ul[name=\"' + this.name + '\"]'), this.setting, this.zTreeNodes);\n        $.fn.zTreeKeyboardNavigation(this.zTree, $('ul[name=\"' + this.name + '\"]'), null, this.treeicons || defaultTreeIconClass);\n        this.postRenderTree();\n    }\n\n    private setChecked(zNode, node) {\n        node.checked = zNode.checked;\n        const children = getEvaluatedData(node, {field: this.nodechildren, bindExpression: this.bindnodechildren}, this.viewParent) || node.children;\n        if(children?.length) {\n            children.forEach((node, index) => {\n                this.setChecked(zNode.children[index], node);\n            });\n        }\n    }\n\n    private selectNode(event, node) {\n        const deSelectElm = $(`.app-tree[name=${this.name}] li[treenode].selected`);\n        deSelectElm.removeClass('selected');\n\n        if(!node) {\n            this.refreshTreeNodeTemplateHosts();\n            return;\n        }\n        const selectElm = $(`#${node.tId}:has(.curSelectedNode)`);\n        selectElm.addClass('selected');\n\n\n        const classList = (this.treeClass || \"\").split(\" \");\n        if (classList.includes('Checkbox') || classList.includes('Radio')) {\n            this.setChecked(node, node.data);\n        }\n\n        const path = this.getPath(node, \"\");\n        this.selecteditem = getClonedObject(node.data) || {};\n        this.selecteditem.path = path;\n\n        const eventParams = {\n            '$event'  : event,\n            \"$item\"   : getClonedObject(node.data),\n            \"$path\" : path\n        };\n\n        //[Todo-CSP]: this data will be dynamic, can not generate function upfront\n        const nodeAction = node.data[this.nodeaction || 'action'];\n        if (nodeAction) {\n            $parseEvent(nodeAction)(this);\n        }\n        this.invokeEventCallback('select', eventParams);\n        this.refreshTreeNodeTemplateHosts();\n    }\n\n    private expandNode(node, expand, eventFlag) {\n        this.zTree.expandNode(node, expand, false, false, eventFlag);\n        const el = $(`#${node.tId}_switch`);\n        $(el).addClass(this.treeicons || defaultTreeIconClass);\n        this.refreshTreeNodeTemplateHosts();\n    }\n\n    private postRenderTree() {\n        setTimeout(() => {\n            this.changeTreeIcons(this.treeicons || defaultTreeIconClass);\n\n            const allNodes = this.zTree.transformToArray(this.zTree.getNodes());\n            const selectedNode = allNodes.find(n => n.selected);\n\n            if (selectedNode) {\n                this.zTree.selectNode(selectedNode, false);\n                this.selectNode(undefined, selectedNode);\n                this.expandNode(selectedNode, true, false);\n                return;\n            }\n\n            if (this.datavalue && !this.selecteditem) {\n                const nodes = this.zTree.getNodes();\n                let node;\n                if(nodes.length) {\n                    if (this.datavalue === 'FirstNode') {\n                        node = nodes[0];\n                    }\n                    if(this.datavalue === 'LastNode') {\n                        node = nodes[nodes.length - 1];\n                    }\n                }\n\n                if(node) {\n                    this.zTree.selectNode(node, false);\n                    this.selectNode(undefined, node);\n                    this.expandNode(node, true, false);\n                }\n            }\n        }, 200);\n    }\n\n    private selectById(value?) {\n        const simpleNodes = this.zTree?.transformToArray(this.zTree.getNodes());\n        const node = simpleNodes?.find(node => value === node.nodeId);\n        if(node) {\n            this.zTree.selectNode(node, false);\n            this.selectNode(undefined, node);\n        }\n    }\n    private deselectById(value?) {\n        this.selecteditem = {};\n        this.selectById();\n    }\n}\n","<ul #wmTree class=\"ztree\" id=\"ztree\"></ul>  "]}

package/components/basic/tree/esm2022/tree.props.mjs

@@ -0,0 +1,22 @@
+import { PROP_ANY, PROP_BOOLEAN, PROP_NUMBER, PROP_STRING, register } from '@wm/components/base';
+export const registerProps = () => {
+    register('wm-tree', new Map([
+        ['class', PROP_STRING],
+        ['template', PROP_STRING],
+        ['dataset', { value: 'node1, node2, node3', ...PROP_ANY }],
+        ['datavalue', PROP_STRING],
+        ['levels', { value: 0, ...PROP_NUMBER }],
+        ['name', PROP_STRING],
+        ['nodeaction', PROP_STRING],
+        ['nodechildren', PROP_STRING],
+        ['nodeclick', { value: 'none', ...PROP_STRING }],
+        ['nodeicon', PROP_STRING],
+        ['nodeid', PROP_STRING],
+        ['nodelabel', PROP_STRING],
+        ['orderby', PROP_STRING],
+        ['show', { value: true, ...PROP_BOOLEAN }],
+        ['tabindex', { value: 0, ...PROP_NUMBER }],
+        ['treeicons', PROP_STRING]
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,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