chore: automated housekeeping...

src/UI/InputElement/Helpers/DistanceInput.svelte

@@ -1,5 +1,4 @@
 <script lang="ts">
-
   /**
    * Used to quickly calculate a distance by dragging a map (and selecting start- and endpoints)
    */
@@ -24,71 +23,77 @@
 
   export let value: UIEventSource<number>
   export let feature: Feature
-  export let args: { background?: string, zoom?: number }
+  export let args: { background?: string; zoom?: number }
   export let state: ThemeViewState = undefined
   export let map: UIEventSource<MlMap> = new UIEventSource<MlMap>(undefined)
 
   let center = GeoOperations.centerpointCoordinates(feature)
-  export let initialCoordinate: { lon: number, lat: number } = { lon: center[0], lat: center[1] }
-  let mapLocation: UIEventSource<{ lon: number, lat: number }> = new UIEventSource(initialCoordinate)
+  export let initialCoordinate: { lon: number; lat: number } = { lon: center[0], lat: center[1] }
+  let mapLocation: UIEventSource<{ lon: number; lat: number }> = new UIEventSource(
+    initialCoordinate
+  )
   let bg = args?.background
   let rasterLayer = state?.mapProperties.rasterLayer
   if (bg !== undefined) {
     if (eliCategory.indexOf(bg) >= 0) {
       const availableLayers = state.availableLayers.store.data
-      const startLayer: RasterLayerPolygon = RasterLayerUtils.SelectBestLayerAccordingTo(availableLayers, bg)
+      const startLayer: RasterLayerPolygon = RasterLayerUtils.SelectBestLayerAccordingTo(
+        availableLayers,
+        bg
+      )
       rasterLayer = new UIEventSource(startLayer)
-      state?.mapProperties.rasterLayer.addCallbackD(layer => rasterLayer.set(layer))
+      state?.mapProperties.rasterLayer.addCallbackD((layer) => rasterLayer.set(layer))
     }
-
   }
   let mapProperties: Partial<MapProperties> = {
     rasterLayer: rasterLayer,
     location: mapLocation,
-    zoom: new UIEventSource(args?.zoom ?? 18)
+    zoom: new UIEventSource(args?.zoom ?? 18),
   }
 
-  let start: UIEventSource<{ lon: number, lat: number }> = new UIEventSource(undefined)
+  let start: UIEventSource<{ lon: number; lat: number }> = new UIEventSource(undefined)
 
   function selectStart() {
     start.set(mapLocation.data)
   }
 
-  let lengthFeature: Store<Feature[]> = start.map(start => {
-    if (!start) {
-      return []
-    }
-    // A bit of a double task: calculate the actual value _and_ the map rendering
-    const end = mapLocation.data
-    const distance = GeoOperations.distanceBetween([start.lon, start.lat], [end.lon, end.lat])
-    value.set(distance.toFixed(2))
-
-
-    return <Feature[]>[
-
-      {
-        type: "Feature",
-        properties: {
-          id: "distance_line_" + distance,
-          distance: "" + distance
-        },
-        geometry: {
-          type: "LineString",
-          coordinates: [[start.lon, start.lat], [end.lon, end.lat]]
-        }
+  let lengthFeature: Store<Feature[]> = start.map(
+    (start) => {
+      if (!start) {
+        return []
       }
-    ]
+      // A bit of a double task: calculate the actual value _and_ the map rendering
+      const end = mapLocation.data
+      const distance = GeoOperations.distanceBetween([start.lon, start.lat], [end.lon, end.lat])
+      value.set(distance.toFixed(2))
 
-  }, [mapLocation])
+      return <Feature[]>[
+        {
+          type: "Feature",
+          properties: {
+            id: "distance_line_" + distance,
+            distance: "" + distance,
+          },
+          geometry: {
+            type: "LineString",
+            coordinates: [
+              [start.lon, start.lat],
+              [end.lon, end.lat],
+            ],
+          },
+        },
+      ]
+    },
+    [mapLocation]
+  )
 
   new ShowDataLayer(map, {
     layer: new LayerConfig(conflation),
-    features: new StaticFeatureSource(lengthFeature)
+    features: new StaticFeatureSource(lengthFeature),
   })
-
 </script>
 
-<div class="relative w-full h-64">
+<div class="relative h-64 w-full">
   <LocationInput value={mapLocation} {mapProperties} {map} />
   <div class="absolute bottom-0 left-0 p-4">
     <OpenBackgroundSelectorButton {state} {map} />

src/UI/InputElement/Validators.ts

@@ -61,7 +61,7 @@ export default class Validators {
         "translation",
         "url",
         "velopark",
-        "wikidata"
+        "wikidata",
     ] as const
 
     public static readonly AllValidators: ReadonlyArray<Validator> = [
@@ -93,7 +93,7 @@ export default class Validators {
         new VeloparkValidator(),
         new NameSuggestionIndexValidator(),
         new CurrencyValidator(),
-        new RegexValidator()
+        new RegexValidator(),
     ]
 
     private static _byType = Validators._byTypeConstructor()

src/UI/InputElement/Validators/DistanceValidator.ts

@@ -6,17 +6,19 @@ export default class DistanceValidator extends Validator {
     private readonly docs: string = [
         "#### Helper-arguments",
         "Options are:",
-        ["````json",
-            "  \"background\": \"some_background_id or category, e.g. 'map'\"",
-            "  \"zoom\": 20 # initial zoom level of the map",
+        [
+            "````json",
+            '  "background": "some_background_id or category, e.g. \'map\'"',
+            '  "zoom": 20 # initial zoom level of the map',
             "}",
-            "```"].join("\n")
+            "```",
+        ].join("\n"),
     ].join("\n\n")
 
     constructor() {
         super(
             "distance",
-            "A geographical distance in meters (rounded at two points). Will give an extra minimap with a measurement tool. Arguments: [ zoomlevel, preferredBackgroundMapType (comma separated) ], e.g. `[\"21\", \"map,photo\"]",
+            'A geographical distance in meters (rounded at two points). Will give an extra minimap with a measurement tool. Arguments: [ zoomlevel, preferredBackgroundMapType (comma separated) ], e.g. `["21", "map,photo"]',
             "decimal"
         )
     }
@@ -35,14 +37,18 @@ export default class DistanceValidator extends Validator {
         }
 
         const optionalKeys = ["background", "zoom"]
-        const keys = Object.keys(args).filter(k => optionalKeys.indexOf(k) < 0)
+        const keys = Object.keys(args).filter((k) => optionalKeys.indexOf(k) < 0)
         if (keys.length > 0) {
-            return "Unknown key " + keys.join("; ") + "; use " + optionalKeys.join("; ") + " instead"
+            return (
+                "Unknown key " + keys.join("; ") + "; use " + optionalKeys.join("; ") + " instead"
+            )
         }
         const bg = args["background"]
         if (bg && eliCategory.indexOf(bg) < 0) {
-            return "The given background layer is not a recognized ELI-type. Perhaps you meant one of " +
-                Utils.sortedByLevenshteinDistance(bg, eliCategory, x => x).slice(0, 5)
+            return (
+                "The given background layer is not a recognized ELI-type. Perhaps you meant one of " +
+                Utils.sortedByLevenshteinDistance(bg, eliCategory, (x) => x).slice(0, 5)
+            )
         }
         if (typeof args["zoom"] !== "number") {
             return "zoom must be a number, got a " + typeof args["zoom"]