@nx/rspack 0.0.0-pr-28218-5048fd1

package/src/executors/module-federation-static-server/module-federation-static-server.impl.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startProxies = startProxies;
+exports.default = moduleFederationStaticServer;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const file_server_impl_1 = tslib_1.__importDefault(require("@nx/web/src/executors/file-server/file-server.impl"));
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const module_federation_1 = require("../../utils/module-federation");
+const build_static_remotes_1 = require("../../utils/module-federation/build-static.remotes");
+const parse_static_remotes_config_1 = require("../../utils/module-federation/parse-static-remotes-config");
+function getBuildAndServeOptionsFromServeTarget(serveTarget, context) {
+    const target = (0, devkit_1.parseTargetString)(serveTarget, context);
+    const serveOptions = (0, devkit_1.readTargetOptions)(target, context);
+    const buildTarget = (0, devkit_1.parseTargetString)(serveOptions.buildTarget, context);
+    const buildOptions = (0, devkit_1.readTargetOptions)(buildTarget, context);
+    let pathToManifestFile = (0, path_1.join)(context.root, context.projectGraph.nodes[context.projectName].data.sourceRoot, 'assets/module-federation.manifest.json');
+    if (serveOptions.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, serveOptions.pathToManifestFile);
+        if (!(0, fs_1.existsSync)(userPathToManifestFile)) {
+            throw new Error(`The provided Module Federation manifest file path does not exist. Please check the file exists at "${userPathToManifestFile}".`);
+        }
+        else if ((0, path_1.extname)(serveOptions.pathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    return {
+        buildTarget,
+        buildOptions,
+        serveOptions,
+        pathToManifestFile,
+    };
+}
+async function buildHost(nxBin, buildTarget, context) {
+    await new Promise((res, rej) => {
+        const staticProcess = (0, child_process_1.fork)(nxBin, [
+            `run`,
+            `${buildTarget.project}:${buildTarget.target}${buildTarget.configuration
+                ? `:${buildTarget.configuration}`
+                : context.configurationName
+                    ? `:${context.configurationName}`
+                    : ''}`,
+        ], {
+            cwd: context.root,
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        });
+        staticProcess.stdout.on('data', (data) => {
+            const ANSII_CODE_REGEX = 
+            // eslint-disable-next-line no-control-regex
+            /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+            const stdoutString = data.toString().replace(ANSII_CODE_REGEX, '');
+            // in addition to writing into the stdout stream, also show error directly in console
+            // so the error is easily discoverable. 'ERROR in' is the key word to search in webpack output.
+            if (stdoutString.includes('ERROR in')) {
+                devkit_1.logger.log(stdoutString);
+            }
+            if (stdoutString.includes('Successfully ran target build')) {
+                staticProcess.stdout.removeAllListeners('data');
+                devkit_1.logger.info(`NX Built host`);
+                res();
+            }
+        });
+        staticProcess.stderr.on('data', (data) => devkit_1.logger.info(data.toString()));
+        staticProcess.once('exit', (code) => {
+            staticProcess.stdout.removeAllListeners('data');
+            staticProcess.stderr.removeAllListeners('data');
+            if (code !== 0) {
+                rej(`Host failed to build. See above for details.`);
+            }
+            else {
+                res();
+            }
+        });
+        process.on('SIGTERM', () => staticProcess.kill('SIGTERM'));
+        process.on('exit', () => staticProcess.kill('SIGTERM'));
+    });
+}
+function moveToTmpDirectory(staticRemotesConfig, hostOutputPath, hostUrlSegment) {
+    const commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-module-federation');
+    for (const app of staticRemotesConfig.remotes) {
+        const remoteConfig = staticRemotesConfig.config[app];
+        (0, fs_1.cpSync)(remoteConfig.outputPath, (0, path_1.join)(commonOutputDirectory, remoteConfig.urlSegment), {
+            force: true,
+            recursive: true,
+        });
+    }
+    (0, fs_1.cpSync)(hostOutputPath, (0, path_1.join)(commonOutputDirectory, hostUrlSegment), {
+        force: true,
+        recursive: true,
+    });
+    const cleanup = () => {
+        (0, fs_1.rmSync)(commonOutputDirectory, { force: true, recursive: true });
+    };
+    process.on('SIGTERM', () => {
+        cleanup();
+    });
+    process.on('exit', () => {
+        cleanup();
+    });
+    return commonOutputDirectory;
+}
+function startProxies(staticRemotesConfig, hostServeOptions, mappedLocationOfHost, mappedLocationsOfRemotes, sslOptions) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { createProxyMiddleware } = require('http-proxy-middleware');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const express = require('express');
+    let sslCert;
+    let sslKey;
+    if (sslOptions && sslOptions.pathToCert && sslOptions.pathToKey) {
+        if ((0, fs_1.existsSync)(sslOptions.pathToCert) && (0, fs_1.existsSync)(sslOptions.pathToKey)) {
+            sslCert = (0, fs_1.readFileSync)(sslOptions.pathToCert);
+            sslKey = (0, fs_1.readFileSync)(sslOptions.pathToKey);
+        }
+        else {
+            devkit_1.logger.warn(`Encountered SSL options in project.json, however, the certificate files do not exist in the filesystem. Using http.`);
+            devkit_1.logger.warn(`Attempted to find '${sslOptions.pathToCert}' and '${sslOptions.pathToKey}'.`);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const http = require('http');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const https = require('https');
+    devkit_1.logger.info(`NX Starting static remotes proxies...`);
+    for (const app of staticRemotesConfig.remotes) {
+        const expressProxy = express();
+        expressProxy.use(createProxyMiddleware({
+            target: mappedLocationsOfRemotes[app],
+            changeOrigin: true,
+            secure: sslCert ? false : undefined,
+        }));
+        const proxyServer = (sslCert ? https : http)
+            .createServer({ cert: sslCert, key: sslKey }, expressProxy)
+            .listen(staticRemotesConfig.config[app].port);
+        process.on('SIGTERM', () => proxyServer.close());
+        process.on('exit', () => proxyServer.close());
+    }
+    devkit_1.logger.info(`NX Static remotes proxies started successfully`);
+    devkit_1.logger.info(`NX Starting static host proxy...`);
+    const expressProxy = express();
+    expressProxy.use(createProxyMiddleware({
+        target: mappedLocationOfHost,
+        changeOrigin: true,
+        secure: sslCert ? false : undefined,
+        pathRewrite: (path) => {
+            let pathRewrite = path;
+            for (const app of staticRemotesConfig.remotes) {
+                if (path.endsWith(app)) {
+                    pathRewrite = '/';
+                    break;
+                }
+            }
+            return pathRewrite;
+        },
+    }));
+    const proxyServer = (sslCert ? https : http)
+        .createServer({ cert: sslCert, key: sslKey }, expressProxy)
+        .listen(hostServeOptions.port);
+    process.on('SIGTERM', () => proxyServer.close());
+    process.on('exit', () => proxyServer.close());
+    devkit_1.logger.info('NX Static host proxy started successfully');
+}
+async function* moduleFederationStaticServer(schema, context) {
+    // Force Node to resolve to look for the nx binary that is inside node_modules
+    const nxBin = require.resolve('nx/bin/nx');
+    // Get the remotes from the module federation config
+    const p = context.projectsConfigurations.projects[context.projectName];
+    const options = getBuildAndServeOptionsFromServeTarget(schema.serveTarget, context);
+    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(options.buildOptions.tsConfig, context.root, p.root, 'react');
+    const remotes = (0, module_federation_1.getRemotes)([], options.serveOptions.skipRemotes, moduleFederationConfig, {
+        projectName: context.projectName,
+        projectGraph: context.projectGraph,
+        root: context.root,
+    }, options.pathToManifestFile);
+    const staticRemotesConfig = (0, parse_static_remotes_config_1.parseStaticRemotesConfig)([...remotes.staticRemotes, ...remotes.dynamicRemotes], context);
+    options.serveOptions.staticRemotesPort ??= remotes.staticRemotePort;
+    const mappedLocationsOfStaticRemotes = await (0, build_static_remotes_1.buildStaticRemotes)(staticRemotesConfig, nxBin, context, options.serveOptions);
+    // Build the host
+    const hostUrlSegment = (0, path_1.basename)(options.buildOptions.outputPath);
+    const mappedLocationOfHost = `http${options.serveOptions.ssl ? 's' : ''}://${options.serveOptions.host}:${options.serveOptions.staticRemotesPort}/${hostUrlSegment}`;
+    await buildHost(nxBin, options.buildTarget, context);
+    // Move to a temporary directory
+    const commonOutputDirectory = moveToTmpDirectory(staticRemotesConfig, options.buildOptions.outputPath, hostUrlSegment);
+    // File Serve the temporary directory
+    const staticFileServerIter = (0, file_server_impl_1.default)({
+        cors: true,
+        watch: false,
+        staticFilePath: commonOutputDirectory,
+        parallel: false,
+        spa: false,
+        withDeps: false,
+        host: options.serveOptions.host,
+        port: options.serveOptions.staticRemotesPort,
+        ssl: options.serveOptions.ssl,
+        sslCert: options.serveOptions.sslCert,
+        sslKey: options.serveOptions.sslKey,
+        cacheSeconds: -1,
+    }, context);
+    // express proxy all of it
+    startProxies(staticRemotesConfig, options.serveOptions, mappedLocationOfHost, mappedLocationsOfStaticRemotes, options.serveOptions.ssl
+        ? {
+            pathToCert: (0, path_1.join)(devkit_1.workspaceRoot, options.serveOptions.sslCert),
+            pathToKey: (0, path_1.join)(devkit_1.workspaceRoot, options.serveOptions.sslKey),
+        }
+        : undefined);
+    return yield* (0, async_iterable_1.combineAsyncIterables)(staticFileServerIter, (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        const host = options.serveOptions.host ?? 'localhost';
+        const baseUrl = `http${options.serveOptions.ssl ? 's' : ''}://${host}:${options.serveOptions.port}`;
+        if (remotes.remotePorts.length === 0) {
+            const portsToWaitFor = [options.serveOptions.staticRemotesPort];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: host,
+            })));
+            devkit_1.logger.info(`NX Server ready at ${baseUrl}`);
+            next({ success: true, baseUrl: baseUrl });
+            done();
+            return;
+        }
+        try {
+            const portsToWaitFor = staticFileServerIter
+                ? [options.serveOptions.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: host,
+            })));
+            devkit_1.logger.info(`NX Server ready at ${baseUrl}`);
+            next({ success: true, baseUrl: baseUrl });
+        }
+        catch (err) {
+            throw new Error(`Failed to start. Check above for any errors.`);
+        }
+        finally {
+            done();
+        }
+    }));
+}

package/src/executors/module-federation-static-server/schema.d.ts

@@ -0,0 +1,3 @@
+export interface ModuleFederationStaticServerSchema {
+  serveTarget: string;
+}

package/src/executors/module-federation-static-server/schema.json

@@ -0,0 +1,14 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Module Federation Static Dev Server",
+  "description": "Serve a host application statically along with it's remotes.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "serveTarget": {
+      "type": "string"
+    }
+  },
+  "required": ["serveTarget"]
+}

package/src/executors/rspack/rspack.impl.d.ts

@@ -0,0 +1,6 @@
+import { ExecutorContext } from '@nx/devkit';
+import { RspackExecutorSchema } from './schema';
+export default function runExecutor(options: RspackExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    outfile?: string;
+}, void, undefined>;

package/src/executors/rspack/rspack.impl.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runExecutor;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const js_1 = require("@nx/js");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const create_compiler_1 = require("../../utils/create-compiler");
+const mode_utils_1 = require("../../utils/mode-utils");
+async function* runExecutor(options, context) {
+    process.env.NODE_ENV ??= options.mode ?? 'production';
+    if ((0, mode_utils_1.isMode)(process.env.NODE_ENV)) {
+        options.mode = process.env.NODE_ENV;
+    }
+    if (options.typeCheck) {
+        await executeTypeCheck(options, context);
+    }
+    // Mimic --clean from webpack.
+    (0, fs_1.rmSync)(path.join(context.root, options.outputPath), {
+        force: true,
+        recursive: true,
+    });
+    const compiler = await (0, create_compiler_1.createCompiler)(options, context);
+    const iterable = (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        if (options.watch) {
+            const watcher = compiler.watch({}, async (err, stats) => {
+                if (err) {
+                    devkit_1.logger.error(err);
+                    next({ success: false });
+                    return;
+                }
+                if (!compiler || !stats) {
+                    devkit_1.logger.error(new Error('Compiler or stats not available'));
+                    next({ success: false });
+                    return;
+                }
+                const statsOptions = getStatsOptions(compiler);
+                const printedStats = stats.toString(statsOptions);
+                // Avoid extra empty line when `stats: 'none'`
+                if (printedStats) {
+                    console.error(printedStats);
+                }
+                next({
+                    success: !stats.hasErrors(),
+                    outfile: path.resolve(context.root, options.outputPath, 'main.js'),
+                });
+            });
+            registerCleanupCallback(() => {
+                watcher.close(() => {
+                    devkit_1.logger.info('Watcher closed');
+                });
+            });
+        }
+        else {
+            compiler.run(async (err, stats) => {
+                compiler.close(() => {
+                    if (err) {
+                        devkit_1.logger.error(err);
+                        next({ success: false });
+                        return;
+                    }
+                    if (!compiler || !stats) {
+                        devkit_1.logger.error(new Error('Compiler or stats not available'));
+                        next({ success: false });
+                        return;
+                    }
+                    const statsOptions = getStatsOptions(compiler);
+                    const printedStats = stats.toString(statsOptions);
+                    // Avoid extra empty line when `stats: 'none'`
+                    if (printedStats) {
+                        console.error(printedStats);
+                    }
+                    next({
+                        success: !stats.hasErrors(),
+                        outfile: path.resolve(context.root, options.outputPath, 'main.js'),
+                    });
+                    done();
+                });
+            });
+        }
+    });
+    yield* iterable;
+}
+// copied from packages/esbuild/src/executors/esbuild/esbuild.impl.ts
+function registerCleanupCallback(callback) {
+    const wrapped = () => {
+        callback();
+        process.off('SIGINT', wrapped);
+        process.off('SIGTERM', wrapped);
+        process.off('exit', wrapped);
+    };
+    process.on('SIGINT', wrapped);
+    process.on('SIGTERM', wrapped);
+    process.on('exit', wrapped);
+}
+async function executeTypeCheck(options, context) {
+    const projectConfiguration = context.projectGraph.nodes[context.projectName].data;
+    const result = await (0, js_1.runTypeCheck)({
+        workspaceRoot: path.resolve(projectConfiguration.root),
+        tsConfigPath: options.tsConfig,
+        mode: 'noEmit',
+    });
+    await (0, js_1.printDiagnostics)(result.errors, result.warnings);
+    if (result.errors.length > 0) {
+        throw new Error('Found type errors. See above.');
+    }
+}
+function getStatsOptions(compiler) {
+    return (0, create_compiler_1.isMultiCompiler)(compiler)
+        ? {
+            children: compiler.compilers.map((compiler) => compiler.options ? compiler.options.stats : undefined),
+        }
+        : compiler.options
+            ? compiler.options.stats
+            : undefined;
+}

package/src/executors/rspack/schema.d.ts

@@ -0,0 +1,34 @@
+import type { Mode } from '@rspack/core';
+
+export interface RspackExecutorSchema {
+  target: 'web' | 'node';
+  main: string;
+  index?: string;
+  tsConfig: string;
+  typeCheck?: boolean;
+  outputPath: string;
+  outputFileName?: string;
+  indexHtml?: string;
+  mode?: Mode;
+  watch?: boolean;
+  baseHref?: string;
+  deployUrl?: string;
+
+  rspackConfig: string;
+  optimization?: boolean | OptimizationOptions;
+  sourceMap?: boolean | string;
+  assets?: any[];
+  extractLicenses?: boolean;
+  fileReplacements?: FileReplacement[];
+  generatePackageJson?: boolean;
+}
+
+export interface FileReplacement {
+  replace: string;
+  with: string;
+}
+
+export interface OptimizationOptions {
+  scripts: boolean;
+  styles: boolean;
+}

package/src/executors/rspack/schema.json

@@ -0,0 +1,177 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "Rspack build executor",
+  "description": "Run Rspack via an executor for a project.",
+  "type": "object",
+  "properties": {
+    "target": {
+      "type": "string",
+      "description": "The platform to target (e.g. web, node).",
+      "enum": ["web", "node"]
+    },
+    "main": {
+      "type": "string",
+      "description": "The main entry file."
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The output path for the bundle."
+    },
+    "outputFileName": {
+      "type": "string",
+      "description": "The main output entry file"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The tsconfig file to build the project."
+    },
+    "typeCheck": {
+      "type": "boolean",
+      "description": "Skip the type checking."
+    },
+    "indexHtml": {
+      "type": "string",
+      "description": "The path to the index.html file."
+    },
+    "index": {
+      "type": "string",
+      "description": "HTML File which will be contain the application.",
+      "x-completion-type": "file",
+      "x-completion-glob": "**/*@(.html|.htm)"
+    },
+    "baseHref": {
+      "type": "string",
+      "description": "Base url for the application being built."
+    },
+    "deployUrl": {
+      "type": "string",
+      "description": "URL where the application will be deployed."
+    },
+    "rspackConfig": {
+      "type": "string",
+      "description": "The path to the rspack config file."
+    },
+    "optimization": {
+      "description": "Enables optimization of the build output.",
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "scripts": {
+              "type": "boolean",
+              "description": "Enables optimization of the scripts output.",
+              "default": true
+            },
+            "styles": {
+              "type": "boolean",
+              "description": "Enables optimization of the styles output.",
+              "default": true
+            }
+          },
+          "additionalProperties": false
+        },
+        {
+          "type": "boolean"
+        }
+      ]
+    },
+    "sourceMap": {
+      "description": "Output sourcemaps. Use 'hidden' for use with error reporting tools without generating sourcemap comment.",
+      "default": true,
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    },
+    "assets": {
+      "type": "array",
+      "description": "List of static application assets.",
+      "default": [],
+      "items": {
+        "$ref": "#/definitions/assetPattern"
+      }
+    },
+    "extractLicenses": {
+      "type": "boolean",
+      "description": "Extract all licenses in a separate file.",
+      "default": true
+    },
+    "fileReplacements": {
+      "description": "Replace files with other files in the build.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "replace": {
+            "type": "string",
+            "description": "The file to be replaced.",
+            "x-completion-type": "file"
+          },
+          "with": {
+            "type": "string",
+            "description": "The file to replace with.",
+            "x-completion-type": "file"
+          }
+        },
+        "additionalProperties": false,
+        "required": ["replace", "with"]
+      },
+      "default": []
+    },
+    "mode": {
+      "type": "string",
+      "description": "Mode to run the build in.",
+      "enum": ["development", "production", "none"]
+    },
+    "generatePackageJson": {
+      "type": "boolean",
+      "description": "Generates a `package.json` and pruned lock file with the project's `node_module` dependencies populated for installing in a container. If a `package.json` exists in the project's directory, it will be reused with dependencies populated."
+    }
+  },
+  "required": ["target", "main", "outputPath", "tsConfig", "rspackConfig"],
+  "definitions": {
+    "assetPattern": {
+      "oneOf": [
+        {
+          "type": "object",
+          "properties": {
+            "glob": {
+              "type": "string",
+              "description": "The pattern to match."
+            },
+            "input": {
+              "type": "string",
+              "description": "The input directory path in which to apply 'glob'. Defaults to the project root."
+            },
+            "ignore": {
+              "description": "An array of globs to ignore.",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "output": {
+              "type": "string",
+              "description": "Absolute path within the output."
+            },
+            "watch": {
+              "type": "boolean",
+              "description": "Enable re-building when files change.",
+              "default": false
+            }
+          },
+          "additionalProperties": false,
+          "required": ["glob", "input", "output"]
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  }
+}

package/src/executors/ssr-dev-server/lib/wait-until-server-is-listening.d.ts

@@ -0,0 +1 @@
+export declare function waitUntilServerIsListening(port: number): Promise<void>;

package/src/executors/ssr-dev-server/lib/wait-until-server-is-listening.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilServerIsListening = waitUntilServerIsListening;
+const tslib_1 = require("tslib");
+const net = tslib_1.__importStar(require("net"));
+function waitUntilServerIsListening(port) {
+    const allowedErrorCodes = ['ECONNREFUSED', 'ECONNRESET'];
+    const maxAttempts = 25;
+    let attempts = 0;
+    const client = new net.Socket();
+    const cleanup = () => {
+        client.removeAllListeners('connect');
+        client.removeAllListeners('error');
+        client.end();
+        client.destroy();
+        client.unref();
+    };
+    return new Promise((resolve, reject) => {
+        const listen = () => {
+            client.once('connect', () => {
+                cleanup();
+                resolve();
+            });
+            client.on('error', (err) => {
+                if (attempts > maxAttempts ||
+                    !allowedErrorCodes.includes(err['code'])) {
+                    cleanup();
+                    reject(err);
+                }
+                else {
+                    attempts++;
+                    setTimeout(listen, 100 * attempts);
+                }
+            });
+            client.connect({ port, host: 'localhost' });
+        };
+        listen();
+    });
+}

package/src/executors/ssr-dev-server/schema.d.ts

@@ -0,0 +1,11 @@
+interface TargetOptions {
+  [key: string]: string | boolean | number | TargetOptions;
+}
+
+export interface RspackSsrDevServerOptions {
+  browserTarget: string;
+  serverTarget: string;
+  port: number;
+  browserTargetOptions: TargetOptions;
+  serverTargetOptions: TargetOptions;
+}