@simpleangularcontrols/sac-common 13.0.0-rc.2

package/esm2020/components/browser/browser.mjs

@@ -0,0 +1,553 @@
+import { Directive, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+import { SACICON_SERVICE, SACLOCALISATION_SERVICE, SacDefaultIconService, } from '../../services';
+import { SACFILEBROWSER_SERVICE, SacDefaultFileBrowserService, } from '../../services/sac-filebrowser.service';
+import { SacDefaultLocalisationService } from '../../services/sac-localisation.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+/**
+ * Base Component für File Browser
+ */
+export class SacFileBrowserCommon {
+    // #endregion Properties
+    // #region Constructors
+    /**
+     * Konstruktor
+     * @param httpclient Angular HTTP Client
+     * @param injector Service Injector
+     */
+    constructor(httpclient, injector) {
+        /**
+         * File welches beim starten des Browsers bereits selektiert ist
+         */
+        this.preselecedfile = null;
+        /**
+         * Erlaubte Dateierweiterungen für Fileauswahl und Upload. Dateierweiterung mit Punkt und
+         * getrennt durch Komma für mehr als eine Erweiterung (Example: ".jpg,.gif")
+         */
+        this.allowedtypes = '';
+        /**
+         * Erlaubt das löschen einer Datei
+         */
+        this.allowfiledelete = true;
+        /**
+         * Erlaubt das umbenennen einer Datei
+         */
+        this.allowfilerename = true;
+        /**
+         * Erlaubt den Upload von Dateien
+         */
+        this.allowfileupload = true;
+        /**
+         * Erlaubt das erstellen eines neuen Ordners
+         */
+        this.allowfoldercreate = true;
+        /**
+         * Erlaubt das löschen eines Ordners
+         */
+        this.allowfolderdelete = true;
+        /**
+         * Erlaubt das Umbenennen eines Ordners
+         */
+        this.allowfolderrename = true;
+        /**
+         * Output Emitter wenn File selektiert wird.
+         */
+        this.file = new EventEmitter();
+        /**
+         * Root Node Item für Tree
+         */
+        this.rootNode = {
+            Name: '',
+            ChildNodes: [],
+            Files: [],
+            IsExpanded: true,
+            IsEditMode: false,
+            IsNewNode: false,
+            Path: '',
+        };
+        /**
+         * Selected File Item
+         */
+        this.selectedFileItem = null;
+        /**
+         * Selected Node Item
+         */
+        this.selectedNode = null;
+        /**
+         * Liste von Uploads
+         */
+        this.uploads = [];
+        this.browserService = injector.get(SACFILEBROWSER_SERVICE, new SacDefaultFileBrowserService(httpclient));
+        this.lngResourceService = injector.get(SACLOCALISATION_SERVICE, new SacDefaultLocalisationService());
+        this.iconService = injector.get(SACICON_SERVICE, new SacDefaultIconService());
+    }
+    // #endregion Constructors
+    // #region Public Getters And Setters
+    /**
+     * CSS icon class for delete icon
+     * @returns css class with icon
+     */
+    get iconDelete() {
+        return this.iconService.BrowserComponentDeleteIcon;
+    }
+    /**
+     * CSS icon class for edit icon
+     * @returns css class with icon
+     */
+    get iconEdit() {
+        return this.iconService.BrowserComponentEditIcon;
+    }
+    /**
+     * CSS icon for folders in tree there are collabsed
+     * @returns css class with icon
+     */
+    get iconFolderCollabsed() {
+        return this.iconService.BrowserComponentFolderClosedIcon;
+    }
+    /**
+     * CSS icon class for folders without subfolders
+     * @returns css class with icon
+     */
+    get iconFolderEmpty() {
+        return this.iconService.BrowserComponentFolderEmptyIcon;
+    }
+    /**
+     * CSS icon for new folders action
+     * @returns css class with icon
+     */
+    get iconFolderNew() {
+        return this.iconService.BrowserComponentFolderNewIcon;
+    }
+    /**
+     * CSS icon for folders in tree there are expanded
+     * @returns css class with icon
+     */
+    get iconFolderOpen() {
+        return this.iconService.BrowserComponentFolderOpenIcon;
+    }
+    /**
+     * CSS icon class for refresh icon
+     * @returns css class with icon
+     */
+    get iconRefresh() {
+        return this.iconService.BrowserComponentRefreshIcon;
+    }
+    /**
+     * Getter für Selected File. Ist an Input Property gebunden
+     */
+    get selectedfile() {
+        if (this.selectFile && this.selectFile.length > 0) {
+            return this.selectedFile;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Setzt den Seleced Node über den Pfad
+     */
+    set selectedfile(v) {
+        const selectednode = this.findSelectedNodeByPath(this.rootNode, v);
+        if (selectednode !== null) {
+            this.selectNode(selectednode);
+        }
+        this.preselecedfile = v;
+    }
+    // #endregion Public Getters And Setters
+    // #region Public Methods
+    /**
+     * Löscht ein File
+     * @param file File welches gelöscht werden soll
+     */
+    deleteFile(file) {
+        this.confirmDeleteFile(file).subscribe((confirm) => {
+            if (confirm) {
+                this.browserService
+                    .DeleteFile(this.apiurl, this.selectedNode.Path + '/' + file.Filename, this.allowedtypes)
+                    .subscribe((result) => {
+                    this.selectedNode.Files = result.Files;
+                });
+            }
+        });
+    }
+    /**
+     * Löscht einen Node
+     * @param node Node welcher gelöscht werden soll
+     */
+    deleteNode(node) {
+        this.confirmDeleteNode(node).subscribe((confirm) => {
+            if (confirm) {
+                this.browserService
+                    .DeleteNode(this.apiurl, node.Path)
+                    .subscribe((result) => {
+                    const parentNode = this.findParentNode(this.rootNode, node);
+                    parentNode.ChildNodes = result.Node.ChildNodes;
+                    this.rootNode.ChildNodes.forEach((itm) => {
+                        this.fillPath(itm, '');
+                    });
+                    this.selectNode(parentNode);
+                });
+            }
+        });
+    }
+    /**
+     * Setzt ein File in den Edit Mode
+     * @param file File welches in den Edit Mode gesetzt werden soll
+     */
+    editFile(file) {
+        file.IsEditMode = true;
+    }
+    /**
+     * Setzt einen Node in den Edit Mode
+     * @param node Node welcher bearbeitet werden soll
+     */
+    editNode(node) {
+        node.IsEditMode = true;
+    }
+    /**
+     * HostListener welcher den Edit Mode bei allen Files und Nodes beendet.
+     */
+    exitEditMode(targetElement) {
+        if (this.selectedNode) {
+            this.selectedNode.Files.forEach((itm) => (itm.IsEditMode = false));
+            if (!this.selectedNode ||
+                this.selectedNode.Name === null ||
+                this.selectedNode.Name.length === 0) {
+                this.clearNewChildNodes(this.rootNode);
+            }
+        }
+        this.resetNodeEditMode(null);
+    }
+    /**
+     * Erzeugt einen neuen Node im Tree
+     * @param node Node unter welchem ein neuer Node erstellt werden soll
+     */
+    newNode(node) {
+        const item = {
+            ChildNodes: [],
+            Files: [],
+            IsEditMode: false,
+            IsExpanded: false,
+            Name: '',
+            Path: node.Path,
+            IsNewNode: true,
+        };
+        node.ChildNodes.push(item);
+        this.selectNode(item);
+        this.editNode(item);
+    }
+    /**
+     * Init Event der Komponente
+     */
+    ngOnInit() {
+        this.browserService
+            .GetNode(this.apiurl, '', this.allowedtypes)
+            .subscribe((result) => {
+            this.rootNode = {
+                Name: result.Node.Name,
+                Files: result.Node.Files,
+                ChildNodes: result.Node.ChildNodes,
+                IsExpanded: true,
+                IsEditMode: false,
+                IsNewNode: false,
+                Path: '/',
+            };
+            this.setPathToAllNodes();
+            this.selectedNode = this.rootNode;
+            // Selected File erneut setzen, wenn Property gesetzt wurde bevor Daten vom Service geladen wurden.
+            if (this.preselecedfile !== null && this.preselecedfile.length > 0) {
+                this.selectedfile = this.preselecedfile;
+            }
+        });
+    }
+    /**
+     * Aktualisiert den Node
+     */
+    refreshNode(node) {
+        if (!node.IsExpanded) {
+            this.switchExpandNode(node);
+        }
+        this.browserService
+            .GetNode(this.apiurl, node.Path, this.allowedtypes)
+            .subscribe((result) => {
+            node.ChildNodes = result.Node.ChildNodes;
+            node.Files = result.Node.Files;
+            this.setPathToAllNodes();
+        });
+    }
+    /**
+     * Methode wenn eine Datei umbenannt werden soll
+     * @param file File welches umbenannt werden soll
+     * @param newFilename Neuer Dateiname
+     */
+    renameFile(file, newFilename) {
+        file.IsEditMode = false;
+        if (!newFilename || newFilename === null || newFilename.length === 0) {
+            // Cancel, Invalid Filename
+            return;
+        }
+        if (file.Filename !== newFilename) {
+            this.browserService
+                .RenameFile(this.apiurl, this.selectedNode.Path + '/' + file.Filename, newFilename, this.allowedtypes)
+                .subscribe((result) => {
+                this.selectedNode.Files = result.Files;
+            });
+        }
+    }
+    /**
+     * Methode wenn ein Node umbenannt werden soll
+     * @param node Node welcher umbenannt werden soll
+     * @param newFoldername Neuer Ordnername
+     */
+    renameNode(node, newFoldername) {
+        node.IsEditMode = false;
+        if (!node.IsNewNode) {
+            if (!newFoldername ||
+                newFoldername === null ||
+                newFoldername.length === 0) {
+                // Cancel Rename. Invalid Foldername
+                return;
+            }
+            if (node.Name !== newFoldername) {
+                this.browserService
+                    .RenameNode(this.apiurl, node.Path, newFoldername)
+                    .subscribe((result) => {
+                    node.Name = result.Node.Name;
+                    this.setPathToAllNodes();
+                });
+            }
+        }
+        else {
+            if (!newFoldername ||
+                newFoldername === null ||
+                newFoldername.length === 0) {
+                this.clearNewChildNodes(this.rootNode);
+                return;
+            }
+            node.Name = newFoldername;
+            node.IsNewNode = false;
+            this.browserService
+                .SaveNode(this.apiurl, node.Path, newFoldername)
+                .subscribe((result) => {
+                node.Name = result.Node.Name;
+                node.Files = result.Node.Files;
+                this.setPathToAllNodes();
+            });
+        }
+    }
+    /**
+     * Methode wenn ein File selektiert wird
+     * @param file File welches selektiert wird
+     */
+    selectFile(file) {
+        if (!file.IsEditMode) {
+            this.selectedNode.Files.forEach((itm) => (itm.IsEditMode = false));
+        }
+        if (!this.selectedNode.Path.endsWith('/')) {
+            this.selectedFile = this.selectedNode.Path + '/' + file.Filename;
+        }
+        else {
+            this.selectedFile = '/' + file.Filename;
+        }
+        this.selectedFileItem = file;
+        this.file.emit(this.selectedFile);
+    }
+    /**
+     * Methode wenn ein Node selektiert wird
+     * @param node Node welcher selektiert werden soll
+     */
+    selectNode(node) {
+        if (!node.IsExpanded) {
+            this.switchExpandNode(node);
+        }
+        // Reset the Edit Mode in all Nodes
+        this.resetNodeEditMode(null);
+        if (!node.Files) {
+            this.browserService
+                .GetFiles(this.apiurl, node.Path, this.allowedtypes)
+                .subscribe((result) => {
+                node.Files = result.Files;
+                this.selectedNode = node;
+                if (this.preselecedfile !== null && this.preselecedfile.length > 0) {
+                    const filename = this.preselecedfile.substring(this.preselecedfile.lastIndexOf('/') + 1);
+                    const file = node.Files.find((itm) => itm.Filename === filename);
+                    if (file) {
+                        this.selectFile(file);
+                    }
+                }
+            });
+        }
+        else {
+            this.selectedNode = node;
+        }
+    }
+    /**
+     * Expand/Collabse Methode für Nodes
+     * @param node Node welcher geöffnet oder geschlossen werden soll
+     */
+    switchExpandNode(node) {
+        if (node.IsExpanded) {
+            node.IsExpanded = false;
+        }
+        else {
+            node.IsExpanded = true;
+        }
+    }
+    /**
+     * Methode die Aufgerufen werden muss, wenn ein Upload beendet ist.
+     * @param param Parameter des hochgeladenen Files
+     */
+    uploadComplete(node, uploadIdList) {
+        if (uploadIdList !== null) {
+            uploadIdList.forEach((element) => {
+                if (this.uploads.indexOf(element) < 0) {
+                    this.uploads.push(element);
+                }
+            });
+        }
+        const id = this.uploads.pop();
+        if (id) {
+            this.browserService
+                .SaveFile(this.apiurl, node.Path, id, this.allowedtypes)
+                .subscribe((result) => {
+                this.selectedNode.Files = result.Files;
+                this.uploadedFileMoved(id);
+            });
+        }
+    }
+    // #endregion Public Abstract Methods
+    // #region Private Methods
+    /**
+     * Rekursive Methode welche beim Node und all seinen Childs neue Nodes entfernt
+     * @param node Node bei welchem alle neuen Nodes entfernt werden soll.
+     */
+    clearNewChildNodes(node) {
+        node.ChildNodes.forEach((itm) => {
+            if (itm.IsNewNode) {
+                node.ChildNodes.splice(node.ChildNodes.indexOf(itm));
+            }
+        });
+        node.ChildNodes.forEach((itm) => this.clearNewChildNodes(itm));
+    }
+    /**
+     * Methode welche den Pfad für einen Node erzeugt
+     * @param node Node für welchen der Pfad erzeugt werden soll
+     * @param parentPath Übergeordneter Pfad
+     */
+    fillPath(node, parentPath) {
+        node.Path = parentPath + '/' + node.Name;
+        node.ChildNodes.forEach((itm) => {
+            this.fillPath(itm, node.Path);
+        });
+    }
+    /**
+     * Sucht den übergeordneten Node im Tree
+     * @param node Aktueller Node
+     * @param nodeToFind Node welcher gefunden werden soll
+     * @returns Node wenn er gefunden wurde, ansonsten wird NULL zurückgegeben
+     */
+    findParentNode(node, nodeToFind) {
+        if (node.ChildNodes.indexOf(nodeToFind) >= 0) {
+            return node;
+        }
+        for (const child of node.ChildNodes) {
+            const result = this.findParentNode(child, nodeToFind);
+            if (result !== null) {
+                return result;
+            }
+        }
+        return null;
+    }
+    /**
+     * Sucht einen Node gem. einem URL Pfad
+     * @param node Node in welchem gesucht werden soll
+     * @param path Pfad nach welchem gesucht wird
+     * @returns Node welcher zum gesuchten Pfad passt. Wenn kein Node gefunden wird, wird NULL zurückgegeben
+     */
+    findSelectedNodeByPath(node, path) {
+        // Cancel wenn Pfad nicht definiert
+        if (path === undefined || path === null) {
+            return null;
+        }
+        // Pfad in Array splitten und Root Foldername setzen
+        const pathArray = path.split('/');
+        pathArray[0] = this.rootNode.Name;
+        return this.findSelectedNodeByPathArray(node, pathArray, 0);
+    }
+    /**
+     * Sucht einen Node gem. einem Array von Node Namen
+     * @param node Node in welchem gesucht werden soll
+     * @param path Array von Node Namen, welche die Hirarchy des Pfades abbilden
+     * @param index Aktueller Index im PATH Array
+     * @returns Node wenn einer gefunden wurde, ansonsten NULL
+     */
+    findSelectedNodeByPathArray(node, path, index) {
+        // Check ob Ordner korrekt. Letzer Ordner zurückgeben. Path Last Index ist der Filename
+        if (node.Name === path[index] && path.length - 2 === index) {
+            return node;
+        }
+        else if (node.Name === path[index]) {
+            // Expand Node
+            node.IsExpanded = true;
+            for (const item of node.ChildNodes) {
+                const result = this.findSelectedNodeByPathArray(item, path, index + 1);
+                if (result !== null) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Rekursive Methode welche beim Node und all seinen Childs den Edit Mode beendet.
+     * @param node Node bei welchem der Edit Mode beendet werden soll
+     */
+    resetNodeEditMode(node) {
+        if (node === null) {
+            this.resetNodeEditMode(this.rootNode);
+        }
+        else {
+            node.IsEditMode = false;
+            if (node.ChildNodes) {
+                node.ChildNodes.forEach((itm) => this.resetNodeEditMode(itm));
+            }
+        }
+    }
+    /**
+     * Setzt den Pfad in allen Nodes
+     */
+    setPathToAllNodes() {
+        this.rootNode.ChildNodes.forEach((itm) => {
+            this.fillPath(itm, '');
+        });
+    }
+}
+SacFileBrowserCommon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacFileBrowserCommon, deps: [{ token: i1.HttpClient }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive });
+SacFileBrowserCommon.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.7", type: SacFileBrowserCommon, inputs: { allowedtypes: "allowedtypes", allowfiledelete: "allowfiledelete", allowfilerename: "allowfilerename", allowfileupload: "allowfileupload", allowfoldercreate: "allowfoldercreate", allowfolderdelete: "allowfolderdelete", allowfolderrename: "allowfolderrename", apiurl: "apiurl", selectedfile: "selectedfile" }, outputs: { file: "file" }, host: { listeners: { "document:click": "exitEditMode($event.target)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacFileBrowserCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.Injector }]; }, propDecorators: { allowedtypes: [{
+                type: Input
+            }], allowfiledelete: [{
+                type: Input
+            }], allowfilerename: [{
+                type: Input
+            }], allowfileupload: [{
+                type: Input
+            }], allowfoldercreate: [{
+                type: Input
+            }], allowfolderdelete: [{
+                type: Input
+            }], allowfolderrename: [{
+                type: Input
+            }], apiurl: [{
+                type: Input
+            }], file: [{
+                type: Output
+            }], selectedfile: [{
+                type: Input
+            }], exitEditMode: [{
+                type: HostListener,
+                args: ['document:click', ['$event.target']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/components/browser/browser.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport {\r\n  Directive,\r\n  EventEmitter,\r\n  HostListener,\r\n  Injector,\r\n  Input,\r\n  OnInit,\r\n  Output,\r\n} from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { ISacFileBrowserService } from '../../interfaces/ISacFileBrowserService';\r\nimport { ISacIconService } from '../../interfaces/ISacIconService';\r\nimport { ISacLocalisationService } from '../../interfaces/ISacLocalisationService';\r\nimport {\r\n  SACICON_SERVICE,\r\n  SACLOCALISATION_SERVICE,\r\n  SacDefaultIconService,\r\n} from '../../services';\r\nimport {\r\n  SACFILEBROWSER_SERVICE,\r\n  SacDefaultFileBrowserService,\r\n} from '../../services/sac-filebrowser.service';\r\nimport { SacDefaultLocalisationService } from '../../services/sac-localisation.service';\r\nimport { IBrowserFile } from './models/browserfile';\r\nimport { IBrowserFileResponse } from './models/browserfileresponse';\r\nimport { IBrowserNode } from './models/browsernode';\r\nimport { IBrowserNodeResponse } from './models/browsernoderesponse';\r\n\r\n/**\r\n * Base Component für File Browser\r\n */\r\n@Directive()\r\nexport abstract class SacFileBrowserCommon implements OnInit {\r\n  // #region Properties\r\n\r\n  /**\r\n   * Service für File Browser Zugriff (Backend)\r\n   */\r\n  private browserService: ISacFileBrowserService;\r\n  /**\r\n   * Icon service to receive icon classes for ui\r\n   */\r\n  private iconService: ISacIconService;\r\n  /**\r\n   * File welches beim starten des Browsers bereits selektiert ist\r\n   */\r\n  private preselecedfile: string | null = null;\r\n\r\n  /**\r\n   * Erlaubte Dateierweiterungen für Fileauswahl und Upload. Dateierweiterung mit Punkt und\r\n   * getrennt durch Komma für mehr als eine Erweiterung (Example: \".jpg,.gif\")\r\n   */\r\n  @Input()\r\n  public allowedtypes: string = '';\r\n  /**\r\n   * Erlaubt das löschen einer Datei\r\n   */\r\n  @Input()\r\n  public allowfiledelete: boolean = true;\r\n  /**\r\n   * Erlaubt das umbenennen einer Datei\r\n   */\r\n  @Input()\r\n  public allowfilerename: boolean = true;\r\n  /**\r\n   * Erlaubt den Upload von Dateien\r\n   */\r\n  @Input()\r\n  public allowfileupload: boolean = true;\r\n  /**\r\n   * Erlaubt das erstellen eines neuen Ordners\r\n   */\r\n  @Input()\r\n  public allowfoldercreate: boolean = true;\r\n  /**\r\n   * Erlaubt das löschen eines Ordners\r\n   */\r\n  @Input()\r\n  public allowfolderdelete: boolean = true;\r\n  /**\r\n   * Erlaubt das Umbenennen eines Ordners\r\n   */\r\n  @Input()\r\n  public allowfolderrename: boolean = true;\r\n  /**\r\n   * URL für Backend API\r\n   */\r\n  @Input()\r\n  public apiurl: string;\r\n  /**\r\n   * Output Emitter wenn File selektiert wird.\r\n   */\r\n  @Output()\r\n  public file: EventEmitter<string> = new EventEmitter<string>();\r\n  /**\r\n   * Service für Error Localisation\r\n   */\r\n  public lngResourceService: ISacLocalisationService;\r\n  /**\r\n   * Root Node Item für Tree\r\n   */\r\n  public rootNode: IBrowserNode = {\r\n    Name: '',\r\n    ChildNodes: [],\r\n    Files: [],\r\n    IsExpanded: true,\r\n    IsEditMode: false,\r\n    IsNewNode: false,\r\n    Path: '',\r\n  };\r\n  /**\r\n   * Selected File Name\r\n   */\r\n  public selectedFile: string;\r\n  /**\r\n   * Selected File Item\r\n   */\r\n  public selectedFileItem: IBrowserFile = null;\r\n  /**\r\n   * Selected Node Item\r\n   */\r\n  public selectedNode: IBrowserNode = null;\r\n  /**\r\n   * Liste von Uploads\r\n   */\r\n  public uploads: string[] = [];\r\n\r\n  // #endregion Properties\r\n\r\n  // #region Constructors\r\n\r\n  /**\r\n   * Konstruktor\r\n   * @param httpclient Angular HTTP Client\r\n   * @param injector Service Injector\r\n   */\r\n  constructor(httpclient: HttpClient, injector: Injector) {\r\n    this.browserService = injector.get(\r\n      SACFILEBROWSER_SERVICE,\r\n      new SacDefaultFileBrowserService(httpclient)\r\n    );\r\n\r\n    this.lngResourceService = injector.get(\r\n      SACLOCALISATION_SERVICE,\r\n      new SacDefaultLocalisationService()\r\n    );\r\n\r\n    this.iconService = injector.get(\r\n      SACICON_SERVICE,\r\n      new SacDefaultIconService()\r\n    );\r\n  }\r\n\r\n  // #endregion Constructors\r\n\r\n  // #region Public Getters And Setters\r\n\r\n  /**\r\n   * CSS icon class for delete icon\r\n   * @returns css class with icon\r\n   */\r\n  public get iconDelete(): string {\r\n    return this.iconService.BrowserComponentDeleteIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon class for edit icon\r\n   * @returns css class with icon\r\n   */\r\n  public get iconEdit(): string {\r\n    return this.iconService.BrowserComponentEditIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon for folders in tree there are collabsed\r\n   * @returns css class with icon\r\n   */\r\n  public get iconFolderCollabsed(): string {\r\n    return this.iconService.BrowserComponentFolderClosedIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon class for folders without subfolders\r\n   * @returns css class with icon\r\n   */\r\n  public get iconFolderEmpty(): string {\r\n    return this.iconService.BrowserComponentFolderEmptyIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon for new folders action\r\n   * @returns css class with icon\r\n   */\r\n  public get iconFolderNew(): string {\r\n    return this.iconService.BrowserComponentFolderNewIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon for folders in tree there are expanded\r\n   * @returns css class with icon\r\n   */\r\n  public get iconFolderOpen(): string {\r\n    return this.iconService.BrowserComponentFolderOpenIcon;\r\n  }\r\n\r\n  /**\r\n   * CSS icon class for refresh icon\r\n   * @returns css class with icon\r\n   */\r\n  public get iconRefresh(): string {\r\n    return this.iconService.BrowserComponentRefreshIcon;\r\n  }\r\n\r\n  /**\r\n   * Getter für Selected File. Ist an Input Property gebunden\r\n   */\r\n  public get selectedfile(): string | null {\r\n    if (this.selectFile && this.selectFile.length > 0) {\r\n      return this.selectedFile;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setzt den Seleced Node über den Pfad\r\n   */\r\n  @Input()\r\n  public set selectedfile(v: string | null) {\r\n    const selectednode = this.findSelectedNodeByPath(this.rootNode, v);\r\n\r\n    if (selectednode !== null) {\r\n      this.selectNode(selectednode);\r\n    }\r\n\r\n    this.preselecedfile = v;\r\n  }\r\n\r\n  // #endregion Public Getters And Setters\r\n\r\n  // #region Public Methods\r\n\r\n  /**\r\n   * Löscht ein File\r\n   * @param file File welches gelöscht werden soll\r\n   */\r\n  public deleteFile(file: IBrowserFile): void {\r\n    this.confirmDeleteFile(file).subscribe((confirm) => {\r\n      if (confirm) {\r\n        this.browserService\r\n          .DeleteFile(\r\n            this.apiurl,\r\n            this.selectedNode.Path + '/' + file.Filename,\r\n            this.allowedtypes\r\n          )\r\n          .subscribe((result: IBrowserFileResponse) => {\r\n            this.selectedNode.Files = result.Files;\r\n          });\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Löscht einen Node\r\n   * @param node Node welcher gelöscht werden soll\r\n   */\r\n  public deleteNode(node: IBrowserNode): void {\r\n    this.confirmDeleteNode(node).subscribe((confirm) => {\r\n      if (confirm) {\r\n        this.browserService\r\n          .DeleteNode(this.apiurl, node.Path)\r\n          .subscribe((result: IBrowserNodeResponse) => {\r\n            const parentNode = this.findParentNode(this.rootNode, node);\r\n            parentNode.ChildNodes = result.Node.ChildNodes;\r\n\r\n            this.rootNode.ChildNodes.forEach((itm) => {\r\n              this.fillPath(itm, '');\r\n            });\r\n\r\n            this.selectNode(parentNode);\r\n          });\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Setzt ein File in den Edit Mode\r\n   * @param file File welches in den Edit Mode gesetzt werden soll\r\n   */\r\n  public editFile(file: IBrowserFile): void {\r\n    file.IsEditMode = true;\r\n  }\r\n\r\n  /**\r\n   * Setzt einen Node in den Edit Mode\r\n   * @param node Node welcher bearbeitet werden soll\r\n   */\r\n  public editNode(node: IBrowserNode): void {\r\n    node.IsEditMode = true;\r\n  }\r\n\r\n  /**\r\n   * HostListener welcher den Edit Mode bei allen Files und Nodes beendet.\r\n   */\r\n  @HostListener('document:click', ['$event.target'])\r\n  /**\r\n   * Click Event\r\n   */\r\n  public exitEditMode(targetElement): void {\r\n    if (this.selectedNode) {\r\n      this.selectedNode.Files.forEach((itm) => (itm.IsEditMode = false));\r\n\r\n      if (\r\n        !this.selectedNode ||\r\n        this.selectedNode.Name === null ||\r\n        this.selectedNode.Name.length === 0\r\n      ) {\r\n        this.clearNewChildNodes(this.rootNode);\r\n      }\r\n    }\r\n\r\n    this.resetNodeEditMode(null);\r\n  }\r\n\r\n  /**\r\n   * Erzeugt einen neuen Node im Tree\r\n   * @param node Node unter welchem ein neuer Node erstellt werden soll\r\n   */\r\n  public newNode(node: IBrowserNode) {\r\n    const item: IBrowserNode = {\r\n      ChildNodes: [],\r\n      Files: [],\r\n      IsEditMode: false,\r\n      IsExpanded: false,\r\n      Name: '',\r\n      Path: node.Path,\r\n      IsNewNode: true,\r\n    };\r\n\r\n    node.ChildNodes.push(item);\r\n    this.selectNode(item);\r\n    this.editNode(item);\r\n  }\r\n\r\n  /**\r\n   * Init Event der Komponente\r\n   */\r\n  public ngOnInit(): void {\r\n    this.browserService\r\n      .GetNode(this.apiurl, '', this.allowedtypes)\r\n      .subscribe((result: IBrowserNodeResponse) => {\r\n        this.rootNode = {\r\n          Name: result.Node.Name,\r\n          Files: result.Node.Files,\r\n          ChildNodes: result.Node.ChildNodes,\r\n          IsExpanded: true,\r\n          IsEditMode: false,\r\n          IsNewNode: false,\r\n          Path: '/',\r\n        };\r\n\r\n        this.setPathToAllNodes();\r\n        this.selectedNode = this.rootNode;\r\n\r\n        // Selected File erneut setzen, wenn Property gesetzt wurde bevor Daten vom Service geladen wurden.\r\n        if (this.preselecedfile !== null && this.preselecedfile.length > 0) {\r\n          this.selectedfile = this.preselecedfile;\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Aktualisiert den Node\r\n   */\r\n  public refreshNode(node: IBrowserNode): void {\r\n    if (!node.IsExpanded) {\r\n      this.switchExpandNode(node);\r\n    }\r\n\r\n    this.browserService\r\n      .GetNode(this.apiurl, node.Path, this.allowedtypes)\r\n      .subscribe((result: IBrowserNodeResponse) => {\r\n        node.ChildNodes = result.Node.ChildNodes;\r\n        node.Files = result.Node.Files;\r\n\r\n        this.setPathToAllNodes();\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Methode wenn eine Datei umbenannt werden soll\r\n   * @param file File welches umbenannt werden soll\r\n   * @param newFilename Neuer Dateiname\r\n   */\r\n  public renameFile(file: IBrowserFile, newFilename: string): void {\r\n    file.IsEditMode = false;\r\n\r\n    if (!newFilename || newFilename === null || newFilename.length === 0) {\r\n      // Cancel, Invalid Filename\r\n      return;\r\n    }\r\n\r\n    if (file.Filename !== newFilename) {\r\n      this.browserService\r\n        .RenameFile(\r\n          this.apiurl,\r\n          this.selectedNode.Path + '/' + file.Filename,\r\n          newFilename,\r\n          this.allowedtypes\r\n        )\r\n        .subscribe((result: IBrowserFileResponse) => {\r\n          this.selectedNode.Files = result.Files;\r\n        });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Methode wenn ein Node umbenannt werden soll\r\n   * @param node Node welcher umbenannt werden soll\r\n   * @param newFoldername Neuer Ordnername\r\n   */\r\n  public renameNode(node: IBrowserNode, newFoldername: string): void {\r\n    node.IsEditMode = false;\r\n\r\n    if (!node.IsNewNode) {\r\n      if (\r\n        !newFoldername ||\r\n        newFoldername === null ||\r\n        newFoldername.length === 0\r\n      ) {\r\n        // Cancel Rename. Invalid Foldername\r\n        return;\r\n      }\r\n\r\n      if (node.Name !== newFoldername) {\r\n        this.browserService\r\n          .RenameNode(this.apiurl, node.Path, newFoldername)\r\n          .subscribe((result: IBrowserNodeResponse) => {\r\n            node.Name = result.Node.Name;\r\n\r\n            this.setPathToAllNodes();\r\n          });\r\n      }\r\n    } else {\r\n      if (\r\n        !newFoldername ||\r\n        newFoldername === null ||\r\n        newFoldername.length === 0\r\n      ) {\r\n        this.clearNewChildNodes(this.rootNode);\r\n        return;\r\n      }\r\n\r\n      node.Name = newFoldername;\r\n      node.IsNewNode = false;\r\n      this.browserService\r\n        .SaveNode(this.apiurl, node.Path, newFoldername)\r\n        .subscribe((result: IBrowserNodeResponse) => {\r\n          node.Name = result.Node.Name;\r\n          node.Files = result.Node.Files;\r\n\r\n          this.setPathToAllNodes();\r\n        });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Methode wenn ein File selektiert wird\r\n   * @param file File welches selektiert wird\r\n   */\r\n  public selectFile(file: IBrowserFile) {\r\n    if (!file.IsEditMode) {\r\n      this.selectedNode.Files.forEach((itm) => (itm.IsEditMode = false));\r\n    }\r\n\r\n    if (!this.selectedNode.Path.endsWith('/')) {\r\n      this.selectedFile = this.selectedNode.Path + '/' + file.Filename;\r\n    } else {\r\n      this.selectedFile = '/' + file.Filename;\r\n    }\r\n\r\n    this.selectedFileItem = file;\r\n    this.file.emit(this.selectedFile);\r\n  }\r\n\r\n  /**\r\n   * Methode wenn ein Node selektiert wird\r\n   * @param node Node welcher selektiert werden soll\r\n   */\r\n  public selectNode(node: IBrowserNode): void {\r\n    if (!node.IsExpanded) {\r\n      this.switchExpandNode(node);\r\n    }\r\n\r\n    // Reset the Edit Mode in all Nodes\r\n    this.resetNodeEditMode(null);\r\n\r\n    if (!node.Files) {\r\n      this.browserService\r\n        .GetFiles(this.apiurl, node.Path, this.allowedtypes)\r\n        .subscribe((result: IBrowserFileResponse) => {\r\n          node.Files = result.Files;\r\n          this.selectedNode = node;\r\n\r\n          if (this.preselecedfile !== null && this.preselecedfile.length > 0) {\r\n            const filename = this.preselecedfile.substring(\r\n              this.preselecedfile.lastIndexOf('/') + 1\r\n            );\r\n            const file = node.Files.find((itm) => itm.Filename === filename);\r\n            if (file) {\r\n              this.selectFile(file);\r\n            }\r\n          }\r\n        });\r\n    } else {\r\n      this.selectedNode = node;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Expand/Collabse Methode für Nodes\r\n   * @param node Node welcher geöffnet oder geschlossen werden soll\r\n   */\r\n  public switchExpandNode(node: IBrowserNode): void {\r\n    if (node.IsExpanded) {\r\n      node.IsExpanded = false;\r\n    } else {\r\n      node.IsExpanded = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Methode die Aufgerufen werden muss, wenn ein Upload beendet ist.\r\n   * @param param Parameter des hochgeladenen Files\r\n   */\r\n  public uploadComplete(node: IBrowserNode, uploadIdList: string[]): void {\r\n    if (uploadIdList !== null) {\r\n      uploadIdList.forEach((element) => {\r\n        if (this.uploads.indexOf(element) < 0) {\r\n          this.uploads.push(element);\r\n        }\r\n      });\r\n    }\r\n\r\n    const id = this.uploads.pop();\r\n    if (id) {\r\n      this.browserService\r\n        .SaveFile(this.apiurl, node.Path, id, this.allowedtypes)\r\n        .subscribe((result: IBrowserFileResponse) => {\r\n          this.selectedNode.Files = result.Files;\r\n          this.uploadedFileMoved(id);\r\n        });\r\n    }\r\n  }\r\n\r\n  // #endregion Public Methods\r\n\r\n  // #region Public Abstract Methods\r\n\r\n  /**\r\n   * Abstrakte Confirm Methode welche implementiert werden muss. Methode wird aufgerufen, wenn eine\r\n   * Datei gelöscht werden soll.\r\n   * @param file File für welches ein Delete Confirm eingefordert werden soll\r\n   */\r\n  public abstract confirmDeleteFile(file: IBrowserFile): Observable<boolean>;\r\n  /**\r\n   * Abstrakte Confirm Methode welche implementiert werden muss. Methode wird aufgerufen, wenn ein\r\n   * Ordner gelöscht werden soll.\r\n   * @param folder Ordern für welchen ein Delete Confirm eingefordert werden soll.\r\n   */\r\n  public abstract confirmDeleteNode(folder: IBrowserNode): Observable<boolean>;\r\n  /**\r\n   * Abstrakte Methode die Aufgerufen wird, wenn das Hochgeladene File aus dem Temp Folder in die\r\n   * Struktur verschoben wurde.\r\n   * @param uploadid ID des Uploads\r\n   */\r\n  public abstract uploadedFileMoved(uploadid: string): void;\r\n\r\n  // #endregion Public Abstract Methods\r\n\r\n  // #region Private Methods\r\n\r\n  /**\r\n   * Rekursive Methode welche beim Node und all seinen Childs neue Nodes entfernt\r\n   * @param node Node bei welchem alle neuen Nodes entfernt werden soll.\r\n   */\r\n  private clearNewChildNodes(node: IBrowserNode) {\r\n    node.ChildNodes.forEach((itm) => {\r\n      if (itm.IsNewNode) {\r\n        node.ChildNodes.splice(node.ChildNodes.indexOf(itm));\r\n      }\r\n    });\r\n\r\n    node.ChildNodes.forEach((itm) => this.clearNewChildNodes(itm));\r\n  }\r\n\r\n  /**\r\n   * Methode welche den Pfad für einen Node erzeugt\r\n   * @param node Node für welchen der Pfad erzeugt werden soll\r\n   * @param parentPath Übergeordneter Pfad\r\n   */\r\n  private fillPath(node: IBrowserNode, parentPath: string) {\r\n    node.Path = parentPath + '/' + node.Name;\r\n    node.ChildNodes.forEach((itm) => {\r\n      this.fillPath(itm, node.Path);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sucht den übergeordneten Node im Tree\r\n   * @param node Aktueller Node\r\n   * @param nodeToFind Node welcher gefunden werden soll\r\n   * @returns Node wenn er gefunden wurde, ansonsten wird NULL zurückgegeben\r\n   */\r\n  private findParentNode(\r\n    node: IBrowserNode,\r\n    nodeToFind: IBrowserNode\r\n  ): IBrowserNode {\r\n    if (node.ChildNodes.indexOf(nodeToFind) >= 0) {\r\n      return node;\r\n    }\r\n\r\n    for (const child of node.ChildNodes) {\r\n      const result = this.findParentNode(child, nodeToFind);\r\n      if (result !== null) {\r\n        return result;\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Sucht einen Node gem. einem URL Pfad\r\n   * @param node Node in welchem gesucht werden soll\r\n   * @param path Pfad nach welchem gesucht wird\r\n   * @returns Node welcher zum gesuchten Pfad passt. Wenn kein Node gefunden wird, wird NULL zurückgegeben\r\n   */\r\n  private findSelectedNodeByPath(\r\n    node: IBrowserNode,\r\n    path: string\r\n  ): IBrowserNode {\r\n    // Cancel wenn Pfad nicht definiert\r\n    if (path === undefined || path === null) {\r\n      return null;\r\n    }\r\n\r\n    // Pfad in Array splitten und Root Foldername setzen\r\n    const pathArray = path.split('/');\r\n    pathArray[0] = this.rootNode.Name;\r\n\r\n    return this.findSelectedNodeByPathArray(node, pathArray, 0);\r\n  }\r\n\r\n  /**\r\n   * Sucht einen Node gem. einem Array von Node Namen\r\n   * @param node Node in welchem gesucht werden soll\r\n   * @param path Array von Node Namen, welche die Hirarchy des Pfades abbilden\r\n   * @param index Aktueller Index im PATH Array\r\n   * @returns Node wenn einer gefunden wurde, ansonsten NULL\r\n   */\r\n  private findSelectedNodeByPathArray(\r\n    node: IBrowserNode,\r\n    path: string[],\r\n    index: number\r\n  ): IBrowserNode {\r\n    // Check ob Ordner korrekt. Letzer Ordner zurückgeben. Path Last Index ist der Filename\r\n    if (node.Name === path[index] && path.length - 2 === index) {\r\n      return node;\r\n    } else if (node.Name === path[index]) {\r\n      // Expand Node\r\n      node.IsExpanded = true;\r\n      for (const item of node.ChildNodes) {\r\n        const result = this.findSelectedNodeByPathArray(item, path, index + 1);\r\n\r\n        if (result !== null) {\r\n          return result;\r\n        }\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Rekursive Methode welche beim Node und all seinen Childs den Edit Mode beendet.\r\n   * @param node Node bei welchem der Edit Mode beendet werden soll\r\n   */\r\n  private resetNodeEditMode(node: IBrowserNode): void {\r\n    if (node === null) {\r\n      this.resetNodeEditMode(this.rootNode);\r\n    } else {\r\n      node.IsEditMode = false;\r\n\r\n      if (node.ChildNodes) {\r\n        node.ChildNodes.forEach((itm) => this.resetNodeEditMode(itm));\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setzt den Pfad in allen Nodes\r\n   */\r\n  private setPathToAllNodes() {\r\n    this.rootNode.ChildNodes.forEach((itm) => {\r\n      this.fillPath(itm, '');\r\n    });\r\n  }\r\n\r\n  // #endregion Private Methods\r\n}\r\n"]}

package/esm2020/components/browser/browser.ngfactory.mjs

@@ -0,0 +1,4 @@
+import * as i0 from '@angular/core';
+import { SacFileBrowserCommon } from './browser';
+export const ɵNonEmptyModule = true;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci5uZ2ZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb21wb25lbnRzL2Jyb3dzZXIvYnJvd3Nlci5uZ2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDcEMsT0FBTyxFQUFDLG9CQUFvQixFQUFDLE1BQU0sV0FBVyxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBpMCBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7U2FjRmlsZUJyb3dzZXJDb21tb259IGZyb20gJy4vYnJvd3Nlcic7XG5leHBvcnQgY29uc3QgU2FjRmlsZUJyb3dzZXJDb21tb25OZ0ZhY3Rvcnk6IGkwLsm1TmdNb2R1bGVGYWN0b3J5PGFueT4gPSBuZXcgaTAuybVOZ01vZHVsZUZhY3RvcnkoU2FjRmlsZUJyb3dzZXJDb21tb24pO1xuZXhwb3J0IGNvbnN0IMm1Tm9uRW1wdHlNb2R1bGUgPSB0cnVlOyJdfQ==

package/esm2020/components/browser/browser.ngsummary.mjs

@@ -0,0 +1,2 @@
+export const SacFileBrowserCommonNgSummary = null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci5uZ3N1bW1hcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb21wb25lbnRzL2Jyb3dzZXIvYnJvd3Nlci5uZ3N1bW1hcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQVEsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFNhY0ZpbGVCcm93c2VyQ29tbW9uTmdTdW1tYXJ5OiBhbnkgPSBudWxsOyJdfQ==

package/esm2020/components/browser/models/browserfile.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3NlcmZpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb21wb25lbnRzL2Jyb3dzZXIvbW9kZWxzL2Jyb3dzZXJmaWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogSW50ZXJmYWNlIGbDvHIgRGF0ZWkgSXRlbXMgaW4gRmlsZSBCcm93c2VyIENvbXBvbmVudFxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBJQnJvd3NlckZpbGUge1xyXG4gIC8qKlxyXG4gICAqIERhdGVpbmFtZVxyXG4gICAqL1xyXG4gIEZpbGVuYW1lOiBzdHJpbmc7XHJcbiAgLyoqXHJcbiAgICogR3LDtnNzZSBkZXIgRGF0ZWlcclxuICAgKi9cclxuICBTaXplOiBudW1iZXI7XHJcbiAgLyoqXHJcbiAgICogSXRlbSB3aXJkIGJlYXJiZWl0ZXRcclxuICAgKi9cclxuICBJc0VkaXRNb2RlOiBib29sZWFuO1xyXG59XHJcbiJdfQ==

package/esm2020/components/browser/models/browserfile.ngfactory.mjs

@@ -0,0 +1,2 @@
+export const ɵNonEmptyModule = true;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3NlcmZpbGUubmdmYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2FjLWNvbW1vbi9zcmMvY29tcG9uZW50cy9icm93c2VyL21vZGVscy9icm93c2VyZmlsZS5uZ2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsTUFBTSxDQUFDLE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIlxuZXhwb3J0IGNvbnN0IMm1Tm9uRW1wdHlNb2R1bGUgPSB0cnVlOyJdfQ==

package/esm2020/components/browser/models/browserfile.ngsummary.mjs

@@ -0,0 +1,2 @@
+export const ɵempty = null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3NlcmZpbGUubmdzdW1tYXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2FjLWNvbW1vbi9zcmMvY29tcG9uZW50cy9icm93c2VyL21vZGVscy9icm93c2VyZmlsZS5uZ3N1bW1hcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCDJtWVtcHR5ID0gbnVsbDsiXX0=