tg-map-core 0.0.1

package/dist/src/index.d.ts

@@ -0,0 +1,50 @@
+/// <reference path="../../src/map/dts/index.d.ts" preserve="true" />
+export { bindEvents, type Tg } from './map/event';
+export { AbstractEventTargetDelegate, TalksEventTargetDelegate } from './map/event-target';
+export * from './map/lat-lng';
+export { getTgMapConfig, setTgMapConfig, type PartialTgMapConfig, type TgMapConfig } from './map/map-config';
+export * from './map/map-factory';
+export { loadCachedMap } from './map/map-loader';
+export * from './map/map/baidu-map';
+export * from './map/map/controls/control';
+export * from './map/map/controls/map-type.control';
+export * from './map/map/controls/scale.control';
+export * from './map/map/controls/street-view.control';
+export * from './map/map/controls/zoom.control';
+export * from './map/map/extra/autocomplete';
+export * from './map/map/extra/heatmap';
+export * from './map/map/extra/map-urls';
+export * from './map/map/extra/marker-clusterer';
+export * from './map/map/extra/places-service';
+export * from './map/map/extra/search-box';
+export * from './map/map/google-map';
+export * from './map/map/here-map';
+export * from './map/map/map';
+export * from './map/map/map-options';
+export * from './map/map/map-type';
+export * from './map/map/overlay/circle';
+export * from './map/map/overlay/element-overlay';
+export * from './map/map/overlay/icon';
+export * from './map/map/overlay/info-box';
+export * from './map/map/overlay/info-window';
+export * from './map/map/overlay/label';
+export * from './map/map/overlay/marker';
+export * from './map/map/overlay/marker-label';
+export * from './map/map/overlay/overlay';
+export * from './map/map/overlay/polygon';
+export * from './map/map/overlay/polyline';
+export * from './map/map/overlay/rectangle';
+export * from './map/map/talks-map';
+export * from './map/talks/talks-layers';
+export * from './map/talks/talks-utils';
+export * from './map/types';
+export * from './utils/arrays';
+export * from './utils/formatter';
+export * from './utils/map-utils';
+export * from './utils/mapped-types';
+export * from './utils/maps-utils';
+export { Objects } from './utils/objects';
+export * from './utils/spherical-utils';
+export * from './utils/strings';
+export * from './utils/utils';
+export * from './utils/values';

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

@@ -0,0 +1,80 @@
+import * as maptalks from 'maptalks';
+import { type Tg } from './event';
+import { type CoordTypeSupplier } from './lat-lng';
+import type { AbstractMapEventMap, BaseMap } from './map/map';
+import type { UnionBaiduEventTarget, UnionGoogleEventTarget } from './unions';
+/**
+ * 移除事件监听的函数
+ *
+ * 实现{@link EventTarget}有点复杂, 对于简单的情况, 实现一个设置监听的函数+返回{@link RemoveEventListenerFunction}就够了
+ * @see addBaiduEventListener
+ * @see addGoogleEventListener
+ * */
+export interface RemoveEventListenerFunction {
+    (): void;
+}
+export declare function addGoogleEventListener(target: UnionGoogleEventTarget, type: string, listener: (...args: any[]) => void): RemoveEventListenerFunction;
+export declare function addBaiduEventListener(target: UnionBaiduEventTarget, type: string, listener: (...args: any[]) => void): RemoveEventListenerFunction;
+export declare function addHtmlEventListener<K extends keyof EventMap, EventMap = HTMLElementEventMap, T extends EventTarget = HTMLElement>(target: T, type: K, listener: (this: T, ev: EventMap[K]) => any, options?: AddEventListenerOptions | boolean): RemoveEventListenerFunction;
+export declare function addTgEventListener<K extends keyof EventMap, EventMap = AbstractMapEventMap, T extends Tg.EventTarget = BaseMap>(target: T, type: K, listener: (this: T, ev: EventMap[K]) => any): RemoveEventListenerFunction;
+export interface EventTargetDelegate extends Tg.EventTarget {
+    setTarget(target: Tg.EventTarget): this;
+}
+/**
+ * ## Delegate(代理) VS Mixin(混合)
+ * Delegate相对于Mixin的优点是调用路径更明确, 缺点是js/ts原生不支持, 需要写样板代码
+ */
+export declare abstract class AbstractEventTargetDelegate<T = any> implements EventTargetDelegate {
+    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 EventHubEventTargetDelegate<EventTypes extends string = string> implements EventTargetDelegate {
+    private delegate;
+    private options;
+    private eventHub;
+    constructor(delegate: EventTargetDelegate, options: {
+        /** 由{@link eventHub}手动处理的事件 */
+        types: EventTypes[];
+        /** 用户开始监听{@link type} */
+        onListen: (type: EventTypes) => void;
+        /** 用户结束监听{@link type} */
+        onCancel: (type: EventTypes) => void;
+    });
+    notify(event: Tg.Event): void;
+    hasListener(type: EventTypes): boolean;
+    setTarget(target: Tg.EventTarget): this;
+    addEventListener(type: string, listener: Tg.EventListener): void;
+    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 TalksEventTargetDelegate<T extends maptalks.Eventable = maptalks.Eventable> extends AbstractEventTargetDelegate<T> {
+    static EVENT_TYPE_MAP: {
+        'center-changed': string;
+        'zoom-changed': string;
+    } & Record<string, string | undefined>;
+    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,50 @@
+import type { LatLng } from './lat-lng';
+/**
+ * ## 事件机制对比
+ * - 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;
+    }
+    /** 带事件的类型信息, 可以监听任何事件 */
+    type EventTargetTyped2<THIS extends EventTarget, MAP extends {
+        [k: string]: Event;
+    }> = EventTargetTyped<THIS, MAP> & EventTarget;
+}
+export declare function bindEvents(listeners: Record<string, unknown>, 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,160 @@
+import { type LngLatTuple } from 'coordtransform';
+import * as maptalks from 'maptalks';
+import { type StringEnumValue } from '../utils/mapped-types';
+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 interface WeightedLatLng {
+    position: LatLng;
+    weight: number;
+}
+export declare class LatLng {
+    /**
+     * 纬度, 分南北, [-90, 90], 0点为赤道
+     */
+    readonly lat: number;
+    /**
+     * 经度, 分东西, [-180, 180], 0点为本初子午线
+     */
+    readonly lng: number;
+    /** 坐标系 */
+    readonly coord: CoordType;
+    static ZERO: LatLng;
+    /**
+     * {@template latlng_normalize}
+     *
+     * 对经纬度进行标准化, 参考google的实现
+     *
+     * ## 行为不一致
+     * - google: google.maps.LatLng的构造器会对经纬度进行标准化, 所有点都能正常显示
+     * - baidu: BMap.Point的构造器不会对经纬度进行标准化, 超出范围的点显示到(0, 0)位置
+     *
+     * {@endtemplate}
+     */
+    static _normalize(lng: number, lat: number): number[];
+    /** @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 fromTalks(coordinate: maptalks.Coordinate, 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(
+    /**
+     * 纬度, 分南北, [-90, 90], 0点为赤道
+     */
+    lat: number, 
+    /**
+     * 经度, 分东西, [-180, 180], 0点为本初子午线
+     */
+    lng: number, 
+    /** 坐标系 */
+    coord: CoordType);
+    /** 转换坐标到指定坐标系 */
+    to(coordType: StringEnumValue<typeof CoordType>): LatLng;
+    /**
+     * TODO: normalize要不要默认设为true, 和google的行为保持一致?
+     * 转换成baidu的经纬度
+     * @param normalize 转换时是否进行标准化, 默认false
+     * @see _normalize {@macro latlng_normalize}
+     */
+    toBaidu(coord: CoordType, normalize?: boolean): BMap.Point;
+    /**
+     * 转换成google的经纬度, 内部会自动进行标准化
+     * @see _normalize {@macro latlng_normalize}
+     */
+    toGoogle(coord: CoordType): google.maps.LatLng;
+    toHere(coord: CoordType): H.geo.Point;
+    toTalks(coord: CoordType): maptalks.Coordinate;
+    /**
+     * 该方法之所以设计的这么不友好, 是为了防止不必要的开销(大概有点影响😅)
+     *
+     * 私有方法, 外部需要转换坐标系, 请使用{@link to}/toBaidu/Google/Here, 之所以不添加private关键字, 是因为设成私有后, 有的地方会报类型错误...
+     *
+     * @returns `[lng, lat]` 注意不要取错顺序
+     * @throws 若当前coord和targetCoord相同, 会抛异常, 故请在外部判断
+     */
+    _convert(targetCoord: CoordType): LngLatTuple;
+    /**
+     * 标准化, 返回合法的坐标点
+     * @see _normalize {@macro latlng_normalize}
+     */
+    normalize(): LatLng;
+    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;
+    /**
+     * 从数组创建bounds
+     *
+     * 只有{@link positions}为空时, 才会返回`undefined`, 可以借助{@link Arrays.isNotEmpty}协助进行类型推断
+     */
+    static fromArray(positions: readonly []): undefined;
+    /** @see Arrays.isNotEmpty */
+    static fromArray(positions: readonly [LatLng, ...LatLng[]]): LatLngBounds;
+    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;
+    /**
+     * 矩形的四个点数组
+     * 顺时针: sw(西南) -> nw(西北) -> ne(东北) -> se(东南)
+     * */
+    toRectArray(): LatLng[];
+    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;
+    }
+}
+/** 在导航/搜索等接口中使用的 位置 */
+export type Location = string | LatLng;
+export declare namespace Location {
+    function toString(place: Location | undefined, coordType: CoordType): string | undefined;
+    function getCoordType(place: Location | undefined): CoordType | undefined;
+}

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

@@ -0,0 +1,82 @@
+import { LatLng, LatLngBounds } from '../lat-lng';
+import type { Padding, Point } from '../types';
+import { CustomControl } from './controls/control';
+import { BaiduMapTypeControl } from './controls/map-type.control';
+import { BaiduScaleControl } from './controls/scale.control';
+import { BaiduStreetViewControl } from './controls/street-view.control';
+import { BaiduZoomControl } from './controls/zoom.control';
+import { type Autocomplete, type AutocompleteOptions } from './extra/autocomplete';
+import { type Heatmap, type HeatmapOptions } from './extra/heatmap';
+import { type MapUrls, type MapUrlsOptions } from './extra/map-urls';
+import { BaiduMarkerClusterer, type MarkerClustererOptions } from './extra/marker-clusterer';
+import { type PlacesService, type PlacesServiceOptions } from './extra/places-service';
+import { type SearchBox, type SearchBoxOptions } from './extra/search-box';
+import { BaseMap, type AbstractMapEventMap } from './map';
+import { GestureHandlingOptions, MapOptions, type MapStyle } from './map-options';
+import { BuildInMapTypeId, MapType, type Layer } from './map-type';
+import { BaiduCircle } from './overlay/circle';
+import type { ElementOverlay } from './overlay/element-overlay';
+import { BaiduInfoBoxOverlay } from './overlay/info-box';
+import { BaiduInfoWindow } from './overlay/info-window';
+import { BaiduLabelOverlay } from './overlay/label';
+import { BaiduMarker } from './overlay/marker';
+import type { BaiduOverlay } from './overlay/overlay';
+import { BaiduPolygon } from './overlay/polygon';
+import { BaiduPolyline } from './overlay/polyline';
+import { BaiduRectangle } from './overlay/rectangle';
+export declare class BaiduMap extends BaseMap {
+    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;
+    setDefaultCursor(cursor: string): void;
+    setDraggable(draggable: boolean): void;
+    setDoubleClickZoom(enable: boolean): void;
+    getCenter(): LatLng;
+    setCenter(latlng: LatLng): void;
+    getZoom(): number;
+    setZoom(zoom: number): 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;
+    createRectangle: typeof BaiduRectangle.create;
+    createInfoWindow: typeof BaiduInfoWindow.create;
+    createInfoBox: typeof BaiduInfoBoxOverlay.create;
+    createMarker: typeof BaiduMarker.create;
+    createMapTypeControl: typeof BaiduMapTypeControl.create;
+    createZoomControl: typeof BaiduZoomControl.create;
+    createStreetViewControl: typeof BaiduStreetViewControl.create;
+    createScaleControl: typeof BaiduScaleControl.create;
+    createMarkerClusterer(options: MarkerClustererOptions): BaiduMarkerClusterer;
+    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/controls/control.d.ts

@@ -0,0 +1,112 @@
+import { KeyValue } from '../../../utils/values';
+import type { UnionControl } from '../../unions';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-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;
+}
+/** Control的空实现 */
+export declare class EmptyControl extends AbstractControl {
+    private visible;
+    private position;
+    constructor(visible: boolean, position: ControlPosition);
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    getPosition(): ControlPosition;
+    setPosition(position: ControlPosition): void;
+    addTo(_map: AbstractMap): void;
+    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,29 @@
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import { MapType } from '../map-type';
+import { AbstractControl, BaiduControl, ControlPosition, GoogleControl } from './control';
+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,19 @@
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { TalksMap } from '../talks-map';
+import { AbstractControl, BaiduControl, ControlPosition, EmptyControl, GoogleControl } from './control';
+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);
+}
+export declare class TalksScaleControl extends EmptyControl implements ScaleControl {
+    static create(this: TalksMap, options: ScaleControlOptions): TalksScaleControl;
+}

package/dist/src/map/map/controls/street-view.control.d.ts

@@ -0,0 +1,25 @@
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { TalksMap } from '../talks-map';
+import { AbstractControl, ControlPosition, EmptyControl, GoogleControl } from './control';
+/**
+ * ## 不同实现
+ * - google: 支持街景控件
+ * - baidu: 不支持, {@link BaiduStreetViewControl}是一个空实现
+ * - talks: 不支持
+ */
+export interface StreetViewControl extends AbstractControl {
+}
+export interface StreetViewControlOptions {
+    position?: ControlPosition;
+}
+export declare class BaiduStreetViewControl extends EmptyControl implements StreetViewControl {
+    static create(this: BaiduMap, options: StreetViewControlOptions): BaiduStreetViewControl;
+}
+export declare class GoogleStreetViewControl extends GoogleControl implements StreetViewControl {
+    static create(this: GoogleMap, options: StreetViewControlOptions): GoogleStreetViewControl;
+    constructor(position?: ControlPosition);
+}
+export declare class TalksStreetViewControl extends EmptyControl implements StreetViewControl {
+    static create(this: TalksMap, options: StreetViewControlOptions): TalksStreetViewControl;
+}

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

@@ -0,0 +1,19 @@
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { TalksMap } from '../talks-map';
+import { AbstractControl, BaiduControl, ControlPosition, EmptyControl, GoogleControl } from './control';
+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);
+}
+export declare class TalksZoomControl extends EmptyControl implements ZoomControl {
+    static create(this: TalksMap, options: ZoomControlOptions): TalksZoomControl;
+}