shakapacker 8.0.2 → 9.2.0

data/package/rules/rspack.ts

@@ -0,0 +1,176 @@
+/* eslint global-require: 0 */
+
+const { moduleExists } = require("../utils/helpers")
+const { debug, info, warn } = require("../utils/debug")
+
+debug("Loading Rspack rules configuration...")
+
+const rules = []
+
+// Use Rspack's built-in SWC loader for JavaScript files
+debug("Adding JavaScript rule with builtin:swc-loader")
+rules.push({
+  test: /\.(js|jsx|mjs)$/,
+  exclude: /node_modules/,
+  // The 'type' field is required for Rspack to properly handle JavaScript modules
+  // when using builtin loaders. It ensures correct module parsing and transformation.
+  type: "javascript/auto",
+  use: [
+    {
+      loader: "builtin:swc-loader",
+      options: {
+        jsc: {
+          parser: {
+            syntax: "ecmascript",
+            jsx: true
+          },
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      }
+    }
+  ]
+})
+
+// Use Rspack's built-in SWC loader for TypeScript files
+debug("Adding TypeScript rule with builtin:swc-loader")
+rules.push({
+  test: /\.(ts|tsx)$/,
+  exclude: /node_modules/,
+  // The 'type' field is required for Rspack to properly handle TypeScript modules
+  // when using builtin loaders. It ensures correct module parsing and transformation.
+  type: "javascript/auto",
+  use: [
+    {
+      loader: "builtin:swc-loader",
+      options: {
+        jsc: {
+          parser: {
+            syntax: "typescript",
+            tsx: true
+          },
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      }
+    }
+  ]
+})
+
+// CSS rules using Rspack's built-in CSS handling
+debug("Checking for CSS loader...")
+if (moduleExists("css-loader")) {
+  debug("css-loader found, loading CSS rule configuration...")
+  const css = require("./css")
+  if (css) {
+    debug("Successfully added CSS rule")
+    rules.push(css)
+  } else {
+    warn("css-loader found but rule configuration returned null")
+  }
+} else {
+  info("Skipping CSS support - css-loader not installed")
+}
+
+// Sass rules
+debug("Checking for Sass loader...")
+if (moduleExists("sass") && moduleExists("sass-loader")) {
+  debug("sass and sass-loader found, loading Sass rule configuration...")
+  const sass = require("./sass")
+  if (sass) {
+    debug("Successfully added Sass rule")
+    rules.push(sass)
+  } else {
+    warn("sass and sass-loader found but rule configuration returned null")
+  }
+} else if (!moduleExists("sass")) {
+  info("Skipping Sass support - sass not installed")
+} else if (!moduleExists("sass-loader")) {
+  info("Skipping Sass support - sass-loader not installed")
+}
+
+// Less rules
+debug("Checking for Less loader...")
+if (moduleExists("less") && moduleExists("less-loader")) {
+  debug("less and less-loader found, loading Less rule configuration...")
+  const less = require("./less")
+  if (less) {
+    debug("Successfully added Less rule")
+    rules.push(less)
+  } else {
+    warn("less and less-loader found but rule configuration returned null")
+  }
+} else if (!moduleExists("less")) {
+  info("Skipping Less support - less not installed")
+} else if (!moduleExists("less-loader")) {
+  info("Skipping Less support - less-loader not installed")
+}
+
+// Stylus rules
+debug("Checking for Stylus loader...")
+if (moduleExists("stylus") && moduleExists("stylus-loader")) {
+  debug("stylus and stylus-loader found, loading Stylus rule configuration...")
+  const stylus = require("./stylus")
+  if (stylus) {
+    debug("Successfully added Stylus rule")
+    rules.push(stylus)
+  } else {
+    warn("stylus and stylus-loader found but rule configuration returned null")
+  }
+} else if (!moduleExists("stylus")) {
+  info("Skipping Stylus support - stylus not installed")
+} else if (!moduleExists("stylus-loader")) {
+  info("Skipping Stylus support - stylus-loader not installed")
+}
+
+// ERB template support
+debug("Checking for ERB template support...")
+const erb = require("./erb")
+
+if (erb) {
+  debug("Successfully added ERB rule")
+  rules.push(erb)
+} else {
+  info("Skipping ERB support - rails-erb-loader not installed")
+}
+
+// File/asset handling using Rspack's built-in asset modules
+// This is a critical rule required for proper asset handling
+debug("Adding file/asset handling rule...")
+const file = require("./file")
+
+if (!file) {
+  throw new Error(
+    "CRITICAL: file rule configuration returned null. " +
+      "Asset handling is required for proper bundling. " +
+      "Please ensure the file rule module exports a valid rule configuration."
+  )
+}
+
+debug("Successfully added file/asset rule")
+rules.push(file)
+
+// Raw file loading
+// This is a critical rule required for raw file imports
+debug("Adding raw file loading rule...")
+const raw = require("./raw")
+
+if (!raw) {
+  throw new Error(
+    "CRITICAL: raw rule configuration returned null. " +
+      "Raw file loading is required for proper bundling. " +
+      "Please ensure the raw rule module exports a valid rule configuration."
+  )
+}
+
+debug("Successfully added raw file rule")
+rules.push(raw)
+
+debug(`Rspack rules configuration complete. Total rules: ${rules.length}`)
+export = rules

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

@@ -1,17 +1,21 @@
 /* eslint global-require: 0 */
 
-const getStyleRule = require("../utils/getStyleRule")
+const { getStyleRule } = require("../utils/getStyleRule")
 const { canProcess, packageMajorVersion } = require("../utils/helpers")
 const { additional_paths: extraPaths } = require("../config")
 
-module.exports = canProcess("sass-loader", (resolvedPath) => {
+export = canProcess("sass-loader", (resolvedPath: string) => {
   const optionKey =
     packageMajorVersion("sass-loader") > 15 ? "loadPaths" : "includePaths"
   return getStyleRule(/\.(scss|sass)(\.erb)?$/i, [
     {
       loader: resolvedPath,
       options: {
-        sassOptions: { [optionKey]: extraPaths }
+        sourceMap: true,
+        sassOptions: {
+          [optionKey]: extraPaths,
+          quietDeps: true
+        }
       }
     }
   ])

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

@@ -1,23 +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("stylus-loader", (resolvedPath) =>
+export = canProcess("stylus-loader", (resolvedPath: string) =>
   getStyleRule(/\.(styl(us)?)(\.erb)?$/i, [
     {
       loader: resolvedPath,
       options: {
         stylusOptions: {
-          include: [
-            path.resolve(__dirname, "node_modules"),
-            sourcePath,
-            ...paths
-          ]
+          // Additional paths for Stylus imports (node_modules is resolved automatically)
+          include: [sourcePath, ...paths]
         },
         sourceMap: true
       }

data/package/rules/swc.ts

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

data/package/rules/webpack.ts

@@ -0,0 +1,16 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+export = [
+  require("./raw"),
+  require("./file"),
+  require("./css"),
+  require("./sass"),
+  require("./babel"),
+  require("./swc"),
+  require("./esbuild"),
+  require("./erb"),
+  require("./coffee"),
+  require("./less"),
+  require("./stylus")
+].filter(Boolean)

data/package/swc/index.ts

@@ -0,0 +1,56 @@
+/* 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 JSX_FILE_REGEX = /\.(jsx|tsx)(\.erb)?$/
+const TYPESCRIPT_FILE_REGEX = /\.(ts|tsx)(\.erb)?$/
+
+const isJsxFile = (filename: string): boolean =>
+  !!filename.match(JSX_FILE_REGEX)
+
+const isTypescriptFile = (filename: string): boolean =>
+  !!filename.match(TYPESCRIPT_FILE_REGEX)
+
+const getCustomConfig = (): Partial<RuleSetRule> => {
+  const path = resolve("config", "swc.config.js")
+  if (existsSync(path)) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require(path)
+  }
+  return {}
+}
+
+const getSwcLoaderConfig = (filenameToProcess: string): RuleSetRule => {
+  const customConfig = getCustomConfig()
+  const isTs = isTypescriptFile(filenameToProcess)
+  const isJsx = isJsxFile(filenameToProcess)
+  const jsxKey = isTs ? "tsx" : "jsx"
+
+  const defaultConfig: RuleSetRule = {
+    loader: require.resolve("swc-loader"),
+    options: {
+      jsc: {
+        parser: {
+          dynamicImport: true,
+          syntax: isTs ? "typescript" : "ecmascript",
+          [jsxKey]: isJsx
+        },
+        loose: false
+      },
+      sourceMaps: true,
+      env: {
+        coreJs: 3,
+        exclude: ["transform-typeof-symbol"],
+        mode: "entry"
+      }
+    }
+  }
+
+  return merge(defaultConfig, customConfig)
+}
+
+export { getSwcLoaderConfig }

data/package/types/README.md

@@ -0,0 +1,88 @@
+# Shakapacker TypeScript Types
+
+This directory exports all TypeScript types used in Shakapacker for easier consumer imports.
+
+## Usage
+
+Instead of importing types from deep paths:
+
+```typescript
+// ❌ Old way - importing from multiple deep paths
+import type { Config } from 'shakapacker/package/types'
+import type { WebpackConfigWithDevServer } from 'shakapacker/package/environments/types'
+```
+
+You can now import all types from a single location:
+
+```typescript
+// ✅ New way - single import path
+import type {
+  Config,
+  WebpackConfigWithDevServer,
+  RspackConfigWithDevServer
+} from 'shakapacker/types'
+```
+
+## Available Types
+
+### Core Configuration Types
+- `Config` - Main Shakapacker configuration interface
+- `YamlConfig` - YAML configuration structure
+- `LegacyConfig` - Legacy configuration with deprecated options
+- `Env` - Environment variables interface
+- `DevServerConfig` - Development server configuration
+
+### Loader Types
+- `ShakapackerLoader` - Loader interface
+- `ShakapackerLoaderOptions` - Loader options interface
+- `LoaderResolver` - Function type for resolving loaders
+- `LoaderConfig` - Loader configuration interface
+
+### Webpack/Rspack Types
+- `WebpackConfigWithDevServer` - Webpack config with dev server
+- `RspackConfigWithDevServer` - Rspack config with dev server
+- `RspackPluginInstance` - Rspack plugin instance type
+- `RspackPlugin` - **⚠️ Deprecated:** Use `RspackPluginInstance` instead
+- `RspackDevServerConfig` - Rspack dev server configuration
+- `CompressionPluginOptions` - Options for compression plugin
+- `CompressionPluginConstructor` - Constructor type for compression plugin
+- `ReactRefreshWebpackPlugin` - React refresh plugin for Webpack
+- `ReactRefreshRspackPlugin` - React refresh plugin for Rspack
+
+### Webpack-Specific Types
+- `ShakapackerWebpackConfig` - Extended Webpack configuration
+- `ShakapackerRule` - Extended Webpack rule
+- `LoaderType` - String or loader object type
+- `LoaderUtils` - Loader utility functions
+
+### Re-exported Types
+- `WebpackConfiguration` - From 'webpack'
+- `WebpackPluginInstance` - From 'webpack'
+- `RuleSetRule` - From 'webpack'
+- `NodeJSError` - Node.js error exception type
+
+## Example Usage
+
+```typescript
+import type {
+  Config,
+  WebpackConfigWithDevServer
+} from 'shakapacker/types'
+
+const config: Config = {
+  source_path: 'app/javascript',
+  source_entry_path: 'packs',
+  public_root_path: 'public',
+  public_output_path: 'packs',
+  // ... other config
+}
+
+const webpackConfig: WebpackConfigWithDevServer = {
+  mode: 'development',
+  devServer: {
+    hot: true,
+    port: 3035
+  }
+  // ... other webpack config
+}
+```

data/package/types/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Central type exports for Shakapacker
+ * This file re-exports all public TypeScript types for easier consumer imports
+ *
+ * @example
+ * ```typescript
+ * import type { Config, WebpackConfigWithDevServer } from 'shakapacker/types'
+ * ```
+ *
+ * @module shakapacker/types
+ */
+
+// Core configuration types
+export type {
+  Config,
+  YamlConfig,
+  LegacyConfig,
+  Env,
+  DevServerConfig
+} from '../types'
+
+// Loader types
+export type {
+  ShakapackerLoader,
+  ShakapackerLoaderOptions,
+  LoaderResolver,
+  LoaderConfig
+} from '../loaders'
+
+// Webpack-specific types
+export type {
+  ShakapackerWebpackConfig,
+  ShakapackerRule,
+  ShakapackerLoaderOptions as WebpackLoaderOptions,
+  ShakapackerLoader as WebpackLoader,
+  LoaderType,
+  LoaderUtils
+} from '../webpack-types'
+
+// Environment configuration types
+export type {
+  WebpackConfigWithDevServer,
+  RspackPluginInstance,
+  RspackPlugin,
+  RspackDevServerConfig,
+  RspackConfigWithDevServer,
+  CompressionPluginOptions,
+  CompressionPluginConstructor,
+  ReactRefreshWebpackPlugin,
+  ReactRefreshRspackPlugin
+} from '../environments/types'
+
+// Node.js error type (re-exported for convenience)
+export type NodeJSError = NodeJS.ErrnoException
+
+// Re-export commonly used webpack types for convenience
+export type {
+  Configuration as WebpackConfiguration,
+  WebpackPluginInstance,
+  RuleSetRule
+} from 'webpack'

data/package/types.ts

@@ -0,0 +1,108 @@
+import * as https from "node:https"
+
+// Type for the raw YAML config file
+export interface YamlConfig {
+  [environment: string]: Partial<Config>
+}
+
+// Type for backward compatibility
+export interface LegacyConfig extends Config {
+  webpack_loader?: string
+}
+
+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
+  private_output_path?: string
+  cache_path: string
+  webpack_compile_output: boolean
+  shakapacker_precompile: boolean
+  additional_paths: string[]
+  cache_manifest: boolean
+  javascript_transpiler: string
+  ensure_consistent_versioning: boolean
+  compiler_strategy: string
+  useContentHash: boolean
+  compile: boolean
+  outputPath: string
+  publicPath: string
+  publicPathWithoutCDN: string
+  manifestPath: string
+  manifest_path?: string
+  assets_bundler?: string
+  dev_server?: DevServerConfig
+  integrity?: {
+    enabled: boolean
+    cross_origin: string
+    hash_functions?: 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}
+ */
+export 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
+  inline_css?: boolean
+  env_prefix?: string
+  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
+}
+

data/package/utils/configPath.ts

@@ -0,0 +1,6 @@
+import { resolve } from "path"
+
+const configPath: string =
+  process.env.SHAKAPACKER_CONFIG || resolve("config", "shakapacker.yml")
+
+export = configPath

data/package/utils/debug.ts

@@ -0,0 +1,49 @@
+/**
+ * Debug utility for Shakapacker
+ * Provides conditional logging based on environment variables
+ */
+
+const isDebugMode = (): boolean => {
+  // Explicitly check for debug mode being disabled
+  if (process.env.SHAKAPACKER_DEBUG === "false") {
+    return false
+  }
+
+  // Support both SHAKAPACKER_DEBUG (new) and DEBUG_SHAKAPACKER (legacy) for backwards compatibility
+  return (
+    process.env.SHAKAPACKER_DEBUG === "true" ||
+    process.env.DEBUG_SHAKAPACKER === "true"
+  )
+}
+
+const debug = (message: string, ...args: unknown[]): void => {
+  if (isDebugMode()) {
+    // eslint-disable-next-line no-console
+    console.log(`[Shakapacker] ${message}`, ...args)
+  }
+}
+
+const warn = (message: string, ...args: unknown[]): void => {
+  // eslint-disable-next-line no-console
+  console.warn(`[Shakapacker] WARNING: ${message}`, ...args)
+}
+
+const error = (message: string, ...args: unknown[]): void => {
+  // eslint-disable-next-line no-console
+  console.error(`[Shakapacker] ERROR: ${message}`, ...args)
+}
+
+const info = (message: string, ...args: unknown[]): void => {
+  if (isDebugMode()) {
+    // eslint-disable-next-line no-console
+    console.info(`[Shakapacker] INFO: ${message}`, ...args)
+  }
+}
+
+export = {
+  debug,
+  warn,
+  error,
+  info,
+  isDebugMode
+}

data/package/utils/defaultConfigPath.ts

@@ -0,0 +1,4 @@
+import { resolve } from "path"
+
+const path: string = resolve(__dirname, "../../lib/install/config/shakapacker.yml")
+export = path