js-build-tools 4.1.1 → 5.0.0

package/dist/testQuick.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 })
 exports.testQuick = void 0
-var gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
-var _jest = require('jest')
-function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(); var n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o; var i; var f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
+const gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
+const _jest = require('jest')
+function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; let o; let i; const f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
 /**
  * Run the Jest tests for files which have been modified (based on git status).
  * Configure where tests are located by using 'testPath'.

package/dist/typeScript.js

@@ -1,13 +1,13 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.typeScript = void 0
-var _tsFor = require('./partials/tsFor.js')
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.typeScript = void 0
+const _tsFor = require('./partials/tsFor.js')
 /**
  * Simplified typescript task using tsFor.
  * @memberOf module:js-build-tools
  * @returns {Function}
- */
-const typeScript = exports.typeScript = (0, _tsFor.tsFor)()
+ */
+const typeScript = exports.typeScript = (0, _tsFor.tsFor)()

package/dist/watchFull.js

@@ -1,14 +1,14 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.watchFull = void 0
-var _partials = require('./partials.js')
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.watchFull = void 0
+const _partials = require('./partials.js')
 /**
  * Watch for changes and run the distribution for the changed files, then bundle and test the changed files.
  * @memberOf module:js-build-tools
  * @returns {FSWatcher}
- */
-const watchFull = () => (0, _partials.beginWatcher)().on('change', _partials.runOnChange)
-exports.watchFull = watchFull
+ */
+const watchFull = () => (0, _partials.beginWatcher)().on('change', _partials.runOnChange)
+exports.watchFull = watchFull

package/dist/watchTest.js

@@ -1,20 +1,20 @@
-'use strict'
-
-require('core-js/modules/esnext.weak-map.delete-all.js')
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.watchTest = void 0
-var gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
-var _gulp = require('gulp')
-var _testQuick = require('./testQuick.js')
-function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(); var n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o; var i; var f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
+'use strict'
+
+require('core-js/modules/esnext.weak-map.delete-all.js')
+Object.defineProperty(exports, '__esModule', {
+  value: true
+})
+exports.watchTest = void 0
+const gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
+const _gulp = require('gulp')
+const _testQuick = require('./testQuick.js')
+function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; let o; let i; const f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
 /**
  * Watch for changes and run the tests.
  * @memberOf module:js-build-tools
  * @returns {*}
- */
-const watchTest = () => (0, _gulp.watch)(gulpConfig.get('test.watch'), {
-  ignoreInitial: false
-}, _testQuick.testQuick)
-exports.watchTest = watchTest
+ */
+const watchTest = () => (0, _gulp.watch)(gulpConfig.get('test.watch'), {
+  ignoreInitial: false
+}, _testQuick.testQuick)
+exports.watchTest = watchTest

package/functions/build.mjs

@@ -21,7 +21,7 @@ import { testFull } from './testFull.mjs'
 export const build = (done = null) => {
   const distLintMinify = parallel(distLint, distMinify)
   const bundleLintMinify = parallel(bundleLint, bundleMinify)
-  const buildActions = [clean, distSeries(), distLintMinify]
+  const buildActions = [distSeries(), distLintMinify]
   if (gulpConfig.get('typescript.enabled')) {
     // For ts usage, we need to run the readme on the dist directly since that is where the .js files are located
     buildActions.push(compileReadme)
@@ -51,7 +51,10 @@ export const build = (done = null) => {
     // Conditionally add SASS process
     runActions.push(sass)
   }
-  return parallel(
-    ...runActions
+  // clean has to finish before anything writes into the output folders - images, fonts and sass all write into
+  // browser/, so running clean in parallel with them races (ENOTEMPTY errors from clean, or output deleted mid-write).
+  return series(
+    clean,
+    parallel(...runActions)
   )(done)
 }

package/functions/build.test.mjs

@@ -5,6 +5,9 @@ import { clean } from './partials/clean.mjs'
 import { testFull } from './testFull.mjs'
 import { countMatches } from 'test-filesystem'
 
+// Run the real Standard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
+jest.mock('./partials/standardLint.mjs', () => require('./test-helpers/standardLintWithRealStandard.mjs'))
+
 setUp.setDefaults('test-build')
 const gulpConfig = setUp.gulpConfig
 
@@ -621,4 +624,32 @@ describe('build', () => {
       done()
     })
   }, 30000)
+
+  test('finishes clean before starting the tasks that write into the output folders', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    const sourcesPath = `${srcPath}/sources`
+    fs.writeFileSync(`${sourcesPath}/file1.js`, file1Contents)
+    fs.writeFileSync(`${sourcesPath}/file2.js`, file2Contents)
+    fs.writeFileSync(`${srcPath}/main.js`, mainFileContents)
+    expect.assertions(1)
+    const events = []
+    clean.mockImplementationOnce(() => new Promise(resolve => setTimeout(() => {
+      events.push('clean finished')
+      resolve(true)
+    }, 100)))
+    testFull.mockImplementationOnce(() => {
+      events.push('testFull started')
+      return Promise.resolve(true)
+    })
+    // Earlier tests leave these enabled, so state them explicitly to keep this test independent of test order.
+    gulpConfig.set('browser.enabled', false)
+    gulpConfig.set('fonts.enabled', false)
+    gulpConfig.set('images.enabled', false)
+    gulpConfig.set('sass.enabled', false)
+    gulpConfig.set('typescript.enabled', false)
+    build(() => {
+      expect(events).toEqual(['clean finished', 'testFull started'])
+      done()
+    })
+  }, 30000)
 })

package/functions/bundleLint.mjs

@@ -1,6 +1,6 @@
 import { dest, src } from 'gulp'
 import * as gulpConfig from '../gulp.config.mjs'
-import standard from 'gulp-standard'
+import { standardLint } from './partials/standardLint.mjs'
 
 /**
  * Applies Standard code style linting to bundled file.
@@ -8,9 +8,5 @@ import standard from 'gulp-standard'
  * @returns {stream.Stream}
  */
 export const bundleLint = () => src(`${gulpConfig.get('browser.to')}/${gulpConfig.get('browser.name')}.js`)
-  .pipe(standard({ fix: true }))
-  .pipe(standard.reporter('default', {
-    fix: true,
-    quiet: true
-  }))
+  .pipe(standardLint({ fix: true }))
   .pipe(dest(gulpConfig.get('browser.to')))

package/functions/bundleLint.test.mjs

@@ -3,6 +3,9 @@ import * as setUp from './test-helpers/setUp.mjs'
 import { bundleLint } from './bundleLint.mjs'
 import { countMatches } from 'test-filesystem'
 
+// Run the real Standard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
+jest.mock('./partials/standardLint.mjs', () => require('./test-helpers/standardLintWithRealStandard.mjs'))
+
 setUp.setDefaults('test-bundle-lint')
 const gulpConfig = setUp.gulpConfig
 

package/functions/distLint.mjs

@@ -1,6 +1,6 @@
 import * as gulpConfig from '../gulp.config.mjs'
 import { dest, src } from 'gulp'
-import standard from 'gulp-standard'
+import { standardLint } from './partials/standardLint.mjs'
 
 /**
  * Applies Standard code style linting to distribution files.
@@ -8,9 +8,5 @@ import standard from 'gulp-standard'
  * @returns {*}
  */
 export const distLint = () => src(gulpConfig.get('browser.from'))
-  .pipe(standard({ fix: true }))
-  .pipe(standard.reporter('default', {
-    fix: true,
-    quiet: true
-  }))
+  .pipe(standardLint({ fix: true }))
   .pipe(dest(gulpConfig.get('dist.to')))

package/functions/distLint.test.mjs

@@ -3,6 +3,9 @@ import * as setUp from './test-helpers/setUp.mjs'
 import { distLint } from './distLint.mjs'
 import { countMatches } from 'test-filesystem'
 
+// Run the real Standard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
+jest.mock('./partials/standardLint.mjs', () => require('./test-helpers/standardLintWithRealStandard.mjs'))
+
 setUp.setDefaults('test-dist-lint')
 const gulpConfig = setUp.gulpConfig
 

package/functions/partials/copyFor.mjs

@@ -7,5 +7,6 @@ import { dest, src } from 'gulp'
  * @param {string} destPath
  * @returns {stream.Stream}
  */
-export const copyFor = (srcPath, destPath) => src(srcPath)
+// encoding: false copies the bytes untouched - Gulp 5's default utf8 handling corrupts binary files such as fonts.
+export const copyFor = (srcPath, destPath) => src(srcPath, { encoding: false })
   .pipe(dest(destPath))

package/functions/partials/copyFor.test.mjs

@@ -32,4 +32,22 @@ describe('copyFor', () => {
         done()
       })
   })
+
+  test('copies binary files byte for byte, including a leading BOM and bytes above 0x7f', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    const binaryFile = `${srcPath}/font.woff`
+    const original = Buffer.concat([Buffer.from([0xef, 0xbb, 0xbf]), Buffer.from(Array.from({ length: 512 }, (_, i) => i % 256))])
+    fs.writeFileSync(binaryFile, original)
+    expect.assertions(1)
+    const browserPath = gulpConfig.get('browser.to')
+    copyFor(binaryFile, browserPath)
+      .on('finish', () => {
+        expect(fs.readFileSync(`${browserPath}/font.woff`).equals(original)).toBeTruthy()
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
 })

package/functions/partials/imagesFor.mjs

@@ -1,7 +1,36 @@
 import cache from 'gulp-cache'
+import { createRequire } from 'node:module'
 import { dest, src } from 'gulp'
+import path from 'node:path'
 import * as gulpConfig from '../../gulp.config.mjs'
-import imagemin from 'gulp-imagemin'
+
+const installHint = 'Add it to your project with: npm install --save-dev github:jheagle/gulp-imagemin#common-js-compatibility ' +
+  '(the CommonJS-compatible fork - upstream gulp-imagemin is ESM-only and cannot be require()d by this package\'s CommonJS build).'
+
+/**
+ * Load `gulp-imagemin`, an optional peer dependency: image optimization is off by default and its binary-download
+ * dependency chain is heavy, so it is only required once the images task actually runs, and it is resolved from the
+ * consuming project's own directory rather than from this package.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] - The project directory to resolve `gulp-imagemin` from.
+ * @returns {Function} The gulp-imagemin plugin factory.
+ * @throws {Error} With install instructions when gulp-imagemin is missing or is the ESM-only upstream release.
+ */
+export const loadImagemin = (projectPath = process.cwd()) => {
+  let loaded
+  try {
+    loaded = createRequire(path.join(projectPath, 'package.json'))('gulp-imagemin')
+  } catch (error) {
+    if (error.code === 'MODULE_NOT_FOUND' && /Cannot find module 'gulp-imagemin'/.test(error.message)) {
+      throw new Error(`The images task needs the optional peer dependency gulp-imagemin, which is not installed. ${installHint}`)
+    }
+    if (error.code === 'ERR_REQUIRE_ESM') {
+      throw new Error(`gulp-imagemin could not be loaded because it is ESM-only. ${installHint}`)
+    }
+    throw error
+  }
+  return loaded && (loaded.__esModule || loaded.default) ? loaded.default : loaded
+}
 
 /**
  * Move and optimize images into the browser directory.
@@ -10,8 +39,10 @@ import imagemin from 'gulp-imagemin'
  * @param {string} [imageDest=dest/image/folder]
  * @return {stream.Stream}
  */
-export const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest = gulpConfig.get('images.to')) =>
-  src(imageSrc)
+export const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest = gulpConfig.get('images.to')) => {
+  const imagemin = loadImagemin()
+  // Gulp 5 reads files as utf8 text unless told otherwise, which corrupts binary images (and makes gulp-cache drop them).
+  return src(imageSrc, { encoding: false })
     .pipe(
       // Caching images that ran through imagemin
       cache(
@@ -23,3 +54,4 @@ export const imagesFor = (imageSrc = gulpConfig.get('images.from'), imageDest =
       )
     )
     .pipe(dest(imageDest))
+}

package/functions/partials/imagesFor.test.mjs

@@ -1,6 +1,8 @@
 import fs from 'fs'
 import * as setUp from '../test-helpers/setUp.mjs'
-import { imagesFor } from './imagesFor.mjs'
+import os from 'os'
+import zlib from 'zlib'
+import { imagesFor, loadImagemin } from './imagesFor.mjs'
 
 setUp.setDefaults('test-images-for')
 const gulpConfig = setUp.gulpConfig
@@ -116,6 +118,44 @@ const imageContents = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n'
 
 const imageCompressed = '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="600" height="600"><image width="600" height="600" preserveAspectRatio="none" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKAAAACgCAYAAACLz2ctAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz AAADsQAAA7EB9YPtSQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAhrSURB VHic7d3fi1x3Gcfx97M7TdKYYNPYbLaxlVZrUaK1iviToiIpeNFIwQuLBW8UEQTv9C/wSvDS+yKo CFopiFe2QVpqMKVYf0DaRmibZnfTRpNs9lez+3hxzq7T3ZnZmXO+3/PMmf284DDJzJznPGfOZ79n zpmzs+buiESZim5A9jYFUEIpgBJKAZRQCqCEUgAllAIooRRACaUASigFUEIpgBJKAZRQCqCEUgAl lAIooRRACaUASigFUEIpgBKqU2dmM5spa2wAXk4bXf/vd7/3eQ6AbZumdvl/931T2+6b6rOODtzs 00Ov3gY+7u5uZr2W36+33R6fBt509/XBW6A3M9sPHAPWh1ynXe/bZR0HbYN+6zwF3KgVQOBbwGzN Gq1XbJfkfgJcqTjvXcD3EvaSax2fr7sL3p+kDemlzmvblu2yXwEcX3Ve233JushLARxjB2rMO/kB NLNpah7EyEB7YQQ8UGcE1OiXV50QtSWA+xTA8VUnRHV23026xap+N0y5Cz4GHAIO97i9GziYps+R rAGXgXlgobx9G1gtp0M9ej0M3EbRc9M/WOtd/W5Oc8Bld9+oUrBr2xwHZrpuj9L8hw9LwGvANeB6 17QIXKscwN2UJy1ngVPAySwL+b8V4AzwV+C/XnGlyg13D/AIcGe69nZw4AXgGWC+atBGZWYd4ATw VeAjmRf3KvAUcHHQ9sgWwK0FFEH8LnBfpkW8APzO3ZdTFTSzw8CPyLMrWwJ+7u6XMtQempl9CPgO xacuqV0Bfurua7s9MftwXKb/bKbyK8CTKcMH4O7XKX6Cc3guOnwA7v4KcC5T+X8OEz5o7v1Arhf8 jLsvZar9Zoaa68CzGepW9UymukO/dk0FcIHiw//UzmeouSnHD82VcnQdC+6+ALyTofTQr10jASzf ZC9kKJ1zY85nqDk24euSo6e5YZ/Y5CF5jhHwWoaam3KMDOMYwMXUBd196NeuzRekLrt7jlDnNI4B DO2pzQHMOfrlMo4BTD4CjqLNAVyNbqCCoU5NNCy0pzYHUCaAAiihFEAJpQBKKAVQQimAEkoBlFAK oIRSACWUAiihFEAJpQBKKAVQQimAEkoBlFAKoIRSACWUAiihFEAJpS+YbNZDZvZgdBPbHIlcuALY rCMEb/Bxo12whFIAJZQCKKEUQAmlAEooBVBCKYASSgGUUDoR3awLwMXoJrb5IHn/JMVACmCzXnL3 P0c30c3MThMYQO2CJVSbA5jlT3hLs9ocwDb3LqU2b0SNgBOgzQFsc+9SavNG1Ag4AdocwDb3LqU2 b8Q29y6lNm9E7YIngAIoodocQJkACqCEUgAllAIooRRACaUASigFUEIpgBJKAZRQCqCEUgAllAIo oRRACdXmAN7MXF9X21RkZkPnqs0BXM1c/z2Z60+yoV87BbC/Q5nrT7KhXzsFsL/DGWqO4249R08K YAI5RsCjGWrWlaOnPRHAlcz135ehZtiXAA0wm6HmHcM+sc0BzDYCmtlB4BMZSufY2JWZ2a3AbRlK f8bMpod5ogLY2xeAWzLUPWBm4zQK3pOp7nuBTw3zxDYHMPku2MyOmdm3gYdT1+7yTTO7PWP9oZjZ CeDRjIv4hpk9ZmYD/zJUm7+gsvIIWJ4ovR2YAY6X0+a/c/9QzgI/NrPXgZeBt4BF4Ho5Lbr7RooF mVmH4oDgcNftDHBf2UfOo3IDPgk8YGaXgDlgvpzmgP+4u++pAJqZAT+k2AiR6z4FfKCctnMzWwZ+ 7+7nqhQ3s68AXwZurd5iMtPA+8up25qZXWjzLnjkALq7A8cY75HfgIMUG66qacYjfIPsA+5ocwCr vgfMff4wlbWgeZu02uYAXqk4X2s2To1527KOa00GMOUuYdndr1WctzUbJ2jeJq00GcCUV5fM1Zi3 NRunxrxteZvRzC64PO2RcgS8VGPetgRwL+yCV5s6GjxI2nNOdUbA54DzgHdNG31uh33cKdZvc5rq c9vvvl7/v15jHeeBP/RZhzrraQy/nsM8/npTAUx9cecrVWd097+lbGQcuftV4E/RfQyjqfeAKQP4 lrsvJKwngZoKYMprzv6RsJYEGxhAM7vXzD6dYDkfT1Bj098T1pJgO94DlkesJ4EvAXeX930U+LW7 j3xqoLzm7MP12txy0d3/naiWjIF3BbAM32PsvBjzY8CdZvaEu4/6925PUu9zzW5/TFRHxsTWLri8 gvVx+l8JfBT4gZl9fsRlpLqy+DV3/1eiWjImut8DnqYY6QbpAI+a2eNmtn+34uWu+/4a/XXT6DeB OgDlZeKfG2G+B4ATZvZbdz/f6wlmdj/F7jyFl/otR9rN3B0z+z5wb8Ual4CzwBvAMsWVxg9S7HpT fPrxNvCzKgdAMv46Znac6uGD4tLu04n62e4m8ITCN7mmgLuimxjgyQpH3dIiHXZeqz8OHHjK3Z+P bkTy6pDuHF0qDvzG3c9GNyL5TQEXopvosg78QuHbOzrAq9FNlK4Cv3L3l6MbkeZ03P2qmV1mhC+U yeAcxQHHcmAPEmDzk5AzQcu/QXGa5ZcK395kxe9qg5mdAk41tNw14FngaXdfamiZMoa2AghgZl8H vphxee9Q/E7G0+6+mHE50hLbA2jA14CHSHt6Zg54EfiLu9f5ZRuZMO8K4NadxdeHPUzx7UZVP8+9 TBG6F919vnKHMtF6BnDrQbNZ4LMU3yY1w84v7naKX6C+QXFRwhubk7vfyNGwTJaBAdzxZLMDwBGK g4glYMVHKSCyzUgBFEmtzd+OJRNAAZRQCqCEUgAllAIooRRACaUASigFUEIpgBJKAZRQCqCEUgAl lAIooRRACaUASigFUEIpgBJKAZRQCqCEUgAllAIooRRACaUASigFUEL9D1MqMi7YkUEVAAAAAElF TkSuQmCC"/><path d="M19.04 494.382C2.001 482.76-2.83 468.022 5.006 451.587c3.27-6.858 10.156-15.228 15.3-18.599 8.904-5.834 9.948-5.675 21.728 3.31 28.014 21.367 44.09 18.882 51.548-7.971 5.951-21.426 5.252-305.141-.77-313.044-2.617-3.433-11.316-6.65-19.688-7.28-14.39-1.082-15.047-1.7-16.164-15.19L55.797 78.75h326.107l2.574 11.718c2.93 13.34-1.711 18.133-17.648 18.225-19.29.11-21.83 7.13-21.83 60.325V217.5h135v-48.169c0-41.902-.892-48.976-6.858-54.375-3.772-3.413-10.384-6.206-14.693-6.206-15.006 0-19.699-4.116-19.699-17.276V78.75h161.703l-1.164 14.063c-1.132 13.677-1.605 14.094-17.28 15.224-13.45.97-16.737 2.798-19.876 11.053-5.802 15.26-2.837 249.42 3.25 256.747 2.617 3.15 11.477 6.801 19.688 8.114C599.596 386.274 600 386.745 600 401.37v15.03l-79.687-1.012-79.688-1.012-1.137-13.607c-1.135-13.594-1.12-13.61 16.875-16.305 9.907-1.484 19.252-4.642 20.767-7.018 1.515-2.376 2.781-30.054 2.813-61.508L480 258.75H344.814l1.03 60.938 1.031 60.937 19.688 3.34c20.492 3.476 22.165 5.78 17.323 23.848-2.253 8.408-2.53 8.437-80.573 8.437H225v-14.956c0-14.536.418-15.022 14.93-17.343 8.21-1.313 17.07-4.966 19.687-8.119 3.637-4.381 4.758-35.56 4.758-132.343 0-69.636-1.23-127.842-2.735-129.348-9.738-9.743-68.924-8.348-79.154 1.866-3.087 3.081-4.993 46.77-6.525 149.486-1.455 97.609-3.646 149.68-6.69 159.02-13.551 41.573-61.403 74.912-111 77.337-22.755 1.112-28.167.082-39.232-7.468z"/></svg>'
 
+// Build a small but real PNG so the test exercises binary data (a text-only SVG hid Gulp 5's utf8 corruption of images).
+const crc32 = buffer => {
+  let crc = 0xffffffff
+  for (const byte of buffer) {
+    crc ^= byte
+    for (let bit = 0; bit < 8; bit++) {
+      crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1))
+    }
+  }
+  return (crc ^ 0xffffffff) >>> 0
+}
+const pngChunk = (type, data) => {
+  const length = Buffer.alloc(4)
+  length.writeUInt32BE(data.length)
+  const body = Buffer.concat([Buffer.from(type), data])
+  const crc = Buffer.alloc(4)
+  crc.writeUInt32BE(crc32(body))
+  return Buffer.concat([length, body, crc])
+}
+const makePng = (size = 32) => {
+  const header = Buffer.alloc(13)
+  header.writeUInt32BE(size, 0)
+  header.writeUInt32BE(size, 4)
+  header.set([8, 2, 0, 0, 0], 8) // 8-bit RGB
+  const rows = Buffer.alloc((size * 3 + 1) * size)
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size * 3; x++) {
+      rows[y * (size * 3 + 1) + 1 + x] = (x * 37 + y * 91) % 256 // bytes above 0x7f exercise utf8 corruption
+    }
+  }
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    pngChunk('IHDR', header),
+    pngChunk('IDAT', zlib.deflateSync(rows)),
+    pngChunk('IEND', Buffer.alloc(0))
+  ])
+}
+
 beforeEach(setUp.beforeEach)
 
 afterEach(setUp.afterEach)
@@ -141,4 +181,46 @@ describe('imagesFor', () => {
         done()
       })
   })
+
+  test('keeps binary images intact - Gulp 5 would otherwise decode them as utf8 text and corrupt or drop them', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    const pngFile = `${srcPath}/binary.png`
+    const original = makePng()
+    fs.writeFileSync(pngFile, original)
+    expect.assertions(4)
+    const browserPath = gulpConfig.get('browser.to')
+    imagesFor(pngFile, browserPath)
+      .on('finish', () => {
+        const outputPath = `${browserPath}/binary.png`
+        expect(fs.existsSync(outputPath)).toBeTruthy()
+        const optimized = fs.readFileSync(outputPath)
+        // Still a real PNG (signature and IEND intact) and never bigger than what went in.
+        expect(optimized.subarray(0, 8).equals(original.subarray(0, 8))).toBeTruthy()
+        expect(optimized.subarray(-12).equals(original.subarray(-12))).toBeTruthy()
+        expect(optimized.length).toBeLessThanOrEqual(original.length)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+})
+
+describe('loadImagemin', () => {
+  test('loads the gulp-imagemin plugin factory from the project directory', () => {
+    expect.assertions(1)
+    expect(typeof loadImagemin()).toBe('function')
+  })
+
+  test('throws a helpful error with install instructions when gulp-imagemin is not installed', () => {
+    expect.assertions(2)
+    const emptyProject = fs.mkdtempSync(`${os.tmpdir()}/no-imagemin-`)
+    try {
+      expect(() => loadImagemin(emptyProject)).toThrow(/optional peer dependency gulp-imagemin, which is not installed/)
+      expect(() => loadImagemin(emptyProject)).toThrow(/github:jheagle\/gulp-imagemin#common-js-compatibility/)
+    } finally {
+      fs.rmSync(emptyProject, { recursive: true })
+    }
+  })
 })

package/functions/partials/removeDirectory.mjs

@@ -1,20 +1,34 @@
-import { rm, exists } from 'fs'
+import { access, rm } from 'node:fs/promises'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const attempts = 4
+
+const exists = dirPath => access(dirPath).then(() => true, () => false)
 
 /**
- * Return a promise to be completed once the specified directory is deleted.
+ * Delete a directory and everything in it, resolving only once it is really gone.
+ *
+ * A single rm can leave a directory behind - most often when something is still writing into it (a build task, a
+ * watcher, a dev server) or has it briefly locked (EBUSY/EPERM/ENOTEMPTY) - which silently leaves stale output for
+ * the next build. So: Node's own retry-with-back-off handles the transient errors, then the directory is checked and
+ * removed again if it was recreated, and a clear error is raised rather than carrying on with stale output.
  * @memberOf module:partials
  * @param {string} dirPath
- * @returns {Promise<*>}
+ * @returns {Promise<string>} Resolves with dirPath once the directory no longer exists (or already didn't).
+ * @throws {Error} If the directory still exists after several attempts.
  */
-export const removeDirectory = dirPath => new Promise(
-  (resolve, reject) => exists(
-    dirPath,
-    doesExist => doesExist
-      ? rm(
-        dirPath,
-        { recursive: true },
-        error => error ? reject(error) : resolve(dirPath)
-      )
-      : resolve(dirPath)
+export const removeDirectory = async dirPath => {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    await rm(dirPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+    if (!await exists(dirPath)) {
+      return dirPath
+    }
+    if (attempt < attempts) {
+      await sleep(200 * attempt)
+    }
+  }
+  throw new Error(
+    `Unable to remove "${dirPath}" - it was recreated or is locked. Stop anything that has it open or is writing ` +
+    'into it (watchers, dev servers, editors, other build tasks) and try again.'
   )
-)
+}

package/functions/partials/removeDirectory.test.mjs

@@ -1,6 +1,26 @@
 import fs from 'fs'
+import { rm } from 'node:fs/promises'
 import { removeDirectory } from './removeDirectory.mjs'
 
+// Wrap rm so tests can simulate something recreating the directory while (or right after) it is deleted.
+jest.mock('node:fs/promises', () => {
+  const actual = jest.requireActual('node:fs/promises')
+  return { ...actual, rm: jest.fn(actual.rm) }
+})
+const { rm: realRm } = jest.requireActual('node:fs/promises')
+
+const dirPath = 'remove-directory'
+const recreateAfterRemoving = async (target, options) => {
+  await realRm(target, options)
+  fs.mkdirSync(target)
+}
+
+afterEach(() => {
+  rm.mockReset()
+  rm.mockImplementation(realRm)
+  fs.rmSync(dirPath, { recursive: true, force: true })
+})
+
 describe('removeDirectory', () => {
   test('able to delete the remove-directory', async () => {
     const dirPath = 'remove-directory'
@@ -25,4 +45,28 @@ describe('removeDirectory', () => {
     expect(fs.existsSync(dirPath)).toBeFalsy()
     expect(await removeDirectory(dirPath)).toBe(dirPath)
   })
+
+  test('removes with force and Node\'s built-in retry-with-back-off for busy or locked directories', async () => {
+    expect.assertions(1)
+    fs.mkdirSync(dirPath)
+    await removeDirectory(dirPath)
+    expect(rm).toHaveBeenCalledWith(dirPath, expect.objectContaining({ recursive: true, force: true, maxRetries: 5 }))
+  })
+
+  test('removes the directory again when something recreates it right after the first removal', async () => {
+    expect.assertions(2)
+    fs.mkdirSync(dirPath)
+    rm.mockImplementationOnce(recreateAfterRemoving)
+    await removeDirectory(dirPath)
+    expect(fs.existsSync(dirPath)).toBeFalsy()
+    expect(rm).toHaveBeenCalledTimes(2)
+  })
+
+  test('fails with a clear error instead of leaving stale output when the directory keeps coming back', async () => {
+    expect.assertions(2)
+    fs.mkdirSync(dirPath)
+    rm.mockImplementation(recreateAfterRemoving)
+    await expect(removeDirectory(dirPath)).rejects.toThrow(/Unable to remove "remove-directory" - it was recreated or is locked/)
+    expect(rm).toHaveBeenCalledTimes(4)
+  })
 })

package/functions/partials/sassFor.mjs

@@ -1,6 +1,8 @@
 import { dest, src } from 'gulp'
 import * as gulpConfig from '../../gulp.config.mjs'
-import cssnano from 'gulp-cssnano'
+import autoprefixer from 'autoprefixer'
+import cssnano from 'cssnano'
+import postcss from 'gulp-postcss'
 import rename from 'gulp-rename'
 import * as sass from 'sass'
 import { default as gulpSass } from 'gulp-sass'
@@ -17,6 +19,7 @@ const runSass = gulpSass(sass)
 export const sassFor = (srcSearch = gulpConfig.get('sass.from'), cssPath = gulpConfig.get('sass.to')) => src(srcSearch)
   .pipe(runSass().on('error', runSass.logError)) // Passes it through a gulp-sass, log errors to console
   .pipe(dest(cssPath))
-  .pipe(cssnano())
+  // add: false - the old gulp-cssnano only ever removed obsolete vendor prefixes, never added any; keep that.
+  .pipe(postcss([autoprefixer({ add: false }), cssnano()]))
   .pipe(rename({ extname: '.min.css' }))
   .pipe(dest(cssPath))

package/functions/partials/sassFor.test.mjs

@@ -27,10 +27,7 @@ const sassContents = 'html\n' +
 
 const sassPath = gulpConfig.get('sass.path')
 
-beforeEach(() => {
-  setUp.beforeEach()
-  return fs.mkdirSync(sassPath, { recursive: true })
-})
+beforeEach(() => setUp.beforeEach().then(() => fs.mkdirSync(sassPath, { recursive: true })))
 
 afterEach(setUp.afterEach)
 
@@ -60,4 +57,25 @@ describe('sassFor', () => {
         done()
       })
   })
+
+  test('also writes a minified .min.css next to the css output', done => {
+    const sassFile = `${sassPath}/sassFor.sass`
+    fs.writeFileSync(sassFile, sassContents)
+    expect.assertions(4)
+    const cssPath = gulpConfig.get('sass.to')
+    sassFor(sassFile)
+      .on('finish', () => {
+        const cssContents = fs.readFileSync(`${cssPath}/sassFor.css`).toString()
+        const minContents = fs.readFileSync(`${cssPath}/sassFor.min.css`).toString()
+        expect(minContents.length).toBeLessThan(cssContents.length)
+        expect(countMatches(minContents.trim(), '\n')).toEqual(0)
+        expect(minContents).toContain('outline:none')
+        expect(minContents).toContain('text-align:center')
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
 })