@mappable-world/mappable-types 0.0.18 → 0.0.20

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';
@@ -143,7 +144,9 @@ interface VectorTileDataSourceDescription {
     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/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";
 }>;

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/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;

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/imperative/search/index.d.ts

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

package/package.json

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

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];
 } & {};