shakapacker 8.0.2 → 9.2.0

data/package/loaders.d.ts

@@ -0,0 +1,28 @@
+// @ts-ignore: webpack is an optional peer dependency (using type-only import)
+import type { LoaderDefinitionFunction } from 'webpack'
+
+export interface ShakapackerLoaderOptions {
+  [key: string]: any
+}
+
+export interface ShakapackerLoader {
+  loader: string
+  options?: ShakapackerLoaderOptions
+}
+
+export type LoaderResolver = (name: string) => string
+
+export interface LoaderConfig {
+  test: RegExp | ((value: string) => boolean)
+  use: Array<string | ShakapackerLoader | LoaderDefinitionFunction>
+  exclude?: RegExp | string | Array<string>
+  include?: RegExp | string | Array<string>
+  type?: string
+  generator?: {
+    filename?: string
+    publicPath?: string
+  }
+}
+
+export function resolveLoader(name: string): string
+export function createLoader(config: LoaderConfig): LoaderConfig

data/package/optimization/rspack.ts

@@ -0,0 +1,36 @@
+const { requireOrError } = require("../utils/requireOrError")
+const { error: logError } = require("../utils/debug")
+
+const rspack = requireOrError("@rspack/core")
+
+interface OptimizationConfig {
+  minimize: boolean
+  minimizer?: unknown[]
+}
+
+const getOptimization = (): OptimizationConfig => {
+  // Use Rspack's built-in minification instead of terser-webpack-plugin
+  const result: OptimizationConfig = { minimize: true }
+  try {
+    result.minimizer = [
+      new rspack.SwcJsMinimizerRspackPlugin(),
+      new rspack.LightningCssMinimizerRspackPlugin()
+    ]
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    const errorStack = error instanceof Error ? error.stack : ''
+    // Log full error with stack trace
+    logError(
+      `Failed to configure Rspack minimizers: ${errorMessage}\n${errorStack}`
+    )
+    // Re-throw the error to properly propagate it
+    throw new Error(
+      `Could not configure Rspack minimizers: ${errorMessage}. Please check that @rspack/core is properly installed.`
+    )
+  }
+  return result
+}
+
+export = {
+  getOptimization
+}

data/package/optimization/webpack.ts

@@ -0,0 +1,57 @@
+const { requireOrError } = require("../utils/requireOrError")
+
+const TerserPlugin = requireOrError("terser-webpack-plugin")
+const { moduleExists } = require("../utils/helpers")
+
+const tryCssMinimizer = (): unknown | null => {
+  if (
+    moduleExists("css-loader") &&
+    moduleExists("css-minimizer-webpack-plugin")
+  ) {
+    const CssMinimizerPlugin = requireOrError("css-minimizer-webpack-plugin")
+    return new CssMinimizerPlugin()
+  }
+
+  return null
+}
+
+interface OptimizationConfig {
+  minimizer: unknown[]
+}
+
+const getOptimization = (): OptimizationConfig => {
+  return {
+    minimizer: [
+      tryCssMinimizer(),
+      new TerserPlugin({
+        // SHAKAPACKER_PARALLEL env var: number of parallel workers, or true for auto (os.cpus().length - 1)
+        // If not set or invalid, defaults to true (automatic parallelization)
+        parallel: process.env.SHAKAPACKER_PARALLEL
+          ? Number.parseInt(process.env.SHAKAPACKER_PARALLEL, 10) || true
+          : true,
+        terserOptions: {
+          parse: {
+            // Let terser parse ecma 8 code but always output
+            // ES5 compliant code for older browsers
+            ecma: 8
+          },
+          compress: {
+            ecma: 5,
+            warnings: false,
+            comparisons: false
+          },
+          mangle: { safari10: true },
+          output: {
+            ecma: 5,
+            comments: false,
+            ascii_only: true
+          }
+        }
+      })
+    ].filter(Boolean)
+  }
+}
+
+export = {
+  getOptimization
+}

data/package/plugins/rspack.ts

@@ -0,0 +1,103 @@
+const { requireOrError } = require("../utils/requireOrError")
+
+const { RspackManifestPlugin } = requireOrError("rspack-manifest-plugin")
+const rspack = requireOrError("@rspack/core")
+const config = require("../config")
+const { isProduction } = require("../env")
+const { moduleExists } = require("../utils/helpers")
+
+interface ManifestFile {
+  name: string
+  path: string
+}
+
+interface EntrypointAssets {
+  js: string[]
+  css: string[]
+}
+
+interface Manifest {
+  entrypoints?: Record<string, { assets: EntrypointAssets }>
+  [key: string]: string | { assets: EntrypointAssets } | Record<string, { assets: EntrypointAssets }> | undefined
+}
+
+const getPlugins = (): unknown[] => {
+  const plugins = [
+    new rspack.EnvironmentPlugin(process.env),
+    new RspackManifestPlugin({
+      fileName: config.manifestPath.split("/").pop(), // Get just the filename
+      publicPath: config.publicPathWithoutCDN,
+      writeToFileEmit: true,
+      // rspack-manifest-plugin uses different option names than webpack-assets-manifest
+      generate: (seed: Manifest | null, files: ManifestFile[], entrypoints: Record<string, string[]>) => {
+        const manifest: Manifest = seed || {}
+
+        // Add files mapping first
+        files.forEach((file) => {
+          manifest[file.name] = file.path
+        })
+
+        // Add entrypoints information compatible with Shakapacker expectations
+        const entrypointsManifest: Record<string, { assets: EntrypointAssets }> = {}
+        Object.entries(entrypoints).forEach(
+          ([entrypointName, entrypointFiles]) => {
+            const jsFiles = entrypointFiles
+              .filter(
+                (file) => file.endsWith(".js") && !file.includes(".hot-update.")
+              )
+              .map((file) => config.publicPathWithoutCDN + file)
+            const cssFiles = entrypointFiles
+              .filter(
+                (file) =>
+                  file.endsWith(".css") && !file.includes(".hot-update.")
+              )
+              .map((file) => config.publicPathWithoutCDN + file)
+
+            entrypointsManifest[entrypointName] = {
+              assets: {
+                js: jsFiles,
+                css: cssFiles
+              }
+            }
+          }
+        )
+        manifest.entrypoints = entrypointsManifest
+
+        return manifest
+      }
+    })
+  ]
+
+  if (moduleExists("css-loader")) {
+    const hash = isProduction || config.useContentHash ? "-[contenthash:8]" : ""
+    // Use Rspack's built-in CSS extraction
+    const { CssExtractRspackPlugin } = rspack
+    plugins.push(
+      new CssExtractRspackPlugin({
+        filename: `css/[name]${hash}.css`,
+        chunkFilename: `css/[id]${hash}.css`,
+        // For projects where css ordering has been mitigated through consistent use of scoping or naming conventions,
+        // the css order warnings can be disabled by setting the ignoreOrder flag.
+        ignoreOrder: config.css_extract_ignore_order_warnings,
+        // Force writing CSS files to disk in development for Rails compatibility
+        emit: true
+      })
+    )
+  }
+
+  // Use Rspack's built-in SubresourceIntegrityPlugin
+  if (config.integrity.enabled) {
+    plugins.push(
+      new rspack.SubresourceIntegrityPlugin({
+        hashFuncNames: config.integrity.hash_functions,
+        enabled: isProduction
+      })
+    )
+  }
+
+  return plugins
+}
+
+export = {
+  getPlugins
+}

data/package/plugins/webpack.ts

@@ -0,0 +1,62 @@
+const { requireOrError } = require("../utils/requireOrError")
+// TODO: Change to `const { WebpackAssetsManifest }` when dropping 'webpack-assets-manifest < 6.0.0' (Node >=20.10.0) support
+const WebpackAssetsManifest = requireOrError("webpack-assets-manifest")
+const webpack = requireOrError("webpack")
+const config = require("../config")
+const { isProduction } = require("../env")
+const { moduleExists } = require("../utils/helpers")
+
+const getPlugins = (): unknown[] => {
+  // TODO: Remove WebpackAssetsManifestConstructor workaround when dropping 'webpack-assets-manifest < 6.0.0' (Node >=20.10.0) support
+  const WebpackAssetsManifestConstructor =
+    "WebpackAssetsManifest" in WebpackAssetsManifest
+      ? WebpackAssetsManifest.WebpackAssetsManifest
+      : WebpackAssetsManifest
+  const plugins = [
+    new webpack.EnvironmentPlugin(process.env),
+    new WebpackAssetsManifestConstructor({
+      entrypoints: true,
+      writeToDisk: true,
+      output: config.manifestPath,
+      entrypointsUseAssets: true,
+      publicPath: config.publicPathWithoutCDN,
+      integrity: config.integrity.enabled,
+      integrityHashes: config.integrity.hash_functions
+    })
+  ]
+
+  if (moduleExists("css-loader") && moduleExists("mini-css-extract-plugin")) {
+    const hash = isProduction || config.useContentHash ? "-[contenthash:8]" : ""
+    const MiniCssExtractPlugin = requireOrError("mini-css-extract-plugin")
+    plugins.push(
+      new MiniCssExtractPlugin({
+        filename: `css/[name]${hash}.css`,
+        chunkFilename: `css/[id]${hash}.css`,
+        // For projects where css ordering has been mitigated through consistent use of scoping or naming conventions,
+        // the css order warnings can be disabled by setting the ignoreOrder flag.
+        ignoreOrder: config.css_extract_ignore_order_warnings
+      })
+    )
+  }
+
+  if (
+    config.integrity.enabled &&
+    moduleExists("webpack-subresource-integrity")
+  ) {
+    const SubresourceIntegrityPlugin = requireOrError(
+      "webpack-subresource-integrity"
+    )
+    plugins.push(
+      new SubresourceIntegrityPlugin({
+        hashFuncNames: config.integrity.hash_functions,
+        enabled: isProduction
+      })
+    )
+  }
+
+  return plugins
+}
+
+export = {
+  getPlugins
+}

data/package/rspack/index.ts

@@ -0,0 +1,64 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+// Mixed require/import syntax:
+// - Using require() for compiled JS modules that may not have proper ES module exports
+// - Using import for type-only imports and Node.js built-in modules
+const webpackMerge = require("webpack-merge")
+import { resolve } from "path"
+import { existsSync } from "fs"
+import type { RspackConfigWithDevServer } from "../environments/types"
+const config = require("../config")
+const baseConfig = require("../environments/base")
+const devServer = require("../dev_server")
+const env = require("../env")
+const { moduleExists, canProcess } = require("../utils/helpers")
+const inliningCss = require("../utils/inliningCss")
+const { getPlugins } = require("../plugins/rspack")
+const { getOptimization } = require("../optimization/rspack")
+const { validateRspackDependencies } = require("../utils/validateDependencies")
+
+const rulesPath = resolve(__dirname, "../rules", "rspack.js")
+const rules = require(rulesPath)
+
+const generateRspackConfig = (extraConfig: RspackConfigWithDevServer = {}, ...extraArgs: unknown[]): RspackConfigWithDevServer => {
+  // Validate required dependencies first
+  validateRspackDependencies()
+  if (extraArgs.length > 0) {
+    throw new Error(
+      "Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker"
+    )
+  }
+
+  const { nodeEnv } = env
+  const path = resolve(__dirname, "../environments", `${nodeEnv}.js`)
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const environmentConfig = existsSync(path) ? require(path) : baseConfig
+
+  // Create base rspack config
+  const rspackConfig: RspackConfigWithDevServer = {
+    ...environmentConfig,
+    module: {
+      rules
+    },
+    plugins: getPlugins(),
+    optimization: getOptimization()
+  }
+
+  return webpackMerge.merge({}, rspackConfig, extraConfig)
+}
+
+// Re-export webpack-merge utilities for backward compatibility
+export { merge, mergeWithCustomize, mergeWithRules, unique } from "webpack-merge"
+
+export {
+  config, // shakapacker.yml
+  devServer,
+  generateRspackConfig,
+  baseConfig,
+  env,
+  rules,
+  moduleExists,
+  canProcess,
+  inliningCss
+}

data/package/rules/{babel.js → babel.ts}

@@ -1,9 +1,9 @@
 const { loaderMatches } = require("../utils/helpers")
-const { webpack_loader: webpackLoader } = require("../config")
+const { javascript_transpiler: javascriptTranspiler } = require("../config")
 const { isProduction } = require("../env")
 const jscommon = require("./jscommon")
 
-module.exports = loaderMatches(webpackLoader, "babel", () => ({
+export = loaderMatches(javascriptTranspiler, "babel", () => ({
   test: /\.(js|jsx|mjs|ts|tsx|coffee)?(\.erb)?$/,
   ...jscommon,
   use: [

data/package/rules/{coffee.js → coffee.ts}

@@ -1,6 +1,6 @@
 const { canProcess } = require("../utils/helpers")
 
-module.exports = canProcess("coffee-loader", (resolvedPath) => ({
+export = canProcess("coffee-loader", (resolvedPath: string) => ({
   test: /\.coffee(\.erb)?$/,
   use: [{ loader: resolvedPath }]
 }))

data/package/rules/css.ts

@@ -0,0 +1,3 @@
+const { getStyleRule } = require("../utils/getStyleRule")
+
+export = getStyleRule(/\.(css)$/i)

data/package/rules/{erb.js → erb.ts}

@@ -2,7 +2,7 @@ const { canProcess } = require("../utils/helpers")
 
 const runner = /^win/.test(process.platform) ? "ruby " : ""
 
-module.exports = canProcess("rails-erb-loader", (resolvedPath) => ({
+export = canProcess("rails-erb-loader", (resolvedPath: string) => ({
   test: /\.erb$/,
   enforce: "pre",
   exclude: /node_modules/,

data/package/rules/esbuild.ts

@@ -0,0 +1,10 @@
+const { loaderMatches } = require("../utils/helpers")
+const { getEsbuildLoaderConfig } = require("../esbuild")
+const { javascript_transpiler: javascriptTranspiler } = require("../config")
+const jscommon = require("./jscommon")
+
+export = loaderMatches(javascriptTranspiler, "esbuild", () => ({
+  test: /\.(ts|tsx|js|jsx|mjs|coffee)?(\.erb)?$/,
+  ...jscommon,
+  use: ({ resource }: { resource: string }) => getEsbuildLoaderConfig(resource)
+}))

data/package/rules/file.ts

@@ -0,0 +1,40 @@
+import { dirname, sep, normalize } from "path"
+const {
+  additional_paths: additionalPaths,
+  source_path: sourcePath
+} = require("../config")
+
+export = {
+  test: /\.(bmp|gif|jpe?g|png|tiff|ico|avif|webp|eot|otf|ttf|woff|woff2|svg)$/,
+  exclude: /\.(js|mjs|jsx|ts|tsx)$/,
+  type: "asset/resource",
+  generator: {
+    filename: (pathData: { filename?: string }) => {
+      // Guard against null/undefined pathData or filename
+      if (!pathData || !pathData.filename) {
+        return `static/[name]-[hash][ext][query]`
+      }
+      const path = normalize(dirname(pathData.filename))
+      const stripPaths = [...additionalPaths, sourcePath].map((p: string) =>
+        normalize(p)
+      )
+
+      const selectedStripPath = stripPaths.find((includePath: string) =>
+        path.startsWith(includePath)
+      )
+
+      if (!selectedStripPath) {
+        return `static/[name]-[hash][ext][query]`
+      }
+
+      // Split on both forward and backward slashes for cross-platform compatibility
+      const folders = path
+        .replace(selectedStripPath, "")
+        .split(/[\\/]/)
+        .filter(Boolean)
+
+      const foldersWithStatic = ["static", ...folders].join("/")
+      return `${foldersWithStatic}/[name]-[hash][ext][query]`
+    }
+  }
+}

data/package/rules/{jscommon.js → jscommon.ts}

@@ -1,11 +1,11 @@
-const { resolve } = require("path")
-const { realpathSync } = require("fs")
+import { resolve } from "path"
+import { realpathSync } from "fs"
 const {
   source_path: sourcePath,
   additional_paths: additionalPaths
 } = require("../config")
 
-const inclusions = [sourcePath, ...additionalPaths].map((p) => {
+const inclusions = [sourcePath, ...additionalPaths].map((p: string) => {
   try {
     return realpathSync(p)
   } catch (e) {
@@ -13,7 +13,7 @@ const inclusions = [sourcePath, ...additionalPaths].map((p) => {
   }
 })
 
-module.exports = {
+export = {
   include: inclusions,
   exclude: [
     {

data/package/rules/{less.js → less.ts}

@@ -1,19 +1,19 @@
-const path = require("path")
 const { canProcess } = require("../utils/helpers")
-const getStyleRule = require("../utils/getStyleRule")
+const { getStyleRule } = require("../utils/getStyleRule")
 
 const {
   additional_paths: paths,
   source_path: sourcePath
 } = require("../config")
 
-module.exports = canProcess("less-loader", (resolvedPath) =>
+export = canProcess("less-loader", (resolvedPath: string) =>
   getStyleRule(/\.(less)(\.erb)?$/i, [
     {
       loader: resolvedPath,
       options: {
         lessOptions: {
-          paths: [path.resolve(__dirname, "node_modules"), sourcePath, ...paths]
+          // Additional paths for Less imports (node_modules is resolved automatically)
+          paths: [sourcePath, ...paths]
         },
         sourceMap: true
       }

data/package/rules/raw.ts

@@ -0,0 +1,25 @@
+const config = require("../config")
+
+const rspackRawConfig = () => ({
+  resourceQuery: /raw/,
+  type: "asset/source"
+})
+
+const webpackRawConfig = () => ({
+  oneOf: [
+    {
+      // Match any file with ?raw query parameter
+      resourceQuery: /raw/,
+      type: "asset/source"
+    },
+    {
+      // Fallback: match .html files without query
+      test: /\.html$/,
+      exclude: /\.(js|mjs|jsx|ts|tsx)$/,
+      type: "asset/source"
+    }
+  ]
+})
+
+export =
+  config.assets_bundler === "rspack" ? rspackRawConfig() : webpackRawConfig()