@mappable-world/mappable-types 0.0.21 → 0.0.22

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

@@ -122,11 +122,19 @@ interface VectorTileDataSourceDescription {
     meshRequestWithCredentials?: boolean;
     glyphRequestWithCredentials?: boolean;
     richModelRequestWithCredentials?: boolean;
+    indoorPlanRequestWithCredentials?: boolean;
+    styleRequestWithCredentials?: boolean;
+    fontListRequestWithCredentials?: boolean;
+    fontObjectRequestWithCredentials?: boolean;
     tileRequestHeaders?: Record<string, string>;
     iconRequestHeaders?: Record<string, string>;
     glyphRequestHeaders?: Record<string, string>;
     meshRequestHeaders?: Record<string, string>;
     richModelRequestHeaders?: Record<string, string>;
+    indoorPlanRequestHeaders?: Record<string, string>;
+    styleRequestHeaders?: Record<string, string>;
+    fontListRequestHeaders?: Record<string, string>;
+    fontObjectRequestHeaders?: Record<string, string>;
     priority: VectorDataSourcePriority;
     collisionPriority?: VectorObjectsCollisionPriority;
     requestTileSize?: VectorTileSize;

package/imperative/DomContext.d.ts

@@ -18,8 +18,8 @@ export declare function createDomContext(containerEntity: GenericComplexEntity<u
 /**
  * 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
+ * @param element - DOM element to attach
+ * @param container - DOM element to provide to descendants in new 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;

package/imperative/MMap/index.d.ts

@@ -6,29 +6,51 @@ import { Config } from "../config";
 import { MMapTheme } from "../ThemeContext";
 import { overrideKeyReactify } from "../wrappers";
 /**
- * Sets map center.
+ * Sets map center. In this case, the zoom of the map remains unchanged.
+ * ```javascript
+ * map.update({
+ *   location: {center: [-0.118092, 51.509865]}
+ * });
+ * ```
  */
 export type MMapCenterLocation = {
     center: LngLat;
 };
 /**
- * Sets map zoom.
+ * Sets map zoom. In this case, the center of the map remains unchanged.
+ * ```javascript
+ * map.update({
+ *    location: {zoom: 10}
+ * });
+ * ```
  */
 export type MMapZoomLocation = {
     zoom: number;
 };
 /**
- * Sets map bounds.
+ * Calculate the center and zoom by specifying the coordinates of the top left and bottom right corners of the map.
+ * In this case, the center of the map will be in the center of the rectangle described at the given coordinates.
+ * If the map have an aspect ratio different from this rectangle, the rectangle will be inscribed in height and the map will be centered in width.
+ * ```javascript
+ * map.update({
+ *     location: {bounds: [[-0.118092, 51.509865], [-0.118092, 51.509865]]}
+ * });
+ * ```
  */
 export type MMapBoundsLocation = {
     bounds: LngLatBounds;
 };
 /**
  * Sets map center and zoom. Combination of MMapCenterLocation and MMapZoomLocation
+ * ```javascript
+ * map.update({
+ *  location: {center: [-0.118092, 51.509865], zoom: 10}
+ * });
+ * ```
  */
 export type MMapCenterZoomLocation = MMapCenterLocation & MMapZoomLocation;
 /**
- * Sets map center and zoom or bounds. Combination of @mixes MMapZoomLocation and MMapBoundsLocation
+ * Union type for describing the position of the map through the center and zoom or through the bounds of the map
  */
 export type MMapLocation = MMapCenterZoomLocation & Partial<MMapBoundsLocation>;
 /**
@@ -41,7 +63,27 @@ export type MMapCamera = {
     azimuth?: number;
 };
 /**
- * Describes how to change current map location. Change can be instantenious or animated if duration property is set.
+ * Describes how to change current map location. Change can be instantaneous or animated if duration property is set.
+ * ```javascript
+ * map.update({
+ *  location: {
+ *      center: [-0.118092, 51.509865], // Center of the map
+ *      zoom: 10, // Zoom level
+ *      duration: 200, // Animation of moving map will take 200 milliseconds
+ *      easing: 'ease-in-out' // Animation easing function
+ *  }
+ * });
+ * ```
+ * or just change center of the map
+ * ```javascript
+ * map.update({
+ *  location: {
+ *     center: [-0.118092, 51.509865], // Center of the map
+ *     duration: 200, // Animation of moving map will take 200 milliseconds
+ *     easing: 'linear' // Animation easing function
+ *  }
+ * })';
+ * ```
  */
 export type MMapLocationRequest = (MMapBoundsLocation | MMapCenterLocation | MMapZoomLocation | MMapCenterZoomLocation) & {
     /** Animation duration */
@@ -49,6 +91,17 @@ export type MMapLocationRequest = (MMapBoundsLocation | MMapCenterLocation | MMa
     /** Animation easing function */
     easing?: EasingFunctionDescription;
 };
+/**
+ * Describes how to change current camera position. Change can be instantaneous or animated if duration property is set.
+ * ```javascript
+ * map.update({camera: {
+ *      tilt: 45 * (Math.PI / 180), // 45 degrees
+ *      azimuth: 30 * (Math.PI / 180) // 30 degrees
+ *      duration: 200, // Animation of moving camera will take 200 milliseconds
+ *      easing: 'ease-in-out'
+ *  }});
+ * ```
+ */
 export type MMapCameraRequest = MMapCamera & {
     /** Animation duration */
     duration?: number;
@@ -56,7 +109,24 @@ export type MMapCameraRequest = MMapCamera & {
     easing?: EasingFunctionDescription;
 };
 /**
- * MMap props
+ * Map settings. Allow to set map mode, behaviors, margin, zoom rounding, zoom range, restrict map area, theme and other settings.
+ * ```javascript
+ * const map = new MMap(document.getElementById('map-root'), {
+ *    className: 'custom-map',
+ *    location: {center: [-0.118092, 51.509865], zoom: 10},
+ *    camera: {tilt: 45 * (Math.PI / 180), azimuth: 30 * (Math.PI / 180)}
+ *    mode: 'raster',
+ *    behaviors: ['drag', 'scrollZoom', 'dblClick', 'mouseRotate', 'mouseTilt'],
+ *    margin: [0, 100, 0, 0],
+ *    theme: 'light'
+ * });
+ * ```
+ * But required only `location` prop.
+ * ```javascript
+ * const map = new MMap(document.getElementById('map-root'), {
+ *   location: {center: [-0.118092, 51.509865], zoom: 10}
+ * });
+ * ```
  */
 export type MMapProps = {
     /** Map container css class name */
@@ -131,7 +201,7 @@ type DefaultProps = typeof defaultProps;
  * ```javascript
  * const map = new MMap(
  *     document.getElementById('map-root'),
- *     {location: {center: [37.622504, 55.753215], zoom: 10}}
+ *     {location: {center: [-0.118092, 51.509865], zoom: 10}}
  * );
  * // add default Mappable scheme layer
  * map.addChild(new MMapDefaultSchemeLayer());

package/imperative/MMap/projection.d.ts

@@ -1,2 +1,2 @@
-import { WebMercator } from "../utils/projections/web-mercator";
+import { WebMercator } from "../projections/web-mercator";
 export declare const projection: WebMercator;

package/imperative/MMapCollection/index.d.ts

@@ -1,3 +1,21 @@
 import { MMapGroupEntity } from "../MMapEnities";
+/**
+ * MMapCollection is a collection of MMapEntity objects.
+ * Allow adding or removing [[MMapEntity]] objects.
+ * ```typescript
+ * const collection = new MMapCollection({});
+ * const markerElement = document.createElement('div');
+ * markerElement.className = 'marker';
+ *
+ * for (let i = 0; i < 10_000; i++) {
+ *  collection.addChild(new MMapMarker({
+ *    coordinates: [Math.random() * 180, Math.random() * 180]
+ *  }, markerElement.cloneNode(true)));
+ * }
+ *
+ * map.addChild(collection); // Add collection to the map
+ * map.removeChild(collection); // Remove all markers from the map
+ * ```
+ */
 export declare class MMapCollection extends MMapGroupEntity<{}> {
 }

package/imperative/MMapContainer/index.d.ts

@@ -17,6 +17,20 @@ declare const defaultProps: {
 };
 type DefaultProps = typeof defaultProps;
 type ComputedMMapContainerProps<TContext> = MMapContainerProps<TContext> & MMapContainerPropsImpl<TContext>;
+/**
+ * Allow adding or removing [[MMapEntity]] objects or usual DOM elements inside the MMap.
+ * ```tsx
+ * const container = <MMapContainer>
+ *     <MMapMarker coordinates={[55.76, 37.64]}><div className="point"></div></MMapMarker>
+ *     <div>Some text</div>
+ * </MMapContainer>;
+ *
+ * ReactDOM.render(<MMap>{container}</MMap, document.getElementById('root'));
+ * ```
+ * In this example, the `container` variable contains a `MMapContainer` object with two children: `MMapMarker` and `div`.
+ * - `MMapMarker` is a MMapEntity
+ * - `div` is a usual DOM element
+ */
 declare class MMapContainer extends MMapGroupEntity<ComputedMMapContainerProps<unknown>, DefaultProps> {
     static defaultProps: {
         tagName: string;

package/imperative/MMapContextProvider/index.d.ts

@@ -11,13 +11,38 @@ export type MMapContextProviderProps<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' }`
+ * And define context consumer:
+ * ```ts
+ * class SomeContextConsumer extends mappable.MMapEntity<{}> {
+ *    constructor() {
+ *        super({});
+ *    }
+ *
+ *    _onAttach() {
+ *      const value = this._consumeContext(SomeMapContext);
+ *      console.log(value); // {your: 'value'}
+ *    }
+ * }
+ * ```
+ * When adding nested containers, the context will be available in them:
+ * ```ts
+ * mapContextProvider.addChild(new SomeContextConsumer());
+ * ```
+ * But the most important thing is that the context can be passed at any nesting level:
+ * ```tsx
+ * <MMapContextProvider context={SomeMapContext} value={{your: 'value'}}>
+ *     <MMapContainer>
+ *         <MMapContainer>
+ *             <SomeContextConsumer />
+ *         <MMapContainer>
+ *     </MMapContainer>
+ * </MMapContextProvider>
+ * ```
  */
 export declare class MMapContextProvider<T> extends MMapGroupEntity<MMapContextProviderProps<T>> {
     protected _onAttach(): void;

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -1,7 +1,18 @@
 import { MMapComplexEntity, MMapGroupEntity } from "../MMapEnities";
 import { overrideKeyReactify } from "../wrappers";
 /**
- * MMapControlButton props
+ * Properties for [[MMapControlCommonButton]]
+ * ```typescript
+ * const button = new MMapControlCommonButton({
+ *   text: 'Click me!',
+ *   disabled: false,
+ *   color: 'black',
+ *   background: 'white',
+ *   onClick: () => {
+ *      console.log('Button clicked');
+ *   }
+ * });
+ * ```
  */
 export type MMapControlCommonButtonProps = {
     /** On click handler */
@@ -20,7 +31,19 @@ export type MMapControlCommonButtonProps = {
 export type MMapControlButtonProps = MMapControlCommonButtonProps;
 /** @module MMapControlButton */
 /**
- * Default control button.
+ * Default control button. Can be used as a base for custom controls.
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {...});
+ * const controls = new mappable.MMapControls({position: 'bottom right'});
+ * const button = new mappable.MMapControlCommonButton({
+ *    text: 'Click me!',
+ *    onClick: () => {
+ *      console.log('Button clicked');
+ *    }
+ * });
+ * controls.addChild(button);
+ * ```
+ * More about controls: [Mappable Maps API controls](https://mappable.world/docs/js-api/dg/concepts/controls/index.html)
  */
 export declare class MMapControlCommonButton extends MMapGroupEntity<MMapControlCommonButtonProps> {
     private _element?;

package/imperative/MMapCopyrights/index.d.ts

@@ -1,4 +1,13 @@
 import { MMapGroupEntity } from "../MMapEnities";
+/**
+ * Copyrights position on the map container. By default, 'bottom right'.
+ * For example, 'top left' or 'bottom right'
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {
+ *  copyrightsPosition: 'top left'
+ * });
+ * ```
+ */
 type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom right";
 type MMapCopyrightsProps = {
     /** Position of copyright on the map */
@@ -20,35 +29,25 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
         position: MMapCopyrightsPosition;
         showScale: false;
     }>;
-    private _boxElement;
+    private _containerElement;
     private _copyrightsTextElement;
-    private _linkElement;
+    private _agreementLinkElement;
     private _logoElement;
     private _copyrightsContainer;
     private _scaleElement;
     private _scaleControl;
-    private _mapWidth;
     private _copyrights;
-    private _fixedCopyrights;
-    private _userAgreementText;
-    private _userAgreementState;
-    private _unwatchMapContext?;
-    private _unwatchThemeContext?;
     private _detachDom?;
     constructor(props?: MMapCopyrightsProps);
     protected _onAttach(): void;
     protected _onUpdate(props: Partial<MMapCopyrightsProps>): void;
     protected _onDetach(): void;
     private _createDom;
-    private _syncDom;
-    private _syncMapWidth;
+    private _render;
     private _syncTheme;
-    private _setUserAgreementText;
-    private _setUserAgreementState;
-    private _setCopyrights;
-    private _setFixedCopyrights;
-    private _copyrightsChangeHandler;
-    private _adjustText;
+    private _applyCopyrights;
+    private _computeMaxWidth;
+    private _rearrange;
     private _toggleScaleControl;
 }
 export { MMapCopyrights, MMapCopyrightsPosition, MMapCopyrightsProps };

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -1,6 +1,16 @@
 import type { VectorCustomization } from "../../common/types";
 import { MMapLayerProps } from "../MMapLayer";
 import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * Types of underlay layers available in the default scheme.
+ * Each layer is displayed on the map according to its zIndex.
+ * By default, layers are displayed in the following order:
+ * 1. ground
+ * 2. buildings
+ * 3. icons
+ * 4. labels
+ * @see https://mappable.world/docs/js-api/dg/concepts/general.html#source-prepared
+ */
 type MMapDefaultSchemeLayerType = "ground" | "buildings" | "icons" | "labels";
 /**
  * MMapDefaultSchemeLayer props
@@ -30,7 +40,7 @@ type MMapDefaultSchemeLayerProps = {
          * const defaultSchemeLayer = new MMapDefaultSchemeLayer({clampMapZoom: false});
          * map.addChild(defaultSchemeLayer);
          * ```
-         * See example https://mappable.world/docs/jsapi/examples/cases/over-zoom
+         * See example https://mappable.world/docs/js-api/examples/cases/over-zoom.html
          * @default true
          */
     clampMapZoom?: boolean;
@@ -65,8 +75,6 @@ declare const MAP_TYPES: {
     admin: string;
     driving: string;
     transit: string;
-    "future-map": string;
-    "legacy-map": string;
 };
 /**
  * Map default layer to show mappable-world scheme on map.

package/imperative/MMapEnities.d.ts

@@ -91,4 +91,51 @@ declare abstract class MMapGroupEntity<Props, DefaultProps extends {} = {}> exte
     addChild(child: MMapEntity<unknown>, index?: number): this;
     removeChild(child: MMapEntity<unknown>): this;
 }
-export { MMapEntity, MMapComplexEntity, MMapGroupEntity, Context as MMapContext };
+/**
+ * Context for MMap. It allows you to provide a value to the context and use it in the children of the context provider.
+ * ```ts
+ * const MMapSomeContext = new mappable.MMapContext('MMapSomeContext');
+ * class SomeValueProvider extends mappable.MMapGroupEntity<{}> {
+ *  constructor() {
+ *     super({});
+ *     this._provideContext(MMapSomeContext, {your: 'value'}); // Special method to provide context value
+ *  }
+ * }
+ * ```
+ * And some child entity can use this context:
+ * ```ts
+ * class SomeContextConsumer extends mappable.MMapEntity<{}> {
+ *    constructor() {
+ *        super({});
+ *    }
+ *
+ *    _onAttach() {
+ *      const value = this._consumeContext(MMapSomeContext); // Special method to get context value
+ *      console.log(value); // {your: 'value'}
+ *    }
+ * }
+ * ```
+ * In any level of nesting:
+ * ```tsx
+ * <SomeValueProvider>
+ *     <MMapContainer>
+ *          <MMapContainer>
+ *              <SomeContextConsumer />
+ *          </MMapContainer>
+ *     </MMapContainer>
+ * </SomeEntity>
+ * ```
+ * You can set the context value using [[MMapContextProvider]]:
+ * ```tsx
+ * <MMapContextProvider context={MMapSomeContext} value={{your: 'value'}}>
+ *     <MMapContainer>
+ *          <MMapContainer>
+ *              <SomeContextConsumer />
+ *          </MMapContainer>
+ *     </MMapContainer>
+ * </SomeEntity>
+ * ```
+ */
+declare class MMapContext<T> extends Context<T> {
+}
+export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext };

package/imperative/MMapFeature/index.d.ts

@@ -23,9 +23,10 @@ type DefaultProps = typeof defaultProps & {
     id: string;
 };
 /**
- * The feature component on the map.
+ * Component for creating a geo object on the map.
+ * Supports drag-and-drop functionality, drawing styles, and event handling.
+ * Supported geometries: `Point`, `LineString`, `MultiLineString`, `Polygon` and `MultiPolygon`.
  *
- * @example
  * ```javascript
  * const feature = new MMapFeature({
  *     geometry: {
@@ -43,6 +44,19 @@ type DefaultProps = typeof defaultProps & {
  *     .addChild(new MMapDefaultFeaturesLayer())
  *     .addChild(feature);
  * ```
+ * You can add Point geometry with HTMLElement:
+ * ```javascript
+ * const feature = new MMapFeature({
+ *    geometry: {
+ *      type: 'Point',
+ *      coordinates: [37.40108963847453, 55.70173382087952]
+ *    },
+ *    style: {
+ *      element: document.createElement('div')
+ *    }
+ * });
+ * ```
+ * But better to use [[MMapMarker]] for this.
  */
 declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     static defaultProps: Readonly<{

package/imperative/MMapFeature/types.d.ts

@@ -50,4 +50,19 @@ export interface FeatureClickEvents {
     onFastClick?: (event: MouseEvent, mapEvent: MapEvent) => void;
 }
 export type Geometry = PolygonGeometry | MultiPolygonGeometry | LineStringGeometry | MultiLineStringGeometry | PointGeometry;
+/**
+ * Feature drag event handler.
+ * ```typescript
+ * function onDragEvent(type, coordinates) => {
+ *    console.log('Event:', type, coordinates);
+ * };
+ * const feature = new MMapFeature({
+ *   geometry: {...},
+ *   draggable: true,
+ *   onDragStart: onDragEvent.bind(null, 'dragStart'),
+ *   onDragMove: onDragEvent.bind(null, 'dragMove'),
+ *   onDragEnd: onDragEvent.bind(null, 'dragEnd'),
+ * });
+ * ```
+ */
 export type MMapFeatureEventHandler = (coordinates: Geometry['coordinates']) => void | false;

package/imperative/MMapHotspot/index.d.ts

@@ -1,7 +1,21 @@
 import type { GenericGeometry, LngLat } from "../../common/types";
 /**
+ * Some active area on the map that can be clicked.
  * This is not a real MMapEntity, it cannot be added to the map.
  * But you can check it by `instance of` in MMapListener handlers
+ * For example, in [custom layers](https://mappable.world/docs/js-api/dg/concepts/custom-layers.html) you can pass an object of this type in the `findObjectInPosition` method
+ * Or just listen to the `onEventName` event and check the object:
+ * ```javascript
+ * const map = new mappable.MMap(document.getElementById('map-root'), {...});
+ * map.addChild(new mappable.MMapListener({
+ *   layer: 'any',
+ *   onClick: (object) => {
+ *      if (object instanceof mappable.MMapHotspot) {
+ *          console.log('Hotspot clicked', object);
+ *      }
+ *   }
+ * }))
+ * ```
  */
 declare class MMapHotspot {
     private static _uid;

package/imperative/MMapReactContainer/index.d.ts

@@ -1,9 +1,18 @@
 import { MMapContainer, MMapContainerProps, MMapContainerPropsImpl } from "../MMapContainer";
-/** @deprecated Use MMapContainerPropsImpl instead */
+/**
+ * @deprecated Use {@link MMapContainerPropsImpl} instead
+ * @private
+ */
 type MMapReactContainerPropsImpl<TContext> = MMapContainerPropsImpl<TContext>;
-/** @deprecated Use MMapContainerProps instead */
+/**
+ * @deprecated Use {@link MMapContainerProps} instead
+ * @private
+ */
 type MMapReactContainerProps<TContext> = MMapContainerProps<TContext>;
-/** @deprecated Use MMapContainer instead */
+/**
+ * @deprecated Use {@link MMapContainer} instead
+ * @private
+ */
 declare class MMapReactContainer extends MMapContainer {
 }
 export { MMapReactContainer, MMapReactContainerPropsImpl, MMapReactContainerProps };

package/imperative/MMapScaleControl/index.d.ts

@@ -1,5 +1,11 @@
 import { MMapComplexEntity } from "../MMapEnities";
+/**
+ * Types of measurement units that scale control can display.
+ */
 export type UnitType = "imperial" | "metric" | "nautical";
+/**
+ * Properties for [[MMapScaleControl]]
+ */
 type MMapScaleControlProps = {
     /** Maximum width of scale line in pixels */
     maxWidth?: number;
@@ -11,6 +17,22 @@ declare const defaultProps: Readonly<{
     unit: "metric";
 }>;
 type DefaultProps = typeof defaultProps;
+/**
+ * A control that shows the map scale in different units of measurement.
+ * @example Add scale control to the lower left part of the map:
+ * ```js
+ * const scaleControl = new MMapScaleControl({});
+ * const controls = new MMapControls({position: 'bottom left'}, [scaleControl]);
+ * map.addChild(controls)
+ * ```
+ * Alternatively, you can show the integrated scale control on the map by `showScaleInCopyrights` props:
+ * ```js
+ * const map = new MMap(document.getElementById('map-root'), {
+ *   showScaleInCopyrights: true,
+ *   location: {center: [37.622504, 55.753215], zoom: 10}
+ * });
+ * ```
+ */
 declare class MMapScaleControl extends MMapComplexEntity<MMapScaleControlProps, DefaultProps> {
     static defaultProps: Readonly<{
         maxWidth: 74;

package/imperative/MMapTileDataSource/index.d.ts

@@ -1,9 +1,9 @@
-import type { RasterTileDataSourceDescription, VectorTileDataSourceDescription, ZoomRange } from "../../common/types";
+import type { RasterTileDataSourceDescription, ZoomRange } from "../../common/types";
 import { MMapEntity } from "../MMapEnities";
 /**
  * MMapTileDataSource props
  */
-type MMapTileDataSourceProps = {
+interface MMapTileDataSourceProps {
     /** Data source id */
     id: string;
     /** Min and max zoom for tiles */
@@ -18,7 +18,7 @@ type MMapTileDataSourceProps = {
     raster?: RasterTileDataSourceDescription;
     /** Data source copyrights */
     copyrights?: string[];
-};
+}
 /**
  * Create map tile data source.
  *

package/imperative/ThemeContext.d.ts

@@ -1,6 +1,12 @@
 import { Context } from "./Entities";
 /**
- * Sets map theme
+ * Map theme. Affects the colors of the map controls and background.
+ * ```typescript
+ * const map = new mappable.MMap({
+ *    location: {center: [55.751574, 37.573856], zoom: 9},
+ *    theme: 'dark'
+ * });
+ * ```
  */
 export type MMapTheme = "light" | "dark";
 export type MMapThemeContext = {

package/imperative/TypeContext.d.ts

@@ -3,4 +3,7 @@ export type MMapType = string;
 export type MMapTypeContext = {
     type?: MMapType;
 };
+/**
+ * Selects one of predefined map style modes optimized for particular use case.
+ */
 export declare const TypeContext: Context<MMapTypeContext>;

package/imperative/config.d.ts

@@ -1,11 +1,36 @@
+/**
+ * All possible apikeys for http-services.
+ */
 interface Apikeys {
     suggest?: string;
     router?: string;
     search?: string;
 }
+/**
+ * Configuration object for whole API.
+ * For example, it can be used to set experiments or apikeys.
+ * ```js
+ * mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.
+ * ```
+ */
 export declare class Config {
     readonly description: string;
+    /**
+     * Set experiments for map.
+     */
     setExperiments(experiments: Record<string, boolean>): void;
+    /**
+     * Set apikeys for http-services.
+     * ```js
+     * mappable.getDefaultConfig().setApikeys({search: "YOUR_SEARCH_API_KEY"})`.
+     * ```
+     */
     setApikeys(apikeys: Apikeys): void;
 }
+/**
+ * Returns default config object.
+ * ```js
+ * mappable.getDefaultConfig().setApikeys({suggest: "YOUR_SUGGEST_API_KEY"})`.
+ * ```
+ */
 export declare function getDefaultConfig(): Config;

package/imperative/index.d.ts

@@ -1,4 +1,4 @@
-import * as projections_ from "./utils/projections";
+import * as projections_ from "./projections";
 export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
 export { MMapThemeContext, ThemeContext, MMapTheme } from "./ThemeContext";
 export { MMapTypeContext, TypeContext, MMapType } from "./TypeContext";

package/imperative/{utils/projections → projections}/web-mercator.d.ts

@@ -1,11 +1,9 @@
-import type { Projection, LngLat, WorldCoordinates } from "../../../common/types";
+import type { Projection, LngLat, WorldCoordinates } from "../../common/types";
 /**
- * @class Mercator projection onto a sphere.
- * Used by many mapping services, in particular OpenStreetMap.
- * @name projection.webMercator
- * @augments Projection
- * @static
- * @example
+ * @private
+ * Mercator projection onto a sphere.
+ * Used by many mapping services, in particular OpenStreetMap
+ *
  * ```js
  * // Create a map in the web Mercator projection
  * const map = new mappable.MMap(document.getElementById('MMapsID'), {

package/package.json

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

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

@@ -6,7 +6,7 @@ import { optionsKeyVuefy, overrideKeyReactify, overrideKeyVuefy } from "../../..
 type MMapHintProps = {
     hint: (object: MMapFeature | MMapMarker | MMapHotspot | undefined) => unknown;
 };
-declare const MMapHintContext: import("../../../imperative/Entities").Context<unknown>;
+declare const MMapHintContext: import("../../../imperative/MMapEnities").MMapContext<unknown>;
 /**
  * Display hint on map elements.
  *

package/imperative/MMapCoverage/index.d.ts

@@ -1,55 +0,0 @@
-import type { ZoomRange } from "../../common/types";
-import { MMapComplexEntity } from "../MMapEnities";
-import { Context } from "../Entities";
-interface MMapCoverageProps {
-    onError?: (e: Error) => void;
-}
-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 _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;
-    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/utils/allowed-custom-layer-implementations.d.ts

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

package/imperative/utils/deepFreeze.d.ts

@@ -1,2 +0,0 @@
-declare function deepFreeze<ObjectType>(obj: ObjectType): ObjectType;
-export { deepFreeze };

package/imperative/utils/errorLogger.d.ts

@@ -1,29 +0,0 @@
-interface MappableError extends Error {
-    additionalInfo?: Additional;
-    logged?: boolean;
-}
-type Additional = Record<string, unknown>;
-interface LogErrorOptions {
-    message?: string;
-    service?: string;
-    source?: string;
-    sourceMethod?: string;
-    type?: string;
-    block?: string;
-    method?: string;
-    page?: string;
-    additional?: Additional;
-    level?: "info" | "debug" | "warn" | "error" | "critical" | "trace";
-}
-interface LogErrorInitSettings {
-    project?: string;
-    unhandledRejection?: boolean;
-    uncaughtException?: boolean;
-}
-type ErrorLoggerInitFunction = (settings: LogErrorInitSettings) => ErrorLoggerFunction;
-type ErrorLoggerFunction = (options: LogErrorOptions, error?: MappableError) => void;
-export type MappableReactError = Omit<MappableError, "logged">;
-export { ErrorLoggerInitFunction };
-export declare function errorLoggerFactory(initLogger: ErrorLoggerInitFunction): void;
-export declare function logError(error: MappableReactError, options?: Record<string, unknown>): void;
-export declare function throwError(error: MappableReactError): never;

package/imperative/utils/id.d.ts

@@ -1,2 +0,0 @@
-declare function idIncrementedFactory(min?: number, max?: number): () => number;
-export { idIncrementedFactory };

package/imperative/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./errorLogger";
-export * from "./metrics";
-export * from "./requestCoverage";

package/imperative/utils/jsonp.d.ts

@@ -1,9 +0,0 @@
-type BooleanFlag = 0 | 1;
-type JsonpRequest = {
-    url: string;
-    callbackName: string;
-};
-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, signal?: AbortSignal): Promise<JsonpResponse>;
-export { jsonp, composeUrl, boolToFlag };

package/imperative/utils/metrics.d.ts

@@ -1,12 +0,0 @@
-type Metrics = {};
-type TransportOptions = {
-    share?: number;
-};
-type MetricsTransport<T> = (metrics: T, options?: TransportOptions) => void;
-type CreateTransportOptions = {
-    prefix?: string;
-    /** Events with share (if defined) less than this value will not be sent, should be in [0, 1] range */
-    sendBoundary?: number;
-};
-export declare const SEND_BOUNDARY: number;
-export {};

package/imperative/utils/pEachChunk.d.ts

@@ -1,2 +0,0 @@
-declare function pEachChunk<T>(data: T[], callback: (elem: T, index: number) => void, chunkSize?: number): Promise<void>;
-export { pEachChunk };

package/imperative/utils/removeUndefined.d.ts

@@ -1 +0,0 @@
-export declare function removeUndefined<T extends {}>(obj: T, recursive?: boolean): T;

package/imperative/utils/requestCoverage.d.ts

@@ -1,25 +0,0 @@
-import type { ReadonlyLngLat, ZoomRange } from "../../common/types";
-export type LayerInfo = {
-    id: string;
-    zoomRange?: ZoomRange;
-    copyrights?: string[];
-    LayerMetaData?: unknown[];
-    version?: string;
-};
-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

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