license-checker-plugin 1.0.2 → 1.0.3

package/dist/LicensePluginCore.d.ts

@@ -79,6 +79,9 @@ export declare class LicensePluginCore {
     }>;
     private resolveLicenseEntries;
     private checkCompliance;
+    private isAllowed;
+    private isFailed;
+    private parseSpdxIdentifiers;
     private buildOutputItems;
     private recordReport;
     private mergeReports;

package/dist/LicensePluginCore.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LicensePluginCore = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const spdx_expression_parse_1 = __importDefault(require("spdx-expression-parse"));
 const LicenseDatabase_1 = require("./checker/LicenseDatabase");
 const BuiltInLicenseChecker_1 = require("./checker/BuiltInLicenseChecker");
 const HtmlFormatter_1 = require("./formatter/HtmlFormatter");
@@ -47,12 +51,14 @@ class LicensePluginCore {
     async generateLicenseItems(packages, context) {
         const entries = this.resolveLicenseEntries(packages);
         const errors = this.checkCompliance(entries);
+        let items;
         if (errors.length > 0) {
             for (const err of errors)
                 context.reportError(err);
+            this.recordReport([]);
             return { items: [], errors };
         }
-        let items = this.buildOutputItems(entries);
+        items = this.buildOutputItems(entries);
         this.recordReport(items);
         if (this.options.recordOnly)
             return { items: [], errors: [] };
@@ -87,15 +93,61 @@ class LicensePluginCore {
     checkCompliance(entries) {
         const errors = [];
         for (const { info, licenseInfo } of entries) {
-            if (this.options.onlyAllow.length > 0 && !this.options.onlyAllow.includes(licenseInfo.license)) {
+            if (this.options.onlyAllow.length > 0 && !this.isAllowed(licenseInfo.license)) {
                 errors.push(`LicensePlugin: License "${licenseInfo.license}" for package "${info.name}@${info.version}" is not in the allowed list: ${this.options.onlyAllow.join(', ')}`);
             }
-            else if (this.options.failOn.length > 0 && this.options.failOn.includes(licenseInfo.license)) {
+            else if (this.options.failOn.length > 0 && this.isFailed(licenseInfo.license)) {
                 errors.push(`LicensePlugin: License "${licenseInfo.license}" for package "${info.name}@${info.version}" is in the fail list`);
             }
         }
         return errors;
     }
+    isAllowed(license) {
+        if (this.options.onlyAllow.includes(license))
+            return true;
+        const ids = this.parseSpdxIdentifiers(license);
+        if (!ids)
+            return false;
+        if (ids.conjunction === 'and')
+            return ids.identifiers.every((id) => this.options.onlyAllow.includes(id));
+        if (ids.conjunction === 'or')
+            return ids.identifiers.some((id) => this.options.onlyAllow.includes(id));
+        return false;
+    }
+    isFailed(license) {
+        if (this.options.failOn.includes(license))
+            return true;
+        const ids = this.parseSpdxIdentifiers(license);
+        if (!ids)
+            return false;
+        return ids.identifiers.some((id) => this.options.failOn.includes(id));
+    }
+    parseSpdxIdentifiers(license) {
+        try {
+            const node = (0, spdx_expression_parse_1.default)(license);
+            const identifiers = [];
+            let conjunction = null;
+            const walk = (n) => {
+                if ('license' in n) {
+                    identifiers.push(n.license);
+                }
+                else {
+                    const expr = n;
+                    if (!conjunction)
+                        conjunction = expr.conjunction;
+                    walk(expr.left);
+                    walk(expr.right);
+                }
+            };
+            walk(node);
+            if (!conjunction)
+                return null;
+            return { identifiers, conjunction };
+        }
+        catch {
+            return null;
+        }
+    }
     buildOutputItems(entries) {
         return entries.map(({ info, licenseInfo }) => ({
             package: {

package/dist/LicenseWebpackPlugin.js

@@ -34,8 +34,10 @@ class LicenseWebpackPlugin {
             reportWarning: (msg) => compilation.warnings.push(new Error(msg)),
         };
         const initialized = await this.core.initialize(startPath, context);
-        if (!initialized)
+        if (!initialized) {
+            this.core.options.recorder?.record({ items: [] });
             return;
+        }
         const scanner = new PackageScanner_1.PackageScanner();
         const packages = scanner.scan(compilation);
         const { items, errors } = await this.core.generateLicenseItems(packages, context);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "license-checker-plugin",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "A bundler-agnostic plugin to generate third-party license notices for bundled packages. Supports webpack 5, Rspack, and Vite.",
   "author": "Axetroy <axetroy.dev@gmail.com>",
   "repository": {