@mappable-world/mappable-types 0.0.2 → 0.0.4

package/README.md

@@ -7,7 +7,7 @@ Type definitions for Mappable Maps JavaScript API (https://mappable.world).
 ## Getting started
 
 ```bash
-npm i @mappable/mappable-types -D
+npm i @mappable-world/mappable-types -D
 ```
 
 tsconfig.json
@@ -15,7 +15,7 @@ tsconfig.json
 ```json
 {
   "compilerOptions": {
-    "types": ["@mappable/mappable-types"]
+    "types": ["@mappable-world/mappable-types"]
   }
 }
 ```

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -42,7 +42,7 @@ declare const defaultProps: {
 };
 type DefaultProps = typeof defaultProps;
 /**
- * Map default layer to show mappable scheme on map.
+ * Map default layer to show mappable-world scheme on map.
  *
  * @example
  * ```javascript

package/imperative/MMapReactContainer/index.d.ts

@@ -1,7 +1,7 @@
 import type TReact from "react";
 import type { Context } from "../Entities";
-import { reactify } from "../../reactify";
 import { MMapGroupEntity } from "../MMapEnities";
+import { overrideKeyReactify } from "../wrappers";
 interface MMapReactContainerPropsImpl<TContext> {
     onElement: (element?: Element) => void;
     onContext: (context?: TContext) => void;
@@ -22,7 +22,7 @@ declare class MMapReactContainer extends MMapGroupEntity<ComputedMMapReactContai
         tagName: string;
     };
     /** @internal */
-    static [reactify.overrideKey]: import("../../reactify/reactify").CustomReactify<MMapReactContainer, TReact.FC<MMapReactContainerProps<unknown> & {
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapReactContainer, TReact.FC<MMapReactContainerProps<unknown> & {
         children?: TReact.ReactNode;
     }>>;
     element?: Element;

package/imperative/index.d.ts

@@ -8,12 +8,13 @@ export { MMapFeatureDataSource, MMapFeatureDataSourceProps } from "./MMapFeature
 export { MMapLayer, MMapLayerProps } from "./MMapLayer";
 export * from "./MMapListener";
 export * from "./MMapHotspot";
+export * from "./wrappers";
 export { MMapMarker, MMapMarkerProps, MMapMarkerEventHandler } from "./MMapMarker";
 export { MMapTileDataSource, MMapTileDataSourceProps } from "./MMapTileDataSource";
 export { MMapControls, MMapControlsProps } from "./MMapControls";
 export { MMapControl, MMapControlProps, MMapControlButton, MMapControlButtonProps, MMapControlCommonButton } from "./MMapControl";
 export { MMapCollection } from "./MMapCollection";
-export * from "./mappableMaps";
+export * from "./mappable-worldMaps";
 export * from "./search";
 export * from "./suggest";
 export * from "./route";
@@ -22,4 +23,6 @@ export { useDomContext } 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";

package/imperative/route/index.d.ts

@@ -44,8 +44,10 @@ export interface RouteOptions {
     results?: 1;
     /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
     jams?: boolean;
-    /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
+    /** 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}. */

package/imperative/suggest.d.ts

@@ -1,18 +1,22 @@
 import type { LngLat, LngLatBounds } from "../common/types";
 import { Config } from "./config";
-type GeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
+type DeprecatedGeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
+type GeoSuggestType = "biz" | "geo" | "street" | "metro" | "district" | "locality" | "area" | "province" | "country" | "house";
 export type SuggestOptions = {
     text: string;
     center?: LngLat;
     span?: LngLat;
     bounds?: LngLatBounds;
-    countries?: string;
-    type?: GeoSuggestType;
     limit?: number;
     localOnly?: number;
     highlight?: boolean;
+    types?: GeoSuggestType[];
+    /** @deprecated */
+    countries?: string;
+    /** @deprecated use types instead */
+    type?: DeprecatedGeoSuggestType;
 };
-type ObjectType = "unknown" | "toponym" | "business" | "transit";
+type DeprecatedObjectType = "unknown" | "toponym" | "business" | "transit";
 /** Positions of chars to highlight between  */
 type Highlight = [
     number,
@@ -22,15 +26,25 @@ type TextWithHighlight = {
     text: string;
     hl: Highlight[];
 };
+type Distance = {
+    text: string;
+    value: number;
+};
 export type SuggestResponseItem = {
-    /** Type of suggested object */
-    type?: ObjectType;
     /** Human-readable object title with matching highlighting */
     title: TextWithHighlight;
     /** Human-readable object subtitle with matching highlighting */
     subtitle?: TextWithHighlight;
-    /** Object value. Useful for next substitution in mappable.search function */
+    /** Distance to the object in meters */
+    distance?: Distance;
+    /** Additional object information that can be used in a Geocoder HTTP API request. */
+    uri?: string;
+    /** Object tags. Possible values: business, street, metro, district, locality, area, province, country, hydro, railway, station, route, vegetation, airport, other, house */
+    tags?: string[];
+    /** @deprecated Use uri instead */
     value: string;
+    /** @deprecated Use tags instead */
+    type?: DeprecatedObjectType;
 };
 export type SuggestResponse = SuggestResponseItem[];
 export declare function suggest(options: SuggestOptions, config?: Config | undefined): Promise<SuggestResponse>;

package/imperative/wrappers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Key is used in `reactify` wrapper, to define custom implementations for react mappable.MMapEntity entities
+ * ```typescript
+ * type MMapSomeClassProps = {
+ *     id: string;
+ * };
+ * export class MMapSomeClass extends mappable.MMapComplexEntity<MMapSomeClassProps> {
+ *  static [mappable.overrideKeyReactify] = MMapSomeClassReactifyOverride;
+ *  //...
+ * }
+ * ```
+ * and
+ * ```jsx
+ * export const MMapSomeClassReactifyOverride = (
+ *   MMapSomeClassI, // it is same MMapSomeClass
+ *   {reactify, React}
+ * ) => {
+ *   const MMapSomeClassReactified = reactify.entity(MMapSomeClassI); // Standard reactivation method
+ *     const MMapSomeClassR = React.forwardRef((props, ref) => {
+ *       return (<>
+ *         <MMapSomeClassReactified {...props} ref={ref} ... />
+ *       </>);
+ *     })
+ *   return MMapSomeClassR;
+ * }
+ * ```
+ * and in the end app
+ * ```jsx
+ * import {MMapSomeClass} from './some-class';
+ * import React from 'react';
+ * import ReactDOM from 'react-dom';
+ * // ...
+ * const mappableReact = await mappable.import('@mappable-world/mappable-reactify');
+ * const reactify = mappableReact.reactify.bindTo(React, ReactDOM);
+ * const {MMapSomeClass as MMapSomeClassR} = reactify.module({MMapSomeClass});
+ *
+ * function App() {
+ *     return <MMapSomeClassR id="some_id"/>;
+ * }
+ * ```
+ */
+export declare const overrideKeyReactify: unique symbol;

package/import.d.ts

@@ -20,7 +20,7 @@ export interface Import {
 declare global {
     const __MODULES__: string[];
     const __PACKAGES__: string[];
-    const __VENDOR__: "mappable" | "mappable";
+    const __VENDOR__: "mappable-world" | "mappable-world";
     const __NAMESPACE__: "mappable" | "mappable";
     const __LOGO_WIDHT__: `${number}px`;
 }

package/main.d.ts

@@ -1,4 +1,8 @@
 export * from "./imperative";
-/** Toggle this to enable/disable strict mode. */
-export declare let strictMode: boolean;
-export declare const __DTS_HIDDEN_BEGIN__: unknown;
+export * as __implReactify from "./reactify";
+export declare const __implReactifyOverride: (reactify: import("./reactify").Reactify) => {
+    reactify: import("./reactify").Reactify;
+    MMapReactContainer: import("react").FC<import("./imperative/MMapReactContainer").MMapReactContainerProps<unknown> & {
+        children?: import("react").ReactNode;
+    }>;
+};

package/modules/types.d.ts

@@ -1,7 +1,7 @@
 import "../import";
 declare module "../import" {
     interface Import {
-        (pkg: "@mappable/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
-        (pkg: "@mappable/mappable-reactify"): Promise<typeof import("../reactify")>;
+        (pkg: "@mappable-world/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
+        (pkg: "@mappable-world/mappable-reactify"): Promise<typeof import("../reactify")>;
     }
 }

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.2",
+    "version": "0.0.4",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",
     "keywords": [
-        "mappable",
+        "mappable-world",
         "api",
         "map",
         "mappable",

package/packages/cartesian-projection/index.d.ts

@@ -18,7 +18,7 @@ import type { Projection, LngLat, WorldCoordinates } from "../../common/types";
  *     const PIC_WIDTH = 2526;
  *     const PIC_HEIGHT = 1642;
  *
- *     const {Cartesian} = await mappable.import('@mappable/mappable-cartesian-projection@0.0.1');
+ *     const {Cartesian} = await mappable.import('@mappable-world/mappable-cartesian-projection@0.0.1');
  *     // We set as a projection Cartesian. With this calculation, the center of the image will lie in the coordinates [0, 0].
  *     const projection = new Cartesian([
  *         [-PIC_WIDTH / 2, PIC_HEIGHT / 2 - worldSize],

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

@@ -1,6 +1,5 @@
 import type { MMapEntity } from "../../..";
 import type { LngLat } from "../../../common/types";
-import { reactify } from "../../../reactify";
 import type { ClustererObject, Feature, IClusterMethod } from "./interface";
 /**
  * MMapClusterer props
@@ -52,7 +51,7 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
         tickTimeout: 200;
     }>;
     /** @internal */
-    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
         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<MMapClustererProps & {

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

@@ -20,7 +20,7 @@ type DefaultProps = typeof defaultProps;
  * @example
  * ```javascript
  * const controls = new MMapControls({position: 'right'});
- * const {MMapZoomControl} = await mappable.import('@mappable/mappable-controls@0.0.1');
+ * const {MMapZoomControl} = await mappable.import('@mappable-world/mappable-controls@0.0.1');
  * const zoomControl = new MMapZoomControl();
  * controls.addChild(zoomControl);
  * map.addChild(controls);

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

@@ -11,14 +11,14 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  *
  * @example
  * ```javascript
- * const {MMapHint, MMapHintContext} = await mappable.import('@mappable/mappable-hint@0.0.1');
+ * const {MMapHint, MMapHintContext} = await mappable.import('@mappable-world/mappable-hint@0.0.1');
  * map.addChild(defaultFeatures = new MMapDefaultFeaturesLayer());
  * map.addChild(hint = MMapHint({
  *    layers: [defaultFeatures.layer],
  *    hint: object => object?.properties?.hint
  * }));
  *
- * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * const {MMapDefaultMarker} = await mappable.import('@mappable-world/mappable-markers@0.0.1');
  * map.addChild(new MMapDefaultMarker({coordinates: [37, 55], properties: {hint: 'Hello world!'}}));
  *
  * hint.addChild(new class MyHint extends mappable.MMapEntity {

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

@@ -1,6 +1,5 @@
 import type { LngLat } from "../../../common/types";
 import type { MMapMarkerProps } from "../../../imperative/MMapMarker";
-import { reactify } from "../../../reactify";
 type DefaultMarkerCustomProps = {
     /** Marker title */
     title?: string;
@@ -31,7 +30,7 @@ type DefaultProps = typeof defaultProps;
  *
  * @example
  * ```javascript
- * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * const {MMapDefaultMarker} = await mappable.import('@mappable-world/mappable-markers@0.0.1');
  * map.addChild(new MMapDefaultMarker({
  *     coordinates: [34, 54],
  *     title: 'Hello World!',
@@ -45,8 +44,8 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         color: "#f33";
     }>;
     /** @internal */
-    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
-        coordinates: LngLat;
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
+        coordinates: LngLat; /** Should popup hide marker. Default is false */
         source?: string | undefined;
         zIndex?: number | undefined;
         properties?: Record<string, unknown> | undefined;

package/packages/spherical-mercator-projection/index.d.ts

@@ -7,7 +7,7 @@ import type { Projection } from "../../common/types";
  * @static
  * @example
  * ```js
- * const { SphericalMercator } = await mappable.import('@mappable/mappable-spherical-mercator-projection@0.0.1');
+ * const { SphericalMercator } = await mappable.import('@mappable-world/mappable-spherical-mercator-projection@0.0.1');
  * // Create a map in the spherical Mercator projection
  * const map = new mappable.MMap(document.getElementById('MMapsID'), {
  *     location: {

package/packages/types.d.ts

@@ -1,11 +1,11 @@
 import "../import";
 declare module "../import" {
     interface Import {
-        (pkg: "@mappable/mappable-cartesian-projection@0.0.1"): Promise<typeof import("./cartesian-projection")>;
-        (pkg: "@mappable/mappable-spherical-mercator-projection@0.0.1"): Promise<typeof import("./spherical-mercator-projection")>;
-        (pkg: "@mappable/mappable-controls@0.0.1"): Promise<typeof import("./controls")>;
-        (pkg: "@mappable/mappable-markers@0.0.1"): Promise<typeof import("./markers")>;
-        (pkg: "@mappable/mappable-hint@0.0.1"): Promise<typeof import("./hint")>;
-        (pkg: "@mappable/mappable-clusterer@0.0.1"): Promise<typeof import("./clusterer")>;
+        (pkg: "@mappable-world/mappable-cartesian-projection@0.0.1"): Promise<typeof import("./cartesian-projection")>;
+        (pkg: "@mappable-world/mappable-spherical-mercator-projection@0.0.1"): Promise<typeof import("./spherical-mercator-projection")>;
+        (pkg: "@mappable-world/mappable-controls@0.0.1"): Promise<typeof import("./controls")>;
+        (pkg: "@mappable-world/mappable-markers@0.0.1"): Promise<typeof import("./markers")>;
+        (pkg: "@mappable-world/mappable-hint@0.0.1"): Promise<typeof import("./hint")>;
+        (pkg: "@mappable-world/mappable-clusterer@0.0.1"): Promise<typeof import("./clusterer")>;
     }
 }

package/reactify/index.d.ts

@@ -1,10 +1,18 @@
 import type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule } from "./reactify";
-import { overrideKey } from "./reactify";
+import type { MMapReactContainer } from "../imperative/MMapReactContainer";
+import { overrideKeyReactify } from "../imperative/wrappers";
 type TReact = typeof import("react");
 type TReactDOM = typeof import("react-dom");
 export type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule };
 export type GenericReactify = {
-    readonly overrideKey: typeof overrideKey;
+    readonly overrideKey: typeof overrideKeyReactify;
     bindTo(React: TReact, ReactDOM: TReactDOM): Reactify;
 };
 export declare const reactify: Readonly<GenericReactify>;
+declare module "./reactify" {
+    interface ReactifyModule<TModule extends BaseModule = BaseModule> {
+        (module: typeof import("../index")): ReactifiedModule<BaseModule & typeof import("../index") & {
+            MMapReactContainer: typeof MMapReactContainer;
+        }>;
+    }
+}

package/reactify/reactify.d.ts

@@ -1,6 +1,7 @@
 import type TReact from "react";
 import type TReactDOM from "react-dom";
 import { GenericEntity, Context, EntityConstructor, EntityProps } from "../imperative/Entities";
+import { overrideKeyReactify } from "../imperative/wrappers";
 type RefInstance<TEntity extends GenericEntity<unknown>> = React.MutableRefObject<TEntity | undefined>;
 interface ReactParent {
     entityRef: RefInstance<GenericEntity<unknown>>;
@@ -15,10 +16,9 @@ export type Reactify = {
     entity: ReactifyEntity;
 };
 export declare const moduleOverrideExport: string;
-export declare const overrideKey: unique symbol;
 export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
     reactify: {
-        module: <TModule extends BaseModule>(module: TModule) => ReactifiedModule<TModule>;
+        module: ReactifyModule;
         entity<T extends EntityConstructor<GenericEntity<unknown>> = EntityConstructor<TEntity>>(...args: Parameters<InternalReactifyEntity<T>>): ReturnType<InternalReactifyEntity<T>>;
         context: <TContext extends Context<unknown>>(context?: TContext) => TReact.Context<unknown>;
     };
@@ -27,13 +27,15 @@ export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (c
     ReactDOM: typeof TReactDOM;
 }) => TResult;
 export type Overrided<TReactResult> = {
-    [overrideKey]: CustomReactify<GenericEntity<unknown>, TReactResult>;
+    [overrideKeyReactify]: CustomReactify<GenericEntity<unknown>, 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>>>;
 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 type ReactifyModule = <TModule extends 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];