@mappable-world/mappable-types 0.0.20 → 0.0.22

package/modules/ruler/MMapRulerCommon.d.ts

@@ -0,0 +1,102 @@
+import { DrawingStyle, LngLat, MMapComplexEntity, MMapMarkerEventHandler } from "../../imperative";
+export declare const TYPE_RULER = "ruler";
+export declare const TYPE_PLANIMETER = "planimeter";
+export type RulerType = typeof TYPE_RULER | typeof TYPE_PLANIMETER;
+export type Measurements = RulerMeasurements | PlanimeterMeasurements;
+export type RulerMeasurements = {
+    type: typeof TYPE_RULER;
+    /** the distance in meters from the first point of the line */
+    distance: number;
+    /** the distance in meters from the previous point of the line */
+    segmentDistance: number;
+    /** the total distance of the line in meters */
+    totalDistance: number;
+};
+export type PlanimeterMeasurements = {
+    type: typeof TYPE_PLANIMETER;
+    /** the area of the closed line shape in square meters */
+    area: number;
+};
+export type CommonMeasurements = Omit<RulerMeasurements, "distance" | "segmentDistance"> | PlanimeterMeasurements;
+export type RulerPointState = {
+    index: number;
+    totalCount: number;
+    coordinates: LngLat;
+    measurements: Measurements;
+    editable: boolean;
+    source: string;
+};
+export type RulerCommonState = {
+    measurements: CommonMeasurements;
+    points: LngLat[];
+};
+export type RenderPointCommon = (params: RenderPointCommonArgs) => RenderPointCommonResult;
+export type RenderPointCommonArgs = {
+    state: RulerPointState;
+    onDragMove: MMapMarkerEventHandler;
+    onDragStart: MMapMarkerEventHandler;
+    onDragEnd: MMapMarkerEventHandler;
+    onDelete: () => void;
+};
+export type RenderPointCommonResult = {
+    update: (state: RulerPointState) => void;
+    remove: (index: number) => void;
+};
+export type UpdateCommonFn = (commonState: RulerCommonState) => void;
+export type UpdateStartFn = (commonState: {}) => void;
+export type UpdateEndFn = (commonState: {}) => void;
+export type RulerGeometry = {
+    style: DrawingStyle;
+};
+export type MMapRulerCommonProps = {
+    type: RulerType;
+    points: LngLat[];
+    editable?: boolean;
+    geometry: RulerGeometry;
+    source?: string;
+    zIndex?: number;
+    previewPoint: HTMLElement;
+    point: RenderPointCommon;
+    onUpdate?: UpdateCommonFn;
+    onUpdateStart?: UpdateStartFn;
+    onUpdateEnd?: UpdateEndFn;
+};
+export declare const defaultProps: Readonly<{
+    editable: true;
+    zIndex: 2600;
+    source: "mappable-ruler";
+}>;
+export declare class MMapRulerCommon extends MMapComplexEntity<MMapRulerCommonProps, typeof defaultProps> {
+    static defaultProps: Readonly<{
+        editable: true;
+        zIndex: 2600;
+        source: "mappable-ruler";
+    }>;
+    private _lineFeature;
+    private _polygonFeature;
+    private _listener;
+    private _previewPointMarker?;
+    private _dataSource;
+    private _markersLayer;
+    private _featuresLayer;
+    private _blockerLayer;
+    private _rulerPoints;
+    private _measurements;
+    private _totalDistance;
+    private _area;
+    constructor(props: MMapRulerCommonProps);
+    protected _onAttach(): void;
+    protected _onDetach(): void;
+    protected _onUpdate(props: Partial<MMapRulerCommonProps>): void;
+    private _commonUpdate;
+    private _updateRulerCoordinates;
+    private _updateRulerGeometry;
+    private _onMouseMoveHandler;
+    private _onMouseMoveOnPreviewMarker;
+    private _onClickHandler;
+    private _createPreviewPointMarker;
+    private _updateMeasurements;
+    private _getFeaturesCoordinates;
+    private _createNewRulerPoint;
+    private _removeRulerPoint;
+}

package/modules/ruler/index.d.ts

@@ -0,0 +1,2 @@
+export { MMapRuler, MMapRulerProps, RenderPointArgs } from "./MMapRuler";
+export { RulerGeometry, RulerType, RulerPointState, RulerCommonState, Measurements } from "./MMapRulerCommon";

package/modules/ruler/react/MMapRuler.d.ts

@@ -0,0 +1,11 @@
+import type TReact from "react";
+import type { MMapEntity } from "../../../imperative";
+import type { CustomReactify, OverrideProps, Prettify } from "../../../reactify/reactify";
+import { RenderPointCommonArgs, MMapRulerCommonProps, MMapRulerCommon as MMapRulerI } from "../MMapRulerCommon";
+type MMapRulerReactifiedProps = Prettify<OverrideProps<MMapRulerCommonProps, {
+    point: (params: RenderPointCommonArgs) => TReact.ReactElement;
+    previewPoint: TReact.ReactElement;
+}>>;
+type MMapRulerR = TReact.ForwardRefExoticComponent<Prettify<MMapRulerReactifiedProps & React.RefAttributes<MMapEntity<MMapRulerReactifiedProps>>>>;
+export declare const MMapRulerReactifyOverride: CustomReactify<MMapRulerI, MMapRulerR>;
+export {};

package/modules/ruler/utils.d.ts

@@ -0,0 +1,54 @@
+import type { LngLat } from "../../imperative";
+import { RulerMeasurements, RulerType } from "./MMapRulerCommon";
+/**
+ * Creates a geodesic line at several points
+ * @param points - Points where the geodesic line is created
+ * @param type - If the type is a `ruler`, then the line is not closed. If the type is a `planimeter`, then it creates a closed line
+ * @param projectionType – Map projection type
+ * @returns Geodesic line coordinates
+ */
+export declare function createGeodesicGeometry(points: LngLat[], type: RulerType): LngLat[];
+/**
+ * Returns a great circle segment between two coordinates
+ * @param firstCoordinates - First coordinate
+ * @param secondCoordinates - Second coordinate
+ * @param npoints - Number of points on the great circle segment
+ * @returns Great circle segment
+ */
+export declare function getGreatCircleSegment(firstCoordinates: LngLat, secondCoordinates: LngLat, npoints?: number): LngLat[];
+/**
+ * Calculates the area of a geodesic figure in square metres.
+ * @param coordinates - Geodesic geometry coordinates
+ * @returns Area in square metres
+ */
+export declare function calcArea(coordinates: LngLat[]): number;
+type DistanceMeasurements = Omit<RulerMeasurements, "type" | "totalDistance">;
+/**
+ * Calculates measurements for each point of the line
+ * @param points - Coordinates of the points on the line
+ * @param projectionType – Map projection type
+ * @returns Array of measurements for each point of the line
+ */
+export declare function calcDistance(points: LngLat[]): DistanceMeasurements[];
+/**
+ * Fixes the line display when crossing the border of the "world".
+ * To do this, it transfers values outside the range (-180, 180) to another "world".
+ * @param lineStringCoordinates - Coordinates of the points on the line
+ * @returns Array of fixed coordinates
+ */
+export declare function unfoldLineStringByShorterDistances(lineStringCoordinates: LngLat[]): LngLat[];
+export declare function getNearestPointOnLine(lineCoordinates: LngLat[], point: LngLat): {
+    index: number;
+    coordinates: LngLat;
+};
+/**
+ * Finds the index of the segment at points, by the index of the segment in the geometry
+ * @param geometry - Geometry coordinates
+ * @param points - Points that lie on the geometry
+ * @param geometrySegmentIndex - Index of segment in geometry
+ * @returns The segment index found in points
+ */
+export declare function findIndexInGeometry(geometry: LngLat[], points: LngLat[], geometrySegmentIndex: number): number;
+export declare function areLngLatFuzzyEqual(a: LngLat, b: LngLat, tolerance?: number): boolean;
+export declare function areLngLatEqual(a: LngLat, b: LngLat): boolean;
+export {};

package/modules/ruler/vue/MMapRuler.d.ts

@@ -0,0 +1,6 @@
+import type { CustomVuefyFn, CustomVuefyOptions } from "../../vuefy";
+import { MMapRulerCommonProps, MMapRulerCommon as MMapRulerI } from "../MMapRulerCommon";
+type MMapRulerVuefyProps = Omit<MMapRulerCommonProps, "point" | "previewPoint">;
+export declare const MMapRulerVuefyOptions: CustomVuefyOptions<MMapRulerI, MMapRulerVuefyProps>;
+export declare const MMapRulerVuefyOverride: CustomVuefyFn<MMapRulerI, MMapRulerVuefyProps>;
+export {};

package/modules/types.d.ts

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

package/modules/vuefy/options/common.d.ts

@@ -1,5 +1,5 @@
 import type { CustomVuefyOptions } from "..";
-import { MMap, MMapContainer, MMapControlButton, MMapControls, MMapDefaultFeaturesLayer, MMapDefaultSchemeLayer, MMapFeature, MMapFeatureDataSource, MMapLayer, MMapMarker, MMapTileDataSource } from "../../../imperative";
+import { MMap, MMapContainer, MMapControlButton, MMapControls, MMapDefaultFeaturesLayer, MMapDefaultSchemeLayer, MMapFeature, MMapFeatureDataSource, MMapLayer, MMapMarker, MMapTileDataSource, MMapContextProvider } from "../../../imperative";
 import { type EntityConstructor, type GenericEntity } from "../../../imperative/Entities";
 import type { ComputedMMapMarkerContainerProps } from "../overrides/MMapMarker";
 export declare const MMapVuefyOptions: CustomVuefyOptions<MMap>;
@@ -13,5 +13,6 @@ export declare const MMapLayerVuefyOptions: CustomVuefyOptions<MMapLayer>;
 export declare const MMapMarkerVuefyOptions: CustomVuefyOptions<MMapMarker, ComputedMMapMarkerContainerProps>;
 export declare const MMapTileDataSourceVuefyOptions: CustomVuefyOptions<MMapTileDataSource>;
 export declare const MMapContainerVuefyOptions: CustomVuefyOptions<MMapContainer>;
+export declare const MMapContextProviderVuefyOptions: CustomVuefyOptions<MMapContextProvider<unknown>>;
 declare const _default: Map<EntityConstructor<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>, CustomVuefyOptions<GenericEntity<unknown, {}, import("../../../imperative/Entities").GenericRootEntity<unknown, {}>>>>;
 export default _default;

package/package.json

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

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

@@ -58,16 +58,16 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
     static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<{
         features: Feature[];
         maxZoom?: number | undefined;
-        tickTimeout?: number | undefined;
         method: IClusterMethod;
+        tickTimeout?: number | undefined;
         onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;
         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>>;
         ref?: import("react").Ref<MMapEntity<{
             features: Feature[];
             maxZoom?: number | undefined;
-            tickTimeout?: number | undefined;
             method: IClusterMethod;
+            tickTimeout?: number | undefined;
             onRender?: ((clusters: ClustererObject[]) => false | void) | undefined;
             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>>;

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

@@ -6,7 +6,7 @@ import { optionsKeyVuefy, overrideKeyReactify, overrideKeyVuefy } from "../../..
 type MMapHintProps = {
     hint: (object: MMapFeature | MMapMarker | MMapHotspot | undefined) => unknown;
 };
-declare const MMapHintContext: import("../../../imperative/Entities").Context<unknown>;
+declare const MMapHintContext: import("../../../imperative/MMapEnities").MMapContext<unknown>;
 /**
  * Display hint on map elements.
  *

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

@@ -1,9 +1,9 @@
 import type { LngLat } from "../../../common/types";
 import type { MMapMarkerProps } from "../../../imperative/MMapMarker";
 type DefaultMarkerCustomProps = {
-    /** Marker title */
+    /** Marker title HTML */
     title?: string;
-    /** Marker subtitle */
+    /** Marker subtitle HTML */
     subtitle?: string;
     /** Marker icon color */
     color?: string;
@@ -62,9 +62,9 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         onDragMove?: import("../../../imperative/MMapMarker").MMapMarkerEventHandler | undefined;
         blockEvents?: boolean | undefined;
         blockBehaviors?: boolean | undefined;
-        onDoubleClick?: ((event: MouseEvent) => void) | undefined;
-        onClick?: ((event: MouseEvent) => void) | undefined;
-        onFastClick?: ((event: MouseEvent) => void) | undefined;
+        onDoubleClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
+        onClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
+        onFastClick?: ((event: MouseEvent, mapEvent: import("../../../imperative/MMapFeature/types").MapEvent) => void) | undefined;
         title?: string | undefined;
         subtitle?: string | undefined;
         color?: string | undefined;

package/reactify/reactify.d.ts

@@ -14,6 +14,7 @@ export declare let ReactParent: React.Context<[
 export type Reactify = {
     module: ReactifyModule;
     entity: ReactifyEntity;
+    useDefault: <T>(value: T, dependencies?: unknown[]) => T;
 };
 export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
     reactify: {

package/imperative/MMapCoverage/index.d.ts

@@ -1,20 +0,0 @@
-import { MMapComplexEntity } from "../MMapEnities";
-interface MMapCoverageProps {
-    onError?: (e: Error) => void;
-}
-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
- */
-declare class MMapCoverage extends MMapComplexEntity<MMapCoverageProps, {}> {
-    private _abortController?;
-    private _prevMeta;
-    private _unwatchMapContext?;
-    constructor(props?: MMapCoverageProps);
-    protected _onAttach(): void;
-    protected _onDetach(): void;
-    private _compareIfMetaDiffers;
-    private _attemptCoverageRequest;
-}
-export { MMapCoverage, MMapCoverageProps };

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

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

package/imperative/utils/deepFreeze.d.ts

@@ -1,2 +0,0 @@
-declare function deepFreeze<ObjectType>(obj: ObjectType): ObjectType;
-export { deepFreeze };

package/imperative/utils/errorLogger.d.ts

@@ -1,29 +0,0 @@
-interface MappableError extends Error {
-    additionalInfo?: Additional;
-    logged?: boolean;
-}
-type Additional = Record<string, unknown>;
-interface LogErrorOptions {
-    message?: string;
-    service?: string;
-    source?: string;
-    sourceMethod?: string;
-    type?: string;
-    block?: string;
-    method?: string;
-    page?: string;
-    additional?: Additional;
-    level?: "info" | "debug" | "warn" | "error" | "critical" | "trace";
-}
-interface LogErrorInitSettings {
-    project?: string;
-    unhandledRejection?: boolean;
-    uncaughtException?: boolean;
-}
-type ErrorLoggerInitFunction = (settings: LogErrorInitSettings) => ErrorLoggerFunction;
-type ErrorLoggerFunction = (options: LogErrorOptions, error?: MappableError) => void;
-export type MappableReactError = Omit<MappableError, "logged">;
-export { ErrorLoggerInitFunction };
-export declare function errorLoggerFactory(initLogger: ErrorLoggerInitFunction): void;
-export declare function logError(error: MappableReactError, options?: Record<string, unknown>): void;
-export declare function throwError(error: MappableReactError): never;

package/imperative/utils/id.d.ts

@@ -1,2 +0,0 @@
-declare function idIncrementedFactory(min?: number, max?: number): () => number;
-export { idIncrementedFactory };

package/imperative/utils/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./errorLogger";
-export * from "./metrics";
-export * from "./requestCoverage";

package/imperative/utils/jsonp.d.ts

@@ -1,9 +0,0 @@
-type BooleanFlag = 0 | 1;
-type JsonpRequest = {
-    url: string;
-    callbackName: string;
-};
-declare function boolToFlag(value: undefined | boolean): undefined | BooleanFlag;
-declare function composeUrl(baseUrl: string, params: Record<string, string | number | undefined>): string;
-declare function jsonp<JsonpResponse>({ url, callbackName }: JsonpRequest): Promise<JsonpResponse>;
-export { jsonp, composeUrl, boolToFlag };

package/imperative/utils/metrics.d.ts

@@ -1,12 +0,0 @@
-type Metrics = {};
-type TransportOptions = {
-    share?: number;
-};
-type MetricsTransport<T> = (metrics: T, options?: TransportOptions) => void;
-type CreateTransportOptions = {
-    prefix?: string;
-    /** Events with share (if defined) less than this value will not be sent, should be in [0, 1] range */
-    sendBoundary?: number;
-};
-export declare const SEND_BOUNDARY: number;
-export {};

package/imperative/utils/pEachChunk.d.ts

@@ -1,2 +0,0 @@
-declare function pEachChunk<T>(data: T[], callback: (elem: T, index: number) => void, chunkSize?: number): Promise<void>;
-export { pEachChunk };

package/imperative/utils/removeUndefined.d.ts

@@ -1 +0,0 @@
-export declare function removeUndefined<T extends {}>(obj: T, recursive?: boolean): T;

package/imperative/utils/requestCoverage.d.ts

@@ -1,10 +0,0 @@
-import type { ReadonlyLngLat, ZoomRange } from "../../common/types";
-export type LayerInfo = {
-    id: string;
-    zoomRange?: ZoomRange;
-    copyrights?: string[];
-    LayerMetaData?: unknown[];
-};
-export type Coverage = LayerInfo[];
-declare function requestCoverage(host: string, layers: string[], coordinates: ReadonlyLngLat, zoom: number, lang: string, signal?: AbortSignal): Promise<Coverage>;
-export { requestCoverage };