@epublishing/grunt-epublishing 0.3.19 → 0.3.23

package/lib/configure-webpack.js

@@ -53,7 +53,7 @@ module.exports = function configureWebpack(grunt, config) {
     if (!config.babelLoader) {
       config.babelLoader = {
         exceptions: [],
-        exclude: /(node_modules|bower_components)/,
+        exclude: /(node_modules)/,
       };
     }
 
@@ -144,7 +144,7 @@ module.exports = function configureWebpack(grunt, config) {
       rules.push({
         enforce: "pre",
         test: /\.js$/,
-        exclude: /(node_modules|bower_components|public|vendor)/,
+        exclude: /(node_modules|public|vendor)/,
         loader: "eslint-loader",
         options: {
           configFile: eslintConfig,

package/lib/init-jade-config.js

@@ -69,11 +69,6 @@ module.exports = function initJadeConfig(grunt, jadePath, jadeChildPath, jadeChi
   // Add package.json to the grunt config
   grunt.config.set('pkg', grunt.file.readJSON('package.json'));
 
-  // Check to see if we need to add the bower tasks
-  if (fs.existsSync('bower.json')) {
-    jadeTasks.unshift('bower-install-simple', 'bower');
-  }
-
   // Register the main jade task!
   grunt.registerTask('jade', jadeTasks);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@epublishing/grunt-epublishing",
   "description": "Automated front-end tasks for ePublishing Jade and client sites.",
-  "version": "0.3.19",
+  "version": "0.3.23",
   "homepage": "https://www.epublishing.com",
   "contributors": [
     {
@@ -54,8 +54,6 @@
     "grunt": "^1.0.3",
     "grunt-babel": "^7.0.0",
     "grunt-bless": "^1.0.2",
-    "grunt-bower": "^0.21.4",
-    "grunt-bower-install-simple": "^1.2.6",
     "grunt-contrib-clean": "^1.1.0",
     "grunt-contrib-concat": "^1.0.1",
     "grunt-contrib-uglify": "^3.4.0",

package/tasks/sass.js

@@ -2,37 +2,152 @@
 const util = require('util');
 const sass = require('sass');
 const path = require('path');
+const fs = require('fs');
+const fsPromises = require('fs').promises;
+const crypto = require('crypto');
 
 module.exports = grunt => {
-	grunt.registerMultiTask('sass', 'Compile Sass to CSS', function () {
+	// Cache for compiled results
+	const cache = new Map();
+	
+	// Generate cache key for a file
+	const getCacheKey = (filePath, options) => {
+		const content = fs.readFileSync(filePath, 'utf8');
+		const optionsHash = crypto.createHash('md5').update(JSON.stringify(options)).digest('hex');
+		const contentHash = crypto.createHash('md5').update(content).digest('hex');
+		return `${filePath}:${contentHash}:${optionsHash}`;
+	};
+
+	// Check if file needs recompilation
+	const needsRecompilation = async (src, dest, options) => {
+		try {
+			const cacheKey = getCacheKey(src, options);
+			const cached = cache.get(cacheKey);
+			
+			if (!cached) return true;
+			
+			// Check if destination file exists and is newer than source
+			const srcStats = await fsPromises.stat(src);
+			const destStats = await fsPromises.stat(dest);
+			
+			return srcStats.mtime > destStats.mtime;
+		} catch (error) {
+			// If destination doesn't exist or other error, recompile
+			return true;
+		}
+	};
+
+	grunt.registerMultiTask('sass', 'Compile Sass to CSS with performance optimizations', function () {
 		const done = this.async();
+		const startTime = Date.now();
 
 		const options = this.options({
-			precision: 10
+			precision: 10,
+			cache: true,
+			parallel: true,
+			maxConcurrency: require('os').cpus().length
 		});
 
-		(async () => {
-			await Promise.all(this.files.map(async item => {
+		// Filter out partial files and create compilation tasks
+		const compilationTasks = this.files
+			.map(item => {
 				const [src] = item.src;
-
 				if (!src || path.basename(src)[0] === '_') {
+					return null;
+				}
+				return { src, dest: item.dest, options };
+			})
+			.filter(Boolean);
+
+		if (compilationTasks.length === 0) {
+			grunt.log.writeln('No Sass files to compile');
+			done();
+			return;
+		}
+
+		// Process files with concurrency control
+		const processFile = async (task) => {
+			const { src, dest, options: taskOptions } = task;
+			
+			try {
+				// Check if recompilation is needed
+				if (options.cache && !(await needsRecompilation(src, dest, taskOptions))) {
+					grunt.log.debug(`Skipping ${src} (cached)`);
 					return;
 				}
 
-				const result = await util.promisify(sass.render)(Object.assign({}, options, {
+				// Compile Sass
+				const sassOptions = {
+					...taskOptions,
 					file: src,
-					outFile: item.dest,
-				}));
+					outFile: dest,
+				};
+
+				const result = await util.promisify(sass.render)(sassOptions);
+				
+				// Write CSS file
+				await fsPromises.writeFile(dest, result.css);
+				
+				// Write source map if requested
+				if (taskOptions.sourceMap) {
+					const mapPath = taskOptions.sourceMap === true ? `${dest}.map` : taskOptions.sourceMap;
+					await fsPromises.writeFile(mapPath, result.map);
+				}
+
+				// Cache the result
+				if (options.cache) {
+					const cacheKey = getCacheKey(src, taskOptions);
+					cache.set(cacheKey, {
+						css: result.css,
+						map: result.map,
+						timestamp: Date.now()
+					});
+				}
+
+				grunt.log.ok(`Compiled ${src} → ${dest}`);
+			} catch (error) {
+				grunt.log.error(`Error compiling ${src}: ${error.message}`);
+				throw error;
+			}
+		};
 
-				grunt.file.write(item.dest, result.css);
+		// Process files with controlled concurrency
+		const processWithConcurrency = async (tasks, maxConcurrency) => {
+			const results = [];
+			const chunks = [];
+			
+			// Split tasks into chunks
+			for (let i = 0; i < tasks.length; i += maxConcurrency) {
+				chunks.push(tasks.slice(i, i + maxConcurrency));
+			}
 
-				if (options.sourceMap) {
-					const filePath = options.sourceMap === true ? `${item.dest}.map` : options.sourceMap;
-					grunt.file.write(filePath, result.map);
+			// Process chunks sequentially, but files within each chunk in parallel
+			for (const chunk of chunks) {
+				const chunkResults = await Promise.all(chunk.map(processFile));
+				results.push(...chunkResults);
+			}
+
+			return results;
+		};
+
+		// Main execution
+		(async () => {
+			try {
+				if (options.parallel) {
+					await processWithConcurrency(compilationTasks, options.maxConcurrency);
+				} else {
+					// Sequential processing for debugging or when parallel is disabled
+					for (const task of compilationTasks) {
+						await processFile(task);
+					}
 				}
-			}));
-		})().catch(error => {
-			grunt.fatal(error.formatted || error);
-		}).then(done);
+
+				const duration = Date.now() - startTime;
+				grunt.log.ok(`Sass compilation completed in ${duration}ms`);
+				done();
+			} catch (error) {
+				grunt.fatal(error.formatted || error.message);
+			}
+		})();
 	});
 };