@mappable-world/mappable-types 0.0.14 → 0.0.16

package/common/types/data-source-description.d.ts

@@ -41,10 +41,17 @@ interface RenderedHotspot {
     readonly geometry: GenericGeometry<PixelCoordinates>;
 }
 type Hotspot = WorldHotspot | RenderedHotspot;
-interface FetchedTile {
+interface FetchedCommonTile {
+    destroy?(): void;
+}
+interface FetchedRasterTile extends FetchedCommonTile {
     image: HTMLImageElement | HTMLCanvasElement | ImageBitmap;
 }
-type FetchTileFunction = (x: number, y: number, z: number, scale: number, signal: AbortSignal) => Promise<FetchedTile>;
+/**
+ * @deprecated Use FetchedRasterTile instead
+ */
+type FetchedTile = FetchedRasterTile;
+type FetchTileFunction = (x: number, y: number, z: number, scale: number, signal: AbortSignal) => Promise<FetchedCommonTile | FetchedRasterTile>;
 type ComposeTileUrlFunction = (x: number, y: number, z: number, scale: number, signal: AbortSignal) => string;
 /**
  * Provides hotspots for given tile coordinates and zoom.
@@ -127,12 +134,14 @@ interface VectorTileDataSourceDescription {
     tileCacheSize?: number;
     richModelCacheSize?: number;
     richModelEnabled?: boolean;
+    richPointEnabled?: boolean;
     allObjectsInteractive?: boolean;
     /** Forces tiles to wait for the icons, disables hiding icons by zoom diff */
     iconsOnlyTiles?: boolean;
+    richModelDecoderWorkerUrl?: string;
     customization?: VectorCustomization;
     theme?: MapTheme;
     /** Defines how hotspots of type should be treated: enabled/disabled or use custom hotspots instead. */
     hotspots?: Record<string, boolean | FetchHotspotsFunction | HotspotsOptions>;
 }
-export { VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, FetchHotspotsFunction, VectorTileDataSourceDescription, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority, HotspotsOptions, FetchTileFunction, ComposeTileUrlFunction, Hotspot, WorldHotspot, RenderedHotspot, FetchedTile, MapTheme };
+export { VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, FetchHotspotsFunction, VectorTileDataSourceDescription, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority, HotspotsOptions, FetchTileFunction, ComposeTileUrlFunction, Hotspot, WorldHotspot, RenderedHotspot, FetchedRasterTile, FetchedTile, FetchedCommonTile, MapTheme };

package/common/types/index.d.ts

@@ -20,3 +20,4 @@ export * from "./utils";
 export * from "./world-options";
 export * from "./data-source-description";
 export * from "./matrix";
+export * from "./tilt-range";

package/common/types/tilt-range.d.ts

@@ -0,0 +1,8 @@
+export interface TiltRange {
+    /** Minimum tilt in radians. */
+    readonly min: number;
+    /** Maximum tilt in radians. */
+    readonly max: number;
+    /** Behavior tilt expansion in radians. E.g. you can tilt map with fingers a little bit more than `max`. */
+    readonly expansion: number;
+}

package/imperative/Entities.d.ts

@@ -91,6 +91,18 @@ declare abstract class GenericEntity<Props, DefaultProps extends {} = {}, Root e
          * @returns Context value.
          */
     protected _consumeContext<T>(consumer: Context<T>): T | undefined;
+    /**
+         * Subscribes to changes in a context
+         * @param context - The context that provides access to the context value.
+         * @param watcher - Callback function that is called when the context value is changed.
+         * @param params - Params for watcher.
+         * @param params.immediate - Calls watcher immediately. For most handlers it allows to inline watcher function.
+         * @returns Function to unsubscribe from changes context.
+         * For most handlers it can be, because it is called automatically on detach.
+         */
+    protected _watchContext<T>(context: Context<T>, watcher: ContextWatcherFn, params?: {
+        immediate: boolean;
+    }): () => void;
 }
 interface ComplexOptions<Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
     children?: GenericEntity<unknown, {}, Root>[];

package/imperative/MMap/index.d.ts

@@ -1,4 +1,4 @@
-import type { BehaviorType, LngLat, MapMode, Margin, PixelCoordinates, Projection, ReadonlyLngLat, LngLatBounds, ZoomRange, ZoomRounding, WorldOptions, ZoomStrategy, EasingFunctionDescription } from "../../common/types";
+import type { BehaviorType, LngLat, MapMode, Margin, PixelCoordinates, Projection, ReadonlyLngLat, LngLatBounds, ZoomRange, ZoomRounding, WorldOptions, ZoomStrategy, EasingFunctionDescription, TiltRange } from "../../common/types";
 import type { MMapEntity } from "../MMapEnities";
 import { GenericRootEntity } from "../Entities";
 import { MMapCopyrightsPosition } from "../MMapCopyrights";
@@ -35,9 +35,9 @@ export type MMapLocation = MMapCenterZoomLocation & Partial<MMapBoundsLocation>;
  * Observer camera position
  */
 export type MMapCamera = {
-    /** Map tilt in radians. Can take values from 0 to 45 degrees (degrees * (Math.PI / 180)) */
+    /** Map tilt in radians. Can take values from 0 to 50 degrees (degrees * (Math.PI / 180)) */
     tilt?: number;
-    /** Map rotation in degrees. Can take values from -180 to 180 degrees */
+    /** Map rotation in radians. Can take values from -Math.PI to Math.PI */
     azimuth?: number;
 };
 /**
@@ -85,6 +85,8 @@ export type MMapProps = {
     hotspotsStrategy?: "forViewport" | "forPointerPosition";
     /** Position of copyright on the page. Default is 'bottom right' */
     copyrightsPosition?: MMapCopyrightsPosition;
+    /** Show the map scale next to copyright */
+    showScaleInCopyrights?: boolean;
     /**
          * Projection used in map
          */
@@ -111,6 +113,7 @@ declare const defaultProps: Readonly<{
     margin: Margin | undefined;
     copyrights: true;
     copyrightsPosition: "bottom right";
+    showScaleInCopyrights: false;
     worldOptions: {
         cycledX: boolean;
         cycledY: boolean;
@@ -157,6 +160,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         margin: Margin | undefined;
         copyrights: true;
         copyrightsPosition: "bottom right";
+        showScaleInCopyrights: false;
         worldOptions: {
             cycledX: boolean;
             cycledY: boolean;
@@ -181,6 +185,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         hotspotsStrategy?: "forViewport" | "forPointerPosition" | undefined;
         copyrights?: boolean | undefined;
         copyrightsPosition?: MMapCopyrightsPosition | undefined;
+        showScaleInCopyrights?: boolean | undefined;
         projection?: Projection | undefined;
         worldOptions?: WorldOptions | undefined;
         theme?: MMapTheme | undefined;
@@ -228,6 +233,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * getter for {@link MMapProps}.zoomRange prop
          */
     get zoomRange(): Readonly<ZoomRange>;
+    get tiltRange(): Readonly<TiltRange>;
     /**
          * getter for {@link MMapProps}.projection prop
          */
@@ -257,6 +263,11 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * @param location
          */
     setLocation(location: MMapLocationRequest): void;
+    /**
+         * setter for {@link MMapProps}.camera prop
+         * @param camera
+         */
+    setCamera(camera: MMapCameraRequest): void;
     private __setLocation;
     /**
          * setter for {@link MMapProps}.mode prop

package/imperative/MMapControl/MMapControl.d.ts

@@ -3,7 +3,14 @@ import { MMapGroupEntity } from "../MMapEnities";
 /**
  * MMapControl props
  */
-export type MMapControlProps = {};
+export type MMapControlProps = {
+    /** Makes the control transparent by removing background color and shadows */
+    transparent?: boolean;
+};
+declare const defaultProps: Readonly<{
+    transparent: false;
+}>;
+type DefaultProps = typeof defaultProps;
 /**
  *  DOM wrapper for creating custom controls. Connects the styles required by the control.
  *
@@ -30,20 +37,27 @@ export type MMapControlProps = {};
  *
  * @module MMapControl
  */
-export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends MMapGroupEntity<T> {
-    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl<MMapControlProps>, import("react").ForwardRefExoticComponent<{
+export declare class MMapControl extends MMapGroupEntity<MMapControlProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        transparent: false;
+    }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl, import("react").ForwardRefExoticComponent<{
+        transparent?: boolean | undefined;
         children?: import("react").ReactNode;
-        ref?: import("react").Ref<import("../Entities").GenericEntity<{
+        ref?: import("react").Ref<import("../Entities").GenericEntity<MMapControlProps & {
             controlElement: HTMLElement;
         }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
         key?: import("react").Key | null | undefined;
     }>>;
-    private _detachDom?;
     private _element?;
+    private _detachDom?;
     private _unwatchThemeContext?;
-    constructor();
+    constructor(props?: MMapControlProps);
     protected _createDom(): HTMLElement;
     protected _onAttach(): void;
+    protected _onUpdate(props: Partial<MMapControlProps>): void;
+    private __watchThemeContext;
     protected _onDetach(): void;
     private _updateTheme;
 }
+export {};

package/imperative/MMapControls/index.d.ts

@@ -1,11 +1,22 @@
+import { Context } from "../Entities";
 import { MMapEntity, MMapGroupEntity } from "../MMapEnities";
-type VerlicalPosition = "top" | "bottom";
+type VerticalPosition = "top" | "bottom";
+type ComputedVerticalPosition = "top" | "center" | "bottom";
 type HorizontalPosition = "left" | "right";
+type ComputedHorizontalPosition = "left" | "center" | "right";
 type Orientation = "horizontal" | "vertical";
+export type MMapControlContext = {
+    position: [
+        ComputedVerticalPosition,
+        ComputedHorizontalPosition,
+        Orientation
+    ];
+};
+export declare const ControlContext: Context<MMapControlContext>;
 /**
  * Describes controls position.
  */
-type Position = VerlicalPosition | HorizontalPosition | `${VerlicalPosition} ${HorizontalPosition}` | `${HorizontalPosition} ${VerlicalPosition}`;
+type Position = VerticalPosition | HorizontalPosition | `${VerticalPosition} ${HorizontalPosition}` | `${HorizontalPosition} ${VerticalPosition}`;
 /**
  * MMapControls props
  */

package/imperative/MMapCopyrights/index.d.ts

@@ -3,9 +3,12 @@ type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom
 type MMapCopyrightsProps = {
     /** Position of copyright on the map */
     position?: MMapCopyrightsPosition;
+    /** Show the map scale next to the map */
+    showScale?: boolean;
 };
 declare const defaultProps: Readonly<{
     position: MMapCopyrightsPosition;
+    showScale: false;
 }>;
 type DefaultProps = typeof defaultProps;
 /**
@@ -15,12 +18,15 @@ type DefaultProps = typeof defaultProps;
 declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, DefaultProps> {
     static defaultProps: Readonly<{
         position: MMapCopyrightsPosition;
+        showScale: false;
     }>;
     private _boxElement;
     private _copyrightsTextElement;
     private _linkElement;
     private _logoElement;
     private _copyrightsContainer;
+    private _scaleElement;
+    private _scaleControl;
     private _mapWidth;
     private _copyrights;
     private _fixedCopyrights;
@@ -30,8 +36,8 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
     private _unwatchThemeContext?;
     private _detachDom?;
     constructor(props?: MMapCopyrightsProps);
-    protected _updateDom(): void;
     protected _onAttach(): void;
+    protected _onUpdate(props: Partial<MMapCopyrightsProps>): void;
     protected _onDetach(): void;
     private _createDom;
     private _syncDom;
@@ -43,5 +49,6 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
     private _setFixedCopyrights;
     private _copyrightsChangeHandler;
     private _adjustText;
+    private _toggleScaleControl;
 }
 export { MMapCopyrights, MMapCopyrightsPosition, MMapCopyrightsProps };

package/imperative/MMapCoverage/index.d.ts

@@ -2,7 +2,7 @@ import { MMapComplexEntity } from "../MMapEnities";
 interface MMapCoverageProps {
     onError?: (e: Error) => void;
 }
-export declare const COVERAGE_LAYERS_TO_SOURCES: Record<string, string>;
+export declare const COVERAGE_LAYERS_TO_SOURCES: Map<string, string>;
 /**
  * The component of loading data on copyrights on the map and the zoom range for
  * the area where the center of the map is located

package/imperative/MMapDefaultFeaturesLayer/index.d.ts

@@ -7,6 +7,8 @@ type MMapDefaultFeaturesLayerProps = {
     visible?: boolean;
     /** Layer z-index */
     zIndex?: number;
+    /** Name for source */
+    source?: string;
 };
 declare const defaultProps: Readonly<{
     visible: true;

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -1,10 +1,15 @@
 import type { VectorCustomization } from "../../common/types";
+import { MMapLayerProps } from "../MMapLayer";
 import { MMapComplexEntity } from "../MMapEnities";
+type MMapDefaultSchemeLayerType = "ground" | "buildings" | "icons" | "labels";
 /**
  * MMapDefaultSchemeLayer props
  */
 type MMapDefaultSchemeLayerProps = {
-    /** Should show layer */
+    /**
+         * Should show layers
+         * @deprecated use {@link MMapDefaultSchemeLayerProps}.layers instead
+         */
     visible?: boolean;
     /** Vector tiles customization. */
     customization?: VectorCustomization;
@@ -13,28 +18,33 @@ type MMapDefaultSchemeLayerProps = {
          * @deprecated use {@link MMapProps}.theme prop in {@link MMap} instead
          * */
     theme?: "dark" | "light";
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapDefaultSchemeLayerType, Partial<MMapLayerProps>>>;
 };
 declare const defaultProps: {
     visible: boolean;
     source: string;
-    layersInfo: {
+    layers: {
         ground: {
-            type: string;
             zIndex: number;
         };
         buildings: {
-            type: string;
             zIndex: number;
         };
         icons: {
-            type: string;
             zIndex: number;
         };
         labels: {
-            type: string;
             zIndex: number;
         };
     };
+    /** @deprecated use {@link DefaultProps}.layers instead */
+    readonly layersInfo: Record<MMapDefaultSchemeLayerType, {
+        type: string;
+        zIndex: number;
+    }>;
 };
 type DefaultProps = typeof defaultProps;
 /**
@@ -53,24 +63,25 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     static defaultProps: {
         visible: boolean;
         source: string;
-        layersInfo: {
+        layers: {
             ground: {
-                type: string;
                 zIndex: number;
             };
             buildings: {
-                type: string;
                 zIndex: number;
             };
             icons: {
-                type: string;
                 zIndex: number;
             };
             labels: {
-                type: string;
                 zIndex: number;
             };
         };
+        /** @deprecated use {@link DefaultProps}.layers instead */
+        readonly layersInfo: Record<MMapDefaultSchemeLayerType, {
+            type: string;
+            zIndex: number;
+        }>;
     };
     private _dataSource?;
     private _layers;

package/imperative/MMapFeature/index.d.ts

@@ -52,6 +52,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     private _id;
     private _source;
     private _defaultPropsId?;
+    get id(): string;
     constructor(props: MMapFeatureProps);
     get properties(): Record<string, unknown> | undefined;
     get geometry(): GenericGeometry<LngLat>;
@@ -64,6 +65,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     private __onClick;
     private __onDoubleClick;
     private __onFastClick;
-    private __isMy;
+    private __isMySomeObject;
+    private __isMyDraggableObject;
 }
 export { MMapFeature, MMapFeatureProps };

package/{modules/controls-extra → imperative}/MMapScaleControl/index.d.ts

@@ -1,5 +1,5 @@
-import { MMapComplexEntity } from "../../../imperative";
-export type UnitType = 'imperial' | 'metric' | 'nautical';
+import { MMapComplexEntity } from "../MMapEnities";
+export type UnitType = "imperial" | "metric" | "nautical";
 type MMapScaleControlProps = {
     /** Maximum width of scale line in pixels */
     maxWidth?: number;
@@ -7,13 +7,13 @@ type MMapScaleControlProps = {
     unit?: UnitType;
 };
 declare const defaultProps: Readonly<{
-    maxWidth: 85;
+    maxWidth: 74;
     unit: "metric";
 }>;
 type DefaultProps = typeof defaultProps;
 declare class MMapScaleControl extends MMapComplexEntity<MMapScaleControlProps, DefaultProps> {
     static defaultProps: Readonly<{
-        maxWidth: 85;
+        maxWidth: 74;
         unit: "metric";
     }>;
     private _unwatchThemeContext?;

package/imperative/MMapTileDataSource/index.d.ts

@@ -50,9 +50,12 @@ type MMapTileDataSourceProps = {
  */
 declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
     private _id;
+    private _unwatchVectorContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;
-    private _validateVectorSource;
+    private _getDataSourceDescription;
+    private _onVectorContextUpdate;
+    private _prepareVectorSource;
 }
 export { MMapTileDataSource, MMapTileDataSourceProps };

package/imperative/index.d.ts

@@ -13,10 +13,11 @@ export * from "./MMapHotspot";
 export * from "./wrappers";
 export { MMapMarker, MMapMarkerProps, MMapMarkerEventHandler } from "./MMapMarker";
 export { MMapTileDataSource, MMapTileDataSourceProps } from "./MMapTileDataSource";
-export { MMapControls, MMapControlsProps } from "./MMapControls";
+export * from "./MMapControls";
 export { MMapControl, MMapControlProps, MMapControlButton, MMapControlButtonProps, MMapControlCommonButton } from "./MMapControl";
 export { MMapCollection } from "./MMapCollection";
 export { MMapContainer, MMapContainerProps, MMapContainerPropsImpl, ComputedMMapContainerProps } from "./MMapContainer";
+export { MMapScaleControl, MMapScaleControlProps } from "./MMapScaleControl";
 export * from "./mappable-worldMaps";
 export * from "./search";
 export * from "./suggest";

package/imperative/route/index.d.ts

@@ -1,4 +1,4 @@
 import { Config } from "../config";
-import type { BaseRouteResponse, RouteOptions } from "./interface";
+import type { BaseRouteResponse, RouteOptions, RouteFeature } from "./interface";
 export declare function route(options: RouteOptions, config?: Config | undefined): Promise<BaseRouteResponse[]>;
-export { RouteOptions, BaseRouteResponse };
+export { RouteOptions, BaseRouteResponse, RouteFeature };

package/import.d.ts

@@ -4,9 +4,16 @@ export type Module = Function | null | {
     [key: string]: Function | object;
 };
 export type Loader = (pkg: string) => Promise<Module> | Module;
+type Packages = Record<string, {
+    version: string;
+    path?: string;
+    export?: string;
+}>;
 export interface Import {
     loaders: Loader[];
     default: Loader;
+    cdn: (templatePath: string, packages: Packages | string[] | string) => Loader;
+    registerCdn: (templatePath: string, packages: Packages | string[] | string) => void;
     script: (url: string) => Promise<unknown>;
     cssText: (cssText: string, name: string) => Promise<unknown>;
     style: (url: string) => Promise<unknown>;

package/modules/analytics/index.d.ts

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

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

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

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

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

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

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

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