vanilla-jet 1.5.1 → 1.5.3

package/CHANGELOG.md

@@ -4,6 +4,33 @@ 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
+
+- **Brotli precompression** of build outputs (`scripts/compress_br.js` + Gulp `compressBr`): generates
+  `.br` for `vanilla.min.js`, `app.min.css` and `public/pages/home.html`. The server already negotiates
+  `.br -> .gz -> original` when `settings.profile.enable_precompressed_negotiation` is true and the client
+  sends `Accept-Encoding: br`. Additive and safe: clients that don't accept brotli keep getting gzip.
+- **`settings.profile.defer_scripts`** (default `false`): when enabled, `dipper.includeScript()` adds
+  `defer` to non-async scripts so they don't block HTML parsing (document order preserved). Opt-in.
+
 ## [1.5.1] - 2026-06-28
 
 ### Changed

package/framework/dipper.js

@@ -307,7 +307,9 @@ Dipper.prototype.includeScript = function(script) {
 			//type = item['cdn'] ? "" : 'type=\"text/javascript\"',
 			resource = item['resource'],
 			isAsync = item['async'] ? ' async' : '',
-			defer = item['defer'] ? ' defer' : '',
+			// Honor a per-script defer flag, or the global settings.profile.defer_scripts
+			// (applied to non-async scripts so they don't block parsing; order preserved).
+			defer = (item['defer'] || (obj.options && obj.options.defer_scripts && !item['async'])) ? ' defer' : '',
 			origin = item['origin'] != '' ? ' crossorigin=\"' + item['origin'] + '\"' : '',
 			integrity = item['integrity'] != '' ? ' integrity=\"' + item['integrity'] + '\"' : '';
 		

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/framework/server.js

@@ -37,6 +37,7 @@ class Server {
 			wsServer: false,
       enable_precompressed_negotiation: false,
       enable_service_worker: false,
+      defer_scripts: false,
       request_timeout_ms: 30000,
       headers_timeout_ms: 35000,
       keep_alive_timeout_ms: 5000

package/gulpfile.js

@@ -127,6 +127,12 @@ function generateServiceWorker() {
     .pipe(shell([`node scripts/generate_sw.js ${buildEnv}`]));
 }
 
+// Brotli precompression of build outputs (served via Accept-Encoding negotiation)
+function compressBr() {
+  return gulp.src('.')
+    .pipe(shell([`node scripts/compress_br.js`]));
+}
+
 // Watch task
 function watchFiles(cb) {
   livereload.listen();
@@ -168,7 +174,8 @@ const build = gulp.series(
   buildLess,
   compileTemplates,
   gulp.parallel(compressJs, compressCss),
-  generateServiceWorker
+  generateServiceWorker,
+  compressBr
 );
 
 const dev = gulp.series(
@@ -186,6 +193,7 @@ exports.compressJs = compressJs;
 exports.compressCss = compressCss;
 exports.compileTemplates = compileTemplates;
 exports.generateServiceWorker = generateServiceWorker;
+exports.compressBr = compressBr;
 exports.build = build;
 exports.dev = dev;
 exports.default = dev; 

package/package.json

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

package/scripts/compress_br.js

@@ -0,0 +1,59 @@
+// 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');
+const zlib = require('zlib');
+
+function processCwd() {
+	return process.cwd()
+		.replace('/scripts', '')
+		.replace('/gulp', '')
+		.replace('/node_modules/vanilla-jet', '');
+}
+
+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 } };
+
+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));
+
+let count = 0;
+files.forEach((file) => {
+	try {
+		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) {
+		// Skip unreadable files; never fail the build over compression.
+	}
+});
+
+console.log(`VanillaJet - precompressed ${count} assets (.gz + .br)`);