@meteorjs/rspack 1.1.0-beta.9 → 2.0.1

package/lib/meteorRspackHelpers.js

@@ -132,10 +132,14 @@ function splitVendorChunk() {
 }
 
 /**
- * Extend SWC loader config
- * Usage: extendSwcConfig()
+ * Extend SWC loader config by smart-merging custom options on top of Meteor's
+ * defaults (via `mergeSplitOverlap`).  Only the properties you specify are
+ * overridden; everything else is preserved.
  *
- * @returns {Record<string, object>} `{ meteorRspackConfigX: { optimization: { ... } } }`
+ * Usage: Meteor.extendSwcConfig({ jsc: { parser: { decorators: true } } })
+ *
+ * @param {object} swcConfig - SWC loader options to merge with defaults
+ * @returns {Record<string, object>} config fragment for spreading into rspack config
  */
 function extendSwcConfig(swcConfig) {
   return prepareMeteorRspackConfig({
@@ -152,6 +156,44 @@ function extendSwcConfig(swcConfig) {
   });
 }
 
+/**
+ * Replace the SWC loader config entirely, discarding Meteor's defaults.
+ * Use this when you need full control over SWC options and don't want any
+ * automatic merging with Meteor's built-in configuration.
+ *
+ * Usage: Meteor.replaceSwcConfig({ jsc: { parser: { syntax: 'typescript' }, target: 'es2020' } })
+ *
+ * @param {object} swcConfig - Complete SWC loader options (replaces defaults)
+ * @returns {Record<string, object>} config fragment for spreading into rspack config
+ */
+function replaceSwcConfig(swcConfig) {
+  return prepareMeteorRspackConfig({
+    module: {
+      rules: [
+        {
+          test: /\.(?:[mc]?js|jsx|[mc]?ts|tsx)$/i,
+          exclude: /node_modules|\.meteor\/local/,
+          loader: 'builtin:swc-loader',
+          options: swcConfig,
+        },
+      ],
+    },
+  });
+}
+
+/**
+ * Signal that `Meteor.isDevelopment` and `Meteor.isProduction` should be omitted
+ * from DefinePlugin, making the bundle portable across Meteor environments.
+ * Usage: return Meteor.enablePortableBuild() in your rspack.config.js
+ *
+ * @returns {Record<string, object>} config fragment with `meteor.enablePortableBuild: true`
+ */
+function enablePortableBuild() {
+  return prepareMeteorRspackConfig({
+    "meteor.enablePortableBuild": true,
+  });
+}
+
 /**
  * Remove plugins from a Rspack config by name, RegExp, predicate, or array of them.
  * When using a function predicate, it receives both the plugin and its index in the plugins array.
@@ -202,6 +244,92 @@ function disablePlugins(config, matchers) {
   return config;
 }
 
+/**
+ * Create a `writeToDisk` callback that persists specific files to disk
+ * during development.
+ *
+ * Accepts an array (defaults to "always" strategy) or an object with
+ * `once` and/or `always` keys for mixed strategies.
+ *
+ * Matchers can be:
+ * - **string**: matched with `endsWith` (e.g. `'sw.js'`, `'.html'`)
+ * - **RegExp**: tested against the full file path
+ * - **function**: `(filePath: string) => boolean`
+ *
+ * Strategies:
+ * - `always`: Write on every build (default). Use for files that should
+ *             always reflect the latest build output.
+ * - `once`:   Write on the first build only. Skipped on HMR rebuilds to
+ *             avoid triggering service worker re-registration or file
+ *             watcher restarts.
+ *
+ * @example
+ * // Simple: array defaults to "always"
+ * ...Meteor.persistDevFiles(['manifest.json'])
+ *
+ * // Mixed strategies with strings, regex, and functions
+ * ...Meteor.persistDevFiles({
+ *   once: ['sw.js', /\.worker\.js$/],
+ *   always: ['manifest.json', (filePath) => filePath.includes('/custom/')],
+ * })
+ *
+ * @param {(string|RegExp|Function)[] | { once?: (string|RegExp|Function)[], always?: (string|RegExp|Function)[] }} matchers
+ * @returns {Record<string, object>} config fragment with devServer.devMiddleware.writeToDisk
+ */
+/**
+ * Build the writeToDisk callback from matchers.
+ * Shared by persistDevFiles (fragment) and internal usage (direct).
+ * @private
+ */
+function createPersistCallback(matchers) {
+  const once = [];
+  const always = [];
+
+  if (Array.isArray(matchers)) {
+    always.push(...matchers);
+  } else {
+    if (matchers.once) once.push(...matchers.once);
+    if (matchers.always) always.push(...matchers.always);
+  }
+
+  // HTML files are always persisted, Meteor's web server relies on them
+  if (!always.includes('.html')) {
+    always.push('.html');
+  }
+
+  const match = (filePath, pattern) => {
+    if (typeof pattern === 'function') return pattern(filePath);
+    if (typeof pattern === 'string') return filePath.endsWith(pattern);
+    return pattern.test(filePath);
+  };
+
+  const written = new Set();
+
+  return (filePath) => {
+    for (const pattern of always) {
+      if (match(filePath, pattern)) return true;
+    }
+    for (let i = 0; i < once.length; i++) {
+      if (match(filePath, once[i])) {
+        if (written.has(i)) return false;
+        written.add(i);
+        return true;
+      }
+    }
+    return false;
+  };
+}
+
+function persistDevFiles(matchers) {
+  return prepareMeteorRspackConfig({
+    devServer: {
+      devMiddleware: {
+        writeToDisk: createPersistCallback(matchers),
+      },
+    },
+  });
+}
+
 function outputMeteorRspack(data) {
   const jsonString = JSON.stringify(data);
   const output = `[Meteor-Rspack]${jsonString}[/Meteor-Rspack]`;
@@ -214,7 +342,11 @@ module.exports = {
   setCache,
   splitVendorChunk,
   extendSwcConfig,
+  replaceSwcConfig,
   makeWebNodeBuiltinsAlias,
   disablePlugins,
   outputMeteorRspack,
+  enablePortableBuild,
+  persistDevFiles,
+  createPersistCallback,
 };

package/lib/swc.js

@@ -9,11 +9,38 @@ const vm = require('vm');
 function getMeteorAppSwcrc(file = '.swcrc') {
   try {
     const filePath = `${process.cwd()}/${file}`;
-    if (file.endsWith('.js')) {
+    if (file.endsWith('.js') || file.endsWith('.ts')) {
       let content = fs.readFileSync(filePath, 'utf-8');
-      // Check if the content uses ES module syntax (export default)
+      
+      if (file.endsWith('.ts')) {
+        try {
+          const swc = require('@swc/core');
+          const result = swc.transformSync(content, {
+            jsc: {
+              parser: {
+                syntax: 'typescript',
+              },
+              target: 'es2015',
+            },
+          });
+          content = result.code;
+        } catch (swcError) {
+          content = content
+            .replace(/import\s+type\s+.*?from\s+['"][^'"]+['"];?/g, '')
+            .replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, '')
+            .replace(/import\s+['"][^'"]+['"];?/g, '')
+            .replace(/export\s+default\s+/, 'module.exports = ')
+            .replace(/export\s+/g, '')
+            .replace(/:\s*\w+(\[\])?(\s*=)/g, '$2')
+            .replace(/\(([^)]*?):\s*\w+(\[\])?\)/g, '($1)')
+            .replace(/\):\s*\w+(\[\])?\s*\{/g, ') {')
+            .replace(/interface\s+\w+\s*\{[^}]*\}/g, '')
+            .replace(/type\s+\w+\s*=\s*[^;]+;/g, '')
+            .replace(/as\s+\w+(\[\])?/g, '');
+        }
+      }
+      
       if (content.includes('export default')) {
-        // Transform ES module syntax to CommonJS
         content = content.replace(/export\s+default\s+/, 'module.exports = ');
       }
       const script = new vm.Script(`
@@ -27,7 +54,9 @@ function getMeteorAppSwcrc(file = '.swcrc') {
         })()
       `);
       const context = vm.createContext({ process });
-      return script.runInContext(context);
+      const result = script.runInContext(context);
+      // Handle CJS interop wrapper (e.g. { __esModule: true, default: config })
+      return result && result.__esModule && result.default ? result.default : result;
     } else {
       // For .swcrc and other JSON files, parse as JSON
       return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -45,12 +74,13 @@ function getMeteorAppSwcrc(file = '.swcrc') {
 function getMeteorAppSwcConfig() {
   const hasSwcRc = fs.existsSync(`${process.cwd()}/.swcrc`);
   const hasSwcJs = !hasSwcRc && fs.existsSync(`${process.cwd()}/swc.config.js`);
+  const hasSwcTs = !hasSwcRc && !hasSwcJs && fs.existsSync(`${process.cwd()}/swc.config.ts`);
 
-  if (!hasSwcRc && !hasSwcJs) {
+  if (!hasSwcRc && !hasSwcJs && !hasSwcTs) {
     return undefined;
   }
 
-  const swcFile = hasSwcJs ? 'swc.config.js' : '.swcrc';
+  const swcFile = hasSwcTs ? 'swc.config.ts' : hasSwcJs ? 'swc.config.js' : '.swcrc';
   const config = getMeteorAppSwcrc(swcFile);
 
   // Set baseUrl to process.cwd() if it exists

package/lib/test.js

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { createIgnoreRegex, createIgnoreGlobConfig } = require("./ignore.js");
 
+// Normalize a path to always use forward slashes (POSIX style).
+// Module identifiers in bundled JS must use '/' regardless of OS.
+const toPosix = (p) => p.replace(/\\/g, '/');
+
 /**
  * Generates eager test files dynamically
  * @param {Object} options - Options for generating the test file
@@ -42,7 +46,6 @@ const generateEagerTestFile = ({
   const excludeFoldersRegex = createIgnoreRegex(
     createIgnoreGlobConfig(ignoreEntries)
   );
-  console.log("inMeteorIgnoreEntries", inMeteorIgnoreEntries);
   // Create regex from meteor ignore entries
   const excludeMeteorIgnoreRegex = inMeteorIgnoreEntries.length > 0
     ? createIgnoreRegex(createIgnoreGlobConfig(inMeteorIgnoreEntries))
@@ -58,14 +61,14 @@ const generateEagerTestFile = ({
     : "/\\.(?:test|spec)s?\\.[^.]+$/";
 
   const content = `${
-    globalImportPath ? `import '${globalImportPath}';\n\n` : ""
+    globalImportPath ? `import '${toPosix(globalImportPath)}';\n\n` : ""
   }${
     excludeMeteorIgnoreRegex
       ? `const MeteorIgnoreRegex = ${excludeMeteorIgnoreRegex.toString()};`
       : ""
   }
 {
-  const ctx = import.meta.webpackContext('${projectDir}', {
+  const ctx = import.meta.webpackContext('${toPosix(projectDir)}', {
     recursive: true,
     regExp: ${regExp},
     exclude: ${excludeFoldersRegex.toString()},
@@ -81,9 +84,9 @@ const generateEagerTestFile = ({
   }).forEach(ctx);
   ${
     extraEntry
-      ? `const extra = import.meta.webpackContext('${path.dirname(
+      ? `const extra = import.meta.webpackContext('${toPosix(path.dirname(
           extraEntry
-        )}', {
+        ))}', {
     recursive: false,
     regExp: ${new RegExp(`${path.basename(extraEntry)}$`).toString()},
     mode: 'eager',

package/package.json

@@ -1,19 +1,27 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "1.1.0-beta.9",
+  "version": "2.0.1",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",
   "author": "",
   "license": "ISC",
+  "scripts": {
+    "bump": "node ./scripts/bump-version.js",
+    "publish:beta": "bash ./scripts/publish-beta.sh"
+  },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
     "ignore-loader": "^0.1.2",
     "node-polyfill-webpack-plugin": "^4.1.0",
     "webpack-merge": "^6.0.1"
   },
+  "devDependencies": {
+    "semver": "^7.7.4"
+  },
   "peerDependencies": {
     "@rspack/cli": ">=1.3.0",
-    "@rspack/core": ">=1.3.0"
+    "@rspack/core": ">=1.3.0",
+    "@swc/core": ">=1.3.0"
   }
 }

package/plugins/MeteorRspackOutputPlugin.js

@@ -6,6 +6,96 @@
 
 const { outputMeteorRspack } = require('../lib/meteorRspackHelpers');
 
+/**
+ * Extracts file extensions that rspack is configured to handle
+ * from the resolved module.rules test patterns.
+ * @param {import('@rspack/core').Compiler} compiler
+ * @returns {Set<string>} Set of extensions like .css, .less, .scss
+ */
+function extractConfiguredExtensions(compiler) {
+  const delegatableExtensions = ['.css', '.less', '.scss', '.sass', '.styl'];
+  const found = new Set();
+
+  function inspectRules(rules) {
+    for (const rule of rules) {
+      if (!rule) continue;
+      if (rule.test) {
+        const testStr = rule.test instanceof RegExp
+          ? rule.test.source
+          : String(rule.test);
+        for (const ext of delegatableExtensions) {
+          const escaped = ext.replace('.', '\\.');
+          if (testStr.includes(escaped)) {
+            found.add(ext);
+          }
+        }
+      }
+      if (rule.oneOf) inspectRules(rule.oneOf);
+      if (rule.rules) inspectRules(rule.rules);
+    }
+  }
+
+  inspectRules(compiler.options.module?.rules || []);
+  return found;
+}
+
+/**
+ * Extracts file extensions that rspack both has rules for AND actually compiled
+ * from files within entry folder paths (e.g. client/, server/).
+ * An extension is only delegated if Rspack compiled a file with that extension
+ * from an entry folder. Files in non-entry folders (e.g. imports/) don't count,
+ * since delegation only ignores entry folder files for Meteor.
+ * @param {import('@rspack/core').Stats} stats
+ * @param {import('@rspack/core').Compiler} compiler
+ * @returns {string[]} Array of extensions like ['.css', '.less', '.scss']
+ */
+function extractDelegatedExtensions(stats, compiler) {
+  const configured = extractConfiguredExtensions(compiler);
+  if (configured.size === 0) return [];
+
+  const path = require('path');
+  const fs = require('fs');
+  const appRoot = compiler.options.context || process.cwd();
+
+  // Read entry folders from package.json meteor.mainModule
+  const entryFolders = new Set();
+  try {
+    const pkgPath = path.join(appRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const mainModule = pkg?.meteor?.mainModule || {};
+    for (const entry of Object.values(mainModule)) {
+      if (typeof entry === 'string') {
+        const folder = entry.split('/')[0];
+        if (folder) entryFolders.add(folder);
+      }
+    }
+  } catch (e) {
+    // If we can't read package.json, fall back to config-only
+    return Array.from(configured);
+  }
+
+  if (entryFolders.size === 0) return Array.from(configured);
+
+  const found = new Set();
+
+  for (const module of stats.compilation.modules) {
+    const resource = module.resource || module.userRequest;
+    if (!resource) continue;
+
+    const relativePath = path.relative(appRoot, resource);
+    const topFolder = relativePath.split(path.sep)[0];
+    if (!entryFolders.has(topFolder)) continue;
+
+    const ext = path.extname(resource);
+    if (configured.has(ext)) {
+      found.add(ext);
+      if (found.size === configured.size) break;
+    }
+  }
+
+  return Array.from(found);
+}
+
 class MeteorRspackOutputPlugin {
   constructor(options = {}) {
     this.pluginName = 'MeteorRspackOutputPlugin';
@@ -26,6 +116,7 @@ class MeteorRspackOutputPlugin {
         ...(this.getData(stats, {
           compilationCount: this.compilationCount,
           isRebuild: this.compilationCount > 1,
+          compiler,
         }) || {}),
       };
       outputMeteorRspack(data);
@@ -33,4 +124,4 @@ class MeteorRspackOutputPlugin {
   }
 }
 
-module.exports = { MeteorRspackOutputPlugin };
+module.exports = { MeteorRspackOutputPlugin, extractDelegatedExtensions };

package/plugins/RequireExtenalsPlugin.js

@@ -10,6 +10,10 @@
 const fs = require('fs');
 const path = require('path');
 
+// Normalize a path to always use forward slashes (POSIX style).
+// Module identifiers in bundled JS must use '/' regardless of OS.
+const toPosix = (p) => p.replace(/\\/g, '/');
+
 class RequireExternalsPlugin {
   constructor({
     filePath,
@@ -46,7 +50,7 @@ class RequireExternalsPlugin {
     // Prepare paths
     this.filePath = path.resolve(process.cwd(), filePath);
     this.backRoot = '../'.repeat(
-      filePath.replace(/^\.?\/+/, '').split('/').length - 1
+      filePath.replace(/^\.?[/\\]+/, '').split(/[/\\]/).length - 1
     );
 
     // Initialize funcCount based on existing helpers in the file
@@ -96,14 +100,16 @@ class RequireExternalsPlugin {
       pkg &&
       (path.isAbsolute(pkg) ||
         pkg.startsWith('./') ||
+        pkg.startsWith('.\\') ||
         pkg.startsWith('../') ||
+        pkg.startsWith('..\\') ||
         !!depInfo.ext)
     ) {
       const module = this.externalsMeta.get(pkg);
       if (module) {
-        return `${this.backRoot}${module.relativeRequest}`;
+        return `${this.backRoot}${toPosix(module.relativeRequest)}`;
       }
-      return `${this.backRoot}${name}`;
+      return `${this.backRoot}${toPosix(name)}`;
     }
 
     return pkg;
@@ -132,7 +138,7 @@ class RequireExternalsPlugin {
               this.externalsMeta.set(externalRequest, {
                 originalRequest: request,
                 externalRequest,
-                relativeRequest: path.join(relContext, request),
+                relativeRequest: toPosix(path.join(relContext, request)),
               });
 
               // tell Rspack "don't bundle this, import it at runtime"