@meteorjs/rspack 0.0.59 → 0.0.61

package/index.d.ts

@@ -5,7 +5,7 @@ import {
   defineConfig as _rspackDefineConfig,
   Configuration as _RspackConfig,
 } from '@rspack/cli';
-import { HtmlRspackPluginOptions } from '@rspack/core';
+import { HtmlRspackPluginOptions, RuleSetConditions } from '@rspack/core';
 
 export interface MeteorRspackConfig extends _RspackConfig {
   meteor?: {
@@ -31,6 +31,31 @@ type MeteorEnv = Record<string, any> & {
    * @returns An instance of HtmlRspackPlugin
    */
   HtmlRspackPlugin: (options?: HtmlRspackPluginOptions) => HtmlRspackPlugin;
+  /**
+   * Wrap externals for Meteor runtime.
+   * @param deps - Package names or module IDs
+   * @returns A config object with externals configuration
+   */
+  compileWithMeteor: (deps: RuleSetConditions) => Record<string, object>;
+  /**
+   * Add SWC transpilation rules limited to specific deps (monorepo-friendly).
+   * @param deps - Package names to include in SWC loader
+   * @param options - Optional configuration options
+   * @returns A config object with module rules configuration
+   */
+  compileWithRspack: (deps: RuleSetConditions) => Record<string, object>;
+  /**
+   * Enable or disable Rspack cache config.
+   * @param enabled - Whether to enable caching
+   * @param cacheConfig - Optional cache configuration
+   * @returns A config object with cache configuration
+   */
+  setCache: (enabled: boolean | 'memory') => Record<string, object>;
+  /**
+   * Enable Rspack split vendor chunk.
+   * @returns A config object with optimization configuration
+   */
+  splitVendorChunk: () => Record<string, object>;
 }
 
 export type ConfigFactory = (

package/lib/meteorRspackConfigFactory.js

@@ -42,11 +42,17 @@ function prepareMeteorRspackConfig(customConfig, opts = {}) {
  * 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, ...).
+ * Position-aware merge:
+ * Walk the config in insertion order and fold:
+ *   - for a fragment key:  out = mergeSplitOverlap(out, fragment)
+ *   - for a normal key:    out = mergeSplitOverlap(out, { [key]: value })
+ *
+ * Result: fragments behave like spreads at their exact position;
+ * later inline keys override earlier ones (including fragments).
  *
  * @param {object} config
  * @param {{ prefix?: string }} [opts]
- * @returns {object} The same (mutated) config instance.
+ * @returns {object} same (mutated) config
  */
 function mergeMeteorRspackFragments(config, opts = {}) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -54,39 +60,36 @@ function mergeMeteorRspackFragments(config, opts = {}) {
   }
   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);
+  let out = {};
+  for (const key of Object.keys(config)) {
+    const val = config[key];
 
-  if (tempKeys.length === 0) return config;
+    const isFragment =
+      typeof key === "string" &&
+      key.startsWith(prefix) &&
+      /^\d+$/.test(key.slice(prefix.length));
 
-  // 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`);
+    if (isFragment) {
+      if (!val || typeof val !== "object" || Array.isArray(val)) {
+        throw new Error(`Fragment "${key}" must be a plain object`);
+      }
+      out = mergeSplitOverlap(out, val);
+    } else {
+      out = mergeSplitOverlap(out, { [key]: val });
     }
-    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];
-
+  // keep object identity; fragments disappear because `out` doesn't include them
+  replaceObject(config, out);
   return config;
 }
 
 function replaceObject(target, source) {
-  for (const key of Object.keys(target)) {
-    if (!(key in source)) delete target[key];
+  for (const k of Object.keys(target)) {
+    if (!(k in source)) delete target[k];
   }
-  for (const key of Object.keys(source)) {
-    target[key] = source[key];
+  for (const k of Object.keys(source)) {
+    target[k] = source[k];
   }
 }
 

package/lib/meteorRspackHelpers.js

@@ -54,6 +54,30 @@ function compileWithRspack(deps, { options = {} } = {}) {
   });
 }
 
+/**
+ * Enable or disable Rspack cache config
+ * Usage: setCache(false)
+ *
+ * @param {boolean} enabled
+ * @param {Record<string, object>} cacheConfig
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { cache: {} } }`
+ */
+function setCache(
+  enabled,
+  cacheConfig = { cache: true, experiments: { cache: true } }
+) {
+  return prepareMeteorRspackConfig(
+    enabled
+      ? cacheConfig
+      : {
+          cache: false, // disable cache
+          experiments: {
+            cache: false, // disable persistent cache (experimental flag)
+          },
+        }
+  );
+}
+
 /**
  * Build an alias map that disables ALL Node core modules in a web build.
  * - Includes both 'fs' and 'node:fs' keys
@@ -65,7 +89,7 @@ function makeWebNodeBuiltinsAlias(extras = []) {
 
   const names = new Set();
   for (const m of core) {
-    names.add(m);           // e.g. 'fs'
+    names.add(m); // e.g. 'fs'
     names.add(`node:${m}`); // e.g. 'node:fs'
   }
   for (const x of extras) names.add(x);
@@ -74,8 +98,35 @@ function makeWebNodeBuiltinsAlias(extras = []) {
   return Object.fromEntries([...names].map((m) => [m, false]));
 }
 
+/**
+ * Enable Rspack split vendor chunk config
+ * Usage: splitVendorChunk()
+ *
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { optimization: { ... } } }`
+ */
+function splitVendorChunk() {
+  return prepareMeteorRspackConfig({
+    optimization: {
+      splitChunks: {
+        chunks: "all", // split both sync and async imports
+        cacheGroups: {
+          vendor: {
+            test: /[\\/]node_modules[\\/]/,
+            name: "vendor",
+            enforce: true,
+            priority: 10,
+            chunks: "all",
+          },
+        },
+      },
+    },
+  });
+}
+
 module.exports = {
   compileWithMeteor,
   compileWithRspack,
+  setCache,
+  splitVendorChunk,
   makeWebNodeBuiltinsAlias,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",

package/rspack.config.js

@@ -14,6 +14,8 @@ const { mergeMeteorRspackFragments } = require("./lib/meteorRspackConfigFactory.
 const {
   compileWithMeteor,
   compileWithRspack,
+  setCache,
+  splitVendorChunk,
   makeWebNodeBuiltinsAlias,
 } = require('./lib/meteorRspackHelpers.js');
 
@@ -137,6 +139,43 @@ function createSwcConfig({
   };
 }
 
+function createRemoteDevServerConfig() {
+  const rootUrl = process.env.ROOT_URL;
+  let hostname;
+  let protocol;
+  let port;
+
+  if (rootUrl) {
+    try {
+      const url = new URL(rootUrl);
+      // Detect if it's remote (not localhost or 127.x)
+      const isLocal =
+        url.hostname.includes('localhost') ||
+        url.hostname.startsWith('127.') ||
+        url.hostname.endsWith('.local');
+      if (!isLocal) {
+        hostname = url.hostname;
+        protocol = url.protocol === 'https:' ? 'wss' : 'ws';
+        port = url.port ? Number(url.port) : (url.protocol === 'https:' ? 443 : 80);
+
+        return {
+          client: {
+            webSocketURL: {
+              hostname,
+              port,
+              protocol,
+            },
+          },
+        };
+      }
+    } catch (err) {
+      console.warn(`Invalid ROOT_URL "${rootUrl}", falling back to localhost`);
+    }
+  }
+
+  // If local doesn't provide any extra config
+  return {};
+}
 
 // Keep files outside of build folders
 function keepOutsideBuild() {
@@ -218,12 +257,24 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
   Meteor.buildOutputDir = buildOutputDir;
 
+  const cacheStrategy = createCacheStrategy(
+    mode,
+    (Meteor.isClient && 'client') || 'server',
+    { projectConfigPath, configPath }
+  );
+
   // Expose Meteor's helpers to expand Rspack configs
   Meteor.compileWithMeteor = deps => compileWithMeteor(deps);
   Meteor.compileWithRspack = deps =>
     compileWithRspack(deps, {
       options: Meteor.swcConfigOptions,
     });
+  Meteor.setCache = enabled =>
+    setCache(
+      !!enabled,
+      enabled === 'memory' ? undefined : cacheStrategy
+    );
+  Meteor.splitVendorChunk = () => splitVendorChunk();
 
   // Add HtmlRspackPlugin function to Meteor
   Meteor.HtmlRspackPlugin = (options = {}) => {
@@ -432,6 +483,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...(isDevEnvironment && {
       devServer: {
+        ...createRemoteDevServerConfig(),
         static: { directory: clientOutputDir, publicPath: '/__rspack__/' },
         hot: true,
         liveReload: true,
@@ -443,7 +495,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         },
       },
     }),
-    ...merge(createCacheStrategy(mode, "client", { projectConfigPath, configPath }), { experiments: { css: true } })
+    ...merge(cacheStrategy, { experiments: { css: true } })
   };
 
 
@@ -526,7 +578,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     watchOptions,
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...((isDevEnvironment || (isTest && !isTestEager) || isNative) &&
-      createCacheStrategy(mode, "server", { projectConfigPath, configPath })),
+      cacheStrategy),
   };
 
   // Load and apply project-level overrides for the selected build
@@ -561,10 +613,15 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       throw error;
     }
 
-    const userConfig =
+    const rawUserConfig =
       typeof projectConfig === 'function'
         ? projectConfig(Meteor, argv)
         : projectConfig;
+    const resolvedUserConfig = await Promise.resolve(rawUserConfig);
+    const userConfig =
+      resolvedUserConfig && '0' in resolvedUserConfig
+        ? resolvedUserConfig[0]
+        : resolvedUserConfig;
 
     const omitPaths = [
       "name",
@@ -583,22 +640,27 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       );
     };
 
+    let nextUserConfig = cleanOmittedPaths(userConfig, {
+      omitPaths,
+      warningFn,
+    });
+    nextUserConfig = mergeMeteorRspackFragments(nextUserConfig);
+
     if (Meteor.isClient) {
       clientConfig = mergeSplitOverlap(
         clientConfig,
-        cleanOmittedPaths(userConfig, { omitPaths, warningFn }),
+        nextUserConfig
       );
     }
     if (Meteor.isServer) {
       serverConfig = mergeSplitOverlap(
         serverConfig,
-        cleanOmittedPaths(userConfig, { omitPaths, warningFn }),
+        nextUserConfig
       );
     }
   }
 
-  const sideConfig = isClient ? clientConfig : serverConfig;
-  const config = mergeMeteorRspackFragments(sideConfig);
+  const config = isClient ? clientConfig : serverConfig;
 
   if (Meteor.isDebug || Meteor.isVerbose) {
     console.log('Config:', inspect(config, { depth: null, colors: true }));