@meteorjs/rspack 0.0.56 → 0.0.58

package/lib/mergeRulesSplitOverlap.js

@@ -4,6 +4,7 @@
  */
 
 const { mergeWithCustomize } = require('webpack-merge');
+const isEqual = require('fast-deep-equal');
 
 /**
  * File extensions to check when determining rule overlaps.
@@ -87,6 +88,10 @@ function splitOverlapRulesMerge(aRules, bRules) {
     for (let i = 0; i < result.length; i++) {
       const aRule = result[i];
 
+
+      const isMergeableRule = isEqual(aRule?.include || [], bRule?.include || []);
+      if (!isMergeableRule) continue;
+
       // Determine which extensions each rule matches (within our catalog)
       const aExts = EXT_CATALOG.filter(ext => ruleMatchesExt(aRule, ext));
       const bExts = EXT_CATALOG.filter(ext => ruleMatchesExt(bRule, ext));

package/lib/meteorRspackConfigFactory.js

@@ -0,0 +1,96 @@
+// meteorRspackConfigFactory.js
+
+const { mergeSplitOverlap } = require("./mergeRulesSplitOverlap.js");
+
+const DEFAULT_PREFIX = "meteorRspackConfig";
+let counter = 0;
+
+/**
+ * Create a uniquely keyed Rspack config fragment.
+ * Example return: { meteorRspackConfig1: { ...customConfig } }
+ *
+ * @param {object} customConfig
+ * @param {{ key?: number|string, prefix?: string }} [opts]
+ * @returns {Record<string, object>}
+ */
+function prepareMeteorRspackConfig(customConfig, opts = {}) {
+  if (!customConfig || typeof customConfig !== "object") {
+    throw new TypeError("customConfig must be an object");
+  }
+  const prefix = opts.prefix || DEFAULT_PREFIX;
+
+  let name;
+  if (opts.key != null) {
+    const k = String(opts.key).trim();
+    if (/^\d+$/.test(k)) name = `${prefix}${k}`;
+    else if (k.startsWith(prefix) && /^\d+$/.test(k.slice(prefix.length)))
+      name = k;
+    else
+      throw new Error(`opts.key must be a positive integer or "${prefix}<n>"`);
+
+    const n = parseInt(name.slice(prefix.length), 10);
+    if (Number.isFinite(n) && n > counter) counter = n;
+  } else {
+    counter += 1;
+    name = `${prefix}${counter}`;
+  }
+
+  return { [name]: customConfig };
+}
+
+/**
+ * Merge all `{prefix}<n>` fragments into `config` using `mergeSplitOverlap`,
+ * then remove those temporary keys. Mutates `config`.
+ *
+ * Order: fragments are applied in ascending numeric order (1, 2, 3, ...).
+ *
+ * @param {object} config
+ * @param {{ prefix?: string }} [opts]
+ * @returns {object} The same (mutated) config instance.
+ */
+function mergeMeteorRspackFragments(config, opts = {}) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new TypeError("config must be a plain object");
+  }
+  const prefix = opts.prefix || DEFAULT_PREFIX;
+
+  // Collect fragment keys like "meteorRspackConfig12"
+  const tempKeys = Object.keys(config)
+    .filter((k) => k.startsWith(prefix) && /^\d+$/.test(k.slice(prefix.length)))
+    .map((k) => [k, parseInt(k.slice(prefix.length), 10)])
+    .sort((a, b) => a[1] - b[1])
+    .map(([k]) => k);
+
+  if (tempKeys.length === 0) return config;
+
+  // Apply each fragment with your merge policy
+  for (const k of tempKeys) {
+    const fragment = config[k];
+    if (!fragment || typeof fragment !== "object" || Array.isArray(fragment)) {
+      throw new Error(`Fragment "${k}" must be a plain object`);
+    }
+    const merged = mergeSplitOverlap(config, fragment);
+
+    // Keep object identity: replace contents of `config` with `merged`
+    replaceObject(config, merged);
+  }
+
+  // Strip the temp keys at the end
+  for (const k of tempKeys) delete config[k];
+
+  return config;
+}
+
+function replaceObject(target, source) {
+  for (const key of Object.keys(target)) {
+    if (!(key in source)) delete target[key];
+  }
+  for (const key of Object.keys(source)) {
+    target[key] = source[key];
+  }
+}
+
+module.exports = {
+  prepareMeteorRspackConfig,
+  mergeMeteorRspackFragments,
+};

package/lib/meteorRspackHelpers.js

@@ -0,0 +1,81 @@
+const path = require("path");
+const { prepareMeteorRspackConfig } = require("./meteorRspackConfigFactory");
+const { builtinModules } = require("module");
+
+/**
+ * Resolve a package directory from node resolution.
+ * @param {string} pkg
+ * @returns {string} absolute directory of the package
+ */
+function pkgDir(pkg) {
+  const resolved = require.resolve(`${pkg}/package.json`, {
+    paths: [process.cwd()],
+  });
+  return path.dirname(resolved);
+}
+
+/**
+ * Wrap externals for Meteor runtime (marks deps as externals).
+ * Usage: compileWithMeteor(["sharp", "vimeo", "fs"])
+ *
+ * @param {string[]} deps - package names or module IDs
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { externals: [...] } }`
+ */
+function compileWithMeteor(deps) {
+  const flat = deps.flat().filter(Boolean);
+  return prepareMeteorRspackConfig({
+    externals: flat,
+  });
+}
+
+/**
+ * Add SWC transpilation rules limited to specific deps (monorepo-friendly).
+ * Usage: compileWithRspack(["@org/lib-a", "zod"])
+ *
+ * Requires global `Meteor.swcConfigOptions` (as in your setup).
+ *
+ * @param {string[]} deps - package names to include in SWC loader
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { module: { rules: [...] } } }`
+ */
+function compileWithRspack(deps, { options = {} } = {}) {
+  const includeDirs = deps.flat().filter(Boolean).map(pkgDir);
+
+  return prepareMeteorRspackConfig({
+    module: {
+      rules: [
+        {
+          test: /\.(?:[mc]?js|jsx|[mc]?ts|tsx)$/i,
+          include: includeDirs,
+          loader: "builtin:swc-loader",
+          options,
+        },
+      ],
+    },
+  });
+}
+
+/**
+ * Build an alias map that disables ALL Node core modules in a web build.
+ * - Includes both 'fs' and 'node:fs' keys
+ * - Optional extras let you block non-core modules too
+ */
+function makeWebNodeBuiltinsAlias(extras = []) {
+  // Strip potential 'node:' prefixes then add both forms
+  const core = new Set(builtinModules.map((m) => m.replace(/^node:/, "")));
+
+  const names = new Set();
+  for (const m of core) {
+    names.add(m);           // e.g. 'fs'
+    names.add(`node:${m}`); // e.g. 'node:fs'
+  }
+  for (const x of extras) names.add(x);
+
+  // Map every name to false (causes hard error if imported)
+  return Object.fromEntries([...names].map((m) => [m, false]));
+}
+
+module.exports = {
+  compileWithMeteor,
+  compileWithRspack,
+  makeWebNodeBuiltinsAlias,
+};

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "fast-deep-equal": "^3.1.3",
     "ignore-loader": "^0.1.2",
     "webpack-merge": "^6.0.1"
   },

package/rspack.config.js

@@ -1,4 +1,4 @@
-const { DefinePlugin, BannerPlugin } = require('@rspack/core');
+const { DefinePlugin, BannerPlugin, NormalModuleReplacementPlugin } = require('@rspack/core');
 const fs = require('fs');
 const { inspect } = require('node:util');
 const path = require('path');
@@ -10,6 +10,12 @@ const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
 const { RequireExternalsPlugin } = require('./plugins/RequireExtenalsPlugin.js');
 const { generateEagerTestFile } = require("./lib/test.js");
 const { getMeteorIgnoreEntries, createIgnoreGlobConfig } = require("./lib/ignore");
+const { mergeMeteorRspackFragments } = require("./lib/meteorRspackConfigFactory.js");
+const {
+  compileWithMeteor,
+  compileWithRspack,
+  makeWebNodeBuiltinsAlias,
+} = require('./lib/meteorRspackHelpers.js');
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -27,17 +33,52 @@ function safeRequire(moduleName) {
 }
 
 // Persistent filesystem cache strategy
-function createCacheStrategy(mode, side) {
+function createCacheStrategy(mode, side, { projectConfigPath, configPath } = {}) {
+  // Check for configuration files
+  const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+  const hasTsconfig = fs.existsSync(tsconfigPath);
+  const babelRcConfig = path.join(process.cwd(), '.babelrc');
+  const hasBabelRcConfig = fs.existsSync(babelRcConfig);
+  const babelJsConfig = path.join(process.cwd(), 'babel.config.js');
+  const hasBabelJsConfig = fs.existsSync(babelJsConfig);
+  const swcrcPath = path.join(process.cwd(), '.swcrc');
+  const hasSwcrcConfig = fs.existsSync(swcrcPath);
+  const swcJsPath = path.join(process.cwd(), 'swc.config.js');
+  const hasSwcJsConfig = fs.existsSync(swcJsPath);
+  const postcssConfigPath = path.join(process.cwd(), 'postcss.config.js');
+  const hasPostcssConfig = fs.existsSync(postcssConfigPath);
+  const packageLockPath = path.join(process.cwd(), 'package-lock.json');
+  const hasPackageLock = fs.existsSync(packageLockPath);
+  const yarnLockPath = path.join(process.cwd(), 'yarn.lock');
+  const hasYarnLock = fs.existsSync(yarnLockPath);
+
+  // Build dependencies array
+  const buildDependencies = [
+    ...(projectConfigPath ? [projectConfigPath] : []),
+    ...(configPath ? [configPath] : []),
+    ...(hasTsconfig ? [tsconfigPath] : []),
+    ...(hasBabelRcConfig ? [babelRcConfig] : []),
+    ...(hasBabelJsConfig ? [babelJsConfig] : []),
+    ...(hasSwcrcConfig ? [swcrcPath] : []),
+    ...(hasSwcJsConfig ? [swcJsPath] : []),
+    ...(hasPostcssConfig ? [postcssConfigPath] : []),
+    ...(hasPackageLock ? [packageLockPath] : []),
+    ...(hasYarnLock ? [yarnLockPath] : []),
+  ].filter(Boolean);
+
   return {
     cache: true,
     experiments: {
       cache: {
-        version: `swc-${mode}${(side && `-${side}`) || ""}`,
+        version: `cache-${mode}${(side && `-${side}`) || ""}`,
         type: "persistent",
         storage: {
           type: "filesystem",
           directory: `node_modules/.cache/rspack${(side && `/${side}`) || ""}`,
         },
+        ...(buildDependencies.length > 0 && {
+          buildDependencies: buildDependencies,
+        })
       },
     },
   };
@@ -140,6 +181,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const mode = isProd ? 'production' : 'development';
   const projectDir = process.cwd();
   const projectConfigPath = Meteor.projectConfigPath || path.resolve(projectDir, 'rspack.config.js');
+  const configPath = Meteor.configPath;
 
   const isTypescriptEnabled = Meteor.isTypescriptEnabled || false;
   const isJsxEnabled =
@@ -176,6 +218,13 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
   Meteor.buildOutputDir = buildOutputDir;
 
+  // Expose Meteor's helpers to expand Rspack configs
+  Meteor.compileWithMeteor = deps => compileWithMeteor(deps);
+  Meteor.compileWithRspack = deps =>
+    compileWithRspack(deps, {
+      options: Meteor.swcConfigOptions,
+    });
+
   // Add HtmlRspackPlugin function to Meteor
   Meteor.HtmlRspackPlugin = (options = {}) => {
     return new HtmlRspackPlugin({
@@ -225,7 +274,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     console.log('[i] Meteor flags:', Meteor);
   }
 
-  const enableSwcExternalHelpers = !!swcExternalHelpers;
+  const enableSwcExternalHelpers = !isServer && swcExternalHelpers;
   const isDevEnvironment = isRun && isDev && !isTest && !isNative;
   const swcConfigRule = createSwcConfig({
     isTypescriptEnabled,
@@ -247,6 +296,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const alias = {
     '/': path.resolve(process.cwd()),
   };
+  const fallback = {
+    ...(isClient && makeWebNodeBuiltinsAlias()),
+  };
   const extensions = [
     '.ts',
     '.tsx',
@@ -309,8 +361,19 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     entry: path.resolve(process.cwd(), buildContext, entryPath),
     output: {
       path: clientOutputDir,
-      filename: () =>
-        isDevEnvironment ? outputFilename : `../${buildContext}/${outputPath}`,
+      filename: (_module) => {
+        const chunkName = _module.chunk?.name;
+        const isMainChunk = !chunkName || chunkName === "main";
+        const chunkSuffix = `${chunksContext}/[id]${
+          isProd ? '.[chunkhash]' : ''
+        }.js`;
+        if (isDevEnvironment) {
+          if (isMainChunk) return outputFilename;
+          return chunkSuffix;
+        }
+        if (isMainChunk) return `../${buildContext}/${outputPath}`;
+        return chunkSuffix;
+      },
       libraryTarget: 'commonjs',
       publicPath: '/',
       chunkFilename: `${chunksContext}/[id]${isProd ? '.[chunkhash]' : ''}.js`,
@@ -341,7 +404,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         ...extraRules,
       ],
     },
-    resolve: { extensions, alias },
+    resolve: { extensions, alias, fallback },
     externals,
     plugins: [
       ...[
@@ -361,6 +424,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       ...bannerPluginConfig,
       Meteor.HtmlRspackPlugin(),
       ...doctorPluginConfig,
+      new NormalModuleReplacementPlugin(/^node:(.*)$/, (res) => {
+        res.request = res.request.replace(/^node:/, '');
+      }),
     ],
     watchOptions,
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
@@ -377,7 +443,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         },
       },
     }),
-    ...merge(createCacheStrategy(mode, "client"), { experiments: { css: true } })
+    ...merge(createCacheStrategy(mode, "client", { projectConfigPath, configPath }), { experiments: { css: true } })
   };
 
 
@@ -414,7 +480,11 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       assetModuleFilename: `${assetsContext}/[hash][ext][query]`,
       ...(isProd && { clean: { keep: keepOutsideBuild() } }),
     },
-    optimization: { usedExports: true },
+    optimization: {
+      usedExports: true,
+      splitChunks: false,
+      runtimeChunk: false,
+    },
     module: {
       rules: [swcConfigRule, ...extraRules],
       parser: {
@@ -431,6 +501,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       conditionNames: ['import', 'require', 'node', 'default'],
     },
     externals,
+    externalsPresets: { node: true },
     plugins: [
       new DefinePlugin(
         isTest && (isTestModule || isTestEager)
@@ -455,7 +526,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     watchOptions,
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...((isDevEnvironment || (isTest && !isTestEager) || isNative) &&
-      createCacheStrategy(mode, "server")),
+      createCacheStrategy(mode, "server", { projectConfigPath, configPath })),
   };
 
   // Load and apply project-level overrides for the selected build
@@ -496,13 +567,16 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         : projectConfig;
 
     const omitPaths = [
-      'name',
-      'target',
-      'entry',
-      'output.path',
-      'output.filename',
-      'output.publicPath',
-    ];
+      "name",
+      "target",
+      "entry",
+      "output.path",
+      "output.filename",
+      "output.publicPath",
+      ...(Meteor.isServer
+        ? ["optimization.splitChunks", "optimization.runtimeChunk"]
+        : []),
+    ].filter(Boolean);
     const warningFn = path => {
       console.warn(
         `[rspack.config.js] Ignored custom "${path}" — reserved for Meteor-Rspack integration.`,
@@ -523,7 +597,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     }
   }
 
-  const config = isClient ? clientConfig : serverConfig;
+  const sideConfig = isClient ? clientConfig : serverConfig;
+  const config = mergeMeteorRspackFragments(sideConfig);
 
   if (Meteor.isDebug || Meteor.isVerbose) {
     console.log('Config:', inspect(config, { depth: null, colors: true }));