rails-vite-plugin 0.1.1 → 0.2.0-beta.1

package/dist/index.d.ts

@@ -1,14 +1,18 @@
 import { Plugin } from 'vite';
-export type InputOption = string | string[] | Record<string, string>;
+import type { InputOption } from './shared/types.js';
+import { refreshPaths } from './shared/refresh.js';
+export type { InputOption };
+export { refreshPaths };
 export interface RailsViteOptions {
     input?: InputOption;
     sourceDir?: string;
     ssr?: InputOption;
-    ssrOutputDirectory?: string;
+    ssrOutDir?: string;
     devMetaFile?: string;
-    buildDirectory?: string;
-    publicDirectory?: string;
+    /** Directory name under publicDir for Vite build output (default: 'vite') */
+    buildDir?: string;
+    /** Public directory (default: 'public') */
+    publicDir?: string;
     refresh?: boolean | string | string[];
 }
-export declare const refreshPaths: string[];
 export default function rails(options?: RailsViteOptions): Plugin;

package/dist/index.js

@@ -1,20 +1,24 @@
 import fs from 'fs';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import picomatch from 'picomatch';
 import { loadEnv, defaultAllowedOrigins, } from 'vite';
-export const refreshPaths = [
-    'app/views/**/*.{erb,slim,haml}',
-    'app/helpers/**/*.rb',
-];
-let exitHandlersBound = false;
+import { resolveInput, detectEntrypointsDir, discoverEntrypointInputs, detectEntrypoint } from './shared/entries.js';
+import { resolveAlias } from './shared/alias.js';
+import { resolveDevServerUrl, isAddressInfo } from './shared/dev-server.js';
+import { ensureCommandShouldRunInEnvironment } from './shared/env-guard.js';
+import { refreshPaths, resolveRefreshPaths } from './shared/refresh.js';
+import { readDevServerIndexHtml } from './shared/dev-server-page.js';
+import { resolveNoExternal } from './shared/ssr.js';
+import { bindExitHandler } from './shared/cleanup.js';
+export { refreshPaths };
 export default function rails(options = {}) {
     const sourceDir = options.sourceDir ?? 'app/javascript';
-    const input = options.input ?? detectEntrypoint(sourceDir);
-    const publicDirectory = options.publicDirectory ?? 'public';
-    const buildDirectory = options.buildDirectory ?? 'vite';
+    const entrypointsDir = options.input === undefined ? detectEntrypointsDir(sourceDir) : null;
+    const input = options.input ?? (entrypointsDir ? discoverEntrypointInputs(sourceDir, entrypointsDir) : detectEntrypoint(sourceDir));
+    const publicDir = options.publicDir ?? 'public';
+    const buildDir = options.buildDir ?? 'vite';
     const devMetaPath = options.devMetaFile ?? path.join('tmp', 'rails-vite.json');
-    const ssrOutputDirectory = options.ssrOutputDirectory ?? 'ssr';
+    const ssrOutDir = options.ssrOutDir ?? 'ssr';
     const resolvedInput = resolveInput(input, sourceDir);
     const resolvedSsr = options.ssr !== undefined ? resolveInput(options.ssr, sourceDir) : undefined;
     let resolvedConfig;
@@ -22,19 +26,18 @@ export default function rails(options = {}) {
     return {
         name: 'rails-vite',
         enforce: 'post',
-        config(userConfig, { command, mode }) {
+        config(userConfig, { command, mode, isSsrBuild }) {
             const env = loadEnv(mode, userConfig.envDir || process.cwd(), '');
-            const ssr = !!userConfig.build?.ssr;
-            ensureCommandShouldRunInEnvironment(command, env);
+            ensureCommandShouldRunInEnvironment(command, env, 'rails-vite-plugin');
             return {
-                base: userConfig.base ?? (command === 'build' ? `/${buildDirectory}/` : ''),
+                base: userConfig.base ?? (command === 'build' ? `/${buildDir}/` : ''),
                 publicDir: userConfig.publicDir ?? false,
                 build: {
-                    manifest: userConfig.build?.manifest ?? (ssr ? false : 'manifest.json'),
-                    ssrManifest: userConfig.build?.ssrManifest ?? (ssr ? 'ssr-manifest.json' : false),
-                    outDir: userConfig.build?.outDir ?? (ssr ? ssrOutputDirectory : path.join(publicDirectory, buildDirectory)),
+                    manifest: userConfig.build?.manifest ?? (isSsrBuild ? false : 'manifest.json'),
+                    ssrManifest: userConfig.build?.ssrManifest ?? (isSsrBuild ? 'ssr-manifest.json' : false),
+                    outDir: userConfig.build?.outDir ?? (isSsrBuild ? ssrOutDir : path.join(publicDir, buildDir)),
                     rollupOptions: {
-                        input: userConfig.build?.rollupOptions?.input ?? (ssr ? resolvedSsr : resolvedInput),
+                        input: userConfig.build?.rollupOptions?.input ?? (isSsrBuild ? resolvedSsr : resolvedInput),
                     },
                     assetsInlineLimit: userConfig.build?.assetsInlineLimit ?? 0,
                 },
@@ -44,15 +47,7 @@ export default function rails(options = {}) {
                     },
                 },
                 resolve: {
-                    alias: Array.isArray(userConfig.resolve?.alias)
-                        ? [
-                            ...(userConfig.resolve?.alias ?? []),
-                            { find: '@', replacement: path.resolve(process.cwd(), sourceDir) },
-                        ]
-                        : {
-                            '@': path.resolve(process.cwd(), sourceDir),
-                            ...userConfig.resolve?.alias,
-                        },
+                    alias: resolveAlias(userConfig.resolve?.alias, sourceDir),
                 },
                 ssr: {
                     noExternal: resolveNoExternal(userConfig),
@@ -67,7 +62,7 @@ export default function rails(options = {}) {
             if (resolvedConfig.build.ssr)
                 return;
             const outDir = resolvedConfig.build.outDir;
-            fs.writeFileSync(path.join(outDir, 'rails-vite.json'), JSON.stringify({ sourceDir }));
+            fs.writeFileSync(path.join(outDir, 'rails-vite.json'), JSON.stringify(entrypointsDir ? { sourceDir, entrypointsDir } : { sourceDir }));
         },
         configureServer(server) {
             server.httpServer?.once('listening', () => {
@@ -76,6 +71,8 @@ export default function rails(options = {}) {
                     const devServerUrl = resolveDevServerUrl(address, resolvedConfig);
                     resolvedConfig.server.origin = devServerUrl;
                     const meta = { url: devServerUrl, sourceDir };
+                    if (entrypointsDir)
+                        meta.entrypointsDir = entrypointsDir;
                     if (reactRefresh)
                         meta.reactRefresh = true;
                     fs.writeFileSync(devMetaPath, JSON.stringify(meta));
@@ -84,16 +81,9 @@ export default function rails(options = {}) {
                     }, 100);
                 }
             });
-            if (!exitHandlersBound) {
-                const clean = () => {
-                    fs.rmSync(devMetaPath, { force: true });
-                };
-                process.on('exit', clean);
-                process.on('SIGINT', () => process.exit());
-                process.on('SIGTERM', () => process.exit());
-                process.on('SIGHUP', () => process.exit());
-                exitHandlersBound = true;
-            }
+            bindExitHandler(() => {
+                fs.rmSync(devMetaPath, { force: true });
+            });
             // Watch view templates for full-page reload
             const resolvedRefreshPaths = resolveRefreshPaths(options.refresh);
             if (resolvedRefreshPaths.length) {
@@ -102,12 +92,11 @@ export default function rails(options = {}) {
                 server.watcher.on('change', (filePath) => {
                     const relativePath = path.relative(process.cwd(), filePath);
                     if (match(relativePath)) {
-                        server.ws.send({ type: 'full-reload', path: '*' });
+                        server.hot.send({ type: 'full-reload', path: '*' });
                     }
                 });
             }
-            // Serve a helpful page at the dev server root
-            const devServerIndexHtml = fs.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'dev-server-index.html'), 'utf-8');
+            const devServerIndexHtml = readDevServerIndexHtml();
             return () => server.middlewares.use((req, res, next) => {
                 if (req.url === '/index.html') {
                     res.statusCode = 404;
@@ -119,100 +108,3 @@ export default function rails(options = {}) {
         },
     };
 }
-function resolveInput(input, sourceDir) {
-    if (typeof input === 'object' && !Array.isArray(input)) {
-        return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, prefixWithSourceDir(value, sourceDir)]));
-    }
-    if (Array.isArray(input)) {
-        return input.map((entry) => prefixWithSourceDir(entry, sourceDir));
-    }
-    return prefixWithSourceDir(input, sourceDir);
-}
-function prefixWithSourceDir(entry, sourceDir) {
-    if (entry.startsWith(sourceDir + '/') || entry.startsWith('/')) {
-        return entry;
-    }
-    return `${sourceDir}/${entry}`;
-}
-const entrypointExtensions = /\.(mjs|js|mts|ts|jsx|tsx|css|scss|sass|less|styl|pcss)$/;
-function detectEntrypoint(sourceDir) {
-    const entrypointsDir = path.join(sourceDir, 'entrypoints');
-    if (fs.existsSync(entrypointsDir)) {
-        return discoverEntrypoints(entrypointsDir).map((entry) => `entrypoints/${entry}`);
-    }
-    for (const ext of ['.js', '.mjs', '.ts', '.mts', '.jsx', '.tsx']) {
-        const candidate = path.join(sourceDir, `application${ext}`);
-        if (fs.existsSync(candidate)) {
-            return `application${ext}`;
-        }
-    }
-    return 'application.js';
-}
-function discoverEntrypoints(dir, base = dir) {
-    const entries = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        if (entry.isDirectory()) {
-            entries.push(...discoverEntrypoints(path.join(dir, entry.name), base));
-        }
-        else if (entrypointExtensions.test(entry.name)) {
-            entries.push(path.relative(base, path.join(dir, entry.name)));
-        }
-    }
-    return entries;
-}
-function resolveRefreshPaths(refresh) {
-    if (refresh === false)
-        return [];
-    if (!refresh || refresh === true)
-        return refreshPaths;
-    if (typeof refresh === 'string')
-        return [refresh];
-    return refresh;
-}
-function resolveDevServerUrl(address, config) {
-    const hmr = typeof config.server.hmr === 'object' ? config.server.hmr : null;
-    const clientProtocol = hmr?.protocol
-        ? hmr.protocol === 'wss'
-            ? 'https'
-            : 'http'
-        : null;
-    const serverProtocol = config.server.https ? 'https' : 'http';
-    const protocol = clientProtocol ?? serverProtocol;
-    const configHost = typeof config.server.host === 'string' ? config.server.host : null;
-    const serverAddress = address.family === 'IPv6' || address.family === 6
-        ? `[${address.address}]`
-        : address.address;
-    const host = hmr?.host ?? configHost ?? serverAddress;
-    const port = hmr?.clientPort ?? address.port;
-    return `${protocol}://${host}:${port}`;
-}
-function isAddressInfo(x) {
-    return typeof x === 'object' && x !== null;
-}
-function ensureCommandShouldRunInEnvironment(command, env) {
-    if (command === 'build') {
-        return;
-    }
-    if (env.CI !== undefined) {
-        throw new Error('rails-vite-plugin: You should not run the Vite dev server in CI. ' +
-            'Run `rake vite:build` instead.');
-    }
-    if (env.RAILS_ENV === 'production') {
-        throw new Error('rails-vite-plugin: You should not run the Vite dev server in production. ' +
-            'Run `rake vite:build` instead.');
-    }
-}
-function resolveNoExternal(config) {
-    const userNoExternal = config.ssr?.noExternal;
-    const pluginNoExternal = ['rails-vite-plugin'];
-    if (userNoExternal === true) {
-        return true;
-    }
-    if (userNoExternal === undefined) {
-        return pluginNoExternal;
-    }
-    return [
-        ...(Array.isArray(userNoExternal) ? userNoExternal : [userNoExternal]),
-        ...pluginNoExternal,
-    ];
-}

package/dist/jsbundling.d.ts

@@ -0,0 +1,27 @@
+import { Plugin } from 'vite';
+import type { InputOption } from './shared/types.js';
+import { refreshPaths } from './shared/refresh.js';
+export type { InputOption };
+export { refreshPaths };
+export interface JsbundlingOptions {
+    input?: InputOption;
+    sourceDir?: string;
+    /** Directory where Propshaft/Sprockets picks up entry files for Rails helpers.
+     *  Default: 'app/assets/builds' */
+    assetPipelineDir?: string;
+    /** Public directory for the full Vite build output (chunks, assets).
+     *  Default: 'public/assets' */
+    outputDir?: string;
+    /** SSR entry point for Inertia server-side rendering.
+     *  String is a path relative to sourceDir (e.g., 'ssr/ssr.tsx').
+     *  Object form allows customizing the output directory. */
+    ssr?: string | {
+        entry: string;
+        outDir?: string;
+    };
+    refresh?: boolean | string | string[];
+    /** Path to write dev server metadata JSON (default: 'tmp/rails-vite.json').
+     *  Set to false to disable. Useful as a bridge for progressive upgrade to the rails_vite gem. */
+    devMetaFile?: string | false;
+}
+export default function jsbundling(options?: JsbundlingOptions): Plugin;

package/dist/jsbundling.js

@@ -0,0 +1,307 @@
+import fs from 'fs';
+import path from 'path';
+import picomatch from 'picomatch';
+import { loadEnv, defaultAllowedOrigins, } from 'vite';
+import { resolveEntries, entriesToRollupInput, prefixWithSourceDir, detectEntrypointsDir, discoverEntrypointInputs, detectEntrypoint, isEntrypointFile } from './shared/entries.js';
+import { resolveAlias } from './shared/alias.js';
+import { resolveDevServerUrl, isAddressInfo } from './shared/dev-server.js';
+import { ensureCommandShouldRunInEnvironment } from './shared/env-guard.js';
+import { refreshPaths, resolveRefreshPaths } from './shared/refresh.js';
+import { cssExtensions } from './shared/css.js';
+import { readDevServerIndexHtml } from './shared/dev-server-page.js';
+import { resolveNoExternal } from './shared/ssr.js';
+import { bindExitHandler } from './shared/cleanup.js';
+export { refreshPaths };
+const CSS_FACADE_PREFIX = '_css_';
+export default function jsbundling(options = {}) {
+    const sourceDir = options.sourceDir ?? 'app/javascript';
+    const epDir = detectEntrypointsDir(sourceDir);
+    const input = options.input ?? (epDir ? discoverEntrypointInputs(sourceDir, epDir) : detectEntrypoint(sourceDir));
+    const assetPipelineDir = options.assetPipelineDir ?? 'app/assets/builds';
+    const outputDir = options.outputDir ?? 'public/assets';
+    // The URL prefix matching outputDir under public/ — used as Vite's `base` in production
+    // so that dynamic import() URLs resolve to the right place.
+    const buildBase = '/' + path.relative('public', outputDir) + '/';
+    const devMetaPath = options.devMetaFile !== false
+        ? (options.devMetaFile ?? path.join('tmp', 'rails-vite.json'))
+        : null;
+    const entries = resolveEntries(input, sourceDir);
+    const rollupInput = entriesToRollupInput(entries, typeof options.input === 'object' && !Array.isArray(options.input));
+    const ssrConfig = resolveSsrConfig(options.ssr, sourceDir, outputDir);
+    let resolvedConfig;
+    let reactRefresh = false;
+    // Track stubs written in dev so we can clean them up
+    const writtenStubs = [];
+    return {
+        name: 'rails-vite-jsbundling',
+        enforce: 'post',
+        config(userConfig, { command, mode, isSsrBuild }) {
+            const env = loadEnv(mode, userConfig.envDir || process.cwd(), '');
+            ensureCommandShouldRunInEnvironment(command, env, 'rails-vite-plugin/jsbundling');
+            // SSR builds get minimal config — just entry, outDir, base, and alias.
+            // No asset pipeline stubs or client-specific settings.
+            if (isSsrBuild) {
+                return {
+                    base: userConfig.base ?? (command === 'build' ? buildBase : ''),
+                    publicDir: userConfig.publicDir ?? false,
+                    ...(ssrConfig ? {
+                        build: {
+                            ssrManifest: userConfig.build?.ssrManifest ?? 'ssr-manifest.json',
+                            outDir: userConfig.build?.outDir ?? ssrConfig.outDir,
+                            rollupOptions: {
+                                input: userConfig.build?.rollupOptions?.input ?? ssrConfig.entry,
+                            },
+                        },
+                    } : {}),
+                    resolve: {
+                        alias: resolveAlias(userConfig.resolve?.alias, sourceDir),
+                    },
+                    ssr: {
+                        noExternal: resolveNoExternal(userConfig),
+                    },
+                };
+            }
+            // In dev mode, write placeholder stubs immediately so Propshaft/Sprockets
+            // can discover them when Rails boots (both may start concurrently via bin/dev).
+            if (command === 'serve') {
+                writePlaceholderStubs(entries, assetPipelineDir, writtenStubs);
+            }
+            return {
+                base: userConfig.base ?? (command === 'build' ? buildBase : ''),
+                publicDir: userConfig.publicDir ?? false,
+                build: {
+                    manifest: userConfig.build?.manifest ?? false,
+                    outDir: userConfig.build?.outDir ?? outputDir,
+                    rollupOptions: {
+                        input: userConfig.build?.rollupOptions?.input ?? rollupInput,
+                        output: {
+                            entryFileNames: (chunkInfo) => {
+                                if (chunkInfo.facadeModuleId && cssExtensions.test(chunkInfo.facadeModuleId)) {
+                                    return `${CSS_FACADE_PREFIX}[name].js`;
+                                }
+                                return '[name].js';
+                            },
+                            chunkFileNames: '[name]-[hash].js',
+                            assetFileNames: '[name][extname]',
+                        },
+                    },
+                    assetsInlineLimit: userConfig.build?.assetsInlineLimit ?? 0,
+                    cssCodeSplit: true,
+                },
+                server: {
+                    cors: userConfig.server?.cors ?? {
+                        origin: userConfig.server?.origin ?? defaultAllowedOrigins,
+                    },
+                },
+                resolve: {
+                    alias: resolveAlias(userConfig.resolve?.alias, sourceDir),
+                },
+                ssr: {
+                    noExternal: resolveNoExternal(userConfig),
+                },
+            };
+        },
+        configResolved(config) {
+            resolvedConfig = config;
+            reactRefresh = config.plugins.some((p) => p.name === 'vite:react-babel' || p.name === 'vite:react-swc');
+        },
+        generateBundle(_, bundle) {
+            // Rollup wraps CSS entries in empty JS facade chunks. Delete them —
+            // the real CSS is emitted as an asset by Vite's CSS pipeline.
+            for (const fileName of Object.keys(bundle)) {
+                if (fileName.startsWith(CSS_FACADE_PREFIX)) {
+                    delete bundle[fileName];
+                }
+            }
+        },
+        writeBundle(_, bundle) {
+            // 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) {
+                    const src = path.join(outDir, fileName);
+                    const dest = path.join(assetPipelineDir, fileName);
+                    fs.mkdirSync(path.dirname(dest), { recursive: true });
+                    fs.copyFileSync(src, dest);
+                }
+            }
+        },
+        configureServer(server) {
+            let devServerUrl = null;
+            let syncTimer = null;
+            // Re-discover entries from the entrypoints dir and regenerate all stubs.
+            // Called on initial listen and whenever entrypoint files are added/removed.
+            const syncStubs = () => {
+                if (!devServerUrl)
+                    return;
+                const freshInput = epDir ? discoverEntrypointInputs(sourceDir, epDir) : input;
+                const freshEntries = resolveEntries(freshInput, sourceDir);
+                // Clear old stubs
+                for (const stub of writtenStubs) {
+                    fs.rmSync(stub, { force: true });
+                }
+                writtenStubs.length = 0;
+                writeDevStubs(freshEntries, assetPipelineDir, devServerUrl, reactRefresh, writtenStubs);
+            };
+            // Debounced version for watcher events — collapses burst operations
+            // (e.g., pasting multiple files, git checkout) into a single rescan.
+            const debouncedSyncStubs = () => {
+                if (syncTimer)
+                    clearTimeout(syncTimer);
+                syncTimer = setTimeout(syncStubs, 100);
+            };
+            server.httpServer?.once('listening', () => {
+                const address = server.httpServer?.address();
+                if (isAddressInfo(address)) {
+                    devServerUrl = resolveDevServerUrl(address, resolvedConfig);
+                    syncStubs();
+                    // Write dev meta file for progressive upgrade to the rails_vite gem
+                    if (devMetaPath) {
+                        const meta = { url: devServerUrl, sourceDir };
+                        if (epDir)
+                            meta.entrypointsDir = epDir;
+                        if (reactRefresh)
+                            meta.reactRefresh = true;
+                        meta.jsbundling = true;
+                        fs.mkdirSync(path.dirname(devMetaPath), { recursive: true });
+                        fs.writeFileSync(devMetaPath, JSON.stringify(meta));
+                    }
+                    // Watch entrypoints dir for new/removed files and regenerate stubs
+                    if (epDir) {
+                        const epAbsDir = path.resolve(sourceDir, epDir);
+                        server.watcher.add(epAbsDir);
+                        const epAbsDirPrefix = epAbsDir + '/';
+                        server.watcher.on('add', (filePath) => {
+                            if (filePath.startsWith(epAbsDirPrefix) && isEntrypointFile(filePath)) {
+                                server.config.logger.info(`  RAILS  new entrypoint: ${path.relative(sourceDir, filePath)}`);
+                                debouncedSyncStubs();
+                            }
+                        });
+                        server.watcher.on('unlink', (filePath) => {
+                            if (filePath.startsWith(epAbsDirPrefix) && isEntrypointFile(filePath)) {
+                                server.config.logger.info(`  RAILS  removed entrypoint: ${path.relative(sourceDir, filePath)}`);
+                                debouncedSyncStubs();
+                            }
+                        });
+                    }
+                    server.config.logger.info(`\n  RAILS  rails-vite-plugin/jsbundling → ${assetPipelineDir}`);
+                }
+            });
+            bindExitHandler(() => {
+                for (const stub of writtenStubs) {
+                    fs.rmSync(stub, { force: true });
+                }
+                writtenStubs.length = 0;
+                if (devMetaPath) {
+                    fs.rmSync(devMetaPath, { force: true });
+                }
+            });
+            // Watch view templates for full-page reload
+            const resolvedRefreshPaths = resolveRefreshPaths(options.refresh);
+            if (resolvedRefreshPaths.length) {
+                const match = picomatch(resolvedRefreshPaths);
+                server.watcher.add(resolvedRefreshPaths);
+                server.watcher.on('change', (filePath) => {
+                    const relativePath = path.relative(process.cwd(), filePath);
+                    if (match(relativePath)) {
+                        server.hot.send({ type: 'full-reload', path: '*' });
+                    }
+                });
+            }
+            const devServerIndexHtml = readDevServerIndexHtml();
+            return () => server.middlewares.use((req, res, next) => {
+                if (req.url === '/index.html') {
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'text/html');
+                    res.end(devServerIndexHtml);
+                    return;
+                }
+                next();
+            });
+        },
+    };
+}
+function resolveSsrConfig(ssr, sourceDir, outputDir) {
+    if (!ssr)
+        return null;
+    const entry = typeof ssr === 'string' ? ssr : ssr.entry;
+    const outDir = (typeof ssr === 'object' ? ssr.outDir : undefined) ?? outputDir + '-ssr';
+    return {
+        entry: prefixWithSourceDir(entry, sourceDir),
+        outDir,
+    };
+}
+/**
+ * Write placeholder stubs so Propshaft/Sprockets can discover asset files
+ * at boot time, before the Vite dev server is ready with its URL.
+ * Writes unconditionally — stubs are overwritten by writeDevStubs once the server is listening.
+ */
+function writePlaceholderStubs(entries, outDir, writtenStubs) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const seen = new Set();
+    for (const { name } of entries) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const jsStub = path.join(outDir, `${name}.js`);
+        fs.mkdirSync(path.dirname(jsStub), { recursive: true });
+        fs.writeFileSync(jsStub, '// rails-vite placeholder – loading…\n');
+        writtenStubs.push(jsStub);
+        const cssStub = path.join(outDir, `${name}.css`);
+        fs.writeFileSync(cssStub, '/* rails-vite placeholder – loading… */\n');
+        writtenStubs.push(cssStub);
+    }
+}
+function writeDevStubs(entries, outDir, devServerUrl, reactRefresh, writtenStubs) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const importLine = (url) => reactRefresh ? `await import("${url}");` : `import "${url}";`;
+    const jsEntries = entries.filter(e => !cssExtensions.test(e.sourcePath));
+    const cssEntries = entries.filter(e => cssExtensions.test(e.sourcePath));
+    // JS stubs: import @vite/client + all CSS entries (for HMR) + the JS entry itself.
+    for (const { name, sourcePath } of jsEntries) {
+        const stubPath = path.join(outDir, `${name}.js`);
+        fs.mkdirSync(path.dirname(stubPath), { recursive: true });
+        const lines = ['// rails-vite dev stub – DO NOT EDIT'];
+        if (reactRefresh) {
+            // Static import for the refresh runtime — just exports a function, safe to hoist.
+            // Everything else uses dynamic import() so the preamble executes first
+            // (static imports hoist, so injectIntoGlobalHook would run after all modules).
+            lines.push(`import { injectIntoGlobalHook } from "${devServerUrl}/@react-refresh";`);
+            lines.push('injectIntoGlobalHook(window);');
+            lines.push('window.$RefreshReg$ = () => {};');
+            lines.push('window.$RefreshSig$ = () => (type) => type;');
+        }
+        lines.push(importLine(`${devServerUrl}/@vite/client`));
+        // Import CSS entries so Vite's module graph tracks them for HMR
+        for (const { sourcePath: cssPath } of cssEntries) {
+            lines.push(importLine(`${devServerUrl}/${cssPath}`));
+        }
+        lines.push(importLine(`${devServerUrl}/${sourcePath}`));
+        fs.writeFileSync(stubPath, lines.join('\n') + '\n');
+        writtenStubs.push(stubPath);
+    }
+    // Empty CSS stubs so stylesheet_link_tag doesn't error.
+    // Actual CSS is injected by @vite/client through the JS imports above.
+    const seen = new Set();
+    for (const { name } of entries) {
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        const cssStubPath = path.join(outDir, `${name}.css`);
+        fs.mkdirSync(path.dirname(cssStubPath), { recursive: true });
+        fs.writeFileSync(cssStubPath, '/* rails-vite dev stub */\n');
+        writtenStubs.push(cssStubPath);
+    }
+}

package/dist/shared/alias.d.ts

@@ -0,0 +1,2 @@
+import type { AliasOptions } from 'vite';
+export declare function resolveAlias(userAlias: AliasOptions | undefined, sourceDir: string): AliasOptions;

package/dist/shared/alias.js

@@ -0,0 +1,12 @@
+import path from 'path';
+export function resolveAlias(userAlias, sourceDir) {
+    const atReplacement = path.resolve(process.cwd(), sourceDir);
+    if (Array.isArray(userAlias)) {
+        const hasAt = userAlias.some(a => a.find === '@');
+        return hasAt ? userAlias : [...userAlias, { find: '@', replacement: atReplacement }];
+    }
+    return {
+        '@': atReplacement,
+        ...userAlias,
+    };
+}

package/dist/shared/cleanup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a cleanup function that runs on process exit.
+ * Signal handlers are only registered once per process to avoid duplicates.
+ */
+export declare function bindExitHandler(cleanupFn: () => void): void;

package/dist/shared/cleanup.js

@@ -0,0 +1,14 @@
+let exitHandlersBound = false;
+/**
+ * Register a cleanup function that runs on process exit.
+ * Signal handlers are only registered once per process to avoid duplicates.
+ */
+export function bindExitHandler(cleanupFn) {
+    process.on('exit', cleanupFn);
+    if (!exitHandlersBound) {
+        process.on('SIGINT', () => process.exit());
+        process.on('SIGTERM', () => process.exit());
+        process.on('SIGHUP', () => process.exit());
+        exitHandlersBound = true;
+    }
+}

package/dist/shared/css.d.ts

@@ -0,0 +1,2 @@
+export declare const cssExtensionList: string[];
+export declare const cssExtensions: RegExp;

package/dist/shared/css.js

@@ -0,0 +1,2 @@
+export const cssExtensionList = ['css', 'scss', 'sass', 'less', 'styl', 'pcss'];
+export const cssExtensions = new RegExp(`\\.(${cssExtensionList.join('|')})$`);

package/dist/shared/dev-server-page.d.ts

@@ -0,0 +1 @@
+export declare function readDevServerIndexHtml(): string;

package/dist/shared/dev-server-page.js

@@ -0,0 +1,6 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+export function readDevServerIndexHtml() {
+    return fs.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'dev-server-index.html'), 'utf-8');
+}

package/dist/shared/dev-server.d.ts

@@ -0,0 +1,5 @@
+import { AddressInfo } from 'net';
+import type { ResolvedConfig } from 'vite';
+import type { DevServerUrl } from './types.js';
+export declare function resolveDevServerUrl(address: AddressInfo, config: ResolvedConfig): DevServerUrl;
+export declare function isAddressInfo(x: string | AddressInfo | null | undefined): x is AddressInfo;

package/dist/shared/dev-server.js

@@ -0,0 +1,20 @@
+export function resolveDevServerUrl(address, config) {
+    const hmr = typeof config.server.hmr === 'object' ? config.server.hmr : null;
+    const clientProtocol = hmr?.protocol
+        ? hmr.protocol === 'wss'
+            ? 'https'
+            : 'http'
+        : null;
+    const serverProtocol = config.server.https ? 'https' : 'http';
+    const protocol = clientProtocol ?? serverProtocol;
+    const configHost = typeof config.server.host === 'string' ? config.server.host : null;
+    const serverAddress = address.family === 'IPv6' || address.family === 6
+        ? `[${address.address}]`
+        : address.address;
+    const host = hmr?.host ?? configHost ?? serverAddress;
+    const port = hmr?.clientPort ?? address.port;
+    return `${protocol}://${host}:${port}`;
+}
+export function isAddressInfo(x) {
+    return typeof x === 'object' && x !== null;
+}

package/dist/shared/entries.d.ts

@@ -0,0 +1,13 @@
+import type { InputOption, ResolvedEntry } from './types.js';
+export declare function isEntrypointFile(filePath: string): boolean;
+export declare function resolveEntries(input: InputOption, sourceDir: string): ResolvedEntry[];
+/**
+ * Convert resolved entries to Rollup-compatible input.
+ * Array form for string/array inputs; object form preserves explicit user names.
+ */
+export declare function entriesToRollupInput(entries: ResolvedEntry[], isNamedInput: boolean): InputOption;
+export declare function resolveInput(input: InputOption, sourceDir: string): InputOption;
+export declare function prefixWithSourceDir(entry: string, sourceDir: string): string;
+export declare function detectEntrypointsDir(sourceDir: string): string | null;
+export declare function discoverEntrypointInputs(sourceDir: string, entrypointsDir: string): string[];
+export declare function detectEntrypoint(sourceDir: string): string;

package/dist/shared/entries.js

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import path from 'path';
+import { cssExtensionList } from './css.js';
+const jsExtensions = ['mjs', 'js', 'mts', 'ts', 'jsx', 'tsx'];
+const entrypointExtensions = new RegExp(`\\.(${[...jsExtensions, ...cssExtensionList].join('|')})$`);
+export function isEntrypointFile(filePath) {
+    return entrypointExtensions.test(filePath);
+}
+export function resolveEntries(input, sourceDir) {
+    if (typeof input === 'object' && !Array.isArray(input)) {
+        return Object.entries(input).map(([name, value]) => ({
+            name,
+            sourcePath: prefixWithSourceDir(value, sourceDir),
+        }));
+    }
+    const inputs = Array.isArray(input) ? input : [input];
+    const sourcePaths = inputs.map(entry => prefixWithSourceDir(entry, sourceDir));
+    const commonPrefix = detectCommonEntryPrefix(sourcePaths, sourceDir);
+    return sourcePaths.map(sourcePath => ({
+        name: entrypointName(sourcePath, sourceDir, commonPrefix),
+        sourcePath,
+    }));
+}
+/**
+ * Convert resolved entries to Rollup-compatible input.
+ * Array form for string/array inputs; object form preserves explicit user names.
+ */
+export function entriesToRollupInput(entries, isNamedInput) {
+    if (isNamedInput) {
+        return Object.fromEntries(entries.map(e => [e.name, e.sourcePath]));
+    }
+    if (entries.length === 1)
+        return entries[0].sourcePath;
+    return entries.map(e => e.sourcePath);
+}
+export function resolveInput(input, sourceDir) {
+    if (typeof input === 'object' && !Array.isArray(input)) {
+        return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, prefixWithSourceDir(value, sourceDir)]));
+    }
+    if (Array.isArray(input)) {
+        return input.map((entry) => prefixWithSourceDir(entry, sourceDir));
+    }
+    return prefixWithSourceDir(input, sourceDir);
+}
+export function prefixWithSourceDir(entry, sourceDir) {
+    if (entry.startsWith(sourceDir + '/') || entry.startsWith('/')) {
+        return entry;
+    }
+    return `${sourceDir}/${entry}`;
+}
+export function detectEntrypointsDir(sourceDir) {
+    const entrypointsDir = path.join(sourceDir, 'entrypoints');
+    return fs.existsSync(entrypointsDir) ? 'entrypoints' : null;
+}
+export function discoverEntrypointInputs(sourceDir, entrypointsDir) {
+    const absDir = path.join(sourceDir, entrypointsDir);
+    return discoverEntrypoints(absDir).map((entry) => `${entrypointsDir}/${entry}`);
+}
+export function detectEntrypoint(sourceDir) {
+    for (const ext of ['.js', '.mjs', '.ts', '.mts', '.jsx', '.tsx']) {
+        const candidate = path.join(sourceDir, `application${ext}`);
+        if (fs.existsSync(candidate)) {
+            return `application${ext}`;
+        }
+    }
+    return 'application.js';
+}
+function discoverEntrypoints(dir, base = dir) {
+    const entries = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            entries.push(...discoverEntrypoints(path.join(dir, entry.name), base));
+        }
+        else if (entrypointExtensions.test(entry.name)) {
+            entries.push(path.relative(base, path.join(dir, entry.name)));
+        }
+    }
+    return entries;
+}
+function entrypointName(sourcePath, sourceDir, commonPrefix) {
+    let name = sourcePath;
+    if (name.startsWith(sourceDir + '/')) {
+        name = name.slice(sourceDir.length + 1);
+    }
+    if (commonPrefix && name.startsWith(commonPrefix + '/')) {
+        name = name.slice(commonPrefix.length + 1);
+    }
+    return name.replace(/\.[^.]+$/, '');
+}
+/**
+ * Detect the common directory prefix among all input entries (after stripping sourceDir).
+ * This mirrors how Rollup computes entry chunk names and ensures dev stubs match build output.
+ */
+function detectCommonEntryPrefix(sourcePaths, sourceDir) {
+    if (sourcePaths.length === 0)
+        return null;
+    const dirs = sourcePaths.map((entry) => {
+        let name = entry;
+        if (name.startsWith(sourceDir + '/')) {
+            name = name.slice(sourceDir.length + 1);
+        }
+        const dir = path.dirname(name);
+        return dir === '.' ? '' : dir;
+    });
+    const first = dirs[0];
+    if (!first)
+        return null;
+    if (dirs.every((d) => d === first || d.startsWith(first + '/'))) {
+        return first;
+    }
+    const parts = first.split('/');
+    let common = '';
+    for (const part of parts) {
+        const candidate = common ? `${common}/${part}` : part;
+        if (dirs.every((d) => d === candidate || d.startsWith(candidate + '/'))) {
+            common = candidate;
+        }
+        else {
+            break;
+        }
+    }
+    return common || null;
+}

package/dist/shared/env-guard.d.ts

@@ -0,0 +1 @@
+export declare function ensureCommandShouldRunInEnvironment(command: string, env: Record<string, string>, pluginName: string): void;

package/dist/shared/env-guard.js

@@ -0,0 +1,13 @@
+export function ensureCommandShouldRunInEnvironment(command, env, pluginName) {
+    if (command === 'build') {
+        return;
+    }
+    if (env.CI !== undefined) {
+        throw new Error(`${pluginName}: You should not run the Vite dev server in CI. ` +
+            'Run the build command instead.');
+    }
+    if (env.RAILS_ENV === 'production') {
+        throw new Error(`${pluginName}: You should not run the Vite dev server in production. ` +
+            'Run the build command instead.');
+    }
+}

package/dist/shared/refresh.d.ts

@@ -0,0 +1,2 @@
+export declare const refreshPaths: string[];
+export declare function resolveRefreshPaths(refresh: boolean | string | string[] | undefined): string[];

package/dist/shared/refresh.js

@@ -0,0 +1,13 @@
+export const refreshPaths = [
+    'app/views/**/*.{erb,slim,haml}',
+    'app/helpers/**/*.rb',
+];
+export function resolveRefreshPaths(refresh) {
+    if (refresh === false)
+        return [];
+    if (!refresh || refresh === true)
+        return refreshPaths;
+    if (typeof refresh === 'string')
+        return [refresh];
+    return refresh;
+}

package/dist/shared/ssr.d.ts

@@ -0,0 +1,2 @@
+import type { UserConfig } from 'vite';
+export declare function resolveNoExternal(config: UserConfig): true | Array<string | RegExp>;

package/dist/shared/ssr.js

@@ -0,0 +1,14 @@
+export function resolveNoExternal(config) {
+    const userNoExternal = config.ssr?.noExternal;
+    const pluginNoExternal = ['rails-vite-plugin'];
+    if (userNoExternal === true) {
+        return true;
+    }
+    if (userNoExternal === undefined) {
+        return pluginNoExternal;
+    }
+    return [
+        ...(Array.isArray(userNoExternal) ? userNoExternal : [userNoExternal]),
+        ...pluginNoExternal,
+    ];
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,8 @@
+export type InputOption = string | string[] | Record<string, string>;
+export type DevServerUrl = `${'http' | 'https'}://${string}:${number}`;
+export interface ResolvedEntry {
+    /** Output name (e.g., 'application', 'admin/index') */
+    name: string;
+    /** Full path relative to project root */
+    sourcePath: string;
+}

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rails-vite-plugin",
-  "version": "0.1.1",
+  "version": "0.2.0-beta.1",
   "description": "Vite plugin for Rails integration",
   "author": "Svyatoslav Kryukov <me@skryukov.dev>",
   "license": "MIT",
@@ -11,6 +11,10 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./jsbundling": {
+      "import": "./dist/jsbundling.js",
+      "types": "./dist/jsbundling.d.ts"
     }
   },
   "files": [
@@ -43,6 +47,8 @@
   "keywords": [
     "vite",
     "rails",
+    "jsbundling",
+    "jsbundling-rails",
     "vite-plugin"
   ],
   "homepage": "https://github.com/skryukov/rails_vite",