@rsbuild/core 0.0.0-next-20231103091827

package/dist/plugins/cache.js

@@ -0,0 +1,115 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  pluginCache: () => pluginCache
+});
+module.exports = __toCommonJS(cache_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_path = require("path");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_shared = require("@rsbuild/shared");
+async function validateCache(cacheDirectory, buildDependencies) {
+  const configFile = (0, import_path.join)(cacheDirectory, "buildDependencies.json");
+  if (await (0, import_shared.isFileExists)(configFile)) {
+    const prevBuildDependencies = await import_fs_extra.fs.readJSON(configFile);
+    if (JSON.stringify(prevBuildDependencies) === JSON.stringify(buildDependencies)) {
+      return;
+    }
+    await import_fs_extra.fs.remove(cacheDirectory);
+  }
+  await import_fs_extra.fs.outputJSON(configFile, buildDependencies);
+}
+function getDigestHash(digest) {
+  const fsHash = import_crypto.default.createHash("md5");
+  const md5 = fsHash.update(JSON.stringify(digest)).digest("hex").slice(0, 8);
+  return md5;
+}
+function getCacheDirectory({ cacheDirectory }, context) {
+  if (cacheDirectory) {
+    return (0, import_path.isAbsolute)(cacheDirectory) ? cacheDirectory : (0, import_path.join)(context.rootPath, cacheDirectory);
+  }
+  return (0, import_path.join)(context.cachePath, context.bundlerType);
+}
+async function getBuildDependencies(context) {
+  const rootPackageJson = (0, import_path.join)(context.rootPath, "package.json");
+  const browserslistConfig = (0, import_path.join)(context.rootPath, ".browserslistrc");
+  const buildDependencies = {};
+  if (await (0, import_shared.isFileExists)(rootPackageJson)) {
+    buildDependencies.packageJson = [rootPackageJson];
+  }
+  if (context.configPath) {
+    buildDependencies.config = [context.configPath];
+  }
+  if (context.tsconfigPath) {
+    buildDependencies.tsconfig = [context.tsconfigPath];
+  }
+  if (await (0, import_shared.isFileExists)(browserslistConfig)) {
+    buildDependencies.browserslistrc = [browserslistConfig];
+  }
+  const tailwindExts = ["ts", "js", "cjs", "mjs"];
+  const configs = tailwindExts.map(
+    (ext) => (0, import_path.join)(context.rootPath, `tailwind.config.${ext}`)
+  );
+  const tailwindConfig = (0, import_shared.findExists)(configs);
+  if (tailwindConfig) {
+    buildDependencies.tailwindcss = [tailwindConfig];
+  }
+  return buildDependencies;
+}
+const pluginCache = () => ({
+  name: "plugin-cache",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { target, env }) => {
+      const { buildCache } = api.getNormalizedConfig().performance;
+      if (buildCache === false) {
+        chain.cache(false);
+        return;
+      }
+      const { context } = api;
+      const cacheConfig = typeof buildCache === "boolean" ? {} : buildCache;
+      const cacheDirectory = getCacheDirectory(cacheConfig, context);
+      const buildDependencies = await getBuildDependencies(context);
+      await validateCache(cacheDirectory, buildDependencies);
+      const useDigest = Array.isArray(cacheConfig.cacheDigest) && cacheConfig.cacheDigest.length;
+      chain.cache({
+        // The default cache name of webpack is '${name}-${env}', and the `name` is `default` by default.
+        // We set cache name to avoid cache conflicts of different targets.
+        name: useDigest ? `${target}-${env}-${getDigestHash(cacheConfig.cacheDigest)}` : `${target}-${env}`,
+        type: "filesystem",
+        cacheDirectory,
+        buildDependencies
+      });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginCache
+});

package/dist/plugins/cleanOutput.d.ts

@@ -0,0 +1,2 @@
+import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginCleanOutput: () => DefaultRsbuildPlugin;

package/dist/plugins/cleanOutput.js

@@ -0,0 +1,47 @@
+"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 cleanOutput_exports = {};
+__export(cleanOutput_exports, {
+  pluginCleanOutput: () => pluginCleanOutput
+});
+module.exports = __toCommonJS(cleanOutput_exports);
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+const emptyDir = async (dir) => {
+  if (await import_fs_extra.fs.pathExists(dir)) {
+    await import_fs_extra.fs.emptyDir(dir);
+  }
+};
+const pluginCleanOutput = () => ({
+  name: "plugin-clean-output",
+  setup(api) {
+    const clean = async () => {
+      const config = api.getNormalizedConfig();
+      if (config.output.cleanDistPath) {
+        const { distPath } = api.context;
+        await emptyDir(distPath);
+      }
+    };
+    api.onBeforeBuild(clean);
+    api.onBeforeStartDevServer(clean);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginCleanOutput
+});

package/dist/plugins/define.d.ts

@@ -0,0 +1,2 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginDefine: () => DefaultRsbuildPlugin;

package/dist/plugins/define.js

@@ -0,0 +1,59 @@
+"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 define_exports = {};
+__export(define_exports, {
+  pluginDefine: () => pluginDefine
+});
+module.exports = __toCommonJS(define_exports);
+var import_lodash = require("lodash");
+var import_shared = require("@rsbuild/shared");
+const pluginDefine = () => ({
+  name: "plugin-define",
+  async setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { env, target, CHAIN_ID, bundler }) => {
+        const config = api.getNormalizedConfig();
+        const publicPath = chain.output.get("publicPath");
+        const assetPrefix = publicPath && typeof publicPath === "string" ? publicPath : config.output.assetPrefix;
+        const builtinVars = {
+          "process.env.NODE_ENV": process.env.NODE_ENV,
+          "process.env.ASSET_PREFIX": (0, import_shared.removeTailSlash)(assetPrefix)
+        };
+        const globalVars = (0, import_shared.mergeChainedOptions)(
+          builtinVars,
+          config.source.globalVars,
+          { env, target }
+        );
+        const serializedVars = (0, import_lodash.mapValues)(
+          globalVars,
+          (value) => {
+            var _a;
+            return (_a = JSON.stringify(value)) != null ? _a : "undefined";
+          }
+        );
+        const defineExprs = config.source.define;
+        chain.plugin(CHAIN_ID.PLUGIN.DEFINE).use(bundler.DefinePlugin, [{ ...serializedVars, ...defineExprs }]);
+      }
+    );
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginDefine
+});

package/dist/plugins/devtool.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginDevtool: () => DefaultRsbuildPlugin;

package/dist/plugins/devtool.js

@@ -0,0 +1,46 @@
+"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: "plugin-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/entry.d.ts

@@ -0,0 +1,2 @@
+import { type DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginEntry: () => DefaultRsbuildPlugin;

package/dist/plugins/entry.js

@@ -0,0 +1,42 @@
+"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 entry_exports = {};
+__export(entry_exports, {
+  pluginEntry: () => pluginEntry
+});
+module.exports = __toCommonJS(entry_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginEntry = () => ({
+  name: "plugin-entry",
+  setup(api) {
+    api.modifyBundlerChain(async (chain) => {
+      const { entry } = api.context;
+      const { preEntry } = api.getNormalizedConfig().source;
+      Object.keys(entry).forEach((entryName) => {
+        const appendEntry = (file) => chain.entry(entryName).add(file);
+        preEntry.forEach(appendEntry);
+        (0, import_shared.castArray)(entry[entryName]).forEach(appendEntry);
+      });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginEntry
+});

package/dist/plugins/externals.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare function pluginExternals(): DefaultRsbuildPlugin;

package/dist/plugins/externals.js

@@ -0,0 +1,48 @@
+"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 externals_exports = {};
+__export(externals_exports, {
+  pluginExternals: () => pluginExternals
+});
+module.exports = __toCommonJS(externals_exports);
+function pluginExternals() {
+  return {
+    name: "plugin-externals",
+    setup(api) {
+      api.modifyBundlerChain((chain) => {
+        const { externals } = api.getNormalizedConfig().output;
+        if (externals) {
+          chain.externals(externals);
+        }
+      });
+      api.onBeforeCreateCompiler(({ bundlerConfigs }) => {
+        bundlerConfigs.forEach((config) => {
+          const isWebWorker = Array.isArray(config.target) ? config.target.includes("webworker") : config.target === "webworker";
+          if (isWebWorker && config.externals) {
+            delete config.externals;
+          }
+        });
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginExternals
+});

package/dist/plugins/fileSize.d.ts

@@ -0,0 +1,4 @@
+import type { DefaultRsbuildPlugin } from '@rsbuild/shared';
+/** Filter source map and license files */
+export declare const filterAsset: (asset: string) => boolean;
+export declare const pluginFileSize: () => DefaultRsbuildPlugin;

package/dist/plugins/fileSize.js

@@ -0,0 +1,160 @@
+"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 fileSize_exports = {};
+__export(fileSize_exports, {
+  filterAsset: () => filterAsset,
+  pluginFileSize: () => pluginFileSize
+});
+module.exports = __toCommonJS(fileSize_exports);
+var import_path = __toESM(require("path"));
+var import_chalk = require("@rsbuild/shared/chalk");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_shared = require("@rsbuild/shared");
+var import_filesize = __toESM(require("filesize"));
+var import_gzip_size = __toESM(require("gzip-size"));
+const filterAsset = (asset) => !/\.map$/.test(asset) && !/\.LICENSE\.txt$/.test(asset);
+const getAssetColor = (size) => {
+  if (size > 300 * 1e3) {
+    return import_chalk.chalk.bold.red;
+  }
+  if (size > 100 * 1e3) {
+    return import_chalk.chalk.yellow;
+  }
+  return import_chalk.chalk.green;
+};
+async function printHeader(longestFileLength, longestLabelLength) {
+  const longestLengths = [longestFileLength, longestLabelLength];
+  const headerRow = ["File", "Size", "Gzipped"].reduce((prev, cur, index) => {
+    const length = longestLengths[index];
+    let curLabel = cur;
+    if (length) {
+      curLabel = cur.length < length ? cur + " ".repeat(length - cur.length) : cur;
+    }
+    return `${prev + curLabel}    `;
+  }, "  ");
+  import_shared.logger.log(import_chalk.chalk.bold.blue(headerRow));
+}
+async function printFileSizes(stats, distPath) {
+  const formatAsset = (asset) => {
+    const contents = import_fs_extra.fs.readFileSync(import_path.default.join(distPath, asset.name));
+    const size = contents.length;
+    const gzippedSize = import_gzip_size.default.sync(contents);
+    return {
+      size,
+      folder: import_path.default.join(import_path.default.basename(distPath), import_path.default.dirname(asset.name)),
+      name: import_path.default.basename(asset.name),
+      gzippedSize,
+      sizeLabel: (0, import_filesize.default)(size, { round: 1 }),
+      gzipSizeLabel: getAssetColor(gzippedSize)(
+        (0, import_filesize.default)(gzippedSize, { round: 1 })
+      )
+    };
+  };
+  const multiStats = "stats" in stats ? stats.stats : [stats];
+  const assets = multiStats.map((stats2) => {
+    const origin = stats2.toJson({
+      all: false,
+      assets: true,
+      cachedAssets: true,
+      groupAssetsByInfo: false,
+      groupAssetsByPath: false,
+      groupAssetsByChunk: false,
+      groupAssetsByExtension: false,
+      groupAssetsByEmitStatus: false
+    });
+    const filteredAssets = origin.assets.filter(
+      (asset) => filterAsset(asset.name)
+    );
+    return filteredAssets.map(formatAsset);
+  }).reduce((single, all) => all.concat(single), []);
+  if (assets.length === 0) {
+    return;
+  }
+  assets.sort((a, b) => b.size - a.size);
+  const longestLabelLength = Math.max(...assets.map((a) => a.sizeLabel.length));
+  const longestFileLength = Math.max(
+    ...assets.map((a) => (a.folder + import_path.default.sep + a.name).length)
+  );
+  import_shared.logger.info(`Production file sizes:
+`);
+  printHeader(longestFileLength, longestLabelLength);
+  let totalSize = 0;
+  let totalGzipSize = 0;
+  assets.forEach((asset) => {
+    let { sizeLabel } = asset;
+    const { name, folder, gzipSizeLabel } = asset;
+    const fileNameLength = (folder + import_path.default.sep + name).length;
+    const sizeLength = sizeLabel.length;
+    totalSize += asset.size;
+    totalGzipSize += asset.gzippedSize;
+    if (sizeLength < longestLabelLength) {
+      const rightPadding = " ".repeat(longestLabelLength - sizeLength);
+      sizeLabel += rightPadding;
+    }
+    let fileNameLabel = import_chalk.chalk.dim(asset.folder + import_path.default.sep) + import_chalk.chalk.cyan(asset.name);
+    if (fileNameLength < longestFileLength) {
+      const rightPadding = " ".repeat(longestFileLength - fileNameLength);
+      fileNameLabel += rightPadding;
+    }
+    import_shared.logger.log(`  ${fileNameLabel}    ${sizeLabel}    ${gzipSizeLabel}`);
+  });
+  const totalSizeLabel = `${import_chalk.chalk.bold.blue("Total size:")}  ${(0, import_filesize.default)(
+    totalSize,
+    { round: 1 }
+  )}`;
+  const gzippedSizeLabel = `${import_chalk.chalk.bold.blue("Gzipped size:")}  ${(0, import_filesize.default)(
+    totalGzipSize,
+    { round: 1 }
+  )}`;
+  import_shared.logger.log(`
+  ${totalSizeLabel}
+  ${gzippedSizeLabel}
+`);
+}
+const pluginFileSize = () => ({
+  name: "plugin-file-size",
+  setup(api) {
+    api.onAfterBuild(async ({ stats }) => {
+      const config = api.getNormalizedConfig();
+      if (config.performance.printFileSize && stats) {
+        try {
+          await printFileSizes(stats, api.context.distPath);
+        } catch (err) {
+          import_shared.logger.error("Failed to print file size.");
+          import_shared.logger.error(err);
+        }
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  filterAsset,
+  pluginFileSize
+});

package/dist/plugins/html.d.ts

@@ -0,0 +1,7 @@
+import type { HtmlConfig, DefaultRsbuildPlugin, SharedRsbuildPluginAPI, NormalizedOutputConfig } from '@rsbuild/shared';
+export declare function getMetaTags(entryName: string, config: {
+  html: HtmlConfig;
+  output: NormalizedOutputConfig;
+}): Promise<import("html-webpack-plugin").HtmlTagObject[]>;
+export declare const applyInjectTags: (api: SharedRsbuildPluginAPI) => void;
+export declare const pluginHtml: () => DefaultRsbuildPlugin;