@rollup-extras/plugin-size 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Konstantin Shutkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# @rollup-extras/plugin-size
+
+Rollup plugin that reports the size of generated artifacts — raw, minified (via [oxc-minify](https://www.npmjs.com/package/oxc-minify)), and compressed (gzip and/or brotli).
+
+Output is summarised by category:
+
+| Category             | Grouping                              | Sizes shown                    |
+| -------------------- | ------------------------------------- | ------------------------------ |
+| **Entry chunks**     | output format (`es`, `cjs`, `umd`, …) | raw → minified → gzip / brotli |
+| **Non-entry chunks** | output format                         | raw → minified → gzip / brotli |
+| **Assets**           | file extension (`.css`, `.svg`, …)    | raw → gzip / brotli            |
+
+A JSON stats file is maintained between builds so that size deltas are printed on subsequent runs. Only categories that appear in either the current or the previous build are shown — nothing irrelevant is printed.
+
+## Installation
+
+Using npm:
+
+```
+npm install --save-dev @rollup-extras/plugin-size
+```
+
+Using pnpm:
+
+```
+pnpm add -D @rollup-extras/plugin-size
+```
+
+## Usage
+
+### Minimal
+
+```js
+import size from "@rollup-extras/plugin-size";
+
+export default {
+  input: "src/index.js",
+  output: {
+    dir: "dist",
+    format: "es",
+  },
+  plugins: [size()],
+};
+```
+
+### Custom stats file path
+
+```js
+size({ statsFile: "build/.size-stats.json" });
+```
+
+### Disable stats file update (report-only)
+
+```js
+size({ updateStats: false });
+```
+
+### Enable brotli reporting
+
+```js
+size({ brotli: true });
+```
+
+### Brotli only (no gzip)
+
+```js
+size({ gzip: false, brotli: true });
+```
+
+### Full options
+
+```js
+size({
+  statsFile: ".stats.json",
+  updateStats: true,
+  gzip: true,
+  brotli: true,
+  pluginName: "my-size",
+});
+```
+
+## Options
+
+| Option        | Type      | Default                        | Description                                                         |
+| ------------- | --------- | ------------------------------ | ------------------------------------------------------------------- |
+| `statsFile`   | `string`  | `'.stats.json'`                | Path to the JSON stats file (relative to project root or absolute). |
+| `updateStats` | `boolean` | `true`                         | Whether to overwrite the stats file with the current build data.    |
+| `gzip`        | `boolean` | `true`                         | Report gzip-compressed sizes.                                       |
+| `brotli`      | `boolean` | `false`                        | Report brotli-compressed sizes.                                     |
+| `pluginName`  | `string`  | `'@rollup-extras/plugin-size'` | Override the plugin name reported to Rollup.                        |
+
+## How it works
+
+The plugin hooks into Rollup's `generateBundle` and `closeBundle` lifecycle:
+
+1. **`generateBundle`** — iterates over every chunk and asset in the output bundle.
+   - **Chunks** (entry and non-entry) are minified with `oxc-minify` and then compressed with the enabled algorithms (gzip and/or brotli). Sizes are accumulated per output format.
+   - **Assets** are compressed with the enabled algorithms (no JS minification). Sizes are accumulated per file extension.
+2. **`closeBundle`** (via `multiConfigPluginBase`) — loads the previous stats file (if any), prints a comparison report using [`@niceties/ansi`](https://www.npmjs.com/package/@niceties/ansi) colours, and writes the updated stats file.
+
+Size deltas are colour-coded: **green** for decreases, **red** for increases, and dim for no change. Categories that existed in the previous build but are absent in the current one are reported as _removed_.
+
+## License
+
+[MIT](https://github.com/kshutkin/rollup-extras/blob/main/LICENSE)

package/index.d.ts

@@ -0,0 +1,48 @@
+declare module '@rollup-extras/plugin-size' {
+	import type { Plugin } from 'rollup';
+	/**
+	 * Rollup plugin that reports the size of generated artifacts.
+	 *
+	 * Chunks are minified with oxc-minify and then compressed with gzip and / or
+	 * brotli to produce the reported sizes. Assets are compressed only (no JS
+	 * minification). Results are compared against a persisted JSON stats file so
+	 * that size regressions are easy to spot.
+	 *
+	 * */
+	export default function _default(options?: SizePluginOptions): Plugin & {
+		api: {
+			addInstance(): Plugin;
+		};
+	};
+	export type SizePluginOptions = {
+		pluginName?: string;
+		statsFile?: string;
+		updateStats?: boolean;
+		gzip?: boolean;
+		brotli?: boolean;
+	};
+	export type ChunkSizeStats = {
+		raw: number;
+		minified: number;
+		gzip?: number;
+		brotli?: number;
+	};
+	export type AssetSizeStats = {
+		raw: number;
+		gzip?: number;
+		brotli?: number;
+	};
+	export type StatsData = {
+		entries?: Record<string, ChunkSizeStats>;
+		chunks?: Record<string, ChunkSizeStats>;
+		assets?: Record<string, AssetSizeStats>;
+	};
+	export type CompressionFlags = {
+		gzip: boolean;
+		brotli: boolean;
+	};
+
+	export {};
+}
+
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1,19 @@
+{
+	"version": 3,
+	"file": "index.d.ts",
+	"names": [
+		"SizePluginOptions",
+		"ChunkSizeStats",
+		"AssetSizeStats",
+		"StatsData",
+		"CompressionFlags"
+	],
+	"sources": [
+		"index.js"
+	],
+	"sourcesContent": [
+		null
+	],
+	"mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+	"ignoreList": []
+}

package/index.js

@@ -0,0 +1,219 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { brotliCompress as brotliCb, gzip as gzipCb } from 'node:zlib';
+
+import { minify } from 'oxc-minify';
+
+import { bold, cyan, dim, green, red, yellow } from '@niceties/ansi';
+import logger from '@rollup-extras/utils/logger';
+import { multiConfigPluginBase } from '@rollup-extras/utils/multi-config-plugin-base';
+import { getOptionsObject } from '@rollup-extras/utils/options';
+
+const gzip = promisify(gzipCb);
+const brotli = promisify(brotliCb);
+
+const factories = { logger };
+
+function formatSize(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+function formatDelta(current, previous) {
+    if (previous == null) return '';
+    const delta = current - previous;
+    if (delta === 0) return dim(' (=)');
+    if (delta > 0) return red(` (+${formatSize(delta)})`);
+    return green(` (-${formatSize(Math.abs(delta))})`);
+}
+
+function formatCompressed(cur, prev) {
+    const parts = [];
+    if (cur.gzip != null) {
+        parts.push(`${bold(formatSize(cur.gzip))} gzip${formatDelta(cur.gzip, prev?.gzip)}`);
+    }
+    if (cur.brotli != null) {
+        parts.push(`${bold(formatSize(cur.brotli))} brotli${formatDelta(cur.brotli, prev?.brotli)}`);
+    }
+    if (parts.length === 0) return '';
+    return ` → ${parts.join(' / ')}`;
+}
+
+function allKeys(a, b) {
+    const set = new Set([...Object.keys(a || {}), ...Object.keys(b || {})]);
+    return [...set].sort();
+}
+
+function printReport(current, previous, log) {
+    const entryKeys = allKeys(current.entries, previous.entries);
+    const chunkKeys = allKeys(current.chunks, previous.chunks);
+    const assetKeys = allKeys(current.assets, previous.assets);
+
+    if (entryKeys.length === 0 && chunkKeys.length === 0 && assetKeys.length === 0) {
+        return;
+    }
+
+    for (const format of entryKeys) {
+        const cur = current.entries?.[format];
+        const prev = previous.entries?.[format];
+        if (cur) {
+            log(`${bold(cyan(format))} entry: ${formatSize(cur.raw)} → ${formatSize(cur.minified)}${formatCompressed(cur, prev)}`);
+        } else {
+            log(`${bold(cyan(format))} entry: ${dim('removed')}`);
+        }
+    }
+
+    for (const format of chunkKeys) {
+        const cur = current.chunks?.[format];
+        const prev = previous.chunks?.[format];
+        if (cur) {
+            log(`${bold(cyan(format))} chunks: ${formatSize(cur.raw)} → ${formatSize(cur.minified)}${formatCompressed(cur, prev)}`);
+        } else {
+            log(`${bold(cyan(format))} chunks: ${dim('removed')}`);
+        }
+    }
+
+    for (const ext of assetKeys) {
+        const cur = current.assets?.[ext];
+        const prev = previous.assets?.[ext];
+        if (cur) {
+            log(`${bold(yellow(ext))} assets: ${formatSize(cur.raw)}${formatCompressed(cur, prev)}`);
+        } else {
+            log(`${bold(yellow(ext))} assets: ${dim('removed')}`);
+        }
+    }
+}
+
+async function compressSizes(buf, flags) {
+
+    const result = {};
+
+    const tasks = [];
+
+    if (flags.gzip) {
+        tasks.push(
+            gzip(buf).then(compressed => {
+                result.gzip = compressed.byteLength;
+            })
+        );
+    }
+    if (flags.brotli) {
+        tasks.push(
+            brotli(buf).then(compressed => {
+                result.brotli = compressed.byteLength;
+            })
+        );
+    }
+
+    await Promise.all(tasks);
+    return result;
+}
+
+async function collectStats(currentStats, outputOptions, bundle, flags) {
+    const format = outputOptions.format;
+
+    await Promise.all(
+        Object.entries(bundle).map(async ([fileName, item]) => {
+            if (item.type === 'chunk') {
+                const code =  (item).code;
+                const raw = Buffer.byteLength(code, 'utf8');
+
+                const minResult = await minify(fileName, code, {
+                    compress: { target: 'esnext' },
+                    mangle: { toplevel: true },
+                    codegen: { removeWhitespace: true },
+                });
+                const minifiedSize = Buffer.byteLength(minResult.code, 'utf8');
+                const sizes = await compressSizes(Buffer.from(minResult.code, 'utf8'), flags);
+
+                const category =  (item).isEntry ? 'entries' : 'chunks';
+                if (!currentStats[category]) {
+                    currentStats[category] = {};
+                }
+                const bucket =  (currentStats[category]);
+                if (!bucket[format]) {
+                    bucket[format] = { raw: 0, minified: 0 };
+                }
+                bucket[format].raw += raw;
+                bucket[format].minified += minifiedSize;
+                if (sizes.gzip != null) {
+                    bucket[format].gzip = (bucket[format].gzip ?? 0) + sizes.gzip;
+                }
+                if (sizes.brotli != null) {
+                    bucket[format].brotli = (bucket[format].brotli ?? 0) + sizes.brotli;
+                }
+            } else {
+                const source =  (item).source;
+                const raw = typeof source === 'string' ? Buffer.byteLength(source, 'utf8') : source.byteLength;
+                const ext = extname(fileName) || fileName;
+                const buf = typeof source === 'string' ? Buffer.from(source, 'utf8') : Buffer.from(source);
+                const sizes = await compressSizes(buf, flags);
+
+                if (!currentStats.assets) {
+                    currentStats.assets = {};
+                }
+                if (!currentStats.assets[ext]) {
+                    currentStats.assets[ext] = { raw: 0 };
+                }
+                currentStats.assets[ext].raw += raw;
+                if (sizes.gzip != null) {
+                    currentStats.assets[ext].gzip = (currentStats.assets[ext].gzip ?? 0) + sizes.gzip;
+                }
+                if (sizes.brotli != null) {
+                    currentStats.assets[ext].brotli = (currentStats.assets[ext].brotli ?? 0) + sizes.brotli;
+                }
+            }
+        })
+    );
+}
+
+async function loadPreviousStats(statsPath) {
+    try {
+        const content = await readFile(statsPath, 'utf8');
+        return JSON.parse(content);
+    } catch {
+        return {};
+    }
+}
+
+export default function (options) {
+    const normalizedOptions = getOptionsObject(
+        options ?? {},
+        {
+            pluginName: '@rollup-extras/plugin-size',
+            statsFile: '.stats.json',
+            updateStats: true,
+            gzip: true,
+            brotli: false,
+        },
+        factories
+    );
+
+    const { pluginName, statsFile, updateStats, logger } = normalizedOptions;
+
+    const flags = { gzip: normalizedOptions.gzip, brotli: normalizedOptions.brotli };
+
+    const currentStats = {};
+
+    const instance = multiConfigPluginBase(false, pluginName, reportAndSave, onEachOutput);
+
+    return instance;
+
+    async function onEachOutput(outputOptions, bundle) {
+        await collectStats(currentStats, outputOptions, bundle, flags);
+    }
+
+    async function reportAndSave() {
+        const statsPath = resolve(process.cwd(), statsFile);
+
+        const previousStats = await loadPreviousStats(statsPath);
+
+        printReport(currentStats, previousStats, logger);
+
+        if (updateStats) {
+            await writeFile(statsPath, `${JSON.stringify(currentStats, null, 2)}\n`);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "version": "0.1.0",
+  "license": "MIT",
+  "name": "@rollup-extras/plugin-size",
+  "author": "Konstantin Shutkin",
+  "type": "module",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./index.js",
+  "module": "./index.js",
+  "engines": {
+    "node": ">=15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kshutkin/rollup-extras.git",
+    "directory": "plugin-size"
+  },
+  "bugs": "https://github.com/kshutkin/rollup-extras/issues",
+  "homepage": "https://github.com/kshutkin/rollup-extras/blob/main/plugin-size/README.md",
+  "readme": "README.md",
+  "description": "Rollup plugin to report the size of generated artifacts (raw, minified, gzip).",
+  "keywords": [
+    "rollup-plugin",
+    "size",
+    "bundle-size",
+    "gzip",
+    "minify",
+    "report"
+  ],
+  "dependencies": {
+    "@niceties/ansi": "^1.1.2",
+    "@niceties/logger": "^2.1.0",
+    "oxc-minify": "^0.125.0",
+    "@rollup-extras/utils": "^2.0.0"
+  },
+  "peerDependencies": {
+    "rollup": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "rollup": {
+      "optional": true
+    }
+  }
+}