@mappable-world/mappable-types 0.0.16 → 0.0.17

package/modules/types.d.ts

@@ -4,6 +4,5 @@ declare module "../import" {
         (pkg: "@mappable-world/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
         (pkg: "@mappable-world/mappable-reactify"): Promise<typeof import("../reactify")>;
         (pkg: "@mappable-world/mappable-vuefy"): Promise<typeof import("./vuefy")>;
-        (pkg: "@mappable-world/mappable-analytics"): Promise<typeof import("./analytics")>;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.16",
+    "version": "0.0.17",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",

package/modules/analytics/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./src/MMapDataAnalyticsLayer/MMapDataAnalyticsLayer";
-export * from "./src/MMapHeatmapLayer/MMapHeatmapLayer";
-export * from "./src/MMapGeoJsonLayer/MMapGeoJsonLayer";
-export * from "./src/DataProviders";

package/modules/analytics/src/DataProviders/BaseDataProvider.d.ts

@@ -1,40 +0,0 @@
-import Flatbush from "flatbush";
-import type { LngLat, Projection, WorldCoordinates } from "../../../../common/types";
-import type { GeoJSONFeature } from "../interface";
-export interface BaseDataProviderOptions<Feature extends GeoJSONFeature> {
-    filter(item: Feature, tx: number, ty: number, tz: number): boolean;
-    getFeatures: (json: unknown) => Feature[];
-    convert: (item: unknown) => Feature;
-    getBound(item: Feature): [
-        LngLat,
-        LngLat
-    ];
-}
-export declare abstract class BaseDataProvider<Feature extends GeoJSONFeature, Options extends BaseDataProviderOptions<Feature> = BaseDataProviderOptions<Feature>> {
-    protected __version: number;
-    protected __flatbush: Flatbush[];
-    protected __options: Options;
-    protected readonly __projection: Projection;
-    constructor(projection: Projection, options?: Partial<BaseDataProviderOptions<Feature>>);
-    protected __waitFirstChunk: Promise<void>;
-    protected __data: GeoJSONFeature[][];
-    fetchTile(tx: number, ty: number, tz: number, signal: AbortSignal): Promise<{
-        data: GeoJSONFeature[];
-        total: number;
-        version: number;
-    }>;
-    on(event: "update", handler: () => void): void;
-    off(event: "update", handler: () => void): void;
-    private readonly __eventHandlers;
-    protected _emit(event: "update"): void;
-    protected __isLoading: boolean;
-    protected _clusterize(part: GeoJSONFeature[]): Promise<void>;
-}
-/**
- * Convert tile coordinates to special world coordinates.
- * It's not a real some standard, but it's used in mappable.
- */
-export declare function tileToWorld(tx: number, ty: number, tz: number): [
-    WorldCoordinates,
-    WorldCoordinates
-];

package/modules/analytics/src/DataProviders/JSONDataProvider.d.ts

@@ -1,27 +0,0 @@
-import type { Projection } from "../../../../common/types";
-import type { GeoJSONFeature } from "../interface";
-import { BaseDataProvider } from "./BaseDataProvider";
-/**
- * Loads GeoJSON data from a URL. The data is expected to be in the GeoJSON format.
- * But you can specify the `convert` option to convert the data to the GeoJSON format.
- * ```javascript
- * const {JSONDataProvider} = await mappable.import('@mappable-world/mappable-analytics');
- * const dataProvider = new JSONDataProvider('https://example.com/data.json', map.projection, {
- *   convert: (item) => item as GeoJSONFeature,
- * });
- * dataProvider.load();
- * const layer = new MMapGeoJsonLayer({
- *    dataProvider,
- *  });
- * ```
- * @param url - URL to load the data from.
- */
-export declare class JSONDataProvider<Feature extends GeoJSONFeature = GeoJSONFeature> extends BaseDataProvider<Feature> {
-    readonly url: string;
-    constructor(url: string, projection: Projection, options?: {});
-    /**
-         * Starts loading the data from the URL.
-         */
-    load(): Promise<void> | undefined;
-    private __loadGeoJSON;
-}

package/modules/analytics/src/DataProviders/JSONLinesDataProvider.d.ts

@@ -1,41 +0,0 @@
-import type { Projection } from "../../../../common/types";
-import type { GeoJSONFeature } from "../interface";
-import { BaseDataProvider, type BaseDataProviderOptions } from "./BaseDataProvider";
-interface JSONLinesDataProviderDataProviderOptions<Feature extends GeoJSONFeature = GeoJSONFeature> extends BaseDataProviderOptions<Feature> {
-    chunkSize: number;
-    total: number;
-    progress: (progress: number) => void;
-    tickTimeout: number;
-    convert: (item: unknown) => Feature;
-}
-/**
- * Loads GeoJSON lines data from a URL. The data is expected to be in the JSON lines format.
- * Each line should be a valid JSON object.
- * But you can specify the `convert` option to convert the data to the GeoJSON format.
- * ```javascript
- * const {JSONLinesDataProvider} = await mappable.import('@mappable-world/mappable-analytics');
- * const dataProvider = new JSONLinesDataProvider('https://example.com/data.json', map.projection, {
- *  chunkSize: 10000,
- *  total: 1500000,
- *  progress: (progress) => {
- *      console.log(progress);
- *  },
- *  convert: (item) => item as GeoJSONFeature,
- * });
- * dataProvider.load();
- * const layer = new MMapGeoJsonLayer({
- *  dataProvider,
- * });
- *  ```
- */
-export declare class JSONLinesDataProvider<Feature extends GeoJSONFeature = GeoJSONFeature> extends BaseDataProvider<Feature, JSONLinesDataProviderDataProviderOptions<Feature>> {
-    readonly url: string;
-    constructor(url: string, projection: Projection, options?: Partial<JSONLinesDataProviderDataProviderOptions<Feature>>);
-    /**
-         * Starts loading the data from the URL.
-         */
-    load(): Promise<number> | undefined;
-    private __loadByChunks;
-    private __parseJSONLines;
-}
-export {};

package/modules/analytics/src/DataProviders/StaticDataProvider.d.ts

@@ -1,18 +0,0 @@
-import type { Projection } from "../../../../common/types";
-import type { GeoJSONFeature } from "../interface";
-import { BaseDataProvider } from "./BaseDataProvider";
-/**
- * Static data provider. The data for the provider is set in the constructor and can be changed using the `setData` method.
- * ```javascript
- * const {StaticDataProvider} = await mappable.import('@mappable-world/mappable-analytics');
- * const dataProvider = new StaticDataProvider(data, map.projection);
- * const layer = new MMapGeoJsonLayer({
- *   dataProvider,
- * });
- * dataProvider.setData(newData);
- * ```
- */
-export declare class StaticDataProvider<Feature extends GeoJSONFeature = GeoJSONFeature> extends BaseDataProvider<Feature> {
-    constructor(data: unknown, projection: Projection);
-    setData(data: unknown): void;
-}

package/modules/analytics/src/DataProviders/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./BaseDataProvider";
-export * from "./JSONDataProvider";
-export * from "./JSONLinesDataProvider";
-export * from "./StaticDataProvider";

package/modules/analytics/src/DataProviders/utils/loadByChunk.d.ts

@@ -1 +0,0 @@
-export declare function loadNewChunk(url: string, size?: number): AsyncGenerator<string[], void, unknown>;

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

@@ -1,90 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,5 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-/**
- * 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

@@ -1,49 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,3 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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 };

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

@@ -1,8 +0,0 @@
-declare module '*.frag' {
-    const content: string;
-    export default content;
-}
-declare module '*.vert' {
-    const content: string;
-    export default content;
-}