@simpleangularcontrols/sac-common 13.0.0-rc.5 → 16.0.0-rc.2

package/esm2022/controls/treeview/treeview.mjs

@@ -0,0 +1,344 @@
+import { ContentChild, Directive, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Basis Komponente für SacTreeView
+ */
+class SacTreeViewCommon {
+    constructor() {
+        /**
+         * Das Property enthielt array of nodes. Default value: empty array [].
+         */
+        this.nodes = [];
+        /**
+         * Das Property enthielt node attribute: 'isCollapsed'. Es wird benutzt beim rendering. Für Expand/Collapsed Sicht des Node(Wert)
+         */
+        this.collapseAttr = 'isCollapsed';
+        /**
+         * Das Property enthielt node attribute: 'isSelected'. Es wird benutzt beim Vorbereitung des Data des TreeView
+         */
+        this.selectAttr = 'isSelected';
+        /**
+         * Das Property enthielt node attribute: 'isIndeterminate'. Es wird benutzt beim Vorbereitung des Data des TreeView
+         */
+        this.inDeterminateAttr = 'isIndeterminate';
+        /**
+         * Providen data for tree.
+         */
+        this._data = [];
+        /**
+         * Input property für den Namen des TreeView. Type string. Default value: ""
+         */
+        this.name = '';
+        /**
+         * A flag indicating data is flatten in array and prepare is required.(Default
+         * is false).
+         */
+        this.prepareData = false;
+        /**
+         * Attribute for Text in Tree
+         */
+        this.textAttr = 'data';
+        /**
+         * Name of ID property in input data.
+         */
+        this.idAttr = 'id';
+        /**
+         * Name of parent property in input data.
+         */
+        this.parentAttr = 'PARENT_ID';
+        /**
+         * Name of children list property in input data.
+         */
+        this.childrenAttr = 'children';
+        /**
+         * Output Emitter. Emit das ID des selected Node.
+         */
+        this.selectedidchange = new EventEmitter();
+        /**
+         * Output Emitter. Emit das TextAttr des selected Node.
+         */
+        this.selectedtextchanged = new EventEmitter();
+        /**
+         * Output Emitter. Emit wenn ein Node selektiert wird.
+         */
+        this.selecteditem = new EventEmitter();
+    }
+    /**
+     * Getter für Data des TreeView
+     */
+    get data() {
+        return this._data;
+    }
+    /**
+     * Input Property für Data des TreeView
+     */
+    set data(value) {
+        this._data = value;
+        this.nodes = value;
+        // this.nodes.forEach(node => node["typeId"] = "13")
+        this.LoadTree();
+        if (this._collapseAll !== undefined) {
+            this.collapseAllNode(this._collapseAll);
+        }
+    }
+    /**
+     * Die Directive erhält die actions für das TreeView
+     */
+    set treeviewTemplate(v) {
+        this.template = v;
+    }
+    /**
+     * Getter für das TreeView Template
+     */
+    get treeviewTemplate() {
+        return this.template;
+    }
+    /**
+     * Setter property. Deffiniert das FileIcon für das TreeView
+     */
+    set treefileicon(v) {
+        this.fileicontemplate = v;
+    }
+    /**
+     * Getter property. Ergibt das FileIcon für das TreeView
+     */
+    get treefileicon() {
+        return this.fileicontemplate;
+    }
+    // @Input("titleAction") _titleAction: string
+    /**
+     * Collapse or expand all parent nodes.
+     */
+    set collapseall(value) {
+        this._collapseAll = value;
+        if (this.nodes && this.nodes.length && this.nodes.length > 0) {
+            this.collapseAllNode(this._collapseAll);
+        }
+        // this._recursiveEdit(
+        //   this.nodes, this.childrenAttr, this.collapseAttr, this._collapseAll);
+        // this.cd.detectChanges();
+    }
+    /**
+     * Getter für das collapse property. Ergibt boolean Wert, ob die Items collapsed/expand sind.
+     */
+    get collapseall() {
+        return this._collapseAll;
+    }
+    /**
+     * Select or deselect all nodes.
+     */
+    set selectall(value) {
+        this._selectAll = value;
+        this._recursiveEdit(this.nodes, this.childrenAttr, this.selectAttr, value);
+        this._recursiveEdit(this.nodes, this.childrenAttr, this.inDeterminateAttr, false);
+    }
+    /**
+     * Input property - setter. Deffiniert das ID des selektierten Item(node)
+     */
+    set selectedid(v) {
+        this.selectedNode = this.findNode(this.nodes, v, this.idAttr);
+        // if (this.selectedNode) {
+        //   this.selectedIdEmitter.emit(this.selectedNode[this.idAttr]);
+        //   this.selectedTextEmitter.emit(this.selectedNode[this.textAttr]);
+        // }
+    }
+    /**
+     * Getter. Ergibt das ID des selektierten Item(node)
+     */
+    get selectedId() {
+        return this.selectedNode ? this.selectedNode[this.idAttr] : null;
+    }
+    /**
+     * Setter für das selektierte Wert(node). Wenn aufgerufen das ID und TextAttr des selected Node wird emitted
+     */
+    set selectedNode(v) {
+        this._selectedNode = v;
+        if (this._selectedNode) {
+            this.selectedidchange.emit(this.selectedId);
+            this.selectedtextchanged.emit(v[this.textAttr]);
+        }
+    }
+    /**
+     * Getter für das selektierte Wert(node). Ergibt das selektierte Wert(node).
+     */
+    get selectedNode() {
+        return this._selectedNode;
+    }
+    /**
+     * A lifecycle hook that is called after Angular has initialized all data-bound properties of a directive.
+     * Define an ngOnInit() method to handle any additional initialization tasks.
+     */
+    ngOnInit() {
+        this.collapseAllNode(this._collapseAll);
+        if (this.selectedId)
+            this.openSelectedNode(this.nodes);
+    }
+    /**
+     * Funktion setzt alle parent items recusiv zum selected node
+     * auf collapsed = false
+     */
+    openSelectedNode(data) {
+        let result = false;
+        for (let i = 0; i < data.length; i++) {
+            if (data[i][this.childrenAttr].length &&
+                data[i][this.idAttr] != this.selectedId)
+                result = this.openSelectedNode(data[i][this.childrenAttr]);
+            if (result || data[i][this.idAttr] == this.selectedId) {
+                data[i][this.collapseAttr] = false;
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Die Methode vorbereitet die Daten für das TreeView. Die Funktion sollte geändert werden abhängig von dem kommenden Daten (wenn array)
+     */
+    LoadTree() {
+        //if the tree structure require array the function below should be changed
+        const cloned = this._data.map((x) => Object.assign({}, x));
+        // If data is flat, prepare data with recursive function.
+        this.nodes = this.prepareData ? this._getPreparedData(cloned) : this._data;
+    }
+    /**
+     * Die Methode collapse/expand den selectierten Node
+     */
+    onCollapseClick(node) {
+        if (node[this.childrenAttr].length) {
+            node[this.collapseAttr] = !node[this.collapseAttr];
+        }
+    }
+    /**
+     * Die Methode set den selektierten Node und emit es.
+     */
+    onClick(node) {
+        this.selectedNode = node;
+        this.selecteditem.emit(this.selectedNode);
+        // this.cd.detectChanges();
+    }
+    /**
+     * Die Methode wird ein event mit Meldung zu Parent emit-en.
+     */
+    sendMsgToParent(msg) {
+        this.selecteditem.emit(msg);
+    }
+    /**
+     * Die Methode wird alle Nodes collapse
+     */
+    collapseAllNode(command) {
+        this.nodes.forEach((node) => {
+            if (node[this.childrenAttr].length) {
+                collapseAllHIdden(node, this.collapseAttr, command, this.childrenAttr);
+            }
+        });
+        function collapseAllHIdden(node, collapseAttr, command, childrenAttr) {
+            node[collapseAttr] = command;
+            node.children.forEach((child) => {
+                if (child[childrenAttr].length) {
+                    collapseAllHIdden(child, collapseAttr, command, childrenAttr);
+                }
+            });
+        }
+    }
+    /**
+     * Funktion gibt node aus der liste zurück, welches das Value auf dem gewünschten Attribut hat
+     * Wenn node nicht gefunden wird, wird null zurück gegeben
+     * @param data Liste der nodes
+     * @param searchValue Das gesuchte value
+     * @param attr Der namen des Attributs auf dem das value gesucht wird
+     */
+    findNode(data, searchValue, attr) {
+        let result = null;
+        for (let i = 0; i < data.length; i++) {
+            if (data[i][attr] == searchValue)
+                result = data[i];
+            else {
+                if (data[i][this.childrenAttr].length) {
+                    let recursiveResult = this.findNode(data[i][this.childrenAttr], searchValue, attr);
+                    if (recursiveResult)
+                        result = recursiveResult;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Die Methode editiert (recursive) alle eingegebene Nodes abhängig von gegebenen Attibute und Value Kriterien.
+     */
+    _recursiveEdit(list, childrenAttr, attr, value) {
+        if (Array.isArray(list)) {
+            for (let i = 0, len = list.length; i < len; i++) {
+                list[i][attr] = value;
+                if (list[i][childrenAttr].length) {
+                    this._recursiveEdit(list[i][childrenAttr], childrenAttr, attr, value);
+                }
+            }
+        }
+    }
+    /**
+     * Die Methode erstellt eine standarte Sicht-Liste von Nodes
+     */
+    _getPreparedData(list) {
+        const tree = [], lookup = {};
+        for (let i = 0, len = list.length; i < len; i++) {
+            lookup[list[i][this.idAttr]] = list[i];
+            list[i][this.childrenAttr] = [];
+            list[i][this.collapseAttr] = true;
+            list[i][this.selectAttr] = false;
+            list[i][this.inDeterminateAttr] = false;
+        }
+        for (let i = 0, len = list.length; i < len; i++) {
+            if (list[i][this.parentAttr]) {
+                lookup[list[i][this.parentAttr]][this.childrenAttr].push(list[i]);
+            }
+            else {
+                tree.push(list[i]);
+            }
+        }
+        return tree;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacTreeViewCommon, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacTreeViewCommon, inputs: { data: "data", template: "template", fileicontemplate: "fileicontemplate", name: "name", prepareData: "prepareData", textAttr: "textAttr", idAttr: "idAttr", parentAttr: "parentAttr", childrenAttr: "childrenAttr", title: "title", collapseall: "collapseall", selectall: "selectall", selectedid: "selectedid" }, outputs: { selectedidchange: "selectedidchange", selectedtextchanged: "selectedtextchanged", selecteditem: "selecteditem" }, queries: [{ propertyName: "treeviewTemplate", first: true, predicate: ["actions"], descendants: true, static: true }, { propertyName: "treefileicon", first: true, predicate: ["treefileicon"], descendants: true, static: true }], ngImport: i0 }); }
+}
+export { SacTreeViewCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacTreeViewCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { data: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }], treeviewTemplate: [{
+                type: ContentChild,
+                args: ['actions', { static: true }]
+            }], fileicontemplate: [{
+                type: Input
+            }], treefileicon: [{
+                type: ContentChild,
+                args: ['treefileicon', { static: true }]
+            }], name: [{
+                type: Input
+            }], prepareData: [{
+                type: Input
+            }], textAttr: [{
+                type: Input
+            }], idAttr: [{
+                type: Input
+            }], parentAttr: [{
+                type: Input
+            }], childrenAttr: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], collapseall: [{
+                type: Input
+            }], selectall: [{
+                type: Input
+            }], selectedid: [{
+                type: Input
+            }], selectedidchange: [{
+                type: Output
+            }], selectedtextchanged: [{
+                type: Output
+            }], selecteditem: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"treeview.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/treeview/treeview.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ContentChild,\r\n  Directive,\r\n  EventEmitter,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n  TemplateRef,\r\n} from '@angular/core';\r\n\r\n/**\r\n * Basis Komponente für SacTreeView\r\n */\r\n@Directive()\r\nexport class SacTreeViewCommon implements OnInit {\r\n  /**\r\n   * Das Property enthielt boolean Wert und deffiniert, ob alle Items collapsed sind. Default value: undefined/null\r\n   */\r\n  public _collapseAll: boolean;\r\n\r\n  /**\r\n   * Das Property enthielt boolean Wert und deffiniert, ob alle Items selected sind. Default value: undefined/null\r\n   */\r\n  private _selectAll: boolean;\r\n\r\n  /**\r\n   * Das Property enthielt array of nodes. Default value: empty array [].\r\n   */\r\n  public nodes: any[] = [];\r\n\r\n  /**\r\n   * Das Property enthielt node attribute: 'isCollapsed'. Es wird benutzt beim rendering. Für Expand/Collapsed Sicht des Node(Wert)\r\n   */\r\n  public collapseAttr = 'isCollapsed';\r\n\r\n  /**\r\n   * Das Property enthielt node attribute: 'isSelected'. Es wird benutzt beim Vorbereitung des Data des TreeView\r\n   */\r\n  public selectAttr = 'isSelected';\r\n\r\n  /**\r\n   * Das Property enthielt node attribute: 'isIndeterminate'. Es wird benutzt beim Vorbereitung des Data des TreeView\r\n   */\r\n  public inDeterminateAttr = 'isIndeterminate';\r\n\r\n  /**\r\n   * Providen data for tree.\r\n   */\r\n  private _data: any[] = [];\r\n\r\n  /**\r\n   * Getter für Data des TreeView\r\n   */\r\n  get data(): any[] {\r\n    return this._data;\r\n  }\r\n\r\n  /**\r\n   * Input Property für Data des TreeView\r\n   */\r\n  @Input()\r\n  set data(value: any[]) {\r\n    this._data = value;\r\n    this.nodes = value;\r\n\r\n    // this.nodes.forEach(node => node[\"typeId\"] = \"13\")\r\n\r\n    this.LoadTree();\r\n\r\n    if (this._collapseAll !== undefined) {\r\n      this.collapseAllNode(this._collapseAll);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Input Property für template des TreeView. Type: TemplateRef<any>.\r\n   */\r\n  @Input()\r\n  template: TemplateRef<any>;\r\n\r\n  /**\r\n   * Die Directive erhält die actions für das TreeView\r\n   */\r\n  @ContentChild('actions', { static: true })\r\n  public set treeviewTemplate(v: TemplateRef<any>) {\r\n    this.template = v;\r\n  }\r\n\r\n  /**\r\n   * Getter für das TreeView Template\r\n   */\r\n  public get treeviewTemplate(): TemplateRef<any> {\r\n    return this.template;\r\n  }\r\n\r\n  /**\r\n   * Input property erhält Icon für das Template\r\n   */\r\n  @Input()\r\n  fileicontemplate: TemplateRef<any>;\r\n\r\n  /**\r\n   * Setter property. Deffiniert das FileIcon für das TreeView\r\n   */\r\n  @ContentChild('treefileicon', { static: true })\r\n  public set treefileicon(v: TemplateRef<any>) {\r\n    this.fileicontemplate = v;\r\n  }\r\n\r\n  /**\r\n   * Getter property. Ergibt das FileIcon für das TreeView\r\n   */\r\n  public get treefileicon(): TemplateRef<any> {\r\n    return this.fileicontemplate;\r\n  }\r\n\r\n  /**\r\n   * Input property für den Namen des TreeView. Type string. Default value: \"\"\r\n   */\r\n  @Input()\r\n  name: string = '';\r\n\r\n  /**\r\n   * A flag indicating data is flatten in array and prepare is required.(Default\r\n   * is false).\r\n   */\r\n  @Input() prepareData = false;\r\n\r\n  /**\r\n   * Attribute for Text in Tree\r\n   */\r\n  @Input() textAttr = 'data';\r\n\r\n  /**\r\n   * Name of ID property in input data.\r\n   */\r\n  @Input() idAttr = 'id';\r\n\r\n  /**\r\n   * Name of parent property in input data.\r\n   */\r\n  @Input() parentAttr = 'PARENT_ID';\r\n\r\n  /**\r\n   * Name of children list property in input data.\r\n   */\r\n  @Input() childrenAttr = 'children';\r\n\r\n  /**\r\n   * Title des Treeview\r\n   */\r\n  @Input() title;\r\n\r\n  // @Input(\"titleAction\") _titleAction: string\r\n\r\n  /**\r\n   * Collapse or expand all parent nodes.\r\n   */\r\n  @Input()\r\n  set collapseall(value: boolean) {\r\n    this._collapseAll = value;\r\n    if (this.nodes && this.nodes.length && this.nodes.length > 0) {\r\n      this.collapseAllNode(this._collapseAll);\r\n    }\r\n\r\n    // this._recursiveEdit(\r\n    //   this.nodes, this.childrenAttr, this.collapseAttr, this._collapseAll);\r\n\r\n    // this.cd.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * Getter für das collapse property. Ergibt boolean Wert, ob die Items collapsed/expand sind.\r\n   */\r\n  get collapseall(): boolean {\r\n    return this._collapseAll;\r\n  }\r\n\r\n  /**\r\n   * Select or deselect all nodes.\r\n   */\r\n  @Input()\r\n  set selectall(value: boolean) {\r\n    this._selectAll = value;\r\n    this._recursiveEdit(this.nodes, this.childrenAttr, this.selectAttr, value);\r\n    this._recursiveEdit(\r\n      this.nodes,\r\n      this.childrenAttr,\r\n      this.inDeterminateAttr,\r\n      false\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Input property - setter. Deffiniert das ID des selektierten Item(node)\r\n   */\r\n  @Input()\r\n  set selectedid(v: any) {\r\n    this.selectedNode = this.findNode(this.nodes, v, this.idAttr);\r\n\r\n    // if (this.selectedNode) {\r\n    //   this.selectedIdEmitter.emit(this.selectedNode[this.idAttr]);\r\n    //   this.selectedTextEmitter.emit(this.selectedNode[this.textAttr]);\r\n    // }\r\n  }\r\n\r\n  /**\r\n   * Getter. Ergibt das ID des selektierten Item(node)\r\n   */\r\n  get selectedId(): any {\r\n    return this.selectedNode ? this.selectedNode[this.idAttr] : null;\r\n  }\r\n\r\n  /**\r\n   * Das Property erhält das selektierte Wert(node). Default value: undefined/null\r\n   */\r\n  private _selectedNode;\r\n\r\n  /**\r\n   * Setter für das selektierte Wert(node). Wenn aufgerufen das ID und TextAttr des selected Node wird emitted\r\n   */\r\n  set selectedNode(v: any) {\r\n    this._selectedNode = v;\r\n\r\n    if (this._selectedNode) {\r\n      this.selectedidchange.emit(this.selectedId);\r\n      this.selectedtextchanged.emit(v[this.textAttr]);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Getter für das selektierte Wert(node). Ergibt das selektierte Wert(node).\r\n   */\r\n  get selectedNode(): any {\r\n    return this._selectedNode;\r\n  }\r\n\r\n  /**\r\n   * Output Emitter. Emit das ID des selected Node.\r\n   */\r\n  @Output()\r\n  selectedidchange: EventEmitter<any> = new EventEmitter<any>();\r\n\r\n  /**\r\n   * Output Emitter. Emit das TextAttr des selected Node.\r\n   */\r\n  @Output()\r\n  selectedtextchanged: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  /**\r\n   * Output Emitter. Emit wenn ein Node selektiert wird.\r\n   */\r\n  @Output()\r\n  selecteditem: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  /**\r\n   * A lifecycle hook that is called after Angular has initialized all data-bound properties of a directive.\r\n   * Define an ngOnInit() method to handle any additional initialization tasks.\r\n   */\r\n  ngOnInit() {\r\n    this.collapseAllNode(this._collapseAll);\r\n\r\n    if (this.selectedId) this.openSelectedNode(this.nodes);\r\n  }\r\n\r\n  /**\r\n   * Funktion setzt alle parent items recusiv zum selected node\r\n   * auf collapsed = false\r\n   */\r\n  private openSelectedNode(data): boolean {\r\n    let result: boolean = false;\r\n    for (let i = 0; i < data.length; i++) {\r\n      if (\r\n        data[i][this.childrenAttr].length &&\r\n        data[i][this.idAttr] != this.selectedId\r\n      )\r\n        result = this.openSelectedNode(data[i][this.childrenAttr]);\r\n      if (result || data[i][this.idAttr] == this.selectedId) {\r\n        data[i][this.collapseAttr] = false;\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Die Methode vorbereitet die Daten für das TreeView. Die Funktion sollte geändert werden abhängig von dem kommenden Daten (wenn array)\r\n   */\r\n  private LoadTree() {\r\n    //if the tree structure require array the function below should be changed\r\n    const cloned = this._data.map((x) => Object.assign({}, x));\r\n\r\n    // If data is flat, prepare data with recursive function.\r\n    this.nodes = this.prepareData ? this._getPreparedData(cloned) : this._data;\r\n  }\r\n\r\n  /**\r\n   * Die Methode collapse/expand den selectierten Node\r\n   */\r\n  onCollapseClick(node) {\r\n    if (node[this.childrenAttr].length) {\r\n      node[this.collapseAttr] = !node[this.collapseAttr];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Die Methode set den selektierten Node und emit es.\r\n   */\r\n  onClick(node) {\r\n    this.selectedNode = node;\r\n    this.selecteditem.emit(this.selectedNode);\r\n    // this.cd.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * Die Methode wird ein event mit Meldung zu Parent emit-en.\r\n   */\r\n  sendMsgToParent(msg) {\r\n    this.selecteditem.emit(msg);\r\n  }\r\n\r\n  /**\r\n   * Die Methode wird alle Nodes collapse\r\n   */\r\n  collapseAllNode(command) {\r\n    this.nodes.forEach((node) => {\r\n      if (node[this.childrenAttr].length) {\r\n        collapseAllHIdden(node, this.collapseAttr, command, this.childrenAttr);\r\n      }\r\n    });\r\n    function collapseAllHIdden(node, collapseAttr, command, childrenAttr) {\r\n      node[collapseAttr] = command;\r\n      node.children.forEach((child: any) => {\r\n        if (child[childrenAttr].length) {\r\n          collapseAllHIdden(child, collapseAttr, command, childrenAttr);\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Funktion gibt node aus der liste zurück, welches das Value auf dem gewünschten Attribut hat\r\n   * Wenn node nicht gefunden wird, wird null zurück gegeben\r\n   * @param data Liste der nodes\r\n   * @param searchValue Das gesuchte value\r\n   * @param attr Der namen des Attributs auf dem das value gesucht wird\r\n   */\r\n  private findNode(data, searchValue, attr): any {\r\n    let result: any = null;\r\n    for (let i = 0; i < data.length; i++) {\r\n      if (data[i][attr] == searchValue) result = data[i];\r\n      else {\r\n        if (data[i][this.childrenAttr].length) {\r\n          let recursiveResult = this.findNode(\r\n            data[i][this.childrenAttr],\r\n            searchValue,\r\n            attr\r\n          );\r\n          if (recursiveResult) result = recursiveResult;\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Die Methode editiert (recursive) alle eingegebene Nodes abhängig von gegebenen Attibute und Value Kriterien.\r\n   */\r\n  private _recursiveEdit(list, childrenAttr, attr, value) {\r\n    if (Array.isArray(list)) {\r\n      for (let i = 0, len = list.length; i < len; i++) {\r\n        list[i][attr] = value;\r\n        if (list[i][childrenAttr].length) {\r\n          this._recursiveEdit(list[i][childrenAttr], childrenAttr, attr, value);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Die Methode erstellt eine standarte Sicht-Liste von Nodes\r\n   */\r\n  private _getPreparedData(list) {\r\n    const tree = [],\r\n      lookup = {};\r\n    for (let i = 0, len = list.length; i < len; i++) {\r\n      lookup[list[i][this.idAttr]] = list[i];\r\n      list[i][this.childrenAttr] = [];\r\n      list[i][this.collapseAttr] = true;\r\n      list[i][this.selectAttr] = false;\r\n      list[i][this.inDeterminateAttr] = false;\r\n    }\r\n    for (let i = 0, len = list.length; i < len; i++) {\r\n      if (list[i][this.parentAttr]) {\r\n        lookup[list[i][this.parentAttr]][this.childrenAttr].push(list[i]);\r\n      } else {\r\n        tree.push(list[i]);\r\n      }\r\n    }\r\n\r\n    return tree;\r\n  }\r\n}\r\n"]}

package/esm2022/controls/treeview/treeviewchild.mjs

@@ -0,0 +1,22 @@
+import { Directive } from '@angular/core';
+import { SacTreeViewCommon } from './treeview';
+import * as i0 from "@angular/core";
+/**
+ * Komponente für SacTreeViewChildCommon. Extends SacTreeViewCommon
+ */
+class SacTreeViewChildCommon extends SacTreeViewCommon {
+    /**
+     * A lifecycle hook that is called after Angular has initialized all data-bound properties of a directive.
+     * Define an ngOnInit() method to handle any additional initialization tasks.
+     */
+    ngOnInit() {
+        this.collapseAllNode(this.collapseall);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacTreeViewChildCommon, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacTreeViewChildCommon, usesInheritance: true, ngImport: i0 }); }
+}
+export { SacTreeViewChildCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacTreeViewChildCommon, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZXZpZXdjaGlsZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NhYy1jb21tb24vc3JjL2NvbnRyb2xzL3RyZWV2aWV3L3RyZWV2aWV3Y2hpbGQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxZQUFZLENBQUM7O0FBRS9DOztHQUVHO0FBQ0gsTUFDYSxzQkFBdUIsU0FBUSxpQkFBaUI7SUFDM0Q7OztPQUdHO0lBQ0gsUUFBUTtRQUNOLElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFBO0lBQ3hDLENBQUM7K0dBUFUsc0JBQXNCO21HQUF0QixzQkFBc0I7O1NBQXRCLHNCQUFzQjs0RkFBdEIsc0JBQXNCO2tCQURsQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgU2FjVHJlZVZpZXdDb21tb24gfSBmcm9tICcuL3RyZWV2aWV3JztcclxuXHJcbi8qKlxyXG4gKiBLb21wb25lbnRlIGbDvHIgU2FjVHJlZVZpZXdDaGlsZENvbW1vbi4gRXh0ZW5kcyBTYWNUcmVlVmlld0NvbW1vbiBcclxuICovXHJcbkBEaXJlY3RpdmUoKVxyXG5leHBvcnQgY2xhc3MgU2FjVHJlZVZpZXdDaGlsZENvbW1vbiBleHRlbmRzIFNhY1RyZWVWaWV3Q29tbW9uIGltcGxlbWVudHMgT25Jbml0IHtcclxuICAvKipcclxuICAgKiBBIGxpZmVjeWNsZSBob29rIHRoYXQgaXMgY2FsbGVkIGFmdGVyIEFuZ3VsYXIgaGFzIGluaXRpYWxpemVkIGFsbCBkYXRhLWJvdW5kIHByb3BlcnRpZXMgb2YgYSBkaXJlY3RpdmUuIFxyXG4gICAqIERlZmluZSBhbiBuZ09uSW5pdCgpIG1ldGhvZCB0byBoYW5kbGUgYW55IGFkZGl0aW9uYWwgaW5pdGlhbGl6YXRpb24gdGFza3MuXHJcbiAgICovXHJcbiAgbmdPbkluaXQoKXsgICAgXHJcbiAgICB0aGlzLmNvbGxhcHNlQWxsTm9kZSh0aGlzLmNvbGxhcHNlYWxsKVxyXG4gIH1cclxufVxyXG5cclxuXHJcbiJdfQ==

package/esm2022/controls/upload/dropzonemultiple.mjs

@@ -0,0 +1,166 @@
+import { Directive, Input } from '@angular/core';
+import { SacUploadBase } from '../../common/baseuploadcontrol';
+import { Validation } from '../../validation';
+import * as i0 from "@angular/core";
+/**
+ * Upload Komponente für ein einzelnes File
+ */
+class SacDropzoneMultipleCommon extends SacUploadBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * Property wenn Drag Event aktiv ist (Maus über Zone)
+         */
+        this.active = false;
+        /**
+         * Höhe des Upload Controls
+         */
+        this.uploadheight = null;
+        /**
+         * Max. Anzahl Files die hochgeladen werden können
+         */
+        this.maxfiles = 0;
+        /**
+         * Min. Anzahl Files die hochgeladen werden müssen
+         */
+        this.minfiles = 0;
+        /**
+         * Resource Key für Validation Message Required bei Control
+         */
+        this.validationmessageminfiles = 'VALIDATION_ERROR_FILESMIN';
+        /**
+         * Resource Key für Validation Message Required in Validation Summary
+         */
+        this.validationmessagesummaryminfiles = 'VALIDATION_ERROR_SUMMARY_FILESMIN';
+    }
+    /**
+     * Ervent wenn das Control initialisert wird
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        this.autoupload = true;
+    }
+    /**
+     * Methode für Drag and Drop von Files
+     * @param event Drag Event
+     */
+    dropHandler(event) {
+        if (event.dataTransfer &&
+            event.dataTransfer.files &&
+            event.dataTransfer.files.item(0)) {
+            event.stopPropagation();
+            event.preventDefault();
+            this.active = false;
+            this.uploadService.handleFiles(event.dataTransfer.files);
+        }
+    }
+    /**
+     * Methode wenn Drag in die Zone eintritt
+     * @param event DragEnter Event
+     */
+    onDragOver(event) {
+        if (event.dataTransfer &&
+            event.dataTransfer.files &&
+            event.dataTransfer.types.every((itm) => itm === 'Files') &&
+            event.dataTransfer.types.length > 0) {
+            event.dataTransfer.dropEffect = 'copy';
+            event.stopPropagation();
+            event.preventDefault();
+            this.active = true;
+        }
+    }
+    /**
+     * Methode wenn Drag die Zone verlässt
+     * @param event DragLeave Event
+     */
+    onDragLeave(event) {
+        this.active = false;
+    }
+    /**
+     * Prüft ob die max. Files in der Queue nicht überschritten werden
+     *
+     * @param file File das hinzugefügt wurde
+     */
+    CustomAddValidation(file) {
+        if (this.maxfiles > 0 && this.uploads.length >= this.maxfiles) {
+            this.onfileerror.emit('INVALID_MAXFILES');
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Setzt die File ID's der hochgeladen Files in das Model
+     *
+     * @param file ID des Files welches hochgeladen wurde.
+     */
+    SetUploadValue(file) {
+        let documentid = null;
+        if (file === null) {
+            documentid = null;
+        }
+        else {
+            if (file.response !== undefined &&
+                file.response !== null &&
+                file.response.documentid !== null &&
+                file.response.documentid !== undefined) {
+                documentid = file.response.documentid;
+            }
+            else {
+                documentid = file.uploadId;
+            }
+            // Document ID aktualisieren, damit Wert von Server in Model gesetzt werden kann.
+            this.uploads
+                .filter((itm) => itm !== null && itm.uploadId === file.uploadId)
+                .forEach((itm) => {
+                itm.documentid = documentid;
+            });
+        }
+        // List of Files
+        const fileIds = [];
+        // Add all Items with Uploaded State to Model
+        this.uploads
+            .filter((itm) => itm.status === 'complete')
+            .forEach((itm) => {
+            if (itm.documentid !== null && itm.documentid !== undefined) {
+                fileIds.push(itm.documentid);
+            }
+        });
+        if (fileIds.length > 0) {
+            super.setValue(fileIds);
+        }
+        else {
+            super.setValue(null);
+        }
+    }
+    /**
+     * Validiert das Control
+     *
+     * @param c Control
+     */
+    validateData(c) {
+        let error = super.validateData(c);
+        if (error === null) {
+            error = Validation.minFiles(this.minfiles, this.validationmessageminfiles, this.validationmessagesummaryminfiles)(c);
+        }
+        return error;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDropzoneMultipleCommon, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SacDropzoneMultipleCommon, inputs: { uploadheight: "uploadheight", maxfiles: "maxfiles", minfiles: "minfiles", validationmessageminfiles: "validationmessageminfiles", validationmessagesummaryminfiles: "validationmessagesummaryminfiles" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { SacDropzoneMultipleCommon };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SacDropzoneMultipleCommon, decorators: [{
+            type: Directive
+        }], propDecorators: { uploadheight: [{
+                type: Input
+            }], maxfiles: [{
+                type: Input
+            }], minfiles: [{
+                type: Input
+            }], validationmessageminfiles: [{
+                type: Input
+            }], validationmessagesummaryminfiles: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropzonemultiple.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/upload/dropzonemultiple.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, OnInit } from '@angular/core';\r\nimport { AbstractControl, ValidationErrors } from '@angular/forms';\r\nimport { UploadState } from 'ngx-uploadx';\r\nimport { SacUploadBase } from '../../common/baseuploadcontrol';\r\nimport { IUploadControl } from '../../interfaces/iuploadcontrol';\r\nimport { Validation } from '../../validation';\r\n\r\n/**\r\n * Upload Komponente für ein einzelnes File\r\n */\r\n@Directive()\r\nexport class SacDropzoneMultipleCommon\r\n  extends SacUploadBase<string[]>\r\n  implements OnInit\r\n{\r\n  /**\r\n   * Property wenn Drag Event aktiv ist (Maus über Zone)\r\n   */\r\n  public active = false;\r\n\r\n  /**\r\n   * Höhe des Upload Controls\r\n   */\r\n  @Input()\r\n  public uploadheight: string = null;\r\n\r\n  /**\r\n   * Max. Anzahl Files die hochgeladen werden können\r\n   */\r\n  @Input()\r\n  public maxfiles: number = 0;\r\n\r\n  /**\r\n   * Min. Anzahl Files die hochgeladen werden müssen\r\n   */\r\n  @Input()\r\n  public minfiles: number = 0;\r\n\r\n  /**\r\n   * Resource Key für Validation Message Required bei Control\r\n   */\r\n  @Input() validationmessageminfiles: string = 'VALIDATION_ERROR_FILESMIN';\r\n  /**\r\n   * Resource Key für Validation Message Required in Validation Summary\r\n   */\r\n  @Input()\r\n  validationmessagesummaryminfiles: string =\r\n    'VALIDATION_ERROR_SUMMARY_FILESMIN';\r\n\r\n  /**\r\n   * Ervent wenn das Control initialisert wird\r\n   */\r\n  ngOnInit() {\r\n    super.ngOnInit();\r\n\r\n    this.autoupload = true;\r\n  }\r\n\r\n  /**\r\n   * Methode für Drag and Drop von Files\r\n   * @param event Drag Event\r\n   */\r\n  dropHandler(event: DragEvent): void {\r\n    if (\r\n      event.dataTransfer &&\r\n      event.dataTransfer.files &&\r\n      event.dataTransfer.files.item(0)\r\n    ) {\r\n      event.stopPropagation();\r\n      event.preventDefault();\r\n      this.active = false;\r\n      this.uploadService.handleFiles(event.dataTransfer.files);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Methode wenn Drag in die Zone eintritt\r\n   * @param event DragEnter Event\r\n   */\r\n  onDragOver(event: DragEvent): void {\r\n    if (\r\n      event.dataTransfer &&\r\n      event.dataTransfer.files &&\r\n      event.dataTransfer.types.every((itm) => itm === 'Files') &&\r\n      event.dataTransfer.types.length > 0\r\n    ) {\r\n      event.dataTransfer.dropEffect = 'copy';\r\n      event.stopPropagation();\r\n      event.preventDefault();\r\n      this.active = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Methode wenn Drag die Zone verlässt\r\n   * @param event DragLeave Event\r\n   */\r\n  onDragLeave(event: DragEvent): void {\r\n    this.active = false;\r\n  }\r\n\r\n  /**\r\n   * Prüft ob die max. Files in der Queue nicht überschritten werden\r\n   *\r\n   * @param file File das hinzugefügt wurde\r\n   */\r\n  CustomAddValidation(file: UploadState): boolean {\r\n    if (this.maxfiles > 0 && this.uploads.length >= this.maxfiles) {\r\n      this.onfileerror.emit('INVALID_MAXFILES');\r\n      return false;\r\n    } else {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setzt die File ID's der hochgeladen Files in das Model\r\n   *\r\n   * @param file ID des Files welches hochgeladen wurde.\r\n   */\r\n  SetUploadValue(file: UploadState) {\r\n    let documentid: string = null;\r\n    if (file === null) {\r\n      documentid = null;\r\n    } else {\r\n      if (\r\n        file.response !== undefined &&\r\n        file.response !== null &&\r\n        file.response.documentid !== null &&\r\n        file.response.documentid !== undefined\r\n      ) {\r\n        documentid = file.response.documentid;\r\n      } else {\r\n        documentid = file.uploadId;\r\n      }\r\n\r\n      // Document ID aktualisieren, damit Wert von Server in Model gesetzt werden kann.\r\n      this.uploads\r\n        .filter((itm) => itm !== null && itm.uploadId === file.uploadId)\r\n        .forEach((itm) => {\r\n          itm.documentid = documentid;\r\n        });\r\n    }\r\n\r\n    // List of Files\r\n    const fileIds: string[] = [];\r\n\r\n    // Add all Items with Uploaded State to Model\r\n    this.uploads\r\n      .filter((itm) => itm.status === 'complete')\r\n      .forEach((itm) => {\r\n        if (itm.documentid !== null && itm.documentid !== undefined) {\r\n          fileIds.push(itm.documentid);\r\n        }\r\n      });\r\n\r\n    if (fileIds.length > 0) {\r\n      super.setValue(fileIds);\r\n    } else {\r\n      super.setValue(null);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validiert das Control\r\n   *\r\n   * @param c Control\r\n   */\r\n  validateData(c: AbstractControl): ValidationErrors | null {\r\n    let error: ValidationErrors | null = super.validateData(c);\r\n\r\n    if (error === null) {\r\n      error = Validation.minFiles(\r\n        this.minfiles,\r\n        this.validationmessageminfiles,\r\n        this.validationmessagesummaryminfiles\r\n      )(c);\r\n    }\r\n\r\n    return error;\r\n  }\r\n}\r\n"]}