scanoss 0.2.3

package/build/module/lib/scanner/Winnower/Winnower.js

@@ -0,0 +1,411 @@
+import EventEmitter from 'events';
+import fs from 'fs';
+import { Worker } from 'worker_threads';
+import { ScannableItem } from '../Scannable/ScannableItem';
+import { ScannerCfg } from '../ScannerCfg';
+import { ScannerEvents, WinnowingMode } from '../ScannerTypes';
+import { WinnowerExtractor } from './WinnowerExtractor';
+import { WinnowerResponse } from './WinnowerResponse';
+const stringWorker = `
+const { parentPort } = require('worker_threads');
+
+parentPort.on('message', async (scannableItem) => {
+
+  let fingerprint;
+  if ( scannableItem.winnowingMode === "FULL_WINNOWING") {
+    fingerprint = wfp_for_content(
+      scannableItem.content,
+      scannableItem.contentSource,
+      scannableItem.maxSizeWfp
+    );
+  } else {
+    fingerprint = wfp_only_md5(
+      scannableItem.content,
+      scannableItem.contentSource
+    );
+  }
+
+  scannableItem.fingerprint = fingerprint;
+
+  parentPort.postMessage(scannableItem);
+});
+
+
+const crypto = require('crypto');
+
+const isWin = process.platform === 'win32';
+const pathSeparator = isWin ? String.fromCharCode(92) : '/';
+
+// Winnowing configuration. DO NOT CHANGE.
+const GRAM = 30;
+const WINDOW = 64;
+
+// ASCII characters
+const ASCII_0 = 48;
+const ASCII_9 = 57;
+const ASCII_A = 65;
+const ASCII_Z = 90;
+const ASCII_a = 97;
+const ASCII_z = 122;
+const ASCII_LF = 10;
+
+function normalize(byte) {
+  if (byte < ASCII_0 || byte > ASCII_z) {
+    return 0;
+  }
+  if (byte <= ASCII_9 || byte >= ASCII_a) {
+    return byte;
+  }
+  if (byte >= ASCII_A && byte <= ASCII_Z) {
+    return byte + 32;
+  }
+  return 0;
+}
+
+function min_hex_array(array) {
+  let min = 'ffffffff';
+  for (let i = 0; i < array.length; i++) {
+    if (array[i] < min) {
+      min = array[i];
+    }
+  }
+  return min;
+}
+
+function wfp_for_content(content, contentSource, maxSize) {
+  let wfp = wfp_only_md5(content, contentSource);
+  wfp += calc_wfp(content, maxSize);
+  return wfp;
+}
+
+function wfp_only_md5(contents, contentSource) {
+  const file_md5 = crypto.createHash('md5').update(contents).digest('hex');
+  let wfp = 'file=' + String(file_md5) + ',' + String(contents.length) + ',' + String(contentSource)+ String.fromCharCode(10);
+  return wfp;
+}
+
+function calc_wfp(contents, maxSize) {
+  let gram = '';
+  const window = [];
+  let normalized = 0;
+  let line = 1;
+  let min_hash = 'ffffffff';
+  let last_hash = 'ffffffff';
+  let last_line = 0;
+  let output = '';
+  let gram_crc32 = 0;
+  let wfp = '';
+
+  for (let i = 0; i < contents.length; i++) {
+    if(wfp.length > maxSize)
+      return wfp;
+
+    const byte = contents[i];
+    if (byte == ASCII_LF) {
+      line += 1;
+      normalized = 0;
+    } else {
+      normalized = normalize(byte);
+    }
+    // Is this an useful byte?
+    if (normalized) {
+      gram += String.fromCharCode(normalized);
+
+      if (gram.length >= GRAM) {
+        gram_crc32 = crc32c_hex(gram);
+        window.push(gram_crc32);
+
+        if (window.length >= WINDOW) {
+          min_hash = min_hex_array(window);
+          if (min_hash !== last_hash) {
+            // Hashing the hash will result in a better balanced output data set
+            // as it will counter the winnowing effect which selects the "minimum"
+            // hash in each window
+            const min_hash_bytes_le = parseHexString(
+              toLittleEndianCRCHex(min_hash)
+            );
+            const crc_hex = crc32c_for_bytes_hex(min_hash_bytes_le);
+
+            if (last_line != line) {
+              if (output.length > 0) {
+                wfp += String(output) + String.fromCharCode(10);
+              }
+              output = String(line) + '=' + String(crc_hex);
+            } else {
+              output += ',' + String(crc_hex);
+            }
+            last_line = line;
+            last_hash = min_hash;
+          }
+          window.shift();
+        }
+        gram = gram.slice(1);
+      }
+    }
+  }
+  if (output.length > 0) {
+    wfp += String(output) + String.fromCharCode(10);
+  }
+
+  return wfp;
+}
+
+function parseHexString(str) {
+  const result = [];
+  while (str.length >= 2) {
+    result.push(parseInt(str.substring(0, 2), 16));
+    str = str.substring(2, str.length);
+  }
+
+  return result;
+}
+
+/**
+ *
+ * @param {string} hex
+ */
+function toLittleEndianCRCHex(hex) {
+  return (
+    hex.charAt(6) +
+    hex.charAt(7) +
+    hex.charAt(4) +
+    hex.charAt(5) +
+    hex.charAt(2) +
+    hex.charAt(3) +
+    hex.charAt(0) +
+    hex.charAt(1)
+  );
+}
+
+let CRC_TABLE = [];
+
+function makeCRCTable() {
+  let c;
+  const crcTable = [];
+  for (let n = 0; n < 256; n++) {
+    c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    crcTable[n] = c;
+  }
+  return crcTable;
+}
+
+function crc32c(str) {
+  if (CRC_TABLE.length == 0) {
+    CRC_TABLE = makeCRCTable();
+  }
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < str.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ str.charCodeAt(i)) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+}
+
+function crc32c_for_bytes(bytes) {
+  if (CRC_TABLE.length == 0) {
+    CRC_TABLE = makeCRCTable();
+  }
+  let crc = 0 ^ -1;
+
+  for (let i = 0; i < bytes.length; i++) {
+    crc = (crc >>> 8) ^ CRC_TABLE[(crc ^ bytes[i]) & 0xff];
+  }
+
+  return (crc ^ -1) >>> 0;
+}
+
+function crc32c_for_bytes_hex(bytes) {
+  return crc32c_for_bytes(bytes).toString(16).padStart(8, '0');
+}
+
+function crc32c_hex(str) {
+  return crc32c(str).toString(16).padStart(8, '0');
+}
+
+`;
+export class Winnower extends EventEmitter {
+    scannerCfg;
+    fileList;
+    fileListIndex;
+    folderRoot;
+    wfp;
+    worker;
+    continue;
+    isRunning;
+    winnowingMode;
+    readingFromFile;
+    winnowingExtractor;
+    constructor(scannerCfg = new ScannerCfg()) {
+        super();
+        this.scannerCfg = scannerCfg;
+    }
+    init() {
+        this.wfp = '';
+        this.folderRoot = '';
+        this.continue = true;
+        this.isRunning = false;
+        this.readingFromFile = false;
+        this.fileList = [];
+        this.fileListIndex = 0;
+        this.winnowingMode = WinnowingMode.FULL_WINNOWING;
+    }
+    prepareWorker() {
+        this.worker = new Worker(stringWorker, { eval: true });
+        this.worker.on('message', async (scannableItem) => {
+            await this.winnowerPacker(scannableItem.fingerprint);
+            await this.nextStepMachine();
+        });
+    }
+    recoveryIndex() {
+        // Files: contains all files winnowed but not packed yet
+        const files = new WinnowerResponse(this.wfp, this.folderRoot).getFilesWinnowed();
+        if (files.length) {
+            const lastFileWinnowed = files[files.length - 1];
+            let i = 0;
+            while (i <= files.length && lastFileWinnowed !== this.fileList[this.fileListIndex - i]) {
+                i += 1;
+            }
+            // If file already winnowed cannot be found in fileList emit an error.
+            if (i > files.length) {
+                this.emit(ScannerEvents.ERROR, new Error('Cannot recovery index on winnower'));
+                return -1;
+            }
+            this.fileListIndex -= i;
+            if (this.fileList[this.fileListIndex] === lastFileWinnowed)
+                this.fileListIndex += 1;
+        }
+        return 0;
+    }
+    forceStopWorker() {
+        this.worker.removeAllListeners();
+        this.worker.terminate();
+    }
+    // returns true if the a winnowing packet was sended
+    winnowerPacker(winnowingResult) {
+        // When the fingerprint of one file is bigger than 64Kb, truncate to the last 64Kb line.
+        if (winnowingResult.length > this.scannerCfg.WFP_FILE_MAX_SIZE) {
+            let truncateStringOnIndex = this.scannerCfg.WFP_FILE_MAX_SIZE;
+            let keepRemovingCharacters = true;
+            while (keepRemovingCharacters) {
+                if (winnowingResult[truncateStringOnIndex] === '\n')
+                    keepRemovingCharacters = false;
+                truncateStringOnIndex -= 1;
+            }
+            truncateStringOnIndex += 1;
+            // eslint-disable-next-line no-param-reassign
+            winnowingResult = winnowingResult.substring(0, truncateStringOnIndex);
+            // eslint-disable-next-line no-param-reassign
+            winnowingResult += '\n';
+        }
+        if (this.wfp.length + winnowingResult.length >= this.scannerCfg.WFP_FILE_MAX_SIZE) {
+            this.processPackedWfp(this.wfp);
+            this.wfp = '';
+        }
+        this.wfp += winnowingResult;
+        if (this.wfp !== winnowingResult)
+            return false;
+        return true;
+    }
+    processPackedWfp(content) {
+        const wnRsp = new WinnowerResponse(content, this.folderRoot);
+        this.emit(ScannerEvents.WINNOWING_NEW_CONTENT, wnRsp);
+    }
+    async getNextScannableItem() {
+        if (this.fileListIndex >= this.fileList.length)
+            return null;
+        const path = this.fileList[this.fileListIndex];
+        const contentSource = path.replace(`${this.folderRoot}`, '');
+        const content = await fs.promises.readFile(path);
+        this.fileListIndex += 1;
+        const scannable = new ScannableItem(content, contentSource, this.winnowingMode, this.scannerCfg.WFP_FILE_MAX_SIZE);
+        return scannable;
+    }
+    async nextStepMachine() {
+        if (!this.continue)
+            return;
+        const scannableItem = await this.getNextScannableItem();
+        if (scannableItem)
+            this.worker.postMessage(scannableItem);
+        else
+            this.finishWinnowing();
+    }
+    startWinnowingFromFile(filePath) {
+        this.emit(ScannerEvents.WINNOWER_LOG, '[ SCANNER ]: Starting Winnowing from file...');
+        this.readingFromFile = true;
+        this.isRunning = true;
+        this.winnowingExtractor = new WinnowerExtractor();
+        this.winnowingExtractor.loadFile(filePath);
+        this.extractionProcess(this.scannerCfg.DISPATCHER_QUEUE_SIZE_MAX_LIMIT);
+    }
+    async extractionProcess(n) {
+        let winBlock = '-';
+        while (winBlock !== '' && n >= 0) { // this.continue will change on method pause();
+            winBlock = this.winnowingExtractor.extractWinBlock(); // TODO Make async funcion
+            if (winBlock !== '') {
+                if (this.winnowerPacker(winBlock))
+                    n -= 1;
+            }
+        }
+        // Last winnowing block
+        if (winBlock === '')
+            this.finishWinnowing();
+    }
+    async startWinnowing(scanInput) {
+        this.emit(ScannerEvents.WINNOWER_LOG, '[ SCANNER ]: Starting Winnowing...');
+        this.init();
+        this.prepareWorker();
+        if (scanInput.winnowingMode)
+            this.setWinnowingMode(scanInput.winnowingMode);
+        this.readingFromFile = false;
+        this.isRunning = true;
+        this.folderRoot = scanInput.folderRoot;
+        this.fileList = scanInput.fileList;
+        this.nextStepMachine();
+    }
+    finishWinnowing() {
+        if (this.wfp.length !== 0) {
+            this.processPackedWfp(this.wfp);
+        }
+        this.isRunning = false;
+        this.emit(ScannerEvents.WINNOWER_LOG, '[ SCANNER ]: Winnowing Finished...');
+        this.forceStopWorker();
+    }
+    pause() {
+        this.emit(ScannerEvents.WINNOWER_LOG, '[ SCANNER ]: Winnowing paused...');
+        this.continue = false;
+        if (!this.readingFromFile) {
+            this.forceStopWorker();
+            this.prepareWorker();
+        }
+    }
+    resume() {
+        this.emit(ScannerEvents.WINNOWER_LOG, '[ SCANNER ]: Winnowing resumed...');
+        this.continue = true;
+        if (!this.readingFromFile) {
+            this.recoveryIndex();
+            this.nextStepMachine();
+        }
+        else {
+            this.extractionProcess(this.scannerCfg.DISPATCHER_QUEUE_SIZE_MAX_LIMIT * 2);
+        }
+    }
+    stop() {
+        this.continue = false;
+        this.isRunning = false;
+        this.winnowingExtractor = null;
+        this.forceStopWorker();
+        this.prepareWorker();
+        this.init();
+    }
+    hasPendingFiles() {
+        return this.isRunning;
+    }
+    setWinnowingMode(mode) {
+        this.winnowingMode = mode;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Winnower.js","sourceRoot":"","sources":["../../../../../src/lib/scanner/Winnower/Winnower.ts"],"names":[],"mappings":"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"}

package/build/module/lib/scanner/Winnower/WinnowerExtractor.d.ts

@@ -0,0 +1,10 @@
+export declare class WinnowerExtractor {
+    private winnowing;
+    private winnowingFilePath;
+    private blocksIndex;
+    private currentBlock;
+    constructor();
+    private init;
+    loadFile(path: string): void;
+    extractWinBlock(): string;
+}

package/build/module/lib/scanner/Winnower/WinnowerExtractor.js

@@ -0,0 +1,30 @@
+import fs from "fs";
+export class WinnowerExtractor {
+    winnowing;
+    winnowingFilePath;
+    blocksIndex;
+    currentBlock;
+    constructor() {
+        this.init();
+    }
+    init() {
+        this.winnowing = '';
+        this.currentBlock = 0;
+    }
+    loadFile(path) {
+        this.init();
+        this.winnowingFilePath = path;
+        this.winnowing = fs.readFileSync(path, 'utf-8');
+        const reg = /file=/g;
+        this.blocksIndex = [...((this.winnowing).matchAll(reg))].map(x => x.index);
+    }
+    ;
+    extractWinBlock() {
+        let res = '';
+        if (this.currentBlock < this.blocksIndex.length - 1)
+            res = this.winnowing.substring(this.blocksIndex[this.currentBlock], this.blocksIndex[this.currentBlock + 1]);
+        this.currentBlock += 1;
+        return res;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2lubm93ZXJFeHRyYWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NjYW5uZXIvV2lubm93ZXIvV2lubm93ZXJFeHRyYWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBRXBCLE1BQU0sT0FBTyxpQkFBaUI7SUFFcEIsU0FBUyxDQUFTO0lBRWxCLGlCQUFpQixDQUFTO0lBRTFCLFdBQVcsQ0FBZ0I7SUFFM0IsWUFBWSxDQUFTO0lBRTdCO1FBQ0UsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVPLElBQUk7UUFDVixJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQztRQUNwQixJQUFJLENBQUMsWUFBWSxHQUFHLENBQUMsQ0FBQztJQUN4QixDQUFDO0lBRU0sUUFBUSxDQUFDLElBQVk7UUFDMUIsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ1osSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksQ0FBQztRQUM5QixJQUFJLENBQUMsU0FBUyxHQUFHLEVBQUUsQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2hELE1BQU0sR0FBRyxHQUFHLFFBQVEsQ0FBQztRQUNyQixJQUFJLENBQUMsV0FBVyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdFLENBQUM7SUFBQSxDQUFDO0lBRUssZUFBZTtRQUNwQixJQUFJLEdBQUcsR0FBRyxFQUFFLENBQUM7UUFDYixJQUFJLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEdBQUMsQ0FBQztZQUMvQyxHQUFHLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLEVBQUUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsWUFBWSxHQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDN0csSUFBSSxDQUFDLFlBQVksSUFBRSxDQUFDLENBQUM7UUFDckIsT0FBTyxHQUFHLENBQUM7SUFDYixDQUFDO0NBQ0YifQ==

package/build/module/lib/scanner/Winnower/WinnowerResponse.d.ts

@@ -0,0 +1,11 @@
+export declare class WinnowerResponse {
+    private wfpContent;
+    private engineFlags;
+    private scanRoot;
+    constructor(wfpContent: any, scanRoot?: string);
+    isEqual(winnowerResponse: any): boolean;
+    getContent(): string;
+    setEngineFlags(engineFlags: number): void;
+    getEngineFlags(): number;
+    getFilesWinnowed(): any[] | "";
+}

package/build/module/lib/scanner/Winnower/WinnowerResponse.js

@@ -0,0 +1,31 @@
+export class WinnowerResponse {
+    wfpContent;
+    engineFlags;
+    scanRoot;
+    constructor(wfpContent, scanRoot = '') {
+        this.wfpContent = wfpContent;
+        this.scanRoot = scanRoot;
+    }
+    isEqual(winnowerResponse) {
+        return this.getContent() === winnowerResponse.getContent();
+    }
+    getContent() {
+        return this.wfpContent;
+    }
+    setEngineFlags(engineFlags) {
+        this.engineFlags = engineFlags;
+    }
+    getEngineFlags() {
+        return this.engineFlags;
+    }
+    getFilesWinnowed() {
+        const files = [];
+        const regExp = new RegExp(/,(\/.*)/g);
+        let result;
+        // eslint-disable-next-line no-cond-assign
+        while ((result = regExp.exec(this.wfpContent)))
+            files.push(this.scanRoot + result[1]);
+        return files || '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiV2lubm93ZXJSZXNwb25zZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2Nhbm5lci9XaW5ub3dlci9XaW5ub3dlclJlc3BvbnNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxnQkFBZ0I7SUFDbkIsVUFBVSxDQUFTO0lBRW5CLFdBQVcsQ0FBUztJQUVwQixRQUFRLENBQVM7SUFFekIsWUFBWSxVQUFVLEVBQUUsUUFBUSxHQUFHLEVBQUU7UUFDbkMsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7UUFDN0IsSUFBSSxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDM0IsQ0FBQztJQUVNLE9BQU8sQ0FBQyxnQkFBZ0I7UUFDN0IsT0FBTyxJQUFJLENBQUMsVUFBVSxFQUFFLEtBQUssZ0JBQWdCLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDN0QsQ0FBQztJQUVNLFVBQVU7UUFDZixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDekIsQ0FBQztJQUVNLGNBQWMsQ0FBQyxXQUFtQjtRQUN2QyxJQUFJLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztJQUNqQyxDQUFDO0lBRU0sY0FBYztRQUNuQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUM7SUFDMUIsQ0FBQztJQUVNLGdCQUFnQjtRQUNyQixNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7UUFDakIsTUFBTSxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDdEMsSUFBSSxNQUFNLENBQUM7UUFDWCwwQ0FBMEM7UUFDMUMsT0FBTyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztZQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUN0RixPQUFPLEtBQUssSUFBSSxFQUFFLENBQUM7SUFDckIsQ0FBQztDQUNGIn0=

package/build/module/lib/tree/File.d.ts

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

package/build/module/lib/tree/File.js

@@ -0,0 +1,17 @@
+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() {
+        return [this.getPath()];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdHJlZS9GaWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDbEMsT0FBTyxJQUFJLE1BQU0sUUFBUSxDQUFDO0FBRzFCLE1BQU0sQ0FBQyxPQUFPLE9BQU8sSUFBSyxTQUFRLElBQUk7SUFDcEMsWUFBWSxJQUFZLEVBQUUsSUFBWTtRQUNwQyxLQUFLLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ2xCLElBQUksQ0FBQyxJQUFJLEdBQUcsUUFBUSxDQUFDLElBQUksQ0FBQztJQUM1QixDQUFDO0lBRU0sT0FBTyxDQUFDLElBQVk7UUFDekIsSUFBSSxJQUFJLEtBQUssSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQ3pDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVNLFFBQVE7UUFDYixPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDMUIsQ0FBQztDQUVGIn0=

package/build/module/lib/tree/Folder.d.ts

@@ -0,0 +1,10 @@
+import Node from './Node';
+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(): Array<string>;
+}

package/build/module/lib/tree/Folder.js

@@ -0,0 +1,49 @@
+import { NodeType } from "./Node";
+import Node from './Node';
+export default class Folder extends Node {
+    children;
+    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() {
+        const files = [];
+        this.children.forEach((child) => {
+            files.push(...child.getFiles());
+        });
+        return files;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/tree/Node.d.ts

@@ -0,0 +1,15 @@
+export default abstract class Node {
+    protected type: NodeType;
+    protected rPath: string;
+    protected label: string;
+    protected action: string;
+    constructor(path: string, label: string);
+    abstract getNode(path: string): Node;
+    abstract getFiles(): Array<string>;
+    getName(): string;
+    getPath(): string;
+}
+export declare enum NodeType {
+    FOLDER = "FOLDER",
+    FILE = "FILE"
+}

package/build/module/lib/tree/Node.js

@@ -0,0 +1,23 @@
+export default class Node {
+    type;
+    rPath; // Relative path to the folder or file
+    label;
+    action;
+    constructor(path, label) {
+        this.rPath = path;
+        this.label = label;
+    }
+    getName() {
+        return this.label;
+    }
+    getPath() {
+        return this.rPath;
+    }
+}
+export var NodeType;
+(function (NodeType) {
+    NodeType["FOLDER"] = "FOLDER";
+    NodeType["FILE"] = "FILE";
+})(NodeType || (NodeType = {}));
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdHJlZS9Ob2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxPQUFPLE9BQWdCLElBQUk7SUFDdEIsSUFBSSxDQUFXO0lBRWYsS0FBSyxDQUFTLENBQUMsc0NBQXNDO0lBRXJELEtBQUssQ0FBUztJQUVkLE1BQU0sQ0FBUztJQUV6QixZQUFZLElBQVksRUFBRSxLQUFhO1FBQ3JDLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1FBQ2xCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQ3JCLENBQUM7SUFRTSxPQUFPO1FBQ1osT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3BCLENBQUM7SUFFTSxPQUFPO1FBQ1osT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3BCLENBQUM7Q0FFRjtBQUVELE1BQU0sQ0FBTixJQUFZLFFBR1g7QUFIRCxXQUFZLFFBQVE7SUFDbEIsNkJBQWlCLENBQUE7SUFDakIseUJBQWEsQ0FBQTtBQUNmLENBQUMsRUFIVyxRQUFRLEtBQVIsUUFBUSxRQUduQjtBQUFBLENBQUMifQ==

package/build/module/lib/tree/Tree.d.ts

@@ -0,0 +1,19 @@
+import Node from './Node';
+import Folder from './Folder';
+import { FilterList } from '../filters/filtering';
+export declare class Tree {
+    private rootFolder;
+    private rootName;
+    private rootPath;
+    private filter;
+    constructor(path: string);
+    buildTree(): Node;
+    loadFilter(f: FilterList): void;
+    private buildTreeRec;
+    private dirFirstFileAfter;
+    loadTree(data: any): void;
+    private deserialize;
+    getRootFolder(): Folder;
+    getRootPath(): string;
+    getFileList(): Array<string>;
+}