@mappable-world/mappable-types 0.0.13 → 0.0.15

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

@@ -130,6 +130,7 @@ interface VectorTileDataSourceDescription {
     allObjectsInteractive?: boolean;
     /** Forces tiles to wait for the icons, disables hiding icons by zoom diff */
     iconsOnlyTiles?: boolean;
+    richModelDecoderWorkerUrl?: string;
     customization?: VectorCustomization;
     theme?: MapTheme;
     /** Defines how hotspots of type should be treated: enabled/disabled or use custom hotspots instead. */

package/common/types/projection.d.ts

@@ -1,6 +1,11 @@
 import type { LngLat } from "./lng-lat";
 import type { WorldCoordinates } from "./coordinates";
 interface GenericProjection<TSource> {
+    /** Projection identity type. It may be:
+         * - EPSG-code (e.g. [EPSG:3857](https://epsg.io/3857))
+         * - any other string to identify (e.g. 'cartesian')
+         **/
+    readonly type?: string;
     toWorldCoordinates(point: TSource): WorldCoordinates;
     fromWorldCoordinates(coordinates: WorldCoordinates): TSource;
 }

package/imperative/MMap/index.d.ts

@@ -35,9 +35,9 @@ export type MMapLocation = MMapCenterZoomLocation & Partial<MMapBoundsLocation>;
  * Observer camera position
  */
 export type MMapCamera = {
-    /** Map tilt in radians. Can take values from 0 to 45 degrees (degrees * (Math.PI / 180)) */
+    /** Map tilt in radians. Can take values from 0 to 50 degrees (degrees * (Math.PI / 180)) */
     tilt?: number;
-    /** Map rotation in degrees. Can take values from -180 to 180 degrees */
+    /** Map rotation in radians. Can take values from -Math.PI to Math.PI */
     azimuth?: number;
 };
 /**
@@ -85,6 +85,8 @@ export type MMapProps = {
     hotspotsStrategy?: "forViewport" | "forPointerPosition";
     /** Position of copyright on the page. Default is 'bottom right' */
     copyrightsPosition?: MMapCopyrightsPosition;
+    /** Show the map scale next to copyright */
+    showScaleInCopyrights?: boolean;
     /**
          * Projection used in map
          */
@@ -111,6 +113,7 @@ declare const defaultProps: Readonly<{
     margin: Margin | undefined;
     copyrights: true;
     copyrightsPosition: "bottom right";
+    showScaleInCopyrights: false;
     worldOptions: {
         cycledX: boolean;
         cycledY: boolean;
@@ -157,6 +160,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         margin: Margin | undefined;
         copyrights: true;
         copyrightsPosition: "bottom right";
+        showScaleInCopyrights: false;
         worldOptions: {
             cycledX: boolean;
             cycledY: boolean;
@@ -181,6 +185,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
         hotspotsStrategy?: "forViewport" | "forPointerPosition" | undefined;
         copyrights?: boolean | undefined;
         copyrightsPosition?: MMapCopyrightsPosition | undefined;
+        showScaleInCopyrights?: boolean | undefined;
         projection?: Projection | undefined;
         worldOptions?: WorldOptions | undefined;
         theme?: MMapTheme | undefined;
@@ -257,6 +262,11 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
          * @param location
          */
     setLocation(location: MMapLocationRequest): void;
+    /**
+         * setter for {@link MMapProps}.camera prop
+         * @param camera
+         */
+    setCamera(camera: MMapCameraRequest): void;
     private __setLocation;
     /**
          * setter for {@link MMapProps}.mode prop

package/imperative/MMap/projection.d.ts

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

package/imperative/MMapControl/MMapControl.d.ts

@@ -3,7 +3,14 @@ import { MMapGroupEntity } from "../MMapEnities";
 /**
  * MMapControl props
  */
-export type MMapControlProps = {};
+export type MMapControlProps = {
+    /** Makes the control transparent by removing background color and shadows */
+    transparent?: boolean;
+};
+declare const defaultProps: Readonly<{
+    transparent: false;
+}>;
+type DefaultProps = typeof defaultProps;
 /**
  *  DOM wrapper for creating custom controls. Connects the styles required by the control.
  *
@@ -30,20 +37,27 @@ export type MMapControlProps = {};
  *
  * @module MMapControl
  */
-export declare class MMapControl<T extends MMapControlProps = MMapControlProps> extends MMapGroupEntity<T> {
-    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl<MMapControlProps>, import("react").ForwardRefExoticComponent<{
+export declare class MMapControl extends MMapGroupEntity<MMapControlProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        transparent: false;
+    }>;
+    static [overrideKeyReactify]: import("../../reactify/reactify").CustomReactify<MMapControl, import("react").ForwardRefExoticComponent<{
+        transparent?: boolean | undefined;
         children?: import("react").ReactNode;
-        ref?: import("react").Ref<import("../Entities").GenericEntity<{
+        ref?: import("react").Ref<import("../Entities").GenericEntity<MMapControlProps & {
             controlElement: HTMLElement;
         }, {}, import("../Entities").GenericRootEntity<unknown, {}>>> | undefined;
         key?: import("react").Key | null | undefined;
     }>>;
-    private _detachDom?;
     private _element?;
+    private _detachDom?;
     private _unwatchThemeContext?;
-    constructor();
+    constructor(props?: MMapControlProps);
     protected _createDom(): HTMLElement;
     protected _onAttach(): void;
+    protected _onUpdate(props: Partial<MMapControlProps>): void;
+    private __watchThemeContext;
     protected _onDetach(): void;
     private _updateTheme;
 }
+export {};

package/imperative/MMapCopyrights/index.d.ts

@@ -3,9 +3,12 @@ type MMapCopyrightsPosition = "top left" | "top right" | "bottom left" | "bottom
 type MMapCopyrightsProps = {
     /** Position of copyright on the map */
     position?: MMapCopyrightsPosition;
+    /** Show the map scale next to the map */
+    showScale?: boolean;
 };
 declare const defaultProps: Readonly<{
     position: MMapCopyrightsPosition;
+    showScale: false;
 }>;
 type DefaultProps = typeof defaultProps;
 /**
@@ -15,12 +18,15 @@ type DefaultProps = typeof defaultProps;
 declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, DefaultProps> {
     static defaultProps: Readonly<{
         position: MMapCopyrightsPosition;
+        showScale: false;
     }>;
     private _boxElement;
     private _copyrightsTextElement;
     private _linkElement;
     private _logoElement;
     private _copyrightsContainer;
+    private _scaleElement;
+    private _scaleControl;
     private _mapWidth;
     private _copyrights;
     private _fixedCopyrights;
@@ -30,8 +36,8 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
     private _unwatchThemeContext?;
     private _detachDom?;
     constructor(props?: MMapCopyrightsProps);
-    protected _updateDom(): void;
     protected _onAttach(): void;
+    protected _onUpdate(props: Partial<MMapCopyrightsProps>): void;
     protected _onDetach(): void;
     private _createDom;
     private _syncDom;
@@ -43,5 +49,6 @@ declare class MMapCopyrights extends MMapGroupEntity<MMapCopyrightsProps, Defaul
     private _setFixedCopyrights;
     private _copyrightsChangeHandler;
     private _adjustText;
+    private _toggleScaleControl;
 }
 export { MMapCopyrights, MMapCopyrightsPosition, MMapCopyrightsProps };

package/imperative/MMapCoverage/index.d.ts

@@ -2,7 +2,7 @@ import { MMapComplexEntity } from "../MMapEnities";
 interface MMapCoverageProps {
     onError?: (e: Error) => void;
 }
-export declare const COVERAGE_LAYERS_TO_SOURCES: Record<string, string>;
+export declare const COVERAGE_LAYERS_TO_SOURCES: Map<string, string>;
 /**
  * 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

package/imperative/MMapDefaultFeaturesLayer/index.d.ts

@@ -7,6 +7,8 @@ type MMapDefaultFeaturesLayerProps = {
     visible?: boolean;
     /** Layer z-index */
     zIndex?: number;
+    /** Name for source */
+    source?: string;
 };
 declare const defaultProps: Readonly<{
     visible: true;

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -1,10 +1,15 @@
 import type { VectorCustomization } from "../../common/types";
+import { MMapLayerProps } from "../MMapLayer";
 import { MMapComplexEntity } from "../MMapEnities";
+type MMapDefaultSchemeLayerType = "ground" | "buildings" | "icons" | "labels";
 /**
  * MMapDefaultSchemeLayer props
  */
 type MMapDefaultSchemeLayerProps = {
-    /** Should show layer */
+    /**
+         * Should show layers
+         * @deprecated use {@link MMapDefaultSchemeLayerProps}.layers instead
+         */
     visible?: boolean;
     /** Vector tiles customization. */
     customization?: VectorCustomization;
@@ -13,28 +18,33 @@ type MMapDefaultSchemeLayerProps = {
          * @deprecated use {@link MMapProps}.theme prop in {@link MMap} instead
          * */
     theme?: "dark" | "light";
+    /** Name for source */
+    source?: string;
+    /** Layers parameters */
+    layers?: Partial<Record<MMapDefaultSchemeLayerType, Partial<MMapLayerProps>>>;
 };
 declare const defaultProps: {
     visible: boolean;
     source: string;
-    layersInfo: {
+    layers: {
         ground: {
-            type: string;
             zIndex: number;
         };
         buildings: {
-            type: string;
             zIndex: number;
         };
         icons: {
-            type: string;
             zIndex: number;
         };
         labels: {
-            type: string;
             zIndex: number;
         };
     };
+    /** @deprecated use {@link DefaultProps}.layers instead */
+    readonly layersInfo: Record<MMapDefaultSchemeLayerType, {
+        type: string;
+        zIndex: number;
+    }>;
 };
 type DefaultProps = typeof defaultProps;
 /**
@@ -53,24 +63,25 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     static defaultProps: {
         visible: boolean;
         source: string;
-        layersInfo: {
+        layers: {
             ground: {
-                type: string;
                 zIndex: number;
             };
             buildings: {
-                type: string;
                 zIndex: number;
             };
             icons: {
-                type: string;
                 zIndex: number;
             };
             labels: {
-                type: string;
                 zIndex: number;
             };
         };
+        /** @deprecated use {@link DefaultProps}.layers instead */
+        readonly layersInfo: Record<MMapDefaultSchemeLayerType, {
+            type: string;
+            zIndex: number;
+        }>;
     };
     private _dataSource?;
     private _layers;
@@ -79,8 +90,6 @@ declare class MMapDefaultSchemeLayer extends MMapComplexEntity<MMapDefaultScheme
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(propsDiff: Partial<MMapDefaultSchemeLayerProps>): void;
-    private _createTileUrl;
-    private _getProjectionQuery;
     private _getDataSourceDescription;
     private _updateTheme;
 }

package/imperative/MMapFeature/index.d.ts

@@ -64,6 +64,7 @@ declare class MMapFeature extends MMapEntity<MMapFeatureProps, DefaultProps> {
     private __onClick;
     private __onDoubleClick;
     private __onFastClick;
-    private __isMy;
+    private __isMySomeObject;
+    private __isMyDraggableObject;
 }
 export { MMapFeature, MMapFeatureProps };

package/imperative/MMapScaleControl/distance-utils.d.ts

@@ -0,0 +1,14 @@
+import type { UnitType } from ".";
+/**
+ * Converts the distance in one set of units to another set of units
+ * @param distance - non-rounded distance in meters
+ * @param unit - unit of measurement to be converted to
+ * @returns converted distance value
+ */
+export declare function convertDistanceToUnit(distance: number, unit: UnitType): number;
+/**
+ * Rounds off the integer distance to the nearest round number
+ * @param rawDistance - unrounded distance
+ * @returns Rounded distance
+ */
+export declare function floorToNearestTenths(rawDistance: number): number;

package/imperative/MMapScaleControl/index.d.ts

@@ -0,0 +1,34 @@
+import { MMapComplexEntity } from "../MMapEnities";
+export type UnitType = "imperial" | "metric" | "nautical";
+type MMapScaleControlProps = {
+    /** Maximum width of scale line in pixels */
+    maxWidth?: number;
+    /** Units of measurement for the scale line */
+    unit?: UnitType;
+};
+declare const defaultProps: Readonly<{
+    maxWidth: 74;
+    unit: "metric";
+}>;
+type DefaultProps = typeof defaultProps;
+declare class MMapScaleControl extends MMapComplexEntity<MMapScaleControlProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        maxWidth: 74;
+        unit: "metric";
+    }>;
+    private _unwatchThemeContext?;
+    private _detachDom?;
+    private _element?;
+    private _labelElement?;
+    private _listener?;
+    constructor(props: MMapScaleControlProps);
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    private _createDom;
+    private _updateDom;
+    private _updateTheme;
+    private _onMapUpdate;
+    private _updateDistance;
+    private _formatDistance;
+}
+export { MMapScaleControl, MMapScaleControlProps };

package/imperative/MMapTileDataSource/index.d.ts

@@ -50,9 +50,12 @@ type MMapTileDataSourceProps = {
  */
 declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
     private _id;
+    private _unwatchVectorContext?;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;
-    private _validateVectorSource;
+    private _getDataSourceDescription;
+    private _onVectorContextUpdate;
+    private _prepareVectorSource;
 }
 export { MMapTileDataSource, MMapTileDataSourceProps };

package/imperative/index.d.ts

@@ -1,3 +1,4 @@
+import * as projections_ from "./utils/projections";
 export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest, MMapCameraRequest } from "./MMap";
 export { MMapThemeContext, ThemeContext, MMapTheme } from "./ThemeContext";
 export { MMapCopyrightsPosition } from "./MMapCopyrights";
@@ -16,6 +17,7 @@ export { MMapControls, MMapControlsProps } from "./MMapControls";
 export { MMapControl, MMapControlProps, MMapControlButton, MMapControlButtonProps, MMapControlCommonButton } from "./MMapControl";
 export { MMapCollection } from "./MMapCollection";
 export { MMapContainer, MMapContainerProps, MMapContainerPropsImpl, ComputedMMapContainerProps } from "./MMapContainer";
+export { MMapScaleControl, MMapScaleControlProps } from "./MMapScaleControl";
 export * from "./mappable-worldMaps";
 export * from "./search";
 export * from "./suggest";
@@ -24,7 +26,11 @@ export { geolocation } from "./geolocation";
 export { useDomContext, DomDetach } from "./DomContext";
 export { Config, getDefaultConfig } from "./config";
 export { fetchConfig, FetchConfigOptions } from "./fetchConfig";
-export * as projections from "./utils/projections";
+/** @deprecated Use mappable packages instead */
+export declare const projections: {
+    /** @deprecated Use [Web Mercator package](https://www.npmjs.com/package/@mappable-world/mappable-web-mercator-projection) instead. */
+    sphericalMercator: projections_.WebMercator;
+};
 /** Toggle this to enable/disable strict mode. */
 export declare let strictMode: boolean;
 export type { LngLat, ReadonlyLngLat, LngLatBounds, BehaviorType, MapMode, Margin, ZoomRange, ZoomStrategy, ZoomRounding, VectorCustomizationTypes, VectorCustomizationElements, VectorCustomizationItem, VectorCustomization, RasterTileDataSourceDescription, VectorTileDataSourceDescription, RasterLayerOptions, EasingFunctionDescription, EasingPresetName, EasingBezierPreset, EasingFunction, DrawingStyle, DrawingStyleIcon, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority } from "../common/types";

package/imperative/route/index.d.ts

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

package/imperative/utils/allowed-custom-layer-implementations.d.ts

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

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

@@ -1 +1 @@
-export * from "./spherical-mercator";
+export * from "./web-mercator";

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

@@ -2,18 +2,18 @@ import type { Projection, LngLat, WorldCoordinates } from "../../../common/types
 /**
  * @class Mercator projection onto a sphere.
  * Used by many mapping services, in particular OpenStreetMap.
- * @name projection.sphericalMercator
+ * @name projection.webMercator
  * @augments Projection
  * @static
  * @example
  * ```js
- * // Create a map in the spherical Mercator projection
+ * // Create a map in the web Mercator projection
  * const map = new mappable.MMap(document.getElementById('MMapsID'), {
  *     location: {
  *         center: [37, 55],
  *         zoom: 6
  *     },
- *     projection: new mappable.SphericalMercator()
+ *     projection: new WebMercator()
  * });
  * const dataSourceProps = {
  *     raster: {
@@ -34,8 +34,9 @@ import type { Projection, LngLat, WorldCoordinates } from "../../../common/types
  * });
  * ```
  */
-declare class SphericalMercator implements Projection {
+export declare class WebMercator implements Projection {
     private _maxLatitudeRad;
+    type: string;
     toWorldCoordinates(coords: LngLat): WorldCoordinates;
     fromWorldCoordinates(world: WorldCoordinates): LngLat;
     private _worldXToLongitude;
@@ -43,5 +44,5 @@ declare class SphericalMercator implements Projection {
     private _latitudeToWorldY;
     private _worldYToLatitude;
 }
-declare const sphericalMercator: SphericalMercator;
-export { sphericalMercator };
+/** @deprecated Use WebMercator instead */
+export declare const SphericalMercator: typeof WebMercator;

package/import.d.ts

@@ -4,9 +4,16 @@ export type Module = Function | null | {
     [key: string]: Function | object;
 };
 export type Loader = (pkg: string) => Promise<Module> | Module;
+type Packages = Record<string, {
+    version: string;
+    path?: string;
+    export?: string;
+}>;
 export interface Import {
     loaders: Loader[];
     default: Loader;
+    cdn: (templatePath: string, packages: Packages | string[] | string) => Loader;
+    registerCdn: (templatePath: string, packages: Packages | string[] | string) => void;
     script: (url: string) => Promise<unknown>;
     cssText: (cssText: string, name: string) => Promise<unknown>;
     style: (url: string) => Promise<unknown>;

package/package.json

@@ -1,25 +1,23 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.13",
+    "version": "0.0.15",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",
-    "keywords": [
-        "mappable-world",
-        "api",
-        "map",
-        "mappable",
-        "types",
-        "js api"
-    ],
+    "keywords": ["mappable-world", "api", "map", "mappable", "types", "js api"],
     "publishConfig": {
         "registry": "https://registry.npmjs.org"
     },
     "homepage": "https://mappable.world",
     "license": "Apache-2.0",
-    "dependencies": {
-        "@types/react": "*",
-        "@types/react-dom": "*",
-        "@vue/runtime-core": "*"
+    "peerDependencies": {
+        "@types/react": "16-18",
+        "@types/react-dom": "16-18",
+        "@vue/runtime-core": "3"
+    },
+    "peerDependenciesMeta": {
+        "@types/react": {"optional": true},
+        "@types/react-dom": {"optional": true},
+        "@vue/runtime-core": {"optional": true}
     }
 }

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

@@ -37,6 +37,7 @@ export declare class Cartesian implements Projection {
     private _cycled;
     private _xRange;
     private _yRange;
+    readonly type = "cartesian";
     constructor(bounds: [
         LngLat,
         LngLat

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

@@ -5,9 +5,10 @@ import type { Projection } from "../../common/types";
  * @name projection.sphericalMercator
  * @augments Projection
  * @static
+ * @deprecated Use [Web Mercator package](https://www.npmjs.com/package/@mappable-world/mappable-web-mercator-projection) instead.
  * @example
  * ```js
- * const { SphericalMercator } = await mappable.import('@mappable-world/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/reactify/reactify.d.ts

@@ -38,7 +38,7 @@ export interface ReactifyModule {
 }
 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];
+    [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 Prettify<T> = {