vite-plugin-rebundle 1.0.0 → 1.1.1

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/rebundle.d.ts

@@ -1,25 +1,24 @@
+import * as $utils from '@eposlabs/utils';
 import type { BuildOptions } from 'esbuild';
 import type { Plugin } from 'vite';
-export type Options = BuildOptions & {
-    bundles?: {
-        [chunkName: string]: BuildOptions;
-    };
+export type Options = {
+    [chunkName: string]: BuildOptions;
 };
-export type ContentMap = {
-    [path: string]: string;
-};
-export declare class Rebundle {
+export type OptionsInput = Options | (() => Options | Promise<Options>);
+export declare class Rebundle extends $utils.Unit {
     private options;
     private config;
-    private emptyOutDir;
-    private content;
-    constructor(options: Options);
-    get plugin(): Plugin;
-    private onConfig;
+    private chunkFiles;
+    private rebundledContent;
+    constructor(options: OptionsInput);
+    get vite(): Plugin;
     private onConfigResolved;
     private onWriteBundle;
     private get outDir();
-    private getChunkContentMap;
-    private without;
-    private get never();
+    private outPath;
+    private outRead;
+    private outWrite;
+    private getOptions;
+    private readChunkFiles;
+    private removeDirectoryIfEmpty;
 }

package/dist/rebundle.js

@@ -1,22 +1,22 @@
-import $chalk from 'chalk';
 import * as $esbuild from 'esbuild';
-import * as $merge from 'merge-anything';
 import * as $fs from 'node:fs/promises';
 import * as $path from 'node:path';
-export class Rebundle {
+import * as $utils from '@eposlabs/utils';
+import $chalk from 'chalk';
+export class Rebundle extends $utils.Unit {
     options;
     config = null;
-    emptyOutDir = true;
-    content = {};
+    chunkFiles = {};
+    rebundledContent = {};
     constructor(options) {
+        super();
         this.options = options;
     }
-    get plugin() {
+    get vite() {
         return {
             name: 'vite-plugin-rebundle',
             apply: 'build',
             enforce: 'post',
-            config: this.onConfig,
             configResolved: this.onConfigResolved,
             writeBundle: this.onWriteBundle,
         };
@@ -24,23 +24,9 @@ export class Rebundle {
     // ---------------------------------------------------------------------------
     // HOOKS
     // ---------------------------------------------------------------------------
-    onConfig = (config) => {
-        // Save user's `emptyOutDir` value
-        this.emptyOutDir = config.build?.emptyOutDir ?? true;
-        // Make `emptyOutDir = false` to prevent Vite from deleting rebundled output files
-        return {
-            build: {
-                emptyOutDir: false,
-            },
-        };
-    };
     onConfigResolved = async (config) => {
         // Save resolved config
         this.config = config;
-        // Cleanup output directory if user's `emptyOutDir` is `true`
-        if (this.emptyOutDir) {
-            await $fs.rmdir(this.outDir, { recursive: true });
-        }
         // Hide .js files from output logs
         const info = this.config.logger.info;
         this.config.logger.info = (message, options) => {
@@ -51,87 +37,86 @@ export class Rebundle {
         };
     };
     onWriteBundle = async (output, bundle) => {
+        const options = await this.getOptions();
         // Get entry js chunks
         const entryJsChunks = Object.values(bundle)
             .filter(chunkOrAsset => chunkOrAsset.type === 'chunk')
             .filter(chunk => chunk.isEntry && $path.extname(chunk.fileName) === '.js');
-        // Get non-entry chunks (.js, .js.map)
-        const nonEntryChunks = Object.values(bundle)
-            .filter(chunkOrAsset => chunkOrAsset.type === 'chunk')
-            .filter(chunk => !chunk.isEntry);
         // Rebundle entry js chunks with esbuild
         await Promise.all(entryJsChunks.map(async (chunk) => {
             if (!this.config)
                 throw this.never;
-            // Check if chunk has been modified
-            const content = await this.getChunkContentMap(chunk);
-            const usedPaths = Object.keys(content);
-            const changed = usedPaths.some(path => content[path] !== this.content[path]);
-            // Update content map
-            Object.assign(this.content, content);
-            // Not modified? -> Skip
-            if (!changed)
-                return;
-            // Prepare chunk path and build options
-            const chunkPath = $path.join(this.outDir, chunk.fileName);
-            const commonBuildOptions = this.without(this.options, 'bundles');
-            const chunkBuildOptions = this.options.bundles?.[chunk.name] ?? {};
-            // Build with esbuild
-            await $esbuild.build({
-                minify: Boolean(this.config.build.minify),
-                sourcemap: Boolean(this.config.build.sourcemap),
-                ...$merge.mergeAndConcat(commonBuildOptions, chunkBuildOptions),
-                outfile: chunkPath,
-                entryPoints: [chunkPath],
-                bundle: true,
-                allowOverwrite: true,
-                plugins: [
-                    ...(commonBuildOptions.plugins ?? []),
-                    ...(chunkBuildOptions.plugins ?? []),
-                    {
-                        name: 'logger',
-                        setup: build => {
-                            build.onEnd(result => {
-                                if (result.errors.length > 0)
-                                    return;
-                                const dir = $chalk.dim(`${this.outDir}/`);
-                                const name = $chalk.cyan(chunk.fileName);
-                                const tag = $chalk.dim.cyan('rebundle');
-                                console.log(`${dir}${name} ${tag}`);
-                            });
+            const chunkPath = this.outPath(chunk.fileName);
+            const chunkBuildOptions = 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);
+            // Modified? -> Rebundle
+            if (chunkChanged) {
+                // Build with esbuild
+                await $esbuild.build({
+                    sourcemap: Boolean(this.config.build.sourcemap),
+                    ...chunkBuildOptions,
+                    outfile: chunkPath,
+                    entryPoints: [chunkPath],
+                    bundle: true,
+                    minify: false,
+                    allowOverwrite: true,
+                    plugins: [
+                        ...(chunkBuildOptions.plugins ?? []),
+                        {
+                            name: 'logger',
+                            setup: build => {
+                                build.onEnd(result => {
+                                    if (result.errors.length > 0)
+                                        return;
+                                    const outDir = $chalk.dim(`${this.outDir}/`);
+                                    const fileName = $chalk.cyan(chunk.fileName);
+                                    const rebundleTag = $chalk.dim.cyan('rebundle');
+                                    console.log(`${outDir}${fileName} ${rebundleTag}`);
+                                });
+                            },
                         },
-                    },
-                ],
-            });
-            // Update chunk and corresponding sourcemap chunk
-            chunk.code = await $fs.readFile(chunkPath, 'utf-8');
+                    ],
+                });
+                // Save chunk content
+                this.rebundledContent[chunk.fileName] = await this.outRead(chunk.fileName);
+                // Save sourcemap content
+                if (chunk.sourcemapFileName) {
+                    this.rebundledContent[chunk.sourcemapFileName] = await this.outRead(chunk.sourcemapFileName);
+                }
+            }
+            // Overwrite chunk
+            await this.outWrite(chunk.fileName, this.rebundledContent[chunk.fileName]);
+            chunk.code = this.rebundledContent[chunk.fileName];
+            // Overwrite sourcemap
             if (chunk.sourcemapFileName) {
-                const sourcemapChunk = bundle[chunk.sourcemapFileName];
-                if (sourcemapChunk.type !== 'asset')
+                const sourcemapAsset = bundle[chunk.sourcemapFileName];
+                if (sourcemapAsset.type !== 'asset')
                     throw this.never;
-                const sourcemapChunkPath = $path.join(this.outDir, chunk.sourcemapFileName);
-                sourcemapChunk.source = await $fs.readFile(sourcemapChunkPath, 'utf-8');
+                await this.outWrite(chunk.sourcemapFileName, this.rebundledContent[chunk.sourcemapFileName]);
+                sourcemapAsset.source = this.rebundledContent[chunk.sourcemapFileName];
             }
         }));
+        // Get non-entry chunks (.js, .js.map)
+        const nonEntryChunks = Object.values(bundle)
+            .filter(chunkOrAsset => chunkOrAsset.type === 'chunk')
+            .filter(chunk => !chunk.isEntry);
         // Remove all non-entry chunks
         for (const chunk of nonEntryChunks) {
-            // Remove file itself
-            const path = $path.resolve(this.outDir, chunk.fileName);
-            await $fs.unlink(path);
+            // Remove chunk
+            await $fs.unlink(this.outPath(chunk.fileName));
             delete bundle[chunk.fileName];
-            // Remove sourcemap if any
+            // Remove sourcemap
             if (chunk.sourcemapFileName) {
-                const sourcemapPath = $path.resolve(this.outDir, chunk.sourcemapFileName);
-                await $fs.unlink(sourcemapPath);
+                await $fs.unlink(this.outPath(chunk.sourcemapFileName));
                 delete bundle[chunk.sourcemapFileName];
             }
-            // Remove containing directory if empty
-            const dir = $path.dirname(path);
-            const files = await $fs.readdir(dir);
-            if (files.length === 0) {
-                console.warn(await $fs.stat(dir));
-                await $fs.rmdir(dir);
-            }
+            // Remove containing directory if empty (recursively)
+            const dir = $path.dirname(this.outPath(chunk.fileName));
+            await this.removeDirectoryIfEmpty(dir);
         }
     };
     // ---------------------------------------------------------------------------
@@ -142,21 +127,32 @@ export class Rebundle {
             throw this.never;
         return this.config.build.outDir;
     }
-    async getChunkContentMap(chunk) {
-        const content = {};
-        const usedPaths = [chunk.fileName, ...chunk.imports];
-        await Promise.all(usedPaths.map(async (path) => {
-            const fullPath = $path.join(this.outDir, path);
-            content[path] = await $fs.readFile(fullPath, 'utf-8');
-        }));
-        return content;
+    outPath(path) {
+        return $path.join(this.outDir, path);
+    }
+    async outRead(path) {
+        return await $fs.readFile(this.outPath(path), 'utf-8');
+    }
+    async outWrite(path, content) {
+        await $fs.writeFile(this.outPath(path), content, 'utf-8');
     }
-    without(object, key) {
-        const result = { ...object };
-        delete result[key];
-        return result;
+    async getOptions() {
+        if (typeof this.options !== 'function')
+            return this.options;
+        return await this.options();
+    }
+    async readChunkFiles(chunk) {
+        const files = {};
+        await Promise.all([chunk.fileName, ...chunk.imports].map(async (path) => {
+            files[path] = await this.outRead(path);
+        }));
+        return files;
     }
-    get never() {
-        throw new Error('never');
+    async removeDirectoryIfEmpty(dir) {
+        const files = await $fs.readdir(dir);
+        if (files.length > 0)
+            return;
+        await $fs.rmdir(dir);
+        await this.removeDirectoryIfEmpty($path.dirname(dir));
     }
 }

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "vite-plugin-rebundle",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
   "description": "Vite plugin that forces single-file output per entry. Ensures each entry point is bundled into a standalone file without code-splitting.",
+  "keywords": [
+    "vite",
+    "vite-plugin"
+  ],
   "scripts": {
     "dev": "rm -rf dist && tsc --watch",
     "build": "rm -rf dist && tsc",
     "lint": "eslint src",
-    "release": "npm run build && npm publish",
-    "release:patch": "npm version patch && npm run release",
-    "release:minor": "npm version minor && npm run release"
+    "release": "npm version patch && npm run release:raw",
+    "release:raw": "npm run build && npm publish",
+    "release:minor": "npm version minor && npm run release:raw"
   },
   "exports": {
     "import": "./dist/index.js"
@@ -19,12 +23,8 @@
   "files": [
     "dist"
   ],
-  "keywords": [
-    "vite",
-    "vite-plugin"
-  ],
   "dependencies": {
     "chalk": "^5.6.0",
-    "merge-anything": "^6.0.6"
+    "esbuild": "^0.25.9"
   }
 }