vite-plugin-rebundle 1.3.1 → 1.3.3

package/dist/rebundle.d.ts

@@ -0,0 +1,41 @@
+import { Unit } from '@eposlabs/utils';
+import { InputOptions, OutputOptions } from 'rolldown';
+import { OutputChunk, OutputBundle } from 'rollup';
+import { Plugin } from 'vite';
+
+declare const _code_: unique symbol;
+declare const _sourcemap_: unique symbol;
+type RolldownOptions = {
+    input: InputOptions;
+    output: OutputOptions;
+};
+type Options = {
+    [bundleName: string]: RolldownOptions;
+};
+declare class Rebundle extends Unit {
+    private options;
+    private config;
+    private originalFiles;
+    private rebundledFiles;
+    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 readFromDist;
+    private writeToDist;
+    private removeFromDist;
+    private ensureWs;
+    private removeDirectoryIfEmpty;
+}
+declare function rebundle(options?: Options): Plugin<any>;
+
+export { type Options, Rebundle, type RolldownOptions, _code_, _sourcemap_, rebundle as default, rebundle };

package/dist/rebundle.js

@@ -0,0 +1,180 @@
+// src/rebundle.ts
+import { safe, Unit } from "@eposlabs/utils";
+import chalk from "chalk";
+import { filesize } from "filesize";
+import { readdir, readFile, rmdir, stat, unlink, writeFile } from "fs/promises";
+import { dirname, extname, join } from "path";
+import { getPort } from "portfinder";
+import { rolldown } from "rolldown";
+import { WebSocketServer } from "ws";
+var _code_ = Symbol("rebundle:code");
+var _sourcemap_ = Symbol("rebundle:sourcemap");
+var Rebundle = class extends Unit {
+  options;
+  config = null;
+  originalFiles = {};
+  rebundledFiles = {};
+  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 getPort({ port: 3100 });
+    return {
+      define: {
+        "import.meta.env.REBUNDLE_PORT": JSON.stringify(this.port)
+      }
+    };
+  };
+  onConfigResolved = async (config) => {
+    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);
+    };
+  };
+  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);
+    const modifiedChunkNames = [];
+    await Promise.all(
+      entryChunks.map(async (chunk) => {
+        const modified = await this.rebundleChunk(chunk, bundle);
+        if (modified) modifiedChunkNames.push(chunk.name);
+      })
+    );
+    for (const chunk of nonEntryChunks) {
+      await this.removeChunk(chunk, bundle);
+    }
+    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 bundle[chunk.fileName];
+    const chunkPath = join(this.dist, chunk.fileName);
+    const chunkOptions = this.options[chunk.name] ?? {};
+    const chunkFiles = await this.readChunkFiles(chunk);
+    const chunkFilePaths = Object.keys(chunkFiles);
+    const chunkModified = chunkFilePaths.some((path) => chunkFiles[path] !== this.originalFiles[path]);
+    Object.assign(this.originalFiles, chunkFiles);
+    if (!chunkModified) {
+      const code2 = this.rebundledFiles[chunk.fileName];
+      await this.writeToDist(chunk.fileName, code2);
+      if (chunk.sourcemapFileName) {
+        const sourcemap = this.rebundledFiles[chunk.sourcemapFileName];
+        if (sourcemap) await this.writeToDist(chunk.sourcemapFileName, sourcemap);
+      }
+      return false;
+    }
+    const [build] = await safe(rolldown({ ...chunkOptions.input, input: chunkPath }));
+    if (!build) return;
+    const [_, error] = await safe(build.write({ ...chunkOptions.output, file: chunkPath }));
+    if (error) return;
+    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_}`);
+    const code = await this.readFromDist(chunk.fileName);
+    if (!code) throw this.never;
+    this.rebundledFiles[chunk.fileName] = code;
+    if (chunk.sourcemapFileName) {
+      const sourcemap = await this.readFromDist(chunk.sourcemapFileName);
+      if (sourcemap) this.rebundledFiles[chunk.sourcemapFileName] = sourcemap;
+    }
+    return true;
+  }
+  async removeChunk(chunk, bundle) {
+    await this.removeFromDist(chunk.fileName);
+    delete bundle[chunk.fileName];
+    if (chunk.sourcemapFileName) {
+      await this.removeFromDist(chunk.sourcemapFileName);
+      delete bundle[chunk.sourcemapFileName];
+    }
+    const dir = dirname(join(this.dist, 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.readFromDist(path);
+        files[path] = content ?? "";
+      })
+    );
+    return files;
+  }
+  // ---------------------------------------------------------------------------
+  // HELPERS
+  // ---------------------------------------------------------------------------
+  get dist() {
+    if (!this.config) throw this.never;
+    return this.config.build.outDir;
+  }
+  async readFromDist(path) {
+    const [content] = await safe(readFile(join(this.dist, path), "utf-8"));
+    return content;
+  }
+  async writeToDist(path, content) {
+    await writeFile(join(this.dist, path), content, "utf-8");
+  }
+  async removeFromDist(path) {
+    await safe(unlink(join(this.dist, path)));
+  }
+  async ensureWs() {
+    if (this.ws) return this.ws;
+    if (!this.port) throw this.never;
+    this.ws = new WebSocketServer({ port: this.port });
+    return this.ws;
+  }
+  async removeDirectoryIfEmpty(dir) {
+    const files = await readdir(dir);
+    if (files.length > 0) return;
+    await rmdir(dir);
+    await this.removeDirectoryIfEmpty(dirname(dir));
+  }
+};
+function rebundle(options = {}) {
+  return new Rebundle(options).vite;
+}
+var rebundle_default = rebundle;
+export {
+  Rebundle,
+  _code_,
+  _sourcemap_,
+  rebundle_default as default,
+  rebundle
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-rebundle",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,14 +10,21 @@
     "vite-plugin"
   ],
   "scripts": {
+    "build": "tsup src --format esm --dts --clean",
     "lint": "tsc --noEmit",
-    "release": "sh -c 'npm version ${1:-patch} && npm publish' --"
+    "release": "sh -c 'npm version ${1:-patch} && npm run build && npm publish' --"
   },
   "exports": {
-    "import": "./src/rebundle.ts"
+    ".": {
+      "import": "./dist/rebundle.js"
+    },
+    "./ts": {
+      "import": "./src/rebundle.ts"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
   "dependencies": {
     "@eposlabs/utils": "^1.1.1",
@@ -26,7 +33,7 @@
     "filesize": "^11.0.13",
     "portfinder": "^1.0.38",
     "rolldown": "^1.0.0-beta.40",
-    "rollup": "^4.52.2",
+    "rollup": "^4.52.3",
     "vite": "^7.1.7",
     "ws": "^8.18.3"
   }

package/src/rebundle.ts

@@ -119,13 +119,16 @@ export class Rebundle extends Unit {
     const chunkPath = join(this.dist, chunk.fileName)
     const chunkOptions = this.options[chunk.name] ?? {}
 
-    // Read chunk files, save their content
+    // Read chunk files
     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])
 
+    // Update original files content
+    Object.assign(this.originalFiles, chunkFiles)
+
     // Chunk was not modified? -> Use previous content
     if (!chunkModified) {
       // Overwrite vite's output with previously rebundled code
@@ -138,17 +141,15 @@ export class Rebundle extends Unit {
         if (sourcemap) await this.writeToDist(chunk.sourcemapFileName, sourcemap)
       }
 
+      // Return not modified status
       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
-    }
+    const [build] = await safe(rolldown({ ...chunkOptions.input, input: chunkPath }))
+    if (!build) return
+    const [_, error] = await safe(build.write({ ...chunkOptions.output, file: chunkPath }))
+    if (error) return
 
     // Log successful build
     const { size } = await stat(chunkPath)
@@ -169,6 +170,7 @@ export class Rebundle extends Unit {
       if (sourcemap) this.rebundledFiles[chunk.sourcemapFileName] = sourcemap
     }
 
+    // Return modified status
     return true
   }