@mappable-world/mappable-types 0.0.14 → 0.0.16

package/modules/analytics/src/MMapDataAnalyticsLayer/MMapDataAnalyticsLayer.d.ts

@@ -0,0 +1,90 @@
+import type { LngLat, VectorLayerImplementationConstructor, Projection, TileCoordinates } from "../../../../common/types";
+import type { DomEventHandler, MMapLayerProps } from "../../../../imperative";
+import type { GlTile } from "../MMapDefaultVectorLayerImplementation/MMapDefaultVectorLayerImplementation";
+interface MMapDataAnalyticsLayerProps<ItemType> extends Omit<MMapLayerProps, "type" | "implementation" | "source"> {
+    tileSize?: number;
+    hitTestTimeout?: number;
+    tileReconciliationTimeout?: number;
+    tileRemoveTimeout?: number;
+    /**
+         * @param itemId - result of getUniqueId
+         */
+    onMouseEnterItem?: (itemId: unknown, coordinates: LngLat) => void;
+    onMouseLeaveItem?: (itemId: unknown, coordinates: LngLat) => void;
+    onClickItem?: (itemId: unknown, coordinates: LngLat) => void;
+    dataProvider?: {
+        off?(event: "update", clb: Function): void;
+        on?(event: "update", clb: Function): void;
+        fetchTile(tx: number, ty: number, tz: number, signal: AbortSignal): Promise<{
+            data: ItemType[];
+            total?: number;
+            version?: number | string;
+        }>;
+    };
+    /**
+         * Unique data for identify item. it can be id, or object
+         * @param item
+         */
+    getUniqueId(item: ItemType): string | number | object;
+}
+export interface AnalyticsImplProxy<OutputData, Props> {
+    props: () => Props;
+    projection: () => Projection;
+    requestRender: () => void;
+    getIdByScreen?: (coordinates: {
+        x: number;
+        y: number;
+    }) => unknown | undefined;
+    getUniqueId: (item: OutputData) => string | number | object;
+    getTiles: () => GlTile[];
+    convertData: (tileCoordinates: TileCoordinates, zoom: number, data: unknown, signal: AbortSignal) => Promise<unknown>;
+    implReady: {
+        promise: Promise<void>;
+        resolve: () => void;
+    };
+}
+declare const defaultLayerProps: {
+    tileSize: number;
+    hitTestTimeout: number;
+    tileReconciliationTimeout: number;
+    tileRemoveTimeout: number;
+};
+export type DefaultProps = typeof defaultLayerProps;
+export declare abstract class MMapDataAnalyticsLayer<ItemType, Props, Default extends DefaultProps> extends mappable.MMapComplexEntity<MMapDataAnalyticsLayerProps<ItemType> & Props, Default> {
+    PROPS: MMapDataAnalyticsLayerProps<ItemType> & Props;
+    static defaultProps: {
+        tileSize: number;
+        hitTestTimeout: number;
+        tileReconciliationTimeout: number;
+        tileRemoveTimeout: number;
+    };
+    private __virtualTileDataSource;
+    private readonly __virtualTileLayer;
+    private readonly __vectorLayer;
+    private readonly __listener;
+    private __dataCache;
+    private __tileCache;
+    private __tiles;
+    PROXY: AnalyticsImplProxy<ItemType, MMapDataAnalyticsLayerProps<ItemType> & Props>;
+    protected __proxy: this["PROXY"];
+    private __mapInAction;
+    constructor(props: MMapDataAnalyticsLayerProps<ItemType> & Props);
+    protected abstract _getImplementation(): VectorLayerImplementationConstructor;
+    protected _onAttach(): void;
+    protected _onUpdate(props: Partial<this["PROPS"]>, oldProps: Partial<this["PROPS"]>): void;
+    protected _onDetach(): void;
+    protected _stateVersion: number;
+    protected _requestTileRecalculation(): void;
+    private _requestTileRecalculationImd;
+    private __previousSelected;
+    protected _onMouseMoveHitTest: DomEventHandler;
+    private __removedTiles;
+    private __requestRemoveTiles;
+    private __requestRemoveTilesImd;
+    /**
+         * TODO The concept of virtual layers is now used. It's redundant, MAPSAPI-17151
+         * @private
+         */
+    private _getRasterOptions;
+}
+export {};

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/MMapDefaultVectorLayerImplementation.d.ts

@@ -0,0 +1,95 @@
+import type { TileCoordinates, VectorLayerImplementation, VectorLayerImplementationRenderProps, WorldCoordinates } from "../../../../common/types";
+import type { DefaultProps, MMapDataAnalyticsLayer } from "../MMapDataAnalyticsLayer/MMapDataAnalyticsLayer";
+import { MemoryManager } from "./utils/memoryManager";
+import { Atlas } from "./utils/atlas";
+import { FrameBuffer } from "./utils/frameBuffer";
+export interface Program {
+    program: WebGLProgram;
+    uniforms: Record<string, WebGLUniformLocation>;
+    locations: Record<string, number>;
+    shaders: {
+        vertex: WebGLShader;
+        fragment: WebGLShader;
+    };
+}
+type RenderWorldsProps = VectorLayerImplementationRenderProps;
+export type RenderWorldProps = Omit<RenderWorldsProps, "worlds"> & {
+    world: RenderWorldsProps["worlds"][0];
+};
+export interface AnalyticsRenderUnit {
+    program: Program;
+    setup?: (this: MMapDefaultVectorLayerImplementation, props: RenderWorldProps) => void;
+    beforeRender?: (this: MMapDefaultVectorLayerImplementation, props: RenderWorldProps) => void;
+    render: (this: MMapDefaultVectorLayerImplementation, props: RenderWorldProps) => void;
+    afterRender?: (this: MMapDefaultVectorLayerImplementation, props: RenderWorldProps) => void;
+    textures?: Record<string, WebGLTexture>;
+}
+export interface BufferStore {
+    bufferType: number;
+    bufferLength: number;
+    buffer: WebGLBuffer;
+    drawType: number;
+    valueType: number;
+    size: number;
+    attribute: number;
+    data: Float32Array | Uint32Array | null;
+}
+export interface GlTile {
+    readonly coordinates: TileCoordinates;
+    readonly tileBound: [
+        WorldCoordinates,
+        WorldCoordinates
+    ];
+    readonly zoom: number;
+    setup?(): void;
+    render(): void;
+    destroy(): void;
+    getObjectByIndex(id: number): unknown;
+}
+/**
+ * Size of hit test texture
+ */
+export declare const HIT_SIZE = 256;
+export declare abstract class MMapDefaultVectorLayerImplementation implements VectorLayerImplementation {
+    readonly _proxy: MMapDataAnalyticsLayer<unknown, unknown, DefaultProps>["PROXY"];
+    readonly gl: WebGLRenderingContext;
+    readonly options: {
+        requestRender: () => void;
+    };
+    protected readonly _atlas: Atlas;
+    protected readonly _memoryManager: MemoryManager;
+    protected _frameBuffers: Record<"main" | "hit" | string, FrameBuffer>;
+    protected _renderUnits: Record<"main" | string, AnalyticsRenderUnit>;
+    protected _extVertexArrayObject: OES_vertex_array_object;
+    protected _angleExt: ANGLE_instanced_arrays;
+    protected _indexUnitExt: OES_element_index_uint;
+    protected _isReadyForRender: boolean;
+    protected abstract _createRenderUnits(): Record<"main" | string, AnalyticsRenderUnit>;
+    protected abstract _renderWorld(props: RenderWorldProps): void;
+    constructor(_proxy: MMapDataAnalyticsLayer<unknown, unknown, DefaultProps>["PROXY"], gl: WebGLRenderingContext, options: {
+        requestRender: () => void;
+    });
+    private __selectedId;
+    protected set _selectedId(value: number);
+    protected get _selectedId(): number;
+    /**
+         * Read pixel from hit test frame buffer and find object by id
+         */
+    private __getIdByScreen;
+    destroy(): void;
+    protected _createBuffer(location: number, data: number[] | Float32Array | Uint32Array, size?: number): BufferStore;
+    protected _enableAttributeBuffer(attr: BufferStore): void;
+    private __bindBufferData;
+    private _renderRequested;
+    protected _requestLayerRender(): void;
+    render(props: RenderWorldsProps): {
+        color: WebGLTexture;
+        depth: WebGLTexture;
+    };
+    protected _renderUnit(unit: AnalyticsRenderUnit, props: RenderWorldProps): void;
+    private __renderWorlds;
+    protected _renderTiles(tiles: GlTile[], cb?: (tile: GlTile) => void): void;
+    protected __clearGlobalState(): void;
+    protected _convertData(tileCoordinates: TileCoordinates, zoom: number, data: unknown, _: AbortSignal): Promise<unknown>;
+}
+export * from "./utils/utils";

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/atlas.d.ts

@@ -0,0 +1,27 @@
+import type { PixelCoordinates } from "../../../../../common/types";
+export interface IconResource {
+    url: string;
+    size: PixelCoordinates;
+    offset: PixelCoordinates;
+}
+/**
+ * Texture atlas for storing icons.
+ * ```js
+ * const atlas = new Atlas(gl, 1024, 64);
+ * const icon = atlas.loadAndGetOffset('icon.png');
+ * console.log(icon); // {url: 'icon.png', size: {x: 0.5, y: 0.5}, offset: {x: 0, y: 0}}
+ * ```
+ */
+export declare class Atlas {
+    private readonly gl;
+    private readonly size;
+    private readonly iconSize;
+    readonly texture: WebGLTexture;
+    private readonly __cells;
+    constructor(gl: WebGLRenderingContext, size: number, iconSize: number);
+    private __isDestroyed;
+    destroy(): void;
+    private __cache;
+    loadAndGetOffset(urlOrImage: string): IconResource;
+    private __putImage;
+}

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/calculateNormalsForVertices.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Calculates normals for vertices. Used for calculating normals for every triangle.
+ * Normals are used for lighting.
+ */
+export declare function calculateNormalsForVertices(vertices: Float32Array, size: number, normals: Float32Array, featureVertexOffset: number, vertexCount: number): void;

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/frameBuffer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Encapsulate work with WebGL frame buffer object
+ */
+export declare class FrameBuffer {
+    private gl;
+    private options;
+    readonly color: WebGLTexture;
+    readonly depth: WebGLTexture;
+    private readonly __buffer;
+    private readonly __size;
+    constructor(gl: WebGLRenderingContext, options?: {
+        w?: number;
+        h?: number;
+        depth?: boolean;
+    });
+    destroy(): void;
+    clear(): this;
+    private static __current;
+    static bind(frameBuffer: FrameBuffer): void;
+    static unbind(frameBuffer: FrameBuffer): void;
+    static unbindCurrent(gl: WebGLRenderingContext): void;
+    private __needReadPixel;
+    private __pixelStore;
+    /**
+         * FIXME Optimize read pixel MAPSAPI-17272
+         */
+    readPixel(rx: number, ry: number): Uint8Array;
+    resize(w: number, h?: number): this;
+}

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/memoryManager.d.ts

@@ -0,0 +1,49 @@
+type ArrayType = {
+    length: number;
+    type: typeof Float32Array | typeof Uint32Array;
+};
+/**
+ * Memory manager for managing memory allocation for typed arrays.
+ * ```js
+ * const memoryManager = new MemoryManager(1024, 10); // 1024 bytes per buffer, 10 buffers max
+ * const [array] = await memoryManager.allocates([{length: 2, type: Float32Array}]); // 2 elements, 4 bytes each
+ * array[0] = 1;
+ * const newArray = memoryManager.resize(array, 1);
+ * memoryManager.free(newArray);
+ * ```
+ */
+export declare class MemoryManager {
+    private readonly allocateBufferSize;
+    private readonly maxBuffersCount;
+    private __buffers;
+    private __allocatedArrays;
+    private __waitFreeMemory;
+    constructor(allocateBufferSize: number, maxBuffersCount: number);
+    destroy(): void;
+    /**
+         * Asynchronously allocates memory for an arrays of the specified length and type.
+         * Allocate memory only if there is enough free memory for all requested arrays.
+         */
+    allocateArrays<T extends ArrayType[]>(requestedArrays: [
+        ...T
+    ], signal?: AbortSignal): Promise<{
+        [K in keyof T]: InstanceType<T[K]["type"]>;
+    }>;
+    private __canAllocate;
+    /**
+         * Synchronously allocates memory for an array of the specified length and type.
+         */
+    private __allocate;
+    /**
+         * Synchronously resizes the memory allocated for the array. Allow only shrinking the array.
+         */
+    resize<T extends Float32Array | Uint32Array>(array: T, newSize: number): T;
+    /**
+         * Synchronously frees the memory allocated for the array.
+         */
+    free(array: Float32Array | Uint32Array): void;
+    private __createNewBigBuffer;
+    private __makeTypedArray;
+    private __findHole;
+}
+export {};

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/program.d.ts

@@ -0,0 +1,10 @@
+import type { Program } from "../MMapDefaultVectorLayerImplementation";
+interface ProgramOptions {
+    vertexShader: string;
+    fragmentShader: string;
+    uniforms: string[];
+    attributes: string[];
+    setupBeforeRender?: (program: Program) => void;
+}
+export declare function createProgram(gl: WebGLRenderingContext, options: ProgramOptions): Program;
+export {};

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/scheduleManager.d.ts

@@ -0,0 +1,44 @@
+interface AsyncRunnerOptions {
+    timeout: number;
+    minCountPerFrame: number;
+}
+interface AsyncRunnerEvent {
+    timeRemaining(): DOMHighResTimeStamp;
+}
+interface AsyncRunner<Opt extends Partial<AsyncRunnerOptions>> {
+    (callback: (e: AsyncRunnerEvent) => unknown, options?: Opt): void;
+}
+/**
+ * The class is designed to schedule tasks for execution in the browser's event loop.
+ * When `asyncRunner` fires, it launches `__runner`, which executes tasks from the queue.
+ * Tasks can be added to the queue using the add method.
+ * Tasks will be completed until all tasks are completed or until the time allotted for the chunk is completed.
+ * There is also a limit on the number of tasks that can be completed at one time.
+ */
+declare class ScheduleTaskManager {
+    private readonly asyncRunner;
+    private readonly __options;
+    private readonly __taskIterator;
+    private readonly __tasks;
+    private __runnerRequested;
+    constructor(asyncRunner?: AsyncRunner<AsyncScheduleOptions>, options?: Partial<AsyncScheduleOptions>);
+    /**
+         * Add a task to the queue.
+         * ```javascript
+         * const manager = new ScheduleTaskManager();
+         * const result = await manager.add([1, 2, 3], (item) => item * 2, new AbortController().signal);
+         * console.log(result); // [2, 4, 6]
+         * ```
+         */
+    add<I, O>(part: I[], processor: (item: I, index: number) => O, signal?: AbortSignal): Promise<O[]>;
+    private __runner;
+    private __getNewTask;
+    private __hasNewTask;
+    private __requestRunner;
+}
+interface AsyncScheduleOptions extends AsyncRunnerOptions {
+    remainingTime: number;
+    asyncStarter: (cb: Function) => unknown;
+}
+export declare const scheduleManager: ScheduleTaskManager;
+export {};

package/modules/analytics/src/MMapDefaultVectorLayerImplementation/utils/utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * We use only rgb since alpha does not fit into highp float
+ */
+export declare function getColorId(colorComponents: [
+    number,
+    number,
+    number,
+    number
+] | Uint8Array): number;
+export declare function isPowerOf2(value: number): boolean;
+export declare function checkRequiredExtensions(supportedExtensions: string[]): void;
+/**
+ * Generates a new ID for baking to color in a hit test
+ */
+export declare function getIncrementalId(): number;
+/**
+ * Parse color from string to [r, g, b, a]
+ * Allow formats #RRGGBB, #RRGGBBAA, rgb(r, g, b), rgba(r, g, b, a)
+ * @returns [r, g, b, a] - a is in range [0, 1], r, g, b in range [0, 255]
+ */
+export declare function parseColor(input: string | [
+    number,
+    number,
+    number
+] | [
+    number,
+    number,
+    number,
+    number
+]): [
+    number,
+    number,
+    number,
+    number
+];

package/modules/analytics/src/MMapGeoJsonLayer/MMapGeoJsonImplementation.d.ts

@@ -0,0 +1,3 @@
+import type { VectorLayerImplementationConstructor } from "../../../../common/types";
+import type { MMapGeoJsonLayer } from "../MMapGeoJsonLayer/MMapGeoJsonLayer";
+export declare function getImpl(proxy: MMapGeoJsonLayer["PROXY"]): VectorLayerImplementationConstructor;

package/modules/analytics/src/MMapGeoJsonLayer/MMapGeoJsonLayer.d.ts

@@ -0,0 +1,64 @@
+import type { LngLat, VectorLayerImplementationConstructor } from "../../../..";
+import { type DefaultProps, MMapDataAnalyticsLayer } from "../MMapDataAnalyticsLayer/MMapDataAnalyticsLayer";
+import type { GeoJSONFeature, GeoJsonLineStringFeature, GeoJsonPointFeature, GeoJsonPolygonFeature, LineStringDrawingStyle, PointDrawingStyle, PolygonDrawingStyle } from "../interface";
+interface MMapGeoJsonLayerProps {
+    opacity?: number;
+    extruded?: boolean;
+    extrudeMultiplier?: number;
+    wireframe?: boolean | {
+        /**
+                 * Width of the wireframe. In pixels.
+                 */
+        width: number;
+        /**
+                 * Color of the wireframe
+                 * @default #808080
+                 */
+        color: string;
+    };
+    lightPosition?: LngLat;
+    getDrawingStyle(f: GeoJsonPolygonFeature): PolygonDrawingStyle;
+    getDrawingStyle(f: GeoJsonLineStringFeature): LineStringDrawingStyle;
+    getDrawingStyle(f: GeoJsonPointFeature): PointDrawingStyle;
+    getDrawingStyle(f: GeoJSONFeature): PolygonDrawingStyle | LineStringDrawingStyle | PointDrawingStyle;
+}
+declare const defaultProps: {
+    opacity: number;
+    extruded: boolean;
+    extrudeMultiplier: number;
+    wireframe: boolean;
+    lightPosition: number[];
+    getDrawingStyle: (_: GeoJSONFeature) => {
+        fill: string;
+        elevation: number;
+        dash: number;
+        zOffset: number;
+        opacity: number;
+        width: number;
+        iconSize: number;
+        simplificationRate: number;
+    };
+};
+type DefaultPropsGeo = typeof defaultProps;
+export declare class MMapGeoJsonLayer extends MMapDataAnalyticsLayer<GeoJSONFeature, MMapGeoJsonLayerProps, DefaultPropsGeo & DefaultProps> {
+    static defaultPropsJson: {
+        opacity: number;
+        extruded: boolean;
+        extrudeMultiplier: number;
+        wireframe: boolean;
+        lightPosition: number[];
+        getDrawingStyle: (_: GeoJSONFeature) => {
+            fill: string;
+            elevation: number;
+            dash: number;
+            zOffset: number;
+            opacity: number;
+            width: number;
+            iconSize: number;
+            simplificationRate: number;
+        };
+    };
+    protected _getImplementation(): VectorLayerImplementationConstructor;
+    protected _onUpdate(props: Partial<this["PROPS"]>, oldProps: Partial<this["PROPS"]>): void;
+}
+export {};

package/modules/analytics/src/MMapGeoJsonLayer/renders/geojson.d.ts

@@ -0,0 +1,3 @@
+import { type MMapDefaultVectorLayerImplementation, type AnalyticsRenderUnit } from "../../MMapDefaultVectorLayerImplementation/MMapDefaultVectorLayerImplementation";
+import type { MMapGeoJsonLayer } from "../MMapGeoJsonLayer";
+export declare function createGeoJsonRenderUnit(this: MMapDefaultVectorLayerImplementation, proxy: MMapGeoJsonLayer["PROXY"]): AnalyticsRenderUnit;

package/modules/analytics/src/MMapGeoJsonLayer/utils/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Value to compare floating point numbers with zero
+ */
+export declare const EPSILON = 1e-16;
+/**
+ * Maximum number of features to process tile clip geometry
+ */
+export declare const CLIP_GEOMETRY_BY_COUNT = 1000;
+/**
+ * Number of components per vertex (x,y,z)
+ */
+export declare const COMPONENT_PER_VERTEX = 3;
+/**
+ * Number of vertices per edge. 2 triangles with 3 vertices each. 2 vertices are shared
+ * [p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p2.x, p2.y, p3.x, p3.y, p4.x, p4.y]
+ */
+export declare const VERTEX_PER_EDGE = 6;

package/modules/analytics/src/MMapGeoJsonLayer/utils/generateGeometryBuffers.d.ts

@@ -0,0 +1,17 @@
+import type { WorldCoordinates } from "../../../../../common/types";
+import type { GeoJSONFeature } from "../../interface";
+import type { MemoryManager } from "../../MMapDefaultVectorLayerImplementation/utils/memoryManager";
+import type { Atlas } from "../../MMapDefaultVectorLayerImplementation/utils/atlas";
+import { MMapGeoJsonLayer } from "../MMapGeoJsonLayer";
+export interface ConversionResult {
+    vertices: Float32Array;
+    barycentric: Float32Array;
+    normals: Float32Array;
+    colors: Float32Array;
+    ids: Float32Array;
+    texCoord: Float32Array;
+}
+export declare function generateGeometryBuffers(features: GeoJSONFeature[], proxy: MMapGeoJsonLayer["PROXY"], memoryManager: MemoryManager, atlas: Atlas, signal: AbortSignal, tileBounds: [
+    WorldCoordinates,
+    WorldCoordinates
+], mapId: Map<number, unknown>, mapIid: Map<unknown, number>, zoom: number): Promise<ConversionResult>;

package/modules/analytics/src/MMapGeoJsonLayer/utils/generateLineGeometry.d.ts

@@ -0,0 +1,6 @@
+import type { GenericLineStringGeometry, GenericProjection, LngLat, WorldCoordinates } from "../../../../../common/types";
+import type { LineStringDrawingStyle } from "../../interface";
+export declare function generateLineGeometry(geometry: GenericLineStringGeometry<LngLat>, projection: GenericProjection<LngLat>, style: Required<LineStringDrawingStyle>, needClipGeometry: boolean, tileBounds: [
+    WorldCoordinates,
+    WorldCoordinates
+], extruded: undefined | boolean, vertexCount: number, elevation: number, featureVertexOffset: number, texCoord: Float32Array, vertices: Float32Array, minZ: number, worldSimplificationRate: number): number;

package/modules/analytics/src/MMapGeoJsonLayer/utils/generatePointGeometry.d.ts

@@ -0,0 +1,4 @@
+import type { GenericPointGeometry, GenericProjection, LngLat } from "../../../../../common/types";
+import type { PointDrawingStyle } from "../../interface";
+import type { Atlas } from "../../MMapDefaultVectorLayerImplementation/utils/atlas";
+export declare function generatePointGeometry(projection: GenericProjection<LngLat>, geometry: GenericPointGeometry<LngLat>, style: PointDrawingStyle, vertices: Float32Array, featureVertexOffset: number, elevation: number, normals: Float32Array, atlas: Atlas, texCoord: Float32Array): number;

package/modules/analytics/src/MMapGeoJsonLayer/utils/generatePolygonGeometry.d.ts

@@ -0,0 +1,2 @@
+import type { GenericPolygonGeometry, GenericProjection, LngLat } from "../../../../../common/types";
+export declare function generatePolygonGeometry(geometry: GenericPolygonGeometry<LngLat>, projection: GenericProjection<LngLat>, vertexCount: number, extruded: undefined | boolean, featureVertexOffset: number, vertices: Float32Array, elevation: number, minZ: number, worldSimplificationRate: number): number;

package/modules/analytics/src/MMapGeoJsonLayer/utils/utils.d.ts

@@ -0,0 +1,37 @@
+import type { LngLat, Projection, Vec2, WorldCoordinates } from "../../../../../common/types";
+import type { GeoJSONFeature } from "../../interface";
+export type Rectangle = [
+    WorldCoordinates,
+    WorldCoordinates,
+    WorldCoordinates,
+    WorldCoordinates
+];
+/**
+ * Check if the given points form a ring
+ */
+export declare function isRing(points: WorldCoordinates[] | LngLat[]): boolean;
+/**
+ * Fill vertices for rectangle in the buffer by CW order
+ */
+export declare function fillVerticesForRectangle(vertices: Float32Array, offset: number, rect: Rectangle): void;
+/**
+ * Extrude the given ring to the given height
+ */
+export declare function extrudeSides(ring: WorldCoordinates[], vertices: Float32Array, offset: number, height: number, z: number): void;
+interface OffsetDescription {
+    offset: Vec2;
+    size: Vec2;
+}
+/**
+ * Set texture coordinates for the rectangle
+ */
+export declare function setTextureCoords(texCoord: Float32Array, offset: number, description: OffsetDescription): void;
+/**
+ * Calculate barycentric coordinates for triangles
+ */
+export declare function calculateBarycentric(barycentric: Float32Array, size: number, start: number, length: number): void;
+/**
+ * Convert meters to world coordinates
+ */
+export declare function meterToWorld(feature: GeoJSONFeature, projection: Projection): number;
+export {};

package/modules/analytics/src/MMapHeatmapLayer/MMapHeatmapLayer.d.ts

@@ -0,0 +1,38 @@
+import type { VectorLayerImplementationConstructor } from "../../../../common/types";
+import { type DefaultProps, MMapDataAnalyticsLayer } from "../MMapDataAnalyticsLayer/MMapDataAnalyticsLayer";
+import type { GeoJSONFeature, Gradient } from "../interface";
+interface MMapHeatmapLayerProps {
+    /** Function to get the weight of the feature. By default, the weight is 0.5. */
+    getWeight?: (f: GeoJSONFeature) => number;
+    /** Gradient for heat map display. By default, the standard gradient is used. */
+    gradient?: Gradient[];
+    zOffset?: number;
+    opacity?: number;
+    density?: number;
+    pointSize?: number;
+    blur?: number;
+    max?: number;
+}
+declare const defaultProps: {
+    getWeight: () => number;
+    density: number;
+    max: number;
+    pointSize: number;
+    blur: number;
+    zOffset: number;
+    opacity: number;
+};
+type DefaultPropsHeatmap = typeof defaultProps;
+export declare class MMapHeatmapLayer extends MMapDataAnalyticsLayer<GeoJSONFeature, MMapHeatmapLayerProps, DefaultPropsHeatmap & DefaultProps> {
+    static defaultPropsJson: {
+        getWeight: () => number;
+        density: number;
+        max: number;
+        pointSize: number;
+        blur: number;
+        zOffset: number;
+        opacity: number;
+    };
+    protected _getImplementation(): VectorLayerImplementationConstructor;
+}
+export {};

package/modules/analytics/src/MMapHeatmapLayer/MMapHeatmapLayerImplementation.d.ts

@@ -0,0 +1,3 @@
+import type { VectorLayerImplementationConstructor } from "../../../../common/types";
+import type { MMapHeatmapLayer } from "../MMapHeatmapLayer/MMapHeatmapLayer";
+export declare function getHeatmapImpl(proxy: MMapHeatmapLayer["PROXY"]): VectorLayerImplementationConstructor;

package/modules/analytics/src/MMapHeatmapLayer/renders/gradient.d.ts

@@ -0,0 +1,3 @@
+import type { MMapDefaultVectorLayerImplementation, AnalyticsRenderUnit } from "../../MMapDefaultVectorLayerImplementation/MMapDefaultVectorLayerImplementation";
+import type { MMapHeatmapLayer } from "../MMapHeatmapLayer";
+export declare function createGradientRenderUnit(this: MMapDefaultVectorLayerImplementation, proxy: MMapHeatmapLayer["PROXY"]): AnalyticsRenderUnit;

package/modules/analytics/src/MMapHeatmapLayer/renders/heatmap.d.ts

@@ -0,0 +1,3 @@
+import { type MMapDefaultVectorLayerImplementation, type AnalyticsRenderUnit } from "../../MMapDefaultVectorLayerImplementation/MMapDefaultVectorLayerImplementation";
+import type { MMapHeatmapLayer } from "../MMapHeatmapLayer";
+export declare function createHeatmapRenderUnit(this: MMapDefaultVectorLayerImplementation, proxy: MMapHeatmapLayer["PROXY"]): AnalyticsRenderUnit;

package/modules/analytics/src/interface.d.ts

@@ -0,0 +1,42 @@
+import type { GenericFeature, GenericLineStringGeometry, GenericPointGeometry, GenericPolygonGeometry, LngLat } from "../../../common/types";
+type Color = string;
+interface GeoJsonLineStringFeature extends GenericFeature<LngLat> {
+    geometry: GenericLineStringGeometry<LngLat>;
+}
+interface GeoJsonPolygonFeature extends GenericFeature<LngLat> {
+    geometry: GenericPolygonGeometry<LngLat>;
+}
+interface GeoJsonPointFeature extends GenericFeature<LngLat> {
+    geometry: GenericPointGeometry<LngLat>;
+}
+interface PolygonDrawingStyle {
+    fill?: Color;
+    elevation?: number;
+    zOffset?: number;
+    simplificationRate?: number;
+}
+interface LineStringDrawingStyle {
+    fill?: Color;
+    width?: number;
+    elevation?: number;
+    dash?: number | [
+        number,
+        number
+    ];
+    zOffset?: number;
+    simplificationRate?: number;
+}
+interface PointDrawingStyle {
+    icon?: string;
+    iconSize?: number;
+    elevation?: number;
+    zOffset?: number;
+    fill?: string;
+}
+type GeoJSONFeature = GeoJsonLineStringFeature | GeoJsonPolygonFeature | GeoJsonPointFeature;
+type FeatureDrawingStyle = PolygonDrawingStyle | LineStringDrawingStyle | PointDrawingStyle;
+interface Gradient {
+    color: Color;
+    offset: number;
+}
+export type { GeoJSONFeature, GeoJsonLineStringFeature, GeoJsonPolygonFeature, GeoJsonPointFeature, FeatureDrawingStyle, PolygonDrawingStyle, LineStringDrawingStyle, PointDrawingStyle, Gradient };