tg-map-vue3 3.9.7 → 3.9.9

package/CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - ***BREAKING CHANGE***: 依赖[tg-commons](https://www.npmjs.com/package/tg-commons), 移除`typed`/`isDef`等和地图无关的导出
 - feat: [TgMarker]添加`label`属性, **它和已有的[TgLabel]不能同时设置**
+- feat: 添加球体和线段工具: [SphericalUtil], [PolyUtil]
 
 ## 3.8.x
 
@@ -87,3 +88,5 @@
 [LatLng]: src/map/lat-lng.ts#L26
 [BaiduShape]: src/map/map/overlay/shape.ts#L32
 [MapStyle]: src/map/map/map-options.ts#72
+[PolyUtil]: src/utils/maps-utils/poly-util.ts
+[SphericalUtil]: src/utils/maps-utils/spherical-util.ts

package/dist/src/components/TgMap.vue.d.ts

@@ -16,7 +16,7 @@ type TgMapEmits = {
     'update:map-type-id': string;
     'update:last-center': LatLng;
 };
-declare const _default: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /** type没做响应式, 但外部可以把type作为tg-map的key, 让type修改时完全重建tg-map */
     type: {
         type: PropType<StringEnumValue<typeof TgMapType>>;
@@ -90,15 +90,15 @@ declare const _default: import("vue").DefineComponent<{
     hideLogo: {
         type: PropType<boolean>;
     };
-    onLoad: import("vue").Prop<import(".").EventCallback<AbstractMap>>;
-    'onUpdate:center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:current-center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:last-center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:map-type': import("vue").Prop<import(".").EventCallback<MapType>>;
-    'onUpdate:map-type-id': import("vue").Prop<import(".").EventCallback<string>>;
-    'onUpdate:zoom': import("vue").Prop<import(".").EventCallback<number>>;
-    onError: import("vue").Prop<import(".").EventCallback<any>>;
-}, {
+    onLoad: import("vue").Prop<import("./index.ts").EventCallback<AbstractMap>>;
+    'onUpdate:center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:current-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:last-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:map-type': import("vue").Prop<import("./index.ts").EventCallback<MapType>>;
+    'onUpdate:map-type-id': import("vue").Prop<import("./index.ts").EventCallback<string>>;
+    'onUpdate:zoom': import("vue").Prop<import("./index.ts").EventCallback<number>>;
+    onError: import("vue").Prop<import("./index.ts").EventCallback<any>>;
+}>, {
     attrs: import("vue").ComputedRef<{
         binds: Record<string, unknown>;
         listeners: Record<string, unknown>;
@@ -184,41 +184,508 @@ declare const _default: import("vue").DefineComponent<{
     hideLogo: {
         type: PropType<boolean>;
     };
-    onLoad: import("vue").Prop<import(".").EventCallback<AbstractMap>>;
-    'onUpdate:center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:current-center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:last-center': import("vue").Prop<import(".").EventCallback<LatLng>>;
-    'onUpdate:map-type': import("vue").Prop<import(".").EventCallback<MapType>>;
-    'onUpdate:map-type-id': import("vue").Prop<import(".").EventCallback<string>>;
-    'onUpdate:zoom': import("vue").Prop<import(".").EventCallback<number>>;
-    onError: import("vue").Prop<import(".").EventCallback<any>>;
-}>> & {
-    onDrag?: ((event: import(".").Tg.Event) => any) | undefined;
-    onDragend?: ((event: import(".").Tg.Event) => any) | undefined;
-    onDragstart?: ((event: import(".").Tg.Event) => any) | undefined;
-    onLoad?: ((event: AbstractMap) => any) | undefined;
+    onLoad: import("vue").Prop<import("./index.ts").EventCallback<AbstractMap>>;
+    'onUpdate:center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:current-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:last-center': import("vue").Prop<import("./index.ts").EventCallback<LatLng>>;
+    'onUpdate:map-type': import("vue").Prop<import("./index.ts").EventCallback<MapType>>;
+    'onUpdate:map-type-id': import("vue").Prop<import("./index.ts").EventCallback<string>>;
+    'onUpdate:zoom': import("vue").Prop<import("./index.ts").EventCallback<number>>;
+    onError: import("vue").Prop<import("./index.ts").EventCallback<any>>;
+}>> & Readonly<{
+    onClick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onDblclick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onMousedown?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onMouseup?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onMouseout?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onMouseover?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    "onCenter-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    onRightclick?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onContextmenu?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onDragstart?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    onDrag?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    onDragend?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    onMousemove?: ((event: import("./index.ts").Tg.MouseEvent) => any) | undefined;
+    onTilesloaded?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    "onZoom-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
+    "onMap-type-changed"?: ((event: import("./index.ts").Tg.Event) => any) | undefined;
     onError?: ((event: any) => any) | undefined;
-    onClick?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onContextmenu?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onDblclick?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onMousedown?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onMousemove?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onMouseout?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onMouseover?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onMouseup?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
+    onLoad?: ((event: AbstractMap) => any) | undefined;
     "onUpdate:center"?: ((event: LatLng) => any) | undefined;
     "onUpdate:current-center"?: ((event: LatLng) => any) | undefined;
     "onUpdate:zoom"?: ((event: number) => any) | undefined;
     "onUpdate:map-type"?: ((event: MapType) => any) | undefined;
     "onUpdate:map-type-id"?: ((event: string) => any) | undefined;
     "onUpdate:last-center"?: ((event: LatLng) => any) | undefined;
-    "onCenter-changed"?: ((event: import(".").Tg.Event) => any) | undefined;
-    onRightclick?: ((event: import(".").Tg.MouseEvent) => any) | undefined;
-    onTilesloaded?: ((event: import(".").Tg.Event) => any) | undefined;
-    "onZoom-changed"?: ((event: import(".").Tg.Event) => any) | undefined;
-    "onMap-type-changed"?: ((event: import(".").Tg.Event) => any) | undefined;
-}, {
+}>, {
     type: StringEnumValue<typeof TgMapType>;
     centerSyncDelay: number;
-}, {}>;
+}, {}, {}, {}, string, () => {
+    $map: import("vue").ComputedRef<{
+        element: HTMLElement;
+        setGestureHandling: (gestureHandling: GestureHandlingOptions) => void;
+        readonly innerMap: {
+            controls: {
+                clear: () => void;
+                forEach: (callback: (a: HTMLElement, b: number) => void) => void;
+                getArray: () => HTMLElement[];
+                getAt: (i: number) => HTMLElement;
+                getLength: () => number;
+                insertAt: (i: number, elem: HTMLElement) => void;
+                pop: () => HTMLElement;
+                push: (elem: HTMLElement) => number;
+                removeAt: (i: number) => HTMLElement;
+                setAt: (i: number, elem: HTMLElement) => void;
+                addListener: (eventName: string, handler: Function) => google.maps.MapsEventListener;
+                bindTo: (key: string, target: google.maps.MVCObject, targetKey?: string | null, noNotify?: boolean) => void;
+                get: (key: string) => any;
+                notify: (key: string) => void;
+                set: (key: string, value: any) => void;
+                setValues: (values?: object | null) => void;
+                unbind: (key: string) => void;
+                unbindAll: () => void;
+            }[];
+            data: {
+                add: (feature?: google.maps.Data.Feature | null | google.maps.Data.FeatureOptions) => google.maps.Data.Feature;
+                addGeoJson: (geoJson: object, options?: google.maps.Data.GeoJsonOptions | null) => google.maps.Data.Feature[];
+                contains: (feature: google.maps.Data.Feature) => boolean;
+                forEach: (callback: (a: google.maps.Data.Feature) => void) => void;
+                getControlPosition: () => google.maps.ControlPosition;
+                getControls: () => string[] | null;
+                getDrawingMode: () => string | null;
+                getFeatureById: (id: number | string) => google.maps.Data.Feature | undefined;
+                getMap: () => google.maps.Map | null;
+                getStyle: () => (google.maps.Data.StylingFunction) | google.maps.Data.StyleOptions | null;
+                loadGeoJson: (url: string, options?: google.maps.Data.GeoJsonOptions | null, callback?: ((a: google.maps.Data.Feature[]) => void) | undefined) => void;
+                overrideStyle: (feature: google.maps.Data.Feature, style: google.maps.Data.StyleOptions) => void;
+                remove: (feature: google.maps.Data.Feature) => void;
+                revertStyle: (feature?: google.maps.Data.Feature | null) => void;
+                setControlPosition: (controlPosition: google.maps.ControlPosition) => void;
+                setControls: (controls: string[] | null) => void;
+                setDrawingMode: (drawingMode: string | null) => void;
+                setMap: (map: google.maps.Map | null) => void;
+                setStyle: (style: (google.maps.Data.StylingFunction) | google.maps.Data.StyleOptions | null) => void;
+                toGeoJson: (callback: (a: object) => void) => void;
+                addListener: (eventName: string, handler: Function) => google.maps.MapsEventListener;
+                bindTo: (key: string, target: google.maps.MVCObject, targetKey?: string | null, noNotify?: boolean) => void;
+                get: (key: string) => any;
+                notify: (key: string) => void;
+                set: (key: string, value: any) => void;
+                setValues: (values?: object | null) => void;
+                unbind: (key: string) => void;
+                unbindAll: () => void;
+            };
+            fitBounds: (bounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding) => void;
+            getBounds: () => google.maps.LatLngBounds | undefined;
+            getCenter: () => google.maps.LatLng | undefined;
+            getClickableIcons: () => boolean | undefined;
+            getDiv: () => HTMLElement;
+            getFeatureLayer: (featureType: google.maps.FeatureType) => google.maps.FeatureLayer;
+            getHeading: () => number | undefined;
+            getMapCapabilities: () => google.maps.MapCapabilities;
+            getMapTypeId: () => string | undefined;
+            getProjection: () => google.maps.Projection | undefined;
+            getRenderingType: () => google.maps.RenderingType;
+            getStreetView: () => google.maps.StreetViewPanorama;
+            getTilt: () => number | undefined;
+            getZoom: () => number | undefined;
+            mapTypes: {
+                set: (id: string, mapType: any) => void;
+                addListener: (eventName: string, handler: Function) => google.maps.MapsEventListener;
+                bindTo: (key: string, target: google.maps.MVCObject, targetKey?: string | null, noNotify?: boolean) => void;
+                get: (key: string) => any;
+                notify: (key: string) => void;
+                setValues: (values?: object | null) => void;
+                unbind: (key: string) => void;
+                unbindAll: () => void;
+            };
+            moveCamera: (cameraOptions: google.maps.CameraOptions) => void;
+            overlayMapTypes: {
+                clear: () => void;
+                forEach: (callback: (a: google.maps.MapType | null, b: number) => void) => void;
+                getArray: () => (google.maps.MapType | null)[];
+                getAt: (i: number) => google.maps.MapType | null;
+                getLength: () => number;
+                insertAt: (i: number, elem: google.maps.MapType | null) => void;
+                pop: () => google.maps.MapType | null;
+                push: (elem: google.maps.MapType | null) => number;
+                removeAt: (i: number) => google.maps.MapType | null;
+                setAt: (i: number, elem: google.maps.MapType | null) => void;
+                addListener: (eventName: string, handler: Function) => google.maps.MapsEventListener;
+                bindTo: (key: string, target: google.maps.MVCObject, targetKey?: string | null, noNotify?: boolean) => void;
+                get: (key: string) => any;
+                notify: (key: string) => void;
+                set: (key: string, value: any) => void;
+                setValues: (values?: object | null) => void;
+                unbind: (key: string) => void;
+                unbindAll: () => void;
+            };
+            panBy: (x: number, y: number) => void;
+            panTo: (latLng: google.maps.LatLng | google.maps.LatLngLiteral) => void;
+            panToBounds: (latLngBounds: google.maps.LatLngBounds | google.maps.LatLngBoundsLiteral, padding?: number | google.maps.Padding) => void;
+            setCenter: (latlng: google.maps.LatLng | google.maps.LatLngLiteral) => void;
+            setClickableIcons: (value: boolean) => void;
+            setHeading: (heading: number) => void;
+            setMapTypeId: (mapTypeId: string) => void;
+            setOptions: (options: google.maps.MapOptions | null) => void;
+            setStreetView: (panorama: google.maps.StreetViewPanorama | null) => void;
+            setTilt: (tilt: number) => void;
+            setZoom: (zoom: number) => void;
+            addListener: (eventName: string, handler: Function) => google.maps.MapsEventListener;
+            bindTo: (key: string, target: google.maps.MVCObject, targetKey?: string | null, noNotify?: boolean) => void;
+            get: (key: string) => any;
+            notify: (key: string) => void;
+            set: (key: string, value: any) => void;
+            setValues: (values?: object | null) => void;
+            unbind: (key: string) => void;
+            unbindAll: () => void;
+        } | {
+            addEventListener: {
+                (event: string, handler: BMap.Callback): void;
+                (event: string, handler: BMap.Callback): void;
+            };
+            removeEventListener: {
+                (event: string, handler: BMap.Callback): void;
+                (event: string, handler: BMap.Callback): void;
+            };
+            enableDragging: () => void;
+            disableDragging: () => void;
+            enableScrollWheelZoom: () => void;
+            disableScrollWheelZoom: () => void;
+            enableDoubleClickZoom: () => void;
+            disableDoubleClickZoom: () => void;
+            enableKeyboard: () => void;
+            disableKeyboard: () => void;
+            enableInertialDragging: () => void;
+            disableInertialDragging: () => void;
+            enableContinuousZoom: () => void;
+            disableContinuousZoom: () => void;
+            enablePinchToZoom: () => void;
+            disablePinchToZoom: () => void;
+            enableAutoResize: () => void;
+            disableAutoResize: () => void;
+            setDefaultCursor: (cursor: string) => void;
+            getDefaultCursor: () => string;
+            setDraggingCursor: (cursor: string) => void;
+            getDraggingCursor: () => string;
+            setMinZoom: (zoom: number) => void;
+            setMaxZoom: (zoom: number) => void;
+            setMapStyle: (mapStyle: BMap.MapStyle) => void;
+            setMapStyleV2: (style: BMap.MapStyleV2) => void;
+            setPanorama: (pano: BMap.Panorama) => void;
+            disable3DBuilding: () => void;
+            getBounds: () => BMap.Bounds;
+            getCenter: () => BMap.Point;
+            getDistance: (start: BMap.Point, end: BMap.Point) => number;
+            getMapType: () => BMap.MapType;
+            getSize: () => BMap.Size;
+            getViewport: (view: BMap.Point[], viewportOptions?: BMap.ViewportOptions) => BMap.Viewport;
+            getZoom: () => number;
+            getPanorama: () => BMap.Panorama;
+            centerAndZoom: {
+                (center: BMap.Point, zoom: number): void;
+                (city: string): void;
+            };
+            panTo: (center: BMap.Point, opts?: BMap.PanOptions) => void;
+            panBy: (x: number, y: number, opts?: BMap.PanOptions) => void;
+            reset: () => void;
+            setCenter: (center: BMap.Point | string) => void;
+            setCurrentCity: (city: string) => void;
+            setMapType: (mapType: BMap.MapType) => void;
+            setViewport: (view: BMap.Point[], viewportOptions?: BMap.ViewportOptions) => void;
+            setZoom: (zoom: number) => void;
+            highResolutionEnabled: () => boolean;
+            zoomIn: () => void;
+            zoomOut: () => void;
+            addHotspot: (hotspot: BMap.Hotspot) => void;
+            removeHotspot: (hotspot: BMap.Hotspot) => void;
+            clearHotspots: () => void;
+            addControl: (control: BMap.Control) => void;
+            removeControl: (control: BMap.Control) => void;
+            getContainer: () => HTMLElement;
+            addContextMenu: (menu: BMap.ContextMenu) => void;
+            removeContextMenu: (menu: BMap.ContextMenu) => void;
+            addOverlay: (overlay: BMap.Overlay) => void;
+            removeOverlay: (overlay: BMap.Overlay) => void;
+            clearOverlays: () => void;
+            openInfoWindow: (infoWnd: BMap.InfoWindow, point: BMap.Point) => void;
+            closeInfoWindow: () => void;
+            pointToOverlayPixel: (point: BMap.Point) => BMap.Pixel;
+            overlayPixelToPoint: (pixel: BMap.Pixel) => BMap.Point;
+            getInfoWindow: () => BMap.InfoWindow;
+            getOverlays: () => BMap.Overlay[];
+            getPanes: () => BMap.MapPanes;
+            addTileLayer: (tileLayer: BMap.TileLayer) => void;
+            removeTileLayer: (tilelayer: BMap.TileLayer) => void;
+            getTileLayer: (mapType: string) => BMap.TileLayer;
+            pixelToPoint: (pixel: BMap.Pixel) => BMap.Point;
+            pointToPixel: (point: BMap.Point) => BMap.Pixel;
+            onclick: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+                overlay: BMap.Overlay;
+            }) => void;
+            ondblclick: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            onrightclick: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+                overlay: BMap.Overlay;
+            }) => void;
+            onrightdblclick: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+                overlay: BMap.Overlay;
+            }) => void;
+            onmaptypechange: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onmousemove: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+                overlay: BMap.Overlay;
+            }) => void;
+            onmouseover: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onmouseout: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onmovestart: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onmoving: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onmoveend: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onzoomstart: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onzoomend: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onaddoverlay: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onaddcontrol: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onremovecontrol: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onremoveoverlay: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onclearoverlays: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            ondragstart: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            ondragging: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            ondragend: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            onaddtilelayer: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onremovetilelayer: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            onload: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+                zoom: number;
+            }) => void;
+            onresize: (event: {
+                type: string;
+                target: any;
+                size: BMap.Size;
+            }) => void;
+            onhotspotclick: (event: {
+                type: string;
+                target: any;
+                spots: BMap.HotspotOptions;
+            }) => void;
+            onhotspotover: (event: {
+                type: string;
+                target: any;
+                spots: BMap.HotspotOptions;
+            }) => void;
+            onhotspotout: (event: {
+                type: string;
+                target: any;
+                spots: BMap.HotspotOptions;
+            }) => void;
+            ontilesloaded: (event: {
+                type: string;
+                target: any;
+            }) => void;
+            ontouchstart: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            ontouchmove: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            ontouchend: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+            onlongpress: (event: {
+                type: string;
+                target: any;
+                point: BMap.Point;
+                pixel: BMap.Pixel;
+            }) => void;
+        } | {
+            getElement: () => Element;
+            setCenter: (center: H.geo.IPoint, opt_animate?: boolean) => H.Map;
+            getCenter: () => H.geo.Point;
+            setZoom: (zoom: number, opt_animate?: boolean) => H.Map;
+            getZoom: () => number;
+            zoomAt: (zoom: number, x: number, y: number) => void;
+            setViewBounds: (boundingRect: H.geo.Rect, opt_animate?: boolean) => H.Map;
+            getViewBounds: () => H.geo.Rect;
+            getCameraDataForBounds: (rect: H.geo.Rect) => H.map.ViewModel.CameraData;
+            getViewPort: () => H.map.ViewPort;
+            getViewModel: () => H.map.ViewModel;
+            getLayers: () => H.map.DataModel;
+            getImprint: () => H.map.Imprint;
+            capture: (callback?: ((canvas: HTMLCanvasElement) => void) | undefined, opt_capturables?: H.util.ICapturable[], opt_x1?: number, opt_y1?: number, opt_x2?: number, opt_y2?: number) => void;
+            setEngineType: (type: H.Map.EngineType) => H.Map;
+            storeContent: (opt_onprogress?: ((req: H.util.Request) => void) | undefined, opt_bounds?: H.geo.Rect, opt_min?: number, opt_max?: number, opt_layer?: H.map.layer.BaseTileLayer) => H.util.Request;
+            clearContent: (opt_onprogress?: ((req: H.util.Request) => void) | undefined) => H.util.Request;
+            addLayer: (layer: H.map.layer.Layer, opt_idx?: number) => H.Map;
+            removeLayer: (layer: H.map.layer.Layer) => H.Map;
+            setBaseLayer: (layer: H.map.layer.Layer) => H.Map;
+            getBaseLayer: () => H.map.layer.Layer;
+            geoToScreen: (geoPoint: H.geo.IPoint) => H.math.Point;
+            screenToGeo: (x: number, y: number) => H.geo.Point;
+            screenToCameraData: (x: number, y: number) => H.map.ViewModel.CameraData;
+            addObject: (mapObject: H.map.Object) => H.map.Object;
+            removeObject: (mapObject: H.map.Object) => H.map.Object;
+            getObjects: () => H.map.Object[];
+            addObjects: (mapObjects: H.map.Object[]) => H.Map;
+            removeObjects: (mapObjects: (H.map.Object[] | H.map.Group)) => H.Map;
+            getObjectAt: (x: number, y: number) => H.map.Object;
+            getObjectsAt: (x: number, y: number) => H.map.Object[];
+            dispatchEvent: (evt: (H.util.Event | string)) => void;
+            dispose: () => void;
+            addOnDisposeCallback: (callback: () => void, opt_scope?: {}) => void;
+            getEngine: () => H.map.render.p2d.RenderEngine;
+            addEventListener: (type: string, handler: EventListenerOrEventListenerObject, opt_capture?: boolean, opt_scope?: any) => void;
+            removeEventListener: (type: string, handler: EventListenerOrEventListenerObject, opt_capture?: boolean, opt_scope?: any) => void;
+        };
+        readonly coordType: import("./index.ts").CoordType;
+        addEventListener: {
+            <K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
+            (type: string, listener: import("./index.ts").Tg.EventListener): void;
+        };
+        removeEventListener: {
+            <K extends keyof AbstractMapEventMap>(type: K, listener: (event: AbstractMapEventMap[K]) => void): void;
+            (type: string, listener: import("./index.ts").Tg.EventListener): void;
+        };
+        getLatestInfoWindow: () => import("./index.ts").InfoWindowOverlay | undefined;
+        setLatestInfoWindowInternal: (infoWindow: import("./index.ts").InfoWindowOverlay) => void;
+        fromContainerPointToLatLng: (point: import("./index.ts").Point) => LatLng;
+        fromLatLngToContainerPoint: (latLng: LatLng) => import("./index.ts").Point;
+        setDefaultCursor: (cursor: import("csstype").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: import("./index.ts").Layer) => void;
+        removeLayer: (layer: import("./index.ts").Layer) => void;
+        addOverlayMapType: (mapType: import("./index.ts").OverlayMapType) => void;
+        removeOverlayMapType: (mapType: import("./index.ts").OverlayMapType) => void;
+        panTo: (position: LatLng) => void;
+        panBy: (x: number, y: number) => void;
+        fitBounds: (bounds: import("./index.ts").LatLngBounds, padding?: import("./index.ts").Padding) => void;
+        getBounds: () => import("./index.ts").LatLngBounds;
+        addElementOverlay: (overlay: import("./index.ts").ElementOverlay) => void;
+        removeElementOverlay: (overlay: import("./index.ts").ElementOverlay) => void;
+        addOverlay: (overlay: import("./index.ts").Overlay) => void;
+        removeOverlay: (overlay: import("./index.ts").Overlay) => void;
+        createMarker: (options: import("./index.ts").MarkerOptions) => import("./index.ts").MarkerOverlay;
+        createMarkerClusterer: (options: import("./index.ts").MarkerClustererOptions) => import("./index.ts").MarkerClusterer;
+        createHeatmap: (options: import("./index.ts").HeatmapOptions) => import("./index.ts").Heatmap;
+        createAutocomplete: (options: import("./index.ts").AutocompleteOptions) => import("./index.ts").Autocomplete;
+        createSearchBox: (options: import("./index.ts").SearchBoxOptions) => import("./index.ts").SearchBox;
+        createPlacesService: (options: import("./index.ts").PlacesServiceOptions) => import("./index.ts").PlacesService;
+        createMapUrls: (options: import("./index.ts").MapUrlsOptions) => import("./index.ts").MapUrls;
+        createInfoWindow: (options: import("./index.ts").InfoWindowOptions) => import("./index.ts").InfoWindowOverlay;
+        createInfoBox: (options: import("./index.ts").InfoBoxOptions) => import("./index.ts").InfoBoxOverlay;
+        createPolyline: (options: import("./index.ts").PolylineOptions) => import("./index.ts").PolylineOverlay;
+        createPolygon: (options: import("./index.ts").PolygonOptions) => import("./index.ts").PolygonOverlay;
+        createRectangle: (options: import("./index.ts").RectangleOptions) => import("./index.ts").RectangleOverlay;
+        createCircle: (options: import("./index.ts").CircleOptions) => import("./index.ts").CircleOverlay;
+        createLabel: (options: import("../map/map/overlay/label.ts").LabelOptions) => import("../map/map/overlay/label.ts").LabelOverlay;
+        addCustomControl: (control: import("./index.ts").CustomControl) => void;
+        removeCustomControl: (control: import("./index.ts").CustomControl) => void;
+        createMapTypeControl: (options: import("./index.ts").MapTypeControlOptions) => import("./index.ts").MapTypeControl;
+        createZoomControl: (options: import("./index.ts").ZoomControlOptions) => import("./index.ts").ZoomControl;
+        createStreetViewControl: (options: import("./index.ts").StreetViewControlOptions) => import("./index.ts").StreetViewControl;
+        createScaleControl: (options: import("./index.ts").ScaleControlOptions) => import("./index.ts").ZoomControl;
+        addControl: (control: import("./index.ts").AbstractControl) => void;
+        removeControl: (control: import("./index.ts").AbstractControl) => void;
+        getZoom: () => number;
+        setZoom: (zoom: number) => void;
+    } | undefined>;
+}, true, {}, any>;
 export default _default;

package/dist/src/components/TgMapWidget.vue.d.ts

@@ -1,6 +1,6 @@
 import { dimen } from '../utils/formatter';
 /** TgMap上的Widget, 只是对绝对布局进行简单的封装 */
-declare const _default: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     left: {
         type: (StringConstructor | NumberConstructor)[];
         default: null;
@@ -17,7 +17,7 @@ declare const _default: import("vue").DefineComponent<{
         type: (StringConstructor | NumberConstructor)[];
         default: null;
     };
-}, unknown, unknown, {
+}>, {}, {}, {
     topValue(): string | number;
 }, {
     dimen: typeof dimen;
@@ -38,10 +38,10 @@ declare const _default: import("vue").DefineComponent<{
         type: (StringConstructor | NumberConstructor)[];
         default: null;
     };
-}>>, {
+}>> & Readonly<{}>, {
     left: string | number;
     top: string | number;
     right: string | number;
     bottom: string | number;
-}, {}>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/src/components/controls/TgCustomControl.vue.d.ts

@@ -1,20 +1,20 @@
 import { ControlPosition, CustomControl } from '../../map/map/controls/control';
 import { type StringEnumValue } from '../../utils/mapped-types';
-declare const _default: import("vue").DefineComponent<{
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     position: {
         type: import("vue").PropType<StringEnumValue<typeof ControlPosition>>;
         default: ControlPosition;
     };
-}, {
+}>, {
     control: CustomControl;
-}, unknown, {}, {}, import("vue").DefineComponent<{}, {}, {}, {}, {
+}, {}, {}, {}, import("vue").DefineComponent<{}, {}, {}, {}, {
     recreate(): void;
-}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     position: {
         type: import("vue").PropType<StringEnumValue<typeof ControlPosition>>;
         default: ControlPosition;
     };
-}>>, {
+}>> & Readonly<{}>, {
     position: StringEnumValue<typeof ControlPosition>;
-}, {}>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;