tg-map-core 0.0.1

package/dist/src/map/map/talks-map.d.ts

@@ -0,0 +1,81 @@
+import type { Property } from 'csstype';
+import * as maptalks from 'maptalks';
+import 'maptalks/dist/maptalks.css';
+import { LatLng, type CoordType, type LatLngBounds } from '../lat-lng';
+import { type TalksBaseLayerId } from '../talks/talks-layers';
+import type { Padding, Point } from '../types';
+import type { CustomControl } from './controls/control';
+import type { MapTypeControl, MapTypeControlOptions } from './controls/map-type.control';
+import { TalksScaleControl } from './controls/scale.control';
+import { TalksStreetViewControl } from './controls/street-view.control';
+import { TalksZoomControl } from './controls/zoom.control';
+import type { Autocomplete, AutocompleteOptions } from './extra/autocomplete';
+import type { Heatmap, HeatmapOptions } from './extra/heatmap';
+import type { MapUrls, MapUrlsOptions } from './extra/map-urls';
+import type { MarkerClusterer, MarkerClustererOptions } from './extra/marker-clusterer';
+import type { PlacesService, PlacesServiceOptions } from './extra/places-service';
+import type { SearchBox, SearchBoxOptions } from './extra/search-box';
+import { BaseMap } from './map';
+import type { GestureHandlingOptions, MapOptions, MapStyle } from './map-options';
+import { BuildInMapTypeId, type Layer, type MapType } from './map-type';
+import type { CircleOptions, CircleOverlay } from './overlay/circle';
+import type { ElementOverlay } from './overlay/element-overlay';
+import type { InfoBoxOptions, InfoBoxOverlay } from './overlay/info-box';
+import type { InfoWindowOptions, InfoWindowOverlay } from './overlay/info-window';
+import type { LabelOptions, LabelOverlay } from './overlay/label';
+import type { MarkerOptions, MarkerOverlay } from './overlay/marker';
+import type { Overlay } from './overlay/overlay';
+import type { PolygonOptions, PolygonOverlay } from './overlay/polygon';
+import type { PolylineOptions, PolylineOverlay } from './overlay/polyline';
+import type { RectangleOptions, RectangleOverlay } from './overlay/rectangle';
+export declare class TalksMap extends BaseMap {
+    private map;
+    private currentBaseLayerId;
+    constructor(element: HTMLElement, mapOptions: MapOptions, baseLayoutIds: [normal: TalksBaseLayerId] | [normal: TalksBaseLayerId, satellite: TalksBaseLayerId] | [normal: TalksBaseLayerId, satellite: TalksBaseLayerId, hybrid: TalksBaseLayerId]);
+    setGestureHandling(gestureHandling: GestureHandlingOptions): void;
+    get innerMap(): maptalks.Map;
+    get coordType(): CoordType;
+    fromContainerPointToLatLng(point: Point): LatLng;
+    fromLatLngToContainerPoint(latLng: LatLng): Point;
+    setDefaultCursor(cursor: Property.Cursor): void;
+    setDraggable(draggable: boolean): void;
+    setDoubleClickZoom(enable: boolean): void;
+    getCenter(): LatLng;
+    setCenter(latlng: LatLng): void;
+    setMinZoom(zoom: number): void;
+    setMaxZoom(zoom: number): void;
+    setMapStyle(mapStyle?: MapStyle): void;
+    setBuildInMapTypeId(id: BuildInMapTypeId): void;
+    setMapType(mapType: MapType): void;
+    getMapType(): MapType;
+    addLayer(layer: Layer): void;
+    removeLayer(layer: Layer): void;
+    panTo(position: LatLng): void;
+    panBy(x: number, y: number): void;
+    fitBounds(bounds: LatLngBounds, padding?: Padding): void;
+    getBounds(): LatLngBounds;
+    addElementOverlay(overlay: ElementOverlay): void;
+    removeElementOverlay(overlay: ElementOverlay): void;
+    addOverlay(overlay: Overlay): void;
+    removeOverlay(overlay: Overlay): void;
+    createMarker(options: MarkerOptions): MarkerOverlay;
+    createMarkerClusterer(options: MarkerClustererOptions): MarkerClusterer;
+    createHeatmap(options: HeatmapOptions): Heatmap;
+    createAutocomplete(options: AutocompleteOptions): Autocomplete;
+    createSearchBox(options: SearchBoxOptions): SearchBox;
+    createPlacesService(options: PlacesServiceOptions): PlacesService;
+    createMapUrls(options: MapUrlsOptions): MapUrls;
+    createInfoWindow(options: InfoWindowOptions): InfoWindowOverlay;
+    createInfoBox(options: InfoBoxOptions): InfoBoxOverlay;
+    createPolyline(options: PolylineOptions): PolylineOverlay;
+    createPolygon(options: PolygonOptions): PolygonOverlay;
+    createRectangle(options: RectangleOptions): RectangleOverlay;
+    createCircle(options: CircleOptions): CircleOverlay;
+    createLabel(options: LabelOptions): LabelOverlay;
+    addCustomControl(control: CustomControl): void;
+    removeCustomControl(control: CustomControl): void;
+    createMapTypeControl(options: MapTypeControlOptions): MapTypeControl;
+    createZoomControl: typeof TalksZoomControl.create;
+    createStreetViewControl: typeof TalksStreetViewControl.create;
+    createScaleControl: typeof TalksScaleControl.create;
+}

package/dist/src/map/map-config.d.ts

@@ -0,0 +1,29 @@
+import { HERE_SUPPORTED_VERSIONS } from '../utils/here-utils';
+import type { DeepPartial, EmptyObject } from '../utils/mapped-types';
+export interface MapConfig {
+    key: string;
+    version: string;
+}
+export interface TgMapConfig {
+    google: MapConfig & {
+        /** @see https://developers.google.com/maps/documentation/javascript/versions */
+        version: 'weekly' | 'quarterly' | 'beta' | 'alpha' | '3.49' | '3.50' | '3.51' | '3.52';
+        language: string;
+        /** @see https://developers.google.com/maps/documentation/javascript/libraries */
+        libraries: ('drawing' | 'geometry' | 'journeySharing' | 'localContext' | 'marker' | 'places' | 'visualization')[];
+    };
+    baidu: MapConfig & {
+        /** @see https://lbsyun.baidu.com/index.php?title=jspopular3.0/theupdatelog */
+        version: '3.0';
+    };
+    here: MapConfig & {
+        version: typeof HERE_SUPPORTED_VERSIONS[number];
+    };
+    baiduFree: EmptyObject;
+    yandex: EmptyObject;
+    amap: EmptyObject;
+    osm: EmptyObject;
+}
+export type PartialTgMapConfig = DeepPartial<TgMapConfig>;
+export declare function getTgMapConfig(): TgMapConfig;
+export declare function setTgMapConfig(config?: PartialTgMapConfig): void;

package/dist/src/map/map-factory.d.ts

@@ -0,0 +1,33 @@
+import type { BaseMap } from './map/map';
+import { MapOptions } from './map/map-options';
+export declare enum TgMapType {
+    /**
+     * Google地图
+     * - V1: 官方地图, 基本使用免费
+     * - V2: 使用maptalks
+     */
+    google = "google",
+    /**
+     * Baidu地图
+     * - V1: 官方地图, 年费5万
+     * - V2: 使用maptalks
+     */
+    baidu = "baidu",
+    /**
+     * Here地图
+     * - V1: 官方地图, 只实现了1%
+     * - V2: 使用maptalks
+     */
+    here = "here",
+    /** Baidu免费地图, 使用maptalks */
+    baiduFree = "baiduFree",
+    /** Yandex地图, 使用maptalks */
+    yandex = "yandex",
+    /** 高德地图, 使用maptalks */
+    amap = "amap",
+    /** 开源地图, 使用maptalks */
+    osm = "osm"
+}
+export declare namespace TgMapFactory {
+    function createMap(type: TgMapType, $map: HTMLElement, mapOptions?: Partial<MapOptions>): BaseMap;
+}

package/dist/src/map/map-loader.d.ts

@@ -0,0 +1,19 @@
+import { type TgMapConfig } from './map-config';
+import { TgMapType } from './map-factory';
+/**
+ * 使用类型映射的方式`TgMapConfig[T]`, 确定`type`的类型之后, 不会自动推断`config`的类型,
+ * 故另外声明了一个联合类型{@link LoadMapOptionsImpl}, 在实现代码中使用它来自动推断类型
+ */
+type LoadMapOptions<T extends TgMapType> = {
+    type: T;
+    config: TgMapConfig[T];
+};
+/**
+ * 加载缓存的地图, 保证一种地图只加载一次
+ */
+export declare function loadCachedMap(type: TgMapType): Promise<unknown>;
+/** 载入地图库 */
+export declare function loadMap<T extends TgMapType>(options: LoadMapOptions<T>): Promise<unknown>;
+export declare function loadJsonp(url: string, callbackParamName?: string): Promise<unknown>;
+export declare function loadJs(url: string): Promise<unknown>;
+export {};

package/dist/src/map/talks/talks-layers.d.ts

@@ -0,0 +1,9 @@
+import * as maptalks from 'maptalks';
+import { CoordType } from '../lat-lng';
+export declare const talksBaseLayerIds: readonly ["osm", "osm-simple", "google", "baidu", "amap", "tencent", "geoq", "tianditu", "yandex", "bing"];
+export type TalksBaseLayerId = typeof talksBaseLayerIds[number];
+export declare function talksBaseLayerIdToCoordType(layerId: TalksBaseLayerId): CoordType;
+export declare function createTalksBaseLayer(layerId: TalksBaseLayerId, { id, visible, }?: {
+    id?: "google" | "osm" | "osm-simple" | "baidu" | "amap" | "tencent" | "geoq" | "tianditu" | "yandex" | "bing" | undefined;
+    visible?: boolean | undefined;
+}): maptalks.TileLayer;

package/dist/src/map/talks/talks-utils.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Talks {
+    function setVisible(that: {
+        isVisible(): boolean;
+        show(): void;
+        hide(): void;
+    }, visible: boolean): void;
+}

package/dist/src/map/types.d.ts

@@ -0,0 +1,17 @@
+export interface Size {
+    readonly width: number;
+    readonly height: number;
+}
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+export declare namespace Point {
+    const ZERO: Point;
+}
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}

package/dist/src/map/unions.d.ts

@@ -0,0 +1,20 @@
+import * as maptalks from 'maptalks';
+import type { BaiduInfoBox } from './map/overlay/baidu-info-box';
+import type { GoogleLabel } from './map/overlay/google-label';
+/**
+ * Map相关的各种类型的联合, 可以用来简化一部分代码的书写
+ */
+export type UnionMap = google.maps.Map | BMap.Map | H.Map | maptalks.Map;
+export type UnionBaiduIcon = BMap.Icon | BMap.Symbol;
+export type UnionGoogleIcon = google.maps.Icon | google.maps.Symbol | google.maps.UrlIcon;
+export type UnionInfoWindow = google.maps.InfoWindow | BMap.InfoWindow;
+export type UnionAutocomplete = google.maps.places.Autocomplete | BMap.Autocomplete;
+export type UnionPlacesService = google.maps.places.PlacesService | BMap.LocalSearch;
+export type UnionGoogleOverlay = google.maps.Marker | google.maps.Polyline | google.maps.Polygon | google.maps.Circle | google.maps.Rectangle | GoogleLabel;
+export type UnionBaiduOverlay = BMap.Marker | BMap.Polyline | BMap.Polygon | BMap.Circle | BMap.Label | BaiduInfoBox;
+export type UnionGoogleEventTarget = google.maps.MVCObject;
+export type UnionBaiduEventTarget = UnionBaiduOverlay | BMap.InfoWindow | BMap.Autocomplete | BMap.Map;
+export type UnionBaiduShape = BMap.Polyline | BMap.Polygon | BMap.Circle;
+export type UnionGoogleShape = google.maps.Polyline | google.maps.Polygon | google.maps.Circle | google.maps.Rectangle;
+export type UnionControl = BMap.Control | HTMLElement;
+export type GoogleLayer = google.maps.TrafficLayer | google.maps.TransitLayer | google.maps.KmlLayer | google.maps.BicyclingLayer;

package/dist/src/utils/arrays.d.ts

@@ -0,0 +1,19 @@
+import type { AnyFunction, Constructor } from './mapped-types';
+export declare namespace Arrays {
+    function findByType<T>(arr: any[], constructor: Constructor<T>): T | undefined;
+    /** 自动推断item的类型的{@link Array.includes} */
+    function includesTyped<T extends E, E>(arr: T[], item: E): item is T;
+    /** 设置 指定位置的值 */
+    function at<T>(arr: T[], index: number, value: T): void;
+    /** 获取 指定位置的值 */
+    function at<T>(arr: T[], index: number): T | undefined;
+}
+export declare namespace MVCArrays {
+    function indexOf<T>(arr: google.maps.MVCArray<T>, item: T): number;
+    function remove<T>(arr: google.maps.MVCArray<T>, item: T): T | undefined;
+    /**
+     * 监听数组内容变化
+     * @see https://developers.google.com/maps/documentation/javascript/shapes#editable_events
+     * */
+    function listenChanged<T>(path: google.maps.MVCArray<T>, handler: AnyFunction): google.maps.MapsEventListener[];
+}

package/dist/src/utils/baidu-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 3.0版的Overlay是类
+ * @see http://lbsyun.baidu.com/cms/jsapi/reference/jsapi_reference_3_0.html#a3b0
+ */
+export declare function ensureBaiduV3(): void;
+/**
+ * 尝试修复baidu内存占用会越来越大的问题
+ *
+ * 当前版本的baidu源码中, 存在如下代码:
+ * ```
+ * A.lang.qx = function(a) {
+ *   var b = window[A.da]; // A.da等于'$BAIDU$'
+ *   b.kT && delete b.kT[a] // kT属性不存在, 故永远无法移除成功
+ * }
+ * ```
+ * 最终会导致`$BAIDU$._instances`对象不断增长, 故我们把`$BAIDU$`对象的`kT`属性重定向到`_instances`
+ * 保证该方法能够执行成功
+ */
+export declare function tryFixBaiduOutOfMemory(): void;
+export declare const BMapPoints: {
+    /** {@link BMap.Point.equals} 无效, 故需要自己写一个 */
+    equals(a: BMap.Point, b: BMap.Point): boolean;
+};

package/dist/src/utils/elements.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Elements {
+    /** @see https://stackoverflow.com/questions/4880381/check-whether-html-element-has-scrollbars */
+    function isScrollable(ele: Element): boolean;
+}

package/dist/src/utils/formatter.d.ts

@@ -0,0 +1 @@
+export declare function dimen(value: string | number | null | undefined): string | undefined;

package/dist/src/utils/google-utils.d.ts

@@ -0,0 +1,34 @@
+import { type CoordTypeSupplier } from '../map/lat-lng';
+import type { Place } from '../map/map/extra/places-service';
+/**
+ * Google地图官方提供的载入方式, 使用{@link google.map.importLibrary}动态载入依赖
+ *
+ * 实验性的特性, 实测当前只有`3.52`版支持
+ *
+ * @see https://developers.google.com/maps/documentation/javascript/load-maps-js-api#dynamic-library-import
+ */
+export declare function initGoogleMapDynamicLibraryImport(args: {
+    key: string;
+    v?: string;
+}): void;
+export declare const GoogleConst: {
+    /** Google的坐标0点 */
+    readonly LATLNG_ZERO: google.maps.LatLng;
+    readonly BOUNDS_ZERO: google.maps.LatLngBounds;
+};
+export interface AddressFields {
+    /** 国家 */
+    country: string;
+    /** 省 */
+    province: string;
+    /** 市 */
+    city: string;
+    /** 区 */
+    district: string;
+    /** 街道 */
+    street: string;
+    /** 门牌号 */
+    streetNumber: string;
+}
+export declare function parseGoogleAddressComponents(addressComponents: google.maps.GeocoderAddressComponent[], outResult?: AddressFields): AddressFields;
+export declare function parseGooglePlace(place: google.maps.places.PlaceResult, coordTypeSupplier: CoordTypeSupplier): Place;

package/dist/src/utils/here-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 最新是3.1版, 但@types/heremaps和以前的项目都用的是3.0版, 故当前先用3.0...
+ * TODO: 改成使用3.1版实现
+ **/
+export declare const HERE_SUPPORTED_VERSIONS: readonly ["3.0"];
+/**
+ * 当前@types/heremaps是v3.0版, 和v3.1版api有区别, 若要使用3.1版, 需要用这个方法来做到类型注解兼容...
+ * @see https://developer.here.com/documentation/maps/topics/migration.html
+ */
+export declare function ensureHereV31(): void;

package/dist/src/utils/map-utils.d.ts

@@ -0,0 +1,7 @@
+import type { Point } from '../map/types';
+/**
+ * Normalizes the coords that tiles repeat across the x axis (horizontally)
+ * like the standard Google map tiles.
+ * @see https://developers-dot-devsite-v2-prod.appspot.com/maps/documentation/javascript/examples/maptype-image
+ */
+export declare function computeNormalizedTileCoord(tileCoord: Point, zoom: number): Point | null;

package/dist/src/utils/mapped-types.d.ts

@@ -0,0 +1,110 @@
+/** deep版的 `Partial` */
+export type DeepPartial<T> = {
+    [U in keyof T]?: T[U] extends object ? DeepPartial<T[U]> : T[U];
+};
+/** 表示一个函数 */
+export type AnyFunction = (...args: any[]) => any;
+/**
+ * 表示一个构造器
+ * {@link import('vue/types/options').Constructor}
+ * */
+export type Constructor<T = {}> = new (...args: any[]) => T;
+/**
+ * 抽象构造器类型, 相比{@link Constructor}, 不能直接用new创建对象
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures
+ */
+export type AbstractConstructor<T = {}> = abstract new (...args: any[]) => T;
+/** 原始类型=>包装类型 */
+export type PrimitiveToWrapper<T> = T extends boolean ? boolean : T extends string ? string : T extends number ? number : T;
+/** 包装类型=>原始类型 */
+export type WrapperToPrimitive<T> = T extends boolean ? boolean : T extends string ? string : T extends number ? number : T;
+/**
+ * 扩展Record字面量的key的范围为string, 避免用string作为key读取内容时报类型错误的问题
+ *
+ * ```
+ * const r1 = {a: 'a'} // 类型: {a: string}
+ * const v1 = r1['b'] // 类型错误
+ * const r2 = typedRecord({a: 'a'}) // 类型: {a: string} & Record<string, string | undefined>
+ * const v2 = r2['b'] // 类型: string | undefined
+ * ```
+ * */
+export declare function typedRecord<T extends Record<string, any>>(t: T): T & Record<string, T[keyof T] | undefined>;
+/**
+ * `vue instanceof VueConstructor`时`vue`并不会自动转换成`VueConstructor`的子类, 用该方法可以实现这种转换
+ */
+export declare function isInstanceOf<T>(obj: any, constructor: Constructor<T>): obj is T;
+/** @see isInstanceOf */
+export declare function safeAs<T>(obj: any, constructor: Constructor<T>): T | undefined;
+/**
+ * 将可空类型, 强转成非空类型
+ *
+ * 相比`value!`, 若value不是可空类型, 会报类型错误
+ *
+ * @deprecated 和`value!`对比没有明显优势, 留在这里, 主要用来演示TsTypeError的使用...
+ * */
+export declare function asNonNull<T>(value: T): null extends T ? T & {} : undefined extends T ? T & {} : TsTypeError<'value需要是可空类型'>;
+/** {@link NonNullable} 的反义词 */
+export type Nullable<T> = T | null | undefined;
+/** T的所有value的联合类型 */
+export type ValueOf<T> = T[keyof T];
+/**
+ * 提取出T中value为V的子类的所有key
+ * @see https://stackoverflow.com/questions/54520676/in-typescript-how-to-specify-only-keys-of-a-generic-object-whose-values-are-stri
+ * */
+export type KeysMatching<T, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * 并不存在可以精确表示一个枚举类型, 该类只能近似表示一个字符枚举
+ * */
+export type StringEnumLike = {
+    [k: string]: string;
+};
+/**
+ * String枚举的值, 包括`string`类型
+ * @see https://stackoverflow.com/questions/52393730/typescript-string-literal-union-type-from-enum
+ */
+export type StringEnumValue<E extends StringEnumLike> = ValueOf<E> | `${ValueOf<E>}`;
+/**
+ * 包装`T`中的部分枚举字段的值为{@link StringEnumValue}
+ *
+ * 会校验{@link EnumObjects}中的类型是否书写正确, 若写错, 会推断成`never`
+ * */
+export type WrapStringEnumValue<T, EnumObjects extends {
+    [k in keyof T]?: StringEnumLike;
+}> = {
+    [P in keyof T]: P extends keyof EnumObjects ? EnumObjects[P] extends StringEnumLike ? T[P] extends ValueOf<EnumObjects[P]> | undefined ? StringEnumValue<EnumObjects[P]> : never : never : T[P];
+};
+/** 取消包装`T`中的{@link StringEnumValue}字段 */
+export declare function unwrapStringEnumValue<T extends object>(value: T): {
+    [K in keyof T]: T[K] extends StringEnumValue<infer Enum> ? StringEnumLike extends Enum ? T[K] : Enum[keyof Enum] : Exclude<T[K], undefined> extends StringEnumValue<infer Enum> ? StringEnumLike extends Enum ? T[K] : Enum[keyof Enum] | undefined : T[K];
+};
+export declare function unwrapStringEnumValue<E extends StringEnumLike>(value: StringEnumValue<E>, enumObject?: E): E[keyof E];
+export declare function unwrapStringEnumValue<E extends StringEnumLike>(value: StringEnumValue<E> | undefined, enumObject?: E): E[keyof E] | undefined;
+/**
+ * 非空的值
+ *
+ * 类型`{}`也表示"任何非空的值", 但由于它看起来像空对象, 所以一般更推荐用Thing
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/7648#issuecomment-541625573
+ * @see https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
+ */
+export type Thing = string | number | boolean | bigint | object | symbol;
+/**
+ * 空对象, 对象里面不能有任何属性
+ * @see Thing
+ * @see https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
+ */
+export type EmptyObject = Record<string, never>;
+/** 除T指定的类型外, 其他参数 */
+export type TypedAny<T> = T & {
+    [k: string]: any;
+};
+declare const _message: unique symbol;
+/**
+ * TS层级的编译时类型错误
+ */
+export type TsTypeError<Message> = {
+    [_message]: Message;
+};
+export {};

package/dist/src/utils/maps-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * as PolyUtil from './poly-util';
+export * as SphericalUtil from './spherical-util';

package/dist/src/utils/maps-utils/math-util.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The earth's radius, in meters.
+ * Mean radius as defined by IUGG.
+ */
+export declare const EARTH_RADIUS = 6371009;
+/**
+ * Restrict x to the range [low, high].
+ */
+export declare function clamp(x: number, low: number, high: number): number;
+/**
+ * Wraps the given value into the inclusive-exclusive interval between min and max.
+ *
+ * @param n The value to wrap.
+ * @param min The minimum.
+ * @param max The maximum.
+ */
+export declare function wrap(n: number, min: number, max: number): number;
+/**
+ * Returns the non-negative remainder of x / m.
+ *
+ * @param x The operand.
+ * @param m The modulus.
+ */
+export declare function mod(x: number, m: number): number;
+/**
+ * Returns mercator Y corresponding to latitude.
+ * See http://en.wikipedia.org/wiki/Mercator_projection .
+ */
+export declare function mercator(lat: number): number;
+/**
+ * Returns latitude from mercator Y.
+ */
+export declare function inverseMercator(y: number): number;
+/**
+ * Returns haversine(angle-in-radians).
+ * hav(x) == (1 - cos(x)) / 2 == sin(x / 2)^2.
+ */
+export declare function hav(x: number): number;
+/**
+ * Computes inverse haversine. Has good numerical stability around 0.
+ * arcHav(x) == acos(1 - 2 * x) == 2 * asin(sqrt(x)).
+ * The argument must be in [0, 1], and the result is positive.
+ */
+export declare function arcHav(x: number): number;
+export declare function sinFromHav(h: number): number;
+export declare function havFromSin(x: number): number;
+export declare function sinSumFromHav(x: number, y: number): number;
+/**
+ * Returns hav() of distance from (lat1, lng1) to (lat2, lng2) on the unit sphere.
+ */
+export declare function havDistance(lat1: number, lat2: number, dLng: number): number;
+/**
+ * Converts degrees to radians.
+ */
+export declare function toRadians(degrees: number): number;
+/**
+ * Converts radians to degrees.
+ */
+export declare function toDegrees(radians: number): number;

package/dist/src/utils/maps-utils/poly-util.d.ts

@@ -0,0 +1,103 @@
+import type { LatLngLiteral } from '../../map/lat-lng';
+export declare function containsLocation(point: LatLngLiteral, polygon: LatLngLiteral[], geodesic: boolean): boolean;
+/**
+ * Computes whether the given point lies inside the specified polygon.
+ * The polygon is always considered closed, regardless of whether the last point equals
+ * the first or not.
+ * Inside is defined as not containing the South Pole -- the South Pole is always outside.
+ * The polygon is formed of great circle segments if geodesic is true, and of rhumb
+ * (loxodromic) segments otherwise.
+ */
+export declare function containsLocationLatLng(latitude: number, longitude: number, polygon: LatLngLiteral[], geodesic: boolean): boolean;
+/**
+ * Computes whether the given point lies on or near the edge of a polygon, within a specified
+ * tolerance in meters. The polygon edge is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise. The polygon edge is implicitly closed -- the
+ * closing segment between the first point and the last point is included.
+ */
+export declare function isLocationOnEdge(point: LatLngLiteral, polygon: LatLngLiteral[], geodesic?: boolean, tolerance?: number): boolean;
+/**
+ * Computes whether the given point lies on or near a polyline, within a specified
+ * tolerance in meters. The polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise. The polyline is not closed -- the closing
+ * segment between the first point and the last point is not included.
+ */
+export declare function isLocationOnPath(point: LatLngLiteral, polyline: LatLngLiteral[], geodesic?: boolean, tolerance?: number): boolean;
+/**
+ * Computes whether (and where) a given point lies on or near a polyline, within a specified tolerance.
+ * The polyline is not closed -- the closing segment between the first point and the last point is not included.
+ *
+ * @param point our needle
+ * @param poly our haystack
+ * @param geodesic the polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise
+ * @param tolerance tolerance (in meters)
+ * @return -1 if point does not lie on or near the polyline.
+ * 0 if point is between poly[0] and poly[1] (inclusive),
+ * 1 if between poly[1] and poly[2],
+ * ...,
+ * poly.length-2 if between poly[poly.length - 2] and poly[poly.length - 1]
+ */
+export declare function locationIndexOnPath(point: LatLngLiteral, poly: LatLngLiteral[], geodesic: boolean, tolerance?: number): number;
+/**
+ * Computes whether (and where) a given point lies on or near a polyline, within a specified tolerance.
+ * If closed, the closing segment between the last and first points of the polyline is not considered.
+ *
+ * @param point our needle
+ * @param poly our haystack
+ * @param closed whether the polyline should be considered closed by a segment connecting the last point back to the first one
+ * @param geodesic the polyline is composed of great circle segments if geodesic
+ * is true, and of Rhumb segments otherwise
+ * @param toleranceEarth tolerance (in meters)
+ * @return -1 if point does not lie on or near the polyline.
+ * 0 if point is between poly[0] and poly[1] (inclusive),
+ * 1 if between poly[1] and poly[2],
+ * ...,
+ * poly.length-2 if between poly[poly.length - 2] and poly[poly.length - 1]
+ */
+export declare function locationIndexOnEdgeOrPath(point: LatLngLiteral, poly: LatLngLiteral[], closed: boolean, geodesic: boolean, toleranceEarth: number): number;
+/**
+ * Simplifies the given poly (polyline or polygon) using the Douglas-Peucker decimation
+ * algorithm. Increasing the tolerance will result in fewer points in the simplified polyline
+ * or polygon.
+ *
+ * When the providing a polygon as input, the first and last point of the list MUST have the
+ * same latitude and longitude (i.e., the polygon must be closed). If the input polygon is not
+ * closed, the resulting polygon may not be fully simplified.
+ *
+ * The time complexity of Douglas-Peucker is O(n^2), so take care that you do not call this
+ * algorithm too frequently in your code.
+ *
+ * @param poly polyline or polygon to be simplified. Polygon should be closed (i.e.,
+ * first and last points should have the same latitude and longitude).
+ * @param tolerance in meters. Increasing the tolerance will result in fewer points in the
+ * simplified poly.
+ * @return a simplified poly produced by the Douglas-Peucker algorithm
+ */
+export declare function simplify(poly: LatLngLiteral[], tolerance: number): LatLngLiteral[];
+/**
+ * Returns true if the provided list of points is a closed polygon (i.e., the first and last
+ * points are the same), and false if it is not
+ *
+ * @param poly polyline or polygon
+ * @return true if the provided list of points is a closed polygon (i.e., the first and last
+ * points are the same), and false if it is not
+ */
+export declare function isClosedPolygon(poly: LatLngLiteral[]): boolean;
+/**
+ * Computes the distance on the sphere between the point p and the line segment start to end.
+ *
+ * @param p the point to be measured
+ * @param start the beginning of the line segment
+ * @param end the end of the line segment
+ * @return the distance in meters (assuming spherical earth)
+ */
+export declare function distanceToLine(p: LatLngLiteral, start: LatLngLiteral, end: LatLngLiteral): number;
+/**
+ * Decodes an encoded path string into a sequence of LatLngs.
+ */
+export declare function decode(encodedPath: string): LatLngLiteral[];
+/**
+ * Encodes a sequence of LatLngs into an encoded path string.
+ */
+export declare function encode(path: LatLngLiteral[]): string;