mrxy-yk 0.0.1-beta.11

package/dist/@type/utils/amap/@type/LngLat.d.ts

@@ -0,0 +1,34 @@
+import { AMap } from './AMap';
+export class LngLat {
+  constructor(lng?: number, lat?: number, noWrap?: boolean)
+
+  readonly lat
+
+  readonly lng
+
+  readonly kT
+
+  readonly KL
+
+  setLng(lng: number): void
+
+  setLat(lat: number): void
+
+  getLng(): number
+
+  getLat(): number
+
+  equals(another: AMap.LngLat): boolean
+
+  add(another: AMap.LngLat, noWrap: boolean): AMap.LngLat
+
+  subtract(another: AMap.LngLat, noWrap: boolean): AMap.LngLat
+
+  offset(E, N): AMap.LngLat
+
+  toString(): string
+
+  toArray(): number[]
+
+  distance(): number
+}

package/dist/@type/utils/amap/@type/Map.d.ts

@@ -0,0 +1,218 @@
+import { Event } from './Event';
+import { AMap, LngLat } from './AMap';
+import { Layer, Overlay } from './other';
+export class Map extends Event<MapEvent> {
+  constructor(div: string | HTMLDivElement, opts: MapOptions)
+
+  resize(): void
+
+  setCenter(center: number[] | string[] | AMap.LngLat, immediately = false, duration?: number): void
+
+  setZoomAndCenter(zoom: number, center: number[] | AMap.LngLat, immediately = false, duration?: number): void
+
+  getBounds(): AMap.Bounds
+
+  getCenter(): AMap.LngLat
+
+  setZoom(zoom: number, immediately = false, duration?: number): void
+
+  getZoom(digits: number): number
+
+  zoomIn(): void
+
+  zoomOut(): void
+
+  getPitch(): number
+
+  setPitch(pitch: number, immediately = false, duration?: number): void
+
+  getRotation(): number
+
+  setRotation(rotation: number, immediately = false, duration?: number): void
+
+  setBounds(bounds: number[] | AMap.Bounds, immediately = false, duration?: number): void
+
+  panTo(lnglat: number[] | AMap.LngLat, duration?: number): void
+
+  panBy(x: number, y: number, duration?: number): void
+
+  getContainer(): HTMLDivElement
+
+  getSize(): AMap.Size
+
+  addLayer(layer: Layer): void
+
+  removeLayer(layer): void
+
+  add(features: VectorOverlay | any[])
+
+  setLayers(layers: Layer[])
+
+  getLayers(): Layer[]
+
+  remove(features: Overlay | AMap.LngLat | Array<Overlay | AMap.LngLat>)
+
+  getStatus(): MapStatus
+
+  lngLatToCoords(lnglat: number[] | LngLat): any
+
+  setStatus(status: MapStatus): void
+
+  coordsToLnglat(coords: number[]): any
+
+  lngLatToContainer(lnglat: number[] | AMap.LngLat): AMap.Pixel
+
+  getAltitude(lnglat: number[] | AMap.LngLat): number
+
+  containerToLngLat(pixel: number[] | AMap.Pixel): AMap.LngLat
+
+  getDefaultCursor(): string
+
+  setDefaultCursor(cursor: string): void
+
+  coordToContainer(coord: number[]): number[]
+
+  containerToCoord(pixel: number[] | AMap.Pixel)
+
+  destroy(): void
+
+  getAltitudeByContainer(pixel: number[] | AMap.Pixel)
+
+  pixelToLngLat(pixel: number[] | AMap.Pixel, zoom?: number): AMap.LngLat
+
+  lngLatToPixel(lnglat: number[] | AMap.LngLat, zoom?: number): AMap.Pixel
+
+  getLimitBounds(): void
+
+  setLimitBounds(): void
+
+  clearLimitBounds(): void
+
+  getZooms(): number[]
+
+  setZooms(zooms: number[])
+
+  getResolution(): number
+
+  getScale(dpi: number): number
+
+  getCity(getCityCallBack: {(e: any)}, lnglat: number[])
+
+  setCity(cityName: string)
+
+  setFitView(overlays: Overlay[], immediately = false, avoid?: [number, number, number, number], maxZoom?: number): void
+
+  getFitZoomAndCenterByOverlays(overlays: Overlay[], avoid: number[], maxZoom: number): void
+
+  getFitZoomAndCenterByBounds(bounds: number[] | AMap.Bounds, avoid: number[], maxZoom: number): void
+
+  addControl(control: AMap.Control): void
+
+  removeControl(control: AMap.Control): void
+
+  setMapStyle(value: string): void
+
+  getMapStyle(): string
+
+  getAllOverlays(type?: 'marker' | 'circle' | 'polyline' | 'polygon'): Overlay[]
+
+  clearMap(): void
+
+  clearInfoWindow(): void
+
+  getFeatures(): string[]
+
+  setFeatures(features: Array<'bg' | 'point' | 'road' | 'building'>)
+
+  getMapApprovalNumber(): string
+
+  setMask(maskPath: number[][], maskPath: number[]): void
+
+  setLabelRejectMask(reject: boolean): void
+}
+
+export interface MapOptions {
+  center?: number[] | AMap.LngLat,
+  zoom?: number,
+  rotation?: number,
+  pitch?: number,
+  viewMode?: '2D' | '3D',
+  terrain?: boolean,
+  features?: ('bg' | 'point' | 'road' | 'building')[],
+  layers?: Layer[],
+  zooms?: number[],
+  dragEnable?: boolean,
+  zoomEnable?: boolean,
+  jogEnable?: boolean,
+  pitchEnable?: boolean,
+  rotateEnable?: boolean,
+  animateEnable?: boolean,
+  keyboardEnable?: boolean,
+  doubleClickZoom?: boolean,
+  scrollWheel?: boolean,
+  touchZoom?: boolean,
+  touchZoomCenter?: boolean,
+  showLabel?: boolean,
+  defaultCursor?: string,
+  isHotspot?: string,
+  mapStyle?: string,
+  wallColor?: string | number[],
+  roofColor?: string | number[],
+  showBuildingBlock?: boolean,
+  showIndoorMap?: boolean,
+  skyColor?: boolean,
+  labelRejectMask?: boolean,
+  mask?: number[],
+  WebGLParams?: any
+}
+
+interface MapStatus {
+  showIndoorMap?: boolean,
+  resizeEnable?: boolean,
+  dragEnable?: boolean,
+  keyboardEnable?: boolean,
+  doubleClickZoom?: boolean,
+  zoomEnable?: boolean,
+  rotateEnable?: boolean
+}
+
+// region Event
+type MapEventType =
+  | 'resize'
+  | 'complete'
+  | 'click'
+  | 'dblclick'
+  | 'mapmove'
+  | 'hotspotclick'
+  | 'hotspotover'
+  | 'hotspotout'
+  | 'movestart'
+  | 'moveend'
+  | 'zoomchange'
+  | 'zoomstart'
+  | 'zoomend'
+  | 'rotatechange'
+  | 'rotatestart'
+  | 'mousemove'
+  | 'mousewheel'
+  | 'mouseover'
+  | 'mouseout'
+  | 'mouseup'
+  | 'mousedown'
+  | 'rightclick'
+  | 'dragstart'
+  | 'dragging'
+  | 'dragend'
+  | 'touchstart'
+  | 'touchmove'
+  | 'touchend';
+
+export interface MapsEvent {
+  lnglat: AMap.LngLat,
+  pixel: AMap.Pixel,
+  type: string,
+  target: any
+}
+
+type MapEvent = Record<MapEventType, MapsEvent>
+// endregion

package/dist/@type/utils/amap/@type/Marker.d.ts

@@ -0,0 +1,137 @@
+import { AMap } from './AMap';
+import { MapsEvent } from './Map';
+import { Event } from './Event';
+import { MoveAnimation } from './MoveAnimation';
+import { Vector2, Anchor, Direction } from './index';
+interface Marker extends Event<MarkerEvent>, MoveAnimation {}
+export class Marker {
+  constructor(markerOptions: MarkerOptions)
+
+  getIcon(): string | AMap.Icon
+
+  setIcon(icon: string | AMap.Icon): void
+
+  getTitle(): string
+
+  getHeight(): number
+
+  getLabel(): LabelOptions
+
+  setLabel(opts: LabelOptions): void
+
+  getClickable(): boolean
+
+  setClickable(clickable: boolean): void
+
+  getDraggable(): boolean
+
+  setDraggable(draggable: boolean): void
+
+  getTop(): boolean
+
+  setTop(isTop: boolean): void
+
+  getCursor(): string
+
+  setCursor(cursor: string): void
+
+  getExtData(): any
+
+  setExtData(extData: any): void
+
+  remove(): void
+
+  getMap(): AMap.Map
+
+  setMap(map: AMap.Map): void
+
+  addTo(map: AMap.Map): void
+
+  add(map: AMap.Map): void
+
+  show(): void
+
+  hide(): void
+
+  getPosition(): any
+
+  setPosition(position: number[]): void
+
+  getAnchor(): string | number[]
+
+  setAnchor(anchor: Anchor): void
+
+  getOffset(): number[] | AMap.Pixel
+
+  setOffset(offset: number[] | AMap.Pixel): void
+
+  getAngle(): number
+
+  setAngle(angle: number): void
+
+  getSize(): number[] | AMap.Size
+
+  setSize(size: number[] | AMap.Size): void
+
+  getzIndex(): number
+
+  setzIndex(zIndex: number): void
+
+  getOptions(): MarkerOptions
+
+  getContent(): string | HTMLElement
+
+  setContent(content: string | HTMLElement): void
+
+  getBounds(): AMap.Bounds
+}
+
+interface MarkerOptions {
+  map?: AMap.Map,
+  position?: number[] | string[] | AMap.LngLat,
+  icon?: string,
+  content?: string | HTMLElement,
+  title?: string,
+  visible?: boolean,
+  zIndex?: number,
+  offset?: number[] | AMap.Pixel,
+  anchor?: Anchor | Vector2
+  angle?: number,
+  clickable?: boolean,
+  draggable?: boolean,
+  bubble?: boolean,
+  zooms?: number[],
+  cursor?: string,
+  topWhenClick?: boolean,
+  height?: number,
+  label?: LabelOptions,
+  extData?: any
+}
+
+interface LabelOptions {
+  content?: string,
+  offset: AMap.Pixel | Vector2,
+  direction?: Direction
+}
+
+// region Event
+type MarkerEventType =
+  | 'click'
+  | 'dblclick'
+  | 'rightclick'
+  | 'mousemove'
+  | 'mouseover'
+  | 'mouseout'
+  | 'mousedown'
+  | 'mouseup'
+  | 'dragstart'
+  | 'dragging'
+  | 'dragend'
+  | 'moving'
+  | 'moveend'
+  | 'movealong'
+  | 'touchstart'
+  | 'touchmove'
+  | 'touchend'
+type MarkerEvent = Record<MarkerEventType, MapsEvent>
+// endregion

package/dist/@type/utils/amap/@type/MarkerCluster.d.ts

@@ -0,0 +1,65 @@
+import { AMap } from './AMap';
+import { Event } from './Event';
+export class MarkerCluster extends Event<MarkerClusterEvent> {
+  constructor(map: AMap.Map, dataOptions: DataOption[], markerClusterOptions: MarkerClusterOptions)
+
+  addData(dataOptions: DataOption[]): void
+
+  setData(dataOptions: DataOption[]): void
+
+  getClustersCount(): number
+
+  getGridSize(): number
+
+  setGridSize(size: number): void
+
+  getMaxZoom(): number
+
+  setMaxZoom(zoom: number): void
+
+  setStyles(styles: MarkerClusterStyle[])
+
+  getMap(): AMap.Map
+
+  setMap(map: AMap.Map): void
+
+  isAverageCenter(): boolean
+
+  setAverageCenter(averageCenter: boolean): void
+}
+
+interface DataOption { lnglat: Vector2, weight?: number, data?: any }
+
+interface MarkerClusterStyle {
+  url: string,
+  size: AMap.Size,
+  offset?: AMap.Pixel,
+  imageOffset?: AMap.Pixel,
+  textColor?: string,
+  textSize?: number
+}
+
+interface MarkerClusterOptions {
+  gridSize?: number,
+  maxZoom?: number,
+  averageCenter?: boolean,
+  clusterByZoomChange?: boolean,
+  styles?: MarkerClusterStyle[],
+
+  renderClusterMarker?(count: number, marker: AMap.Marker),
+
+  renderMarker?(e: RenderMarkerCallbackParams)
+}
+
+interface MarkerClusterEvent {
+  click: { cluster: any, target: any, lnglat: AMap.LngLat, markers: AMap.Marker }
+}
+
+interface RenderMarkerCallbackParams {
+  count: number,
+  marker: AMap.Marker,
+  data: {
+    lnglat: AMap.LngLat,
+    [p: string]: any
+  }[]
+}

package/dist/@type/utils/amap/@type/MoveAnimation.d.ts

@@ -0,0 +1,33 @@
+import { AMap } from './AMap';
+export class MoveAnimation {
+  moveTo(targetPosition: number[] | AMap.LngLat, opts?: MoveToOptions): void
+
+  moveAlong(path: number[] | AMap.LngLat[], opts?: MoveAlongOptions): void
+
+  startMove(): void
+
+  stopMove(): void
+
+  resumeMove(): void
+}
+
+type AnimationCallback = (index: number, data: AMap.LngLat) => number
+
+type EasingCallback = (passedTime: number) => number
+
+interface MoveAlongOptions {
+  duration: number | AnimationCallback,
+  speed: number | AnimationCallback,
+  easing: EasingCallback,
+  circlable: boolean,
+  delay: number | AnimationCallback,
+  aniInterval: number,
+  autoRotation: boolean
+}
+
+interface MoveToOptions {
+  duration?: number,
+  speed?: number,
+  easing?: EasingCallback,
+  autoRotation?: boolean
+}

package/dist/@type/utils/amap/@type/Pixel.d.ts

@@ -0,0 +1,11 @@
+export class Pixel {
+  constructor(x: number, y: number)
+
+  getX(): number
+
+  getY(): number
+
+  toString(): string
+
+  equals(point: AMap.Pixel): boolean
+}

package/dist/@type/utils/amap/@type/Polyline.d.ts

@@ -0,0 +1,80 @@
+import { Event } from './Event';
+import { MapsEvent } from './Map';
+import { AMap } from './AMap';
+import { LngLatLike } from './other';
+export class Polyline extends Event<PolylineEvent> {
+  constructor(opts: PolylineOptions)
+
+  hide(): void
+
+  show(): void
+
+  getExtData(): any
+
+  getOptions(): PolylineOptions
+
+  getPath(): AMap.LngLat[] | AMap.LngLat[][]
+
+  setExtData(extData: any): void
+
+  setHeight(height: number): void
+
+  destroy(): void
+
+  getBounds(): AMap.Bounds
+
+  setPath(path?: LngLatLike[] | LngLatLike[][]): any
+
+  moveWithPos(dx: any, dy: any): void
+
+  getLength(isTerrain?: boolean): any
+
+  getEndDistance(): void
+
+  generateBuffer(gl: any): void
+
+  setOptions(optsArg: PolylineOptions): void
+
+  contains(point: LngLatLike): boolean
+
+  getPolylineHeight(): any
+}
+
+interface PolylineOptions {
+  path?: AMap.LngLat[] | AMap.LngLat[][]
+  zIndex?: number
+  bubble?: boolean
+  cursor?: string
+  strokeColor?: string
+  strokeOpacity?: number
+  strokeWeight?: number
+  isOutline?: boolean
+  borderWeight?: number
+  outlineColor?: string
+  draggable?: boolean
+  height?: number
+  extData?: any
+  strokeStyle?: 'solid' | 'dashed'
+  strokeDasharray?: number[]
+  lineJoin?: 'miter' | 'round' | 'bevel'
+  lineCap?: 'butt' | 'round' | 'square'
+  geodesic?: boolean
+  showDir?: boolean
+}
+
+// region Event
+type PolylineEventType =
+  | 'hide'
+  | 'show'
+  | 'click'
+  | 'dblclick'
+  | 'rightclick'
+  | 'mousedown'
+  | 'mouseup'
+  | 'mouseover'
+  | 'mouseout'
+  | 'touchstart'
+  | 'touchmove'
+  | 'touchend'
+type PolylineEvent = Record<PolylineEventType, MapsEvent>
+// endregion

package/dist/@type/utils/amap/@type/Size.d.ts

@@ -0,0 +1,9 @@
+export class Size {
+  constructor(width: number, height: number)
+
+  getWidth(): number
+
+  getHeight(): number
+
+  toString(): number
+}

package/dist/@type/utils/amap/@type/index.d.ts

@@ -0,0 +1,23 @@
+export * from './AMap'
+export * from './other'
+
+export type LoadOption = {
+  // 申请好的Web端开发者Key，首次调用 load 时必填
+  key: string
+  // 指定要加载的 JSAPI 的版本，缺省时默认为 1.4.15
+  version: string
+  // 插件列表
+  plugins?: string[]
+  // 是否加载 AMapUI，缺省不加载
+  AMapUI?: {
+    // AMapUI 缺省 1.1
+    version?: string
+    // 需要加载的 AMapUI ui插件
+    plugins?: string[]
+  };
+  // 是否加载 Loca， 缺省不加载
+  Loca?: {
+    // Loca 版本，缺省 1.3.2
+    version?: string
+  }
+}

package/dist/@type/utils/amap/@type/other.d.ts

@@ -0,0 +1,11 @@
+export type Layer = any
+
+export type Overlay = marker | circle | polyline | polygon | any
+
+export type Direction = 'top' | 'right' | 'bottom' | 'left' | 'center'
+
+export type Anchor = 'top-left' | 'top-center' | 'middle-left' | 'center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right'
+
+export type Vector2 = [number, number] | number[]
+
+export type LngLatLike = AMap.LngLat | Vector2

package/dist/@type/utils/amap/index.d.ts

@@ -0,0 +1,3 @@
+import { AMapResolve, LoaderOptions } from './type';
+export * from './utils';
+export declare function AMapLoader(options: LoaderOptions): Promise<AMapResolve>;

package/dist/@type/utils/amap/type.d.ts

@@ -0,0 +1,21 @@
+import { AMap } from './@type/AMap';
+import { LoadOption } from './@type';
+import { MapOptions } from './@type/Map';
+export type LoaderOptions = {
+  // key 高德地图key（缺省使用全局配置）
+  key?: string,
+  // secret 高德地图secret（缺省使用全局配置）
+  secret?: string,
+  // el 地图容器元素
+  el: HTMLDivElement,
+  // plugins 插件列表
+  plugins?: string[],
+  // mapStyle 地图样式
+  mapStyle?: string,
+  // loadOption 加载选项
+  loadOption?: LoadOption,
+  // mapOption 地图选项
+  mapOption?: MapOptions
+}
+
+export type AMapResolve = { AMap: typeof AMap, map: AMap.Map }

package/dist/@type/utils/amap/utils/coordinates.d.ts

@@ -0,0 +1,24 @@
+import { Vector2 } from '../@type';
+/**
+ * 处理坐标系的工具
+ */
+export declare class CoordinatesUtil {
+    /**
+     * GCJ-02(火星坐标系)转WGS-84
+     * @param lngLat
+     */
+    static gcj02ToWgs84(lngLat: Vector2): Vector2;
+    /**
+     * WGS-84转GCJ-02(火星坐标系)
+     * @param lngLat
+     */
+    static wgs84ToGcj02(lngLat: Vector2): Vector2;
+    /**
+     * 检查坐标是否在国内
+     * @param lngLat
+     */
+    static isOutChina(lngLat: Vector2): boolean;
+    private static delta;
+    private static transformLng;
+    private static transformLat;
+}

package/dist/@type/utils/amap/utils/index.d.ts

@@ -0,0 +1,12 @@
+import { AMap } from '../@type';
+import { FitViewOverlays } from './type';
+import { CoordinatesUtil } from './coordinates';
+export declare class AMapUtil {
+    /**
+     * 生成setFitView所需的覆盖物
+     * @param aMap
+     * @param points
+     */
+    static createFitViewOverlays(aMap: typeof AMap, points: FitViewOverlays.ParamPoint[]): AMap.Marker[];
+    static Coordinates: typeof CoordinatesUtil;
+}

package/dist/@type/utils/amap/utils/type.d.ts

@@ -0,0 +1,4 @@
+export namespace FitViewOverlays {
+  export type Point = { lng: number, lat: number }
+  export type ParamPoint = { lnglat: number[] | FitViewOverlays.Point, [p: string]: unknown } | FitViewOverlays.Point | number[]
+}