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

package/dist/loca/layer/labels-layer/labels-layer.svelte

@@ -0,0 +1,74 @@
+<script lang="ts" generics="Properties">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import type { LayerExtraInitOptions } from '../layer'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type LabelsLayerEvents = MapEventProps<Loca.LabelsLayerEventType, Loca.LabelsLayer>
+  interface LabelsLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LabelsLayerStyle<Properties>
+  }
+  type LabelsLayerInitOptions<Properties = any> = Loca.LabelsLayerOptions
+    & LabelsLayerExtraInitProps<Properties>
+    & Instance<Loca.LabelsLayer<Properties>>
+
+  export type LabelsLayerProps<Properties = any> = LabelsLayerInitOptions<Properties> & LabelsLayerEvents
+
+  let { instance = $bindable(), ...props }: LabelsLayerProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+
+  const restProps = omitProps(() => props, 'loca', 'map', ...eventsToProps(layerEvents))
+
+  const labelsLayer = $state.raw<Loca.LabelsLayer<Properties>>(new Loca.LabelsLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = labelsLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.add(labelsLayer)
+
+    return () => {
+      loca.remove(labelsLayer)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.allowCollision !== undefined) {
+      labelsLayer.setAllowCollision(restProps.allowCollision)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.collision !== undefined) {
+      labelsLayer.setCollision(restProps.collision)
+    }
+  })
+
+  useLayerAttributes(() => labelsLayer, restProps)
+
+  createEventListeners<Loca.LabelsLayerEventType, Loca.LabelsLayer<Properties>>(
+    () => labelsLayer,
+    () => props,
+    layerEvents
+  )
+
+  onDestroy(() => {
+    labelsLayer.destroy()
+  })
+</script>

package/dist/loca/layer/labels-layer/labels-layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+import type { LayerExtraInitOptions } from '../layer';
+type LabelsLayerEvents = MapEventProps<Loca.LabelsLayerEventType, Loca.LabelsLayer>;
+interface LabelsLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LabelsLayerStyle<Properties>;
+}
+type LabelsLayerInitOptions<Properties = any> = Loca.LabelsLayerOptions & LabelsLayerExtraInitProps<Properties> & Instance<Loca.LabelsLayer<Properties>>;
+export type LabelsLayerProps<Properties = any> = LabelsLayerInitOptions<Properties> & LabelsLayerEvents;
+declare function $$render<Properties>(): {
+    props: LabelsLayerProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Properties> {
+    props(): ReturnType<typeof $$render<Properties>>['props'];
+    events(): ReturnType<typeof $$render<Properties>>['events'];
+    slots(): ReturnType<typeof $$render<Properties>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Properties>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Properties>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Properties>['props']>, ReturnType<__sveltets_Render<Properties>['events']>, ReturnType<__sveltets_Render<Properties>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Properties>['bindings']>;
+    } & ReturnType<__sveltets_Render<Properties>['exports']>;
+    <Properties>(internal: unknown, props: ReturnType<__sveltets_Render<Properties>['props']> & {}): ReturnType<__sveltets_Render<Properties>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const LabelsLayer: $$IsomorphicComponent;
+type LabelsLayer<Properties> = InstanceType<typeof LabelsLayer<Properties>>;
+export default LabelsLayer;

package/dist/loca/layer/laser-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LaserLayer } from './laser-layer.svelte';
+export type { LaserLayerProps } from './laser-layer.svelte';

package/dist/loca/layer/laser-layer/index.js

@@ -0,0 +1 @@
+export { default as LaserLayer } from './laser-layer.svelte';

package/dist/loca/layer/laser-layer/laser-layer.svelte

@@ -0,0 +1,62 @@
+<script lang="ts" generics="Properties">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import type { LayerExtraInitOptions } from '../layer'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type LaserLayerEvents = MapEventProps<Loca.LaserLayerEventType, Loca.LaserLayer>
+  interface LaserLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LaserLayerStyle<Properties>
+  }
+  type LaserLayerInitOptions<Properties = any> = Loca.LaserLayerOptions
+    & LaserLayerExtraInitProps<Properties>
+    & Instance<Loca.LaserLayer<Properties>>
+
+  export type LaserLayerProps<Properties = any> = LaserLayerInitOptions<Properties> & LaserLayerEvents
+
+  let { instance = $bindable(), ...props }: LaserLayerProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+
+  const restProps = omitProps(() => props, 'loca', 'map', ...eventsToProps(layerEvents))
+
+  const laserLayer = $state.raw<Loca.LaserLayer<Properties>>(new Loca.LaserLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = laserLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.add(laserLayer)
+
+    return () => {
+      loca.remove(laserLayer)
+    }
+  })
+
+  useLayerAttributes(() => laserLayer, restProps)
+
+  createEventListeners<Loca.LaserLayerEventType, Loca.LaserLayer<Properties>>(
+    () => laserLayer,
+    () => props,
+    layerEvents
+  )
+
+  onDestroy(() => {
+    laserLayer.destroy()
+  })
+</script>

package/dist/loca/layer/laser-layer/laser-layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+import type { LayerExtraInitOptions } from '../layer';
+type LaserLayerEvents = MapEventProps<Loca.LaserLayerEventType, Loca.LaserLayer>;
+interface LaserLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LaserLayerStyle<Properties>;
+}
+type LaserLayerInitOptions<Properties = any> = Loca.LaserLayerOptions & LaserLayerExtraInitProps<Properties> & Instance<Loca.LaserLayer<Properties>>;
+export type LaserLayerProps<Properties = any> = LaserLayerInitOptions<Properties> & LaserLayerEvents;
+declare function $$render<Properties>(): {
+    props: LaserLayerProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Properties> {
+    props(): ReturnType<typeof $$render<Properties>>['props'];
+    events(): ReturnType<typeof $$render<Properties>>['events'];
+    slots(): ReturnType<typeof $$render<Properties>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Properties>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Properties>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Properties>['props']>, ReturnType<__sveltets_Render<Properties>['events']>, ReturnType<__sveltets_Render<Properties>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Properties>['bindings']>;
+    } & ReturnType<__sveltets_Render<Properties>['exports']>;
+    <Properties>(internal: unknown, props: ReturnType<__sveltets_Render<Properties>['props']> & {}): ReturnType<__sveltets_Render<Properties>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const LaserLayer: $$IsomorphicComponent;
+type LaserLayer<Properties> = InstanceType<typeof LaserLayer<Properties>>;
+export default LaserLayer;

package/dist/loca/layer/layer/index.d.ts

@@ -0,0 +1,2 @@
+export { layerEvents, useLayerAttributes } from './layer.svelte';
+export type { LayerAttributes, LayerEvents, LayerExtraInitOptions, LayerInitOptions, LayerProps } from './layer.svelte';

package/dist/loca/layer/layer/index.js

@@ -0,0 +1 @@
+export { layerEvents, useLayerAttributes } from './layer.svelte';

package/dist/loca/layer/layer/layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { Accessor, MapEventProps, Nullable } from '@cn-map/gaode-shared/types';
+export type LayerAttributes = Omit<LayerInitOptions, 'loca' | 'map'>;
+export type LayerEvents<T extends Loca.Layer> = MapEventProps<Loca.LayerEventType, T>;
+export interface LayerExtraInitOptions<Properties = any> {
+    /**
+     * 数据源
+     */
+    source?: Nullable<Loca.GeoJSONSource<Properties> | Loca.GeoBufferSource<Properties>>;
+    /**
+     * 淡入淡出效果
+     */
+    duration?: {
+        /**
+         * 淡入效果，单位毫秒
+         * - 图层将会按照设置的时间将透明度从 0 过渡到 `opacity` 设置的值
+         */
+        show?: number;
+        /**
+         * 淡出效果，单位毫秒
+         * - 图层将会按照设置的时间将透明度从 `opacity` 的值过渡到 0
+         */
+        hide?: number;
+    };
+    /**
+     * 完全显示之后执行的回调函数
+     */
+    onShow?: () => void;
+    /**
+     * 完全隐藏之后执行的回调函数
+     */
+    onHide?: () => void;
+}
+export type LayerInitOptions = Loca.LayerOptions & LayerExtraInitOptions;
+export type LayerProps<T extends Loca.Layer> = LayerInitOptions & LayerEvents<T>;
+export declare const layerEvents: Loca.LayerEventType[];
+export declare function useLayerAttributes<L extends Loca.Layer, P extends LayerAttributes>(layer: Accessor<L>, props: P): void;

package/dist/loca/layer/layer/layer.svelte.js

@@ -0,0 +1,42 @@
+import { complete, loaded } from '@cn-map/gaode-shared/const';
+import { patchLocaLayer } from '@cn-map/gaode-shared/patch';
+import { useDataSourceInstance } from '../../source/data-source';
+import { snapshot } from "../../../utils/index.js";
+export const layerEvents = [complete, loaded];
+export function useLayerAttributes(layer, props) {
+    patchLocaLayer();
+    const source = $derived.by(useDataSourceInstance(() => props.source));
+    $effect(() => {
+        layer()?.setOpacity(props.opacity);
+    });
+    $effect(() => {
+        layer()?.setZooms(snapshot(props.zooms));
+    });
+    $effect(() => {
+        layer()?.setzIndex(props.zIndex);
+    });
+    $effect.pre(() => {
+        if (source) {
+            layer()?.setSource(source);
+        }
+        return () => {
+            layer()?.source?.Mr(layer());
+        };
+    });
+    $effect(() => {
+        if (props.style !== undefined) {
+            layer()?.setStyle(snapshot(props.style));
+        }
+    });
+    $effect(() => {
+        if (props.visible !== undefined && layer()?.visible !== props.visible) {
+            const instance = layer();
+            if (props.visible) {
+                instance?.show(props.duration?.show, props.onShow);
+            }
+            else {
+                instance?.hide(props.duration?.hide, props.onHide);
+            }
+        }
+    });
+}

package/dist/loca/layer/line-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LineLayer } from './line-layer.svelte';
+export type { LineLayerProps } from './line-layer.svelte';

package/dist/loca/layer/line-layer/index.js

@@ -0,0 +1 @@
+export { default as LineLayer } from './line-layer.svelte';

package/dist/loca/layer/line-layer/line-layer.svelte

@@ -0,0 +1,62 @@
+<script lang="ts" generics="Properties">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import type { LayerExtraInitOptions } from '../layer'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type LineLayerEvents<Properties = any> = MapEventProps<Loca.LineLayerEventType, Loca.LineLayer<Properties>>
+  interface LineLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LineLayerStyle<Properties>
+  }
+  type LineLayerInitOptions<Properties = any> = Loca.LineLayerOptions
+    & LineLayerExtraInitProps<Properties>
+    & Instance<Loca.LineLayer<Properties>>
+
+  export type LineLayerProps<Properties = any> = LineLayerInitOptions<Properties> & LineLayerEvents
+
+  let { instance = $bindable(), ...props }: LineLayerProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+
+  const restProps = omitProps(() => props, 'loca', 'map', ...eventsToProps(layerEvents))
+
+  const lineLayer = $state.raw<Loca.LineLayer<Properties>>(new Loca.LineLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = lineLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.add(lineLayer)
+
+    return () => {
+      loca.remove(lineLayer)
+    }
+  })
+
+  useLayerAttributes(() => lineLayer, restProps)
+
+  createEventListeners<Loca.LineLayerEventType, Loca.LineLayer<Properties>>(
+    () => lineLayer,
+    () => props,
+    layerEvents
+  )
+
+  onDestroy(() => {
+    lineLayer.destroy()
+  })
+</script>

package/dist/loca/layer/line-layer/line-layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+import type { LayerExtraInitOptions } from '../layer';
+type LineLayerEvents<Properties = any> = MapEventProps<Loca.LineLayerEventType, Loca.LineLayer<Properties>>;
+interface LineLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LineLayerStyle<Properties>;
+}
+type LineLayerInitOptions<Properties = any> = Loca.LineLayerOptions & LineLayerExtraInitProps<Properties> & Instance<Loca.LineLayer<Properties>>;
+export type LineLayerProps<Properties = any> = LineLayerInitOptions<Properties> & LineLayerEvents;
+declare function $$render<Properties>(): {
+    props: LineLayerProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Properties> {
+    props(): ReturnType<typeof $$render<Properties>>['props'];
+    events(): ReturnType<typeof $$render<Properties>>['events'];
+    slots(): ReturnType<typeof $$render<Properties>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Properties>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Properties>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Properties>['props']>, ReturnType<__sveltets_Render<Properties>['events']>, ReturnType<__sveltets_Render<Properties>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Properties>['bindings']>;
+    } & ReturnType<__sveltets_Render<Properties>['exports']>;
+    <Properties>(internal: unknown, props: ReturnType<__sveltets_Render<Properties>['props']> & {}): ReturnType<__sveltets_Render<Properties>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const LineLayer: $$IsomorphicComponent;
+type LineLayer<Properties> = InstanceType<typeof LineLayer<Properties>>;
+export default LineLayer;

package/dist/loca/layer/link-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as LinkLayer } from './link-layer.svelte';
+export type { LinkLayerProps } from './link-layer.svelte';

package/dist/loca/layer/link-layer/index.js

@@ -0,0 +1 @@
+export { default as LinkLayer } from './link-layer.svelte';

package/dist/loca/layer/link-layer/link-layer.svelte

@@ -0,0 +1,62 @@
+<script lang="ts" generics="Properties">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import type { LayerExtraInitOptions } from '../layer'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type LinkLayerEvents<Properties = any> = MapEventProps<Loca.LinkLayerEventType, Loca.LinkLayer<Properties>>
+  interface LinkLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LinkLayerStyle<Properties>
+  }
+  type LinkLayerInitOptions<Properties = any> = Loca.LinkLayerOptions
+    & LinkLayerExtraInitProps<Properties>
+    & Instance<Loca.LinkLayer<Properties>>
+
+  export type LinkLayerProps<Properties = any> = LinkLayerInitOptions<Properties> & LinkLayerEvents
+
+  let { instance = $bindable(), ...props }: LinkLayerProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+
+  const restProps = omitProps(() => props, 'loca', 'map', ...eventsToProps(layerEvents))
+
+  const linkLayer = $state.raw<Loca.LinkLayer<Properties>>(new Loca.LinkLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = linkLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.add(linkLayer)
+
+    return () => {
+      loca.remove(linkLayer)
+    }
+  })
+
+  useLayerAttributes(() => linkLayer, restProps)
+
+  createEventListeners<Loca.LinkLayerEventType, Loca.LinkLayer<Properties>>(
+    () => linkLayer,
+    () => props,
+    layerEvents
+  )
+
+  onDestroy(() => {
+    linkLayer.destroy()
+  })
+</script>

package/dist/loca/layer/link-layer/link-layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+import type { LayerExtraInitOptions } from '../layer';
+type LinkLayerEvents<Properties = any> = MapEventProps<Loca.LinkLayerEventType, Loca.LinkLayer<Properties>>;
+interface LinkLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.LinkLayerStyle<Properties>;
+}
+type LinkLayerInitOptions<Properties = any> = Loca.LinkLayerOptions & LinkLayerExtraInitProps<Properties> & Instance<Loca.LinkLayer<Properties>>;
+export type LinkLayerProps<Properties = any> = LinkLayerInitOptions<Properties> & LinkLayerEvents;
+declare function $$render<Properties>(): {
+    props: LinkLayerProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Properties> {
+    props(): ReturnType<typeof $$render<Properties>>['props'];
+    events(): ReturnType<typeof $$render<Properties>>['events'];
+    slots(): ReturnType<typeof $$render<Properties>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Properties>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Properties>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Properties>['props']>, ReturnType<__sveltets_Render<Properties>['events']>, ReturnType<__sveltets_Render<Properties>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Properties>['bindings']>;
+    } & ReturnType<__sveltets_Render<Properties>['exports']>;
+    <Properties>(internal: unknown, props: ReturnType<__sveltets_Render<Properties>['props']> & {}): ReturnType<__sveltets_Render<Properties>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const LinkLayer: $$IsomorphicComponent;
+type LinkLayer<Properties> = InstanceType<typeof LinkLayer<Properties>>;
+export default LinkLayer;

package/dist/loca/layer/point-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PointLayer } from './point-layer.svelte';
+export type { PointLayerProps } from './point-layer.svelte';

package/dist/loca/layer/point-layer/index.js

@@ -0,0 +1 @@
+export { default as PointLayer } from './point-layer.svelte';

package/dist/loca/layer/point-layer/point-layer.svelte

@@ -0,0 +1,62 @@
+<script lang="ts" generics="Properties">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import type { LayerExtraInitOptions } from '../layer'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type PointLayerEvents = MapEventProps<Loca.PointLayerEventType, Loca.PointLayer>
+  interface PointLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.PointLayerStyle<Properties>
+  }
+  type PointLayerInitOptions<Properties = any> = Loca.PointLayerOptions
+    & PointLayerExtraInitProps<Properties>
+    & Instance<Loca.PointLayer<Properties>>
+
+  export type PointLayerProps<Properties = any> = PointLayerInitOptions<Properties> & PointLayerEvents
+
+  let { instance = $bindable(), ...props }: PointLayerProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+
+  const restProps = omitProps(() => props, 'loca', 'map', ...eventsToProps(layerEvents))
+
+  const pointLayer = $state.raw<Loca.PointLayer<Properties>>(new Loca.PointLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = pointLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.add(pointLayer)
+
+    return () => {
+      loca.remove(pointLayer)
+    }
+  })
+
+  useLayerAttributes(() => pointLayer, restProps)
+
+  createEventListeners<Loca.PointLayerEventType, Loca.PointLayer<Properties>>(
+    () => pointLayer,
+    () => props,
+    layerEvents
+  )
+
+  onDestroy(() => {
+    pointLayer.destroy()
+  })
+</script>

package/dist/loca/layer/point-layer/point-layer.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+import type { LayerExtraInitOptions } from '../layer';
+type PointLayerEvents = MapEventProps<Loca.PointLayerEventType, Loca.PointLayer>;
+interface PointLayerExtraInitProps<Properties = any> extends LayerExtraInitOptions<Properties> {
+    /**
+     * 图层的样式
+     */
+    style?: Loca.PointLayerStyle<Properties>;
+}
+type PointLayerInitOptions<Properties = any> = Loca.PointLayerOptions & PointLayerExtraInitProps<Properties> & Instance<Loca.PointLayer<Properties>>;
+export type PointLayerProps<Properties = any> = PointLayerInitOptions<Properties> & PointLayerEvents;
+declare function $$render<Properties>(): {
+    props: PointLayerProps;
+    exports: {};
+    bindings: "instance";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Properties> {
+    props(): ReturnType<typeof $$render<Properties>>['props'];
+    events(): ReturnType<typeof $$render<Properties>>['events'];
+    slots(): ReturnType<typeof $$render<Properties>>['slots'];
+    bindings(): "instance";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Properties>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Properties>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Properties>['props']>, ReturnType<__sveltets_Render<Properties>['events']>, ReturnType<__sveltets_Render<Properties>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Properties>['bindings']>;
+    } & ReturnType<__sveltets_Render<Properties>['exports']>;
+    <Properties>(internal: unknown, props: ReturnType<__sveltets_Render<Properties>['props']> & {}): ReturnType<__sveltets_Render<Properties>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const PointLayer: $$IsomorphicComponent;
+type PointLayer<Properties> = InstanceType<typeof PointLayer<Properties>>;
+export default PointLayer;

package/dist/loca/layer/polygon-layer/index.d.ts

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

package/dist/loca/layer/polygon-layer/index.js

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