vanilla-jet 1.5.0 → 1.5.2

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable project changes are documented in this file.
 
 The format follows a structure inspired by Keep a Changelog and semantic versioning.
 
+## [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
+
+- **Service worker precache is now fully derived from `vanillaJet.package.json`.** `scripts/generate_sw.js`
+  reads the Dipper's full local registry (`coreDependencies` + `dependencies` + `styles` that resolve to
+  `/public/...`) instead of only the enqueued subset, so first-party assets like `coreLib/*` are precached
+  automatically. Consumers no longer need to hardcode a `service_worker.precache` list.
+- Added `service_worker.precache_exclude` (opt-out by path) for declared assets you don't want cached.
+  `service_worker.precache` remains as an optional escape hatch for extras not declared in the package file.
+
+### Compatibility notes
+
+- Backward compatible: an explicit `service_worker.precache` still works (merged with the derived set).
+
 ## [1.5.0] - 2026-06-27
 
 ### Added

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/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.0",
+  "version": "1.5.2",
   "description": "VannilaJet framework",
   "main": "index.js",
   "bin": {

package/scripts/compress_br.js

@@ -0,0 +1,46 @@
+// 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.
+
+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();
+
+// 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
+	}
+};
+
+TARGETS.forEach((relativePath) => {
+	const filePath = path.join(root, relativePath);
+	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)`);
+	} catch (err) {
+		// File not present (feature not built yet) — skip silently.
+	}
+});

package/scripts/generate_sw.js

@@ -63,9 +63,11 @@ function isLocalPublicPath(url) {
 	return typeof url === 'string' && url.startsWith('/public/') && !url.startsWith('//');
 }
 
-// Best-effort: read the resources the Dipper enqueues for this app, so consumer
-// plugins/styles get precached automatically. Any failure falls back to core only.
-function deriveEnqueuedAssets(root, opts, shared) {
+// Source of truth = vanillaJet.package.json. We hydrate the Dipper and read its full
+// registry (coreDependencies + dependencies + styles), keeping every LOCAL resource.
+// This way the precache list is derived from the declared deps, with no raw paths in
+// the consumer config. Any failure falls back to core only.
+function deriveLocalAssets(root, opts, shared) {
 	try {
 		const Dipper = require('../framework/dipper.js');
 		const Functions = require('../framework/functions.js');
@@ -73,16 +75,16 @@ function deriveEnqueuedAssets(root, opts, shared) {
 		Functions.hydrate(dipper);
 
 		const assets = [];
-		const collect = (registry, enqueued) => {
-			Object.keys(enqueued || {}).forEach((name) => {
+		const collect = (registry) => {
+			Object.keys(registry || {}).forEach((name) => {
 				const entry = registry[name];
 				if (entry && isLocalPublicPath(entry.resource)) {
 					assets.push(stripQuery(entry.resource));
 				}
 			});
 		};
-		collect(dipper.styles, dipper.enqueued_styles);
-		collect(dipper.scripts, dipper.enqueued_scripts);
+		collect(dipper.styles);
+		collect(dipper.scripts);
 		return assets;
 	} catch (err) {
 		return [];
@@ -90,15 +92,18 @@ function deriveEnqueuedAssets(root, opts, shared) {
 }
 
 function buildPrecacheList(root, opts, shared) {
-	const configured = (opts.service_worker && Array.isArray(opts.service_worker.precache))
-		? opts.service_worker.precache
-		: [];
+	const sw = opts.service_worker || {};
+	// `precache` = optional extras NOT declared in vanillaJet.package.json.
+	const configured = Array.isArray(sw.precache) ? sw.precache : [];
+	// `precache_exclude` = opt-out for declared-but-don't-cache assets (heavy/rare).
+	const exclude = (Array.isArray(sw.precache_exclude) ? sw.precache_exclude : []).map(stripQuery);
 
 	const candidates = CORE_PRECACHE
-		.concat(deriveEnqueuedAssets(root, opts, shared))
+		.concat(deriveLocalAssets(root, opts, shared))
 		.concat(configured)
 		.map(stripQuery)
-		.filter(isLocalPublicPath);
+		.filter(isLocalPublicPath)
+		.filter((assetPath) => !exclude.includes(assetPath));
 
 	const seen = new Set();
 	const precache = [];