@defra/interactive-map 0.0.14-alpha → 0.0.16-alpha

package/plugins/beta/draw-es/src/DrawInit.jsx

@@ -2,14 +2,14 @@ import { useEffect } from 'react'
 import { createSketchViewModel } from './sketchViewModel.js'
 import { attachEvents } from './events.js'
 
-export const DrawInit = ({ 
-  appState, 
-  mapState, 
-  pluginConfig, 
-  pluginState, 
-  services, 
-  mapProvider, 
-  buttonConfig 
+export const DrawInit = ({
+  appState,
+  mapState,
+  pluginConfig,
+  pluginState,
+  services,
+  mapProvider,
+  buttonConfig
 }) => {
   const { events, eventBus } = services
   const { mapColorScheme } = mapState.mapStyle || {}
@@ -22,9 +22,9 @@ export const DrawInit = ({
   // Initialize sketch components once
   useEffect(() => {
     if (!isActive || mapProvider.sketchViewModel) {
-			return
-		}
-    
+      return
+    }
+
     const { sketchViewModel, sketchLayer, emptySketchLayer } = createSketchViewModel({
       pluginState,
       mapProvider,
@@ -33,21 +33,21 @@ export const DrawInit = ({
 
     mapProvider.sketchViewModel = sketchViewModel
     mapProvider.sketchLayer = sketchLayer
-		mapProvider.emptySketchLayer = emptySketchLayer
+    mapProvider.emptySketchLayer = emptySketchLayer
     eventBus.emit('draw:ready')
 
     return () => {
       mapProvider.sketchViewModel = null
       mapProvider.sketchLayer = null
-			mapProvider.emptySketchLayer = null
+      mapProvider.emptySketchLayer = null
     }
   }, [mapState.isMapReady, appState.mode])
 
   // Attach/detach events
   useEffect(() => {
     if (!isActive || !mapProvider.sketchViewModel) {
-			return
-		}
+      return
+    }
 
     const cleanup = attachEvents({
       pluginState,
@@ -62,4 +62,4 @@ export const DrawInit = ({
       cleanup()
     }
   }, [isActive, mapColorScheme, pluginState])
-}
+}

package/plugins/beta/draw-es/src/api/addFeature.js

@@ -7,7 +7,7 @@ export const addFeature = ({ pluginState, mapState, mapProvider, services }, fea
   const { eventBus } = services
 
   const graphic = createGraphic(feature.id, feature.geometry.coordinates, mapStyle.mapColorScheme)
-  
+
   // Add the graphic to the layer
   sketchLayer.add(graphic)
 
@@ -15,7 +15,7 @@ export const addFeature = ({ pluginState, mapState, mapProvider, services }, fea
   sketchViewModel.layer = emptySketchLayer
 
   // Store initial feature in plugin state
-  dispatch({ type: 'SET_FEATURE', payload: { feature }})
+  dispatch({ type: 'SET_FEATURE', payload: { feature } })
 
   eventBus.emit('draw:add', feature)
-}
+}

package/plugins/beta/draw-es/src/api/deleteFeature.js

@@ -10,13 +10,13 @@ export const deleteFeature = ({ pluginState, mapProvider, services }, featureId)
   sketchViewModel.cancel()
   sketchLayer.remove(graphic)
   sketchViewModel.layer = emptySketchLayer
-  
+
   // Reset state
-  dispatch({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null }})
+  dispatch({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null } })
 
   // Emit event
   eventBus.emit('draw:delete', { featureId })
 
   // Clear mode
   dispatch({ type: 'SET_MODE', payload: null })
-}
+}

package/plugins/beta/draw-es/src/api/editFeature.js

@@ -18,12 +18,12 @@ export const editFeature = ({ pluginState, mapProvider }, featureId) => {
     tool: 'reshape',
     toggleToolOnClick: false,
     enableRotation: false,
-    enableScaling: false 
+    enableScaling: false
   })
 
   // Set original feature
   const feature = graphicToGeoJSON(graphic)
-  dispatch({ type: 'SET_FEATURE', payload: { feature }})
+  dispatch({ type: 'SET_FEATURE', payload: { feature } })
 
   dispatch({ type: 'SET_MODE', payload: 'edit-feature' })
-}
+}

package/plugins/beta/draw-es/src/api/newPolygon.js

@@ -12,7 +12,7 @@ export const newPolygon = ({ mapState, pluginState, mapProvider, services }, fea
   const handleCreateComplete = sketchViewModel.on('create', (e) => {
     if (e.state === 'complete') {
       e.graphic.attributes = { id: featureId }
-      
+
       // Fix: to address calling some sketchViewModel methods syncronously
       requestAnimationFrame(() => {
         sketchViewModel.update(e.graphic, {
@@ -24,7 +24,7 @@ export const newPolygon = ({ mapState, pluginState, mapProvider, services }, fea
       // Store temp feature in state and emit create
       const tempFeature = graphicToGeoJSON(e.graphic)
       eventBus.emit('draw:created', tempFeature)
-      dispatch({ type: 'SET_FEATURE', payload: { tempFeature }})
+      dispatch({ type: 'SET_FEATURE', payload: { tempFeature } })
 
       handleCreateComplete.remove()
     }
@@ -34,4 +34,4 @@ export const newPolygon = ({ mapState, pluginState, mapProvider, services }, fea
   sketchViewModel.create('polygon')
 
   dispatch({ type: 'SET_MODE', payload: 'new-polygon' })
-}
+}

package/plugins/beta/draw-es/src/events.js

@@ -1,9 +1,9 @@
-import * as simplifyOperator from "@arcgis/core/geometry/operators/simplifyOperator.js"
+import * as simplifyOperator from '@arcgis/core/geometry/operators/simplifyOperator.js'
 import { createGraphic, createSymbol, graphicToGeoJSON } from './graphic.js'
 
 const MODE_CHANGE_DELAY = 50
 
-export function attachEvents({ pluginState, mapProvider, events, eventBus, buttonConfig, mapColorScheme }) {
+export function attachEvents ({ pluginState, mapProvider, events, eventBus, buttonConfig, mapColorScheme }) {
   const { view, sketchViewModel, sketchLayer, emptySketchLayer } = mapProvider
 
   if (!sketchViewModel) {
@@ -12,36 +12,36 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
 
   const { drawDone, drawCancel } = buttonConfig
   const { dispatch, mode, feature } = pluginState
-  
+
   // Re-colour graphics when map style changes
   const reColour = async () => {
     const activeGraphicId = pluginState.feature?.properties?.id
     let activeGraphic = null
     const isCreating = sketchViewModel.state === 'active' && !activeGraphicId
-    
+
     // Cancel and wait, but only if we're in update mode (not create mode)
     if (sketchViewModel.state === 'active' && activeGraphicId) {
       sketchViewModel.cancel()
       await new Promise(resolve => setTimeout(resolve, MODE_CHANGE_DELAY))
     }
-    
+
     // Update the default symbol for new polygons
     sketchViewModel.polygonSymbol = createSymbol(mapColorScheme)
-    
+
     // Update existing graphics
     sketchLayer?.graphics.items.forEach(graphic => {
       const newGraphic = createGraphic(
-        graphic.attributes.id, 
-        graphic.geometry.rings, 
+        graphic.attributes.id,
+        graphic.geometry.rings,
         mapColorScheme
       )
       graphic.symbol = newGraphic.symbol
-      
+
       if (activeGraphicId === graphic.attributes.id) {
         activeGraphic = graphic
       }
     })
-    
+
     // Re-enter update mode only if we were editing (not creating)
     if (activeGraphic && !isCreating && sketchViewModel.layer === sketchLayer) {
       try {
@@ -68,10 +68,19 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
   // Event handlers
   const handleMapStyleChange = () => reColour()
 
+  const onGraphicChanged = (graphic) => {
+    if (!graphic) {
+      return
+    }
+    const tempFeature = graphicToGeoJSON(graphic)
+    eventBus.emit('draw:updated', tempFeature)
+    dispatch({ type: 'SET_FEATURE', payload: { tempFeature } })
+  }
+
   const handleSketchUpdate = (e) => {
     const toolInfoType = e.toolEventInfo?.type
     const graphic = e.graphics[0]
-    
+
     // Prevent polygon move
     if (toolInfoType === 'move-start') {
       sketchViewModel.cancel()
@@ -87,10 +96,8 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
     }
 
     // Emit event on update
-    if (toolInfoType === 'reshape-stop') {
-      const tempFeature = graphicToGeoJSON(graphic)
-      eventBus.emit('draw:updated', tempFeature)
-      dispatch({ type: 'SET_FEATURE', payload: { tempFeature }})
+    if (toolInfoType === 'reshape-stop' || toolInfoType === 'vertex-remove') {
+      onGraphicChanged(graphic)
     }
   }
 
@@ -108,17 +115,38 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
     updateGraphic()
   }
 
+  const handleCreate = async (event) => {
+    const { toolEventInfo } = event
+    const graphic = event?.graphic
+    if (graphic && toolEventInfo?.type === 'vertex-add') {
+      const rings = graphic.geometry?.rings
+      // rings.length is > 1 occurs when the shape becomes complex (ie self intersects)
+      // setTimeout is required to cause the undo to be called after handleCreate completes
+      // otherwise the previous change, rather than this one, is undone
+      if (rings?.length > 1) {
+        setTimeout(() => sketchViewModel.undo(), 0)
+      } else if (rings?.[0]?.length > 3) {
+        onGraphicChanged(graphic) // emit a graphic update on draw, once the graphic is 2D
+      }
+    }
+  }
+
+  const handleUndo = async (event) => {
+    const graphic = event?.graphics?.[0]
+    onGraphicChanged(graphic)
+  }
+
   const handleDone = () => {
     sketchViewModel.cancel()
     sketchViewModel.layer = emptySketchLayer
     dispatch({ type: 'SET_MODE', payload: null })
-    dispatch({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null }})
+    dispatch({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null } })
     eventBus.emit('draw:done', { newFeature: pluginState.tempFeature })
   }
 
   const handleCancel = () => {
     sketchViewModel.cancel()
-    
+
     // Clear all graphics
     sketchLayer.removeAll()
 
@@ -143,10 +171,12 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
   eventBus.on(events.MAP_STYLE_CHANGE, handleMapStyleChange)
   const sketchUpdateHandler = sketchViewModel.on('update', handleSketchUpdate)
   const viewClickHandler = view.on('click', handleViewClick)
-  
+  const createHandler = sketchViewModel.on('create', handleCreate)
+  const undoHandler = sketchViewModel.on('undo', handleUndo)
+
   const prevDoneClick = drawDone.onClick
   const prevCancelClick = drawCancel.onClick
-  
+
   drawDone.onClick = handleDone
   drawCancel.onClick = handleCancel
 
@@ -155,7 +185,9 @@ export function attachEvents({ pluginState, mapProvider, events, eventBus, butto
     eventBus.off(events.MAP_STYLE_CHANGE, handleMapStyleChange)
     sketchUpdateHandler.remove()
     viewClickHandler.remove()
+    createHandler.remove()
+    undoHandler.remove()
     drawDone.onClick = prevDoneClick
     drawCancel.onClick = prevCancelClick
   }
-}
+}

package/plugins/beta/draw-es/src/events.test.js

@@ -0,0 +1,301 @@
+import { attachEvents } from './events.js'
+import { EVENTS as events } from '../../../../src/config/events.js'
+
+import * as graphicJs from './graphic.js'
+jest.mock('./graphic.js')
+const createGraphic = jest.spyOn(graphicJs, 'createGraphic')
+const createSymbol = jest.spyOn(graphicJs, 'createSymbol')
+// const graphicToGeoJSON = jest.spyOn(graphicJs, 'graphicToGeoJSON')
+
+const dispatch = jest.fn()
+
+const createMockEventHandler = (type) => {
+  const callbackSpies = {}
+  const removeSpy = jest.fn()
+  const onSpy = jest.fn((eventType, callback) => {
+    callbackSpies[eventType] = callback
+    return { remove: () => removeSpy(eventType) }
+  })
+
+  // returns an async function that runs asserts
+  const assertOnCalls = (methodArray) => async () => {
+    expect(onSpy.mock.calls, `${type}.on should be called ${methodArray.length} times`)
+      .toHaveLength(methodArray.length)
+    methodArray.forEach((method) =>
+      expect(onSpy, `${type}.on should be called with ${method} and a callback`)
+        .toHaveBeenCalledWith(method, callbackSpies[method]))
+  }
+
+  const assertRemoveCalls = (methodArray) => async () => {
+    expect(removeSpy.mock.calls, `${type}.remove/off should be called ${methodArray.length} times`)
+      .toHaveLength(methodArray.length)
+    methodArray.forEach((method) => {
+      const removeParams = type === 'eventBus' ? [method, callbackSpies[[method]]] : [method]
+      expect(removeSpy, `${type}.remove/off should be called with ${removeParams} `).toHaveBeenCalledWith(...removeParams)
+    })
+  }
+
+  return {
+    removeSpy,
+    callbackSpies,
+    emit: jest.fn(),
+    off: removeSpy,
+    on: onSpy,
+    assertOnCalls,
+    assertRemoveCalls,
+    triggerEvent: (eventType, event) => callbackSpies[eventType](event)
+  }
+}
+const coordinates = [[[337560, 504846], [337580, 504855], [337587, 504838], [337565, 504833], [337560, 504846]]]
+const feature = {
+  type: 'Feature',
+  geometry: {
+    type: 'Polygon',
+    coordinates
+  },
+  properties: { id: 'boundary' }
+}
+
+const mockSymbol = { color: 'blue' }
+const newGraphicMock = { symbol: { color: 'red' } }
+
+const mockGraphic = {
+  attributes: { id: 'boundary' },
+  geometry: { rings: coordinates },
+  symbol: null
+}
+
+const sketchLayer = {
+  removeAll: jest.fn(),
+  add: jest.fn(),
+  graphics: { items: [mockGraphic] }
+}
+
+class ButtonConfigMock {
+  constructor (name) {
+    this.name = name
+    this._onClick = 'Initial Value'
+    this._initialOnClick = this._onClick
+    this.assignOnClickSpy = jest.spyOn(this, 'onClick', 'set')
+  }
+
+  set onClick (onClick) {
+    this._onClick = onClick
+  }
+
+  get onClick () {
+    return this._onClick
+  }
+
+  assertOnClickAssignment () {
+    return async () => {
+      expect(this.assignOnClickSpy.mock.calls, `${this.name}.onClick should have been reassigned once`)
+        .toHaveLength(1)
+      expect(this._onClick, `${this.name}.onClick should have changed`)
+        .not.toEqual(this._initialOnClick)
+    }
+  }
+
+  assertOnClickReset () {
+    return async () => {
+      expect(this.assignOnClickSpy.mock.calls, `${this.name}.onClick should have been assigned twice`)
+        .toHaveLength(2)
+      expect(this._onClick, `${this.name}.onClick should been set back to its initial value`)
+        .toEqual(this._initialOnClick)
+    }
+  }
+}
+const emptySketchLayer = {}
+
+const buildParams = (overrides = {}) => {
+  return {
+    pluginState: {
+      dispatch,
+      mode: 'new-polygon', // or: edit-feature
+      feature,
+      ...overrides.pluginState
+    },
+    mapProvider: {
+      view: createMockEventHandler('view'),
+      sketchViewModel: {
+        ...createMockEventHandler('sketchViewModel'),
+        layer: sketchLayer,
+        cancel: jest.fn(),
+        state: 'idle',
+        polygonSymbol: null,
+        update: jest.fn().mockResolvedValue(undefined)
+      },
+      // sketchViewModel: { ...sketchViewModel, ...overrides.sketchViewModel },
+      sketchLayer,
+      emptySketchLayer,
+      ...overrides.mapProvider
+    },
+    events,
+    eventBus: createMockEventHandler('eventBus'),
+    buttonConfig: {
+      drawDone: new ButtonConfigMock('Done'),
+      drawCancel: new ButtonConfigMock('Cancel')
+    },
+    mapColorScheme: 'MOCK_COLOUR_SCHEME'
+  }
+}
+
+describe('attachEvents - draw-es', () => {
+  beforeEach(() => {
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    jest.useRealTimers()
+  })
+
+  describe('listeners', () => {
+    const params = buildParams()
+    const { drawDone, drawCancel } = params.buttonConfig
+    const { eventBus } = params
+    const { sketchViewModel, view } = params.mapProvider
+    const teardown = attachEvents(params)
+    describe('attach', () => {
+      it('should add view listeners', view.assertOnCalls(['click']))
+      it('should add sketchViewModel listeners', sketchViewModel.assertOnCalls(['update', 'create', 'undo']))
+      it('should add eventBus listeners', eventBus.assertOnCalls([events.MAP_STYLE_CHANGE]))
+      it('should assign a Done click handler', drawDone.assertOnClickAssignment())
+      it('should assign a Cancel click handler', drawCancel.assertOnClickAssignment())
+    })
+
+    describe('teardown', () => {
+      beforeAll(teardown)
+      it('should teardown the view listeners', view.assertRemoveCalls(['click']))
+      it('should teardown the sketchViewModel listeners', sketchViewModel.assertRemoveCalls(['update', 'create', 'undo']))
+      it('should teardown the eventBus listeners', eventBus.assertRemoveCalls([events.MAP_STYLE_CHANGE]))
+      it('should reset the Done click handler', drawDone.assertOnClickReset())
+      it('should reset the Cancel click handler', drawCancel.assertOnClickReset())
+    })
+  })
+
+  describe('internal methods', () => {
+    beforeEach(jest.clearAllMocks)
+
+    it('should return null if sketchViewModel is not set', async () => {
+      const response = attachEvents(buildParams({
+        mapProvider: { sketchViewModel: null }
+      }))
+      expect(response).toBeNull()
+    })
+
+    it('should call handleDone when Done is clicked', async () => {
+      const params = buildParams()
+      params.pluginState.tempFeature = 'Test Feature'
+      attachEvents(params)
+      params.buttonConfig.drawDone.onClick()
+      expect(params.mapProvider.sketchViewModel.cancel).toHaveBeenCalled()
+      expect(params.mapProvider.sketchViewModel.layer).toEqual(emptySketchLayer)
+      expect(dispatch).toHaveBeenCalledWith({ type: 'SET_MODE', payload: null })
+      expect(dispatch).toHaveBeenCalledWith({ type: 'SET_FEATURE', payload: { feature: null, tempFeature: null } })
+      expect(params.eventBus.emit).toHaveBeenCalledWith('draw:done', { newFeature: 'Test Feature' })
+    })
+
+    it('should call handleCancel when Cancel is clicked', async () => {
+      const params = buildParams()
+      params.pluginState.tempFeature = 'Test Feature'
+      // params.pluginState.feature = { properties: { id: 'boundary' } }
+      const { drawCancel } = params.buttonConfig
+      const { sketchViewModel, sketchLayer } = params.mapProvider
+      const { eventBus } = params
+      attachEvents(params)
+      drawCancel.onClick()
+      expect(sketchViewModel.cancel).toHaveBeenCalled()
+      expect(sketchLayer.removeAll).toHaveBeenCalled()
+      expect(createGraphic).toHaveBeenCalled()
+      expect(sketchLayer.add).toHaveBeenCalled()
+      expect(sketchViewModel.layer).toEqual(emptySketchLayer)
+      expect(dispatch).toHaveBeenCalledWith({ type: 'SET_MODE', payload: null })
+      expect(eventBus.emit).toHaveBeenCalledWith('draw:cancelled')
+    })
+
+    describe('reColour', () => {
+      beforeEach(() => {
+        createSymbol.mockReturnValue(mockSymbol)
+        createGraphic.mockReturnValue(newGraphicMock)
+        mockGraphic.symbol = null
+      })
+
+      it('should update polygonSymbol and graphic symbols when state is not active', async () => {
+        const params = buildParams()
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        await Promise.resolve()
+        expect(params.mapProvider.sketchViewModel.polygonSymbol).toEqual(mockSymbol)
+        expect(createGraphic).toHaveBeenCalledWith('boundary', mockGraphic.geometry.rings, params.mapColorScheme)
+        expect(mockGraphic.symbol).toEqual(newGraphicMock.symbol)
+        expect(params.mapProvider.sketchViewModel.cancel).not.toHaveBeenCalled()
+      })
+
+      it('should cancel and re-enter update mode when state is active and activeGraphicId is set (edit mode)', async () => {
+        const params = buildParams()
+        params.mapProvider.sketchViewModel.state = 'active'
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        expect(params.mapProvider.sketchViewModel.cancel).toHaveBeenCalled()
+        jest.advanceTimersByTime(50)
+        await Promise.resolve()
+        await Promise.resolve()
+        expect(params.mapProvider.sketchViewModel.update).toHaveBeenCalledWith(mockGraphic, {
+          tool: 'reshape',
+          toggleToolOnClick: false
+        })
+      })
+
+      it('should not cancel or re-enter update mode when isCreating (active state, no activeGraphicId)', async () => {
+        const params = buildParams({
+          pluginState: { feature: null }
+        })
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        await Promise.resolve()
+        expect(params.mapProvider.sketchViewModel.cancel).not.toHaveBeenCalled()
+        expect(params.mapProvider.sketchViewModel.update).not.toHaveBeenCalled()
+      })
+
+      it('should not call sketchViewModel.update if layer is not sketchLayer', async () => {
+        const params = buildParams()
+        params.mapProvider.sketchViewModel.layer = emptySketchLayer
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        await Promise.resolve()
+        expect(params.mapProvider.sketchViewModel.update).not.toHaveBeenCalled()
+      })
+
+      it('should swallow AbortError thrown by sketchViewModel.update', async () => {
+        const abortError = Object.assign(new Error('Aborted'), { name: 'AbortError' })
+        const params = buildParams()
+        params.mapProvider.sketchViewModel.update.mockRejectedValue(abortError)
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        jest.advanceTimersByTime(50)
+        await Promise.resolve()
+        await Promise.resolve()
+        await Promise.resolve()
+        expect(consoleSpy).not.toHaveBeenCalled()
+        consoleSpy.mockRestore()
+      })
+
+      it('should log non-AbortError thrown by sketchViewModel.update', async () => {
+        const genericError = new Error('Something went wrong')
+        const params = buildParams()
+        params.mapProvider.sketchViewModel.state = 'active'
+        params.mapProvider.sketchViewModel.update.mockRejectedValue(genericError)
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+        attachEvents(params)
+        params.eventBus.triggerEvent(events.MAP_STYLE_CHANGE)
+        jest.advanceTimersByTime(50)
+        await Promise.resolve()
+        await Promise.resolve()
+        await Promise.resolve()
+        expect(consoleSpy).toHaveBeenCalledWith('Error updating sketch:', genericError)
+        consoleSpy.mockRestore()
+      })
+    })
+  })
+})

package/plugins/beta/draw-es/src/graphic.js

@@ -25,7 +25,7 @@ function createGraphic (id, coordinates, mapColorScheme) {
   })
 }
 
-function graphicToGeoJSON(graphic) {
+function graphicToGeoJSON (graphic) {
   if (!graphic?.geometry) {
     throw new Error('Invalid graphic')
   }

package/plugins/beta/draw-es/src/manifest.js

@@ -7,8 +7,8 @@ import { addFeature } from './api/addFeature.js'
 import { deleteFeature } from './api/deleteFeature.js'
 
 const buttonSlots = {
-  mobile:  { slot: 'actions', showLabel: true },
-  tablet:  { slot: 'actions', showLabel: true },
+  mobile: { slot: 'actions', showLabel: true },
+  tablet: { slot: 'actions', showLabel: true },
   desktop: { slot: 'actions', showLabel: true }
 }
 
@@ -27,7 +27,7 @@ export const manifest = {
     hiddenWhen: ({ pluginState }) => !pluginState.mode,
     enableWhen: ({ pluginState }) => !!pluginState.tempFeature,
     ...buttonSlots
-  },{
+  }, {
     id: 'drawCancel',
     label: 'Cancel',
     variant: 'tertiary',
@@ -48,4 +48,4 @@ export const manifest = {
     addFeature,
     deleteFeature
   }
-}
+}

package/plugins/beta/draw-es/src/reducer.js

@@ -27,4 +27,4 @@ const actions = {
 export {
   initialState,
   actions
-}
+}

package/plugins/beta/draw-es/src/sketchViewModel.js

@@ -29,4 +29,4 @@ export const createSketchViewModel = ({ mapProvider }) => {
     emptySketchLayer,
     sketchLayer
   }
-}
+}