@defra/interactive-map 0.0.19-alpha → 0.0.21-alpha

package/rollup.esm.mjs

@@ -255,6 +255,15 @@ const ALL_BUILDS = [
     outDir: 'plugins/beta/datasets/dist/esm',
     manualChunks: (id) => { if (id.includes('/manifest')) return 'im-datasets-plugin' }
   },
+  {
+    entryPath: './plugins/beta/datasets/src/adapters/maplibre/index.js',
+    outDir: 'plugins/beta/datasets/adapters/maplibre/dist/esm',
+    manualChunks: (id) => {
+      if (id.includes('maplibreLayerAdapter')) {
+        return 'im-datasets-ml-adapter'
+      }
+    }
+  },
   {
     entryPath: './plugins/beta/map-styles/src/index.js',
     outDir: 'plugins/beta/map-styles/dist/esm',

package/src/InteractiveMap/InteractiveMap.js

@@ -437,7 +437,7 @@ export default class InteractiveMap {
    * @param {[number, number, number, number] | object} target - Bounds as [west, south, east, north] or [minX, minY, maxX, maxY] depending on the crs, or a GeoJSON Feature, FeatureCollection, or geometry.
    */
   fitToBounds (target) {
-    this.eventBus.emit(events.MAP_FIT_TO_BOUNDS, target)
+    this.eventBus.emitWhenReady(events.MAP_FIT_TO_BOUNDS, target)
   }
 
   /**
@@ -446,7 +446,7 @@ export default class InteractiveMap {
    * @param {{ center?: [number, number], zoom?: number }} opts - View options.
    */
   setView (opts) {
-    this.eventBus.emit(events.MAP_SET_VIEW, opts)
+    this.eventBus.emitWhenReady(events.MAP_SET_VIEW, opts)
   }
 
   /**

package/src/InteractiveMap/InteractiveMap.test.js

@@ -39,8 +39,8 @@ jest.mock('../utils/detectInterfaceType.js', () => ({
 }))
 jest.mock('../services/reverseGeocode.js', () => ({ createReverseGeocode: jest.fn() }))
 jest.mock('../services/eventBus.js', () => ({
-  createEventBus: jest.fn(() => ({ on: jest.fn(), off: jest.fn(), emit: jest.fn(), destroy: jest.fn() })),
-  default: { on: jest.fn(), off: jest.fn(), emit: jest.fn(), destroy: jest.fn() }
+  createEventBus: jest.fn(() => ({ on: jest.fn(), off: jest.fn(), emit: jest.fn(), emitWhenReady: jest.fn(), destroy: jest.fn() })),
+  default: { on: jest.fn(), off: jest.fn(), emit: jest.fn(), emitWhenReady: jest.fn(), destroy: jest.fn() }
 }))
 jest.mock('../App/initialiseApp.js', () => ({ initialiseApp: jest.fn() }))
 
@@ -635,12 +635,12 @@ describe('InteractiveMap Public API Methods', () => {
   it('fitToBounds emits MAP_FIT_TO_BOUNDS with bbox', () => {
     const bbox = [-0.489, 51.28, 0.236, 51.686]
     map.fitToBounds(bbox)
-    expect(map.eventBus.emit).toHaveBeenCalledWith('map:fittobounds', bbox)
+    expect(map.eventBus.emitWhenReady).toHaveBeenCalledWith('map:fittobounds', bbox)
   })
 
   it('setView emits MAP_SET_VIEW with opts', () => {
     const opts = { center: [-0.1276, 51.5074], zoom: 12 }
     map.setView(opts)
-    expect(map.eventBus.emit).toHaveBeenCalledWith('map:setview', opts)
+    expect(map.eventBus.emitWhenReady).toHaveBeenCalledWith('map:setview', opts)
   })
 })

package/src/services/eventBus.js

@@ -1,16 +1,43 @@
 class EventBus {
   constructor () {
     this.events = {}
+    this._queued = {}
   }
 
+  /**
+   * Register a handler for an event. If a value was queued via `emitWhenReady`
+   * before any listeners existed, the handler is called immediately with that
+   * value and the queue is cleared.
+   *
+   * @param {string} eventName
+   * @param {Function} handler
+   * @returns {this}
+   */
   on (eventName, handler) {
     if (!this.events[eventName]) {
       this.events[eventName] = []
     }
     this.events[eventName].push(handler)
+
+    if (this._queued[eventName] !== undefined) {
+      try {
+        handler(...this._queued[eventName])
+      } catch (error) {
+        console.error(`Error in event handler for '${eventName}':`, error)
+      }
+      delete this._queued[eventName]
+    }
+
     return this
   }
 
+  /**
+   * Remove a handler for an event. Omit `handler` to remove all handlers.
+   *
+   * @param {string} eventName
+   * @param {Function} [handler]
+   * @returns {this}
+   */
   off (eventName, handler) {
     if (!this.events[eventName]) {
       return this
@@ -23,6 +50,13 @@ class EventBus {
     return this
   }
 
+  /**
+   * Emit an event, calling all registered handlers synchronously.
+   *
+   * @param {string} eventName
+   * @param {...*} args
+   * @returns {this}
+   */
   emit (eventName, ...args) {
     if (!this.events[eventName]) {
       return this
@@ -38,13 +72,40 @@ class EventBus {
     return this
   }
 
+  /**
+   * Like `emit`, but queues the args if no listeners are registered yet.
+   * The first listener to subscribe will receive the queued value immediately,
+   * after which the queue is cleared. Subsequent `emitWhenReady` calls for the
+   * same event before a listener arrives replace the queued value.
+   *
+   * Use this for events that may be emitted before the listener side is ready
+   * (e.g. called from `map:ready` before React effects have run).
+   *
+   * @param {string} eventName
+   * @param {...*} args
+   * @returns {this}
+   */
+  emitWhenReady (eventName, ...args) {
+    if (!this.events[eventName] || this.events[eventName].length === 0) {
+      this._queued[eventName] = args
+      return this
+    }
+    return this.emit(eventName, ...args)
+  }
+
+  /**
+   * Remove all handlers and clear any queued events.
+   */
   destroy () {
     this.events = {}
+    this._queued = {}
   }
 }
 
 /**
  * Factory for map-local EventBus
+ *
+ * @returns {EventBus}
  */
 export function createEventBus () {
   return new EventBus()

package/src/services/eventBus.test.js

@@ -94,6 +94,76 @@ describe('EventBus singleton', () => {
   })
 })
 
+describe('emitWhenReady', () => {
+  beforeEach(() => {
+    eventBus.destroy()
+  })
+
+  it('fires immediately when listeners are already registered', () => {
+    const handler = jest.fn()
+    eventBus.on('ready', handler)
+
+    eventBus.emitWhenReady('ready', 'value')
+
+    expect(handler).toHaveBeenCalledWith('value')
+  })
+
+  it('queues the call and replays to the first subscriber when no listeners exist', () => {
+    const handler = jest.fn()
+
+    eventBus.emitWhenReady('ready', 'value')
+    expect(handler).not.toHaveBeenCalled()
+
+    eventBus.on('ready', handler)
+    expect(handler).toHaveBeenCalledWith('value')
+  })
+
+  it('clears the queue after replaying so subsequent subscribers do not receive it', () => {
+    const first = jest.fn()
+    const second = jest.fn()
+
+    eventBus.emitWhenReady('ready', 'value')
+    eventBus.on('ready', first)
+    eventBus.on('ready', second)
+
+    expect(first).toHaveBeenCalledWith('value')
+    expect(second).not.toHaveBeenCalled()
+  })
+
+  it('replaces a queued value if emitWhenReady is called again before a subscriber arrives', () => {
+    const handler = jest.fn()
+
+    eventBus.emitWhenReady('ready', 'first')
+    eventBus.emitWhenReady('ready', 'second')
+    eventBus.on('ready', handler)
+
+    expect(handler).toHaveBeenCalledTimes(1)
+    expect(handler).toHaveBeenCalledWith('second')
+  })
+
+  it('catches and logs errors thrown by a handler during queued replay', () => {
+    const error = new Error('boom')
+    const handler = jest.fn(() => { throw error })
+    jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    eventBus.emitWhenReady('ready', 'value')
+    eventBus.on('ready', handler)
+
+    expect(console.error).toHaveBeenCalledWith("Error in event handler for 'ready':", error)
+    console.error.mockRestore()
+  })
+
+  it('clears queued events on destroy', () => {
+    const handler = jest.fn()
+
+    eventBus.emitWhenReady('ready', 'value')
+    eventBus.destroy()
+    eventBus.on('ready', handler)
+
+    expect(handler).not.toHaveBeenCalled()
+  })
+})
+
 describe('createEventBus factory', () => {
   /**
    * Test to ensure coverage for the factory function (Line 50).

package/src/utils/patternUtils.js

@@ -52,21 +52,26 @@ export const getPatternInnerContent = (dataset, patternRegistry) => {
 }
 
 /**
- * Returns a deterministic image ID for a pattern + resolved colour combination.
+ * Returns a deterministic image ID for a pattern + resolved colour + pixel ratio combination.
  *
  * @param {Object} dataset
  * @param {string} mapStyleId
  * @param {Object} patternRegistry
+ * @param {number} [pixelRatio=1]
  * @returns {string|null}
  */
-export const getPatternImageId = (dataset, mapStyleId, patternRegistry) => {
+// Minimum oversampling — keeps 16×16 physical pixels as the floor so patterns remain crisp.
+export const PATTERN_MIN_PIXEL_RATIO = 2
+
+export const getPatternImageId = (dataset, mapStyleId, patternRegistry, pixelRatio = 1) => {
   const innerContent = getPatternInnerContent(dataset, patternRegistry)
   if (!innerContent) {
     return null
   }
   const fg = getValueForStyle(dataset.fillPatternForegroundColor, mapStyleId) || 'black'
   const bg = getValueForStyle(dataset.fillPatternBackgroundColor, mapStyleId) || 'transparent'
-  return `pattern-${hashString(innerContent + fg + bg)}`
+  const effectiveRatio = Math.max(PATTERN_MIN_PIXEL_RATIO, pixelRatio)
+  return `pattern-${hashString(innerContent + fg + bg)}-${effectiveRatio}x`
 }
 
 /**

package/src/utils/patternUtils.test.js

@@ -103,6 +103,23 @@ describe('getPatternImageId', () => {
     expect(idA).not.toBe(idB)
   })
 
+  test('floors effective ratio at PATTERN_MIN_PIXEL_RATIO so low-DPI ids match 2x', () => {
+    const dataset = { fillPattern: 'dot' }
+    const id1x = getPatternImageId(dataset, 'style-a', mockRegistry, 1)
+    const id2x = getPatternImageId(dataset, 'style-a', mockRegistry, 2)
+    expect(id1x).toBe(id2x)
+    expect(id1x).toMatch(/-2x$/)
+  })
+
+  test('produces different ids for pixelRatios above the floor', () => {
+    const dataset = { fillPattern: 'dot' }
+    const id2x = getPatternImageId(dataset, 'style-a', mockRegistry, 2)
+    const id3x = getPatternImageId(dataset, 'style-a', mockRegistry, 3)
+    expect(id2x).not.toBe(id3x)
+    expect(id2x).toMatch(/-2x$/)
+    expect(id3x).toMatch(/-3x$/)
+  })
+
   test('falls back to "black" foreground and "transparent" background when colours are absent', () => {
     const id = getPatternImageId({ fillPattern: 'dot' }, 'style-a', mockRegistry)
     const idExplicit = getPatternImageId(

package/webpack.umd.mjs

@@ -140,6 +140,7 @@ const ALL_BUILDS = [
   { entryPath: './plugins/search/src/index.js', libraryPath: 'searchPlugin', outDir: 'plugins/search/dist/umd' },
   { entryPath: './plugins/interact/src/index.js', libraryPath: 'interactPlugin', outDir: 'plugins/interact/dist/umd' },
   { entryPath: './plugins/beta/datasets/src/index.js', libraryPath: 'datasetsPlugin', outDir: 'plugins/beta/datasets/dist/umd' },
+  { entryPath: './plugins/beta/datasets/src/adapters/maplibre/index.js', libraryPath: 'datasetsMaplibreAdapter', outDir: 'plugins/beta/datasets/adapters/maplibre/dist/umd' },
   { entryPath: './plugins/beta/map-styles/src/index.js', libraryPath: 'mapStylesPlugin', outDir: 'plugins/beta/map-styles/dist/umd' },
   { entryPath: './plugins/beta/draw-ml/src/index.js', libraryPath: 'drawMLPlugin', outDir: 'plugins/beta/draw-ml/dist/umd' },
   { entryPath: './plugins/beta/frame/src/index.js', libraryPath: 'framePlugin', outDir: 'plugins/beta/frame/dist/umd' }