@epublishing/grunt-epublishing 1.2.5 → 1.2.7

package/lib/cli.js

@@ -60,10 +60,12 @@ function printOptions(options) {
 /**
  * Run npm install in jade and jade child gem directories.
  * Installs packages from each gem's package.json (excluding site).
+ * Skips if package-lock.json hasn't changed since the last install.
  * @param {Object} config - Build configuration with paths
  * @param {Object} options - Build options
  */
 async function runNpmInstall(config, options) {
+  const crypto = require('crypto');
   const Resolver = require('@epublishing/jade-resolver');
   const paths = config.paths || {};
   // Build paths object with ONLY jade and jade child gem directories (absolute paths)
@@ -89,10 +91,25 @@ async function runNpmInstall(config, options) {
 
   for (const dir of dirs) {
     const basename = path.basename(dir);
+    const lockFile = path.join(dir, 'package-lock.json');
+    const hasLock = fs.existsSync(lockFile);
+    const stampFile = path.join(dir, 'node_modules', '.package-lock.installed');
+
+    // Skip reinstall if package-lock.json hasn't changed since last npm ci
+    if (hasLock && fs.existsSync(stampFile)) {
+      const currentHash = crypto.createHash('sha1').update(fs.readFileSync(lockFile)).digest('hex');
+      const stampHash = fs.readFileSync(stampFile, 'utf8').trim();
+      if (currentHash === stampHash) {
+        if (options.verbose) {
+          console.log(chalk.gray(`  Skipping npm install in ${basename} (package-lock.json unchanged)`));
+        }
+        continue;
+      }
+    }
+
     const spinner = ora(`Installing npm modules in ${basename}...`).start();
 
     try {
-      const hasLock = fs.existsSync(path.join(dir, 'package-lock.json'));
       const cmd = hasLock ? 'ci' : 'install';
       await new Promise((resolve, reject) => {
         const proc = spawn('npm', [cmd], {
@@ -114,6 +131,16 @@ async function runNpmInstall(config, options) {
           reject(err);
         });
       });
+
+      // Write stamp so we can skip next time if package-lock.json is unchanged
+      if (hasLock) {
+        try {
+          const hash = crypto.createHash('sha1').update(fs.readFileSync(lockFile)).digest('hex');
+          fs.writeFileSync(stampFile, hash + '\n');
+        } catch {
+          // Stamp write failure is non-fatal — we'll just reinstall next time
+        }
+      }
     } catch (err) {
       throw err;
     }

package/lib/sass-compiler.js

@@ -141,7 +141,21 @@ async function ensureDir(filePath) {
 }
 
 /**
- * Compile a single Sass file
+ * Compile a single Sass file in an isolated dart-sass compiler instance.
+ *
+ * Uses `sass.initAsyncCompiler()` instead of the module-level
+ * `sass.compileAsync()` to guarantee no shared state between concurrent
+ * compilations.  The module-level singleton queues all calls through a
+ * single long-running dart-sass worker; in that model any subtle stateful
+ * behavior (import caching, in-flight deps, etc.) can bleed from one
+ * compilation's output into another's when we run a chunk in parallel.
+ *
+ * The symptom was stylesheets ending up with rules that their source
+ * file never imported (e.g. achrnews `application-v2.css` getting print
+ * rules from `jade-bnp-print.scss`).  With a per-file isolated compiler,
+ * each file is compiled in its own worker, disposed when done — no
+ * possible cross-contamination vector.
+ *
  * @param {string} src - Source file path
  * @param {string} dest - Destination file path
  * @param {Object} options - Compilation options
@@ -163,8 +177,10 @@ async function compileFile(src, dest, options = {}) {
     importers.push(adaptLegacyImporter(legacyImporter));
   }
 
+  let compiler = null;
   try {
-    const result = await sass.compileAsync(src, {
+    compiler = await sass.initAsyncCompiler();
+    const result = await compiler.compileAsync(src, {
       style,
       sourceMap,
       loadPaths,
@@ -187,6 +203,14 @@ async function compileFile(src, dest, options = {}) {
     return { src, dest, success: true };
   } catch (error) {
     return { src, dest, success: false, error };
+  } finally {
+    if (compiler) {
+      try {
+        await compiler.dispose();
+      } catch {
+        // Disposal errors are not actionable; compiler is going away.
+      }
+    }
   }
 }
 
@@ -198,7 +222,11 @@ async function compileFile(src, dest, options = {}) {
  */
 async function compileSass(config, options = {}) {
   const {
-    maxConcurrency = 2, // Limit for memory optimization
+    // Serial by default.  compileFile() now spawns an isolated dart-sass
+    // compiler per file so concurrency wouldn't actually share state, but
+    // running serial gives us deterministic output ordering and bounded
+    // memory use.  --parallel in cli.js still bumps this to 4 if needed.
+    maxConcurrency = 1,
     verbose = false,
   } = options;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@epublishing/grunt-epublishing",
   "description": "Modern front-end build tools for ePublishing Jade and client sites.",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "homepage": "https://www.epublishing.com",
   "contributors": [
     {