@lynx-js/rspeedy 0.8.2

package/lib/create-rspeedy.d.ts

@@ -0,0 +1,45 @@
+import type { RsbuildInstance } from '@rsbuild/core';
+import type { Config } from './config/index.js';
+/**
+ * The instance of Rspeedy.
+ *
+ * @public
+ */
+export type RspeedyInstance = RsbuildInstance & {
+    getRspeedyConfig(): Config;
+};
+/**
+ * The options of `createRspeedy` method.
+ *
+ * @public
+ */
+export interface CreateRspeedyOptions {
+    /**
+     * The root path of the current build.
+     */
+    cwd?: string;
+    /**
+     * The config of Rspeedy.
+     */
+    rspeedyConfig?: Config;
+}
+/**
+ * The `createRspeedy` method can let you create a Rspeedy instance and you can customize the build or development process in Node.js Runtime.
+ *
+ * @param options - {@link CreateRspeedyOptions}
+ * @returns - Rspeedy instance.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createRspeedy } from '@lynx-js/rspeedy'
+ *
+ * void async function () {
+ *   const rspeedy = await createRspeedy({})
+ *   await rspeedy.build()
+ * }()
+ * ```
+ *
+ * @public
+ */
+export declare function createRspeedy({ cwd, rspeedyConfig }: CreateRspeedyOptions): Promise<RspeedyInstance>;

package/lib/create-rspeedy.js

@@ -0,0 +1,48 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import path from 'node:path';
+import { createRsbuild } from '@rsbuild/core';
+import { applyDefaultRspeedyConfig } from './config/defaults.js';
+import { toRsbuildConfig } from './config/rsbuild/index.js';
+/**
+ * The `createRspeedy` method can let you create a Rspeedy instance and you can customize the build or development process in Node.js Runtime.
+ *
+ * @param options - {@link CreateRspeedyOptions}
+ * @returns - Rspeedy instance.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createRspeedy } from '@lynx-js/rspeedy'
+ *
+ * void async function () {
+ *   const rspeedy = await createRspeedy({})
+ *   await rspeedy.build()
+ * }()
+ * ```
+ *
+ * @public
+ */
+export async function createRspeedy({ cwd = process.cwd(), rspeedyConfig = {} }) {
+    const config = applyDefaultRspeedyConfig(rspeedyConfig);
+    const [rspeedy, { applyDefaultPlugins }] = await Promise.all([
+        createRsbuild({
+            cwd,
+            rsbuildConfig: toRsbuildConfig(config),
+        }),
+        import('./plugins/index.js'),
+    ]);
+    await applyDefaultPlugins(rspeedy, config);
+    const inspectConfig = rspeedy.inspectConfig.bind(rspeedy);
+    return Object.assign(rspeedy, {
+        getRspeedyConfig: () => config,
+        async inspectConfig(options) {
+            const result = await inspectConfig(options);
+            const { inspectRspeedyConfig } = await import('./plugins/inspect.plugin.js');
+            await inspectRspeedyConfig(rspeedyConfig, path.resolve(options.outputPath ?? rspeedy.context.distPath, '.rsbuild/rspeedy.config.js'), options.verbose ?? false);
+            return result;
+        },
+    });
+}
+//# sourceMappingURL=create-rspeedy.js.map

package/lib/debug.d.ts

@@ -0,0 +1,3 @@
+export declare const isDebug: () => boolean;
+export declare const debug: (message: string | (() => string)) => void;
+export declare const debugList: (prefix: string, messages: string | string[]) => void;

package/lib/debug.js

@@ -0,0 +1,25 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { logger } from '@rsbuild/core';
+import color from 'picocolors';
+export const isDebug = () => {
+    if (!process.env['DEBUG']) {
+        return false;
+    }
+    const values = process.env['DEBUG'].toLocaleLowerCase().split(',');
+    return ['rsbuild', 'rspeedy', '*'].some((key) => values.includes(key));
+};
+const label = color.bgCyan('lynx');
+export const debug = (message) => {
+    if (isDebug()) {
+        const result = typeof message === 'string' ? message : message();
+        // Add `logger.level` since `logger.debug` will not print when `DEBUG=rspeedy`
+        logger.level = 'verbose';
+        logger.debug(`${label} ${result}`);
+    }
+};
+export const debugList = (prefix, messages) => {
+    return debug(() => `${prefix} ${[''].concat(messages).join('\n    - ')}`);
+};
+//# sourceMappingURL=debug.js.map

package/lib/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @packageDocumentation
+ *
+ * The document contains all the configurations of the `@lynx-js/rspeedy` package.
+ *
+ * @example
+ *
+ * Use `lynx.config.ts` with {@link defineConfig} to get better TypeScript intellisense.
+ *
+ * ```ts
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: './src/index.tsx',
+ * })
+ * ```
+ */
+export type { ExposedAPI } from './api.js';
+export { createRspeedy, type RspeedyInstance, type CreateRspeedyOptions, } from './create-rspeedy.js';
+export { logger } from '@rsbuild/core';
+export { defineConfig } from './config/defineConfig.js';
+export { loadConfig, type LoadConfigOptions, type LoadConfigResult, } from './config/loadConfig.js';
+export type { Config } from './config/index.js';
+export type { Dev } from './config/dev/index.js';
+export type { Client as DevClient } from './config/dev/client.js';
+export type { CssModules, CssModuleLocalsConvention, } from './config/output/css-modules.js';
+export type { DistPath } from './config/output/dist-path.js';
+export type { Filename } from './config/output/filename.js';
+export type { Minify } from './config/output/minify.js';
+export type { SourceMap } from './config/output/source-map.js';
+export type { Output } from './config/output/index.js';
+export type { Performance } from './config/performance/index.js';
+export type { ChunkSplit, ChunkSplitBySize, ChunkSplitCustom, } from './config/performance/chunk-split.js';
+export type { ConsoleType } from './config/performance/index.js';
+export type { RsbuildPlugin, RsbuildPluginAPI } from '@rsbuild/core';
+export { rspack } from '@rsbuild/core';
+export type { Rspack } from '@rsbuild/core';
+export type { Server } from './config/server/index.js';
+export type { Source } from './config/source/index.js';
+export type { Decorators } from './config/source/decorators.js';
+export type { Entry, EntryDescription } from './config/source/entry.js';
+export type { TransformImport } from './config/source/transformImport.js';
+export type { CssExtract, CssExtractRspackLoaderOptions, CssExtractRspackPluginOptions, } from './config/tools/css-extract.js';
+export type { CssLoader, CssLoaderModules } from './config/tools/css-loader.js';
+export type { RsdoctorRspackPluginOptions, Tools, } from './config/tools/index.js';
+export { version, rsbuildVersion, rspackVersion } from './version.js';

package/lib/index.js

@@ -0,0 +1,10 @@
+export { createRspeedy, } from './create-rspeedy.js';
+export { logger } from '@rsbuild/core';
+// Config
+export { defineConfig } from './config/defineConfig.js';
+export { loadConfig, } from './config/loadConfig.js';
+// Rspack instance
+export { rspack } from '@rsbuild/core';
+// Version
+export { version, rsbuildVersion, rspackVersion } from './version.js';
+//# sourceMappingURL=index.js.map

package/lib/plugins/api.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Config } from '../config/index.js';
+export declare function pluginAPI(config: Config): RsbuildPlugin;

package/lib/plugins/api.plugin.js

@@ -0,0 +1,25 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { logger } from '@rsbuild/core';
+import { debug } from '../debug.js';
+import { version } from '../version.js';
+const sAPI = Symbol.for('rspeedy.api');
+export function pluginAPI(config) {
+    return {
+        name: 'lynx:rsbuild:plugin-api',
+        setup(api) {
+            api.expose(sAPI, {
+                config,
+                debug,
+                async exit(code) {
+                    const { exit } = await import('../cli/exit.js');
+                    return exit(code);
+                },
+                logger,
+                version,
+            });
+        },
+    };
+}
+//# sourceMappingURL=api.plugin.js.map

package/lib/plugins/chunkLoading.plugin.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function pluginChunkLoading(): RsbuildPlugin;

package/lib/plugins/chunkLoading.plugin.js

@@ -0,0 +1,30 @@
+import { ChunkLoadingWebpackPlugin } from '@lynx-js/chunk-loading-webpack-plugin';
+export function pluginChunkLoading() {
+    return {
+        name: 'lynx:rsbuild:chunk-loading',
+        setup(api) {
+            api.modifyBundlerChain(chain => {
+                // dprint-ignore
+                chain
+                    .plugin('lynx:chunk-loading')
+                    .use(ChunkLoadingWebpackPlugin)
+                    .end()
+                    .output
+                    // Rspack needs `chunkLoading: 'require'` since we use runtimeModule hook
+                    // to override the chunk loading runtime.
+                    .chunkLoading('require')
+                    .chunkFormat('commonjs')
+                    .iife(false)
+                    .end();
+            });
+            api.modifyWebpackChain(chain => {
+                chain
+                    .output
+                    // For webpack, we directly use `chunkLoading: 'lynx'`.
+                    .chunkLoading('lynx')
+                    .end();
+            });
+        },
+    };
+}
+//# sourceMappingURL=chunkLoading.plugin.js.map

package/lib/plugins/dev.plugin.d.ts

@@ -0,0 +1,5 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Dev } from '../config/dev/index.js';
+import type { Server } from '../config/server/index.js';
+export declare function pluginDev(options?: Dev, server?: Server): RsbuildPlugin;
+export declare function findIp(family: 'v4' | 'v6'): Promise<string>;

package/lib/plugins/dev.plugin.js

@@ -0,0 +1,130 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { createRequire } from 'node:module';
+import { logger } from '@rsbuild/core';
+import color from 'picocolors';
+import { debug } from '../debug.js';
+import { CompilationIdPlugin } from '../webpack/CompilationIdPlugin.js';
+import { ProvidePlugin } from '../webpack/ProvidePlugin.js';
+export function pluginDev(options, server) {
+    return {
+        name: 'lynx:rsbuild:dev',
+        async setup(api) {
+            const hostname = server?.host ?? await findIp('v4');
+            let assetPrefix = options?.assetPrefix;
+            switch (typeof assetPrefix) {
+                case 'string': {
+                    if (server?.port !== undefined) {
+                        // We should change the port of `assetPrefix` when `server.port` is set.
+                        const hasPortPlaceholder = assetPrefix.includes('<port>');
+                        if (!hasPortPlaceholder) {
+                            // There is not `<port>` in `dev.assetPrefix`.
+                            const assetPrefixURL = new URL(assetPrefix);
+                            if (assetPrefixURL.port !== String(server.port)) {
+                                logger.warn(`Setting different port values in ${color.cyan('server.port')} and ${color.cyan('dev.assetPrefix')}. Using server.port(${color.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 === true || assetPrefix === undefined
+                        assetPrefix = `http://${hostname}:<port>/`;
+                    }
+                    break;
+                }
+            }
+            debug(`dev.assetPrefix is normalized to ${assetPrefix}`);
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig }) => {
+                return mergeRsbuildConfig(config, {
+                    dev: {
+                        assetPrefix,
+                        client: {
+                            // Lynx cannot use `location.hostname`.
+                            host: hostname,
+                        },
+                    },
+                });
+            });
+            const require = createRequire(import.meta.url);
+            api.modifyBundlerChain((chain, { isProd }) => {
+                if (isProd) {
+                    return;
+                }
+                const rsbuildPath = require.resolve('@rsbuild/core');
+                // dprint-ignore
+                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')}?hostname=${hostname}&port=${api.context.devServer?.port}&pathname=/rsbuild-hmr&hot=true&live-reload=true&protocol=ws`)
+                    .set('@rspack/core/hot/dev-server', require.resolve('@rspack/core/hot/dev-server', {
+                    paths: [rsbuildPath],
+                }))
+                    .end()
+                    .end()
+                    .plugin('lynx.hmr.provide')
+                    .use(ProvidePlugin, [
+                    {
+                        WebSocket: [
+                            options?.client?.websocketTransport ?? require.resolve('@lynx-js/websocket'),
+                            'default',
+                        ],
+                        __webpack_dev_server_client__: [require.resolve('../../client/hmr/WebSocketClient.js'), 'default'],
+                    }
+                ])
+                    .end()
+                    .plugin('lynx.hmr.compilation-id')
+                    .use(CompilationIdPlugin, [])
+                    .end();
+            });
+        },
+    };
+}
+export async function findIp(family) {
+    const [{ default: defaultGateway }, { default: ipaddr }, os,] = await Promise.all([
+        import('default-gateway'),
+        import('ipaddr.js'),
+        import('node:os'),
+    ]);
+    const gateway = await (async () => {
+        if (family === 'v4') {
+            const { gateway } = await defaultGateway.gateway4async();
+            return gateway;
+        }
+        else {
+            const { gateway } = await defaultGateway.gateway6async();
+            return gateway;
+        }
+    })();
+    const gatewayIp = ipaddr.parse(gateway);
+    // Look for the matching interface in all local interfaces.
+    for (const addresses of Object.values(os.networkInterfaces())) {
+        if (!addresses) {
+            continue;
+        }
+        for (const { cidr, internal } of addresses) {
+            if (!cidr || internal) {
+                continue;
+            }
+            const net = ipaddr.parseCIDR(cidr);
+            if (net[0]
+                && net[0].kind() === gatewayIp.kind()
+                && gatewayIp.match(net)) {
+                return net[0].toString();
+            }
+        }
+    }
+    throw new Error(`No valid IP found for the default gateway ${gateway}`);
+}
+//# sourceMappingURL=dev.plugin.js.map

package/lib/plugins/index.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildInstance } from '@rsbuild/core';
+import type { Config } from '../config/index.js';
+export declare function applyDefaultPlugins(rsbuildInstance: RsbuildInstance, config: Config): Promise<void>;

package/lib/plugins/index.js

@@ -0,0 +1,49 @@
+import { debug, isDebug } from '../debug.js';
+async function applyDebugPlugins(rsbuildInstance, config) {
+    const debugPlugins = Object.freeze([
+        import('./inspect.plugin.js').then(({ pluginInspect }) => pluginInspect(config)),
+        import('./stats.plugin.js').then(({ pluginStats }) => pluginStats()),
+    ]);
+    rsbuildInstance.addPlugins(await Promise.all(debugPlugins));
+}
+async function applyDefaultDevPlugins(rsbuildInstance, config) {
+    const devPlugins = Object.freeze([
+        import('./dev.plugin.js').then(({ pluginDev }) => pluginDev(config.dev, config.server)),
+    ]);
+    rsbuildInstance.addPlugins(await Promise.all(devPlugins));
+}
+export async function applyDefaultPlugins(rsbuildInstance, config) {
+    const defaultPlugins = Object.freeze([
+        import('./api.plugin.js').then(({ pluginAPI }) => pluginAPI(config)),
+        import('./chunkLoading.plugin.js').then(({ pluginChunkLoading }) => pluginChunkLoading()),
+        import('./minify.plugin.js').then(({ pluginMinify }) => pluginMinify(config.output?.minify)),
+        import('./optimization.plugin.js').then(({ pluginOptimization }) => pluginOptimization()),
+        import('./output.plugin.js').then(({ pluginOutput }) => pluginOutput(config.output)),
+        import('./resolve.plugin.js').then(({ pluginResolve }) => pluginResolve()),
+        import('./rsdoctor.plugin.js').then(({ pluginRsdoctor }) => pluginRsdoctor(config.tools?.rsdoctor)),
+        import('./sourcemap.plugin.js').then(({ pluginSourcemap }) => pluginSourcemap()),
+        import('./swc.plugin.js').then(({ pluginSwc }) => pluginSwc()),
+        import('./target.plugin.js').then(({ pluginTarget }) => pluginTarget()),
+    ]);
+    const promises = [
+        Promise.all(defaultPlugins).then(plugins => {
+            rsbuildInstance.addPlugins(plugins);
+        }),
+    ];
+    // TODO: replace with `isDev()` helper
+    if (process.env['NODE_ENV'] === 'development') {
+        debug('apply Rspeedy default development plugins');
+        promises.push(applyDefaultDevPlugins(rsbuildInstance, config));
+    }
+    if (isDebug()) {
+        debug('apply Rspeedy default debug plugins');
+        promises.push(applyDebugPlugins(rsbuildInstance, config));
+    }
+    await Promise.all(promises);
+    // If no `@rsbuild/plugin-css-minimizer` is applied, apply it
+    const { pluginCssMinimizer, PLUGIN_CSS_MINIMIZER_NAME } = await import('@rsbuild/plugin-css-minimizer');
+    if (!rsbuildInstance.isPluginExists(PLUGIN_CSS_MINIMIZER_NAME)) {
+        rsbuildInstance.addPlugins([pluginCssMinimizer()]);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/plugins/inspect.plugin.d.ts

@@ -0,0 +1,4 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Config } from '../config/index.js';
+export declare function pluginInspect(config: Config): RsbuildPlugin;
+export declare function inspectRspeedyConfig(config: Config, path: string, verbose: boolean): Promise<void>;

package/lib/plugins/inspect.plugin.js

@@ -0,0 +1,39 @@
+// Copyright 2024 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { mkdir, writeFile } from 'node:fs/promises';
+import path, { dirname } from 'node:path';
+import { logger } from '@rsbuild/core';
+import { stringify } from 'javascript-stringify';
+import color from 'picocolors';
+import { DEFAULT_DIST_PATH_INTERMEDIATE } from '../config/output/dist-path.js';
+import { debug } from '../debug.js';
+export function pluginInspect(config) {
+    return {
+        name: 'lynx:rsbuild:inspect',
+        setup(api) {
+            api.onBeforeBuild(async () => {
+                await inspectRspeedyConfig(config, 
+                /** path */ path.join(api.context.distPath, config.output?.distPath?.intermediate
+                    ?? DEFAULT_DIST_PATH_INTERMEDIATE, 'rspeedy.config.js'), 
+                /** verbose */ false);
+            });
+        },
+    };
+}
+export async function inspectRspeedyConfig(config, path, verbose) {
+    const stringifiedConfig = stringify(config, (value, _, stringify) => {
+        if (typeof value === 'function' && !verbose && value.toString().length > 100) {
+            return `function () { /* omitted long function */ }`;
+        }
+        return stringify(value);
+    }, 2);
+    if (!stringifiedConfig) {
+        debug('No Rspeedy config found, skip inspect config.');
+        return;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `export default ${stringifiedConfig}`);
+    logger.success(`Inspect Rspeedy config succeed, open following files to view the content: \n\n  - ${color.bold(color.yellow('Rspeedy'))}: ${color.underline(path)}\n`);
+}
+//# sourceMappingURL=inspect.plugin.js.map

package/lib/plugins/minify.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Minify } from '../config/output/minify.js';
+export declare function pluginMinify(options?: Minify | boolean): RsbuildPlugin;

package/lib/plugins/minify.plugin.js

@@ -0,0 +1,89 @@
+import { debug } from '../debug.js';
+export function pluginMinify(options) {
+    const defaultConfig = Object.freeze({
+        output: {
+            minify: {
+                js: true,
+                jsOptions: {
+                    minimizerOptions: {
+                        compress: {
+                            /**
+                             * the module wrapper iife need to be kept to provide the return value
+                             * for the module loader in lynx_core.js
+                             */
+                            negate_iife: false,
+                            join_vars: false,
+                            ecma: 2015,
+                            inline: 2,
+                            comparisons: false,
+                            toplevel: true,
+                            // Allow return in module wrapper
+                            side_effects: false,
+                        },
+                        format: {
+                            keep_quoted_props: true,
+                            comments: false,
+                        },
+                        mangle: {
+                            toplevel: true,
+                        },
+                    },
+                },
+                css: true,
+                cssOptions: {
+                    minimizerOptions: {
+                        // Disable the default targets by passing an empty string.
+                        targets: '',
+                        include: {
+                            // Lynx does not support nesting, so we enable it here.
+                            // https://lightningcss.dev/transpilation.html#nesting
+                            nesting: true,
+                            // Lynx does not support double position gradients, so we enable it here.
+                            // https://lightningcss.dev/transpilation.html#double-position-gradients
+                            doublePositionGradients: true,
+                            // Lynx does not support space separated color notation, so we enable it here.
+                            // https://lightningcss.dev/transpilation.html#space-separated-color-notation
+                            spaceSeparatedColorNotation: true,
+                        },
+                        exclude: {
+                            // Lynx does not support vendor prefixes, so we exclude it here.
+                            // https://lightningcss.dev/transpilation.html#vendor-prefixing
+                            vendorPrefixes: true,
+                            // Lynx does not support logical properties(`dir`, `lang`, `is`), so we exclude it here.
+                            // https://lightningcss.dev/transpilation.html#logical-properties
+                            logicalProperties: true,
+                            // Lynx does support hex alpha colors, so we exclude it here.
+                            // https://lightningcss.dev/transpilation.html#hex-alpha-colors
+                            hexAlphaColors: true,
+                        },
+                    },
+                },
+            },
+        },
+    });
+    return {
+        name: 'lynx:rsbuild:minify',
+        setup(api) {
+            api.modifyRsbuildConfig((config, { mergeRsbuildConfig }) => {
+                // Disable minification
+                if (options === false) {
+                    debug(`minification disabled`);
+                    return mergeRsbuildConfig(config, {
+                        output: { minify: false },
+                    });
+                }
+                const configs = [config, defaultConfig];
+                if (options !== true && options !== undefined) {
+                    debug(`merging minification options`);
+                    configs.push({
+                        output: {
+                            minify: options,
+                        },
+                    });
+                }
+                return mergeRsbuildConfig(...configs);
+            });
+        },
+    };
+}
+//# sourceMappingURL=minify.plugin.js.map

package/lib/plugins/optimization.plugin.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare function pluginOptimization(): RsbuildPlugin;

package/lib/plugins/optimization.plugin.js

@@ -0,0 +1,31 @@
+export 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'))
+                    // We do not directly apply this to `CHAIN_ID.RULE.JS` since it will not
+                    // includes the `node_modules` by default.
+                    .parser({
+                    // Make all the modules as strict to avoid entry being wrapped by IIFE.
+                    // See: https://github.com/webpack/webpack/discussions/18367
+                    overrideStrict: 'strict',
+                })
+                    .end();
+                if (isProd) {
+                    // Avoid entry being wrapped by IIFE
+                    // See: https://rspack.dev/config/optimization#optimizationavoidentryiife
+                    chain
+                        .optimization
+                        .avoidEntryIife(true);
+                }
+            });
+        },
+    };
+}
+//# sourceMappingURL=optimization.plugin.js.map

package/lib/plugins/output.plugin.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+import type { Output } from '../config/output/index.js';
+export declare function pluginOutput(options?: Output): RsbuildPlugin;

package/lib/plugins/output.plugin.js

@@ -0,0 +1,34 @@
+import { DEFAULT_DIST_PATH_INTERMEDIATE } from '../config/output/dist-path.js';
+const defaultFilenameOptions = Object.freeze({
+    css: '[name]/[name].css',
+});
+const defaultDistPathOptions = Object.freeze({
+    // We override the default value of Rsbuild(`static/css`) here.
+    // Since all the CSS should be encoded into the template in Lynx.
+    css: DEFAULT_DIST_PATH_INTERMEDIATE,
+});
+export 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),
+                    },
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=output.plugin.js.map