shakapacker 8.4.0 → 9.0.0

data/package/environments/production.ts

@@ -0,0 +1,80 @@
+/**
+ * Production environment configuration for webpack and rspack bundlers
+ * @module environments/production
+ */
+
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const { resolve } = require("path")
+const { merge } = require("webpack-merge")
+const baseConfig = require("./base")
+const { moduleExists } = require("../utils/helpers")
+const config = require("../config")
+import type { Configuration as WebpackConfiguration, WebpackPluginInstance } from "webpack"
+import type { CompressionPluginConstructor } from "./types"
+
+const optimizationPath = resolve(
+  __dirname,
+  "..",
+  "optimization",
+  `${config.assets_bundler}.js`
+)
+const { getOptimization } = require(optimizationPath)
+
+let CompressionPlugin: CompressionPluginConstructor | null = null
+if (moduleExists("compression-webpack-plugin")) {
+  // eslint-disable-next-line global-require
+  CompressionPlugin = require("compression-webpack-plugin")
+}
+
+/**
+ * Generate production plugins including compression
+ * @returns Array of webpack plugins for production
+ */
+const getPlugins = (): WebpackPluginInstance[] => {
+  const plugins: WebpackPluginInstance[] = []
+
+  if (CompressionPlugin) {
+    plugins.push(
+      new CompressionPlugin({
+        filename: "[path][base].gz[query]",
+        algorithm: "gzip",
+        test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/
+      })
+    )
+
+    if ("brotli" in process.versions) {
+      plugins.push(
+        new CompressionPlugin({
+          filename: "[path][base].br[query]",
+          algorithm: "brotliCompress",
+          test: /\.(js|css|html|json|ico|svg|eot|otf|ttf|map)$/
+        })
+      )
+    }
+  }
+
+  return plugins
+}
+
+/**
+ * Production configuration with optimizations and compression
+ */
+const productionConfig: Partial<WebpackConfiguration> = {
+  devtool: "source-map",
+  stats: "normal",
+  bail: true,
+  plugins: getPlugins(),
+  optimization: getOptimization()
+}
+
+if (config.useContentHash === false) {
+  // eslint-disable-next-line no-console
+  console.warn(`⚠️ WARNING
+Setting 'useContentHash' to 'false' in the production environment (specified by NODE_ENV environment variable) is not allowed!
+Content hashes get added to the filenames regardless of setting useContentHash in 'shakapacker.yml' to false.
+`)
+}
+
+module.exports = merge(baseConfig, productionConfig)

data/package/environments/test.ts

@@ -0,0 +1,53 @@
+/**
+ * Test environment configuration for webpack and rspack bundlers
+ * @module environments/test
+ */
+
+const { merge } = require("webpack-merge")
+const config = require("../config")
+const baseConfig = require("./base")
+import type { Configuration as WebpackConfiguration } from "webpack"
+
+interface TestConfig {
+  mode: "development" | "production" | "none"
+  devtool: string | false
+  watchOptions?: {
+    ignored: RegExp
+  }
+}
+
+/**
+ * Shared test configuration for both webpack and rspack
+ * Ensures consistent test behavior across bundlers
+ */
+const sharedTestConfig: TestConfig = {
+  mode: "development",
+  devtool: "cheap-module-source-map",
+  // Disable file watching in test mode
+  watchOptions: {
+    ignored: /node_modules/
+  }
+}
+
+/**
+ * Generate rspack-specific test configuration
+ * @returns Rspack configuration optimized for testing
+ */
+const rspackTestConfig = (): TestConfig => ({
+  ...sharedTestConfig
+  // Add any rspack-specific overrides here if needed
+})
+
+/**
+ * Generate webpack-specific test configuration
+ * @returns Webpack configuration for testing with same settings as rspack
+ */
+const webpackTestConfig = (): Partial<WebpackConfiguration> => ({
+  ...sharedTestConfig
+  // Add any webpack-specific overrides here if needed
+})
+
+const bundlerConfig =
+  config.assets_bundler === "rspack" ? rspackTestConfig() : webpackTestConfig()
+
+module.exports = merge(baseConfig, bundlerConfig)

data/package/environments/types.ts

@@ -0,0 +1,90 @@
+/**
+ * Type definitions for environment configurations
+ * These types are exported for consumer use
+ */
+
+import type { Configuration as WebpackConfiguration, WebpackPluginInstance } from "webpack"
+import type { Configuration as DevServerConfiguration } from "webpack-dev-server"
+
+/**
+ * Webpack configuration extended with dev server support
+ */
+export interface WebpackConfigWithDevServer extends WebpackConfiguration {
+  devServer?: DevServerConfiguration
+  plugins?: WebpackPluginInstance[]
+}
+
+/**
+ * Rspack plugin interface
+ * Rspack plugins follow a similar pattern to webpack but may have different internals
+ */
+export interface RspackPlugin {
+  new(...args: any[]): {
+    apply(compiler: any): void
+    [key: string]: any
+  }
+}
+
+/**
+ * Rspack dev server configuration
+ * Similar to webpack-dev-server but with some rspack-specific options
+ */
+export interface RspackDevServerConfig {
+  port?: number | string | "auto"
+  host?: string
+  hot?: boolean | "only"
+  historyApiFallback?: boolean | Record<string, unknown>
+  headers?: Record<string, string | string[]>
+  proxy?: unknown
+  static?: boolean | string | Array<string | Record<string, unknown>>
+  devMiddleware?: {
+    writeToDisk?: boolean | ((filePath: string) => boolean)
+    publicPath?: string
+    [key: string]: unknown
+  }
+  [key: string]: unknown
+}
+
+/**
+ * Rspack configuration with dev server support
+ */
+export interface RspackConfigWithDevServer {
+  mode?: "development" | "production" | "none"
+  devtool?: string | false
+  devServer?: RspackDevServerConfig
+  plugins?: RspackPlugin[]
+  module?: WebpackConfiguration["module"]
+  resolve?: WebpackConfiguration["resolve"]
+  entry?: WebpackConfiguration["entry"]
+  output?: WebpackConfiguration["output"]
+  optimization?: WebpackConfiguration["optimization"]
+  [key: string]: unknown
+}
+
+/**
+ * Compression plugin options interface
+ */
+export interface CompressionPluginOptions {
+  filename: string
+  algorithm: string | "gzip" | "brotliCompress"
+  test: RegExp
+  threshold?: number
+  minRatio?: number
+  deleteOriginalAssets?: boolean
+}
+
+/**
+ * Compression plugin constructor type
+ */
+export type CompressionPluginConstructor = new (options: CompressionPluginOptions) => WebpackPluginInstance
+
+/**
+ * React Refresh plugin types
+ */
+export interface ReactRefreshWebpackPlugin {
+  new(options?: Record<string, unknown>): WebpackPluginInstance
+}
+
+export interface ReactRefreshRspackPlugin {
+  new(options?: Record<string, unknown>): RspackPlugin
+}

data/package/esbuild/index.ts

@@ -0,0 +1,42 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+import { resolve } from "path"
+import { existsSync } from "fs"
+import { merge } from "webpack-merge"
+import type { RuleSetRule } from "webpack"
+
+const LOADER_EXT_REGEX = /\.([jt]sx?)(\.erb)?$/
+
+const getLoaderExtension = (filename: string): string => {
+  const matchData = filename.match(LOADER_EXT_REGEX)
+
+  if (!matchData) {
+    return "js"
+  }
+
+  return matchData[1] ?? "js"
+}
+
+const getCustomConfig = (): Partial<RuleSetRule> => {
+  const path = resolve("config", "esbuild.config.js")
+  if (existsSync(path)) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path)
+  }
+  return {}
+}
+
+const getEsbuildLoaderConfig = (filenameToProcess: string): RuleSetRule => {
+  const customConfig = getCustomConfig()
+  const defaultConfig: RuleSetRule = {
+    loader: require.resolve("esbuild-loader"),
+    options: {
+      loader: getLoaderExtension(filenameToProcess)
+    }
+  }
+
+  return merge(defaultConfig, customConfig)
+}
+
+export { getEsbuildLoaderConfig }

data/package/index.d.ts

@@ -1,97 +1,3 @@
-declare module 'shakapacker' {
-  import { Configuration, RuleSetRule } from 'webpack'
-  import * as https from 'node:https';
-
-  export interface Config {
-    source_path: string
-    source_entry_path: string
-    nested_entries: boolean
-    css_extract_ignore_order_warnings: boolean
-    public_root_path: string
-    public_output_path: string
-    cache_path: string
-    webpack_compile_output: boolean
-    shakapacker_precompile: boolean
-    additional_paths: string[]
-    cache_manifest: boolean
-    webpack_loader: string
-    ensure_consistent_versioning: boolean
-    compiler_strategy: string
-    useContentHash: boolean
-    compile: boolean,
-    outputPath: string
-    publicPath: string
-    publicPathWithoutCDN: string
-    manifestPath: string
-  }
-
-  export interface Env {
-    railsEnv: string
-    nodeEnv: string
-    isProduction: boolean
-    isDevelopment: boolean
-    runningWebpackDevServer: boolean
-  }
-
-  type Header = Array<{ key: string; value: string }> | Record<string, string | string[]>
-  type ServerType = 'http' | 'https' | 'spdy'
-  type WebSocketType = 'sockjs' | 'ws'
-
-  /**
-   * This has the same keys and behavior as https://webpack.js.org/configuration/dev-server/ except:
-   * 1. `hot` is replaced by `hmr`;
-   * 2. Camel-cased properties are replaced by snake-cased ones.
-   * @see {import('webpack-dev-server').Configuration}
-   */
-  interface DevServerConfig {
-    allowed_hosts?: 'all' | 'auto' | string | string[]
-    bonjour?: boolean | Record<string, unknown> // bonjour.BonjourOptions
-    client?: Record<string, unknown> // Client
-    compress?: boolean
-    dev_middleware?: Record<string, unknown> // webpackDevMiddleware.Options
-    headers?: Header | (() => Header)
-    history_api_fallback?: boolean | Record<string, unknown> // HistoryApiFallbackOptions
-    hmr?: 'only' | boolean
-    host?: 'local-ip' | 'local-ipv4' | 'local-ipv6' | string
-    http2?: boolean
-    https?: boolean | https.ServerOptions
-    ipc?: boolean | string
-    magic_html?: boolean
-    live_reload?: boolean
-    open?: boolean | string | string[] | Record<string, unknown> | Record<string, unknown>[]
-    port?: 'auto' | string | number
-    proxy?: unknown // ProxyConfigMap | ProxyConfigArray
-    setup_exit_signals?: boolean
-    static?: boolean | string | unknown // Static | Array<string | Static>
-    watch_files?: string | string[] | unknown // WatchFiles | Array<WatchFiles | string>
-    web_socket_server?: string | boolean | WebSocketType | { type?: string | boolean | WebSocketType, options?: Record<string, unknown> }
-    server?: string | boolean | ServerType | { type?: string | boolean | ServerType, options?: https.ServerOptions }
-    [otherWebpackDevServerConfigKey: string]: unknown
-  }
-
-  export const config: Config
-  export const devServer: DevServerConfig
-  export function generateWebpackConfig(extraConfig?: Configuration): Configuration
-  export const baseConfig: Configuration
-  export const env: Env
-  export const rules: RuleSetRule[]
-  export function moduleExists(packageName: string): boolean
-  export function canProcess<T = unknown>(rule: string, fn: (modulePath: string) => T): T | null
-  export const inliningCss: boolean
-  export * from 'webpack-merge'
-}
-
-declare module 'shakapacker/package/babel/preset.js' {
-  import { ConfigAPI, PluginItem, TransformOptions } from '@babel/core'
-
-  interface RequiredTransformOptions {
-    plugins: PluginItem[]
-    presets: PluginItem[]
-  }
-
-  const defaultConfigFunc: (
-    api: ConfigAPI
-  ) => TransformOptions & RequiredTransformOptions
-
-  export = defaultConfigFunc
-}
+declare const _default: any;
+export = _default;
+//# sourceMappingURL=index.d.ts.map

data/package/index.ts

@@ -0,0 +1,52 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const webpackMerge = require("webpack-merge")
+import { resolve } from "path"
+import { existsSync } from "fs"
+// @ts-ignore: webpack is an optional peer dependency (using type-only import)
+import type { Configuration } from "webpack"
+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 rulesPath = resolve(__dirname, "rules", `${config.assets_bundler}.js`)
+const rules = require(rulesPath)
+
+const generateWebpackConfig = (extraConfig: Configuration = {}, ...extraArgs: any[]): Configuration => {
+  if (extraArgs.length > 0) {
+    throw new Error(
+      `Invalid usage: generateWebpackConfig() accepts only one configuration object.\n\n` +
+      `You passed ${extraArgs.length + 1} arguments. Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker.\n\n` +
+      `Example:\n` +
+      `  const { merge } = require('webpack-merge')\n` +
+      `  const mergedConfig = merge(config1, config2, config3)\n` +
+      `  const finalConfig = generateWebpackConfig(mergedConfig)\n\n` +
+      `Or if using ES6:\n` +
+      `  import { merge } from 'webpack-merge'\n` +
+      `  const finalConfig = generateWebpackConfig(merge(config1, config2))`
+    )
+  }
+
+  const { nodeEnv } = env
+  const path = resolve(__dirname, "environments", `${nodeEnv}.js`)
+  const environmentConfig = existsSync(path) ? require(path) : baseConfig
+
+  return webpackMerge.merge({}, environmentConfig, extraConfig)
+}
+
+export = {
+  config, // shakapacker.yml
+  devServer,
+  generateWebpackConfig,
+  baseConfig,
+  env,
+  rules,
+  moduleExists,
+  canProcess,
+  inliningCss,
+  ...webpackMerge
+}

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
+}