@maptiler/sdk 4.2.0-rc.1 → 5.0.0-rc.1

package/dist/bundler/next-worker.mjs

@@ -0,0 +1,16 @@
+// Sets the MapLibre worker URL in a Next.js app, from a client component:
+//   "use client";
+//   import "@maptiler/sdk/next-worker";
+//
+// The URL is provided at build time by `withMaptilerWorker` (see "@maptiler/sdk/next"),
+// which copies the worker files into `public/` and exposes their URL.
+// Imported from the SDK (not "maplibre-gl") so it always sets the worker URL on the MapLibre instance the SDK uses
+import { setWorkerUrl } from "@maptiler/sdk";
+
+const workerUrl = process.env.NEXT_PUBLIC_MAPTILER_WORKER_URL;
+
+if (workerUrl) {
+  setWorkerUrl(workerUrl);
+} else {
+  console.warn('[@maptiler/sdk/next-worker] No worker URL found. Wrap your Next.js config with `withMaptilerWorker` from "@maptiler/sdk/next".');
+}

package/dist/bundler/next.cjs

@@ -0,0 +1,42 @@
+// CommonJS version of "@maptiler/sdk/next", for `next.config.js` files using `require`.
+// Keep in sync with next.mjs.
+const { copyFileSync, mkdirSync } = require("node:fs");
+const path = require("node:path");
+
+const WORKER_FILES = ["maplibre-gl-worker.mjs", "maplibre-gl-shared.mjs"];
+const PUBLIC_SUBDIR = "_maptiler";
+
+function copyWorkerFiles() {
+  // Resolved from the SDK's own dependencies, so the worker always matches the SDK's MapLibre
+  const maplibreDist = path.join(path.dirname(require.resolve("maplibre-gl/package.json")), "dist");
+  const destination = path.join(process.cwd(), "public", PUBLIC_SUBDIR);
+
+  mkdirSync(destination, { recursive: true });
+  for (const file of WORKER_FILES) {
+    copyFileSync(path.join(maplibreDist, file), path.join(destination, file));
+  }
+}
+
+function withWorkerEnv(config) {
+  const basePath = config.basePath ?? "";
+  return {
+    ...config,
+    env: {
+      ...config.env,
+      NEXT_PUBLIC_MAPTILER_WORKER_URL: `${basePath}/${PUBLIC_SUBDIR}/maplibre-gl-worker.mjs`,
+    },
+  };
+}
+
+function withMaptilerWorker(nextConfig = {}) {
+  copyWorkerFiles();
+
+  // Next.js also accepts a (possibly async) function returning the config
+  if (typeof nextConfig === "function") {
+    return async (...args) => withWorkerEnv(await nextConfig(...args));
+  }
+
+  return withWorkerEnv(nextConfig);
+}
+
+module.exports = { withMaptilerWorker };

package/dist/bundler/next.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Wraps a Next.js config so that the MapLibre worker files are copied into `public/_maptiler/`
+ * and their URL is exposed to `@maptiler/sdk/next-worker`.
+ * Accepts a config object or a (possibly async) function returning one, as Next.js does.
+ */
+export declare function withMaptilerWorker<TConfig extends object | ((...args: any[]) => any)>(nextConfig?: TConfig): TConfig;

package/dist/bundler/next.mjs

@@ -0,0 +1,48 @@
+// Next.js config wrapper that serves the MapLibre worker files from `public/`:
+//   // next.config.mjs
+//   import { withMaptilerWorker } from "@maptiler/sdk/next";
+//   export default withMaptilerWorker(nextConfig);
+//
+// Next.js (Turbopack and webpack modes) does not emit `maplibre-gl-shared.mjs` next to the worker,
+// so both files are copied into `public/` when the config is loaded (on every `next dev` and `next build`).
+// Pair it with `import "@maptiler/sdk/next-worker"` in the component creating the map.
+import { copyFileSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const WORKER_FILES = ["maplibre-gl-worker.mjs", "maplibre-gl-shared.mjs"];
+const PUBLIC_SUBDIR = "_maptiler";
+
+function copyWorkerFiles() {
+  // Resolved from the SDK's own dependencies, so the worker always matches the SDK's MapLibre
+  const require = createRequire(import.meta.url);
+  const maplibreDist = path.join(path.dirname(require.resolve("maplibre-gl/package.json")), "dist");
+  const destination = path.join(process.cwd(), "public", PUBLIC_SUBDIR);
+
+  mkdirSync(destination, { recursive: true });
+  for (const file of WORKER_FILES) {
+    copyFileSync(path.join(maplibreDist, file), path.join(destination, file));
+  }
+}
+
+function withWorkerEnv(config) {
+  const basePath = config.basePath ?? "";
+  return {
+    ...config,
+    env: {
+      ...config.env,
+      NEXT_PUBLIC_MAPTILER_WORKER_URL: `${basePath}/${PUBLIC_SUBDIR}/maplibre-gl-worker.mjs`,
+    },
+  };
+}
+
+export function withMaptilerWorker(nextConfig = {}) {
+  copyWorkerFiles();
+
+  // Next.js also accepts a (possibly async) function returning the config
+  if (typeof nextConfig === "function") {
+    return async (...args) => withWorkerEnv(await nextConfig(...args));
+  }
+
+  return withWorkerEnv(nextConfig);
+}

package/dist/bundler/side-effect.d.ts

@@ -0,0 +1,2 @@
+// Types for the side-effect-only entries (vite-worker, webpack-worker, next-worker): they export nothing.
+export {};

package/dist/bundler/vite-worker.mjs

@@ -0,0 +1,11 @@
+// Sets the MapLibre worker URL for Vite projects:
+//   import "@maptiler/sdk/vite-worker";
+//
+// This file is shipped as is (not bundled by the SDK build) so that the `?worker&url` import
+// is resolved by the consumer's Vite, which bundles the worker and its shared chunk into one file.
+// `maplibre-gl` is resolved from the SDK's own dependencies, so the worker always matches the SDK's MapLibre.
+// Imported from the SDK (not "maplibre-gl") so it always sets the worker URL on the MapLibre instance the SDK uses
+import { setWorkerUrl } from "@maptiler/sdk";
+import workerUrl from "maplibre-gl/dist/maplibre-gl-worker.mjs?worker&url";
+
+setWorkerUrl(workerUrl);

package/dist/bundler/webpack-worker.mjs

@@ -0,0 +1,11 @@
+// Sets the MapLibre worker URL for webpack 5 / rspack projects:
+//   import "@maptiler/sdk/webpack-worker";
+//
+// This file is shipped as is (not bundled by the SDK build) so that `new URL(..., import.meta.url)`
+// is resolved by the consumer's webpack, which emits the worker file and replaces the expression with its URL.
+// webpack emits only the file named here, so it points to the self-contained worker built by the SDK
+// (MapLibre's worker + its shared chunk), not to MapLibre's own worker, which imports a sibling file.
+// Imported from the SDK (not "maplibre-gl") so it always sets the worker URL on the MapLibre instance the SDK uses
+import { setWorkerUrl } from "@maptiler/sdk";
+
+setWorkerUrl(new URL("./maplibre-gl-worker.mjs", import.meta.url).toString());

package/dist/config.d.ts

@@ -80,6 +80,24 @@ declare class SdkConfig extends EventEmitter {
      * Get the fetch fucntion
      */
     get fetch(): FetchFunction | null;
+    /**
+     * Switch between the default `api.maptiler.com` host and the EU-based `api.maptiler.eu` host.
+     * Set to `false` to switch back to the default.
+     */
+    set useEuEndpoints(value: boolean);
+    /**
+     * Whether the EU-based `api.maptiler.eu` host is currently in use instead of the default `api.maptiler.com`
+     */
+    get useEuEndpoints(): boolean;
+    /**
+     * The host currently used for the MapTiler API requests (`api.maptiler.com` or `api.maptiler.eu`)
+     */
+    get apiHost(): string;
+    /**
+     * The base URL currently used for the MapTiler API requests
+     * (`https://api.maptiler.com/` or `https://api.maptiler.eu/`)
+     */
+    get apiURL(): string;
     /**
      * The default number of steps to sample for the experimental flyTo path preloading.
      */

package/dist/constants/defaults.d.ts

@@ -2,14 +2,9 @@
  * Some default settings for the SDK
  */
 declare const defaults: {
-    maptilerLogoURL: string;
     maptilerURL: string;
-    maptilerApiHost: string;
-    telemetryURL: string;
-    rtlPluginURL: string;
     primaryLanguage: import('@maptiler/client').LanguageInfo;
     secondaryLanguage: import('@maptiler/client').LanguageInfo;
-    terrainSourceURL: string;
     terrainSourceId: string;
 };
 export { defaults };

package/dist/controls/MaptilerGeolocateControl.d.ts

@@ -1,4 +1,4 @@
-import { GeolocateControl } from '../MLAdapters/GeolocateControl';
+import { GeolocateControl } from 'maplibre-gl';
 /**
  * The MaptilerGeolocateControl is an extension of the original GeolocateControl
  * with a few changes. In this version, the active mode persists as long as the

package/dist/controls/MaptilerLogoControl.d.ts

@@ -1,5 +1,4 @@
-import { LogoControlOptions as LogoControlOptionsML } from 'maplibre-gl';
-import { LogoControl } from '../MLAdapters/LogoControl';
+import { LogoControl, LogoControlOptions as LogoControlOptionsML } from 'maplibre-gl';
 import { Map as SDKMap } from '../Map';
 type LogoControlOptions = LogoControlOptionsML & {
     logoURL?: string;

package/dist/controls/MaptilerNavigationControl.d.ts

@@ -1,14 +1,13 @@
-import { NavigationControlOptions } from 'maplibre-gl';
-import { NavigationControl } from '../MLAdapters/NavigationControl';
+import { NavigationControl, NavigationControlOptions } from 'maplibre-gl';
 type HTMLButtonElementPlus = HTMLButtonElement & {
-    clickFunction: (e?: Event) => unknown;
+    clickFunction: (e?: MouseEvent) => unknown;
 };
 export declare class MaptilerNavigationControl extends NavigationControl {
     constructor(options?: NavigationControlOptions);
     /**
      * Overloading: the button now stores its click callback so that we can later on delete it and replace it
      */
-    _createButton(className: string, fn: (e?: Event) => unknown): HTMLButtonElementPlus;
+    _createButton(className: string, fn: (e?: MouseEvent) => unknown): HTMLButtonElementPlus;
     /**
      * Overloading: Limit how flat the compass icon can get
      */

package/dist/controls/Minimap.d.ts

@@ -1,5 +1,5 @@
 import { Map as SDKMap, MapOptions } from '../Map';
-import { ControlPosition, CustomLayerInterface, FillLayerSpecification, FilterSpecification, IControl, LayerSpecification, LineLayerSpecification, SourceSpecification, StyleOptions, StyleSetterOptions, StyleSpecification, StyleSwapOptions } from 'maplibre-gl';
+import { ControlPosition, CustomLayerInterface, FillLayerSpecification, FilterSpecification, IControl, LayerSpecification, LineLayerSpecification, SourceSpecification, StyleOptions, StyleSetterOptions, AllPaintProperties, AllLayoutProperties, StyleSpecification, StyleSwapOptions } from 'maplibre-gl';
 import { MapStyleVariant, ReferenceMapStyle } from '@maptiler/client';
 export interface ParentRect {
     lineLayout: LineLayerSpecification["layout"];
@@ -49,8 +49,8 @@ export default class Minimap implements IControl {
     removeLayer(id: string): this;
     setLayerZoomRange(layerId: string, minzoom: number, maxzoom: number): this;
     setFilter(layerId: string, filter?: FilterSpecification | null, options?: StyleSetterOptions): this;
-    setPaintProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
-    setLayoutProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
+    setPaintProperty<K extends keyof AllPaintProperties>(layerId: string, name: K, value: AllPaintProperties[K], options?: StyleSetterOptions): this;
+    setLayoutProperty<K extends keyof AllLayoutProperties>(layerId: string, name: K, value: AllLayoutProperties[K], options?: StyleSetterOptions): this;
     setGlyphs(glyphsUrl: string | null, options?: StyleSetterOptions): this;
     onAdd(parentMap: SDKMap): HTMLElement;
     onRemove(): void;

package/dist/eslint.mjs

@@ -15,7 +15,7 @@ export default tseslint.config(
       compat: eslintPluginCompat,
       import: {
         rules: {
-          "default-imports-only": {
+          "no-default-imports": {
             meta: {
               type: "suggestion",
               docs: {},
@@ -50,7 +50,7 @@ export default tseslint.config(
 
                         if (bannedLocationRegex.test(filePath)) {
                           node.specifiers.forEach((specifier) => {
-                            if (specifier.type !== "ImportDefaultSpecifier") {
+                            if (specifier.type === "ImportDefaultSpecifier") {
                               context.report({
                                 // @ts-expect-error `message` seems to work with this...
                                 message: config.message ?? `Importing from '${bannedImport}' is banned in '${fp}'`,
@@ -75,12 +75,12 @@ export default tseslint.config(
     },
     rules: {
       "compat/compat": "error",
-      "import/default-imports-only": [
+      "import/no-default-imports": [
         "error",
         {
           "maplibre-gl$": {
             locations: ["^(?!.*\.d\.ts$).*\.((ts|js))$"],
-            message: `Maplibre-gl uses CJS modules, only default imports are supported, named imports may fail on some setups.`,
+            message: `Maplibre-gl v6+ is ESM-only and has no default export, use \`import * as maplibregl from "maplibre-gl"\` or named imports.`,
             ignoreTypeImports: true,
           },
         },

package/dist/index.d.ts

@@ -1,96 +1,20 @@
-import { default as maplibregl } from 'maplibre-gl';
 export type * from 'maplibre-gl';
 /**
  * Get the version of MapTiler SDK, this is declared in the vite config
  * to avoid importing the entire package.json
  */
 export declare function getVersion(): string;
-declare const MapMLGL: typeof maplibregl.Map;
-declare const MarkerMLGL: typeof maplibregl.Marker;
-declare const PopupMLGL: typeof maplibregl.Popup;
-declare const StyleMLGL: typeof maplibregl.Style;
-declare const CanvasSourceMLGL: typeof maplibregl.CanvasSource;
-declare const GeoJSONSourceMLGL: typeof maplibregl.GeoJSONSource;
-declare const ImageSourceMLGL: typeof maplibregl.ImageSource;
-declare const RasterTileSourceMLGL: typeof maplibregl.RasterTileSource;
-declare const RasterDEMTileSourceMLGL: typeof maplibregl.RasterDEMTileSource;
-declare const VectorTileSourceMLGL: typeof maplibregl.VectorTileSource;
-declare const VideoSourceMLGL: typeof maplibregl.VideoSource;
-declare const NavigationControMLGL: typeof maplibregl.NavigationControl;
-declare const GeolocateControlMLGL: typeof maplibregl.GeolocateControl;
-declare const AttributionControlMLGL: typeof maplibregl.AttributionControl;
-declare const LogoControlMLGL: typeof maplibregl.LogoControl;
-declare const ScaleControlMLGL: typeof maplibregl.ScaleControl;
-declare const FullscreenControlMLGL: typeof maplibregl.FullscreenControl;
-declare const TerrainControMLGL: typeof maplibregl.TerrainControl;
-declare const BoxZoomHandlerMLGL: typeof maplibregl.BoxZoomHandler;
-declare const ScrollZoomHandlerMLGL: typeof maplibregl.ScrollZoomHandler;
-declare const CooperativeGesturesHandlerMLGL: typeof maplibregl.CooperativeGesturesHandler;
-declare const KeyboardHandlerMLGL: typeof maplibregl.KeyboardHandler;
-declare const TwoFingersTouchPitchHandlerMLGL: typeof maplibregl.TwoFingersTouchPitchHandler;
-declare const MapWheelEventMLGL: typeof maplibregl.MapWheelEvent;
-declare const MapTouchEventMLGL: typeof maplibregl.MapTouchEvent;
-declare const MapMouseEventMLGL: typeof maplibregl.MapMouseEvent;
-declare const configMLGL: {
-    MAX_PARALLEL_IMAGE_REQUESTS: number;
-    MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME: number;
-    MAX_TILE_CACHE_ZOOM_LEVELS: number;
-    REGISTERED_PROTOCOLS: {
-        [x: string]: maplibregl.AddProtocolAction;
-    };
-    WORKER_URL: string;
-};
-declare const getMapLibreVersion: typeof maplibregl.getVersion;
-declare const setRTLTextPlugin: typeof maplibregl.setRTLTextPlugin, getRTLTextPluginStatus: typeof maplibregl.getRTLTextPluginStatus, LngLat: typeof maplibregl.LngLat, LngLatBounds: typeof maplibregl.LngLatBounds, MercatorCoordinate: typeof maplibregl.MercatorCoordinate, Evented: typeof maplibregl.Evented, AJAXError: typeof maplibregl.AJAXError, prewarm: typeof maplibregl.prewarm, clearPrewarmedResources: typeof maplibregl.clearPrewarmedResources, Hash: typeof maplibregl.Hash, Point: typeof maplibregl.Point, EdgeInsets: typeof maplibregl.EdgeInsets, DragRotateHandler: typeof maplibregl.DragRotateHandler, DragPanHandler: typeof maplibregl.DragPanHandler, TwoFingersTouchZoomRotateHandler: typeof maplibregl.TwoFingersTouchZoomRotateHandler, DoubleClickZoomHandler: typeof maplibregl.DoubleClickZoomHandler, TwoFingersTouchZoomHandler: typeof maplibregl.TwoFingersTouchZoomHandler, TwoFingersTouchRotateHandler: typeof maplibregl.TwoFingersTouchRotateHandler, getWorkerCount: typeof maplibregl.getWorkerCount, setWorkerCount: typeof maplibregl.setWorkerCount, getMaxParallelImageRequests: typeof maplibregl.getMaxParallelImageRequests, setMaxParallelImageRequests: typeof maplibregl.setMaxParallelImageRequests, getWorkerUrl: typeof maplibregl.getWorkerUrl, setWorkerUrl: typeof maplibregl.setWorkerUrl, addSourceType: (name: string, SourceType: maplibregl.SourceClass) => Promise<void>, importScriptInWorkers: typeof maplibregl.importScriptInWorkers, addProtocol: typeof maplibregl.addProtocol, removeProtocol: typeof maplibregl.removeProtocol;
-export { setRTLTextPlugin, getRTLTextPluginStatus, LngLat, LngLatBounds, MercatorCoordinate, Evented, AJAXError, prewarm, clearPrewarmedResources, Hash, Point, EdgeInsets, DragRotateHandler, DragPanHandler, TwoFingersTouchZoomRotateHandler, DoubleClickZoomHandler, TwoFingersTouchZoomHandler, TwoFingersTouchRotateHandler, getWorkerCount, setWorkerCount, getMaxParallelImageRequests, setMaxParallelImageRequests, getWorkerUrl, setWorkerUrl, addSourceType, importScriptInWorkers, addProtocol, removeProtocol, getMapLibreVersion, MapMLGL, MarkerMLGL, PopupMLGL, StyleMLGL, CanvasSourceMLGL, GeoJSONSourceMLGL, ImageSourceMLGL, RasterTileSourceMLGL, RasterDEMTileSourceMLGL, VectorTileSourceMLGL, VideoSourceMLGL, NavigationControMLGL, GeolocateControlMLGL, AttributionControlMLGL, LogoControlMLGL, ScaleControlMLGL, FullscreenControlMLGL, TerrainControMLGL, BoxZoomHandlerMLGL, ScrollZoomHandlerMLGL, CooperativeGesturesHandlerMLGL, KeyboardHandlerMLGL, TwoFingersTouchPitchHandlerMLGL, MapWheelEventMLGL, MapTouchEventMLGL, MapMouseEventMLGL, configMLGL, };
-export type LngLat = InstanceType<typeof LngLat>;
-export type LngLatBounds = InstanceType<typeof LngLatBounds>;
-export type MercatorCoordinate = InstanceType<typeof MercatorCoordinate>;
-export type Evented = InstanceType<typeof Evented>;
-export type AJAXError = InstanceType<typeof AJAXError>;
-export type Hash = InstanceType<typeof Hash>;
-export type Point = InstanceType<typeof Point>;
-export type EdgeInsets = InstanceType<typeof EdgeInsets>;
-export type DragRotateHandler = InstanceType<typeof DragRotateHandler>;
-export type DragPanHandler = InstanceType<typeof DragPanHandler>;
-export type TwoFingersTouchZoomRotateHandler = InstanceType<typeof TwoFingersTouchZoomRotateHandler>;
-export type DoubleClickZoomHandler = InstanceType<typeof DoubleClickZoomHandler>;
-export type TwoFingersTouchZoomHandler = InstanceType<typeof TwoFingersTouchZoomHandler>;
-export type TwoFingersTouchRotateHandler = InstanceType<typeof TwoFingersTouchRotateHandler>;
-export { Marker } from './MLAdapters/Marker';
-export { Popup } from './MLAdapters/Popup';
-export { Style } from './MLAdapters/Style';
-export { CanvasSource } from './MLAdapters/CanvasSource';
-export { GeoJSONSource } from './MLAdapters/GeoJSONSource';
-export { ImageSource } from './MLAdapters/ImageSource';
-export { RasterTileSource } from './MLAdapters/RasterTileSource';
-export { RasterDEMTileSource } from './MLAdapters/RasterDEMTileSource';
-export { VectorTileSource } from './MLAdapters/VectorTileSource';
-export { VideoSource } from './MLAdapters/VideoSource';
-export { NavigationControl } from './MLAdapters/NavigationControl';
-export { GeolocateControl } from './MLAdapters/GeolocateControl';
-export { AttributionControl } from './MLAdapters/AttributionControl';
-export { LogoControl } from './MLAdapters/LogoControl';
-export { ScaleControl } from './MLAdapters/ScaleControl';
-export { FullscreenControl } from './MLAdapters/FullscreenControl';
-export { TerrainControl } from './MLAdapters/TerrainControl';
-export { BoxZoomHandler } from './MLAdapters/BoxZoomHandler';
-export { ScrollZoomHandler } from './MLAdapters/ScrollZoomHandler';
-export { CooperativeGesturesHandler } from './MLAdapters/CooperativeGesturesHandler';
-export { KeyboardHandler } from './MLAdapters/KeyboardHandler';
-export { TwoFingersTouchPitchHandler } from './MLAdapters/TwoFingersTouchPitchHandler';
-export { MapWheelEvent } from './MLAdapters/MapWheelEvent';
-export { MapTouchEvent } from './MLAdapters/MapTouchEvent';
-export { MapMouseEvent } from './MLAdapters/MapMouseEvent';
-export * from './ml-types';
-export { Map, GeolocationType, type AttributionControlOptions, type MapOptions, type LoadWithTerrainEvent } from './Map';
+export { setRTLTextPlugin, getRTLTextPluginStatus, LngLat, LngLatBounds, MercatorCoordinate, Evented, AJAXError, clearPrewarmedResources, Hash, Point, EdgeInsets, DragRotateHandler, DragPanHandler, TwoFingersTouchZoomRotateHandler, DoubleClickZoomHandler, TwoFingersTouchZoomHandler, TwoFingersTouchRotateHandler, getWorkerCount, setWorkerCount, getMaxParallelImageRequests, setMaxParallelImageRequests, getWorkerUrl, setWorkerUrl, addSourceType, importScriptInWorkers, addProtocol, removeProtocol, } from 'maplibre-gl';
+export { getVersion as getMapLibreVersion, Map as MapMLGL, Marker as MarkerMLGL, Popup as PopupMLGL, Style as StyleMLGL, CanvasSource as CanvasSourceMLGL, GeoJSONSource as GeoJSONSourceMLGL, ImageSource as ImageSourceMLGL, RasterTileSource as RasterTileSourceMLGL, RasterDEMTileSource as RasterDEMTileSourceMLGL, VectorTileSource as VectorTileSourceMLGL, VideoSource as VideoSourceMLGL, NavigationControl as NavigationControMLGL, GeolocateControl as GeolocateControlMLGL, AttributionControl as AttributionControlMLGL, LogoControl as LogoControlMLGL, ScaleControl as ScaleControlMLGL, FullscreenControl as FullscreenControlMLGL, TerrainControl as TerrainControMLGL, BoxZoomHandler as BoxZoomHandlerMLGL, ScrollZoomHandler as ScrollZoomHandlerMLGL, CooperativeGesturesHandler as CooperativeGesturesHandlerMLGL, KeyboardHandler as KeyboardHandlerMLGL, TwoFingersTouchPitchHandler as TwoFingersTouchPitchHandlerMLGL, MapWheelEvent as MapWheelEventMLGL, MapTouchEvent as MapTouchEventMLGL, MapMouseEvent as MapMouseEventMLGL, config as configMLGL, } from 'maplibre-gl';
+export { Marker, Popup, Style, CanvasSource, GeoJSONSource, ImageSource, RasterTileSource, RasterDEMTileSource, VectorTileSource, VideoSource, NavigationControl, GeolocateControl, AttributionControl, LogoControl, ScaleControl, FullscreenControl, TerrainControl, BoxZoomHandler, ScrollZoomHandler, CooperativeGesturesHandler, KeyboardHandler, TwoFingersTouchPitchHandler, MapWheelEvent, MapTouchEvent, MapMouseEvent, } from 'maplibre-gl';
+export { Map, GeolocationType, type AttributionControlOptions, type MapOptions, type LoadWithTerrainEvent, type MaptilerMapEventType, type MapEventTypeSDK } from './Map';
 export type { CameraPosition, TilePreloadOptions, WithTilePreload, PreloadTilesForBoundsOptions, PreloadTilesForCameraPositionsOptions, PreloadTilesOptions, TilePreloadErrorCallback, TilePreloadProgressCallback, } from './tile-preloading';
 export { type BaseGeocodingOptions, type ByIdGeocodingOptions, type CommonForwardAndReverseGeocodingOptions, type GeocodingOptions, type LanguageGeocodingOptions, type ReverseGeocodingOptions, geocoding, } from './geocoding';
-export { type ExtraRoutingOptions, type RoutingOptions, routing } from './routing';
 export * from './controls';
-export { type AutomaticStaticMapOptions, type BoundedStaticMapOptions, type BufferToPixelDataFunction, type CenteredStaticMapOptions, 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 GeocodingSearchResult, type GeolocationInfoOptions, type GeolocationResult, type GetDataOptions, MapStyle, type MapStylePreset, type MapStyleType, MapStyleVariant, type PixelData, ReferenceMapStyle, type RoutingAvoidances, type RoutingBicycleOptions, type RoutingCarOptions, type RoutingDistanceUnit, type RoutingInstructionsLanguage, type RoutingLocation, type RoutingPedestrianOptions, type RoutingProfile, type RoutingProfileOptions, type RoutingRequest, type RoutingResponse, type RoutingRoute, type RoutingRouteLeg, type RoutingRouteManeuver, type RoutingRouteStep, type RoutingSummary, type RoutingTruckOptions, ServiceError, type StaticMapBaseOptions, type StaticMapMarker, type TileJSON, type XYZ, bufferToPixelDataBrowser, circumferenceAtLatitude, coordinates, data, elevation, expandMapStyle, geolocation, getBufferToPixelDataParser, getTileCache, mapStylePresetList, math, misc, staticMaps, styleToStyle, type LanguageInfo, areSameLanguages, toLanguageInfo, isLanguageInfo, getAutoLanguage, getLanguageInfoFromFlag, getLanguageInfoFromCode, getLanguageInfoFromKey, canParsePixelData, } from '@maptiler/client';
+export { type AutomaticStaticMapOptions, type BoundedStaticMapOptions, type BufferToPixelDataFunction, type CenteredStaticMapOptions, 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 GeocodingSearchResult, type GeolocationInfoOptions, type GeolocationResult, type GetDataOptions, MapStyle, type MapStylePreset, type MapStyleType, MapStyleVariant, type PixelData, ReferenceMapStyle, ServiceError, type StaticMapBaseOptions, type StaticMapMarker, type TileJSON, type XYZ, bufferToPixelDataBrowser, circumferenceAtLatitude, coordinates, data, elevation, expandMapStyle, geolocation, getBufferToPixelDataParser, getTileCache, mapStylePresetList, math, misc, staticMaps, styleToStyle, type LanguageInfo, areSameLanguages, toLanguageInfo, isLanguageInfo, getAutoLanguage, getLanguageInfoFromFlag, getLanguageInfoFromCode, getLanguageInfoFromKey, canParsePixelData, } from '@maptiler/client';
 export * from './ImageViewer';
 export { getWebGLSupportError, displayWebGLContextLostWarning } from './tools';
+export { prewarm } from './utils/defaultWorkerUrl';
 export { config, SdkConfig } from './config';
 export * from './language';
 export type { Unit } from './types';

package/dist/mapstyle.d.ts

@@ -1,6 +1,7 @@
+import { StyleSpecification } from 'maplibre-gl';
 import { ReferenceMapStyle, MapStyleVariant } from '@maptiler/client';
-export declare function styleToStyle(style: string | ReferenceMapStyle | MapStyleVariant | maplibregl.StyleSpecification | null | undefined): {
-    style: string | maplibregl.StyleSpecification;
+export declare function styleToStyle(style: string | ReferenceMapStyle | MapStyleVariant | StyleSpecification | null | undefined): {
+    style: string | StyleSpecification;
     requiresUrlMonitoring: boolean;
     isFallback: boolean;
     isJSON?: boolean;
@@ -12,7 +13,7 @@ export declare function urlToAbsoluteUrl(url: string): string;
 type StyleValidationReport = {
     isValidJSON: boolean;
     isValidStyle: boolean;
-    styleObject: maplibregl.StyleSpecification | null;
+    styleObject: StyleSpecification | null;
 };
 export declare function convertStringToStyleSpecification(str: string): StyleValidationReport;
 export {};