license-checker-plugin 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Axetroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,239 @@
+# license-checker-plugin
+
+A bundler-agnostic plugin that generates third-party license notices for packages actually bundled into your final build. Supports **webpack 5**, **Rspack**, and **Vite**.
+
+## Features
+
+- Scans the bundler's module graph for used npm packages
+- Reads license metadata using the built-in license checker (zero external dependencies)
+- Emits TXT, JSON, Markdown, or HTML assets at build time
+- Supports compliance rules with `onlyAllow` and `failOn`
+- Filter by package name and/or license type
+- Deduplicates repeated license text
+- Works with webpack 5, Rspack, and Vite
+
+## Installation
+
+```bash
+npm install license-checker-plugin
+```
+
+For webpack/Rspack projects, ensure `webpack` is installed (peer dependency).
+For Vite projects, ensure `vite` is installed (peer dependency).
+
+## Usage
+
+### webpack / Rspack
+
+```js
+const { LicenseWebpackPlugin } = require('license-checker-plugin');
+
+module.exports = {
+  mode: 'production',
+  plugins: [
+    new LicenseWebpackPlugin({
+      filename: 'third-party-licenses.txt',
+      format: 'txt',
+      includeLicenseText: true,
+      onlyAllow: ['MIT', 'Apache-2.0', 'BSD-3-Clause'],
+    }),
+  ],
+};
+```
+
+### Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { viteLicensePlugin } from 'license-checker-plugin';
+
+export default defineConfig({
+  plugins: [
+    viteLicensePlugin({
+      filename: 'third-party-licenses.json',
+      format: 'json',
+      includeLicenseText: true,
+    }),
+  ],
+});
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `filename` | `string` | `licenses.txt` | Output asset name |
+| `format` | `'txt' \| 'json' \| 'markdown' \| 'html'` | `txt` | Output format |
+| `includeLicenseText` | `boolean` | `true` | Include license text when supported |
+| `includeRepository` | `boolean` | `true` | Include repository URLs |
+| `includeHomepage` | `boolean` | `true` | Include homepage URLs |
+| `includeAuthor` | `boolean` | `true` | Include author/publisher details |
+| `excludePackages` | `string[]` | `[]` | Exclude listed packages from output |
+| `onlyAllow` | `string[]` | `[]` | Fail build when a used license is not allowed |
+| `failOn` | `string[]` | `[]` | Fail build when a used license matches the list |
+| `cache` | `boolean` | `true` | Reuse the in-memory license database |
+| `workspaceRoot` | `string` | Bundler's root context | Root path for license scanning |
+| `recorder` | `Recorder` | — | External recorder shared across compiler instances (webpack only) |
+| `recordOnly` | `boolean` | `false` | Record findings without emitting (webpack multi-compiler only) |
+| `waitForRecorderCount` | `number` | — | Wait for N reports before emitting combined asset (webpack only) |
+
+> **Note:** `recorder`, `recordOnly`, and `waitForRecorderCount` are webpack-only options and are not available in the Vite plugin.
+
+## How it works
+
+The plugin uses a **two-phase** architecture:
+
+1. **Database phase**: Scans `node_modules` with the built-in license checker to build a comprehensive cache of all package license information.
+2. **Scan phase**: Inspects the bundler's module graph to find which packages are actually used in the final bundle.
+
+Only packages that appear in the bundler's output are included in the license asset. DevDependencies that are never imported will not appear.
+
+## Filtering dependencies by package or license
+
+The plugin starts with the set of dependency entries detected from the bundler's module graph, resolves license metadata for those entries, and then applies the configured filters. Package names and license names are matched with exact, case-sensitive string comparison.
+
+### Filter options
+
+- `excludePackages`: remove entries whose package name is listed.
+- `onlyAllow`: fail the build if a package license is not in the allowed list.
+- `failOn`: fail the build if a package license matches the list.
+
+### Evaluation order
+
+1. `excludePackages`
+2. `onlyAllow`
+3. `failOn`
+
+All bundled packages are included by default. `excludePackages` removes unwanted entries first, then `onlyAllow` and `failOn` enforce license policies — generating build errors and stopping output when violated.
+
+### Transitive dependency behavior
+
+`excludePackages` is entry-based. Excluding `foo` removes the `foo` entry itself, but it does not automatically remove every dependency that `foo` depends on.
+
+### Combined filter example
+
+```js
+new LicenseWebpackPlugin({
+  excludePackages: ['react-dom'],
+  onlyAllow: ['MIT'],
+  failOn: ['MIT-0'],
+});
+```
+
+With this configuration:
+
+- all bundled packages are included by default
+- `react-dom` is removed from output
+- it fails the build if any remaining package does not have an MIT license
+- it fails the build if any remaining package has an MIT-0 license
+
+## Output formats
+
+### TXT
+Human-readable notice file for app distribution.
+
+### JSON
+Machine-readable output for CI, audits, and internal tooling.
+
+### Markdown
+Useful for GitHub releases or repository documentation.
+
+### HTML
+Useful for Electron about pages and in-app license views.
+
+## Compliance examples
+
+```js
+new LicenseWebpackPlugin({
+  onlyAllow: ['MIT', 'Apache-2.0'],
+});
+
+new LicenseWebpackPlugin({
+  failOn: ['GPL-3.0', 'AGPL-3.0'],
+});
+```
+
+## Multi-compiler usage (webpack only)
+
+When using webpack's [multi-compiler](https://webpack.js.org/configuration/configuration-types/#exporting-multiple-configurations) mode (an array of configurations) each compiler runs independently. The `recorder` option lets all instances share a single `DefaultRecorder` so that one primary instance can merge all their findings and emit a single combined license file.
+
+```js
+const { LicenseWebpackPlugin, DefaultRecorder } = require('license-checker-plugin');
+
+const sharedRecorder = new DefaultRecorder();
+
+module.exports = [
+  {
+    name: 'renderer',
+    entry: './src/renderer/index.js',
+    plugins: [
+      new LicenseWebpackPlugin({
+        recorder: sharedRecorder,
+        recordOnly: true,
+      }),
+    ],
+  },
+  {
+    name: 'main',
+    entry: './src/main/index.js',
+    plugins: [
+      new LicenseWebpackPlugin({
+        filename: 'third-party-licenses.txt',
+        recorder: sharedRecorder,
+        waitForRecorderCount: 2,
+      }),
+    ],
+  },
+];
+```
+
+### `Recorder` interface
+
+```ts
+export interface Recorder {
+  record(report: LicenseBuildReport): void;
+  getReports(): LicenseBuildReport[];
+  waitForReports(expectedCount?: number, timeoutMs?: number): Promise<LicenseBuildReport[]>;
+}
+```
+
+`DefaultRecorder` is the built-in implementation. It stores reports in memory and resolves `waitForReports` as soon as the expected count is reached.
+
+## API
+
+### `LicenseWebpackPlugin`
+
+webpack/Rspack plugin (class, use with `new`).
+
+### `viteLicensePlugin(options)`
+
+Vite plugin (function, returns a plugin object).
+
+```ts
+import { viteLicensePlugin } from 'license-checker-plugin';
+```
+
+### `LicensePluginCore`
+
+Framework-agnostic core that can be used to build adapters for other bundlers.
+
+```ts
+import { LicensePluginCore } from 'license-checker-plugin';
+```
+
+### `DefaultRecorder`
+
+Built-in recorder implementation for multi-compiler scenarios.
+
+## Development
+
+```bash
+npm install
+npm run build
+npm test
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/LicensePluginCore.d.ts

@@ -0,0 +1,84 @@
+import { OutputItem } from './model/LicenseInfo';
+import { PackageInfo } from './model/PackageInfo';
+import { Recorder } from './Recorder';
+export type OutputFormat = 'txt' | 'json' | 'markdown' | 'html';
+export interface LicensePluginOptions {
+    /** Output file name (e.g. `licenses.txt`, `third-party-licenses.json`). */
+    filename?: string;
+    /** Output format. */
+    format?: OutputFormat;
+    /** Include the full license text in the output. */
+    includeLicenseText?: boolean;
+    /** Include the repository URL in each entry. */
+    includeRepository?: boolean;
+    /** Include the homepage URL in each entry. */
+    includeHomepage?: boolean;
+    /** Include the author/publisher in each entry. */
+    includeAuthor?: boolean;
+    /** Exclude specific packages from the output by name. */
+    excludePackages?: string[];
+    /**
+     * Allow only these licenses. When set, the build fails if any bundled
+     * package has a license not in this list.
+     */
+    onlyAllow?: string[];
+    /**
+     * Fail the build when a bundled package license matches this list.
+     * Evaluated after `onlyAllow`.
+     */
+    failOn?: string[];
+    /**
+     * Reuse the in-memory license database across multiple plugin instances
+     * (e.g. in multi-compiler setups). Set to `false` to force a fresh scan
+     * each time.
+     */
+    cache?: boolean;
+    /**
+     * Root path for scanning `node_modules`. Defaults to the bundler's root
+     * context (project root).
+     */
+    workspaceRoot?: string;
+    /**
+     * External recorder for sharing findings across compiler instances
+     * (webpack multi-compiler only).
+     * @see DefaultRecorder
+     */
+    recorder?: Recorder;
+    /**
+     * When `true`, only record findings via `recorder` without emitting a
+     * license asset. Use together with `recorder` and `waitForRecorderCount`
+     * (webpack multi-compiler only).
+     */
+    recordOnly?: boolean;
+    /**
+     * Wait for this many reports from the shared recorder before emitting
+     * the combined, deduplicated license asset.
+     * Requires `recorder` to be set (webpack multi-compiler only).
+     */
+    waitForRecorderCount?: number;
+}
+export interface LicensePluginContext {
+    reportError(msg: string): void;
+    reportWarning(msg: string): void;
+}
+export declare class LicensePluginCore {
+    readonly options: Required<Omit<LicensePluginOptions, 'recorder' | 'waitForRecorderCount'>> & {
+        recorder: Recorder | undefined;
+        waitForRecorderCount: number | undefined;
+    };
+    private db;
+    constructor(options?: LicensePluginOptions);
+    initialize(startPath: string, context: LicensePluginContext): Promise<boolean>;
+    generateLicenseItems(packages: Map<string, PackageInfo>, context: LicensePluginContext): Promise<{
+        items: OutputItem[];
+        errors: string[];
+    }>;
+    private resolveLicenseEntries;
+    private checkCompliance;
+    private buildOutputItems;
+    private recordReport;
+    private mergeReports;
+    format(items: OutputItem[]): string;
+    private filterLicenseFields;
+    private createFormatter;
+}

package/dist/LicensePluginCore.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicensePluginCore = void 0;
+const LicenseDatabase_1 = require("./checker/LicenseDatabase");
+const HtmlFormatter_1 = require("./formatter/HtmlFormatter");
+const JsonFormatter_1 = require("./formatter/JsonFormatter");
+const MarkdownFormatter_1 = require("./formatter/MarkdownFormatter");
+const TxtFormatter_1 = require("./formatter/TxtFormatter");
+class LicensePluginCore {
+    options;
+    db;
+    constructor(options = {}) {
+        this.options = {
+            filename: options.filename || 'licenses.txt',
+            format: options.format || 'txt',
+            includeLicenseText: options.includeLicenseText !== false,
+            includeRepository: options.includeRepository !== false,
+            includeHomepage: options.includeHomepage !== false,
+            includeAuthor: options.includeAuthor !== false,
+            excludePackages: options.excludePackages || [],
+            onlyAllow: options.onlyAllow || [],
+            failOn: options.failOn || [],
+            cache: options.cache !== false,
+            workspaceRoot: options.workspaceRoot || '',
+            recorder: options.recorder,
+            recordOnly: options.recordOnly === true,
+            waitForRecorderCount: options.waitForRecorderCount,
+        };
+        this.db = new LicenseDatabase_1.LicenseDatabase();
+    }
+    async initialize(startPath, context) {
+        if (!this.options.cache) {
+            this.db = new LicenseDatabase_1.LicenseDatabase();
+        }
+        try {
+            await this.db.initialize(startPath);
+            return true;
+        }
+        catch (error) {
+            context.reportError(`LicensePlugin: Failed to initialize license database: ${String(error)}`);
+            return false;
+        }
+    }
+    async generateLicenseItems(packages, context) {
+        const entries = this.resolveLicenseEntries(packages);
+        const errors = this.checkCompliance(entries);
+        if (errors.length > 0) {
+            for (const err of errors)
+                context.reportError(err);
+            return { items: [], errors };
+        }
+        let items = this.buildOutputItems(entries);
+        this.recordReport(items);
+        if (this.options.recordOnly)
+            return { items: [], errors: [] };
+        if (this.options.recorder && this.options.waitForRecorderCount !== undefined) {
+            try {
+                items = this.mergeReports(items, await this.options.recorder.waitForReports(this.options.waitForRecorderCount));
+            }
+            catch (error) {
+                context.reportError(String(error));
+                return { items: [], errors: [String(error)] };
+            }
+        }
+        items.sort((a, b) => a.package.name.localeCompare(b.package.name));
+        return { items, errors: [] };
+    }
+    resolveLicenseEntries(packages) {
+        const entries = [];
+        for (const pkgInfo of packages.values()) {
+            if (this.options.excludePackages.includes(pkgInfo.name))
+                continue;
+            entries.push({
+                info: pkgInfo,
+                licenseInfo: this.filterLicenseFields(this.db.getLicense(pkgInfo.name, pkgInfo.version)),
+            });
+        }
+        return entries;
+    }
+    checkCompliance(entries) {
+        const errors = [];
+        for (const { info, licenseInfo } of entries) {
+            if (this.options.onlyAllow.length > 0 && !this.options.onlyAllow.includes(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)) {
+                errors.push(`LicensePlugin: License "${licenseInfo.license}" for package "${info.name}@${info.version}" is in the fail list`);
+            }
+        }
+        return errors;
+    }
+    buildOutputItems(entries) {
+        return entries.map(({ info, licenseInfo }) => ({
+            package: {
+                ...info,
+                repository: this.options.includeRepository ? info.repository : undefined,
+                homepage: this.options.includeHomepage ? info.homepage : undefined,
+                author: this.options.includeAuthor ? info.author : undefined,
+            },
+            license: { ...licenseInfo },
+        }));
+    }
+    recordReport(items) {
+        if (this.options.recorder) {
+            this.options.recorder.record({ items });
+        }
+    }
+    mergeReports(items, allReports) {
+        const seen = new Set();
+        const merged = [];
+        for (const report of allReports) {
+            for (const item of report.items) {
+                const key = `${item.package.name}@${item.package.version}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    merged.push(item);
+                }
+            }
+        }
+        return merged;
+    }
+    format(items) {
+        return this.createFormatter().generate(items);
+    }
+    filterLicenseFields(licenseInfo) {
+        const result = { license: licenseInfo.license };
+        if (licenseInfo.licenseFile)
+            result.licenseFile = licenseInfo.licenseFile;
+        if (this.options.includeLicenseText && licenseInfo.licenseText) {
+            result.licenseText = licenseInfo.licenseText;
+        }
+        return result;
+    }
+    createFormatter() {
+        switch (this.options.format) {
+            case 'json':
+                return new JsonFormatter_1.JsonFormatter();
+            case 'markdown':
+                return new MarkdownFormatter_1.MarkdownFormatter();
+            case 'html':
+                return new HtmlFormatter_1.HtmlFormatter();
+            case 'txt':
+            default:
+                return new TxtFormatter_1.TxtFormatter({ includeLicenseText: this.options.includeLicenseText });
+        }
+    }
+}
+exports.LicensePluginCore = LicensePluginCore;

package/dist/LicenseWebpackPlugin.d.ts

@@ -0,0 +1,11 @@
+import type { Compiler, WebpackPluginInstance } from 'webpack';
+import type { LicensePluginOptions, OutputFormat } from './LicensePluginCore';
+export type { LicensePluginOptions, OutputFormat };
+/** @deprecated Use `LicensePluginOptions` instead. */
+export type LicenseWebpackPluginOptions = LicensePluginOptions;
+export declare class LicenseWebpackPlugin implements WebpackPluginInstance {
+    private readonly core;
+    constructor(options?: LicensePluginOptions);
+    apply(compiler: Compiler): void;
+    private generateLicenses;
+}

package/dist/LicenseWebpackPlugin.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseWebpackPlugin = void 0;
+const LicensePluginCore_1 = require("./LicensePluginCore");
+const PackageScanner_1 = require("./scanner/PackageScanner");
+const PLUGIN_NAME = 'LicenseWebpackPlugin';
+const DEFAULT_PROCESS_ASSETS_STAGE_REPORT = 5000;
+class LicenseWebpackPlugin {
+    core;
+    constructor(options = {}) {
+        this.core = new LicensePluginCore_1.LicensePluginCore(options);
+    }
+    apply(compiler) {
+        const wp = compiler.webpack;
+        const processAssetsStageReport = wp?.Compilation?.PROCESS_ASSETS_STAGE_REPORT ?? DEFAULT_PROCESS_ASSETS_STAGE_REPORT;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
+            compilation.hooks.processAssets.tapPromise({
+                name: PLUGIN_NAME,
+                stage: processAssetsStageReport,
+            }, async () => {
+                try {
+                    await this.generateLicenses(compiler, compilation, wp);
+                }
+                catch (error) {
+                    compilation.errors.push(error);
+                }
+            });
+        });
+    }
+    async generateLicenses(compiler, compilation, wp) {
+        const startPath = this.core.options.workspaceRoot || compiler.context;
+        const context = {
+            reportError: (msg) => compilation.errors.push(new Error(msg)),
+            reportWarning: (msg) => compilation.warnings.push(new Error(msg)),
+        };
+        const initialized = await this.core.initialize(startPath, context);
+        if (!initialized)
+            return;
+        const scanner = new PackageScanner_1.PackageScanner();
+        const packages = scanner.scan(compilation);
+        const { items, errors } = await this.core.generateLicenseItems(packages, context);
+        if (errors.length > 0)
+            return;
+        const sourcesApi = wp?.sources;
+        if (!sourcesApi) {
+            compilation.warnings.push(new Error('LicenseWebpackPlugin: bundler sources API not available on compiler.webpack; ' +
+                'license asset will not be emitted. Ensure you are using webpack 5 or Rspack.'));
+            return;
+        }
+        compilation.emitAsset(this.core.options.filename, new sourcesApi.RawSource(this.core.format(items)));
+    }
+}
+exports.LicenseWebpackPlugin = LicenseWebpackPlugin;

package/dist/Recorder.d.ts

@@ -0,0 +1,14 @@
+import { LicenseBuildReport } from './model/LicenseBuildReport';
+export interface Recorder {
+    record(report: LicenseBuildReport): void;
+    getReports(): LicenseBuildReport[];
+    waitForReports(expectedCount?: number, timeoutMs?: number): Promise<LicenseBuildReport[]>;
+}
+export declare class DefaultRecorder implements Recorder {
+    private reports;
+    private waiters;
+    record(report: LicenseBuildReport): void;
+    getReports(): LicenseBuildReport[];
+    waitForReports(expectedCount?: number, timeoutMs?: number): Promise<LicenseBuildReport[]>;
+    private flushWaiters;
+}

package/dist/Recorder.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRecorder = void 0;
+class DefaultRecorder {
+    reports = [];
+    waiters = [];
+    record(report) {
+        this.reports.push(report);
+        this.flushWaiters();
+    }
+    getReports() {
+        return [...this.reports];
+    }
+    waitForReports(expectedCount, timeoutMs = 30000) {
+        if (expectedCount === undefined || this.reports.length >= expectedCount) {
+            return Promise.resolve(this.getReports());
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.waiters = this.waiters.filter((w) => w !== waiter);
+                reject(new Error(`LicenseWebpackPlugin: waitForReports timed out after ${timeoutMs}ms. ` +
+                    `Expected ${expectedCount} reports but received ${this.reports.length}.`));
+            }, timeoutMs);
+            const waiter = { expectedCount, resolve, reject, timer };
+            this.waiters.push(waiter);
+        });
+    }
+    flushWaiters() {
+        const satisfied = [];
+        const remaining = [];
+        for (const waiter of this.waiters) {
+            if (this.reports.length >= waiter.expectedCount) {
+                satisfied.push(waiter);
+            }
+            else {
+                remaining.push(waiter);
+            }
+        }
+        this.waiters = remaining;
+        for (const waiter of satisfied) {
+            clearTimeout(waiter.timer);
+            waiter.resolve(this.getReports());
+        }
+    }
+}
+exports.DefaultRecorder = DefaultRecorder;

package/dist/ViteLicensePlugin.d.ts

@@ -0,0 +1,16 @@
+import type { LicensePluginOptions } from './LicensePluginCore';
+interface VitePlugin {
+    name: string;
+    enforce?: 'pre' | 'post';
+    buildStart?: () => void | Promise<void>;
+    transform?: (code: string, id: string) => string | null | undefined | void;
+    generateBundle?: (this: {
+        emitFile: (opts: {
+            type: string;
+            fileName: string;
+            source: string;
+        }) => void;
+    }, opts: unknown, bundle: unknown) => void | Promise<void>;
+}
+export declare function viteLicensePlugin(options?: LicensePluginOptions): VitePlugin;
+export {};

package/dist/ViteLicensePlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viteLicensePlugin = viteLicensePlugin;
+const LicensePluginCore_1 = require("./LicensePluginCore");
+const PackageResolver_1 = require("./scanner/PackageResolver");
+const PLUGIN_NAME = 'vite-license-plugin';
+function viteLicensePlugin(options = {}) {
+    const core = new LicensePluginCore_1.LicensePluginCore(options);
+    const resolver = new PackageResolver_1.PackageResolver();
+    const resolvedPackages = new Map();
+    return {
+        name: PLUGIN_NAME,
+        enforce: 'post',
+        async buildStart() {
+            const root = options.workspaceRoot || process.cwd();
+            const context = {
+                reportError: (msg) => { throw new Error(msg); },
+                reportWarning: (msg) => console.warn(`[${PLUGIN_NAME}] ${msg}`),
+            };
+            await core.initialize(root, context);
+        },
+        transform(_code, id) {
+            if (!id.includes('node_modules'))
+                return null;
+            const pkgInfo = resolver.resolve(id, 'main');
+            if (pkgInfo) {
+                const key = `${pkgInfo.name}@${pkgInfo.version}`;
+                if (!resolvedPackages.has(key)) {
+                    resolvedPackages.set(key, pkgInfo);
+                }
+            }
+            return null;
+        },
+        async generateBundle(_opts, _bundle) {
+            if (resolvedPackages.size === 0)
+                return;
+            const warnings = [];
+            const context = {
+                reportError: (msg) => { throw new Error(msg); },
+                reportWarning: (msg) => warnings.push(msg),
+            };
+            const { items } = await core.generateLicenseItems(resolvedPackages, context);
+            const source = core.format(items);
+            this.emitFile({
+                type: 'asset',
+                fileName: core.options.filename,
+                source,
+            });
+            for (const w of warnings) {
+                console.warn(`[${PLUGIN_NAME}] ${w}`);
+            }
+        },
+    };
+}