rsbuild-plugin-publint/dist/index.cjs

Run [publint](https://github.com/bluwy/publint) to lint npm packages after the build.

"use strict";
var __webpack_modules__ = {
    publint: function(module) {
        module.exports = import("publint");
    },
    "publint/utils": function(module) {
        module.exports = import("publint/utils");
    }
};
var __webpack_module_cache__ = {};
function __webpack_require__(moduleId) {
    var cachedModule = __webpack_module_cache__[moduleId];
    if (void 0 !== cachedModule) return cachedModule.exports;
    var module = __webpack_module_cache__[moduleId] = {
        exports: {}
    };
    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
    return module.exports;
}
(()=>{
    __webpack_require__.n = function(module) {
        var getter = module && module.__esModule ? function() {
            return module['default'];
        } : function() {
            return module;
        };
        __webpack_require__.d(getter, {
            a: getter
        });
        return getter;
    };
})();
(()=>{
    __webpack_require__.d = function(exports1, definition) {
        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
            enumerable: true,
            get: definition[key]
        });
    };
})();
(()=>{
    __webpack_require__.o = function(obj, prop) {
        return Object.prototype.hasOwnProperty.call(obj, prop);
    };
})();
(()=>{
    __webpack_require__.r = function(exports1) {
        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
(()=>{
    __webpack_require__.r(__webpack_exports__);
    __webpack_require__.d(__webpack_exports__, {
        pluginPublint: ()=>pluginPublint
    });
    const promises_namespaceObject = require("node:fs/promises");
    var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
    const external_node_path_namespaceObject = require("node:path");
    const core_namespaceObject = require("@rsbuild/core");
    const external_picocolors_namespaceObject = require("picocolors");
    var external_picocolors_default = /*#__PURE__*/ __webpack_require__.n(external_picocolors_namespaceObject);
    const pluginPublint = (options = {})=>({
            name: 'plugin-publint',
            setup (api) {
                const { enable = true, throwOn = 'error' } = options;
                if (!enable) return;
                api.onAfterBuild({
                    handler: async ({ isFirstCompile })=>{
                        if (!isFirstCompile) return;
                        const { publint } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "publint"));
                        const { formatMessage } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "publint/utils"));
                        const mergedOptions = {
                            pkgDir: api.context.rootPath,
                            ...options.publintOptions
                        };
                        const { messages } = await publint(mergedOptions);
                        const pkg = JSON.parse(await promises_default().readFile((0, external_node_path_namespaceObject.join)(mergedOptions.pkgDir, 'package.json'), 'utf8'));
                        const formatted = {
                            errors: [],
                            warnings: [],
                            suggestions: []
                        };
                        for (const message of messages)if ('error' === message.type) formatted.errors.push(formatMessage(message, pkg));
                        else if ('warning' === message.type) formatted.warnings.push(formatMessage(message, pkg));
                        else formatted.suggestions.push(formatMessage(message, pkg));
                        if (0 === formatted.errors.length && 0 === formatted.warnings.length && 0 === formatted.suggestions.length) core_namespaceObject.logger.info(external_picocolors_default().green('Publint passed.'));
                        if (formatted.errors.length > 0) {
                            core_namespaceObject.logger.error(external_picocolors_default().red(`Publint found ${external_picocolors_default().bold(formatted.errors.length)} errors:`));
                            for (const message of formatted.errors)if (message) core_namespaceObject.logger.error(message);
                            console.log();
                        }
                        if (formatted.warnings.length > 0) {
                            core_namespaceObject.logger.warn(external_picocolors_default().yellow(`Publint found ${external_picocolors_default().bold(formatted.warnings.length)} warnings:`));
                            for (const message of formatted.warnings)if (message) core_namespaceObject.logger.warn(message);
                            console.log();
                        }
                        if (formatted.suggestions.length > 0) {
                            core_namespaceObject.logger.info(external_picocolors_default().cyan(`Publint found ${external_picocolors_default().bold(formatted.suggestions.length)} suggestions:`));
                            for (const message of formatted.suggestions)if (message) core_namespaceObject.logger.info(message);
                        }
                        const shouldThrow = ()=>{
                            switch(throwOn){
                                case 'suggestion':
                                    return formatted.suggestions.length > 0 || formatted.warnings.length > 0 || formatted.errors.length > 0;
                                case 'warning':
                                    return formatted.warnings.length > 0 || formatted.errors.length > 0;
                                case 'error':
                                    return formatted.errors.length > 0;
                                case 'never':
                                    return false;
                            }
                        };
                        if (shouldThrow()) throw new Error('Publint failed!');
                    },
                    order: 'post'
                });
            }
        });
})();
var __webpack_export_target__ = exports;
for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
    value: true
});