tg-map-vue3 3.3.8 → 3.4.0

package/dist/src/map/map/overlay/circle.d.ts

@@ -1,18 +1,21 @@
 /// <reference types="baidumap-web-sdk" />
 /// <reference types="google.maps" />
 import type { Tg } from '../../event';
+import { EventHubEventTargetDelegate } from '../../event-target';
 import { LatLng } from '../../lat-lng';
 import type { BaiduMap } from '../baidu-map';
 import type { GoogleMap } from '../google-map';
 import type { Overlay } from './overlay';
 import { BaiduShape, GoogleShape, type Shape, type ShapeOptions } from './shape';
-type CircleEventMap = {
+export type CircleEventMap = {
     click: Tg.Event;
     dblclick: Tg.Event;
     mousedown: Tg.MouseEvent;
     mouseup: Tg.MouseEvent;
     mouseout: Tg.MouseEvent;
     mouseover: Tg.MouseEvent;
+    'radius-changed': Tg.Event;
+    'center-changed': Tg.Event;
 };
 export interface CircleOptions extends ShapeOptions {
     center: LatLng;
@@ -27,6 +30,15 @@ export interface Circle extends Tg.EventTargetTyped<Circle, CircleEventMap>, Sha
 export type CircleOverlay = Circle & Overlay;
 export declare class BaiduCircle extends BaiduShape<BMap.Circle> implements Circle {
     static create(this: BaiduMap, options: CircleOptions): BaiduCircle;
+    private prevCenter;
+    private prevRadius;
+    private isDoingSetCenter;
+    private isDoingSetRadius;
+    private eventHubDelegate;
+    protected createDelegate(): EventHubEventTargetDelegate<"radius-changed" | "center-changed">;
+    private onRadiusChanged;
+    private onCenterChanged;
+    private resetEditableTimeoutId;
     setCenter(center: LatLng): void;
     getCenter(): LatLng;
     setRadius(radius: number): void;
@@ -39,4 +51,3 @@ export declare class GoogleCircle extends GoogleShape<google.maps.Circle> implem
     setRadius(radius: number): void;
     getRadius(): number;
 }
-export {};

package/dist/src/map/map/overlay/info-window.d.ts

@@ -47,7 +47,7 @@ export interface InfoWindowOptions {
  *
  * 结论: 在baidu以外的地图上模拟open/close事件, 保证行为一致
  */
-type InfoWindowEventMap = {
+export type InfoWindowEventMap = {
     closeclick: Tg.Event;
     /**
      * ## 不同实现
@@ -109,4 +109,3 @@ export declare class GoogleInfoWindow extends InfoWindow {
     getPosition(): LatLng;
     setPosition(position: LatLng): void;
 }
-export {};

package/dist/src/map/map/overlay/marker.d.ts

@@ -33,15 +33,15 @@ export interface MarkerOptions extends OverlayOptions {
     zIndex?: number;
 }
 /** 仅仅起到类型声明的作用... */
-type MarkerEventMap = {
-    click: Tg.Event;
+export type MarkerEventMap = {
+    click: Tg.MouseEvent;
     dblclick: Tg.MouseEvent;
-    rightclick: Tg.Event;
+    rightclick: Tg.MouseEvent;
     mousedown: Tg.MouseEvent;
     mouseup: Tg.MouseEvent;
     mouseout: Tg.MouseEvent;
     mouseover: Tg.MouseEvent;
-    dragstart: Tg.Event;
+    dragstart: Tg.MouseEvent;
     drag: Tg.MouseEvent;
     dragend: Tg.MouseEvent;
 };
@@ -122,4 +122,3 @@ export declare class GoogleMarker extends GoogleOverlay<google.maps.Marker> impl
     getZIndex(): number | undefined;
     setLabel(label: GoogleLabelOverlay | undefined): void;
 }
-export {};

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

@@ -1,5 +1,5 @@
 import type { Tg } from '../../event';
-import { AbstractEventTargetDelegate } from '../../event-target';
+import { type EventTargetDelegate } from '../../event-target';
 import type { CoordType } from '../../lat-lng';
 import type { UnionBaiduOverlay, UnionGoogleOverlay } from '../../unions';
 import type { AbstractMap } from '../map';
@@ -12,23 +12,27 @@ export declare abstract class Overlay<T = unknown> implements Tg.EventTarget {
     /** 用于保存Overlay内部点的坐标, 它的值有可能和map的不同 */
     protected coordType: CoordType;
     protected map: AbstractMap;
-    private delegate;
-    addEventListener: (type: string, listener: Tg.EventListener) => void;
-    removeEventListener: (type: string, listener: Tg.EventListener) => void;
     constructor(innerOverlay: T, 
     /** 用于保存Overlay内部点的坐标, 它的值有可能和map的不同 */
-    coordType: CoordType, map: AbstractMap, delegate: AbstractEventTargetDelegate);
+    coordType: CoordType, map: AbstractMap);
+    protected abstract createDelegate(): EventTargetDelegate;
+    private _delegate;
+    private get delegate();
+    addEventListener(type: string, listener: Tg.EventListener): void;
+    removeEventListener(type: string, listener: Tg.EventListener): void;
     remove(): void;
     abstract isVisible(): boolean;
     abstract setVisible(visible: boolean): void;
 }
 export declare class GoogleOverlay<T extends UnionGoogleOverlay = UnionGoogleOverlay> extends Overlay<T> {
     constructor(innerOverlay: T, coordType: CoordType, map: AbstractMap);
+    protected createDelegate(): EventTargetDelegate;
     isVisible(): boolean;
     setVisible(visible: boolean): void;
 }
 export declare class BaiduOverlay<T extends UnionBaiduOverlay = UnionBaiduOverlay> extends Overlay<T> {
     constructor(innerOverlay: T, coordType: CoordType, map: AbstractMap);
+    protected createDelegate(): EventTargetDelegate;
     /** 仅限内部使用; 设为private时, 生成的d.ts文件中, 方法返回值会变成any, 故改成了public */
     get overlay(): Required<Pick<UnionBaiduOverlay, "isVisible" | "show" | "hide">>;
     isVisible(): boolean;

package/dist/src/map/map/overlay/polygon.d.ts

@@ -1,18 +1,22 @@
 /// <reference types="baidumap-web-sdk" />
 /// <reference types="google.maps" />
 import type { Tg } from '../../event';
+import { EventHubEventTargetDelegate } from '../../event-target';
 import { LatLng } from '../../lat-lng';
 import type { BaiduMap } from '../baidu-map';
 import type { GoogleMap } from '../google-map';
 import type { Overlay } from './overlay';
-import { BaiduShape, GoogleShape, type Shape, type ShapeOptions } from './shape';
-type PolygonEventMap = {
+import { BaiduPolyShape } from './polyline';
+import { GoogleShape, type Shape, type ShapeOptions } from './shape';
+export type PolygonEventMap = {
     click: Tg.Event;
     dblclick: Tg.Event;
     mousedown: Tg.MouseEvent;
     mouseup: Tg.MouseEvent;
     mouseout: Tg.MouseEvent;
     mouseover: Tg.MouseEvent;
+    /** @see PolylineEventMap `.path-edited` */
+    'paths-edited': Tg.Event;
 };
 export interface PolygonOptions extends ShapeOptions {
     paths: LatLng[][];
@@ -22,14 +26,19 @@ export interface Polygon extends Tg.EventTargetTyped<Polygon, PolygonEventMap>,
     setPaths(paths: LatLng[][]): void;
 }
 export type PolygonOverlay = Polygon & Overlay;
-export declare class BaiduPolygon extends BaiduShape<BMap.Polygon> implements Polygon {
+export declare class BaiduPolygon extends BaiduPolyShape<BMap.Polygon> implements Polygon {
     static create(this: BaiduMap, options: PolygonOptions): BaiduPolygon;
+    protected pathEditedEventType: string;
     getPaths(): LatLng[][];
     setPaths(paths: LatLng[][]): void;
 }
 export declare class GooglePolygon extends GoogleShape<google.maps.Polygon> implements Polygon {
     static create(this: GoogleMap, options: PolygonOptions): GooglePolygon;
+    private pathChangedListeners;
+    private setupPathChangedListeners;
+    private clearPathChangedListeners;
+    private eventHubDelegate;
+    protected createDelegate(): EventHubEventTargetDelegate<"paths-edited">;
     getPaths(): LatLng[][];
     setPaths(paths: LatLng[][]): void;
 }
-export {};

package/dist/src/map/map/overlay/polyline.d.ts

@@ -1,18 +1,30 @@
 /// <reference types="baidumap-web-sdk" />
+/// <reference types="baidumap-web-sdk" />
 /// <reference types="google.maps" />
 import type { Tg } from '../../event';
+import { EventHubEventTargetDelegate } from '../../event-target';
 import { LatLng } from '../../lat-lng';
 import type { BaiduMap } from '../baidu-map';
 import type { GoogleMap } from '../google-map';
 import type { Overlay } from './overlay';
 import { BaiduShape, GoogleShape, type NotFillableShape, type NotFillableShapeOptions } from './shape';
-type PolylineEventMap = {
+export type PolylineEventMap = {
     click: Tg.Event;
     dblclick: Tg.Event;
     mousedown: Tg.MouseEvent;
     mouseup: Tg.MouseEvent;
     mouseout: Tg.MouseEvent;
     mouseover: Tg.MouseEvent;
+    /**
+     * 在`editable`模式下编辑了path的事件
+     * 外部调用{@link Polyline#setPath}, 不触发该事件 (之所以这样设计, 是为了避免频繁的进行LatLng<=>地图点对象的相互转换)
+     *
+     * ## 原理
+     * 该事件的实现比较杂, 原始地图并没有等效的事件, 都是通过转换实现的
+     * - google: 通过监听path的`insert/remove/set_at`实现
+     * - baidu: 通过监听`lineupdate`事件, 然后判断path有没有被修改, 来实现的
+     */
+    'path-edited': Tg.Event;
 };
 export interface PolylineOptions extends NotFillableShapeOptions {
     path: LatLng[];
@@ -22,14 +34,30 @@ export interface Polyline extends Tg.EventTargetTyped<Polyline, PolylineEventMap
     setPath(path: LatLng[]): void;
 }
 export type PolylineOverlay = Polyline & Overlay;
-export declare class BaiduPolyline extends BaiduShape<BMap.Polyline> implements Polyline {
+export declare abstract class BaiduPolyShape<T extends BMap.Polyline | BMap.Polygon> extends BaiduShape<T> {
+    /** 路径被编辑的事件名 */
+    protected abstract pathEditedEventType: string;
+    /** 修改路径, 仅内部使用 */
+    protected setPathInternal(path: BMap.Point[]): void;
+    private eventHubDelegate;
+    protected createDelegate(): EventHubEventTargetDelegate<string>;
+    private prevPath;
+    private isDoingSetPath;
+    private onLineUpdate;
+}
+export declare class BaiduPolyline extends BaiduPolyShape<BMap.Polyline> implements Polyline {
     static create(this: BaiduMap, options: PolylineOptions): BaiduPolyline;
+    protected pathEditedEventType: string;
     getPath(): LatLng[];
     setPath(path: LatLng[]): void;
 }
 export declare class GooglePolyline extends GoogleShape<google.maps.Polyline> implements Polyline {
     static create(this: GoogleMap, options: PolylineOptions): GooglePolyline;
+    private pathChangedListeners;
+    private setupPathChangedListeners;
+    private clearPathChangedListeners;
+    private eventHubDelegate;
+    protected createDelegate(): EventHubEventTargetDelegate<"path-edited">;
     getPath(): LatLng[];
     setPath(path: LatLng[]): void;
 }
-export {};

package/dist/src/map/map/overlay/rectangle.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="baidumap-web-sdk" />
+/// <reference types="google.maps" />
+import type { Tg } from '../../event';
+import { CoordType, LatLngBounds } from '../../lat-lng';
+import type { BaiduMap } from '../baidu-map';
+import type { GoogleMap } from '../google-map';
+import type { Overlay } from './overlay';
+import { BaiduPolyShape } from './polyline';
+import { GoogleShape, type Shape, type ShapeOptions } from './shape';
+export type RectangleEventMap = {
+    click: Tg.Event;
+    dblclick: Tg.Event;
+    mousedown: Tg.MouseEvent;
+    mouseup: Tg.MouseEvent;
+    mouseout: Tg.MouseEvent;
+    mouseover: Tg.MouseEvent;
+    /**
+     * - google: 监听[bounds_changed](https://developers.google.com/maps/documentation/javascript/shapes#editable_events)
+     * - baidu: 内部使用Polygon并监听`lineupdate`实现
+     */
+    'bounds-changed': Tg.Event;
+};
+export interface RectangleOptions extends ShapeOptions {
+    bounds: LatLngBounds;
+}
+export interface Rectangle extends Tg.EventTargetTyped<Rectangle, RectangleEventMap>, Shape {
+    getBounds(): LatLngBounds;
+    setBounds(bounds: LatLngBounds): void;
+}
+/**
+ * 矩形覆盖物
+ *
+ * - google: 有矩形
+ * - baidu: 没有矩形, 使用{@link BMap.Polygon}变相实现
+ */
+export type RectangleOverlay = Rectangle & Overlay;
+export declare class BaiduRectangle extends BaiduPolyShape<BMap.Polygon> implements Rectangle {
+    static create(this: BaiduMap, options: RectangleOptions): BaiduRectangle;
+    constructor(innerOverlay: BMap.Polygon, coordType: CoordType, map: BaiduMap, state: {
+        editable: boolean;
+    });
+    protected pathEditedEventType: string;
+    private isDoingUpdateRectangle;
+    private onBoundsChanged;
+    getBounds(): LatLngBounds;
+    setBounds(bounds: LatLngBounds): void;
+}
+export declare class GoogleRectangle extends GoogleShape<google.maps.Rectangle> implements Rectangle {
+    static create(this: GoogleMap, options: RectangleOptions): GoogleRectangle;
+    getBounds(): LatLngBounds;
+    setBounds(bounds: LatLngBounds): void;
+}

package/dist/src/map/map/overlay/shape.d.ts

@@ -25,7 +25,9 @@ export interface Shape {
 export type NotFillableShape = Omit<Shape, 'setFillColor' | 'setFillOpacity'>;
 export type NotFillableShapeOptions = Omit<ShapeOptions, 'fillColor' | 'fillOpacity'>;
 export declare abstract class BaiduShape<T extends UnionBaiduShape> extends BaiduOverlay<T> implements Shape {
-    private state;
+    protected state: {
+        editable: boolean;
+    };
     constructor(innerOverlay: T, coordType: CoordType, map: BaiduMap, state: {
         editable: boolean;
     });

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

@@ -18,6 +18,6 @@ export type UnionBaiduOverlay = BMap.Marker | BMap.Polyline | BMap.Polygon | BMa
 export type UnionGoogleEventTarget = google.maps.MVCObject;
 export type UnionBaiduEventTarget = UnionBaiduOverlay | BMap.InfoWindow | BMap.Autocomplete | BMap.Map;
 export type UnionBaiduShape = BMap.Polyline | BMap.Polygon | BMap.Circle;
-export type UnionGoogleShape = google.maps.Polyline | google.maps.Polygon | google.maps.Circle;
+export type UnionGoogleShape = google.maps.Polyline | google.maps.Polygon | google.maps.Circle | google.maps.Rectangle;
 export type UnionControl = BMap.Control | HTMLElement;
 export type GoogleLayer = google.maps.TrafficLayer | google.maps.TransitLayer | google.maps.KmlLayer | google.maps.BicyclingLayer;

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

@@ -1,10 +1,26 @@
 /// <reference types="google.maps" />
-import type { Constructor } from '../components';
+import type { AnyFunction, Constructor } from '../components';
 export declare namespace Arrays {
+    /**
+     * 浅层比较
+     * @see https://stackoverflow.com/questions/7837456/how-to-compare-arrays-in-javascript
+     * */
+    function equals<T>(a: T[], b: T[]): boolean;
     function remove<T>(arr: T[], item: T): T | undefined;
     function findByType<T>(arr: any[], constructor: Constructor<T>): T | undefined;
+    /** 自动推断item的类型的{@link Array.includes} */
+    function includesTyped<T extends E, E>(arr: T[], item: E): item is T;
+    /** 设置 指定位置的值 */
+    function at<T>(arr: T[], index: number, value: T): void;
+    /** 获取 指定位置的值 */
+    function at<T>(arr: T[], index: number): T | undefined;
 }
 export declare namespace MVCArrays {
     function indexOf<T>(arr: google.maps.MVCArray<T>, item: T): number;
     function remove<T>(arr: google.maps.MVCArray<T>, item: T): T | undefined;
+    /**
+     * 监听数组内容变化
+     * @see https://developers.google.com/maps/documentation/javascript/shapes#editable_events
+     * */
+    function listenChanged<T>(path: google.maps.MVCArray<T>, handler: AnyFunction): google.maps.MapsEventListener[];
 }

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

@@ -3,3 +3,7 @@
  * @see http://lbsyun.baidu.com/cms/jsapi/reference/jsapi_reference_3_0.html#a3b0
  */
 export declare function ensureBaiduV3(): void;
+export declare const BMapPoints: {
+    /** {@link BMap.Point.equals} 无效, 故需要自己写一个 */
+    equals(a: BMap.Point, b: BMap.Point): boolean;
+};

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

@@ -15,6 +15,7 @@ export declare function initGoogleMapDynamicLibraryImport(args: {
 export declare const GoogleConst: {
     /** Google的坐标0点 */
     readonly LATLNG_ZERO: google.maps.LatLng;
+    readonly BOUNDS_ZERO: google.maps.LatLngBounds;
 };
 export interface AddressFields {
     /** 国家 */

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

@@ -3,6 +3,8 @@ import type { Component, ComponentPublicInstance } from 'vue';
 export type DeepPartial<T> = {
     [U in keyof T]?: T[U] extends object ? DeepPartial<T[U]> : T[U];
 };
+/** 表示一个函数 */
+export type AnyFunction = (...args: any[]) => any;
 /**
  * 表示一个构造器
  * {@link import('vue/types/options').Constructor}
@@ -72,7 +74,11 @@ export declare function unwrapStringEnumValue<E extends StringEnumLike>(value: S
 export declare function unwrapStringEnumValue<E extends StringEnumLike>(value: StringEnumValue<E> | undefined, enumObject?: E): E[keyof E] | undefined;
 /**
  * 非空的值
+ *
+ * 类型`{}`也表示"任何非空的值", 但由于它看起来像空对象, 所以一般更推荐用Thing
+ *
  * @see https://github.com/microsoft/TypeScript/issues/7648#issuecomment-541625573
+ * @see https://github.com/typescript-eslint/typescript-eslint/issues/2063#issuecomment-675156492
  */
 export type Thing = string | number | boolean | bigint | object | symbol;
 /** 除T指定的类型外, 其他参数 */

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

@@ -176,12 +176,8 @@ export type EventEmits<T> = {
 };
 /** 给事件类型的属性标注类型 */
 export declare function eventProp<E = any>(): Prop<EventCallback<E>>;
-export declare const eventLogMethods: {
-    /**
-     * @event 一般来说传{@link Tg.Event}对象, 但传其他对象也不会报错
-     */
-    eventLog(this: any, event: Thing | null | undefined): void;
-    /** @see eventLog */
-    eventLogLess(this: any, event: Thing | null | undefined): void;
+export declare const useEventLogMethods: () => {
+    eventLog: (event: Thing | null | undefined) => void;
+    eventLogLess: (this: any, event: Thing | null | undefined) => void;
 };
 export {};