tg-map-vue3 3.0.1

package/dist/src/map/event-target.d.ts

@@ -0,0 +1,35 @@
+import { type Tg } from './event';
+import { type CoordTypeSupplier } from './lat-lng';
+import type { UnionGoogleEventTarget, UnionBaiduEventTarget } from './unions';
+/**
+ * ## Delegate(代理) VS Mixin(混合)
+ * Delegate相对于Mixin的优点是调用路径更明确, 缺点是js/ts原生不支持, 需要写样板代码
+ */
+export declare abstract class AbstractEventTargetDelegate<T = any> implements Tg.EventTarget {
+    protected inner: T;
+    protected coordTypeSupplier: CoordTypeSupplier;
+    protected eventMap: Map<string, any>;
+    protected target: Tg.EventTarget;
+    constructor(inner: T, coordTypeSupplier: CoordTypeSupplier);
+    setTarget(target: Tg.EventTarget): this;
+    abstract addEventListener(type: string, listener: Tg.EventListener): void;
+    abstract removeEventListener(type: string, listener: Tg.EventListener): void;
+}
+export declare class GoogleEventTargetDelegate<T extends UnionGoogleEventTarget = UnionGoogleEventTarget> extends AbstractEventTargetDelegate<T> {
+    private static EVENT_TYPE_MAP;
+    addEventListener(type: string, listener: Tg.EventListener): void;
+    removeEventListener(type: string, listener: Tg.EventListener): void;
+}
+export declare class BaiduEventTargetDelegate<T extends UnionBaiduEventTarget = UnionBaiduEventTarget> extends AbstractEventTargetDelegate<T> {
+    private static EVENT_TYPE_MAP;
+    addEventListener(type: string, listener: Tg.EventListener): void;
+    removeEventListener(type: string, listener: Tg.EventListener): void;
+}
+/** 手动维护事件 */
+export declare class EventHub implements Tg.EventTarget {
+    private typeMap;
+    addEventListener(type: string, listener: Tg.EventListener): void;
+    removeEventListener(type: string, listener: Tg.EventListener): void;
+    hasListener(type: string): boolean;
+    notify(event: Tg.Event): void;
+}

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

@@ -0,0 +1,47 @@
+import type { LatLng } from './lat-lng';
+import type { ComponentPublicInstance } from './@vue/compat';
+/**
+ * ## 事件机制对比
+ * - DOM: add/removeEventListener, Event {type, target}
+ * - Vue: $on/$off, 没有Event, listener直接接收数据
+ * - baidu: 模仿DOM
+ * - here: 模仿DOM
+ * - google: addListener+remove, 没有Event, listener直接接收数据
+ *
+ * 综合对比之后, 决定模仿DOM的事件机制
+ */
+export declare namespace Tg {
+    interface Event {
+        type: string;
+        target: EventTarget;
+        originalEvent?: any;
+    }
+    interface MouseEvent extends Event {
+        position: LatLng;
+    }
+    interface EventListener {
+        (this: EventTarget, event: Event): void;
+        /** 唯一id */
+        __id__?: number;
+    }
+    interface EventTarget {
+        addEventListener(type: string, listener: EventListener): void;
+        removeEventListener(type: string, listener: EventListener): void;
+    }
+    /**
+     * 拥有更详细的类型信息
+     * @see EventTarget
+     * */
+    interface EventTargetTyped<THIS extends EventTarget, MAP extends {
+        [k: string]: Event;
+    }> extends EventTarget {
+        addEventListener<K extends keyof MAP>(type: K, listener: (this: THIS, event: MAP[K]) => void): void;
+        removeEventListener<K extends keyof MAP>(type: K, listener: (this: THIS, event: MAP[K]) => void): void;
+    }
+}
+export declare function bindEvents(this: ComponentPublicInstance, target: Tg.EventTarget, excludes?: string[]): void;
+export declare function generateNextEventListenerId(): number;
+/**
+ * JS的Map/object的key都不支持自定义hashCode()/equals(), 故只能生成字符串当作key
+ */
+export declare function generateEventKey(type: string, listener: Tg.EventListener): string;

package/dist/src/map/lat-lng.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="baidumap-web-sdk" />
+/// <reference types="googlemaps" />
+/// <reference types="heremaps" />
+import { type LngLatTuple } from 'coordtransform';
+export declare enum CoordType {
+    wgs84 = "wgs84",
+    gcj02 = "gcj02",
+    bd09 = "bd09"
+}
+export interface CoordTypeSupplier {
+    readonly coordType: CoordType;
+}
+export interface LatLngLiteral {
+    readonly lat: number;
+    readonly lng: number;
+    readonly coord?: CoordType;
+}
+export declare class LatLng {
+    readonly lat: number;
+    readonly lng: number;
+    readonly coord: CoordType;
+    static ZERO: LatLng;
+    /** @param coord Baidu Map的坐标一般都是bd09 */
+    static fromBaidu(point: BMap.Point, coord: CoordType): LatLng;
+    /** @param coord Google Map的坐标依据地图类型不同是不一样的 */
+    static fromGoogle(latlng: google.maps.LatLng, coord: CoordType): LatLng;
+    static fromHere(point: H.geo.IPoint, coord: CoordType): LatLng;
+    static fromLiteral(latlng: LatLngLiteral): LatLng;
+    static fromLngLat(lng: number, lat: number, coord?: CoordType): LatLng;
+    static create(lat: number, lng: number, coord?: CoordType): LatLng;
+    constructor(lat: number, lng: number, coord: CoordType);
+    to(coord: CoordType): LatLng;
+    toBaidu(coord: CoordType): BMap.Point;
+    toGoogle(coord: CoordType): google.maps.LatLng;
+    toHere(coord: CoordType): H.geo.Point;
+    /**
+     * 该方法之所以设计的这么不友好, 是为了防止不必要的开销(大概有点影响😅)
+     *
+     * @returns `[lng, lat]` 注意不要取错顺序
+     * @throws 若当前coord和targetCoord相同, 会抛异常, 故请在外部判断
+     */
+    convert(targetCoord: CoordType): LngLatTuple;
+    equals(other: LatLng): boolean;
+    toString(): string;
+}
+/** 少数接口同时支持对象形式和字面量形式 */
+export type LatLngType = LatLng | LatLngLiteral;
+/**
+ * 反编译自{@link com.google.android.gms.maps.model.LatLngBounds}
+ */
+export declare class LatLngBounds {
+    sw: LatLng;
+    ne: LatLng;
+    static EMPTY: LatLngBounds;
+    static isBetweenLng(minLng: number, maxLng: number, lng: number): boolean;
+    static fromArray(positions: readonly LatLng[]): LatLngBounds | undefined;
+    static from(...positions: LatLng[]): LatLngBounds;
+    static fromGoogle(bounds: google.maps.LatLngBounds, coord: CoordType): LatLngBounds;
+    static fromBaidu(bounds: BMap.Bounds, coord: CoordType): LatLngBounds;
+    static create(sw: LatLng, ne: LatLng): LatLngBounds;
+    coord: CoordType;
+    /**
+     * 不推荐直接创建LatLngBounds, sw和ne的大小关系可能没法保证, 推荐用LatLngBounds.Builder或者LatLngBounds.from等静态方法来创建
+     * @param sw 西南, lat/lng更小
+     * @param ne 东北, lat/lng更大
+     */
+    constructor(sw: LatLng, ne: LatLng);
+    isEmpty(): boolean;
+    contains(position: LatLng): boolean;
+    getCenter(): LatLng;
+    toString(): string;
+    equals(other: LatLngBounds): boolean;
+    toGoogle(coord: CoordType): google.maps.LatLngBounds;
+    toBaidu(coord: CoordType): BMap.Bounds;
+    toBaiduArray(coord: CoordType): BMap.Point[];
+}
+export declare namespace LatLngBounds {
+    class Builder {
+        private coord;
+        private minLat;
+        private minLng;
+        private maxLat;
+        private maxLng;
+        constructor(start: LatLng);
+        build(): LatLngBounds;
+        include(position: LatLng): this;
+        private delta;
+    }
+}

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

@@ -0,0 +1,66 @@
+import { LatLng, LatLngBounds } from '../lat-lng';
+import { AbstractMap, type AbstractMapEventMap } from './map';
+import { MapOptions, GestureHandlingOptions, type MapStyle } from './map-options';
+import type { BaiduOverlay } from './overlay/overlay';
+import { BaiduMarkerClusterer, type MarkerClustererOptions } from './extra/marker-clusterer';
+import { BaiduPolyline } from './overlay/polyline';
+import { BaiduPolygon } from './overlay/polygon';
+import { BaiduCircle } from './overlay/circle';
+import { CustomControl } from './controls/control';
+import { BaiduMapTypeControl } from './controls/map-type.control';
+import { BaiduZoomControl } from './controls/zoom.control';
+import { BaiduScaleControl } from './controls/scale.control';
+import { BaiduMarker } from './overlay/marker';
+import { BaiduInfoWindow } from './overlay/info-window';
+import { BuildInMapTypeId, MapType, type Layer } from './map-type';
+import type { Padding, Point } from '../types';
+import { BaiduLabelOverlay } from './overlay/label';
+import { BaiduInfoBoxOverlay } from './overlay/info-box';
+import type { ElementOverlay } from './overlay/element-overlay';
+export declare class BaiduMap extends AbstractMap {
+    setDefaultCursor(cursor: string): void;
+    private buildInMapTypeId2BIMT;
+    private baiduMapType2BIMT;
+    private map;
+    constructor(element: HTMLElement, mapOptions: MapOptions);
+    setGestureHandling(gestureHandling?: GestureHandlingOptions): void;
+    get innerMap(): BMap.Map;
+    get coordType(): import("../lat-lng").CoordType;
+    addEventListener<K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
+    removeEventListener<K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
+    fromContainerPointToLatLng(point: Point): LatLng;
+    fromLatLngToContainerPoint(latLng: LatLng): Point;
+    setDraggable(draggable: boolean): void;
+    setDisableDoubleClickZoom(type: 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: BaiduOverlay): void;
+    removeOverlay(overlay: BaiduOverlay): void;
+    addCustomControl(control: CustomControl): void;
+    removeCustomControl(control: CustomControl): void;
+    createLabel: typeof BaiduLabelOverlay.create;
+    createCircle: typeof BaiduCircle.create;
+    createPolygon: typeof BaiduPolygon.create;
+    createPolyline: typeof BaiduPolyline.create;
+    createInfoWindow: typeof BaiduInfoWindow.create;
+    createInfoBox: typeof BaiduInfoBoxOverlay.create;
+    createMarker: typeof BaiduMarker.create;
+    createMapTypeControl: typeof BaiduMapTypeControl.create;
+    createZoomControl: typeof BaiduZoomControl.create;
+    createScaleControl: typeof BaiduScaleControl.create;
+    createMarkerClusterer(options: MarkerClustererOptions): BaiduMarkerClusterer;
+}

package/dist/src/map/map/controls/control.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="googlemaps" />
+import type { UnionControl } from '../../unions';
+import { KeyValue } from '../../../utils/values';
+import type { GoogleMap } from '../google-map';
+import type { BaiduMap } from '../baidu-map';
+import type { AbstractMap } from '../map';
+export declare enum ControlPosition {
+    /** 左上 */
+    TOP_LEFT = "top-left",
+    TOP_CENTER = "top-center",
+    /** 右上 */
+    TOP_RIGHT = "top-right",
+    BOTTOM_LEFT = "bottom-left",
+    BOTTOM_CENTER = "bottom-center",
+    BOTTOM_RIGHT = "bottom-right",
+    LEFT_TOP = "left-top",
+    LEFT_CENTER = "left-center",
+    /** 左下 */
+    LEFT_BOTTOM = "left-bottom",
+    RIGHT_TOP = "right-top",
+    RIGHT_CENTER = "right-center",
+    /** 右下 */
+    RIGHT_BOTTOM = "right-bottom"
+}
+export declare namespace ControlPositionConverter {
+    function getBaidu(): KeyValue<ControlPosition, number>;
+    function getGoogle(): KeyValue<ControlPosition, google.maps.ControlPosition>;
+}
+/**
+ * 自定义的Control
+ * @see BaiduMap.addCustomControl
+ * @see GoogleMap.addCustomControl
+ *  */
+export declare abstract class CustomControl {
+    position: ControlPosition;
+    /** 实际添加到地图中的control对象 */
+    inner?: UnionControl;
+    constructor(position: ControlPosition);
+    /** 创建UI元素 */
+    abstract onCreateElement(): HTMLElement;
+}
+/** 内置的Control */
+export declare abstract class AbstractControl {
+    abstract isVisible(): boolean;
+    abstract setVisible(visible: boolean): void;
+    abstract getPosition(): ControlPosition;
+    abstract setPosition(position: ControlPosition): void;
+    abstract addTo(map: AbstractMap): void;
+    abstract removeFrom(map: AbstractMap): void;
+}
+/**
+ * baidu内置的Control
+ * - NavigationControl
+ * - OverviewMapControl
+ * - ScaleControl
+ * - MapTypeControl
+ * - CopyrightControl
+ * - GeolocationControl
+ */
+export declare class BaiduControl<CONTROL extends BMap.Control = BMap.Control> extends AbstractControl {
+    private inner;
+    /** 由于@tg/map的position和baidu的position是多对一的关系, 为了防止set后再get, 得到不同的值, 应该用this.position保存set的值 */
+    private position?;
+    constructor(inner: CONTROL, 
+    /** 由于@tg/map的position和baidu的position是多对一的关系, 为了防止set后再get, 得到不同的值, 应该用this.position保存set的值 */
+    position?: ControlPosition | undefined);
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    getPosition(): ControlPosition;
+    setPosition(position: ControlPosition): void;
+    addTo(map: BaiduMap): void;
+    removeFrom(map: BaiduMap): void;
+}
+export type GoogleControlType = 'zoom' | 'mapType' | 'scale' | 'streetView' | 'rotate' | 'fullscreen';
+/**
+ * google内置的Control
+ * - ZoomControl
+ * - MapTypeControl
+ * - ScaleControl
+ * - StreetViewControl
+ * - RotateControl
+ * - FullscreenControl
+ */
+export declare class GoogleControl extends AbstractControl {
+    private _type;
+    /** 每种类型的position的初始值不一样, 需要外部传入 */
+    private position;
+    visible: boolean;
+    private map;
+    constructor(_type: GoogleControlType, 
+    /** 每种类型的position的初始值不一样, 需要外部传入 */
+    position: ControlPosition);
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    getPosition(): ControlPosition;
+    setPosition(position: ControlPosition): void;
+    addTo(map: GoogleMap): void;
+    removeFrom(): void;
+    protected onCreateOptions(): any;
+    protected tryUpdateOptions(): void;
+}

package/dist/src/map/map/controls/map-type.control.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="baidumap-web-sdk" />
+import { BaiduControl, GoogleControl, ControlPosition, AbstractControl } from './control';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import { MapType } from '../map-type';
+export interface MapTypeControl extends AbstractControl {
+}
+export declare enum MapTypeControlType {
+    DEFAULT = "default",
+    HORIZONTAL = "horizontal",
+    DROPDOWN = "dropdown"
+}
+export interface MapTypeControlOptions {
+    position?: ControlPosition;
+    type?: MapTypeControlType;
+    /** @default MAP_TYPES_DEFAULT 这有这些mapTypes才是各种地图都兼容的 */
+    mapTypes?: MapType[];
+}
+export declare class BaiduMapTypeControl extends BaiduControl<BMap.MapTypeControl> implements MapTypeControl {
+    static create(this: BaiduMap, options: MapTypeControlOptions): BaiduMapTypeControl;
+}
+export declare class GoogleMapTypeControl extends GoogleControl implements MapTypeControl {
+    type: MapTypeControlType;
+    private mapTypes;
+    static create(this: GoogleMap, options: MapTypeControlOptions): GoogleMapTypeControl;
+    private static type2google;
+    constructor(type?: MapTypeControlType, position?: ControlPosition, mapTypes?: MapType[]);
+    onCreateOptions(): any;
+    addTo(map: GoogleMap): void;
+}

package/dist/src/map/map/controls/scale.control.d.ts

@@ -0,0 +1,15 @@
+import { BaiduControl, GoogleControl, ControlPosition, AbstractControl } from './control';
+import type { GoogleMap } from '../google-map';
+import type { BaiduMap } from '../baidu-map';
+export interface ScaleControl extends AbstractControl {
+}
+export interface ScaleControlOptions {
+    position?: ControlPosition;
+}
+export declare class BaiduScaleControl extends BaiduControl implements ScaleControl {
+    static create(this: BaiduMap, options: ScaleControlOptions): BaiduScaleControl;
+}
+export declare class GoogleScaleControl extends GoogleControl implements ScaleControl {
+    static create(this: GoogleMap, options: ScaleControlOptions): GoogleScaleControl;
+    constructor(position?: ControlPosition);
+}

package/dist/src/map/map/controls/zoom.control.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="baidumap-web-sdk" />
+import { BaiduControl, GoogleControl, ControlPosition, AbstractControl } from './control';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+export interface ZoomControl extends AbstractControl {
+}
+export interface ZoomControlOptions {
+    position?: ControlPosition;
+}
+export declare class BaiduZoomControl extends BaiduControl<BMap.NavigationControl> implements ZoomControl {
+    static create(this: BaiduMap, options: ZoomControlOptions): BaiduZoomControl;
+}
+export declare class GoogleZoomControl extends GoogleControl implements ZoomControl {
+    static create(this: GoogleMap, options: ZoomControlOptions): GoogleZoomControl;
+    constructor(position?: ControlPosition);
+}

package/dist/src/map/map/extra/marker-clusterer.d.ts

@@ -0,0 +1,69 @@
+import type { AbstractMap } from '../map';
+import type { GoogleMap } from '../google-map';
+import type { BaiduMap } from '../baidu-map';
+import type { MarkerOverlay } from '../overlay/marker';
+import type { Size, Point } from '../../types';
+export interface MarkerClustererOptions {
+    markers?: MarkerOverlay[];
+    gridSize?: number;
+    maxZoom?: number;
+    minClusterSize?: number;
+    averageCenter?: boolean;
+    styles?: ClusterIconStyle[];
+    stylesIndexCalculator?: (markersLength: number, stylesLength: number) => number;
+    zIndex?: number;
+}
+export interface ClusterIconStyle {
+    url: string;
+    size: Size;
+    anchor?: Point;
+    offset?: Point;
+    textColor?: string;
+    textSize?: number;
+}
+/**
+ * ## GMarkerClusterer 和 BMarkerClusterer 的区别
+ *
+ * GMarkerClusterer
+ * - resetViewport(): 移除
+ * - redraw(): 绘制新的
+ * - repaint(): 先移除, 再绘制
+ * - setXxx(): 只修改值, 不触发repaint()
+ * - add/removeMarker/s(): 接收`opt_nodraw`参数, 为true时不触发redraw/repaint()
+ * - clearMarkers(): 只有clear才会将marker从map上移除
+ *
+ * BMarkerClusterer
+ * - _clearLastClusters(): 移除
+ * - _createClusters(): 绘制新的
+ * - _redraw(): 先移除, 再重绘
+ * - setXxx(): 修改值, 同时触发_redraw()
+ * - add/removeMarker/s(): 每次都触发_redraw/_createClusters()
+ * - clearMarkers(): 同GMarkerClusterer
+ *
+ * H.clustering.Provider(here的点聚合工具类)
+ * - 和baidu/google的api有很大不同, 但总体倾向于baidu的实现, 每次修改坐标点都触发重新计算点聚合
+ */
+export declare abstract class MarkerClusterer {
+    map: AbstractMap;
+    inner: any;
+    constructor(map: AbstractMap);
+    /** baidu/google 拥有相同的函数名 */
+    clearMarkers(): void;
+    /** @see clearMarkers */
+    addMarker(marker: MarkerOverlay): void;
+    /** @see clearMarkers */
+    removeMarker(marker: MarkerOverlay): boolean;
+    /** @see clearMarkers */
+    addMarkers(markers: MarkerOverlay[]): void;
+    /** @see clearMarkers */
+    removeMarkers(markers: MarkerOverlay[]): boolean;
+    abstract recreate(): void;
+}
+export declare class BaiduMarkerClusterer extends MarkerClusterer {
+    constructor(map: BaiduMap, options: MarkerClustererOptions);
+    recreate(): void;
+}
+export declare class GoogleMarkerClusterer extends MarkerClusterer {
+    constructor(map: GoogleMap, options: MarkerClustererOptions);
+    recreate(): void;
+}

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

@@ -0,0 +1,68 @@
+/// <reference types="googlemaps" />
+import { LatLng, LatLngBounds } from '../lat-lng';
+import { AbstractMap } from './map';
+import type { MapOptions, GestureHandlingOptions, MapStyle } from './map-options';
+import type { GoogleOverlay } from './overlay/overlay';
+import { type MarkerClustererOptions, GoogleMarkerClusterer } from './extra/marker-clusterer';
+import { GooglePolyline } from './overlay/polyline';
+import { GooglePolygon } from './overlay/polygon';
+import { GoogleCircle } from './overlay/circle';
+import { CustomControl } from './controls/control';
+import { GoogleMapTypeControl } from './controls/map-type.control';
+import { GoogleZoomControl } from './controls/zoom.control';
+import { GoogleScaleControl } from './controls/scale.control';
+import { GoogleMarker } from './overlay/marker';
+import { GoogleInfoWindow } from './overlay/info-window';
+import { BuildInMapTypeId, MapType, type Layer, type OverlayMapType } from './map-type';
+import { type Padding, Point } from '../types';
+import { GoogleLabelOverlay } from './overlay/label';
+import { GoogleInfoBoxOverlay } from './overlay/info-box';
+import type { ElementOverlay } from './overlay/element-overlay';
+export declare class GoogleMap extends AbstractMap {
+    mapOptions: MapOptions;
+    setDefaultCursor(cursor: string): void;
+    private buildInMapTypeId2BIMT;
+    private googleMapTypeId2BIMT;
+    private map;
+    constructor(element: HTMLElement, mapOptions: MapOptions);
+    setGestureHandling(gestureHandling?: GestureHandlingOptions): void;
+    get innerMap(): google.maps.Map;
+    get coordType(): import("../lat-lng").CoordType;
+    fromContainerPointToLatLng(point: Point): LatLng;
+    fromLatLngToContainerPoint(latLng: LatLng): Point;
+    setDraggable(draggable: boolean): void;
+    setDisableDoubleClickZoom(type: 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;
+    addOverlayMapType(mapType: OverlayMapType): void;
+    removeOverlayMapType(mapType: OverlayMapType): void;
+    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: GoogleOverlay): void;
+    removeOverlay(overlay: GoogleOverlay): void;
+    addCustomControl(control: CustomControl): void;
+    removeCustomControl(control: CustomControl): void;
+    createLabel: typeof GoogleLabelOverlay.create;
+    createCircle: typeof GoogleCircle.create;
+    createPolygon: typeof GooglePolygon.create;
+    createPolyline: typeof GooglePolyline.create;
+    createInfoWindow: typeof GoogleInfoWindow.create;
+    createInfoBox: typeof GoogleInfoBoxOverlay.create;
+    createMarker: typeof GoogleMarker.create;
+    createMapTypeControl: typeof GoogleMapTypeControl.create;
+    createZoomControl: typeof GoogleZoomControl.create;
+    createScaleControl: typeof GoogleScaleControl.create;
+    createMarkerClusterer(options: MarkerClustererOptions): GoogleMarkerClusterer;
+}

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

@@ -0,0 +1,49 @@
+/// <reference types="heremaps" />
+import { AbstractMap } from './map';
+import type { MapOptions } from './map-options';
+import { CoordType, LatLng } from '../lat-lng';
+export declare class HereMap extends AbstractMap {
+    mapOptions: MapOptions;
+    setDefaultCursor(cursor: string): void;
+    private map;
+    defaultLayers: H.service.DefaultLayers;
+    constructor(element: HTMLElement, mapOptions: MapOptions);
+    get innerMap(): H.Map;
+    get coordType(): CoordType;
+    getCenter(): LatLng;
+    setCenter(latlng: LatLng): void;
+    setDraggable(draggable: boolean): void;
+    setDisableDoubleClickZoom(type: boolean): void;
+    fromContainerPointToLatLng(point: import('../types').Point): LatLng;
+    fromLatLngToContainerPoint(latLng: LatLng): import('../types').Point;
+    addElementOverlay(overlay: import('./overlay/element-overlay').ElementOverlay): void;
+    removeElementOverlay(overlay: import('./overlay/element-overlay').ElementOverlay): void;
+    createInfoBox(options: import('./overlay/info-box').InfoBoxOptions): import('./overlay/info-box').InfoBoxOverlay;
+    createLabel(options: import('./overlay/label').LabelOptions): import('./overlay/label').LabelOverlay;
+    fitBounds(bounds: import('../lat-lng').LatLngBounds, padding?: import('../types').Padding): void;
+    getBounds(): import('../lat-lng').LatLngBounds;
+    panTo(position: LatLng): void;
+    panBy(x: number, y: number): void;
+    setBuildInMapTypeId(id: import('./map-type').BuildInMapTypeId): void;
+    setMapType(mapType: import('./map-type').MapType): void;
+    getMapType(): import('./map-type').MapType;
+    addLayer(layer: import('./map-type').Layer): void;
+    removeLayer(layer: import('./map-type').Layer): void;
+    setGestureHandling(gestureHandling: import('./map-options').GestureHandlingOptions): void;
+    setMinZoom(zoom: number): void;
+    setMaxZoom(zoom: number): void;
+    setMapStyle(mapStyle: import('./map-options').MapStyle): void;
+    addOverlay(overlay: import('./overlay/overlay').Overlay<unknown>): void;
+    removeOverlay(overlay: import('./overlay/overlay').Overlay<unknown>): void;
+    createMarker(options: import('./overlay/marker').MarkerOptions): import('./overlay/marker').MarkerOverlay;
+    createMarkerClusterer(options: import('./extra/marker-clusterer').MarkerClustererOptions): import('./extra/marker-clusterer').MarkerClusterer;
+    createInfoWindow(options: import('./overlay/info-window').InfoWindowOptions): import('./overlay/info-window').InfoWindowOverlay;
+    createPolyline(options: import('./overlay/polyline').PolylineOptions): import('./overlay/polyline').PolylineOverlay;
+    createPolygon(options: import('./overlay/polygon').PolygonOptions): import('./overlay/polygon').PolygonOverlay;
+    createCircle(options: import('./overlay/circle').CircleOptions): import('./overlay/circle').CircleOverlay;
+    addCustomControl(control: import('./controls/control').CustomControl): void;
+    removeCustomControl(control: import('./controls/control').CustomControl): void;
+    createMapTypeControl(options: import('./controls/map-type.control').MapTypeControlOptions): import('./controls/map-type.control').MapTypeControl;
+    createZoomControl(options: import('./controls/zoom.control').ZoomControlOptions): import('./controls/zoom.control').ZoomControl;
+    createScaleControl(options: import('./controls/scale.control').ScaleControlOptions): import('./controls/zoom.control').ZoomControl;
+}

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

@@ -0,0 +1,46 @@
+/// <reference types="googlemaps" />
+import { LatLng } from '../lat-lng';
+import type { BuildInMapTypeId } from './map-type';
+export type InfoWindowMode = 'single' | 'multi';
+/**
+ * 完全模仿google的模式, 合并如下配置:
+ * - draggable
+ * - scrollWheel
+ * - doubleClickZoom
+ */
+export declare enum GestureHandlingOptions {
+    /** 默认, 若页面可滚动, 则为cooperative, 否则为greedy */
+    auto = "auto",
+    /** 全部设为false */
+    none = "none",
+    /** 贪婪, 全部设为true */
+    greedy = "greedy",
+    /** 合作, 按住ctrl或者双指才能缩放地图 */
+    cooperative = "cooperative"
+}
+export interface MapOptions {
+    /** 中心点 */
+    center: LatLng;
+    /** 缩放等级, 必须是整数 */
+    zoom: number;
+    infoWindowMode?: InfoWindowMode;
+    gestureHandling?: GestureHandlingOptions;
+    minZoom?: number;
+    maxZoom?: number;
+    mapStyle?: MapStyle;
+    buildInMapTypeId?: BuildInMapTypeId;
+}
+export declare namespace MapOptions {
+    function create(options?: Partial<MapOptions>): MapOptions;
+}
+export interface MapStyle {
+    toBaidu(): BMap.MapStyleV2;
+    toGoogle(): google.maps.MapTypeStyle[];
+}
+export declare class SimpleMapStyle implements MapStyle {
+    baidu: BMap.MapStyleV2;
+    google: google.maps.MapTypeStyle[];
+    constructor(baidu: BMap.MapStyleV2, google: google.maps.MapTypeStyle[]);
+    toBaidu(): BMap.MapStyleV2;
+    toGoogle(): google.maps.MapTypeStyle[];
+}