@rsbuild/core 0.4.14 → 0.5.0

package/dist/rspack/HtmlBasicPlugin.js

@@ -23,12 +23,158 @@ var __publicField = (obj, key, value) => {
 };
 var HtmlBasicPlugin_exports = {};
 __export(HtmlBasicPlugin_exports, {
+  FILE_ATTRS: () => FILE_ATTRS,
+  HEAD_TAGS: () => HEAD_TAGS,
   HtmlBasicPlugin: () => HtmlBasicPlugin,
+  VOID_TAGS: () => VOID_TAGS,
   hasTitle: () => hasTitle
 });
 module.exports = __toCommonJS(HtmlBasicPlugin_exports);
+var import_shared = require("@rsbuild/shared");
 var import_htmlPluginUtil = require("../provider/htmlPluginUtil");
+const VOID_TAGS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+const HEAD_TAGS = [
+  "title",
+  "base",
+  "link",
+  "style",
+  "meta",
+  "script",
+  "noscript",
+  "template"
+];
+const FILE_ATTRS = {
+  link: "href",
+  script: "src"
+};
 const hasTitle = (html) => html ? /<title/i.test(html) && /<\/title/i.test(html) : false;
+const getTagPriority = (tag, tagConfig) => {
+  const head = tag.head ?? HEAD_TAGS.includes(tag.tag);
+  let priority = head ? -2 : 2;
+  const append = tag.append ?? tagConfig.append;
+  if (typeof append === "boolean") {
+    priority += append ? 1 : -1;
+  }
+  return priority;
+};
+const formatTags = (tags, override) => tags.map((tag) => ({
+  tag: tag.tagName,
+  attrs: tag.attributes,
+  children: tag.innerHTML,
+  publicPath: false,
+  ...override
+}));
+const modifyTags = (data, tagConfig, compilationHash, entryName) => {
+  if (!tagConfig.tags?.length) {
+    return data;
+  }
+  const fromInjectTags = (tags2) => {
+    const ret = [];
+    for (const tag of tags2) {
+      const attrs = { ...tag.attrs };
+      const filenameTag = FILE_ATTRS[tag.tag];
+      let filename = attrs[filenameTag];
+      if (typeof filename === "string") {
+        const optPublicPath = tag.publicPath ?? tagConfig.publicPath;
+        if (typeof optPublicPath === "function") {
+          filename = optPublicPath(filename, data.publicPath);
+        } else if (typeof optPublicPath === "string") {
+          filename = (0, import_shared.withPublicPath)(filename, optPublicPath);
+        } else if (optPublicPath !== false) {
+          filename = (0, import_shared.withPublicPath)(filename, data.publicPath);
+        }
+        const optHash = tag.hash ?? tagConfig.hash;
+        if (typeof optHash === "function") {
+          if (compilationHash.length) {
+            filename = optHash(filename, compilationHash);
+          }
+        } else if (typeof optHash === "string") {
+          if (optHash.length) {
+            filename = `${filename}?${optHash}`;
+          }
+        } else if (optHash === true) {
+          if (compilationHash.length) {
+            filename = `${filename}?${compilationHash}`;
+          }
+        }
+        attrs[filenameTag] = filename;
+      }
+      ret.push({
+        meta: {},
+        tagName: tag.tag,
+        attributes: attrs,
+        voidTag: VOID_TAGS.includes(tag.tag),
+        innerHTML: tag.children
+      });
+    }
+    return ret;
+  };
+  let tags = [
+    ...formatTags(data.headTags, { head: true }),
+    ...formatTags(data.bodyTags, { head: false })
+  ];
+  const utils = {
+    hash: compilationHash,
+    entryName,
+    outputName: data.outputName,
+    publicPath: data.publicPath
+  };
+  for (const item of tagConfig.tags) {
+    if ((0, import_shared.isFunction)(item)) {
+      tags = item(tags, utils) || tags;
+    } else {
+      tags.push(item);
+    }
+    tags = tags.sort(
+      (tag1, tag2) => getTagPriority(tag1, tagConfig) - getTagPriority(tag2, tagConfig)
+    );
+  }
+  const [headTags, bodyTags] = (0, import_shared.partition)(
+    tags,
+    (tag) => tag.head ?? HEAD_TAGS.includes(tag.tag)
+  );
+  data.headTags = fromInjectTags(headTags);
+  data.bodyTags = fromInjectTags(bodyTags);
+  return data;
+};
+const addTitleTag = (headTags, title = "") => {
+  headTags.unshift({
+    tagName: "title",
+    innerHTML: title,
+    attributes: {},
+    voidTag: false,
+    meta: {}
+  });
+};
+const addFavicon = (headTags, favicon) => {
+  if (favicon) {
+    headTags.unshift({
+      tagName: "link",
+      voidTag: true,
+      attributes: {
+        rel: "icon",
+        href: favicon
+      },
+      meta: {}
+    });
+  }
+};
 class HtmlBasicPlugin {
   constructor(options) {
     __publicField(this, "name");
@@ -37,29 +183,6 @@ class HtmlBasicPlugin {
     this.options = options;
   }
   apply(compiler) {
-    const addTitleTag = (headTags, title = "") => {
-      headTags.unshift({
-        tagName: "title",
-        innerHTML: title,
-        attributes: {},
-        voidTag: false,
-        meta: {}
-      });
-    };
-    const addFavicon = (headTags, entryName) => {
-      const { favicon } = this.options.info[entryName];
-      if (favicon) {
-        headTags.unshift({
-          tagName: "link",
-          voidTag: true,
-          attributes: {
-            rel: "icon",
-            href: favicon
-          },
-          meta: {}
-        });
-      }
-    };
     compiler.hooks.compilation.tap(this.name, (compilation) => {
       (0, import_htmlPluginUtil.getHTMLPlugin)().getHooks(compilation).alterAssetTagGroups.tap(this.name, (data) => {
         const entryName = data.plugin.options?.entryName;
@@ -67,11 +190,15 @@ class HtmlBasicPlugin {
           return data;
         }
         const { headTags } = data;
-        const { templateContent } = this.options.info[entryName];
+        const { favicon, tagConfig, templateContent } = this.options[entryName];
         if (!hasTitle(templateContent)) {
           addTitleTag(headTags, data.plugin.options?.title);
         }
-        addFavicon(headTags, entryName);
+        addFavicon(headTags, favicon);
+        if (tagConfig) {
+          const hash = compilation.hash ?? "";
+          modifyTags(data, tagConfig, hash, entryName);
+        }
         return data;
       });
     });
@@ -79,6 +206,9 @@ class HtmlBasicPlugin {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FILE_ATTRS,
+  HEAD_TAGS,
   HtmlBasicPlugin,
+  VOID_TAGS,
   hasTitle
 });

package/dist/rspack/HtmlCrossOriginPlugin.js

@@ -48,17 +48,13 @@ class HtmlCrossOriginPlugin {
     }
     compiler.hooks.compilation.tap(this.name, (compilation) => {
       (0, import_htmlPluginUtil.getHTMLPlugin)().getHooks(compilation).alterAssetTags.tap(this.name, (alterAssetTags) => {
+        var _a;
         const {
           assetTags: { scripts, styles }
         } = alterAssetTags;
-        scripts.forEach((script) => {
-          var _a;
-          (_a = script.attributes).crossorigin ?? (_a.crossorigin = this.crossOrigin);
-        });
-        styles.forEach((style) => {
-          var _a;
-          (_a = style.attributes).crossorigin ?? (_a.crossorigin = this.crossOrigin);
-        });
+        for (const tag of [...scripts, ...styles]) {
+          (_a = tag.attributes).crossorigin ?? (_a.crossorigin = this.crossOrigin);
+        }
         return alterAssetTags;
       });
     });

package/dist/rspack/HtmlNoncePlugin.js

@@ -44,9 +44,9 @@ class HtmlNoncePlugin {
         const {
           assetTags: { scripts }
         } = alterAssetTags;
-        scripts.forEach((script) => {
+        for (const script of scripts) {
           script.attributes.nonce = this.nonce;
-        });
+        }
         return alterAssetTags;
       });
     });

package/dist/rspack/InlineChunkHtmlPlugin.js

@@ -177,13 +177,13 @@ class InlineChunkHtmlPlugin {
         },
         () => {
           const { devtool } = compiler.options;
-          this.inlinedAssets.forEach((name) => {
+          for (const name of this.inlinedAssets) {
             if (devtool === "hidden-source-map") {
               compilation.deleteAsset(name);
             } else {
               delete compilation.assets[name];
             }
-          });
+          }
           this.inlinedAssets.clear();
         }
       );

package/dist/rspack/RemoveCssSourcemapPlugin.js

@@ -39,11 +39,11 @@ class RemoveCssSourcemapPlugin {
           stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
         },
         () => {
-          Object.keys(compilation.assets).forEach((name) => {
+          for (const name of Object.keys(compilation.assets)) {
             if (name.endsWith(".css.map")) {
               compilation.deleteAsset(name);
             }
-          });
+          }
         }
       );
     });

package/dist/server/devServer.d.ts

@@ -1,12 +1,5 @@
-import { type DevServerAPIs, type StartServerResult, type StartDevServerOptions, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
+import { type RsbuildDevServer, type CreateDevServerOptions, type StartDevServerOptions, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
 import type { InternalContext } from '../types';
-export declare function getServerAPIs<Options extends {
+export declare function createDevServer<Options extends {
     context: InternalContext;
-}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler: customCompiler, getPortSilently, }?: StartDevServerOptions & {
-    defaultPort?: number;
-}): Promise<DevServerAPIs>;
-export declare function startDevServer<Options extends {
-    context: InternalContext;
-}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler, getPortSilently, }?: StartDevServerOptions & {
-    defaultPort?: number;
-}): Promise<StartServerResult>;
+}>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler: customCompiler, getPortSilently, runCompile, }?: CreateDevServerOptions): Promise<RsbuildDevServer>;

package/dist/server/devServer.js

@@ -28,8 +28,7 @@ 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, {
-  getServerAPIs: () => getServerAPIs,
-  startDevServer: () => startDevServer
+  createDevServer: () => createDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
 var import_shared = require("@rsbuild/shared");
@@ -39,19 +38,21 @@ var import_restart = require("./restart");
 var import_httpServer = require("./httpServer");
 var import_getDevMiddlewares = require("./getDevMiddlewares");
 var import_middlewares = require("./middlewares");
-async function getServerAPIs(options, createDevMiddleware, {
+async function createDevServer(options, createDevMiddleware, {
   compiler: customCompiler,
-  getPortSilently
+  getPortSilently,
+  runCompile = true
 } = {}) {
   if (!(0, import_shared.getNodeEnv)()) {
     (0, import_shared.setNodeEnv)("development");
   }
+  (0, import_shared.debug)("create dev server");
   const rsbuildConfig = options.context.config;
   const { devServerConfig, port, host, https } = await (0, import_helper.getDevOptions)({
     rsbuildConfig,
     getPortSilently
   });
-  const defaultRoutes = (0, import_helper.formatRoutes)(
+  const routes = (0, import_helper.formatRoutes)(
     options.context.entry,
     rsbuildConfig.output?.distPath?.html,
     rsbuildConfig.html?.outputStructure
@@ -61,128 +62,120 @@ async function getServerAPIs(options, createDevMiddleware, {
     port,
     https
   };
-  return {
-    config: { devServerConfig, port, host, https, defaultRoutes },
-    beforeStart: async () => {
-      await options.context.hooks.onBeforeStartDevServer.call();
-    },
-    afterStart: async (params = {}) => {
-      await options.context.hooks.onAfterStartDevServer.call({
-        port: params.port || port,
-        routes: params.routes || defaultRoutes
-      });
-    },
-    startCompile: async () => {
-      const { devMiddleware, compiler } = await createDevMiddleware(
-        options,
-        customCompiler
-      );
-      const { CompilerDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./compilerDevMiddleware")));
-      const publicPaths = (0, import_shared.isMultiCompiler)(compiler) ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
-      const compilerDevMiddleware = new CompilerDevMiddleware({
-        dev: devServerConfig,
-        publicPaths,
-        devMiddleware
-      });
-      compilerDevMiddleware.init();
-      return {
-        middleware: compilerDevMiddleware.middleware,
-        sockWrite: (...args) => compilerDevMiddleware.sockWrite(...args),
-        onUpgrade: (...args) => compilerDevMiddleware.upgrade(...args),
-        close: () => compilerDevMiddleware?.close()
-      };
-    },
-    getMiddlewares: async (params = {}) => {
-      const { compileMiddlewareAPI, overrides = {} } = params;
-      return (0, import_getDevMiddlewares.getMiddlewares)({
-        pwd: options.context.rootPath,
-        compileMiddlewareAPI,
-        dev: {
-          ...devServerConfig,
-          ...overrides
-        },
-        output: {
-          distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR
-        }
-      });
-    }
+  const startCompile = async () => {
+    const { devMiddleware, compiler } = await createDevMiddleware(
+      options,
+      customCompiler
+    );
+    const { CompilerDevMiddleware } = await Promise.resolve().then(() => __toESM(require("./compilerDevMiddleware")));
+    const publicPaths = (0, import_shared.isMultiCompiler)(compiler) ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
+    const compilerDevMiddleware = new CompilerDevMiddleware({
+      dev: devServerConfig,
+      publicPaths,
+      devMiddleware
+    });
+    compilerDevMiddleware.init();
+    return {
+      middleware: compilerDevMiddleware.middleware,
+      sockWrite: (...args) => compilerDevMiddleware.sockWrite(...args),
+      onUpgrade: (...args) => compilerDevMiddleware.upgrade(...args),
+      close: () => compilerDevMiddleware?.close()
+    };
   };
-}
-async function startDevServer(options, createDevMiddleware, {
-  compiler,
-  getPortSilently
-} = {}) {
-  (0, import_shared.debug)("create dev server");
-  const serverAPIs = await getServerAPIs(options, createDevMiddleware, {
-    compiler,
-    getPortSilently
-  });
-  const {
-    config: { devServerConfig, port, host, https, defaultRoutes }
-  } = serverAPIs;
-  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");
   const protocol = https ? "https" : "http";
   const urls = (0, import_shared.getAddressUrls)({ protocol, port, host });
-  options.context.hooks.onBeforeCreateCompiler.tap(() => {
+  await options.context.hooks.onBeforeStartDevServer.call();
+  if (runCompile) {
+    options.context.hooks.onBeforeCreateCompiler.tap(() => {
+      (0, import_helper.printServerURLs)({
+        urls,
+        port,
+        routes,
+        protocol,
+        printUrls: devServerConfig.printUrls
+      });
+    });
+  } else {
     (0, import_helper.printServerURLs)({
       urls,
       port,
-      routes: defaultRoutes,
+      routes,
       protocol,
       printUrls: devServerConfig.printUrls
     });
+  }
+  const compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
+  const devMiddlewares = await (0, import_getDevMiddlewares.getMiddlewares)({
+    pwd: options.context.rootPath,
+    compileMiddlewareAPI,
+    dev: devServerConfig,
+    output: {
+      distPath: rsbuildConfig.output?.distPath?.root || import_shared.ROOT_DIST_DIR
+    }
   });
-  await serverAPIs.beforeStart();
-  (0, import_shared.debug)("listen dev server");
-  return new Promise((resolve) => {
-    httpServer.listen(
-      {
-        host,
-        port
-      },
-      async (err) => {
-        if (err) {
-          throw err;
-        }
-        const compileMiddlewareAPI = await serverAPIs.startCompile();
-        const devMiddlewares = await serverAPIs.getMiddlewares({
-          compileMiddlewareAPI
-        });
-        devMiddlewares.middlewares.forEach((item) => {
-          if (Array.isArray(item)) {
-            middlewares.use(...item);
-          } else {
-            middlewares.use(item);
-          }
-        });
-        middlewares.use(import_middlewares.notFoundMiddleware);
-        httpServer.on("upgrade", devMiddlewares.onUpgrade);
-        (0, import_shared.debug)("listen dev server done");
-        await serverAPIs.afterStart();
-        const closeServer = async () => {
-          await options.context.hooks.onCloseDevServer.call();
-          await devMiddlewares.close();
-          httpServer.close();
-        };
-        (0, import_restart.onBeforeRestartServer)(closeServer);
-        resolve({
-          port,
-          urls: urls.map((item) => item.url),
-          server: {
-            close: closeServer
+  const middlewares = (0, import_connect.default)();
+  for (const item of devMiddlewares.middlewares) {
+    if (Array.isArray(item)) {
+      middlewares.use(...item);
+    } else {
+      middlewares.use(item);
+    }
+  }
+  const server = {
+    port,
+    middlewares,
+    listen: async () => {
+      const httpServer = await (0, import_httpServer.createHttpServer)({
+        https: devServerConfig.https,
+        middlewares
+      });
+      (0, import_shared.debug)("listen dev server");
+      return new Promise((resolve) => {
+        httpServer.listen(
+          {
+            host,
+            port
+          },
+          async (err) => {
+            if (err) {
+              throw err;
+            }
+            middlewares.use(import_middlewares.notFoundMiddleware);
+            httpServer.on("upgrade", devMiddlewares.onUpgrade);
+            (0, import_shared.debug)("listen dev server done");
+            await server.afterListen();
+            const closeServer = async () => {
+              await server.close();
+              httpServer.close();
+            };
+            (0, import_restart.onBeforeRestartServer)(closeServer);
+            resolve({
+              port,
+              urls: urls.map((item) => item.url),
+              server: {
+                close: closeServer
+              }
+            });
           }
-        });
-      }
-    );
-  });
+        );
+      });
+    },
+    afterListen: async () => {
+      await options.context.hooks.onAfterStartDevServer.call({
+        port,
+        routes
+      });
+    },
+    onHTTPUpgrade: devMiddlewares.onUpgrade,
+    close: async () => {
+      await options.context.hooks.onCloseDevServer.call();
+      await devMiddlewares.close();
+    }
+  };
+  (0, import_shared.debug)("create dev server done");
+  return server;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getServerAPIs,
-  startDevServer
+  createDevServer
 });

package/dist/server/getDevMiddlewares.js

@@ -42,7 +42,7 @@ const applySetupMiddlewares = (dev, compileMiddlewareAPI) => {
   };
   const before = [];
   const after = [];
-  setupMiddlewares.forEach((handler) => {
+  for (const handler of setupMiddlewares) {
     handler(
       {
         unshift: (...handlers) => before.unshift(...handlers),
@@ -50,7 +50,7 @@ const applySetupMiddlewares = (dev, compileMiddlewareAPI) => {
       },
       serverOptions
     );
-  });
+  }
   return { before, after };
 };
 const applyDefaultMiddlewares = async ({
@@ -90,9 +90,9 @@ const applyDefaultMiddlewares = async ({
       dev.proxy
     );
     upgradeEvents.push(upgrade);
-    proxyMiddlewares.forEach((middleware) => {
+    for (const middleware of proxyMiddlewares) {
       middlewares.push(middleware);
-    });
+    }
   }
   const { default: launchEditorMiddleware } = await Promise.resolve().then(() => __toESM(require("../../compiled/launch-editor-middleware")));
   middlewares.push(["/__open-in-editor", launchEditorMiddleware()]);
@@ -131,7 +131,9 @@ const applyDefaultMiddlewares = async ({
   middlewares.push(import_middlewares.faviconFallbackMiddleware);
   return {
     onUpgrade: (...args) => {
-      upgradeEvents.forEach((cb) => cb(...args));
+      for (const cb of upgradeEvents) {
+        cb(...args);
+      }
     }
   };
 };
@@ -145,7 +147,7 @@ const getMiddlewares = async (options) => {
     options.dev,
     compileMiddlewareAPI
   );
-  before.forEach((fn) => middlewares.push(fn));
+  middlewares.push(...before);
   const { onUpgrade } = await applyDefaultMiddlewares({
     middlewares,
     dev: options.dev,
@@ -153,7 +155,7 @@ const getMiddlewares = async (options) => {
     output: options.output,
     pwd: options.pwd
   });
-  after.forEach((fn) => middlewares.push(fn));
+  middlewares.push(...after);
   return {
     close: async () => {
       compileMiddlewareAPI?.close();

package/dist/server/helper.js

@@ -75,12 +75,12 @@ function getURLMessages(urls, routes) {
     }
     message += `  ${`> ${label}`}
 `;
-    routes.forEach((r) => {
+    for (const r of routes) {
       message += `  ${import_shared.color.dim("-")} ${import_shared.color.dim(
         r.entryName.padEnd(maxNameLength + 4)
       )}${import_shared.color.cyan((0, import_shared.normalizeUrl)(`${url}${r.pathname}`))}
 `;
-    });
+    }
   });
   return message;
 }

package/dist/server/index.d.ts

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

package/dist/server/index.js

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

package/dist/server/prodServer.js

@@ -81,9 +81,9 @@ class RsbuildProdServer {
     if (proxy) {
       const { createProxyMiddleware } = await Promise.resolve().then(() => __toESM(require("./proxy")));
       const { middlewares, upgrade } = createProxyMiddleware(proxy);
-      middlewares.forEach((middleware) => {
+      for (const middleware of middlewares) {
         this.middlewares.use(middleware);
-      });
+      }
       this.app.on("upgrade", upgrade);
     }
     this.applyStaticAssetMiddleware();