@nx/rspack 20.1.0-beta.1 → 20.1.0-beta.3

package/src/plugins/utils/loaders/stylesheet-loaders.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommonLoadersForCssModules = getCommonLoadersForCssModules;
+exports.getCommonLoadersForGlobalCss = getCommonLoadersForGlobalCss;
+exports.getCommonLoadersForGlobalStyle = getCommonLoadersForGlobalStyle;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const autoprefixer = require("autoprefixer");
+const postcssImports = require("postcss-import");
+const core_1 = require("@rspack/core");
+const get_css_module_local_ident_1 = require("../get-css-module-local-ident");
+const hash_format_1 = require("../hash-format");
+const postcss_cli_resources_1 = require("../plugins/postcss-cli-resources");
+function getCommonLoadersForCssModules(options, includePaths) {
+    // load component css as raw strings
+    return [
+        {
+            loader: options.extractCss
+                ? core_1.CssExtractRspackPlugin.loader
+                : require.resolve('style-loader'),
+        },
+        {
+            loader: require.resolve('css-loader'),
+            options: {
+                modules: {
+                    mode: 'local',
+                    getLocalIdent: get_css_module_local_ident_1.getCSSModuleLocalIdent,
+                },
+                importLoaders: 1,
+            },
+        },
+        {
+            loader: require.resolve('postcss-loader'),
+            options: {
+                implementation: require('postcss'),
+                postcssOptions: postcssOptionsCreator(options, {
+                    includePaths,
+                    forCssModules: true,
+                }),
+            },
+        },
+    ];
+}
+function getCommonLoadersForGlobalCss(options, includePaths) {
+    return [
+        {
+            loader: options.extractCss
+                ? core_1.CssExtractRspackPlugin.loader
+                : require.resolve('style-loader'),
+        },
+        { loader: require.resolve('css-loader'), options: { url: false } },
+        {
+            loader: require.resolve('postcss-loader'),
+            options: {
+                implementation: require('postcss'),
+                postcssOptions: postcssOptionsCreator(options, {
+                    includePaths,
+                }),
+            },
+        },
+    ];
+}
+function getCommonLoadersForGlobalStyle(options, includePaths) {
+    return [
+        {
+            loader: options.extractCss
+                ? core_1.CssExtractRspackPlugin.loader
+                : require.resolve('style-loader'),
+            options: { esModule: true },
+        },
+        { loader: require.resolve('css-loader'), options: { url: false } },
+        {
+            loader: require.resolve('postcss-loader'),
+            options: {
+                implementation: require('postcss'),
+                postcssOptions: postcssOptionsCreator(options, {
+                    includePaths,
+                }),
+            },
+        },
+    ];
+}
+function postcssOptionsCreator(options, { includePaths, forCssModules = false, }) {
+    const hashFormat = (0, hash_format_1.getOutputHashFormat)(options.outputHashing);
+    // PostCSS options depend on the webpack loader, but we need to set the `config` path as a string due to this check:
+    // https://github.com/webpack-contrib/postcss-loader/blob/0d342b1/src/utils.js#L36
+    const postcssOptions = (loader) => ({
+        map: options.sourceMap &&
+            options.sourceMap !== 'hidden' && {
+            inline: true,
+            annotation: false,
+        },
+        plugins: [
+            postcssImports({
+                addModulesDirectories: includePaths,
+                resolve: (url) => (url.startsWith('~') ? url.slice(1) : url),
+            }),
+            ...(forCssModules
+                ? []
+                : [
+                    (0, postcss_cli_resources_1.PostcssCliResources)({
+                        baseHref: options.baseHref,
+                        deployUrl: options.deployUrl,
+                        loader,
+                        filename: `[name]${hashFormat.file}.[ext]`,
+                        publicPath: options.publicPath,
+                        rebaseRootRelative: options.rebaseRootRelative,
+                    }),
+                    autoprefixer(),
+                ]),
+        ],
+    });
+    // If a path to postcssConfig is passed in, set it for app and all libs, otherwise
+    // use automatic detection.
+    if (typeof options.postcssConfig === 'string') {
+        postcssOptions.config = path.join(options.root, options.postcssConfig);
+    }
+    return postcssOptions;
+}

package/src/plugins/utils/models.d.ts

@@ -0,0 +1,229 @@
+import type { Mode } from '@rspack/core';
+import type { ProjectGraph } from '@nx/devkit';
+import type { AssetGlob } from '@nx/js/src/utils/assets/assets';
+export interface AssetGlobPattern {
+    glob: string;
+    input: string;
+    output: string;
+    ignore?: string[];
+}
+export interface ExtraEntryPointClass {
+    bundleName?: string;
+    inject?: boolean;
+    input: string;
+    lazy?: boolean;
+}
+export interface FileReplacement {
+    replace: string;
+    with: string;
+}
+export interface AdditionalEntryPoint {
+    entryName: string;
+    entryPath: string;
+}
+export interface TransformerPlugin {
+    name: string;
+    options: Record<string, unknown>;
+}
+export type TransformerEntry = string | TransformerPlugin;
+export interface OptimizationOptions {
+    scripts: boolean;
+    styles: boolean;
+}
+export interface NxAppRspackPluginOptions {
+    /**
+     * The tsconfig file for the project. e.g. `tsconfig.json`
+     */
+    tsConfig?: string;
+    /**
+     * The entry point for the bundle. e.g. `src/main.ts`
+     */
+    main?: string;
+    /**
+     * Secondary entry points for the bundle.
+     */
+    additionalEntryPoints?: AdditionalEntryPoint[];
+    /**
+     * Assets to be copied over to the output path.
+     */
+    assets?: Array<AssetGlob | string>;
+    /**
+     * Set <base href> for the resulting index.html.
+     */
+    baseHref?: string;
+    /**
+     * Build the libraries from source. Default is `true`.
+     */
+    buildLibsFromSource?: boolean;
+    commonChunk?: boolean;
+    /**
+     * Delete the output path before building.
+     */
+    deleteOutputPath?: boolean;
+    /**
+     * The deploy path for the application. e.g. `/my-app/`
+     */
+    deployUrl?: string;
+    /**
+     * Define external packages that will not be bundled.
+     * Use `all` to exclude all 3rd party packages, and `none` to bundle all packages.
+     * Use an array to exclude specific packages from the bundle.
+     * Default is `none`.
+     */
+    externalDependencies?: 'all' | 'none' | string[];
+    /**
+     * Extract CSS as an external file. Default is `true`.
+     */
+    extractCss?: boolean;
+    /**
+     * Extract licenses from 3rd party modules and add them to the output.
+     */
+    extractLicenses?: boolean;
+    /**
+     * Replace files at build time. e.g. `[{ "replace": "src/a.dev.ts", "with": "src/a.prod.ts" }]`
+     */
+    fileReplacements?: FileReplacement[];
+    /**
+     * Generate an `index.html` file if `index.html` is passed. Default is `true`
+     */
+    generateIndexHtml?: boolean;
+    /**
+     * Generate a `package.json` file for the bundle. Useful for Node applications.
+     */
+    generatePackageJson?: boolean;
+    /**
+     * Path to the `index.html`.
+     */
+    index?: string;
+    /**
+     * Mode to run the build in.
+     */
+    mode?: Mode;
+    /**
+     * Set the memory limit for the type-checking process. Default is `2048`.
+     */
+    memoryLimit?: number;
+    /**
+     * Use the source file name in output chunks. Useful for development or for Node.
+     */
+    namedChunks?: boolean;
+    /**
+     * Optimize the bundle using Terser.
+     */
+    optimization?: boolean | OptimizationOptions;
+    /**
+     * Specify the output filename for the bundle. Useful for Node applications that use `@nx/js:node` to serve.
+     */
+    outputFileName?: string;
+    /**
+     * Use file hashes in the output filenames. Recommended for production web applications.
+     */
+    outputHashing?: any;
+    /**
+     * Override `output.path` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
+    outputPath?: string;
+    /**
+     * Override `watchOptions.poll` in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
+    poll?: number;
+    /**
+     * The polyfill file to use. Useful for supporting legacy browsers. e.g. `src/polyfills.ts`
+     */
+    polyfills?: string;
+    /**
+     * Manually set the PostCSS configuration file. By default, PostCSS will look for `postcss.config.js` in the directory.
+     */
+    postcssConfig?: string;
+    /**
+     * Display build progress in the terminal.
+     */
+    progress?: boolean;
+    /**
+     * Add an additional chunk for the Webpack runtime. Defaults to `true` when `target === 'web'`.
+     */
+    runtimeChunk?: boolean;
+    /**
+     * External scripts that will be included before the main application entry.
+     */
+    scripts?: Array<ExtraEntryPointClass | string>;
+    /**
+     * Do not add a `overrides` and `resolutions` entries to the generated package.json file. Only works in conjunction with `generatePackageJson` option.
+     */
+    skipOverrides?: boolean;
+    /**
+     * Do not add a `packageManager` entry to the generated package.json file. Only works in conjunction with `generatePackageJson` option.
+     */
+    skipPackageManager?: boolean;
+    /**
+     * Skip type checking. Default is `false`.
+     */
+    skipTypeChecking?: boolean;
+    /**
+     * Skip type checking. Default is `false`.
+     */
+    typeCheck?: boolean;
+    /**
+     * Generate source maps.
+     */
+    sourceMap?: boolean | string;
+    /**
+     * When `true`, `process.env.NODE_ENV` will be excluded from the bundle. Useful for building a web application to run in a Node environment.
+     */
+    ssr?: boolean;
+    /**
+     * Generate a `stats.json` file which can be analyzed using tools such as `webpack-bundle-analyzer`.
+     */
+    statsJson?: boolean;
+    /**
+     * Options for the style preprocessor. e.g. `{ "includePaths": [] }` for SASS.
+     */
+    stylePreprocessorOptions?: any;
+    /**
+     * External stylesheets that will be included with the application.
+     */
+    styles?: Array<ExtraEntryPointClass | string>;
+    /**
+     * Enables the use of subresource integrity validation.
+     */
+    subresourceIntegrity?: boolean;
+    /**
+     * Override the `target` option in webpack configuration. This setting is not recommended and exists for backwards compatibility.
+     */
+    target?: string | string[];
+    /**
+     * List of TypeScript Compiler Transformers Plugins.
+     */
+    transformers?: TransformerEntry[];
+    /**
+     * Generate a separate vendor chunk for 3rd party packages.
+     */
+    vendorChunk?: boolean;
+    /**
+     * Log additional information for debugging purposes.
+     */
+    verbose?: boolean;
+    /**
+     * Watch for file changes.
+     */
+    watch?: boolean;
+    /**
+     * Set a public path for assets resources with absolute paths.
+     */
+    publicPath?: string;
+    /**
+     * Whether to rebase absolute path for assets in postcss cli resources.
+     */
+    rebaseRootRelative?: boolean;
+}
+export interface NormalizedNxAppRspackPluginOptions extends NxAppRspackPluginOptions {
+    projectName: string;
+    root: string;
+    projectRoot: string;
+    sourceRoot: string;
+    configurationName: string;
+    targetName: string;
+    projectGraph: ProjectGraph;
+    outputFileName: string;
+    assets: AssetGlobPattern[];
+}

package/src/plugins/utils/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/plugins/utils/normalize-entry.d.ts

@@ -0,0 +1,2 @@
+import { ExtraEntryPoint, NormalizedEntryPoint } from '../../utils/model';
+export declare function normalizeExtraEntryPoints(extraEntryPoints: ExtraEntryPoint[], defaultBundleName: string): NormalizedEntryPoint[];

package/src/plugins/utils/normalize-entry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExtraEntryPoints = normalizeExtraEntryPoints;
+function normalizeExtraEntryPoints(extraEntryPoints, defaultBundleName) {
+    return extraEntryPoints.map((entry) => {
+        let normalizedEntry;
+        if (typeof entry === 'string') {
+            normalizedEntry = {
+                input: entry,
+                inject: true,
+                bundleName: defaultBundleName,
+            };
+        }
+        else {
+            const { inject = true, ...newEntry } = entry;
+            let bundleName;
+            if (entry.bundleName) {
+                bundleName = entry.bundleName;
+            }
+            else {
+                bundleName = defaultBundleName;
+            }
+            normalizedEntry = { ...newEntry, bundleName };
+        }
+        return normalizedEntry;
+    });
+}

package/src/plugins/utils/plugins/postcss-cli-resources.d.ts

@@ -0,0 +1,14 @@
+import type { LoaderContext } from '@rspack/core';
+export interface PostcssCliResourcesOptions {
+    baseHref?: string;
+    deployUrl?: string;
+    resourcesOutputPath?: string;
+    rebaseRootRelative?: boolean;
+    filename: string;
+    loader: LoaderContext<unknown>;
+    publicPath: string;
+}
+export declare function PostcssCliResources(options: PostcssCliResourcesOptions): {
+    postcssPlugin: string;
+    Once(root: any): Promise<void[]>;
+};

package/src/plugins/utils/plugins/postcss-cli-resources.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostcssCliResources = PostcssCliResources;
+const tslib_1 = require("tslib");
+const loader_utils_1 = require("loader-utils");
+const path = tslib_1.__importStar(require("path"));
+const url = tslib_1.__importStar(require("node:url"));
+function wrapUrl(url) {
+    let wrappedUrl;
+    const hasSingleQuotes = url.indexOf("'") >= 0;
+    if (hasSingleQuotes) {
+        wrappedUrl = `"${url}"`;
+    }
+    else {
+        wrappedUrl = `'${url}'`;
+    }
+    return `url(${wrappedUrl})`;
+}
+async function resolve(file, base, resolver) {
+    try {
+        return await resolver(`./${file}`, base);
+    }
+    catch {
+        return resolver(file, base);
+    }
+}
+module.exports.postcss = true;
+function PostcssCliResources(options) {
+    const { deployUrl = '', baseHref = '', resourcesOutputPath = '', rebaseRootRelative = false, filename, loader, publicPath = '', } = options;
+    const dedupeSlashes = (url) => url.replace(/\/\/+/g, '/');
+    const process = async (inputUrl, context, resourceCache) => {
+        // If root-relative, absolute or protocol relative url, leave as is
+        if (/^((?:\w+:)?\/\/|data:|chrome:|#)/.test(inputUrl)) {
+            return inputUrl;
+        }
+        if (!rebaseRootRelative && /^\//.test(inputUrl)) {
+            return inputUrl;
+        }
+        // If starts with a caret, remove and return remainder
+        // this supports bypassing asset processing
+        if (inputUrl.startsWith('^')) {
+            return inputUrl.slice(1);
+        }
+        const cacheKey = path.resolve(context, inputUrl);
+        const cachedUrl = resourceCache.get(cacheKey);
+        if (cachedUrl) {
+            return cachedUrl;
+        }
+        if (inputUrl.startsWith('~')) {
+            inputUrl = inputUrl.slice(1);
+        }
+        if (inputUrl.startsWith('/')) {
+            let outputUrl = '';
+            if (deployUrl.match(/:\/\//) || deployUrl.startsWith('/')) {
+                // If deployUrl is absolute or root relative, ignore baseHref & use deployUrl as is.
+                outputUrl = `${deployUrl.replace(/\/$/, '')}${inputUrl}`;
+            }
+            else if (baseHref.match(/:\/\//)) {
+                // If baseHref contains a scheme, include it as is.
+                outputUrl =
+                    baseHref.replace(/\/$/, '') +
+                        dedupeSlashes(`/${deployUrl}/${inputUrl}`);
+            }
+            else {
+                // Join together base-href, deploy-url and the original URL.
+                outputUrl = dedupeSlashes(`/${baseHref}/${deployUrl}/${publicPath}/${inputUrl}`);
+            }
+            resourceCache.set(cacheKey, outputUrl);
+            return outputUrl;
+        }
+        const { pathname, hash, search } = url.parse(inputUrl.replace(/\\/g, '/'));
+        const resolver = (file, base) => new Promise((resolve, reject) => {
+            loader.resolve(base, decodeURI(file), (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+        const result = await resolve(pathname, context, resolver);
+        return new Promise((resolve, reject) => {
+            loader.fs.readFile(result, (err, content) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                let outputPath = (0, loader_utils_1.interpolateName)({ resourcePath: result }, filename, { content });
+                if (resourcesOutputPath) {
+                    outputPath = path.posix.join(resourcesOutputPath, outputPath);
+                }
+                loader.addDependency(result);
+                loader.emitFile(outputPath, content, undefined);
+                let outputUrl = outputPath.replace(/\\/g, '/');
+                if (hash || search) {
+                    outputUrl = url.format({ pathname: outputUrl, hash, search });
+                }
+                const loaderOptions = loader.loaders[loader.loaderIndex].options;
+                if (deployUrl && loaderOptions.ident !== 'extracted') {
+                    outputUrl = url.resolve(deployUrl, outputUrl);
+                }
+                resourceCache.set(cacheKey, outputUrl);
+                resolve(outputUrl);
+            });
+        });
+    };
+    return {
+        postcssPlugin: 'postcss-cli-resources',
+        Once(root) {
+            const urlDeclarations = [];
+            /**
+             * TODO: Explore if this can be rewritten using the new `Declaration()`
+             * listener added in postcss v8
+             */
+            root.walkDecls((decl) => {
+                if (decl.value && decl.value.includes('url')) {
+                    urlDeclarations.push(decl);
+                }
+            });
+            if (urlDeclarations.length === 0) {
+                return;
+            }
+            const resourceCache = new Map();
+            return Promise.all(urlDeclarations.map(async (decl) => {
+                const value = decl.value;
+                const urlRegex = /url(?:\(\s*(['"]?))(.*?)(?:\1\s*\))/g;
+                const segments = [];
+                let match;
+                let lastIndex = 0;
+                let modified = false;
+                // We want to load it relative to the file that imports
+                const inputFile = decl.source && decl.source.input.file;
+                const context = (inputFile && path.dirname(inputFile)) || loader.context;
+                while ((match = urlRegex.exec(value))) {
+                    const originalUrl = match[2];
+                    let processedUrl;
+                    try {
+                        processedUrl = await process(originalUrl, context, resourceCache);
+                    }
+                    catch (err) {
+                        loader.emitError(decl.error(err.message, { word: originalUrl }));
+                        continue;
+                    }
+                    if (lastIndex < match.index) {
+                        segments.push(value.slice(lastIndex, match.index));
+                    }
+                    if (!processedUrl || originalUrl === processedUrl) {
+                        segments.push(match[0]);
+                    }
+                    else {
+                        segments.push(wrapUrl(processedUrl));
+                        modified = true;
+                    }
+                    lastIndex = match.index + match[0].length;
+                }
+                if (lastIndex < value.length) {
+                    segments.push(value.slice(lastIndex));
+                }
+                if (modified) {
+                    decl.value = segments.join('');
+                }
+            }));
+        },
+    };
+}

package/src/plugins/utils/plugins/scripts-rspack-plugin.d.ts

@@ -0,0 +1,16 @@
+import { type Compiler } from '@rspack/core';
+export interface ScriptsRspackPluginOptions {
+    name: string;
+    sourceMap: boolean;
+    scripts: string[];
+    filename: string;
+    basePath: string;
+}
+export declare class ScriptsRspackPlugin {
+    private options;
+    private _lastBuildTime?;
+    private _cachedOutput?;
+    constructor(options?: Partial<ScriptsRspackPluginOptions>);
+    private _insertOutput;
+    apply(compiler: Compiler): void;
+}

package/src/plugins/utils/plugins/scripts-rspack-plugin.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptsRspackPlugin = void 0;
+const tslib_1 = require("tslib");
+const loader_utils_1 = require("loader-utils");
+const path = tslib_1.__importStar(require("path"));
+const core_1 = require("@rspack/core");
+function addDependencies(compilation, scripts) {
+    for (const script of scripts) {
+        compilation.fileDependencies.add(script);
+    }
+}
+function hook(compiler, action) {
+    compiler.hooks.thisCompilation.tap('scripts-rspack-plugin', (compilation) => {
+        compilation.hooks.additionalAssets.tapAsync('scripts-rspack-plugin', (callback) => action(compilation, callback));
+    });
+}
+class ScriptsRspackPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    _insertOutput(compiler, compilation, { filename, source }, cached = false) {
+        new core_1.EntryPlugin(compiler.context, this.options.name).apply(compiler);
+        compilation.assets[filename] = source;
+    }
+    apply(compiler) {
+        if (!this.options.scripts || this.options.scripts.length === 0) {
+            return;
+        }
+        const scripts = this.options.scripts
+            .filter((script) => !!script)
+            .map((script) => path.resolve(this.options.basePath || '', script));
+        hook(compiler, (compilation, callback) => {
+            const sourceGetters = scripts.map((fullPath) => {
+                return new Promise((resolve, reject) => {
+                    compilation.inputFileSystem.readFile(fullPath, (err, data) => {
+                        if (err) {
+                            reject(err);
+                            return;
+                        }
+                        const content = data.toString();
+                        let source;
+                        if (this.options.sourceMap) {
+                            // TODO: Look for source map file (for '.min' scripts, etc.)
+                            let adjustedPath = fullPath;
+                            if (this.options.basePath) {
+                                adjustedPath = path.relative(this.options.basePath, fullPath);
+                            }
+                            source = new core_1.sources.OriginalSource(content, adjustedPath);
+                        }
+                        else {
+                            source = new core_1.sources.RawSource(content);
+                        }
+                        resolve(source);
+                    });
+                });
+            });
+            Promise.all(sourceGetters)
+                .then((_sources) => {
+                const concatSource = new core_1.sources.ConcatSource();
+                _sources.forEach((source) => {
+                    concatSource.add(source);
+                    concatSource.add('\n;');
+                });
+                const combinedSource = new core_1.sources.CachedSource(concatSource);
+                const filename = (0, loader_utils_1.interpolateName)({ resourcePath: 'scripts.js' }, this.options.filename, { content: combinedSource.source() });
+                const output = { filename, source: combinedSource };
+                this._insertOutput(compiler, compilation, output);
+                this._cachedOutput = output;
+                addDependencies(compilation, scripts);
+                callback();
+            })
+                .catch((err) => callback(err));
+        });
+    }
+}
+exports.ScriptsRspackPlugin = ScriptsRspackPlugin;

package/src/utils/config.d.ts

@@ -1,10 +1,10 @@
-import type { ExecutorContext } from '@nx/devkit';
+import { ExecutorContext } from '@nx/devkit';
 import type { Configuration } from '@rspack/core';
-import { SharedConfigContext } from './model';
+import { NormalizedRspackExecutorSchema } from '../executors/rspack/schema';
 export declare const nxRspackComposablePlugin = "nxRspackComposablePlugin";
 export declare function isNxRspackComposablePlugin(a: unknown): a is AsyncNxComposableRspackPlugin;
 export interface NxRspackExecutionContext {
-    options: unknown;
+    options: NormalizedRspackExecutorSchema;
     context: ExecutorContext;
     configuration?: string;
 }
@@ -14,4 +14,9 @@ export interface NxComposableRspackPlugin {
 export interface AsyncNxComposableRspackPlugin {
     (config: Configuration, ctx: NxRspackExecutionContext): Configuration | Promise<Configuration>;
 }
-export declare function composePlugins(...plugins: any[]): (config: Configuration, ctx: SharedConfigContext) => Promise<Configuration>;
+export declare function composePlugins(...plugins: (NxComposableRspackPlugin | AsyncNxComposableRspackPlugin | Promise<NxComposableRspackPlugin | AsyncNxComposableRspackPlugin>)[]): ((config: Configuration, ctx: NxRspackExecutionContext) => Promise<Configuration>) & {
+    nxRspackComposablePlugin: boolean;
+};
+export declare function composePluginsSync(...plugins: NxComposableRspackPlugin[]): ((config: Configuration, ctx: NxRspackExecutionContext) => Configuration) & {
+    nxRspackComposablePlugin: boolean;
+};