@mappable-world/mappable-types 0.0.8 → 0.0.9

package/common/types/graphics.d.ts

@@ -21,6 +21,9 @@ interface DrawingStyleIcon {
     ];
     readonly scale?: number;
 }
+type HideOutsideRule = {
+    extent: number;
+} | true | false;
 interface DrawingStyle {
     zIndex?: number;
     fill?: string;
@@ -33,4 +36,4 @@ interface DrawingStyle {
     icon?: DrawingStyleIcon;
     element?: HTMLElement;
 }
-export { DrawingStyle, Palette, StrokeStyle, Stroke, DrawingStyleIcon, FillRule };
+export { DrawingStyle, Palette, StrokeStyle, Stroke, DrawingStyleIcon, FillRule, HideOutsideRule };

package/common/types/index.d.ts

@@ -9,6 +9,7 @@ export * from "./zoom";
 export * from "./zoom-strategy";
 export * from "./geojson";
 export * from "./layer-description";
+export * from "./layer-implementation";
 export * from "./indoor";
 export * from "./vec2";
 export * from "./camera";
@@ -18,3 +19,4 @@ export * from "./hotspot";
 export * from "./utils";
 export * from "./world-options";
 export * from "./data-source-description";
+export * from "./matrix";

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

@@ -4,6 +4,9 @@ interface VectorObjectsInteractiveArea {
     /** Minimal size of the side of the icons interactive area. */
     minSize?: number;
 }
+interface VectorModelsAnimationDescription {
+    duration: number;
+}
 type RasterLayerOptions = Record<string, unknown> & {
     opacity?: number;
     /**
@@ -18,24 +21,12 @@ type RasterLayerOptions = Record<string, unknown> & {
     tileRevealDuration?: number;
 };
 type VectorLayerOptions = Record<string, unknown> & {
-    modelsAppearingAnimation?: {
-        duration: number;
-    };
+    modelsAppearingAnimation?: VectorModelsAnimationDescription;
     iconsInteractiveArea?: VectorObjectsInteractiveArea;
-    transformLayers?: Record<string, {
-        color?: {
-            r: number;
-            g: number;
-            b: number;
-            a: number;
-        };
-        lightness?: number;
-        saturation?: number;
-        opacity?: number;
-    }>;
+    /** @deprecated Use layer.grouppedWith instead */
     parentLayerId?: string;
     opacity?: number;
     /** Isolates colliding of the layer's objects, not colliding them with other layers' objects */
     isolateObjectsColliding?: boolean;
 };
-export { RasterLayerOptions, VectorLayerOptions, VectorObjectsInteractiveArea };
+export { RasterLayerOptions, VectorLayerOptions, VectorObjectsInteractiveArea, VectorModelsAnimationDescription };

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

@@ -0,0 +1,65 @@
+import type { Matrix4 } from "./matrix";
+import type { RasterLayerOptions } from "./layer-description";
+import type { Vec2 } from "./vec2";
+import type { Camera } from "./camera";
+import type { WorldOptions } from "./world-options";
+import type { GenericProjection } from "./projection";
+import type { PixelCoordinates } from "./coordinates";
+interface WorldOffset {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface LayerImplementationRenderProps {
+    size: PixelCoordinates;
+}
+interface RasterLayerImplementationRenderProps extends LayerImplementationRenderProps {
+    camera: Camera;
+    worlds: WorldOffset[];
+}
+interface RasterLayerImplementation {
+    destroy(): void;
+    render(props: RasterLayerImplementationRenderProps): void;
+}
+interface RasterLayerImplementationConstructorProps {
+    requestRender: () => void;
+    size: PixelCoordinates;
+    element: HTMLElement;
+    camera: Camera;
+    worldOptions: WorldOptions;
+    projection: GenericProjection<unknown>;
+    options?: RasterLayerOptions;
+}
+interface RasterLayerImplementationConstructor {
+    new (props: RasterLayerImplementationConstructorProps): RasterLayerImplementation;
+}
+interface VectorLayerImplementationRenderProps extends LayerImplementationRenderProps {
+    camera: Camera;
+    worlds: {
+        lookAt: Vec2;
+        viewProjMatrix: Matrix4;
+    }[];
+}
+interface VectorLayerImplementation {
+    render(props: VectorLayerImplementationRenderProps): {
+        color: WebGLTexture;
+        depth?: WebGLTexture;
+    };
+    destroy(): void;
+}
+interface VectorLayerImplementationConstructor {
+    new (gl: WebGLRenderingContext, options: {
+        requestRender: () => void;
+    }): VectorLayerImplementation;
+}
+type LayerImplementationClassesProps<Mode extends 'raster' | 'vector' = 'raster' | 'vector'> = {
+    source: string;
+    type: string;
+    effectiveMode: Mode;
+};
+interface LayerImplementationClasses {
+    <Result extends RasterLayerImplementationConstructor = RasterLayerImplementationConstructor>(props: LayerImplementationClassesProps<'raster'>): Result;
+    <Result extends VectorLayerImplementationConstructor = VectorLayerImplementationConstructor>(props: LayerImplementationClassesProps<'vector'>): Result;
+}
+export { WorldOffset, RasterLayerImplementation, RasterLayerImplementationRenderProps, RasterLayerImplementationConstructor, RasterLayerImplementationConstructorProps, VectorLayerImplementation, VectorLayerImplementationRenderProps, VectorLayerImplementationConstructor, LayerImplementationClassesProps, LayerImplementationClasses };

package/common/types/matrix.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Matrix stored as an array in column-major order:
+ *
+ * ```
+ * [
+ *     m11, m21, m31, m41,
+ *     m12, m22, m32, m42,
+ *     m13, m23, m33, m43,
+ *     m14, m24, m34, m44
+ * ],
+ * ```
+ *
+ * where mij - matrix element in the i-th row and j-th column.
+ */
+interface Matrix4 {
+    [i: number]: number;
+    readonly length: number;
+}
+export { Matrix4 };

package/imperative/DomContext.d.ts

@@ -16,6 +16,7 @@ export declare function createDomContext(containerEntity: GenericComplexEntity<u
     DomContextDestroy
 ];
 export declare function useDomContext(entity: GenericComplexEntity<unknown>, element: Element, container: Element | null): () => void;
+/** @deprecated Use `useDomContext` instead. */
 export declare abstract class DomEntity<TProps, TElement extends Element = HTMLElement, DefaultProps extends {} = {}> extends MMapGroupEntity<TProps, DefaultProps> {
     protected _element?: TElement;
     private _detachDom?;

package/imperative/Entities.d.ts

@@ -19,7 +19,6 @@ declare abstract class GenericEntity<Props, DefaultProps extends {} = {}, Root e
          * @param {DefaultProps} defaultProps
          */
     constructor(props: Props);
-    destroy?(): void;
     update(changedProps: Partial<Props>): void;
     protected _onAttach?(): void;
     protected _onDetach?(): void;
@@ -57,6 +56,7 @@ declare abstract class GenericRootEntity<Props, DefaultProps extends {} = {}> ex
     get root(): this;
     protected _onAttach: undefined;
     protected _onDetach: undefined;
+    abstract destroy(): void;
 }
 type EntityProps<T extends GenericEntity<unknown>> = T extends GenericEntity<infer P> ? P : never;
 type EntityConstructor<TEntity extends GenericEntity<unknown>> = new (...args: any[]) => TEntity;

package/imperative/MMap/index.d.ts

@@ -3,7 +3,7 @@ import type { MMapEntity } from "../MMapEnities";
 import { GenericRootEntity } from "../Entities";
 import { MMapCopyrightsPosition } from "../MMapCopyrights";
 import { Config } from "../config";
-import { reactify } from "../../reactify";
+import { overrideKeyReactify } from "../wrappers";
 /**
  * Sets map center.
  */
@@ -161,6 +161,27 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         readonly config: Config;
         projection: Projection;
     }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMap, import("react").ForwardRefExoticComponent<{
+        className?: string | undefined;
+        location: MMapLocationRequest;
+        camera?: MMapCameraRequest | undefined;
+        mode?: MapMode | undefined;
+        behaviors?: BehaviorType[] | undefined;
+        restrictMapArea?: false | LngLatBounds | undefined;
+        zoomRange?: ZoomRange | undefined;
+        zoomStrategy?: ZoomStrategy | undefined;
+        zoomRounding?: ZoomRounding | undefined;
+        margin?: Margin | undefined;
+        config?: Config | undefined;
+        hotspotsStrategy?: "forViewport" | "forPointerPosition" | undefined;
+        copyrights?: boolean | undefined;
+        copyrightsPosition?: MMapCopyrightsPosition | undefined;
+        projection?: Projection | undefined;
+        worldOptions?: WorldOptions | undefined;
+        children?: import("react").ReactNode;
+        ref?: import("react").Ref<MMap> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     private readonly _rootContainer;
     private readonly _container;
     private readonly _resizeObserver;
@@ -169,6 +190,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
     private _layers;
     private _copyrights;
     private _coverage;
+    private _isDestroyed;
     constructor(rootContainer: HTMLElement, props: MMapProps, children?: MMapEntity<unknown>[]);
     readonly children: MMapEntity<unknown>[];
     addChild(child: MMapEntity<unknown>, index?: number): this;

package/imperative/MMapControl/MMapControl.d.ts

@@ -1,5 +1,5 @@
 import { DomEntity } from "../DomContext";
-import { reactify } from "../../reactify";
+import { overrideKeyReactify } from "../wrappers";
 /**
  * MMapControl props
  */
@@ -31,6 +31,13 @@ export type MMapControlProps = {};
  * @module MMapControl
  */
 export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends DomEntity<T> {
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl<MMapControlProps>, import("react").ForwardRefExoticComponent<{
+        children?: import("react").ReactNode;
+        ref?: import("react").Ref<import("../Entities").GenericEntity<{
+            controlElement: HTMLElement;
+        }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     protected _createDom(): {
         element: HTMLElement;
         container: HTMLElement;

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -1,6 +1,6 @@
 import { DomEntity } from "../DomContext";
 import { MMapComplexEntity } from "../MMapEnities";
-import { reactify } from "../../reactify";
+import { overrideKeyReactify } from "../wrappers";
 /**
  * MMapControlButton props
  */
@@ -49,6 +49,17 @@ export declare class MMapControlCommonButton extends DomEntity<MMapControlCommon
  * @see https://mappable.world/docs/jsapi/dg/concepts/controls/about.html
  */
 export declare class MMapControlButton extends MMapComplexEntity<MMapControlButtonProps> {
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControlButton, import("react").ForwardRefExoticComponent<{
+        onClick?: (() => void) | undefined;
+        disabled?: boolean | undefined;
+        text?: string | undefined;
+        color?: string | undefined;
+        background?: string | undefined;
+        element?: HTMLElement | undefined;
+        children?: import("react").ReactNode;
+        ref?: import("react").Ref<import("../Entities").GenericEntity<MMapControlCommonButtonProps, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     private _control;
     private _button;
     constructor(props: MMapControlButtonProps);

package/imperative/MMapFeature/index.d.ts

@@ -1,4 +1,4 @@
-import type { DrawingStyle, GenericGeometry, LngLat } from "../../common/types";
+import type { DrawingStyle, GenericGeometry, LngLat, HideOutsideRule } from "../../common/types";
 import type { DraggableProps, FeatureClickEvents } from "./types";
 import { MMapEntity } from "../MMapEnities";
 import type { Geometry, MMapFeatureEventHandler } from "./types";
@@ -13,6 +13,8 @@ type MMapFeatureProps = {
     properties?: Record<string, unknown>;
     /** Do not round coordinates */
     disableRoundCoordinates?: boolean;
+    /** Hide the marker if it goes beyond the edge of the viewport */
+    hideOutsideViewport?: HideOutsideRule;
 } & DraggableProps<MMapFeatureEventHandler> & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     source: "mappable-default-feature";
@@ -55,7 +57,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     get geometry(): GenericGeometry<LngLat>;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate({ style, id, source, disableRoundCoordinates }: Partial<MMapFeatureProps>): void;
+    protected _onUpdate({ style, id, source, disableRoundCoordinates, hideOutsideViewport: newHideOutsideViewport }: Partial<MMapFeatureProps>): void;
     private __onDragStart;
     private __onDragMove;
     private __onDragEnd;

package/imperative/MMapLayer/index.d.ts

@@ -1,21 +1,26 @@
 import type { RasterLayerOptions } from "../../common/types";
 import { MMapEntity } from "../MMapEnities";
+import type { LayerImplementationClasses } from "../../common/types/layer-implementation";
 /**
  * MMapLayer props
  */
 type MMapLayerProps = {
     /** Layer id */
     id?: string;
-    /** Layer source */
-    source: string;
     /** Layer type. For tile data sources should use 'ground' */
     type: string;
+    /** Layer source */
+    source?: string;
     /** Layer z-index to control order. Default is 1500 */
     zIndex?: number;
+    /** Layer id to control order in parent group */
+    grouppedWith?: string;
     /** Layer options */
     options?: {
         raster?: RasterLayerOptions;
     };
+    /** Method, allows you to define your own implementation of the layer */
+    implementation?: LayerImplementationClasses;
 };
 declare const defaultProps: Readonly<{
     zIndex: 1500;

package/imperative/MMapMarker/index.d.ts

@@ -1,7 +1,7 @@
-import type { LngLat } from "../../common/types";
+import type { HideOutsideRule, LngLat } from "../../common/types";
 import type { DraggableProps, FeatureClickEvents } from "../MMapFeature/types";
 import { MMapGroupEntity } from "../MMapEnities";
-import { reactify } from "../../reactify";
+import { overrideKeyReactify } from "../wrappers";
 /**
  * MMapMarker events handler
  */
@@ -19,12 +19,37 @@ type MMapMarkerProps = {
     id?: string;
     /** Do not round coordinates */
     disableRoundCoordinates?: boolean;
+    /**
+         * Hide the marker if it goes beyond the edge of the viewport.
+         * Two modes of operation are supported true and {extent: number}
+         * ```js
+         * const marker = new MMapMarker({
+         *  //...,
+         *  hideOutsideViewport: true
+         * })
+         * ```
+         * A point element will be removed from the map to optimize DOM size if its coordinates are 100px outside the visible area of the map.
+         * For most markers, this is sufficient.
+         * But for very large markers, this can cause an unpleasant blinking effect.
+         *
+         * ```js
+         * const marker = new MMapMarker({
+         *  //...,
+         *  hideOutsideViewport: {
+         *      extent: 1000
+         *  }
+         * })
+         * ```
+         * A point will be removed from the map if its coordinates are 1000px outside the visible area of the map.
+         */
+    hideOutsideViewport?: HideOutsideRule;
 } & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     draggable: false;
     mapFollowsOnDrag: false;
     blockEvents: false;
     blockBehaviors: false;
+    hideOutsideViewport: false;
     zIndex: 0;
     source: "mappable-default-feature";
 }>;
@@ -52,9 +77,71 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
         mapFollowsOnDrag: false;
         blockEvents: false;
         blockBehaviors: false;
+        hideOutsideViewport: false;
         zIndex: 0;
         source: "mappable-default-feature";
     }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapMarker, import("react").ForwardRefExoticComponent<{
+        coordinates: LngLat;
+        source?: string | undefined;
+        zIndex?: number | undefined;
+        properties?: Record<string, unknown> | undefined;
+        id?: string | undefined;
+        disableRoundCoordinates?: boolean | undefined;
+        hideOutsideViewport?: HideOutsideRule | undefined;
+        draggable?: boolean | undefined;
+        mapFollowsOnDrag?: boolean | {
+            activeZoneMargin?: import("../../common/types/margin").Margin | undefined;
+        } | undefined;
+        onDragStart?: MMapMarkerEventHandler | undefined;
+        onDragEnd?: MMapMarkerEventHandler | undefined;
+        onDragMove?: MMapMarkerEventHandler | undefined;
+        blockEvents?: boolean | undefined;
+        blockBehaviors?: boolean | undefined;
+        onDoubleClick?: ((event: MouseEvent) => void) | undefined;
+        onClick?: ((event: MouseEvent) => void) | undefined;
+        onFastClick?: ((event: MouseEvent) => void) | undefined;
+        markerElement?: HTMLElement | undefined;
+        children?: import("react").ReactNode;
+        ref?: import("react").Ref<import("../Entities").GenericEntity<{
+            /** Coordinates of the marker */
+            coordinates: LngLat;
+            source?: string | undefined;
+            /** z index of the marker, defaults to 0 */
+            zIndex?: number | undefined;
+            properties?: Record<string, unknown> | undefined;
+            id?: string | undefined;
+            /** Do not round coordinates */
+            disableRoundCoordinates?: boolean | undefined;
+            /**
+                         * Hide the marker if it goes beyond the edge of the viewport.
+                         * Two modes of operation are supported true and {extent: number}
+                         * ```js
+                         * const marker = new MMapMarker({
+                         *  //...,
+                         *  hideOutsideViewport: true
+                         * })
+                         * ```
+                         * A point element will be removed from the map to optimize DOM size if its coordinates are 100px outside the visible area of the map.
+                         * For most markers, this is sufficient.
+                         * But for very large markers, this can cause an unpleasant blinking effect.
+                         *
+                         * ```js
+                         * const marker = new MMapMarker({
+                         *  //...,
+                         *  hideOutsideViewport: {
+                         *      extent: 1000
+                         *  }
+                         * })
+                         * ```
+                         * A point will be removed from the map if its coordinates are 1000px outside the visible area of the map.
+                         */
+            hideOutsideViewport?: HideOutsideRule | undefined;
+        } & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents & {
+            markerElement?: HTMLElement | undefined;
+        }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     readonly element: HTMLElement;
     private _destroyDomCtx?;
     constructor(props: MMapMarkerProps, element?: HTMLElement);
@@ -63,6 +150,7 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
         mapFollowsOnDrag: false;
         blockEvents: false;
         blockBehaviors: false;
+        hideOutsideViewport: false;
         zIndex: 0;
         source: "mappable-default-feature";
     }>;

package/imperative/{search.d.ts → search/index.d.ts}

@@ -1,11 +1,7 @@
-import type { LngLat, LngLatBounds } from "../common/types";
-import { Config } from "./config";
-declare const geocoderSearchTypes: {
-    businesses: string;
-    toponyms: string;
-};
-type GeocoderSearchType = keyof typeof geocoderSearchTypes;
-type SearchOptions = {
+import type { LngLat, LngLatBounds } from "../../common/types";
+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;
     /**
@@ -14,9 +10,12 @@ type SearchOptions = {
          * if both types are queried):
          * - toponyms
          * - businesses
-         * */
-    type?: GeocoderSearchType[];
-    /** Map zoom. */
+         **/
+    type?: SearchType[];
+    /**
+         * @deprecated
+         * Map zoom.
+         **/
     zoom?: number;
     /**
          * Flag that defines whether
@@ -29,7 +28,7 @@ type SearchOptions = {
          * false — the search area is *not* restricted
          *
          * true — the search area is restricted
-         * */
+         **/
     strictBounds?: boolean;
     /**
          * The maximum amount of returned objects.
@@ -39,19 +38,19 @@ type SearchOptions = {
          * **10** is default.
          *
          * **100** is maximum.
-         * */
+         **/
     limit?: number;
     /**
          * The amount of objects (if any returned) that are skipped starting from the first one.
          *
          * Parameter {@link SearchOptions.limit `limit`} must be provided.
-         * */
+         **/
     offset?: number;
     /**
          * {@link LngLat `LngLat`} of the center point of search area.
          *
          * {@link SearchOptions.span `span`} parameter sets the length of the search area.
-         * */
+         **/
     center?: LngLat;
     /**
          * Parameter {@link span `span`} is specified with two numbers that represent
@@ -62,11 +61,11 @@ type SearchOptions = {
     span?: LngLat;
     /**
          * {@link bounds `bounds`} parameter has priority over
-         * {@link SearchOptions.ll `ll`} and {@link SearchOptions.spn `span`}
-         * */
+         * {@link SearchOptions.center `center`} and {@link SearchOptions.spn `span`}
+         **/
     bounds?: LngLatBounds;
 };
-type RawFeature = {
+export type Feature = {
     properties: {
         name: string;
         description: string;
@@ -76,8 +75,13 @@ type RawFeature = {
         coordinates: LngLat;
     };
 };
-type Feature = RawFeature;
-type SearchResponse = Feature[];
-declare function search(options: SearchOptions, config?: Config | undefined): Promise<SearchResponse>;
-export { search };
-export type { SearchOptions, SearchResponse };
+export type SearchResponse = Feature[];
+/**
+ * Static function to work with Search API.
+ *
+ *
+ * @param {SearchOptions} options Request options
+ * @param {Config} config Current config
+ * @returns {Promise<SearchResponse>}
+ */
+export declare function search(options: SearchOptions, config?: Config | undefined): Promise<SearchResponse>;

package/imperative/{suggest.d.ts → suggest/index.d.ts}

@@ -1,5 +1,5 @@
-import type { LngLat, LngLatBounds } from "../common/types";
-import { Config } from "./config";
+import type { LngLat, LngLatBounds } from "../../common/types";
+import { Config } from "../config";
 type DeprecatedGeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
 type GeoSuggestType = "biz" | "geo" | "street" | "metro" | "district" | "locality" | "area" | "province" | "country" | "house";
 export type SuggestOptions = {

package/package.json

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

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

@@ -50,13 +50,23 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     static defaultProps: Readonly<{
         tickTimeout: 200;
     }>;
-    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<Pick<MMapClustererProps, "features" | "tickTimeout" | "method" | "onRender"> & {
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<{
+        features: Feature[];
+        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>>;
-    } & import("react").RefAttributes<MMapEntity<Pick<MMapClustererProps, "features" | "tickTimeout" | "method" | "onRender"> & {
-        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[];
+            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>>;
+        }, {}>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     /** All created entities with cluster id*/
     private _entitiesCache;
     /** Viewport entities with cluster id */

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

@@ -1,6 +1,6 @@
 import type TReact from "react";
 import type { LngLat, MMapEntity } from "../../../..";
-import type { CustomReactify, OverrideProps } from "../../../../reactify/reactify";
+import type { CustomReactify, OverrideProps, Prettify } from "../../../../reactify/reactify";
 import type { Feature } from "../interface";
 import type { MMapClusterer as MMapClustererI, MMapClustererProps } from "../MMapClusterer";
 /**
@@ -33,12 +33,12 @@ import type { MMapClusterer as MMapClustererI, MMapClustererProps } from "../MMa
  * </MMap>
  * ```
  */
-type MMapClustererReactifiedProps = OverrideProps<MMapClustererProps, {
+type MMapClustererReactifiedProps = Prettify<OverrideProps<MMapClustererProps, {
     /** Function that returns MMapMarker react component to render marker*/
     marker: (feature: Feature) => TReact.ReactElement;
     /** Function that returns MMapMarker react component to render cluster*/
     cluster: (coordinates: LngLat, features: Feature[]) => TReact.ReactElement;
-}>;
-type MMapClustererR = TReact.ForwardRefExoticComponent<MMapClustererReactifiedProps & React.RefAttributes<MMapEntity<MMapClustererReactifiedProps>>>;
+}>>;
+type MMapClustererR = TReact.ForwardRefExoticComponent<Prettify<MMapClustererReactifiedProps & React.RefAttributes<MMapEntity<MMapClustererReactifiedProps>>>>;
 export declare const MMapClustererReactifyOverride: CustomReactify<MMapClustererI, MMapClustererR>;
 export {};

package/packages/hint/MMapHint/index.d.ts

@@ -1,7 +1,7 @@
 import type TReact from "react";
 import type { MMapFeature, MMapMarker, MMapHotspot } from "../../../imperative";
 import type { CustomReactify } from "../../../reactify/reactify";
-import { reactify } from "../../../reactify";
+import { overrideKeyReactify } from "../../../imperative/wrappers";
 type MMapHintProps = {
     hint: (object: MMapFeature | MMapMarker | MMapHotspot | undefined) => unknown;
 };
@@ -39,6 +39,7 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  * ```
  */
 declare class MMapHint extends mappable.MMapGroupEntity<MMapHintProps> {
+    static [overrideKeyReactify]: CustomReactify<MMapHint, TReact.FC<MMapHintProps>>;
     private _destroyDomContext;
     private _detachDom;
     private _element;

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

@@ -23,6 +23,7 @@ type DefaultMarkerCustomProps = {
 type MMapDefaultMarkerProps = MMapMarkerProps & DefaultMarkerCustomProps;
 declare const defaultProps: Readonly<{
     color: "#f33";
+    hideOutsideViewport: true;
 }>;
 type DefaultProps = typeof defaultProps;
 /**
@@ -42,6 +43,7 @@ type DefaultProps = typeof defaultProps;
 declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMarkerProps, DefaultProps> {
     static defaultProps: Readonly<{
         color: "#f33";
+        hideOutsideViewport: true;
     }>;
     static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
         coordinates: LngLat;
@@ -50,9 +52,34 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         properties?: Record<string, unknown> | undefined;
         id?: string | undefined;
         disableRoundCoordinates?: boolean | undefined;
-    } & import("../../../imperative/MMapFeature/types").DraggableProps<import("../../../imperative/MMapMarker").MMapMarkerEventHandler> & import("../../../imperative/MMapFeature/types").FeatureClickEvents & DefaultMarkerCustomProps & {
+        hideOutsideViewport?: import("../../../common/types/graphics").HideOutsideRule | undefined;
+        draggable?: boolean | undefined;
+        mapFollowsOnDrag?: boolean | {
+            activeZoneMargin?: import("../../../common/types/margin").Margin | undefined;
+        } | undefined;
+        onDragStart?: import("../../../imperative/MMapMarker").MMapMarkerEventHandler | undefined;
+        onDragEnd?: import("../../../imperative/MMapMarker").MMapMarkerEventHandler | undefined;
+        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;
+        title?: string | undefined;
+        subtitle?: string | undefined;
+        color?: string | undefined;
+        popup?: {
+            /** Popup content */
+            content: string | ((close: () => void) => HTMLElement);
+            /** Popup position */
+            position: "top" | "left" | "right";
+            /** Should popup hide marker. Default is false */
+            hidesMarker?: boolean | undefined;
+        } | undefined;
         children?: import("react").ReactNode;
-    } & import("react").RefAttributes<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>>>>;
+        ref?: import("react").Ref<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>> | undefined;
+        key?: import("react").Key | null | undefined;
+    }>>;
     private _marker;
     private _container;
     private _popup;

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

@@ -1,8 +1,8 @@
 import type TReactNamespace from "react";
-import type { CustomReactify } from "../../../../reactify/reactify";
+import type { CustomReactify, Prettify } from "../../../../reactify/reactify";
 import type { MMapEntity } from "../../../..";
 import { MMapDefaultMarker, MMapDefaultMarkerProps } from "../index";
 type MMapDefaultMarkerContainerProps = TReactNamespace.PropsWithChildren<MMapDefaultMarkerProps>;
-type MMapDefaultMarkerR = TReactNamespace.ForwardRefExoticComponent<MMapDefaultMarkerContainerProps & React.RefAttributes<MMapEntity<MMapDefaultMarkerProps>>>;
+type MMapDefaultMarkerR = TReactNamespace.ForwardRefExoticComponent<Prettify<MMapDefaultMarkerContainerProps & React.RefAttributes<MMapEntity<MMapDefaultMarkerProps>>>>;
 export declare const MMapDefaultMarkerReactifyOverride: CustomReactify<MMapDefaultMarker, MMapDefaultMarkerR>;
 export {};

package/reactify/overrides/MMap.d.ts

@@ -1,7 +1,6 @@
 import type TReact from "react";
-import type { CustomReactify } from "../reactify";
-import type { GenericRootEntity } from "../../imperative/Entities";
-import type { MMap as MMapI, MMapProps } from "../../imperative/MMap";
+import type { CustomReactify, Prettify } from "../reactify";
+import type { MMap as MMapI, MMapProps as MMapPropsI } from "../../imperative/MMap";
 declare global {
     namespace JSX {
         interface IntrinsicElements {
@@ -9,10 +8,7 @@ declare global {
         }
     }
 }
-type ComputedMMapProps = MMapProps & {
-    container: HTMLElement;
-};
-type MMapContainerProps = TReact.PropsWithChildren<MMapProps>;
-type MMapR = TReact.ForwardRefExoticComponent<MMapContainerProps & TReact.RefAttributes<GenericRootEntity<ComputedMMapProps>>>;
+type MMapContainerProps = TReact.PropsWithChildren<MMapPropsI>;
+type MMapR = TReact.ForwardRefExoticComponent<Prettify<MMapContainerProps & TReact.RefAttributes<MMapI>>>;
 export declare const MMapReactifyOverride: CustomReactify<MMapI, MMapR>;
 export {};

package/reactify/overrides/MMapControl.d.ts

@@ -1,11 +1,11 @@
 import type TReact from "react";
-import type { CustomReactify } from "../reactify";
+import type { CustomReactify, Prettify } from "../reactify";
 import type { GenericEntity } from "../../imperative/Entities";
 import type { MMapControl as MMapControlI, MMapControlProps } from "../../imperative/MMapControl";
 type ComputedMMapControlProps = MMapControlProps & {
     controlElement: HTMLElement;
 };
 type MMapControlContainerProps = TReact.PropsWithChildren<MMapControlProps>;
-type MMapControlR = TReact.ForwardRefExoticComponent<MMapControlContainerProps & React.RefAttributes<GenericEntity<ComputedMMapControlProps>>>;
+type MMapControlR = TReact.ForwardRefExoticComponent<Prettify<MMapControlContainerProps & React.RefAttributes<GenericEntity<ComputedMMapControlProps>>>>;
 export declare const MMapControlReactifyOverride: CustomReactify<MMapControlI, MMapControlR>;
 export {};

package/reactify/overrides/MMapControlButton.d.ts

@@ -1,8 +1,8 @@
 import type TReact from "react";
-import type { CustomReactify } from "../reactify";
+import type { CustomReactify, Prettify } from "../reactify";
 import type { MMapControlButton as MMapControlButtonI, MMapControlButtonProps } from "../../imperative/MMapControl";
 import type { GenericEntity } from "../../imperative/Entities";
 type MMapControlButtonContainerProps = TReact.PropsWithChildren<MMapControlButtonProps>;
-type MMapControlButtonR = TReact.ForwardRefExoticComponent<MMapControlButtonContainerProps & React.RefAttributes<GenericEntity<MMapControlButtonProps>>>;
+type MMapControlButtonR = TReact.ForwardRefExoticComponent<Prettify<MMapControlButtonContainerProps & React.RefAttributes<GenericEntity<MMapControlButtonProps>>>>;
 export declare const MMapControlButtonReactifyOverride: CustomReactify<MMapControlButtonI, MMapControlButtonR>;
 export {};

package/reactify/overrides/MMapMarker.d.ts

@@ -1,11 +1,11 @@
 import type TReactNamespace from "react";
-import type { CustomReactify } from "../reactify";
+import type { CustomReactify, Prettify } from "../reactify";
 import type { GenericEntity } from "../../imperative/Entities";
 import type { MMapMarker as MMapMarkerI, MMapMarkerProps } from "../../imperative/MMapMarker";
 type ComputedMMapMarkerProps = MMapMarkerProps & {
     markerElement?: HTMLElement;
 };
 type MMapMarkerContainerProps = TReactNamespace.PropsWithChildren<ComputedMMapMarkerProps>;
-type MMapMarkerR = TReactNamespace.ForwardRefExoticComponent<MMapMarkerContainerProps & React.RefAttributes<GenericEntity<ComputedMMapMarkerProps>>>;
+type MMapMarkerR = TReactNamespace.ForwardRefExoticComponent<Prettify<MMapMarkerContainerProps & React.RefAttributes<GenericEntity<ComputedMMapMarkerProps>>>>;
 export declare const MMapMarkerReactifyOverride: CustomReactify<MMapMarkerI, MMapMarkerR>;
 export {};

package/reactify/reactify.d.ts

@@ -41,6 +41,9 @@ export type ReactifiedModule<TModule extends BaseModule> = {
     [Property in keyof TModule]: TModule[Property] extends EntityConstructor<GenericEntity<unknown>> ? ReturnType<InternalReactifyEntity<TModule[Property]>> : TModule[Property] extends typeof Context ? ReturnType<GetReactContext<TModule[Property]>> : TModule[Property];
 };
 export type BaseModule = Record<string | symbol, unknown>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 export type OverrideProps<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 export default function createReactify(React: typeof TReact, ReactDOM: typeof TReactDOM): Reactify;
 export {};