js-build-tools 6.6.0 → 6.8.0

package/functions/partials/addToReadme.test.mjs

@@ -1,34 +1,34 @@
-/* eslint-disable no-template-curly-in-string -- fixture source code, the ${...} is meant to stay literal */
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { addToReadme } from './addToReadme.mjs'
-
-setUp.setDefaults('test-add-to-readme')
-const gulpConfig = setUp.gulpConfig
-gulpConfig.set('dist.from', 'test-temp/src/addToReadme.js')
-
-const rawContents = '/**\n' +
-  ' * Say hello with a given name.\n' +
-  ' * @param {string} name\n' +
-  ' * @returns {string}\n' +
-  ' */\n' +
-  'const sayHello = name => `Hello from ${name}`\n' +
-  '\n' +
-  'module.exports = sayHello\n'
-
-beforeEach(() => setUp.beforeEach()
-  .then(() => fs.writeFileSync(gulpConfig.get('srcPath') + '/addToReadme.js', rawContents)))
-
-afterEach(setUp.afterEach)
-
-describe('addToReadme', () => {
-  test('generates the documentation', async () => {
-    const readmeFilePath = gulpConfig.get('readme.to') + gulpConfig.get('readme.file')
-    expect.assertions(2)
-    await addToReadme()
-    await expect(fs.existsSync(readmeFilePath)).toBeTruthy()
-    const readme = await fs.readFileSync(readmeFilePath)
-    // At least the documentation will have the addToReadme documentation
-    await expect(readme.includes('sayHello')).toBeTruthy()
-  })
-})
+/* eslint-disable no-template-curly-in-string -- fixture source code, the ${...} is meant to stay literal */
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { addToReadme } from './addToReadme.mjs'
+
+setUp.setDefaults('test-add-to-readme')
+const gulpConfig = setUp.gulpConfig
+gulpConfig.set('dist.from', 'test-temp/src/addToReadme.js')
+
+const rawContents = '/**\n' +
+  ' * Say hello with a given name.\n' +
+  ' * @param {string} name\n' +
+  ' * @returns {string}\n' +
+  ' */\n' +
+  'const sayHello = name => `Hello from ${name}`\n' +
+  '\n' +
+  'module.exports = sayHello\n'
+
+beforeEach(() => setUp.beforeEach()
+  .then(() => fs.writeFileSync(gulpConfig.get('srcPath') + '/addToReadme.js', rawContents)))
+
+afterEach(setUp.afterEach)
+
+describe('addToReadme', () => {
+  test('generates the documentation', async () => {
+    const readmeFilePath = gulpConfig.get('readme.to') + gulpConfig.get('readme.file')
+    expect.assertions(2)
+    await addToReadme()
+    await expect(fs.existsSync(readmeFilePath)).toBeTruthy()
+    const readme = await fs.readFileSync(readmeFilePath)
+    // At least the documentation will have the addToReadme documentation
+    await expect(readme.includes('sayHello')).toBeTruthy()
+  })
+})

package/functions/partials/beginWatcher.mjs

@@ -1,9 +1,9 @@
-import * as gulpConfig from '../../gulp.config.mjs'
-import { watch } from 'gulp'
-
-/**
- * Create a chokidar instance which watches and triggers change when the globed files are modified.
- * @memberOf module:partials
- * @returns {FSWatcher}
- */
-export const beginWatcher = () => watch(gulpConfig.get('test.watch'))
+import * as gulpConfig from '../../gulp.config.mjs'
+import { watch } from 'gulp'
+
+/**
+ * Create a chokidar instance which watches and triggers change when the globed files are modified.
+ * @memberOf module:partials
+ * @returns {FSWatcher}
+ */
+export const beginWatcher = () => watch(gulpConfig.get('test.watch'))

package/functions/partials/beginWatcher.test.mjs

@@ -1,19 +1,19 @@
-import * as setUp from '../test-helpers/setUp.mjs'
-import { beginWatcher } from './beginWatcher.mjs'
-import { EventEmitter } from 'node:events'
-
-setUp.setDefaults('test-begin-watcher')
-const gulpConfig = setUp.gulpConfig
-
-beforeEach(setUp.beforeEach)
-
-afterEach(setUp.afterEach)
-
-describe('beginWatcher', () => {
-  test('returns instance of EventEmitter / FSWatcher', () => {
-    gulpConfig.set('test.watch', 'test-begin-watcher/*.js')
-    const fsWatcher = beginWatcher()
-    expect(fsWatcher).toBeInstanceOf(EventEmitter)
-    fsWatcher.close()
-  })
-})
+import * as setUp from '../test-helpers/setUp.mjs'
+import { beginWatcher } from './beginWatcher.mjs'
+import { EventEmitter } from 'node:events'
+
+setUp.setDefaults('test-begin-watcher')
+const gulpConfig = setUp.gulpConfig
+
+beforeEach(setUp.beforeEach)
+
+afterEach(setUp.afterEach)
+
+describe('beginWatcher', () => {
+  test('returns instance of EventEmitter / FSWatcher', () => {
+    gulpConfig.set('test.watch', 'test-begin-watcher/*.js')
+    const fsWatcher = beginWatcher()
+    expect(fsWatcher).toBeInstanceOf(EventEmitter)
+    fsWatcher.close()
+  })
+})

package/functions/partials/cacheFiles.mjs

@@ -0,0 +1,114 @@
+import { createHash, randomUUID } from 'crypto'
+import { mkdir, readFile, rename, writeFile } from 'fs/promises'
+import path from 'path'
+import { Transform } from 'stream'
+
+// Marks a file sent to the plugin with its cache file and its path, so its result is cached even if the plugin renames it
+const cacheFile = Symbol('cacheFile')
+
+/**
+ * The cache file for a file's contents: a hash of the cache name, the fingerprint and the contents, so the same file
+ * with other plugin settings or plugin versions gets a result of its own.
+ * @private
+ * @param {string} directory
+ * @param {string} name
+ * @param {string} fingerprint
+ * @param {Buffer} contents
+ * @returns {string}
+ */
+const cachePath = (directory, name, fingerprint, contents) => path.join(
+  directory,
+  name,
+  createHash('sha256').update(name).update('\0').update(fingerprint).update('\0').update(contents).digest('hex')
+)
+
+/**
+ * Write through a temporary file and rename it, so a reader (another build or test worker) never sees a half-written
+ * result.
+ * @private
+ * @param {string} file
+ * @param {Buffer} contents
+ * @returns {Promise<void>}
+ */
+const writeAtomic = async (file, contents) => {
+  await mkdir(path.dirname(file), { recursive: true })
+  const temporary = `${file}.${randomUUID()}.tmp`
+  await writeFile(temporary, contents)
+  await rename(temporary, file)
+}
+
+/**
+ * Run a gulp plugin only on files it hasn't processed before. A file whose contents (with this cache name and
+ * fingerprint) were processed by an earlier run gets that run's result from the cache instead, and skips the plugin.
+ * Replaces gulp-cache, which kept one cache for every process in the system's temp folder.
+ *
+ * A result is cached when the plugin passes on the file object it was given (as gulp plugins usually do); a plugin
+ * that makes new file objects still works, its results just aren't cached. When the plugin renames a file, the cache
+ * keeps the new name too (next to the result, as `<entry>.path`), so a cached file is renamed the same way. Entries
+ * are never pruned: delete the directory to start over.
+ * @memberOf module:partials
+ * @param {stream.Transform} plugin - The gulp plugin stream to run on uncached files (e.g. imagemin()).
+ * @param {Object} options
+ * @param {string} options.directory - Where cached results are kept (see images.cacheDir).
+ * @param {string} [options.name='default'] - The cache's folder; keeps results of different plugin settings apart.
+ * @param {string} [options.fingerprint=''] - Anything else that changes the plugin's output, such as its version and
+ * options: when it changes, earlier results are no longer used.
+ * @returns {stream.Transform}
+ */
+export const cacheFiles = (plugin, { directory, name = 'default', fingerprint = '' }) => {
+  const writes = []
+  const pluginDone = new Promise((resolve, reject) => {
+    plugin.on('end', resolve)
+    plugin.on('error', reject)
+  })
+  // The error also reaches the stream (below); this only stops it from being reported a second time as unhandled
+  pluginDone.catch(() => {})
+
+  const stream = new Transform({
+    objectMode: true,
+    transform (file, encoding, callback) {
+      if (!file.isBuffer()) {
+        callback(null, file)
+        return
+      }
+      const cached = cachePath(directory, name, fingerprint, file.contents)
+      readFile(cached).then(
+        async contents => {
+          file.contents = contents
+          // Written before the result, so it's there whenever the result is
+          const renamed = await readFile(`${cached}.path`, 'utf8').catch(() => undefined)
+          if (renamed !== undefined) {
+            file.path = path.join(path.dirname(file.path), renamed)
+          }
+          callback(null, file)
+        },
+        () => {
+          file[cacheFile] = { cached, from: file.path }
+          plugin.write(file)
+          callback()
+        }
+      )
+    },
+    flush (callback) {
+      plugin.end()
+      pluginDone
+        .then(() => Promise.all(writes))
+        .then(() => callback(), callback)
+    }
+  })
+
+  plugin.on('data', file => {
+    const tag = file[cacheFile]
+    delete file[cacheFile]
+    if (tag && file.isBuffer()) {
+      const { cached, from } = tag
+      const renamed = file.path === from ? Promise.resolve() : writeAtomic(`${cached}.path`, path.relative(path.dirname(from), file.path))
+      // The cache only saves time: a result that can't be written is processed again next run, not a failed build
+      writes.push(renamed.then(() => writeAtomic(cached, file.contents)).catch(() => {}))
+    }
+    stream.push(file)
+  })
+  plugin.on('error', error => stream.destroy(error))
+
+  return stream
+}

package/functions/partials/cacheFiles.test.mjs

@@ -0,0 +1,151 @@
+import fs from 'fs'
+import path from 'path'
+import { Readable, Transform } from 'stream'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { cacheFiles } from './cacheFiles.mjs'
+
+setUp.setDefaults('test-cache-files')
+const gulpConfig = setUp.gulpConfig
+
+beforeEach(setUp.beforeEach)
+
+afterEach(setUp.afterEach)
+
+// Just enough of a Vinyl file for cacheFiles and the fake plugin
+const file = (filePath, text) => ({
+  path: filePath,
+  contents: text === null ? null : Buffer.from(text),
+  isBuffer () {
+    return Buffer.isBuffer(this.contents)
+  }
+})
+
+// A plugin that upper-cases each file, counting the files it's given
+const upperCase = () => {
+  const plugin = new Transform({
+    objectMode: true,
+    transform (input, encoding, callback) {
+      plugin.calls++
+      input.contents = Buffer.from(input.contents.toString().toUpperCase())
+      callback(null, input)
+    }
+  })
+  plugin.calls = 0
+  return plugin
+}
+
+// Run files through cacheFiles and collect what comes out, as text by path
+const run = (files, plugin, options) => new Promise((resolve, reject) => {
+  const out = {}
+  Readable.from(files)
+    .pipe(cacheFiles(plugin, options))
+    .on('data', output => {
+      out[path.basename(output.path)] = output.contents === null ? null : output.contents.toString()
+    })
+    .on('end', () => resolve(out))
+    .on('error', reject)
+})
+
+const cacheDir = () => `${gulpConfig.get('rootPath')}cache`
+
+describe('cacheFiles', () => {
+  test('a file it hasn\'t seen goes through the plugin, and the result is cached', async () => {
+    const plugin = upperCase()
+    expect(await run([file('/a.txt', 'one'), file('/b.txt', 'two')], plugin, { directory: cacheDir() }))
+      .toEqual({ 'a.txt': 'ONE', 'b.txt': 'TWO' })
+    expect(plugin.calls).toBe(2)
+    expect(fs.readdirSync(path.join(cacheDir(), 'default'))).toHaveLength(2)
+  })
+
+  test('the same contents again come from the cache, without the plugin', async () => {
+    await run([file('/a.txt', 'one')], upperCase(), { directory: cacheDir() })
+    const plugin = upperCase()
+    // Another path with the same contents is the same result
+    expect(await run([file('/a.txt', 'one'), file('/copy.txt', 'one')], plugin, { directory: cacheDir() }))
+      .toEqual({ 'a.txt': 'ONE', 'copy.txt': 'ONE' })
+    expect(plugin.calls).toBe(0)
+  })
+
+  test('changed contents, or another cache name, go through the plugin again', async () => {
+    await run([file('/a.txt', 'one')], upperCase(), { directory: cacheDir() })
+    const changed = upperCase()
+    expect(await run([file('/a.txt', 'one!')], changed, { directory: cacheDir() })).toEqual({ 'a.txt': 'ONE!' })
+    expect(changed.calls).toBe(1)
+    const otherName = upperCase()
+    expect(await run([file('/a.txt', 'one')], otherName, { directory: cacheDir(), name: 'other' })).toEqual({ 'a.txt': 'ONE' })
+    expect(otherName.calls).toBe(1)
+  })
+
+  test('another fingerprint (say, a new plugin version) goes through the plugin again', async () => {
+    await run([file('/a.txt', 'one')], upperCase(), { directory: cacheDir(), fingerprint: 'v1' })
+    const sameVersion = upperCase()
+    await run([file('/a.txt', 'one')], sameVersion, { directory: cacheDir(), fingerprint: 'v1' })
+    expect(sameVersion.calls).toBe(0)
+    const newVersion = upperCase()
+    await run([file('/a.txt', 'one')], newVersion, { directory: cacheDir(), fingerprint: 'v2' })
+    expect(newVersion.calls).toBe(1)
+  })
+
+  test('a plugin that renames files has its results cached, and a cached file is renamed the same way', async () => {
+    const renaming = () => {
+      const plugin = upperCase()
+      const transform = plugin._transform.bind(plugin)
+      plugin._transform = (input, encoding, callback) => transform(input, encoding, (error, output) => {
+        output.path = output.path.replace('.txt', '.md')
+        callback(error, output)
+      })
+      return plugin
+    }
+    expect(await run([file('/a.txt', 'one')], renaming(), { directory: cacheDir() })).toEqual({ 'a.md': 'ONE' })
+    const again = renaming()
+    // From the cache, renamed the same way, without the plugin
+    expect(await run([file('/a.txt', 'one')], again, { directory: cacheDir() })).toEqual({ 'a.md': 'ONE' })
+    expect(again.calls).toBe(0)
+  })
+
+  test('a plugin that makes new file objects still works; its results just aren\'t cached', async () => {
+    const copying = new Transform({
+      objectMode: true,
+      transform (input, encoding, callback) {
+        callback(null, file(input.path, input.contents.toString().toUpperCase()))
+      }
+    })
+    expect(await run([file('/a.txt', 'one')], copying, { directory: cacheDir() })).toEqual({ 'a.txt': 'ONE' })
+    expect(fs.existsSync(path.join(cacheDir(), 'default'))).toBe(false)
+  })
+
+  test('a file without contents (a directory) passes straight through', async () => {
+    const plugin = upperCase()
+    expect(await run([file('/folder', null)], plugin, { directory: cacheDir() })).toEqual({ folder: null })
+    expect(plugin.calls).toBe(0)
+  })
+
+  test('a cache that can\'t be written still gives the plugin\'s results', async () => {
+    // A file where the cache directory should be: nothing can be written inside it
+    fs.writeFileSync(cacheDir(), 'not a directory')
+    const plugin = upperCase()
+    expect(await run([file('/a.txt', 'one')], plugin, { directory: cacheDir() })).toEqual({ 'a.txt': 'ONE' })
+    expect(plugin.calls).toBe(1)
+  })
+
+  test('two runs at once into the same cache both get every result (the cache file is written whole)', async () => {
+    const files = () => Array.from({ length: 20 }, (_, index) => file(`/f${index}.txt`, `file ${index}`))
+    const expected = Object.fromEntries(Array.from({ length: 20 }, (_, index) => [`f${index}.txt`, `FILE ${index}`]))
+    const results = await Promise.all([
+      run(files(), upperCase(), { directory: cacheDir() }),
+      run(files(), upperCase(), { directory: cacheDir() })
+    ])
+    expect(results).toEqual([expected, expected])
+    expect(fs.readdirSync(path.join(cacheDir(), 'default')).filter(name => name.endsWith('.tmp'))).toEqual([])
+  })
+
+  test('a plugin error fails the stream', async () => {
+    const failing = new Transform({
+      objectMode: true,
+      transform (input, encoding, callback) {
+        callback(new Error('plugin failed'))
+      }
+    })
+    await expect(run([file('/a.txt', 'one')], failing, { directory: cacheDir() })).rejects.toThrow('plugin failed')
+  })
+})

package/functions/partials/clean.mjs

@@ -1,13 +1,13 @@
-import * as gulpConfig from '../../gulp.config.mjs'
-import { removeDirectory } from './removeDirectory.mjs'
-
-/**
- * Deletes all the distribution and browser files (used before create a new build).
- * Configure array of directories to remove with 'cleanPaths'.
- * @memberOf module:partials
- * @returns {Promise<string[]> | *}
- */
-export const clean = () => gulpConfig.get('cleanPaths').reduce(
-  (promise, path) => promise.then(() => removeDirectory(path)),
-  Promise.resolve()
-)
+import * as gulpConfig from '../../gulp.config.mjs'
+import { removeDirectory } from './removeDirectory.mjs'
+
+/**
+ * Deletes all the distribution and browser files (used before create a new build).
+ * Configure array of directories to remove with 'cleanPaths'.
+ * @memberOf module:partials
+ * @returns {Promise<string[]> | *}
+ */
+export const clean = () => gulpConfig.get('cleanPaths').reduce(
+  (promise, path) => promise.then(() => removeDirectory(path)),
+  Promise.resolve()
+)

package/functions/partials/clean.test.mjs

@@ -1,22 +1,22 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { clean } from './clean.mjs'
-
-setUp.setDefaults('test-clean')
-const gulpConfig = setUp.gulpConfig
-const srcPath = gulpConfig.get('srcPath')
-gulpConfig.set('cleanPaths', [srcPath])
-
-beforeEach(setUp.beforeEach)
-
-afterEach(setUp.afterEach)
-
-describe('clean', () => {
-  test('removes all contents of directories specified', async () => {
-    expect.assertions(2)
-    expect(fs.readdirSync(srcPath)).toBeTruthy()
-    // Run the clean script to empty the directories
-    await clean()
-    expect(fs.existsSync(srcPath)).toBeFalsy()
-  })
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { clean } from './clean.mjs'
+
+setUp.setDefaults('test-clean')
+const gulpConfig = setUp.gulpConfig
+const srcPath = gulpConfig.get('srcPath')
+gulpConfig.set('cleanPaths', [srcPath])
+
+beforeEach(setUp.beforeEach)
+
+afterEach(setUp.afterEach)
+
+describe('clean', () => {
+  test('removes all contents of directories specified', async () => {
+    expect.assertions(2)
+    expect(fs.readdirSync(srcPath)).toBeTruthy()
+    // Run the clean script to empty the directories
+    await clean()
+    expect(fs.existsSync(srcPath)).toBeFalsy()
+  })
+})

package/functions/partials/copyFor.mjs

@@ -1,15 +1,15 @@
-import { dest, src } from 'gulp'
-
-/**
- * Copy some files to a different location.
- * @memberOf module:partials
- * @param {string|array} srcPath
- * @param {string} destPath
- * @param {Object} [options]
- * @param {string} [options.base] - Passed through to gulp's own src(pattern, {base}), to preserve srcPath's own
- * subdirectory structure in destPath instead of flattening it.
- * @returns {stream.Stream}
- */
-// encoding: false copies the bytes untouched - Gulp 5's default utf8 handling corrupts binary files such as fonts.
-export const copyFor = (srcPath, destPath, { base } = {}) => src(srcPath, { encoding: false, ...(base ? { base } : {}) })
-  .pipe(dest(destPath))
+import { dest, src } from 'gulp'
+
+/**
+ * Copy some files to a different location.
+ * @memberOf module:partials
+ * @param {string|array} srcPath
+ * @param {string} destPath
+ * @param {Object} [options]
+ * @param {string} [options.base] - Passed through to gulp's own src(pattern, {base}), to preserve srcPath's own
+ * subdirectory structure in destPath instead of flattening it.
+ * @returns {stream.Stream}
+ */
+// encoding: false copies the bytes untouched - Gulp 5's default utf8 handling corrupts binary files such as fonts.
+export const copyFor = (srcPath, destPath, { base } = {}) => src(srcPath, { encoding: false, ...(base ? { base } : {}) })
+  .pipe(dest(destPath))

package/functions/partials/copyFor.test.mjs

@@ -1,53 +1,53 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { copyFor } from './copyFor.mjs'
-
-setUp.setDefaults('test-copy-for')
-const gulpConfig = setUp.gulpConfig
-
-const fileContents = 'some file contents'
-
-beforeEach(setUp.beforeEach)
-
-afterEach(setUp.afterEach)
-
-describe('copyFor', () => {
-  test('copies the file and ', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    const copyFile = `${srcPath}/fileToCopy.txt`
-    fs.writeFileSync(copyFile, fileContents)
-    expect.assertions(3)
-    const oldContents = fs.readFileSync(copyFile).toString()
-    expect(oldContents).toEqual(fileContents)
-    const browserPath = gulpConfig.get('browser.to')
-    copyFor(copyFile, browserPath)
-      .on('finish', () => {
-        expect(fs.existsSync(browserPath)).toBeTruthy()
-        const movedContents = fs.readFileSync(`${browserPath}/fileToCopy.txt`).toString()
-        expect(movedContents).toEqual(fileContents)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        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()
-      })
-  })
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { copyFor } from './copyFor.mjs'
+
+setUp.setDefaults('test-copy-for')
+const gulpConfig = setUp.gulpConfig
+
+const fileContents = 'some file contents'
+
+beforeEach(setUp.beforeEach)
+
+afterEach(setUp.afterEach)
+
+describe('copyFor', () => {
+  test('copies the file and ', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    const copyFile = `${srcPath}/fileToCopy.txt`
+    fs.writeFileSync(copyFile, fileContents)
+    expect.assertions(3)
+    const oldContents = fs.readFileSync(copyFile).toString()
+    expect(oldContents).toEqual(fileContents)
+    const browserPath = gulpConfig.get('browser.to')
+    copyFor(copyFile, browserPath)
+      .on('finish', () => {
+        expect(fs.existsSync(browserPath)).toBeTruthy()
+        const movedContents = fs.readFileSync(`${browserPath}/fileToCopy.txt`).toString()
+        expect(movedContents).toEqual(fileContents)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        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/distFor.mjs

@@ -1,22 +1,22 @@
-import babel from 'gulp-babel'
-import { dest, src } from 'gulp'
-import { distForSrc } from './distForSrc.mjs'
-import * as gulpConfig from '../../gulp.config.mjs'
-import through from 'through2'
-
-/**
- * Build the distribution for a given source pattern.
- * @memberOf module:partials
- * @param {string|array} [srcPath='src/config/path/dist/for']
- * @param {string} [destPath='dist/config/path']
- * @returns {stream.Stream}
- */
-export const distFor = (srcPath = distForSrc(), destPath = gulpConfig.get('dist.to')) => src(srcPath)
-  .pipe(babel())
-  .pipe(through.obj(function (file, enc, callback) {
-    const regex = /\.mjs(['"]\s*\))/gi
-    file.contents = Buffer.from(file.contents.toString().replaceAll(regex, '.js$1'))
-    this.push(file)
-    callback()
-  }))
-  .pipe(dest(destPath))
+import babel from 'gulp-babel'
+import { dest, src } from 'gulp'
+import { distForSrc } from './distForSrc.mjs'
+import * as gulpConfig from '../../gulp.config.mjs'
+import through from 'through2'
+
+/**
+ * Build the distribution for a given source pattern.
+ * @memberOf module:partials
+ * @param {string|array} [srcPath='src/config/path/dist/for']
+ * @param {string} [destPath='dist/config/path']
+ * @returns {stream.Stream}
+ */
+export const distFor = (srcPath = distForSrc(), destPath = gulpConfig.get('dist.to')) => src(srcPath)
+  .pipe(babel())
+  .pipe(through.obj(function (file, enc, callback) {
+    const regex = /\.mjs(['"]\s*\))/gi
+    file.contents = Buffer.from(file.contents.toString().replaceAll(regex, '.js$1'))
+    this.push(file)
+    callback()
+  }))
+  .pipe(dest(destPath))