vite-plugin-rebundle 1.2.16 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-rebundle",
-  "version": "1.2.16",
+  "version": "1.3.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,24 +10,22 @@
     "vite-plugin"
   ],
   "scripts": {
-    "dev": "rm -rf dist && tsc --watch",
-    "build": "rm -rf dist && tsc",
     "lint": "tsc --noEmit",
-    "release": "sh -c 'npm version ${1:-patch} && npm run build && npm publish' --"
+    "release": "sh -c 'npm version ${1:-patch} && npm publish' --"
   },
   "exports": {
-    "import": "./dist/index.js"
+    "import": "./src/index.ts"
   },
   "files": [
-    "dist"
+    "src"
   ],
   "dependencies": {
     "@eposlabs/utils": "^1.0.13",
     "@types/ws": "^8.18.1",
     "chalk": "^5.6.2",
-    "esbuild": "^0.25.9",
     "filesize": "^11.0.2",
     "portfinder": "^1.0.38",
+    "rolldown": "^1.0.0-beta.40",
     "rollup": "^4.50.1",
     "vite": "^7.1.5",
     "ws": "^8.18.3"

package/readme.md

@@ -4,7 +4,7 @@ A Vite plugin that guarantees **one standalone file per entry point**. Each entr
 
 ## Why?
 
-Sometimes you need bundles without dynamic imports. Vite/Rollup don’t provide this option when building with multiple entries. This plugin solves it by rebundling Vite’s output with esbuild to enforce single-file output.
+Sometimes you need bundles without dynamic imports. Vite/Rollup don’t provide this option when building with multiple entries. This plugin solves it by rebundling Vite’s output with rolldown to enforce single-file output.
 
 > ⚠️ This plugin runs **only during** `vite build`. It does not affect the Vite dev server.
 
@@ -38,21 +38,18 @@ export default defineConfig({
 
 ## Options
 
-You can provide **esbuild options per entry point**. This is useful, for example, to inject custom define variables into specific bundles:
+You can provide **rolldown options per entry point**. This is useful, for example, to inject custom define variables into specific bundles:
 
 ```javascript
 export default defineConfig({
   plugins: [
     rebundle({
       app: {
-        define: {
-          BUNDLE_NAME: JSON.stringify('app'),
-        },
+        output: { define: { BUNDLE_NAME: JSON.stringify('app') } },
       },
       libs: {
-        define: {
-          BUNDLE_NAME: JSON.stringify('libs'),
-        },
+        input: { keepNames: true },
+        output: { define: { BUNDLE_NAME: JSON.stringify('libs') } },
       },
     }),
   ],
@@ -73,10 +70,10 @@ export default defineConfig({
 ## How it works
 
 When you run `vite build`, Rollup normally outputs multiple chunks per entry if code-splitting is needed.
-`vite-plugin-rebundle` hooks into the build and **rebundles each entry’s output with esbuild**, forcing a single self-contained file per entry.
+`vite-plugin-rebundle` hooks into the build and **rebundles each entry’s output with rolldown**, forcing a single self-contained file per entry.
 
-- Rollup still handles the initial build (tree-shaking, asset pipeline, etc.).
-- Afterward, each entry is passed through esbuild.
+- Vite still handles the initial build (tree-shaking, asset pipeline, etc.).
+- Afterward, each entry is passed through rolldown.
 - The final result is one .js file per entry with no dynamic imports or shared chunks.
 - If sourcemaps are enabled, they are preserved — the rebundled files include correct mappings.
 

package/src/index.ts

@@ -0,0 +1,9 @@
+import { Rebundle, type Options } from './rebundle.ts'
+
+export type RebundleOptions = Options[string]
+
+export function rebundle(options: Options = {}) {
+  return new Rebundle(options).vite
+}
+
+export default rebundle

package/src/rebundle.ts

@@ -0,0 +1,236 @@
+import { safe, Unit } from '@eposlabs/utils'
+import chalk from 'chalk'
+import { filesize } from 'filesize'
+import { readdir, readFile, rmdir, stat, unlink, writeFile } from 'node:fs/promises'
+import { dirname, extname, join } from 'node:path'
+import { getPort } from 'portfinder'
+import { rolldown, type InputOptions, type OutputOptions } from 'rolldown'
+import type { NormalizedOutputOptions, OutputBundle, OutputChunk } from 'rollup'
+import type { Plugin, ResolvedConfig } from 'vite'
+import { WebSocketServer } from 'ws'
+
+export const _code_ = Symbol('rebundle:code')
+export const _sourcemap_ = Symbol('rebundle:sourcemap')
+
+export type Options = {
+  [bundleName: string]: {
+    input: InputOptions
+    output: OutputOptions
+  }
+}
+
+export class Rebundle extends Unit {
+  private options: Options
+  private config: ResolvedConfig | null = null
+  private originalFiles: Record<string, string> = {}
+  private rebundledFiles: Record<string, string> = {}
+  private hasError = false
+  private port: number | null = null
+  private ws: WebSocketServer | null = null
+
+  constructor(options: Options) {
+    super()
+    this.options = options
+  }
+
+  get vite(): Plugin {
+    return {
+      name: 'vite-plugin-rebundle',
+      apply: 'build',
+      enforce: 'post',
+      config: this.onConfig,
+      configResolved: this.onConfigResolved,
+      buildEnd: this.onBuildEnd,
+      writeBundle: this.onWriteBundle,
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // VITE HOOKS
+  // ---------------------------------------------------------------------------
+
+  private onConfig = async () => {
+    this.port = await getPort({ port: 3100 })
+    return {
+      define: {
+        'import.meta.env.REBUNDLE_PORT': JSON.stringify(this.port),
+      },
+    }
+  }
+
+  private onConfigResolved = async (config: ResolvedConfig) => {
+    // Save resolved config
+    this.config = config
+
+    // Hide js files from output logs (rollup only, not supported in rolldown)
+    const info = this.config.logger.info
+    this.config.logger.info = (message, options) => {
+      const path = message.split(/\s+/)[0]
+      if (extname(path) === '.js') return
+      info(message, options)
+    }
+  }
+
+  private onBuildEnd = (error?: Error) => {
+    this.hasError = !!error
+  }
+
+  private onWriteBundle = async (_output: NormalizedOutputOptions, bundle: OutputBundle) => {
+    if (this.hasError) return
+    if (!this.config) throw this.never
+
+    const chunks = Object.values(bundle).filter(chunkOrAsset => chunkOrAsset.type === 'chunk')
+    const entryChunks = chunks.filter(chunk => chunk.isEntry)
+    const nonEntryChunks = chunks.filter(chunk => !chunk.isEntry)
+
+    // Rebundle entry chunks
+    const modifiedChunkNames: string[] = []
+    await Promise.all(
+      entryChunks.map(async chunk => {
+        const modified = await this.rebundleChunk(chunk, bundle)
+        if (modified) modifiedChunkNames.push(chunk.name)
+      }),
+    )
+
+    // Remove non-entry chunks
+    for (const chunk of nonEntryChunks) {
+      await this.removeChunk(chunk, bundle)
+    }
+
+    // Notify about modified chunks
+    if (this.config.build.watch && modifiedChunkNames.length > 0) {
+      const ws = await this.ensureWs()
+      ws.clients.forEach(client => client.send(JSON.stringify(modifiedChunkNames)))
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // CHUNK METHODS
+  // ---------------------------------------------------------------------------
+
+  async rebundleChunk(chunk: OutputChunk, bundle: OutputBundle) {
+    if (!this.config) throw this.never
+
+    // Delete chunk from bundle to hide log for rolldown-vite. Call for rollup for consistency.
+    delete bundle[chunk.fileName]
+
+    const chunkPath = join(this.dist, chunk.fileName)
+    const chunkOptions = this.options[chunk.name] ?? {}
+
+    // Read chunk files, save their content
+    const chunkFiles = await this.readChunkFiles(chunk)
+
+    // Check if chunk was modified
+    const chunkFilePaths = Object.keys(chunkFiles)
+    const chunkModified = chunkFilePaths.some(path => chunkFiles[path] !== this.originalFiles[path])
+
+    // Chunk was not modified? -> Use previous content
+    if (!chunkModified) {
+      // Overwrite vite's output with previously rebundled code
+      const code = this.rebundledFiles[chunk.fileName]
+      await this.writeToDist(chunk.fileName, code)
+
+      // Overwrite vite's sourcemap
+      if (chunk.sourcemapFileName) {
+        const sourcemap = this.rebundledFiles[chunk.sourcemapFileName]
+        if (sourcemap) await this.writeToDist(chunk.sourcemapFileName, sourcemap)
+      }
+
+      return false
+    }
+
+    // Build with rolldown
+    try {
+      const build = await rolldown({ ...chunkOptions.input, input: chunkPath })
+      await build.write({ sourcemap: !!this.config.build.sourcemap, ...chunkOptions.output, file: chunkPath })
+    } catch (error) {
+      console.error(error)
+      return
+    }
+
+    // Log successful build
+    const { size } = await stat(chunkPath)
+    const _dist_ = chalk.dim(`${this.dist}/`)
+    const _fileName_ = chalk.cyan(chunk.fileName)
+    const _rebundle_ = chalk.dim.cyan('[rebundle]')
+    const _size_ = chalk.bold.dim(`${filesize(size)}`)
+    console.log(`${_dist_}${_fileName_} ${_rebundle_} ${_size_}`)
+
+    // Save code
+    const code = await this.readFromDist(chunk.fileName)
+    if (!code) throw this.never
+    this.rebundledFiles[chunk.fileName] = code
+
+    // Save sourcemap
+    if (chunk.sourcemapFileName) {
+      const sourcemap = await this.readFromDist(chunk.sourcemapFileName)
+      if (sourcemap) this.rebundledFiles[chunk.sourcemapFileName] = sourcemap
+    }
+
+    return true
+  }
+
+  private async removeChunk(chunk: OutputChunk, bundle: OutputBundle) {
+    await this.removeFromDist(chunk.fileName)
+    delete bundle[chunk.fileName]
+
+    if (chunk.sourcemapFileName) {
+      await this.removeFromDist(chunk.sourcemapFileName)
+      delete bundle[chunk.sourcemapFileName]
+    }
+
+    // Recursively remove containing directory if empty
+    const dir = dirname(join(this.dist, chunk.fileName))
+    await this.removeDirectoryIfEmpty(dir)
+  }
+
+  private async readChunkFiles(chunk: OutputChunk) {
+    const files: Record<string, string> = {}
+    const usedPaths = [chunk.fileName, ...chunk.imports]
+
+    await Promise.all(
+      usedPaths.map(async path => {
+        const content = await this.readFromDist(path)
+        files[path] = content ?? ''
+      }),
+    )
+
+    return files
+  }
+
+  // ---------------------------------------------------------------------------
+  // HELPERS
+  // ---------------------------------------------------------------------------
+
+  private get dist() {
+    if (!this.config) throw this.never
+    return this.config.build.outDir
+  }
+
+  private async readFromDist(path: string) {
+    const [content] = await safe(readFile(join(this.dist, path), 'utf-8'))
+    return content
+  }
+
+  private async writeToDist(path: string, content: string) {
+    await writeFile(join(this.dist, path), content, 'utf-8')
+  }
+
+  private async removeFromDist(path: string) {
+    await safe(unlink(join(this.dist, path)))
+  }
+
+  private async ensureWs() {
+    if (this.ws) return this.ws
+    if (!this.port) throw this.never
+    this.ws = new WebSocketServer({ port: this.port })
+    return this.ws
+  }
+
+  private async removeDirectoryIfEmpty(dir: string) {
+    const files = await readdir(dir)
+    if (files.length > 0) return
+    await rmdir(dir)
+    await this.removeDirectoryIfEmpty(dirname(dir))
+  }
+}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-import { type Options } from './rebundle.js';
-import type { BuildOptions } from 'esbuild';
-export type { BuildOptions };
-export default function rebundle(options?: Options): import("vite").Plugin<any>;
-export { rebundle };

package/dist/index.js

@@ -1,6 +0,0 @@
-import { Rebundle } from './rebundle.js';
-export default function rebundle(options = {}) {
-    const rb = new Rebundle(options);
-    return rb.vite;
-}
-export { rebundle };

package/dist/rebundle.d.ts

@@ -1,34 +0,0 @@
-import * as $utils from '@eposlabs/utils';
-import type { BuildOptions } from 'esbuild';
-import type { OutputBundle, OutputChunk } from 'rollup';
-import type { Plugin } from 'vite';
-export declare const _code_: unique symbol;
-export declare const _sourcemap_: unique symbol;
-export type Options = {
-    [chunkName: string]: BuildOptions;
-};
-export declare class Rebundle extends $utils.Unit {
-    private options;
-    private config;
-    private chunkFiles;
-    private rebundledContent;
-    private hasError;
-    private port;
-    private ws;
-    constructor(options: Options);
-    get vite(): Plugin;
-    private onConfig;
-    private onConfigResolved;
-    private onBuildEnd;
-    private onWriteBundle;
-    rebundleChunk(chunk: OutputChunk, bundle: OutputBundle): Promise<boolean | undefined>;
-    private removeChunk;
-    private readChunkFiles;
-    private get dist();
-    private resolve;
-    private read;
-    private write;
-    private remove;
-    private ensureWs;
-    private removeDirectoryIfEmpty;
-}

package/dist/rebundle.js

@@ -1,213 +0,0 @@
-import * as $utils from '@eposlabs/utils';
-import $chalk from 'chalk';
-import * as $esbuild from 'esbuild';
-import { filesize } from 'filesize';
-import * as $fs from 'node:fs/promises';
-import * as $path from 'node:path';
-import $portfinder from 'portfinder';
-import * as $ws from 'ws';
-export const _code_ = Symbol('rebundle:code');
-export const _sourcemap_ = Symbol('rebundle:sourcemap');
-export class Rebundle extends $utils.Unit {
-    options;
-    config = null;
-    chunkFiles = {};
-    rebundledContent = {};
-    hasError = false;
-    port = null;
-    ws = null;
-    constructor(options) {
-        super();
-        this.options = options;
-    }
-    get vite() {
-        return {
-            name: 'vite-plugin-rebundle',
-            apply: 'build',
-            enforce: 'post',
-            config: this.onConfig,
-            configResolved: this.onConfigResolved,
-            buildEnd: this.onBuildEnd,
-            writeBundle: this.onWriteBundle,
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // VITE HOOKS
-    // ---------------------------------------------------------------------------
-    onConfig = async () => {
-        this.port = await $portfinder.getPort({ port: 3100 });
-        return {
-            define: {
-                'import.meta.env.REBUNDLE_PORT': JSON.stringify(this.port),
-            },
-        };
-    };
-    onConfigResolved = async (config) => {
-        // Save resolved config
-        this.config = config;
-        // Hide js files from output logs (rollup only, not supported in rolldown)
-        const info = this.config.logger.info;
-        this.config.logger.info = (message, options) => {
-            const path = message.split(/\s+/)[0];
-            if ($path.extname(path) === '.js')
-                return;
-            info(message, options);
-        };
-    };
-    onBuildEnd = (error) => {
-        this.hasError = !!error;
-    };
-    onWriteBundle = async (_output, bundle) => {
-        if (this.hasError)
-            return;
-        if (!this.config)
-            throw this.never;
-        const chunks = Object.values(bundle).filter(chunkOrAsset => chunkOrAsset.type === 'chunk');
-        const entryChunks = chunks.filter(chunk => chunk.isEntry);
-        const nonEntryChunks = chunks.filter(chunk => !chunk.isEntry);
-        // Rebundle entry chunks
-        const modifiedChunkNames = [];
-        await Promise.all(entryChunks.map(async (chunk) => {
-            const modified = await this.rebundleChunk(chunk, bundle);
-            if (modified)
-                modifiedChunkNames.push(chunk.name);
-        }));
-        // Remove non-entry chunks
-        for (const chunk of nonEntryChunks) {
-            await this.removeChunk(chunk, bundle);
-        }
-        // Notify about modified chunks
-        if (this.config.build.watch && modifiedChunkNames.length > 0) {
-            const ws = await this.ensureWs();
-            ws.clients.forEach(client => client.send(JSON.stringify(modifiedChunkNames)));
-        }
-    };
-    // ---------------------------------------------------------------------------
-    // CHUNK METHODS
-    // ---------------------------------------------------------------------------
-    async rebundleChunk(chunk, bundle) {
-        if (!this.config)
-            throw this.never;
-        // Delete chunk from bundle to hide log for vite-rolldown.
-        // Call for rollup as well for consistency.
-        delete bundle[chunk.fileName];
-        const chunkPath = this.resolve(chunk.fileName);
-        const chunkBuildOptions = this.options[chunk.name] ?? {};
-        const chunkFiles = await this.readChunkFiles(chunk);
-        const chunkFilePaths = Object.keys(chunkFiles);
-        const chunkChanged = chunkFilePaths.some(path => chunkFiles[path] !== this.chunkFiles[path]);
-        // Update files cache
-        Object.assign(this.chunkFiles, chunkFiles);
-        // Not modified? -> Use pervious content
-        if (!chunkChanged) {
-            // Overwrite vite's code
-            const code = this.rebundledContent[chunk.fileName];
-            await this.write(chunk.fileName, code);
-            // Overwrite vite's sourcemap
-            if (chunk.sourcemapFileName) {
-                const sourcemap = this.rebundledContent[chunk.sourcemapFileName];
-                if (sourcemap)
-                    await this.write(chunk.sourcemapFileName, sourcemap);
-            }
-            return false;
-        }
-        // Build with esbuild
-        let result;
-        try {
-            result = await $esbuild.build({
-                sourcemap: Boolean(this.config.build.sourcemap),
-                format: 'esm',
-                ...chunkBuildOptions,
-                banner: { ...chunkBuildOptions.banner, js: ';(async () => {' + (chunkBuildOptions.banner?.js ?? '') },
-                footer: { ...chunkBuildOptions.footer, js: (chunkBuildOptions.footer?.js ?? '') + '})();' },
-                outfile: chunkPath,
-                entryPoints: [chunkPath],
-                bundle: true,
-                allowOverwrite: true,
-            });
-        }
-        catch (err) {
-            return;
-        }
-        // Errors? -> Ignore, esbuild will show errors in console
-        if (result.errors.length > 0)
-            return;
-        // Log successful build
-        const { size } = await $fs.stat(chunkPath);
-        const _dist_ = $chalk.dim(`${this.dist}/`);
-        const _fileName_ = $chalk.cyan(chunk.fileName);
-        const _rebundle_ = $chalk.dim.cyan('[rebundle]');
-        const _size_ = $chalk.bold.dim(`${filesize(size)}`);
-        console.log(`${_dist_}${_fileName_} ${_rebundle_} ${_size_}`);
-        // Save code
-        const code = await this.read(chunk.fileName);
-        if (!code)
-            throw this.never;
-        this.rebundledContent[chunk.fileName] = code;
-        // Save sourcemap
-        if (chunk.sourcemapFileName) {
-            const sourcemap = await this.read(chunk.sourcemapFileName);
-            if (sourcemap)
-                this.rebundledContent[chunk.sourcemapFileName] = sourcemap;
-        }
-        return true;
-    }
-    async removeChunk(chunk, bundle) {
-        await this.remove(chunk.fileName);
-        delete bundle[chunk.fileName];
-        if (chunk.sourcemapFileName) {
-            await this.remove(chunk.sourcemapFileName);
-            delete bundle[chunk.sourcemapFileName];
-        }
-        // Recursively remove containing directory if empty
-        const dir = $path.dirname(this.resolve(chunk.fileName));
-        await this.removeDirectoryIfEmpty(dir);
-    }
-    async readChunkFiles(chunk) {
-        const files = {};
-        const usedPaths = [chunk.fileName, ...chunk.imports];
-        await Promise.all(usedPaths.map(async (path) => {
-            const content = await this.read(path);
-            if (!content)
-                return;
-            files[path] = content;
-        }));
-        return files;
-    }
-    // ---------------------------------------------------------------------------
-    // HELPERS
-    // ---------------------------------------------------------------------------
-    get dist() {
-        if (!this.config)
-            throw this.never;
-        return this.config.build.outDir;
-    }
-    resolve(path) {
-        return $path.join(this.dist, path);
-    }
-    async read(path) {
-        const [content] = await $utils.safe($fs.readFile(this.resolve(path), 'utf-8'));
-        return content;
-    }
-    async write(path, content) {
-        await $fs.writeFile(this.resolve(path), content, 'utf-8');
-    }
-    async remove(path) {
-        await $utils.safe($fs.unlink(this.resolve(path)));
-    }
-    async ensureWs() {
-        if (this.ws)
-            return this.ws;
-        if (!this.port)
-            throw this.never;
-        this.ws = new $ws.WebSocketServer({ port: this.port });
-        return this.ws;
-    }
-    async removeDirectoryIfEmpty(dir) {
-        const files = await $fs.readdir(dir);
-        if (files.length > 0)
-            return;
-        await $fs.rmdir(dir);
-        await this.removeDirectoryIfEmpty($path.dirname(dir));
-    }
-}