@meteorjs/rspack 0.0.51 → 0.0.52

package/lib/ignore.js

@@ -33,14 +33,9 @@ function cleanWildcardEntry(entry) {
  * the parsed entries.
  *
  * @param {string} projectDir - The project directory path
- * @param {Object} options - Options for processing ignore entries
- * @param {boolean} options.foldersOnly - If true, returns only folder entries
- * @returns {Array<string>} - Array of ignore entries
+ * @returns {Object} - Object with rootFolders and nestedFolders arrays
  */
-const getMeteorIgnoreEntries = function (projectDir, options) {
-  options = options || {};
-  const foldersOnly = !!options.foldersOnly;
-
+const getMeteorIgnoreEntries = function (projectDir) {
   const meteorIgnorePath = path.join(projectDir, '.meteorignore');
 
   // Check if .meteorignore file exists
@@ -50,39 +45,35 @@ const getMeteorIgnoreEntries = function (projectDir, options) {
 
     // Process each line in the file
     entries = fileContent.split(/\r?\n/).filter(line => {
-      // Skip empty lines and comments
-      return line.trim() !== '' && !line.trim().startsWith('#');
-    });
+      // Trim the line
+      const trimmedLine = line.trim();
+      // Skip empty lines, comments, and negation entries (starting with !)
+      return trimmedLine !== '' && !trimmedLine.startsWith('#') && !trimmedLine.startsWith('!');
+    }).map(line => line.trim()); // Ensure all lines are trimmed
 
     // Clean all entries from wildcard patterns (*/** parts)
     entries = entries.map(entry => {
       return cleanWildcardEntry(entry);
     }).filter(entry => entry !== null);
 
-    if (foldersOnly) {
-      // Filter to include only entries that are likely to be folders
-      entries = entries.filter(entry => {
-        // Entries ending with / are definitely folders
-        if (entry.endsWith('/')) {
-          return true;
-        }
-
-        // Try to determine if it's a folder by checking if it exists
-        // and is a directory
-        try {
-          const fullPath = path.join(projectDir, entry);
-          return fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory();
-        } catch (e) {
-          // If we can't determine, assume it's not a folder
-          return false;
-        }
-      });
-    }
+    // Separate entries into rootFolders and nestedFolders
+    const rootFolders = [];
+    const nestedFolders = [];
+
+    entries.forEach(entry => {
+      // If entry starts with / or ./, it's a root folder
+      if (entry.startsWith('/') || entry.startsWith('./')) {
+        rootFolders.push(entry);
+      } else {
+        // Otherwise, it's a nested folder
+        nestedFolders.push(entry);
+      }
+    });
 
-    return entries;
+    return { rootFolders, nestedFolders };
   } catch (e) {
-    // If the file doesn't exist or can't be read, return an empty array
-    return [];
+    // If the file doesn't exist or can't be read, return empty arrays
+    return { rootFolders: [], nestedFolders: [] };
   }
 };
 
@@ -90,28 +81,92 @@ const getMeteorIgnoreEntries = function (projectDir, options) {
  * Creates a regex pattern to ignore specified folders.
  * The pattern will match paths where the specified folders appear as complete path segments.
  * Special regex characters in folder names are automatically escaped.
- * @param {string[]} folders - Array of folder names to ignore
+ * @param {Object|string[]} options - Options object
+ * @param {string[]} [options.nestedFolders] - Array of folder names to ignore anywhere in the path
+ * @param {string[]} [options.rootFolders] - Array of folder names that should only match at the root level
  * @returns {RegExp} - Regex pattern to ignore the specified folders
  */
-function createIgnoreFoldersRegex(folders) {
-  if (!Array.isArray(folders) || folders.length === 0) {
-    throw new Error('folders must be a non-empty array');
+function createIgnoreFoldersRegex(options) {
+  const nestedFolders = options.nestedFolders || [];
+  const rootFolders = options.rootFolders || [];
+
+  if (!Array.isArray(nestedFolders) || nestedFolders.length === 0) {
+    throw new Error('nestedFolders must be a non-empty array');
   }
 
+  // If rootFolders is not provided or empty, use the original behavior
+  if (!rootFolders || !Array.isArray(rootFolders) || rootFolders.length === 0) {
+    // Escape special regex characters in folder names
+    const escapedFolders = nestedFolders.map(folder => 
+      folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    );
+
+    // Join folder names with | for the regex pattern
+    const foldersPattern = escapedFolders.join('|');
+
+    // Create a regex that matches paths where the specified folders appear as complete path segments
+    // Format: /(^|\/)(folder1|folder2|folder3)(\/|$)/
+    return new RegExp(`(^|\\/)(${foldersPattern})(\\/|$)`);
+  }
+
+  // Handle both rootFolders and nestedFolders
   // Escape special regex characters in folder names
-  const escapedFolders = folders.map(folder => 
+  const escapedNestedFolders = nestedFolders.map(folder => 
+    folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  );
+
+  const escapedRootFolders = rootFolders.map(folder => 
     folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
   );
 
-  // Join folder names with | for the regex pattern
-  const foldersPattern = escapedFolders.join('|');
+  // Join folder names with | for the regex patterns
+  const nestedFoldersPattern = escapedNestedFolders.join('|');
+  const rootFoldersPattern = escapedRootFolders.join('|');
+
+  // Create a regex that matches:
+  // 1. Root folders at the beginning of the path: /^(folderRootOnly)(\/|$)/
+  // 2. Nested folders anywhere in the path: /(^|\/)(folderAny1|folderAny2)(\/|$)/
+  const pattern = `^(${rootFoldersPattern})(\\/|$)|(^|\\/)(${nestedFoldersPattern})(\\/|$)`;
+  return new RegExp(pattern);
+}
+
+/**
+ * Creates a glob config array for ignoring specified folders.
+ * For nested folders, the pattern will be "**/" + folder + "/**".
+ * For root folders, the pattern will be folder + "/**".
+ * @param {Object} options - Options object
+ * @param {string[]} [options.nestedFolders] - Array of folder names to ignore anywhere in the path
+ * @param {string[]} [options.rootFolders] - Array of folder names that should only match at the root level
+ * @returns {string[]} - Array of glob patterns to ignore the specified folders
+ */
+function createIgnoreGlobConfig(options = {}) {
+  const nestedFolders = options.nestedFolders || [];
+  const rootFolders = options.rootFolders || [];
+  const globPatterns = [];
+
+  // Create glob patterns for nested folders: **/{nestedFolder}/**
+  if (Array.isArray(nestedFolders) && nestedFolders.length > 0) {
+    nestedFolders.forEach(folder => {
+      // Remove leading ./ or / if present
+      const cleanFolder = folder.replace(/^(\.\/|\/)/g, '');
+      globPatterns.push(`**/${cleanFolder}/**`);
+    });
+  }
+
+  // Create glob patterns for root folders: {rootFolder}/**
+  if (Array.isArray(rootFolders) && rootFolders.length > 0) {
+    rootFolders.forEach(folder => {
+      // Remove leading ./ or / if present
+      const cleanFolder = folder.replace(/^(\.\/|\/)/g, '');
+      globPatterns.push(`${cleanFolder}/**`);
+    });
+  }
 
-  // Create a regex that matches paths where the specified folders appear as complete path segments
-  // Format: /(^|\/)(folder1|folder2|folder3)(\/|$)/
-  return new RegExp(`(^|\\/)(${foldersPattern})(\\/|$)`);
+  return globPatterns;
 }
 
 module.exports = {
   createIgnoreFoldersRegex,
   getMeteorIgnoreEntries,
+  createIgnoreGlobConfig,
 };

package/lib/test.js

@@ -1,29 +1,40 @@
 const fs = require('fs');
 const path = require('path');
-const { createIgnoreFoldersRegex, getMeteorIgnoreEntries } = require("./ignore.js");
+const { createIgnoreFoldersRegex } = require("./ignore.js");
 
 /**
  * Generates eager test files dynamically
  * @param {Object} options - Options for generating the test file
  * @param {boolean} options.isAppTest - Whether this is an app test
  * @param {string} options.projectDir - The project directory
+ * @param {string} options.buildContext - The build context
+ * @param {string} options.rootFolders
+ * @param {string} options.nestedFolders
  * @returns {string} The path to the generated file
  */
-const generateEagerTestFile = ({ isAppTest, projectDir }) => {
+const generateEagerTestFile = ({
+  isAppTest,
+  projectDir,
+  buildContext,
+  rootFolders,
+  nestedFolders,
+}) => {
   const distDir = path.resolve(projectDir, ".meteor/local/test");
   if (!fs.existsSync(distDir)) {
     fs.mkdirSync(distDir, { recursive: true });
   }
 
-  const ignoredFolders = getMeteorIgnoreEntries(projectDir, {
-    foldersOnly: true,
+  const excludeFoldersRegex = createIgnoreFoldersRegex({
+    nestedFolders: [
+      "node_modules",
+      ".meteor",
+      "public",
+      "private",
+      buildContext,
+      ...nestedFolders,
+    ],
+    rootFolders,
   });
-  const excludeFoldersRegex = createIgnoreFoldersRegex([
-    "node_modules",
-    ".meteor",
-    "_build",
-    ...ignoredFolders,
-  ]);
 
   const filename = isAppTest ? "eager-app-tests.mjs" : "eager-tests.mjs";
   const filePath = path.resolve(distDir, filename);

package/package.json

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

package/rspack.config.js

@@ -8,8 +8,8 @@ const { cleanOmittedPaths, mergeSplitOverlap } = require("./lib/mergeRulesSplitO
 const { getMeteorAppSwcConfig } = require('./lib/swc.js');
 const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
 const { RequireExternalsPlugin } = require('./plugins/RequireExtenalsPlugin.js');
-const { createIgnoreFoldersRegex, getMeteorIgnoreEntries } = require("./lib/ignore.js");
 const { generateEagerTestFile } = require("./lib/test.js");
+const { getMeteorIgnoreEntries, createIgnoreGlobConfig } = require("./lib/ignore");
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -103,11 +103,6 @@ function keepOutsideBuild() {
   };
 }
 
-// Watch options shared across both builds
-const defaultWatchOptions = {
-  ignored: ['**/.meteor/local/**', '**/dist/**'],
-};
-
 /**
  * @param {{ isClient: boolean; isServer: boolean; isDevelopment?: boolean; isProduction?: boolean; isTest?: boolean }} Meteor
  * @param {{ mode?: string; clientEntry?: string; serverEntry?: string; clientOutputFolder?: string; serverOutputFolder?: string; chunksContext?: string; assetsContext?: string; serverAssetsContext?: string }} argv
@@ -165,8 +160,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const bannerOutput = JSON.parse(Meteor.bannerOutput || process.env.RSPACK_BANNER || '""');
 
   // Determine output directories
-  const clientOutputDir = path.resolve(process.cwd(), 'public');
-  const serverOutputDir = path.resolve(process.cwd(), 'private');
+  const clientOutputDir = path.resolve(projectDir, 'public');
+  const serverOutputDir = path.resolve(projectDir, 'private');
 
   // Determine context for bundles and assets
   const buildContext = Meteor.buildContext || '_build';
@@ -174,7 +169,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const chunksContext = Meteor.chunksContext || 'build-chunks';
 
   // Determine build output and pass to Meteor
-  const buildOutputDir = path.resolve(process.cwd(), buildContext, outputDir);
+  const buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
   Meteor.buildOutputDir = buildOutputDir;
 
   // Add HtmlRspackPlugin function to Meteor
@@ -199,18 +194,24 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     });
   };
 
-  // Set watch options
+  // Get Meteor ignore entries
+  const { rootFolders, nestedFolders } = getMeteorIgnoreEntries(projectDir);
+
+  // Set default watch options
   const watchOptions = {
-    ...defaultWatchOptions,
-    ...(isTest &&
-      isTestEager && {
-        ignored: [
-          ...defaultWatchOptions.ignored,
-          `**/${buildContext}/**`,
-          '**/.meteor/local/**',
-          '**/node_modules/**',
+    ignored: [
+      ...createIgnoreGlobConfig({
+        rootFolders,
+        nestedFolders: [
+          ".meteor/local",
+          "dist",
+          ...(isTest && isTestEager
+            ? [buildContext, ".meteor/local", "node_modules"]
+            : []),
+          ...(nestedFolders || []),
         ],
       }),
+    ],
   };
 
   if (Meteor.isDebug || Meteor.isVerbose) {
@@ -374,10 +375,22 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   const serverEntry =
     isTest && isTestEager && isTestFullApp
-      ? generateEagerTestFile({ isAppTest: true, projectDir })
+      ? generateEagerTestFile({
+          isAppTest: true,
+          projectDir,
+          buildContext,
+          rootFolders,
+          nestedFolders,
+        })
       : isTest && isTestEager
-      ? generateEagerTestFile({ isAppTest: false, projectDir })
-      : path.resolve(process.cwd(), buildContext, entryPath);
+      ? generateEagerTestFile({
+          isAppTest: false,
+          projectDir,
+          buildContext,
+          rootFolders,
+          nestedFolders,
+        })
+      : path.resolve(projectDir, buildContext, entryPath);
   const serverNameConfig = `[${(isTest && 'test-') || ''}${
     (isTestModule && 'module') || 'server'
   }-rspack]`;
@@ -408,7 +421,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     resolve: {
       extensions,
       alias,
-      modules: ['node_modules', path.resolve(process.cwd())],
+      modules: ['node_modules', path.resolve(projectDir)],
       conditionNames: ['import', 'require', 'node', 'default'],
     },
     externals,
@@ -441,7 +454,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   // Load and apply project-level overrides for the selected build
   // Check if we're in a Meteor package directory by looking at the path
-  const isMeteorPackageConfig = process.cwd().includes('/packages/rspack');
+  const isMeteorPackageConfig = projectDir.includes('/packages/rspack');
   if (fs.existsSync(projectConfigPath) && !isMeteorPackageConfig) {
     // Check if there's a .mjs or .cjs version of the config file
     const mjsConfigPath = projectConfigPath.replace(/\.js$/, '.mjs');