@kalisio/kdk 2.1.9 → 2.2.1

package/extras/tours/map/timeline.js

@@ -1,77 +1,77 @@
 module.exports = [{
-  target: '#timeline',
+  target: '#timecontrols',
   title: 'tours.timeline.TIMELINE_LABEL',
   params: {
     placement: 'top'
   }
 }, {
-  target: '#timeline-date',
+  target: '#datetime-controls',
   title: 'tours.timeline.DATE_LABEL',
   params: {
     placement: 'top'
   }
 }, {
-  target: '#timeline-now',
-  title: 'tours.timeline.NOW_LABEL',
+  target: '#date-button',
+  title: 'tours.timeline.PICK_DAY_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
+    clickOn: '#date-button',
+    clickDelay: 100
   }
 }, {
-  target: '#timeline-forward',
-  title: 'tours.timeline.NEXT_STEP_LABEL',
-  link: 'tours.timeline.SETTINGS_LINK_LABEL',
+  target: '#time-button',
+  title: 'tours.timeline.PICK_TIMES_LABEL',
   params: {
     placement: 'top',
-    tour: 'home'
+    clickOn: '#time-button',
+    clickDelay: 100
   }
 }, {
-  target: '#timeline-backward',
-  title: 'tours.timeline.PREVIOUS_STEP_LABEL',
-  link: 'tours.timeline.SETTINGS_LINK_LABEL',
+  target: '#timecontrol-now',
+  title: 'tours.timeline.NOW_LABEL',
   params: {
-    placement: 'top',
-    tour: 'home'
+    placement: 'top'
   }
 }, {
-  target: '#timeline-minutes-1',
-  title: 'tours.timeline.PICK_MINUTES_LABEL',
+  target: '#timecontrol-step',
+  title: 'tours.timeline.STEP_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-next-hour',
-  title: 'tours.timeline.NEXT_HOUR_LABEL',
+  target: '#previous-step',
+  title: 'tours.timeline.PREVIOUS_STEP_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-previous-hour',
+  target: '#previous-hour',
   title: 'tours.timeline.PREVIOUS_HOUR_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-hours-1',
-  title: 'tours.timeline.PICK_HOUR_LABEL',
+  target: '#previous-day',
+  title: 'tours.timeline.PREVIOUS_DAY_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-next-day',
+  target: '#next-day',
   title: 'tours.timeline.NEXT_DAY_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-previous-day',
-  title: 'tours.timeline.PREVIOUS_DAY_LABEL',
+  target: '#next-hour',
+  title: 'tours.timeline.NEXT_HOUR_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }, {
-  target: '#timeline-days-1',
-  title: 'tours.timeline.PICK_DAY_LABEL',
+  target: '#next-step',
+  title: 'tours.timeline.NEXT_STEP_LABEL',
   params: {
-    placement: 'top'
+    placement: 'top',
   }
 }]

package/map/api/config/categories.cjs

@@ -21,7 +21,10 @@ module.exports = function (categoryFiles, context) {
     categories = categories.concat(categoriesFromFile)
   })
   debug(`Found ${categories.length} category definitions to build catalog from`)
-
+  // Sort categories
+  categories.sort((category, other) => {
+    return (category.order || 50) - (other.order || 50)
+  })
   // All categories by default
   let filter = categories.map(category => category.name.replace('Categories.', ''))
   // Now build filter according any env filter

package/map/api/hooks/hooks.catalog.js

@@ -83,3 +83,42 @@ export async function updateLayerReferences (hook) {
   debug(`Updated ${contexts.length} contexts and categories after renaming or removing layer ${layer.name} `)
   return hook
 }
+
+// Update projects when a layer/view is removed
+export async function updateProjects (hook) {
+  const app = hook.app
+  const context = hook.service.getContextId()
+  const projectsService = app.getService('projects', context)
+  if (!projectsService) return hook
+  let removedItems = getItems(hook)
+  if (!Array.isArray(removedItems)) removedItems = [removedItems]
+  for (let i = 0; i < removedItems.length; i++) {
+    const removedItem = removedItems[i]
+    const isLayer = removedItem.type !== 'Context'
+    const query = {}
+    if (isLayer) {
+      query.$or = [{ 'layers._id': removedItem._id }, { 'layers.name': removedItem.name }]
+    } else {
+      query['views._id'] = removedItem._id
+    }
+    // Retrieve the list of all projects involving the item
+    const projects = await projectsService.find({
+      query, paginate: false
+    })
+    // Stop when non found
+    if (projects.length === 0) {
+      debug(`No project to update after removing item ${removedItem.name} `)
+      return hook
+    }
+    // Update each project otherwise
+    await Promise.all(projects.map(project => {
+      // Remove item in list
+      const items = (isLayer ? project.layers : project.views)
+      _.remove(items, item => item._id ? removedItem._id.toString() === item._id.toString() : removedItem.name === item.name)
+      return projectsService.patch(project._id.toString(), isLayer ? { layers: items } : { views: items })
+    }))
+
+    debug(`Updated ${projects.length} projects after removing item ${removedItem.name} `)
+  }
+  return hook
+}

package/map/api/hooks/hooks.features.js

@@ -4,6 +4,7 @@ import bbox from '@turf/bbox'
 import makeDebug from 'debug'
 import feathers from '@feathersjs/feathers'
 import common from 'feathers-hooks-common'
+import mongodbFuzzySearch from 'feathers-mongodb-fuzzy-search'
 import { hooks as coreHooks, unmarshallTime } from '../../../core/api/index.js'
 
 const { defaultEventMap } = feathers
@@ -31,12 +32,16 @@ function getLayers (features) {
 }
 
 export function simplifyResult (hook) {
+  // Force full result emission ?
+  const fullResult = _.get(hook, 'params.fullResult')
+  if (fullResult) return hook
   const service = hook.service
   const method = hook.method
   const result = getItems(hook)
   const simplifyResult = _.get(service, 'options.simplifyResult', ['create', 'update', 'patch', 'remove'])
+  const simplifyResultLimit = _.get(service, 'options.simplifyResultLimit', 1)
   // Only keep track of object IDs so that caller can at least get them if required
-  if (simplifyResult.includes(method) && Array.isArray(result)) {
+  if (simplifyResult.includes(method) && Array.isArray(result) && (result.length > simplifyResultLimit)) {
     debug(`Simplifying multi result for ${method} method on service ${service.name}`)
     replaceItems(hook, result.map(item => ({ _id: item._id })))
   }
@@ -44,6 +49,9 @@ export function simplifyResult (hook) {
 }
 
 export function skipEvents (hook) {
+  // Force standard event emission ?
+  const emitEvents = _.get(hook, 'params.emitEvents')
+  if (emitEvents) return hook
   const service = hook.service
   const method = hook.method
   const event = defaultEventMap[method]
@@ -52,12 +60,16 @@ export function skipEvents (hook) {
   const simplifyEvents = _.get(service, 'options.simplifyEvents', [])
   // Even if we emit simplified events we skip standard feathers events to emit our own version
   let skip = skipEvents.includes(event) || simplifyEvents.includes(event)
-  skip = skip && Array.isArray(result)
+  const skipEventsLimit = _.get(service, 'options.skipEventsLimit', 1)
+  skip = skip && Array.isArray(result) && (result.length > skipEventsLimit)
   if (skip) debug(`Skipping standard event ${event} for multi operation on service ${service.name}`)
   return iff(hook => skip, coreHooks.skipEvents)(hook)
 }
 
 export function simplifyEvents (hook) {
+  // Force standard event emission ?
+  const emitEvents = _.get(hook, 'params.emitEvents')
+  if (emitEvents) return hook
   const service = hook.service
   const params = hook.params
   const data = hook.data
@@ -67,7 +79,8 @@ export function simplifyEvents (hook) {
   const event = defaultEventMap[method]
   const result = getItems(hook)
   const simplifyEvents = _.get(service, 'options.simplifyEvents', [])
-  if (simplifyEvents.includes(event) && Array.isArray(result)) {
+  const simplifyEventsLimit = _.get(service, 'options.simplifyEventsLimit', 1)
+  if (simplifyEvents.includes(event) && Array.isArray(result) && (result.length > simplifyEventsLimit)) {
     debug(`Simplifying event ${event} for multi operation on service ${service.name}`)
     // Keep track of query selector when updating/patching/removing in batch
     const payload = (event === 'created' ? {} : { data })
@@ -82,3 +95,10 @@ export function simplifyEvents (hook) {
   }
   return hook
 }
+
+export function fuzzySearch (hook) {
+  const service = hook.service
+  const featureLabel = _.castArray(_.get(service, 'options.featureLabel', []))
+  const fields = featureLabel.map((prop) => 'properties.' + prop)
+  return featureLabel.length ? mongodbFuzzySearch({ fields: fields })(hook) : hook
+}

package/map/api/hooks/hooks.query.js

@@ -12,6 +12,35 @@ export function marshallGeometryQuery (hook) {
   marshallGeometry(geometry)
 }
 
+function getGeometryQueryForBBox (bbox) {
+  // Here we use the custom MongoDB CRS that enforces counter-clockwise winding order
+  // and allows to support queries with a single-ringed GeoJSON polygon
+  // whose area is greater than or equal to a single hemisphere.
+  // Otherwise $geoIntersects queries for the complementary geometry.
+  return {
+    $geoIntersects: {
+      $geometry: {
+        type: 'Polygon',
+        coordinates: [bbox],
+        crs: {
+          type: 'name',
+          properties: { name: 'urn:x-mongodb:crs:strictwinding:EPSG:4326' }
+        }
+      }
+    }
+  }
+}
+
+export function marshallGeoJsonQuery (hook) {
+  const query = hook.params.query
+  if (query) {
+    if (query.geoJson) {
+      delete query.geoJson
+      hook.params.asGeoJson = true
+    }
+  }
+}
+
 export function marshallSpatialQuery (hook) {
   const query = hook.params.query
   if (query) {
@@ -66,17 +95,20 @@ export function marshallSpatialQuery (hook) {
       delete query.north
       delete query.west
       delete query.east
-      const geometryQuery = {
-        $geoIntersects: {
-          $geometry: {
-            type: 'Polygon',
-            coordinates: [ // BBox as a polygon
-              [[west, south], [east, south], [east, north], [west, north], [west, south]] // Closing point
-            ]
-          }
-        }
+      
+      // FIXME: MongoDB should allow to support queries with a single-ringed GeoJSON polygon
+      // whose area is greater than or equal to a single hemisphere.
+      // However, we did not succeeed in making it work as expected, for now on we split large polygon into two halfs.
+      if ((east-west) <= 180) {
+        // BBox as a polygon also requires the closing point.
+        const bbox = [[west, south], [east, south], [east, north], [west, north], [west, south]]
+        query.geometry = getGeometryQueryForBBox(bbox)
+      } else {
+        // BBox as a polygon also requires the closing point.
+        const leftHalfBbox = [[west, south], [0.5*(west+east), south], [0.5*(west+east), north], [west, north], [west, south]]
+        const rightHalfBbox = [[0.5*(west+east), south], [east, south], [east, north], [0.5*(west+east), north], [0.5*(west+east), south]]
+        query.$or = [{ geometry: getGeometryQueryForBBox(leftHalfBbox) }, { geometry: getGeometryQueryForBBox(rightHalfBbox) }]
       }
-      query.geometry = geometryQuery
     }
     // Shortcut for location query
     if (!_.isNil(query.longitude) && !_.isNil(query.latitude)) {
@@ -95,11 +127,9 @@ export function marshallSpatialQuery (hook) {
       }
       query.geometry = geometryQuery
     }
-    if (query.geoJson) {
-      delete query.geoJson
-      hook.params.asGeoJson = true
-    }
   }
+  // Include GeoJson query by default
+  marshallGeoJsonQuery(hook)
 }
 
 export function asGeoJson (options = {}) {
@@ -118,6 +148,9 @@ export function asGeoJson (options = {}) {
     const isPaginated = !_.isNil(results.data)
     const pagination = (isPaginated ? _.pick(results, ['total', 'skip', 'limit']) : {})
     results = (isPaginated ? results.data : results)
+    // Single item case, i.e. GET ?
+    const isFeatureCollection = Array.isArray(results)
+    if (!isFeatureCollection) results = [results]
     results = results
       .filter(item => {
         // Check if item is not already in GeoJson feature format and we can convert if required
@@ -169,24 +202,35 @@ export function asGeoJson (options = {}) {
     // Move some data to properties ?
     if (options.properties) {
       results.forEach(item => {
-        options.properties.forEach(mapping => {
-          if (mapping.from) _.set(item, `properties.${mapping.to || mapping.from}`, _.get(item, `${mapping.from}`))
-          if (mapping.delete) _.unset(item, `${mapping.from}`)
-        })
+        // True indicates to move all fields to properties
+        if (options.properties === true) {
+          _.forOwn(item, (value, key) => {
+            if ((key === 'geometry') || (key === 'type') || (key === '_id')) return
+            _.set(item, `properties.${key}`, _.get(item, key))
+            _.unset(item, key)
+          })
+        } else { // Else we expect a specific mapping
+          options.properties.forEach(mapping => {
+            if (mapping.from) _.set(item, `properties.${mapping.to || mapping.from}`, _.get(item, `${mapping.from}`))
+            if (mapping.delete) _.unset(item, `${mapping.from}`)
+          })
+        }
       })
     }
-    // Copy pagination information if any so that client can use it anyway
-    if (_.get(options, 'asFeatureCollection', true)) {
+    // If we should make it available as a GeoJson feature collection create it
+    if (isFeatureCollection && _.get(options, 'asFeatureCollection', true)) {
+      // Copy pagination information if any so that client can use it anyway
       _.set(hook, options.dataPath || 'result', Object.assign({
         type: 'FeatureCollection',
         features: results
       }, pagination)) // If no pagination this merged object will be empty
     } else if (isPaginated) {
+      // Copy pagination information if any so that client can use it anyway
       _.set(hook, options.dataPath || 'result', Object.assign({
         data: results
       }, pagination))
     } else {
-      _.set(hook, options.dataPath || 'result', results)
+      _.set(hook, options.dataPath || 'result', isFeatureCollection ? results : results[0])
     }
   }
 }

package/map/api/models/projects.model.mongodb.js

@@ -0,0 +1,8 @@
+export default function (app, options) {
+  const db = options.db || app.db
+  options.Model = db.collection('projects')
+  // Collation provided in query ensure sorting to be case insensitive w.r.t. user's language
+  // We built indices with collation to cover the most used languages, it requires different naming...
+  options.Model.createIndex({ name: 1 }, { name: 'name-en', collation: { locale: 'en', strength: 1 } })
+  options.Model.createIndex({ name: 1 }, { name: 'name-fr', collation: { locale: 'fr', strength: 1 } })
+}

package/map/api/services/catalog/catalog.hooks.js

@@ -1,7 +1,8 @@
 import _ from 'lodash'
 import common from 'feathers-hooks-common'
+import fuzzySearch from 'feathers-mongodb-fuzzy-search'
 import { hooks as coreHooks } from '../../../../core/api/index.js'
-import { filterLayers, updateLayerReferences, getDefaultCategories, getDefaultSublegends } from '../../hooks/index.js'
+import { filterLayers, updateLayerReferences, updateProjects, getDefaultCategories, getDefaultSublegends } from '../../hooks/index.js'
 
 const { setNow, discard } = common
 
@@ -9,7 +10,7 @@ export default {
   before: {
     all: [],
     find: [
-      filterLayers, coreHooks.distinct
+      fuzzySearch({ fields: ['name'] }), coreHooks.diacriticSearch(), filterLayers, coreHooks.distinct
     ],
     get: [],
     create: [
@@ -60,7 +61,8 @@ export default {
     ],
     remove: [
       setNow('updatedAt'),
-      updateLayerReferences
+      updateLayerReferences,
+      updateProjects
     ]
   },
 

package/map/api/services/features/features.hooks.js

@@ -1,19 +1,31 @@
+import _ from 'lodash'
 import { hooks as coreHooks } from '../../../../core/api/index.js'
 import {
   marshallSpatialQuery, aggregateFeaturesQuery, asGeoJson,
-  simplifyResult, simplifyEvents, skipEvents
+  simplifyResult, simplifyEvents, skipEvents, fuzzySearch
 } from '../../hooks/index.js'
 
+// Allow to control real-time events emission if required
+const emitEvents = (hook) => {
+  _.set(hook, 'params.emitEvents', _.get(hook, 'params.query.emitEvents'))
+  _.unset(hook, 'params.query.emitEvents')
+}
+// Allow to control full result emission if required
+const fullResult = (hook) => {
+  _.set(hook, 'params.fullResult', _.get(hook, 'params.query.fullResult'))
+  _.unset(hook, 'params.query.fullResult')
+}
+
 export default {
   before: {
     all: [coreHooks.marshallTimeQuery, coreHooks.convertObjectIDs(['layer'])],
     find: [coreHooks.marshallComparisonQuery, coreHooks.marshallSortQuery, marshallSpatialQuery,
-      coreHooks.distinct, aggregateFeaturesQuery, coreHooks.aggregationQuery],
+      coreHooks.distinct, aggregateFeaturesQuery, coreHooks.aggregationQuery, fuzzySearch, coreHooks.diacriticSearch],
     get: [],
-    create: [coreHooks.processTimes(['time'])],
-    update: [coreHooks.processTimes(['time'])],
-    patch: [coreHooks.processTimes(['time'])],
-    remove: [coreHooks.marshallComparisonQuery, marshallSpatialQuery]
+    create: [coreHooks.processTimes(['time']), fullResult, emitEvents],
+    update: [coreHooks.processTimes(['time']), fullResult, emitEvents],
+    patch: [coreHooks.processTimes(['time']), fullResult, emitEvents],
+    remove: [coreHooks.marshallComparisonQuery, marshallSpatialQuery, fullResult, emitEvents]
   },
 
   after: {

package/map/api/services/index.js

@@ -18,7 +18,7 @@ export function createFeaturesService (options = {}) {
 
   debug('Creating features service with options', options)
   return app.createService(options.collection, Object.assign({
-    fileName: 'features',
+    modelName: 'features',
     servicesPath,
     modelsPath,
     paginate: { default: 5000, max: 5000 },
@@ -50,6 +50,22 @@ export function removeCatalogService (options = {}) {
   return app.removeService(app.getService('catalog', options.context))
 }
 
+export async function createProjectsService (options = {}) {
+  const app = this
+
+  debug('Creating projects service with options', options)
+  await app.createService('projects', Object.assign({
+    servicesPath,
+    modelsPath,
+    paginate: { default: 20, max: 5000 }
+  }, options))
+}
+
+export function removeProjectsService (options = {}) {
+  const app = this
+  return app.removeService(app.getService('projects', options.context))
+}
+
 export function createAlertsService (options = {}) {
   const app = this
 
@@ -126,13 +142,13 @@ export async function createDefaultCatalogLayers (options) {
       featuresService = await createFeaturesServiceForLayer.call(app, Object.assign({
         collection: defaultLayer.service,
         db: app.db.db(defaultLayer.dbName)
-      }, _.pick(defaultLayer, ['ttl', 'featureId', 'featureIdType', 'variables', 'simplifyResult', 'skipEvents', 'simplifyEvents'])))
+      }, _.pick(defaultLayer, ['ttl', 'featureId', 'featureIdType', 'featureLabel', 'variables', 'simplifyResult', 'skipEvents', 'simplifyEvents'])))
     }
     if (defaultLayer.probeService) {
       await createFeaturesServiceForLayer.call(app, Object.assign({
         collection: defaultLayer.probeService,
         db: app.db.db(defaultLayer.dbName)
-      }, _.pick(defaultLayer, ['simplifyResult', 'skipEvents', 'simplifyEvents'])))
+      }, _.pick(defaultLayer, ['featureLabel', 'simplifyResult', 'skipEvents', 'simplifyEvents'])))
     }
     // And if we need to initialize some data as well
     if (!createdLayer && featuresService && (defaultLayer.url || defaultLayer.fileName)) {
@@ -183,9 +199,9 @@ export default async function () {
   if (catalogConfig) {
     await createCatalogService.call(app)
   }
-  const geocoderConfig = app.get('geocoder')
-  if (geocoderConfig) {
-    await app.createService('geocoder', { servicesPath })
+  const projectsConfig = app.get('projects')
+  if (projectsConfig) {
+    await createProjectsService.call(app)
   }
   // Add app-specific hooks to required services
   app.on('service', async service => {

package/map/api/services/projects/projects.hooks.js

@@ -0,0 +1,118 @@
+import _ from 'lodash'
+import commonHooks from 'feathers-hooks-common'
+// import { hooks as schemaHooks, resolve } from '@feathersjs/schema'
+import { hooks as coreHooks } from '../../../../core/api/index.js'
+
+const { setNow, discard, getItems, replaceItems, when } = commonHooks
+
+/* Populate is too much specialized and does not allow to merge input/output
+ but we need the service information on the fronted
+export const populateLayers = populate({
+  schema: hook => {
+    const service = hook.app.getService('catalog')
+    return {
+      include: [{
+        service: service.getPath(true),
+        nameAs: 'layers',
+        select: (hook, project) => ({ _id: { $in: _.map(project.layers, '_id') } })
+      }]
+    }
+  }
+})
+*/
+
+/* Can't get resolvers to work
+  const layersResolver = resolve({
+  layers: async (project, context) => {
+    // Populate the layers associated via ids
+    const layers = await context.app.getService('catalog').find({ query: { _id: [project.layers] } })
+    return layers
+  }
+})
+const contextsResolver = resolve({
+  contexts: async (project, context) => {
+    // Populate the contexts associated via ids
+    const contexts = await context.app.getService('catalog').find({ query: { _id: [project.contexts], type: 'Context' } })
+    return contexts
+  }
+})
+*/
+
+function marshallPopulateQuery (hook) {
+  const query = hook.params.query
+  if (query) {
+    if (query.populate) {
+      delete query.populate
+      hook.params.populate = true
+    }
+  }
+}
+
+const populateProjects = async (hook) => {
+  let items = getItems(hook)
+  const isArray = Array.isArray(items)
+  items = (isArray ? items : [items])
+  for (let i = 0; i < items.length; i++) {
+    const project = items[i]
+    const layers = project.layers || []
+    for (let j = 0; j < layers.length; j++) {
+      let layer = layers[j]
+      // Get only name when listing
+      const query = { $select: ['name', 'service', 'probeService'] }
+      const service = hook.app.getService('catalog', _.has(layer, 'context') ? layer.context : hook.service.context)
+      // As we keep track of ID/name depending on if a layer is a user-defined one or not we need to process both
+      Object.assign(query, (layer._id ? { _id: layer._id } : { name: layer.name }))
+      const response = await service.find({ query })
+      layer = _.get(response, 'data[0]')
+      Object.assign(layers[j], layer)
+    }
+    const views = project.views || []
+    for (let j = 0; j < views.length; j++) {
+      let view = views[j]
+      // Get only name when listing
+      const query = { $select: ['name'], type: 'Context' }
+      Object.assign(query, { _id: view._id })
+      const service = hook.app.getService('catalog', _.has(view, 'context') ? view.context : hook.service.context)
+      const response = await service.find({ query })
+      view = _.get(response, 'data[0]')
+      Object.assign(views[j], view)
+    }
+  }
+  replaceItems(hook, isArray ? items : items[0])
+}
+
+export default {
+  before: {
+    all: [],
+    find: [marshallPopulateQuery],
+    get: [marshallPopulateQuery],
+    create: [coreHooks.convertObjectIDs(['layers', 'views']), setNow('createdAt', 'updatedAt')],
+    update: [],
+    patch: [coreHooks.convertObjectIDs(['layers', 'views']), discard('createdAt', 'updatedAt'), setNow('updatedAt')],
+    remove: []
+  },
+
+  after: {
+    all: [],
+    find: [when(hook => hook.params.populate, populateProjects)],
+    get: [when(hook => hook.params.populate, populateProjects)],
+    create: [],
+    update: [],
+    patch: [],
+    remove: []
+  },
+  /* Can't get resolvers to work
+  around: {
+    all: [schemaHooks.resolveResult(layersResolver), schemaHooks.resolveResult(contextsResolver)]
+  },
+  */
+  error: {
+    all: [],
+    find: [],
+    get: [],
+    create: [],
+    update: [],
+    patch: [],
+    remove: [setNow('updatedAt')]
+  }
+}

package/map/client/capture.js

@@ -0,0 +1,16 @@
+import { Notify } from 'quasar'
+import { capture } from './utils/utils.capture.js'
+import { i18n } from '../../core/client/index.js'
+
+// Export singleton
+export const Capture = {
+  processing: false,
+  async process (values) {
+    if (this.processing) Notify.create({ type: 'negative', message: i18n.t('KCapture.ERROR_MESSAGE') })
+    else {
+      this.processing = true
+      await capture(values)
+      this.processing = false
+    }
+  }
+}

package/map/client/cesium/utils/index.js

@@ -0,0 +1,4 @@
+export * from './utils.events.js'
+export * from './utils.popup.js'
+export * from './utils.style.js'
+export * from './utils.features.js'