@mappable-world/mappable-types 0.0.1

package/imperative/index.d.ts

@@ -0,0 +1,26 @@
+export { MMap, MMapProps, MMapCenterLocation, MMapZoomLocation, MMapBoundsLocation, MMapCenterZoomLocation, MMapLocationRequest } from "./MMap";
+export { MMapCopyrightsPosition } from "./MMapCopyrights";
+export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
+export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";
+export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps } from "./MMapDefaultSchemeLayer";
+export { MMapDefaultSatelliteLayer, MMapDefaultSatelliteLayerProps } from "./MMapDefaultSatelliteLayer";
+export * from "./MMapFeature";
+export { MMapFeatureDataSource, MMapFeatureDataSourceProps } from "./MMapFeatureDataSource";
+export { MMapLayer, MMapLayerProps } from "./MMapLayer";
+export * from "./MMapListener";
+export * from "./MMapHotspot";
+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 "./search";
+export * from "./suggest";
+export * from "./route";
+export { geolocation } from "./geolocation";
+export { useDomContext } from "./DomContext";
+export { Config } from "./config";
+export { fetchConfig, FetchConfigOptions } from "./fetchConfig";
+export * as projections from "./utils/projections";
+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/mappableMaps.d.ts

@@ -0,0 +1,7 @@
+import type { MMap } from "./MMap";
+type MappableMaps = {
+    getLink: (map: MMap) => string;
+    open: (map: MMap) => void;
+};
+declare const mappableMaps: MappableMaps;
+export { mappableMaps };

package/imperative/route/driving.d.ts

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

package/imperative/route/index.d.ts

@@ -0,0 +1,54 @@
+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;
+    /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
+    bounds?: boolean;
+}
+export interface BaseRouteResponse {
+    /** Return requested route as {@link RouteFeature RouteFeature}. */
+    toRoute(): RouteFeature;
+}
+export declare function route(options: RouteOptions, config?: Config | undefined): Promise<BaseRouteResponse[]>;

package/imperative/route/utils.d.ts

@@ -0,0 +1,21 @@
+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 {};

package/imperative/search.d.ts

@@ -0,0 +1,83 @@
+import type { LngLat, LngLatBounds } from "../common/types";
+import { Config } from "./config";
+declare const geocoderSearchTypes: {
+    businesses: string;
+    toponyms: string;
+};
+type GeocoderSearchType = keyof typeof geocoderSearchTypes;
+type SearchOptions = {
+    /** Request string represented by a text or {@link LngLat LngLat} point. */
+    text: string;
+    /**
+         * {@link type `type`} parameter specifies the type of
+         * objects that are being searched (and the order of objects
+         * if both types are queried):
+         * - toponyms
+         * - businesses
+         * */
+    type?: GeocoderSearchType[];
+    /** Map zoom. */
+    zoom?: number;
+    /**
+         * Flag that defines whether
+         * search area is restricted by the provided parameters.
+         *
+         * Area restriction is specified by {@link SearchOptions.center `center`}
+         * and {@link SearchOptions.span `span`} parameters
+         * or {@link SearchOptions.bounds `bounds`} parameter.
+         *
+         * false — the search area is *not* restricted
+         *
+         * true — the search area is restricted
+         * */
+    strictBounds?: boolean;
+    /**
+         * The maximum amount of returned objects.
+         *
+         * Parameter has to be specified explicitly if {@link SearchOptions.offset `offset`} parameter is provided.
+         *
+         * **10** is default.
+         *
+         * **100** is maximum.
+         * */
+    limit?: number;
+    /**
+         * The amount of objects (if any returned) that are skipped starting from the first one.
+         *
+         * Parameter {@link SearchOptions.limit `limit`} must be provided.
+         * */
+    offset?: number;
+    /**
+         * {@link LngLat `LngLat`} of the center point of search area.
+         *
+         * {@link SearchOptions.span `span`} parameter sets the length of the search area.
+         * */
+    center?: LngLat;
+    /**
+         * Parameter {@link span `span`} is specified with two numbers that represent
+         * differences between the minimum and maximum:
+         * - longitude of the area
+         * - latitude of the area
+         */
+    span?: LngLat;
+    /**
+         * {@link bounds `bounds`} parameter has priority over
+         * {@link SearchOptions.ll `ll`} and {@link SearchOptions.spn `span`}
+         * */
+    bounds?: LngLatBounds;
+};
+type RawFeature = {
+    properties: {
+        name: string;
+        description: string;
+    };
+    geometry?: {
+        type: "Point";
+        coordinates: LngLat;
+    };
+};
+type Feature = RawFeature;
+type SearchResponse = Feature[];
+declare function search(options: SearchOptions, config?: Config | undefined): Promise<SearchResponse>;
+export { search };
+export type { SearchOptions, SearchResponse };

package/imperative/suggest.d.ts

@@ -0,0 +1,37 @@
+import type { LngLat, LngLatBounds } from "../common/types";
+import { Config } from "./config";
+type GeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
+export type SuggestOptions = {
+    text: string;
+    center?: LngLat;
+    span?: LngLat;
+    bounds?: LngLatBounds;
+    countries?: string;
+    type?: GeoSuggestType;
+    limit?: number;
+    localOnly?: number;
+    highlight?: boolean;
+};
+type ObjectType = "unknown" | "toponym" | "business" | "transit";
+/** Positions of chars to highlight between  */
+type Highlight = [
+    number,
+    number
+];
+type TextWithHighlight = {
+    text: string;
+    hl: Highlight[];
+};
+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 */
+    value: string;
+};
+export type SuggestResponse = SuggestResponseItem[];
+export declare function suggest(options: SuggestOptions, config?: Config | undefined): Promise<SuggestResponse>;
+export {};

package/imperative/traverse.d.ts

@@ -0,0 +1,19 @@
+import { GenericComplexEntity, GenericEntity } from "./Entities";
+export declare const enum TraverseOrder {
+    PREORDER = 1,
+    POSTORDER = -1
+}
+export type TraverseOptions = {
+    readonly order: TraverseOrder;
+    readonly recurse: (node: GenericComplexEntity<unknown>) => boolean;
+};
+export type TraverseState = TraverseOptions & {
+    path: {
+        node: GenericComplexEntity<unknown>;
+        next: number;
+    }[];
+    current?: GenericEntity<unknown>;
+};
+export declare function traverseInit(entity: GenericComplexEntity<unknown>, options: TraverseOptions): TraverseState;
+export declare function traverseStep(state: TraverseState): void;
+export declare function traverseUntil(traverse: TraverseState, predicate: (entity: GenericEntity<unknown>) => boolean): void;

package/imperative/utils/deepFreeze.d.ts

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

package/imperative/utils/errorLogger.d.ts

@@ -0,0 +1,29 @@
+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

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

package/imperative/utils/index.d.ts

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

package/imperative/utils/jsonp.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,16 @@
+import type { ConfigMetaMetrics } from "../config";
+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 function createMetricsTransport<T extends Record<string, unknown>>(metaMetrics: ConfigMetaMetrics, options?: CreateTransportOptions): MetricsTransport<T>;
+export declare const SEND_BOUNDARY: number;
+export declare function initMetrics(config: ConfigMetaMetrics): void;
+export declare function sendMetrics(data: Metrics, options?: TransportOptions): void;
+export {};

package/imperative/utils/pEachChunk.d.ts

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

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

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

package/imperative/utils/projections/spherical-mercator.d.ts

@@ -0,0 +1,47 @@
+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
+ * @augments Projection
+ * @static
+ * @example
+ * ```js
+ * // Create a map in the spherical Mercator projection
+ * const map = new mappable.MMap(document.getElementById('MMapsID'), {
+ *     location: {
+ *         center: [37, 55],
+ *         zoom: 6
+ *     },
+ *     projection: new mappable.SphericalMercator()
+ * });
+ * const dataSourceProps = {
+ *     raster: {
+ *         type: 'ground',
+ *         fetchTile: "https://tile.openstreetmap.org/{{z}}/{{y}}/{{x}}"
+ *     }
+ * };
+ * // Add osm tiles
+ * const dataSource = new mappable.MMapTileDataSource({
+ *     id: "osmSource",
+ *     ...dataSourceProps,
+ * });
+ *
+ * const layer = new mappable.MMapLayer({
+ *     id: "osm",
+ *     source: "osmSource",
+ *     type: "ground",
+ * });
+ * ```
+ */
+declare class SphericalMercator implements Projection {
+    private _maxLatitudeRad;
+    toWorldCoordinates(coords: LngLat): WorldCoordinates;
+    fromWorldCoordinates(world: WorldCoordinates): LngLat;
+    private _worldXToLongitude;
+    private _longitudeToWorldX;
+    private _latitudeToWorldY;
+    private _worldYToLatitude;
+}
+declare const sphericalMercator: SphericalMercator;
+export { sphericalMercator };

package/imperative/utils/removeUndefined.d.ts

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

package/imperative/utils/requestCoverage.d.ts

@@ -0,0 +1,10 @@
+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 };

package/import.d.ts

@@ -0,0 +1,28 @@
+import "./modules/types";
+import "./packages/types";
+export type Module = Function | null | {
+    [key: string]: Function | object;
+};
+export type Loader = (pkg: string) => Promise<Module> | Module;
+export interface Import {
+    /** @internal */
+    __implCache: Record<string, Promise<Module>>;
+    /** @internal */
+    __implInit(base: string, ready: Promise<unknown>): void;
+    /** @internal */
+    __implInlineModules: Record<string, () => Promise<Module>>;
+    loaders: Loader[];
+    default: Loader;
+    script: (url: string) => Promise<unknown>;
+    cssText: (cssText: string, name: string) => Promise<unknown>;
+    style: (url: string) => Promise<unknown>;
+}
+declare global {
+    const __MODULES__: string[];
+    const __PACKAGES__: string[];
+    const __VENDOR__: "mappable" | "mappable";
+    const __NAMESPACE__: "mappable" | "mappable";
+    const __LOGO_WIDHT__: `${number}px`;
+}
+declare const mappableImport: Import;
+export { mappableImport };

package/index.d.ts

@@ -0,0 +1,10 @@
+import "./modules/types";
+import "./packages/types";
+export * from "./imperative";
+export * from "./common/types";
+export const ready: Promise<void>;
+declare const import_: import("./import").Import;
+export { import_ as import };
+declare global {
+    const mappable: typeof import("./index");
+}

package/init.template.d.ts

@@ -0,0 +1,33 @@
+import { ConfigMeta } from "./imperative/config";
+import type { Import } from "./import";
+import { mappableImport } from "./import";
+interface Config {
+    meta?: ConfigMeta;
+    src: {
+        base: string;
+    };
+}
+interface AdhocConfig {
+    /** All logic with this field is for development and CI only. */
+    adhoc?: {
+        meta: {
+            hosts: ConfigMeta["hosts"];
+            apikey: string;
+        };
+        options: {
+            lang: string;
+            signal?: AbortSignal;
+        };
+    };
+}
+type MainModule = typeof import("./main");
+interface MMaps3 extends MainModule {
+    import: Import;
+    ready: Promise<void>;
+    __implReactify: typeof import("./reactify");
+}
+declare global {
+    const __CFG__: Config & AdhocConfig;
+}
+declare const ready: Promise<MMaps3>;
+export { mappableImport as import, ready };

package/main.d.ts

@@ -0,0 +1,4 @@
+export * from "./imperative";
+/** Toggle this to enable/disable strict mode. */
+export declare let strictMode: boolean;
+export declare const __DTS_HIDDEN_BEGIN__: unknown;

package/modules/controls-extra/MMapOpenMapsButton/index.d.ts

@@ -0,0 +1,11 @@
+import { MMapEntity } from "../../../imperative/MMapEnities";
+/**
+ * MMapOpenMapsButton props
+ */
+type MMapOpenMapsButtonProps = {
+    /** Button title */
+    title?: string;
+};
+declare class MMapOpenMapsButton extends MMapEntity<MMapOpenMapsButtonProps> {
+}
+export { MMapOpenMapsButton, MMapOpenMapsButtonProps };

package/modules/controls-extra/index.d.ts

@@ -0,0 +1 @@
+export * from "./MMapOpenMapsButton";

package/modules/editors/MMapFeatureEditor/MMapCustomDomLayer.d.ts

@@ -0,0 +1,9 @@
+import { MMapComplexEntity } from "../../../imperative/MMapEnities";
+type MMapCustomDomLayerProps = {
+    id: string;
+    zIndex: number;
+};
+declare class MMapCustomDomLayer extends MMapComplexEntity<MMapCustomDomLayerProps> {
+    constructor(props: MMapCustomDomLayerProps);
+}
+export { MMapCustomDomLayer, MMapCustomDomLayerProps };

package/modules/editors/MMapFeatureEditor/MMapFeatureEditor.d.ts

@@ -0,0 +1,55 @@
+import { MMapComplexEntity } from "../../../imperative/MMapEnities";
+import type { MMapFeatureEditorProps } from "./interface";
+import { MMapFeatureEditorDefaultPreviewPoint } from "./MMapFeatureEditorDefaultPreviewPoint";
+import { MMapFeatureEditorDefaultPoint } from "./MMapFeatureEditorDefaultPoint";
+declare const defaultProps: Readonly<{
+    isActive: true;
+    featureStyle: {};
+    prefix: "EDITOR";
+    zIndex: 2600;
+    pointZIndex: 1900;
+    previewPointZIndex: 1800;
+    previewPointElement: MMapFeatureEditorDefaultPreviewPoint;
+    renderPoint: () => MMapFeatureEditorDefaultPoint;
+}>;
+type DefaultProps = typeof defaultProps;
+declare class MMapFeatureEditor extends MMapComplexEntity<MMapFeatureEditorProps, DefaultProps> {
+    static defaultProps: Readonly<{
+        isActive: true;
+        featureStyle: {};
+        prefix: "EDITOR";
+        zIndex: 2600;
+        pointZIndex: 1900;
+        previewPointZIndex: 1800;
+        previewPointElement: MMapFeatureEditorDefaultPreviewPoint;
+        renderPoint: () => MMapFeatureEditorDefaultPoint;
+    }>;
+    private _previewPoint;
+    private _draggingPoint;
+    private _getName;
+    private _getZIndex;
+    private shape;
+    private line;
+    constructor(props: MMapFeatureEditorProps);
+    protected __implGetDefaultProps(): DefaultProps;
+    private _updatePreviewPoint;
+    private _updateDraggingPoint;
+    protected _onUpdate({ points, geometry, featureStyle, isActive, prefix, zIndex }: Partial<MMapFeatureEditorProps>): void;
+    private _markers;
+    private _upsertMarker;
+    private _previewMarker;
+    private _upsertPreviewPoint;
+    private handleLayerClick;
+    private handlePointClick;
+    private handlePointDblClick;
+    private _handleDragStart;
+    private handlePreviewDragStart;
+    private handleDragMove;
+    private handlePreviewDragMove;
+    private handleMouseMove;
+    private handlePreviewPointClick;
+    private _handleDragEnd;
+}
+export declare function getCorrectName(prefix: string, postfix: string): string;
+export declare function getCorrectZIndex(zIndex: number, offset: number): number;
+export { MMapFeatureEditor, MMapFeatureEditorProps };

package/modules/editors/MMapFeatureEditor/MMapFeatureEditorDefaultPoint.d.ts

@@ -0,0 +1,9 @@
+import { DomEntity } from "../../../imperative/DomContext";
+declare class MMapFeatureEditorDefaultPoint extends DomEntity<{}> {
+    protected _createDom(): {
+        element: HTMLElement;
+        container: HTMLElement;
+    };
+    protected _updateDom(): void;
+}
+export { MMapFeatureEditorDefaultPoint };

package/modules/editors/MMapFeatureEditor/MMapFeatureEditorDefaultPreviewPoint.d.ts

@@ -0,0 +1,6 @@
+import { DomEntity } from "../../../imperative/DomContext";
+declare class MMapFeatureEditorDefaultPreviewPoint extends DomEntity<{}> {
+    protected _createDom(): HTMLElement;
+    protected _updateDom(): void;
+}
+export { MMapFeatureEditorDefaultPreviewPoint };

package/modules/editors/MMapFeatureEditor/defaults.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_PREFIX = "EDITOR";
+export declare const DEFAULT_Z_INDEX = 2600;
+export declare const DEFAULT_POINT_Z_INDEX = 1900;
+export declare const DEFAULT_PREVIEW_POINT_Z_INDEX = 1800;
+export declare const EVENT_BLOCKER_LAYER_POSTFIX = "EVENT_BLOCKER_LAYER";
+export declare const EVENT_BLOCKER_LAYER_Z_INDEX_OFFSET = 0;
+export declare const FEATURE_POLYGON_SOURCE_POSTFIX = "FEATURE_POLYGON_SOURCE";
+export declare const FEATURE_POLYGON_LAYER_POSTFIX = "FEATURE_POLYGON_LAYER";
+export declare const FEATURE_POLYGON_LAYER_Z_INDEX_OFFSET = 100;
+export declare const FEATURE_LINE_SOURCE_POSTFIX = "FEATURE_LINE_SOURCE";
+export declare const FEATURE_LINE_LAYER_POSTFIX = "FEATURE_LINE_LAYER";
+export declare const FEATURE_LINE_LAYER_Z_INDEX_OFFSET = 200;
+export declare const MARKER_SOURCE_POSTFIX = "MARKER_SOURCE";
+export declare const MARKER_LAYER_POSTFIX = "MARKER_LAYER";
+export declare const MARKER_LAYER_Z_INDEX_OFFSET = 300;
+export declare const LINE_POSTFIX = "LINE";
+export declare const POLYGON_POSTFIX = "POLYGON";

package/modules/editors/MMapFeatureEditor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./defaults";
+export * from "./MMapFeatureEditor";

package/modules/editors/MMapFeatureEditor/interface.d.ts

@@ -0,0 +1,32 @@
+import type { LngLat, DrawingStyle, GenericLineStringGeometry, GenericPolygonGeometry } from "../../../common/types";
+import type { DomEntity } from "../../../imperative/DomContext";
+export type Geometry = GenericPolygonGeometry<LngLat> | GenericLineStringGeometry<LngLat>;
+export interface DraggingPoint {
+    point: LngLat;
+    index: number;
+}
+export interface PreviewPoint {
+    point: LngLat;
+    segmentIndex: number;
+}
+export type MMapFeatureEditorProps = {
+    isActive?: boolean;
+    points: LngLat[];
+    geometry: Geometry;
+    featureStyle?: DrawingStyle;
+    renderPoint?: (index: number) => HTMLElement | DomEntity<unknown>;
+    previewPointElement?: false | HTMLElement | DomEntity<unknown>;
+    onLayerClick?: (coordinates: LngLat, index: number) => void;
+    onPointClick?: (index: number) => void;
+    onPointDblClick?: (index: number) => void;
+    onPointDrag?: (coordinates: LngLat, index: number) => void;
+    onPreviewPointClick?: (coordinates: LngLat, index: number) => void;
+    onPreviewPointDragStart?: (coordinates: LngLat, index: number) => void;
+    onPreviewPointDrag?: (coordinates: LngLat, index: number) => void;
+    onDrag?: (newGeometry: Geometry) => void;
+    prefix?: string;
+    zIndex?: number;
+    /** z index of marker point/preview point, defaults to {@link DEFAULT_Z_INDEX} */
+    pointZIndex?: number;
+    previewPointZIndex?: number;
+};

package/modules/editors/MMapFeatureEditor/math.d.ts

@@ -0,0 +1,6 @@
+import type { LngLat, Projection } from "../../../common/types";
+import type { PreviewPoint } from "./interface";
+declare function getPointWorld(point: LngLat): number;
+declare function findPointProjectionOnLine(projection: Projection, lineCoordinates: LngLat[], point: LngLat, lineWidth: number, zoom: number): PreviewPoint | undefined;
+declare function findIndexForNewPoint(coordinates: LngLat[], points: LngLat[], pointIndex: number): number;
+export { getPointWorld, findIndexForNewPoint, findPointProjectionOnLine, PreviewPoint };

package/modules/editors/index.d.ts

@@ -0,0 +1 @@
+export * from "./MMapFeatureEditor";