@cn-map/gaode-svelte 0.0.0-stage → 0.0.1

package/dist/overlay/marker-cluster/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MarkerCluster } from './marker-cluster.svelte';
+export type { MarkerClusterProps } from './marker-cluster.svelte';

package/dist/overlay/marker-cluster/index.js

@@ -0,0 +1 @@
+export { default as MarkerCluster } from './marker-cluster.svelte';

package/dist/overlay/marker-cluster/marker-cluster.svelte

@@ -0,0 +1,134 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import { click } from '@cn-map/gaode-shared/const'
+  import { clone, eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { untrack } from 'svelte'
+  import { createEventListeners } from '../../hooks/index.js'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+
+  type MarkerClusterEvents = MapEventProps<AMap.MarkerClusterEventType, AMap.MarkerCluster>
+  interface MarkerClusterExtraInitOptions {
+    /**
+     * 点标记聚合数据项
+     */
+    data: AMap.MarkerClusterDataOptions[]
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map
+  }
+  type MarkerClusterInitOptions = AMap.MarkerClusterOptions
+    & MarkerClusterExtraInitOptions
+    & Instance<AMap.MarkerCluster>
+
+  export type MarkerClusterProps = MarkerClusterInitOptions & MarkerClusterEvents
+
+  const markerClusterEvents: AMap.MarkerClusterEventType[] = [click]
+
+  let { instance = $bindable(), data, ...props }: MarkerClusterProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(markerClusterEvents))
+
+  const markerCluster = $state.raw<AMap.MarkerCluster>(
+    new AMap.MarkerCluster(
+      null,
+      clone(
+        untrack(() => data),
+        true
+      ),
+      snapshot(restProps)
+    )
+  )
+
+  // whether the markerCluster is added to the map
+  let isMounted = $state(false)
+
+  $effect(() => {
+    instance = markerCluster
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    markerCluster.i = null
+    markerCluster.setMap(map)
+    isMounted = !!markerCluster.getMap()
+
+    return () => {
+      markerCluster.setMap(null)
+      isMounted = false
+    }
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+
+    markerCluster.setData(clone(data, true))
+
+    return () => {
+      markerCluster.setData([])
+    }
+  })
+
+  function getDefaultStyles() {
+    const markerCluster = new AMap.MarkerCluster()
+    const styles = markerCluster.getStyles()
+    markerCluster.setMap(null)
+
+    return styles
+  }
+
+  $effect(() => {
+    if (!isMounted) return
+    if (restProps.averageCenter !== undefined) {
+      markerCluster.setAverageCenter(restProps.averageCenter)
+    }
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    if (restProps.gridSize !== undefined) {
+      markerCluster.setGridSize(restProps.gridSize)
+    }
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    if (restProps.maxZoom !== undefined) {
+      markerCluster.setMaxZoom(restProps.maxZoom)
+    }
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    if (restProps.minClusterSize !== undefined) {
+      markerCluster.setMinClusterSize(restProps.minClusterSize)
+    }
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    markerCluster.renderClusterMarker = restProps.renderClusterMarker
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    markerCluster.setRenderMarkerStyle(restProps.renderMarker)
+  })
+
+  $effect(() => {
+    if (!isMounted) return
+    markerCluster.setStyles(snapshot(restProps.styles) ?? getDefaultStyles())
+  })
+
+  createEventListeners<AMap.MarkerClusterEventType, AMap.MarkerCluster>(
+    () => markerCluster,
+    () => props,
+    markerClusterEvents
+  )
+</script>

package/dist/overlay/marker-cluster/marker-cluster.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+type MarkerClusterEvents = MapEventProps<AMap.MarkerClusterEventType, AMap.MarkerCluster>;
+interface MarkerClusterExtraInitOptions {
+    /**
+     * 点标记聚合数据项
+     */
+    data: AMap.MarkerClusterDataOptions[];
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map;
+}
+type MarkerClusterInitOptions = AMap.MarkerClusterOptions & MarkerClusterExtraInitOptions & Instance<AMap.MarkerCluster>;
+export type MarkerClusterProps = MarkerClusterInitOptions & MarkerClusterEvents;
+declare const MarkerCluster: import("svelte").Component<MarkerClusterProps, {}, "instance">;
+type MarkerCluster = ReturnType<typeof MarkerCluster>;
+export default MarkerCluster;

package/dist/overlay/mass-marks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as MassMarks } from './mass-marks.svelte';
+export type { MassMarksProps } from './mass-marks.svelte';

package/dist/overlay/mass-marks/index.js

@@ -0,0 +1 @@
+export { default as MassMarks } from './mass-marks.svelte';

package/dist/overlay/mass-marks/mass-marks.svelte

@@ -0,0 +1,110 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import {
+    click,
+    complete,
+    dblClick,
+    mouseDown,
+    mouseMove,
+    mouseOut,
+    mouseOver,
+    mouseUp,
+    touchEnd,
+    touchStart,
+  } from '@cn-map/gaode-shared/const'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy, untrack } from 'svelte'
+  import { createEventListeners } from '../../hooks/index.js'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+
+  type MassMarksEvents = MapEventProps<AMap.MassMarksEventType, AMap.MassMarks>
+  interface MassMarksExtraInitOptions {
+    /**
+     * 海量点数据参数
+     */
+    data: AMap.MassMarksDataOptions[]
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map
+  }
+  type MassMarksInitOptions = AMap.MassMarksOptions & MassMarksExtraInitOptions & Instance<AMap.MassMarks>
+
+  export type MassMarksProps = MassMarksInitOptions & MassMarksEvents
+
+  const massMarksEvents: AMap.MassMarksEventType[] = [
+    click,
+    complete,
+    dblClick,
+    mouseDown,
+    mouseMove,
+    mouseOut,
+    mouseOver,
+    mouseUp,
+    touchEnd,
+    touchStart,
+  ]
+
+  let { instance = $bindable(), data, ...props }: MassMarksProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(massMarksEvents))
+
+  const massMarks = $state.raw<AMap.MassMarks>(new AMap.MassMarks(snapshot(untrack(() => data)), snapshot(restProps)))
+
+  $effect(() => {
+    instance = massMarks
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    massMarks.setMap(map)
+
+    return () => {
+      massMarks.setMap(null)
+    }
+  })
+
+  $effect(() => {
+    massMarks.setData(snapshot(data))
+  })
+
+  $effect(() => {
+    if (restProps.opacity !== undefined) {
+      massMarks.setOpacity(restProps.opacity)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.style !== undefined) {
+      massMarks.setStyle(snapshot(restProps.style))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.zIndex !== undefined) {
+      massMarks.setzIndex(restProps.zIndex)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.zooms !== undefined) {
+      massMarks.setZooms(snapshot(restProps.zooms))
+    }
+  })
+
+  createEventListeners<AMap.MassMarksEventType, AMap.MassMarks>(
+    () => massMarks,
+    () => props,
+    massMarksEvents
+  )
+
+  onDestroy(() => massMarks.clear())
+</script>

package/dist/overlay/mass-marks/mass-marks.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+type MassMarksEvents = MapEventProps<AMap.MassMarksEventType, AMap.MassMarks>;
+interface MassMarksExtraInitOptions {
+    /**
+     * 海量点数据参数
+     */
+    data: AMap.MassMarksDataOptions[];
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map;
+}
+type MassMarksInitOptions = AMap.MassMarksOptions & MassMarksExtraInitOptions & Instance<AMap.MassMarks>;
+export type MassMarksProps = MassMarksInitOptions & MassMarksEvents;
+declare const MassMarks: import("svelte").Component<MassMarksProps, {}, "instance">;
+type MassMarks = ReturnType<typeof MassMarks>;
+export default MassMarks;

package/dist/overlay/overlay-group/index.d.ts

@@ -0,0 +1,2 @@
+export { default as OverlayGroup } from './overlay-group.svelte';
+export type { OverlayGroupProps } from './overlay-group.svelte';

package/dist/overlay/overlay-group/index.js

@@ -0,0 +1 @@
+export { default as OverlayGroup } from './overlay-group.svelte';

package/dist/overlay/overlay-group/overlay-group.svelte

@@ -0,0 +1,146 @@
+<script lang="ts" generics="ExtData">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import type { VectorOverlayExtraInitOptions } from '../vector-overlay'
+  import { eventsToProps, eventToProp, lowercase } from '@cn-map/gaode-shared/utils'
+  import { onDestroy, untrack } from 'svelte'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+  import { domOverlayEvents } from '../dom-overlay'
+  import { vectorOverlayEvents } from '../vector-overlay'
+
+  type OverlayGroupEvents<ExtData> = MapEventProps<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>
+  type OverlayGroupInitOptions<ExtData> = {
+    /**
+     * 覆盖物集合
+     */
+    overlays?: AMap.OverlayGroupOverlay<ExtData>[]
+  } & VectorOverlayExtraInitOptions
+    & Instance<AMap.OverlayGroup<ExtData>>
+
+  export type OverlayGroupProps<ExtData = any> = OverlayGroupInitOptions<ExtData> & OverlayGroupEvents<ExtData>
+
+  const overlayGroupEvents: AMap.OverlayGroupEventType[] = [...new Set([...vectorOverlayEvents, ...domOverlayEvents])]
+
+  let { instance = $bindable(), overlays, ...props }: OverlayGroupProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(overlayGroupEvents))
+
+  const overlayGroup = $state.raw<AMap.OverlayGroup<ExtData>>(new AMap.OverlayGroup(snapshot(untrack(() => overlays))))
+
+  $effect(() => {
+    instance = overlayGroup
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    map.add(overlayGroup)
+
+    return () => {
+      map.remove(overlayGroup)
+    }
+  })
+
+  $effect(() => {
+    if (!overlays) return
+
+    const current = new Set(overlayGroup.getOverlays() as AMap.OverlayGroupOverlay[])
+    const next = new Set(snapshot(overlays) as AMap.OverlayGroupOverlay[])
+    const toRemove = [...current].filter(o => !next.has(o))
+    const toAdd = [...next].filter(o => !current.has(o))
+
+    if (toRemove.length) overlayGroup.removeOverlays(toRemove)
+    if (toAdd.length) overlayGroup.addOverlays(toAdd)
+  })
+
+  $effect(() => {
+    if (restProps.visible !== undefined) {
+      if (restProps.visible) {
+        overlayGroup.show()
+      } else {
+        overlayGroup.hide()
+      }
+    }
+  })
+
+  // eslint-disable-next-line svelte/prefer-svelte-reactivity
+  const boundMap = new Map<
+    AMap.OverlayGroupOverlay<ExtData>,
+    Map<AMap.OverlayGroupEventType, AMap.EventCallback<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>>
+  >()
+
+  function dispose(): void {
+    for (const [overlay, handlerMap] of boundMap) {
+      for (const [eventType, handler] of handlerMap) {
+        // @ts-expect-error TS2349
+        overlay.off(lowercase(eventType), handler)
+      }
+
+      if ('destroy' in overlay && typeof overlay.destroy === 'function') {
+        overlay.destroy()
+      }
+    }
+    boundMap.clear()
+  }
+
+  $effect(() => {
+    const current = overlays
+
+    const nextOverlays = current ? [...new Set(current)] : []
+
+    const nextSet = new Set(nextOverlays)
+
+    for (const [overlay, handlerMap] of boundMap) {
+      if (!nextSet.has(overlay)) {
+        for (const [eventType, handler] of handlerMap) {
+          // @ts-expect-error TS2349
+          overlay.off(lowercase(eventType), handler)
+        }
+        boundMap.delete(overlay)
+
+        if ('destroy' in overlay && typeof overlay.destroy === 'function') {
+          overlay.destroy()
+        }
+      }
+    }
+
+    for (const overlay of nextOverlays) {
+      if (boundMap.has(overlay)) continue
+
+      const eventTypes: AMap.OverlayGroupEventType[] =
+        overlay instanceof AMap.Marker ? domOverlayEvents : vectorOverlayEvents
+
+      // eslint-disable-next-line svelte/prefer-svelte-reactivity
+      const handlerMap = new Map<
+        AMap.OverlayGroupEventType,
+        AMap.EventCallback<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>
+      >()
+
+      for (const eventType of eventTypes) {
+        const handler: AMap.EventCallback<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>> = event => {
+          const fn = props[eventToProp(eventType)] as
+            | AMap.EventCallback<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>
+            | undefined
+          fn?.(event)
+        }
+
+        // @ts-expect-error TS2349
+        overlay.on(lowercase(eventType), handler)
+        handlerMap.set(eventType, handler)
+      }
+
+      boundMap.set(overlay, handlerMap)
+    }
+  })
+
+  onDestroy(() => {
+    dispose()
+    overlayGroup.clearOverlays()
+  })
+</script>

package/dist/overlay/overlay-group/overlay-group.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+import type { VectorOverlayExtraInitOptions } from '../vector-overlay';
+type OverlayGroupEvents<ExtData> = MapEventProps<AMap.OverlayGroupEventType, AMap.OverlayGroupOverlay<ExtData>>;
+type OverlayGroupInitOptions<ExtData> = {
+    /**
+     * 覆盖物集合
+     */
+    overlays?: AMap.OverlayGroupOverlay<ExtData>[];
+} & VectorOverlayExtraInitOptions & Instance<AMap.OverlayGroup<ExtData>>;
+export type OverlayGroupProps<ExtData = any> = OverlayGroupInitOptions<ExtData> & OverlayGroupEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: OverlayGroupProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<ExtData> {
+    props(): ReturnType<typeof $$render<ExtData>>['props'];
+    events(): ReturnType<typeof $$render<ExtData>>['events'];
+    slots(): ReturnType<typeof $$render<ExtData>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <ExtData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<ExtData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<ExtData>['props']>, ReturnType<__sveltets_Render<ExtData>['events']>, ReturnType<__sveltets_Render<ExtData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<ExtData>['bindings']>;
+    } & ReturnType<__sveltets_Render<ExtData>['exports']>;
+    <ExtData>(internal: unknown, props: ReturnType<__sveltets_Render<ExtData>['props']> & {}): ReturnType<__sveltets_Render<ExtData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const OverlayGroup: $$IsomorphicComponent;
+type OverlayGroup<ExtData> = InstanceType<typeof OverlayGroup<ExtData>>;
+export default OverlayGroup;

package/dist/overlay/polygon/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Polygon } from './polygon.svelte';
+export type { PolygonProps } from './polygon.svelte';

package/dist/overlay/polygon/index.js

@@ -0,0 +1 @@
+export { default as Polygon } from './polygon.svelte';

package/dist/overlay/polygon/polygon.svelte

@@ -0,0 +1,83 @@
+<script lang="ts" generics="ExtData">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import type { VectorOverlayExtraInitOptions } from '../vector-overlay'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../hooks/index.js'
+  import { useVectorLayerInstance } from '../../layer/vector-layer'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+  import { useVectorOverlayAttributes, vectorOverlayEvents } from '../vector-overlay'
+
+  type PolygonEvents<ExtData> = MapEventProps<AMap.PolygonEventType, AMap.Polygon<ExtData>>
+  type PolygonInitOptions<ExtData = any> = AMap.PolygonOptions<ExtData>
+    & VectorOverlayExtraInitOptions
+    & Instance<AMap.Polygon<ExtData>>
+
+  export type PolygonProps<ExtData = any> = PolygonInitOptions<ExtData> & PolygonEvents<ExtData>
+
+  const polygonEvents: AMap.PolygonEventType[] = vectorOverlayEvents
+
+  let { instance = $bindable(), ...props }: PolygonProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(polygonEvents))
+
+  const polygon = $state.raw<AMap.Polygon<ExtData>>(new AMap.Polygon(snapshot(restProps)))
+
+  $effect(() => {
+    instance = polygon
+
+    return () => {
+      instance = null
+    }
+  })
+
+  const getVectorLayer = useVectorLayerInstance()
+
+  $effect(() => {
+    const vectorLayer = getVectorLayer()
+    if (vectorLayer) {
+      vectorLayer.add(polygon)
+
+      return () => {
+        vectorLayer.remove(polygon)
+      }
+    } else {
+      if (!map) return
+
+      map.add(polygon)
+
+      return () => {
+        map.remove(polygon)
+      }
+    }
+  })
+
+  useVectorOverlayAttributes(() => polygon, restProps)
+
+  const rest = omitProps(() => restProps, ['draggable', 'extData', 'visible', 'extrusionHeight', 'path'])
+
+  $effect(() => {
+    if (restProps.extrusionHeight !== undefined) {
+      polygon.setExtrusionHeight(restProps.extrusionHeight)
+    }
+  })
+
+  $effect(() => {
+    polygon.setOptions(snapshot(rest))
+  })
+
+  $effect(() => {
+    polygon.setPath(snapshot(restProps.path))
+  })
+
+  createEventListeners<AMap.PolygonEventType, AMap.Polygon<ExtData>>(
+    () => polygon,
+    () => props,
+    polygonEvents
+  )
+
+  onDestroy(() => polygon.destroy())
+</script>

package/dist/overlay/polygon/polygon.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+import type { VectorOverlayExtraInitOptions } from '../vector-overlay';
+type PolygonEvents<ExtData> = MapEventProps<AMap.PolygonEventType, AMap.Polygon<ExtData>>;
+type PolygonInitOptions<ExtData = any> = AMap.PolygonOptions<ExtData> & VectorOverlayExtraInitOptions & Instance<AMap.Polygon<ExtData>>;
+export type PolygonProps<ExtData = any> = PolygonInitOptions<ExtData> & PolygonEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: PolygonProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<ExtData> {
+    props(): ReturnType<typeof $$render<ExtData>>['props'];
+    events(): ReturnType<typeof $$render<ExtData>>['events'];
+    slots(): ReturnType<typeof $$render<ExtData>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <ExtData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<ExtData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<ExtData>['props']>, ReturnType<__sveltets_Render<ExtData>['events']>, ReturnType<__sveltets_Render<ExtData>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<ExtData>['bindings']>;
+    } & ReturnType<__sveltets_Render<ExtData>['exports']>;
+    <ExtData>(internal: unknown, props: ReturnType<__sveltets_Render<ExtData>['props']> & {}): ReturnType<__sveltets_Render<ExtData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Polygon: $$IsomorphicComponent;
+type Polygon<ExtData> = InstanceType<typeof Polygon<ExtData>>;
+export default Polygon;

package/dist/overlay/polyline/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Polyline } from './polyline.svelte';
+export type { PolylineProps } from './polyline.svelte';

package/dist/overlay/polyline/index.js

@@ -0,0 +1 @@
+export { default as Polyline } from './polyline.svelte';