@mappable-world/mappable-types 0.0.19 → 0.0.21

package/common/types/bounds.d.ts

@@ -8,10 +8,10 @@ export type GenericBounds<T> = [
     T
 ];
 /**
- * Rectangle bounded by bottom-left and top-right coordinates
+ * Rectangle bounded by top-left and bottom-right coordinates
  */
 export type LngLatBounds = GenericBounds<LngLat>;
 /**
- * Rectangle bounded by bottom-left and top-right world coordinates
+ * Rectangle bounded by top-left and bottom-right world coordinates
  */
 export type WorldBounds = GenericBounds<WorldCoordinates>;

package/common/types/layer-implementation.d.ts

@@ -15,7 +15,9 @@ interface LayerImplementationRenderProps {
     size: PixelCoordinates;
 }
 interface RasterLayerImplementationRenderProps extends LayerImplementationRenderProps {
-    camera: Camera;
+    camera: Camera & {
+        fov: number;
+    };
     worlds: WorldOffset[];
 }
 interface RasterLayerImplementation {
@@ -39,7 +41,9 @@ interface RasterLayerImplementationConstructor {
     new (props: RasterLayerImplementationConstructorProps): RasterLayerImplementation;
 }
 interface VectorLayerImplementationRenderProps extends LayerImplementationRenderProps {
-    camera: Camera;
+    camera: Camera & {
+        fov: number;
+    };
     worlds: {
         lookAt: Vec2;
         viewProjMatrix: Matrix4;

package/imperative/Entities.d.ts

@@ -9,6 +9,7 @@ declare class ContextProvider<T> {
     consume(): T | undefined;
     provide(nextContext: T): void;
 }
+export declare const __implEntityKeepOldPropValue: {};
 type WithDefaults<Props, DefaultProps extends Partial<Props>> = Props & {
     [K in keyof DefaultProps]: K extends keyof Props ? NonNullable<Props[K]> : never;
 };

package/imperative/MMap/index.d.ts

@@ -200,8 +200,8 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
     private __abortVectorLoad?;
     private _layers;
     private _copyrights;
-    private _coverage;
     private _isDestroyed;
+    private _isVectorLoading;
     constructor(rootContainer: HTMLElement, props: MMapProps, children?: MMapEntity<unknown>[]);
     readonly children: MMapEntity<unknown>[];
     addChild(child: MMapEntity<unknown>, index?: number): this;

package/imperative/MMapContextProvider/index.d.ts

@@ -0,0 +1,25 @@
+import { MMapGroupEntity } from "../MMapEnities";
+import type { Context } from "../Entities";
+/**
+ * MMapContextProvider props
+ */
+export type MMapContextProviderProps<T> = {
+    /** Context that will receive the provided value */
+    context: Context<T>;
+    /** Value to be provided in the context. */
+    value: T;
+};
+/**
+ * Context provider for MMap, allowing to inject a context and its value.
+ * @example
+ * ```javascript
+ * const mapContextProvider = new MMapContextProvider({context: SomeMapContext, value: {your: 'value'}});
+ * mapContextProvider.addChild(new MMapDefaultSchemeLayer({}));
+ * map.addChild(mapContextProvider);
+ * ```
+ * `MMapDefaultSchemeLayer` will receive the context `SomeMapContext` with the value `{ your: 'value' }`
+ */
+export declare class MMapContextProvider<T> extends MMapGroupEntity<MMapContextProviderProps<T>> {
+    protected _onAttach(): void;
+    protected _onUpdate({ value }: Partial<MMapContextProviderProps<T>>): void;
+}

package/imperative/MMapControl/MMapControl.d.ts

@@ -50,9 +50,10 @@ export declare class MMapControl extends MMapGroupEntity<MMapControlProps, Defau
         key?: import("react").Key | null | undefined;
     }>>;
     private _element?;
+    private _innerElement?;
     private _detachDom?;
     private _unwatchThemeContext?;
-    constructor(props?: MMapControlProps);
+    constructor(props?: MMapControlProps, element?: HTMLElement);
     protected _createDom(): HTMLElement;
     protected _onAttach(): void;
     protected _onUpdate(props: Partial<MMapControlProps>): void;

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -48,7 +48,7 @@ export declare class MMapControlCommonButton extends MMapGroupEntity<MMapControl
  * map.addChild(controls);
  * ```
  *
- * @see https://mappable.world/docs/jsapi/dg/concepts/controls/about.html
+ * @see <https://mappable.world/docs/js-api/dg/concepts/controls/index.html>
  */
 export declare class MMapControlButton extends MMapComplexEntity<MMapControlButtonProps> {
     static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControlButton, import("react").ForwardRefExoticComponent<{

package/imperative/MMapControls/index.d.ts

@@ -49,7 +49,7 @@ export declare class MMapControls extends MMapGroupEntity<MMapControlsProps> {
     private _detachDom?;
     constructor(props: MMapControlsProps, children?: MMapEntity<unknown>[]);
     protected _onAttach(): void;
-    protected _onUpdate(): void;
+    protected _onUpdate(diffProps: Partial<MMapControlsProps>): void;
     protected _onDetach(): void;
 }
 export {};

package/imperative/MMapCoverage/index.d.ts

@@ -1,20 +1,55 @@
+import type { ZoomRange } from "../../common/types";
 import { MMapComplexEntity } from "../MMapEnities";
+import { Context } from "../Entities";
 interface MMapCoverageProps {
     onError?: (e: Error) => void;
 }
-export declare const COVERAGE_LAYERS_TO_SOURCES: Map<string, string>;
+export interface CoverageContext {
+    subscribe(args: CoverageSubscriptionArgs): CoverageSubscription;
+}
+export declare const CoverageContext: Context<CoverageContext>;
 /**
  * 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
  */
 declare class MMapCoverage extends MMapComplexEntity<MMapCoverageProps, {}> {
     private _abortController?;
-    private _prevMeta;
-    private _unwatchMapContext?;
+    private _coverageArgs?;
+    private _subscriptions;
+    private readonly _queueRequest;
+    private readonly _queueRequestStamps;
+    private _stampsRequestsInterval?;
+    private _currentIntervalMs;
+    private _stampsAbortController?;
     constructor(props?: MMapCoverageProps);
+    subscribe(args: CoverageSubscriptionArgs): CoverageSubscription;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    private _compareIfMetaDiffers;
-    private _attemptCoverageRequest;
+    protected _scheduleStampsRequests(): void;
+    private _onMapContextChange;
+    private _request;
+    _requestStamps(): void;
+}
+export interface CoverageSubscriptionArgs {
+    layer: string;
+    maptype: string | undefined;
+    versioned?: {
+        interval: number;
+    };
+    onUpdate: () => void;
+}
+export declare class CoverageSubscription {
+    private readonly _onDestroy;
+    readonly layer: string;
+    readonly maptype: string | undefined;
+    readonly onUpdate: () => void;
+    readonly versioned?: {
+        interval: number;
+    };
+    copyrights?: string[];
+    zoomRange?: ZoomRange;
+    version?: string;
+    constructor(args: CoverageSubscriptionArgs, _onDestroy: () => void);
+    destroy(): void;
 }
 export { MMapCoverage, MMapCoverageProps };

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -22,6 +22,18 @@ type MMapDefaultSchemeLayerProps = {
     source?: string;
     /** Layers parameters */
     layers?: Partial<Record<MMapDefaultSchemeLayerType, Partial<MMapLayerProps>>>;
+    /**
+         * Allow to clamp map zoom. If you want the layer to not lock zoom when it reaches
+         * its maximum value, you can set this field to false.
+         * This may be necessary, for example, when your own layers are working at scales greater than 21.
+         * ```js
+         * const defaultSchemeLayer = new MMapDefaultSchemeLayer({clampMapZoom: false});
+         * map.addChild(defaultSchemeLayer);
+         * ```
+         * See example https://mappable.world/docs/jsapi/examples/cases/over-zoom
+         * @default true
+         */
+    clampMapZoom?: boolean;
 };
 declare const defaultProps: {
     visible: boolean;
@@ -45,8 +57,17 @@ declare const defaultProps: {
         type: string;
         zIndex: number;
     }>;
+    clampMapZoom: boolean;
 };
 type DefaultProps = typeof defaultProps;
+declare const MAP_TYPES: {
+    map: string;
+    admin: string;
+    driving: string;
+    transit: string;
+    "future-map": string;
+    "legacy-map": string;
+};
 /**
  * Map default layer to show mappable-world scheme on map.
  *
@@ -82,15 +103,17 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
             type: string;
             zIndex: number;
         }>;
+        clampMapZoom: boolean;
     };
     private _dataSource?;
     private _layers;
     private _unwatchMapContext?;
     private _unwatchThemeContext?;
+    private _coverageSubscription?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;
-    private _getDataSourceDescription;
+    private _getTileDataSourceProps;
     private _updateTheme;
 }
-export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps };
+export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps, MAP_TYPES };

package/imperative/MMapFeature/index.d.ts

@@ -58,15 +58,13 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     get geometry(): GenericGeometry<LngLat>;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate({ id, source }: Partial<MMapFeatureProps>): void;
+    protected _onUpdate({ id, source, geometry }: Partial<MMapFeatureProps>): void;
     protected _getDefaultProps(): DefaultProps;
-    private __onDragStart;
-    private __onDragMove;
-    private __onDragEnd;
-    private __onClick;
-    private __onDoubleClick;
-    private __onFastClick;
-    private __isMySomeObject;
-    private __isMyDraggableObject;
+    private static _onDragStart;
+    private static _onDragMove;
+    private static _onDragEnd;
+    private static _onClick;
+    private static _onFastClick;
+    private static _onDoubleClick;
 }
 export { MMapFeature, MMapFeatureProps };

package/imperative/MMapFeature/types.d.ts

@@ -1,4 +1,4 @@
-import type { LineStringGeometry, Margin, MultiLineStringGeometry, MultiPolygonGeometry, PointGeometry, PolygonGeometry } from "../../common/types";
+import type { LineStringGeometry, Margin, MultiLineStringGeometry, MultiPolygonGeometry, PointGeometry, PolygonGeometry, LngLat } from "../../common/types";
 export interface DraggableProps<Callback> {
     /** Feature can be draggable */
     draggable?: boolean;
@@ -32,13 +32,22 @@ export interface BlockingProps {
          */
     blockBehaviors?: boolean;
 }
+export interface MapEvent {
+    /** [x, y] */
+    screenCoordinates: [
+        number,
+        number
+    ];
+    coordinates: LngLat;
+    stopPropagation: () => void;
+}
 export interface FeatureClickEvents {
     /** Double click handler */
-    onDoubleClick?: (event: MouseEvent) => void;
+    onDoubleClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
     /** Click handler */
-    onClick?: (event: MouseEvent) => void;
+    onClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
     /** Fast click handler */
-    onFastClick?: (event: MouseEvent) => void;
+    onFastClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
 }
 export type Geometry = PolygonGeometry | MultiPolygonGeometry | LineStringGeometry | MultiLineStringGeometry | PointGeometry;
 export type MMapFeatureEventHandler = (coordinates: Geometry['coordinates']) => void | false;

package/imperative/MMapListener/index.d.ts

@@ -15,6 +15,8 @@ export interface DomEvent {
 type HandlerEntity<TType extends string, TEntity> = {
     type: TType;
     entity: TEntity;
+    layer: string;
+    source: string;
 };
 export type DomEventHandlerObject = HandlerEntity<"feature", MMapFeature> | HandlerEntity<"marker", MMapMarker> | HandlerEntity<"hotspot", MMapHotspot> | undefined;
 interface TileLayerState {
@@ -105,7 +107,7 @@ type MMapListenerProps = DomEventsProps | NullablePartial<MapEvents> | NullableP
  *
  * map.addChild(mapListener);
  * ```
- * @see [More about events](https://mappable.world/docs/jsapi/dg/concepts/events.html)
+ * @see [More about events](https://mappable.world/docs/js-api/dg/concepts/events.html)
  */
 declare class MMapListener extends MMapEntity<MMapListenerProps> {
     private _domHandlers;

package/imperative/MMapMarker/index.d.ts

@@ -98,9 +98,9 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
         onDragMove?: MMapMarkerEventHandler | undefined;
         blockEvents?: boolean | undefined;
         blockBehaviors?: boolean | undefined;
-        onDoubleClick?: ((event: MouseEvent) => void) | undefined;
-        onClick?: ((event: MouseEvent) => void) | undefined;
-        onFastClick?: ((event: MouseEvent) => void) | undefined;
+        onDoubleClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
+        onClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
+        onFastClick?: ((event: MouseEvent, mapEvent: import("../MMapFeature/types").MapEvent) => void) | undefined;
         markerElement?: HTMLElement | undefined;
         children?: import("react").ReactNode;
         ref?: import("react").Ref<import("../Entities").GenericEntity<{
@@ -144,10 +144,10 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
     }>>;
     readonly element: HTMLElement;
     private _destroyDomCtx?;
-    constructor(props: MMapMarkerProps, element?: HTMLElement);
-    private __feature;
+    private __feature?;
     get properties(): Record<string, unknown> | undefined;
     get coordinates(): LngLat;
+    constructor(props: MMapMarkerProps, element?: HTMLElement);
     _onAttach(): void;
     _onDetach(): void;
     protected _onUpdate({ coordinates, zIndex, ...props }: Partial<MMapMarkerProps>): void;

package/imperative/MMapTileDataSource/index.d.ts

@@ -1,4 +1,4 @@
-import type { RasterTileDataSourceDescription, ZoomRange } from "../../common/types";
+import type { RasterTileDataSourceDescription, VectorTileDataSourceDescription, ZoomRange } from "../../common/types";
 import { MMapEntity } from "../MMapEnities";
 /**
  * MMapTileDataSource props
@@ -50,7 +50,6 @@ type MMapTileDataSourceProps = {
  */
 declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
     private _id;
-    private _unwatchVectorContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;

package/imperative/TypeContext.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "./Entities";
+export type MMapType = string;
+export type MMapTypeContext = {
+    type?: MMapType;
+};
+export declare const TypeContext: Context<MMapTypeContext>;

package/imperative/fetchConfig.d.ts

@@ -5,6 +5,8 @@ import { Config } from "./config";
 export type FetchConfigOptions = {
     /** Language */
     lang: string;
+    /** Data provider */
+    dataProvider?: string;
     /** Signal to abort request */
     signal?: AbortSignal;
 };
@@ -13,6 +15,6 @@ export type FetchConfigOptions = {
  *
  * @param {FetchConfigOptions} options Request options
  * @param {Config} config Current config
- * @returns {Promise<Config>} config for map construction
+ * @returns {Promise<Config>} Config for map construction
  */
 export declare function fetchConfig(options: FetchConfigOptions, config?: Config | undefined): Promise<Config>;

package/imperative/index.d.ts

@@ -1,6 +1,8 @@
 import * as projections_ from "./utils/projections";
 export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
 export { MMapThemeContext, ThemeContext, MMapTheme } from "./ThemeContext";
+export { MMapTypeContext, TypeContext, MMapType } from "./TypeContext";
+export { MMapContextProvider, MMapContextProviderProps } from "./MMapContextProvider";
 export { MMapCopyrightsPosition } from "./MMapCopyrights";
 export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
 export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";

package/imperative/search/index.d.ts

@@ -3,7 +3,12 @@ import { Config } from "../config";
 export type SearchType = "businesses" | "toponyms";
 export type SearchOptions = {
     /** Request string represented by a text or {@link LngLat LngLat} point. */
-    text: string;
+    text?: string;
+    /**
+         * Additional information about the object.
+         * The parameter value is returned in the Geosuggest response.
+         * To use it in a request, specify a value instead of text. */
+    uri?: string;
     /**
          * {@link type `type`} parameter specifies the type of
          * objects that are being searched (and the order of objects

package/imperative/utils/jsonp.d.ts

@@ -5,5 +5,5 @@ type JsonpRequest = {
 };
 declare function boolToFlag(value: undefined | boolean): undefined | BooleanFlag;
 declare function composeUrl(baseUrl: string, params: Record<string, string | number | undefined>): string;
-declare function jsonp<JsonpResponse>({ url, callbackName }: JsonpRequest): Promise<JsonpResponse>;
+declare function jsonp<JsonpResponse>({ url, callbackName }: JsonpRequest, signal?: AbortSignal): Promise<JsonpResponse>;
 export { jsonp, composeUrl, boolToFlag };

package/imperative/utils/requestCoverage.d.ts

@@ -4,7 +4,22 @@ export type LayerInfo = {
     zoomRange?: ZoomRange;
     copyrights?: string[];
     LayerMetaData?: unknown[];
+    version?: string;
 };
-export type Coverage = LayerInfo[];
-declare function requestCoverage(host: string, layers: string[], coordinates: ReadonlyLngLat, zoom: number, lang: string, signal?: AbortSignal): Promise<Coverage>;
-export { requestCoverage };
+export type Coverage = Map<string, LayerInfo>;
+export interface CoverageArgs {
+    host: string;
+    layers: string[];
+    coordinates: ReadonlyLngLat;
+    zoom: number;
+    lang: string;
+    maptype?: string | undefined;
+}
+declare function requestCoverage(args: CoverageArgs, signal?: AbortSignal): Promise<Coverage>;
+interface RequestStampsArgs {
+    host: string;
+    layers: string[];
+    lang: string;
+}
+declare function requestStamps(args: RequestStampsArgs, signal?: AbortSignal): Promise<Coverage>;
+export { requestCoverage, requestStamps };

package/imperative/utils/sphere-geo-utils.d.ts

@@ -0,0 +1 @@
+import type { LngLat } from "../../common/types";

package/modules/layers-extra/MMapCarparksLayer.d.ts

@@ -0,0 +1,50 @@
+import { optionsKeyVuefy, MMapComplexEntity, MMapLayerProps } from "../../imperative";
+import type { CustomVuefyOptions } from "../vuefy";
+type MMapCarparksLayerType = "ground" | "icons";
+type MMapCarparksLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapCarparksLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    updateTime: number;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+    };
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapCarparksLayer extends MMapComplexEntity<MMapCarparksLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        updateTime: number;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+        };
+    };
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapCarparksLayer>;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    private _dataSource?;
+    private _layers;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(): void;
+    protected _onDetach(): void;
+}
+export { MMapCarparksLayer, MMapCarparksLayerProps };

package/modules/layers-extra/MMapPanoramaLayer.d.ts

@@ -0,0 +1,52 @@
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import { MMapLayerProps } from "../../imperative/MMapLayer";
+type MMapPanoramaLayerType = "ground" | "icons";
+type MMapPanoramaLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapPanoramaLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+    };
+    updateTime: number;
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapPanoramaLayer extends MMapComplexEntity<MMapPanoramaLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+        };
+        updateTime: number;
+    };
+    private _dataSource?;
+    private _layers;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapPanoramaLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onDetach(): void;
+    protected _onUpdate(): void;
+}
+export { MMapPanoramaLayer, MMapPanoramaLayerProps };

package/modules/layers-extra/MMapTrafficEventsLayer.d.ts

@@ -0,0 +1,58 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import { MMapLayerProps } from "../../imperative/MMapLayer";
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+type MMapTrafficEventsLayerType = "ground" | "icons" | "labels";
+type MMapTrafficEventsLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapTrafficEventsLayerType, Partial<MMapLayerProps>>>;
+};
+declare const defaultProps: {
+    visible: boolean;
+    source: string;
+    updateTime: number;
+    layers: {
+        ground: {
+            zIndex: number;
+        };
+        icons: {
+            zIndex: number;
+        };
+        labels: {
+            zIndex: number;
+        };
+    };
+};
+type DefaultProps = typeof defaultProps;
+declare class MMapTrafficEventsLayer extends MMapComplexEntity<MMapTrafficEventsLayerProps, DefaultProps> {
+    static defaultProps: {
+        visible: boolean;
+        source: string;
+        updateTime: number;
+        layers: {
+            ground: {
+                zIndex: number;
+            };
+            icons: {
+                zIndex: number;
+            };
+            labels: {
+                zIndex: number;
+            };
+        };
+    };
+    private _dataSource?;
+    private _layers;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapTrafficEventsLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(): void;
+    protected _onDetach(): void;
+}
+export { MMapTrafficEventsLayer, MMapTrafficEventsLayerProps };

package/modules/layers-extra/MMapTrafficLayer.d.ts

@@ -0,0 +1,36 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+import type { CustomVuefyOptions } from "../vuefy";
+import { optionsKeyVuefy } from "../../imperative/wrappers";
+type MMapTrafficLayerProps = {
+    /** Should show layer. Default is true */
+    visible?: boolean;
+    /** Layer z-index */
+    zIndex?: number;
+    /** Name for source */
+    source?: string;
+};
+declare const defaultProps: Readonly<{
+    visible: true;
+    source: "mappable-traffic-layer";
+    zIndex: 1000;
+    updateTime: number;
+}>;
+type DefaultProps = typeof defaultProps;
+declare class MMapTrafficLayer extends MMapComplexEntity<MMapTrafficLayerProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        visible: true;
+        source: "mappable-traffic-layer";
+        zIndex: 1000;
+        updateTime: number;
+    }>;
+    private _dataSource?;
+    private _layer?;
+    private _coverageSubscription?;
+    private _unwatchThemeContext?;
+    static [optionsKeyVuefy]: CustomVuefyOptions<MMapTrafficLayer>;
+    protected _onAttach(): void;
+    private _getTileDataSourceProps;
+    protected _onUpdate(props: Partial<MMapTrafficLayerProps>): void;
+    protected _onDetach(): void;
+}
+export { MMapTrafficLayer, MMapTrafficLayerProps };

package/modules/layers-extra/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./MMapTrafficLayer";
+export * from "./MMapTrafficEventsLayer";
+export * from "./MMapCarparksLayer";
+export * from "./MMapPanoramaLayer";

package/modules/layers-extra/utils.d.ts

@@ -0,0 +1 @@
+export declare function transformUrlTemplate(urlTemplate: string, locale: string, version?: string): string;

package/modules/ruler/EventsBlockerLayer.d.ts

@@ -0,0 +1,10 @@
+import { MMapComplexEntity } from "../../imperative/MMapEnities";
+type EventBlockerLayerProps = {
+    zIndex: number;
+};
+declare class EventBlockerLayer extends MMapComplexEntity<EventBlockerLayerProps> {
+    private _layer;
+    constructor(props: EventBlockerLayerProps);
+    protected _onUpdate(props: Partial<EventBlockerLayerProps>): void;
+}
+export { EventBlockerLayer, EventBlockerLayerProps };

package/modules/ruler/MMapRuler.d.ts

@@ -0,0 +1,66 @@
+import { MMapComplexEntity, MMapEntity } from "../../imperative";
+import { optionsKeyVuefy, overrideKeyReactify, overrideKeyVuefy } from "../../imperative/wrappers";
+import { RenderPointCommonArgs, MMapRulerCommon, MMapRulerCommonProps } from "./MMapRulerCommon";
+export type MMapRulerProps = Omit<MMapRulerCommonProps, "point"> & {
+    point: (params: RenderPointArgs) => MMapEntity<RenderPointArgs>;
+};
+export type RenderPointArgs = RenderPointCommonArgs;
+declare const defaultProps: Readonly<{}>;
+export declare class MMapRuler extends MMapComplexEntity<MMapRulerProps, typeof defaultProps> {
+    static defaultProps: Readonly<{}>;
+    static [optionsKeyVuefy]: import("../vuefy").CustomVuefyOptions<MMapRulerCommon, {
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+    }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapRulerCommon, import("react").ForwardRefExoticComponent<{
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+        point: (params: RenderPointCommonArgs) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        previewPoint: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        ref?: import("react").Ref<MMapEntity<{
+            type: import("./MMapRulerCommon").RulerType;
+            source?: string | undefined;
+            geometry: import("./MMapRulerCommon").RulerGeometry;
+            zIndex?: number | undefined;
+            onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+            points: import("../../common/types/lng-lat").LngLat[];
+            editable?: boolean | undefined;
+            onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+            onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+            point: (params: RenderPointCommonArgs) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+            previewPoint: import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        }, {}>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
+    static [overrideKeyVuefy]: import("../vuefy").CustomVuefyFn<MMapRulerCommon, {
+        type: import("./MMapRulerCommon").RulerType;
+        source?: string | undefined;
+        geometry: import("./MMapRulerCommon").RulerGeometry;
+        zIndex?: number | undefined;
+        onUpdate?: import("./MMapRulerCommon").UpdateCommonFn | undefined;
+        points: import("../../common/types/lng-lat").LngLat[];
+        editable?: boolean | undefined;
+        onUpdateStart?: import("./MMapRulerCommon").UpdateStartFn | undefined;
+        onUpdateEnd?: import("./MMapRulerCommon").UpdateEndFn | undefined;
+    }>;
+    private _rulerCommon;
+    private _previewPointWrapper;
+    constructor(props: MMapRulerProps);
+    protected _onUpdate(): void;
+    private _renderPoints;
+}
+export {};

package/modules/ruler/MMapRulerCommon.d.ts

@@ -0,0 +1,102 @@
+import { DrawingStyle, LngLat, MMapComplexEntity, MMapMarkerEventHandler } from "../../imperative";
+export declare const TYPE_RULER = "ruler";
+export declare const TYPE_PLANIMETER = "planimeter";
+export type RulerType = typeof TYPE_RULER | typeof TYPE_PLANIMETER;
+export type Measurements = RulerMeasurements | PlanimeterMeasurements;
+export type RulerMeasurements = {
+    type: typeof TYPE_RULER;
+    /** the distance in meters from the first point of the line */
+    distance: number;
+    /** the distance in meters from the previous point of the line */
+    segmentDistance: number;
+    /** the total distance of the line in meters */
+    totalDistance: number;
+};
+export type PlanimeterMeasurements = {
+    type: typeof TYPE_PLANIMETER;
+    /** the area of the closed line shape in square meters */
+    area: number;
+};
+export type CommonMeasurements = Omit<RulerMeasurements, "distance" | "segmentDistance"> | PlanimeterMeasurements;
+export type RulerPointState = {
+    index: number;
+    totalCount: number;
+    coordinates: LngLat;
+    measurements: Measurements;
+    editable: boolean;
+    source: string;
+};
+export type RulerCommonState = {
+    measurements: CommonMeasurements;
+    points: LngLat[];
+};
+export type RenderPointCommon = (params: RenderPointCommonArgs) => RenderPointCommonResult;
+export type RenderPointCommonArgs = {
+    state: RulerPointState;
+    onDragMove: MMapMarkerEventHandler;
+    onDragStart: MMapMarkerEventHandler;
+    onDragEnd: MMapMarkerEventHandler;
+    onDelete: () => void;
+};
+export type RenderPointCommonResult = {
+    update: (state: RulerPointState) => void;
+    remove: (index: number) => void;
+};
+export type UpdateCommonFn = (commonState: RulerCommonState) => void;
+export type UpdateStartFn = (commonState: {}) => void;
+export type UpdateEndFn = (commonState: {}) => void;
+export type RulerGeometry = {
+    style: DrawingStyle;
+};
+export type MMapRulerCommonProps = {
+    type: RulerType;
+    points: LngLat[];
+    editable?: boolean;
+    geometry: RulerGeometry;
+    source?: string;
+    zIndex?: number;
+    previewPoint: HTMLElement;
+    point: RenderPointCommon;
+    onUpdate?: UpdateCommonFn;
+    onUpdateStart?: UpdateStartFn;
+    onUpdateEnd?: UpdateEndFn;
+};
+export declare const defaultProps: Readonly<{
+    editable: true;
+    zIndex: 2600;
+    source: "mappable-ruler";
+}>;
+export declare class MMapRulerCommon extends MMapComplexEntity<MMapRulerCommonProps, typeof defaultProps> {
+    static defaultProps: Readonly<{
+        editable: true;
+        zIndex: 2600;
+        source: "mappable-ruler";
+    }>;
+    private _lineFeature;
+    private _polygonFeature;
+    private _listener;
+    private _previewPointMarker?;
+    private _dataSource;
+    private _markersLayer;
+    private _featuresLayer;
+    private _blockerLayer;
+    private _rulerPoints;
+    private _measurements;
+    private _totalDistance;
+    private _area;
+    constructor(props: MMapRulerCommonProps);
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(props: Partial<MMapRulerCommonProps>): void;
+    private _commonUpdate;
+    private _updateRulerCoordinates;
+    private _updateRulerGeometry;
+    private _onMouseMoveHandler;
+    private _onMouseMoveOnPreviewMarker;
+    private _onClickHandler;
+    private _createPreviewPointMarker;
+    private _updateMeasurements;
+    private _getFeaturesCoordinates;
+    private _createNewRulerPoint;
+    private _removeRulerPoint;
+}

package/modules/ruler/index.d.ts

@@ -0,0 +1,2 @@
+export { MMapRuler, MMapRulerProps, RenderPointArgs } from "./MMapRuler";
+export { RulerGeometry, RulerType, RulerPointState, RulerCommonState, Measurements } from "./MMapRulerCommon";

package/modules/ruler/react/MMapRuler.d.ts

@@ -0,0 +1,11 @@
+import type TReact from "react";
+import type { MMapEntity } from "../../../imperative";
+import type { CustomReactify, OverrideProps, Prettify } from "../../../reactify/reactify";
+import { RenderPointCommonArgs, MMapRulerCommonProps, MMapRulerCommon as MMapRulerI } from "../MMapRulerCommon";
+type MMapRulerReactifiedProps = Prettify<OverrideProps<MMapRulerCommonProps, {
+    point: (params: RenderPointCommonArgs) => TReact.ReactElement;
+    previewPoint: TReact.ReactElement;
+}>>;
+type MMapRulerR = TReact.ForwardRefExoticComponent<Prettify<MMapRulerReactifiedProps & React.RefAttributes<MMapEntity<MMapRulerReactifiedProps>>>>;
+export declare const MMapRulerReactifyOverride: CustomReactify<MMapRulerI, MMapRulerR>;
+export {};

package/modules/ruler/utils.d.ts

@@ -0,0 +1,54 @@
+import type { LngLat } from "../../imperative";
+import { RulerMeasurements, RulerType } from "./MMapRulerCommon";
+/**
+ * Creates a geodesic line at several points
+ * @param points - Points where the geodesic line is created
+ * @param type - If the type is a `ruler`, then the line is not closed. If the type is a `planimeter`, then it creates a closed line
+ * @param projectionType – Map projection type
+ * @returns Geodesic line coordinates
+ */
+export declare function createGeodesicGeometry(points: LngLat[], type: RulerType): LngLat[];
+/**
+ * Returns a great circle segment between two coordinates
+ * @param firstCoordinates - First coordinate
+ * @param secondCoordinates - Second coordinate
+ * @param npoints - Number of points on the great circle segment
+ * @returns Great circle segment
+ */
+export declare function getGreatCircleSegment(firstCoordinates: LngLat, secondCoordinates: LngLat, npoints?: number): LngLat[];
+/**
+ * Calculates the area of a geodesic figure in square metres.
+ * @param coordinates - Geodesic geometry coordinates
+ * @returns Area in square metres
+ */
+export declare function calcArea(coordinates: LngLat[]): number;
+type DistanceMeasurements = Omit<RulerMeasurements, "type" | "totalDistance">;
+/**
+ * Calculates measurements for each point of the line
+ * @param points - Coordinates of the points on the line
+ * @param projectionType – Map projection type
+ * @returns Array of measurements for each point of the line
+ */
+export declare function calcDistance(points: LngLat[]): DistanceMeasurements[];
+/**
+ * Fixes the line display when crossing the border of the "world".
+ * To do this, it transfers values outside the range (-180, 180) to another "world".
+ * @param lineStringCoordinates - Coordinates of the points on the line
+ * @returns Array of fixed coordinates
+ */
+export declare function unfoldLineStringByShorterDistances(lineStringCoordinates: LngLat[]): LngLat[];
+export declare function getNearestPointOnLine(lineCoordinates: LngLat[], point: LngLat): {
+    index: number;
+    coordinates: LngLat;
+};
+/**
+ * Finds the index of the segment at points, by the index of the segment in the geometry
+ * @param geometry - Geometry coordinates
+ * @param points - Points that lie on the geometry
+ * @param geometrySegmentIndex - Index of segment in geometry
+ * @returns The segment index found in points
+ */
+export declare function findIndexInGeometry(geometry: LngLat[], points: LngLat[], geometrySegmentIndex: number): number;
+export declare function areLngLatFuzzyEqual(a: LngLat, b: LngLat, tolerance?: number): boolean;
+export declare function areLngLatEqual(a: LngLat, b: LngLat): boolean;
+export {};

package/modules/ruler/vue/MMapRuler.d.ts

@@ -0,0 +1,6 @@
+import type { CustomVuefyFn, CustomVuefyOptions } from "../../vuefy";
+import { MMapRulerCommonProps, MMapRulerCommon as MMapRulerI } from "../MMapRulerCommon";
+type MMapRulerVuefyProps = Omit<MMapRulerCommonProps, "point" | "previewPoint">;
+export declare const MMapRulerVuefyOptions: CustomVuefyOptions<MMapRulerI, MMapRulerVuefyProps>;
+export declare const MMapRulerVuefyOverride: CustomVuefyFn<MMapRulerI, MMapRulerVuefyProps>;
+export {};

package/modules/types.d.ts

@@ -1,6 +1,7 @@
 import "../import";
 declare module "../import" {
     interface Import {
+        (pkg: "@mappable-world/mappable-ruler"): Promise<typeof import("./ruler")>;
         (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")>;

package/modules/vuefy/options/common.d.ts

@@ -1,5 +1,5 @@
 import type { CustomVuefyOptions } from "..";
-import { MMap, MMapContainer, MMapControlButton, MMapControls, MMapDefaultFeaturesLayer, MMapDefaultSchemeLayer, MMapFeature, MMapFeatureDataSource, MMapLayer, MMapMarker, MMapTileDataSource } from "../../../imperative";
+import { MMap, MMapContainer, MMapControlButton, MMapControls, MMapDefaultFeaturesLayer, MMapDefaultSchemeLayer, MMapFeature, MMapFeatureDataSource, MMapLayer, MMapMarker, MMapTileDataSource, MMapContextProvider } from "../../../imperative";
 import { type EntityConstructor, type GenericEntity } from "../../../imperative/Entities";
 import type { ComputedMMapMarkerContainerProps } from "../overrides/MMapMarker";
 export declare const MMapVuefyOptions: CustomVuefyOptions<MMap>;
@@ -13,5 +13,6 @@ export declare const MMapLayerVuefyOptions: CustomVuefyOptions<MMapLayer>;
 export declare const MMapMarkerVuefyOptions: CustomVuefyOptions<MMapMarker, ComputedMMapMarkerContainerProps>;
 export declare const MMapTileDataSourceVuefyOptions: CustomVuefyOptions<MMapTileDataSource>;
 export declare const MMapContainerVuefyOptions: CustomVuefyOptions<MMapContainer>;
+export declare const MMapContextProviderVuefyOptions: CustomVuefyOptions<MMapContextProvider<unknown>>;
 declare const _default: Map<EntityConstructor<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>, CustomVuefyOptions<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>>;
 export default _default;

package/package.json

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

package/packages/clusterer/MMapClusterer/MMapClusterer.d.ts

@@ -58,16 +58,16 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<{
         features: Feature[];
         maxZoom?: number | undefined;
-        tickTimeout?: number | undefined;
         method: IClusterMethod;
+        tickTimeout?: number | undefined;
         onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;
         marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
         cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
         ref?: import("react").Ref<MMapEntity<{
             features: Feature[];
             maxZoom?: number | undefined;
-            tickTimeout?: number | undefined;
             method: IClusterMethod;
+            tickTimeout?: number | undefined;
             onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;
             marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
             cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/packages/markers/MMapDefaultMarker/index.d.ts

@@ -1,9 +1,9 @@
 import type { LngLat } from "../../../common/types";
 import type { MMapMarkerProps } from "../../../imperative/MMapMarker";
 type DefaultMarkerCustomProps = {
-    /** Marker title */
+    /** Marker title HTML */
     title?: string;
-    /** Marker subtitle */
+    /** Marker subtitle HTML */
     subtitle?: string;
     /** Marker icon color */
     color?: string;
@@ -62,9 +62,9 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         onDragMove?: import("../../../imperative/MMapMarker").MMapMarkerEventHandler | undefined;
         blockEvents?: boolean | undefined;
         blockBehaviors?: boolean | undefined;
-        onDoubleClick?: ((event: MouseEvent) => void) | undefined;
-        onClick?: ((event: MouseEvent) => void) | undefined;
-        onFastClick?: ((event: MouseEvent) => void) | undefined;
+        onDoubleClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
+        onClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
+        onFastClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
         title?: string | undefined;
         subtitle?: string | undefined;
         color?: string | undefined;

package/reactify/reactify.d.ts

@@ -14,6 +14,7 @@ export declare let ReactParent: React.Context<[
 export type Reactify = {
     module: ReactifyModule;
     entity: ReactifyEntity;
+    useDefault: <T>(value: T, dependencies?: unknown[]) => T;
 };
 export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
     reactify: {