@maptiler/sdk 2.2.0 → 2.2.2

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, LanguageGeocoding, type LanguageGeocodingOptions, type LanguageGeocodingString, 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, getAutoLanguageGeocoding, getBufferToPixelDataParser, getTileCache, mapStylePresetList, math, misc, staticMaps, styleToStyle, } 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,142 @@
+/**
+ * Languages. Note that not all the languages of this list are available but the compatibility list may be expanded in the future.
+ */
+declare 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.
+     */
+    readonly 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.
+     */
+    readonly 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`.
+     */
+    readonly STYLE: "style";
+    /**
+     * AUTO mode uses the language of the browser
+     */
+    readonly AUTO: "auto";
+    /**
+     * STYLE is a custom flag to keep the language of the map as defined into the style.
+     * If STYLE is set in the constructor, then further modification of the language
+     * with `.setLanguage()` is not possible.
+     */
+    readonly STYLE_LOCK: "style_lock";
+    /**
+     * Default fallback languages that uses latin charaters
+     */
+    readonly LATIN: "name:latin";
+    /**
+     * Default fallback languages that uses non-latin charaters
+     */
+    readonly NON_LATIN: "name:nonlatin";
+    /**
+     * Labels are in their local language, when available
+     */
+    readonly LOCAL: "name";
+    /**
+     * International name
+     */
+    readonly INTERNATIONAL: "name_int";
+    readonly ALBANIAN: "name:sq";
+    readonly AMHARIC: "name:am";
+    readonly ARABIC: "name:ar";
+    readonly ARMENIAN: "name:hy";
+    readonly AZERBAIJANI: "name:az";
+    readonly BASQUE: "name:eu";
+    readonly BELORUSSIAN: "name:be";
+    readonly BENGALI: "name:bn";
+    readonly BOSNIAN: "name:bs";
+    readonly BRETON: "name:br";
+    readonly BULGARIAN: "name:bg";
+    readonly CATALAN: "name:ca";
+    readonly CHINESE: "name:zh";
+    readonly TRADITIONAL_CHINESE: "name:zh-Hant";
+    readonly SIMPLIFIED_CHINESE: "name:zh-Hans";
+    readonly CORSICAN: "name:co";
+    readonly CROATIAN: "name:hr";
+    readonly CZECH: "name:cs";
+    readonly DANISH: "name:da";
+    readonly DUTCH: "name:nl";
+    readonly ENGLISH: "name:en";
+    readonly ESPERANTO: "name:eo";
+    readonly ESTONIAN: "name:et";
+    readonly FINNISH: "name:fi";
+    readonly FRENCH: "name:fr";
+    readonly FRISIAN: "name:fy";
+    readonly GEORGIAN: "name:ka";
+    readonly GERMAN: "name:de";
+    readonly GREEK: "name:el";
+    readonly HEBREW: "name:he";
+    readonly HINDI: "name:hi";
+    readonly HUNGARIAN: "name:hu";
+    readonly ICELANDIC: "name:is";
+    readonly INDONESIAN: "name:id";
+    readonly IRISH: "name:ga";
+    readonly ITALIAN: "name:it";
+    readonly JAPANESE: "name:ja";
+    readonly JAPANESE_HIRAGANA: "name:ja-Hira";
+    readonly JAPANESE_KANA: "name:ja_kana";
+    readonly JAPANESE_LATIN: "name:ja_rm";
+    readonly JAPANESE_2018: "name:ja-Latn";
+    readonly KANNADA: "name:kn";
+    readonly KAZAKH: "name:kk";
+    readonly KOREAN: "name:ko";
+    readonly KOREAN_LATIN: "name:ko-Latn";
+    readonly KURDISH: "name:ku";
+    readonly ROMAN_LATIN: "name:la";
+    readonly LATVIAN: "name:lv";
+    readonly LITHUANIAN: "name:lt";
+    readonly LUXEMBOURGISH: "name:lb";
+    readonly MACEDONIAN: "name:mk";
+    readonly MALAYALAM: "name:ml";
+    readonly MALTESE: "name:mt";
+    readonly NORWEGIAN: "name:no";
+    readonly OCCITAN: "name:oc";
+    readonly PERSIAN: "name:fa";
+    readonly POLISH: "name:pl";
+    readonly PORTUGUESE: "name:pt";
+    readonly PUNJABI: "name:pa";
+    readonly WESTERN_PUNJABI: "name:pnb";
+    readonly ROMANIAN: "name:ro";
+    readonly ROMANSH: "name:rm";
+    readonly RUSSIAN: "name:ru";
+    readonly SCOTTISH_GAELIC: "name:gd";
+    readonly SERBIAN_CYRILLIC: "name:sr";
+    readonly SERBIAN_LATIN: "name:sr-Latn";
+    readonly SLOVAK: "name:sk";
+    readonly SLOVENE: "name:sl";
+    readonly SPANISH: "name:es";
+    readonly SWEDISH: "name:sv";
+    readonly TAMIL: "name:ta";
+    readonly TELUGU: "name:te";
+    readonly THAI: "name:th";
+    readonly TURKISH: "name:tr";
+    readonly UKRAINIAN: "name:uk";
+    readonly URDU: "name:ur";
+    readonly VIETNAMIAN_LATIN: "name:vi";
+    readonly WELSH: "name:cy";
+};
+declare function isLanguageSupported(lang: string): boolean;
+/**
+ * Type representing the key of the Language object
+ */
+type LanguageKey = keyof typeof Language;
+type Values<T> = T[keyof T];
+/**
+ * Built-in languages values as strings
+ */
+type LanguageString = Values<typeof Language>;
+declare function getBrowserLanguage(): LanguageString;
+export { Language, type LanguageString, type LanguageKey, getBrowserLanguage, isLanguageSupported };

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.0",
+  "version": "2.2.2",
   "description": "The Javascript & TypeScript map SDK tailored for MapTiler Cloud",
   "module": "dist/maptiler-sdk.mjs",
   "types": "dist/maptiler-sdk.d.ts",
@@ -34,43 +34,35 @@
     "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": "NODE_ENV=production tsc && vite build -c vite.config-umd.ts",
+    "build-es": "NODE_ENV=production tsc && 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"
   },
   "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",
     "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"
   },
   "dependencies": {
     "@maptiler/client": "^1.8.1",
     "events": "^3.3.0",
     "js-base64": "^3.7.4",
     "maplibre-gl": "4.4.1",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "xmldom": "^0.6.0"
   }
 }

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,
+    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",
+        "xmldom",
+      ],
+      output: {
+        // Provide global variables to use in the UMD build
+        // for externalized deps
+        globals: {},
+      },
+    },
+  },
+  plugins,
+})

package/vite.config-umd.ts

@@ -0,0 +1,25 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+const isProduction = process.env.NODE_ENV === "production";
+
+const plugins = [];
+
+
+export default defineConfig({
+  mode: isProduction ? "production" : "development",
+  build: {
+    outDir: "build",
+    minify: 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) => "maptiler-sdk.umd.js",
+      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}}