@meteorjs/rspack 0.0.50 → 0.0.52

package/lib/ignore.js

@@ -0,0 +1,172 @@
+var fs = require('fs');
+var path = require('path');
+
+// Cleans an entry from wildcard patterns (*/**)
+function cleanWildcardEntry(entry) {
+  // If it's an extension pattern like *.ext, skip it
+  if (entry.match(/\*\.[^\/]+$/)) {
+    return null;
+  }
+
+  // Handle patterns like my-folder/**/* by extracting the folder part
+  if (entry.includes('/**/')) {
+    const folderContext = entry.split('/**/')[0].replace(/\/+$/, '');
+    if (folderContext) {
+      return folderContext;
+    }
+  }
+
+  // Otherwise, extract the folder context by removing the wildcard part
+  if (entry.includes('*')) {
+    const folderContext = entry.split('*')[0].replace(/\/+$/, '');
+    if (folderContext) {
+      return folderContext;
+    }
+    return null;
+  }
+
+  return entry;
+}
+
+/**
+ * Reads the .meteorignore file from the given project directory and returns
+ * the parsed entries.
+ *
+ * @param {string} projectDir - The project directory path
+ * @returns {Object} - Object with rootFolders and nestedFolders arrays
+ */
+const getMeteorIgnoreEntries = function (projectDir) {
+  const meteorIgnorePath = path.join(projectDir, '.meteorignore');
+
+  // Check if .meteorignore file exists
+  let entries = [];
+  try {
+    const fileContent = fs.readFileSync(meteorIgnorePath, 'utf8');
+
+    // Process each line in the file
+    entries = fileContent.split(/\r?\n/).filter(line => {
+      // 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);
+
+    // 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 { rootFolders, nestedFolders };
+  } catch (e) {
+    // If the file doesn't exist or can't be read, return empty arrays
+    return { rootFolders: [], nestedFolders: [] };
+  }
+};
+
+/**
+ * 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 {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(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 escapedNestedFolders = nestedFolders.map(folder => 
+    folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  );
+
+  const escapedRootFolders = rootFolders.map(folder => 
+    folder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  );
+
+  // 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}/**`);
+    });
+  }
+
+  return globPatterns;
+}
+
+module.exports = {
+  createIgnoreFoldersRegex,
+  getMeteorIgnoreEntries,
+  createIgnoreGlobConfig,
+};

package/lib/test.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+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,
+  buildContext,
+  rootFolders,
+  nestedFolders,
+}) => {
+  const distDir = path.resolve(projectDir, ".meteor/local/test");
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir, { recursive: true });
+  }
+
+  const excludeFoldersRegex = createIgnoreFoldersRegex({
+    nestedFolders: [
+      "node_modules",
+      ".meteor",
+      "public",
+      "private",
+      buildContext,
+      ...nestedFolders,
+    ],
+    rootFolders,
+  });
+
+  const filename = isAppTest ? "eager-app-tests.mjs" : "eager-tests.mjs";
+  const filePath = path.resolve(distDir, filename);
+  const regExp = isAppTest
+    ? "/\\.app-(?:test|spec)s?\\.[^.]+$/"
+    : "/\\.(?:test|spec)s?\\.[^.]+$/";
+
+  const content = `{
+  const ctx = import.meta.webpackContext('/', {
+    recursive: true,
+    regExp: ${regExp},
+    exclude: ${excludeFoldersRegex.toString()},
+    mode: 'eager',
+  });
+  ctx.keys().forEach(ctx);
+}`;
+
+  fs.writeFileSync(filePath, content);
+  return filePath;
+};
+
+module.exports = {
+  generateEagerTestFile,
+};

package/package.json

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

package/rspack.config.js

@@ -8,6 +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 { 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) {
@@ -101,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
@@ -137,7 +134,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const swcExternalHelpers = !!Meteor.swcExternalHelpers;
   const isNative = !!Meteor.isNative;
   const mode = isProd ? 'production' : 'development';
-  const projectConfigPath = Meteor.projectConfigPath || path.resolve(process.cwd(), 'rspack.config.js');
+  const projectDir = process.cwd();
+  const projectConfigPath = Meteor.projectConfigPath || path.resolve(projectDir, 'rspack.config.js');
 
   const isTypescriptEnabled = Meteor.isTypescriptEnabled || false;
   const isJsxEnabled =
@@ -162,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';
@@ -171,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
@@ -196,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) {
@@ -368,12 +372,25 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     experiments: { css: true },
   };
 
+
   const serverEntry =
     isTest && isTestEager && isTestFullApp
-      ? path.resolve(process.cwd(), 'node_modules/@meteorjs/rspack/entries/eager-app-tests.mjs')
+      ? generateEagerTestFile({
+          isAppTest: true,
+          projectDir,
+          buildContext,
+          rootFolders,
+          nestedFolders,
+        })
       : isTest && isTestEager
-      ? path.resolve(process.cwd(), 'node_modules/@meteorjs/rspack/entries/eager-tests.mjs')
-      : 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]`;
@@ -404,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,
@@ -437,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');

package/entries/eager-app-tests.mjs

@@ -1,9 +0,0 @@
-{
-  const ctx = import.meta.webpackContext('/', {
-    recursive: true,
-    regExp: /\.app-(?:test|spec)s?\.[^.]+$/,
-    exclude: /(^|\/)(node_modules|\.meteor|_build)(\/|$)/,
-    mode: 'eager',
-  });
-  ctx.keys().forEach(ctx);
-}

package/entries/eager-tests.mjs

@@ -1,9 +0,0 @@
-{
-  const ctx = import.meta.webpackContext('/', {
-    recursive: true,
-    regExp: /\.(?:test|spec)s?\.[^.]+$/,
-    exclude: /(^|\/)(node_modules|\.meteor|_build)(\/|$)/,
-    mode: 'eager',
-  });
-  ctx.keys().forEach(ctx);
-}