@meteorjs/rspack 0.0.11 → 0.0.13

package/package.json

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

package/plugins/RequireExtenalsPlugin.js

@@ -22,12 +22,25 @@ export class RequireExternalsPlugin {
     // It can be used to customize how external modules are mapped to file paths
     // If not provided, the default behavior is to map the external module name.
     externalMap = null,
+    // Enable global polyfill for module and exports
+    // If true, globalThis.module and globalThis.exports will be defined if they don't exist
+    enableGlobalPolyfill = true,
+    // Check function to determine if an external import should be eager
+    // If provided, it will be called with the package name and should return true for eager imports
+    // If not provided or returns false, the import will be lazy (default behavior)
+    isEagerImport = null,
+    // Array of module paths that should always be imported at the end of the file
+    // These will be treated as eager imports but will always be placed after all other imports
+    lastImports = null,
   } = {}) {
     this.pluginName = 'RequireExternalsPlugin';
 
     // Prepare externals
     this._externals = externals;
     this._externalMap = externalMap;
+    this._enableGlobalPolyfill = enableGlobalPolyfill;
+    this._isEagerImport = isEagerImport;
+    this._lastImports = lastImports;
     this._defaultExternalPrefix = 'external ';
 
     // Prepare paths
@@ -77,11 +90,14 @@ export class RequireExternalsPlugin {
   _extractPackageName(name) {
     let pkg = name.slice(this._defaultExternalPrefix.length);
     if (pkg.startsWith('"') && pkg.endsWith('"')) pkg = pkg.slice(1, -1);
-
+    const depInfo = path.parse(name);
     // If the extracted package name is a path, use the path as is
     if (
       pkg &&
-      (path.isAbsolute(pkg) || pkg.startsWith('./') || pkg.startsWith('../'))
+      (path.isAbsolute(pkg) ||
+        pkg.startsWith('./') ||
+        pkg.startsWith('../') ||
+        !!depInfo.ext)
     ) {
       const module = this.externalsMeta.get(pkg);
       if (module) {
@@ -130,8 +146,10 @@ export class RequireExternalsPlugin {
     }
 
     compiler.hooks.done.tap({ name: this.pluginName, stage: -10 }, (stats) => {
-      // 1) Ensure globalThis.module / exports block is present
-      this._ensureGlobalThisModule();
+      // 1) Ensure globalThis.module / exports block is present if enabled
+      if (this._enableGlobalPolyfill) {
+        this._ensureGlobalThisModule();
+      }
 
       // 2) Re-load existing requires from disk on every run
       const existing = this._readExistingRequires();
@@ -163,21 +181,39 @@ export class RequireExternalsPlugin {
         // Strip out any now-empty helper functions:
         //   function lazyExternalImportsX() {
         //   }
-        const emptyFnRe = /^function\s+lazyExternalImports\d+\s*\(\)\s*{\s*}\s*(\r?\n)?/gm;
-        content = content.replace(emptyFnRe, '');
+        // or new format:
+        //   // (function eagerExternalImportsX() {
+        //   // })
+        // or lastImports format:
+        //   // (function lastImports() {
+        //   // })
+        const emptyLazyFnRe = /^function\s+lazyExternalImports\d+\s*\(\)\s*{\s*}\s*(\r?\n)?/gm;
+        const emptyEagerFnRe = /^\/\/\s*\(function\s+eagerExternalImports\d+\s*\(\)\s*{\s*\n\/\/\s*\}\)\s*(\r?\n)?/gm;
+        const emptyLastFnRe = /^\/\/\s*\(function\s+lastImports(?:\d+)?\s*\(\)\s*{\s*\n\/\/\s*\}\)\s*(\r?\n)?/gm;
+        content = content.replace(emptyLazyFnRe, '');
+        content = content.replace(emptyEagerFnRe, '');
+        content = content.replace(emptyLastFnRe, '');
 
         // Write the cleaned file back
         fs.writeFileSync(this.filePath, content, 'utf-8');
 
         // Re-populate `existing` so the add-diff is accurate
         existing.clear();
+        // Check for require statements
         for (const match of content.matchAll(/require\('([^']+)'\)/g)) {
           existing.add(match[1]);
         }
+        // Also check for import statements (used in the new format)
+        for (const match of content.matchAll(/import\s+'([^']+)'/g)) {
+          existing.add(match[1]);
+        }
       }
 
-      // 3) Collect any new externals from this build
-      const newRequires = [];
+      // 3) Collect any new externals from this build and separate into eager, lazy, and last
+      const newLazyRequires = [];
+      const newEagerRequires = [];
+      const newLastRequires = [];
+
       for (const module of info.modules) {
         const name = module.name;
         const matchInfo = this._isExternalModule(name);
@@ -186,19 +222,180 @@ export class RequireExternalsPlugin {
         const pkg = this._extractPackageName(name, matchInfo);
         if (pkg && !existing.has(pkg)) {
           existing.add(pkg);
-          newRequires.push(`require('${pkg}')`);
+
+          // Check if this should be a last import
+          if (this._lastImports && Array.isArray(this._lastImports) && this._lastImports.includes(pkg)) {
+            newLastRequires.push(`require('${pkg}')`);
+          }
+          // Check if this should be an eager import
+          else if (this._isEagerImport && typeof this._isEagerImport === 'function' && this._isEagerImport(pkg)) {
+            newEagerRequires.push(`require('${pkg}')`);
+          } else {
+            // Default to lazy import
+            newLazyRequires.push(`require('${pkg}')`);
+          }
         }
       }
 
-      // 4) Append new imports if any
-      if (newRequires.length) {
+      // 4) Append new lazy imports if any
+      if (newLazyRequires.length) {
         const fnName = `lazyExternalImports${this._funcCount++}`;
-        const body = newRequires.map(req => `  ${req};`).join('\n');
+        const body = newLazyRequires.map(req => `  ${req};`).join('\n');
         const fnCode = `\nfunction ${fnName}() {\n${body}\n}\n`;
         try {
           fs.appendFileSync(this.filePath, fnCode);
         } catch (err) {
-          console.error(`Failed to append imports to ${this.filePath}:`, err);
+          console.error(`Failed to append lazy imports to ${this.filePath}:`, err);
+        }
+      }
+
+      // 5) Append new eager imports if any
+      if (newEagerRequires.length) {
+        const fnName = `eagerExternalImports${this._funcCount++}`;
+        // Convert require statements to import statements
+        const body = newEagerRequires
+          .map(req => {
+            // Extract the module path from require('path')
+            const modulePath = req.match(/require\('([^']+)'\)/)[1];
+            return `import '${modulePath}';`;
+          })
+          .join('\n');
+        // Use comments instead of actual function
+        const fnCode = `\n// (function ${fnName}() {\n${body}\n// })\n`;
+        try {
+          fs.appendFileSync(this.filePath, fnCode);
+        } catch (err) {
+          console.error(`Failed to append eager imports to ${this.filePath}:`, err);
+        }
+      }
+
+      // 6) Handle lastImports - these should always be at the end of the file
+      // First, check if lastImports already exist in the file
+      let lastImportsExist = false;
+      let lastImportsAtEnd = false;
+      let content = '';
+
+      if (fs.existsSync(this.filePath)) {
+        content = fs.readFileSync(this.filePath, 'utf-8');
+
+        // Check if lastImports exist in the file
+        const lastImportsRe = /\/\/\s*\(function\s+lastImports(?:\d+)?\s*\(\)\s*{\s*\n([\s\S]*?)\/\/\s*\}\)/g;
+        const match = lastImportsRe.exec(content);
+
+        if (match) {
+          lastImportsExist = true;
+
+          // Check if lastImports are at the end of the file
+          // We'll consider them at the end if there's only whitespace after them
+          const afterLastImports = content.substring(match.index + match[0].length);
+          if (/^\s*$/.test(afterLastImports)) {
+            lastImportsAtEnd = true;
+          }
+        }
+      }
+
+      // If lastImports exist but are not at the end, move them to the end
+      if (lastImportsExist && !lastImportsAtEnd) {
+        // Remove the existing lastImports
+        const lastImportsRe = /\/\/\s*\(function\s+lastImports(?:\d+)?\s*\(\)\s*{\s*\n[\s\S]*?\/\/\s*\}\)\s*(\r?\n)?/g;
+        content = content.replace(lastImportsRe, '');
+
+        // Extract the imports from the existing lastImports
+        const importRe = /import\s+'([^']+)'/g;
+        const existingLastImports = [];
+        let match;
+
+        while ((match = importRe.exec(content)) !== null) {
+          if (this._lastImports && Array.isArray(this._lastImports) && this._lastImports.includes(match[1])) {
+            existingLastImports.push(`import '${match[1]}';`);
+          }
+        }
+
+        // Add any new lastImports
+        if (this._lastImports && Array.isArray(this._lastImports)) {
+          for (const pkg of this._lastImports) {
+            if (!existingLastImports.some(imp => imp === `import '${pkg}';`) && existing.has(pkg)) {
+              existingLastImports.push(`import '${pkg}';`);
+            }
+          }
+        }
+
+        // Add the lastImports to the end of the file
+        if (existingLastImports.length > 0) {
+          const body = existingLastImports.join('\n');
+          const fnCode = `\n// (function lastImports() {\n${body}\n// })\n`;
+          fs.writeFileSync(this.filePath, content + fnCode);
+        } else {
+          fs.writeFileSync(this.filePath, content);
+        }
+      }
+      // If lastImports don't exist, add them if needed
+      else if (!lastImportsExist) {
+        // Collect all lastImports
+        const allLastImports = [];
+
+        // Add any new lastImports from this build
+        if (newLastRequires.length) {
+          for (const req of newLastRequires) {
+            const modulePath = req.match(/require\('([^']+)'\)/)[1];
+            allLastImports.push(`import '${modulePath}';`);
+          }
+        }
+
+        // Add any existing lastImports from the configuration
+        if (this._lastImports && Array.isArray(this._lastImports)) {
+          for (const pkg of this._lastImports) {
+            if (!allLastImports.some(imp => imp === `import '${pkg}';`) && !existing.has(pkg)) {
+              allLastImports.push(`import '${pkg}';`);
+            }
+          }
+        }
+
+        // Add the lastImports to the end of the file
+        if (allLastImports.length > 0) {
+          const body = allLastImports.join('\n');
+          const fnCode = `\n// (function lastImports() {\n${body}\n// })\n`;
+          try {
+            fs.appendFileSync(this.filePath, fnCode);
+          } catch (err) {
+            console.error(`Failed to append last imports to ${this.filePath}:`, err);
+          }
+        }
+      }
+      // If lastImports exist and are already at the end, add any new ones
+      else if (lastImportsExist && lastImportsAtEnd && newLastRequires.length) {
+        // Extract the existing lastImports
+        const lastImportsRe = /\/\/\s*\(function\s+lastImports(?:\d+)?\s*\(\)\s*{\s*\n([\s\S]*?)\/\/\s*\}\)/;
+        const match = lastImportsRe.exec(content);
+
+        if (match) {
+          const existingBody = match[1];
+          const existingImports = new Set();
+
+          // Extract the imports from the existing lastImports
+          const importRe = /import\s+'([^']+)'/g;
+          let importMatch;
+
+          while ((importMatch = importRe.exec(existingBody)) !== null) {
+            existingImports.add(importMatch[1]);
+          }
+
+          // Add any new lastImports
+          let newBody = existingBody;
+          for (const req of newLastRequires) {
+            const modulePath = req.match(/require\('([^']+)'\)/)[1];
+            if (!existingImports.has(modulePath)) {
+              newBody += `import '${modulePath}';\n`;
+            }
+          }
+
+          // Replace the existing lastImports with the updated ones
+          const updatedContent = content.replace(
+            lastImportsRe,
+            `// (function lastImports() {\n${newBody}// })`
+          );
+
+          fs.writeFileSync(this.filePath, updatedContent);
         }
       }
     });
@@ -209,12 +406,33 @@ export class RequireExternalsPlugin {
     if (fs.existsSync(this.filePath)) {
       try {
         const content = fs.readFileSync(this.filePath, 'utf-8');
-        const fnRe = /function\s+lazyExternalImports(\d+)\s*\(\)/g;
+        // Check for lazy, eager, and last external imports functions
+        const lazyFnRe = /function\s+lazyExternalImports(\d+)\s*\(\)/g;
+        // Only match the new commented format
+        const eagerFnRe = /\/\/\s*\(function\s+eagerExternalImports(\d+)\s*\(\)/g;
+        // Match the lastImports format
+        const lastFnRe = /\/\/\s*\(function\s+lastImports(\d+)?\s*\(\)/g;
+
         let match;
-        while ((match = fnRe.exec(content)) !== null) {
+        // Check lazy imports
+        while ((match = lazyFnRe.exec(content)) !== null) {
+          const n = parseInt(match[1], 10);
+          if (n > max) max = n;
+        }
+
+        // Check eager imports
+        while ((match = eagerFnRe.exec(content)) !== null) {
           const n = parseInt(match[1], 10);
           if (n > max) max = n;
         }
+
+        // Check last imports
+        while ((match = lastFnRe.exec(content)) !== null) {
+          if (match[1]) {
+            const n = parseInt(match[1], 10);
+            if (n > max) max = n;
+          }
+        }
       } catch {
         // ignore read errors
       }
@@ -251,11 +469,18 @@ export class RequireExternalsPlugin {
     const existing = new Set();
     try {
       const content = fs.readFileSync(this.filePath, 'utf-8');
+      // Check for require statements
       const requireRegex = /require\('([^']+)'\)/g;
       let match;
       while ((match = requireRegex.exec(content)) !== null) {
         existing.add(match[1]);
       }
+
+      // Also check for import statements (used in the new format)
+      const importRegex = /import\s+'([^']+)'/g;
+      while ((match = importRegex.exec(content)) !== null) {
+        existing.add(match[1]);
+      }
     } catch {
       // ignore if file missing or unreadable
     }

package/rspack.config.js

@@ -43,7 +43,7 @@ function createCacheStrategy(mode) {
 }
 
 // SWC loader rule (JSX/JS)
-function createSwcConfig({ isRun, isTypescriptEnabled, isJsxEnabled, isTsxEnabled, externalHelpers }) {
+function createSwcConfig({ isTypescriptEnabled, isJsxEnabled, isTsxEnabled, externalHelpers, isDevEnvironment }) {
   const defaultConfig = {
     jsc: {
       baseUrl: process.cwd(),
@@ -56,8 +56,8 @@ function createSwcConfig({ isRun, isTypescriptEnabled, isJsxEnabled, isTsxEnable
       target: 'es2015',
       transform: {
         react: {
-          development: isRun,
-          refresh: isRun,
+          development: isDevEnvironment,
+          refresh: isDevEnvironment,
         },
       },
       externalHelpers,
@@ -156,12 +156,13 @@ export default function (inMeteor = {}, argv = {}) {
     console.log('[i] Meteor flags:', Meteor);
   }
 
+  const isDevEnvironment = isRun && isDev && !isTest;
   const swcConfigRule = createSwcConfig({
-    isRun,
     isTypescriptEnabled,
     isJsxEnabled,
     isTsxEnabled,
     externalHelpers: swcExternalHelpers,
+    isDevEnvironment,
   });
   const externals = [
     /^meteor.*/,
@@ -193,16 +194,12 @@ export default function (inMeteor = {}, argv = {}) {
     filePath: path.join(buildContext, runPath),
     ...(Meteor.isBlazeEnabled && {
       externals: /\.html$/,
-      externalMap: (module) => {
-        const { request, context } = module;
-        if (request.endsWith('.html')) {
-          const relContext = path.relative(process.cwd(), context);
-          const { name } = path.parse(request);
-          return `./${relContext}/template.${name}.js`;
-        }
-        return request;
+      isEagerImport: (module) => module.endsWith('.html'),
+      ...isProd && {
+        lastImports: [`./${outputFilename}`],
       },
     }),
+    enableGlobalPolyfill: isDevEnvironment,
   });
 
   const clientNameConfig = `[${isTest && 'test-' || ''}${isTestModule && 'module' || 'client'}-rspack]`;
@@ -210,12 +207,12 @@ export default function (inMeteor = {}, argv = {}) {
   let clientConfig = {
     name: clientNameConfig,
     target: 'web',
-    mode,
+    mode: 'development',
     entry: path.resolve(process.cwd(), buildContext, entryPath),
     output: {
       path: clientOutputDir,
       filename: () =>
-        isRun && !isTest ? outputFilename : `../${buildContext}/${outputPath}`,
+        isDevEnvironment ? outputFilename : `../${buildContext}/${outputPath}`,
       libraryTarget: 'commonjs',
       publicPath: '/',
       chunkFilename: `${bundlesContext}/[id].[chunkhash].js`,
@@ -243,7 +240,7 @@ export default function (inMeteor = {}, argv = {}) {
     externals,
     plugins: [
       ...[
-        ...(isReactEnabled && reactRefreshModule
+        ...(isReactEnabled && reactRefreshModule && isDevEnvironment
           ? [new reactRefreshModule()]
           : []),
         requireExternalsPlugin,
@@ -261,8 +258,8 @@ export default function (inMeteor = {}, argv = {}) {
       }),
     ],
     watchOptions,
-    devtool: isDev || isTest ? 'source-map' : 'hidden-source-map',
-    ...(isRun && !isTest && {
+    devtool: isDevEnvironment || isTest ? 'source-map' : 'hidden-source-map',
+    ...(isDevEnvironment && {
       devServer: {
         static: { directory: clientOutputDir, publicPath: '/__rspack__/' },
         hot: true,
@@ -322,8 +319,8 @@ export default function (inMeteor = {}, argv = {}) {
       isTestModule && requireExternalsPlugin,
     ],
     watchOptions,
-    devtool: isRun ? 'source-map' : 'hidden-source-map',
-    ...((isRun || isTest) &&
+    devtool: isDevEnvironment || isTest ? 'source-map' : 'hidden-source-map',
+    ...((isDevEnvironment || isTest) &&
       createCacheStrategy(mode)
     ),
   };