js-build-tools 6.5.0 → 6.7.0

package/functions/bundle.mjs

@@ -1,44 +1,44 @@
-import browserify from 'browserify'
-import { dest } from 'gulp'
-import mergeStream from 'merge-stream'
-import * as gulpConfig from '../gulp.config.mjs'
-import source from 'vinyl-source-stream'
-import { getBundleConfigs } from './utilities/getBundleConfigs.mjs'
-
-/**
- * Starting at each bundle's own entry point (dist.main for the primary bundle, or its own
- * override from browser.bundles), bundle all the reachable files into a single file per bundle and
- * store them in the specified output directory. A project with no browser.bundles entries gets
- * exactly the one bundle it always did; each additional entry produces its own separate bundle
- * (for example, a render-only variant built from a different entry point than the full bundle).
- *
- * A bundle's name does double duty: it names the output file (name.js) and, via browserify's
- * `standalone` option, is also the name its exports are exposed under - as a global when loaded
- * with a bare `<script>` tag, or as the module when required via CommonJS/AMD. Without this, a
- * bundle built from a real entry point (one that actually exports something) builds successfully
- * but exposes nothing a consumer can reach.
- *
- * Two escape hatches from browser.config.json keep an unwanted dependency (or a dependency's dependency) out of the
- * bundle: 'ignore' replaces it with an empty object (safe when your code never actually calls into it - for example
- * a library's default option value you always override with your own) and 'exclude' leaves it out entirely (your
- * code must not require it, or provide it another way, such as a separate script tag).
- * @memberOf module:js-build-tools
- * @returns {stream.Stream}
- */
-export const bundle = () => mergeStream(
-  getBundleConfigs().map(({ name, main, ignore, exclude }) => {
-    const bundler = browserify(main, { standalone: name })
-    if (ignore.length) {
-      bundler.ignore(ignore)
-    }
-    if (exclude.length) {
-      bundler.exclude(exclude)
-    }
-    return bundler
-      .bundle()
-      .pipe(source(`${name}.js`))
-  })
-  // One shared dest() for every bundle, not one per bundle - vinyl-fs's dest() races against
-  // itself (a real "write after end" failure) when two separate dest() streams target the same
-  // directory concurrently, which every additional bundle's own dest() call otherwise would.
-).pipe(dest(gulpConfig.get('browser.to')))
+import browserify from 'browserify'
+import { dest } from 'gulp'
+import mergeStream from 'merge-stream'
+import * as gulpConfig from '../gulp.config.mjs'
+import source from 'vinyl-source-stream'
+import { getBundleConfigs } from './utilities/getBundleConfigs.mjs'
+
+/**
+ * Starting at each bundle's own entry point (dist.main for the primary bundle, or its own
+ * override from browser.bundles), bundle all the reachable files into a single file per bundle and
+ * store them in the specified output directory. A project with no browser.bundles entries gets
+ * exactly the one bundle it always did; each additional entry produces its own separate bundle
+ * (for example, a render-only variant built from a different entry point than the full bundle).
+ *
+ * A bundle's name does double duty: it names the output file (name.js) and, via browserify's
+ * `standalone` option, is also the name its exports are exposed under - as a global when loaded
+ * with a bare `<script>` tag, or as the module when required via CommonJS/AMD. Without this, a
+ * bundle built from a real entry point (one that actually exports something) builds successfully
+ * but exposes nothing a consumer can reach.
+ *
+ * Two escape hatches from browser.config.json keep an unwanted dependency (or a dependency's dependency) out of the
+ * bundle: 'ignore' replaces it with an empty object (safe when your code never actually calls into it - for example
+ * a library's default option value you always override with your own) and 'exclude' leaves it out entirely (your
+ * code must not require it, or provide it another way, such as a separate script tag).
+ * @memberOf module:js-build-tools
+ * @returns {stream.Stream}
+ */
+export const bundle = () => mergeStream(
+  getBundleConfigs().map(({ name, main, ignore, exclude }) => {
+    const bundler = browserify(main, { standalone: name })
+    if (ignore.length) {
+      bundler.ignore(ignore)
+    }
+    if (exclude.length) {
+      bundler.exclude(exclude)
+    }
+    return bundler
+      .bundle()
+      .pipe(source(`${name}.js`))
+  })
+  // One shared dest() for every bundle, not one per bundle - vinyl-fs's dest() races against
+  // itself (a real "write after end" failure) when two separate dest() streams target the same
+  // directory concurrently, which every additional bundle's own dest() call otherwise would.
+).pipe(dest(gulpConfig.get('browser.to')))

package/functions/bundle.test.mjs

@@ -1,219 +1,219 @@
-import fs from 'fs'
-import path from 'path'
-import * as setUp from './test-helpers/setUp.mjs'
-import { bundle } from './bundle.mjs'
-import { countMatches } from 'test-filesystem'
-
-setUp.setDefaults('test-bundle')
-const gulpConfig = setUp.gulpConfig
-
-const file1Contents = 'function file1 () {\n' +
-  '  console.log(\'Hello from file1\')\n' +
-  '}\n' +
-  '\n' +
-  'module.exports = file1\n'
-const file2Contents = 'function file2 () {\n' +
-  '  console.log(\'Good-bye from file2\')\n' +
-  '}\n' +
-  '\n' +
-  'module.exports = file2\n'
-const mainFileContents = 'const file1 = require(\'./sources/file1\')\n' +
-  'const file2 = require(\'./sources/file2\')\n' +
-  '\n' +
-  'module.exports = {\n' +
-  '  file1,\n' +
-  '  file2,\n' +
-  '}\n'
-
-beforeEach(
-  () => setUp.beforeEach()
-    .then(
-      async () => {
-        const distPath = gulpConfig.get('dist.to')
-        const mainFile = gulpConfig.get('dist.main')
-        const sourcesPath = `${distPath}/sources`
-        await fs.mkdirSync(distPath)
-        await fs.mkdirSync(sourcesPath)
-        await fs.writeFileSync(`${sourcesPath}/file1.js`, file1Contents)
-        await fs.writeFileSync(`${sourcesPath}/file2.js`, file2Contents)
-        return fs.writeFileSync(`${mainFile}.js`, mainFileContents)
-      }
-    )
-)
-
-afterEach(setUp.afterEach)
-
-describe('bundle', () => {
-  test('copies all the dist contents into a single file for browsers', done => {
-    const distPath = gulpConfig.get('dist.to')
-    const destFile = `${gulpConfig.get('browser.name')}.js`
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${destFile}`
-    const sourcesPath = `${distPath}/sources`
-    const file1Path = `${sourcesPath}/file1.js`
-    const file2Path = `${sourcesPath}/file2.js`
-    const oldFile1Contents = fs.readFileSync(file1Path).toString()
-    const oldFile2Contents = fs.readFileSync(file2Path).toString()
-    expect.assertions(2)
-    bundle()
-      .on('finish', () => {
-        const bundledContents = fs.readFileSync(bundledFile).toString()
-        expect(countMatches(bundledContents, oldFile1Contents)).toEqual(1)
-        expect(countMatches(bundledContents, oldFile2Contents)).toEqual(1)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  })
-
-  test('exposes browser.name as the standalone export, reachable by a real consumer', done => {
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    expect.assertions(2)
-    bundle()
-      .on('finish', () => {
-        // A UMD bundle (browserify's `standalone` option) resolves to its CommonJS branch when
-        // required like this, and to a `window.<browser.name>` global when loaded via a bare
-        // <script> tag in a real browser - both paths hit the same exported value.
-        const resolved = path.resolve(bundledFile)
-        delete require.cache[resolved]
-        const loaded = require(resolved)
-        expect(typeof loaded.file1).toBe('function')
-        expect(typeof loaded.file2).toBe('function')
-        done()
-      })
-      .on('error', error => done(error))
-  })
-})
-
-describe('bundle with additional bundles', () => {
-  const renderOnlyFileContents = 'const file1 = require(\'./sources/file1\')\n' +
-    '\n' +
-    'module.exports = {\n' +
-    '  file1,\n' +
-    '}\n'
-
-  afterEach(() => gulpConfig.set('browser.bundles', []))
-
-  test('produces one file per additional bundle, each from its own entry point', done => {
-    const distPath = gulpConfig.get('dist.to')
-    const renderOnlyMain = `${distPath}/renderOnly`
-    fs.writeFileSync(`${renderOnlyMain}.js`, renderOnlyFileContents)
-    gulpConfig.set('browser.bundles', [{ name: 'renderOnly', main: renderOnlyMain }])
-
-    const destPath = gulpConfig.get('browser.to')
-    const primaryFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    const renderOnlyFile = `${destPath}/renderOnly.js`
-    expect.assertions(4)
-    bundle()
-      .on('finish', () => {
-        // The primary bundle is unaffected - still built from dist.main, still has both files.
-        const primaryContents = fs.readFileSync(primaryFile).toString()
-        expect(primaryContents).toContain('Hello from file1')
-        expect(primaryContents).toContain('Good-bye from file2')
-
-        // The additional bundle came from its own entry point - file1 only, never file2.
-        const renderOnlyContents = fs.readFileSync(renderOnlyFile).toString()
-        expect(renderOnlyContents).toContain('Hello from file1')
-        expect(renderOnlyContents).not.toContain('Good-bye from file2')
-        done()
-      })
-      .on('error', error => done(error))
-  })
-
-  test('an additional bundle exposes its own name as its standalone export', done => {
-    const distPath = gulpConfig.get('dist.to')
-    const renderOnlyMain = `${distPath}/renderOnly`
-    fs.writeFileSync(`${renderOnlyMain}.js`, renderOnlyFileContents)
-    gulpConfig.set('browser.bundles', [{ name: 'renderOnly', main: renderOnlyMain }])
-
-    const destPath = gulpConfig.get('browser.to')
-    const renderOnlyFile = `${destPath}/renderOnly.js`
-    expect.assertions(2)
-    bundle()
-      .on('finish', () => {
-        const resolved = path.resolve(renderOnlyFile)
-        delete require.cache[resolved]
-        const loaded = require(resolved)
-        expect(typeof loaded.file1).toBe('function')
-        expect(loaded.file2).toBeUndefined()
-        done()
-      })
-      .on('error', error => done(error))
-  })
-})
-
-describe('bundle ignore / exclude', () => {
-  const optionalDepMarker = 'MARKER_FROM_THE_OPTIONAL_DEPENDENCY_CODE'
-
-  beforeEach(() => {
-    const tempDir = gulpConfig.get('rootPath')
-    const depDir = `${tempDir}node_modules/optional-dep`
-    fs.mkdirSync(depDir, { recursive: true })
-    fs.writeFileSync(`${depDir}/package.json`, JSON.stringify({ name: 'optional-dep', main: 'index.js' }))
-    fs.writeFileSync(`${depDir}/index.js`, `module.exports = '${optionalDepMarker}'\n`)
-    const distPath = gulpConfig.get('dist.to')
-    const mainFile = gulpConfig.get('dist.main')
-    fs.mkdirSync(distPath, { recursive: true })
-    // Only reached as a fallback for an option the caller always overrides, the way css-select falls back to its
-    // own default adapter (domutils) unless one is given - exactly the case ignore / exclude exist for.
-    fs.writeFileSync(`${mainFile}.js`, 'const optionalDep = require(\'optional-dep\')\n\nmodule.exports = (given) => given || optionalDep\n')
-  })
-
-  test('without ignore or exclude, the dependency is bundled', done => {
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    expect.assertions(1)
-    bundle()
-      .on('finish', () => {
-        expect(fs.readFileSync(bundledFile).toString()).toContain(optionalDepMarker)
-        done()
-      })
-      .on('error', error => done(error))
-  })
-
-  test('ignore replaces the dependency with an empty object, but the bundle still finishes', done => {
-    gulpConfig.set('browser.ignore', ['optional-dep'])
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    expect.assertions(2)
-    bundle()
-      .on('finish', () => {
-        const bundledContents = fs.readFileSync(bundledFile).toString()
-        // The ignored module is still in the bundle (as an empty stub, so requiring it by name still resolves) -
-        // it just no longer has the real code that would have pulled in the marker
-        expect(bundledContents).toContain('optional-dep')
-        expect(bundledContents).not.toContain(optionalDepMarker)
-        done()
-      })
-      .on('error', error => done(error))
-  })
-
-  test('exclude leaves the dependency out of the bundle entirely', done => {
-    gulpConfig.set('browser.exclude', ['optional-dep'])
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    expect.assertions(1)
-    bundle()
-      .on('finish', () => {
-        expect(fs.readFileSync(bundledFile).toString()).not.toContain(optionalDepMarker)
-        done()
-      })
-      .on('error', error => done(error))
-  })
-
-  test('a single string is accepted the same as a one item array', done => {
-    gulpConfig.set('browser.ignore', 'optional-dep')
-    const destPath = gulpConfig.get('browser.to')
-    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
-    expect.assertions(1)
-    bundle()
-      .on('finish', () => {
-        expect(fs.readFileSync(bundledFile).toString()).not.toContain(optionalDepMarker)
-        done()
-      })
-      .on('error', error => done(error))
-  })
-})
+import fs from 'fs'
+import path from 'path'
+import * as setUp from './test-helpers/setUp.mjs'
+import { bundle } from './bundle.mjs'
+import { countMatches } from 'test-filesystem'
+
+setUp.setDefaults('test-bundle')
+const gulpConfig = setUp.gulpConfig
+
+const file1Contents = 'function file1 () {\n' +
+  '  console.log(\'Hello from file1\')\n' +
+  '}\n' +
+  '\n' +
+  'module.exports = file1\n'
+const file2Contents = 'function file2 () {\n' +
+  '  console.log(\'Good-bye from file2\')\n' +
+  '}\n' +
+  '\n' +
+  'module.exports = file2\n'
+const mainFileContents = 'const file1 = require(\'./sources/file1\')\n' +
+  'const file2 = require(\'./sources/file2\')\n' +
+  '\n' +
+  'module.exports = {\n' +
+  '  file1,\n' +
+  '  file2,\n' +
+  '}\n'
+
+beforeEach(
+  () => setUp.beforeEach()
+    .then(
+      async () => {
+        const distPath = gulpConfig.get('dist.to')
+        const mainFile = gulpConfig.get('dist.main')
+        const sourcesPath = `${distPath}/sources`
+        await fs.mkdirSync(distPath)
+        await fs.mkdirSync(sourcesPath)
+        await fs.writeFileSync(`${sourcesPath}/file1.js`, file1Contents)
+        await fs.writeFileSync(`${sourcesPath}/file2.js`, file2Contents)
+        return fs.writeFileSync(`${mainFile}.js`, mainFileContents)
+      }
+    )
+)
+
+afterEach(setUp.afterEach)
+
+describe('bundle', () => {
+  test('copies all the dist contents into a single file for browsers', done => {
+    const distPath = gulpConfig.get('dist.to')
+    const destFile = `${gulpConfig.get('browser.name')}.js`
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${destFile}`
+    const sourcesPath = `${distPath}/sources`
+    const file1Path = `${sourcesPath}/file1.js`
+    const file2Path = `${sourcesPath}/file2.js`
+    const oldFile1Contents = fs.readFileSync(file1Path).toString()
+    const oldFile2Contents = fs.readFileSync(file2Path).toString()
+    expect.assertions(2)
+    bundle()
+      .on('finish', () => {
+        const bundledContents = fs.readFileSync(bundledFile).toString()
+        expect(countMatches(bundledContents, oldFile1Contents)).toEqual(1)
+        expect(countMatches(bundledContents, oldFile2Contents)).toEqual(1)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+
+  test('exposes browser.name as the standalone export, reachable by a real consumer', done => {
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    expect.assertions(2)
+    bundle()
+      .on('finish', () => {
+        // A UMD bundle (browserify's `standalone` option) resolves to its CommonJS branch when
+        // required like this, and to a `window.<browser.name>` global when loaded via a bare
+        // <script> tag in a real browser - both paths hit the same exported value.
+        const resolved = path.resolve(bundledFile)
+        delete require.cache[resolved]
+        const loaded = require(resolved)
+        expect(typeof loaded.file1).toBe('function')
+        expect(typeof loaded.file2).toBe('function')
+        done()
+      })
+      .on('error', error => done(error))
+  })
+})
+
+describe('bundle with additional bundles', () => {
+  const renderOnlyFileContents = 'const file1 = require(\'./sources/file1\')\n' +
+    '\n' +
+    'module.exports = {\n' +
+    '  file1,\n' +
+    '}\n'
+
+  afterEach(() => gulpConfig.set('browser.bundles', []))
+
+  test('produces one file per additional bundle, each from its own entry point', done => {
+    const distPath = gulpConfig.get('dist.to')
+    const renderOnlyMain = `${distPath}/renderOnly`
+    fs.writeFileSync(`${renderOnlyMain}.js`, renderOnlyFileContents)
+    gulpConfig.set('browser.bundles', [{ name: 'renderOnly', main: renderOnlyMain }])
+
+    const destPath = gulpConfig.get('browser.to')
+    const primaryFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    const renderOnlyFile = `${destPath}/renderOnly.js`
+    expect.assertions(4)
+    bundle()
+      .on('finish', () => {
+        // The primary bundle is unaffected - still built from dist.main, still has both files.
+        const primaryContents = fs.readFileSync(primaryFile).toString()
+        expect(primaryContents).toContain('Hello from file1')
+        expect(primaryContents).toContain('Good-bye from file2')
+
+        // The additional bundle came from its own entry point - file1 only, never file2.
+        const renderOnlyContents = fs.readFileSync(renderOnlyFile).toString()
+        expect(renderOnlyContents).toContain('Hello from file1')
+        expect(renderOnlyContents).not.toContain('Good-bye from file2')
+        done()
+      })
+      .on('error', error => done(error))
+  })
+
+  test('an additional bundle exposes its own name as its standalone export', done => {
+    const distPath = gulpConfig.get('dist.to')
+    const renderOnlyMain = `${distPath}/renderOnly`
+    fs.writeFileSync(`${renderOnlyMain}.js`, renderOnlyFileContents)
+    gulpConfig.set('browser.bundles', [{ name: 'renderOnly', main: renderOnlyMain }])
+
+    const destPath = gulpConfig.get('browser.to')
+    const renderOnlyFile = `${destPath}/renderOnly.js`
+    expect.assertions(2)
+    bundle()
+      .on('finish', () => {
+        const resolved = path.resolve(renderOnlyFile)
+        delete require.cache[resolved]
+        const loaded = require(resolved)
+        expect(typeof loaded.file1).toBe('function')
+        expect(loaded.file2).toBeUndefined()
+        done()
+      })
+      .on('error', error => done(error))
+  })
+})
+
+describe('bundle ignore / exclude', () => {
+  const optionalDepMarker = 'MARKER_FROM_THE_OPTIONAL_DEPENDENCY_CODE'
+
+  beforeEach(() => {
+    const tempDir = gulpConfig.get('rootPath')
+    const depDir = `${tempDir}node_modules/optional-dep`
+    fs.mkdirSync(depDir, { recursive: true })
+    fs.writeFileSync(`${depDir}/package.json`, JSON.stringify({ name: 'optional-dep', main: 'index.js' }))
+    fs.writeFileSync(`${depDir}/index.js`, `module.exports = '${optionalDepMarker}'\n`)
+    const distPath = gulpConfig.get('dist.to')
+    const mainFile = gulpConfig.get('dist.main')
+    fs.mkdirSync(distPath, { recursive: true })
+    // Only reached as a fallback for an option the caller always overrides, the way css-select falls back to its
+    // own default adapter (domutils) unless one is given - exactly the case ignore / exclude exist for.
+    fs.writeFileSync(`${mainFile}.js`, 'const optionalDep = require(\'optional-dep\')\n\nmodule.exports = (given) => given || optionalDep\n')
+  })
+
+  test('without ignore or exclude, the dependency is bundled', done => {
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    expect.assertions(1)
+    bundle()
+      .on('finish', () => {
+        expect(fs.readFileSync(bundledFile).toString()).toContain(optionalDepMarker)
+        done()
+      })
+      .on('error', error => done(error))
+  })
+
+  test('ignore replaces the dependency with an empty object, but the bundle still finishes', done => {
+    gulpConfig.set('browser.ignore', ['optional-dep'])
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    expect.assertions(2)
+    bundle()
+      .on('finish', () => {
+        const bundledContents = fs.readFileSync(bundledFile).toString()
+        // The ignored module is still in the bundle (as an empty stub, so requiring it by name still resolves) -
+        // it just no longer has the real code that would have pulled in the marker
+        expect(bundledContents).toContain('optional-dep')
+        expect(bundledContents).not.toContain(optionalDepMarker)
+        done()
+      })
+      .on('error', error => done(error))
+  })
+
+  test('exclude leaves the dependency out of the bundle entirely', done => {
+    gulpConfig.set('browser.exclude', ['optional-dep'])
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    expect.assertions(1)
+    bundle()
+      .on('finish', () => {
+        expect(fs.readFileSync(bundledFile).toString()).not.toContain(optionalDepMarker)
+        done()
+      })
+      .on('error', error => done(error))
+  })
+
+  test('a single string is accepted the same as a one item array', done => {
+    gulpConfig.set('browser.ignore', 'optional-dep')
+    const destPath = gulpConfig.get('browser.to')
+    const bundledFile = `${destPath}/${gulpConfig.get('browser.name')}.js`
+    expect.assertions(1)
+    bundle()
+      .on('finish', () => {
+        expect(fs.readFileSync(bundledFile).toString()).not.toContain(optionalDepMarker)
+        done()
+      })
+      .on('error', error => done(error))
+  })
+})

package/functions/bundleMinify.mjs

@@ -1,16 +1,16 @@
-import * as gulpConfig from '../gulp.config.mjs'
-import { minifyFor } from './partials/minifyFor.mjs'
-import { getBundleConfigs } from './utilities/getBundleConfigs.mjs'
-
-/**
- * Creates the minified file for every bundle (the primary bundle, plus any additional ones from
- * browser.bundles). The minify step itself never varies per bundle, so this is one shared
- * src()/dest() pipeline (inside minifyFor) fed every bundle's filename at once, rather than one
- * pipeline per bundle - gulp's src() accepts an array of paths natively.
- * @memberOf module:js-build-tools
- * @returns {*}
- */
-export const bundleMinify = () => minifyFor(
-  getBundleConfigs().map(({ name }) => `${gulpConfig.get('browser.to')}/${name}.js`),
-  gulpConfig.get('browser.to')
-)
+import * as gulpConfig from '../gulp.config.mjs'
+import { minifyFor } from './partials/minifyFor.mjs'
+import { getBundleConfigs } from './utilities/getBundleConfigs.mjs'
+
+/**
+ * Creates the minified file for every bundle (the primary bundle, plus any additional ones from
+ * browser.bundles). The minify step itself never varies per bundle, so this is one shared
+ * src()/dest() pipeline (inside minifyFor) fed every bundle's filename at once, rather than one
+ * pipeline per bundle - gulp's src() accepts an array of paths natively.
+ * @memberOf module:js-build-tools
+ * @returns {*}
+ */
+export const bundleMinify = () => minifyFor(
+  getBundleConfigs().map(({ name }) => `${gulpConfig.get('browser.to')}/${name}.js`),
+  gulpConfig.get('browser.to')
+)

package/functions/bundleMinify.test.mjs

@@ -1,37 +1,37 @@
-import { testHelpers } from './testHelpers.mjs'
-import { bundleMinify } from './bundleMinify.mjs'
-import { minifyFor } from './partials/minifyFor.mjs'
-
-const gulpConfig = testHelpers.gulpConfig
-
-jest.mock('./partials/minifyFor.mjs', () => ({ minifyFor: jest.fn(() => Promise.resolve(true)) }))
-
-describe('bundleMinify', () => {
-  afterEach(() => {
-    gulpConfig.set('browser.bundles', [])
-    minifyFor.mockClear()
-  })
-
-  test('calls minifyFor with the primary bundle', () => {
-    expect.assertions(1)
-    bundleMinify()
-    expect(minifyFor).toHaveBeenCalledWith(
-      [`${gulpConfig.get('browser.to')}/${gulpConfig.get('browser.name')}.js`],
-      gulpConfig.get('browser.to')
-    )
-  })
-
-  test('calls minifyFor once, with every additional bundle included in the same array', () => {
-    gulpConfig.set('browser.bundles', [{ name: 'renderOnly' }])
-    expect.assertions(2)
-    bundleMinify()
-    expect(minifyFor).toHaveBeenCalledTimes(1)
-    expect(minifyFor).toHaveBeenCalledWith(
-      [
-        `${gulpConfig.get('browser.to')}/${gulpConfig.get('browser.name')}.js`,
-        `${gulpConfig.get('browser.to')}/renderOnly.js`
-      ],
-      gulpConfig.get('browser.to')
-    )
-  })
-})
+import { testHelpers } from './testHelpers.mjs'
+import { bundleMinify } from './bundleMinify.mjs'
+import { minifyFor } from './partials/minifyFor.mjs'
+
+const gulpConfig = testHelpers.gulpConfig
+
+jest.mock('./partials/minifyFor.mjs', () => ({ minifyFor: jest.fn(() => Promise.resolve(true)) }))
+
+describe('bundleMinify', () => {
+  afterEach(() => {
+    gulpConfig.set('browser.bundles', [])
+    minifyFor.mockClear()
+  })
+
+  test('calls minifyFor with the primary bundle', () => {
+    expect.assertions(1)
+    bundleMinify()
+    expect(minifyFor).toHaveBeenCalledWith(
+      [`${gulpConfig.get('browser.to')}/${gulpConfig.get('browser.name')}.js`],
+      gulpConfig.get('browser.to')
+    )
+  })
+
+  test('calls minifyFor once, with every additional bundle included in the same array', () => {
+    gulpConfig.set('browser.bundles', [{ name: 'renderOnly' }])
+    expect.assertions(2)
+    bundleMinify()
+    expect(minifyFor).toHaveBeenCalledTimes(1)
+    expect(minifyFor).toHaveBeenCalledWith(
+      [
+        `${gulpConfig.get('browser.to')}/${gulpConfig.get('browser.name')}.js`,
+        `${gulpConfig.get('browser.to')}/renderOnly.js`
+      ],
+      gulpConfig.get('browser.to')
+    )
+  })
+})