@mappable-world/mappable-types 0.0.12 → 0.0.13

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

@@ -19,7 +19,7 @@ type VectorCustomizationStyler = {
 };
 type VectorCustomizationTypes = 'point' | 'polyline' | 'polygon';
 type VectorCustomizationElements = 'geometry' | 'geometry.fill' | 'geometry.fill.pattern' | 'geometry.outline' | 'label' | 'label.icon' | 'label.text' | 'label.text.fill' | 'label.text.outline';
-type VectorCustomization = {
+type VectorCustomizationItem = {
     tags?: {
         all?: string | string[];
         any?: string | string[];
@@ -28,7 +28,8 @@ type VectorCustomization = {
     types?: VectorCustomizationTypes | VectorCustomizationTypes[];
     elements?: VectorCustomizationElements | VectorCustomizationElements[];
     stylers?: VectorCustomizationStyler | VectorCustomizationStyler[];
-}[];
+};
+type VectorCustomization = VectorCustomizationItem[];
 interface WorldHotspot {
     readonly type: 'world';
     readonly feature: HotspotFeature<unknown>;
@@ -134,4 +135,4 @@ interface VectorTileDataSourceDescription {
     /** Defines how hotspots of type should be treated: enabled/disabled or use custom hotspots instead. */
     hotspots?: Record<string, boolean | FetchHotspotsFunction | HotspotsOptions>;
 }
-export { 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, FetchedTile, MapTheme };

package/imperative/DomContext.d.ts

@@ -15,8 +15,15 @@ export declare function createDomContext(containerEntity: GenericComplexEntity<u
     DomContext,
     DomContextDestroy
 ];
-export declare function useDomContext(entity: GenericComplexEntity<unknown>, element: Element, container: Element | null): () => void;
-/** @deprecated Use `useDomContext` instead. */
+/**
+ * Hook for providing DOM context in entity
+ * @param entity - Entity to provide the DomContext
+ * @param element - Dom element that is passed to DomContext
+ * @param container - Inner DOM element that is passed to the DOMContext
+ * @returns Function that detaches the DOM element and DomContext from the entity
+ */
+export declare function useDomContext(entity: GenericComplexEntity<unknown>, element: Element, container: Element | null): DomDetach;
+/** @deprecated Use {@link 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

@@ -12,39 +12,177 @@ declare class ContextProvider<T> {
 type WithDefaults<Props, DefaultProps extends Partial<Props>> = Props & {
     [K in keyof DefaultProps]: K extends keyof Props ? NonNullable<Props[K]> : never;
 };
+/**
+ * Entity Base Class. It has event handlers for attaching, detaching and updating props. Has a method for providing and using context.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @typeParam Root - Root Entity Class.
+ * @example
+ * ```ts
+ * type MMapSomeEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps> {
+ *  public isAttached: boolean;
+ *  constructor(props: MMapSomeEntityProps) {
+ *      super(props);
+ *      this.isAttached = false
+ *      // Additional actions can be taken in the constructor of a class.
+ *  }
+ *  protected _onAttach(): void {
+ *      this.isAttached = true;
+ *      // Additional actions can be taken when an Entity is attached.
+ *  }
+ *  // ...
+ * }
+ * ```
+ */
 declare abstract class GenericEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
+    /**
+         * The value of input props.
+         */
     protected _props: WithDefaults<Props, DefaultProps>;
     /**
-         * @param {Props} props
-         * @param {DefaultProps} defaultProps
+         * @param props - The value of input props.
          */
     constructor(props: Props);
+    /**
+         * Method for updating props of Entity.
+         * @param changedProps - New props values.
+         */
     update(changedProps: Partial<Props>): void;
+    /**
+         * Handler of the attachment event to the parent Entity.
+         * @virtual
+         */
     protected _onAttach?(): void;
+    /**
+         * Handler of the detachment event to the parent Entity.
+         * @virtual
+         */
     protected _onDetach?(): void;
+    /**
+         * Handler of the update event to the current Entity.
+         * @param props - New props values.
+         * @param oldProps - Previous props values.
+         * @virtual
+         */
     protected _onUpdate?(props: Partial<Props>, oldProps: Props): void;
+    /**
+         * Get parent entity.
+         */
     get parent(): GenericComplexEntity<unknown> | null;
+    /**
+         * Get root entity.
+         */
     get root(): Root | null;
+    /**
+         * Provides context in the Entity.
+         * @param consumer - The context that provides access to the context value.
+         * @param ctx - The value passed to the context.
+         */
     protected _provideContext<T>(consumer: Context<T>, ctx: T): void;
+    /**
+         * Gets the value from the passed context.
+         * @param consumer - The context that provides access to the context value.
+         * @returns Context value.
+         */
     protected _consumeContext<T>(consumer: Context<T>): T | undefined;
 }
 interface ComplexOptions<Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> {
     children?: GenericEntity<unknown, {}, Root>[];
     container?: boolean;
 }
+/**
+ * Entity that aggregates multiple Entities but looks basic from the outside.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @typeParam Root - Root Entity Class.
+ * @example
+ * ```ts
+ * type MMapSomeComplexEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeComplexEntity extends GenericComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
+ *  private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
+ *  protected _onAttach(): void {
+ *      this._someEntity = new MMapSomeEntity();
+ *      this.addChild(this._someEntity); // add someEntity as children
+ *      // ...
+ *  }
+ *  // ...
+ * }
+ * ```
+ */
 declare class GenericComplexEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> extends GenericEntity<Props, DefaultProps, Root> {
+    /**
+         * Array of child Entities of the current ComplexEntity.
+         */
     protected readonly children: readonly GenericEntity<unknown, {}, Root>[];
     protected readonly _childContainer: GenericComplexEntity<unknown, {}, Root>;
+    /**
+         * @param props - The value of input props.
+         * @param options - Optional options object.
+         * @param children - Array of child Entities of the current ComplexEntity.
+         * @param options.children - Array of child Entities of the current ComplexEntity.
+         * @param options.container - Creating a proxy container inside ComplexEntity.
+         */
     constructor(props: Props, options?: ComplexOptions<Root>);
+    constructor(props: Props, children?: GenericEntity<unknown, {}, Root>[], options?: Omit<ComplexOptions<Root>, "children">);
     protected __makeProxyContainer(): GenericComplexEntity<unknown, {}, Root>;
     /**
-         * Adds a child directly to __implChildren, without _childContainer
+         * Adds a child directly to __implChildren, without _childContainer.
+         * @param child - Child Entity to be added
+         * @param index - 0-based ordinal number of the entity being added
          */
     protected _addDirectChild(child: GenericEntity<unknown, {}, Root>, index?: number): void;
+    /**
+         * Adds a child directly to  _childContainer
+         * @param child - Child Entity to be added
+         * @param index - 0-based ordinal number of the entity being added
+         * @returns Current ComplexEntity
+         */
     protected addChild(child: GenericEntity<unknown, {}, Root>, index?: number): this;
+    /**
+         * Deletes a child element directly in __implChildren, without _childContainer.
+         * @param child - Child Entity to be removed
+         */
     protected _removeDirectChild(child: GenericEntity<unknown, {}, Root>): void;
+    /**
+         * Deletes a child directly to  _childContainer
+         * @param child - Child Entity to be removed
+         * @returns Current ComplexEntity
+         */
     protected removeChild(child: GenericEntity<unknown, {}, Root>): this;
 }
+/**
+ * Entity that aggregates multiple Entities, and allows you to publicly add and remove entities to a subtree.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @typeParam Root - Root Entity Class.
+ * @example
+ * ```ts
+ * type MMapSomeGroupEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeGroupEntity extends GenericGroupEntity<MMapSomeGroupEntityProps, typeof defaultProps> {
+ *  // ...
+ * }
+ * const groupEntity = new MMapSomeGroupEntity()
+ * const someEntity = new MMapSomeEntity(); // MMapSomeEntity extends GenericEntity
+ * groupEntity.addChild(someEntity); // add someEntity in MMapSomeGroupEntity object
+ * groupEntity.removeChild(someEntity); // remove someEntity from MMapSomeGroupEntity object
+ * ```
+ */
 declare class GenericGroupEntity<Props, DefaultProps extends {} = {}, Root extends GenericRootEntity<unknown> = GenericRootEntity<unknown>> extends GenericComplexEntity<Props, DefaultProps, Root> {
     readonly children: readonly GenericEntity<unknown, {}, Root>[];
     protected readonly _childContainer: GenericGroupEntity<unknown, {}, Root>;
@@ -52,10 +190,29 @@ declare class GenericGroupEntity<Props, DefaultProps extends {} = {}, Root exten
     addChild(child: GenericEntity<unknown, {}, Root>, index?: number): this;
     removeChild(child: GenericEntity<unknown, {}, Root>): this;
 }
+/**
+ * Entity that is root and cannot be added anywhere
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @example
+ * type MMapProps = {
+ *  name?: string;
+ * };
+ * class MMap extends GenericRootEntity<MMapProps, typeof defaultProps> {
+ *  // ...
+ * }
+ * // Now we can specify their root element for the Entity
+ * class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps, MMap> {
+ *  // ...
+ * }
+ */
 declare abstract class GenericRootEntity<Props, DefaultProps extends {} = {}> extends GenericGroupEntity<Props, DefaultProps> {
     get root(): this;
     protected _onAttach: undefined;
     protected _onDetach: undefined;
+    /**
+         * Completely destroys the entity tree including the current entity
+         */
     abstract destroy(): void;
 }
 type EntityProps<T extends GenericEntity<unknown>> = T extends GenericEntity<infer P> ? P : never;

package/imperative/MMap/index.d.ts

@@ -3,6 +3,7 @@ import type { MMapEntity } from "../MMapEnities";
 import { GenericRootEntity } from "../Entities";
 import { MMapCopyrightsPosition } from "../MMapCopyrights";
 import { Config } from "../config";
+import { MMapTheme } from "../ThemeContext";
 import { overrideKeyReactify } from "../wrappers";
 /**
  * Sets map center.
@@ -92,6 +93,8 @@ export type MMapProps = {
          * Whether to repeat the world in X and Y
          */
     worldOptions?: WorldOptions;
+    /** Theme applied to the scheme */
+    theme?: MMapTheme;
 };
 declare const defaultProps: Readonly<{
     className: "";
@@ -115,6 +118,7 @@ declare const defaultProps: Readonly<{
     restrictMapArea: false;
     readonly config: Config;
     projection: Projection;
+    theme: "light";
 }>;
 type DefaultProps = typeof defaultProps;
 /**
@@ -160,6 +164,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         restrictMapArea: false;
         readonly config: Config;
         projection: Projection;
+        theme: "light";
     }>;
     static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMap, import("react").ForwardRefExoticComponent<{
         className?: string | undefined;
@@ -178,6 +183,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         copyrightsPosition?: MMapCopyrightsPosition | undefined;
         projection?: Projection | undefined;
         worldOptions?: WorldOptions | undefined;
+        theme?: MMapTheme | undefined;
         children?: import("react").ReactNode;
         ref?: import("react").Ref<MMap> | undefined;
         key?: import("react").Key | null | undefined;
@@ -238,6 +244,14 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * getter for {@link MMapProps}.config prop
          */
     get config(): Readonly<Config>;
+    /**
+         * getter for {@link MMapProps}.restrictMapArea prop
+         */
+    get restrictMapArea(): Readonly<LngLatBounds | false>;
+    /**
+         * getter for {@link MMapProps}.theme prop
+         */
+    get theme(): "light" | "dark";
     /**
          * setter for {@link MMapProps}.location prop
          * @param location
@@ -279,6 +293,11 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * @param {Projection} projection
          */
     setProjection(projection: Projection): void;
+    /**
+         * setter for {@link MMapProps}.config prop
+         * @param {LngLatBounds} restrictMapArea
+         */
+    setRestrictMapArea(restrictMapArea: LngLatBounds): void;
     /**
          * Destroy map and remove it from user DOM-element
          */
@@ -290,5 +309,6 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
     private __onVectorInitFailed;
     private __loadVectorEngine;
     private __toggleCopyrights;
+    private setTheme;
 }
 export { MMap };

package/imperative/MMapControl/MMapControl.d.ts

@@ -1,5 +1,5 @@
-import { DomEntity } from "../DomContext";
 import { overrideKeyReactify } from "../wrappers";
+import { MMapGroupEntity } from "../MMapEnities";
 /**
  * MMapControl props
  */
@@ -9,7 +9,7 @@ export type MMapControlProps = {};
  *
  * @example
  * ```javascript
- * const control = new MMapControl({});
+ * const control = new MMapControl();
  * class MMapSomeController extends DomEntity {
  *     _createDom() {
  *         const element = document.createElement('button');
@@ -30,7 +30,7 @@ export type MMapControlProps = {};
  *
  * @module MMapControl
  */
-export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends DomEntity<T> {
+export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends MMapGroupEntity<T> {
     static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl<MMapControlProps>, import("react").ForwardRefExoticComponent<{
         children?: import("react").ReactNode;
         ref?: import("react").Ref<import("../Entities").GenericEntity<{
@@ -38,9 +38,12 @@ export declare class MMapControl<T extends MMapControlProps = MMapControlProps>
         }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
         key?: import("react").Key | null | undefined;
     }>>;
-    protected _createDom(): {
-        element: HTMLElement;
-        container: HTMLElement;
-    };
-    protected _updateDom(element: HTMLElement): void;
+    private _detachDom?;
+    private _element?;
+    private _unwatchThemeContext?;
+    constructor();
+    protected _createDom(): HTMLElement;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    private _updateTheme;
 }

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -1,5 +1,4 @@
-import { DomEntity } from "../DomContext";
-import { MMapComplexEntity } from "../MMapEnities";
+import { MMapComplexEntity, MMapGroupEntity } from "../MMapEnities";
 import { overrideKeyReactify } from "../wrappers";
 /**
  * MMapControlButton props
@@ -23,12 +22,15 @@ export type MMapControlButtonProps = MMapControlCommonButtonProps;
 /**
  * Default control button.
  */
-export declare class MMapControlCommonButton extends DomEntity<MMapControlCommonButtonProps, HTMLButtonElement> {
-    protected _createDom(): {
-        element: HTMLButtonElement;
-        container: HTMLElement;
-    };
-    protected _updateDom(element: HTMLButtonElement, props: Partial<MMapControlCommonButtonProps>, init?: boolean): void;
+export declare class MMapControlCommonButton extends MMapGroupEntity<MMapControlCommonButtonProps> {
+    private _element?;
+    private _detachDom?;
+    private _unwatchThemeContext?;
+    protected _onAttach(): void;
+    private _updateElement;
+    protected _onUpdate(props: Partial<MMapControlCommonButtonProps>): void;
+    protected _onDetach(): void;
+    private _updateTheme;
 }
 /**
  * The control element - button.
@@ -62,7 +64,8 @@ export declare class MMapControlButton extends MMapComplexEntity<MMapControlButt
     }>>;
     private _control;
     private _button;
-    constructor(props: MMapControlButtonProps);
+    protected _onAttach(): void;
     protected _onUpdate(props: Partial<MMapControlButtonProps>): void;
+    protected _onDetach(): void;
     get text(): string | undefined;
 }

package/imperative/MMapControls/index.d.ts

@@ -1,4 +1,4 @@
-import { DomEntity } from "../DomContext";
+import { MMapEntity, MMapGroupEntity } from "../MMapEnities";
 type VerlicalPosition = "top" | "bottom";
 type HorizontalPosition = "left" | "right";
 type Orientation = "horizontal" | "vertical";
@@ -33,11 +33,12 @@ export type MMapControlsProps = {
  * map.addChild(controls);
  * ```
  */
-export declare class MMapControls extends DomEntity<MMapControlsProps> {
-    protected _createDom(): {
-        element: HTMLElement;
-        container: HTMLElement;
-    };
-    protected _updateDom(element: HTMLElement): void;
+export declare class MMapControls extends MMapGroupEntity<MMapControlsProps> {
+    private _element?;
+    private _detachDom?;
+    constructor(props: MMapControlsProps, children?: MMapEntity<unknown>[]);
+    protected _onAttach(): void;
+    protected _onUpdate(): void;
+    protected _onDetach(): void;
 }
 export {};

package/imperative/MMapCopyrights/index.d.ts

@@ -1,4 +1,4 @@
-import { DomEntity } from "../DomContext";
+import { MMapGroupEntity } from "../MMapEnities";
 type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom right";
 type MMapCopyrightsProps = {
     /** Position of copyright on the map */
@@ -12,7 +12,7 @@ type DefaultProps = typeof defaultProps;
  * The copyright display component on the map.
  * Data for display uses from the `MMapCoverage` component
  */
-declare class MMapCopyrights extends DomEntity<MMapCopyrightsProps, HTMLElement, DefaultProps> {
+declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, DefaultProps> {
     static defaultProps: Readonly<{
         position: MMapCopyrightsPosition;
     }>;
@@ -20,19 +20,23 @@ declare class MMapCopyrights extends DomEntity<MMapCopyrightsProps, HTMLElement,
     private _copyrightsTextElement;
     private _linkElement;
     private _logoElement;
+    private _copyrightsContainer;
     private _mapWidth;
     private _copyrights;
     private _fixedCopyrights;
     private _userAgreementText;
     private _userAgreementState;
     private _unwatchMapContext?;
+    private _unwatchThemeContext?;
+    private _detachDom?;
     constructor(props?: MMapCopyrightsProps);
     protected _updateDom(): void;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _createDom(): HTMLDivElement;
+    private _createDom;
     private _syncDom;
     private _syncMapWidth;
+    private _syncTheme;
     private _setUserAgreementText;
     private _setUserAgreementState;
     private _setCopyrights;
@@ -40,4 +44,4 @@ declare class MMapCopyrights extends DomEntity<MMapCopyrightsProps, HTMLElement,
     private _copyrightsChangeHandler;
     private _adjustText;
 }
-export { MMapCopyrights, MMapCopyrightsProps, MMapCopyrightsPosition };
+export { MMapCopyrights, MMapCopyrightsPosition, MMapCopyrightsProps };

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -6,9 +6,12 @@ import { MMapComplexEntity } from "../MMapEnities";
 type MMapDefaultSchemeLayerProps = {
     /** Should show layer */
     visible?: boolean;
-    /** Vector tiles customization. Not allowed on a free tariff. */
+    /** Vector tiles customization. */
     customization?: VectorCustomization;
-    /** Theme applied to the scheme */
+    /**
+         * Theme applied to the scheme
+         * @deprecated use {@link MMapProps}.theme prop in {@link MMap} instead
+         * */
     theme?: "dark" | "light";
 };
 declare const defaultProps: {
@@ -72,11 +75,13 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     private _dataSource?;
     private _layers;
     private _unwatchMapContext?;
+    private _unwatchThemeContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;
     private _createTileUrl;
     private _getProjectionQuery;
     private _getDataSourceDescription;
+    private _updateTheme;
 }
 export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps };

package/imperative/MMapEnities.d.ts

@@ -1,13 +1,86 @@
 import type { MMap } from "./MMap";
 import { GenericComplexEntity, GenericEntity, GenericGroupEntity, Context } from "./Entities";
+/**
+ * Entity Base Class. It has event handlers for attaching, detaching and updating props. Has a method for providing and using context.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @example
+ * ```ts
+ * type MMapSomeEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeEntity extends MMapEntity<MMapSomeEntityProps, typeof defaultProps> {
+ *  public isAttached: boolean;
+ *  constructor(props: MMapSomeEntityProps) {
+ *      super(props);
+ *      this.isAttached = false
+ *      // Additional actions can be taken in the constructor of a class.
+ *  }
+ *  protected _onAttach(): void {
+ *      this.isAttached = true;
+ *      // Additional actions can be taken when an Entity is attached.
+ *  }
+ *  // ...
+ * }
+ * ```
+ */
 declare abstract class MMapEntity<Props, DefaultProps extends {} = {}> extends GenericEntity<Props, DefaultProps, MMap> {
     get root(): null | MMap;
     get parent(): null | MMapComplexEntity<unknown>;
 }
+/**
+ * Entity that aggregates multiple Entities but looks basic from the outside.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @typeParam Root - Root Entity Class.
+ * @example
+ * ```ts
+ * type MMapSomeComplexEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeComplexEntity extends MMapComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
+ *  private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
+ *  protected _onAttach(): void {
+ *      this._someEntity = new MMapSomeEntity();
+ *      this.addChild(this._someEntity); // add someEntity as children
+ *      // ...
+ *  }
+ *  // ...
+ * }
+ * ```
+ */
 declare abstract class MMapComplexEntity<Props, DefaultProps extends {} = {}> extends GenericComplexEntity<Props, DefaultProps, MMap> implements MMapEntity<Props, DefaultProps> {
     get root(): null | MMap;
     get parent(): null | MMapComplexEntity<unknown>;
 }
+/**
+ * Entity that aggregates multiple Entities, and allows you to publicly add and remove entities to a subtree.
+ * @typeParam Props - Type of input props of the Entity.
+ * @typeParam DefaultProps - Type of default input props of the Entity.
+ * @typeParam Root - Root Entity Class.
+ * @example
+ * ```ts
+ * type MMapSomeGroupEntityProps = {
+ *  name?: string;
+ * };
+ * const defaultProps = {
+ *  name: 'entity'
+ * };
+ * class MMapSomeGroupEntity extends MMapGroupEntity<MMapSomeGroupEntityProps, typeof defaultProps> {
+ *  // ...
+ * }
+ * const groupEntity = new MMapSomeGroupEntity()
+ * const someEntity = new MMapSomeEntity(); // MMapSomeEntity extends GenericEntity
+ * groupEntity.addChild(someEntity); // add someEntity in MMapSomeGroupEntity object
+ * groupEntity.removeChild(someEntity); // remove someEntity from MMapSomeGroupEntity object
+ * ```
+ */
 declare abstract class MMapGroupEntity<Props, DefaultProps extends {} = {}> extends GenericGroupEntity<Props, DefaultProps, MMap> implements MMapComplexEntity<Props, DefaultProps> {
     get root(): null | MMap;
     get parent(): null | MMapComplexEntity<unknown>;

package/imperative/ThemeContext.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "./Entities";
+/**
+ * Sets map theme
+ */
+export type MMapTheme = "light" | "dark";
+export type MMapThemeContext = {
+    theme: MMapTheme;
+};
+export declare const ThemeContext: Context<MMapThemeContext>;

package/imperative/index.d.ts

@@ -1,4 +1,5 @@
 export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
+export { MMapThemeContext, ThemeContext, MMapTheme } from "./ThemeContext";
 export { MMapCopyrightsPosition } from "./MMapCopyrights";
 export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
 export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";
@@ -20,10 +21,10 @@ export * from "./search";
 export * from "./suggest";
 export * from "./route";
 export { geolocation } from "./geolocation";
-export { useDomContext } from "./DomContext";
+export { useDomContext, DomDetach } from "./DomContext";
 export { Config, getDefaultConfig } from "./config";
 export { fetchConfig, FetchConfigOptions } from "./fetchConfig";
 export * as projections from "./utils/projections";
 /** Toggle this to enable/disable strict mode. */
 export declare let strictMode: boolean;
-export type { LngLat, ReadonlyLngLat, LngLatBounds, BehaviorType, MapMode, Margin, ZoomRange, ZoomStrategy, ZoomRounding, VectorCustomization, RasterTileDataSourceDescription, VectorTileDataSourceDescription, RasterLayerOptions, EasingFunctionDescription, EasingPresetName, EasingBezierPreset, EasingFunction, DrawingStyle, DrawingStyleIcon, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority } from "../common/types";
+export type { LngLat, ReadonlyLngLat, LngLatBounds, BehaviorType, MapMode, Margin, ZoomRange, ZoomStrategy, ZoomRounding, VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, VectorTileDataSourceDescription, RasterLayerOptions, EasingFunctionDescription, EasingPresetName, EasingBezierPreset, EasingFunction, DrawingStyle, DrawingStyleIcon, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority } from "../common/types";

package/modules/editors/MMapFeatureEditor/MMapFeatureEditorDefaultPoint.d.ts

@@ -1,9 +1,8 @@
-import { DomEntity } from "../../../imperative/DomContext";
-declare class MMapFeatureEditorDefaultPoint extends DomEntity<{}> {
-    protected _createDom(): {
-        element: HTMLElement;
-        container: HTMLElement;
-    };
-    protected _updateDom(): void;
+import { MMapGroupEntity } from "../../../imperative";
+declare class MMapFeatureEditorDefaultPoint extends MMapGroupEntity<{}> {
+    private _detachDom?;
+    private _element?;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
 }
 export { MMapFeatureEditorDefaultPoint };

package/modules/editors/MMapFeatureEditor/MMapFeatureEditorDefaultPreviewPoint.d.ts

@@ -1,6 +1,8 @@
-import { DomEntity } from "../../../imperative/DomContext";
-declare class MMapFeatureEditorDefaultPreviewPoint extends DomEntity<{}> {
-    protected _createDom(): HTMLElement;
-    protected _updateDom(): void;
+import { MMapGroupEntity } from "../../../imperative";
+declare class MMapFeatureEditorDefaultPreviewPoint extends MMapGroupEntity<{}> {
+    private _detachDom?;
+    private _element?;
+    protected _onAttach(): void;
+    protected _onDetach(): void;
 }
 export { MMapFeatureEditorDefaultPreviewPoint };

package/modules/editors/MMapFeatureEditor/interface.d.ts

@@ -1,5 +1,5 @@
 import type { LngLat, DrawingStyle, GenericLineStringGeometry, GenericPolygonGeometry } from "../../../common/types";
-import type { DomEntity } from "../../../imperative/DomContext";
+import type { MMapEntity } from "../../../imperative";
 export type Geometry = GenericPolygonGeometry<LngLat> | GenericLineStringGeometry<LngLat>;
 export interface DraggingPoint {
     point: LngLat;
@@ -14,8 +14,8 @@ export type MMapFeatureEditorProps = {
     points: LngLat[];
     geometry: Geometry;
     featureStyle?: DrawingStyle;
-    renderPoint?: (index: number) => HTMLElement | DomEntity<unknown>;
-    previewPointElement?: false | HTMLElement | DomEntity<unknown>;
+    renderPoint?: (index: number) => HTMLElement | MMapEntity<unknown>;
+    previewPointElement?: false | HTMLElement | MMapEntity<unknown>;
     onLayerClick?: (coordinates: LngLat, index: number) => void;
     onPointClick?: (index: number) => void;
     onPointDblClick?: (index: number) => void;

package/package.json

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

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

@@ -17,6 +17,11 @@ type MMapClustererProps = {
     tickTimeout?: number;
     /** Return false, if you want to override the render */
     onRender?: (clusters: ClustererObject[]) => void | false;
+    /**
+         * Maximum zoom for clusterisation.
+         * If map zoom is bigger, markers will be displayed as is.
+         **/
+    maxZoom?: number;
 };
 type DefaultProps = typeof defaultProps;
 declare const defaultProps: Readonly<{
@@ -52,6 +57,7 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     }>;
     static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<{
         features: Feature[];
+        maxZoom?: number | undefined;
         method: IClusterMethod;
         tickTimeout?: number | undefined;
         onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;
@@ -59,6 +65,7 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
         cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
         ref?: import("react").Ref<MMapEntity<{
             features: Feature[];
+            maxZoom?: number | undefined;
             method: IClusterMethod;
             tickTimeout?: number | undefined;
             onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;

package/packages/controls/MMapGeolocationControl/MMapControlSpinner/index.d.ts

@@ -1,6 +1,8 @@
 declare class MMapControlSpinner extends mappable.MMapComplexEntity<{}> {
     private _detachDom?;
+    private _unwatchThemeContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
+    private _updateTheme;
 }
 export { MMapControlSpinner };

package/packages/controls/MMapGeolocationControl/index.d.ts

@@ -40,6 +40,7 @@ declare class MMapGeolocationControl extends mappable.MMapGroupEntity<MMapGeoloc
     private _loading;
     private _element;
     private _unwatchMapContext?;
+    private _unwatchThemeContext?;
     constructor(props: MMapGeolocationControlProps);
     private _timeout;
     private _setLoading;
@@ -51,5 +52,6 @@ declare class MMapGeolocationControl extends mappable.MMapGroupEntity<MMapGeoloc
     protected _onUpdate(props: Partial<MMapGeolocationControlProps>): void;
     private _initMarker;
     private _updateMarkerIcon;
+    private _updateTheme;
 }
 export { MMapGeolocationControl, MMapGeolocationControlProps };

package/packages/controls/MMapZoomControl/index.d.ts

@@ -1,6 +1,7 @@
 import type { EasingFunctionDescription } from "../../../common/types";
 import type { MMapControlCommonButton } from "../../../imperative/MMapControl";
 import type { MMapListener } from "../../../imperative/MMapListener";
+import type { DomDetach } from "../../../imperative";
 import type { CustomVuefyOptions } from "../../../modules/vuefy";
 /**
  * MMapZoomControl props
@@ -27,7 +28,7 @@ type DefaultProps = typeof defaultProps;
  * map.addChild(controls);
  * ```
  */
-declare class MMapZoomControl extends mappable.MMapControl<MMapZoomControlProps> {
+declare class MMapZoomControl extends mappable.MMapGroupEntity<MMapZoomControlProps> {
     static defaultProps: Readonly<{
         duration: 200;
     }>;
@@ -36,11 +37,15 @@ declare class MMapZoomControl extends mappable.MMapControl<MMapZoomControlProps>
     protected _zoomOut: MMapControlCommonButton;
     protected _listener: MMapListener;
     private _currentZoom;
+    protected _detachDom?: DomDetach;
+    protected _element?: HTMLElement;
+    private _unwatchThemeContext?;
     constructor(props: MMapZoomControlProps);
     private _onMapUpdate;
     private _changeZoom;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate(props: MMapZoomControlProps): void;
+    protected _onUpdate(): void;
+    private _updateTheme;
 }
 export { MMapZoomControl, MMapZoomControlProps };

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

@@ -35,6 +35,7 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  *
  *    _onDetach() {
  *        this._detachDom();
+ *        this._detachDom = undefined;
  *    }
  * });
  * ```
@@ -43,7 +44,7 @@ declare class MMapHint extends mappable.MMapGroupEntity<MMapHintProps> {
     static [overrideKeyReactify]: CustomReactify<MMapHint, TReact.FC<MMapHintProps>>;
     static [overrideKeyVuefy]: CustomVuefyFn<MMapHint>;
     static [optionsKeyVuefy]: CustomVuefyOptions<MMapHint>;
-    private _detachDom;
+    private _detachDom?;
     private _element;
     private _hintElement;
     constructor(props: MMapHintProps);