@meteorjs/rspack 0.0.49 → 0.0.51

package/lib/ignore.js

@@ -0,0 +1,117 @@
+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
+ * @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
+ */
+const getMeteorIgnoreEntries = function (projectDir, options) {
+  options = options || {};
+  const foldersOnly = !!options.foldersOnly;
+
+  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 => {
+      // Skip empty lines and comments
+      return line.trim() !== '' && !line.trim().startsWith('#');
+    });
+
+    // 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;
+        }
+      });
+    }
+
+    return entries;
+  } catch (e) {
+    // If the file doesn't exist or can't be read, return an empty array
+    return [];
+  }
+};
+
+/**
+ * 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
+ * @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');
+  }
+
+  // Escape special regex characters in folder names
+  const escapedFolders = folders.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})(\\/|$)`);
+}
+
+module.exports = {
+  createIgnoreFoldersRegex,
+  getMeteorIgnoreEntries,
+};

package/lib/test.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const path = require('path');
+const { createIgnoreFoldersRegex, getMeteorIgnoreEntries } = 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
+ * @returns {string} The path to the generated file
+ */
+const generateEagerTestFile = ({ isAppTest, projectDir }) => {
+  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([
+    "node_modules",
+    ".meteor",
+    "_build",
+    ...ignoredFolders,
+  ]);
+
+  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.49",
+  "version": "0.0.51",
   "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 { createIgnoreFoldersRegex, getMeteorIgnoreEntries } = require("./lib/ignore.js");
+const { generateEagerTestFile } = require("./lib/test.js");
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -52,7 +54,7 @@ function createSwcConfig({
   const defaultConfig = {
     jsc: {
       baseUrl: process.cwd(),
-      paths: { '/*': ['*'] },
+      paths: { '/*': ['*', '/*'] },
       parser: {
         syntax: isTypescriptEnabled ? 'typescript' : 'ecmascript',
         ...(isTsxEnabled && { tsx: true }),
@@ -137,7 +139,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 =
@@ -368,11 +371,12 @@ 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 })
       : isTest && isTestEager
-      ? path.resolve(process.cwd(), 'node_modules/@meteorjs/rspack/entries/eager-tests.mjs')
+      ? generateEagerTestFile({ isAppTest: false, projectDir })
       : path.resolve(process.cwd(), buildContext, entryPath);
   const serverNameConfig = `[${(isTest && 'test-') || ''}${
     (isTestModule && 'module') || 'server'

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);
-}