@qbs-origin/origin-form 0.5.0

package/esm2022/lib/shared-components/dictionaries-tree.component.mjs

@@ -0,0 +1,301 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { EnvironmentType } from '../others/environment-type';
+import { Utils } from '../others/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/dictionary.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/progress-spinner";
+import * as i4 from "./treeview/treeview.component";
+export class DictionariesTreeComponent {
+    constructor(dictService) {
+        this.dictService = dictService;
+        this.allowCheckItems = true;
+        this.allowFilter = false;
+        this.drawReferenceDictionariesAsSeparateNode = true;
+        this.drawChildDictionariesAsSeparateNode = true;
+        this.drawRootNode = true;
+        this.allowSelectNonLeafNodes = false;
+        this.hideParentArrow = false;
+        // NEW: Accept preloaded dictionary data
+        this.preloadedDictionary = null;
+        this.preloadedDictionaries = null;
+        this.usePreloadedData = false;
+        this.selectedDictionaryValuesChanged = new EventEmitter();
+    }
+    ngOnInit() {
+        // Only initialize if not already set
+        if (!this.allDictionaries) {
+            this.allDictionaries = [];
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['dictionaryId']) {
+            const changed = changes['dictionaryId'];
+            if (changed.currentValue !== changed.previousValue) {
+                this.loadDictionary();
+            }
+        }
+        // NEW: Handle preloaded data changes
+        if (changes['preloadedDictionary'] ||
+            changes['preloadedDictionaries'] ||
+            changes['usePreloadedData']) {
+            if (this.usePreloadedData && this.preloadedDictionary) {
+                this.loadFromPreloadedData();
+            }
+            else if (this.dictionaryId) {
+                this.loadDictionary();
+            }
+        }
+        if (changes['filterText'] && this.treeViewControl) {
+            let text = changes['filterText'].currentValue;
+            this.treeViewControl.filterText(text);
+        }
+    }
+    ngAfterViewInit() {
+        // If we have a main dictionary but haven't built the tree yet, build it now
+        if (this.mainDictionary && this.treeViewControl) {
+            this.rebuildTree();
+        }
+        // If we have a dictionaryId but haven't loaded the dictionary yet, load it now
+        // This handles the case where the component is initialized with a pre-populated dictionaryId
+        if (this.dictionaryId && !this.mainDictionary && !this.isLoading) {
+            if (this.usePreloadedData && this.preloadedDictionary) {
+                this.loadFromPreloadedData();
+            }
+            else {
+                this.loadDictionary();
+            }
+        }
+    }
+    loadDictionary() {
+        if (this.dictionaryId) {
+            this.isLoading = true;
+            const params = {
+                env: EnvironmentType.Config, // TODO: retrieve correct environment
+                languageId: this.languageId > 0 ? this.languageId : undefined,
+                valueIdsToShow: this.valuesIdsToShow?.length > 0 ? this.valuesIdsToShow : undefined,
+            };
+            this.dictService.getDictionaryTree(this.dictionaryId, params).subscribe({
+                next: (response) => {
+                    this.mainDictionary = response.mainDictionary;
+                    this.allDictionaries = response.allDictionaries;
+                    this.rebuildTree();
+                    this.isLoading = false;
+                },
+                error: (error) => {
+                    console.error('Failed to load dictionary tree:', error);
+                    this.isLoading = false;
+                },
+            });
+        }
+        else {
+            this.clearTree();
+        }
+    }
+    /**
+     * NEW: Load dictionary from preloaded data instead of API calls
+     */
+    loadFromPreloadedData() {
+        if (!this.preloadedDictionary) {
+            console.warn('No preloaded dictionary data available, falling back to API');
+            this.loadDictionary();
+            return;
+        }
+        this.isLoading = true;
+        this.mainDictionary = { ...this.preloadedDictionary }; // Create a copy
+        // Apply value filtering if needed
+        if (this.valuesIdsToShow?.length > 0) {
+            this.mainDictionary.values =
+                this.mainDictionary.values?.filter((v) => this.valuesIdsToShow.some((c) => c == v.id)) || [];
+        }
+        // Use preloaded dictionaries for dependencies
+        this.loadAllNeededDictionariesFromPreloaded(this.mainDictionary);
+        this.isLoading = false;
+    }
+    /**
+     * NEW: Load needed dictionaries from preloaded data instead of API calls
+     */
+    loadAllNeededDictionariesFromPreloaded(dictionary) {
+        if (!this.preloadedDictionaries) {
+            console.warn('No preloaded dictionaries map available');
+            return;
+        }
+        // Initialize with all preloaded dictionaries - this ensures child dictionaries are available
+        this.allDictionaries = Array.from(this.preloadedDictionaries.values());
+        // Build the tree
+        this.rebuildTree();
+    }
+    rebuildTree() {
+        // Check if treeViewControl is available (ViewChild might not be initialized yet)
+        if (!this.treeViewControl) {
+            return;
+        }
+        let node = this.buildDictionaryTree(this.mainDictionary);
+        if (this.drawRootNode) {
+            this.treeViewControl.initialize([node]);
+        }
+        else {
+            this.treeViewControl.initialize(node.children);
+        }
+        if (this.allowCheckItems) {
+            if (this.selectedValueIds && this.selectedValueIds.length > 0) {
+                this.treeViewControl.expandAll();
+            }
+            else {
+                this.treeViewControl.expandNode(0);
+            }
+        }
+    }
+    clearTree() {
+        // Check if treeViewControl is available
+        if (!this.treeViewControl) {
+            return;
+        }
+        let node = {};
+        this.treeViewControl.initialize([node]);
+    }
+    buildDictionaryTree(dictionary) {
+        let node = {
+            name: dictionary.name,
+            children: [],
+            data: null,
+            canSelect: false,
+            hideArrow: false,
+        };
+        // Build the tree recursively
+        this.buildTreeChildren(dictionary, node);
+        // Set canSelect for root node based on whether it has children
+        if (!this.hideParentArrow) {
+            node.canSelect = this.getCanSelect(node);
+        }
+        else {
+            node.canSelect = false;
+            node.hideArrow = true;
+        }
+        return node;
+    }
+    buildTreeChildren(dictionary, node) {
+        if (dictionary.values) {
+            dictionary.values.forEach((v) => {
+                let childrenNode = {
+                    name: v.name,
+                    children: [],
+                    data: v,
+                    isSelected: false,
+                    canSelect: false,
+                    hideArrow: false,
+                };
+                if (this.languageId > 0) {
+                    const val = Utils.findValueTranslation(v.valueTranslations, this.languageId);
+                    if (val) {
+                        childrenNode.name = val;
+                    }
+                }
+                if (this.selectedValueIds && this.selectedValueIds.indexOf(v.id) >= 0) {
+                    childrenNode.isSelected = true;
+                }
+                // Recursively build child dictionaries if any
+                if (v.childDictionaryId || v.childDictionaryUUID) {
+                    let dict;
+                    // Try UUID-based lookup first (for preloaded data)
+                    if (v.childDictionaryUUID) {
+                        dict = this.allDictionaries.find((d) => d.uuid === v.childDictionaryUUID);
+                    }
+                    // Fallback to ID-based lookup (for API-loaded data)
+                    if (!dict && v.childDictionaryId) {
+                        dict = this.allDictionaries.find((d) => d.id === v.childDictionaryId);
+                    }
+                    if (dict) {
+                        this.buildTreeChildren(dict, childrenNode);
+                    }
+                }
+                // Handle reference values
+                if (v.referenceValues?.length > 0 &&
+                    this.drawReferenceDictionariesAsSeparateNode === true) {
+                    // Try to find reference dictionary by UUID first, then by ID
+                    let refDict = this.allDictionaries.find((d) => dictionary.referredInDictionariesUUIds?.includes(d.uuid || ''));
+                    if (!refDict) {
+                        refDict = this.allDictionaries.find((d) => d.id === dictionary.referenceId);
+                    }
+                    v.referenceValues.forEach((rv) => {
+                        let referenceNode = {
+                            name: rv.name + ` (${refDict?.name})`,
+                            children: [],
+                            data: rv,
+                            isSelected: false,
+                            canSelect: true, // Reference values are leaf nodes and can be selected
+                            hideArrow: false,
+                        };
+                        if (this.selectedValueIds &&
+                            this.selectedValueIds.indexOf(rv.id) >= 0) {
+                            referenceNode.isSelected = true;
+                        }
+                        childrenNode.children.push(referenceNode);
+                    });
+                }
+                // Determine if the current node can be selected
+                childrenNode.canSelect = this.getCanSelect(childrenNode);
+                // Add the child node to the current node's children
+                node.children.push(childrenNode);
+            });
+        }
+    }
+    // Helper method to determine if a node can be selected
+    getCanSelect(node) {
+        const isLeaf = node.children.length === 0;
+        return isLeaf || this.allowSelectNonLeafNodes;
+    }
+    onTreeSelectionChanged(node) {
+        var selectedNodes = this.treeViewControl.getSelectedNodes();
+        var values = selectedNodes.map((n) => n.data);
+        let dvs = this.createCopy(values);
+        this.selectedDictionaryValuesChanged.next(dvs);
+    }
+    createCopy(objectToCopy) {
+        var s = JSON.stringify(objectToCopy);
+        var news = s.replace(/"valueTranslations":/g, '"translations":');
+        return JSON.parse(news);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DictionariesTreeComponent, deps: [{ token: i1.DictionaryService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DictionariesTreeComponent, selector: "app-dictionaries-tree", inputs: { dictionaryId: "dictionaryId", selectedValueIds: "selectedValueIds", allowCheckItems: "allowCheckItems", allowFilter: "allowFilter", drawReferenceDictionariesAsSeparateNode: "drawReferenceDictionariesAsSeparateNode", drawChildDictionariesAsSeparateNode: "drawChildDictionariesAsSeparateNode", drawRootNode: "drawRootNode", filterText: "filterText", allowSelectNonLeafNodes: "allowSelectNonLeafNodes", languageId: "languageId", valuesIdsToShow: "valuesIdsToShow", hideParentArrow: "hideParentArrow", preloadedDictionary: "preloadedDictionary", preloadedDictionaries: "preloadedDictionaries", usePreloadedData: "usePreloadedData" }, outputs: { selectedDictionaryValuesChanged: "selectedDictionaryValuesChanged" }, viewQueries: [{ propertyName: "treeViewControl", first: true, predicate: ["treeView"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<mat-spinner *ngIf=\"isLoading === true\" class=\"m-x-auto\"></mat-spinner>\n<app-treeview #treeView [autoSelectDescendants]=\"false\"\n              [allowCheckItems]=\"allowCheckItems\"\n              [allowFilter]=\"allowFilter\"\n              (selectionChanged)=\"onTreeSelectionChanged($event)\">\n\n</app-treeview>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "component", type: i4.AppTreeviewComponent, selector: "app-treeview", inputs: ["allowAddItems", "autoSelectDescendants", "allowCheckItems", "allowFilter"], outputs: ["selectionChanged"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DictionariesTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-dictionaries-tree', template: "<mat-spinner *ngIf=\"isLoading === true\" class=\"m-x-auto\"></mat-spinner>\n<app-treeview #treeView [autoSelectDescendants]=\"false\"\n              [allowCheckItems]=\"allowCheckItems\"\n              [allowFilter]=\"allowFilter\"\n              (selectionChanged)=\"onTreeSelectionChanged($event)\">\n\n</app-treeview>\n" }]
+        }], ctorParameters: () => [{ type: i1.DictionaryService }], propDecorators: { treeViewControl: [{
+                type: ViewChild,
+                args: ['treeView']
+            }], dictionaryId: [{
+                type: Input
+            }], selectedValueIds: [{
+                type: Input
+            }], allowCheckItems: [{
+                type: Input
+            }], allowFilter: [{
+                type: Input
+            }], drawReferenceDictionariesAsSeparateNode: [{
+                type: Input
+            }], drawChildDictionariesAsSeparateNode: [{
+                type: Input
+            }], drawRootNode: [{
+                type: Input
+            }], filterText: [{
+                type: Input
+            }], allowSelectNonLeafNodes: [{
+                type: Input
+            }], languageId: [{
+                type: Input
+            }], valuesIdsToShow: [{
+                type: Input
+            }], hideParentArrow: [{
+                type: Input
+            }], preloadedDictionary: [{
+                type: Input
+            }], preloadedDictionaries: [{
+                type: Input
+            }], usePreloadedData: [{
+                type: Input
+            }], selectedDictionaryValuesChanged: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dictionaries-tree.component.js","sourceRoot":"","sources":["../../../../../projects/origin-form/src/lib/shared-components/dictionaries-tree.component.ts","../../../../../projects/origin-form/src/lib/shared-components/dictionaries-tree.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { DictionaryValue, DictionaryDto, DictionaryValueDto } from '../models/dictionary.model';\nimport { EnvironmentType } from '../others/environment-type';\nimport { Utils } from '../others/utils';\nimport { DictionaryService, DictionaryTreeResponseDto } from '../services/dictionary.service';\nimport { ItemNode, ItemFlatNode } from '../models/treeview.model';\nimport { AppTreeviewComponent } from './treeview/treeview.component';\n\n\n@Component({\n  selector: 'app-dictionaries-tree',\n  templateUrl: './dictionaries-tree.component.html',\n  styleUrl: './dictionaries-tree.component.scss',\n})\nexport class DictionariesTreeComponent\n  implements OnInit, OnChanges, AfterViewInit\n{\n  @ViewChild('treeView') treeViewControl: AppTreeviewComponent;\n  @Input() dictionaryId: string;\n  @Input() selectedValueIds: number[];\n  @Input() allowCheckItems: boolean = true;\n  @Input() allowFilter: boolean = false;\n  @Input() drawReferenceDictionariesAsSeparateNode: boolean = true;\n  @Input() drawChildDictionariesAsSeparateNode: boolean = true;\n  @Input() drawRootNode: boolean = true;\n  @Input() filterText: string;\n  @Input() allowSelectNonLeafNodes: boolean = false;\n  @Input() languageId: number;\n  @Input() valuesIdsToShow: number[];\n  @Input() hideParentArrow: boolean = false;\n\n  // NEW: Accept preloaded dictionary data\n  @Input() preloadedDictionary: DictionaryDto | null = null;\n  @Input() preloadedDictionaries: Map<string, DictionaryDto> | null = null;\n  @Input() usePreloadedData: boolean = false;\n\n  @Output() selectedDictionaryValuesChanged: EventEmitter<DictionaryValue[]> =\n    new EventEmitter<DictionaryValue[]>();\n\n  allDictionaries: DictionaryDto[];\n  mainDictionary: DictionaryDto;\n  isLoading: boolean;\n\n  constructor(private dictService: DictionaryService) {}\n\n  ngOnInit(): void {\n    // Only initialize if not already set\n    if (!this.allDictionaries) {\n      this.allDictionaries = [];\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['dictionaryId']) {\n      const changed = changes['dictionaryId'];\n      if (changed.currentValue !== changed.previousValue) {\n        this.loadDictionary();\n      }\n    }\n\n    // NEW: Handle preloaded data changes\n    if (\n      changes['preloadedDictionary'] ||\n      changes['preloadedDictionaries'] ||\n      changes['usePreloadedData']\n    ) {\n      if (this.usePreloadedData && this.preloadedDictionary) {\n        this.loadFromPreloadedData();\n      } else if (this.dictionaryId) {\n        this.loadDictionary();\n      }\n    }\n\n    if (changes['filterText'] && this.treeViewControl) {\n      let text = changes['filterText'].currentValue as string;\n      this.treeViewControl.filterText(text);\n    }\n  }\n\n  ngAfterViewInit(): void {\n    // If we have a main dictionary but haven't built the tree yet, build it now\n    if (this.mainDictionary && this.treeViewControl) {\n      this.rebuildTree();\n    }\n\n    // If we have a dictionaryId but haven't loaded the dictionary yet, load it now\n    // This handles the case where the component is initialized with a pre-populated dictionaryId\n    if (this.dictionaryId && !this.mainDictionary && !this.isLoading) {\n      if (this.usePreloadedData && this.preloadedDictionary) {\n        this.loadFromPreloadedData();\n      } else {\n        this.loadDictionary();\n      }\n    }\n  }\n\n  loadDictionary() {\n    if (this.dictionaryId) {\n      this.isLoading = true;\n\n      const params = {\n        env: EnvironmentType.Config, // TODO: retrieve correct environment\n        languageId: this.languageId > 0 ? this.languageId : undefined,\n        valueIdsToShow:\n          this.valuesIdsToShow?.length > 0 ? this.valuesIdsToShow : undefined,\n      };\n\n      this.dictService.getDictionaryTree(this.dictionaryId, params).subscribe({\n        next: (response: DictionaryTreeResponseDto) => {\n          this.mainDictionary = response.mainDictionary;\n          this.allDictionaries = response.allDictionaries;\n          this.rebuildTree();\n          this.isLoading = false;\n        },\n        error: (error) => {\n          console.error('Failed to load dictionary tree:', error);\n          this.isLoading = false;\n        },\n      });\n    } else {\n      this.clearTree();\n    }\n  }\n\n  /**\n   * NEW: Load dictionary from preloaded data instead of API calls\n   */\n  loadFromPreloadedData() {\n    if (!this.preloadedDictionary) {\n      console.warn(\n        'No preloaded dictionary data available, falling back to API'\n      );\n      this.loadDictionary();\n      return;\n    }\n\n    this.isLoading = true;\n    this.mainDictionary = { ...this.preloadedDictionary }; // Create a copy\n\n    // Apply value filtering if needed\n    if (this.valuesIdsToShow?.length > 0) {\n      this.mainDictionary.values =\n        this.mainDictionary.values?.filter((v) =>\n          this.valuesIdsToShow.some((c) => c == v.id)\n        ) || [];\n    }\n\n    // Use preloaded dictionaries for dependencies\n    this.loadAllNeededDictionariesFromPreloaded(this.mainDictionary);\n    this.isLoading = false;\n  }\n\n  /**\n   * NEW: Load needed dictionaries from preloaded data instead of API calls\n   */\n  loadAllNeededDictionariesFromPreloaded(dictionary: DictionaryDto) {\n    if (!this.preloadedDictionaries) {\n      console.warn('No preloaded dictionaries map available');\n      return;\n    }\n\n    // Initialize with all preloaded dictionaries - this ensures child dictionaries are available\n    this.allDictionaries = Array.from(this.preloadedDictionaries.values());\n\n    // Build the tree\n    this.rebuildTree();\n  }\n\n  rebuildTree() {\n    // Check if treeViewControl is available (ViewChild might not be initialized yet)\n    if (!this.treeViewControl) {\n      return;\n    }\n\n    let node = this.buildDictionaryTree(this.mainDictionary);\n    if (this.drawRootNode) {\n      this.treeViewControl.initialize([node]);\n    } else {\n      this.treeViewControl.initialize(node.children);\n    }\n    if (this.allowCheckItems) {\n      if (this.selectedValueIds && this.selectedValueIds.length > 0) {\n        this.treeViewControl.expandAll();\n      } else {\n        this.treeViewControl.expandNode(0);\n      }\n    }\n  }\n\n  clearTree() {\n    // Check if treeViewControl is available\n    if (!this.treeViewControl) {\n      return;\n    }\n\n    let node = {} as ItemNode;\n    this.treeViewControl.initialize([node]);\n  }\n\n  buildDictionaryTree(dictionary: DictionaryDto): ItemNode {\n    let node = {\n      name: dictionary.name,\n      children: [],\n      data: null,\n      canSelect: false,\n      hideArrow: false,\n    } as ItemNode;\n\n    // Build the tree recursively\n    this.buildTreeChildren(dictionary, node);\n\n    // Set canSelect for root node based on whether it has children\n    if (!this.hideParentArrow) {\n      node.canSelect = this.getCanSelect(node);\n    } else {\n      node.canSelect = false;\n      node.hideArrow = true;\n    }\n\n    return node;\n  }\n\n  buildTreeChildren(dictionary: DictionaryDto, node: ItemNode): void {\n    if (dictionary.values) {\n      dictionary.values.forEach((v) => {\n        let childrenNode = {\n          name: v.name,\n          children: [],\n          data: v,\n          isSelected: false,\n          canSelect: false,\n          hideArrow: false,\n        } as ItemNode;\n        if (this.languageId > 0) {\n          const val = Utils.findValueTranslation(\n            v.valueTranslations,\n            this.languageId\n          );\n          if (val) {\n            childrenNode.name = val;\n          }\n        }\n\n        if (this.selectedValueIds && this.selectedValueIds.indexOf(v.id) >= 0) {\n          childrenNode.isSelected = true;\n        }\n\n        // Recursively build child dictionaries if any\n        if (v.childDictionaryId || v.childDictionaryUUID) {\n          let dict: DictionaryDto | undefined;\n\n          // Try UUID-based lookup first (for preloaded data)\n          if (v.childDictionaryUUID) {\n            dict = this.allDictionaries.find(\n              (d) => d.uuid === v.childDictionaryUUID\n            );\n          }\n\n          // Fallback to ID-based lookup (for API-loaded data)\n          if (!dict && v.childDictionaryId) {\n            dict = this.allDictionaries.find(\n              (d) => d.id === v.childDictionaryId\n            );\n          }\n\n          if (dict) {\n            this.buildTreeChildren(dict, childrenNode);\n          }\n        }\n\n        // Handle reference values\n        if (\n          v.referenceValues?.length > 0 &&\n          this.drawReferenceDictionariesAsSeparateNode === true\n        ) {\n          // Try to find reference dictionary by UUID first, then by ID\n          let refDict = this.allDictionaries.find((d) =>\n            dictionary.referredInDictionariesUUIds?.includes(d.uuid || '')\n          );\n\n          if (!refDict) {\n            refDict = this.allDictionaries.find(\n              (d) => d.id === dictionary.referenceId\n            );\n          }\n\n          v.referenceValues.forEach((rv) => {\n            let referenceNode = {\n              name: rv.name + ` (${refDict?.name})`,\n              children: [],\n              data: rv,\n              isSelected: false,\n              canSelect: true, // Reference values are leaf nodes and can be selected\n              hideArrow: false,\n            } as ItemNode;\n\n            if (\n              this.selectedValueIds &&\n              this.selectedValueIds.indexOf(rv.id) >= 0\n            ) {\n              referenceNode.isSelected = true;\n            }\n\n            childrenNode.children.push(referenceNode);\n          });\n        }\n\n        // Determine if the current node can be selected\n        childrenNode.canSelect = this.getCanSelect(childrenNode);\n\n        // Add the child node to the current node's children\n        node.children.push(childrenNode);\n      });\n    }\n  }\n\n  // Helper method to determine if a node can be selected\n  getCanSelect(node: ItemNode): boolean {\n    const isLeaf = node.children.length === 0;\n    return isLeaf || this.allowSelectNonLeafNodes;\n  }\n\n  onTreeSelectionChanged(node: ItemFlatNode) {\n    var selectedNodes = this.treeViewControl.getSelectedNodes();\n    var values = selectedNodes.map((n) => n.data) as DictionaryValueDto[];\n    let dvs = this.createCopy(values);\n\n    this.selectedDictionaryValuesChanged.next(dvs);\n  }\n\n  createCopy(objectToCopy: DictionaryValueDto[]): DictionaryValue[] {\n    var s = JSON.stringify(objectToCopy);\n    var news = s.replace(/\"valueTranslations\":/g, '\"translations\":');\n    return JSON.parse(news) as DictionaryValue[];\n  }\n}\n","<mat-spinner *ngIf=\"isLoading === true\" class=\"m-x-auto\"></mat-spinner>\n<app-treeview #treeView [autoSelectDescendants]=\"false\"\n              [allowCheckItems]=\"allowCheckItems\"\n              [allowFilter]=\"allowFilter\"\n              (selectionChanged)=\"onTreeSelectionChanged($event)\">\n\n</app-treeview>\n"]}