vite-plugin-rebundle 1.15.0 → 1.16.0

package/dist/rebundle.d.ts

@@ -13,18 +13,22 @@ declare class Rebundle {
     private bundleOptions;
     private config;
     private originals;
-    private rebundled;
     private port;
     private ws;
+    private isRollupVite;
+    private isRolldownVite;
+    private ORIGINALS_DIR;
     constructor(commonOptions?: RolldownOptions | null, bundleOptions?: BundleOptions);
     get vite(): Plugin;
     private onConfig;
     private onConfigResolved;
+    private onGenerateBundle;
     private onWriteBundle;
     private get dist();
-    private removeFromDist;
-    private ensureWs;
-    private removeDirectoryIfEmpty;
+    private prefixed;
+    private unprefixed;
+    private getChunks;
+    private getEntryChunks;
     private merge;
 }
 declare function rebundle(commonOptions?: RolldownOptions | null, bundleOptions?: BundleOptions): Plugin<any>;

package/dist/rebundle.js

@@ -1,9 +1,9 @@
 // src/rebundle.ts
-import { is, safe } from "@eposlabs/utils";
+import { is } from "@eposlabs/utils";
 import chalk from "chalk";
 import { filesize } from "filesize";
-import { readdir, rmdir, stat, unlink, writeFile } from "fs/promises";
-import { dirname, extname, join } from "path";
+import { rm, stat } from "fs/promises";
+import { extname, join } from "path";
 import { getPort } from "portfinder";
 import { rolldown } from "rolldown";
 import { WebSocketServer } from "ws";
@@ -12,9 +12,11 @@ var Rebundle = class {
   bundleOptions;
   config = null;
   originals = {};
-  rebundled = {};
   port = null;
   ws = null;
+  isRollupVite = false;
+  isRolldownVite = false;
+  ORIGINALS_DIR = "__originals__";
   constructor(commonOptions, bundleOptions) {
     this.commonOptions = commonOptions ?? {};
     this.bundleOptions = bundleOptions ?? {};
@@ -26,74 +28,81 @@ var Rebundle = class {
       enforce: "post",
       config: this.onConfig,
       configResolved: this.onConfigResolved,
+      generateBundle: this.onGenerateBundle,
       writeBundle: this.onWriteBundle
     };
   }
   // ---------------------------------------------------------------------------
   // VITE HOOKS
   // ---------------------------------------------------------------------------
-  onConfig = async () => {
-    this.port = await getPort({ port: 3100 });
+  onConfig = async (config) => {
+    if (config.build?.watch) {
+      this.port = await getPort({ port: 3100 });
+      this.ws = new WebSocketServer({ port: this.port });
+    }
     return {
       define: { "import.meta.env.REBUNDLE_PORT": JSON.stringify(this.port) },
       build: { sourcemap: false }
     };
   };
   onConfigResolved = async (config) => {
+    this.isRollupVite = !("oxc" in config);
+    this.isRolldownVite = !this.isRollupVite;
     this.config = config;
-    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);
-    };
+    if (this.isRollupVite) {
+      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);
+      };
+    }
+  };
+  onGenerateBundle = async (_options, bundle) => {
+    for (const chunk of this.getChunks(bundle)) {
+      const originalFileName = chunk.fileName;
+      chunk.fileName = this.prefixed(originalFileName);
+      chunk.imports = chunk.imports.map((name) => this.prefixed(name));
+      if (this.isRollupVite) {
+        bundle[chunk.fileName] = chunk;
+        delete bundle[originalFileName];
+      }
+    }
   };
   onWriteBundle = async (_output, bundle) => {
-    const modifiedChunkNames = [];
+    const modifiedEntryChunks = this.getEntryChunks(bundle).filter((chunk) => {
+      const usedPaths = [chunk.fileName, ...chunk.imports];
+      return usedPaths.some((path) => "code" in bundle[path] && bundle[path].code !== this.originals[path]);
+    });
+    if (modifiedEntryChunks.length === 0) return;
     await Promise.all(
-      Object.values(bundle).map(async (chunkOrAsset) => {
-        const chunk = chunkOrAsset.type === "chunk" && chunkOrAsset.isEntry ? chunkOrAsset : null;
-        if (!chunk) return;
-        const chunkFilePath = join(this.dist, chunk.fileName);
-        const modified = [chunk.fileName, ...chunk.imports].some((name) => {
-          return bundle[name].type === "chunk" && bundle[name].code !== this.originals[name];
-        });
-        if (!modified) {
-          await writeFile(chunkFilePath, this.rebundled[chunk.fileName]);
-          return;
-        }
+      modifiedEntryChunks.map(async (chunk) => {
+        const originalFileName = this.unprefixed(chunk.fileName);
         const build = await rolldown({
           ...this.merge(this.commonOptions.input ?? {}, this.bundleOptions[chunk.name]?.input ?? {}),
-          input: chunkFilePath
+          input: join(this.dist, chunk.fileName)
         });
-        const result = await build.write({
+        await build.write({
           ...this.merge(this.commonOptions.output ?? {}, this.bundleOptions[chunk.name]?.output ?? {}),
           sourcemap: false,
-          file: chunkFilePath
+          file: join(this.dist, originalFileName)
         });
-        const { size } = await stat(join(this.dist, chunk.fileName));
-        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_}`);
-        modifiedChunkNames.push(chunk.name);
-        this.rebundled[chunk.fileName] = result.output[0].code;
+        const { size } = await stat(join(this.dist, originalFileName));
+        const $dist = chalk.dim(`${this.dist}/`);
+        const $fileName = chalk.cyan(originalFileName);
+        const $rebundle = chalk.dim.cyan("[rebundle]");
+        const $size = chalk.bold.dim(`${filesize(size)}`);
+        console.log(`${$dist}${$fileName} ${$rebundle} ${$size}`);
       })
     );
-    for (const chunkOrAsset of Object.values(bundle)) {
-      const chunk = chunkOrAsset.type === "chunk" ? chunkOrAsset : null;
-      if (!chunk) continue;
-      this.originals[chunk.fileName] = chunk.code;
-      delete bundle[chunk.fileName];
-      if (!chunk.isEntry) {
-        await this.removeFromDist(chunk.fileName);
-      }
+    for (const chunk of this.getChunks(bundle)) {
+      this.originals[this.unprefixed(chunk.fileName)] = chunk.code;
+      if (this.isRolldownVite) delete bundle[chunk.fileName];
     }
-    if (!this.config) throw "never";
-    if (this.config.build.watch && modifiedChunkNames.length > 0) {
-      const ws = await this.ensureWs();
-      ws.clients.forEach((client) => client.send(JSON.stringify(modifiedChunkNames)));
+    await rm(join(this.dist, this.ORIGINALS_DIR), { recursive: true });
+    if (this.ws && modifiedEntryChunks.length > 0) {
+      const names = modifiedEntryChunks.map((chunk) => chunk.name);
+      this.ws.clients.forEach((client) => client.send(JSON.stringify(names)));
     }
   };
   // ---------------------------------------------------------------------------
@@ -103,23 +112,17 @@ var Rebundle = class {
     if (!this.config) throw "never";
     return this.config.build.outDir;
   }
-  async removeFromDist(path) {
-    path = join(this.dist, path);
-    const dir = dirname(path);
-    await safe(unlink(path));
-    await this.removeDirectoryIfEmpty(dir);
+  prefixed(path) {
+    return join(this.ORIGINALS_DIR, path);
+  }
+  unprefixed(path) {
+    return path.replace(`${this.ORIGINALS_DIR}/`, "");
   }
-  async ensureWs() {
-    if (this.ws) return this.ws;
-    if (!this.port) throw "never";
-    this.ws = new WebSocketServer({ port: this.port });
-    return this.ws;
+  getChunks(bundle) {
+    return Object.values(bundle).filter((item) => item.type === "chunk");
   }
-  async removeDirectoryIfEmpty(dir) {
-    const files = await readdir(dir);
-    if (files.length > 0) return;
-    await rmdir(dir);
-    await this.removeDirectoryIfEmpty(dirname(dir));
+  getEntryChunks(bundle) {
+    return Object.values(bundle).filter((item) => item.type === "chunk").filter((chunk) => chunk.isEntry);
   }
   merge(obj1, obj2) {
     const result = { ...obj1 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-rebundle",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",

package/src/rebundle.ts

@@ -1,12 +1,12 @@
-import { is, safe } from '@eposlabs/utils'
+import { is } from '@eposlabs/utils'
 import chalk from 'chalk'
 import { filesize } from 'filesize'
-import { readdir, rmdir, stat, unlink, writeFile } from 'node:fs/promises'
-import { dirname, extname, join } from 'node:path'
+import { rm, stat } from 'node:fs/promises'
+import { extname, join } from 'node:path'
 import { getPort } from 'portfinder'
 import { rolldown, type InputOptions, type OutputOptions } from 'rolldown'
 import type { NormalizedOutputOptions, OutputBundle } from 'rollup'
-import type { Plugin, ResolvedConfig } from 'vite'
+import type { Plugin, ResolvedConfig, UserConfig } from 'vite'
 import { WebSocketServer } from 'ws'
 
 export type RolldownOptions = {
@@ -23,9 +23,11 @@ export class Rebundle {
   private bundleOptions: BundleOptions
   private config: ResolvedConfig | null = null
   private originals: Record<string, string> = {}
-  private rebundled: Record<string, string> = {}
   private port: number | null = null
   private ws: WebSocketServer | null = null
+  private isRollupVite = false
+  private isRolldownVite = false
+  private ORIGINALS_DIR = '__originals__'
 
   constructor(commonOptions?: RolldownOptions | null, bundleOptions?: BundleOptions) {
     this.commonOptions = commonOptions ?? {}
@@ -39,6 +41,7 @@ export class Rebundle {
       enforce: 'post',
       config: this.onConfig,
       configResolved: this.onConfigResolved,
+      generateBundle: this.onGenerateBundle,
       writeBundle: this.onWriteBundle,
     }
   }
@@ -47,8 +50,12 @@ export class Rebundle {
   // VITE HOOKS
   // ---------------------------------------------------------------------------
 
-  private onConfig = async () => {
-    this.port = await getPort({ port: 3100 })
+  private onConfig = async (config: UserConfig) => {
+    if (config.build?.watch) {
+      this.port = await getPort({ port: 3100 })
+      this.ws = new WebSocketServer({ port: this.port })
+    }
+
     return {
       define: { 'import.meta.env.REBUNDLE_PORT': JSON.stringify(this.port) },
       build: { sourcemap: false },
@@ -56,89 +63,91 @@ export class Rebundle {
   }
 
   private onConfigResolved = async (config: ResolvedConfig) => {
+    // Detect Vite variant
+    this.isRollupVite = !('oxc' in config)
+    this.isRolldownVite = !this.isRollupVite
+
     // 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)
+    // Hide js files from output logs for rollup Vite
+    if (this.isRollupVite) {
+      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 onGenerateBundle = async (_options: NormalizedOutputOptions, bundle: OutputBundle) => {
+    for (const chunk of this.getChunks(bundle)) {
+      const originalFileName = chunk.fileName
+
+      // Move all chunks to a temporary subfolder
+      chunk.fileName = this.prefixed(originalFileName)
+      chunk.imports = chunk.imports.map(name => this.prefixed(name))
+
+      // Use prefixed names as bundle keys for rollup Vite (rolldown Vite does this automatically)
+      if (this.isRollupVite) {
+        bundle[chunk.fileName] = chunk
+        delete bundle[originalFileName]
+      }
     }
   }
 
   private onWriteBundle = async (_output: NormalizedOutputOptions, bundle: OutputBundle) => {
-    const modifiedChunkNames: string[] = []
+    // Get modified entry chunks
+    const modifiedEntryChunks = this.getEntryChunks(bundle).filter(chunk => {
+      const usedPaths = [chunk.fileName, ...chunk.imports]
+      return usedPaths.some(path => 'code' in bundle[path] && bundle[path].code !== this.originals[path])
+    })
 
-    // Rebundle entry chunks
-    await Promise.all(
-      Object.values(bundle).map(async chunkOrAsset => {
-        // Only process entry chunks
-        const chunk = chunkOrAsset.type === 'chunk' && chunkOrAsset.isEntry ? chunkOrAsset : null
-        if (!chunk) return
-        const chunkFilePath = join(this.dist, chunk.fileName)
-
-        // Check if chunk is modified
-        const modified = [chunk.fileName, ...chunk.imports].some(name => {
-          return bundle[name].type === 'chunk' && bundle[name].code !== this.originals[name]
-        })
+    // No modified entry chunks? -> Skip rebundle
+    if (modifiedEntryChunks.length === 0) return
 
-        // Not modified? -> Overwrite Vite's output with cached rebundled content
-        if (!modified) {
-          await writeFile(chunkFilePath, this.rebundled[chunk.fileName])
-          return
-        }
+    // Rebundle modified entry chunks
+    await Promise.all(
+      modifiedEntryChunks.map(async chunk => {
+        const originalFileName = this.unprefixed(chunk.fileName)
 
-        // Modified? -> Rebundle with rolldown
+        // Build with rolldown
         const build = await rolldown({
           ...this.merge(this.commonOptions.input ?? {}, this.bundleOptions[chunk.name]?.input ?? {}),
-          input: chunkFilePath,
+          input: join(this.dist, chunk.fileName),
         })
-        const result = await build.write({
+        await build.write({
           ...this.merge(this.commonOptions.output ?? {}, this.bundleOptions[chunk.name]?.output ?? {}),
           sourcemap: false,
-          file: chunkFilePath,
+          file: join(this.dist, originalFileName),
         })
 
         // Log successful build
-        const { size } = await stat(join(this.dist, chunk.fileName))
-        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_}`)
-
-        // Keep track of modified chunks
-        modifiedChunkNames.push(chunk.name)
-
-        // Cache rebundled code
-        this.rebundled[chunk.fileName] = result.output[0].code
+        const { size } = await stat(join(this.dist, originalFileName))
+        const $dist = chalk.dim(`${this.dist}/`)
+        const $fileName = chalk.cyan(originalFileName)
+        const $rebundle = chalk.dim.cyan('[rebundle]')
+        const $size = chalk.bold.dim(`${filesize(size)}`)
+        console.log(`${$dist}${$fileName} ${$rebundle} ${$size}`)
       }),
     )
 
-    for (const chunkOrAsset of Object.values(bundle)) {
-      // Process chunks only
-      const chunk = chunkOrAsset.type === 'chunk' ? chunkOrAsset : null
-      if (!chunk) continue
-
+    for (const chunk of this.getChunks(bundle)) {
       // Save original chunk code
-      this.originals[chunk.fileName] = chunk.code
-
-      // Delete chunk from the `bundle` to hide log for `rolldown-vite`. Call for `rollup` for consistency.
-      delete bundle[chunk.fileName]
+      this.originals[this.unprefixed(chunk.fileName)] = chunk.code
 
-      // Non-entry chunk? -> Remove its file
-      if (!chunk.isEntry) {
-        await this.removeFromDist(chunk.fileName)
-      }
+      // Delete chunk from the bundle to hide Vite's output log
+      if (this.isRolldownVite) delete bundle[chunk.fileName]
     }
 
+    // Remove folder with original chunks
+    await rm(join(this.dist, this.ORIGINALS_DIR), { recursive: true })
+
     // Notify about modified chunks
-    if (!this.config) throw 'never'
-    if (this.config.build.watch && modifiedChunkNames.length > 0) {
-      const ws = await this.ensureWs()
-      ws.clients.forEach(client => client.send(JSON.stringify(modifiedChunkNames)))
+    if (this.ws && modifiedEntryChunks.length > 0) {
+      const names = modifiedEntryChunks.map(chunk => chunk.name)
+      this.ws.clients.forEach(client => client.send(JSON.stringify(names)))
     }
   }
 
@@ -151,25 +160,22 @@ export class Rebundle {
     return this.config.build.outDir
   }
 
-  private async removeFromDist(path: string) {
-    path = join(this.dist, path)
-    const dir = dirname(path)
-    await safe(unlink(path))
-    await this.removeDirectoryIfEmpty(dir)
+  private prefixed(path: string) {
+    return join(this.ORIGINALS_DIR, path)
+  }
+
+  private unprefixed(path: string) {
+    return path.replace(`${this.ORIGINALS_DIR}/`, '')
   }
 
-  private async ensureWs() {
-    if (this.ws) return this.ws
-    if (!this.port) throw 'never'
-    this.ws = new WebSocketServer({ port: this.port })
-    return this.ws
+  private getChunks(bundle: OutputBundle) {
+    return Object.values(bundle).filter(item => item.type === 'chunk')
   }
 
-  private async removeDirectoryIfEmpty(dir: string) {
-    const files = await readdir(dir)
-    if (files.length > 0) return
-    await rmdir(dir)
-    await this.removeDirectoryIfEmpty(dirname(dir))
+  private getEntryChunks(bundle: OutputBundle) {
+    return Object.values(bundle)
+      .filter(item => item.type === 'chunk')
+      .filter(chunk => chunk.isEntry)
   }
 
   private merge(obj1: Record<string, any>, obj2: Record<string, any>) {