govuk_publishing_components 43.4.0 → 43.4.1

data/node_modules/accessible-autocomplete/test/functional/wrapper.js

@@ -0,0 +1,339 @@
+/* global before, beforeEach, after, describe, it */
+
+import { expect } from 'chai'
+import accessibleAutocomplete from '../../src/wrapper'
+
+const DEFAULT_OPTIONS = {
+  '': 'Select',
+  fr: 'France',
+  de: 'Germany',
+  gb: 'United Kingdom of Great Britain & Northern Ireland'
+}
+
+const injectSelectToEnhanceIntoDOM = (element, settings) => {
+  settings = settings || {}
+  settings.options = settings.options || DEFAULT_OPTIONS
+  settings.id = settings.id !== undefined ? settings.id : 'location-picker-id'
+  settings.name = settings.name !== undefined ? settings.name : 'location-picker-name'
+  const $select = document.createElement('select')
+  if (settings.id) {
+    $select.id = settings.id
+  }
+  if (settings.name) {
+    $select.name = settings.name
+  }
+
+  Object.keys(settings.options)
+    .map(optionKey => {
+      const option = document.createElement('option')
+      option.value = optionKey
+      option.text = settings.options[optionKey]
+      option.selected = (settings.selected === optionKey)
+      return option
+    })
+    .forEach(option => $select.appendChild(option))
+
+  element.appendChild($select)
+
+  return $select
+}
+
+describe('Wrapper', () => {
+  let scratch
+  before(() => {
+    scratch = document.createElement('div');
+    (document.body || document.documentElement).appendChild(scratch)
+  })
+
+  beforeEach(() => {
+    scratch.innerHTML = ''
+  })
+
+  after(() => {
+    scratch.parentNode.removeChild(scratch)
+    scratch = null
+  })
+
+  it('throws an error when called on nonexistent element', () => {
+    expect(
+      accessibleAutocomplete.bind(null, {
+        element: document.querySelector('#nothing-container'),
+        id: 'scratch',
+        source: () => {}
+      })
+    ).to.throw('element is not defined')
+  })
+
+  it('throws an error when called without an id ', () => {
+    expect(
+      accessibleAutocomplete.bind(null, {
+        element: scratch,
+        source: () => {}
+      })
+    ).to.throw('id is not defined')
+  })
+
+  it('throws an error when called without a source', () => {
+    expect(
+      accessibleAutocomplete.bind(null, {
+        element: scratch,
+        id: 'scratch'
+      })
+    ).to.throw('source is not defined')
+  })
+
+  it('throws an error when called on nonexistent selectElement', () => {
+    expect(
+      accessibleAutocomplete.enhanceSelectElement.bind(null, {
+        selectElement: document.querySelector('#nothing')
+      })
+    ).to.throw('selectElement is not defined')
+  })
+
+  it('can enhance a select element', () => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+    const id = select.id
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    expect(autocompleteInstances.length).to.equal(1)
+
+    const autocompleteInstance = autocompleteInstances[0]
+
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    expect(autocompleteInput.tagName.toLowerCase()).to.equal('input')
+    expect(autocompleteInput.id).to.equal(id)
+  })
+
+  it('uses the defaultValue setting to populate the input field if no option is selected', () => {
+    const select = injectSelectToEnhanceIntoDOM(scratch, { selected: '' })
+    accessibleAutocomplete.enhanceSelectElement({
+      defaultValue: '',
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    expect(autocompleteInput.value).to.equal('')
+  })
+
+  it('uses the option label as the default input element value if an option is selected', () => {
+    const select = injectSelectToEnhanceIntoDOM(scratch, { selected: 'de' })
+    accessibleAutocomplete.enhanceSelectElement({
+      defaultValue: '',
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    expect(autocompleteInput.value).to.equal('Germany')
+  })
+
+  it('gives the autocomplete element a blank name attribute by default', () => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+
+    const autocompleteInstance = autocompleteInstances[0]
+
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    expect(autocompleteInput.name).to.equal('')
+  })
+
+  it('can define a name for the autocomplete element', () => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      name: 'location-picker-autocomplete',
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+
+    const autocompleteInstance = autocompleteInstances[0]
+
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    expect(autocompleteInput.name).to.equal('location-picker-autocomplete')
+  })
+
+  it('does not include "null" options in autocomplete', (done) => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+
+    // Using setTimeouts here since changes in values take a while to reflect in lists
+    autocompleteInput.value = 'e'
+    setTimeout(() => {
+      const autocompleteOptions = autocompleteInstance.querySelectorAll('.autocomplete__option')
+      expect(autocompleteOptions.length).to.equal(3)
+      expect([].map.call(autocompleteOptions, o => o.textContent)).not.to.contain('Select')
+      done()
+    }, 250)
+  })
+
+  it('includes "null" options in autocomplete if `preserveNullOptions` flag is true', (done) => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      preserveNullOptions: true,
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+
+    // Using setTimeouts here since changes in values take a while to reflect in lists
+    autocompleteInput.value = 'e'
+    setTimeout(() => {
+      const autocompleteOptions = autocompleteInstance.querySelectorAll('.autocomplete__option')
+      expect(autocompleteOptions.length).to.equal(4)
+      expect([].map.call(autocompleteOptions, o => o.textContent)).to.contain('Select')
+      done()
+    }, 250)
+  })
+
+  it('has all options when typing', (done) => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    const autocompleteOption = autocompleteInstance.querySelector('.autocomplete__option')
+
+    // Using setTimeouts here since changes in values take a while to reflect in lists
+    autocompleteInput.value = 'Fran'
+    setTimeout(() => {
+      expect(autocompleteOption.textContent).to.equal('France')
+      autocompleteInput.value = 'Ger'
+      setTimeout(() => {
+        expect(autocompleteOption.textContent).to.equal('Germany')
+        autocompleteInput.value = 'United'
+        setTimeout(() => {
+          const autocompleteHint = autocompleteInstance.querySelector('.autocomplete__hint')
+          expect(autocompleteOption.textContent).to.equal('United Kingdom of Great Britain & Northern Ireland')
+          expect(autocompleteHint.value).to.equal('United Kingdom of Great Britain & Northern Ireland')
+          done()
+        }, 250)
+      }, 250)
+    }, 250)
+  })
+
+  it('includes aria attributes on each option, to indicate position within the full set of list item elements', (done) => {
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    autocompleteInput.value = 'e'
+    setTimeout(() => {
+      const autocompleteOptions = autocompleteInstance.querySelectorAll('.autocomplete__option')
+      expect(autocompleteOptions.length).to.equal(3)
+      expect(autocompleteOptions[0].getAttribute('aria-posinset')).to.equal('1')
+      expect(autocompleteOptions[0].getAttribute('aria-setsize')).to.equal('3')
+      expect(autocompleteOptions[1].getAttribute('aria-posinset')).to.equal('2')
+      expect(autocompleteOptions[1].getAttribute('aria-setsize')).to.equal('3')
+      expect(autocompleteOptions[2].getAttribute('aria-posinset')).to.equal('3')
+      expect(autocompleteOptions[2].getAttribute('aria-setsize')).to.equal('3')
+      done()
+    }, 250)
+  })
+
+  it('includes an explicit position suffix on each list item option when iOS is detected', (done) => {
+    Object.defineProperty(global.navigator, 'userAgent', { value: 'iPhone AppleWebKit', configurable: true })
+
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    const autocompleteOption = autocompleteInstance.querySelector('.autocomplete__option')
+
+    autocompleteInput.value = 'Fran'
+    setTimeout(() => {
+      expect(autocompleteOption.textContent).to.equal('France 1 of 1')
+      const iosSuffixSpan = autocompleteOption.querySelector('#location-picker-id__option-suffix--0')
+      expect(iosSuffixSpan.textContent).to.equal(' 1 of 1')
+      done()
+    }, 250)
+  })
+
+  it('does not include a position suffix on each list item option, when iOS is not detected', (done) => {
+    Object.defineProperty(global.navigator, 'userAgent', { value: 'definitely not an iDevice', configurable: true })
+
+    const select = injectSelectToEnhanceIntoDOM(scratch)
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    const autocompleteOption = autocompleteInstance.querySelector('.autocomplete__option')
+
+    autocompleteInput.value = 'Fran'
+    setTimeout(() => {
+      expect(autocompleteOption.textContent).to.equal('France')
+      const iosSuffixSpan = autocompleteOption.querySelector('#location-picker-id__option-suffix--0')
+      expect(iosSuffixSpan).to.equal(null)
+      done()
+    }, 250)
+  })
+
+  it('onConfirm updates original select', (done) => {
+    const select = injectSelectToEnhanceIntoDOM(scratch, { selected: 'de' })
+
+    accessibleAutocomplete.enhanceSelectElement({
+      selectElement: select
+    })
+
+    const autocompleteInstances = document.querySelectorAll('.autocomplete__wrapper')
+    const autocompleteInstance = autocompleteInstances[0]
+    const autocompleteInput = autocompleteInstance.querySelector('.autocomplete__input')
+    const autocompleteOption = autocompleteInstance.querySelector('.autocomplete__option')
+
+    // Check the initial value of the original selectElement
+    expect(select.value).to.equal('de')
+    // Using setTimeouts here since changes in values take a while to reflect in lists
+    autocompleteInput.value = 'United'
+    setTimeout(() => {
+      expect(autocompleteOption.textContent).to.equal('United Kingdom of Great Britain & Northern Ireland')
+      autocompleteOption.click()
+      expect(select.value).to.equal('gb')
+      setTimeout(() => {
+        expect(autocompleteInput.value).to.equal('United Kingdom of Great Britain & Northern Ireland')
+        done()
+      }, 250)
+    }, 250)
+  })
+})

data/node_modules/accessible-autocomplete/test/integration/index.js

@@ -0,0 +1,309 @@
+/* global afterEach, beforeEach, describe, it */
+
+const { mkdir } = require('fs/promises')
+const { dirname, join } = require('path')
+const { cwd } = require('process')
+const { $, browser, expect } = require('@wdio/globals')
+const { Key } = require('webdriverio')
+
+const { browserName, browserVersion } = browser.capabilities
+const isChrome = browserName === 'chrome'
+// const isFireFox = browserName === 'firefox'
+const isIE = browserName === 'internet explorer'
+const liveRegionWaitTimeMillis = 10000
+
+const basicExample = () => {
+  describe('basic example', function () {
+    const input = 'input#autocomplete-default'
+
+    let $input
+    let $menu
+
+    beforeEach(async () => {
+      $input = await $(input)
+      $menu = await $(`${input} + ul`)
+    })
+
+    it('should show the input', async () => {
+      await $input.waitForExist()
+      expect(await $input.isDisplayed()).toEqual(true)
+    })
+
+    it('should allow focusing the input', async () => {
+      await $input.click()
+      expect(await $input.isFocused()).toEqual(true)
+    })
+
+    it('should display suggestions', async () => {
+      await $input.click()
+      await $input.setValue('ita')
+      await $menu.waitForDisplayed()
+      expect(await $menu.isDisplayed()).toEqual(true)
+    })
+
+    // These tests are flakey when run through Saucelabs so we only run them
+    // in Chrome
+    if (isChrome) {
+      it('should announce status changes using two alternately updated aria live regions', async () => {
+        const $regionA = await $('#autocomplete-default__status--A')
+        const $regionB = await $('#autocomplete-default__status--B')
+
+        expect(await $regionA.getText()).toEqual('')
+        expect(await $regionB.getText()).toEqual('')
+
+        await $input.click()
+        await $input.setValue('a')
+
+        // We can't tell which region will be used first, so we have to
+        // await all region status text for at least one non-empty value
+        const waitForText = ($elements) => async () =>
+          Promise.all($elements.map(($element) => $element.getText()))
+            .then((values) => values.some(Boolean))
+
+        await browser.waitUntil(
+          waitForText([$regionA, $regionB]),
+          liveRegionWaitTimeMillis,
+          `expected the first aria live region to be populated within ${liveRegionWaitTimeMillis} milliseconds`
+        )
+
+        if (await $regionA.getText()) {
+          await $input.addValue('s')
+          await browser.waitUntil(
+            waitForText([$regionA, $regionB]),
+            liveRegionWaitTimeMillis,
+            `expected the first aria live region to be cleared, and the second to be populated within ${liveRegionWaitTimeMillis} milliseconds`
+          )
+
+          await $input.addValue('h')
+          await browser.waitUntil(
+            waitForText([$regionA, $regionB]),
+            liveRegionWaitTimeMillis,
+            `expected the first aria live region to be populated, and the second to be cleared within ${liveRegionWaitTimeMillis} milliseconds`
+          )
+        } else {
+          await $input.addValue('s')
+          await browser.waitUntil(
+            waitForText([$regionA, $regionB]),
+            liveRegionWaitTimeMillis,
+            `expected the first aria live region to be populated, and the second to be cleared within ${liveRegionWaitTimeMillis} milliseconds`
+          )
+
+          await $input.addValue('h')
+          await browser.waitUntil(
+            waitForText([$regionA, $regionB]),
+            liveRegionWaitTimeMillis,
+            `expected the first aria live region to be cleared, and the second to be populated within ${liveRegionWaitTimeMillis} milliseconds`
+          )
+        }
+      })
+    }
+
+    it('should set aria-selected to true on selected option and false on other options', async () => {
+      await $input.click()
+      await $input.setValue('ita')
+
+      const $option1 = await $(`${input} + ul li:nth-child(1)`)
+      const $option2 = await $(`${input} + ul li:nth-child(2)`)
+
+      await browser.keys([Key.ArrowDown])
+      expect(await $option1.getAttribute('aria-selected')).toEqual('true')
+      expect(await $option2.getAttribute('aria-selected')).toEqual('false')
+      await browser.keys([Key.ArrowDown])
+      expect(await $option1.getAttribute('aria-selected')).toEqual('false')
+      expect(await $option2.getAttribute('aria-selected')).toEqual('true')
+    })
+
+    describe('keyboard use', () => {
+      it('should allow typing', async () => {
+        await $input.click()
+        await $input.addValue('ita')
+        expect(await $input.getValue()).toEqual('ita')
+      })
+
+      it('should allow selecting an option', async () => {
+        await $input.click()
+        await $input.setValue('ita')
+
+        const $option1 = await $(`${input} + ul li:nth-child(1)`)
+        const $option2 = await $(`${input} + ul li:nth-child(2)`)
+
+        await browser.keys([Key.ArrowDown])
+        expect(await $input.isFocused()).toEqual(false)
+        expect(await $option1.isFocused()).toEqual(true)
+        await browser.keys([Key.ArrowDown])
+        expect(await $menu.isDisplayed()).toEqual(true)
+        expect(await $input.getValue()).toEqual('ita')
+        expect(await $option1.isFocused()).toEqual(false)
+        expect(await $option2.isFocused()).toEqual(true)
+      })
+
+      it('should allow confirming an option', async () => {
+        await $input.click()
+        await $input.setValue('ita')
+        await browser.keys([Key.ArrowDown, Key.Enter])
+        await browser.waitUntil(async () => await $input.getValue() !== 'ita')
+        expect(await $input.isFocused()).toEqual(true)
+        expect(await $input.getValue()).toEqual('Italy')
+      })
+
+      it('should redirect keypresses on an option to input', async () => {
+        if (!isIE) {
+          await $input.click()
+          await $input.setValue('ita')
+
+          const $option1 = await $(`${input} + ul li:nth-child(1)`)
+
+          await browser.keys([Key.ArrowDown])
+          expect(await $input.isFocused()).toEqual(false)
+          expect(await $option1.isFocused()).toEqual(true)
+          await $option1.addValue('l')
+          expect(await $input.isFocused()).toEqual(true)
+          expect(await $input.getValue()).toEqual('ital')
+        } else {
+          // FIXME: This feature does not work correctly on IE 11
+        }
+      })
+    })
+
+    describe('mouse use', () => {
+      it('should allow confirming an option', async () => {
+        await $input.click()
+        await $input.setValue('ita')
+
+        const $option1 = await $(`${input} + ul li:nth-child(1)`)
+        await $option1.click()
+
+        expect(await $input.isFocused()).toEqual(true)
+        expect(await $input.getValue()).toEqual('Italy')
+      })
+    })
+  })
+}
+
+const customTemplatesExample = () => {
+  describe('custom templates example', function () {
+    const input = 'input#autocomplete-customTemplates'
+
+    let $input
+
+    beforeEach(async () => {
+      $input = await $(input)
+
+      await $input.setValue('') // Prevent autofilling, IE likes to do this.
+    })
+
+    describe('mouse use', () => {
+      it('should allow confirming an option by clicking on child elements', async () => {
+        await $input.setValue('uni')
+
+        const $option1InnerElement = await $(`${input} + ul li:nth-child(1) strong`)
+
+        if (isIE) {
+          // FIXME: This feature works correctly on IE but testing it doesn't seem to work.
+          return
+        }
+
+        try {
+          await $option1InnerElement.click()
+        } catch (error) {
+          // In some cases (mainly ChromeDriver) the automation protocol won't
+          // allow clicking span elements. In this case we just skip the test.
+          if (error.toString().match(/Other element would receive the click/)) {
+            return
+          } else {
+            throw error
+          }
+        }
+
+        expect(await $input.isFocused()).toEqual(true)
+        expect(await $input.getValue()).toEqual('United Kingdom')
+      })
+    })
+  })
+}
+
+const classesPropsExamples = () => {
+  describe('classes properties', () => {
+    it('should set `inputClasses` on both hint and input', async () => {
+      const $input = await $('input#autocomplete-inputClasses')
+      await expect($input).toHaveElementClass('app-input')
+
+      // Trigger the display of the hint
+      await $input.setValue('fra')
+
+      const $hint = $input.parentElement().$('.autocomplete__hint')
+      await expect($hint).toBeDisplayed()
+      await expect($hint).toHaveElementClass('app-input')
+    })
+
+    it('should set `hintClasses` on the hint', async () => {
+      const $input = await $('input#autocomplete-hintClasses')
+
+      // Trigger the display of the hint
+      await $input.setValue('fra')
+
+      const $hint = $input.parentElement().$('.autocomplete__hint')
+      await expect($hint).toBeDisplayed()
+      await expect($hint).toHaveElementClass('app-hint')
+    })
+  })
+}
+
+const takeScreenshotsIfFail = () => {
+  afterEach(async function () {
+    const testFailed = this.currentTest.state === 'failed'
+    if (testFailed) {
+      const timestamp = +new Date()
+      const browserVariant = isIE ? `ie${browserVersion}` : browserName
+      const testTitle = this.currentTest.title.replace(/\W/g, '-')
+      const filename = join(cwd(), `screenshots/${timestamp}-${browserVariant}-${testTitle}.png`)
+      await mkdir(dirname(filename), { recursive: true })
+      await browser.saveScreenshot(filename)
+      console.log(`Test failed, created: ${filename}`)
+    }
+  })
+}
+
+describe('Accessible Autocomplete', () => {
+  beforeEach(async () => {
+    await browser.url('/')
+  })
+
+  it('should have the right title', async () => {
+    expect(await browser.getTitle()).toEqual('Accessible Autocomplete examples')
+  })
+
+  basicExample()
+  customTemplatesExample()
+  classesPropsExamples()
+
+  takeScreenshotsIfFail()
+})
+
+describe('Accessible Autocomplete Preact', () => {
+  beforeEach(async () => {
+    await browser.url('/preact')
+  })
+
+  it('should have the right title', async () => {
+    expect(await browser.getTitle()).toEqual('Accessible Autocomplete Preact examples')
+  })
+
+  basicExample()
+
+  takeScreenshotsIfFail()
+})
+
+describe('Accessible Autocomplete React', () => {
+  beforeEach(async () => {
+    await browser.url('/react')
+  })
+
+  it('should have the right title', async () => {
+    expect(await browser.getTitle()).toEqual('Accessible Autocomplete React examples')
+  })
+
+  basicExample()
+
+  takeScreenshotsIfFail()
+})

data/node_modules/accessible-autocomplete/test/karma.config.js

@@ -0,0 +1,46 @@
+require('@babel/register')({
+  rootMode: 'upward'
+})
+
+const puppeteer = require('puppeteer')
+const webpackConfig = require('../webpack.config.mjs')
+
+// Use Chrome headless
+process.env.CHROME_BIN = puppeteer.executablePath()
+
+module.exports = function (config) {
+  config.set({
+    basePath: '../',
+    frameworks: ['mocha', 'webpack'],
+    reporters: ['mocha'],
+
+    browsers: ['ChromeHeadless'],
+
+    files: [
+      'test/functional/**/*.js'
+    ],
+
+    preprocessors: {
+      'test/**/*.js': ['webpack'],
+      'src/**/*.js': ['webpack'],
+      '**/*.js': ['sourcemap']
+    },
+
+    webpack: {
+      // Use standalone webpack config [0] rather
+      // than Preact [1] or React [2] configs
+      ...webpackConfig.default[0],
+
+      // Use Karma managed test entry points
+      entry: undefined,
+
+      // Use Karma default `os.tmpdir()` output
+      output: undefined,
+
+      // Suppress webpack performance warnings due to
+      // Karma chunked output and inline source maps
+      performance: { hints: false },
+      stats: { preset: 'errors-only' }
+    }
+  })
+}