@kalisio/kdk 2.4.0 → 2.5.1

package/map/client/mixins/mixin.activity.js

@@ -1,7 +1,8 @@
 import _ from 'lodash'
 import logger from 'loglevel'
 import config from 'config'
-import { Store, utils as kCoreUtils } from '../../../core/client/index.js'
+import { Store } from '../../../core/client/index.js'
+import { filterContent, bindContent, listenToServiceEvents, unlistenToServiceEvents } from '../../../core/client/utils/index.js'
 import { Geolocation } from '../geolocation.js'
 import { setEngineJwt, getLayers, getCategories } from '../utils/utils.catalog.js'
 import * as layers from '../utils/utils.layers.js'
@@ -121,25 +122,34 @@ export const activity = {
     },
     isLayerProbable: layers.isLayerProbable,
     isLayerStorable: layers.isLayerStorable,
+    isLayerCached: layers.isLayerCached,
+    isLayerCachable: layers.isLayerCachable,
+    setLayerCached: layers.setLayerCached,
+    setLayerUncached: layers.setLayerUncached,
     isLayerEditable: layers.isLayerEditable,
     isLayerRemovable: layers.isLayerRemovable,
     isLayerStyleEditable: layers.isLayerStyleEditable,
     isLayerDataEditable: layers.isLayerDataEditable,
     async resetLayer (layer) {
+      // Keep track of data as we will reset the layer
+      let geoJson
+      if (typeof this.toGeoJson === 'function') geoJson = await this.toGeoJson(layer.name)
       // Reset layer with new setup but keep track of current visibility state
       // as adding the layer back will restore default visibility state
       const isVisible = this.isLayerVisible(layer.name)
       await this.removeLayer(layer.name)
       await this.addLayer(layer)
       if (isVisible) await this.showLayer(layer.name)
+      if (geoJson && (typeof this.toGeoJson === 'function')) this.updateLayer(layer.name, geoJson)
     },
     configureLayerActions (layer) {
       let actions = _.get(this, 'activityOptions.layers.actions', [])
       // Apply filtering
-      actions = kCoreUtils.filterContent(actions, _.get(this, 'activityOptions.layers.filter', {}))
+      actions = filterContent(actions, _.get(this, 'activityOptions.layers.filter', {}))
+      
       // As context is different for each item we need to clone the global action configuration
       // otherwise context will always reference the last processed item
-      actions = kCoreUtils.bindContent(_.cloneDeep(actions), this)
+      actions = bindContent(_.cloneDeep(actions), this, ['dialog'])
       // Add 'virtual' actions used to trigger the layer/filters
       actions.push({ id: 'toggle', handler: () => this.onTriggerLayer(layer) })
       actions.push({ id: 'toggle-filter', handler: (filter) => this.onTriggerLayerFilter(layer, filter) })
@@ -159,7 +169,8 @@ export const activity = {
     },
     async onTriggerLayerFilter (layer, filter) {
       // Can only apply to realtime layers as we need to force a data refresh
-      if (typeof this.updateLayer === 'function') await this.updateLayer(layer.name)
+      // removeMissing seems needed for 3d
+      if (typeof this.updateLayer === 'function') await this.updateLayer(layer.name, null, { removeMissing: true})
     },
     onZoomIn () {
       const center = this.getCenter()
@@ -217,6 +228,12 @@ export const activity = {
       // this one can be triggered from a toolbar to accept or reject changes
       await this.stopEditLayer(status)
     },
+    async onResetLayerStyle (layer) {
+      await layers.editLayerStyle(layer, {})
+      if (!layer._id) {
+        await this.resetLayer(layer)
+      }
+    },
     async onRemoveLayer (layer) {
       // Stop any running edition
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) await this.stopEditLayer('reject')
@@ -235,6 +252,29 @@ export const activity = {
       if (!this.$q.fullscreen.isActive) this.$q.fullscreen.request()
       else this.$q.fullscreen.exit()
     },
+    listenToCatalogServiceEvents () {
+      // Listen about changes in global/contextual catalog services
+      const globalCatalogService = this.$api.getService('catalog', 'global')
+      const catalogService = this.$api.getService('catalog')
+      this.globalCatalogListeners = listenToServiceEvents('catalog', {
+        context: 'global', all: this.onCatalogUpdated, removed: (object) => this.onCatalogUpdated(object, 'removed')
+      }, this.globalCatalogListeners)
+      if (catalogService && (catalogService !== globalCatalogService)) {
+        this.catalogListeners = listenToServiceEvents('catalog', {
+          all: this.onCatalogUpdated, removed: (object) => this.onCatalogUpdated(object, 'removed')
+        }, this.catalogListeners)
+      }
+    },
+    unlistenToCatalogServiceEvents () {
+      if (this.globalCatalogListeners) unlistenToServiceEvents(this.globalCatalogListeners)
+      if (this.catalogListeners) unlistenToServiceEvents(this.catalogListeners)
+      this.globalCatalogListeners = null
+      this.catalogListeners = null
+    },
+    resetCatalogServiceEventsListeners () {
+      // Listening again will unlisten previous ones if any
+      this.listenToCatalogServiceEvents()
+    },
     async initialize () {
       // Check if the activity is using context restoration
       const hasContext = (typeof this.restoreContext === 'function')
@@ -244,7 +284,7 @@ export const activity = {
         try {
           await this.setupWeacast()
         } catch (error) {
-          logger.error(`[KDK] ${error}`)
+          logger.error('[KDK]', error)
         }
       } else {
         if (weacastEnabled) logger.warn('[KDK] Weacast setup function is missing')
@@ -256,7 +296,7 @@ export const activity = {
         await this.refreshLayers()
         if (hasContext) await this.restoreContext('layers')
       } catch (error) {
-        logger.error(`[KDK] ${error}`)
+        logger.error('[KDK]', error)
       }
       // Retrieve the time
       if (hasContext) await this.restoreContext('time')
@@ -267,42 +307,12 @@ export const activity = {
         await Geolocation.update()
         if (Geolocation.hasLocation()) this.center(Geolocation.getLongitude(), Geolocation.getLatitude())
       }
-      // Listen about changes in global/contextual catalog services
-      const globalCatalogService = this.$api.getService('catalog', '')
-      const catalogService = this.$api.getService('catalog')
-      // Keep track of binded listeners as we use the same function with different contexts
-      this.catalogListeners = {}
-      if (globalCatalogService.events !== undefined) {
-        globalCatalogService.events.forEach(event => {
-          // Avoid reentrance
-          if (!this.catalogListeners[event]) {
-            this.catalogListeners[event] = (object) => this.onCatalogUpdated(event, object)
-            globalCatalogService.on(event, this.catalogListeners[event])
-            if (catalogService && (catalogService !== globalCatalogService)) {
-              catalogService.on(event, this.catalogListeners[event])
-            }
-          }
-        })
-      }
+      this.listenToCatalogServiceEvents()
     },
     finalize () {
-      // Stop listening about changes in global/contextual catalog services
-      const globalCatalogService = this.$api.getService('catalog', '')
-      const catalogService = this.$api.getService('catalog')
-      if (globalCatalogService.events !== undefined) {
-        globalCatalogService.events.forEach(event => {
-          // Avoid reentrance
-          if (this.catalogListeners[event]) {
-            globalCatalogService.removeListener(event, this.catalogListeners[event])
-            if (catalogService && (catalogService !== globalCatalogService)) {
-              catalogService.removeListener(event, this.catalogListeners[event])
-            }
-          }
-        })
-      }
-      this.catalogListeners = {}
+      this.unlistenToCatalogServiceEvents()
     },
-    async onCatalogUpdated (event, object) {
+    async onCatalogUpdated (object, event) {
       switch (object.type) {
         case 'Category':
           // In any case we rebuild categories
@@ -346,16 +356,26 @@ export const activity = {
       // Take care that if we only use the default options the specific options will be undefined
       this.activityOptions.engine = _.defaultsDeep(_.get(this.activityOptions, 'engine', {}), defaultOptions)
     }
-  },
-  mounted () {
+    // Listen to map events
     this.$engineEvents.on('map-ready', this.onEngineReady)
     this.$engineEvents.on('globe-ready', this.onEngineReady)
     this.$engineEvents.on('layer-added', this.configureLayerActions)
   },
+  mounted () {
+    // Target online/offline service depending on status
+    this.$events.on('navigator-disconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.on('navigator-reconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.on('websocket-disconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.on('websocket-reconnected', this.resetCatalogServiceEventsListeners)
+  },
   beforeUnmount () {
     this.$engineEvents.off('map-ready', this.onEngineReady)
     this.$engineEvents.off('globe-ready', this.onEngineReady)
     this.$engineEvents.off('layer-added', this.configureLayerActions)
+    this.$events.off('navigator-disconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.off('navigator-reconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.off('websocket-disconnected', this.resetCatalogServiceEventsListeners)
+    this.$events.off('websocket-reconnected', this.resetCatalogServiceEventsListeners)
     this.finalize()
   }
 }

package/map/client/mixins/mixin.context.js

@@ -169,22 +169,27 @@ export const context = {
       // Restore from local storage/catalog if no route parameters
       if (_.isEmpty(targetParameters)) {
         const savedParameters = LocalStorage.get(this.getContextKey(context))
-        if (this.shouldRestoreContext(context) && !_.isEmpty(savedParameters)) {
-          targetParameters = savedParameters
-          // Backward compatibility: we previously stored the bounds as an array
-          if (Array.isArray(targetParameters)) {
-            targetParameters = {
-              south: targetParameters[0][0],
-              west: targetParameters[0][1],
-              north: targetParameters[1][0],
-              east: targetParameters[1][1]
+        if (this.shouldRestoreContext(context)) {
+          if (!_.isEmpty(savedParameters)) {
+            targetParameters = savedParameters
+            // Backward compatibility: we previously stored the bounds as an array
+            if (Array.isArray(targetParameters)) {
+              targetParameters = {
+                south: targetParameters[0][0],
+                west: targetParameters[0][1],
+                north: targetParameters[1][0],
+                east: targetParameters[1][1]
+              }
             }
+          } else {
+            // Check for a home context if not already retrieved
+            // Use undefined here to check for a first try as if we find none we set it to null
+            if (_.isUndefined(this.homeContext)) {
+              const response = await this.$api.getService('catalog').find({ query: { type: 'Context', isDefault: true } })
+              this.homeContext = (response.data.length > 0 ? response.data[0] : null)
+            }
+            if (this.homeContext) targetParameters = this.homeContext
           }
-        } else {
-          // Check for a home context
-          const response = await this.$api.getService('catalog').find({ query: { type: 'Context', isDefault: true } })
-          const homeContext = (response.data.length > 0 ? response.data[0] : null)
-          if (homeContext) targetParameters = homeContext
         }
       }
       // Restore context if possible

package/map/client/mixins/mixin.feature-selection.js

@@ -27,4 +27,3 @@ export const featureSelection = {
     }
   }
 }
- 

package/map/client/mixins/mixin.feature-service.js

@@ -1,7 +1,7 @@
 import _ from 'lodash'
 import sift from 'sift'
-import { getType, getGeom } from '@turf/invariant'
 import logger from 'loglevel'
+import { listenToServiceEvents, unlistenToServiceEvents } from '../../../core/client/utils/index.js'
 import * as features from '../utils/utils.features.js'
 import * as layers from '../utils/utils.layers.js'
 
@@ -69,12 +69,12 @@ export const featureService = {
     createFeatures: features.createFeatures,
     editFeaturesGeometry: features.editFeaturesGeometry,
     editFeaturesProperties: features.editFeaturesProperties,
+    editFeaturesStyle: features.editFeaturesStyle,
     removeFeatures: features.removeFeatures,
-    onFeaturesUpdated (feature, layerId) {
-      // We only support single feature edition
-      if (!getType(feature) || !getGeom(feature)) return
-      // Find related layer
-      const layer = this.getLayerById(layerId || feature.layer)
+    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 = this.getLayerById(feature.layer)
       if (!layer || !this.isLayerVisible(layer.name)) return
       // Only possible when not edited by default
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) return
@@ -89,11 +89,10 @@ export const featureService = {
         if (filteredFeature.length > 0) this.updateLayer(layer.name, feature, { removeMissing: false })
       }
     },
-    onFeaturesRemoved (feature, layerId) {
-      // We only support single feature edition
-      if (!getType(feature) || !getGeom(feature)) return
-      // Find related layer
-      const layer = this.getLayerById(layerId || feature.layer)
+    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 = this.getLayerById(feature.layer)
       if (!layer || !this.isLayerVisible(layer.name)) return
       // Only possible when not edited by default
       if ((typeof this.isLayerEdited === 'function') && this.isLayerEdited(layer)) return
@@ -108,31 +107,23 @@ export const featureService = {
         if (filteredFeature.length > 0) this.updateLayer(layer.name, feature, { remove: true })
       }
     },
-    listenToServiceEvents (layer) {
-      // User-defined layers are already managed
-      if (!layer.service || !layer.serviceEvents || layers.isInMemoryLayer(layer) || layers.isFeatureLayer(layer)) return
-      const service = this.$api.getService(layer.service)
-      // Check if service available and not already registered
-      if (!service || this.layerServiceEventListeners[layer._id]) return
-      // Generate listeners targetting the right layer as in this case the features won't hold it contrary to user-defined layers
-      const onFeaturesUpdated = (feature) => this.onFeaturesUpdated(feature, layer._id)
-      const onFeaturesRemoved = (feature) => this.onFeaturesRemoved(feature, layer._id)
-      this.layerServiceEventListeners[layer._id] = { layerService: layer.service, onFeaturesUpdated, onFeaturesRemoved }
-      service.on('created', onFeaturesUpdated)
-      service.on('patched', onFeaturesUpdated)
-      service.on('removed', onFeaturesRemoved)
+    listenToFeaturesServiceEventsForLayer (layer) {
+      const listeners = features.listenToFeaturesServiceEventsForLayer(layer, {
+        created: this.onFeatureUpdated, updated: this.onFeatureUpdated, patched: this.onFeatureUpdated, removed: this.onFeatureRemoved
+      }, this.layerServiceEventListeners[layer._id])
+      if (listeners) this.layerServiceEventListeners[layer._id] = listeners
     },
-    unlistenToServiceEvents (layer) {
-      // Check if listeners are registered for layer
-      if (!this.layerServiceEventListeners[layer._id]) return
-      const { layerService, onFeaturesUpdated, onFeaturesRemoved } = this.layerServiceEventListeners[layer._id]
-      const service = this.$api.getService(layerService)
-      // Check if service still available
-      if (!service) return
-      service.off('created', onFeaturesUpdated)
-      service.off('patched', onFeaturesUpdated)
-      service.off('removed', onFeaturesRemoved)
+    unlistenToFeaturesServiceEventsForLayer (layer) {
+      features.unlistenToFeaturesServiceEventsForLayer(layer, this.layerServiceEventListeners[layer._id])
       delete this.layerServiceEventListeners[layer._id]
+    },
+    listenToFeaturesServiceEventsForLayers () {
+      this.layerServiceEventListeners = {}
+      _.forEach(this.getLayers(), this.listenToFeaturesServiceEventsForLayer)
+    },
+    unlistenToFeaturesServiceEventsForLayers () {
+      _.forOwn(this.layerServiceEventListeners, this.unlistenToFeaturesServiceEventsForLayer)
+      this.layerServiceEventListeners = {}
     }
   },
   created () {
@@ -140,34 +131,25 @@ export const featureService = {
     this.$api.getService('features').timeout = 60 * 60 * 1000 // 1h should be sufficient since we also have size limits
   },
   mounted () {
-    // Here we need to listen to service events for all realtime layers triggered by it
-    // 1) user-defined layers targetting the features service
-    const featuresService = this.$api.getService('features')
-    featuresService.on('created', this.onFeaturesUpdated)
-    featuresService.on('patched', this.onFeaturesUpdated)
-    featuresService.on('removed', this.onFeaturesRemoved)
-    // 2) built-in layers targetting specific services
+    // Here we need to listen to service events for all realtime layers
+    this.listenToFeaturesServiceEventsForLayers()
     // As we don't know target services upfront we register listeners when layer are added, we track it in a map
-    this.layerServiceEventListeners = {}
-    this.$engineEvents.on('layer-added', this.listenToServiceEvents)
-    this.$engineEvents.on('layer-removed', this.unlistenToServiceEvents)
+    this.$engineEvents.on('layer-added', this.listenToFeaturesServiceEventsForLayer)
+    this.$engineEvents.on('layer-removed', this.unlistenToFeaturesServiceEventsForLayer)
+    // Target online/offline service depending on status
+    this.$events.on('navigator-disconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.on('navigator-reconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.on('websocket-disconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.on('websocket-reconnected', this.listenToFeaturesServiceEventsForLayers)
   },
   beforeUnmount () {
     // Remove all listeners
-    const featuresService = this.$api.getService('features')
-    featuresService.off('created', this.onFeaturesUpdated)
-    featuresService.off('patched', this.onFeaturesUpdated)
-    featuresService.off('removed', this.onFeaturesRemoved)
-    _.forOwn(this.layerServiceEventListeners, listeners => {
-      const { layerService, onFeaturesUpdated, onFeaturesRemoved } = listeners
-      const service = this.$api.getService(layerService)
-      // Check if service still available
-      if (!service) return
-      service.off('created', onFeaturesUpdated)
-      service.off('patched', onFeaturesUpdated)
-      service.off('removed', onFeaturesRemoved)
-    })
-    this.$engineEvents.off('layer-added', this.listenToServiceEvents)
-    this.$engineEvents.off('layer-removed', this.unlistenToServiceEvents)
+    this.unlistenToFeaturesServiceEventsForLayers()
+    this.$engineEvents.off('layer-added', this.listenToFeaturesServiceEventsForLayer)
+    this.$engineEvents.off('layer-removed', this.unlistenToFeaturesServiceEventsForLayer)
+    this.$events.off('navigator-disconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.off('navigator-reconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.off('websocket-disconnected', this.listenToFeaturesServiceEventsForLayers)
+    this.$events.off('websocket-reconnected', this.listenToFeaturesServiceEventsForLayers)
   }
 }

package/map/client/mixins/mixin.weacast.js

@@ -26,7 +26,7 @@ export const weacast = {
       }
     },
     async setupForecastModels () {
-      if (!this.getWeacastApi()) return
+      if (!this.getWeacastApi() || this.getWeacastApi().isDisconnected || this.getWeacastApi().useLocalFirst) return
       const response = await this.getWeacastApi().getService('forecasts').find()
       // Required to use splice when modifying objects inside an array to make it reactive
       this.forecastModels.splice(0, this.forecastModels.length, ...response.data)

package/map/client/navigator.js

@@ -0,0 +1,38 @@
+import _ from 'lodash'
+import logger from 'loglevel'
+import { Store, Platform, LocalStorage } from '../../core/client/index.js'
+
+export const Navigator = {
+  initialize () {
+    this.availableApps = {
+      waze: 'https://waze.com/ul?q=<%= lat %>,<%= lon %>',
+      'google-maps': 'https://www.google.com/maps/dir/?api=1&destination=<%= lat %>,<%= lon %>',
+      'apple-plan': 'https://maps.apple.com/place?ll=<%= lat %>,<%= lon %>'
+    }
+    const settings = LocalStorage.get('settings')
+    if (_.isNil(settings)) {
+      let app = 'google-maps'
+      if (Platform.ios) app = 'apple-plan'
+      Store.set('navigator', app)
+      logger.debug('[KDK] Navigator initialized to:', this.get())
+    } else {
+      logger.debug('[KDK] Navigator initialized to:', settings.navigator)
+    }
+  },
+  get () {
+    return Store.get('navigator')
+  },
+  navigateTo (lat, lon) {
+    // Retrieve the default app
+    const app = this.get()
+    if (_.isEmpty(app)) {
+      logger.debug('[KDK] Default navigator is undefined')
+      return
+    }
+    // Template the url
+    const compiledUrl = _.template(this.availableApps[app])
+    const interpolatedUrl = compiledUrl({ lat, lon })
+    // Open the interpolated url
+    window.open(interpolatedUrl)
+  }
+}

package/map/client/pixi-utils.js

@@ -95,7 +95,7 @@ export const WEBGL_FUNCTIONS = {
 PIXI.TYPES.HALF_FLOAT_VERTEX = 0x140b
 
 export function buildShaderCode (features) {
-  let vtxCode = '#version 300 es'
+  let vtxCode = '#version 300 es\nprecision highp float;'
   let frgCode = '#version 300 es\nprecision highp float;'
   // attributes, uniforms and varyings
   vtxCode += '\n\n/// attributes, uniforms and varyings\n'

package/map/client/planets.js

@@ -22,7 +22,7 @@ export const Planets = {
       renewJwt: false
     })
 
-    const client = createClient(options)
+    const client = await createClient(options)
     setupApi.bind(client)(options)
     client.on('authenticated', (data) => {
       // Store API gateway token if any

package/map/client/readers/reader.kml.js

@@ -1,6 +1,8 @@
 import logger from 'loglevel'
+import _ from 'lodash'
 import { kml } from '@tmcw/togeojson'
 import { i18n } from '../../../core/client/i18n.js'
+import { convertSimpleStyleToPointStyle, convertSimpleStyleToLineStyle, convertSimpleStyleToPolygonStyle } from '../utils/utils.style.js'
 
 export const KMLReader = {
   read (files, options) {
@@ -15,7 +17,7 @@ export const KMLReader = {
       reader.onloadend = () => {
         let content = reader.result
         try {
-          content = kml(new DOMParser().parseFromString(content, 'text/xml'))
+          content = convertToGeoJsonWithStyle(new DOMParser().parseFromString(content, 'text/xml'))
         } catch (error) {
           logger.debug(error)
           reject(new Error(i18n.t('errors.INVALID_KML_FILE', { file: file.name }), { errors: error }))
@@ -34,3 +36,57 @@ export const KMLReader = {
     return []
   }
 }
+
+function getExtraPropertiesFromKMLByName (document) {
+  const properties = {}
+  const propertiesToAdd = ['extrude', 'altitudeMode']
+  const placemarks = document.getElementsByTagName('Placemark')
+  _.forEach(placemarks, placemark => {
+    const nameElements = placemark.getElementsByTagName('name')
+    if (!nameElements.length) return
+    const name = nameElements[0].textContent
+    _.forEach(propertiesToAdd, property => {
+      const propertyElements = placemark.getElementsByTagName(property)
+      if (!propertyElements.length) return
+
+      let value = propertyElements[0].textContent
+      if (['0', '1'].includes(value)) {
+        value = value === '1'
+      }
+      _.set(properties, [name, property].join('.'), value)
+    })
+  })
+  return properties
+}
+
+export function convertToGeoJsonWithStyle (document) {
+  const extraProperties = getExtraPropertiesFromKMLByName(document)
+
+  const geoJson = kml(document)
+
+  _.forEach(_.get(geoJson, 'features', []), feature => {
+    const name = _.get(feature, 'properties.name', false)
+    // Apply all styles to prevent them for being overridden by the default ones
+    const style = _.merge(convertSimpleStyleToPointStyle(feature.properties), convertSimpleStyleToLineStyle(feature.properties), convertSimpleStyleToPolygonStyle(feature.properties))
+    if (name && _.has(extraProperties, name)) {
+      _.merge(style, extraProperties[name])
+    }
+    _.set(feature, 'style', style)
+
+    // Trim all string properties
+    const trimmedProperties = _.mapValues(_.get(feature, 'properties', {}), value => {
+      return typeof value === 'string' ? value.trim() : value
+    })
+    _.set(feature, 'properties', trimmedProperties)
+
+    // Add label for points if they have a name
+    if (_.get(feature, 'geometry.type') === 'Point' && _.has(feature, 'properties.name')) {
+      _.set(feature, 'properties.icon-text', feature.properties.name)
+      _.set(feature, 'properties.entityStyle.label', {
+        heightReference: 'Cesium.HeightReference.RELATIVE_TO_GROUND'
+      })
+    }
+  })
+
+  return geoJson
+}

package/map/client/utils/index.js

@@ -4,6 +4,7 @@ export * from './utils.catalog.js'
 export * from './utils.features.js'
 export * from './utils.layers.js'
 export * from './utils.location.js'
+export * from './utils.offline.js'
 export * from './utils.project.js'
 export * from './utils.schema.js'
 export * from './utils.style.js'

package/map/client/utils/utils.capture.js

@@ -35,7 +35,7 @@ export async function capture (values) {
   dismiss = Notify.create({
     group: 'capture',
     icon: 'las la-hourglass-half',
-    message: i18n.t('KCapture.CAPTURING_VIEW'),
+    message: i18n.t('KCapture.PRINTING_VIEW'),
     color: 'primary',
     timeout: 0,
     spinner: true
@@ -53,6 +53,7 @@ export async function capture (values) {
         size: { width: +values.resolution.width, height: +values.resolution.height },
         layout: getLayout(values),
         time: dateArray[index],
+        basePath: _.has(values, 'basePath') ? values.basePath : '/#/home/',
         lang: getAppLocale()
       })
       const response = await fetch(endpoint, options)
@@ -92,9 +93,10 @@ function getLayout (values) {
     },
     fab: { visible: false }
   }
-  if (_.has(values, 'header')) _.set(layout, 'header', headerFooterComponent(values.header, 'header'))
-  if (_.has(values, 'footer')) _.set(layout, 'footer', headerFooterComponent(values.footer, 'footer'))
-  if (_.includes(placements, values.compass)) _.set(layout, 'page', compassComponent(values.compass))
+
+  if (_.has(values, 'header') && !_.isEmpty(values.header)) _.set(layout, 'header', headerFooterComponent(values.header, 'header'))
+  if (_.has(values, 'footer') && !_.isEmpty(values.footer)) _.set(layout, 'footer', headerFooterComponent(values.footer, 'footer'))
+  if (_.includes(placements, values.north)) _.set(layout, 'stickies', northComponent(values.north))
   if (_.includes(placements, values.legend)) _.set(layout, `windows.${values.legend}`, legendComponent())
 
   return layout
@@ -102,8 +104,9 @@ function getLayout (values) {
 function headerFooterComponent (text, position) {
   return { content: [{ component: _.get(config, `capture.${position}.component`, 'KCaptureTextArea'), text, position }], visible: true }
 }
-function compassComponent (position) {
-  return { content: _.union(Layout.getStickies().content, [{ position, offset: [0, 5], content: [{ component: 'KNorth' }] }]) }
+function northComponent (position) {
+  const northSticky = Layout.findSticky('north-sticky')
+  return { content: [{ ...northSticky, position, offset: [0, 5], visible: true }] }
 }
 function legendComponent () {
   return {
@@ -173,4 +176,4 @@ async function generatePdf (imageArray, width, height) {
     inputs.push({ capture: `data:image/png;base64,${base64Encode(value)}` })
   })
   return await generate({ template, plugins, inputs })
-}
+}

package/map/client/utils/utils.catalog.js

@@ -90,8 +90,8 @@ export function getOrphanLayers (layers, layersByCategory) {
 
 function processTranslations (item) {
   if (item.i18n) i18n.registerTranslation(item.i18n)
-  item.label = i18n.tie(item.name)
-  item.description = i18n.tie(item.description)
+  if (!_.has(item, 'label')) item.label = i18n.tie(item.name)
+  if (_.has(item, 'description')) item.description = i18n.tie(item.description)
 }
 
 export async function getLayers (options = {}) {