tg-map-core 0.0.1

package/dist/src/map/map/extra/autocomplete.d.ts

@@ -0,0 +1,42 @@
+import { type AddressFields } from '../../../utils/google-utils';
+import type { EventCallback } from '../../../utils/utils';
+import { type RemoveEventListenerFunction } from '../../event-target';
+import type { LatLngBounds } from '../../lat-lng';
+import type { UnionAutocomplete } from '../../unions';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { AbstractMap } from '../map';
+export interface AutocompleteResult extends AddressFields {
+    /** 名字 */
+    title: string;
+}
+export interface AutocompleteOptions {
+    input: HTMLInputElement;
+    /** 将{@link Autocomplete.setBounds}自动设为地图的当前范围 */
+    bindToMap?: boolean;
+}
+/**
+ * 该类没有太多事件, 故没有去实现{@link Tg.EventTarget}接口
+ */
+export declare abstract class Autocomplete {
+    abstract inner: UnionAutocomplete;
+    abstract map: AbstractMap;
+    abstract addResultListener(listener: EventCallback<AutocompleteResult>): RemoveEventListenerFunction;
+    abstract setBounds(bounds: LatLngBounds): void;
+}
+export declare class GoogleAutocomplete extends Autocomplete {
+    map: GoogleMap;
+    inner: google.maps.places.Autocomplete;
+    constructor(map: GoogleMap, options: AutocompleteOptions);
+    setBounds(bounds: LatLngBounds): void;
+    addResultListener(listener: EventCallback<AutocompleteResult>): RemoveEventListenerFunction;
+}
+export declare class BaiduAutocomplete extends Autocomplete {
+    map: BaiduMap;
+    inner: BMap.Autocomplete;
+    private input;
+    private removeableArray;
+    constructor(map: BaiduMap, options: AutocompleteOptions);
+    setBounds(bounds: LatLngBounds): void;
+    addResultListener(listener: EventCallback<AutocompleteResult>): RemoveEventListenerFunction;
+}

package/dist/src/map/map/extra/heatmap.d.ts

@@ -0,0 +1,71 @@
+import BHeatMapOverlay from 'bmaplib.heatmap';
+import type { LatLng, WeightedLatLng } from '../../lat-lng';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { AbstractMap } from '../map';
+type BHeatMapOverlayType = InstanceType<typeof BHeatMapOverlay>;
+export interface HeatmapOptions {
+    data: HeatmapData;
+    /**
+     * 透明度
+     *
+     * ## 不同效果
+     * - google: 正常
+     * - baidu: 设置透明度后模糊效果有问题, 感觉是bug
+     */
+    opacity?: number;
+    /**
+     * 半径
+     *
+     * ## 默认半径的区别
+     * - google: 默认半径是10
+     * - baidu: 默认半径是40
+     *
+     * 这里统一成默认半径{@link RADIUS_DEFAULT}
+     */
+    radius?: number;
+    /**
+     * ## 不同实现
+     * - google: 接收颜色数组, 不能设置插值的位置
+     * - baidu: 接收`{.1: 'red', .9: 'green'}`形式的颜色对象, 可以指定插值的位置
+     */
+    gradient?: Record<number, string>;
+    maxIntensity?: number;
+}
+export type HeatmapData = (LatLng | WeightedLatLng)[];
+export declare abstract class Heatmap {
+    abstract inner: google.maps.visualization.HeatmapLayer | BHeatMapOverlayType;
+    abstract map: AbstractMap;
+    /** 只更新data */
+    abstract setData(data: HeatmapData): void;
+    /** 一次性更新所有options */
+    abstract setOptions(options: HeatmapOptions): void;
+    /**
+     * 从地图上移除
+     * 创建之后会被立即添加到地图上, 故只有remove方法
+     * */
+    abstract remove(): void;
+}
+export declare class GoogleHeatmap extends Heatmap {
+    map: GoogleMap;
+    inner: google.maps.visualization.HeatmapLayer;
+    constructor(map: GoogleMap, options: HeatmapOptions);
+    setData(data: HeatmapData): void;
+    setOptions(options: HeatmapOptions): void;
+    remove(): void;
+}
+export declare class BaiduHeatmap extends Heatmap {
+    map: BaiduMap;
+    inner: BHeatMapOverlayType;
+    /**
+     * 当前的最大值
+     * 直接读取/修改`inner.data.max`, 实现类似google那种, 可以直接设置最大值的效果
+     * */
+    private get innerDataMax();
+    private set innerDataMax(value);
+    constructor(map: BaiduMap, options: HeatmapOptions);
+    setData(data: HeatmapData): void;
+    setOptions(options: HeatmapOptions): void;
+    remove(): void;
+}
+export {};

package/dist/src/map/map/extra/map-urls.d.ts

@@ -0,0 +1,59 @@
+import { Location, type LatLng } from '../../lat-lng';
+export type DirectionMode = 'transit' | 'driving' | 'walking';
+/** google多支持一种导航模式 */
+type GoogleDirectionMode = DirectionMode | 'bicycling';
+export interface MapUrlsOptions {
+}
+export declare abstract class MapUrls {
+    protected options: MapUrlsOptions;
+    constructor(options: MapUrlsOptions);
+    /**
+     * 导航
+     *
+     * ## {@link origin}为空时的行为差异
+     * - google: 用我的位置当做起点
+     * - baidu: 用{@link destination}当作起点
+     */
+    abstract directions(origin: Location | undefined, destination: Location, mode?: DirectionMode): URL;
+    /**
+     * 搜索
+     */
+    abstract search(location: Location): URL;
+}
+/**
+ * @see https://developers.google.com/maps/documentation/urls/get-started
+ */
+export declare class GoogleMapUrls extends MapUrls {
+    static BASE_URL: string;
+    /** @see https://developers.google.com/maps/documentation/urls/get-started#directions-action */
+    directions(origin: Location | undefined, destination: Location, mode?: GoogleDirectionMode): URL;
+    /** @see https://developers.google.com/maps/documentation/urls/get-started#search-action */
+    search(location: Location): URL;
+}
+/**
+ * @see https://lbsyun.baidu.com/faq/api?title=webapi/uri
+ */
+export declare class BaiduMapUrls extends MapUrls {
+    static BASE_URL: string;
+    /**
+     * 导航
+     * @see https://lbsyun.baidu.com/faq/api?title=webapi/uri/web#:~:text=%E6%9C%8D%E5%8A%A1%E5%9C%B0%E5%9D%80-,http%3A//api.map.baidu.com/direction,-//PC%26Webapp%E6%9C%8D%E5%8A%A1
+     * */
+    directions(origin: Location | undefined, destination: Location, mode?: DirectionMode): URL;
+    search(location: Location): URL;
+    /**
+     * 显示经纬度, {@link markerApi}中途跳转的url, 一定能够定位到
+     * */
+    latlngApi(location: LatLng): URL;
+    /**
+     * 显示marker点, 由于缓存等因素的存在, 不一定能够定位到点
+     * @see https://lbsyun.baidu.com/faq/api?title=webapi/uri/web#%E5%9B%BE%E5%8C%BA%E5%8A%9F%E8%83%BD
+     */
+    markerApi(location: LatLng, title: string, content: string): URL;
+    /**
+     * 编码/反编码, 由于缓存等因素的存在, 不一定能够定位到点
+     * @see https://lbsyun.baidu.com/faq/api?title=webapi/uri/web#%E5%9B%BE%E5%8C%BA%E5%8A%9F%E8%83%BD:~:text=%E4%B8%8D%E4%BF%9D%E8%AF%81%E6%9C%8D%E5%8A%A1%E3%80%82-,2.1.2%20%E5%9C%B0%E5%9D%80%E8%A7%A3%E6%9E%90,-%E8%B0%83%E7%94%A8%E8%AF%A5
+     * */
+    geocoderApi(location: Location): URL;
+}
+export {};

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

@@ -0,0 +1,73 @@
+import GMarkerClusterer from '@google/markerclusterer';
+import BMarkerClusterer from 'bmaplib.markerclusterer';
+import type { Point, Size } from '../../types';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { AbstractMap } from '../map';
+import type { MarkerOverlay } from '../overlay/marker';
+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;
+    abstract 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 {
+    inner: BMarkerClusterer;
+    constructor(map: BaiduMap, options: MarkerClustererOptions);
+    recreate(): void;
+}
+export declare class GoogleMarkerClusterer extends MarkerClusterer {
+    inner: GMarkerClusterer;
+    constructor(map: GoogleMap, options: MarkerClustererOptions);
+    recreate(): void;
+}

package/dist/src/map/map/extra/places-service.d.ts

@@ -0,0 +1,47 @@
+import { LatLng, LatLngBounds, Location } from '../../lat-lng';
+import type { UnionPlacesService } from '../../unions';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { AbstractMap } from '../map';
+export interface Place {
+    id: string;
+    position: LatLng;
+    country: string;
+    province: string;
+    city: string;
+    title: string;
+    address: string;
+}
+export interface PlacesServiceOptions {
+}
+export declare abstract class PlacesService {
+    abstract inner: UnionPlacesService;
+    abstract map: AbstractMap;
+    constructor();
+    /** 指定{@link location}搜索, 若不指定, 则默认使用地图的中心点 */
+    abstract search(query: string, location?: Location): Promise<Place[]>;
+    /** 在指定的bounds范围内搜索 */
+    abstract searchInBounds(query: string, bounds: LatLngBounds): Promise<Place[]>;
+    /** 在指定的center+radius范围内搜索 */
+    abstract searchNearBy(query: string, center: LatLng, radius: number): Promise<Place[]>;
+}
+export declare class GooglePlacesService extends PlacesService {
+    map: GoogleMap;
+    inner: google.maps.places.PlacesService;
+    constructor(map: GoogleMap, _options: PlacesServiceOptions);
+    search(query: string, location?: Location): Promise<Place[]>;
+    searchInBounds(query: string, bounds: LatLngBounds): Promise<Place[]>;
+    searchNearBy(query: string, center: LatLng, radius: number): Promise<Place[]>;
+    private searchImpl;
+}
+export declare class BaiduPlacesService extends PlacesService {
+    map: BaiduMap;
+    private searchRequestMap;
+    get inner(): BMap.LocalSearch;
+    currentSearch: BMap.LocalSearch | undefined;
+    constructor(map: BaiduMap, _options: PlacesServiceOptions);
+    search(query: string, location?: Location): Promise<Place[]>;
+    searchInBounds(query: string, bounds: LatLngBounds): Promise<Place[]>;
+    searchNearBy(query: string, center: LatLng, radius: number): Promise<Place[]>;
+    private newSearch;
+}

package/dist/src/map/map/extra/search-box.d.ts

@@ -0,0 +1,38 @@
+import type { EventCallback } from '../../../utils/utils';
+import { type RemoveEventListenerFunction } from '../../event-target';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { BaseMap } from '../map';
+import type { Place } from './places-service';
+export interface SearchBoxOptions {
+    input: HTMLInputElement;
+}
+export declare abstract class SearchBox {
+    map: BaseMap;
+    protected input: HTMLInputElement;
+    protected onData: EventCallback<Place[]> | undefined;
+    protected onError: ((e: any) => void) | undefined;
+    constructor(map: BaseMap, input: HTMLInputElement);
+    /**
+     * 设置搜索结果监听
+     *
+     * @mustCallSuper 子类必须调用一次`super.setSearchListener`, 用来保存{@link onData}和{@link onError}
+     * */
+    setSearchListener(onData: EventCallback<Place[]>, onError?: (e: any) => void): RemoveEventListenerFunction;
+    /** 用输入框的内容执行一次搜索 */
+    abstract search(): void;
+}
+export declare class GoogleSearchBox extends SearchBox {
+    private searchBox;
+    constructor(map: GoogleMap, options: SearchBoxOptions);
+    setSearchListener(onData: EventCallback<Place[]>, onError?: (e: any) => void): RemoveEventListenerFunction;
+    search(): void;
+}
+export declare class BaiduSearchBox extends SearchBox {
+    private autocomplete;
+    private placesService;
+    constructor(map: BaiduMap, options: SearchBoxOptions);
+    setSearchListener(onData: EventCallback<Place[]>, onError?: (e: any) => void): RemoveEventListenerFunction;
+    search(): void;
+    private searchImpl;
+}

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

@@ -0,0 +1,81 @@
+import { LatLng, LatLngBounds } from '../lat-lng';
+import { Point, type Padding } from '../types';
+import { CustomControl } from './controls/control';
+import { GoogleMapTypeControl } from './controls/map-type.control';
+import { GoogleScaleControl } from './controls/scale.control';
+import { GoogleStreetViewControl } from './controls/street-view.control';
+import { GoogleZoomControl } from './controls/zoom.control';
+import { Autocomplete, type AutocompleteOptions } from './extra/autocomplete';
+import { type Heatmap, type HeatmapOptions } from './extra/heatmap';
+import { type MapUrls, type MapUrlsOptions } from './extra/map-urls';
+import { GoogleMarkerClusterer, type MarkerClustererOptions } from './extra/marker-clusterer';
+import { type PlacesService, type PlacesServiceOptions } from './extra/places-service';
+import { SearchBox, type SearchBoxOptions } from './extra/search-box';
+import { BaseMap } from './map';
+import type { GestureHandlingOptions, MapOptions, MapStyle } from './map-options';
+import { BuildInMapTypeId, MapType, type Layer, type OverlayMapType } from './map-type';
+import { GoogleCircle } from './overlay/circle';
+import type { ElementOverlay } from './overlay/element-overlay';
+import { GoogleInfoBoxOverlay } from './overlay/info-box';
+import { GoogleInfoWindow } from './overlay/info-window';
+import { GoogleLabelOverlay } from './overlay/label';
+import { GoogleMarker } from './overlay/marker';
+import type { GoogleOverlay } from './overlay/overlay';
+import { GooglePolygon } from './overlay/polygon';
+import { GooglePolyline } from './overlay/polyline';
+import { GoogleRectangle } from './overlay/rectangle';
+export declare class GoogleMap extends BaseMap {
+    mapOptions: MapOptions;
+    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;
+    setDefaultCursor(cursor: string): 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;
+    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;
+    createRectangle: typeof GoogleRectangle.create;
+    createInfoWindow: typeof GoogleInfoWindow.create;
+    createInfoBox: typeof GoogleInfoBoxOverlay.create;
+    createMarker: typeof GoogleMarker.create;
+    createMapTypeControl: typeof GoogleMapTypeControl.create;
+    createZoomControl: typeof GoogleZoomControl.create;
+    createStreetViewControl: typeof GoogleStreetViewControl.create;
+    createScaleControl: typeof GoogleScaleControl.create;
+    createMarkerClusterer(options: MarkerClustererOptions): GoogleMarkerClusterer;
+    createHeatmap(options: HeatmapOptions): Heatmap;
+    createAutocomplete(options: AutocompleteOptions): Autocomplete;
+    createSearchBox(options: SearchBoxOptions): SearchBox;
+    createPlacesService(options: PlacesServiceOptions): PlacesService;
+    createMapUrls(options: MapUrlsOptions): MapUrls;
+}

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

@@ -0,0 +1,78 @@
+import { CoordType, LatLng, LatLngBounds } from '../lat-lng';
+import type { Padding, Point } from '../types';
+import type { CustomControl } from './controls/control';
+import type { MapTypeControl, MapTypeControlOptions } from './controls/map-type.control';
+import type { ScaleControlOptions } from './controls/scale.control';
+import type { StreetViewControl, StreetViewControlOptions } from './controls/street-view.control';
+import type { ZoomControl, ZoomControlOptions } 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 type { BuildInMapTypeId, Layer, 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 HereMap extends BaseMap {
+    mapOptions: MapOptions;
+    private map;
+    defaultLayers: H.service.DefaultLayers;
+    constructor(element: HTMLElement, mapOptions: MapOptions);
+    get innerMap(): H.Map;
+    get coordType(): CoordType;
+    getCenter(): LatLng;
+    setCenter(latlng: LatLng): void;
+    setGestureHandling(gestureHandling: GestureHandlingOptions): void;
+    fromContainerPointToLatLng(point: Point): LatLng;
+    fromLatLngToContainerPoint(latLng: LatLng): Point;
+    setDefaultCursor(cursor: string): void;
+    setDraggable(draggable: boolean): void;
+    setDoubleClickZoom(enable: boolean): 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 | undefined): void;
+    getBounds(): LatLngBounds;
+    addElementOverlay(overlay: ElementOverlay): void;
+    removeElementOverlay(overlay: ElementOverlay): void;
+    addOverlay(overlay: Overlay<unknown>): void;
+    removeOverlay(overlay: Overlay<unknown>): 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(options: ZoomControlOptions): ZoomControl;
+    createStreetViewControl(options: StreetViewControlOptions): StreetViewControl;
+    createScaleControl(options: ScaleControlOptions): ZoomControl;
+}

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

@@ -0,0 +1,60 @@
+import { LatLng } from '../lat-lng';
+import type { BuildInMapTypeId } from './map-type';
+export declare const InfoWindowModeValues: readonly ["single", "multi"];
+export type InfoWindowMode = typeof InfoWindowModeValues[number];
+/**
+ * 完全模仿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;
+    /**
+     * ## 不同行为
+     * - baidu: 只支持单窗口
+     * - google: 支持单窗口或多窗口, 默认多窗口
+     *
+     * 要显示多个弹窗, 推荐使用InfoBox替代
+     *
+     * {@macros info_window_vs_box}
+     */
+    infoWindowMode?: InfoWindowMode;
+    gestureHandling?: GestureHandlingOptions;
+    minZoom?: number;
+    maxZoom?: number;
+    mapStyle?: MapStyle;
+    buildInMapTypeId?: BuildInMapTypeId;
+}
+export declare namespace MapOptions {
+    function create(options?: Partial<MapOptions>): MapOptions;
+}
+/**
+ * ## 本地样式编辑器
+ * - google: https://mapstyle.withgoogle.com/
+ * - baidu: https://lbsyun.baidu.com/apiconsole/custommap
+ *
+ * ## 关于云端样式
+ * - google: mapId只有创建时有效, 之后再更改无效
+ * - baidu: styleId无效, 原因未知
+ */
+export interface MapStyle {
+    baidu: BMap.MapStyleV2;
+    google: {
+        styles?: google.maps.MapTypeStyle[];
+        mapId?: string;
+    };
+}

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

@@ -0,0 +1,110 @@
+import { FastFindValues } from '../../utils/values';
+import { CoordType } from '../lat-lng';
+import type { Point } from '../types';
+import type { GoogleLayer } from '../unions';
+/**
+ * 内置地图的id
+ */
+export declare enum BuildInMapTypeId {
+    normal = "normal",
+    satellite = "satellite",
+    hybrid = "hybrid"
+}
+/**
+ * 包括不兼容的地图类型
+ * - 'terrain': google中为地形图, baidu中为三维图
+ * */
+export type BuildInMapTypeIdIncludeIncompatible = BuildInMapTypeId | 'terrain';
+/**
+ * ## 注意
+ * `asXxx()`多次调用时应返回同一个对象
+ */
+export interface MapType {
+    /** MapType的唯一标识符, 命名时推荐包含`-`, 防止和BuildInMapTypeId冲突 */
+    id: string;
+    getBaiduCoordType(): CoordType;
+    asBaiduMapType(): BaiduMapType;
+    getGoogleCoordType(): CoordType;
+    asGoogleMapType(): GoogleMapType;
+}
+export interface Layer {
+    asBaiduLayer(): BMap.TileLayer;
+    asGoogleLayer(): GoogleLayer;
+}
+/**
+ * 同时实现`MapType`和`Layer`的对象被称作`OverlayMapType`
+ * - 往google中添加`OverlayMapType`, 将被看作`MapType`
+ * - 往baidu中添加`OverlayMapType`, 将被看作`Layer`
+ * @see TgMap.addOverlayMapType
+ * @see TgMap.removeOverlayMapType
+ * @see ImageMapType
+ */
+export type OverlayMapType = MapType & Layer;
+export declare class BuildInMapType implements MapType {
+    id: BuildInMapTypeIdIncludeIncompatible;
+    private baidu;
+    private google;
+    private googleCoordType;
+    constructor(id: BuildInMapTypeIdIncludeIncompatible, baidu: () => BMap.MapType, // 需要延迟初始化, 故写成方法
+    google: () => google.maps.MapTypeId, // 同上
+    googleCoordType: CoordType);
+    getId(): BuildInMapTypeIdIncludeIncompatible;
+    getBaiduCoordType(): CoordType;
+    asBaiduMapType(): BaiduMapType;
+    getGoogleCoordType(): CoordType;
+    /** 内置地图的id和google的id是不一样的 */
+    getGoogleMapTypeId(): google.maps.MapTypeId;
+    asGoogleMapType(): GoogleMapType;
+}
+export type GoogleMapType = google.maps.MapType & {
+    /** 需要在创建实例时设置该值 */
+    __google_map_type__?: MapType;
+};
+export type BaiduMapType = BMap.MapType & {
+    /** 需要在创建实例时设置该值 */
+    __baidu_map_type__?: MapType;
+};
+export interface ImageMapTypeOptions {
+    readonly id: string;
+    /**
+     * @param tileCoord 统一成google的瓦片坐标, 原点在左上角
+     * @returns 返回值可以为空
+     */
+    getTileUrl: (tileCoord: Point, zoom: number) => string | null;
+    maxZoom: number;
+    minZoom?: number;
+    name: string;
+    describe?: string;
+}
+/**
+ * ImageMapType应该同时实现MapType和Layer接口
+ */
+export declare class ImageMapType implements OverlayMapType {
+    coordType: CoordType;
+    options: ImageMapTypeOptions;
+    private baiduLayerCached;
+    private baiduMapTypeCached;
+    private googleCached;
+    constructor(coordType: CoordType, options: ImageMapTypeOptions);
+    get id(): string;
+    getBaiduCoordType(): CoordType;
+    asBaiduMapType(): BaiduMapType;
+    asBaiduLayer(): BMap.TileLayer;
+    getGoogleCoordType(): CoordType;
+    asGoogleMapType(): GoogleMapType;
+    asGoogleLayer(): GoogleLayer;
+}
+/** 交通流量图层 */
+export declare class TrafficLayer implements Layer {
+    private baiduCache;
+    private googleCache;
+    asBaiduLayer(): BMap.TileLayer;
+    asGoogleLayer(): GoogleLayer;
+}
+export declare namespace MapType {
+    const NORMAL: BuildInMapType;
+    const SATELLITE: BuildInMapType;
+    const HYBRID: BuildInMapType;
+    const TERRAIN: BuildInMapType;
+    const BUILD_IN_MAP_TYPES: FastFindValues<BuildInMapType>;
+}