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

package/dist/overlay/polyline/polyline.svelte

@@ -0,0 +1,77 @@
+<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 PolylineEvents<ExtData> = MapEventProps<AMap.PolylineEventType, AMap.Polyline<ExtData>>
+  type PolylineInitOptions<ExtData = any> = AMap.PolylineOptions<ExtData>
+    & VectorOverlayExtraInitOptions
+    & Instance<AMap.Polyline<ExtData>>
+
+  export type PolylineProps<ExtData = any> = PolylineInitOptions<ExtData> & PolylineEvents<ExtData>
+
+  const polylineEvents: AMap.PolylineEventType[] = vectorOverlayEvents
+
+  let { instance = $bindable(), ...props }: PolylineProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(polylineEvents))
+
+  const polyline = $state.raw<AMap.Polyline<ExtData>>(new AMap.Polyline(snapshot(restProps)))
+
+  $effect(() => {
+    instance = polyline
+
+    return () => {
+      instance = null
+    }
+  })
+
+  const getVectorLayer = useVectorLayerInstance()
+
+  $effect(() => {
+    const vectorLayer = getVectorLayer()
+    if (vectorLayer) {
+      vectorLayer.add(polyline)
+
+      return () => {
+        vectorLayer.remove(polyline)
+      }
+    } else {
+      if (!map) return
+
+      map.add(polyline)
+
+      return () => {
+        map.remove(polyline)
+      }
+    }
+  })
+
+  useVectorOverlayAttributes(() => polyline, restProps)
+
+  const rest = omitProps(() => restProps, ['draggable', 'extData', 'visible', 'height', 'path'])
+
+  $effect(() => {
+    polyline.setOptions(snapshot(rest))
+  })
+
+  $effect(() => {
+    polyline.setPath(snapshot(restProps.path))
+  })
+
+  createEventListeners<AMap.PolylineEventType, AMap.Polyline<ExtData>>(
+    () => polyline,
+    () => props,
+    polylineEvents
+  )
+
+  onDestroy(() => polyline.destroy())
+</script>

package/dist/overlay/polyline/polyline.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 PolylineEvents<ExtData> = MapEventProps<AMap.PolylineEventType, AMap.Polyline<ExtData>>;
+type PolylineInitOptions<ExtData = any> = AMap.PolylineOptions<ExtData> & VectorOverlayExtraInitOptions & Instance<AMap.Polyline<ExtData>>;
+export type PolylineProps<ExtData = any> = PolylineInitOptions<ExtData> & PolylineEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: PolylineProps;
+    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 Polyline: $$IsomorphicComponent;
+type Polyline<ExtData> = InstanceType<typeof Polyline<ExtData>>;
+export default Polyline;

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

@@ -0,0 +1,2 @@
+export { default as Rectangle } from './rectangle.svelte';
+export type { RectangleProps } from './rectangle.svelte';

package/dist/overlay/rectangle/index.js

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

package/dist/overlay/rectangle/rectangle.svelte

@@ -0,0 +1,77 @@
+<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 RectangleEvents<ExtData> = MapEventProps<AMap.RectangleEventType, AMap.Rectangle<ExtData>>
+  type RectangleInitOptions<ExtData = any> = AMap.RectangleOptions<ExtData>
+    & VectorOverlayExtraInitOptions
+    & Instance<AMap.Rectangle<ExtData>>
+
+  export type RectangleProps<ExtData = any> = RectangleInitOptions<ExtData> & RectangleEvents<ExtData>
+
+  const rectangleEvents: AMap.RectangleEventType[] = vectorOverlayEvents
+
+  let { instance = $bindable(), ...props }: RectangleProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(rectangleEvents))
+
+  const rectangle = $state.raw<AMap.Rectangle<ExtData>>(new AMap.Rectangle(snapshot(restProps)))
+
+  $effect(() => {
+    instance = rectangle
+
+    return () => {
+      instance = null
+    }
+  })
+
+  const getVectorLayer = useVectorLayerInstance()
+
+  $effect(() => {
+    const vectorLayer = getVectorLayer()
+    if (vectorLayer) {
+      vectorLayer.add(rectangle)
+
+      return () => {
+        vectorLayer.remove(rectangle)
+      }
+    } else {
+      if (!map) return
+
+      map.add(rectangle)
+
+      return () => {
+        map.remove(rectangle)
+      }
+    }
+  })
+
+  useVectorOverlayAttributes(() => rectangle, restProps)
+
+  const rest = omitProps(() => restProps, ['draggable', 'extData', 'visible', 'bounds'])
+
+  $effect(() => {
+    rectangle.setOptions(snapshot(rest))
+  })
+
+  $effect(() => {
+    rectangle.setBounds(restProps.bounds)
+  })
+
+  createEventListeners<AMap.RectangleEventType, AMap.Rectangle<ExtData>>(
+    () => rectangle,
+    () => props,
+    rectangleEvents
+  )
+
+  onDestroy(() => rectangle.destroy())
+</script>

package/dist/overlay/rectangle/rectangle.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 RectangleEvents<ExtData> = MapEventProps<AMap.RectangleEventType, AMap.Rectangle<ExtData>>;
+type RectangleInitOptions<ExtData = any> = AMap.RectangleOptions<ExtData> & VectorOverlayExtraInitOptions & Instance<AMap.Rectangle<ExtData>>;
+export type RectangleProps<ExtData = any> = RectangleInitOptions<ExtData> & RectangleEvents<ExtData>;
+declare function $$render<ExtData>(): {
+    props: RectangleProps;
+    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 Rectangle: $$IsomorphicComponent;
+type Rectangle<ExtData> = InstanceType<typeof Rectangle<ExtData>>;
+export default Rectangle;

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

@@ -0,0 +1,2 @@
+export { default as Text } from './text.svelte';
+export type { TextProps } from './text.svelte';

package/dist/overlay/text/index.js

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

package/dist/overlay/text/text.svelte

@@ -0,0 +1,81 @@
+<script lang="ts" generics="ExtData">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Snippet } from 'svelte'
+  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 { CustomContent } from '../dom-overlay'
+  import { markerEvents, useMarkerAttributes } from '../marker/use-attributes.svelte'
+
+  type TextEvents<ExtData> = MapEventProps<AMap.TextEventType, AMap.Text<ExtData>>
+  type TextInitOptions<ExtData> = AMap.TextOptions<ExtData> & MarkerExtraInitOptions & Instance<AMap.Text<ExtData>>
+
+  export type TextProps<ExtData = any> = TextInitOptions<ExtData> & TextEvents<ExtData> & { children?: Snippet }
+
+  const textEvents: AMap.TextEventType[] = markerEvents
+
+  let { instance = $bindable(), children, ...props }: TextProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(textEvents))
+
+  const text = $state.raw<AMap.Text<ExtData>>(new AMap.Text(snapshot(restProps)))
+
+  $effect(() => {
+    instance = text
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    map.add(text)
+
+    return () => {
+      map.remove(text)
+    }
+  })
+
+  const rest = omitProps(() => restProps, 'style', 'text')
+
+  useMarkerAttributes<ExtData>(
+    () => text as unknown as AMap.Marker<ExtData>,
+    rest,
+    () => children
+  )
+
+  $effect(() => {
+    if (restProps.style !== undefined) {
+      text.setStyle(snapshot(restProps.style))
+    }
+  })
+
+  $effect(() => {
+    if (children != null || restProps.content != null) return
+
+    if (restProps.text !== undefined) {
+      text.setText(snapshot(restProps.text))
+    }
+  })
+
+  createEventListeners<AMap.TextEventType, AMap.Text<ExtData>>(
+    () => text,
+    () => props,
+    textEvents
+  )
+
+  onDestroy(() => text.destroy())
+</script>
+
+{#if children}
+  <CustomContent instance={text}>
+    {@render children()}
+  </CustomContent>
+{/if}

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

@@ -0,0 +1,33 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Snippet } from 'svelte';
+import type { Instance } from '../../types/index.ts';
+import type { MarkerExtraInitOptions } from '../marker/use-attributes.svelte';
+type TextEvents<ExtData> = MapEventProps<AMap.TextEventType, AMap.Text<ExtData>>;
+type TextInitOptions<ExtData> = AMap.TextOptions<ExtData> & MarkerExtraInitOptions & Instance<AMap.Text<ExtData>>;
+export type TextProps<ExtData = any> = TextInitOptions<ExtData> & TextEvents<ExtData> & {
+    children?: Snippet;
+};
+declare function $$render<ExtData>(): {
+    props: TextProps;
+    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 Text: $$IsomorphicComponent;
+type Text<ExtData> = InstanceType<typeof Text<ExtData>>;
+export default Text;

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

@@ -0,0 +1,2 @@
+export { useVectorOverlayAttributes, vectorOverlayEvents } from './vector-overlay.svelte';
+export type { VectorOverlayAttributes, VectorOverlayExtraInitOptions, VectorOverlayInitOptions, } from './vector-overlay.svelte';

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

@@ -0,0 +1 @@
+export { useVectorOverlayAttributes, vectorOverlayEvents } from './vector-overlay.svelte';

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

@@ -0,0 +1,15 @@
+import type { Accessor } from '@cn-map/gaode-shared/types';
+export type VectorOverlayAttributes<ExtData = any> = Omit<VectorOverlayInitOptions<ExtData>, 'map'>;
+export interface VectorOverlayExtraInitOptions {
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map;
+    /**
+     * 是否可见
+     */
+    visible?: boolean;
+}
+export type VectorOverlayInitOptions<ExtData> = AMap.VectorOverlayOptions<ExtData> & VectorOverlayExtraInitOptions;
+export declare const vectorOverlayEvents: AMap.VectorOverlayEventType[];
+export declare function useVectorOverlayAttributes<O extends AMap.VectorOverlay<ExtData>, P extends VectorOverlayAttributes<ExtData>, ExtData = any>(overlay: Accessor<O>, props: P): void;

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

@@ -0,0 +1,39 @@
+import { click, dblClick, dragEnd, dragging, dragStart, hide, mouseDown, mouseOut, mouseOver, mouseUp, rightClick, show, touchEnd, touchMove, touchStart, } from '@cn-map/gaode-shared/const';
+import { snapshot } from "../../utils/index.js";
+export const vectorOverlayEvents = [
+    hide,
+    show,
+    click,
+    dblClick,
+    rightClick,
+    mouseDown,
+    mouseUp,
+    mouseOver,
+    mouseOut,
+    dragStart,
+    dragging,
+    dragEnd,
+    touchStart,
+    touchMove,
+    touchEnd,
+];
+export function useVectorOverlayAttributes(overlay, props) {
+    $effect(() => {
+        if (props.draggable !== undefined) {
+            overlay().setDraggable(props.draggable);
+        }
+    });
+    $effect(() => {
+        overlay().setExtData(snapshot(props.extData));
+    });
+    $effect(() => {
+        if (props.visible !== undefined) {
+            if (props.visible) {
+                overlay().show();
+            }
+            else {
+                overlay().hide();
+            }
+        }
+    });
+}

package/dist/tool/bezier-curve-editor/bezier-curve-editor.svelte

@@ -0,0 +1,109 @@
+<script lang="ts">
+  import type { AccessorLike, MapEventProps, Nullable } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import { add, addNode, adjust, end, removeNode } 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 { isAccessor, omitProps, snapshot } from '../../utils/index.js'
+
+  type BezierCurveEditorEvents = MapEventProps<AMap.BezierCurveEditorEventType, AMap.BezierCurveEditor>
+  interface BezierCurveEditorExtraInitOptions {
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map
+    /**
+     * 要编辑的贝塞尔曲线对象
+     */
+    target?: AccessorLike<Nullable<AMap.BezierCurve>>
+  }
+  type BezierCurveEditorInitOptions = AMap.BezierCurveEditorOptions
+    & BezierCurveEditorExtraInitOptions
+    & Instance<AMap.BezierCurveEditor>
+
+  export type BezierCurveEditorProps = BezierCurveEditorInitOptions & BezierCurveEditorEvents
+
+  const bezierCurveEditorEvents: AMap.BezierCurveEditorEventType[] = [add, end, adjust, addNode, removeNode]
+
+  let { instance = $bindable(), target, ...props }: BezierCurveEditorProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(bezierCurveEditorEvents))
+
+  const bezierCurve = $derived((isAccessor(target) ? target() : target) ?? undefined)
+  let bezierCurveEditor = $state.raw<Nullable<AMap.BezierCurveEditor>>(null)
+
+  $effect(() => {
+    instance = bezierCurveEditor
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (map) {
+      bezierCurveEditor = new AMap.BezierCurveEditor(
+        map,
+        untrack(() => bezierCurve),
+        snapshot(restProps)
+      )
+    }
+  })
+
+  $effect(() => {
+    bezierCurveEditor?.setTarget(bezierCurve)
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.createOptions && editor) {
+      editor._normalPolylineStyle = AMap.extend(editor._normalPolylineStyle, snapshot(restProps.createOptions))
+    }
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.editOptions && editor) {
+      editor._editingPolylineStyle = AMap.extend(editor._editingPolylineStyle, snapshot(restProps.editOptions))
+    }
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.controlPoint && editor) {
+      editor.opts.controlPoint = snapshot(restProps.controlPoint)
+    }
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.midControlPoint && editor) {
+      editor.opts.midControlPoint = snapshot(restProps.midControlPoint)
+    }
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.bezierControlPoint && editor) {
+      editor.opts.bezierControlPoint = snapshot(restProps.bezierControlPoint)
+    }
+  })
+
+  $effect(() => {
+    const editor = bezierCurveEditor
+    if (restProps.bezierControlLine && editor) {
+      editor.opts.bezierControlLine = AMap.extend(editor.opts.bezierControlLine, snapshot(restProps.bezierControlLine))
+    }
+  })
+
+  createEventListeners<AMap.BezierCurveEditorEventType, AMap.BezierCurveEditor>(
+    () => bezierCurveEditor,
+    () => props,
+    bezierCurveEditorEvents
+  )
+
+  onDestroy(() => bezierCurveEditor?.destroy())
+</script>

package/dist/tool/bezier-curve-editor/bezier-curve-editor.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { AccessorLike, MapEventProps, Nullable } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+type BezierCurveEditorEvents = MapEventProps<AMap.BezierCurveEditorEventType, AMap.BezierCurveEditor>;
+interface BezierCurveEditorExtraInitOptions {
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map;
+    /**
+     * 要编辑的贝塞尔曲线对象
+     */
+    target?: AccessorLike<Nullable<AMap.BezierCurve>>;
+}
+type BezierCurveEditorInitOptions = AMap.BezierCurveEditorOptions & BezierCurveEditorExtraInitOptions & Instance<AMap.BezierCurveEditor>;
+export type BezierCurveEditorProps = BezierCurveEditorInitOptions & BezierCurveEditorEvents;
+declare const BezierCurveEditor: import("svelte").Component<BezierCurveEditorProps, {}, "instance">;
+type BezierCurveEditor = ReturnType<typeof BezierCurveEditor>;
+export default BezierCurveEditor;

package/dist/tool/bezier-curve-editor/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BezierCurveEditor } from './bezier-curve-editor.svelte';
+export type { BezierCurveEditorProps } from './bezier-curve-editor.svelte';

package/dist/tool/bezier-curve-editor/index.js

@@ -0,0 +1 @@
+export { default as BezierCurveEditor } from './bezier-curve-editor.svelte';

package/dist/tool/circle-editor/circle-editor.svelte

@@ -0,0 +1,93 @@
+<script lang="ts">
+  import type { AccessorLike, MapEventProps, Nullable } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../types/index.js'
+  import { add, adjust, end, move } 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 { isAccessor, omitProps, snapshot } from '../../utils/index.js'
+
+  type CircleEditorEvents = MapEventProps<AMap.CircleEditorEventType, AMap.CircleEditor>
+  interface CircleEditorExtraInitOptions {
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map
+    /**
+     * 要编辑的圆对象
+     */
+    target?: AccessorLike<Nullable<AMap.Circle>>
+  }
+  type CircleEditorInitOptions = AMap.CircleEditorOptions & CircleEditorExtraInitOptions & Instance<AMap.CircleEditor>
+
+  export type CircleEditorProps = CircleEditorInitOptions & CircleEditorEvents
+
+  const circleEditorEvents: AMap.CircleEditorEventType[] = [add, end, adjust, move]
+
+  let { instance = $bindable(), target, ...props }: CircleEditorProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(circleEditorEvents))
+
+  const circle = $derived((isAccessor(target) ? target() : target) ?? undefined)
+  let circleEditor = $state.raw<Nullable<AMap.CircleEditor>>(null)
+
+  $effect(() => {
+    instance = circleEditor
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (map) {
+      circleEditor = new AMap.CircleEditor(
+        map,
+        untrack(() => circle),
+        snapshot(restProps)
+      )
+    }
+  })
+
+  $effect(() => {
+    circleEditor?.setTarget(circle)
+  })
+
+  $effect(() => {
+    const editor = circleEditor
+    if (restProps.createOptions && editor) {
+      editor._normalCircleStyle = AMap.extend(editor._normalCircleStyle, snapshot(restProps.createOptions))
+    }
+  })
+
+  $effect(() => {
+    const editor = circleEditor
+    if (restProps.editOptions && editor) {
+      editor._editStyle = AMap.extend(editor._editStyle, snapshot(restProps.editOptions))
+    }
+  })
+
+  $effect(() => {
+    const editor = circleEditor
+    if (restProps.movePoint && editor) {
+      editor._opts.movePoint = snapshot(restProps.movePoint)
+    }
+  })
+
+  $effect(() => {
+    const editor = circleEditor
+    if (restProps.resizePoint && editor) {
+      editor._opts.resizePoint = snapshot(restProps.resizePoint)
+    }
+  })
+
+  createEventListeners<AMap.CircleEditorEventType, AMap.CircleEditor>(
+    () => circleEditor,
+    () => props,
+    circleEditorEvents
+  )
+
+  onDestroy(() => circleEditor?.destroy())
+</script>

package/dist/tool/circle-editor/circle-editor.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { AccessorLike, MapEventProps, Nullable } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../types/index.ts';
+type CircleEditorEvents = MapEventProps<AMap.CircleEditorEventType, AMap.CircleEditor>;
+interface CircleEditorExtraInitOptions {
+    /**
+     * 地图对象
+     */
+    map?: AMap.Map;
+    /**
+     * 要编辑的圆对象
+     */
+    target?: AccessorLike<Nullable<AMap.Circle>>;
+}
+type CircleEditorInitOptions = AMap.CircleEditorOptions & CircleEditorExtraInitOptions & Instance<AMap.CircleEditor>;
+export type CircleEditorProps = CircleEditorInitOptions & CircleEditorEvents;
+declare const CircleEditor: import("svelte").Component<CircleEditorProps, {}, "instance">;
+type CircleEditor = ReturnType<typeof CircleEditor>;
+export default CircleEditor;

package/dist/tool/circle-editor/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CircleEditor } from './circle-editor.svelte';
+export type { CircleEditorProps } from './circle-editor.svelte';

package/dist/tool/circle-editor/index.js

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