@mappable-world/mappable-types 0.0.17 → 0.0.19

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

@@ -104,6 +104,7 @@ type MapTheme = 'dark';
 type VectorTileSize = 'X1' | 'X4' | 'X16';
 type VectorDataSourcePriority = 'low' | 'medium' | 'high';
 type VectorObjectsCollisionPriority = 'low' | 'medium' | 'high' | 'ultra';
+type VectorMapType = 'map' | 'driving' | 'transit' | 'admin';
 interface VectorTileDataSourceDescription {
     /** Default is `'vmap2'` */
     tileFormat?: 'vmap2' | 'vmap3';
@@ -138,10 +139,14 @@ interface VectorTileDataSourceDescription {
     allObjectsInteractive?: boolean;
     /** Forces tiles to wait for the icons, disables hiding icons by zoom diff */
     iconsOnlyTiles?: boolean;
+    /** Milliseconds */
+    cameraIdleThrottling?: number;
     richModelDecoderWorkerUrl?: string;
     customization?: VectorCustomization;
     theme?: MapTheme;
+    hdModeEnabled?: boolean;
+    mapType?: VectorMapType;
     /** Defines how hotspots of type should be treated: enabled/disabled or use custom hotspots instead. */
     hotspots?: Record<string, boolean | FetchHotspotsFunction | HotspotsOptions>;
 }
-export { VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, FetchHotspotsFunction, VectorTileDataSourceDescription, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority, HotspotsOptions, FetchTileFunction, ComposeTileUrlFunction, Hotspot, WorldHotspot, RenderedHotspot, FetchedRasterTile, FetchedTile, FetchedCommonTile, MapTheme };
+export { VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, FetchHotspotsFunction, VectorTileDataSourceDescription, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority, VectorMapType, HotspotsOptions, FetchTileFunction, ComposeTileUrlFunction, Hotspot, WorldHotspot, RenderedHotspot, FetchedRasterTile, FetchedTile, FetchedCommonTile, MapTheme };

package/common/types/hotspot.d.ts

@@ -10,4 +10,8 @@ interface HotspotObject {
     type: 'hotspot';
     feature: HotspotFeature<LngLat>;
 }
-export { HotspotFeature, HotspotObject };
+interface RawHotspotObject {
+    type: 'raw-hotspot';
+    feature: HotspotFeature<LngLat>;
+}
+export { HotspotFeature, HotspotObject, RawHotspotObject };

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

@@ -4,7 +4,7 @@ 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";
+import type { PixelCoordinates, WorldCoordinates } from "./coordinates";
 interface WorldOffset {
     readonly left: number;
     readonly top: number;
@@ -21,6 +21,10 @@ interface RasterLayerImplementationRenderProps extends LayerImplementationRender
 interface RasterLayerImplementation {
     destroy(): void;
     render(props: RasterLayerImplementationRenderProps): void;
+    findObjectInPosition?(coords: {
+        readonly worldCoordinates: WorldCoordinates;
+        readonly screenCoordinates: PixelCoordinates;
+    }): unknown | undefined | null;
 }
 interface RasterLayerImplementationConstructorProps {
     requestRender: () => void;

package/imperative/Entities.d.ts

@@ -26,6 +26,7 @@ type WithDefaults<Props, DefaultProps extends Partial<Props>> = Props & {
  *  name: 'entity'
  * };
  * class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  public isAttached: boolean;
  *  constructor(props: MMapSomeEntityProps) {
  *      super(props);
@@ -49,6 +50,12 @@ declare abstract class GenericEntity<Props, DefaultProps extends {} = {}, Root e
          * @param props - The value of input props.
          */
     constructor(props: Props);
+    /**
+         * The method provides the default values for the properties of an Entity.
+         * @param _props - Input props value for the Entity.
+         * @returns Props with default values.
+         */
+    protected _getDefaultProps(_props: Props): DefaultProps | undefined;
     /**
          * Method for updating props of Entity.
          * @param changedProps - New props values.
@@ -122,6 +129,7 @@ interface ComplexOptions<Root extends GenericRootEntity<unknown> = GenericRootEn
  *  name: 'entity'
  * };
  * class MMapSomeComplexEntity extends GenericComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
  *  protected _onAttach(): void {
  *      this._someEntity = new MMapSomeEntity();
@@ -187,6 +195,7 @@ declare class GenericComplexEntity<Props, DefaultProps extends {} = {}, Root ext
  *  name: 'entity'
  * };
  * class MMapSomeGroupEntity extends GenericGroupEntity<MMapSomeGroupEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  // ...
  * }
  * const groupEntity = new MMapSomeGroupEntity()
@@ -215,6 +224,7 @@ declare class GenericGroupEntity<Props, DefaultProps extends {} = {}, Root exten
  * }
  * // Now we can specify their root element for the Entity
  * class MMapSomeEntity extends GenericEntity<MMapSomeEntityProps, typeof defaultProps, MMap> {
+ *  static defaultProps = defaultProps;
  *  // ...
  * }
  */

package/imperative/MMapEnities.d.ts

@@ -13,6 +13,7 @@ import { GenericComplexEntity, GenericEntity, GenericGroupEntity, Context } from
  *  name: 'entity'
  * };
  * class MMapSomeEntity extends MMapEntity<MMapSomeEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  public isAttached: boolean;
  *  constructor(props: MMapSomeEntityProps) {
  *      super(props);
@@ -45,6 +46,7 @@ declare abstract class MMapEntity<Props, DefaultProps extends {} = {}> extends G
  *  name: 'entity'
  * };
  * class MMapSomeComplexEntity extends MMapComplexEntity<MMapSomeComplexEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  private _someEntity?: MMapSomeEntity; // MMapSomeEntity extends GenericEntity
  *  protected _onAttach(): void {
  *      this._someEntity = new MMapSomeEntity();
@@ -73,6 +75,7 @@ declare abstract class MMapComplexEntity<Props, DefaultProps extends {} = {}> ex
  *  name: 'entity'
  * };
  * class MMapSomeGroupEntity extends MMapGroupEntity<MMapSomeGroupEntityProps, typeof defaultProps> {
+ *  static defaultProps = defaultProps;
  *  // ...
  * }
  * const groupEntity = new MMapSomeGroupEntity()

package/imperative/MMapFeature/index.d.ts

@@ -1,5 +1,5 @@
 import type { DrawingStyle, GenericGeometry, LngLat, HideOutsideRule } from "../../common/types";
-import type { DraggableProps, FeatureClickEvents } from "./types";
+import type { BlockingProps, DraggableProps, FeatureClickEvents } from "./types";
 import { MMapEntity } from "../MMapEnities";
 import type { Geometry, MMapFeatureEventHandler } from "./types";
 /**
@@ -15,7 +15,7 @@ type MMapFeatureProps = {
     disableRoundCoordinates?: boolean;
     /** Hide the marker if it goes beyond the edge of the viewport */
     hideOutsideViewport?: HideOutsideRule;
-} & DraggableProps<MMapFeatureEventHandler> & FeatureClickEvents;
+} & DraggableProps<MMapFeatureEventHandler> & BlockingProps & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     source: "mappable-default-feature";
 }>;
@@ -59,6 +59,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate({ id, source }: Partial<MMapFeatureProps>): void;
+    protected _getDefaultProps(): DefaultProps;
     private __onDragStart;
     private __onDragMove;
     private __onDragEnd;

package/imperative/MMapFeature/types.d.ts

@@ -9,17 +9,27 @@ export interface DraggableProps<Callback> {
     /** Fires on drag start */
     onDragStart?: Callback;
     /**
-         * Maybe a function which will be called when the user drags and drops the element to a new position in the map.
-         * The arguments to the function will be with new coordinates.
-         * A component using with component should immediately store the new coordinates into its state and then pass
-         * the new coordinates as the marker's props.
+         * May be a function that will be called when the user drags and drops an element to a new location on the map.
+         * The arguments to the function will include the new coordinates.
+         * A component that uses this component should immediately save the new coordinates in its state and then use
+         * the new coordinates as props for the marker.
          * */
     onDragEnd?: Callback;
     /** Fires on drag move */
     onDragMove?: Callback;
-    /** Will block maps events on marker */
+}
+export interface BlockingProps {
+    /**
+         * This parameter block all map events for the element.
+         * The map will no longer be able to respond to any {@link DomEvents} on this element, including clicks, double-clicks and others.
+         */
     blockEvents?: boolean;
-    /** Will block maps behaviors on marker */
+    /**
+         * This parameter block all map behaviors for the element.
+         * The element itself can be zoomed and scrolled by mouse and gestures.
+         * The map will no longer be able to respond to any {@link BehaviorType} on this element (except `dblClick`).
+         * Double clicks and other map events will be blocked by the {@link BlockingProps.blockEvents} parameter.
+         */
     blockBehaviors?: boolean;
 }
 export interface FeatureClickEvents {

package/imperative/MMapHotspot/index.d.ts

@@ -4,6 +4,8 @@ import type { GenericGeometry, LngLat } from "../../common/types";
  * But you can check it by `instance of` in MMapListener handlers
  */
 declare class MMapHotspot {
+    private static _uid;
+    readonly id: string;
     readonly geometry?: GenericGeometry<LngLat>;
     readonly properties: Record<string, unknown>;
     constructor(geometry: GenericGeometry<LngLat> | undefined, properties: Record<string, unknown>);

package/imperative/MMapLayer/index.d.ts

@@ -35,6 +35,7 @@ declare class MMapLayer extends MMapEntity<MMapLayerProps, DefaultProps> {
     static defaultProps: Readonly<{
         zIndex: 1500;
     }>;
+    protected _getDefaultProps(props: MMapLayerProps): DefaultProps;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(): void;

package/imperative/MMapMarker/index.d.ts

@@ -1,5 +1,5 @@
 import type { HideOutsideRule, LngLat } from "../../common/types";
-import type { DraggableProps, FeatureClickEvents } from "../MMapFeature/types";
+import type { BlockingProps, DraggableProps, FeatureClickEvents } from "../MMapFeature/types";
 import { MMapGroupEntity } from "../MMapEnities";
 import { overrideKeyReactify } from "../wrappers";
 /**
@@ -43,7 +43,7 @@ type MMapMarkerProps = {
          * 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;
+} & DraggableProps<MMapMarkerEventHandler> & BlockingProps & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     draggable: false;
     mapFollowsOnDrag: false;
@@ -137,7 +137,7 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
                          * 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 & {
+        } & DraggableProps<MMapMarkerEventHandler> & BlockingProps & FeatureClickEvents & {
             markerElement?: HTMLElement | undefined;
         }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
         key?: import("react").Key | null | undefined;
@@ -145,15 +145,6 @@ declare class MMapMarker extends MMapGroupEntity<MMapMarkerProps, DefaultProps>
     readonly element: HTMLElement;
     private _destroyDomCtx?;
     constructor(props: MMapMarkerProps, element?: HTMLElement);
-    protected _getDefaultProps(): Readonly<{
-        draggable: false;
-        mapFollowsOnDrag: false;
-        blockEvents: false;
-        blockBehaviors: false;
-        hideOutsideViewport: false;
-        zIndex: 0;
-        source: "mappable-default-feature";
-    }>;
     private __feature;
     get properties(): Record<string, unknown> | undefined;
     get coordinates(): LngLat;

package/imperative/config.d.ts

@@ -1,6 +1,7 @@
 interface Apikeys {
     suggest?: string;
     router?: string;
+    search?: string;
 }
 export declare class Config {
     readonly description: string;

package/imperative/route/driving.d.ts

@@ -1,7 +1,8 @@
-import type { BaseRouteResponse, RouteFeature, RouteOptions, RawRoute } from "./interface";
+import type { BaseRouteResponse, RawRoute, RouteFeature, RouteOptions } from "./interface";
 export declare class DrivingRouteResponse implements BaseRouteResponse {
     #private;
     private _options?;
     constructor(data: RawRoute, options?: RouteOptions);
     toRoute(): RouteFeature;
+    toSteps(): RouteFeature[];
 }

package/imperative/route/index.d.ts

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

package/imperative/route/interface.d.ts

@@ -3,6 +3,7 @@ export interface RawStep {
     length: number;
     duration: number;
     mode: string;
+    feature_class?: string;
     polyline: {
         points: LngLat[];
     };
@@ -24,7 +25,11 @@ export interface RawRoute {
 export interface RouteFeature extends GenericFeature<LngLat> {
     geometry: LineStringGeometry;
     properties: {
+        length?: number;
+        duration?: number;
+        mode?: string;
         bounds?: LngLatBounds;
+        featureClass?: string;
         flags?: {
             hasTolls?: boolean;
             hasNonTransactionalTolls?: boolean;
@@ -34,14 +39,38 @@ export interface RouteFeature extends GenericFeature<LngLat> {
 export interface BaseRouteResponse {
     /** Return requested route as {@link RouteFeature RouteFeature}. */
     toRoute(): RouteFeature;
+    /** Returns requested route, divided into steps, as {@link RouteFeature RouteFeature}[]. */
+    toSteps(): RouteFeature[];
+}
+export interface TruckParameters {
+    /** Vehicle weight in tons */
+    weight?: number;
+    /** Actual vehicle axle load in tons */
+    axleWeight?: number;
+    /** Maximum allowed vehicle weight in tons */
+    maxWeight?: number;
+    /** Maximum vehicle load capacity in tons */
+    payload?: number;
+    /** Vehicle height in meters */
+    height?: number;
+    /** Vehicle width in meters */
+    width?: number;
+    /** Vehicle length in meters */
+    length?: number;
+    /** Vehicle emission standard (number from 1 to 6, for example, 1 corresponds to Euro-1 class) */
+    ecoClass?: number;
+    /** Has a truck trailer  */
+    hasTrailer?: boolean;
 }
 export interface RouteOptions {
     /** Route points represented by {@link LngLat LngLat} coordinates. */
     points: LngLat[];
-    /** Route type. Only 'driving' type is available at this moment. */
-    type: 'driving';
+    /** Route type. */
+    type: 'driving' | 'truck' | 'walking' | 'transit';
     /** If specified, bounding box of the route will be returned in properties. Default is `false`. */
     bounds?: boolean;
     /** Avoid roads with tolls. Default is `false`. */
     avoidTolls?: boolean;
+    /** Parameters for a truck (only for `type=truck`). */
+    truck?: TruckParameters;
 }

package/imperative/route/transit.d.ts

@@ -0,0 +1,8 @@
+import type { BaseRouteResponse, RawRoute, RouteFeature, RouteOptions } from "./interface";
+export declare class TransitRouteResponse implements BaseRouteResponse {
+    #private;
+    private _options?;
+    constructor(data: RawRoute, options?: RouteOptions);
+    toRoute(): RouteFeature;
+    toSteps(): RouteFeature[];
+}

package/imperative/route/truck.d.ts

@@ -0,0 +1,8 @@
+import type { BaseRouteResponse, RawRoute, RouteFeature, RouteOptions } from "./interface";
+export declare class TruckRouteResponse implements BaseRouteResponse {
+    #private;
+    private _options?;
+    constructor(data: RawRoute, options?: RouteOptions);
+    toRoute(): RouteFeature;
+    toSteps(): RouteFeature[];
+}

package/imperative/route/utils/bounds.d.ts

@@ -1,2 +1,3 @@
-import type { LngLatBounds } from "../../../common/types";
+import type { LngLat, LngLatBounds } from "../../../common/types";
 export declare function isFiniteBounds(bounds: LngLatBounds): boolean;
+export declare function boundsFromCoordinates(coordinates: LngLat[]): LngLatBounds;

package/imperative/route/utils/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./bounds";
 export * from "./points";
+export * from "./step-to-feature";
+export * from "./to-route";

package/imperative/route/utils/step-to-feature.d.ts

@@ -0,0 +1,2 @@
+import type { RawRoute, RawStep, RouteFeature, RouteOptions } from "../interface";
+export declare function stepToBasicRouteFeature(step: RawStep, featureId: string, route: RawRoute["route"], options?: RouteOptions): RouteFeature;

package/imperative/route/utils/to-route.d.ts

@@ -0,0 +1,2 @@
+import type { RawRoute, RouteFeature, RouteOptions } from "../interface";
+export declare function toRoute(rawRoute: RawRoute, featureId: string, options?: RouteOptions): RouteFeature;

package/imperative/route/walking.d.ts

@@ -0,0 +1,8 @@
+import type { BaseRouteResponse, RawRoute, RouteFeature, RouteOptions } from "./interface";
+export declare class WalkingRouteResponse implements BaseRouteResponse {
+    #private;
+    private _options?;
+    constructor(data: RawRoute, options?: RouteOptions);
+    toRoute(): RouteFeature;
+    toSteps(): RouteFeature[];
+}

package/package.json

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

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

@@ -25,7 +25,7 @@ type DefaultProps = typeof defaultProps;
  * map.addChild(controls);
  * ```
  */
-declare class MMapZoomControl extends mappable.MMapComplexEntity<MMapZoomControlProps> {
+declare class MMapZoomControl extends mappable.MMapComplexEntity<MMapZoomControlProps, DefaultProps> {
     static [mappable.optionsKeyVuefy]: CustomVuefyOptions<MMapZoomControl>;
     static defaultProps: Readonly<{
         duration: 200;

package/reactify/reactify.d.ts

@@ -15,7 +15,6 @@ export type Reactify = {
     module: ReactifyModule;
     entity: ReactifyEntity;
 };
-export declare const moduleOverrideExport: string;
 export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
     reactify: {
         module: ReactifyModule;
@@ -40,7 +39,9 @@ export type GetReactContext<TContext extends Context<unknown>> = (context?: TCon
 export type ReactifiedModule<TModule extends BaseModule> = {
     [Property in keyof TModule]: TModule[Property] extends EntityConstructor<GenericEntity<unknown>> ? ReturnType<InternalReactifyEntity<TModule[Property]>> : TModule[Property] extends Context<any> ? ReturnType<GetReactContext<TModule[Property]>> : TModule[Property];
 };
-export type BaseModule = Record<string | symbol, unknown>;
+export type BaseModule = Record<string | symbol, unknown> & {
+    __implReactifyOverride?: (reactify: Reactify) => object;
+};
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};