@mappable-world/mappable-types 0.0.6 → 0.0.8

package/imperative/MMapControl/MMapControlButton.d.ts

@@ -1,5 +1,6 @@
 import { DomEntity } from "../DomContext";
 import { MMapComplexEntity } from "../MMapEnities";
+import { reactify } from "../../reactify";
 /**
  * MMapControlButton props
  */

package/imperative/MMapFeature/index.d.ts

@@ -11,6 +11,8 @@ type MMapFeatureProps = {
     source?: string;
     style?: DrawingStyle;
     properties?: Record<string, unknown>;
+    /** Do not round coordinates */
+    disableRoundCoordinates?: boolean;
 } & DraggableProps<MMapFeatureEventHandler> & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     source: "mappable-default-feature";
@@ -53,7 +55,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     get geometry(): GenericGeometry<LngLat>;
     protected _onAttach(): void;
     protected _onDetach(): void;
-    protected _onUpdate({ style, id, source }: Partial<MMapFeatureProps>): void;
+    protected _onUpdate({ style, id, source, disableRoundCoordinates }: Partial<MMapFeatureProps>): void;
     private __onDragStart;
     private __onDragMove;
     private __onDragEnd;

package/imperative/MMapMarker/index.d.ts

@@ -1,7 +1,7 @@
 import type { LngLat } from "../../common/types";
 import type { DraggableProps, FeatureClickEvents } from "../MMapFeature/types";
-import { reactify } from "../../reactify";
 import { MMapGroupEntity } from "../MMapEnities";
+import { reactify } from "../../reactify";
 /**
  * MMapMarker events handler
  */
@@ -17,6 +17,8 @@ type MMapMarkerProps = {
     zIndex?: number;
     properties?: Record<string, unknown>;
     id?: string;
+    /** Do not round coordinates */
+    disableRoundCoordinates?: boolean;
 } & DraggableProps<MMapMarkerEventHandler> & FeatureClickEvents;
 declare const defaultProps: Readonly<{
     draggable: false;

package/imperative/MMapReactContainer/index.d.ts

@@ -21,6 +21,9 @@ declare class MMapReactContainer extends MMapGroupEntity<ComputedMMapReactContai
     static defaultProps: {
         tagName: string;
     };
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapReactContainer, TReact.FC<MMapReactContainerProps<unknown> & {
+        children?: TReact.ReactNode;
+    }>>;
     element?: Element;
     private _detachDom?;
     private _disposeWatch?;

package/imperative/config.d.ts

@@ -1,5 +1,10 @@
-export class Config {
+interface Apikeys {
+    suggest?: string;
+    router?: string;
+}
+export declare class Config {
     readonly description: string;
     setExperiments(experiments: Record<string, boolean>): void;
+    setApikeys(apikeys: Apikeys): void;
 }
-export function getDefaultConfig(): Config;
+export declare function getDefaultConfig(): Config;

package/imperative/route/driving.d.ts

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

package/imperative/route/index.d.ts

@@ -1,56 +1,4 @@
-import type { GenericFeature, LineStringGeometry, LngLat, LngLatBounds } from "../../common/types";
 import { Config } from "../config";
-export declare enum MMapJamType {
-    UNKNOWN = 1,
-    CLOSED = 2,
-    FREE = 3,
-    LIGHT = 4,
-    HARD = 5,
-    VERY_HARD = 6
-}
-export type MMapJamSegment = {
-    /**
-         * Traffic jam type, one of {@link MMapJamType MMapJamType}
-         * */
-    type: MMapJamType;
-    /**
-         * How many items of the {@link RouteFeature.coordinates RouteFeature.coordinates}
-         * array this {@link JamSegment JamSegment} spans across
-         * Use these values to build palettes for a {@link MMapFeature MMapFeature} stroke style
-         * */
-    count: number;
-};
-export interface RouteFeature extends GenericFeature<LngLat> {
-    geometry: LineStringGeometry;
-    properties: {
-        jams?: MMapJamSegment[];
-        bounds?: LngLatBounds;
-    };
-}
-export interface RoutePoint {
-    type: "way" | "via";
-    coordinates: LngLat;
-}
-export interface RouteOptions {
-    /**
-         * Route points represented by {@link LngLat LngLat} coordinates.
-         * Its may be array of {@link LngLat LngLat} or array of {type, coordinates} objects.
-         * {@link LngLat LngLat}[] is a shorthand for {type: 'way', coordinates: {@link LngLat LngLat}}[].
-         **/
-    points: (RoutePoint | LngLat)[];
-    /** Route type. Only 'driving' type is available at this moment. */
-    type: "driving";
-    /** Maximum amount of returned routes. Only one result is available at this moment. */
-    results?: 1;
-    /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
-    jams?: boolean;
-    /** 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;
-}
-export interface BaseRouteResponse {
-    /** Return requested route as {@link RouteFeature RouteFeature}. */
-    toRoute(): RouteFeature;
-}
+import type { BaseRouteResponse, RouteOptions } from "./interface";
 export declare function route(options: RouteOptions, config?: Config | undefined): Promise<BaseRouteResponse[]>;
+export { RouteOptions, BaseRouteResponse };

package/imperative/route/interface.d.ts

@@ -0,0 +1,47 @@
+import type { GenericFeature, LineStringGeometry, LngLat, LngLatBounds } from "../../common/types";
+export interface RawStep {
+    length: number;
+    duration: number;
+    mode: string;
+    polyline: {
+        points: LngLat[];
+    };
+}
+export interface RawLeg {
+    status: string;
+    steps: RawStep[];
+}
+export interface RawRoute {
+    traffic: string;
+    route: {
+        legs: RawLeg[];
+        flags?: {
+            hasTolls?: boolean;
+            hasNonTransactionalTolls?: boolean;
+        };
+    };
+}
+export interface RouteFeature extends GenericFeature<LngLat> {
+    geometry: LineStringGeometry;
+    properties: {
+        bounds?: LngLatBounds;
+        flags?: {
+            hasTolls?: boolean;
+            hasNonTransactionalTolls?: boolean;
+        };
+    };
+}
+export interface BaseRouteResponse {
+    /** Return requested route as {@link RouteFeature RouteFeature}. */
+    toRoute(): RouteFeature;
+}
+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';
+    /** 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;
+}

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

@@ -0,0 +1,2 @@
+import type { LngLatBounds } from "../../../common/types";
+export declare function isFiniteBounds(bounds: LngLatBounds): boolean;

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

@@ -0,0 +1,2 @@
+export * from "./bounds";
+export * from "./points";

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

@@ -0,0 +1,4 @@
+import type { LngLat } from "../../../common/types";
+import type { RawRoute } from "../interface";
+export declare function mapPoints(points: LngLat[]): LngLat[];
+export declare function mapRoute(raw: RawRoute): RawRoute;

package/package.json

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

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

@@ -50,6 +50,13 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     static defaultProps: Readonly<{
         tickTimeout: 200;
     }>;
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<Pick<MMapClustererProps, "features" | "tickTimeout" | "method" | "onRender"> & {
+        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    } & import("react").RefAttributes<MMapEntity<Pick<MMapClustererProps, "features" | "tickTimeout" | "method" | "onRender"> & {
+        marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+        cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+    }, {}>>>>;
     /** All created entities with cluster id*/
     private _entitiesCache;
     /** Viewport entities with cluster id */

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

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

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

@@ -43,6 +43,16 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
     static defaultProps: Readonly<{
         color: "#f33";
     }>;
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
+        coordinates: LngLat;
+        source?: string | undefined;
+        zIndex?: number | undefined;
+        properties?: Record<string, unknown> | undefined;
+        id?: string | undefined;
+        disableRoundCoordinates?: boolean | undefined;
+    } & import("../../../imperative/MMapFeature/types").DraggableProps<import("../../../imperative/MMapMarker").MMapMarkerEventHandler> & import("../../../imperative/MMapFeature/types").FeatureClickEvents & DefaultMarkerCustomProps & {
+        children?: import("react").ReactNode;
+    } & import("react").RefAttributes<import("../../../imperative/MMapEnities").MMapEntity<MMapDefaultMarkerProps, {}>>>>;
     private _marker;
     private _container;
     private _popup;

package/reactify/overrides/MMapControlButton.d.ts

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

package/reactify/overrides/index.d.ts

@@ -2,3 +2,4 @@ export * from "./MMap";
 export * from "./MMapControl";
 export * from "./MMapMarker";
 export * from "./MMapReactContainer";
+export * from "./MMapControlButton";

package/reactify/reactify.d.ts

@@ -26,20 +26,21 @@ export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (c
     React: typeof TReact;
     ReactDOM: typeof TReactDOM;
 }) => TResult;
-export type Overrided<TReactResult> = {
-    [overrideKeyReactify]: CustomReactify<GenericEntity<unknown>, TReactResult>;
+export type Overrided<TCtor extends EntityConstructor<GenericEntity<unknown>>, TReactResult> = {
+    [overrideKeyReactify]: CustomReactify<InstanceType<TCtor>, TReactResult>;
 };
 type InternalReactify<TEntity extends GenericEntity<unknown>> = (ctor: EntityConstructor<TEntity>, displayName?: string) => TReact.ForwardRefExoticComponent<TReact.PropsWithoutRef<TReact.PropsWithChildren<EntityProps<TEntity>>> & React.RefAttributes<TEntity | undefined>>;
-type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;
+type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<TCtor, infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;
 export type ReactifyEntity = <TCtor extends EntityConstructor<GenericEntity<unknown>>>(...args: Parameters<InternalReactifyEntity<TCtor>>) => ReturnType<InternalReactifyEntity<TCtor>>;
 export type ReactifiedEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = ReturnType<InternalReactifyEntity<TCtor>>;
-export interface ReactifyModule<TModule extends BaseModule = BaseModule> {
-    (module: TModule): ReactifiedModule<TModule>;
+export interface ReactifyModule {
+    <TModule extends BaseModule = BaseModule>(module: TModule): ReactifiedModule<TModule>;
 }
 export type GetReactContext<TContext extends Context<unknown>> = (context?: TContext | undefined) => React.Context<unknown>;
 export type ReactifiedModule<TModule extends BaseModule> = {
     [Property in keyof TModule]: TModule[Property] extends EntityConstructor<GenericEntity<unknown>> ? ReturnType<InternalReactifyEntity<TModule[Property]>> : TModule[Property] extends typeof Context ? ReturnType<GetReactContext<TModule[Property]>> : TModule[Property];
 };
 export type BaseModule = Record<string | symbol, unknown>;
+export type OverrideProps<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
 export default function createReactify(React: typeof TReact, ReactDOM: typeof TReactDOM): Reactify;
 export {};

package/imperative/route/utils.d.ts

@@ -1,21 +0,0 @@
-import type { GenericMappableFeatureCollection, LngLat, LngLatBounds } from "../../common/types";
-import type { MMapJamSegment } from ".";
-export declare function decodeRouteCoordinates(input: string): LngLat[];
-interface EncodedPathFeatureCollection extends GenericMappableFeatureCollection<LngLat> {
-    properties: {
-        encodedCoordinates: string;
-        jams?: MMapJamSegment[];
-        boundedBy?: LngLatBounds;
-    };
-}
-export interface EncodedRouteFeatureCollection extends GenericMappableFeatureCollection<LngLat> {
-    features: EncodedPathFeatureCollection[];
-}
-export interface RawRouteResponse {
-    data: {
-        features: EncodedRouteFeatureCollection[];
-    };
-}
-export declare function prepareRoutes({ data }: RawRouteResponse): EncodedRouteFeatureCollection[];
-export declare function isFiniteBounds(bounds: LngLatBounds): boolean;
-export {};