@meteorjs/rspack 1.1.0-beta.31 → 1.1.0-beta.33

package/README.md

@@ -14,6 +14,7 @@ When Meteor runs with the Rspack bundler enabled, this package is what generates
 - **Asset externals and HTML generation** through custom Rspack plugins
 - **A `defineConfig` helper** that accepts a factory function receiving Meteor environment flags and build utilities
 - **Customizable config** via `rspack.config.js` in your project root, with safe merging that warns if you try to override reserved settings
+- **Automatic CSS delegation** when rspack is configured with CSS, Less, or SCSS loaders, Meteor automatically detects the handled extensions after the first compilation and stops processing those files itself in the entry folder context. No `.meteorignore` entries needed.
 
 ## Installation
 

package/lib/localDependenciesHelpers.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract local file dependencies from a config file by parsing require/import statements using AST
+ * @param {string} configFilePath - Path to the config file to parse
+ * @returns {string[]} - Array of absolute paths to local dependencies
+ */
+function extractLocalDependencies(configFilePath) {
+  if (!configFilePath || !fs.existsSync(configFilePath)) {
+    return [];
+  }
+
+  try {
+    const swc = require('@swc/core');
+    const content = fs.readFileSync(configFilePath, 'utf-8');
+    const configDir = path.dirname(configFilePath);
+    const projectDir = process.cwd();
+    const dependencies = [];
+
+    // Parse the file into an AST
+    const ast = swc.parseSync(content, {
+      syntax: 'ecmascript',
+      dynamicImport: true,
+      target: 'es2020',
+    });
+
+    // Visit all nodes to find import/require statements
+    visitNode(ast, (node) => {
+      let modulePath = null;
+
+      // Handle require() calls: require('./plugin')
+      if (node.type === 'CallExpression' && 
+          node.callee.type === 'Identifier' && 
+          node.callee.value === 'require' &&
+          node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.expression?.type === 'StringLiteral') {
+          modulePath = arg.expression.value;
+        }
+      }
+
+      // Handle dynamic import() calls: import('./plugin')
+      if (node.type === 'CallExpression' &&
+          node.callee.type === 'Import' &&
+          node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.expression?.type === 'StringLiteral') {
+          modulePath = arg.expression.value;
+        }
+      }
+
+      // Handle static imports: import x from './plugin'
+      if (node.type === 'ImportDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // Handle export re-exports: export * from './plugin'
+      if (node.type === 'ExportAllDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // Handle named export re-exports: export { x } from './plugin'
+      if (node.type === 'ExportNamedDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // If we found a module path, try to resolve it
+      if (modulePath) {
+        const resolvedPath = resolveLocalModule(modulePath, configDir, projectDir);
+        if (resolvedPath) {
+          dependencies.push(resolvedPath);
+        }
+      }
+    });
+
+    // Remove duplicates
+    return [...new Set(dependencies)];
+  } catch (error) {
+    console.warn('[Rspack Cache] Failed to parse config dependencies:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Recursively visit all nodes in an AST
+ * @param {Object} node - AST node
+ * @param {Function} callback - Function to call for each node
+ */
+function visitNode(node, callback) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  callback(node);
+
+  // Visit all properties of the node
+  for (const key in node) {
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        value.forEach(child => visitNode(child, callback));
+      } else if (typeof value === 'object') {
+        visitNode(value, callback);
+      }
+    }
+  }
+}
+
+/**
+ * Resolve a module path to an absolute path if it's a local file
+ * @param {string} modulePath - Module path from require/import statement
+ * @param {string} configDir - Directory containing the config file
+ * @param {string} projectDir - Project root directory
+ * @returns {string|null} - Resolved absolute path or null
+ */
+function resolveLocalModule(modulePath, configDir, projectDir) {
+  // Only process relative paths (starts with . or ..)
+  if (!modulePath.startsWith('.')) {
+    return null;
+  }
+
+  try {
+    let resolvedPath = path.resolve(configDir, modulePath);
+    const extensions = ['.js', '.mjs', '.cjs', '.ts', '.json'];
+
+    // If the path exists as-is, check if it's a directory needing index resolution
+    if (fs.existsSync(resolvedPath)) {
+      if (fs.statSync(resolvedPath).isDirectory()) {
+        let found = false;
+        for (const ext of extensions) {
+          const indexPath = path.join(resolvedPath, `index${ext}`);
+          if (fs.existsSync(indexPath)) {
+            resolvedPath = indexPath;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return null;
+        }
+      }
+    } else {
+      // Try common extensions if file doesn't exist as-is
+      let found = false;
+
+      for (const ext of extensions) {
+        const pathWithExt = resolvedPath + ext;
+        if (fs.existsSync(pathWithExt)) {
+          resolvedPath = pathWithExt;
+          found = true;
+          break;
+        }
+      }
+
+      // If still not found, return null
+      if (!found) {
+        return null;
+      }
+    }
+
+    // Verify file is within project (not node_modules)
+    const resolvedReal = fs.realpathSync(resolvedPath);
+    const projectReal = fs.realpathSync(projectDir);
+
+    const isWithinProject = 
+      resolvedReal === projectReal ||
+      resolvedReal.startsWith(projectReal + path.sep);
+    const hasNodeModulesSegment = resolvedReal.split(path.sep).includes('node_modules');
+
+    if (isWithinProject && !hasNodeModulesSegment) {
+      return resolvedPath;
+    }
+  } catch (error) {
+    // Silently ignore resolution errors
+  }
+
+  return null;
+}
+
+module.exports = {
+  extractLocalDependencies,
+  resolveLocalModule,
+};

package/package.json

@@ -1,19 +1,27 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "1.1.0-beta.31",
+  "version": "1.1.0-beta.33",
   "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/rspack.config.js

@@ -10,7 +10,7 @@ const { getMeteorAppSwcConfig } = require('./lib/swc.js');
 const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
 const { RequireExternalsPlugin } = require('./plugins/RequireExtenalsPlugin.js');
 const { AssetExternalsPlugin } = require('./plugins/AssetExternalsPlugin.js');
-const { MeteorRspackOutputPlugin } = require('./plugins/MeteorRspackOutputPlugin.js');
+const { MeteorRspackOutputPlugin, extractDelegatedExtensions } = require('./plugins/MeteorRspackOutputPlugin.js');
 const { generateEagerTestFile } = require("./lib/test.js");
 const { getMeteorIgnoreEntries, createIgnoreGlobConfig } = require("./lib/ignore");
 const {
@@ -27,6 +27,8 @@ const {
 } = require('./lib/meteorRspackHelpers.js');
 const { loadUserAndOverrideConfig } = require('./lib/meteorRspackConfigHelpers.js');
 const { prepareMeteorRspackConfig } = require("./lib/meteorRspackConfigFactory");
+const { extractLocalDependencies } = require('./lib/localDependenciesHelpers.js');
+
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -69,10 +71,16 @@ function createCacheStrategy(
   const yarnLockPath = path.join(process.cwd(), 'yarn.lock');
   const hasYarnLock = fs.existsSync(yarnLockPath);
 
+  // Extract local dependencies from project config (e.g., plugin files)
+  const localDependencies = projectConfigPath 
+    ? extractLocalDependencies(projectConfigPath) 
+    : [];
+
   // Build dependencies array
   const buildDependencies = [
     ...(projectConfigPath ? [projectConfigPath] : []),
     ...(configPath ? [configPath] : []),
+    ...localDependencies,
     ...(hasTsconfig ? [tsconfigPath] : []),
     ...(hasBabelRcConfig ? [babelRcConfig] : []),
     ...(hasBabelJsConfig ? [babelJsConfig] : []),
@@ -643,7 +651,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         port: devServerPort,
         devMiddleware: {
           writeToDisk: (filePath) =>
-            /\.(html)$/.test(filePath) && !filePath.includes(".hot-update."),
+            /\.(html)$/.test(filePath) || filePath.endsWith('sw.js'),
         },
         onListening(devServer) {
           if (!devServer) return;
@@ -843,7 +851,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   // Add MeteorRspackOutputPlugin as the last plugin to output compilation info
   const meteorRspackOutputPlugin = new MeteorRspackOutputPlugin({
-    getData: (stats, { isRebuild, compilationCount }) => ({
+    getData: (stats, { isRebuild, compilationCount, compiler }) => ({
       name: config.name,
       mode: config.mode,
       hasErrors: stats.hasErrors(),
@@ -852,6 +860,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       statsOverrided,
       compilationCount,
       isRebuild,
+      ...(!isRebuild && compiler && {
+        delegatedExtensions: extractDelegatedExtensions(stats, compiler),
+      }),
     }),
   });
   config.plugins = [meteorRspackOutputPlugin, ...(config.plugins || [])];