vanilla-jet 1.5.2 → 1.5.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable project changes are documented in this file.
 
 The format follows a structure inspired by Keep a Changelog and semantic versioning.
 
+## [1.5.3] - 2026-06-28
+
+### Changed
+
+- **Static compression now applies to ALL compressible assets, not just the app bundle.**
+  `framework/router.js` negotiates `.br`/`.gz` for any `css`/`js` request that has a precompressed
+  sibling (falling back to the original otherwise) — previously only `vanilla.min.js`/`app.min.css`.
+  This makes self-hosted vendor libraries serve gzip/brotli instead of uncompressed.
+- `scripts/compress_br.js` now walks `public/scripts`, `public/styles`, `public/pages` and emits
+  `.gz` + `.br` for every `.js`/`.css`/`.html` (was: only three named files).
+
+### Why
+
+- Self-hosting third-party libs (to cut CDN origins) only helps if they're served compressed;
+  otherwise a large lib (e.g. a 369 KB bundle) would ship uncompressed and regress vs the CDN.
+
 ## [1.5.2] - 2026-06-28
 
 ### Added

package/framework/router.js

@@ -199,7 +199,11 @@ class Router {
   getStaticCandidates(request, ext, filename) {
     let obj = this;
     let candidates = [{ filename: filename, contentEncoding: '' }];
-    let isCompressible = obj.compressionMimes.includes(ext) && obj.compressionFiles.includes(path.basename(filename));
+    // Any compressible type can be served precompressed; resolveFirstAvailableStaticFile
+    // falls back to the original when a .br/.gz sibling doesn't exist. This lets ALL
+    // self-hosted assets (vendor libs, plugins, …) be served gzip/brotli, not just the
+    // app bundle — otherwise self-hosting a large lib would ship it uncompressed.
+    let isCompressible = obj.compressionMimes.includes(ext);
     if (!isCompressible) {
       return candidates;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vanilla-jet",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "VannilaJet framework",
   "main": "index.js",
   "bin": {

package/scripts/compress_br.js

@@ -1,6 +1,8 @@
-// Brotli-precompresses the build outputs so the server can negotiate `.br`
-// (smaller than gzip). Safe + additive: the framework only serves `.br` when the
-// client sends `Accept-Encoding: br`; otherwise it falls back to `.gz`/original.
+// Precompresses build outputs to .gz + .br so the server can serve any self-hosted
+// asset (vendor libs, plugins, bundles, styles, pages) compressed via Accept-Encoding
+// negotiation. Without this, self-hosting a large library would ship it uncompressed.
+// Safe + additive: clients that don't accept br get gzip; those that accept neither
+// get the original (resolveFirstAvailableStaticFile falls back).
 
 const fs = require('fs');
 const path = require('path');
@@ -14,33 +16,44 @@ function processCwd() {
 }
 
 const root = processCwd();
+const DIRS = ['public/scripts', 'public/styles', 'public/pages'];
+const COMPRESSIBLE = new Set(['.js', '.css', '.html']);
+const BROTLI_OPTIONS = { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 } };
 
-// Same files the framework negotiates `.br` for (router static + response.render).
-const TARGETS = [
-	'public/scripts/vanilla.min.js',
-	'public/styles/app.min.css',
-	'public/pages/home.html'
-];
-
-const BROTLI_OPTIONS = {
-	params: {
-		[zlib.constants.BROTLI_PARAM_QUALITY]: 11,
-		[zlib.constants.BROTLI_PARAM_SIZE_HINT]: 0
+function walk(dir, out) {
+	let entries;
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch (err) {
+		return;
+	}
+	for (const entry of entries) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			walk(full, out);
+		} else if (
+			COMPRESSIBLE.has(path.extname(entry.name)) &&
+			!entry.name.endsWith('.gz') &&
+			!entry.name.endsWith('.br')
+		) {
+			out.push(full);
+		}
 	}
-};
+}
+
+const files = [];
+DIRS.forEach((dir) => walk(path.join(root, dir), files));
 
-TARGETS.forEach((relativePath) => {
-	const filePath = path.join(root, relativePath);
+let count = 0;
+files.forEach((file) => {
 	try {
-		const stats = fs.statSync(filePath);
-		if (!stats.isFile()) {
-			return;
-		}
-		const input = fs.readFileSync(filePath);
-		const compressed = zlib.brotliCompressSync(input, BROTLI_OPTIONS);
-		fs.writeFileSync(filePath + '.br', compressed);
-		console.log(`VanillaJet - brotli: ${relativePath}.br (${input.length} -> ${compressed.length} B)`);
+		const input = fs.readFileSync(file);
+		fs.writeFileSync(file + '.gz', zlib.gzipSync(input, { level: 9 }));
+		fs.writeFileSync(file + '.br', zlib.brotliCompressSync(input, BROTLI_OPTIONS));
+		count = count + 1;
 	} catch (err) {
-		// File not present (feature not built yet) — skip silently.
+		// Skip unreadable files; never fail the build over compression.
 	}
 });
+
+console.log(`VanillaJet - precompressed ${count} assets (.gz + .br)`);