scanoss 0.7.5 → 0.7.9

package/build/module/src/sdk/scanner/WfpProvider/WfpSplitter/WfpSplitter.js

@@ -0,0 +1,132 @@
+import { WfpProvider } from "../WfpProvider";
+import fs from "fs";
+import { ScannerCfg } from "../../ScannerCfg";
+//Regex find paths from wfp string
+export class WfpSplitter extends WfpProvider {
+    constructor(scannerCfg = new ScannerCfg()) {
+        super();
+        this.scannerCfg = scannerCfg;
+    }
+    start(params) {
+        this.sendLog('[ SCANNER ]: WFP Splitter starting...');
+        this.init();
+        this.pendingFiles = true;
+        this.chunkDataRead = '';
+        this.fingerprints = [];
+        this.continue = true;
+        this.fingerprintIndex = 0;
+        this.ignoreFiles = new Set(params?.fileList);
+        const wfpPath = params.wfpPath;
+        if (!wfpPath)
+            this.sendError('WFP path is not defined');
+        this.wfpStream = fs.createReadStream(wfpPath, { encoding: 'utf8' });
+        this.setStreamListeners();
+        return this.finishPromise;
+    }
+    stop() {
+        this.continue = false;
+    }
+    pause() {
+        this.sendLog('[ SCANNER ]: WFP Splitter paused...');
+        this.continue = false;
+    }
+    resume() {
+        this.sendLog('[ SCANNER ]: WFP Splitter resumed...');
+        this.continue = true;
+        this.sendFingerprints();
+        this.streamBufferFlush();
+    }
+    sendFingerprints() {
+        //The timer allows the main thread not to be blocked while sending wfps
+        if (this.timer === undefined) {
+            this.timer = setInterval(() => {
+                if (this.fingerprintIndex < this.fingerprints.length && this.continue) {
+                    this.fingerprintPacker(this.fingerprints[this.fingerprintIndex]);
+                    this.fingerprintIndex++;
+                }
+                else {
+                    this.stopSendFingerprints();
+                }
+            });
+        }
+    }
+    stopSendFingerprints() {
+        clearInterval(this.timer);
+        this.timer = undefined;
+        if (this.fingerprintIndex === this.fingerprints.length) {
+            this.finishWinnowing();
+            this.sendLog('[ SCANNER ]: WFP Splitter finished...');
+        }
+    }
+    streamBufferFlush() {
+        let ignoreFirstChunkOfFingerprint = false;
+        //Use a loop to make sure we read all currently available data
+        while (this.continue && null !== (this.chunkDataRead = this.wfpStream.read(1 * 1024 * 1024))) { // Read chunks of 1MB 1*1024*1024
+            /**** This part removes all the wfp that includes the paths inside this.ignoreFiles ****/
+            if (this.ignoreFiles.size > 0) {
+                // Removes fingerprints that are loose because the file=...... was removed in previous iteration
+                if (ignoreFirstChunkOfFingerprint) { //TODO: Test this scenario
+                    //If there is no file= delete everything then
+                    if (this.chunkDataRead.indexOf("file=") >= 0) {
+                        this.chunkDataRead = this.chunkDataRead.substring(this.chunkDataRead.indexOf('file='));
+                        ignoreFirstChunkOfFingerprint = false;
+                    }
+                    else
+                        this.chunkDataRead = "";
+                }
+                const rWfpPath = new RegExp(/^file=\w+,\d+,(?<path>.+)$/gm);
+                //Search for paths in the wfp and compares with the ignorefiles set
+                //When there is a match the matched fingerprint is deleted on the fly
+                let result;
+                while ((result = rWfpPath.exec(this.chunkDataRead)) !== null) {
+                    if (this.ignoreFiles.has(result?.groups?.path)) {
+                        const indexDeleteFrom = result.index;
+                        //TODO: Verify this condition
+                        //If there is no next file= in the string, remove until end.
+                        let indexDeleteTo = this.chunkDataRead.indexOf('file=', indexDeleteFrom + 1);
+                        if (indexDeleteTo < 0) {
+                            indexDeleteTo = this.chunkDataRead.length;
+                            //After the deletion of a wfp there are no other file=, so then set ignoreFirstChunkOfFingerprint to true.
+                            //In the next iteration, the next chunk of data will be fingerprints without a file=. So, this first part will be discarded.
+                            ignoreFirstChunkOfFingerprint = true;
+                        }
+                        const first = this.chunkDataRead.substring(0, indexDeleteFrom);
+                        const second = this.chunkDataRead.substring(indexDeleteTo, this.chunkDataRead.length);
+                        this.chunkDataRead = first + second;
+                        rWfpPath.lastIndex = 0; //Make sure we reset the state of the regex.
+                    }
+                }
+            }
+            /**** This part removes all the wfp that includes the paths inside this.ignoreFiles ****/
+            /**** This part process a chunk of wfp and send the packages to the subscriber ****/
+            if (this.chunkDataRead.length) {
+                // Extract the first portion of the chunk until the first file=
+                // Then append the chunk to the last fingerprint.
+                if (!this.chunkDataRead.startsWith('file=')) {
+                    const chunkOfData = this.chunkDataRead.substring(0, this.chunkDataRead.indexOf('file='));
+                    this.fingerprints[this.fingerprints.length - 1] += chunkOfData;
+                }
+                this.fingerprints = [...this.fingerprints, ...this.splitFingerprints(this.chunkDataRead)];
+                this.sendFingerprints();
+            }
+            /**** This part process a chunk of wfp and send the packages to the subscriber ****/
+        }
+    }
+    setStreamListeners() {
+        this.wfpStream.on('readable', () => {
+            this.streamBufferFlush();
+        });
+        this.wfpStream.on('end', () => { });
+    }
+    splitFingerprints(chunkOfData) {
+        const reg = /file=/g;
+        const blocksIndex = [...((chunkOfData).matchAll(reg))].map(x => x.index);
+        const fingerprints = [];
+        for (let i = 0; i < blocksIndex.length; i++) {
+            const fingerprint = chunkOfData.substring(blocksIndex[i], blocksIndex[i + 1]);
+            fingerprints.push(fingerprint);
+        }
+        return fingerprints;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/src/sdk/tree/File.d.ts

@@ -0,0 +1,7 @@
+import Node from './Node';
+import { Filter } from './Filters/Filter';
+export default class File extends Node {
+    constructor(name: string, path: string);
+    getNode(path: string): Node;
+    getFiles(f: Filter): Array<string>;
+}

package/build/module/src/sdk/tree/File.js

@@ -0,0 +1,19 @@
+import { NodeType } from './Node';
+import Node from './Node';
+export default class File extends Node {
+    constructor(name, path) {
+        super(name, path);
+        this.type = NodeType.FILE;
+    }
+    getNode(path) {
+        if (path === this.getPath())
+            return this;
+        return null;
+    }
+    getFiles(f) {
+        if (!f || !f.evaluate(this))
+            return [];
+        return [this.getPath()];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvdHJlZS9GaWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDbEMsT0FBTyxJQUFJLE1BQU0sUUFBUSxDQUFDO0FBSTFCLE1BQU0sQ0FBQyxPQUFPLE9BQU8sSUFBSyxTQUFRLElBQUk7SUFDcEMsWUFBWSxJQUFZLEVBQUUsSUFBWTtRQUNwQyxLQUFLLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ2xCLElBQUksQ0FBQyxJQUFJLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQztJQUM1QixDQUFDO0lBRU0sT0FBTyxDQUFDLElBQVk7UUFDekIsSUFBSSxJQUFJLEtBQUssSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQ3pDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVNLFFBQVEsQ0FBQyxDQUFTO1FBQ3ZCLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQztZQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3ZDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUMxQixDQUFDO0NBRUYifQ==

package/build/module/src/sdk/tree/Filters/DecompressionFilter.d.ts

@@ -0,0 +1,7 @@
+import { Filter } from './Filter';
+import Node from '../Node';
+export declare class DecompressionFilter extends Filter {
+    private supportedFileExtension;
+    constructor(filterName: string);
+    evaluate(node: Node): boolean;
+}

package/build/module/src/sdk/tree/Filters/DecompressionFilter.js

@@ -0,0 +1,18 @@
+import { Filter } from './Filter';
+import { NodeType } from '../Node';
+import { DecompressionManager } from '../../Decompress/DecompressionManager';
+export class DecompressionFilter extends Filter {
+    constructor(filterName) {
+        super();
+        this.supportedFileExtension = new DecompressionManager().getSupportedFormats();
+    }
+    //Returns true if you want the file
+    evaluate(node) {
+        if (node.getType() == NodeType.FOLDER)
+            return true;
+        if (this.supportedFileExtension.some(supportedFormat => node.getName().endsWith(supportedFormat)))
+            return true;
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVjb21wcmVzc2lvbkZpbHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvdHJlZS9GaWx0ZXJzL0RlY29tcHJlc3Npb25GaWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUNsQyxPQUFhLEVBQUUsUUFBUSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBRzdFLE1BQU0sT0FBTyxtQkFBb0IsU0FBUSxNQUFNO0lBSTdDLFlBQW1CLFVBQWtCO1FBQ25DLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLHNCQUFzQixHQUFHLElBQUksb0JBQW9CLEVBQUUsQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO0lBQ2pGLENBQUM7SUFFRCxtQ0FBbUM7SUFDNUIsUUFBUSxDQUFDLElBQVU7UUFDeEIsSUFBRyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksUUFBUSxDQUFDLE1BQU07WUFBRSxPQUFPLElBQUksQ0FBQztRQUNsRCxJQUFJLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsUUFBUSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBQUUsT0FBTyxJQUFJLENBQUM7UUFDL0csT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBRUYifQ==

package/build/module/src/sdk/tree/Filters/DependencyFilter.d.ts

@@ -0,0 +1,7 @@
+import { Filter } from './Filter';
+import Node from '../Node';
+export declare class DependencyFilter extends Filter {
+    private filter;
+    constructor(filterName: string);
+    evaluate(node: Node): boolean;
+}

package/build/module/src/sdk/tree/Filters/DependencyFilter.js

@@ -0,0 +1,14 @@
+import { Filter } from './Filter';
+import { FilterList } from '../../filters/filtering';
+import { defaultFilterForDependencies } from '../../filters/DefaultFilterForDependencies';
+export class DependencyFilter extends Filter {
+    constructor(filterName) {
+        super();
+        this.filter = new FilterList(filterName);
+        this.filter.load(defaultFilterForDependencies);
+    }
+    evaluate(node) {
+        return this.filter.include(node.getPath());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVwZW5kZW5jeUZpbHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvdHJlZS9GaWx0ZXJzL0RlcGVuZGVuY3lGaWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUVsQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUNMLDRCQUE0QixFQUM3QixNQUFNLDRDQUE0QyxDQUFDO0FBRXBELE1BQU0sT0FBTyxnQkFBaUIsU0FBUSxNQUFNO0lBSTFDLFlBQW1CLFVBQWtCO1FBQ25DLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUN6QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyw0QkFBMEMsQ0FBQyxDQUFBO0lBQzlELENBQUM7SUFFTSxRQUFRLENBQUMsSUFBVTtRQUN4QixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQzdDLENBQUM7Q0FFRiJ9

package/build/module/src/sdk/tree/Filters/Filter.d.ts

@@ -0,0 +1,4 @@
+import Node from '../Node';
+export declare abstract class Filter {
+    abstract evaluate(node: Node): boolean;
+}

package/build/module/src/sdk/tree/Filters/Filter.js

@@ -0,0 +1,3 @@
+export class Filter {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmlsdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL3Nkay90cmVlL0ZpbHRlcnMvRmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBZ0IsTUFBTTtDQUUzQiJ9

package/build/module/src/sdk/tree/Filters/ScanFilter.d.ts

@@ -0,0 +1,7 @@
+import { Filter } from './Filter';
+import Node from '../Node';
+export declare class ScanFilter extends Filter {
+    private filter;
+    constructor(filterName: string);
+    evaluate(node: Node): boolean;
+}

package/build/module/src/sdk/tree/Filters/ScanFilter.js

@@ -0,0 +1,14 @@
+import { Filter } from './Filter';
+import { FilterList } from '../../filters/filtering';
+import { defaultFilterForScanning } from '../../filters/DefaultFilterForScanning';
+export class ScanFilter extends Filter {
+    constructor(filterName) {
+        super();
+        this.filter = new FilterList(filterName);
+        this.filter.load(defaultFilterForScanning);
+    }
+    evaluate(node) {
+        return this.filter.include(node.getPath());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2NhbkZpbHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvdHJlZS9GaWx0ZXJzL1NjYW5GaWx0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUVsQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUNMLHdCQUF3QixFQUN6QixNQUFNLHdDQUF3QyxDQUFDO0FBRWhELE1BQU0sT0FBTyxVQUFXLFNBQVEsTUFBTTtJQUlwQyxZQUFtQixVQUFrQjtRQUNuQyxLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDekMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsd0JBQXNDLENBQUMsQ0FBQTtJQUMxRCxDQUFDO0lBRU0sUUFBUSxDQUFDLElBQVU7UUFDeEIsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztJQUM3QyxDQUFDO0NBRUYifQ==

package/build/module/src/sdk/tree/Folder.d.ts

@@ -0,0 +1,12 @@
+import Node from './Node';
+import { Filter } from './Filters/Filter';
+export default class Folder extends Node {
+    private children;
+    constructor(path: string, label: string);
+    addChild(node: Node): void;
+    getChildren(): Node[];
+    getNode(path: string): Node;
+    private checkMyPath;
+    getFiles(f?: Filter): Array<string>;
+    removeChildren(): void;
+}

package/build/module/src/sdk/tree/Folder.js

@@ -0,0 +1,53 @@
+import { NodeType } from "./Node";
+import Node from './Node';
+export default class Folder extends Node {
+    constructor(path, label) {
+        super(path, label);
+        this.type = NodeType.FOLDER;
+        this.children = [];
+    }
+    addChild(node) {
+        this.children.push(node);
+    }
+    getChildren() {
+        return this.children;
+    }
+    getNode(path) {
+        if (!this.checkMyPath(path))
+            return null;
+        if (path === this.getPath())
+            return this;
+        for (const child of this.children) {
+            const node = child.getNode(path);
+            if (node !== null)
+                return node;
+        }
+        return null;
+    }
+    // Returns true only if my path is contained in the path (parameter)
+    checkMyPath(path) {
+        if (!path.includes(this.getPath()))
+            return false;
+        // Only if first filter is passed.
+        const myPathExploded = this.getPath().split('/');
+        const pathExploded = path.split('/');
+        for (let i = 0; i < myPathExploded.length; i += 1) {
+            if (myPathExploded[i] !== pathExploded[i])
+                return false;
+        }
+        return true;
+    }
+    getFiles(f) {
+        if (!f || !f.evaluate(this))
+            return [];
+        const files = [];
+        this.children.forEach((child) => {
+            files.push(...child.getFiles(f));
+        });
+        return files;
+    }
+    removeChildren() {
+        this.children = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/src/sdk/tree/Node.d.ts

@@ -0,0 +1,17 @@
+import { Filter } from './Filters/Filter';
+export default abstract class Node {
+    protected type: NodeType;
+    protected path: string;
+    protected label: string;
+    protected action: string;
+    constructor(path: string, label: string);
+    abstract getNode(path: string): Node;
+    abstract getFiles(f: Filter): Array<string>;
+    getName(): string;
+    getPath(): string;
+    getType(): NodeType;
+}
+export declare enum NodeType {
+    FOLDER = "FOLDER",
+    FILE = "FILE"
+}

package/build/module/src/sdk/tree/Node.js

@@ -0,0 +1,22 @@
+export default class Node {
+    constructor(path, label) {
+        this.path = path;
+        this.label = label;
+    }
+    getName() {
+        return this.label;
+    }
+    getPath() {
+        return this.path;
+    }
+    getType() {
+        return this.type;
+    }
+}
+export var NodeType;
+(function (NodeType) {
+    NodeType["FOLDER"] = "FOLDER";
+    NodeType["FILE"] = "FILE";
+})(NodeType || (NodeType = {}));
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvdHJlZS9Ob2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBQyxPQUFPLE9BQWdCLElBQUk7SUFTaEMsWUFBWSxJQUFZLEVBQUUsS0FBYTtRQUNyQyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztRQUNqQixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUNyQixDQUFDO0lBTU0sT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztJQUNwQixDQUFDO0lBRU0sT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRU0sT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0NBRUY7QUFFRCxNQUFNLENBQU4sSUFBWSxRQUdYO0FBSEQsV0FBWSxRQUFRO0lBQ2xCLDZCQUFpQixDQUFBO0lBQ2pCLHlCQUFhLENBQUE7QUFDZixDQUFDLEVBSFcsUUFBUSxLQUFSLFFBQVEsUUFHbkI7QUFBQSxDQUFDIn0=

package/build/module/src/sdk/tree/Tree.d.ts

@@ -0,0 +1,18 @@
+import Node from './Node';
+import Folder from './Folder';
+import { Filter } from './Filters/Filter';
+export declare class Tree {
+    private rootFolder;
+    private rootName;
+    private rootPath;
+    private filter;
+    constructor(path: string);
+    build(): Node;
+    private buildRec;
+    private dirFirstFileAfter;
+    loadTree(data: any): void;
+    private deserialize;
+    getRootFolder(): Folder;
+    getRootPath(): string;
+    getFileList(f?: Filter): Array<string>;
+}

package/build/module/src/sdk/tree/Tree.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import pathLib from 'path';
+import { NodeType } from './Node';
+import File from './File';
+import Folder from './Folder';
+export class Tree {
+    constructor(path) {
+        const pathParts = path.split(pathLib.sep);
+        this.rootName = pathLib.basename(path);
+        this.rootPath = path;
+        this.rootFolder = new Folder('/', this.rootName);
+    }
+    build() {
+        this.rootFolder.removeChildren();
+        this.buildRec(this.rootPath, this.rootFolder);
+        return this.rootFolder;
+    }
+    buildRec(path, root) {
+        const dirEntries = fs
+            .readdirSync(path, { withFileTypes: true }) // Returns a list of files and folders
+            .sort(this.dirFirstFileAfter)
+            .filter((dirent) => !dirent.isSymbolicLink());
+        for (const dirEntry of dirEntries) {
+            const fullPath = `${path}/${dirEntry.name}`;
+            const relativePath = fullPath.replace(this.rootPath, '');
+            if (dirEntry.isDirectory()) {
+                const f = new Folder(fullPath, dirEntry.name);
+                const subTree = this.buildRec(`${path}/${dirEntry.name}`, f);
+                root.addChild(subTree);
+            }
+            else
+                root.addChild(new File(fullPath, dirEntry.name));
+        }
+        return root;
+    }
+    // This is a sorter that will sort folders before files in alphabetical order.
+    dirFirstFileAfter(a, b) {
+        if (!a.isDirectory() && b.isDirectory())
+            return 1;
+        if (a.isDirectory() && !b.isDirectory())
+            return -1;
+        return 0;
+    }
+    loadTree(data) {
+        this.rootFolder = this.deserialize(data);
+    }
+    deserialize(data) {
+        if (data.type === NodeType.FILE) {
+            return Object.assign(Object.create(File.prototype), data);
+        }
+        const children = data.children.map((child) => this.deserialize(child));
+        return Object.assign(Object.create(Folder.prototype), { ...data, children });
+    }
+    getRootFolder() {
+        return this.rootFolder;
+    }
+    getRootPath() {
+        return this.rootPath;
+    }
+    getFileList(f) {
+        return this.rootFolder.getFiles(f);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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