@maptiler/sdk 1.1.2 → 1.2.1

package/src/index.ts

@@ -2,14 +2,11 @@
  * Maplibre export first, then extensions can overload the exports.
  */
 export * from "maplibre-gl";
-
 /**
  * To perform explicit named export so that they are included in the UMD bundle
  */
 // import * as ML from "maplibre-gl";
-
 import maplibregl from "maplibre-gl";
-
 const {
   // supported,
   setRTLTextPlugin,
@@ -28,7 +25,6 @@ const {
   addProtocol,
   removeProtocol,
 } = maplibregl;
-
 // We still want to export maplibregl.Map, but as a different name
 const MapMLGL = maplibregl.Map;
 const MarkerMLGL = maplibregl.Marker;
@@ -48,7 +44,6 @@ const LogoControlMLGL = maplibregl.LogoControl;
 const ScaleControlMLGL = maplibregl.ScaleControl;
 const FullscreenControlMLGL = maplibregl.FullscreenControl;
 const TerrainControlMLGL = maplibregl.TerrainControl;
-
 export {
   // supported,
   setRTLTextPlugin,
@@ -78,7 +73,6 @@ export {
   removeProtocol,
   MapMLGL,
 };
-
 // Exporting types of class instances from MapLibre:
 export type NavigationControlMLGL = InstanceType<typeof NavigationControlMLGL>;
 export type GeolocateControlMLGL = InstanceType<typeof GeolocateControlMLGL>;
@@ -107,126 +101,101 @@ export type RasterTileSourceMLGL = InstanceType<typeof RasterTileSourceMLGL>;
 export type VectorTileSourceMLGL = InstanceType<typeof VectorTileSourceMLGL>;
 export type VideoSourceMLGL = InstanceType<typeof VideoSourceMLGL>;
 export type MapMLGL = InstanceType<typeof MapMLGL>;
-
 // SDK specific
-import { Map, GeolocationType } from "./Map";
-import type { MapOptions, LoadWithTerrainEvent } from "./Map";
-
-import { Marker } from "./Marker";
-import { Popup } from "./Popup";
-import { Style } from "./Style";
-import { CanvasSource } from "./CanvasSource";
-import { GeoJSONSource } from "./GeoJSONSource";
-import { ImageSource } from "./ImageSource";
-import { RasterTileSource } from "./RasterTileSource";
-import { RasterDEMTileSource } from "./RasterDEMTileSource";
-import { VectorTileSource } from "./VectorTileSource";
-import { VideoSource } from "./VideoSource";
-import { NavigationControl } from "./NavigationControl";
-import { GeolocateControl } from "./GeolocateControl";
-import { AttributionControl } from "./AttributionControl";
-import { LogoControl } from "./LogoControl";
-import { ScaleControl } from "./ScaleControl";
-import { FullscreenControl } from "./FullscreenControl";
-import { TerrainControl } from "./TerrainControl";
-
-// Import of modified versions of the controls
-import { MaptilerGeolocateControl } from "./MaptilerGeolocateControl";
-import { MaptilerLogoControl } from "./MaptilerLogoControl";
-import { MaptilerTerrainControl } from "./MaptilerTerrainControl";
-import { MaptilerNavigationControl } from "./MaptilerNavigationControl";
-
-// importing client functions to expose them as part of the SDK
-import type {
-  BBox,
-  Position,
-  GeocodingOptions,
-  CoordinatesSearchOptions,
-  CenteredStaticMapOptions,
-  AutomaticStaticMapOptions,
-  BoundedStaticMapOptions,
-} from "@maptiler/client";
-
-import {
-  geocoding,
-  geolocation,
-  coordinates,
-  data,
-  staticMaps,
-  ServiceError,
-  LanguageGeocoding,
-  LanguageGeocodingString,
-  ReferenceMapStyle,
-  MapStyle,
-  MapStyleVariant,
-} from "@maptiler/client";
-
-import type { MapStyleType } from "@maptiler/client";
-
-import { Point } from "./Point";
-import type { Matrix2 } from "./Point";
-
-// Importing enums and configs
-import { config, SdkConfig } from "./config";
-import { Language, LanguageString, LanguageKey } from "./language";
-import type { Unit } from "./unit";
-
-// Exporting types
-export type {
-  MapOptions,
-  LoadWithTerrainEvent,
-  GeocodingOptions,
-  BBox,
-  Position,
-  CoordinatesSearchOptions,
-  CenteredStaticMapOptions,
-  BoundedStaticMapOptions,
-  AutomaticStaticMapOptions,
-  LanguageString,
-  LanguageKey,
-  LanguageGeocodingString,
-  Unit,
-  MapStyleType,
-  Matrix2,
-};
-
-// Exporting classes, objects, functions, etc.
 export {
   Map,
-  Marker,
-  Popup,
-  Style,
-  CanvasSource,
-  GeoJSONSource,
-  ImageSource,
-  RasterTileSource,
-  RasterDEMTileSource,
-  VideoSource,
-  NavigationControl,
-  GeolocateControl,
-  AttributionControl,
-  LogoControl,
-  ScaleControl,
-  FullscreenControl,
-  TerrainControl,
-  VectorTileSource,
   GeolocationType,
-  SdkConfig,
-  config,
+  type MapOptions,
+  type LoadWithTerrainEvent,
+} from "./Map";
+export { Marker } from "./Marker";
+export { Popup } from "./Popup";
+export { Style } from "./Style";
+export { CanvasSource } from "./CanvasSource";
+export { GeoJSONSource } from "./GeoJSONSource";
+export { ImageSource } from "./ImageSource";
+export { RasterTileSource } from "./RasterTileSource";
+export { RasterDEMTileSource } from "./RasterDEMTileSource";
+export { VectorTileSource } from "./VectorTileSource";
+export { VideoSource } from "./VideoSource";
+export { NavigationControl } from "./NavigationControl";
+export { GeolocateControl } from "./GeolocateControl";
+export { AttributionControl } from "./AttributionControl";
+export { LogoControl } from "./LogoControl";
+export { ScaleControl } from "./ScaleControl";
+export { FullscreenControl } from "./FullscreenControl";
+export { TerrainControl } from "./TerrainControl";
+// Export of modified versions of the controls
+export * from "./MaptilerGeolocateControl";
+export * from "./MaptilerLogoControl";
+export * from "./MaptilerTerrainControl";
+export * from "./MaptilerNavigationControl";
+export {
+  type AutomaticStaticMapOptions,
+  type BoundedStaticMapOptions,
+  type BufferToPixelDataFunction,
+  type ByIdGeocodingOptions,
+  type CenteredStaticMapOptions,
+  type CommonForwardAndReverseGeocodingOptions,
+  type CoordinateExport,
+  type CoordinateGrid,
+  type CoordinateId,
+  type CoordinateSearch,
+  type CoordinateSearchResult,
+  type CoordinateTransformResult,
+  type CoordinateTransformation,
+  type Coordinates,
+  type CoordinatesSearchOptions,
+  type CoordinatesTransformOptions,
+  type DefaultTransformation,
+  type ElevationAtOptions,
+  type ElevationBatchOptions,
+  type FeatureHierarchy,
+  type FetchFunction,
+  type GeocodingFeature,
+  type GeocodingOptions,
+  type GeocodingSearchResult,
+  type GeolocationInfoOptions,
+  type GeolocationResult,
+  type GetDataOptions,
+  LanguageGeocoding,
+  type LanguageGeocodingOptions,
+  type LanguageGeocodingString,
+  MapStyle,
+  type MapStylePreset,
+  type MapStyleType,
+  MapStyleVariant,
+  type PixelData,
+  ReferenceMapStyle,
+  type ReverseGeocodingOptions,
   ServiceError,
-  geocoding,
-  geolocation,
+  type StaticMapBaseOptions,
+  type StaticMapMarker,
+  type TileJSON,
+  type XYZ,
+  bufferToPixelDataBrowser,
+  circumferenceAtLatitude,
   coordinates,
   data,
+  elevation,
+  expandMapStyle,
+  geocoding,
+  geolocation,
+  getAutoLanguageGeocoding,
+  getBufferToPixelDataParser,
+  getTileCache,
+  mapStylePresetList,
+  math,
+  misc,
   staticMaps,
-  MapStyle,
-  Language,
-  LanguageGeocoding,
-  Point,
-  ReferenceMapStyle,
-  MapStyleVariant,
-  MaptilerGeolocateControl,
-  MaptilerLogoControl,
-  MaptilerTerrainControl,
-  MaptilerNavigationControl,
-};
+  styleToStyle,
+} from "@maptiler/client";
+
+export * from "./Point";
+export { config, SdkConfig } from "./config";
+export * from "./language";
+export { type Unit } from "./unit";
+export * from "./Minimap";
+export * from "./converters";
+export * from "./colorramp";
+export * from "./helpers";

package/src/language.ts

@@ -2,6 +2,30 @@
  * Languages. Note that not all the languages of this list are available but the compatibility list may be expanded in the future.
  */
 const Language = {
+  /**
+   * The visitor language mode concatenates the prefered language from the user settings and the "default name".
+   * Note: The "default name" is equivalent to OSM's `{name}`, which can be the most recognized names a global
+   * scale or the local name.
+   * This mode is helpful in the context where a user needs to access both the local names and the names in their
+   * own language, for instance when traveling abroad, where signs likely to be only available in the local language.
+   */
+  VISITOR: "visitor",
+
+  /**
+   * The visitor language mode concatenates English and the "default name".
+   * Note: The "default name" is equivalent to OSM's `{name}`, which can be the most recognized names a global
+   * scale or the local name.
+   * This mode is helpful in the context where a user needs to access both the local names and the names in their
+   * own language, for instance when traveling abroad, where signs likely to be only available in the local language.
+   */
+  VISITOR_ENGLISH: "visitor_en",
+
+  /**
+   * Language as the style is designed. Not that this is the default state and one
+   * the language has been changed to another than `STYLE`, then it cannot be set back to `STYLE`.
+   */
+  STYLE: "style",
+
   /**
    * AUTO mode uses the language of the browser
    */
@@ -17,88 +41,101 @@ const Language = {
   /**
    * Default fallback languages that uses latin charaters
    */
-  LATIN: "latin",
+  LATIN: "name:latin",
 
   /**
    * Default fallback languages that uses non-latin charaters
    */
-  NON_LATIN: "nonlatin",
+  NON_LATIN: "name:nonlatin",
 
   /**
    * Labels are in their local language, when available
    */
-  LOCAL: "",
-
-  ALBANIAN: "sq",
-  AMHARIC: "am",
-  ARABIC: "ar",
-  ARMENIAN: "hy",
-  AZERBAIJANI: "az",
-  BASQUE: "eu",
-  BELORUSSIAN: "be",
-  BOSNIAN: "bs",
-  BRETON: "br",
-  BULGARIAN: "bg",
-  CATALAN: "ca",
-  CHINESE: "zh",
-  CORSICAN: "co",
-  CROATIAN: "hr",
-  CZECH: "cs",
-  DANISH: "da",
-  DUTCH: "nl",
-  ENGLISH: "en",
-  ESPERANTO: "eo",
-  ESTONIAN: "et",
-  FINNISH: "fi",
-  FRENCH: "fr",
-  FRISIAN: "fy",
-  GEORGIAN: "ka",
-  GERMAN: "de",
-  GREEK: "el",
-  HEBREW: "he",
-  HINDI: "hi",
-  HUNGARIAN: "hu",
-  ICELANDIC: "is",
-  INDONESIAN: "id",
-  IRISH: "ga",
-  ITALIAN: "it",
-  JAPANESE: "ja",
-  JAPANESE_HIRAGANA: "ja-Hira",
-  JAPANESE_KANA: "ja_kana",
-  JAPANESE_LATIN: "ja_rm",
-  JAPANESE_2018: "ja-Latn",
-  KANNADA: "kn",
-  KAZAKH: "kk",
-  KOREAN: "ko",
-  KOREAN_LATIN: "ko-Latn",
-  KURDISH: "ku",
-  ROMAN_LATIN: "la",
-  LATVIAN: "lv",
-  LITHUANIAN: "lt",
-  LUXEMBOURGISH: "lb",
-  MACEDONIAN: "mk",
-  MALAYALAM: "ml",
-  MALTESE: "mt",
-  NORWEGIAN: "no",
-  OCCITAN: "oc",
-  POLISH: "pl",
-  PORTUGUESE: "pt",
-  ROMANIAN: "ro",
-  ROMANSH: "rm",
-  RUSSIAN: "ru",
-  SCOTTISH_GAELIC: "gd",
-  SERBIAN_CYRILLIC: "sr",
-  SERBIAN_LATIN: "sr-Latn",
-  SLOVAK: "sk",
-  SLOVENE: "sl",
-  SPANISH: "es",
-  SWEDISH: "sv",
-  TAMIL: "ta",
-  TELUGU: "te",
-  THAI: "th",
-  TURKISH: "tr",
-  UKRAINIAN: "uk",
-  WELSH: "cy",
+  LOCAL: "name",
+
+  /**
+   * International name
+   */
+  INTERNATIONAL: "name_int",
+
+  ALBANIAN: "name:sq",
+  AMHARIC: "name:am",
+  ARABIC: "name:ar",
+  ARMENIAN: "name:hy",
+  AZERBAIJANI: "name:az",
+  BASQUE: "name:eu",
+  BELORUSSIAN: "name:be",
+  BENGALI: "name:bn",
+  BOSNIAN: "name:bs",
+  BRETON: "name:br",
+  BULGARIAN: "name:bg",
+  CATALAN: "name:ca",
+  CHINESE: "name:zh",
+  TRADITIONAL_CHINESE: "name:zh-Hant",
+  SIMPLIFIED_CHINESE: "name:zh-Hans",
+  CORSICAN: "name:co",
+  CROATIAN: "name:hr",
+  CZECH: "name:cs",
+  DANISH: "name:da",
+  DUTCH: "name:nl",
+  ENGLISH: "name:en",
+  ESPERANTO: "name:eo",
+  ESTONIAN: "name:et",
+  FINNISH: "name:fi",
+  FRENCH: "name:fr",
+  FRISIAN: "name:fy",
+  GEORGIAN: "name:ka",
+  GERMAN: "name:de",
+  GREEK: "name:el",
+  HEBREW: "name:he",
+  HINDI: "name:hi",
+  HUNGARIAN: "name:hu",
+  ICELANDIC: "name:is",
+  INDONESIAN: "name:id",
+  IRISH: "name:ga",
+  ITALIAN: "name:it",
+  JAPANESE: "name:ja",
+  JAPANESE_HIRAGANA: "name:ja-Hira",
+  JAPANESE_KANA: "name:ja_kana",
+  JAPANESE_LATIN: "name:ja_rm",
+  JAPANESE_2018: "name:ja-Latn",
+  KANNADA: "name:kn",
+  KAZAKH: "name:kk",
+  KOREAN: "name:ko",
+  KOREAN_LATIN: "name:ko-Latn",
+  KURDISH: "name:ku",
+  ROMAN_LATIN: "name:la",
+  LATVIAN: "name:lv",
+  LITHUANIAN: "name:lt",
+  LUXEMBOURGISH: "name:lb",
+  MACEDONIAN: "name:mk",
+  MALAYALAM: "name:ml",
+  MALTESE: "name:mt",
+  NORWEGIAN: "name:no",
+  OCCITAN: "name:oc",
+  PERSIAN: "name:fa",
+  POLISH: "name:pl",
+  PORTUGUESE: "name:pt",
+  PUNJABI: "name:pa",
+  WESTERN_PUNJABI: "name:pnb",
+  ROMANIAN: "name:ro",
+  ROMANSH: "name:rm",
+  RUSSIAN: "name:ru",
+  SCOTTISH_GAELIC: "name:gd",
+  SERBIAN_CYRILLIC: "name:sr",
+  SERBIAN_LATIN: "name:sr-Latn",
+  SLOVAK: "name:sk",
+  SLOVENE: "name:sl",
+  SPANISH: "name:es",
+  SWEDISH: "name:sv",
+  TAMIL: "name:ta",
+  TELUGU: "name:te",
+  THAI: "name:th",
+  TURKISH: "name:tr",
+  UKRAINIAN: "name:uk",
+  URDU: "name:ur",
+  VIETNAMIAN_LATIN: "name:vi",
+  WELSH: "name:cy",
 } as const;
 
 const languagesIsoSet = new Set(Object.values(Language) as Array<string>);
@@ -123,18 +160,18 @@ type LanguageString = Values<typeof Language>;
 
 function getBrowserLanguage(): LanguageString {
   if (typeof navigator === "undefined") {
-    return Intl.DateTimeFormat()
-      .resolvedOptions()
-      .locale.split("-")[0] as LanguageString;
+    return `name:${
+      Intl.DateTimeFormat().resolvedOptions().locale.split("-")[0]
+    }` as LanguageString;
   }
 
   const canditatelangs = Array.from(
-    new Set(navigator.languages.map((l) => l.split("-")[0]))
+    new Set(navigator.languages.map((l) => `name:${l.split("-")[0]}`)),
   ).filter((l) => languageCodeSet.has(l as LanguageString));
 
   return canditatelangs.length
     ? (canditatelangs[0] as LanguageString)
-    : Language.LATIN;
+    : Language.LOCAL;
 }
 
 export {

package/src/mapstyle.ts

@@ -13,10 +13,12 @@ export function styleToStyle(
     | MapStyleVariant
     | maplibregl.StyleSpecification
     | null
-    | undefined
+    | undefined,
 ): string | maplibregl.StyleSpecification {
   if (!style) {
-    return MapStyle[mapStylePresetList[0].referenceStyleID]
+    return MapStyle[
+      mapStylePresetList[0].referenceStyleID as keyof typeof MapStyle
+    ]
       .getDefaultVariant()
       .getExpandedStyleURL();
   }

package/src/tools.ts

@@ -13,19 +13,20 @@ export function enableRTL() {
   if (maplibregl.getRTLTextPluginStatus() === "unavailable") {
     maplibregl.setRTLTextPlugin(
       defaults.rtlPluginURL,
-      null,
-      true // Lazy load the plugin
+      (err?: Error | undefined) => {
+        if (err) console.error(err);
+      },
+      true, // Lazy load the plugin
     );
   }
 }
 
 // This comes from:
 // https://github.com/maplibre/maplibre-gl-js/blob/v2.4.0/src/util/util.ts#L223
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function bindAll(fns: Array<string>, context: any): void {
   fns.forEach((fn) => {
-    if (!context[fn]) {
-      return;
-    }
+    if (typeof context[fn] !== "function") return;
     context[fn] = context[fn].bind(context);
   });
 }
@@ -35,7 +36,7 @@ export function bindAll(fns: Array<string>, context: any): void {
 export function DOMcreate<K extends keyof HTMLElementTagNameMap>(
   tagName: K,
   className?: string,
-  container?: HTMLElement
+  container?: HTMLElement,
 ): HTMLElementTagNameMap[K] {
   const el = window.document.createElement(tagName);
   if (className !== undefined) el.className = className;
@@ -55,13 +56,12 @@ export function DOMremove(node: HTMLElement) {
  * This function is meant to be used as transformRequest by any Map instance created.
  * It adds the session ID as well as the MapTiler Cloud key from the config to all the requests
  * performed on MapTiler Cloud servers.
- * @param url
- * @param resourceType
- * @returns
  */
 export function maptilerCloudTransformRequest(
   url: string,
-  resourceType?: ResourceType
+  // keep incase we need it in the future
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _resourceType?: ResourceType,
 ): RequestParameters {
   let reqUrl = null;
 
@@ -94,19 +94,17 @@ export function maptilerCloudTransformRequest(
 /**
  * This combines a user-defined tranformRequest function (optionnal)
  * with the MapTiler Cloud-specific one: maptilerCloudTransformRequest
- * @param userDefinedRTF
- * @returns
  */
 export function combineTransformRequest(
-  userDefinedRTF: RequestTransformFunction = null
+  userDefinedRTF?: RequestTransformFunction,
 ): RequestTransformFunction {
   return function (
     url: string,
-    resourceType?: ResourceType
+    resourceType?: ResourceType,
   ): RequestParameters {
-    if (userDefinedRTF) {
+    if (userDefinedRTF !== undefined) {
       const rp = userDefinedRTF(url, resourceType);
-      const rp2 = maptilerCloudTransformRequest(rp.url);
+      const rp2 = maptilerCloudTransformRequest(rp?.url ?? "");
 
       return {
         ...rp,
@@ -117,3 +115,57 @@ export function combineTransformRequest(
     }
   };
 }
+
+/**
+ * Generate a random string. Handy to create random IDs
+ */
+export function generateRandomString(): string {
+  return Math.random().toString(36).substring(2);
+}
+
+/**
+ * Check if a given string is in a uuid format
+ */
+export function isUUID(s: string): boolean {
+  // Regular expression to check if string is a valid UUID
+  const regexExp =
+    /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gi;
+  return regexExp.test(s);
+}
+
+/**
+ * Attempt a JSON parse of a string but does not throw if the string is not valid JSON, returns `null` instead.
+ */
+export function jsonParseNoThrow<T>(doc: string): T | null {
+  try {
+    return JSON.parse(doc);
+  } catch (e) {
+    // pass
+  }
+
+  return null;
+}
+
+/**
+ * Simple function to check if an object is a GeoJSON
+ */
+export function isValidGeoJSON<T>(obj: T & { type: string }): boolean {
+  if (typeof obj !== "object" || Array.isArray(obj) || obj === null)
+    return false;
+  if (!("type" in obj)) return false;
+
+  const validTypes = [
+    "Feature",
+    "FeatureCollection",
+    "Point",
+    "MultiPoint",
+    "LineString",
+    "MultiLineString",
+    "Polygon",
+    "MultiPolygon",
+    "GeometryCollection",
+  ];
+
+  if (validTypes.includes(obj.type)) return true;
+  return false;
+}

package/tsconfig.json

@@ -1,11 +1,14 @@
 {
   "compilerOptions": {
-    "moduleResolution": "Node",
+    "moduleResolution": "Bundler",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
     "target": "es6",
     "declaration": true,
     "allowSyntheticDefaultImports": true,
     "resolveJsonModule": true,
-    "esModuleInterop": true,
-  }
-  
-}
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "vite.config.ts"],
+  "exclude": ["node_modules", "dist", "demos", "scripts", "docs", "**/*.js", "**/*.cjs"]
+}

package/vite.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/**/*.test.ts"],
+    typecheck: {
+      tsconfig: "./tsconfig.json",
+    },
+  },
+});