scanoss 0.7.5 → 0.7.8

package/build/module/src/cli/bin/cli-bin.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { depHandler } from '../commands/dep';
+import { wfpHandler } from '../commands/wfp';
+import { scanHandler } from '../commands/scan';
+function CLIErrorHandler(e) {
+    console.error(' ');
+    console.error(e);
+    process.exit(1);
+}
+async function main() {
+    program
+        .version("0.6.2")
+        .description('The SCANOSS JS package provides a simple, easy to consume module for interacting with SCANOSS APIs/Engine.');
+    program
+        .command('scan <source>')
+        .description('Scan a folder/file')
+        .option('-w, --wfp', 'Scan a .wfp file instead of a folder')
+        .option('-H, --hpsm', 'Scan using winnowing high precision matching')
+        .option('-x, --extract', 'Extract compressed files before launch scan in folder <<zip_name>>-unzipped')
+        .option('   --extract-overwrite', 'Overwrite folder when decompressing if exists')
+        .option('   --extract-deep <number>', 'Sets uncompress recursion level')
+        .option('   --extract-suffix <suffix>', 'Sets suffix for the folder name')
+        .option('-c, --concurrency <number>', 'Number of concurrent connections to use while scanning (optional -default 10)')
+        .option('-n, --ignore <ignore>', 'Ignore components specified in the SBOM file')
+        .option('-o, --output <filename>', 'Output result file name (optional - default stdout)')
+        .option('-f, --format <format>', 'Result output format. {JSON, HTML} Default: JSON')
+        .option('-F, --flags <flags>', 'Scanning engine flags (1: disable snippet matching, 2 enable snippet ids, 4: disable dependencies, 8: disable licenses, 16: disable copyrights,32: disable vulnerabilities, 64: disable quality, 128: disable cryptography,256: disable best match, 512: Report identified files)')
+        .option('-P, --post-size <postsize>', 'Number of kilobytes to limit the post to while scanning (optional - default 64)')
+        .option('-R, --max-retry <retry>', 'Max number of retries for each POST (optional -default 5)')
+        .option('-M, --timeout <timeout>', 'Timeout (in seconds) for API communication (optional -default 120)')
+        .option('-D, --dependencies', 'Add dependency scanning')
+        .option('-a, --apiurl <apiurl>', 'SCANOSS API URL (optional - default: https://osskb.org/api/scan/direct)')
+        .option('-a, --api2url <api2url>', 'SCANOSS gRPC API 2.0 URL (optional - default: scanoss.com)')
+        .option('-k, --key <key>', 'SCANOSS API Key token (optional - not required for default OSSKB URL)')
+        .option('--ignore-cert-errors', 'Ignore self signed certificate errors')
+        .option('--ca-cert <cert>', 'Specify a path for a cert used in SSL/TLS connection')
+        .option('--proxy <proxy>', 'Use proxy')
+        .option('-v, --verbose', 'Makes scan operation verbose')
+        .action((source, options) => { scanHandler(source, options).catch((e) => { CLIErrorHandler(e); }); })
+        .addHelpText('after', `
+  Examples:
+    $ scanoss-js scan -o scan-output.json <source-folder>`);
+    program
+        .command('dep <source>')
+        .description('Scan for dependencies')
+        .option('-o, --output <filename>', 'Output result file name (optional - default stdout)')
+        .option('-a, --grpc-host <host>', 'SCANOSS GRPC HOST (optional - default: scanoss.com)')
+        .option('-p, --grpc-port <port>', 'SCANOSS GRPC PORT  (optional - default: 443)')
+        .action((source, options) => { depHandler(source, options).catch((e) => { CLIErrorHandler(e); }); });
+    program
+        .command('wfp <source>')
+        .description('Generates fingerprints for a folder/file')
+        .option('-H, --hpsm', 'Scan using winnowing high precision matching')
+        .option('-o, --output <filename>', 'Output result file name (optional - default stdout)')
+        .option('-p, --block-size <size>', 'Maximum size in Kb for each fingerprint block (optional - default 64Kb)')
+        .action((source, options) => { wfpHandler(source, options).catch((e) => { CLIErrorHandler(e); }); });
+    await program.parseAsync(process.argv);
+}
+try {
+    main();
+}
+catch (e) {
+    console.error(e);
+    process.exit(1);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/src/cli/commands/dep.d.ts

@@ -0,0 +1 @@
+export declare function depHandler(rootPath: string, options: any): Promise<void>;

package/build/module/src/cli/commands/dep.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+import { DependencyScanner } from "../../sdk/Dependencies/DependencyScanner";
+import { DependencyScannerCfg } from "../../sdk/Dependencies/DependencyScannerCfg";
+import { Tree } from "../../sdk/tree/Tree";
+import { DependencyFilter } from '../../sdk/tree/Filters/DependencyFilter';
+import { isFolder } from "./helpers";
+export async function depHandler(rootPath, options) {
+    rootPath = rootPath.replace(/\/$/, ''); // Remove trailing slash if exists
+    rootPath = rootPath.replace(/^\./, process.env.PWD); // Convert relative path to absolute path.
+    const pathIsFolder = await isFolder(rootPath);
+    const dependencyScannerCfg = new DependencyScannerCfg();
+    if (options.grpcHost)
+        dependencyScannerCfg.DEFAULT_GRPC_HOST = options.grpcHost;
+    if (options.grpcPort)
+        dependencyScannerCfg.DEFAULT_GRPC_PORT = options.grpcPort;
+    const dependencyScanner = new DependencyScanner(dependencyScannerCfg);
+    let fileList = [];
+    fileList.push(rootPath);
+    if (pathIsFolder) {
+        const tree = new Tree(rootPath);
+        tree.build();
+        fileList = tree.getFileList(new DependencyFilter(""));
+    }
+    const results = await dependencyScanner.scan(fileList);
+    if (options.output) {
+        fs.promises.writeFile(options.output, JSON.stringify(results, null, 2));
+    }
+    else {
+        console.log(JSON.stringify(results, null, 2));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2NsaS9jb21tYW5kcy9kZXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3BCLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQzdFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBQ25GLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQztBQUMzRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBR3JDLE1BQU0sQ0FBQyxLQUFLLFVBQVUsVUFBVSxDQUFDLFFBQWdCLEVBQUUsT0FBWTtJQUU3RCxRQUFRLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBRSxrQ0FBa0M7SUFDM0UsUUFBUSxHQUFHLFFBQVEsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBRSwwQ0FBMEM7SUFDaEcsTUFBTSxZQUFZLEdBQUcsTUFBTSxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUMsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLG9CQUFvQixFQUFFLENBQUM7SUFDeEQsSUFBRyxPQUFPLENBQUMsUUFBUTtRQUFFLG9CQUFvQixDQUFDLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUM7SUFDL0UsSUFBRyxPQUFPLENBQUMsUUFBUTtRQUFFLG9CQUFvQixDQUFDLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUM7SUFFL0UsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGlCQUFpQixDQUFDLG9CQUFvQixDQUFDLENBQUM7SUFFdEUsSUFBSSxRQUFRLEdBQWtCLEVBQUUsQ0FBQztJQUNqQyxRQUFRLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBRXhCLElBQUksWUFBWSxFQUFFO1FBQ2hCLE1BQU0sSUFBSSxHQUFHLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ2hDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNiLFFBQVEsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksZ0JBQWdCLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztLQUN2RDtJQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0saUJBQWlCLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBRXZELElBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRTtRQUNqQixFQUFFLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQ3pFO1NBQU07UUFDTCxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0tBQy9DO0FBRUgsQ0FBQyJ9

package/build/module/src/cli/commands/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const isFolder: (path: string) => Promise<boolean>;
+export declare function getProjectNameFromPath(path: string): string;

package/build/module/src/cli/commands/helpers.js

@@ -0,0 +1,19 @@
+import pathLib from 'path';
+import fs from 'fs';
+// Async function that verify if a path is a folder. If the path is not valid the promise will be rejected
+export const isFolder = (path) => {
+    return new Promise((resolve, reject) => {
+        fs.stat(path, (err, stats) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(stats.isDirectory());
+            }
+        });
+    });
+};
+export function getProjectNameFromPath(path) {
+    return pathLib.basename(path, pathLib.extname(path));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jbGkvY29tbWFuZHMvaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE9BQU8sTUFBTSxNQUFNLENBQUM7QUFDM0IsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBRXBCLDBHQUEwRztBQUMxRyxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsQ0FBQyxJQUFZLEVBQW9CLEVBQUU7SUFDekQsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtRQUNyQyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRTtZQUMzQixJQUFJLEdBQUcsRUFBRTtnQkFDUCxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDYjtpQkFBTTtnQkFDTCxPQUFPLENBQUMsS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDLENBQUM7YUFDOUI7UUFDSCxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFBO0FBRUQsTUFBTSxVQUFVLHNCQUFzQixDQUFDLElBQVk7SUFDakQsT0FBTyxPQUFPLENBQUMsUUFBUSxDQUFDLElBQUksRUFBQyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7QUFDckQsQ0FBQyJ9

package/build/module/src/cli/commands/scan.d.ts

@@ -0,0 +1 @@
+export declare function scanHandler(rootPath: string, options: any): Promise<void>;

package/build/module/src/cli/commands/scan.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import { Scanner } from '../../sdk/scanner/Scanner';
+import { SbomMode, ScannerEvents, WinnowingMode } from '../../sdk/scanner/ScannerTypes';
+import { ScannerCfg } from '../../sdk/scanner/ScannerCfg';
+import { Tree } from '../../sdk/tree/Tree';
+import cliProgress from 'cli-progress';
+import { getProjectNameFromPath, isFolder } from './helpers';
+import { DependencyScannerCfg } from '../../sdk/Dependencies/DependencyScannerCfg';
+import { DependencyScanner } from '../../sdk/Dependencies/DependencyScanner';
+import { ScanFilter } from '../../sdk/tree/Filters/ScanFilter';
+import { DependencyFilter } from '../../sdk/tree/Filters/DependencyFilter';
+import { Report } from '../../sdk/Report/Report';
+import { DataProviderManager } from '../../sdk/DataLayer/DataProviderManager';
+import { ComponentDataProvider } from '../../sdk/DataLayer/DataProviders/ComponentDataProvider';
+import { DependencyDataProvider } from '../../sdk/DataLayer/DataProviders/DependencyDataProvider';
+import { LicenseDataProvider } from '../../sdk/DataLayer/DataProviders/LicenseDataProvider';
+import { SummaryDataProvider } from '../../sdk/DataLayer/DataProviders/SummaryDataProvider';
+import { DecompressionFilter } from '../../sdk/tree/Filters/DecompressionFilter';
+import { DecompressionManager } from '../../sdk/Decompress/DecompressionManager';
+export async function scanHandler(rootPath, options) {
+    rootPath = rootPath.replace(/\/$/, ''); // Remove trailing slash if exists
+    rootPath = rootPath.replace(/^\./, process.env.PWD); // Convert relative path to absolute path.
+    const pathIsFolder = await isFolder(rootPath);
+    const projectName = getProjectNameFromPath(rootPath);
+    // Create dependency scanner and set parameters
+    const dependencyScannerCfg = new DependencyScannerCfg();
+    if (options.api2url)
+        dependencyScannerCfg.DEFAULT_GRPC_HOST = options.api2url;
+    const dependencyScanner = new DependencyScanner(dependencyScannerCfg);
+    let dependencyInput = [];
+    // Create scanner and set connections parameters
+    const scannerCfg = new ScannerCfg();
+    if (options.concurrency)
+        scannerCfg.CONCURRENCY_LIMIT = parseInt(options.concurrency);
+    if (options.postSize)
+        scannerCfg.WFP_FILE_MAX_SIZE = parseInt(options.postSize) * 1024;
+    if (options.apiurl)
+        scannerCfg.API_URL = options.apiurl;
+    if (options.key)
+        scannerCfg.API_KEY = options.key;
+    if (options.timeout)
+        scannerCfg.TIMEOUT = options.timeout * 1000;
+    if (options.maxRetry)
+        scannerCfg.MAX_RETRIES_FOR_RECOVERABLES_ERRORS = options.maxRetry;
+    if (options.proxy)
+        scannerCfg.PROXY = options.proxy;
+    if (options.caCert)
+        scannerCfg.CA_CERT = options.caCert;
+    if (options.ignoreCertErrors)
+        scannerCfg.IGNORE_CERT_ERRORS = true;
+    const scanner = new Scanner(scannerCfg);
+    let scannerInput = { fileList: [] };
+    scannerInput.folderRoot = rootPath + '/'; // This will remove the project root path from the results.
+    if (options.flags)
+        scannerInput.engineFlags = options.flags;
+    if (!options.wfp) {
+        if (pathIsFolder) {
+            console.error('Reading directory...  ');
+            const tree = new Tree(rootPath);
+            tree.build();
+            if (options.extract) {
+                const archives = tree.getFileList(new DecompressionFilter(""));
+                console.error("Searching archives files...");
+                if (archives.length) {
+                    console.error("Extracting archives...");
+                    const decompressionManager = new DecompressionManager(options.extractDeep, options.extractSuffix, options.extractOverwrite);
+                    await decompressionManager.decompress(archives);
+                    console.error("Reindexing files...");
+                    tree.build();
+                }
+                else
+                    console.error("No archives found.");
+            }
+            scannerInput.fileList = tree.getFileList(new ScanFilter(""));
+            dependencyInput = tree.getFileList(new DependencyFilter(""));
+        }
+        else {
+            scannerInput.fileList = [rootPath];
+            dependencyInput = [rootPath];
+        }
+    }
+    else {
+        const winnowing = fs.readFileSync(rootPath, { encoding: 'utf-8' });
+        scannerInput.fileList.length = [...winnowing.matchAll(/file=/g)].length;
+    }
+    if (!options.verbose) {
+        const optBar1 = { format: 'Scan Progress: [{bar}] {percentage}% | Scanned {value} files of {total}' };
+        const bar1 = new cliProgress.SingleBar(optBar1, cliProgress.Presets.shades_classic);
+        bar1.start(scannerInput.fileList.length, 0);
+        scanner.on(ScannerEvents.DISPATCHER_NEW_DATA, (dispResp) => {
+            bar1.increment(dispResp.getFilesScanned().length);
+        });
+        scanner.on(ScannerEvents.SCAN_DONE, async (resultPath) => { bar1.stop(); });
+    }
+    else {
+        scanner.on(ScannerEvents.SCANNER_LOG, (logText) => console.error(logText));
+    }
+    if (options.wfp)
+        scannerInput.wfpPath = rootPath;
+    if (options.hpsm)
+        scannerInput.winnowingMode = WinnowingMode.FULL_WINNOWING_HPSM;
+    if (options.ignore) {
+        scannerInput.sbom = fs.readFileSync(options.ignore, 'utf-8');
+        scannerInput.sbomMode = SbomMode.SBOM_IGNORE;
+    }
+    // Dependency scanner
+    let pDependencyScanner = Promise.resolve({});
+    if (options.dependencies) {
+        pDependencyScanner = dependencyScanner.scan(dependencyInput);
+    }
+    //Launch parallel scanners
+    const pScanner = scanner.scan([scannerInput]);
+    const [scannerResultPath, depResults] = await Promise.all([pScanner, pDependencyScanner]);
+    const scannerResults = JSON.parse(await fs.promises.readFile(scannerResultPath, 'utf-8'));
+    //TODO Unify results.json and dependency.json. What happens with result.json that includes dependencies?
+    const scannersResults = {
+        scanner: scannerResults,
+        ...(options.dependencies && { dependencies: depResults })
+    };
+    let scannerResultsString = JSON.stringify(scannersResults, null, 2);
+    if (options.format && options.format.toLowerCase() === "html") {
+        const dataProviderManager = new DataProviderManager();
+        dataProviderManager.addDataProvider(new ComponentDataProvider(scannersResults.scanner, scannersResults.dependencies));
+        dataProviderManager.addDataProvider(new DependencyDataProvider(scannersResults.dependencies));
+        dataProviderManager.addDataProvider(new LicenseDataProvider(scannersResults.scanner, scannersResults.dependencies));
+        dataProviderManager.addDataProvider(new SummaryDataProvider(projectName, new Date(), scannersResults.scanner));
+        const report = new Report(dataProviderManager);
+        scannerResultsString = await report.getHTML();
+    }
+    if (options.output)
+        await fs.promises.writeFile(options.output, scannerResultsString);
+    else
+        console.log(scannerResultsString);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../../../../src/cli/commands/scan.ts"],"names":[],"mappings":"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"}

package/build/module/src/cli/commands/wfp.d.ts

@@ -0,0 +1 @@
+export declare function wfpHandler(rootPath: string, options: any): Promise<void>;

package/build/module/src/cli/commands/wfp.js

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import cliProgress from 'cli-progress';
+import { isFolder } from './helpers';
+import { ScannerEvents, WinnowingMode } from '../../sdk/scanner/ScannerTypes';
+import { WfpCalculator } from '../../sdk/scanner/WfpProvider/WfpCalculator/WfpCalculator';
+import { Tree } from '../../sdk/tree/Tree';
+import { DependencyFilter } from '../../sdk/tree/Filters/DependencyFilter';
+export async function wfpHandler(rootPath, options) {
+    rootPath = rootPath.replace(/\/$/, ''); // Remove trailing slash if exists
+    rootPath = rootPath.replace(/^\./, process.env.PWD); // Convert relative path to absolute path.
+    const pathIsFolder = await isFolder(rootPath);
+    const wfpCalculator = new WfpCalculator();
+    let filesToFingerprint = [];
+    if (pathIsFolder) {
+        const tree = new Tree(rootPath);
+        tree.build();
+        filesToFingerprint = tree.getFileList(new DependencyFilter(""));
+    }
+    else {
+        filesToFingerprint.push(rootPath);
+    }
+    const optBar1 = { format: 'Fingerprinting Progress: [{bar}] {percentage}% | Fingerprinted {value} files of {total}' };
+    const bar1 = new cliProgress.SingleBar(optBar1, cliProgress.Presets.shades_classic);
+    bar1.start(filesToFingerprint.length, 0);
+    let fingerprints = '';
+    wfpCalculator.on(ScannerEvents.WINNOWING_NEW_CONTENT, (fingerprintPackage) => {
+        bar1.increment(fingerprintPackage.getNumberFilesFingerprinted());
+        fingerprints = fingerprints.concat(fingerprintPackage.getContent());
+    });
+    if (options.verbose)
+        wfpCalculator.on(ScannerEvents.WINNOWER_LOG, (log) => {
+            console.error(log);
+        });
+    wfpCalculator.on(ScannerEvents.WINNOWING_FINISHED, () => {
+        bar1.stop();
+        if (options.output) {
+            fs.writeFileSync(options.output, fingerprints);
+        }
+        else {
+            console.log(fingerprints);
+        }
+    });
+    const wfpInput = { fileList: filesToFingerprint, folderRoot: rootPath };
+    if (options.hpsm)
+        wfpInput.winnowingMode = WinnowingMode.FULL_WINNOWING_HPSM;
+    wfpCalculator.start(wfpInput);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from './sdk/scanner/Scanner';
+export * from './sdk/scanner/ScannerTypes';
+export * from './sdk/scanner/ScannerCfg';
+export * from './sdk/scanner/WfpProvider/WfpCalculator/WfpCalculator';
+export * from './sdk/Dependencies/DependencyTypes';
+export * from './sdk/Dependencies/DependencyScannerCfg';
+export * from './sdk/Dependencies/DependencyScanner';
+export * from './sdk/DataLayer/DataLayerTypes';
+export * from './sdk/DataLayer/DataProviderManager';
+export * from './sdk/DataLayer/DataProviders/LicenseDataProvider';
+export * from './sdk/DataLayer/DataProviders/SummaryDataProvider';
+export * from './sdk/DataLayer/DataProviders/DependencyDataProvider';
+export * from './sdk/DataLayer/DataProviders/ComponentDataProvider';
+export * from './sdk/Decompress/DecompressionManager';

package/build/module/src/index.js

@@ -0,0 +1,19 @@
+// *** Code scanner exports *** //
+export * from './sdk/scanner/Scanner';
+export * from './sdk/scanner/ScannerTypes';
+export * from './sdk/scanner/ScannerCfg';
+export * from './sdk/scanner/WfpProvider/WfpCalculator/WfpCalculator';
+// *** Dependency scanner exports *** //
+export * from './sdk/Dependencies/DependencyTypes';
+export * from './sdk/Dependencies/DependencyScannerCfg';
+export * from './sdk/Dependencies/DependencyScanner';
+// *** Data layers export *** //
+export * from './sdk/DataLayer/DataLayerTypes';
+export * from './sdk/DataLayer/DataProviderManager';
+export * from './sdk/DataLayer/DataProviders/LicenseDataProvider';
+export * from './sdk/DataLayer/DataProviders/SummaryDataProvider';
+export * from './sdk/DataLayer/DataProviders/DependencyDataProvider';
+export * from './sdk/DataLayer/DataProviders/ComponentDataProvider';
+// *** Unzip *** //
+export * from './sdk/Decompress/DecompressionManager';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0NBQWtDO0FBQ2xDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdURBQXVELENBQUM7QUFFdEUsd0NBQXdDO0FBQ3hDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLHNDQUFzQyxDQUFDO0FBR3JELGdDQUFnQztBQUNoQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxtREFBbUQsQ0FBQztBQUNsRSxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsc0RBQXNELENBQUM7QUFDckUsY0FBYyxxREFBcUQsQ0FBQztBQUVwRSxtQkFBbUI7QUFDbkIsY0FBYyx1Q0FBdUMsQ0FBQyJ9

package/build/module/src/sdk/DataLayer/DataLayerTypes.d.ts

@@ -0,0 +1,108 @@
+/*************  Component interface definition  *************/
+export interface ComponentDataLayer {
+    key: string;
+    purls: string[];
+    name: string;
+    vendor: string;
+    url: string;
+    health: Health;
+    versions: Version[];
+}
+export interface Version {
+    version: string;
+    licenses: string[];
+    copyrights: Copyright[];
+    cryptography: Cryptography[];
+    quality: Quality;
+}
+export interface Copyright {
+    name: string;
+    source: string;
+}
+export interface Cryptography {
+    algorithm: string;
+    strength: string;
+}
+export interface Quality {
+    scoreAvg: number;
+    count: number;
+    sum: number;
+}
+export interface Health {
+    creation_date: string;
+    issues: number;
+    last_push: string;
+    last_update: string;
+    watchers: number;
+    country: string;
+    stars: number;
+    forks: number;
+}
+/*************  Component interface definition  *************/
+/*************  Dependency interface definition  *************/
+export interface DependencyDataLayer {
+    file: string;
+    dependencies: Dependency[];
+}
+export interface License {
+    name: string;
+    spdxid: string;
+}
+export interface Dependency {
+    purl: string;
+    component: string;
+    version: string;
+    licenses: License[];
+}
+/*************  Dependency interface definition  *************/
+/*************  Vulnerability interface definition  *************/
+export interface Vulnerability {
+    id: string;
+    cve: string;
+    url: string;
+    summary: string;
+    severity: string;
+    published: string;
+    modified: string;
+    source: string;
+}
+export interface VulnerabilityDataLayer {
+    purl: string;
+    vulnerability: Vulnerability[];
+}
+/*************  Vulnerability interface definition  *************/
+/*************  License interface definition  *************/
+export interface LicenseDataLayer {
+    label: string;
+    value: number;
+    components: Array<LicenseComponent>;
+    incompatibleWith: Array<string>;
+    hasIncompatibles: Array<string>;
+    copyleft: boolean;
+}
+export interface LicenseComponent {
+    purl: string;
+    name: string;
+    versions: Array<string>;
+    url: string;
+    vendor: string;
+}
+/*************  License interface definition  *************/
+export interface SummaryDataLayer {
+    projectName: string;
+    timestamp: Date;
+    matchedFiles: number;
+    noMatchFiles: number;
+    totalFiles: number;
+}
+export interface IDataLayers {
+    licenses: LicenseDataLayer[];
+    component: ComponentDataLayer[];
+    dependencies: DependencyDataLayer[];
+    vulnerabilities: VulnerabilityDataLayer[];
+    summary: SummaryDataLayer;
+}
+export interface DataProvider {
+    getData(): IDataLayers;
+    getLayerName(): string;
+}

package/build/module/src/sdk/DataLayer/DataLayerTypes.js

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

package/build/module/src/sdk/DataLayer/DataProviderManager.d.ts

@@ -0,0 +1,7 @@
+import { DataProvider, IDataLayers } from './DataLayerTypes';
+export declare class DataProviderManager {
+    private dataLayersProviders;
+    constructor();
+    addDataProvider(l: DataProvider): void;
+    generateData(): IDataLayers;
+}

package/build/module/src/sdk/DataLayer/DataProviderManager.js

@@ -0,0 +1,21 @@
+export class DataProviderManager {
+    constructor() {
+        this.dataLayersProviders = [];
+    }
+    addDataProvider(l) {
+        this.dataLayersProviders.push(l);
+    }
+    generateData() {
+        let dataLayer = {
+            component: null,
+            dependencies: null,
+            vulnerabilities: null,
+            summary: null,
+            licenses: null
+        };
+        for (const layer of this.dataLayersProviders)
+            Object.assign(dataLayer, layer.getData());
+        return dataLayer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0YVByb3ZpZGVyTWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvRGF0YUxheWVyL0RhdGFQcm92aWRlck1hbmFnZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLG1CQUFtQjtJQUc5QjtRQUNFLElBQUksQ0FBQyxtQkFBbUIsR0FBRyxFQUFFLENBQUM7SUFDaEMsQ0FBQztJQUVNLGVBQWUsQ0FBQyxDQUFlO1FBQ3BDLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFDbEMsQ0FBQztJQUVNLFlBQVk7UUFFakIsSUFBSSxTQUFTLEdBQWdCO1lBQzNCLFNBQVMsRUFBRSxJQUFJO1lBQ2YsWUFBWSxFQUFFLElBQUk7WUFDbEIsZUFBZSxFQUFFLElBQUk7WUFDckIsT0FBTyxFQUFFLElBQUk7WUFDYixRQUFRLEVBQUUsSUFBSTtTQUNmLENBQUM7UUFFRixLQUFLLE1BQU0sS0FBSyxJQUFJLElBQUksQ0FBQyxtQkFBbUI7WUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUN4RixPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0NBQ0YifQ==

package/build/module/src/sdk/DataLayer/DataProviders/ComponentDataProvider.d.ts

@@ -0,0 +1,13 @@
+import { DataProvider, IDataLayers } from '../DataLayerTypes';
+import { ScannerResults } from '../../scanner/ScannerTypes';
+import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
+export declare class ComponentDataProvider implements DataProvider {
+    private scanRawResults;
+    private componentList;
+    private dependencies;
+    constructor(scanRawResults: ScannerResults, dependencies?: IDependencyResponse);
+    getLayerName(): string;
+    getData(): IDataLayers;
+    private parseComponentsFromDependencies;
+    private parseComponentsFromScanner;
+}