@meteorjs/rspack 0.0.0

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@meteorjs/rspack",
+  "version": "0.0.0",
+  "description": "Configuration logic for using Rspack in Meteor projects",
+  "main": "index.js",
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@rspack/plugin-react-refresh": "^1.4.3",
+    "ignore-loader": "^0.1.2",
+    "webpack-merge": "^6.0.1"
+  },
+  "peerDependencies": {
+    "@rspack/cli": ">=1.3.0",
+    "@rspack/core": ">=1.3.0"
+  }
+}

package/plugins/RequireExtenalsPlugin.js

@@ -0,0 +1,264 @@
+// RequireExternalsPlugin.js
+//
+// This plugin prepare the require of externals used to be lazy required by Meteor bundler.
+//
+// It can describe additional externals using the externals option by array, RegExp or function.
+// These externals will be lazy required as well, and optionally could be resolved using
+// the externalMap function if provided.
+// Used for Blaze to translate require of html files to require of js files bundled by Meteor.
+
+import fs from 'fs';
+import path from 'path';
+
+export class RequireExternalsPlugin {
+  constructor({
+    filePath,
+    // Externals can be:
+    // - An array of strings: module name must be included in the array
+    // - A RegExp: module name must match the regex
+    // - A function: function(name) must return true for the module name
+    externals = null,
+    // ExternalMap is a function that receives the request object and returns the external request path
+    // 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,
+  } = {}) {
+    this.pluginName = 'RequireExternalsPlugin';
+
+    // Prepare externals
+    this._externals = externals;
+    this._externalMap = externalMap;
+    this._defaultExternalPrefix = 'external ';
+
+    // Prepare paths
+    this.filePath = path.resolve(process.cwd(), filePath);
+    this.backRoot = '../'.repeat(
+      filePath.replace(/^\.?\/+/, '').split('/').length - 1
+    );
+
+    // Initialize funcCount based on existing helpers in the file
+    this._funcCount = this._computeNextFuncCount();
+  }
+
+  // Helper method to check if a module name matches the externals or default prefix
+  _isExternalModule(name) {
+    if (typeof name !== 'string') return false;
+
+    // Check externals if provided
+    if (this._externals) {
+      // If externals is an array, use includes method
+      if (Array.isArray(this._externals)) {
+        if (this._externals.includes(name)) {
+          return { isExternal: true, type: 'externals', value: name };
+        }
+      }
+      // If externals is a RegExp, use test method
+      else if (this._externals instanceof RegExp) {
+        if (this._externals.test(name)) {
+          return { isExternal: true, type: 'externals', value: name };
+        }
+      }
+      // If externals is a function, call it with the name
+      else if (typeof this._externals === 'function') {
+        if (this._externals(name)) {
+          return { isExternal: true, type: 'externals', value: name };
+        }
+      }
+    }
+
+    if (name.startsWith(this._defaultExternalPrefix)) {
+      return { isExternal: true, type: 'prefix', value: name };
+    }
+
+    return { isExternal: false };
+  }
+
+  // Helper method to extract package name from module name
+  _extractPackageName(name) {
+    let pkg = name.slice(this._defaultExternalPrefix.length);
+    if (pkg.startsWith('"') && pkg.endsWith('"')) pkg = pkg.slice(1, -1);
+
+    // If the extracted package name is a path, use the path as is
+    if (
+      pkg &&
+      (path.isAbsolute(pkg) || pkg.startsWith('./') || pkg.startsWith('../'))
+    ) {
+      const module = this.externalsMeta.get(pkg);
+      if (module) {
+        return `${this.backRoot}${module.relativeRequest}`;
+      }
+      return `${this.backRoot}${name}`;
+    }
+
+    return pkg;
+  }
+
+  apply(compiler) {
+    // Initialize externalsMeta if it doesn't exist
+    this.externalsMeta = this.externalsMeta || new Map();
+
+    // Only set compiler.options.externals if both externals and externalMap are defined
+    if (this._externals && this._externalMap) {
+      compiler.options.externals = [
+        ...compiler.options.externals || [],
+        (module, callback) => {
+          const { request, context } = module;
+          const matchInfo = this._isExternalModule(request);
+          if (matchInfo.isExternal) {
+
+            let externalRequest;
+            // Use externalMap function if provided
+            if (this._externalMap && typeof this._externalMap === 'function') {
+              externalRequest = this._externalMap(module);
+
+              const relContext = path.relative(process.cwd(), context);
+              // Store the original request to resolve properly the lazy html require later
+              this.externalsMeta.set(externalRequest, {
+                originalRequest: request,
+                externalRequest,
+                relativeRequest: path.join(relContext, request),
+              });
+
+              // tell Rspack "don't bundle this, import it at runtime"
+              return callback(null, externalRequest);
+            }
+          }
+
+          callback(); // otherwise normal resolution
+        }
+      ];
+    }
+
+    compiler.hooks.done.tap({ name: this.pluginName, stage: -10 }, (stats) => {
+      // 1) Ensure globalThis.module / exports block is present
+      this._ensureGlobalThisModule();
+
+      // 2) Re-load existing requires from disk on every run
+      const existing = this._readExistingRequires();
+
+      // 2a) Compute the *current* externals in this build
+      const info = stats.toJson({ modules: true });
+      const current = new Set();
+      for (const m of info.modules) {
+        const matchInfo = this._isExternalModule(m.name);
+        if (matchInfo.isExternal) {
+          const pkg = this._extractPackageName(m.name, matchInfo);
+          if (pkg) {
+            current.add(pkg);
+          }
+        }
+      }
+
+      // 2b) Remove any requires that are no longer in `current`
+      const toRemove = [...existing].filter(p => !current.has(p));
+      if (toRemove.length) {
+        let content = fs.readFileSync(this.filePath, 'utf-8');
+
+        // Strip stale require(...) lines
+        for (const pkg of toRemove) {
+          const re = new RegExp(`^.*require\\('${pkg}'\\);?.*(\\r?\\n)?`, 'gm');
+          content = content.replace(re, '');
+        }
+
+        // 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, '');
+
+        // Write the cleaned file back
+        fs.writeFileSync(this.filePath, content, 'utf-8');
+
+        // Re-populate `existing` so the add-diff is accurate
+        existing.clear();
+        for (const match of content.matchAll(/require\('([^']+)'\)/g)) {
+          existing.add(match[1]);
+        }
+      }
+
+      // 3) Collect any new externals from this build
+      const newRequires = [];
+      for (const module of info.modules) {
+        const name = module.name;
+        const matchInfo = this._isExternalModule(name);
+        if (!matchInfo.isExternal) continue;
+
+        const pkg = this._extractPackageName(name, matchInfo);
+        if (pkg && !existing.has(pkg)) {
+          existing.add(pkg);
+          newRequires.push(`require('${pkg}')`);
+        }
+      }
+
+      // 4) Append new imports if any
+      if (newRequires.length) {
+        const fnName = `lazyExternalImports${this._funcCount++}`;
+        const body = newRequires.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);
+        }
+      }
+    });
+  }
+
+  _computeNextFuncCount() {
+    let max = 0;
+    if (fs.existsSync(this.filePath)) {
+      try {
+        const content = fs.readFileSync(this.filePath, 'utf-8');
+        const fnRe = /function\s+lazyExternalImports(\d+)\s*\(\)/g;
+        let match;
+        while ((match = fnRe.exec(content)) !== null) {
+          const n = parseInt(match[1], 10);
+          if (n > max) max = n;
+        }
+      } catch {
+        // ignore read errors
+      }
+    }
+    // next count is max found plus one
+    return max + 1;
+  }
+
+  _ensureGlobalThisModule() {
+    const block = [
+      `/* Polyfill globalThis.module & exports */`,
+      `if (typeof globalThis.module === 'undefined') {`,
+      `  globalThis.module = { exports: {} };`,
+      `}`,
+      `if (typeof globalThis.exports === 'undefined') {`,
+      `  globalThis.exports = globalThis.module.exports;`,
+      `}`
+    ].join('\n') + '\n';
+
+    let content = '';
+    if (fs.existsSync(this.filePath)) {
+      content = fs.readFileSync(this.filePath, 'utf-8');
+      if (!content.includes(`typeof globalThis.module === 'undefined'`)) {
+        // Prepend so it lives at the very top
+        fs.writeFileSync(this.filePath, content + '\n' + block, 'utf-8');
+      }
+    } else {
+      // File doesn’t exist yet: create with just the block
+      fs.writeFileSync(this.filePath, block, 'utf-8');
+    }
+  }
+
+  _readExistingRequires() {
+    const existing = new Set();
+    try {
+      const content = fs.readFileSync(this.filePath, 'utf-8');
+      const requireRegex = /require\('([^']+)'\)/g;
+      let match;
+      while ((match = requireRegex.exec(content)) !== null) {
+        existing.add(match[1]);
+      }
+    } catch {
+      // ignore if file missing or unreadable
+    }
+    return existing;
+  }
+}

package/rspack.config.js

@@ -0,0 +1,286 @@
+import { DefinePlugin, BannerPlugin } from '@rspack/core';
+import fs from 'fs';
+import { createRequire } from 'module';
+import path from 'path';
+import { merge } from 'webpack-merge';
+
+import { RequireExternalsPlugin } from './plugins/RequireExtenalsPlugin.js';
+
+const require = createRequire(import.meta.url);
+
+// Safe require that doesn't throw if the module isn't found
+function safeRequire(moduleName) {
+  try {
+    return require(moduleName);
+  } catch (error) {
+    if (
+      error.code === 'MODULE_NOT_FOUND' &&
+      error.message.includes(moduleName)
+    ) {
+      return null;
+    }
+    throw error; // rethrow if it's a different error
+  }
+}
+
+// Persistent filesystem cache strategy
+function createCacheStrategy(mode) {
+  return {
+    cache: true,
+    experiments: {
+      cache: {
+        version: `swc-${mode}`,
+        type: 'persistent',
+        storage: {
+          type: 'filesystem',
+          directory: 'node_modules/.cache/rspack',
+        },
+      },
+    },
+  };
+}
+
+// SWC loader rule (JSX/JS)
+function createSwcConfig({ isRun }) {
+  return {
+    test: /\.[jt]sx?$/,
+    exclude: /node_modules|\.meteor\/local/,
+    loader: 'builtin:swc-loader',
+    options: {
+      jsc: {
+        baseUrl: process.cwd(),
+        paths: { '/*': ['*'] },
+        parser: { syntax: 'ecmascript', jsx: true },
+        target: 'es2015',
+        transform: {
+          react: {
+            development: isRun,
+            refresh: isRun,
+          },
+        },
+      },
+    },
+  };
+}
+
+// Watch options shared across both builds
+const watchOptions = {
+  ignored: ['**/main.html', '**/dist/**', '**/.meteor/local/**'],
+};
+
+/**
+ * @param {{ isClient: boolean; isServer: boolean; isDevelopment?: boolean; isProduction?: boolean; isTest?: boolean }} Meteor
+ * @param {{ mode?: string; clientEntry?: string; serverEntry?: string; clientOutputFolder?: string; serverOutputFolder?: string; bundlesContext?: string; assetsContext?: string; serverAssetsContext?: string }} argv
+ * @returns {import('@rspack/cli').Configuration[]}
+ */
+export default function (inMeteor = {}, argv = {}) {
+  // Transform Meteor env properties to proper boolean values
+  const Meteor = { ...inMeteor };
+  // Convert string boolean values to actual booleans
+  for (const key in Meteor) {
+    if (Meteor[key] === 'true' || Meteor[key] === true) {
+      Meteor[key] = true;
+    } else if (Meteor[key] === 'false' || Meteor[key] === false) {
+      Meteor[key] = false;
+    }
+  }
+
+  const isProd = Meteor.isProduction || argv.mode === 'production';
+  const isDev = Meteor.isDevelopment || !isProd;
+  const isTest = Meteor.isTest;
+  const isClient = Meteor.isClient;
+  const isRun = Meteor.isRun;
+  const isReactEnabled = Meteor.isReactEnabled;
+  const mode = isProd ? 'production' : 'development';
+
+  // Determine entry points
+  const entryPath = Meteor.entryPath;
+
+  // Determine output points
+  const outputPath = Meteor.outputPath;
+  const outputFilename = Meteor.outputFilename;
+
+  // Determine run point
+  const runPath = Meteor.runPath;
+
+  // Determine banner
+  const bannerOutput = JSON.parse(Meteor.bannerOutput || '');
+
+  // Determine output directories
+  const clientOutputDir = path.resolve(process.cwd(), 'public');
+  const serverOutputDir = path.resolve(process.cwd(), 'server');
+
+  // Determine context for bundles and assets
+  const buildContext = Meteor.buildContext || '_rspack';
+  const bundlesContext = Meteor.bundlesContext || 'bundles';
+  const assetsContext = Meteor.assetsContext || 'assets';
+
+  if (Meteor.isDebug) {
+    console.log('[i] Rspack mode:', mode);
+    console.log('[i] Meteor flags:', Meteor);
+  }
+
+  // Base client config
+  let clientConfig = {
+    name: 'meteor-client',
+    target: 'web',
+    mode,
+    entry: path.resolve(process.cwd(), buildContext, entryPath),
+    output: {
+      path: clientOutputDir,
+      filename: () =>
+        isDev ? outputFilename : `../${buildContext}/${outputPath}`,
+      libraryTarget: 'commonjs',
+      publicPath: '/',
+      chunkFilename: `${bundlesContext}/[id].[chunkhash].js`,
+      assetModuleFilename: `${assetsContext}/[hash][ext][query]`,
+    },
+    optimization: {
+      usedExports: true,
+      splitChunks: { chunks: 'async' },
+    },
+    module: {
+      rules: [
+        createSwcConfig({ isRun }),
+        ...(Meteor.isBlazeEnabled
+          ? [
+              {
+                test: /\.html$/,
+                loader: 'ignore-loader',
+              },
+            ]
+          : []),
+      ],
+    },
+    resolve: { extensions: ['.js', '.jsx', '.json'] },
+    externals: [/^(meteor.*|react$|react-dom$)/],
+    plugins: [
+      ...(isRun
+        ? [
+            ...(isReactEnabled
+              ? [new (safeRequire('@rspack/plugin-react-refresh'))()]
+              : []),
+            new RequireExternalsPlugin({
+              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;
+                },
+              }),
+            }),
+          ].filter(Boolean)
+        : []),
+      new DefinePlugin({
+        'Meteor.isClient': JSON.stringify(true),
+        'Meteor.isServer': JSON.stringify(false),
+        'Meteor.isTest': JSON.stringify(isTest),
+        'Meteor.isDevelopment': JSON.stringify(isDev),
+        'Meteor.isProduction': JSON.stringify(isProd),
+      }),
+      new BannerPlugin({
+        banner: bannerOutput,
+        entryOnly: true,
+      }),
+    ],
+    watchOptions,
+    devtool: isDev ? 'source-map' : 'hidden-source-map',
+    ...(isRun && {
+      devServer: {
+        static: { directory: clientOutputDir, publicPath: '/__rspack__/' },
+        hot: true,
+        liveReload: true,
+        ...(Meteor.isBlazeEnabled && { hot: false }),
+        port: 3005,
+        devMiddleware: {
+          writeToDisk: false,
+        },
+      },
+      experiments: { incremental: true },
+    }),
+  };
+
+  // Base server config
+  let serverConfig = {
+    name: 'meteor-server',
+    target: 'node',
+    mode,
+    entry: path.resolve(process.cwd(), buildContext, entryPath),
+    output: {
+      path: serverOutputDir,
+      filename: () => `../${buildContext}/${outputPath}`,
+      libraryTarget: 'commonjs',
+      chunkFilename: `${bundlesContext}/[id].[chunkhash].js`,
+      assetModuleFilename: `${assetsContext}/[hash][ext][query]`,
+    },
+    optimization: { usedExports: true },
+    module: {
+      rules: [
+        {
+          test: /\.meteor\/local/,
+          use: 'builtin:empty-loader',
+          sideEffects: false,
+        },
+        createSwcConfig({ isRun }),
+      ],
+    },
+    resolve: {
+      extensions: ['.js', '.jsx', '.json'],
+      modules: ['node_modules', path.resolve(process.cwd())],
+      conditionNames: ['import', 'require', 'node', 'default'],
+    },
+    externals: [/^(meteor.*|react|react-dom)/],
+    plugins: [
+      new DefinePlugin({
+        'Meteor.isClient': JSON.stringify(false),
+        'Meteor.isServer': JSON.stringify(true),
+        'Meteor.isTest': JSON.stringify(isTest),
+        'Meteor.isDevelopment': JSON.stringify(isDev),
+        'Meteor.isProduction': JSON.stringify(isProd),
+      }),
+      new BannerPlugin({
+        banner: bannerOutput,
+        entryOnly: true,
+      }),
+    ],
+    watchOptions,
+    devtool: isRun ? 'source-map' : 'hidden-source-map',
+    ...(isRun &&
+      merge(createCacheStrategy(mode), { experiments: { incremental: true } })),
+  };
+
+  // Load and apply project-level overrides for the selected build
+  const projectConfigPath = path.resolve(process.cwd(), 'rspack.config.js');
+
+  // Check if we're in a Meteor package directory by looking at the path
+  const isMeteorPackageConfig = process.cwd().includes('/packages/rspack');
+  if (fs.existsSync(projectConfigPath) && !isMeteorPackageConfig) {
+    const projectConfig =
+      require(projectConfigPath)?.default || require(projectConfigPath);
+
+    const userConfig =
+      typeof projectConfig === 'function'
+        ? projectConfig(Meteor, argv)
+        : projectConfig;
+
+    if (Meteor.isClient) {
+      clientConfig = merge(clientConfig, userConfig);
+    }
+    if (Meteor.isServer) {
+      serverConfig = merge(serverConfig, userConfig);
+    }
+  }
+
+  // Return the appropriate configuration
+  if (isClient) {
+    return [clientConfig];
+  }
+  // Meteor.isServer
+  return [serverConfig];
+}