shakapacker 9.0.0.beta.4 → 9.0.0.beta.6

data/package/environments/base.js

@@ -1,126 +1,103 @@
+"use strict";
 /* eslint global-require: 0 */
 /* eslint import/no-dynamic-require: 0 */
-
-const { basename, dirname, join, relative, resolve } = require("path")
-const { existsSync, readdirSync } = require("fs")
-const extname = require("path-complete-extname")
-const config = require("../config")
-const { isProduction } = require("../env")
-
-const pluginsPath = resolve(
-  __dirname,
-  "..",
-  "plugins",
-  `${config.assets_bundler}.js`
-)
-const { getPlugins } = require(pluginsPath)
-const rulesPath = resolve(
-  __dirname,
-  "..",
-  "rules",
-  `${config.assets_bundler}.js`
-)
-const rules = require(rulesPath)
-
+const { basename, dirname, join, relative, resolve } = require("path");
+const { existsSync, readdirSync } = require("fs");
+const extname = require("path-complete-extname");
+const config = require("../config");
+const { isProduction } = require("../env");
+const pluginsPath = resolve(__dirname, "..", "plugins", `${config.assets_bundler}.js`);
+const { getPlugins } = require(pluginsPath);
+const rulesPath = resolve(__dirname, "..", "rules", `${config.assets_bundler}.js`);
+const rules = require(rulesPath);
 // Don't use contentHash except for production for performance
 // https://webpack.js.org/guides/build-performance/#avoid-production-specific-tooling
-const hash = isProduction || config.useContentHash ? "-[contenthash]" : ""
-
+const hash = isProduction || config.useContentHash ? "-[contenthash]" : "";
 const getFilesInDirectory = (dir, includeNested) => {
-  if (!existsSync(dir)) {
-    return []
-  }
-
-  return readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
-    const filePath = join(dir, dirent.name)
-
-    if (dirent.isDirectory() && includeNested) {
-      return getFilesInDirectory(filePath, includeNested)
+    if (!existsSync(dir)) {
+        return [];
     }
-    if (dirent.isFile()) {
-      return filePath
-    }
-    return []
-  })
-}
-
+    return readdirSync(dir, { withFileTypes: true }).flatMap((dirent) => {
+        const filePath = join(dir, dirent.name);
+        if (dirent.isDirectory() && includeNested) {
+            return getFilesInDirectory(filePath, includeNested);
+        }
+        if (dirent.isFile()) {
+            return filePath;
+        }
+        return [];
+    });
+};
 const getEntryObject = () => {
-  const entries = {}
-  const rootPath = join(config.source_path, config.source_entry_path)
-  if (config.source_entry_path === "/" && config.nested_entries) {
-    throw new Error(
-      "Your shakapacker config specified using a source_entry_path of '/' with 'nested_entries' == " +
-        "'true'. Doing this would result in packs for every one of your source files"
-    )
-  }
-
-  getFilesInDirectory(rootPath, config.nested_entries).forEach((path) => {
-    const namespace = relative(join(rootPath), dirname(path))
-    const name = join(namespace, basename(path, extname(path)))
-    let assetPaths = resolve(path)
-
-    // Allows for multiple filetypes per entry (https://webpack.js.org/guides/entry-advanced/)
-    // Transforms the config object value to an array with all values under the same name
-    let previousPaths = entries[name]
-    if (previousPaths) {
-      previousPaths = Array.isArray(previousPaths)
-        ? previousPaths
-        : [previousPaths]
-      previousPaths.push(assetPaths)
-      assetPaths = previousPaths
+    const entries = {};
+    const rootPath = join(config.source_path, config.source_entry_path);
+    if (config.source_entry_path === "/" && config.nested_entries) {
+        throw new Error(`Invalid Shakapacker configuration detected!\n\n` +
+            `You have set source_entry_path to '/' with nested_entries enabled.\n` +
+            `This would create webpack entry points for EVERY file in your source directory,\n` +
+            `which would severely impact build performance.\n\n` +
+            `To fix this issue, either:\n` +
+            `1. Set 'nested_entries: false' in your shakapacker.yml\n` +
+            `2. Change 'source_entry_path' to a specific subdirectory (e.g., 'packs')\n` +
+            `3. Or use both options for better organization of your entry points`);
     }
-
-    entries[name] = assetPaths
-  })
-
-  return entries
-}
-
+    getFilesInDirectory(rootPath, config.nested_entries).forEach((path) => {
+        const namespace = relative(join(rootPath), dirname(path));
+        const name = join(namespace, basename(path, extname(path)));
+        const assetPath = resolve(path);
+        // Allows for multiple filetypes per entry (https://webpack.js.org/guides/entry-advanced/)
+        // Transforms the config object value to an array with all values under the same name
+        const previousPaths = entries[name];
+        if (previousPaths) {
+            const pathArray = Array.isArray(previousPaths)
+                ? previousPaths
+                : [previousPaths];
+            pathArray.push(assetPath);
+            entries[name] = pathArray;
+        }
+        else {
+            entries[name] = assetPath;
+        }
+    });
+    return entries;
+};
 const getModulePaths = () => {
-  const result = [resolve(config.source_path)]
-
-  if (config.additional_paths) {
-    config.additional_paths.forEach((path) => result.push(resolve(path)))
-  }
-  result.push("node_modules")
-
-  return result
-}
-
-module.exports = {
-  mode: "production",
-  output: {
-    filename: `js/[name]${hash}.js`,
-    chunkFilename: `js/[name]${hash}.chunk.js`,
-
-    // https://webpack.js.org/configuration/output/#outputhotupdatechunkfilename
-    hotUpdateChunkFilename: "js/[id].[fullhash].hot-update.js",
-    path: config.outputPath,
-    publicPath: config.publicPath,
-
-    // This is required for SRI to work.
-    crossOriginLoading: config.integrity.enabled
-      ? config.integrity.cross_origin
-      : false
-  },
-  entry: getEntryObject(),
-  resolve: {
-    extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".coffee"],
-    modules: getModulePaths()
-  },
-
-  plugins: getPlugins(),
-
-  resolveLoader: {
-    modules: ["node_modules"]
-  },
-
-  optimization: {
-    splitChunks: { chunks: "all" },
-    runtimeChunk: "single"
-  },
-
-  module: {
-    rules
-  }
-}
+    const result = [resolve(config.source_path)];
+    if (config.additional_paths) {
+        config.additional_paths.forEach((path) => result.push(resolve(path)));
+    }
+    result.push("node_modules");
+    return result;
+};
+const baseConfig = {
+    mode: "production",
+    output: {
+        filename: `js/[name]${hash}.js`,
+        chunkFilename: `js/[name]${hash}.chunk.js`,
+        // https://webpack.js.org/configuration/output/#outputhotupdatechunkfilename
+        hotUpdateChunkFilename: "js/[id].[fullhash].hot-update.js",
+        path: config.outputPath,
+        publicPath: config.publicPath,
+        // This is required for SRI to work.
+        crossOriginLoading: config.integrity && config.integrity.enabled
+            ? config.integrity.cross_origin
+            : false
+    },
+    entry: getEntryObject(),
+    resolve: {
+        extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".coffee"],
+        modules: getModulePaths()
+    },
+    plugins: getPlugins(),
+    resolveLoader: {
+        modules: ["node_modules"]
+    },
+    optimization: {
+        splitChunks: { chunks: "all" },
+        runtimeChunk: "single"
+    },
+    module: {
+        rules
+    }
+};
+module.exports = baseConfig;

data/package/environments/base.ts

@@ -0,0 +1,138 @@
+/* eslint global-require: 0 */
+/* eslint import/no-dynamic-require: 0 */
+
+const { basename, dirname, join, relative, resolve } = require("path")
+const { existsSync, readdirSync } = require("fs")
+import { Dirent } from "fs"
+const extname = require("path-complete-extname")
+// @ts-ignore: webpack is an optional peer dependency (using type-only import)
+import type { Configuration, Entry } from "webpack"
+const config = require("../config")
+const { isProduction } = require("../env")
+
+const pluginsPath = resolve(
+  __dirname,
+  "..",
+  "plugins",
+  `${config.assets_bundler}.js`
+)
+const { getPlugins } = require(pluginsPath)
+const rulesPath = resolve(
+  __dirname,
+  "..",
+  "rules",
+  `${config.assets_bundler}.js`
+)
+const rules = require(rulesPath)
+
+// Don't use contentHash except for production for performance
+// https://webpack.js.org/guides/build-performance/#avoid-production-specific-tooling
+const hash = isProduction || config.useContentHash ? "-[contenthash]" : ""
+
+const getFilesInDirectory = (dir: string, includeNested: boolean): string[] => {
+  if (!existsSync(dir)) {
+    return []
+  }
+
+  return readdirSync(dir, { withFileTypes: true }).flatMap((dirent: Dirent) => {
+    const filePath = join(dir, dirent.name)
+
+    if (dirent.isDirectory() && includeNested) {
+      return getFilesInDirectory(filePath, includeNested)
+    }
+    if (dirent.isFile()) {
+      return filePath
+    }
+    return []
+  })
+}
+
+const getEntryObject = (): Entry => {
+  const entries: Entry = {}
+  const rootPath = join(config.source_path, config.source_entry_path)
+  if (config.source_entry_path === "/" && config.nested_entries) {
+    throw new Error(
+      `Invalid Shakapacker configuration detected!\n\n` +
+      `You have set source_entry_path to '/' with nested_entries enabled.\n` +
+      `This would create webpack entry points for EVERY file in your source directory,\n` +
+      `which would severely impact build performance.\n\n` +
+      `To fix this issue, either:\n` +
+      `1. Set 'nested_entries: false' in your shakapacker.yml\n` +
+      `2. Change 'source_entry_path' to a specific subdirectory (e.g., 'packs')\n` +
+      `3. Or use both options for better organization of your entry points`
+    )
+  }
+
+  getFilesInDirectory(rootPath, config.nested_entries).forEach((path) => {
+    const namespace = relative(join(rootPath), dirname(path))
+    const name = join(namespace, basename(path, extname(path)))
+    const assetPath: string = resolve(path)
+
+    // Allows for multiple filetypes per entry (https://webpack.js.org/guides/entry-advanced/)
+    // Transforms the config object value to an array with all values under the same name
+    const previousPaths = entries[name]
+    if (previousPaths) {
+      const pathArray = Array.isArray(previousPaths)
+        ? previousPaths as string[]
+        : [previousPaths as string]
+      pathArray.push(assetPath)
+      entries[name] = pathArray
+    } else {
+      entries[name] = assetPath
+    }
+  })
+
+  return entries
+}
+
+const getModulePaths = (): string[] => {
+  const result = [resolve(config.source_path)]
+
+  if (config.additional_paths) {
+    config.additional_paths.forEach((path: string) => result.push(resolve(path)))
+  }
+  result.push("node_modules")
+
+  return result
+}
+
+const baseConfig: Configuration = {
+  mode: "production",
+  output: {
+    filename: `js/[name]${hash}.js`,
+    chunkFilename: `js/[name]${hash}.chunk.js`,
+
+    // https://webpack.js.org/configuration/output/#outputhotupdatechunkfilename
+    hotUpdateChunkFilename: "js/[id].[fullhash].hot-update.js",
+    path: config.outputPath,
+    publicPath: config.publicPath,
+
+    // This is required for SRI to work.
+    crossOriginLoading: config.integrity && config.integrity.enabled
+      ? (config.integrity.cross_origin as "anonymous" | "use-credentials" | false)
+      : false
+  },
+  entry: getEntryObject(),
+  resolve: {
+    extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".coffee"],
+    modules: getModulePaths()
+  },
+
+  plugins: getPlugins(),
+
+  resolveLoader: {
+    modules: ["node_modules"]
+  },
+
+  optimization: {
+    splitChunks: { chunks: "all" },
+    runtimeChunk: "single"
+  },
+
+  module: {
+    rules
+  }
+}
+
+export = baseConfig
+

data/package/index.d.ts

@@ -1,150 +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
-    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}
-   */
-  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
-  }
-
-  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/rspack" {
-  import type { RspackOptions } from "@rspack/core"
-
-  export const config: import("shakapacker").Config
-  export function generateRspackConfig(
-    extraConfig?: RspackOptions
-  ): RspackOptions
-  export const baseConfig: RspackOptions
-  export const env: import("shakapacker").Env
-  export const rules: NonNullable<RspackOptions["module"]>["rules"]
-  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.js → index.ts}

@@ -2,22 +2,32 @@
 /* eslint import/no-dynamic-require: 0 */
 
 const webpackMerge = require("webpack-merge")
-const { resolve } = require("path")
-const { existsSync } = require("fs")
+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 rulesPath = resolve(__dirname, "rules", `${config.assets_bundler}.js`)
-const rules = require(rulesPath)
 const devServer = require("./dev_server")
 const env = require("./env")
 const { moduleExists, canProcess } = require("./utils/helpers")
 const inliningCss = require("./utils/inliningCss")
 
-const generateWebpackConfig = (extraConfig = {}, ...extraArgs) => {
+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(
-      "Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker"
+      `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))`
     )
   }
 
@@ -28,7 +38,7 @@ const generateWebpackConfig = (extraConfig = {}, ...extraArgs) => {
   return webpackMerge.merge({}, environmentConfig, extraConfig)
 }
 
-module.exports = {
+export = {
   config, // shakapacker.yml
   devServer,
   generateWebpackConfig,

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