license-checker-plugin 1.0.0

package/dist/checker/BuiltInLicenseChecker.d.ts

@@ -0,0 +1,27 @@
+export interface LicenseCheckerOptions {
+    start: string;
+    excludePrivatePackages?: boolean;
+    customFormat?: Record<string, unknown>;
+}
+export interface PackageLicenseInfo {
+    name?: string;
+    version?: string;
+    licenses?: string | string[];
+    licenseFile?: string;
+    licenseText?: string;
+    repository?: string;
+    publisher?: string;
+    email?: string;
+    url?: string;
+    homepage?: string;
+    private?: boolean;
+    path?: string;
+    copyright?: string;
+}
+export declare function normalizeLicense(license: string): string;
+export declare function normalizeRepositoryUrl(repo: string): string;
+export declare function parseAuthor(author: string | object | undefined): {
+    name?: string;
+    email?: string;
+};
+export declare function builtInLicenseChecker(options: LicenseCheckerOptions): Promise<Record<string, PackageLicenseInfo>>;

package/dist/checker/BuiltInLicenseChecker.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLicense = normalizeLicense;
+exports.normalizeRepositoryUrl = normalizeRepositoryUrl;
+exports.parseAuthor = parseAuthor;
+exports.builtInLicenseChecker = builtInLicenseChecker;
+const promises_1 = require("fs/promises");
+const path = __importStar(require("path"));
+const spdx_expression_parse_1 = __importDefault(require("spdx-expression-parse"));
+const LICENSE_BASENAMES = [
+    /^LICENSE$/i,
+    /^LICENSE\-\w+$/i,
+    /^LICENCE$/i,
+    /^LICENCE\-\w+$/i,
+    /^MIT-LICENSE$/i,
+    /^COPYING$/i,
+    /^COPYRIGHT$/i,
+];
+const LICENSE_PATTERNS = [
+    [/permission is hereby granted, free of charge, to any person obtaining a copy of this software/i, 'MIT*'],
+    [/redistribution and use in source and binary forms, with or without modification, are permitted/i, 'BSD*'],
+    [/licensed under the apache license, version 2\.0/i, 'Apache-2.0*'],
+    [/apache license[\s\n]+version[\s\n]+2/i, 'Apache-2.0*'],
+    [/the isc license/i, 'ISC*'],
+    [/\bMIT\b/, 'MIT*'],
+    [/\bApache(?:\s+License)?\b/i, 'Apache*'],
+    [/\bBSD\b/, 'BSD*'],
+    [/\bISC\b/, 'ISC*'],
+    [/gnu general public license/i, 'GPL*'],
+    [/gnu lesser\/library general public license/i, 'LGPL*'],
+    [/cc0 1\.0 universal/i, 'CC0-1.0*'],
+    [/public domain/i, 'Public Domain'],
+    [/do what the f\*ck you want to public license/i, 'WTFPL*'],
+];
+const COPYRIGHT_PATTERNS = [
+    /©?\s*copyright\s+(?:\(c\)\s*)?(\d{4}(?:\s*-\s*\d{4})?)\s+([^\n\r]+)/gi,
+    /©\s*(\d{4}(?:\s*-\s*\d{4})?)\s+([^\n\r]+)/gi,
+];
+function normalizeLicense(license) {
+    try {
+        (0, spdx_expression_parse_1.default)(license);
+        return license;
+    }
+    catch {
+        return 'Custom';
+    }
+}
+function extractCopyright(content) {
+    const copyrightLines = [];
+    for (const pattern of COPYRIGHT_PATTERNS) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            let copyright = match[0];
+            copyright = copyright.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+            if (!copyrightLines.includes(copyright)) {
+                copyrightLines.push(copyright);
+            }
+        }
+        pattern.lastIndex = 0;
+    }
+    if (copyrightLines.length > 0) {
+        return copyrightLines[0];
+    }
+    return undefined;
+}
+async function findLicenseFile(packageDir) {
+    try {
+        const files = await (0, promises_1.readdir)(packageDir);
+        const candidates = [];
+        for (const file of files) {
+            const fullPath = path.join(packageDir, file);
+            try {
+                if (!(await (0, promises_1.stat)(fullPath)).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            for (let i = 0; i < LICENSE_BASENAMES.length; i++) {
+                if (LICENSE_BASENAMES[i].test(file)) {
+                    candidates.push({ file: fullPath, order: i });
+                    break;
+                }
+            }
+        }
+        candidates.sort((a, b) => a.order - b.order);
+        return candidates.length > 0 ? candidates[0].file : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function readPackageJson(packageJsonPath) {
+    try {
+        const content = await (0, promises_1.readFile)(packageJsonPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function getLicenseString(license) {
+    if (!license)
+        return undefined;
+    if (typeof license === 'string')
+        return license;
+    if (typeof license === 'object' && 'type' in license) {
+        return String(license.type);
+    }
+    return undefined;
+}
+function normalizeRepositoryUrl(repo) {
+    return repo
+        .replace(/^git\+https:\/\//, 'https://')
+        .replace(/^git:\/\//, 'https://')
+        .replace(/^git\+ssh:\/\/git@/, 'https://')
+        .replace(/^git\+ssh:\/\//, 'https://')
+        .replace(/\.git$/, '');
+}
+function getRepositoryUrl(repository) {
+    if (!repository)
+        return undefined;
+    if (typeof repository === 'string') {
+        let url = normalizeRepositoryUrl(repository);
+        const scpMatch = url.match(/^https:\/\/([^:/]+):(.+)$/);
+        if (scpMatch) {
+            url = `https://${scpMatch[1]}/${scpMatch[2]}`;
+        }
+        return url;
+    }
+    if (typeof repository === 'object' && 'url' in repository) {
+        return getRepositoryUrl(repository.url);
+    }
+    return undefined;
+}
+function parseAuthor(author) {
+    if (!author)
+        return {};
+    if (typeof author === 'string') {
+        const match = author.match(/^(.+?)(?:\s*<([^>]+)>)?$/);
+        if (match) {
+            return { name: match[1].trim(), email: match[2] };
+        }
+        return { name: author };
+    }
+    if (typeof author === 'object' && 'name' in author) {
+        const a = author;
+        return { name: a.name, email: a.email };
+    }
+    return {};
+}
+async function findPackages(startPath) {
+    const packages = [];
+    const nodeModulesPath = path.join(startPath, 'node_modules');
+    try {
+        await (0, promises_1.stat)(nodeModulesPath);
+    }
+    catch {
+        return packages;
+    }
+    try {
+        const entries = await (0, promises_1.readdir)(nodeModulesPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.name.startsWith('@')) {
+                const scopeDir = path.join(nodeModulesPath, entry.name);
+                try {
+                    const scopeEntries = await (0, promises_1.readdir)(scopeDir, { withFileTypes: true });
+                    for (const scopeEntry of scopeEntries) {
+                        if (!scopeEntry.isDirectory())
+                            continue;
+                        const pkgPath = path.join(scopeDir, scopeEntry.name);
+                        try {
+                            await (0, promises_1.stat)(path.join(pkgPath, 'package.json'));
+                            packages.push(pkgPath);
+                        }
+                        catch {
+                            // Skip packages without package.json
+                        }
+                    }
+                }
+                catch {
+                    // Ignore errors
+                }
+            }
+            else {
+                const pkgPath = path.join(nodeModulesPath, entry.name);
+                try {
+                    await (0, promises_1.stat)(path.join(pkgPath, 'package.json'));
+                    packages.push(pkgPath);
+                }
+                catch {
+                    // Skip packages without package.json
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return packages;
+}
+async function processPackage(packagePath, options) {
+    const packageJson = await readPackageJson(path.join(packagePath, 'package.json'));
+    if (!packageJson)
+        return null;
+    if (options.excludePrivatePackages && packageJson.private === true) {
+        return null;
+    }
+    let licenses;
+    if (packageJson.license) {
+        licenses = getLicenseString(packageJson.license);
+    }
+    else if (packageJson.licenses) {
+        if (Array.isArray(packageJson.licenses)) {
+            licenses = packageJson.licenses.map((l) => getLicenseString(l) || 'UNKNOWN').filter(Boolean);
+        }
+        else {
+            licenses = getLicenseString(packageJson.licenses);
+        }
+    }
+    const licenseFile = await findLicenseFile(packagePath);
+    let licenseText;
+    let copyright;
+    if (licenseFile && options.customFormat?.licenseText) {
+        try {
+            licenseText = await (0, promises_1.readFile)(licenseFile, 'utf-8');
+            copyright = extractCopyright(licenseText);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
+    const authorInfo = parseAuthor(packageJson.author);
+    const name = packageJson.name || path.basename(packagePath);
+    const version = packageJson.version || '0.0.0';
+    return [
+        `${name}@${version}`,
+        {
+            name,
+            version,
+            licenses,
+            licenseFile: licenseFile || undefined,
+            licenseText,
+            copyright,
+            repository: getRepositoryUrl(packageJson.repository),
+            publisher: authorInfo.name,
+            email: authorInfo.email,
+            url: packageJson.homepage,
+            private: packageJson.private === true,
+            path: packagePath,
+        },
+    ];
+}
+async function builtInLicenseChecker(options) {
+    const startPath = path.resolve(options.start);
+    try {
+        await (0, promises_1.stat)(startPath);
+    }
+    catch {
+        throw new Error(`Path does not exist: ${startPath}`);
+    }
+    const packagePaths = await findPackages(startPath);
+    const results = await Promise.all(packagePaths.map((pkgPath) => processPackage(pkgPath, options)));
+    const packages = {};
+    for (const result of results) {
+        if (result) {
+            packages[result[0]] = result[1];
+        }
+    }
+    return packages;
+}

package/dist/checker/LicenseCache.d.ts

@@ -0,0 +1,9 @@
+import { LicenseInfo } from '../model/LicenseInfo';
+export declare class LicenseCache {
+    private readonly cache;
+    set(packageKey: string, info: LicenseInfo): void;
+    get(packageKey: string): LicenseInfo | undefined;
+    has(packageKey: string): boolean;
+    getAll(): Map<string, LicenseInfo>;
+    clear(): void;
+}

package/dist/checker/LicenseCache.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseCache = void 0;
+class LicenseCache {
+    cache = new Map();
+    set(packageKey, info) {
+        this.cache.set(packageKey, info);
+    }
+    get(packageKey) {
+        return this.cache.get(packageKey);
+    }
+    has(packageKey) {
+        return this.cache.has(packageKey);
+    }
+    getAll() {
+        return new Map(this.cache);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+exports.LicenseCache = LicenseCache;

package/dist/checker/LicenseDatabase.d.ts

@@ -0,0 +1,8 @@
+import { LicenseInfo } from '../model/LicenseInfo';
+export declare class LicenseDatabase {
+    private readonly cache;
+    private initialized;
+    private initializedPath;
+    initialize(startPath: string): Promise<void>;
+    getLicense(packageName: string, packageVersion: string): LicenseInfo;
+}

package/dist/checker/LicenseDatabase.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseDatabase = void 0;
+const BuiltInLicenseChecker_1 = require("./BuiltInLicenseChecker");
+const LicenseCache_1 = require("./LicenseCache");
+class LicenseDatabase {
+    cache = new LicenseCache_1.LicenseCache();
+    initialized = false;
+    initializedPath = null;
+    async initialize(startPath) {
+        if (this.initialized && this.initializedPath === startPath) {
+            return;
+        }
+        this.cache.clear();
+        this.initialized = false;
+        const packages = await (0, BuiltInLicenseChecker_1.builtInLicenseChecker)({
+            start: startPath,
+            excludePrivatePackages: false,
+            customFormat: {
+                licenseText: true,
+            },
+        });
+        for (const [key, info] of Object.entries(packages ?? {})) {
+            let licenseStr = 'UNKNOWN';
+            if (info.licenses) {
+                if (Array.isArray(info.licenses)) {
+                    const joined = info.licenses.join(' AND ');
+                    licenseStr = (0, BuiltInLicenseChecker_1.normalizeLicense)(joined);
+                }
+                else {
+                    licenseStr = info.licenses;
+                    if (licenseStr !== 'UNKNOWN') {
+                        licenseStr = (0, BuiltInLicenseChecker_1.normalizeLicense)(licenseStr);
+                    }
+                }
+            }
+            const licenseText = typeof info.licenseText === 'string' && info.licenseText.length > 0 ? info.licenseText : undefined;
+            const licenseInfo = {
+                license: licenseStr,
+                licenseFile: info.licenseFile,
+                licenseText,
+            };
+            this.cache.set(key, licenseInfo);
+        }
+        this.initialized = true;
+        this.initializedPath = startPath;
+    }
+    getLicense(packageName, packageVersion) {
+        return this.cache.get(`${packageName}@${packageVersion}`) || { license: 'UNKNOWN' };
+    }
+}
+exports.LicenseDatabase = LicenseDatabase;

package/dist/formatter/Formatter.d.ts

@@ -0,0 +1,4 @@
+import { OutputItem } from '../model/LicenseInfo';
+export interface Formatter {
+    generate(items: OutputItem[]): string;
+}

package/dist/formatter/Formatter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/formatter/HtmlFormatter.d.ts

@@ -0,0 +1,6 @@
+import { OutputItem } from '../model/LicenseInfo';
+import { Formatter } from './Formatter';
+export declare class HtmlFormatter implements Formatter {
+    generate(items: OutputItem[]): string;
+    private escape;
+}

package/dist/formatter/HtmlFormatter.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlFormatter = void 0;
+class HtmlFormatter {
+    generate(items) {
+        const rows = items
+            .map((item) => {
+            const name = this.escape(item.package.name);
+            const version = this.escape(item.package.version);
+            const license = this.escape(item.license.license);
+            const licenseText = item.license.licenseText
+                ? `<details><summary>View License</summary><pre>${this.escape(item.license.licenseText)}</pre></details>`
+                : '';
+            return `  <tr>\n    <td>${name}</td>\n    <td>${version}</td>\n    <td>${license}</td>\n    <td>${licenseText}</td>\n  </tr>`;
+        })
+            .join('\n');
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Third Party Licenses</title>
+  <style>
+    body { font-family: sans-serif; margin: 2em; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
+    th { background: #f5f5f5; }
+    pre { white-space: pre-wrap; word-break: break-word; max-height: 200px; overflow-y: auto; }
+  </style>
+</head>
+<body>
+  <h1>Third Party Licenses</h1>
+  <table>
+    <thead>
+      <tr><th>Package</th><th>Version</th><th>License</th><th>License Text</th></tr>
+    </thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>
+</body>
+</html>
+`;
+    }
+    escape(str) {
+        return str
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+}
+exports.HtmlFormatter = HtmlFormatter;

package/dist/formatter/JsonFormatter.d.ts

@@ -0,0 +1,5 @@
+import { OutputItem } from '../model/LicenseInfo';
+import { Formatter } from './Formatter';
+export declare class JsonFormatter implements Formatter {
+    generate(items: OutputItem[]): string;
+}

package/dist/formatter/JsonFormatter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFormatter = void 0;
+class JsonFormatter {
+    generate(items) {
+        const result = items.map((item) => ({
+            name: item.package.name,
+            version: item.package.version,
+            license: item.license.license,
+            repository: item.package.repository,
+            homepage: item.package.homepage,
+            author: item.package.author,
+        }));
+        return JSON.stringify(result, null, 2);
+    }
+}
+exports.JsonFormatter = JsonFormatter;

package/dist/formatter/MarkdownFormatter.d.ts

@@ -0,0 +1,5 @@
+import { OutputItem } from '../model/LicenseInfo';
+import { Formatter } from './Formatter';
+export declare class MarkdownFormatter implements Formatter {
+    generate(items: OutputItem[]): string;
+}

package/dist/formatter/MarkdownFormatter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownFormatter = void 0;
+class MarkdownFormatter {
+    generate(items) {
+        const lines = [
+            '# Third Party Licenses',
+            '',
+            '| Package | Version | License |',
+            '|---------|---------|---------|',
+        ];
+        for (const item of items) {
+            lines.push(`| ${item.package.name} | ${item.package.version} | ${item.license.license} |`);
+        }
+        return `${lines.join('\n')}\n`;
+    }
+}
+exports.MarkdownFormatter = MarkdownFormatter;

package/dist/formatter/TxtFormatter.d.ts

@@ -0,0 +1,12 @@
+import { OutputItem } from '../model/LicenseInfo';
+import { Formatter } from './Formatter';
+export interface TxtFormatterOptions {
+    includeLicenseText?: boolean;
+}
+export declare class TxtFormatter implements Formatter {
+    private readonly options;
+    constructor(options?: TxtFormatterOptions);
+    generate(items: OutputItem[]): string;
+    private formatField;
+    private formatAuthor;
+}

package/dist/formatter/TxtFormatter.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxtFormatter = void 0;
+class TxtFormatter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    generate(items) {
+        const lines = ['# THIRD-PARTY LICENSES', ''];
+        const labelWidth = 'Package Name'.length;
+        items.forEach((item, index) => {
+            // Keep labels aligned to improve readability in plain text outputs and diffs.
+            lines.push(this.formatField('Package Name', item.package.name, labelWidth));
+            lines.push(this.formatField('Version', item.package.version, labelWidth));
+            lines.push(this.formatField('License', item.license.license, labelWidth));
+            if (item.package.repository) {
+                lines.push(this.formatField('Repository', item.package.repository, labelWidth));
+            }
+            if (item.package.author) {
+                lines.push(this.formatField('Author', this.formatAuthor(item.package.author), labelWidth));
+            }
+            if (this.options.includeLicenseText !== false && item.license.licenseText) {
+                lines.push('');
+                // Keep license bodies in a separate block because they are multi-line and don't fit label-value alignment.
+                lines.push('License Text:');
+                lines.push(item.license.licenseText);
+            }
+            if (index < items.length - 1) {
+                lines.push('');
+                lines.push('---');
+                lines.push('');
+            }
+        });
+        return `${lines.join('\n')}\n`;
+    }
+    formatField(label, value, width) {
+        return `${label.padEnd(width)} : ${value}`;
+    }
+    formatAuthor(author) {
+        const match = author.match(/^(.*)\s*<([^>]+)>$/);
+        if (!match)
+            return author.trim();
+        const name = match[1].trim();
+        const email = match[2].trim();
+        return name ? `${name} <a>${email}</a>` : `<a>${email}</a>`;
+    }
+}
+exports.TxtFormatter = TxtFormatter;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { LicenseWebpackPlugin } from './LicenseWebpackPlugin';
+export { LicensePluginCore } from './LicensePluginCore';
+export { viteLicensePlugin } from './ViteLicensePlugin';
+export { normalizeLicense } from './checker/BuiltInLicenseChecker';
+export type { LicensePluginOptions, OutputFormat, LicensePluginContext } from './LicensePluginCore';
+export type { LicenseWebpackPluginOptions, OutputFormat as WebpackOutputFormat } from './LicenseWebpackPlugin';
+export type { PackageInfo } from './model/PackageInfo';
+export type { LicenseInfo, OutputItem } from './model/LicenseInfo';
+export type { LicenseBuildReport } from './model/LicenseBuildReport';
+export type { Recorder } from './Recorder';
+export { DefaultRecorder } from './Recorder';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRecorder = exports.normalizeLicense = exports.viteLicensePlugin = exports.LicensePluginCore = exports.LicenseWebpackPlugin = void 0;
+var LicenseWebpackPlugin_1 = require("./LicenseWebpackPlugin");
+Object.defineProperty(exports, "LicenseWebpackPlugin", { enumerable: true, get: function () { return LicenseWebpackPlugin_1.LicenseWebpackPlugin; } });
+var LicensePluginCore_1 = require("./LicensePluginCore");
+Object.defineProperty(exports, "LicensePluginCore", { enumerable: true, get: function () { return LicensePluginCore_1.LicensePluginCore; } });
+var ViteLicensePlugin_1 = require("./ViteLicensePlugin");
+Object.defineProperty(exports, "viteLicensePlugin", { enumerable: true, get: function () { return ViteLicensePlugin_1.viteLicensePlugin; } });
+var BuiltInLicenseChecker_1 = require("./checker/BuiltInLicenseChecker");
+Object.defineProperty(exports, "normalizeLicense", { enumerable: true, get: function () { return BuiltInLicenseChecker_1.normalizeLicense; } });
+var Recorder_1 = require("./Recorder");
+Object.defineProperty(exports, "DefaultRecorder", { enumerable: true, get: function () { return Recorder_1.DefaultRecorder; } });

package/dist/model/LicenseBuildReport.d.ts

@@ -0,0 +1,4 @@
+import { OutputItem } from './LicenseInfo';
+export interface LicenseBuildReport {
+    items: OutputItem[];
+}

package/dist/model/LicenseBuildReport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/model/LicenseInfo.d.ts

@@ -0,0 +1,17 @@
+import { PackageInfo } from './PackageInfo';
+/** License metadata for a single package. */
+export interface LicenseInfo {
+    /** SPDX license identifier(s) joined by ` AND ` for multiple licenses. */
+    license: string;
+    /** Path to the license file on disk, if found. */
+    licenseFile?: string;
+    /** Full license text content, if available and requested. */
+    licenseText?: string;
+}
+/** A single entry in the final license report. */
+export interface OutputItem {
+    /** Package identity and metadata discovered by the bundler scanner. */
+    package: PackageInfo;
+    /** License information resolved from the package's `node_modules` entry. */
+    license: LicenseInfo;
+}