rails-vite-plugin 0.2.1 → 0.2.3

package/dist/jsbundling.js

@@ -56,6 +56,9 @@ export default function jsbundling(options = {}) {
                             outDir: userConfig.build?.outDir ?? ssrConfig.outDir,
                             [bundlerOptionsKey]: {
                                 input: userBundlerInput ?? ssrConfig.entry,
+                                output: {
+                                    assetFileNames: '[name][extname]',
+                                },
                             },
                         },
                     } : {}),
@@ -80,7 +83,7 @@ export default function jsbundling(options = {}) {
                                 if (chunkInfo.facadeModuleId && cssExtensions.test(chunkInfo.facadeModuleId)) {
                                     return `${CSS_FACADE_PREFIX}[name].js`;
                                 }
-                                return '[name].js';
+                                return '_[name]-[hash].js';
                             },
                             chunkFileNames: '[name]-[hash].js',
                             assetFileNames: '[name][extname]',
@@ -120,19 +123,30 @@ export default function jsbundling(options = {}) {
             // SSR bundles are Node.js server code — not served to browsers.
             if (resolvedConfig.build.ssr)
                 return;
-            // Copy entry files (JS + CSS) to the asset pipeline directory
-            // so Propshaft/Sprockets can serve them via Rails helpers.
-            // Chunks stay in outputDir and are served directly by the web server.
             fs.mkdirSync(assetPipelineDir, { recursive: true });
             const outDir = resolvedConfig.build.outDir;
-            // Only copy CSS files that correspond to entries (entry CSS or CSS extracted
-            // from JS entries). Shared chunk CSS stays in outputDir.
             const entryNames = new Set(entries.map(e => e.name));
             for (const [fileName, chunk] of Object.entries(bundle)) {
                 const isEntryJs = chunk.type === 'chunk' && chunk.isEntry;
                 const isEntryCss = chunk.type === 'asset' && cssExtensions.test(fileName)
                     && entryNames.has(fileName.replace(/\.[^.]+$/, ''));
-                if (isEntryJs || isEntryCss) {
+                if (isEntryJs) {
+                    // JS entries are built as _[name]-[hash].js (content-hashed).
+                    // Write a thin shim as [name].js for the asset pipeline so that
+                    // Propshaft/Sprockets can serve it via javascript_include_tag.
+                    //
+                    // Why: Propshaft digests entry filenames (inertia.js → inertia-abc123.js)
+                    // but cannot rewrite import paths inside Vite's chunks. Without the shim,
+                    // the <script> tag and chunk imports resolve to different ES module
+                    // instances — duplicating React, Inertia, and other stateful singletons.
+                    // The shim ensures both paths chain to the same _[name]-[hash].js module.
+                    const shimName = chunk.name + '.js';
+                    const shim = `import "./${fileName}";export * from "./${fileName}";\n`;
+                    fs.writeFileSync(path.join(outDir, shimName), shim);
+                    fs.writeFileSync(path.join(assetPipelineDir, shimName), shim);
+                }
+                else if (isEntryCss) {
+                    // Copy entry CSS to the asset pipeline. Shared chunk CSS stays in outputDir.
                     const src = path.join(outDir, fileName);
                     const dest = path.join(assetPipelineDir, fileName);
                     fs.mkdirSync(path.dirname(dest), { recursive: true });

package/dist/shared/entries.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import picomatch from 'picomatch';
 import { cssExtensionList } from './css.js';
 const jsExtensions = ['mjs', 'js', 'mts', 'ts', 'jsx', 'tsx'];
 const entrypointExtensions = new RegExp(`\\.(${[...jsExtensions, ...cssExtensionList].join('|')})$`);
@@ -13,7 +14,8 @@ export function resolveEntries(input, sourceDir) {
             sourcePath: prefixWithSourceDir(value, sourceDir),
         }));
     }
-    const inputs = Array.isArray(input) ? input : [input];
+    const rawInputs = Array.isArray(input) ? input : [input];
+    const inputs = rawInputs.flatMap(entry => expandGlob(entry, sourceDir));
     const sourcePaths = inputs.map(entry => prefixWithSourceDir(entry, sourceDir));
     const commonPrefix = detectCommonEntryPrefix(sourcePaths, sourceDir);
     return sourcePaths.map(sourcePath => ({
@@ -65,6 +67,52 @@ export function detectEntrypoint(sourceDir) {
     }
     return 'application.js';
 }
+function isGlob(pattern) {
+    return /[*?{]/.test(pattern);
+}
+function expandGlob(entry, sourceDir) {
+    if (!isGlob(entry))
+        return [entry];
+    const matcher = picomatch(entry);
+    if (entry.includes('**')) {
+        // Recursive: find the static prefix directory, then walk it
+        const parts = entry.split('/');
+        const staticParts = [];
+        for (const part of parts) {
+            if (isGlob(part))
+                break;
+            staticParts.push(part);
+        }
+        const baseDir = staticParts.length > 0
+            ? path.join(sourceDir, ...staticParts)
+            : sourceDir;
+        if (!fs.existsSync(baseDir))
+            return [];
+        return walkDir(baseDir, sourceDir).filter(f => matcher(f));
+    }
+    // Non-recursive: single directory match
+    const dir = path.join(sourceDir, path.dirname(entry));
+    const pattern = path.basename(entry);
+    const fileMatcher = picomatch(pattern);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .filter(f => f.isFile() && fileMatcher(f.name))
+        .map(f => path.relative(sourceDir, path.join(dir, f.name)));
+}
+function walkDir(dir, baseDir) {
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...walkDir(full, baseDir));
+        }
+        else if (entry.isFile()) {
+            results.push(path.relative(baseDir, full));
+        }
+    }
+    return results;
+}
 function discoverEntrypoints(dir, base = dir) {
     const entries = [];
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rails-vite-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Vite plugin for Rails integration",
   "author": "Svyatoslav Kryukov <me@skryukov.dev>",
   "license": "MIT",