@rsbuild/core 0.1.9 → 0.2.0

package/dist/server/devServer.d.ts

@@ -1,30 +1,17 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Server } from 'http';
-import type { ListenOptions } from 'net';
-import { RsbuildDevServerOptions, CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
-import connect from '@rsbuild/shared/connect';
+import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPI } from '@rsbuild/shared';
 import type { Context } from '../types';
-export declare class RsbuildDevServer {
-  private readonly dev;
-  private readonly devMiddleware;
-  private pwd;
-  private app;
-  private output;
-  middlewares: connect.Server;
-  constructor(options: RsbuildDevServerOptions);
-  private applySetupMiddlewares;
-  onInit(app: Server): Promise<void>;
-  private applyDefaultMiddlewares;
-  createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
-  listen(options?: number | ListenOptions | undefined, listener?: (err?: Error) => Promise<void>): void;
-  close(): void;
-}
-export declare function startDevServer<Options extends {
+export declare function createDevServer<Options extends {
   context: Context;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
   compiler: customCompiler,
+  getPortSilently
+}?: StartDevServerOptions & {
+  defaultPort?: number;
+}): Promise<DevServerAPI>;
+export declare function startDevServer<Options extends {
+  context: Context;
+}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, {
+  compiler,
   printURLs,
   logger: customLogger,
   getPortSilently

package/dist/server/devServer.js

@@ -28,189 +28,96 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var devServer_exports = {};
 __export(devServer_exports, {
-  RsbuildDevServer: () => RsbuildDevServer,
+  createDevServer: () => createDevServer,
   startDevServer: () => startDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
-var import_http = require("http");
-var import_https = require("https");
-var import_url = __toESM(require("url"));
 var import_shared = require("@rsbuild/shared");
-var import_dev_middleware = __toESM(require("./dev-middleware"));
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
-var import_middlewares = require("./middlewares");
-var import_path = require("path");
 var import_restart = require("./restart");
-class RsbuildDevServer {
-  constructor(options) {
-    this.middlewares = (0, import_connect.default)();
-    this.pwd = options.pwd;
-    this.dev = options.dev;
-    this.output = options.output;
-    this.devMiddleware = new import_dev_middleware.default({
-      dev: this.dev,
-      publicPaths: options.output.publicPaths,
-      devMiddleware: options.devMiddleware
-    });
-  }
-  applySetupMiddlewares() {
-    const setupMiddlewares = this.dev.setupMiddlewares || [];
-    const serverOptions = {
-      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
-    };
-    const before = [];
-    const after = [];
-    setupMiddlewares.forEach((handler) => {
-      handler(
-        {
-          unshift: (...handlers) => before.unshift(...handlers),
-          push: (...handlers) => after.push(...handlers)
-        },
-        serverOptions
-      );
-    });
-    return { before, after };
-  }
-  // Complete the preparation of services
-  async onInit(app) {
-    this.app = app;
-    const { before, after } = this.applySetupMiddlewares();
-    before.forEach((fn) => this.middlewares.use(fn));
-    await this.applyDefaultMiddlewares(app);
-    after.forEach((fn) => this.middlewares.use(fn));
-  }
-  async applyDefaultMiddlewares(app) {
-    const { dev, devMiddleware } = this;
-    if (dev.compress) {
-      const { default: compression } = await Promise.resolve().then(() => __toESM(require("../../compiled/http-compression")));
-      this.middlewares.use((req, res, next) => {
-        compression({
-          gzip: true,
-          brotli: false
-        })(req, res, next);
-      });
-    }
-    this.middlewares.use((req, res, next) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      const path = req.url ? import_url.default.parse(req.url).pathname : "";
-      if (path?.includes("hot-update")) {
-        res.setHeader("Access-Control-Allow-Credentials", "false");
-      }
-      const confHeaders = dev.headers;
-      if (confHeaders) {
-        for (const [key, value] of Object.entries(confHeaders)) {
-          res.setHeader(key, value);
-        }
-      }
-      next();
-    });
-    if (dev.proxy) {
-      const { createProxyMiddleware } = await Promise.resolve().then(() => __toESM(require("./proxy")));
-      const { middlewares } = createProxyMiddleware(dev.proxy, app);
-      middlewares.forEach((middleware) => {
-        this.middlewares.use(middleware);
-      });
-    }
-    devMiddleware.init(app);
-    devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
-    if (dev.publicDir && dev.publicDir.name) {
-      const { default: sirv } = await Promise.resolve().then(() => __toESM(require("../../compiled/sirv")));
-      const { name } = dev.publicDir;
-      const publicDir = (0, import_path.isAbsolute)(name) ? name : (0, import_path.join)(this.pwd, name);
-      const assetMiddleware = sirv(publicDir, {
-        etag: true,
-        dev: true
-      });
-      this.middlewares.use(assetMiddleware);
-    }
-    const { distPath } = this.output;
-    this.middlewares.use(
-      (0, import_middlewares.getHtmlFallbackMiddleware)({
-        distPath: (0, import_path.isAbsolute)(distPath) ? distPath : (0, import_path.join)(this.pwd, distPath),
-        callback: devMiddleware.middleware,
-        htmlFallback: this.dev.htmlFallback
-      })
-    );
-    if (dev.historyApiFallback) {
-      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("../../compiled/connect-history-api-fallback")));
-      const historyApiFallbackMiddleware = connectHistoryApiFallback(
-        dev.historyApiFallback === true ? {} : dev.historyApiFallback
-      );
-      this.middlewares.use(historyApiFallbackMiddleware);
-      devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
-    }
-    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
-    this.middlewares.use(import_middlewares.notFoundMiddleware);
-  }
-  async createHTTPServer() {
-    const { dev } = this;
-    const devHttpsOption = typeof dev === "object" && dev.https;
-    if (devHttpsOption) {
-      return (0, import_https.createServer)(devHttpsOption, this.middlewares);
-    } else {
-      return (0, import_http.createServer)(this.middlewares);
-    }
-  }
-  listen(options, listener) {
-    const callback = () => {
-      listener?.();
-    };
-    if (typeof options === "object") {
-      this.app.listen(options, callback);
-    } else {
-      this.app.listen(options || 8080, callback);
-    }
-  }
-  close() {
-    this.devMiddleware.close();
-    this.app.close();
-  }
-}
-async function startDevServer(options, createDevMiddleware, {
+var import_httpServer = require("./httpServer");
+var import_devMiddlewares = require("./devMiddlewares");
+async function createDevServer(options, createDevMiddleware, {
   compiler: customCompiler,
-  printURLs = true,
-  logger: customLogger,
   getPortSilently
 } = {}) {
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
   const rsbuildConfig = options.context.config;
-  const logger = customLogger ?? import_shared.logger;
   const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
     rsbuildConfig,
     getPortSilently
   });
+  const defaultRoutes = (0, import_shared.formatRoutes)(
+    options.context.entry,
+    rsbuildConfig.output?.distPath?.html,
+    rsbuildConfig.html?.outputStructure
+  );
   options.context.devServer = {
     hostname: host,
     port,
     https
   };
-  const protocol = https ? "https" : "http";
-  let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
-  const routes = (0, import_shared.formatRoutes)(
-    options.context.entry,
-    rsbuildConfig.output?.distPath?.html,
-    rsbuildConfig.html?.outputStructure
-  );
-  (0, import_shared.debug)("create dev server");
   const { devMiddleware, compiler } = await createDevMiddleware(
     options,
     customCompiler
   );
   const publicPaths = compiler.compilers ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
-  const server = new RsbuildDevServer({
-    pwd: options.context.rootPath,
-    devMiddleware,
-    dev: devServerConfig,
-    output: {
-      distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
-      publicPaths
-    }
+  return {
+    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes },
+    beforeStart: async () => {
+      await options.context.hooks.onBeforeStartDevServerHook.call();
+    },
+    afterStart: async ({ port: port2, routes }) => {
+      await options.context.hooks.onAfterStartDevServerHook.call({
+        port: port2,
+        routes
+      });
+    },
+    getMiddlewares: async ({
+      dev,
+      app
+    }) => await (0, import_devMiddlewares.getMiddlewares)(
+      {
+        pwd: options.context.rootPath,
+        devMiddleware,
+        dev,
+        output: {
+          distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR,
+          publicPaths
+        }
+      },
+      app
+    )
+  };
+}
+async function startDevServer(options, createDevMiddleware, {
+  compiler,
+  printURLs = true,
+  logger: customLogger,
+  getPortSilently
+} = {}) {
+  (0, import_shared.debug)("create dev server");
+  const rsbuildServer = await createDevServer(options, createDevMiddleware, {
+    compiler,
+    printURLs,
+    logger: customLogger,
+    getPortSilently
+  });
+  const {
+    resolvedConfig: { devServerConfig, port, host, https, defaultRoutes }
+  } = rsbuildServer;
+  const logger = customLogger ?? import_shared.logger;
+  const middlewares = (0, import_connect.default)();
+  const httpServer = await (0, import_httpServer.createHttpServer)({
+    https: devServerConfig.https,
+    middlewares
   });
   (0, import_shared.debug)("create dev server done");
-  await options.context.hooks.onBeforeStartDevServerHook.call();
-  const httpServer = await server.createHTTPServer();
+  await rsbuildServer.beforeStart();
+  const protocol = https ? "https" : "http";
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
   if (printURLs) {
     if ((0, import_shared.isFunction)(printURLs)) {
       urls = printURLs(urls);
@@ -218,12 +125,16 @@ async function startDevServer(options, createDevMiddleware, {
         throw new Error("Please return an array in the `printURLs` function.");
       }
     }
-    (0, import_shared.printServerURLs)(urls, routes, logger);
+    (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
   }
-  await server.onInit(httpServer);
+  const devMiddlewares = await rsbuildServer.getMiddlewares({
+    dev: devServerConfig,
+    app: httpServer
+  });
+  devMiddlewares.middlewares.forEach((m) => middlewares.use(m));
   (0, import_shared.debug)("listen dev server");
   return new Promise((resolve) => {
-    server.listen(
+    httpServer.listen(
       {
         host,
         port
@@ -233,17 +144,21 @@ async function startDevServer(options, createDevMiddleware, {
           throw err;
         }
         (0, import_shared.debug)("listen dev server done");
-        await options.context.hooks.onAfterStartDevServerHook.call({
+        await rsbuildServer.afterStart({
           port,
-          routes
+          routes: defaultRoutes
         });
-        (0, import_restart.registerCleaner)(() => server.close());
+        const onClose = async () => {
+          await devMiddlewares.close();
+          httpServer.close();
+        };
+        (0, import_restart.registerCleaner)(onClose);
         resolve({
           port,
           urls: urls.map((item) => item.url),
           server: {
             close: async () => {
-              server.close();
+              await onClose();
             }
           }
         });
@@ -253,6 +168,6 @@ async function startDevServer(options, createDevMiddleware, {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RsbuildDevServer,
+  createDevServer,
   startDevServer
 });

package/dist/server/httpServer.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ServerConfig } from '@rsbuild/shared';
+import type connect from '@rsbuild/shared/connect';
+export declare const createHttpServer: (options: {
+  https?: ServerConfig['https'];
+  middlewares: connect.Server;
+}) => Promise<import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;

package/dist/server/httpServer.js

@@ -0,0 +1,48 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var httpServer_exports = {};
+__export(httpServer_exports, {
+  createHttpServer: () => createHttpServer
+});
+module.exports = __toCommonJS(httpServer_exports);
+const createHttpServer = async (options) => {
+  let app;
+  if (options.https) {
+    const { createServer } = await Promise.resolve().then(() => __toESM(require("https")));
+    app = createServer(options.https, options.middlewares);
+  } else {
+    const { createServer } = await Promise.resolve().then(() => __toESM(require("http")));
+    app = createServer(options.middlewares);
+  }
+  return app;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHttpServer
+});

package/dist/server/index.d.ts

@@ -1,2 +1,2 @@
-export { startDevServer } from './devServer';
+export { startDevServer, createDevServer } from './devServer';
 export { startProdServer } from './prodServer';

package/dist/server/index.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
+  createDevServer: () => import_devServer.createDevServer,
   startDevServer: () => import_devServer.startDevServer,
   startProdServer: () => import_prodServer.startProdServer
 });
@@ -26,6 +27,7 @@ var import_devServer = require("./devServer");
 var import_prodServer = require("./prodServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createDevServer,
   startDevServer,
   startProdServer
 });

package/dist/server/prodServer.d.ts

@@ -1,7 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { ListenOptions } from 'net';
 import { Server } from 'http';
 import connect from '@rsbuild/shared/connect';
 import { type ServerConfig, type RsbuildConfig, type StartServerResult, type PreviewServerOptions } from '@rsbuild/shared';
@@ -22,8 +19,6 @@ export declare class RsbuildProdServer {
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
   private applyStaticAssetMiddleware;
-  createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
-  listen(options?: number | ListenOptions | undefined, listener?: () => Promise<void>): void;
   close(): void;
 }
 export declare function startProdServer(context: Context, rsbuildConfig: RsbuildConfig, {

package/dist/server/prodServer.js

@@ -32,13 +32,12 @@ __export(prodServer_exports, {
   startProdServer: () => startProdServer
 });
 module.exports = __toCommonJS(prodServer_exports);
-var import_http = require("http");
-var import_https = require("https");
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_path = require("path");
 var import_sirv = __toESM(require("../../compiled/sirv"));
 var import_shared = require("@rsbuild/shared");
 var import_middlewares = require("./middlewares");
+var import_httpServer = require("./httpServer");
 class RsbuildProdServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
@@ -111,27 +110,7 @@ class RsbuildProdServer {
       }
     });
   }
-  async createHTTPServer() {
-    const { serverConfig } = this.options;
-    const httpsOption = serverConfig.https;
-    if (httpsOption) {
-      return (0, import_https.createServer)(httpsOption, this.middlewares);
-    } else {
-      return (0, import_http.createServer)(this.middlewares);
-    }
-  }
-  listen(options, listener) {
-    const callback = () => {
-      listener?.();
-    };
-    if (typeof options === "object") {
-      this.app.listen(options, callback);
-    } else {
-      this.app.listen(options || 8080, callback);
-    }
-  }
   close() {
-    this.app.close();
   }
 }
 async function startProdServer(context, rsbuildConfig, { printURLs = true, getPortSilently } = {}) {
@@ -151,10 +130,13 @@ async function startProdServer(context, rsbuildConfig, { printURLs = true, getPo
     serverConfig
   });
   await context.hooks.onBeforeStartProdServerHook.call();
-  const httpServer = await server.createHTTPServer();
+  const httpServer = await (0, import_httpServer.createHttpServer)({
+    https: serverConfig.https,
+    middlewares: server.middlewares
+  });
   await server.onInit(httpServer);
   return new Promise((resolve) => {
-    server.listen(
+    httpServer.listen(
       {
         host,
         port
@@ -176,12 +158,16 @@ async function startProdServer(context, rsbuildConfig, { printURLs = true, getPo
             routes
           );
         }
+        const onClose = () => {
+          server.close();
+          httpServer.close();
+        };
         resolve({
           port,
           urls: urls.map((item) => item.url),
           server: {
             close: async () => {
-              server.close();
+              onClose();
             }
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -56,14 +56,14 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "0.4.1",
+    "@rspack/core": "0.4.2",
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
-    "@rsbuild/shared": "0.1.9"
+    "@rsbuild/shared": "0.2.0"
   },
   "devDependencies": {
-    "@types/node": "^16",
+    "@types/node": "16.x",
     "typescript": "^5.3.0",
     "webpack": "^5.89.0"
   },

package/dist/plugins/devtool.d.ts

@@ -1,2 +0,0 @@
-import type { RsbuildPlugin } from '../types';
-export declare const pluginDevtool: () => RsbuildPlugin;

package/dist/plugins/devtool.js

@@ -1,46 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var devtool_exports = {};
-__export(devtool_exports, {
-  pluginDevtool: () => pluginDevtool
-});
-module.exports = __toCommonJS(devtool_exports);
-var import_shared = require("@rsbuild/shared");
-const pluginDevtool = () => ({
-  name: "rsbuild:devtool",
-  setup(api) {
-    api.modifyBundlerChain((chain, { isProd, isServer }) => {
-      const config = api.getNormalizedConfig();
-      if (!(0, import_shared.isUseJsSourceMap)(config)) {
-        chain.devtool(false);
-      } else {
-        const prodDevTool = isServer ? "source-map" : "hidden-source-map";
-        const devtool = isProd ? (
-          // hide the source map URL in production to avoid Chrome warning
-          prodDevTool
-        ) : "cheap-module-source-map";
-        chain.devtool(devtool);
-      }
-    });
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  pluginDevtool
-});

package/dist/plugins/server.d.ts

@@ -1,2 +0,0 @@
-import type { RsbuildPlugin } from '../types';
-export declare const pluginServer: () => RsbuildPlugin;

package/dist/plugins/server.js

@@ -1,56 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-__export(server_exports, {
-  pluginServer: () => pluginServer
-});
-module.exports = __toCommonJS(server_exports);
-var import_shared = require("@rsbuild/shared");
-const pluginServer = () => ({
-  name: "rsbuild:server",
-  setup(api) {
-    api.modifyRsbuildConfig((rsbuildConfig, { mergeRsbuildConfig }) => {
-      if ((0, import_shared.isProd)() && rsbuildConfig.server?.publicDir) {
-        const { name, copyOnBuild } = rsbuildConfig.server?.publicDir;
-        if (!copyOnBuild || !name) {
-          return;
-        }
-        const { copy } = rsbuildConfig.output || {};
-        const publicPattern = [
-          {
-            from: name,
-            to: "",
-            noErrorOnMissing: true
-          }
-        ];
-        return mergeRsbuildConfig(rsbuildConfig, {
-          output: {
-            copy: Array.isArray(copy) ? publicPattern : {
-              patterns: publicPattern
-            }
-          }
-        });
-      }
-    });
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  pluginServer
-});

package/dist/provider/plugins/basic.d.ts

@@ -1,5 +0,0 @@
-import type { RsbuildPlugin } from '../../types';
-/**
- * Provide some basic configs of rspack
- */
-export declare const pluginBasic: () => RsbuildPlugin;