@defra/interactive-map 0.0.4-alpha → 0.0.5-alpha

package/src/InteractiveMap/InteractiveMap.js

@@ -9,6 +9,8 @@
  */
 
 import '../scss/main.scss'
+// Polyfills to ensure entry point works on all devices
+import './polyfills.js'
 import historyManager from './historyManager.js'
 import { parseDataProperties } from './parseDataProperties.js'
 import { checkDeviceSupport } from './deviceChecker.js'
@@ -22,6 +24,7 @@ import { createInterfaceDetector, getInterfaceType } from '../utils/detectInterf
 import { createReverseGeocode } from '../services/reverseGeocode.js'
 import { EVENTS as events } from '../config/events.js'
 import { createEventBus } from '../services/eventBus.js'
+import { toggleInertElements } from '../utils/toggleInertElements.js'
 
 /**
  * Main entry point for the Interactive Map component.
@@ -33,6 +36,7 @@ export default class InteractiveMap {
   _breakpointDetector = null
   _interfaceDetectorCleanup = null
   _hybridBehaviourCleanup = null
+  _isHidden = false // tracks if map is hidden but preserved (hybrid mode)
 
   /**
    * Create a new InteractiveMap instance.
@@ -98,16 +102,39 @@ export default class InteractiveMap {
   }
 
   _handleButtonClick (e) {
-    this.loadApp()
     history.pushState({ isBack: true }, '', e.currentTarget.getAttribute('href'))
+    if (this._isHidden) {
+      this.showApp()
+    } else {
+      this.loadApp()
+    }
+  }
+
+  _removeMapParamFromUrl (href, key) {
+    const regex = new RegExp(`[?&]${key}=[^&]*(&|$)`)
+
+    if (!regex.test(href)) {
+      return href
+    }
+
+    return href
+      .replace(regex, (_, p1) => {
+        return p1 === '&' ? '?' : ''
+      })
+      .replace(/\?$/, '')
   }
 
   _handleExitClick () {
-    this.removeApp()
-    // Remove the map param from the URL using regex to prevent encoding
+    if (this.config.preserveStateOnClose) {
+      this.hideApp()
+    } else {
+      this.removeApp()
+    }
+
     const key = this.config.mapViewParamKey
     const href = location.href
-    const newUrl = href.replace(new RegExp(`[?&]${key}=[^&]*(&|$)`), (_, p1) => (p1 === '&' ? '?' : '')).replace(/\?$/, '')
+    const newUrl = this._removeMapParamFromUrl(href, key)
+
     history.replaceState(history.state, '', newUrl)
   }
 
@@ -153,10 +180,10 @@ export default class InteractiveMap {
       delete appInstance._root
 
       // Only assign properties but don't eventBus methods
-      const protectedKeys = ['on', 'off', 'emit']
+      const protectedKeys = new Set(['on', 'off', 'emit'])
 
       Object.keys(appInstance).forEach(key => {
-        if (!protectedKeys.includes(key)) {
+        if (!protectedKeys.has(key)) {
           this[key] = appInstance[key]
         }
       })
@@ -190,6 +217,52 @@ export default class InteractiveMap {
     this.eventBus.emit(events.MAP_DESTROY, { mapId: this.id })
   }
 
+  /**
+   * Hide the map application without destroying it (preserves state).
+   * Used in hybrid mode when resizing below breakpoint.
+   *
+   * @internal Not intended for end-user use.
+   */
+  hideApp () {
+    this._isHidden = true
+    this.rootEl.style.display = 'none'
+
+    // Restore inert elements before focusing button
+    toggleInertElements({ containerEl: this.rootEl, isFullscreen: false })
+
+    if (this._openButton) {
+      this._openButton.removeAttribute('style')
+      this._openButton.focus()
+    }
+
+    // Remove fullscreen classes
+    document.documentElement.classList.remove('im-is-fullscreen')
+    this.rootEl.classList.remove('im-is-fullscreen')
+
+    // Reset page title (remove prepended map title)
+    const parts = document.title.split(': ')
+    if (parts.length > 1) {
+      document.title = parts[parts.length - 1]
+    }
+  }
+
+  /**
+   * Show a previously hidden map application.
+   * Used in hybrid mode when resizing above breakpoint or clicking button.
+   *
+   * @internal Not intended for end-user use.
+   */
+  showApp () {
+    this._isHidden = false
+    this.rootEl.style.display = ''
+
+    if (this._openButton) {
+      this._openButton.style.display = 'none'
+    }
+
+    updateDOMState(this)
+  }
+
   /**
    * Destroy the map instance and clean up all resources.
    *

package/src/InteractiveMap/InteractiveMap.test.js

@@ -268,20 +268,23 @@ describe('InteractiveMap Core Functionality', () => {
     expect(() => map.destroy()).not.toThrow()
   })
 
-  it('_handleExitClick removes app and calls replaceState', () => {
+  it('_handleExitClick removes app when preserveStateOnClose is false', () => {
     const replaceStateSpy = jest.spyOn(history, 'replaceState').mockImplementation(() => {})
 
     const map = new InteractiveMap('map', {
       behaviour: 'buttonFirst',
       mapProvider: mapProviderMock,
-      mapViewParamKey: 'mv'
+      mapViewParamKey: 'mv',
+      preserveStateOnClose: false
     })
 
     const removeAppSpy = jest.spyOn(map, 'removeApp').mockImplementation(() => {})
+    const hideAppSpy = jest.spyOn(map, 'hideApp').mockImplementation(() => {})
 
     map._handleExitClick()
 
     expect(removeAppSpy).toHaveBeenCalled()
+    expect(hideAppSpy).not.toHaveBeenCalled()
     expect(replaceStateSpy).toHaveBeenCalledWith(
       history.state,
       '',
@@ -289,8 +292,158 @@ describe('InteractiveMap Core Functionality', () => {
     )
 
     removeAppSpy.mockRestore()
+    hideAppSpy.mockRestore()
     replaceStateSpy.mockRestore()
   })
+
+  it('_handleExitClick hides app when preserveStateOnClose is true', () => {
+    const replaceStateSpy = jest.spyOn(history, 'replaceState').mockImplementation(() => {})
+
+    const map = new InteractiveMap('map', {
+      behaviour: 'buttonFirst',
+      mapProvider: mapProviderMock,
+      mapViewParamKey: 'mv',
+      preserveStateOnClose: true
+    })
+
+    const removeAppSpy = jest.spyOn(map, 'removeApp').mockImplementation(() => {})
+    const hideAppSpy = jest.spyOn(map, 'hideApp').mockImplementation(() => {})
+
+    map._handleExitClick()
+
+    expect(hideAppSpy).toHaveBeenCalled()
+    expect(removeAppSpy).not.toHaveBeenCalled()
+    expect(replaceStateSpy).toHaveBeenCalled()
+
+    removeAppSpy.mockRestore()
+    hideAppSpy.mockRestore()
+    replaceStateSpy.mockRestore()
+  })
+
+  it('_handleButtonClick calls showApp when map is hidden', async () => {
+    const map = new InteractiveMap('map', { behaviour: 'buttonFirst', mapProvider: mapProviderMock })
+    map._isHidden = true
+    const showAppSpy = jest.spyOn(map, 'showApp').mockImplementation(() => {})
+    const loadAppSpy = jest.spyOn(map, 'loadApp').mockResolvedValue()
+    const pushStateSpy = jest.spyOn(history, 'pushState').mockImplementation(() => {})
+    const fakeEvent = { currentTarget: { getAttribute: jest.fn().mockReturnValue('/?mv=map') } }
+
+    await openButtonCallback(fakeEvent)
+
+    expect(showAppSpy).toHaveBeenCalled()
+    expect(loadAppSpy).not.toHaveBeenCalled()
+    expect(pushStateSpy).toHaveBeenCalled()
+
+    showAppSpy.mockRestore()
+    loadAppSpy.mockRestore()
+    pushStateSpy.mockRestore()
+  })
+
+  it('hideApp sets _isHidden and hides element', () => {
+    const map = new InteractiveMap('map', { behaviour: 'buttonFirst', mapProvider: mapProviderMock })
+    map._openButton = mockButtonInstance
+
+    map.hideApp()
+
+    expect(map._isHidden).toBe(true)
+    expect(map.rootEl.style.display).toBe('none')
+    expect(mockButtonInstance.removeAttribute).toHaveBeenCalledWith('style')
+    expect(mockButtonInstance.focus).toHaveBeenCalled()
+  })
+
+  it('hideApp restores document title when it contains a map prefix', () => {
+    document.title = 'Map View: Original Page Title'
+
+    const map = new InteractiveMap('map', {
+      behaviour: 'buttonFirst',
+      mapProvider: mapProviderMock
+    })
+
+    map._openButton = mockButtonInstance
+    map.hideApp()
+
+    expect(document.title).toBe('Original Page Title')
+  })
+
+  it('hideApp works when _openButton is null', () => {
+    const map = new InteractiveMap('map', {
+      behaviour: 'buttonFirst',
+      mapProvider: mapProviderMock
+    })
+
+    map._openButton = null
+    map.hideApp()
+
+    expect(map._isHidden).toBe(true)
+    expect(map.rootEl.style.display).toBe('none')
+  })
+
+  it('showApp sets _isHidden false and shows element', () => {
+    const map = new InteractiveMap('map', { behaviour: 'buttonFirst', mapProvider: mapProviderMock })
+    map._isHidden = true
+    map._openButton = mockButtonInstance
+    map.rootEl.style.display = 'none'
+
+    map.showApp()
+
+    expect(map._isHidden).toBe(false)
+    expect(map.rootEl.style.display).toBe('')
+    expect(mockButtonInstance.style.display).toBe('none')
+    expect(updateDOMState).toHaveBeenCalledWith(map)
+  })
+
+  it('showApp works when _openButton is null', () => {
+    const map = new InteractiveMap('map', {
+      behaviour: 'buttonFirst',
+      mapProvider: mapProviderMock
+    })
+
+    map._isHidden = true
+    map._openButton = null
+    map.rootEl.style.display = 'none'
+
+    map.showApp()
+
+    expect(map._isHidden).toBe(false)
+    expect(map.rootEl.style.display).toBe('')
+    expect(updateDOMState).toHaveBeenCalledWith(map)
+  })
+})
+
+describe('_removeMapParamFromUrl', () => {
+  let map
+
+  beforeEach(() => {
+    document.body.innerHTML = '<div id="map"></div>'
+    map = new InteractiveMap('map', {
+      mapProvider: { load: jest.fn() },
+      mapViewParamKey: 'mv'
+    })
+  })
+
+  it('removes param when followed by another param (& branch)', () => {
+    const href = 'https://example.com/page?mv=map&foo=1'
+    const result = map._removeMapParamFromUrl(href, 'mv')
+    expect(result).toBe('https://example.com/page?foo=1')
+  })
+
+  it('removes param when it is the last param (end-of-string branch)', () => {
+    const href = 'https://example.com/page?foo=1&mv=map'
+    const result = map._removeMapParamFromUrl(href, 'mv')
+    expect(result).toBe('https://example.com/page?foo=1')
+  })
+
+  it('removes lone param and trailing ?', () => {
+    const href = 'https://example.com/page?mv=map'
+    const result = map._removeMapParamFromUrl(href, 'mv')
+    expect(result).toBe('https://example.com/page')
+  })
+
+  it('returns href unchanged when param does not exist (no-match branch)', () => {
+    const href = 'https://example.com/page?foo=1'
+    const result = map._removeMapParamFromUrl(href, 'mv')
+    expect(result).toBe(href)
+  })
 })
 
 describe('InteractiveMap Public API Methods', () => {
@@ -347,4 +500,13 @@ describe('InteractiveMap Public API Methods', () => {
     expect(map.eventBus.emit).toHaveBeenCalledWith('app:showpanel', 'panel2')
     expect(map.eventBus.emit).toHaveBeenCalledWith('app:hidepanel', 'panel3')
   })
+
+  it('delegates toggleButtonState correctly', () => {
+    map.toggleButtonState('btn-1', 'disabled', true)
+
+    expect(map.eventBus.emit).toHaveBeenCalledWith(
+      'app:togglebuttonstate',
+      { id: 'btn-1', prop: 'disabled', value: true }
+    )
+  })
 })

package/src/InteractiveMap/behaviourController.js

@@ -1,5 +1,6 @@
 import { getQueryParam } from '../utils/queryString.js'
 import { isHybridFullscreen } from '../utils/getIsFullscreen.js'
+import { updateDOMState } from './domStateManager.js'
 import defaults from '../config/defaults.js'
 
 // -----------------------------------------------------------------------------
@@ -56,9 +57,18 @@ function setupBehavior (mapInstance) {
 
     const handleChange = () => {
       if (shouldLoadComponent(mapInstance.config)) {
-        mapInstance.loadApp()
+        if (mapInstance._isHidden) {
+          mapInstance.showApp()
+        } else if (mapInstance._root == null) {
+          mapInstance.loadApp()
+        } else {
+          // Map is showing - update DOM state for fullscreen/inline transition
+          updateDOMState(mapInstance)
+        }
+      } else if (mapInstance._root) {
+        mapInstance.hideApp()
       } else {
-        mapInstance.removeApp()
+        // No action
       }
     }
 

package/src/InteractiveMap/behaviourController.test.js

@@ -4,8 +4,10 @@
 
 import { setupBehavior, shouldLoadComponent } from './behaviourController.js'
 import * as queryString from '../utils/queryString.js'
+import { updateDOMState } from './domStateManager.js'
 
 jest.mock('../utils/queryString.js')
+jest.mock('./domStateManager.js', () => ({ updateDOMState: jest.fn() }))
 
 describe('shouldLoadComponent', () => {
   beforeEach(() => {
@@ -60,8 +62,12 @@ describe('setupBehavior', () => {
     mockMapInstance = {
       config: { hybridWidth: null, maxMobileWidth: 640 },
       _breakpointDetector: mockBreakpointDetector,
+      _root: null,
+      _isHidden: false,
       loadApp: jest.fn(),
-      removeApp: jest.fn()
+      removeApp: jest.fn(),
+      hideApp: jest.fn(),
+      showApp: jest.fn()
     }
     // Default: viewport is wide
     window.matchMedia = jest.fn().mockImplementation(() => ({
@@ -145,4 +151,79 @@ describe('setupBehavior', () => {
     const cleanup = setupBehavior(mockMapInstance)
     expect(cleanup).toBeNull()
   })
+
+  describe('hybrid behaviour handleChange', () => {
+    let handleChange
+
+    beforeEach(() => {
+      const mockAddEventListener = jest.fn((event, cb) => { handleChange = cb })
+      window.matchMedia = jest.fn().mockImplementation(() => ({
+        matches: false,
+        addEventListener: mockAddEventListener,
+        removeEventListener: jest.fn()
+      }))
+      mockMapInstance.config = { id: 'test', behaviour: 'hybrid', hybridWidth: null, maxMobileWidth: 640 }
+      setupBehavior(mockMapInstance)
+    })
+
+    it('calls showApp when map is hidden and should load', () => {
+      mockMapInstance._isHidden = true
+      queryString.getQueryParam.mockReturnValue(null) // wide viewport, should load
+
+      handleChange()
+
+      expect(mockMapInstance.showApp).toHaveBeenCalled()
+      expect(mockMapInstance.loadApp).not.toHaveBeenCalled()
+    })
+
+    it('calls loadApp when map has no root and should load', () => {
+      mockMapInstance._isHidden = false
+      mockMapInstance._root = null
+      queryString.getQueryParam.mockReturnValue(null)
+
+      handleChange()
+
+      expect(mockMapInstance.loadApp).toHaveBeenCalled()
+      expect(mockMapInstance.showApp).not.toHaveBeenCalled()
+    })
+
+    it('calls updateDOMState when map is showing and should load', () => {
+      mockMapInstance._isHidden = false
+      mockMapInstance._root = {} // has root
+      queryString.getQueryParam.mockReturnValue(null)
+
+      handleChange()
+
+      expect(updateDOMState).toHaveBeenCalledWith(mockMapInstance)
+      expect(mockMapInstance.loadApp).not.toHaveBeenCalled()
+      expect(mockMapInstance.showApp).not.toHaveBeenCalled()
+    })
+
+    it('calls hideApp when should not load and has root', () => {
+      mockMapInstance._root = {}
+      // Simulate narrow viewport where shouldLoadComponent returns false
+      window.matchMedia = jest.fn().mockImplementation(() => ({ matches: true }))
+      queryString.getQueryParam.mockReturnValue(null)
+
+      handleChange()
+
+      expect(mockMapInstance.hideApp).toHaveBeenCalled()
+    })
+
+    it('does nothing when should not load and map has no root', () => {
+      mockMapInstance._root = null
+      mockMapInstance._isHidden = false
+
+      // Force shouldLoadComponent === false
+      window.matchMedia = jest.fn().mockImplementation(() => ({ matches: true }))
+      queryString.getQueryParam.mockReturnValue(null)
+
+      handleChange()
+
+      expect(mockMapInstance.hideApp).not.toHaveBeenCalled()
+      expect(mockMapInstance.loadApp).not.toHaveBeenCalled()
+      expect(mockMapInstance.showApp).not.toHaveBeenCalled()
+      expect(updateDOMState).not.toHaveBeenCalled()
+    })
+  })
 })

package/src/InteractiveMap/deviceChecker.js

@@ -19,7 +19,7 @@ export function checkDeviceSupport (rootEl, config) {
 
   if (!mapProvider) {
     console.log('No map provider')
-    return
+    return false
   }
 
   if (!device?.isSupported) {

package/src/InteractiveMap/deviceChecker.test.js

@@ -49,13 +49,13 @@ describe('checkDeviceSupport', () => {
     expect(console.log).toHaveBeenCalledWith('WebGL not available')
   })
 
-  it('logs "No map provider" and returns undefined if mapProvider is missing', () => {
+  it('logs "No map provider" and returns false if mapProvider is missing', () => {
     config = {
       mapProvider: null,
       deviceNotSupportedText: 'Device not supported'
     }
 
-    expect(checkDeviceSupport(rootEl, config)).toBeUndefined()
+    expect(checkDeviceSupport(rootEl, config)).toBe(false)
     expect(console.log).toHaveBeenCalledWith('No map provider')
     expect(renderError).not.toHaveBeenCalled()
     expect(removeLoadingState).not.toHaveBeenCalled()

package/src/InteractiveMap/historyManager.js

@@ -6,6 +6,40 @@ import defaults from '../config/defaults.js'
 // Internal helpers
 // -----------------------------------------------------------------------------
 
+/**
+ * Opens the map application for a given map instance.
+ *
+ * If the map instance was previously hidden, it restores the existing app.
+ * Otherwise, it loads the app for the first time.
+ *
+ * @param {MapInstance} mapInstance
+ *   The map instance whose application should be opened.
+ */
+function openMap (mapInstance) {
+  if (mapInstance._isHidden) {
+    mapInstance.showApp?.()
+  } else {
+    mapInstance.loadApp?.()
+  }
+}
+
+/**
+ * Closes the map application for a given map instance.
+ *
+ * Depending on the configuration, the map state is either preserved
+ * by hiding the app or fully removed from the DOM.
+ *
+ * @param {MapInstance} mapInstance
+ *   The map instance whose application should be closed.
+ */
+function closeMap (mapInstance) {
+  if (mapInstance.config.preserveStateOnClose) {
+    mapInstance.hideApp?.()
+  } else {
+    mapInstance.removeApp?.()
+  }
+}
+
 /**
  * Handles the `popstate` event triggered by browser back/forward navigation.
  *
@@ -28,11 +62,13 @@ function handlePopstate () {
     const isHybridVisible = mapInstance.config.behaviour === 'hybrid' && !isHybridFullscreen(mapInstance.config)
     const isOpen = mapInstance.rootEl?.children.length
 
-    if (shouldBeOpen && !isOpen) {
-      mapInstance.loadApp?.()
-    } else if (!shouldBeOpen && isOpen && !isHybridVisible) {
-      mapInstance.removeApp?.()
-      mapInstance.openButton?.focus?.()
+    if (shouldBeOpen && (!isOpen || mapInstance._isHidden)) {
+      openMap(mapInstance)
+      continue
+    }
+
+    if (!shouldBeOpen && isOpen && !isHybridVisible) {
+      closeMap(mapInstance)
     }
   }
 }

package/src/InteractiveMap/historyManager.test.js

@@ -13,19 +13,25 @@ describe('historyManager', () => {
   beforeEach(() => {
     component1 = {
       id: 'map',
-      config: { behaviour: 'buttonFirst', hybridWidth: null, maxMobileWidth: 640 },
+      config: { behaviour: 'buttonFirst', hybridWidth: null, maxMobileWidth: 640, preserveStateOnClose: false },
       rootEl: document.createElement('div'),
       loadApp: jest.fn(),
       removeApp: jest.fn(),
-      openButton: { focus: jest.fn() }
+      hideApp: jest.fn(),
+      showApp: jest.fn(),
+      openButton: { focus: jest.fn() },
+      _isHidden: false
     }
     component2 = {
       id: 'list',
-      config: { behaviour: 'hybrid', hybridWidth: null, maxMobileWidth: 640 },
+      config: { behaviour: 'hybrid', hybridWidth: null, maxMobileWidth: 640, preserveStateOnClose: false },
       rootEl: document.createElement('div'),
       loadApp: jest.fn(),
       removeApp: jest.fn(),
-      openButton: { focus: jest.fn() }
+      hideApp: jest.fn(),
+      showApp: jest.fn(),
+      openButton: { focus: jest.fn() },
+      _isHidden: false
     }
     popstateEvent = new PopStateEvent('popstate')
     jest.clearAllMocks()
@@ -63,7 +69,8 @@ describe('historyManager', () => {
     expect(component1.loadApp).not.toHaveBeenCalled()
   })
 
-  it('removes component and focuses button when view param does not match', () => {
+  it('removes component when view param does not match and preserveStateOnClose is false', () => {
+    component1.config.preserveStateOnClose = false
     component1.rootEl.appendChild(document.createElement('div'))
     historyManager.register(component1)
     queryString.getQueryParam.mockReturnValue(null)
@@ -71,7 +78,19 @@ describe('historyManager', () => {
     window.dispatchEvent(popstateEvent)
 
     expect(component1.removeApp).toHaveBeenCalled()
-    expect(component1.openButton.focus).toHaveBeenCalled()
+    expect(component1.hideApp).not.toHaveBeenCalled()
+  })
+
+  it('hides component when view param does not match and preserveStateOnClose is true', () => {
+    component1.config.preserveStateOnClose = true
+    component1.rootEl.appendChild(document.createElement('div'))
+    historyManager.register(component1)
+    queryString.getQueryParam.mockReturnValue(null)
+
+    window.dispatchEvent(popstateEvent)
+
+    expect(component1.hideApp).toHaveBeenCalled()
+    expect(component1.removeApp).not.toHaveBeenCalled()
   })
 
   it('does not remove hybrid component when viewport is wide (inline mode)', () => {
@@ -87,6 +106,7 @@ describe('historyManager', () => {
   })
 
   it('removes hybrid component when viewport is narrow and view does not match', () => {
+    component2.config.preserveStateOnClose = false
     component2.rootEl.appendChild(document.createElement('div'))
     historyManager.register(component2)
     queryString.getQueryParam.mockReturnValue(null)
@@ -98,6 +118,17 @@ describe('historyManager', () => {
     expect(component2.removeApp).toHaveBeenCalled()
   })
 
+  it('calls showApp when view param matches and component is hidden', () => {
+    component1._isHidden = true
+    historyManager.register(component1)
+    queryString.getQueryParam.mockReturnValue('map')
+
+    window.dispatchEvent(popstateEvent)
+
+    expect(component1.showApp).toHaveBeenCalled()
+    expect(component1.loadApp).not.toHaveBeenCalled()
+  })
+
   it('uses hybridWidth for media query when provided', () => {
     component2.config.hybridWidth = 768
     component2.rootEl.appendChild(document.createElement('div'))

package/src/InteractiveMap/polyfills.js

@@ -0,0 +1,39 @@
+// crypto.randomUUID
+if (typeof crypto !== 'undefined' && !crypto.randomUUID) {
+  let last = 0
+  crypto.randomUUID = () => {
+    last = Math.max(Date.now(), last + 1)
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c, i) => {
+      const v = i < 12 ? Number.parseInt(last.toString(16).padStart(12, '0')[i], 16) : Math.random() * 16 | 0 // NOSONAR
+      return (c === 'x' ? v : (v & 0x3 | 0x8)).toString(16)
+    })
+  }
+}
+
+// AbortSignal.throwIfAborted
+const needsThrowIfAborted = typeof AbortController !== 'undefined' &&
+  !Object.getPrototypeOf(new AbortController().signal).throwIfAborted
+
+if (needsThrowIfAborted) {
+  const signalProto = Object.getPrototypeOf(new AbortController().signal)
+  signalProto.throwIfAborted = function () {
+    if (this.aborted) {
+      const err = new Error('The operation was aborted.')
+      err.name = 'AbortError'
+      throw err
+    }
+  }
+}
+
+// Inject polyfill into web workers created from blob URLs (e.g. MapLibre GL)
+// Workers have their own global scope so main thread polyfills don't apply
+if (needsThrowIfAborted && typeof URL !== 'undefined' && URL.createObjectURL) {
+  const _createObjectURL = URL.createObjectURL.bind(URL)
+  URL.createObjectURL = (blob) => {
+    if (blob instanceof Blob && blob.type === 'text/javascript') {
+      const p = 'if(typeof AbortController!=="undefined"){var _p=Object.getPrototypeOf(new AbortController().signal);if(!_p.throwIfAborted){_p.throwIfAborted=function(){if(this.aborted){var e=new Error("The operation was aborted.");e.name="AbortError";throw e}}}}\n'
+      blob = new Blob([p, blob], { type: 'text/javascript' })
+    }
+    return _createObjectURL(blob)
+  }
+}