vite-plugin-rebundle 1.7.0 → 1.8.0

package/dist/rebundle.d.ts

@@ -0,0 +1,43 @@
+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 onGenerateBundle;
+    private onWriteBundle;
+    rebundleChunk(chunk: OutputChunk, bundle: OutputBundle): Promise<boolean | undefined>;
+    private readChunkFiles;
+    private getChunks;
+    private get dist();
+    private prefixed;
+    private unprefixed;
+    private readFromDist;
+    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,181 @@
+// src/rebundle.ts
+import { safe, Unit } from "@eposlabs/utils";
+import chalk from "chalk";
+import { filesize } from "filesize";
+import { readdir, readFile, rmdir, stat, unlink } 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,
+      generateBundle: this.onGenerateBundle,
+      writeBundle: this.onWriteBundle
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // VITE HOOKS
+  // ---------------------------------------------------------------------------
+  onConfig = async () => {
+    this.port = await getPort({ port: 3100 });
+    return {
+      define: { "import.meta.env.REBUNDLE_PORT": JSON.stringify(this.port) },
+      build: { sourcemap: false }
+    };
+  };
+  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;
+  };
+  onGenerateBundle = async (_options, bundle) => {
+    const chunks = this.getChunks(bundle);
+    for (const chunk of chunks) {
+      if (!chunk.isEntry) continue;
+      chunk.fileName = this.prefixed(chunk.fileName);
+    }
+  };
+  onWriteBundle = async (_output, bundle) => {
+    if (this.hasError) return;
+    if (!this.config) throw this.never;
+    const chunks = this.getChunks(bundle);
+    const modifiedChunkNames = [];
+    await Promise.all(
+      chunks.map(async (chunk) => {
+        if (!chunk.isEntry) return;
+        const modified = await this.rebundleChunk(chunk, bundle);
+        if (modified) modifiedChunkNames.push(chunk.name);
+      })
+    );
+    for (const chunk of chunks) {
+      if (chunk.isEntry) continue;
+      await this.removeFromDist(chunk.fileName);
+      delete bundle[chunk.fileName];
+      const dir = dirname(join(this.dist, chunk.fileName));
+      await this.removeDirectoryIfEmpty(dir);
+    }
+    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 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) {
+      await this.removeFromDist(chunk.fileName);
+      return false;
+    }
+    const options = this.options[chunk.name] ?? {};
+    const [result] = await safe(async () => {
+      const inputPath = join(this.dist, chunk.fileName);
+      const outputPath = join(this.dist, this.unprefixed(chunk.fileName));
+      const build = await rolldown({ ...options.input, input: inputPath });
+      const result2 = await build.write({ ...options.output, sourcemap: false, file: outputPath });
+      return result2;
+    });
+    if (!result) return;
+    const { size } = await stat(join(this.dist, chunk.fileName));
+    const _dist_ = chalk.dim(`${this.dist}/`);
+    const _fileName_ = chalk.cyan(this.unprefixed(chunk.fileName));
+    const _rebundle_ = chalk.dim.cyan("[rebundle]");
+    const _size_ = chalk.bold.dim(`${filesize(size)}`);
+    console.log(`${_dist_}${_fileName_} ${_rebundle_} ${_size_}`);
+    const code = result.output[0].code;
+    if (!code) throw this.never;
+    this.rebundledFiles[chunk.fileName] = code;
+    await this.removeFromDist(chunk.fileName);
+    return true;
+  }
+  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;
+  }
+  getChunks(bundle) {
+    return Object.values(bundle).filter((chunkOrAsset) => chunkOrAsset.type === "chunk");
+  }
+  // ---------------------------------------------------------------------------
+  // HELPERS
+  // ---------------------------------------------------------------------------
+  get dist() {
+    if (!this.config) throw this.never;
+    return this.config.build.outDir;
+  }
+  prefixed(fileName) {
+    return `rebundle-original-${fileName}`;
+  }
+  unprefixed(fileName) {
+    return fileName.replace("rebundle-original-", "");
+  }
+  async readFromDist(path) {
+    const [content] = await safe(readFile(join(this.dist, path), "utf-8"));
+    return content;
+  }
+  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.7.0",
+  "version": "1.8.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,17 +10,24 @@
     "vite-plugin"
   ],
   "scripts": {
+    "dev": "tsup --config ../tsup.config.ts --watch",
+    "build": "tsup --config ../tsup.config.ts",
     "lint": "tsc --noEmit",
-    "release": "sh -c 'npm version ${1:-minor} && npm publish' --"
+    "release": "sh -c 'npm version ${1:-minor} && npm run build && npm publish' --"
   },
   "exports": {
-    ".": "./src/rebundle.ts"
+    ".": {
+      "source": "./src/rebundle.ts",
+      "import": "./dist/rebundle.js",
+      "types": "./dist/rebundle.d.ts"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
   "dependencies": {
-    "@eposlabs/utils": "^1.5.0",
+    "@eposlabs/utils": "^1.8.0",
     "@types/ws": "^8.18.1",
     "chalk": "^5.6.2",
     "filesize": "^11.0.13",

package/readme.md

@@ -1,82 +0,0 @@
-# vite-plugin-rebundle
-
-A Vite plugin that guarantees **one standalone file per entry point**. Each entry is bundled into a single file with no code-splitting or dynamic imports.
-
-## Why?
-
-Sometimes you need bundles without dynamic imports. Vite/Rollup don’t provide this option when building with multiple entries. `vite-plugin-rebundle` solves this issue by rebundling Vite’s output with rolldown to enforce single-file output. This plugin runs only during `vite build`, and it does not affect the Vite dev server.
-
-## Installation
-
-```bash
-npm install -D vite-plugin-rebundle
-```
-
-## Usage
-
-```javascript
-import { defineConfig } from 'vite'
-import { rebundle } from 'vite-plugin-rebundle'
-
-export default defineConfig({
-  plugins: [rebundle()],
-  build: {
-    rollupOptions: {
-      input: {
-        app: 'src/app.js',
-        libs: 'src/libs.js',
-      },
-      output: {
-        entryFileNames: '[name].js',
-      },
-    },
-  },
-})
-```
-
-## Options
-
-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: {
-        output: {
-          define: { BUNDLE_NAME: JSON.stringify('app') },
-        },
-      },
-      libs: {
-        input: {
-          keepNames: true,
-        },
-        output: {
-          define: { BUNDLE_NAME: JSON.stringify('libs') },
-        },
-      },
-    }),
-  ],
-  build: {
-    rollupOptions: {
-      input: {
-        app: 'src/app.js',
-        libs: 'src/libs.js',
-      },
-      output: {
-        entryFileNames: '[name].js',
-      },
-    },
-  },
-})
-```
-
-## 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 rolldown**, forcing a single self-contained file per entry.
-
-- 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.
-- Sourcemaps are ignored, as they would be inaccurate after rebundling.