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

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

@@ -0,0 +1,85 @@
+<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 CircleMarkerEvents<ExtData> = MapEventProps<AMap.CircleMarkerEventType, AMap.CircleMarker<ExtData>>
+  type CircleMarkerInitOptions<ExtData> = AMap.CircleMarkerOptions<ExtData>
+    & VectorOverlayExtraInitOptions
+    & Instance<AMap.CircleMarker<ExtData>>
+
+  export type CircleMarkerProps<ExtData = any> = CircleMarkerInitOptions<ExtData> & CircleMarkerEvents<ExtData>
+
+  const circleMarkerEvents: AMap.CircleMarkerEventType[] = vectorOverlayEvents
+
+  let { instance = $bindable(), ...props }: CircleMarkerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(circleMarkerEvents))
+
+  const circleMarker = $state.raw<AMap.CircleMarker<ExtData>>(new AMap.CircleMarker(snapshot(restProps)))
+
+  $effect(() => {
+    instance = circleMarker
+
+    return () => {
+      instance = null
+    }
+  })
+
+  const getVectorLayer = useVectorLayerInstance()
+
+  $effect(() => {
+    const vectorLayer = getVectorLayer()
+    if (vectorLayer) {
+      vectorLayer.add(circleMarker)
+
+      return () => {
+        vectorLayer.remove(circleMarker)
+      }
+    } else {
+      if (!map) return
+
+      map.add(circleMarker)
+
+      return () => {
+        map.remove(circleMarker)
+      }
+    }
+  })
+
+  useVectorOverlayAttributes(() => circleMarker, restProps)
+
+  const rest = omitProps(() => restProps, ['draggable', 'extData', 'visible', 'center', 'radius'])
+
+  $effect(() => {
+    if (restProps.center !== undefined) {
+      circleMarker.setCenter(snapshot(restProps.center))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.radius !== undefined) {
+      circleMarker.setRadius(restProps.radius)
+    }
+  })
+
+  $effect(() => {
+    circleMarker.setOptions(snapshot(rest))
+  })
+
+  createEventListeners<AMap.CircleMarkerEventType, AMap.CircleMarker<ExtData>>(
+    () => circleMarker,
+    () => props,
+    circleMarkerEvents
+  )
+
+  onDestroy(() => circleMarker.destroy())
+</script>

package/dist/overlay/circle-marker/circle-marker.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 CircleMarkerEvents<ExtData> = MapEventProps<AMap.CircleMarkerEventType, AMap.CircleMarker<ExtData>>;
+type CircleMarkerInitOptions<ExtData> = AMap.CircleMarkerOptions<ExtData> & VectorOverlayExtraInitOptions & Instance<AMap.CircleMarker<ExtData>>;
+export type CircleMarkerProps<ExtData = any> = CircleMarkerInitOptions<ExtData> & CircleMarkerEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: CircleMarkerProps;
+    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 CircleMarker: $$IsomorphicComponent;
+type CircleMarker<ExtData> = InstanceType<typeof CircleMarker<ExtData>>;
+export default CircleMarker;

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

@@ -0,0 +1,2 @@
+export { default as CircleMarker } from './circle-marker.svelte';
+export type { CircleMarkerProps } from './circle-marker.svelte';

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

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

package/dist/overlay/context-menu/context-menu.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Snippet } from 'svelte'
+  import type { Instance } from '../../types/index.js'
+  import { close, open } from '@cn-map/gaode-shared/const'
+  import { patchContextMenu } from '@cn-map/gaode-shared/patch'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../hooks/index.js'
+  import { omitProps, snapshot } from '../../utils/index.js'
+  import { CustomContent, useDOMOverlayAttributes } from '../dom-overlay'
+
+  type ContextMenuAttributes = Omit<ContextMenuInitOptions, 'map' | 'instance'>
+  type ContextMenuEvents = MapEventProps<AMap.ContextMenuEventType, AMap.ContextMenu>
+  type ContextMenuInitOptions = AMap.ContextMenuOptions & Instance<AMap.ContextMenu>
+
+  export type ContextMenuProps = ContextMenuInitOptions & ContextMenuEvents & { children?: Snippet }
+
+  const contextMenuEvents: AMap.ContextMenuEventType[] = [close, open]
+
+  let { instance = $bindable(), children, ...props }: ContextMenuProps = $props()
+
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(contextMenuEvents))
+
+  const contextMenu = $state.raw<AMap.ContextMenu>(new AMap.ContextMenu(snapshot(restProps)))
+
+  $effect(() => {
+    instance = contextMenu
+
+    return () => {
+      instance = null
+    }
+  })
+
+  patchContextMenu()
+
+  useDOMOverlayAttributes<AMap.ContextMenu, ContextMenuAttributes, AMap.ContextMenuEventType>(
+    () => contextMenu,
+    restProps,
+    () => children
+  )
+
+  createEventListeners<AMap.ContextMenuEventType, AMap.ContextMenu>(
+    () => contextMenu,
+    () => props,
+    contextMenuEvents
+  )
+
+  onDestroy(() => {
+    if (contextMenu?._parent?._container?.contains(contextMenu.getContentDom())) {
+      contextMenu.remove()
+    }
+    contextMenu.destroy()
+  })
+</script>
+
+{#if children}
+  <CustomContent instance={contextMenu}>
+    {@render children()}
+  </CustomContent>
+{/if}

package/dist/overlay/context-menu/context-menu.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Snippet } from 'svelte';
+import type { Instance } from '../../types/index.ts';
+type ContextMenuEvents = MapEventProps<AMap.ContextMenuEventType, AMap.ContextMenu>;
+type ContextMenuInitOptions = AMap.ContextMenuOptions & Instance<AMap.ContextMenu>;
+export type ContextMenuProps = ContextMenuInitOptions & ContextMenuEvents & {
+    children?: Snippet;
+};
+declare const ContextMenu: import("svelte").Component<ContextMenuProps, {}, "instance">;
+type ContextMenu = ReturnType<typeof ContextMenu>;
+export default ContextMenu;

package/dist/overlay/context-menu/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ContextMenu } from './context-menu.svelte';
+export type { ContextMenuProps } from './context-menu.svelte';

package/dist/overlay/context-menu/index.js

@@ -0,0 +1 @@
+export { default as ContextMenu } from './context-menu.svelte';

package/dist/overlay/dom-overlay/custom-content.svelte

@@ -0,0 +1,38 @@
+<script
+  lang="ts"
+  generics="T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text"
+>
+  import type { Snippet } from 'svelte'
+  import { untrack } from 'svelte'
+  import Portal from './portal.svelte'
+
+  const {
+    instance,
+    children,
+  }: {
+    instance: T
+    children: Snippet
+  } = $props()
+
+  const dom = document.createElement('div')
+
+  untrack(() => instance).setContent(dom)
+
+  $effect(() => {
+    // 监听 DOM 尺寸变化，重新调用 setContent 以更新锚点位置
+    const resizeObserver = new ResizeObserver(() => {
+      instance.setContent(dom)
+    })
+
+    resizeObserver.observe(dom)
+
+    return () => {
+      resizeObserver.disconnect()
+      dom.remove()
+    }
+  })
+</script>
+
+<Portal target={dom}>
+  {@render children()}
+</Portal>

package/dist/overlay/dom-overlay/custom-content.svelte.d.ts

@@ -0,0 +1,28 @@
+import type { Snippet } from 'svelte';
+declare function $$render<T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text>(): {
+    props: {
+        instance: T;
+        children: Snippet;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const CustomContent: $$IsomorphicComponent;
+type CustomContent<T extends AMap.InfoWindow | AMap.ContextMenu | AMap.Marker | AMap.ElasticMarker | AMap.Text> = InstanceType<typeof CustomContent<T>>;
+export default CustomContent;

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

@@ -0,0 +1,6 @@
+import type { Accessor } from '@cn-map/gaode-shared/types';
+import type { Snippet } from 'svelte';
+export type DOMOverlayAttributes = Omit<DOMOverlayInitOptions, 'map'>;
+export type DOMOverlayInitOptions = AMap.DOMOverlayOptions;
+export declare const domOverlayEvents: AMap.DOMOverlayEventType[];
+export declare function useDOMOverlayAttributes<O extends AMap.DOMOverlay<any, P, E>, P extends DOMOverlayAttributes, E extends AMap.EventType = AMap.DOMOverlayEventType>(overlay: Accessor<O>, props: P, children?: Accessor<Snippet | undefined>): void;

package/dist/overlay/dom-overlay/dom-overlay.svelte.js

@@ -0,0 +1,68 @@
+import { click, dblClick, dragEnd, dragging, dragStart, mouseDown, mouseMove, mouseOut, mouseOver, mouseUp, moveAlong, moveEnd, moveStart, moving, rightClick, touchEnd, touchMove, touchStart, } from '@cn-map/gaode-shared/const';
+import { snapshot } from "../../utils/index.js";
+export const domOverlayEvents = [
+    click,
+    dblClick,
+    rightClick,
+    dragStart,
+    dragging,
+    dragEnd,
+    mouseDown,
+    mouseUp,
+    mouseOver,
+    mouseOut,
+    mouseMove,
+    moveStart,
+    moveAlong,
+    moveEnd,
+    moving,
+    touchStart,
+    touchMove,
+    touchEnd,
+];
+export function useDOMOverlayAttributes(overlay, props, children) {
+    $effect(() => {
+        overlay().setAnchor(props.anchor);
+    });
+    $effect(() => {
+        if (!children || children() == null) {
+            overlay().setContent(props.content);
+        }
+    });
+    $effect(() => {
+        overlay().setOffset(snapshot(props.offset));
+    });
+    $effect(() => {
+        overlay().setOrientation(props.orientation);
+    });
+    $effect(() => {
+        if (props.position !== undefined) {
+            overlay().setPosition(snapshot(props.position));
+        }
+    });
+    $effect(() => {
+        if (props.rotate !== undefined) {
+            overlay().setAngle(props.rotate);
+        }
+    });
+    $effect(() => {
+        if (props.size !== undefined) {
+            overlay().setSize(snapshot(props.size));
+        }
+    });
+    $effect(() => {
+        if (props.visible !== undefined) {
+            if (props.visible) {
+                overlay().show();
+            }
+            else {
+                overlay().hide();
+            }
+        }
+    });
+    $effect(() => {
+        if (props.zIndex !== undefined) {
+            overlay().setzIndex(props.zIndex);
+        }
+    });
+}

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

@@ -0,0 +1,4 @@
+export { default as CustomContent } from './custom-content.svelte';
+export { domOverlayEvents, useDOMOverlayAttributes } from './dom-overlay.svelte';
+export type { DOMOverlayAttributes, DOMOverlayInitOptions } from './dom-overlay.svelte';
+export { default as Portal } from './portal.svelte';

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

@@ -0,0 +1,3 @@
+export { default as CustomContent } from './custom-content.svelte';
+export { domOverlayEvents, useDOMOverlayAttributes } from './dom-overlay.svelte';
+export { default as Portal } from './portal.svelte';

package/dist/overlay/dom-overlay/portal-consumer.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+
+  const { children }: { children?: Snippet } = $props()
+</script>
+
+{#if children}
+  {@render children()}
+{/if}

package/dist/overlay/dom-overlay/portal-consumer.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+};
+declare const PortalConsumer: import("svelte").Component<$$ComponentProps, {}, "">;
+type PortalConsumer = ReturnType<typeof PortalConsumer>;
+export default PortalConsumer;

package/dist/overlay/dom-overlay/portal.svelte

@@ -0,0 +1,27 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+  import { getAllContexts, mount, unmount } from 'svelte'
+  import PortalConsumer from './portal-consumer.svelte'
+
+  const {
+    target = document.body,
+    children,
+  }: {
+    target: string | HTMLElement
+    children: Snippet
+  } = $props()
+
+  const context = getAllContexts()
+
+  $effect(() => {
+    const instance = mount(PortalConsumer, {
+      target: typeof target === 'string' ? (document.querySelector(target) ?? document.body) : target,
+      props: { children },
+      context,
+    })
+
+    return () => {
+      unmount(instance)
+    }
+  })
+</script>

package/dist/overlay/dom-overlay/portal.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    target: string | HTMLElement;
+    children: Snippet;
+};
+declare const Portal: import("svelte").Component<$$ComponentProps, {}, "">;
+type Portal = ReturnType<typeof Portal>;
+export default Portal;

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

@@ -0,0 +1,69 @@
+<script lang="ts" generics="ExtData">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import type { MarkerExtraInitOptions } from '../marker/use-attributes.svelte'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../hooks/index.js'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+  import { markerEvents, useMarkerAttributes } from '../marker/use-attributes.svelte'
+
+  type ElasticMarkerEvents<ExtData> = MapEventProps<AMap.ElasticMarkerEventType, AMap.ElasticMarker<ExtData>>
+  type ElasticMarkerInitOptions<ExtData> = AMap.ElasticMarkerOptions<ExtData>
+    & MarkerExtraInitOptions
+    & Instance<AMap.ElasticMarker<ExtData>>
+
+  export type ElasticMarkerProps<ExtData = any> = ElasticMarkerInitOptions<ExtData> & ElasticMarkerEvents<ExtData>
+
+  const elasticMarkerEvents: AMap.ElasticMarkerEventType[] = markerEvents
+
+  let { instance = $bindable(), ...props }: ElasticMarkerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(elasticMarkerEvents))
+
+  const elasticMarker = $state.raw<AMap.ElasticMarker<ExtData>>(new AMap.ElasticMarker(snapshot(restProps)))
+
+  $effect(() => {
+    instance = elasticMarker
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    map.add(elasticMarker)
+
+    return () => {
+      map.remove(elasticMarker)
+    }
+  })
+
+  const rest = omitProps(() => restProps, 'styles', 'zoomStyleMapping')
+
+  useMarkerAttributes<ExtData>(() => elasticMarker as unknown as AMap.Marker<ExtData>, rest)
+
+  $effect(() => {
+    if (restProps.zoomStyleMapping !== undefined) {
+      elasticMarker.setMapping(snapshot(restProps.zoomStyleMapping))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.styles !== undefined) {
+      elasticMarker.setStyle(snapshot(restProps.styles))
+    }
+  })
+
+  createEventListeners<AMap.ElasticMarkerEventType, AMap.ElasticMarker<ExtData>>(
+    () => elasticMarker,
+    () => props,
+    elasticMarkerEvents
+  )
+
+  onDestroy(() => elasticMarker.destroy())
+</script>

package/dist/overlay/elastic-marker/elastic-marker.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 { MarkerExtraInitOptions } from '../marker/use-attributes.svelte';
+type ElasticMarkerEvents<ExtData> = MapEventProps<AMap.ElasticMarkerEventType, AMap.ElasticMarker<ExtData>>;
+type ElasticMarkerInitOptions<ExtData> = AMap.ElasticMarkerOptions<ExtData> & MarkerExtraInitOptions & Instance<AMap.ElasticMarker<ExtData>>;
+export type ElasticMarkerProps<ExtData = any> = ElasticMarkerInitOptions<ExtData> & ElasticMarkerEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: ElasticMarkerProps;
+    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 ElasticMarker: $$IsomorphicComponent;
+type ElasticMarker<ExtData> = InstanceType<typeof ElasticMarker<ExtData>>;
+export default ElasticMarker;

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

@@ -0,0 +1,2 @@
+export { default as ElasticMarker } from './elastic-marker.svelte';
+export type { ElasticMarkerProps } from './elastic-marker.svelte';

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

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

package/dist/overlay/ellipse/ellipse.svelte

@@ -0,0 +1,85 @@
+<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 EllipseEvents<ExtData> = MapEventProps<AMap.EllipseEventType, AMap.Ellipse<ExtData>>
+  type EllipseInitOptions<ExtData = any> = AMap.EllipseOptions<ExtData>
+    & VectorOverlayExtraInitOptions
+    & Instance<AMap.Ellipse<ExtData>>
+
+  export type EllipseProps<ExtData = any> = EllipseInitOptions<ExtData> & EllipseEvents<ExtData>
+
+  const ellipseEvents: AMap.EllipseEventType[] = vectorOverlayEvents
+
+  let { instance = $bindable(), ...props }: EllipseProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(ellipseEvents))
+
+  const ellipse = $state.raw<AMap.Ellipse<ExtData>>(new AMap.Ellipse(snapshot(restProps)))
+
+  $effect(() => {
+    instance = ellipse
+
+    return () => {
+      instance = null
+    }
+  })
+
+  const getVectorLayer = useVectorLayerInstance()
+
+  $effect(() => {
+    const vectorLayer = getVectorLayer()
+    if (vectorLayer) {
+      vectorLayer.add(ellipse)
+
+      return () => {
+        vectorLayer.remove(ellipse)
+      }
+    } else {
+      if (!map) return
+
+      map.add(ellipse)
+
+      return () => {
+        map.remove(ellipse)
+      }
+    }
+  })
+
+  useVectorOverlayAttributes(() => ellipse, restProps)
+
+  const rest = omitProps(() => restProps, ['draggable', 'extData', 'visible', 'center', 'radius'])
+
+  $effect(() => {
+    if (restProps.center !== undefined) {
+      ellipse.setCenter(snapshot(restProps.center))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.radius !== undefined) {
+      ellipse.setRadius(restProps.radius)
+    }
+  })
+
+  $effect(() => {
+    ellipse.setOptions(snapshot(rest))
+  })
+
+  createEventListeners<AMap.EllipseEventType, AMap.Ellipse<ExtData>>(
+    () => ellipse,
+    () => props,
+    ellipseEvents
+  )
+
+  onDestroy(() => ellipse.destroy())
+</script>

package/dist/overlay/ellipse/ellipse.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 EllipseEvents<ExtData> = MapEventProps<AMap.EllipseEventType, AMap.Ellipse<ExtData>>;
+type EllipseInitOptions<ExtData = any> = AMap.EllipseOptions<ExtData> & VectorOverlayExtraInitOptions & Instance<AMap.Ellipse<ExtData>>;
+export type EllipseProps<ExtData = any> = EllipseInitOptions<ExtData> & EllipseEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: EllipseProps;
+    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 Ellipse: $$IsomorphicComponent;
+type Ellipse<ExtData> = InstanceType<typeof Ellipse<ExtData>>;
+export default Ellipse;

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

@@ -0,0 +1,2 @@
+export { default as Ellipse } from './ellipse.svelte';
+export type { EllipseProps } from './ellipse.svelte';

package/dist/overlay/ellipse/index.js

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