@kalisio/kdk 2.4.0 → 2.5.1

package/map/client/composables/location.js

@@ -1,9 +1,10 @@
 import _ from 'lodash'
 import { ref } from 'vue'
-import { Store, i18n, api } from '../../../core.client.js'
+import { Store, Context, i18n } from '../../../core.client.js'
 import { Geolocation } from '../geolocation.js'
+import { Geocoder } from '../geocoder.js'
 import { useCurrentActivity } from './activity.js'
-import { searchLocation, listGeocoders, filterGeocoders } from '../utils/utils.location.js'
+import { filterGeocoders } from '../utils/utils.location.js'
 
 export function useLocation () {
   const { getActivityProject } = useCurrentActivity({ selection: false, probe: false })
@@ -11,49 +12,67 @@ export function useLocation () {
   // Data
   const availableGeocoders = ref([])
   const selectedGeocoders = ref([])
+  const selectedViewbox = ref([])
 
   // Functions
   // Input geocoders if given should be like { source: xxx, selected: true }
   async function setGeocoders (geocoders) {
-    const project = getActivityProject()
-    const planet = (project ? project.getPlanetApi().getConfig() : api.getConfig())
     if (_.isNull(geocoders)) {
       // clear the geocoders
       availableGeocoders.value = []
       selectedGeocoders.value = []
     } else {
       // check the capabilities to list the geocoders
-      let allGeocoders = await listGeocoders(planet)
-      allGeocoders = filterGeocoders(allGeocoders, project)
+      let allGeocoders = await Geocoder.getForwardCapabilities()
+      allGeocoders = filterGeocoders(allGeocoders, getActivityProject())
       if (_.isEmpty(geocoders)) {
         availableGeocoders.value = _.map(allGeocoders, geocoder => {
           return { value: geocoder, label: i18n.tie(`Geocoders.${geocoder}`) }
         })
         selectedGeocoders.value = allGeocoders
       } else {
-        availableGeocoders.value = geocoders
-          .filter(geocoder => allGeocoders.includes(geocoder.source))
-          .map(geocoder => ({ value: geocoder.source, label: i18n.tie(`Geocoders.${geocoder.source}`) }))
-        selectedGeocoders.value = _.map(_.filter(geocoders, geocoder => geocoder.selected), 'source')
+        availableGeocoders.value = _.reduce(geocoders, (reducedGeocoders, geocoder) => {
+          const source = _.replace(geocoder.source, /^services:.*\//g, `services:${Context.getId()}/`)
+          const label = _.replace(geocoder.source, /^services:.*\//g, `services:*/`)
+          if (allGeocoders.includes(source)) {
+            reducedGeocoders.push({ value: source, label: i18n.tie(`Geocoders.${label}`), selected: geocoder.selected })
+          }
+          return reducedGeocoders
+        }, [])
+        selectedGeocoders.value = _.reduce(availableGeocoders.value, (reducedGeocoders, geocoder) => {
+          if (geocoder.selected) reducedGeocoders.push(geocoder.value)
+          return reducedGeocoders
+        }, [])
       }
     }
   }
+  // Input viewbox if given should be like [lon1,lat1,lon2,lat2]
+  async function setViewbox (viewbox) {
+    if (_.isNull(viewbox)) {
+      selectedViewbox.value = []
+    } else {
+      selectedViewbox.value = viewbox
+    }
+  }
   async function geolocate () {
     await Geolocation.update()
     const error = Store.get('geolocation.error')
     if (error) return
     return Store.get('geolocation.location')
   }
-  async function search (pattern) {
-    const project = getActivityProject()
-    const planet = (project ? project.getPlanetApi().getConfig() : api.getConfig())
-    return searchLocation(planet, pattern, { geocoders: selectedGeocoders.value })
+  async function search (pattern, limit = 25) {
+    return Geocoder.queryForward(pattern, {
+      geocoders: selectedGeocoders.value,
+      viewbox: selectedViewbox.value,
+      limit
+    })
   }
   // Expose
   return {
     availableGeocoders,
     selectedGeocoders,
     setGeocoders,
+    setViewbox,
     geolocate,
     search
   }

package/map/client/composables/project.js

@@ -2,6 +2,7 @@ import _ from 'lodash'
 import { ref, computed, watch, onBeforeMount, onBeforeUnmount } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import { api } from '../../../core.client.js'
+import { listenToServiceEvents, unlistenToServiceEvents } from '../../../core/client/utils/index.js'
 import { useCurrentActivity } from '../composables/activity.js'
 import { getCatalogProjectQuery } from '../utils/utils.project.js'
 
@@ -12,7 +13,7 @@ export function useProject (options = {}) {
     // Set if project should be extracted from route
     // otherwise it should be loaded manually
     route: true,
-    // Default to global service
+    // Default to contextual or global service depending on store
     context: '',
     // Default to target activity
     updateActivity: true,
@@ -25,6 +26,7 @@ export function useProject (options = {}) {
   const router = useRouter()
   const projectId = ref(null)
   const project = ref(null)
+  let serviceEventListeners
 
   // Computed
   const projectQuery = computed(() => {
@@ -95,19 +97,16 @@ export function useProject (options = {}) {
 
   onBeforeMount(() => {
     refreshProjectId()
-    const projectsService = options.planetApi.getService('projects', options.context)
-    // Keep track of changes once project is loaded
-    projectsService.on('patched', onProjectUpdated)
-    projectsService.on('updated', onProjectUpdated)
-    projectsService.on('removed', onProjectRemoved)
+    serviceEventListeners = listenToServiceEvents(options.planetApi.getService('projects', options.context), {
+      patched: onProjectUpdated,
+      updated: onProjectUpdated,
+      removed: onProjectRemoved
+    })
   })
 
   // Cleanup
   onBeforeUnmount(() => {
-    const projectsService = options.planetApi.getService('projects', options.context)
-    projectsService.off('patched', onProjectUpdated)
-    projectsService.off('updated', onProjectUpdated)
-    projectsService.off('removed', onProjectRemoved)
+    unlistenToServiceEvents(serviceEventListeners)
   })
 
   return {

package/map/client/composables/selection.js

@@ -1,4 +1,5 @@
 import _ from 'lodash'
+import config from 'config'
 import L from 'leaflet'
 import sift from 'sift'
 import centroid from '@turf/centroid'
@@ -8,11 +9,19 @@ import intersects from '@turf/boolean-intersects'
 import { featureEach } from '@turf/meta'
 import { unref } from 'vue'
 import * as composables from '../../../core/client/composables/index.js'
-import { getFeatureId } from '../utils.js'
+import * as utils from '../utils.js'
+import { convertPolygonStyleToLeafletPath } from '../leaflet/utils/index.js'
 
 export function useSelection (name, options = {}) {
+  // Data
+  let layerServiceEventListeners = {}
+  // Retrieve core selection
+  const selection = composables.useSelection(name, options)
+  // Selection store, as we store options inside check if already initialized
+  const { get, has, set } = composables.useStore(`selections.${name}`)
+
   // Set default options
-  options = Object.assign({
+  options = get('options', Object.assign({
     // Specific selection item comparator
     matches: (item1) => (item2) => {
       const layer1 = _.get(item1, 'layer.name')
@@ -22,8 +31,8 @@ export function useSelection (name, options = {}) {
         if (layer1 !== layer2) return false
         // Then compare features
         if (item1.feature && item2.feature) {
-          const id1 = getFeatureId(item1.feature, item1.layer)
-          const id2 = getFeatureId(item2.feature, item2.layer)
+          const id1 = utils.getFeatureId(item1.feature, item1.layer)
+          const id2 = utils.getFeatureId(item2.feature, item2.layer)
           return id1 === id2
         } else {
           // If only one has a feature then it cannot be the same
@@ -42,37 +51,70 @@ export function useSelection (name, options = {}) {
     multiple: 'ctrlKey',
     // Buffer selection width (10px)
     buffer: 10,
+    showBuffer: false,
+    showBufferDelay: 250,
     boxSelection: true,
     clusterSelection: false
-  }, options)
-  // Retrieve selection
-  const selection = composables.useSelection(name, options)
+  }, options))
+  // Track options in store if not already done
+  if (!has('options')) set('options', options)
   // Retrieve activity
   const { kActivity } = composables.useCurrentActivity()
   // Avoid using .value everywhere
   let activity = unref(kActivity)
 
-  // data
-
-  // functions
+  // Functions
   function setCurrentActivity (newActivity) {
     // Avoid multiple updates
     if (activity === newActivity) return
     // Remove listeners on previous activity and set it on new one
     if (activity && activity.$engineEvents) {
+      unlistenToFeaturesServiceEventsForLayers()
+      selection.setSelectionEnabled()
+      selection.clearSelection()
       activity.$engineEvents.off('click', onClicked)
       if (options.boxSelection) activity.$engineEvents.off('boxselectionend', onBoxSelection)
       if (options.clusterSelection) activity.$engineEvents.off('spiderfied', onClusterSelection)
+      activity.$engineEvents.off('layer-added', listenToFeaturesServiceEventsForLayer)
+      activity.$engineEvents.off('layer-removed', unlistenToFeaturesServiceEventsForLayer)
       activity.$engineEvents.off('layer-hidden', onSelectedLayerHidden)
     }
     activity = newActivity
-    if (newActivity && newActivity.$engineEvents) {
-      newActivity.$engineEvents.on('click', onClicked)
-      if (options.boxSelection) newActivity.$engineEvents.on('boxselectionend', onBoxSelection)
-      if (options.clusterSelection) newActivity.$engineEvents.on('spiderfied', onClusterSelection)
-      newActivity.$engineEvents.on('layer-hidden', onSelectedLayerHidden)
+    if (activity && activity.$engineEvents) {
+      listenToFeaturesServiceEventsForLayers()
+      activity.$engineEvents.on('click', onClicked)
+      if (options.boxSelection) activity.$engineEvents.on('boxselectionend', onBoxSelection)
+      if (options.clusterSelection) activity.$engineEvents.on('spiderfied', onClusterSelection)
+      activity.$engineEvents.on('layer-added', listenToFeaturesServiceEventsForLayer)
+      activity.$engineEvents.on('layer-removed', unlistenToFeaturesServiceEventsForLayer)
+      activity.$engineEvents.on('layer-hidden', onSelectedLayerHidden)
+    }
+  }
+  function setBoxSelectionEnabled (enabled) {
+    if (options.boxSelection === enabled) return
+    options.boxSelection = enabled
+    if (!activity) return
+    if (enabled) {
+      activity.$engineEvents.on('boxselectionend', onBoxSelection)
+      activity.map.boxSelection.enable()
+    } else {
+      activity.$engineEvents.off('boxselectionend', onBoxSelection)
+      activity.map.boxSelection.disable()
+    }
+  }
+  function setClusterSelectionEnabled (enabled) {
+    if (options.clusterSelection === enabled) return
+    options.clusterSelection = enabled
+    if (!activity) return
+    if (enabled) {
+      activity.$engineEvents.on('spiderfied', onClusterSelection)
+    } else {
+      activity.$engineEvents.off('spiderfied', onClusterSelection)
     }
   }
+  function setBufferWidth (width) {
+    options.buffer = width
+  }
   // Single selection will rely on the lastly selected item only
   function hasSelectedFeature () {
     return selection.hasSelectedItem() && selection.getSelectedItem().feature
@@ -80,32 +122,51 @@ export function useSelection (name, options = {}) {
   function getSelectedFeature () {
     return selection.getSelectedItem().feature
   }
+  function getSelectedFeatures () {
+    return selection.getSelectedItems().filter(item => item.feature).map(item => item.feature)
+  }
   function getSelectedFeatureCollection () {
     return { type: 'FeatureCollection', features: selection.getSelectedItems().filter(item => item.feature).map(item => item.feature) }
   }
+  function getSelectedFeaturesByLayer () {
+    const featuresByLayer = {}
+    const items = selection.getSelectedItems().filter(item => item.feature && item.layer)
+    items.forEach(item => {
+      const key = item.layer._id || item.layer.name
+      if (!featuresByLayer[key]) featuresByLayer[key] = { layer: item.layer, features: [] }
+      featuresByLayer[key].features.push(item.feature)
+    })
+    return _.values(featuresByLayer)
+  }
   function hasSelectedLayer () {
     return selection.hasSelectedItem() && selection.getSelectedItem().layer
   }
   function getSelectedLayer () {
     return selection.getSelectedItem().layer
   }
+  function getSelectedLayers () {
+    return selection.getSelectedItem().filter(item => item.layer).map(item => item.layer)
+  }
   function hasSelectedLocation () {
     return selection.hasSelectedItem() && selection.getSelectedItem().location
   }
   function getSelectedLocation () {
     return selection.getSelectedItem().location
   }
-  function isFeatureSelected (feature, layer) {
+  function findSelectedFeature (feature, layer) {
     const items = selection.getSelectedItems()
     for (let i = 0; i < items.length; i++) {
       const item = items[i]
       if (item.feature && item.layer && (item.layer.name === layer.name)) {
-        const selectedId = getFeatureId(item.feature, item.layer)
-        const featureId = getFeatureId(feature, layer)
-        if (featureId === selectedId) return true
+        const selectedId = utils.getFeatureId(item.feature, item.layer)
+        const featureId = utils.getFeatureId(feature, layer)
+        if (featureId === selectedId) return item
       }
     }
-    return false
+    return null
+  }
+  function isFeatureSelected (feature, layer) {
+    return findSelectedFeature(feature, layer) !== null
   }
   function getWidgetForSelection () {
     let widget
@@ -194,6 +255,8 @@ export function useSelection (name, options = {}) {
 
   let lastClickedPosition, lastBoxSelectionPosition
   function onClicked (layer, event) {
+    if (!selection.isSelectionEnabled()) return
+    
     // FIXME: For some layers, eg based on path, we get a first click with the layer as target
     // then a second click with the map as target, we need to filter the later for selection
     // Similarly we get a click when performing a box selection
@@ -216,6 +279,11 @@ export function useSelection (name, options = {}) {
     // Retrieve the location
     const location = _.get(event, 'latlng')
     if (selection.getSelectionMode() === 'buffer') {
+      if (activity.is2D() && options.showBuffer) {
+        const highlightStyle = _.get(config, `engines.${activity.engine}.style.selection.polygon`, {})
+        const marker = L.circleMarker(location, Object.assign({ radius: options.buffer }, convertPolygonStyleToLeafletPath(highlightStyle))).addTo(activity.map)
+        setTimeout(() => marker.removeFrom(activity.map), options.showBufferDelay)
+      }
       const center = activity.getCenter()
       // https://wiki.openstreetmap.org/wiki/Zoom_levels
       const metresPerPixel = 40075016.686 * Math.abs(Math.cos(location.lat * Math.PI / 180)) / Math.pow(2, center.zoomLevel + 8)
@@ -249,7 +317,9 @@ export function useSelection (name, options = {}) {
     else handleSelection(items, clearSelection)
   }
   function onBoxSelection (map, event) {
-    lastBoxSelectionPosition = L.point(_.get(event, 'x'), _.get(event, 'y'))
+    if (!selection.isSelectionEnabled()) return
+
+    lastBoxSelectionPosition = _.get(event, 'containerPoint')
     const { bounds } = event
     let items = getIntersectedItems(bboxPolygon([
       bounds.getWest(), bounds.getSouth(), bounds.getEast(), bounds.getNorth()
@@ -263,6 +333,8 @@ export function useSelection (name, options = {}) {
     else handleSelection(items, true)
   }
   function onClusterSelection (layer, event) {
+    if (!selection.isSelectionEnabled()) return
+      
     // Not relevent in this case
     if (selection.isSingleSelectionMode()) return
     const items = _.get(event, 'markers', []).map(marker => {
@@ -282,19 +354,60 @@ export function useSelection (name, options = {}) {
     const hiddenFeatures = selection.getSelectedItems().filter(item => layer.name === _.get(item, 'layer.name'))
     hiddenFeatures.forEach((item) => selection.unselectItem(item))
   }
+  function listenToFeaturesServiceEventsForLayer (layer) {
+    const listeners = utils.listenToFeaturesServiceEventsForLayer(layer, {
+      all: onFeatureUpdated, removed: onFeatureRemoved
+    }, layerServiceEventListeners[layer._id])
+    if (listeners) layerServiceEventListeners[layer._id] = listeners
+  }
+  function unlistenToFeaturesServiceEventsForLayer (layer) {
+    utils.unlistenToFeaturesServiceEventsForLayer(layer, layerServiceEventListeners[layer._id])
+    delete layerServiceEventListeners[layer._id]
+  }
+  function listenToFeaturesServiceEventsForLayers () {
+    layerServiceEventListeners = {}
+    _.forEach(activity.getLayers(), listenToFeaturesServiceEventsForLayer)
+  }
+  function unlistenToFeaturesServiceEventsForLayers () {
+    _.forOwn(layerServiceEventListeners, unlistenToFeaturesServiceEventsForLayer)
+    layerServiceEventListeners = {}
+  }
+  function onFeatureUpdated (feature, layer) {
+    // Find related layer, either directly given in feature if coming from user-defined features service
+    // otherwise bound to the listener for features services attached to a built-in layer
+    if (!layer && feature.layer) layer = activity.getLayerById(feature.layer)
+    if (!layer) return
+    const item = findSelectedFeature(feature, layer)
+    if (item) Object.assign(item.feature, feature)
+  }
+  function onFeatureRemoved (feature, layer) {
+    // Find related layer, either directly given in feature if coming from user-defined features service
+    // otherwise bound to the listener for features services attached to a built-in layer
+    if (!layer && feature.layer) layer = activity.getLayerById(feature.layer)
+    if (!layer) return
+    const item = findSelectedFeature(feature, layer)
+    if (item) selection.unselectItem(item)
+  }
 
-  // expose
+  // Expose
   return {
     ...selection,
+    getSelectionOptions: () => get('options'),
     setCurrentActivity,
     hasSelectedFeature,
     getSelectedFeature,
+    getSelectedFeatures,
     getSelectedFeatureCollection,
+    getSelectedFeaturesByLayer,
     hasSelectedLayer,
     getSelectedLayer,
+    getSelectedLayers,
     hasSelectedLocation,
     getSelectedLocation,
     getWidgetForSelection,
-    centerOnSelection
+    centerOnSelection,
+    setBoxSelectionEnabled,
+    setClusterSelectionEnabled,
+    setBufferWidth
   }
 }

package/map/client/geocoder.js

@@ -0,0 +1,104 @@
+import _ from 'lodash'
+import logger from 'loglevel'
+import config from 'config'
+import { Store, api, i18n, Events } from '../../core/client/index.js'
+import { parseCoordinates } from './utils/index.js'
+import { formatUserCoordinates, formatForwardGeocodingResult } from './utils/utils.location.js'
+import { Planets } from './planets.js'
+
+export const Geocoder = {
+  initialize () {
+    // Sets the available apps
+    Store.set('geocoder', _.defaultsDeep(config.geocoder, {
+      planet: undefined,
+      path: 'geocoder'
+    }))
+    logger.debug('[KDK] Geocoder initialized with configuration:', Store.get('geocoder'))
+  },
+  getApiConfig () {
+    const planet = Store.get('geocoder.planet')
+    if (planet) return Planets.get(planet).getConfig()
+    return api.getConfig()
+  },
+  getApiPath () {
+    return Store.get('geocoder.path')
+  },
+  async query (path, query = '') {
+    // retrieve required data
+    const apiConfig = this.getApiConfig()
+    if (!_.has(apiConfig, 'gateway')) {
+      logger.error('[KDK] Invalid Geocoder configuration: missing \'gateway\' property')
+      return
+    }
+    if (!_.has(apiConfig, 'gatewayJwt')) {
+      logger.error('[KDK] Invalid Geocoder configuration: missing \'gatewayJwt\' property')
+      return
+    }
+    const endpoint = `${apiConfig.gateway}/${this.getApiPath()}`
+    const jwt = await api.get('storage').getItem(apiConfig.gatewayJwt)
+    // setup the query url
+    let url = `${endpoint}/${path}`
+    if (query) url += `?${query}`
+    // query the service
+    const response = await fetch(url, { headers: { Authorization: `Bearer ${jwt}` } })
+    return response.json()
+  },
+  async getForwardCapabilities () {
+    let response
+    try {
+      response = await this.query('capabilities/forward')
+      if (response.i18n) i18n.registerTranslation(response.i18n)
+    } catch (error) {
+      Events.emit('error', { message: i18n.t('errors.NETWORK_ERROR') })
+    }
+    return _.get(response, 'geocoders', [])
+  },
+  async getReverseCapabilities () {
+    let response
+    try {
+      response = await this.query('capabilities/reverse')
+      if (response.i18n) i18n.registerTranslation(response.i18n)
+    } catch (error) {
+      Events.emit('error', { message: i18n.t('errors.NETWORK_ERROR') })
+    }
+    return _.get(response, 'geocoders', [])
+  },
+  async queryForward (pattern, options = {}) {
+    const locations = []
+    // Try to parse lat/long coordinates
+    const coordinates = parseCoordinates(pattern)
+    if (coordinates) {
+      locations.push({
+        type: 'Feature',
+        geometry: {
+          type: 'Point',
+          coordinates: [coordinates.longitude, coordinates.latitude]
+        },
+        properties: {
+          name: formatUserCoordinates(coordinates.latitude, coordinates.longitude, Store.get('locationFormat', 'FFf'))
+        }
+      })
+    } else {
+      let filter = ''
+      // Take into account optional geocoders
+      if (!_.isEmpty(options.geocoders)) {
+        filter += '&sources=*(' + options.geocoders.join('|') + ')'
+      }
+      // Take into account optional viewbo
+      if (!_.isEmpty(options.viewbox)) {
+        filter += '&viewbox=' + options.viewbox.join(',')
+      }
+      // Define the limit
+      filter += '&limit=' + (options.limit || 20)
+      const results = await this.query('forward', `q=${pattern}${filter}`)
+      results.forEach(result => {
+        locations.push(
+          Object.assign(
+            _.pick(result, ['type', 'geometry']),
+            { properties: { name: formatForwardGeocodingResult(result), source: result.geokoder.source } }))
+      })
+    }
+    return locations
+  }
+
+}

package/map/client/geolocation.js

@@ -56,7 +56,7 @@ export const Geolocation = {
     try {
       location = await this.refresh()
       Store.patch('geolocation', { location, error: undefined })
-      logger.debug('[KDK] geolocation updated: ', JSON.stringify(location, null, 4))
+      logger.debug('[KDK] Geolocation updated:', location)
     } catch (error) {
       const code = error.code
       const geolocationError = new errors.KGeolocationError()

package/map/client/globe.js

@@ -1,5 +1,6 @@
 import * as commonMixins from './mixins/index.js'
 import * as globeMixins from './mixins/globe/index.js'
+import * as hooks from './hooks/index.js'
 import * as utils from './utils.globe.js'
 import init from './init.js'
 
@@ -7,6 +8,8 @@ const mixins = Object.assign({}, commonMixins, { globe: globeMixins })
 
 export * from './geolocation.js'
 export * from './planets.js'
+export * from './navigator.js'
+export { hooks }
 export { utils }
 export { mixins }
 export * from '../common/index.js'

package/map/client/hooks/hooks.offline.js

@@ -0,0 +1,95 @@
+import _ from 'lodash'
+import logger from 'loglevel'
+import booleanIntersects from '@turf/boolean-intersects'
+import { polygon } from '@turf/helpers'
+
+export function removeServerSideParameters(context) {
+  const params = context.params
+  if (_.has(params, 'query.east')) {
+    _.set(params, 'east', _.get(params, 'query.east'))
+    _.unset(params, 'query.east')
+  }
+  if (_.has(params, 'query.west')) {
+    _.set(params, 'west', _.get(params, 'query.west'))
+    _.unset(params, 'query.west')
+  }
+  if (_.has(params, 'query.north')) {
+    _.set(params, 'north', _.get(params, 'query.north'))
+    _.unset(params, 'query.north')
+  }
+  if (_.has(params, 'query.south')) {
+    _.set(params, 'south', _.get(params, 'query.south'))
+    _.unset(params, 'query.south')
+  }
+}
+
+async function updateReferenceCount(service, id, increment) {
+  const feature = await service._get(id)
+  const count = _.get(feature, 'referenceCount', 0) + increment
+  const data = await service._patch(id, { referenceCount: count })
+  return data
+}
+export async function referenceCountCreateHook(context) {
+  const service = context.service
+  const features = (Array.isArray(context.data) ? context.data : [context.data])
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i]
+    try {
+      // This will raise if feature does not exist
+      await updateReferenceCount(service, feature._id, +1)
+    } catch (error) {
+      feature.referenceCount = 1
+      await service._create(feature)
+    }
+  }
+  context.result = context.data
+}
+
+export async function referenceCountRemoveHook(context) {
+  const service = context.service
+  // By ID or by query ?
+  if (!context.id) {
+    context.result = await service._find(Object.assign(context.params, { paginate: false }))
+    for (let i = 0; i < context.result.length; i++) {
+      const feature = context.result[i]
+      try {
+        const { referenceCount } = await updateReferenceCount(service, feature._id, -1)
+        // Skip removing if still used
+        if (referenceCount <= 0) await service._remove(feature._id)
+      } catch (error) {
+        logger.debug('[KDK] reference count update failed: ', error)
+      }
+    }
+  } else {
+    const feature = await updateReferenceCount(service, context.id, -1)
+    // Skip removing if still used
+    if (feature.referenceCount <= 0) await service._remove(context.id)
+    context.result = feature
+  }
+}
+
+export function geoJsonPaginationHook(context) {
+  const result = context.result
+  const features = result.data
+  if (_.get(features, '[0].type') !== 'Feature') return
+  context.result = Object.assign({
+    type: 'FeatureCollection',
+    features: result.data
+  }, _.pick(result, ['total', 'skip', 'limit']))
+}
+
+export async function intersectBBoxHook(context) {
+  const params = context.params
+  if (!_.has(params, 'east') || !_.has(params, 'west') || !_.has(params, 'north') || !_.has(params, 'south')) return context
+  const service = context.service
+  const query = await service._find(_.omit(params, ['east', 'west', 'north', 'south']))
+  const features = query.data
+  const bbox = polygon([[[params.east, params.south], [params.west, params.south], [params.west, params.north], [params.east, params.north], [params.east, params.south]]])
+  let result = []
+  for (let feature of features) {
+    if (booleanIntersects(bbox, feature)) {
+      result.push(feature)
+    }
+  }
+  _.set(context, 'result.data', result)
+}

package/map/client/hooks/index.js

@@ -0,0 +1 @@
+export * from './hooks.offline.js'