@lynx-js/rspeedy 0.11.2 → 0.11.4

package/dist/{src_plugins_api_plugin_ts.js → 1~src_plugins_api_plugin_ts.js}

@@ -4,7 +4,6 @@ export const __webpack_ids__ = [
 ];
 export const __webpack_modules__ = {
     "./src/plugins/api.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.r(__webpack_exports__);
         __webpack_require__.d(__webpack_exports__, {
             pluginAPI: ()=>pluginAPI
         });

package/dist/1~src_plugins_chunkLoading_plugin_ts.js

@@ -0,0 +1,23 @@
+import { LynxCacheEventsPlugin } from "@lynx-js/cache-events-webpack-plugin";
+import { ChunkLoadingWebpackPlugin } from "@lynx-js/chunk-loading-webpack-plugin";
+export const __webpack_id__ = "src_plugins_chunkLoading_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_chunkLoading_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/chunkLoading.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginChunkLoading: ()=>pluginChunkLoading
+        });
+        function pluginChunkLoading() {
+            return {
+                name: 'lynx:rsbuild:chunk-loading',
+                setup (api) {
+                    api.modifyBundlerChain((chain)=>{
+                        chain.plugin('lynx:chunk-loading').use(ChunkLoadingWebpackPlugin).end().plugin('lynx:cache-events').use(LynxCacheEventsPlugin).end().output.chunkLoading('lynx').chunkFormat('commonjs').end();
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_dev_plugin_ts.js

@@ -0,0 +1,149 @@
+import { createRequire } from "node:module";
+export const __webpack_id__ = "src_plugins_dev_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_dev_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/dev.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginDev: ()=>pluginDev
+        });
+        var external_node_path_ = __webpack_require__("node:path");
+        var core_ = __webpack_require__("@rsbuild/core");
+        var picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+        var debug = __webpack_require__("./src/debug.ts");
+        function isLynx(environment) {
+            return 'string' == typeof environment ? 'lynx' === environment : 'lynx' === environment.name;
+        }
+        class ProvidePlugin_ProvidePlugin {
+            definitions;
+            constructor(definitions){
+                this.definitions = definitions;
+            }
+            apply(compiler) {
+                const { ProvidePlugin } = compiler.webpack;
+                new ProvidePlugin(this.definitions).apply(compiler);
+            }
+        }
+        function pluginDev(options, server) {
+            return {
+                name: 'lynx:rsbuild:dev',
+                apply (config, { action }) {
+                    return 'dev' === action || 'development' === config.mode;
+                },
+                async setup (api) {
+                    const hostname = server?.host ?? await findIp('v4');
+                    let assetPrefix = options?.assetPrefix;
+                    switch(typeof assetPrefix){
+                        case 'string':
+                            if (server?.port !== void 0) {
+                                const hasPortPlaceholder = assetPrefix.includes('<port>');
+                                if (!hasPortPlaceholder) {
+                                    const assetPrefixURL = new URL(assetPrefix);
+                                    if (assetPrefixURL.port !== String(server.port)) {
+                                        core_.logger.warn(`Setting different port values in ${picocolors_default().cyan('server.port')} and ${picocolors_default().cyan('dev.assetPrefix')}. Using server.port(${picocolors_default().cyan(server.port)}) to make HMR work.`);
+                                        assetPrefixURL.port = String(server.port);
+                                        assetPrefix = assetPrefixURL.toString();
+                                    }
+                                }
+                            }
+                            break;
+                        case 'undefined':
+                        case 'boolean':
+                            if (options?.assetPrefix !== false) assetPrefix = `http://${hostname}:<port>/`;
+                            break;
+                    }
+                    if (server?.base) {
+                        if (assetPrefix.endsWith('/')) assetPrefix = assetPrefix.slice(0, -1);
+                        assetPrefix = `${assetPrefix}${server.base}/`;
+                    }
+                    (0, debug.Yz)(`dev.assetPrefix is normalized to ${assetPrefix}`);
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                            dev: {
+                                assetPrefix,
+                                client: {
+                                    host: hostname,
+                                    port: '<port>'
+                                }
+                            },
+                            output: {
+                                assetPrefix
+                            }
+                        }));
+                    const require = createRequire(import.meta.url);
+                    api.modifyBundlerChain((chain, { isDev, environment })=>{
+                        const { action } = api.context;
+                        if ('dev' !== action && !isDev) return;
+                        const rsbuildPath = require.resolve('@rsbuild/core');
+                        const rspeedyDir = external_node_path_["default"].dirname(require.resolve('@lynx-js/rspeedy/package.json'));
+                        const searchParams = new URLSearchParams({
+                            hostname,
+                            port: api.context.devServer?.port?.toString() ?? '',
+                            pathname: '/rsbuild-hmr',
+                            hot: options?.hmr ?? true ? 'true' : 'false',
+                            'live-reload': options?.liveReload ?? true ? 'true' : 'false',
+                            protocol: 'ws'
+                        });
+                        if (environment.webSocketToken) searchParams.set('token', environment.webSocketToken);
+                        chain.resolve.alias.set('webpack/hot/log.js', require.resolve('@rspack/core/hot/log', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).set('webpack/hot/emitter.js', require.resolve('@rspack/core/hot/emitter', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).set('@lynx-js/webpack-dev-transport/client', `${require.resolve('@lynx-js/webpack-dev-transport/client')}?${searchParams.toString()}`).set('@rspack/core/hot/dev-server', require.resolve('@rspack/core/hot/dev-server', {
+                            paths: [
+                                rsbuildPath
+                            ]
+                        })).end().end().plugin('lynx.hmr.provide.dev_server_client').use(ProvidePlugin_ProvidePlugin, [
+                            {
+                                __webpack_dev_server_client__: [
+                                    require.resolve('./client/hmr/WebSocketClient.js', {
+                                        paths: [
+                                            rspeedyDir
+                                        ]
+                                    }),
+                                    'default'
+                                ]
+                            }
+                        ]).end();
+                        if (isLynx(environment)) chain.plugin('lynx.hmr.provide.websocket').use(ProvidePlugin_ProvidePlugin, [
+                            {
+                                WebSocket: [
+                                    options?.client?.websocketTransport ?? require.resolve('@lynx-js/websocket'),
+                                    'default'
+                                ]
+                            }
+                        ]).end();
+                    });
+                }
+            };
+        }
+        async function findIp(family, isInternal = false) {
+            const [{ default: ipaddr }, os] = await Promise.all([
+                __webpack_require__.e("vendors-node_modules_pnpm_ipaddr_js_2_2_0_node_modules_ipaddr_js_lib_ipaddr_js").then(__webpack_require__.t.bind(__webpack_require__, "../../../node_modules/.pnpm/ipaddr.js@2.2.0/node_modules/ipaddr.js/lib/ipaddr.js", 23)),
+                import("node:os")
+            ]);
+            let host;
+            const networks = Object.values(os.networkInterfaces()).flatMap((networks)=>networks ?? []).filter((network)=>{
+                if (!network || !network.address) return false;
+                if (network.family !== `IP${family}`) return false;
+                if (network.internal !== isInternal) return false;
+                if ('v6' === family) {
+                    const range = ipaddr.parse(network.address).range();
+                    if ('ipv4Mapped' !== range && 'uniqueLocal' !== range) return false;
+                }
+                return network.address;
+            });
+            if (networks.length > 0) {
+                host = networks[0].address;
+                if (host.includes(':')) host = `[${host}]`;
+            }
+            if (!host) throw new Error("No valid IP found");
+            return host;
+        }
+    }
+};

package/dist/1~src_plugins_emitOnErrors_plugin_ts.js

@@ -0,0 +1,21 @@
+export const __webpack_id__ = "src_plugins_emitOnErrors_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_emitOnErrors_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/emitOnErrors.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginEmitOnErrors: ()=>pluginEmitOnErrors
+        });
+        function pluginEmitOnErrors() {
+            return {
+                name: 'lynx:rsbuild:emit-on-errors',
+                setup (api) {
+                    api.modifyBundlerChain((chain)=>{
+                        chain.optimization.emitOnErrors(true);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_index_ts.js

@@ -0,0 +1,52 @@
+export const __webpack_id__ = "src_plugins_index_ts";
+export const __webpack_ids__ = [
+    "src_plugins_index_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            applyDefaultPlugins: ()=>applyDefaultPlugins
+        });
+        var _debug_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/debug.ts");
+        async function applyDebugPlugins(rsbuildInstance, config) {
+            const debugPlugins = Object.freeze([
+                __webpack_require__.e("src_plugins_emitOnErrors_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/emitOnErrors.plugin.ts")).then(({ pluginEmitOnErrors })=>pluginEmitOnErrors()),
+                Promise.all([
+                    __webpack_require__.e("vendors-node_modules_pnpm_javascript-stringify_2_1_0_node_modules_javascript-stringify_dist_i-562fbc"),
+                    __webpack_require__.e("src_plugins_inspect_plugin_ts")
+                ]).then(__webpack_require__.bind(__webpack_require__, "./src/plugins/inspect.plugin.ts")).then(({ pluginInspect })=>pluginInspect(config))
+            ]);
+            rsbuildInstance.addPlugins(await Promise.all(debugPlugins));
+        }
+        async function applyDefaultPlugins(rsbuildInstance, config) {
+            const defaultPlugins = Object.freeze([
+                __webpack_require__.e("src_plugins_api_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/api.plugin.ts")).then(({ pluginAPI })=>pluginAPI(config)),
+                __webpack_require__.e("src_plugins_chunkLoading_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/chunkLoading.plugin.ts")).then(({ pluginChunkLoading })=>pluginChunkLoading()),
+                __webpack_require__.e("src_plugins_dev_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/dev.plugin.ts")).then(({ pluginDev })=>pluginDev(config.dev, config.server)),
+                __webpack_require__.e("src_plugins_minify_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/minify.plugin.ts")).then(({ pluginMinify })=>pluginMinify(config.output?.minify)),
+                __webpack_require__.e("src_plugins_optimization_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/optimization.plugin.ts")).then(({ pluginOptimization })=>pluginOptimization()),
+                __webpack_require__.e("src_plugins_output_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/output.plugin.ts")).then(({ pluginOutput })=>pluginOutput(config.output)),
+                __webpack_require__.e("src_plugins_resolve_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/resolve.plugin.ts")).then(({ pluginResolve })=>pluginResolve()),
+                __webpack_require__.e("src_plugins_rsdoctor_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/rsdoctor.plugin.ts")).then(({ pluginRsdoctor })=>pluginRsdoctor(config.tools?.rsdoctor)),
+                __webpack_require__.e("src_plugins_sourcemap_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/sourcemap.plugin.ts")).then(({ pluginSourcemap })=>pluginSourcemap()),
+                __webpack_require__.e("src_plugins_swc_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/swc.plugin.ts")).then(({ pluginSwc })=>pluginSwc()),
+                __webpack_require__.e("src_plugins_target_plugin_ts").then(__webpack_require__.bind(__webpack_require__, "./src/plugins/target.plugin.ts")).then(({ pluginTarget })=>pluginTarget())
+            ]);
+            const promises = [
+                Promise.all(defaultPlugins).then((plugins)=>{
+                    rsbuildInstance.addPlugins(plugins);
+                })
+            ];
+            if ((0, _debug_js__WEBPACK_IMPORTED_MODULE_0__._o)()) {
+                (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)('apply Rspeedy default debug plugins');
+                promises.push(applyDebugPlugins(rsbuildInstance, config));
+            }
+            await Promise.all(promises);
+            const { pluginCssMinimizer, PLUGIN_CSS_MINIMIZER_NAME } = await import("@rsbuild/plugin-css-minimizer");
+            if (!rsbuildInstance.isPluginExists(PLUGIN_CSS_MINIMIZER_NAME)) rsbuildInstance.addPlugins([
+                pluginCssMinimizer()
+            ]);
+        }
+    }
+};

package/dist/1~src_plugins_inspect_plugin_ts.js

@@ -0,0 +1,48 @@
+import { mkdir, writeFile } from "node:fs/promises";
+export const __webpack_id__ = "src_plugins_inspect_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_inspect_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/config/output/dist-path.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            z: ()=>DEFAULT_DIST_PATH_INTERMEDIATE
+        });
+        const DEFAULT_DIST_PATH_INTERMEDIATE = '.rspeedy';
+    },
+    "./src/plugins/inspect.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            inspectRspeedyConfig: ()=>inspectRspeedyConfig,
+            pluginInspect: ()=>pluginInspect
+        });
+        var external_node_path_ = __webpack_require__("node:path");
+        var core_ = __webpack_require__("@rsbuild/core");
+        var dist = __webpack_require__("../../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js");
+        var picocolors = __webpack_require__("../../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+        var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
+        var dist_path = __webpack_require__("./src/config/output/dist-path.ts");
+        var debug = __webpack_require__("./src/debug.ts");
+        function pluginInspect(config) {
+            return {
+                name: 'lynx:rsbuild:inspect',
+                setup (api) {
+                    api.onBeforeBuild(async ()=>{
+                        await inspectRspeedyConfig(config, external_node_path_["default"].join(api.context.distPath, dist_path.z, 'rspeedy.config.js'), false);
+                    });
+                }
+            };
+        }
+        async function inspectRspeedyConfig(config, path, verbose) {
+            const stringifiedConfig = (0, dist.stringify)(config, (value, _, stringify)=>{
+                if ('function' == typeof value && !verbose && value.toString().length > 100) return "function () { /* omitted long function */ }";
+                return stringify(value);
+            }, 2);
+            if (!stringifiedConfig) return void (0, debug.Yz)('No Rspeedy config found, skip inspect config.');
+            await mkdir((0, external_node_path_.dirname)(path), {
+                recursive: true
+            });
+            await writeFile(path, `export default ${stringifiedConfig}`);
+            core_.logger.success(`Inspect Rspeedy config succeed, open following files to view the content: \n\n  - ${picocolors_default().bold(picocolors_default().yellow('Rspeedy'))}: ${picocolors_default().underline(path)}\n`);
+        }
+    }
+};

package/dist/1~src_plugins_minify_plugin_ts.js

@@ -0,0 +1,85 @@
+export const __webpack_id__ = "src_plugins_minify_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_minify_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/minify.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginMinify: ()=>pluginMinify
+        });
+        var _debug_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/debug.ts");
+        function pluginMinify(options) {
+            const defaultConfig = Object.freeze({
+                output: {
+                    minify: {
+                        js: true,
+                        jsOptions: {
+                            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
+                                }
+                            }
+                        },
+                        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) {
+                            (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)("minification disabled");
+                            return mergeRsbuildConfig(config, {
+                                output: {
+                                    minify: false
+                                }
+                            });
+                        }
+                        const configs = [
+                            config,
+                            defaultConfig
+                        ];
+                        if (true !== options && void 0 !== options) {
+                            (0, _debug_js__WEBPACK_IMPORTED_MODULE_0__.Yz)("merging minification options");
+                            configs.push({
+                                output: {
+                                    minify: options
+                                }
+                            });
+                        }
+                        return mergeRsbuildConfig(...configs);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_optimization_plugin_ts.js

@@ -0,0 +1,25 @@
+export const __webpack_id__ = "src_plugins_optimization_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_optimization_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/optimization.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginOptimization: ()=>pluginOptimization
+        });
+        function pluginOptimization() {
+            return {
+                name: 'lynx:rsbuild:optimization',
+                setup (api) {
+                    api.modifyBundlerChain((chain, { CHAIN_ID, isProd })=>{
+                        const rule = chain.module.rules.get(CHAIN_ID.RULE.JS);
+                        chain.module.rule('js-override-strict').type(rule.get('type')).test(rule.get('test')).parser({
+                            overrideStrict: 'strict'
+                        }).end();
+                        if (isProd) chain.optimization.avoidEntryIife(true);
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_output_plugin_ts.js

@@ -0,0 +1,46 @@
+export const __webpack_id__ = "src_plugins_output_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_output_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/config/output/dist-path.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            z: ()=>DEFAULT_DIST_PATH_INTERMEDIATE
+        });
+        const DEFAULT_DIST_PATH_INTERMEDIATE = '.rspeedy';
+    },
+    "./src/plugins/output.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginOutput: ()=>pluginOutput
+        });
+        var _config_output_dist_path_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/config/output/dist-path.ts");
+        const defaultFilenameOptions = Object.freeze({
+            css: '[name]/[name].css'
+        });
+        const defaultDistPathOptions = Object.freeze({
+            css: _config_output_dist_path_js__WEBPACK_IMPORTED_MODULE_0__.z
+        });
+        function pluginOutput(options) {
+            return {
+                name: 'lynx:rsbuild:output',
+                setup (api) {
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                        if (!options) return mergeRsbuildConfig({
+                            output: {
+                                filename: {
+                                    css: defaultFilenameOptions.css
+                                }
+                            }
+                        }, config);
+                        return mergeRsbuildConfig(config, {
+                            output: {
+                                distPath: Object.assign({}, defaultDistPathOptions, options.distPath),
+                                filename: Object.assign({}, defaultFilenameOptions, options.filename)
+                            }
+                        });
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/1~src_plugins_resolve_plugin_ts.js

@@ -0,0 +1,21 @@
+export const __webpack_id__ = "src_plugins_resolve_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_resolve_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/resolve.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginResolve: ()=>pluginResolve
+        });
+        function pluginResolve() {
+            return {
+                name: 'lynx:rsbuild:resolve',
+                setup (api) {
+                    api.modifyBundlerChain((chain)=>{
+                        chain.resolve.aliasFields.add('browser').end().conditionNames.add('lynx').add('import').add('require').add('browser').end().extensions.add('.cjs').end().mainFields.add('lynx').add('module').add('main').end().mainFiles.add('index.lynx').add('index').end().end().end();
+                    });
+                }
+            };
+        }
+    }
+};

package/dist/{src_plugins_rsdoctor_plugin_ts.js → 1~src_plugins_rsdoctor_plugin_ts.js}

@@ -4,7 +4,6 @@ export const __webpack_ids__ = [
 ];
 export const __webpack_modules__ = {
     "./src/plugins/rsdoctor.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.r(__webpack_exports__);
         __webpack_require__.d(__webpack_exports__, {
             pluginRsdoctor: ()=>pluginRsdoctor
         });

package/dist/1~src_plugins_sourcemap_plugin_ts.js

@@ -0,0 +1,99 @@
+export const __webpack_id__ = "src_plugins_sourcemap_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_sourcemap_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/sourcemap.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginSourcemap: ()=>pluginSourcemap
+        });
+        var isProduction = 'production' === process.env.NODE_ENV;
+        var prefix = 'Invariant failed';
+        function invariant(condition, message) {
+            if (condition) return;
+            if (isProduction) throw new Error(prefix);
+            var provided = 'function' == typeof message ? message() : message;
+            var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+            throw new Error(value);
+        }
+        class EvalSourceMapDevToolPlugin_EvalSourceMapDevToolPlugin {
+            options;
+            constructor(options){
+                this.options = options;
+            }
+            apply(compiler) {
+                const { EvalSourceMapDevToolPlugin } = compiler.webpack;
+                new EvalSourceMapDevToolPlugin(this.options).apply(compiler);
+            }
+        }
+        class SourceMapDevToolPlugin_SourceMapDevToolPlugin {
+            options;
+            constructor(options){
+                this.options = options;
+            }
+            apply(compiler) {
+                const { SourceMapDevToolPlugin } = compiler.webpack;
+                new SourceMapDevToolPlugin(this.options).apply(compiler);
+            }
+        }
+        function pluginSourcemap() {
+            return {
+                name: 'lynx:rsbuild:sourcemap',
+                pre: [
+                    'lynx:rsbuild:dev'
+                ],
+                setup (api) {
+                    api.modifyBundlerChain((chain, { isDev })=>{
+                        const { dev, output, server } = api.getRsbuildConfig('current');
+                        const publicPath = isDev ? dev?.assetPrefix : output?.assetPrefix;
+                        if (false === publicPath) return;
+                        invariant('string' == typeof publicPath || void 0 === publicPath, `dev.assetPrefix should be normalized to string, got ${dev?.assetPrefix}`);
+                        applySourceMapPlugin(chain, getDevtoolFromSourceMap(), publicPath?.replaceAll('<port>', String(api.context.devServer?.port ?? server?.port)));
+                        function getDevtoolFromSourceMap() {
+                            const DEFAULT_DEV_DEVTOOL = 'cheap-module-source-map';
+                            switch(typeof output?.sourceMap){
+                                case 'boolean':
+                                    if (output.sourceMap) return isDev ? DEFAULT_DEV_DEVTOOL : 'source-map';
+                                    return false;
+                                case 'undefined':
+                                case 'object':
+                                    return output?.sourceMap?.js ?? (isDev ? DEFAULT_DEV_DEVTOOL : false);
+                            }
+                        }
+                    });
+                }
+            };
+        }
+        function applySourceMapPlugin(chain, devtool, publicPath) {
+            if (false === devtool) return;
+            const CHAIN_ID_DEV_SOURCEMAP = 'lynx:sourcemap';
+            const output = chain.get('output');
+            if (devtool.includes('source-map')) {
+                const hidden = devtool.includes('hidden');
+                const inline = devtool.includes('inline');
+                const evalWrapped = devtool.includes('eval');
+                const cheap = devtool.includes('cheap');
+                const moduleMaps = devtool.includes('module');
+                const noSources = devtool.includes('nosources');
+                const debugIds = devtool.includes('debugids');
+                const options = {
+                    filename: inline ? null : output?.sourceMapFilename ?? '[file].map[query]',
+                    moduleFilenameTemplate: output?.devtoolModuleFilenameTemplate ?? 'file://[absolute-resource-path]',
+                    fallbackModuleFilenameTemplate: output?.devtoolFallbackModuleFilenameTemplate ?? 'file://[absolute-resource-path]?[hash]',
+                    append: hidden ? false : void 0,
+                    module: moduleMaps ? true : !cheap,
+                    columns: !cheap,
+                    noSources,
+                    namespace: output?.devtoolNamespace,
+                    publicPath,
+                    debugIds
+                };
+                chain.devtool(false).plugin(CHAIN_ID_DEV_SOURCEMAP).when(evalWrapped, (plugin)=>plugin.use(EvalSourceMapDevToolPlugin_EvalSourceMapDevToolPlugin, [
+                        options
+                    ]), (plugin)=>plugin.use(SourceMapDevToolPlugin_SourceMapDevToolPlugin, [
+                        options
+                    ]));
+            }
+        }
+    }
+};

package/dist/1~src_plugins_swc_plugin_ts.js

@@ -0,0 +1,39 @@
+export const __webpack_id__ = "src_plugins_swc_plugin_ts";
+export const __webpack_ids__ = [
+    "src_plugins_swc_plugin_ts"
+];
+export const __webpack_modules__ = {
+    "./src/plugins/swc.plugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            pluginSwc: ()=>pluginSwc
+        });
+        var _utils_getESVersionTarget_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/utils/getESVersionTarget.ts");
+        function pluginSwc() {
+            return {
+                name: 'lynx:rsbuild:swc',
+                setup (api) {
+                    api.modifyRsbuildConfig((config, { mergeRsbuildConfig })=>{
+                        const isProd = 'production' === config.mode;
+                        return mergeRsbuildConfig(config, {
+                            tools: {
+                                swc (config) {
+                                    delete config.env;
+                                    config.jsc ??= {};
+                                    config.jsc.target = (0, _utils_getESVersionTarget_js__WEBPACK_IMPORTED_MODULE_0__.y)(isProd);
+                                }
+                            }
+                        });
+                    });
+                }
+            };
+        }
+    },
+    "./src/utils/getESVersionTarget.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            y: ()=>getESVersionTarget
+        });
+        function getESVersionTarget(isProd) {
+            return isProd ? 'es2015' : 'es2019';
+        }
+    }
+};