@maptrip/map-tiles 1.2.1 → 1.3.0

package/README.md

@@ -68,6 +68,7 @@ L.map("map", {
 
 - `token`: A valid and non-expired token for your account, see section _Authorization_ (**required**)
 - `attribution`: The copyright notes to show in the map
+- `releaseDate`: Boolean value stating whether to append the map release data to the attribution; default is false. 
 - `minZoom`: The minimum zoom level for the map (must not be smaller than 2)
 - `maxZoom`: The maximum zoom level for the map (must not be larger than 18)
 
@@ -108,6 +109,8 @@ new Map({
 `MapTripOpenLayersSource` can be configured with all properties listed in the section _Properties_, and also with these:
 
 - `token`: A valid and non-expired token for your account, see section _Authorization_ (**required**)
+- `attribution`: The copyright notes to show in the map
+- `releaseDate`: Boolean value stating whether to append the map release data to the attribution; default is false. 
 
 ### Google Maps
 
@@ -274,6 +277,7 @@ To use them, you mapping API has to be able to use both base layers and overlays
 
 ## History
 
+- 1.3.0: Added map release data for Leaflet and OpenLayers map attributions
 - 1.2.1: Fixed a bug in MapTripLeafletGridLayer type implementation 
 - 1.2.0: Added TypeScript declaration file
 - 1.1.1: Added rendering config for foot_path layer

package/dist/api-extensions/leaflet/MapTripLeafletGridLayer.d.ts

@@ -1,4 +1,5 @@
 import { PointXY, RENDERING_CONFIG } from '../../types/interfaces.js';
+import { MapReleaseFetcher } from '../../util/MapReleaseFetcher.js';
 import { VectorTileFactory } from '../../core/VectorTileFactory.js';
 import { default as L } from 'leaflet';
 
@@ -7,6 +8,11 @@ declare class MapTripLeafletGridLayer extends L.GridLayer {
     MAX_ZOOM: number;
     token: string;
     factory: VectorTileFactory;
+    releaseFetcher: MapReleaseFetcher;
+    provider: string;
+    attribution: string;
+    release: string;
+    releaseDate: boolean;
     constructor(options: {
         provider?: string;
         baseMap?: boolean;
@@ -19,7 +25,12 @@ declare class MapTripLeafletGridLayer extends L.GridLayer {
         attribution?: string;
         minZoom?: number;
         maxZoom?: number;
+        releaseDate?: boolean;
     });
     createTile(coords: PointXY): HTMLCanvasElement;
+    private initializeAttribution;
+    private setRelease;
+    private setAttribution;
+    private onBaseLayerChange;
 }
 export { MapTripLeafletGridLayer };

package/dist/api-extensions/openlayers/MapTripOpenLayersSource.d.ts

@@ -1,3 +1,4 @@
+import { MapReleaseFetcher } from '../../main.js';
 import { RENDERING_CONFIG } from '../../types/interfaces.js';
 import { VectorTileFactory } from '../../core/VectorTileFactory.js';
 import { default as XYZ } from 'ol/source/XYZ.js';
@@ -5,6 +6,9 @@ import { default as XYZ } from 'ol/source/XYZ.js';
 declare class MapTripOpenLayersSource extends XYZ {
     token: string;
     factory: VectorTileFactory;
+    release: string;
+    releaseFetcher: MapReleaseFetcher;
+    releaseDate: boolean;
     constructor(properties: {
         provider?: string;
         baseMap?: boolean;
@@ -14,6 +18,9 @@ declare class MapTripOpenLayersSource extends XYZ {
         detourProfile?: string;
         renderingConfig?: RENDERING_CONFIG;
         token?: string;
+        releaseDate?: boolean;
     });
+    private fetchAndSetAttribution;
+    private updateAttribution;
 }
 export { MapTripOpenLayersSource };

package/dist/map-tiles.d.ts

@@ -1,9 +1,10 @@
 import { MapTripOpenLayersSource } from './api-extensions/openlayers/MapTripOpenLayersSource.js';
 import { MapTripLeafletGridLayer } from './api-extensions/leaflet/MapTripLeafletGridLayer.js';
 import { MapTripGoogleMapType } from './api-extensions/google/MapTripGoogleMapType.js';
+import { MapReleaseFetcher } from './util/MapReleaseFetcher.js';
 import { RENDERING_CONFIG_TRAFFIC } from './core/rendering_config_traffic.js';
 import { RENDERING_CONFIG_GRAYSCALE } from './core/rendering_config_grayscale.js';
 import { RENDERING_CONFIG_DEFAULT } from './core/rendering_config_default.js';
 import { VectorTileFactory } from './core/VectorTileFactory.js';
 
-export { VectorTileFactory, RENDERING_CONFIG_DEFAULT, RENDERING_CONFIG_GRAYSCALE, RENDERING_CONFIG_TRAFFIC, MapTripLeafletGridLayer, MapTripGoogleMapType, MapTripOpenLayersSource, };
+export { VectorTileFactory, RENDERING_CONFIG_DEFAULT, RENDERING_CONFIG_GRAYSCALE, RENDERING_CONFIG_TRAFFIC, MapReleaseFetcher, MapTripLeafletGridLayer, MapTripGoogleMapType, MapTripOpenLayersSource, };

package/dist/map-tiles.js

@@ -3248,7 +3248,7 @@ class VectorTileFactory {
       throw new Error("Unknown provider");
     }
     if (this._properties.traffic && !PROVIDER_TRAFFIC[this._properties.provider]) {
-      throw new Error("There is now traffic information for this provider");
+      throw new Error("There is no traffic information for this provider");
     }
     if (!this._properties.baseMap && !this._properties.traffic) {
       throw new Error(
@@ -4548,6 +4548,81 @@ const RENDERING_CONFIG_GRAYSCALE = {
   }
 };
 
+class MapReleaseFetcher {
+  _baseUrl;
+  _token;
+  _tomtom = null;
+  _osm = null;
+  _here = null;
+  constructor(token) {
+    this._baseUrl = "https://v1.maptrip.de/?CMD=GETFILE&PROJECT=${project}&RELATIVEPATH=/data/mapset/data/routing_geocoder/admin.bin&acao=true";
+    this._token = token;
+  }
+  updateUrl(provider) {
+    if (provider === "tomtom") {
+      this._baseUrl = this._baseUrl.replace("${project}", "TomTom_latest");
+    } else if (provider === "openstreetmap") {
+      this._baseUrl = this._baseUrl.replace("${project}", "OSM_latest");
+    } else {
+      this._baseUrl = this._baseUrl.replace("${project}", "HERE_latest");
+    }
+  }
+  async getRelease(provider) {
+    const providerLowercase = provider.toLowerCase();
+    if (providerLowercase === "tomtom") {
+      if (!this._tomtom) {
+        this._tomtom = this.fetchAndExtractRelease(providerLowercase);
+      }
+      return this._tomtom;
+    } else if (providerLowercase === "here") {
+      if (!this._here) {
+        this._here = this.fetchAndExtractRelease(providerLowercase);
+      }
+      return this._here;
+    } else {
+      if (!this._osm) {
+        this._osm = this.fetchAndExtractRelease(providerLowercase);
+      }
+      return this._osm;
+    }
+  }
+  async fetchAndExtractRelease(provider) {
+    this.updateUrl(provider);
+    return new Promise((resolve, reject) => {
+      var xhr = new XMLHttpRequest();
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState !== XMLHttpRequest.DONE)
+          return;
+        if (xhr.status === 200) {
+          const text = new TextDecoder("latin1").decode(xhr.response);
+          const textString = this.extractTargetString(text);
+          const release = ` ${textString}`;
+          if (provider === "tomtom") {
+            this._tomtom = Promise.resolve(release);
+          } else if (provider === "here") {
+            this._here = Promise.resolve(release);
+          } else if (provider === "openstreetmap") {
+            this._osm = Promise.resolve(release);
+          }
+          resolve(release);
+        } else {
+          reject(`Error fetching: ${xhr.status}`);
+        }
+      };
+      xhr.open("GET", this._baseUrl, true);
+      xhr.setRequestHeader("Authorization", `Bearer ${this._token}`);
+      xhr.setRequestHeader("Accept", "*/*");
+      xhr.setRequestHeader("Content-Type", "application/octet-stream");
+      xhr.responseType = "arraybuffer";
+      xhr.send(null);
+    });
+  }
+  extractTargetString(text) {
+    const match = text.match(/2\d{3}Q[1-4]/);
+    return match ? match[0] : null;
+  }
+}
+
 class MapTripGoogleMapType {
   tileSize = new google.maps.Size(256, 256);
   alt = null;
@@ -19092,10 +19167,31 @@ class MapTripLeafletGridLayer extends L$1.GridLayer {
   MAX_ZOOM = MAX_ZOOM;
   token;
   factory;
+  releaseFetcher;
+  provider;
+  attribution;
+  release;
+  releaseDate;
   constructor(options) {
     super(options);
     this.token = options.token;
+    this.provider = options.provider ? options.provider?.toLowerCase() : "openstreetmap";
     this.options.attribution = options.attribution ? options.attribution : ATTRIBUTION;
+    this.releaseFetcher = new MapReleaseFetcher(this.token);
+    this.release = "";
+    this.attribution = "";
+    this.releaseDate = options.releaseDate ? options.releaseDate : false;
+    if (this.releaseDate) {
+      this.initializeAttribution();
+      this.on("add", () => {
+        if (this._map) {
+          this._map.on(
+            "baselayerchange",
+            (event) => this.onBaseLayerChange(event)
+          );
+        }
+      });
+    }
     this.options.minZoom = options.minZoom ? Math.max(this.MIN_ZOOM, options.minZoom) : this.MIN_ZOOM;
     this.options.maxZoom = options.maxZoom ? Math.min(this.MAX_ZOOM, options.maxZoom) : this.MAX_ZOOM;
     this.factory = VectorTileFactory.createFactory(options);
@@ -19103,6 +19199,57 @@ class MapTripLeafletGridLayer extends L$1.GridLayer {
   createTile(coords) {
     return this.factory.getJsonTile(coords.z, coords.x, coords.y, this.token);
   }
+  async initializeAttribution() {
+    await this.setRelease();
+    await this.setAttribution();
+  }
+  // Set an original release
+  async setRelease() {
+    const release = await this.releaseFetcher.getRelease(this.provider);
+    if (release) {
+      this.release = release;
+    }
+  }
+  async setAttribution() {
+    if (!this._map)
+      return;
+    try {
+      const newRelease = await this.releaseFetcher.getRelease(this.provider);
+      if (newRelease && newRelease !== this.release) {
+        this.release = newRelease;
+      }
+      this._map.attributionControl.removeAttribution(this.options.attribution);
+      this.attribution = `${this.options.attribution} ${this.release}`;
+      this._map.attributionControl.addAttribution(this.attribution);
+      const map = this._map;
+      this._map.addEventListener("baselayerchange", () => {
+        map.attributionControl.removeAttribution(this.attribution);
+      });
+    } catch (error) {
+      console.error("Error fetching release version: ", error);
+    }
+  }
+  async onBaseLayerChange(event) {
+    if (!this._map) {
+      return;
+    }
+    this._map.attributionControl.removeAttribution(this.attribution);
+    const eventProvider = event.layer.options.provider;
+    let newProvider;
+    if (eventProvider) {
+      if (eventProvider.toLowerCase() === "opensreetmap") {
+        newProvider = "openstreetmap";
+      } else if (eventProvider.toLowerCase() === "tomtom") {
+        newProvider = "tomtom";
+      } else if (eventProvider.toLowerCase() === "here") {
+        newProvider = "here";
+      } else {
+        newProvider = "openstreetmap";
+      }
+      this.provider = newProvider;
+      await this.setAttribution();
+    }
+  }
 }
 
 /**
@@ -26999,8 +27146,10 @@ const XYZ$1 = XYZ;
 class MapTripOpenLayersSource extends XYZ$1 {
   token;
   factory;
+  release = "";
+  releaseFetcher;
+  releaseDate;
   constructor(properties) {
-    super();
     const options = {};
     const projection = "EPSG:3857";
     const tileGrid = createXYZ({
@@ -27034,8 +27183,36 @@ class MapTripOpenLayersSource extends XYZ$1 {
     });
     this.token = properties.token;
     this.factory = VectorTileFactory.createFactory(properties);
+    this.releaseFetcher = new MapReleaseFetcher(this.token);
+    this.releaseDate = properties.releaseDate ? properties.releaseDate : false;
+    if (this.releaseDate) {
+      this.fetchAndSetAttribution(properties.provider, properties.token);
+      this.on("change", () => this.updateAttribution(properties.provider));
+    }
+  }
+  async fetchAndSetAttribution(provider, token) {
+    try {
+      const release = await this.releaseFetcher.getRelease(provider);
+      if (release) {
+        this.release = release;
+        this.setAttributions(`${ATTRIBUTION} ${this.release}`);
+      }
+    } catch (error) {
+      console.error("Error fetching release version: ", error);
+    }
+  }
+  async updateAttribution(provider) {
+    try {
+      const release = await this.releaseFetcher.getRelease(provider);
+      if (release && release !== this.release) {
+        this.release = release;
+        this.setAttributions(`${ATTRIBUTION} ${this.release}`);
+      }
+    } catch (error) {
+      console.error("Error updating attribution: ", error);
+    }
   }
 }
 
-export { MapTripGoogleMapType, MapTripLeafletGridLayer, MapTripOpenLayersSource, RENDERING_CONFIG_DEFAULT, RENDERING_CONFIG_GRAYSCALE, RENDERING_CONFIG_TRAFFIC, VectorTileFactory };
+export { MapReleaseFetcher, MapTripGoogleMapType, MapTripLeafletGridLayer, MapTripOpenLayersSource, RENDERING_CONFIG_DEFAULT, RENDERING_CONFIG_GRAYSCALE, RENDERING_CONFIG_TRAFFIC, VectorTileFactory };
 //# sourceMappingURL=map-tiles.js.map