@maptiler/sdk 2.2.1 → 2.3.0

package/dist/src/index.d.ts

@@ -0,0 +1,89 @@
+import { default as maplibregl } from 'maplibre-gl';
+
+export type * from 'maplibre-gl';
+/**
+ * Get the version of MapTiler SDK
+ */
+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: maplibregl.Config;
+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 { Map, GeolocationType, type MapOptions, type LoadWithTerrainEvent, } from './Map';
+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, type LanguageGeocodingOptions, MapStyle, type MapStylePreset, type MapStyleType, MapStyleVariant, type PixelData, ReferenceMapStyle, type ReverseGeocodingOptions, ServiceError, type StaticMapBaseOptions, type StaticMapMarker, type TileJSON, type XYZ, bufferToPixelDataBrowser, circumferenceAtLatitude, coordinates, data, elevation, expandMapStyle, geocoding, geolocation, getBufferToPixelDataParser, getTileCache, mapStylePresetList, math, misc, staticMaps, styleToStyle, type LanguageInfo, areSameLanguages, toLanguageInfo, isLanguageInfo, getAutoLanguage, getLanguageInfoFromFlag, getLanguageInfoFromCode, getLanguageInfoFromKey, } from '@maptiler/client';
+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/dist/src/language.d.ts

@@ -0,0 +1,108 @@
+import { LanguageInfo } from '@maptiler/client';
+
+declare const Language: {
+    readonly AUTO: LanguageInfo;
+    readonly LATIN: LanguageInfo;
+    readonly NON_LATIN: LanguageInfo;
+    readonly LOCAL: LanguageInfo;
+    readonly AMHARIC: LanguageInfo;
+    readonly ARABIC: LanguageInfo;
+    readonly AZERBAIJANI: LanguageInfo;
+    readonly BELARUSIAN: LanguageInfo;
+    readonly BULGARIAN: LanguageInfo;
+    readonly BENGALI: LanguageInfo;
+    readonly BRETON: LanguageInfo;
+    readonly BOSNIAN: LanguageInfo;
+    readonly CATALAN: LanguageInfo;
+    readonly CHINESE: LanguageInfo;
+    readonly TRADITIONAL_CHINESE: LanguageInfo;
+    readonly SIMPLIFIED_CHINESE: LanguageInfo;
+    readonly CORSICAN: LanguageInfo;
+    readonly CZECH: LanguageInfo;
+    readonly WELSH: LanguageInfo;
+    readonly DANISH: LanguageInfo;
+    readonly GERMAN: LanguageInfo;
+    readonly GREEK: LanguageInfo;
+    readonly ENGLISH: LanguageInfo;
+    readonly ESPERANTO: LanguageInfo;
+    readonly SPANISH: LanguageInfo;
+    readonly ESTONIAN: LanguageInfo;
+    readonly BASQUE: LanguageInfo;
+    readonly FINNISH: LanguageInfo;
+    readonly FRENCH: LanguageInfo;
+    readonly FRISIAN: LanguageInfo;
+    readonly IRISH: LanguageInfo;
+    readonly SCOTTISH_GAELIC: LanguageInfo;
+    readonly HEBREW: LanguageInfo;
+    readonly HINDI: LanguageInfo;
+    readonly CROATIAN: LanguageInfo;
+    readonly HUNGARIAN: LanguageInfo;
+    readonly ARMENIAN: LanguageInfo;
+    readonly INDONESIAN: LanguageInfo;
+    readonly ICELANDIC: LanguageInfo;
+    readonly ITALIAN: LanguageInfo;
+    readonly JAPANESE: LanguageInfo;
+    readonly JAPANESE_HIRAGANA: LanguageInfo;
+    readonly JAPANESE_2018: LanguageInfo;
+    readonly JAPANESE_KANA: LanguageInfo;
+    readonly JAPANESE_LATIN: LanguageInfo;
+    readonly GEORGIAN: LanguageInfo;
+    readonly KAZAKH: LanguageInfo;
+    readonly KANNADA: LanguageInfo;
+    readonly KOREAN: LanguageInfo;
+    readonly KOREAN_LATIN: LanguageInfo;
+    readonly KURDISH: LanguageInfo;
+    readonly CLASSICAL_LATIN: LanguageInfo;
+    readonly LUXEMBOURGISH: LanguageInfo;
+    readonly LITHUANIAN: LanguageInfo;
+    readonly LATVIAN: LanguageInfo;
+    readonly MACEDONIAN: LanguageInfo;
+    readonly MALAYALAM: LanguageInfo;
+    readonly MALTESE: LanguageInfo;
+    readonly DUTCH: LanguageInfo;
+    readonly NORWEGIAN: LanguageInfo;
+    readonly OCCITAN: LanguageInfo;
+    readonly POLISH: LanguageInfo;
+    readonly PERSIAN: LanguageInfo;
+    readonly PUNJABI: LanguageInfo;
+    readonly WESTERN_PUNJABI: LanguageInfo;
+    readonly PORTUGUESE: LanguageInfo;
+    readonly ROMANSH: LanguageInfo;
+    readonly ROMANIAN: LanguageInfo;
+    readonly RUSSIAN: LanguageInfo;
+    readonly SLOVAK: LanguageInfo;
+    readonly SLOVENE: LanguageInfo;
+    readonly ALBANIAN: LanguageInfo;
+    readonly SERBIAN_CYRILLIC: LanguageInfo;
+    readonly SERBIAN_LATIN: LanguageInfo;
+    readonly SWEDISH: LanguageInfo;
+    readonly TAMIL: LanguageInfo;
+    readonly TELUGU: LanguageInfo;
+    readonly THAI: LanguageInfo;
+    readonly TURKISH: LanguageInfo;
+    readonly UKRAINIAN: LanguageInfo;
+    readonly VIETNAMESE: LanguageInfo;
+    /**
+     * Language mode to display labels in both the local language and the language of the visitor's device, concatenated.
+     * Note that if those two languages are the same, labels won't be duplicated.
+     */
+    readonly VISITOR: LanguageInfo;
+    /**
+     * Language mode to display labels in both the local language and English, concatenated.
+     * Note that if those two languages are the same, labels won't be duplicated.
+     */
+    readonly VISITOR_ENGLISH: LanguageInfo;
+    /**
+     * Language mode to display labels in a language enforced in the style.
+     */
+    readonly STYLE: LanguageInfo;
+    /**
+     * Language mode to display labels in a language enforced in the style. The language cannot be further modified.
+     */
+    readonly STYLE_LOCK: LanguageInfo;
+};
+/**
+ * Get the browser language
+ */
+export declare function getBrowserLanguage(): LanguageInfo;
+export { Language, type LanguageInfo };

package/dist/src/mapstyle.d.ts

@@ -0,0 +1,3 @@
+import { ReferenceMapStyle, MapStyleVariant } from '@maptiler/client';
+
+export declare function styleToStyle(style: string | ReferenceMapStyle | MapStyleVariant | maplibregl.StyleSpecification | null | undefined): string | maplibregl.StyleSpecification;

package/dist/src/tools.d.ts

@@ -0,0 +1,46 @@
+import { RequestParameters, ResourceType, RequestTransformFunction } from 'maplibre-gl';
+
+export declare function enableRTL(): void;
+export declare function bindAll(fns: Array<string>, context: any): void;
+export declare function DOMcreate<K extends keyof HTMLElementTagNameMap>(tagName: K, className?: string, container?: HTMLElement): HTMLElementTagNameMap[K];
+export declare function DOMremove(node: HTMLElement): void;
+/**
+ * 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.
+ */
+export declare function maptilerCloudTransformRequest(url: string, resourceType?: ResourceType): RequestParameters;
+/**
+ * This combines a user-defined tranformRequest function (optionnal)
+ * with the MapTiler Cloud-specific one: maptilerCloudTransformRequest
+ */
+export declare function combineTransformRequest(userDefinedRTF?: RequestTransformFunction | null): RequestTransformFunction;
+/**
+ * Generate a random string. Handy to create random IDs
+ */
+export declare function generateRandomString(): string;
+/**
+ * Check if a given string is in a uuid format
+ */
+export declare function isUUID(s: string): boolean;
+/**
+ * Attempt a JSON parse of a string but does not throw if the string is not valid JSON, returns `null` instead.
+ */
+export declare function jsonParseNoThrow<T>(doc: string): T | null;
+/**
+ * Simple function to check if an object is a GeoJSON
+ */
+export declare function isValidGeoJSON<T>(obj: T & {
+    type: string;
+}): boolean;
+/**
+ * This function tests if WebGL2 is supported. Since it can be for a different reasons that WebGL2 is
+ * not supported but we do not have an action to take based on the reason, this function return null
+ * if there is no error (WebGL is supported), or returns a string with the error message if WebGL2 is
+ * not supported.
+ */
+export declare function getWebGLSupportError(): string | null;
+/**
+ * Display an error message in the Map div if WebGL2 is not supported
+ */
+export declare function displayNoWebGlWarning(container: HTMLElement | string): void;

package/dist/src/unit.d.ts

@@ -0,0 +1 @@
+export type Unit = "imperial" | "metric" | "nautical";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maptiler/sdk",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "The Javascript & TypeScript map SDK tailored for MapTiler Cloud",
   "module": "dist/maptiler-sdk.mjs",
   "types": "dist/maptiler-sdk.d.ts",
@@ -34,43 +34,37 @@
     "url": "https://github.com/maptiler/maptiler-sdk-js.git"
   },
   "scripts": {
-    "build": "rm -rf dist/* && NODE_ENV=production rollup -c",
-    "dev": "rm -rf dist/* && NODE_ENV=development rollup -c -w",
     "biome": "biome check --max-diagnostics=1000",
     "biome:fix": "npx @biomejs/biome check --max-diagnostics=1000 --write",
     "doc": "rm -rf docs/* && typedoc --out docs && cp -r images docs/",
-    "prepare": "npm run biome:fix && npm run build && npm run test",
-    "test:dev": "vitest dev",
-    "test": "vitest run"
+    "test": "vitest run",
+    "build-css": "node scripts/replace-path-with-content.js src/style/style_template.css dist/tmp_maptiler-sdk.css && cat node_modules/maplibre-gl/dist/maplibre-gl.css dist/tmp_maptiler-sdk.css > dist/maptiler-sdk.css && rm dist/tmp_maptiler-sdk.css && cp dist/maptiler-sdk.css build/maptiler-sdk.css",
+    "build-umd": "tsc && NODE_ENV=production vite build -c vite.config-umd.ts",
+    "build-es": "tsc && NODE_ENV=production vite build -c vite.config-es.ts",
+    "build": "npm run build-es; npm run build-umd; npm run build-css",
+    "make": "npm run biome:fix && npm run build",
+    "dev-umd": "npm run build-css && tsc && NODE_ENV=dev vite build -w -c vite.config-umd.ts",
+    "help": "vite build --help"
   },
   "author": "MapTiler",
   "devDependencies": {
     "@biomejs/biome": "1.8.3",
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/uuid": "^9.0.2",
     "@types/xmldom": "^0.1.31",
-    "rollup": "^4.18.0",
-    "rollup-plugin-copy-merge": "^1.0.2",
-    "rollup-plugin-dts": "^6.1.1",
-    "rollup-plugin-esbuild": "^6.1.1",
-    "rollup-plugin-node-globals": "^1.4.0",
-    "rollup-plugin-shell": "^1.0.9",
-    "rollup-plugin-string": "^3.0.0",
-    "rollup-plugin-swc": "^0.2.1",
+    "@xmldom/xmldom": "^0.8.10",
     "serve": "^14.2.0",
     "terser": "^5.17.1",
     "typedoc": "^0.24.8",
     "typescript": "^5.1.6",
-    "vitest": "^0.34.2",
-    "xmldom": "^0.6.0"
+    "vite": "^5.3.4",
+    "vite-plugin-dts": "^4.0.0-beta.0",
+    "vitest": "^0.34.2"
   },
   "dependencies": {
-    "@maptiler/client": "^1.8.1",
+    "@maptiler/client": "^2.0.0",
     "events": "^3.3.0",
     "js-base64": "^3.7.4",
-    "maplibre-gl": "4.4.1",
+    "maplibre-gl": "^4.7.0",
     "uuid": "^9.0.0"
   }
 }

package/readme.md

@@ -862,6 +862,37 @@ Turning off *zoom compensation* allows for more accurate adjustments to the visu
 
 All the other options are documented on [our reference page](https://docs.maptiler.com/sdk-js/api/helpers/#heatmap) and more examples are available [here](https://docs.maptiler.com/sdk-js/examples/?q=heatmap+helper).
 
+# Other helper
+## Take Screenshots, programmatically
+There are two different ways to create screenshot, corresponding to two very different usecases. Note that screenshots will not contain *DOM elements* such as `Marker` and `Popup`, since those are not part of the rendering context.
+
+**1. Get a `blob` of a screenshot, PNG encoded:**
+```ts
+import { Map, helpers } from "@maptiler/sdk";
+
+// ... initialize a Map instance, wait for the "load" or "ready" event ...
+
+// Inside an async function, or with using .then()
+const blob = await helpers.takeScreenshot(map);
+```
+The returned `Blob` of a PNG image file can be very handy if the goal is to programmatically further manipulate the screenshot, such as sending it to some feedback endpoint with a POST request.
+
+**2. Download a PNG file:**
+```ts
+import { Map, helpers } from "@maptiler/sdk";
+
+// ... initialize a Map instance, wait for the "load" or "ready" event ...
+
+// No need to be inside an async function, the download will be triggered when the file is ready
+maptilersdk.helpers.takeScreenshot(map, {
+  download: true, 
+  filename: "map_screenshot.png"
+});
+```
+Getting a file directly is a nice option that can be useful to share some debugging context with colleagues, compare multiple styles, or share your creation on social media.
+
+> 📣 *__Note:__* Keep in mind that MapTiler Cloud data are copyrighted and their usage is restricted. This include MapTiler built-in styles and tilesets, among others. In case of doubt, do not hesitate to read our [terms](https://www.maptiler.com/terms/) or to ask our [support team](https://www.maptiler.com/contacts/).
+
 # Caching
 Starting from v2, MapTiler SDK introduced the **caching** of tiles and fonts served by MapTiler Cloud, which can represent a large chunk of the data being fetched when browsing a map. This caching leverages modern browsers caching API so it's well-managed and there is no risk of bloating! When we update **MapTiler Planet** or our **official styles**, the caching logic will detect it and automatically invalidate older versions of the tiles that were previously cached.
 

package/tsconfig.json

@@ -1,14 +1,27 @@
 {
   "compilerOptions": {
-    "moduleResolution": "Bundler",
-    "forceConsistentCasingInFileNames": true,
+    "baseUrl": "src",
+    "moduleResolution": "Node",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
     "strict": true,
-    "target": "es6",
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+
+
     "declaration": true,
     "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true
   },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "vite.config.ts"],
-  "exclude": ["node_modules", "dist", "demos", "scripts", "docs", "**/*.js", "**/*.cjs"]
-}
+  "include": ["src"]
+}

package/vite.config-es.ts

@@ -0,0 +1,48 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+
+const isProduction = process.env.NODE_ENV === "production";
+
+const plugins = [
+  dts({insertTypesEntry: true}),
+];
+
+export default defineConfig({
+  mode: isProduction ? "production" : "development",
+  build: {
+    minify: isProduction,
+    emptyOutDir: isProduction,
+    outDir: "dist",
+    sourcemap: true,
+    lib: {
+      // Could also be a dictionary or array of multiple entry points
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'maptilersdk',
+      // the proper extensions will be added
+      fileName: (format, entryName) => "maptiler-sdk.mjs",
+      formats: ['es'],
+    },
+    
+    rollupOptions: {
+      // make sure to externalize deps that shouldn't be bundled
+      // into your library
+      external: [
+        "maplibre-gl", 
+        "@maptiler/client", 
+        "@mapbox/point-geometry", 
+        "uuid", 
+        "@mapbox/unitbezier", 
+        "events", 
+        "js-base64", 
+        "geojson-validation",
+      ],
+      output: {
+        // Provide global variables to use in the UMD build
+        // for externalized deps
+        globals: {},
+      },
+    },
+  },
+  plugins,
+})

package/vite.config-umd.ts

@@ -0,0 +1,27 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+const isProduction = process.env.NODE_ENV === "production";
+const bundleFilename = isProduction ? "maptiler-sdk.umd.min.js" : "maptiler-sdk.umd.js"
+
+const plugins = [];
+
+
+export default defineConfig({
+  mode: isProduction ? "production" : "development",
+  build: {
+    outDir: "build",
+    minify: isProduction,
+    emptyOutDir: isProduction,
+    sourcemap: true,
+    lib: {
+      // Could also be a dictionary or array of multiple entry points
+      entry: resolve(__dirname, 'src/index.ts'),
+      name: 'maptilersdk',
+      // the proper extensions will be added
+      fileName: (format, entryName) => bundleFilename,
+      formats: ['umd'],
+    }
+  },
+  plugins,
+})

package/.github/pull_request_template.md

@@ -1,11 +0,0 @@
-## Objective
-What is the goal?
-
-## Description
-What changed, how and why?
-
-## Acceptance
-How were changes tested?
-
-## Checklist
-- [ ] I have added relevant info to the CHANGELOG.md

package/.github/workflows/format-lint.yml

@@ -1,21 +0,0 @@
-name: Format and Lint
-
-on: [pull_request]
-
-jobs:
-  format-and-lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out Git repository
-        uses: actions/checkout@v3
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-
-      - name: Install Node.js dependencies
-        run: npm ci
-
-      - name: Formatting and linting with Biome
-        run: npm run biome

package/.github/workflows/npm-publish.yml

@@ -1,22 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}