@lynx-js/rspeedy/dist/0~minify.plugin.js

A webpack/rspack-based frontend toolchain for Lynx

import { mergeRspeedyConfig, debug } from "./src_index_ts.js";
const MAIN_THREAD_JS_PATTERN = /.*main-thread(?:\.[A-Fa-f0-9]*)?\.js$/;
const BACKGROUND_JS_PATTERN = /.*background(?:\.[A-Fa-f0-9]*)?\.js$/;
function mergeJsOptions(baseOptions, threadOptions) {
    const merged = mergeRspeedyConfig({
        output: {
            minify: {
                jsOptions: baseOptions
            }
        }
    }, {
        output: {
            minify: {
                jsOptions: threadOptions
            }
        }
    });
    return merged.output?.minify?.jsOptions ?? {};
}
function pluginMinify(options) {
    const defaultJsOptions = Object.freeze({
        minimizerOptions: {
            compress: {
                negate_iife: false,
                join_vars: false,
                ecma: 2015,
                inline: 2,
                comparisons: false,
                toplevel: true,
                side_effects: false
            },
            format: {
                keep_quoted_props: true,
                comments: false
            },
            mangle: {
                toplevel: true
            }
        }
    });
    const defaultConfig = Object.freeze({
        output: {
            minify: {
                js: true,
                jsOptions: defaultJsOptions,
                css: true,
                cssOptions: {
                    minimizerOptions: {
                        targets: '',
                        include: {
                            nesting: true,
                            doublePositionGradients: true,
                            spaceSeparatedColorNotation: true
                        },
                        exclude: {
                            vendorPrefixes: true,
                            logicalProperties: true,
                            hexAlphaColors: true
                        }
                    }
                }
            }
        }
    });
    return {
        name: 'lynx:rsbuild:minify',
        setup (api) {
            api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
                if (false === options) {
                    debug("minification disabled");
                    return mergeRsbuildConfig(config, {
                        output: {
                            minify: false
                        }
                    });
                }
                const configs = [
                    config,
                    defaultConfig
                ];
                if (true !== options && void 0 !== options) {
                    debug("merging minification options");
                    configs.push({
                        output: {
                            minify: options
                        }
                    });
                }
                return mergeRsbuildConfig(...configs);
            });
            api.modifyBundlerChain((chain, { rspack, CHAIN_ID })=>{
                const currentConfig = api.getRsbuildConfig('normalized');
                const minify = currentConfig.output?.minify;
                if ('object' != typeof minify || null === minify || false === minify.js) return;
                if (void 0 === minify.mainThreadOptions && void 0 === minify.backgroundOptions) return;
                const jsOptions = minify.jsOptions ?? {};
                if (chain.optimization.minimizers.has(CHAIN_ID.MINIMIZER.JS)) chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).tap((args)=>{
                    const defaultOptions = args[0] ?? {};
                    const threadExclude = [
                        MAIN_THREAD_JS_PATTERN,
                        BACKGROUND_JS_PATTERN
                    ];
                    defaultOptions.exclude = defaultOptions.exclude ? Array.isArray(defaultOptions.exclude) ? [
                        ...defaultOptions.exclude,
                        ...threadExclude
                    ] : [
                        defaultOptions.exclude,
                        ...threadExclude
                    ] : threadExclude;
                    return [
                        defaultOptions
                    ];
                });
                const mainThreadOptions = mergeJsOptions(jsOptions, minify.mainThreadOptions);
                const mtInclude = [
                    MAIN_THREAD_JS_PATTERN
                ];
                mainThreadOptions.include = mainThreadOptions.include ? Array.isArray(mainThreadOptions.include) ? [
                    ...mainThreadOptions.include,
                    ...mtInclude
                ] : [
                    mainThreadOptions.include,
                    ...mtInclude
                ] : mtInclude;
                chain.optimization.minimizer('js-main-thread').use(rspack.SwcJsMinimizerRspackPlugin, [
                    mainThreadOptions
                ]).end();
                const backgroundOptions = mergeJsOptions(jsOptions, minify.backgroundOptions);
                const bgInclude = [
                    BACKGROUND_JS_PATTERN
                ];
                backgroundOptions.include = backgroundOptions.include ? Array.isArray(backgroundOptions.include) ? [
                    ...backgroundOptions.include,
                    ...bgInclude
                ] : [
                    backgroundOptions.include,
                    ...bgInclude
                ] : bgInclude;
                chain.optimization.minimizer('js-background').use(rspack.SwcJsMinimizerRspackPlugin, [
                    backgroundOptions
                ]).end();
            });
        }
    };
}
export { pluginMinify };