@maptiler/sdk 3.4.0-rc1 → 3.4.0-rc3

package/dist/src/config.d.ts

@@ -0,0 +1,85 @@
+import { default as EventEmitter } from 'events';
+import { LanguageInfo } from './language';
+import { FetchFunction } from '@maptiler/client';
+import { Unit } from './types';
+export declare const MAPTILER_SESSION_ID: string;
+/**
+ * Configuration class for the SDK
+ */
+declare class SdkConfig extends EventEmitter {
+    /**
+     * The primary language. By default, the language of the web browser is used.
+     */
+    primaryLanguage: LanguageInfo;
+    /**
+     * The secondary language, to overwrite the default language defined in the map style.
+     * This settings is highly dependant on the style compatibility and may not work in most cases.
+     */
+    secondaryLanguage?: LanguageInfo;
+    /**
+     * Setting on whether of not the SDK runs with a session logic.
+     * A "session" is started at the initialization of the SDK and finished when the browser
+     * page is being refreshed.
+     * When `session` is enabled (default: true), the extra URL param `mtsid` is added to queries
+     * on the MapTiler Cloud API. This allows MapTiler to enable "session based billing".
+     */
+    session: boolean;
+    /**
+     * Enables client-side caching of requests for tiles and fonts.
+     * The cached requests persist multiple browser sessions and will be reused when possible.
+     * Works only for requests to the MapTiler Cloud API when sessions are enabled.
+     */
+    caching: boolean;
+    /**
+     * Telemetry is enabled by default but can be opted-out by setting this value to `false`.
+     * The telemetry is very valuable to the team at MapTiler because it shares information
+     * about where to add the extra effort. It also helps spotting some incompatibility issues
+     * that may arise between the SDK and a specific version of a module.
+     *
+     * It consists in sending metrics about usage of the following features:
+     * - SDK version [string]
+     * - API key [string]
+     * - MapTiler sesion ID (if opted-in) [string]
+     * - if tile caching is enabled [boolean]
+     * - if language specified at initialization [boolean]
+     * - if terrain is activated at initialization [boolean]
+     * - if globe projection is activated at initialization [boolean]
+     *
+     * In addition, each official module will be added to a list, alongside its version number.
+     */
+    telemetry: boolean;
+    /**
+     * Unit to be used
+     */
+    private _unit;
+    /**
+     * MapTiler Cloud API key
+     */
+    private _apiKey;
+    /**
+     * Set the unit system
+     */
+    set unit(u: Unit);
+    /**
+     * Get the unit system
+     */
+    get unit(): Unit;
+    /**
+     * Set the MapTiler Cloud API key
+     */
+    set apiKey(k: string);
+    /**
+     * Get the MapTiler Cloud API key
+     */
+    get apiKey(): string;
+    /**
+     * Set a the custom fetch function to replace the default one
+     */
+    set fetch(f: FetchFunction);
+    /**
+     * Get the fetch fucntion
+     */
+    get fetch(): FetchFunction | null;
+}
+declare const config: SdkConfig;
+export { config, SdkConfig };

package/dist/src/constants/defaults.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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/src/controls/MaptilerGeolocateControl.d.ts

@@ -0,0 +1,21 @@
+import { GeolocateControl } from '../MLAdapters/GeolocateControl';
+/**
+ * The MaptilerGeolocateControl is an extension of the original GeolocateControl
+ * with a few changes. In this version, the active mode persists as long as the
+ * location is still centered. This means it's robust to rotation, pitch and zoom.
+ *
+ */
+export declare class MaptilerGeolocateControl extends GeolocateControl {
+    private lastUpdatedCenter;
+    /**
+     * Update the camera location to center on the current position
+     *
+     * @param {Position} position the Geolocation API Position
+     * @private
+     */
+    _updateCamera: (position: GeolocationPosition) => void;
+    _finishSetupUI: (supported: boolean) => void;
+    _updateCircleRadius(): void;
+    _onZoom: () => void;
+    _setErrorState(): void;
+}

package/dist/src/controls/MaptilerLogoControl.d.ts

@@ -0,0 +1,19 @@
+import { LogoControlOptions as LogoControlOptionsML } from 'maplibre-gl';
+import { LogoControl } from '../MLAdapters/LogoControl';
+import { Map as SDKMap } from '../Map';
+type LogoControlOptions = LogoControlOptionsML & {
+    logoURL?: string;
+    linkURL?: string;
+};
+/**
+ * This LogoControl extends the MapLibre LogoControl but instead can use any image URL and
+ * any link URL. By default this is using MapTiler logo and URL.
+ */
+export declare class MaptilerLogoControl extends LogoControl {
+    _compact: boolean;
+    private logoURL;
+    private linkURL;
+    constructor(options?: LogoControlOptions);
+    onAdd(map: SDKMap): HTMLElement;
+}
+export {};

package/dist/src/controls/MaptilerNavigationControl.d.ts

@@ -0,0 +1,17 @@
+import { NavigationControlOptions } from 'maplibre-gl';
+import { NavigationControl } from '../MLAdapters/NavigationControl';
+type HTMLButtonElementPlus = HTMLButtonElement & {
+    clickFunction: (e?: Event) => 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;
+    /**
+     * Overloading: Limit how flat the compass icon can get
+     */
+    _rotateCompassArrow: () => void;
+}
+export {};

package/dist/src/controls/MaptilerProjectionControl.d.ts

@@ -0,0 +1,14 @@
+import { Map as SDKMap } from '../Map';
+import { IControl } from 'maplibre-gl';
+/**
+ * A `MaptilerProjectionControl` control adds a button to switch from Mercator to Globe projection.
+ */
+export declare class MaptilerProjectionControl implements IControl {
+    map: SDKMap;
+    container: HTMLElement;
+    projectionButton: HTMLButtonElement;
+    onAdd(map: SDKMap): HTMLElement;
+    onRemove(): void;
+    private toggleProjection;
+    private updateProjectionIcon;
+}

package/dist/src/controls/MaptilerTerrainControl.d.ts

@@ -0,0 +1,16 @@
+import { Map as SDKMap } from '../Map';
+import { IControl } from 'maplibre-gl';
+/**
+ * A `MaptilerTerrainControl` control adds a button to turn terrain on and off
+ * by triggering the terrain logic that is already deployed in the Map object.
+ */
+export declare class MaptilerTerrainControl implements IControl {
+    _map: SDKMap;
+    _container: HTMLElement;
+    _terrainButton: HTMLButtonElement;
+    constructor();
+    onAdd(map: SDKMap): HTMLElement;
+    onRemove(): void;
+    _toggleTerrain(): void;
+    _updateTerrainIcon(): void;
+}

package/dist/src/controls/Minimap.d.ts

@@ -0,0 +1,57 @@
+import { Map as SDKMap, MapOptions } from '../Map';
+import { ControlPosition, CustomLayerInterface, FillLayerSpecification, FilterSpecification, IControl, LayerSpecification, LineLayerSpecification, SourceSpecification, StyleOptions, StyleSetterOptions, StyleSpecification, StyleSwapOptions } from 'maplibre-gl';
+import { MapStyleVariant, ReferenceMapStyle } from '@maptiler/client';
+export interface ParentRect {
+    lineLayout: LineLayerSpecification["layout"];
+    linePaint: LineLayerSpecification["paint"];
+    fillPaint: FillLayerSpecification["paint"];
+}
+export interface MinimapOptionsInput {
+    /**
+     * Style of the map. Can be:
+     * - a full style URL (possibly with API key)
+     * - a shorthand with only the MapTIler style name (eg. `"streets-v2"`)
+     * - a longer form with the prefix `"maptiler://"` (eg. `"maptiler://streets-v2"`)
+     */
+    style?: ReferenceMapStyle | MapStyleVariant | StyleSpecification | string;
+    /**
+     * Set the zoom difference between the parent and the minimap
+     * If the parent is zoomed to 10 and the minimap is zoomed to 8, the zoomAdjust should be 2
+     * Default: -4
+     */
+    zoomAdjust?: number;
+    /** Set a zoom of the minimap and don't allow any future changes */
+    lockZoom?: number;
+    /** Adjust the pitch only if the user requests */
+    pitchAdjust?: boolean;
+    /** Set CSS properties of the container using object key-values */
+    containerStyle?: Record<string, string>;
+    /** Set the position of the minimap at either "top-left", "top-right", "bottom-left", or "bottom-right" */
+    position?: ControlPosition;
+    /** Set the parentRect fill and/or line options */
+    parentRect?: ParentRect;
+}
+export interface MinimapOptions extends MapOptions {
+    zoomAdjust: number;
+    pitchAdjust: boolean;
+    containerStyle: Record<string, string>;
+    parentRect?: ParentRect;
+}
+export default class Minimap implements IControl {
+    #private;
+    map: SDKMap;
+    constructor(options: MinimapOptionsInput, mapOptions: MapOptions);
+    setStyle(style: null | ReferenceMapStyle | MapStyleVariant | StyleSpecification | string, options?: StyleSwapOptions & StyleOptions): void;
+    addLayer(layer: (LayerSpecification & {
+        source?: string | SourceSpecification;
+    }) | CustomLayerInterface, beforeId?: string): SDKMap;
+    moveLayer(id: string, beforeId?: string): SDKMap;
+    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;
+    setGlyphs(glyphsUrl: string | null, options?: StyleSetterOptions): this;
+    onAdd(parentMap: SDKMap): HTMLElement;
+    onRemove(): void;
+}

package/dist/src/controls/index.d.ts

@@ -0,0 +1,6 @@
+export * from './MaptilerGeolocateControl';
+export * from './MaptilerLogoControl';
+export * from './MaptilerTerrainControl';
+export * from './MaptilerNavigationControl';
+export * from './MaptilerProjectionControl';
+export * from './Minimap';

package/dist/src/converters/index.d.ts

@@ -0,0 +1 @@
+export * from './xml';

package/dist/src/converters/xml.d.ts

@@ -0,0 +1,54 @@
+export interface Link {
+    href: string | null;
+}
+export interface XMLProperties {
+    links?: Link[];
+}
+export interface PlacemarkProperties {
+    name?: string;
+    address?: string;
+    styleUrl?: string;
+    description?: string;
+    styleHash?: string;
+    styleMapHash?: Record<string, string | null>;
+    timespan?: {
+        begin: string;
+        end: string;
+    };
+    timestamp?: string;
+    stroke?: string;
+    "stroke-opacity"?: number;
+    "stroke-width"?: number;
+    fill?: string;
+    "fill-opacity"?: number;
+    visibility?: string;
+    icon?: string;
+    coordTimes?: (string | null)[] | (string | null)[][];
+}
+/**
+ * create a function that converts a string to XML
+ * https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+ */
+export declare function str2xml(str: string): Document;
+/**
+ * Check one of the top level child node is of a given type ("gpx", "kml").
+ * The check is not case sensitive.
+ * @param doc
+ * @param nodeName
+ * @returns
+ */
+export declare function hasChildNodeWithName(doc: Document, nodeName: string): boolean;
+/**
+ * create a function that converts a XML to a string
+ * https://developer.mozilla.org/en-US/docs/Web/API/XMLSerializer
+ */
+export declare function xml2str(node: Node): string;
+/**
+ * Given a XML document using the GPX spec, return GeoJSON
+ */
+export declare function gpx(doc: string | Document): GeoJSON.FeatureCollection;
+/**
+ * Given a XML document using the KML spec, return GeoJSON
+ */
+export declare function kml(doc: string | Document, xml2string?: (node: Node) => string): GeoJSON.FeatureCollection;
+export declare function gpxOrKml(doc: string | Document): GeoJSON.FeatureCollection | null;

package/dist/src/custom-layers/AnimatedRouteLayer.d.ts

@@ -0,0 +1,291 @@
+import { AnimationEvent, AnimationEventTypes, EasingFunctionName, Keyframe } from '../utils/MaptilerAnimation/types';
+import { default as MaptilerAnimation, MaptilerAnimationOptions } from '../utils/MaptilerAnimation/MaptilerAnimation';
+import { CustomLayerInterface, Map } from '../index';
+export type SourceData = {
+    id: string;
+    featureSetIndex: number;
+    layerID: string;
+};
+/**
+ * Options for configuring the animated stroke effect for routes.
+ * When an object is provided, it defines colors for active and inactive parts of the route.
+ * When `false`, the animated stroke effect is disabled.
+ *
+ * @typedef {Object|boolean} AnimatedStrokeOptions
+ * @property {[number, number, number, number]} activeColor - The color of the path that has been progressed, in RGBA format.
+ * @property {[number, number, number, number]} inactiveColor - The base color of the path, in RGBA format.
+ */
+export type AnimatedStrokeOptions = {
+    activeColor: [number, number, number, number];
+    inactiveColor: [number, number, number, number];
+} | false;
+/**
+ * Options for configuring the animated camera movement
+ * along the route.
+ *
+ * @typedef {Object|boolean} AnimatedCameraOptions
+ * @property {boolean} [follow] - Whether the camera should follow the animation.
+ * @property {Object|boolean} [pathSmoothing] - Whether the camera path should be smoothed.
+ * @property {number} [pathSmoothing.resolution] - The resolution of the smoothing, higher resolution means more fidelity to the path.
+ * @property {number} [pathSmoothing.epsilon] - How much to simplify the path beforehand.
+ * @property {false} [pathSmoothing] - Whether the camera path should be smoothed.
+ */
+export type AnimatedCameraOptions = {
+    /** Whether the camera should follow the animation */
+    follow?: boolean;
+    /** Whether the camera path should be smoothed */
+    pathSmoothing?: {
+        /** the resolution of the smoothing, higher resolution means more fidelity to the path */
+        resolution: number;
+        /** How mich to simplify the path beforehand */
+        epsilon: number;
+    } | false;
+} | false;
+/**
+ * Configuration options for the AnimatedRouteLayer.
+ * This type supports either providing keyframes directly OR source data for the animation.
+ *
+ * @typedef AnimatedRouteLayerOptions
+ * @property {number} [duration] - The duration of the animation in milliseconds
+ * @property {number} [iterations] - The number of animation iterations to perform
+ * @property {number} [delay] - The delay in milliseconds before starting the animation
+ * @property {EasingFunctionName} [easing] - The default easing function to use if not provided in the GeoJSON
+ * @property {AnimatedCameraOptions} [cameraAnimation] - Options for camera animation
+ * @property {AnimatedStrokeOptions} [pathStrokeAnimation] - Options for stroke animation, only applicable for LineString geometries
+ * @property {boolean} [autoplay] - Whether the animation should start playing automatically
+ * @property {boolean} [manualUpdate] - Whether the animation should update automatically or require manual frameAdvance calls
+ * @property {Keyframe[]} [keyframes] - The keyframes for the animation (mutually exclusive with source)
+ * @property {SourceData} [source] - The source data for the animation (mutually exclusive with keyframes)
+ */
+export type AnimatedRouteLayerOptions = {
+    /** The Duration in ms */
+    duration?: number;
+    /** The number of iterations */
+    iterations?: number;
+    /** The delay in ms before playing */
+    delay?: number;
+    /** The default easing to use if not provided in teh GeoJSON */
+    easing?: EasingFunctionName;
+    /** The camera animation options */
+    cameraAnimation?: AnimatedCameraOptions;
+    /** The stroke animation options, only viable for LineString geometries */
+    pathStrokeAnimation?: AnimatedStrokeOptions;
+    /** Whether the animation should autoplay */
+    autoplay?: boolean;
+    /** Whether the animation should auto matically animated or whether the frameAdvance method should be called */
+    manualUpdate?: boolean;
+} & ({
+    /** The keyframes for the the animation OR */
+    keyframes: Keyframe[];
+    source?: never;
+} | {
+    /** The source data  */
+    source: SourceData;
+    keyframes?: never;
+});
+/**
+ * A callback function that gets executed for each animation frame. This is simply a utility type.
+ * @param {AnimationEvent} event - The animation event data provided during animation frame updates.
+ */
+export type FrameCallback = (event: AnimationEvent) => void;
+export declare const ANIM_LAYER_PREFIX = "animated-route-layer";
+/**
+ * This layer allows you to create animated paths on a map by providing keyframes or a GeoJSON source
+ * with route data. The animation can control both the visual appearance of the path (using color transitions)
+ * and optionally animate the camera to follow along the route path.
+ * @class AnimatedRouteLayer
+ *
+ * @example
+ * ```typescript
+ * // Create an animated route layer using a GeoJSON source
+ * const animatedRoute = new AnimatedRouteLayer({
+ *   source: {
+ *     id: 'route-source',
+ *     layerID: 'route-layer',
+ *     featureSetIndex: 0
+ *   },
+ *   duration: 5000,
+ *   pathStrokeAnimation: {
+ *     activeColor: [0, 255, 0, 1],
+ *     inactiveColor: [100, 100, 100, 0.5]
+ *   },
+ *   autoplay: true
+ * });
+ *
+ * // Add the layer to the map
+ * map.addLayer(animatedRoute);
+ *
+ * // Control playback
+ * animatedRoute.play();
+ * animatedRoute.pause();
+ * ```
+ *
+ * @remarks
+ * The animation can be configured using either explicit keyframes or a GeoJSON source.
+ * When using a GeoJSON source, the feature can include special properties that control
+ * animation behavior:
+ * - `@duration`: Animation duration in milliseconds
+ * - `@iterations`: Number of times to repeat the animation
+ * - `@delay`: Delay before starting animation in milliseconds
+ * - `@autoplay`: Whether to start the animation automatically
+ *
+ * Only one AnimatedRouteLayer can be active at a time on a map.
+ */
+/**
+ * Creates an animated route layer for MapTiler maps.
+ *
+ * The `AnimatedRouteLayer` allows you to animate paths on a map with visual effects and optional camera following.
+ * You can define animations either through explicit keyframes or by referencing GeoJSON data with animation metadata.
+ *
+ * Features:
+ * - Animate route paths with color transitions (active/inactive segments)
+ * - Optional camera following along the route
+ * - Control animation playback (play, pause)
+ * - Configure animation properties (duration, iterations, delay, easing)
+ * - Support for manual or automatic animation updates
+ * - Event system for animation state changes
+ *
+ * @example
+ * ```typescript
+ * // Create an animated route from GeoJSON source
+ * const animatedRoute = new AnimatedRouteLayer({
+ *   source: {
+ *     id: 'route-source',
+ *     layerID: 'route-layer',
+ *     featureSetIndex: 0
+ *   },
+ *   duration: 5000,
+ *   iterations: 1,
+ *   autoplay: true,
+ *   cameraAnimation: {
+ *     follow: true,
+ *     pathSmoothing: { resolution: 20, epsilon: 5 }
+ *   },
+ *   pathStrokeAnimation: {
+ *     activeColor: [255, 0, 0, 1],
+ *     inactiveColor: [0, 0, 255, 1]
+ *   }
+ * });
+ *
+ * // Add the layer to the map
+ * map.addLayer(animatedRoute);
+ *
+ * // Control playback
+ * animatedRoute.pause();
+ * animatedRoute.play();
+ *
+ * // Listen for animation events
+ * animatedRoute.addEventListener(AnimationEventTypes.Finish, () => {
+ *   console.log('Animation completed');
+ * });
+ * ```
+ *
+ * @implements {CustomLayerInterface}
+ */
+export declare class AnimatedRouteLayer implements CustomLayerInterface {
+    /** Unique ID for the layer */
+    readonly id: string;
+    readonly type = "custom";
+    /** The MaptilerAnimation instance that handles the animation */
+    animationInstance: MaptilerAnimation;
+    /**
+     * Keyframes for the animation
+     * If keyframes are provided, they will be used for the animation
+     * If a source is provided, the keyframes will be parsed from the GeoJSON feature
+     */
+    private keyframes;
+    /**
+     * Source data for the animation
+     * If a source is provided, it will be used to get the keyframes
+     * If keyframes are provided, this will be ignored
+     */
+    private source;
+    /** The duration of the animation in ms */
+    private duration;
+    /** The number of interations */
+    private iterations;
+    /** The delay before the animation starts in ms */
+    private delay;
+    /** The default easing function for the animation */
+    private easing?;
+    /** The map instance */
+    private map;
+    /** The camera animation options */
+    private cameraMaptilerAnimationOptions?;
+    /**
+     * The path stroke animation options
+     * This controls the color of the path during the animation
+     */
+    private pathStrokeAnimation?;
+    /** Whether the animation will autoplay */
+    private autoplay;
+    /** Whether the animation will be managed manually */
+    private manualUpdate;
+    private enquedEventHandlers;
+    private enquedCommands;
+    constructor({ keyframes, source, duration, iterations, easing, delay, cameraAnimation, pathStrokeAnimation, autoplay, manualUpdate, }: AnimatedRouteLayerOptions);
+    /**
+     * This method is called when the layer is added to the map.
+     * It initializes the animation instance and sets up event listeners.
+     *
+     * @param {Map} map - The map instance
+     */
+    onAdd(map: Map): Promise<void>;
+    /**
+     * This method is used to manually advance the animation
+     *
+     * @returns {AnimatedRouteLayer} - The current instance of AnimatedRouteLayer
+     */
+    frameAdvance(): this;
+    /**
+     * Adds an event listener to the animation instance.
+     *
+     * @param {AnimationEventTypes} type - The type of event to listen for
+     * @param {FrameCallback} callback - The callback function to execute when the event occurs
+     */
+    addEventListener(type: AnimationEventTypes, callback: FrameCallback): AnimatedRouteLayer;
+    /**
+     * Removes an event listener from the animation instance.
+     *
+     * @param {AnimationEventTypes} type - The type of event to remove
+     * @param {FrameCallback} callback - The callback function to remove
+     */
+    removeEventListener(type: AnimationEventTypes, callback: FrameCallback): AnimatedRouteLayer;
+    updateManual(): void;
+    /**
+     * Updates the layer's properties based on the animation event.
+     * @private
+     * @param {AnimationEvent} event - The animation event
+     */
+    private update;
+    /**
+     * Plays the animation.
+     *
+     * @returns {AnimatedRouteLayer} - The current instance of AnimatedRouteLayer
+     */
+    play(): AnimatedRouteLayer;
+    /**
+     * Stops the animation.
+     *
+     * @returns {AnimatedRouteLayer} - The current instance of AnimatedRouteLayer
+     */
+    pause(): AnimatedRouteLayer;
+    /**
+     * Gets the source GeoJSON data from the map instance, parses it, and returns the animation options.
+     *
+     * @returns {Promise<MaptilerAnimationOptions>} - The MaptilerAnimation constructor options
+     */
+    getMaptilerAnimationOptions(): Promise<MaptilerAnimationOptions & {
+        autoplay: boolean;
+    }>;
+    /**
+     * This method is called when the layer is removed from the map.
+     * It destroys the animation instance.
+     */
+    onRemove(): void;
+    /**
+     * This method is called to render the layer.
+     * It is a no-op for this layer.
+     */
+    render(): void;
+}

package/dist/src/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './screenshot';
+export * from './vectorlayerhelpers';
+export * from './stylehelper';

package/dist/src/helpers/screenshot.d.ts

@@ -0,0 +1,18 @@
+import { Map as MapSDK } from '../Map';
+/**
+ * Takes a screenshot (PNG file) of the curent map view.
+ * Depending on the options, this function can automatically trigger a download of te file.
+ */
+export declare function takeScreenshot(map: MapSDK, options?: {
+    /**
+     * If `true`, this function will trigger a download in addition to returning a blob.
+     * Default: `false`
+     */
+    download?: boolean;
+    /**
+     * Only if `options.download` is `true`. Indicates the filename under which
+     * the file will be downloaded.
+     * Default: `"maptiler_screenshot.png"`
+     */
+    filename?: string;
+}): Promise<Blob>;

package/dist/src/helpers/stylehelper.d.ts

@@ -0,0 +1,28 @@
+import { DataDrivenPropertyValueSpecification, ExpressionSpecification } from 'maplibre-gl';
+import { ColorRamp } from '../ColorRamp';
+import { DataDrivenStyle, PropertyValues, ZoomNumberValues, ZoomStringValues } from './vectorlayerhelpers';
+export type ColorPalette = [string, string, string, string];
+export declare const colorPalettes: Array<ColorPalette>;
+export declare function getRandomColor(): string;
+export declare function generateRandomSourceName(): string;
+export declare function generateRandomLayerName(): string;
+/**
+ * Linera interpolation to find a value at an arbitrary zoom level, given a list of tuple zoom-value
+ */
+export declare function lerpZoomNumberValues(znv: ZoomNumberValues, z: number): number;
+export declare function paintColorOptionsToPaintSpec(color: ZoomStringValues): DataDrivenPropertyValueSpecification<string>;
+export declare function rampedOptionsToLayerPaintSpec(ramp: ZoomNumberValues): DataDrivenPropertyValueSpecification<number>;
+export declare function computeRampedOutlineWidth(lineWidth: number | ZoomNumberValues, outlineWidth: number | ZoomNumberValues): number | DataDrivenPropertyValueSpecification<number>;
+export declare function rampedPropertyValueWeight(ramp: PropertyValues, property: string): DataDrivenPropertyValueSpecification<number>;
+/**
+ * Create a dash array from a string pattern that uses underscore and whitespace characters
+ */
+export declare function dashArrayMaker(pattern: string): Array<number>;
+export declare function colorDrivenByProperty(style: DataDrivenStyle, property: string): DataDrivenPropertyValueSpecification<string>;
+export declare function radiusDrivenByProperty(style: DataDrivenStyle, property: string, zoomCompensation?: boolean): DataDrivenPropertyValueSpecification<number>;
+export declare function radiusDrivenByPropertyHeatmap(style: PropertyValues, property: string, zoomCompensation?: boolean): DataDrivenPropertyValueSpecification<number>;
+/**
+ * Turns a ColorRamp instance into a MapLibre style for ramping the opacity, driven by a property
+ */
+export declare function opacityDrivenByProperty(colorramp: ColorRamp, property: string): DataDrivenPropertyValueSpecification<number>;
+export declare function heatmapIntensityFromColorRamp(colorRamp: ColorRamp, steps?: number): ExpressionSpecification;