@maptiler/sdk 3.10.0 → 3.10.1-rc.1

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/ImageViewerFitImageToBoundsControl.d.ts

@@ -0,0 +1,13 @@
+import { IControl } from 'maplibre-gl';
+import { ImageViewer } from '../ImageViewer';
+import { Map as MapSDK } from '../Map';
+export declare class ImageViewerFitImageToBoundsControl implements IControl {
+    private viewer;
+    private container;
+    constructor({ imageViewer }: {
+        imageViewer: ImageViewer;
+    });
+    handleClick: () => void;
+    onAdd(_map: MapSDK): HTMLElement;
+    onRemove(): void;
+}

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

@@ -0,0 +1,17 @@
+import { Map as SDKMap } from '../Map';
+import { IControl, MapLibreEvent } from 'maplibre-gl';
+export type MaptilerCustomControlCallback<E> = (map: SDKMap, element: HTMLElement, event: E) => void;
+/**
+ * The MaptilerCustomControl allows any existing element to become a map control.
+ */
+export declare class MaptilerCustomControl implements IControl {
+    #private;
+    /**
+     * @param selectorOrElement Element to be used as control, specified as either reference to element itself or a CSS selector to find the element in DOM
+     * @param onClick Function called when the element is clicked
+     * @param onRender Function called every time the underlying map renders a new state
+     */
+    constructor(selectorOrElement: string | HTMLElement, onClick?: MaptilerCustomControlCallback<Event>, onRender?: MaptilerCustomControlCallback<MapLibreEvent>);
+    onAdd(map: SDKMap): HTMLElement;
+    onRemove(): void;
+}

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

@@ -0,0 +1,25 @@
+import { Map as SDKMap } from '../Map';
+import { IControl } from 'maplibre-gl';
+import { MaptilerCustomControl, MaptilerCustomControlCallback } from './MaptilerCustomControl';
+export type MaptilerExternalControlType = "zoom-in" | "zoom-out" | "toggle-projection" | "toggle-terrain" | "reset-view" | "reset-bearing" | "reset-pitch" | "reset-roll";
+/**
+ * The MaptilerExternalControl allows any existing element to automatically become a map control. Used for detected controls if `customControls` config is turned on.
+ */
+export declare class MaptilerExternalControl extends MaptilerCustomControl implements IControl {
+    #private;
+    static controlCallbacks: Record<MaptilerExternalControlType, MaptilerCustomControlCallback<Event>>;
+    /**
+     * Constructs an instance of External Control to have a predefined functionality
+     * @param controlElement Element to be used as control, specified as reference to element itself
+     * @param controlType One of the predefined types of functionality
+     */
+    constructor(controlElement: HTMLElement, controlType?: MaptilerExternalControlType);
+    onAdd(map: SDKMap): HTMLElement;
+    onRemove(): void;
+    /**
+     * Configure a child element to be part of this control and to have a predefined functionality added
+     * @param controlElement Element that is a descendant of the control element and that optionally should have some functionality
+     * @param controlType One of the predefined types of functionality
+     */
+    configureGroupItem(controlElement: HTMLElement, controlType: MaptilerExternalControlType | undefined): void;
+}

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,15 @@
+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;
+}
+export declare function toggleProjection(map: SDKMap): void;

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

@@ -0,0 +1,17 @@
+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;
+}
+export declare function toggleTerrain(map: SDKMap): 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 Omit<MapOptions, "space" | "halo"> {
+    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,8 @@
+export * from './MaptilerCustomControl';
+export * from './MaptilerExternalControl';
+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/CubemapLayer/CubemapLayer.d.ts

@@ -0,0 +1,239 @@
+import { CustomLayerInterface, CustomRenderMethodInput } from 'maplibre-gl';
+import { Map as MapSDK } from '../../Map';
+import { WebGLContext } from '../../utils/webgl-utils';
+import { CubemapDefinition, CubemapFaces, CubemapLayerConstructorOptions } from './types';
+declare class CubemapLayer implements CustomLayerInterface {
+    id: string;
+    type: CustomLayerInterface["type"];
+    renderingMode: CustomLayerInterface["renderingMode"];
+    /**
+     * The map instance to which this layer is added.
+     * @type {MapSDK}
+     * @private
+     */
+    private map;
+    /**
+     * The cubemap faces definition, which can be either a preset, path, or explicit face URLs.
+     * @type {CubemapFaces | null}
+     * @remarks
+     * This property is set during the initialization of the layer and can be updated later.
+     * If no faces are defined, it will be `null`.
+     */
+    private faces?;
+    /**
+     * Indicates whether to use a cubemap texture for rendering.
+     * @type {boolean}
+     * @private
+     * @default true
+     */
+    private useCubemapTexture;
+    /**
+     * The current opacity of the fade effect applied to the cubemap image texture, used for fading in and out.
+     * @type {number}
+     * @private
+     * @default 0.0
+     */
+    private currentFadeOpacity;
+    /**
+     * Indicates whether the cubemap needs to be updated, typically when the faces or texture changes.
+     * @type {boolean}
+     * @private
+     * @default false
+     */
+    private cubeMapNeedsUpdate;
+    /**
+     * The background color of the cubemap layer, represented as a Vec4 (RGBA).
+     * @type {Vec4}
+     * @private
+     */
+    private bgColor;
+    /**
+     * The previous background color used for transition animations.
+     * @type {Vec4}
+     * @private
+     */
+    private previousBgColor;
+    /**
+     * The target background color to which the layer will transition.
+     * @type {Vec4}
+     * @private
+     */
+    private targetBgColor;
+    /**
+     * The delta value used for transitioning the background color. 0 = start of transition, 1 = end of transition.
+     * This value is incremented over time to create a smooth transition effect.
+     * @type {number}
+     * @private
+     */
+    private transitionDelta;
+    /**
+     * The WebGL context used for rendering the cubemap layer.
+     * @type {WebGLContext}
+     * @private
+     */
+    private gl;
+    /**
+     * The cubemap object that contains the shader program, buffers and uniform locations for rendering.
+     * @type {Object3D}
+     * @private
+     */
+    private cubemap?;
+    /**
+     * The WebGL texture used for the cubemap, which is created from the defined faces.
+     * This texture is used to render the cubemap in the scene.
+     * @type {WebGLTexture | undefined}
+     * @private
+     */
+    private texture?;
+    /**
+     * The key representing the current faces definition, used to diff / track changes in the cubemap faces.
+     * @type {string}
+     */
+    currentFacesDefinitionKey: string;
+    /**
+     * The configuration options for the cubemap layer.
+     * @type {CubemapLayerConstructorOptions}
+     * @private
+     */
+    private options;
+    private animationActive;
+    /**
+     * Creates a new instance of CubemapLayer
+     *
+     * @param {CubemapLayerConstructorOptions | true} cubemapConfig - Configuration options for the cubemap layer or `true` to use default options.
+     * Can specify faces, preset, path, and color properties to configure the cubemap.
+     *
+     * @remarks You shouldn't have to use this class directly.
+     * Instead, use the `Map.setHalo` method to create and add a halo layer to the map.
+     * The constructor initializes the cubemap with the provided configuration.
+     * It processes the faces definition, sets up background colors, and determines
+     * whether to use a cubemap texture based on the provided options.
+     */
+    constructor(cubemapConfig: CubemapLayerConstructorOptions | true);
+    /**
+     * Updates the cubemap object with the current faces and shader configuration.
+     * This method is called when the cubemap faces change or when the layer is initialized.
+     * @returns {void}
+     * @remarks
+     * It creates a new Object3D instance with the specified vertex and fragment shaders,
+     * attributes, and uniforms. The cubemap will be rendered using this configuration.
+     */
+    updateCubemap({ facesNeedUpdate }?: {
+        facesNeedUpdate: boolean;
+    }): void;
+    /**
+     * Called when the layer is added to the map.
+     * Initializes the cubemap and sets up the WebGL context.
+     *
+     * @param {MapSDK} map - The map instance to which this layer is added.
+     * @param {WebGLRenderingContext | WebGL2RenderingContext} gl - The WebGL context used for rendering.
+     */
+    onAdd(map: MapSDK, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * Called when the layer is removed from the map.
+     * Cleans up the cubemap resources and WebGL buffers.
+     *
+     * @param {MapSDK} _map - The map instance from which this layer is removed.
+     * @param {WebGLRenderingContext | WebGL2RenderingContext} gl - The WebGL context used for rendering.
+     */
+    onRemove(_map: MapSDK, gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * Updates the cubemap texture with the provided faces.
+     * This method is called when the cubemap faces change or when the layer is initialized.
+     *
+     * @param {WebGLContext} gl - The WebGL context used for rendering.
+     * @param {CubemapFaces} faces - The cubemap faces to be loaded into the texture.
+     */
+    updateTexture(gl: WebGLContext, faces: CubemapFaces): void;
+    /**
+     * Called before the layer is rendered.
+     * Updates the cubemap texture with the current faces.
+     *
+     * @param {WebGLContext} gl - The WebGL context used for rendering.
+     * @param {CustomRenderMethodInput} _options - Additional options for the render method.
+     */
+    prerender(_gl: WebGLContext, _options: CustomRenderMethodInput): void;
+    /**
+     * Lerps the background color transition of the cubemap layer.
+     * This method smoothly transitions the background color from the previous color to the target color.
+     *
+     * @private
+     */
+    private animateColorChange;
+    /**
+     * Animates the cubemap image fading in.
+     * This method gradually increases the opacity of the cubemap image to create a fade-in effect.
+     *
+     * @private
+     */
+    private imageIsAnimating;
+    /**
+     * The delta value used for the image fade-in animation.
+     * This value is incremented over time to create a smooth fade-in effect.
+     * @type {number}
+     * @private
+     */
+    private imageFadeInDelta;
+    /**
+     * Animates the cubemap image fading in.
+     * This method gradually increases the opacity of the cubemap image to create a fade-in effect.
+     * @private
+     */
+    private animateIn;
+    /**
+     * Animates the cubemap image fading out.
+     * This method gradually decreases the opacity of the cubemap image to create a fade-out effect.
+     * @returns {Promise<void>} A promise that resolves when the animation is complete.
+     * @private
+     */
+    private animateOut;
+    setAnimationActive(active: boolean): void;
+    /**
+     * Renders the cubemap layer to the WebGL context.
+     * This method is called internally during the rendering phase of the map.
+     *
+     * @param {WebGLRenderingContext | WebGL2RenderingContext} gl - The WebGL context used for rendering.
+     * @param {CustomRenderMethodInput} _options - Additional options for the render method.
+     * @throws Error if the map, cubemap, or texture is undefined.
+     */
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, _options: CustomRenderMethodInput): void;
+    private setBgColor;
+    /**
+     * Returns the current configuration options for the cubemap layer.
+     * @returns {CubemapLayerConstructorOptions} The current configuration options.
+     */
+    getConfig(): CubemapLayerConstructorOptions;
+    /**
+     * Checks if the cubemap needs to be updated based on the provided specification.
+     *
+     * @param {CubemapDefinition} spec - The cubemap specification to compare with the current cubemap.
+     * @returns {boolean} True if the cubemap needs to be updated, false otherwise.
+     */
+    shouldUpdate(newSpec?: CubemapDefinition | boolean): boolean;
+    private setCubemapFaces;
+    /**
+     * Sets the cubemap for the layer based on the provided definition.
+     * This method updates the cubemap faces, background color, and triggers a repaint of the map.
+     *
+     * @param {CubemapDefinition} cubemap - The cubemap definition containing faces, preset, path, or color.
+     * @returns {Promise<void>} A promise that resolves when the cubemap is set and the map is updated.
+     * @remarks
+     * This method checks if the provided cubemap definition has a color, and if so, it updates the background color.
+     * It also checks if the faces definition has changed compared to the current one,
+     * and if so, it updates the cubemap faces.
+     * Finally, it calls `updateCubemap` to apply the changes and trigger a repaint of the map.
+     */
+    setCubemap(spec: CubemapDefinition | boolean): Promise<void>;
+    /**
+     * Shows the cubemap layer by setting its visibility to "visible".
+     * This method is used to make the cubemap layer visible on the map.
+     */
+    show(): void;
+    /**
+     * Hides the cubemap layer by setting its visibility to "none".
+     * This method is used to remove the cubemap layer from the map without deleting it.
+     */
+    hide(): void;
+}
+export declare function validateSpaceSpecification(space?: CubemapDefinition | boolean): boolean;
+export { CubemapLayer };

package/dist/src/custom-layers/CubemapLayer/constants.d.ts

@@ -0,0 +1,3 @@
+declare const VERTICES: number[];
+declare const INDICES: number[];
+export { VERTICES, INDICES };

package/dist/src/custom-layers/CubemapLayer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CubemapLayer';
+export * from './types';

package/dist/src/custom-layers/CubemapLayer/loadCubemapTexture.d.ts

@@ -0,0 +1,43 @@
+import { CubemapFaces } from './types';
+type WebGLCtx = WebGLRenderingContext | WebGL2RenderingContext;
+interface LoadCubemapTextureOptions {
+    gl: WebGLCtx;
+    faces?: CubemapFaces;
+    onReady: (texture: WebGLTexture, images?: HTMLImageElement[]) => void;
+    forceRefresh?: boolean;
+}
+export declare function deleteMemoizedTexture(gl: WebGLCtx): void;
+/**
+ * Loads a cubemap texture from a set of image URLs.
+ *
+ * This function creates and configures a WebGL cubemap texture from a set of images.
+ * It memoizes the created texture to avoid redundant loading of the same faces,
+ * unless the `forceRefresh` flag is set.
+ *
+ * @param {Object} options - The options object.
+ * @param {WebGLRenderingContext | WebGL2RenderingContext} options.gl - The WebGL rendering context.
+ * @param {CubemapFaces} options.faces - An object containing URLs for each face of the cubemap.
+ *                                        Must contain exactly 6 faces.
+ * @param {Function} [options.onReady] - Optional callback function to be called when all faces are loaded.
+ * @param {boolean} [options.forceRefresh] - If true, forces creation of a new texture instead of returning the memoized one.
+ *
+ * @returns {WebGLTexture | undefined} The created WebGL cubemap texture, or undefined if there was an error.
+ *
+ * @see {@link facesKey}
+ * @see {@link memoizedReturnValue}
+ * @example
+ * const texture = loadCubemapTexture({
+ *   gl: webglContext,
+ *   faces: {
+ *     px: 'right.jpg',
+ *     nx: 'left.jpg',
+ *     py: 'top.jpg',
+ *     ny: 'bottom.jpg',
+ *     pz: 'front.jpg',
+ *     nz: 'back.jpg'
+ *   },
+ *   onReady: () => console.log('Cubemap loaded')
+ * });
+ */
+export declare function loadCubemapTexture({ gl, faces, onReady, forceRefresh }: LoadCubemapTextureOptions): void;
+export {};