scanoss 0.9.3 → 0.10.1

package/build/module/sdk/Report/DataLayer/DataProviders/ComponentDataProvider.js

@@ -0,0 +1,170 @@
+export class ComponentDataProvider {
+    constructor(scanRawResults, dependencies) {
+        this.scanRawResults = scanRawResults;
+        this.dependencies = dependencies;
+    }
+    getLayerName() {
+        return this.constructor.name;
+    }
+    async getData() {
+        const componentLayer = { component: null };
+        if (!this.scanRawResults && !this.dependencies)
+            return componentLayer;
+        //Extract all components from scanRawResults, does not matter if there are duplicated
+        //And removes all no match results.
+        this.componentList = Object.values(this.scanRawResults).flat();
+        this.componentList = this.componentList.filter((component) => component.id !== 'none');
+        const scannerComponentLayer = this.parseComponentsFromScanner(this.componentList);
+        const dependenciesComponentLayer = this.parseComponentsFromDependencies(this.dependencies);
+        componentLayer.component = [
+            ...scannerComponentLayer,
+            ...dependenciesComponentLayer,
+        ].sort((itemA, itemB) => {
+            if (itemA.name < itemB.name)
+                return -1;
+            else if (itemA.name > itemB.name)
+                return 1;
+            return 0;
+        });
+        if (!componentLayer.component.length)
+            componentLayer.component = null;
+        return componentLayer;
+    }
+    parseComponentsFromDependencies(dependencies) {
+        const componentLayer = [];
+        if (!dependencies)
+            return componentLayer;
+        dependencies.filesList.forEach((file) => {
+            file.dependenciesList.forEach((dependency) => {
+                const newComponent = {};
+                newComponent.key = dependency.purl;
+                newComponent.purls = [dependency.purl];
+                newComponent.name = dependency.component;
+                newComponent.url = null;
+                newComponent.vendor = null;
+                newComponent.health = null;
+                newComponent.versions = [
+                    {
+                        version: dependency.version,
+                        licenses: dependency.licensesList.map((license) => license.spdxId),
+                        copyrights: null,
+                        cryptography: null,
+                        quality: null,
+                    },
+                ];
+                const existingComponent = componentLayer.find((component) => component.key === newComponent.key);
+                if (existingComponent) {
+                    const existingVersion = existingComponent.versions.find((version) => version.version === newComponent.versions[0].version);
+                    if (!existingVersion)
+                        existingComponent.versions.push({
+                            version: newComponent.versions[0].version,
+                            licenses: newComponent.versions[0].licenses,
+                            copyrights: newComponent.versions[0].copyrights,
+                            quality: null,
+                            cryptography: null,
+                        });
+                }
+                else {
+                    //Component does not exist, insert as it is.
+                    componentLayer.push(newComponent);
+                }
+            });
+        });
+        return componentLayer;
+    }
+    parseComponentsFromScanner(scanComponents) {
+        const componentLayer = [];
+        if (!scanComponents)
+            return componentLayer;
+        for (let i = 0; i < scanComponents.length; i++) {
+            try {
+                // qualityValue would have a number from 0 to 5 or undefined.
+                const qualityValue = Number(scanComponents[i]?.quality?.shift()?.score?.split('/').shift());
+                //Generates a new component
+                const newComponent = {
+                    key: scanComponents[i].purl[0],
+                    purls: scanComponents[i].purl,
+                    name: scanComponents[i].component,
+                    url: scanComponents[i].url,
+                    vendor: scanComponents[i].vendor,
+                    health: scanComponents[i].health,
+                    versions: [
+                        {
+                            version: scanComponents[i].version,
+                            licenses: scanComponents[i].licenses.map((license) => license.name),
+                            copyrights: scanComponents[i].copyrights,
+                            quality: { sum: 0, scoreAvg: 0, count: 0 },
+                            cryptography: scanComponents[i]?.cryptography,
+                        },
+                    ],
+                };
+                //Removes duplicated licenses
+                newComponent.versions[0].licenses = [
+                    ...new Set(newComponent.versions[0].licenses),
+                ];
+                if (qualityValue) {
+                    newComponent.versions[0].quality.count = 1;
+                    newComponent.versions[0].quality.sum = qualityValue;
+                    newComponent.versions[0].quality.scoreAvg = qualityValue;
+                }
+                //Merge new component in componentList
+                const componentTarget = componentLayer.find((component) => component.key === newComponent.key);
+                if (componentTarget) {
+                    const versionTarget = componentTarget.versions.find((item) => item.version === newComponent.versions[0].version);
+                    if (versionTarget) {
+                        //Insert licenses
+                        newComponent.versions[0].licenses.forEach((licence) => {
+                            if (!versionTarget.licenses.includes(licence))
+                                versionTarget.licenses.push(licence);
+                        });
+                        //Insert copyright
+                        newComponent.versions[0]?.copyrights?.forEach((newCopyright) => {
+                            if (versionTarget.copyrights.every((copyright) => newCopyright.name != copyright.name)) {
+                                versionTarget.copyrights.push(newCopyright);
+                            }
+                        });
+                        //Insert cryptography
+                        newComponent.versions[0]?.cryptography?.forEach((newCryptoAlgo) => {
+                            if (versionTarget.cryptography.every((cryptoAlgorithm) => cryptoAlgorithm.algorithm != newCryptoAlgo.algorithm)) {
+                                versionTarget.cryptography.push(newCryptoAlgo);
+                            }
+                        });
+                        //recalculate quality average in case we have a quality value
+                        if (qualityValue) {
+                            versionTarget.quality.count++;
+                            versionTarget.quality.sum += Number(qualityValue);
+                            versionTarget.quality.scoreAvg =
+                                versionTarget.quality.sum / versionTarget.quality.count;
+                        }
+                    }
+                    else {
+                        //newComponent version is not included in the component with same purl key
+                        componentTarget.versions = componentTarget.versions.concat(newComponent.versions);
+                    }
+                }
+                else
+                    componentLayer.push(newComponent);
+            }
+            catch (e) {
+                console.error(`Problem inserting new component building Component Data Layer - `, e);
+            }
+        }
+        //Replace [] for null in versions
+        for (let i = 0; i < componentLayer.length; i++) {
+            if (!componentLayer[i].health)
+                componentLayer[i].health = null;
+            componentLayer[i].versions.forEach((version) => {
+                if (version.copyrights?.length == 0)
+                    version.copyrights = null;
+                if (version.licenses?.length == 0)
+                    version.licenses = null;
+                if (version.cryptography?.length === 0)
+                    version.cryptography = null;
+                if (version.quality.count === 0)
+                    version.quality = null;
+            });
+        }
+        return componentLayer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ComponentDataProvider.js","sourceRoot":"","sources":["../../../../../../src/sdk/Report/DataLayer/DataProviders/ComponentDataProvider.ts"],"names":[],"mappings":"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"}

package/build/module/sdk/{DataLayer → Report/DataLayer}/DataProviders/DependencyDataProvider.d.ts

@@ -1,9 +1,9 @@
 import { DataProvider, IDataLayers, DependencyDataLayer } from '../DataLayerTypes';
-import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
+import { IDependencyResponse } from '../../../Dependencies/DependencyTypes';
 export declare class DependencyDataProvider implements DataProvider {
     private dependencies;
     constructor(dependencies: IDependencyResponse);
     getLayerName(): string;
-    getData(): IDataLayers;
+    getData(): Promise<IDataLayers>;
     parseDependencyData(dependencies: IDependencyResponse): DependencyDataLayer[];
 }

package/build/module/sdk/Report/DataLayer/DataProviders/DependencyDataProvider.js

@@ -0,0 +1,39 @@
+export class DependencyDataProvider {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    getLayerName() {
+        return this.constructor.name;
+    }
+    async getData() {
+        const dependencyLayer = { dependencies: null };
+        if (!this.dependencies)
+            return dependencyLayer;
+        const parsedDepLayer = this.parseDependencyData(this.dependencies);
+        dependencyLayer.dependencies = parsedDepLayer;
+        if (!dependencyLayer.dependencies.length)
+            dependencyLayer.dependencies = null;
+        return dependencyLayer;
+    }
+    parseDependencyData(dependencies) {
+        const dependencyLayer = [];
+        dependencies.filesList.forEach((file) => {
+            const newDependencies = [];
+            file.dependenciesList.forEach((dependency) => {
+                const newLicenses = [];
+                dependency.licensesList.forEach((license) => {
+                    newLicenses.push({ name: license.name, spdxid: license.spdxId });
+                });
+                newDependencies.push({
+                    purl: dependency.purl,
+                    licenses: newLicenses,
+                    version: dependency.version,
+                    component: dependency.component,
+                });
+            });
+            dependencyLayer.push({ file: file.file, dependencies: newDependencies });
+        });
+        return dependencyLayer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVwZW5kZW5jeURhdGFQcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvUmVwb3J0L0RhdGFMYXllci9EYXRhUHJvdmlkZXJzL0RlcGVuZGVuY3lEYXRhUHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsTUFBTSxPQUFPLHNCQUFzQjtJQUdqQyxZQUFZLFlBQWlDO1FBQzNDLElBQUksQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDO0lBQ25DLENBQUM7SUFFTSxZQUFZO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUM7SUFDL0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLE1BQU0sZUFBZSxHQUFnQixFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQztRQUM1RCxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVk7WUFBRSxPQUFPLGVBQWUsQ0FBQztRQUMvQyxNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ25FLGVBQWUsQ0FBQyxZQUFZLEdBQUcsY0FBYyxDQUFDO1FBQzlDLElBQUksQ0FBQyxlQUFlLENBQUMsWUFBWSxDQUFDLE1BQU07WUFDdEMsZUFBZSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFFdEMsT0FBTyxlQUFlLENBQUM7SUFDekIsQ0FBQztJQUVNLG1CQUFtQixDQUN4QixZQUFpQztRQUVqQyxNQUFNLGVBQWUsR0FBK0IsRUFBRSxDQUFDO1FBRXZELFlBQVksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDdEMsTUFBTSxlQUFlLEdBQXNCLEVBQUUsQ0FBQztZQUM5QyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUU7Z0JBQzNDLE1BQU0sV0FBVyxHQUFtQixFQUFFLENBQUM7Z0JBQ3ZDLFVBQVUsQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLEVBQUU7b0JBQzFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7Z0JBQ25FLENBQUMsQ0FBQyxDQUFDO2dCQUNILGVBQWUsQ0FBQyxJQUFJLENBQUM7b0JBQ25CLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSTtvQkFDckIsUUFBUSxFQUFFLFdBQVc7b0JBQ3JCLE9BQU8sRUFBRSxVQUFVLENBQUMsT0FBTztvQkFDM0IsU0FBUyxFQUFFLFVBQVUsQ0FBQyxTQUFTO2lCQUNoQyxDQUFDLENBQUM7WUFDTCxDQUFDLENBQUMsQ0FBQztZQUNILGVBQWUsQ0FBQyxJQUFJLENBQUMsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUUsZUFBZSxFQUFFLENBQUMsQ0FBQztRQUMzRSxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sZUFBZSxDQUFDO0lBQ3pCLENBQUM7Q0FDRiJ9

package/build/module/sdk/{DataLayer → Report/DataLayer}/DataProviders/LicenseDataProvider.d.ts

@@ -1,6 +1,6 @@
 import { DataProvider, IDataLayers } from '../DataLayerTypes';
-import { ScannerResults } from '../../scanner/ScannerTypes';
-import { IDependencyResponse } from '../../Dependencies/DependencyTypes';
+import { ScannerResults } from '../../../scanner/ScannerTypes';
+import { IDependencyResponse } from '../../../Dependencies/DependencyTypes';
 export declare class LicenseDataProvider implements DataProvider {
     private scanResults;
     private componentList;
@@ -9,10 +9,8 @@ export declare class LicenseDataProvider implements DataProvider {
     private licenseLayer;
     constructor(scanResults: ScannerResults, dependencies?: IDependencyResponse);
     getLayerName(): string;
-    getData(): IDataLayers;
+    getData(): Promise<IDataLayers>;
     private updateLicenseStorageFromComponentList;
     private updateLicenseStorageFromDependencies;
-    private updateIncompatibilities;
     private insertComponentIntoLicense;
-    private unknownLicensesToEnd;
 }

package/build/module/sdk/Report/DataLayer/DataProviders/LicenseDataProvider.js

@@ -0,0 +1,115 @@
+export class LicenseDataProvider {
+    constructor(scanResults, dependencies) {
+        this.scanResults = scanResults;
+        this.dependencies = dependencies;
+        //Maps a license name to its own data
+        this.licenseStorage = {};
+        this.licenseLayer = [];
+    }
+    getLayerName() {
+        return this.constructor.name;
+    }
+    async getData() {
+        this.componentList = Object.values(this.scanResults).flat();
+        this.componentList = this.componentList.filter((component) => component.id !== 'none');
+        if (this.componentList.length > 0)
+            this.updateLicenseStorageFromComponentList();
+        if (this.dependencies && this.dependencies.filesList.length > 0)
+            this.updateLicenseStorageFromDependencies();
+        this.licenseLayer = Object.values(this.licenseStorage);
+        this.licenseLayer.sort((itemA, itemB) => {
+            if (itemA.value > itemB.value)
+                return -1;
+            else if (itemA.value < itemB.value)
+                return 1;
+            return 0;
+        });
+        return { licenses: this.licenseLayer };
+    }
+    //Gets all license from the result of scan and stores in this.licenseStorage map
+    updateLicenseStorageFromComponentList() {
+        this.componentList.forEach((component) => {
+            component.licenses.forEach((license) => {
+                const newLicenseComponent = {};
+                newLicenseComponent.purl = component.purl[0];
+                newLicenseComponent.vendor = component.vendor;
+                newLicenseComponent.versions = [component.version];
+                newLicenseComponent.name = component.component;
+                newLicenseComponent.url = component.url;
+                const licenseExist = !!this.licenseStorage[license.name];
+                if (!licenseExist) {
+                    const newLicense = {};
+                    newLicense.value = 1;
+                    newLicense.label = license.name;
+                    newLicense.components = [newLicenseComponent];
+                    this.licenseStorage[license.name] = newLicense;
+                }
+                else {
+                    this.licenseStorage[license.name] = this.insertComponentIntoLicense(this.licenseStorage[license.name], newLicenseComponent);
+                }
+            });
+        });
+    }
+    //Gets all licenses from results of dependency analysis
+    updateLicenseStorageFromDependencies() {
+        this.dependencies.filesList.forEach((file) => {
+            file.dependenciesList.forEach((dependency) => {
+                dependency.licensesList.forEach((license) => {
+                    const newLicenseComponent = {};
+                    newLicenseComponent.purl = dependency.purl;
+                    newLicenseComponent.versions = [dependency.version];
+                    newLicenseComponent.name = dependency.component;
+                    newLicenseComponent.vendor = null;
+                    newLicenseComponent.url = null;
+                    if (license.spdxId !== '') {
+                        license.spdxId.split(/;|\//g).forEach((license_name) => {
+                            const licenseExist = !!this.licenseStorage[license_name];
+                            if (!licenseExist) {
+                                const newLicense = {};
+                                newLicense.value = 1;
+                                newLicense.label = license_name;
+                                newLicense.components = [newLicenseComponent];
+                                this.licenseStorage[license_name] = newLicense;
+                            }
+                            else {
+                                this.licenseStorage[license_name] =
+                                    this.insertComponentIntoLicense(this.licenseStorage[license_name], newLicenseComponent);
+                            }
+                        });
+                    }
+                    else {
+                        // Unknown license
+                        const licenseExist = !!this.licenseStorage['unknown'];
+                        if (!licenseExist) {
+                            const newLicense = {};
+                            newLicense.value = 1;
+                            newLicense.label = 'unknown';
+                            newLicense.components = [newLicenseComponent];
+                            this.licenseStorage['unknown'] = newLicense;
+                        }
+                        else {
+                            this.licenseStorage['unknown'] = this.insertComponentIntoLicense(this.licenseStorage['unknown'], newLicenseComponent);
+                        }
+                    }
+                });
+            });
+        });
+    }
+    insertComponentIntoLicense(license, newComponent) {
+        const componentIndex = license.components.findIndex((c) => c.purl === newComponent.purl);
+        if (componentIndex >= 0) {
+            //if newComponent exist in license
+            const versionExist = !!license.components[componentIndex].versions.find((version) => version === newComponent.versions[0]);
+            if (!versionExist) {
+                license.components[componentIndex].versions.push(newComponent.versions[0]);
+                license.value++;
+            }
+        }
+        else {
+            license.components.push(newComponent);
+            license.value++;
+        }
+        return license;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/sdk/Report/DataLayer/DataProviders/LicenseObligationDataProvider.d.ts

@@ -0,0 +1,13 @@
+import { DataProvider, IDataLayers } from '../DataLayerTypes';
+import { ScannerResults } from '../../../scanner/ScannerTypes';
+import { IDependencyResponse } from '../../../Dependencies/DependencyTypes';
+export declare class LicenseObligationDataProvider implements DataProvider {
+    private scanResults;
+    private dependencies;
+    private licenseLayer;
+    private componentList;
+    private licenseSet;
+    constructor(scanResults: ScannerResults, dependencies?: IDependencyResponse);
+    getLayerName(): string;
+    getData(): Promise<IDataLayers>;
+}

package/build/module/sdk/Report/DataLayer/DataProviders/LicenseObligationDataProvider.js

@@ -0,0 +1,60 @@
+export class LicenseObligationDataProvider {
+    constructor(scanResults, dependencies) {
+        this.scanResults = scanResults;
+        this.dependencies = dependencies;
+        //Maps a license name to its own data
+        this.licenseSet = {};
+        this.licenseLayer = [];
+    }
+    getLayerName() {
+        return 'License Obligation Layer';
+    }
+    async getData() {
+        /* Get licenses from Scan Results */
+        this.componentList = Object.values(this.scanResults).flat();
+        this.componentList = this.componentList.filter((component) => component.id !== 'none');
+        if (this.componentList.length > 0) {
+            this.componentList.forEach((component) => {
+                component.licenses.forEach((license) => {
+                    if (!this.licenseSet[license.name]) {
+                        this.licenseSet[license.name] = {
+                            copyleft: license.copyleft?.toLowerCase() === 'yes' ? true : false,
+                            label: license.name,
+                            hasIncompatibles: [],
+                            incompatibleWith: license.incompatible_with
+                                ? license.incompatible_with.split('')
+                                : [],
+                        };
+                    }
+                });
+            });
+        }
+        /* Get licenses from Dependencies Results */
+        if (this.dependencies && this.dependencies.filesList.length > 0) {
+            this.dependencies.filesList.forEach((file) => {
+                file.dependenciesList.forEach((dependency) => {
+                    dependency.licensesList.forEach((license) => {
+                        license.spdxId?.split(/;|\//g).forEach((spdxid) => {
+                            if (spdxid !== '' && !this.licenseSet[spdxid]) {
+                                this.licenseSet[spdxid] = {
+                                    copyleft: false,
+                                    label: spdxid,
+                                    hasIncompatibles: [],
+                                    incompatibleWith: [],
+                                };
+                            }
+                        });
+                    });
+                });
+            });
+        }
+        const allSpdxid = Object.keys(this.licenseSet);
+        const allLicenses = Object.values(this.licenseSet);
+        const licensesObligations = allLicenses.map((l) => {
+            l.incompatibleWith = l.incompatibleWith.filter((spdxid) => allSpdxid.includes(spdxid));
+            return l;
+        });
+        return { licensesObligations };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/{main/sdk → module/sdk/Report}/DataLayer/DataProviders/SummaryDataProvider.d.ts

@@ -1,11 +1,13 @@
 import { DataProvider, IDataLayers } from '../DataLayerTypes';
-import { ScannerResults } from '../../scanner/ScannerTypes';
+import { ScannerResults } from '../../../scanner/ScannerTypes';
 export declare class SummaryDataProvider implements DataProvider {
     private scannerResults;
     private summary;
     private projectName;
     private projectCreateAt;
+    private reportTitle;
     constructor(projectName: string, projectCreatedAt: Date, scannerResults: ScannerResults);
     getLayerName(): string;
-    getData(): IDataLayers;
+    getData(): Promise<IDataLayers>;
+    getReportTitle(): string;
 }

package/build/module/sdk/Report/DataLayer/DataProviders/SummaryDataProvider.js

@@ -0,0 +1,35 @@
+import { ScannerComponentId, } from '../../../scanner/ScannerTypes';
+export class SummaryDataProvider {
+    constructor(projectName, projectCreatedAt, scannerResults) {
+        this.reportTitle = 'Detected Report';
+        this.scannerResults = scannerResults;
+        this.projectName = projectName;
+        this.projectCreateAt = projectCreatedAt;
+        this.summary = {};
+    }
+    getLayerName() {
+        return this.constructor.name;
+    }
+    async getData() {
+        this.summary.projectName = this.projectName;
+        this.summary.timestamp = this.projectCreateAt;
+        this.summary.totalFiles = 0;
+        this.summary.noMatchFiles = 0;
+        this.summary.matchedFiles = 0;
+        this.summary.reportTitle = this.getReportTitle();
+        for (const [file, components] of Object.entries(this.scannerResults)) {
+            components.forEach((component) => {
+                if (component.id == ScannerComponentId.NONE)
+                    this.summary.noMatchFiles++;
+                else
+                    this.summary.matchedFiles++;
+                this.summary.totalFiles++;
+            });
+        }
+        return { summary: this.summary };
+    }
+    getReportTitle() {
+        return this.reportTitle;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3VtbWFyeURhdGFQcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9zZGsvUmVwb3J0L0RhdGFMYXllci9EYXRhUHJvdmlkZXJzL1N1bW1hcnlEYXRhUHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUVMLGtCQUFrQixHQUVuQixNQUFNLCtCQUErQixDQUFDO0FBRXZDLE1BQU0sT0FBTyxtQkFBbUI7SUFVOUIsWUFDRSxXQUFtQixFQUNuQixnQkFBc0IsRUFDdEIsY0FBOEI7UUFKeEIsZ0JBQVcsR0FBVyxpQkFBaUIsQ0FBQztRQU05QyxJQUFJLENBQUMsY0FBYyxHQUFHLGNBQWMsQ0FBQztRQUNyQyxJQUFJLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztRQUMvQixJQUFJLENBQUMsZUFBZSxHQUFHLGdCQUFnQixDQUFDO1FBQ3hDLElBQUksQ0FBQyxPQUFPLEdBQXFCLEVBQUUsQ0FBQztJQUN0QyxDQUFDO0lBRU0sWUFBWTtRQUNqQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDO0lBQy9CLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztRQUNsQixJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQzVDLElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUM7UUFDOUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEdBQUcsQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxHQUFHLENBQUMsQ0FBQztRQUM5QixJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUM7UUFDOUIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBRWpELEtBQUssTUFBTSxDQUFDLElBQUksRUFBRSxVQUFVLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsRUFBRTtZQUNwRSxVQUFVLENBQUMsT0FBTyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUU7Z0JBQy9CLElBQUksU0FBUyxDQUFDLEVBQUUsSUFBSSxrQkFBa0IsQ0FBQyxJQUFJO29CQUN6QyxJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDOztvQkFDekIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQztnQkFDakMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQUUsQ0FBQztZQUM1QixDQUFDLENBQUMsQ0FBQztTQUNKO1FBRUQsT0FBb0IsRUFBRSxPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ2hELENBQUM7SUFFTSxjQUFjO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQztJQUMxQixDQUFDO0NBQ0YifQ==

package/build/module/sdk/Report/Report.d.ts

@@ -1,8 +1,14 @@
-import { DataProviderManager } from '../../sdk/DataLayer/DataProviderManager';
+import { DataProviderManager } from './DataLayer/DataProviderManager';
 export declare class Report {
     private dataProviderManager;
     private dataLayer;
+    private report;
+    private templatePath;
+    private dataPlaceholder;
     constructor(dpm?: DataProviderManager);
     setDataProviderManager(dpm: DataProviderManager): void;
+    setTemplatePath(filePath: string): void;
+    getTemplatePath(): string;
     getHTML(): Promise<string>;
+    saveToFile(fsPath: string): Promise<void>;
 }

package/build/module/sdk/Report/Report.js

@@ -1,20 +1,33 @@
 import fs from 'fs';
 import path from 'path';
-import { DataProviderManager } from '../../sdk/DataLayer/DataProviderManager';
-const reportDefaultPath = path.join(__dirname, "../../../../assets/ReportHTMLTemplate/index.html");
+import { DataProviderManager } from './DataLayer/DataProviderManager';
 export class Report {
     constructor(dpm = new DataProviderManager()) {
+        this.templatePath = path.join(__dirname, '../../../../assets/ReportHTMLTemplate/index.html');
+        this.dataPlaceholder = '#DATA';
         this.dataProviderManager = dpm;
     }
     setDataProviderManager(dpm) {
         this.dataProviderManager = dpm;
     }
+    setTemplatePath(filePath) {
+        this.templatePath = filePath;
+    }
+    getTemplatePath() {
+        return this.templatePath;
+    }
     async getHTML() {
-        this.dataLayer = this.dataProviderManager.generateData();
-        const html = (await fs.promises.readFile(reportDefaultPath, 'utf-8'));
+        this.dataLayer = await this.dataProviderManager.generateData();
+        const html = await fs.promises.readFile(this.getTemplatePath(), 'utf-8');
         if (!html)
             throw new Error('Invalid template path');
-        return html.replace('#DATA', JSON.stringify(this.dataLayer));
+        if (!html.includes(this.dataPlaceholder))
+            throw new Error(`Placeholder ${this.dataPlaceholder} not found, cannot insert the data`);
+        this.report = html.replace(this.dataPlaceholder, JSON.stringify(this.dataLayer).replace(/\\\"/g, '\\\\u0022'));
+        return this.report;
+    }
+    async saveToFile(fsPath) {
+        return await fs.promises.writeFile(fsPath, this.report, 'utf-8');
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Nkay9SZXBvcnQvUmVwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQixPQUFPLElBQUksTUFBTSxNQUFNLENBQUM7QUFDeEIsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFJOUUsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBQyxrREFBa0QsQ0FBQyxDQUFDO0FBRWxHLE1BQU0sT0FBTyxNQUFNO0lBTWpCLFlBQVksTUFBMkIsSUFBSSxtQkFBbUIsRUFBRTtRQUM5RCxJQUFJLENBQUMsbUJBQW1CLEdBQUcsR0FBRyxDQUFDO0lBQ2pDLENBQUM7SUFFTSxzQkFBc0IsQ0FBQyxHQUF3QjtRQUNwRCxJQUFJLENBQUMsbUJBQW1CLEdBQUcsR0FBRyxDQUFDO0lBQ2pDLENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTztRQUNsQixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUN6RCxNQUFNLElBQUksR0FBRyxDQUFDLE1BQU0sRUFBRSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsaUJBQWlCLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUN0RSxJQUFHLENBQUMsSUFBSTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLENBQUMsQ0FBQztRQUNuRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDOUQsQ0FBQztDQUVGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3Nkay9SZXBvcnQvUmVwb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLElBQUksQ0FBQztBQUNwQixPQUFPLElBQUksTUFBTSxNQUFNLENBQUM7QUFDeEIsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFHdEUsTUFBTSxPQUFPLE1BQU07SUFhakIsWUFBWSxNQUEyQixJQUFJLG1CQUFtQixFQUFFO1FBTnhELGlCQUFZLEdBQVcsSUFBSSxDQUFDLElBQUksQ0FDdEMsU0FBUyxFQUNULGtEQUFrRCxDQUNuRCxDQUFDO1FBRU0sb0JBQWUsR0FBVyxPQUFPLENBQUM7UUFFeEMsSUFBSSxDQUFDLG1CQUFtQixHQUFHLEdBQUcsQ0FBQztJQUNqQyxDQUFDO0lBRU0sc0JBQXNCLENBQUMsR0FBd0I7UUFDcEQsSUFBSSxDQUFDLG1CQUFtQixHQUFHLEdBQUcsQ0FBQztJQUNqQyxDQUFDO0lBRU0sZUFBZSxDQUFDLFFBQWdCO1FBQ3JDLElBQUksQ0FBQyxZQUFZLEdBQUcsUUFBUSxDQUFDO0lBQy9CLENBQUM7SUFFTSxlQUFlO1FBQ3BCLE9BQU8sSUFBSSxDQUFDLFlBQVksQ0FBQztJQUMzQixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU87UUFDbEIsSUFBSSxDQUFDLFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUMvRCxNQUFNLElBQUksR0FBRyxNQUFNLEVBQUUsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxlQUFlLEVBQUUsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUN6RSxJQUFJLENBQUMsSUFBSTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsdUJBQXVCLENBQUMsQ0FBQztRQUNwRCxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDO1lBQ3RDLE1BQU0sSUFBSSxLQUFLLENBQ2IsZUFBZSxJQUFJLENBQUMsZUFBZSxvQ0FBb0MsQ0FDeEUsQ0FBQztRQUNKLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FDeEIsSUFBSSxDQUFDLGVBQWUsRUFDcEIsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUMsQ0FDN0QsQ0FBQztRQUVGLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztJQUNyQixDQUFDO0lBRU0sS0FBSyxDQUFDLFVBQVUsQ0FBQyxNQUFjO1FBQ3BDLE9BQU8sTUFBTSxFQUFFLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNuRSxDQUFDO0NBQ0YifQ==

package/build/module/sdk/Services/Grpc/BaseService.d.ts

@@ -0,0 +1,18 @@
+import * as grpc from '@grpc/grpc-js';
+import * as CommonMessages from './scanoss/api/common/v2/scanoss-common_pb';
+export interface PurlRequest extends CommonMessages.PurlRequest.AsObject {
+}
+export interface EchoRequest extends CommonMessages.EchoRequest.AsObject {
+}
+export declare class BaseService {
+    protected GRPC_ENDPOINT: string;
+    protected API_TOKEN: string;
+    protected IS_PREMIUM_SERVICE: boolean;
+    protected SERVICE_NAME: string;
+    protected handleResponse(response: {
+        status: CommonMessages.StatusResponse.AsObject;
+    }): {};
+    protected buildGRPCPurlRequest(purlRequest: PurlRequest): CommonMessages.PurlRequest;
+    protected buildGRPCEchoRequest(echoRequest: EchoRequest): CommonMessages.EchoRequest;
+    protected generateChannelCredentials(): grpc.ChannelCredentials;
+}