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

package/dist/layer/tile-layer/flexible/flexible.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type FlexibleAttributes = Omit<FlexibleInitOptions, 'map' | 'instance'>
+  type FlexibleEvents = MapEventProps<AMap.TileLayer.FlexibleEventType, AMap.TileLayer.Flexible>
+  type FlexibleInitOptions = AMap.TileLayer.FlexibleOptions & Instance<AMap.TileLayer.Flexible>
+
+  export type FlexibleProps = FlexibleInitOptions & FlexibleEvents
+
+  const flexibleEvents: AMap.TileLayer.FlexibleEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: FlexibleProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(flexibleEvents))
+
+  const flexible = $state.raw<AMap.TileLayer.Flexible>(new AMap.TileLayer.Flexible(snapshot(restProps)))
+
+  $effect(() => {
+    instance = flexible
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    flexible.setMap(map)
+
+    return () => {
+      flexible.setMap(null)
+    }
+  })
+
+  // @ts-expect-error fine
+  useTileLayerAttributes<AMap.TileLayer.Flexible, FlexibleAttributes, 'TileLayer.Flexible'>(() => flexible, restProps)
+
+  createEventListeners<AMap.TileLayer.FlexibleEventType, AMap.TileLayer.Flexible>(
+    () => flexible,
+    () => props,
+    flexibleEvents
+  )
+
+  onDestroy(() => flexible.destroy())
+</script>

package/dist/layer/tile-layer/flexible/flexible.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type FlexibleEvents = MapEventProps<AMap.TileLayer.FlexibleEventType, AMap.TileLayer.Flexible>;
+type FlexibleInitOptions = AMap.TileLayer.FlexibleOptions & Instance<AMap.TileLayer.Flexible>;
+export type FlexibleProps = FlexibleInitOptions & FlexibleEvents;
+declare const Flexible: import("svelte").Component<FlexibleProps, {}, "instance">;
+type Flexible = ReturnType<typeof Flexible>;
+export default Flexible;

package/dist/layer/tile-layer/flexible/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Flexible } from './flexible.svelte';
+export type { FlexibleProps } from './flexible.svelte';

package/dist/layer/tile-layer/flexible/index.js

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

package/dist/layer/tile-layer/index.d.ts

@@ -0,0 +1,8 @@
+export { Flexible, type FlexibleProps } from './flexible';
+export { Mark, type MarkProps } from './mark';
+export { RoadNet, type RoadNetProps } from './road-net';
+export { Satellite, type SatelliteProps } from './satellite';
+export { TileLayer, type TileLayerProps } from './tile-layer';
+export { Traffic, type TrafficProps } from './traffic';
+export { WMS, type WMSProps } from './wms';
+export { WMTS, type WMTSProps } from './wmts';

package/dist/layer/tile-layer/index.js

@@ -0,0 +1,8 @@
+export { Flexible } from './flexible';
+export { Mark } from './mark';
+export { RoadNet } from './road-net';
+export { Satellite } from './satellite';
+export { TileLayer } from './tile-layer';
+export { Traffic } from './traffic';
+export { WMS } from './wms';
+export { WMTS } from './wmts';

package/dist/layer/tile-layer/mark/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Mark } from './mark.svelte';
+export type { MarkProps } from './mark.svelte';

package/dist/layer/tile-layer/mark/index.js

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

package/dist/layer/tile-layer/mark/mark.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type MarkAttributes = Omit<MarkInitOptions, 'map' | 'instance'>
+  type MarkEvents = MapEventProps<AMap.TileLayer.MarkEventType, AMap.TileLayer.Mark>
+  type MarkInitOptions = AMap.TileLayer.MarkOptions & Instance<AMap.TileLayer.Mark>
+
+  export type MarkProps = MarkInitOptions & MarkEvents
+
+  const markEvents: AMap.TileLayer.MarkEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: MarkProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(markEvents))
+
+  const mark = $state.raw<AMap.TileLayer.Mark>(new AMap.TileLayer.Mark(snapshot(restProps)))
+
+  $effect(() => {
+    instance = mark
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    mark.setMap(map)
+
+    return () => {
+      mark.setMap(null)
+    }
+  })
+
+  useTileLayerAttributes<AMap.TileLayer.Mark, MarkAttributes, 'TileLayer.Mark'>(() => mark, restProps)
+
+  createEventListeners<AMap.TileLayer.MarkEventType, AMap.TileLayer.Mark>(
+    () => mark,
+    () => props,
+    markEvents
+  )
+
+  onDestroy(() => mark.destroy())
+</script>

package/dist/layer/tile-layer/mark/mark.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type MarkEvents = MapEventProps<AMap.TileLayer.MarkEventType, AMap.TileLayer.Mark>;
+type MarkInitOptions = AMap.TileLayer.MarkOptions & Instance<AMap.TileLayer.Mark>;
+export type MarkProps = MarkInitOptions & MarkEvents;
+declare const Mark: import("svelte").Component<MarkProps, {}, "instance">;
+type Mark = ReturnType<typeof Mark>;
+export default Mark;

package/dist/layer/tile-layer/road-net/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RoadNet } from './road-net.svelte';
+export type { RoadNetProps } from './road-net.svelte';

package/dist/layer/tile-layer/road-net/index.js

@@ -0,0 +1 @@
+export { default as RoadNet } from './road-net.svelte';

package/dist/layer/tile-layer/road-net/road-net.svelte

@@ -0,0 +1,54 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type RoadNetAttributes = Omit<RoadNetInitOptions, 'map' | 'instance'>
+  type RoadNetEvents = MapEventProps<AMap.TileLayer.RoadNetEventType, AMap.TileLayer.RoadNet>
+  type RoadNetInitOptions = AMap.TileLayer.RoadNetOptions & Instance<AMap.TileLayer.RoadNet>
+
+  export type RoadNetProps = RoadNetInitOptions & RoadNetEvents
+
+  const roadNetEvents: AMap.TileLayer.RoadNetEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: RoadNetProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(roadNetEvents))
+
+  const roadNet = $state.raw<AMap.TileLayer.RoadNet>(new AMap.TileLayer.RoadNet(snapshot(restProps)))
+
+  $effect(() => {
+    instance = roadNet
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    roadNet.setMap(map)
+
+    return () => {
+      roadNet.setMap(null)
+    }
+  })
+
+  useTileLayerAttributes<AMap.TileLayer.RoadNet, RoadNetAttributes, 'TileLayer.RoadNet'>(() => roadNet, restProps)
+
+  createEventListeners<AMap.TileLayer.RoadNetEventType, AMap.TileLayer.RoadNet>(
+    () => roadNet,
+    () => props,
+    roadNetEvents
+  )
+
+  onDestroy(() => roadNet.destroy())
+</script>

package/dist/layer/tile-layer/road-net/road-net.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type RoadNetEvents = MapEventProps<AMap.TileLayer.RoadNetEventType, AMap.TileLayer.RoadNet>;
+type RoadNetInitOptions = AMap.TileLayer.RoadNetOptions & Instance<AMap.TileLayer.RoadNet>;
+export type RoadNetProps = RoadNetInitOptions & RoadNetEvents;
+declare const RoadNet: import("svelte").Component<RoadNetProps, {}, "instance">;
+type RoadNet = ReturnType<typeof RoadNet>;
+export default RoadNet;

package/dist/layer/tile-layer/satellite/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Satellite } from './satellite.svelte';
+export type { SatelliteProps } from './satellite.svelte';

package/dist/layer/tile-layer/satellite/index.js

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

package/dist/layer/tile-layer/satellite/satellite.svelte

@@ -0,0 +1,58 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type SatelliteAttributes = Omit<SatelliteInitOptions, 'map' | 'instance'>
+  type SatelliteEvents = MapEventProps<AMap.TileLayer.SatelliteEventType, AMap.TileLayer.Satellite>
+  type SatelliteInitOptions = AMap.TileLayer.SatelliteOptions & Instance<AMap.TileLayer.Satellite>
+
+  export type SatelliteProps = SatelliteInitOptions & SatelliteEvents
+
+  const satelliteEvents: AMap.TileLayer.SatelliteEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: SatelliteProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(satelliteEvents))
+
+  const satellite = $state.raw<AMap.TileLayer.Satellite>(new AMap.TileLayer.Satellite(snapshot(restProps)))
+
+  $effect(() => {
+    instance = satellite
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    satellite.setMap(map)
+
+    return () => {
+      satellite.setMap(null)
+    }
+  })
+
+  // @ts-expect-error fine
+  useTileLayerAttributes<AMap.TileLayer.Satellite, SatelliteAttributes, 'TileLayer.Satellite'>(
+    () => satellite,
+    restProps
+  )
+
+  createEventListeners<AMap.TileLayer.SatelliteEventType, AMap.TileLayer.Satellite>(
+    () => satellite,
+    () => props,
+    satelliteEvents
+  )
+
+  onDestroy(() => satellite.destroy())
+</script>

package/dist/layer/tile-layer/satellite/satellite.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type SatelliteEvents = MapEventProps<AMap.TileLayer.SatelliteEventType, AMap.TileLayer.Satellite>;
+type SatelliteInitOptions = AMap.TileLayer.SatelliteOptions & Instance<AMap.TileLayer.Satellite>;
+export type SatelliteProps = SatelliteInitOptions & SatelliteEvents;
+declare const Satellite: import("svelte").Component<SatelliteProps, {}, "instance">;
+type Satellite = ReturnType<typeof Satellite>;
+export default Satellite;

package/dist/layer/tile-layer/tile-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TileLayer } from './tile-layer.svelte';
+export type { TileLayerProps } from './tile-layer.svelte';

package/dist/layer/tile-layer/tile-layer/index.js

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

package/dist/layer/tile-layer/tile-layer/tile-layer.svelte

@@ -0,0 +1,53 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from './use-attributes.svelte'
+
+  type TileLayerEvents = MapEventProps<AMap.TileLayerEventType, AMap.TileLayer>
+  type TileLayerInitOptions = AMap.TileLayerOptions & Instance<AMap.TileLayer>
+
+  export type TileLayerProps = TileLayerInitOptions & TileLayerEvents
+
+  const tileLayerEvents: AMap.TileLayerEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: TileLayerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(tileLayerEvents))
+
+  const tileLayer = $state.raw<AMap.TileLayer>(new AMap.TileLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = tileLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    tileLayer.setMap(map)
+
+    return () => {
+      tileLayer.setMap(null)
+    }
+  })
+
+  useTileLayerAttributes(() => tileLayer, restProps)
+
+  createEventListeners<AMap.TileLayerEventType, AMap.TileLayer>(
+    () => tileLayer,
+    () => props,
+    tileLayerEvents
+  )
+
+  onDestroy(() => tileLayer.destroy())
+</script>

package/dist/layer/tile-layer/tile-layer/tile-layer.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type TileLayerEvents = MapEventProps<AMap.TileLayerEventType, AMap.TileLayer>;
+type TileLayerInitOptions = AMap.TileLayerOptions & Instance<AMap.TileLayer>;
+export type TileLayerProps = TileLayerInitOptions & TileLayerEvents;
+declare const TileLayer: import("svelte").Component<TileLayerProps, {}, "instance">;
+type TileLayer = ReturnType<typeof TileLayer>;
+export default TileLayer;

package/dist/layer/tile-layer/tile-layer/use-attributes.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from '@cn-map/gaode-shared/types';
+type TileLayerAttributes = Omit<AMap.TileLayerOptions, 'map' | 'instance'>;
+export default function <L extends AMap.TileLayer<any, Name>, P extends TileLayerAttributes, Name extends string = 'TileLayer'>(tileLayer: Accessor<L>, props: P): void;
+export {};

package/dist/layer/tile-layer/tile-layer/use-attributes.svelte.js

@@ -0,0 +1,10 @@
+import { useLayerAttributes } from '../../layer';
+export default function (tileLayer, props) {
+    useLayerAttributes(tileLayer, props);
+    $effect(() => {
+        const url = props.getTileUrl;
+        if (typeof url === 'string') {
+            tileLayer().setTileUrl(url);
+        }
+    });
+}

package/dist/layer/tile-layer/traffic/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Traffic } from './traffic.svelte';
+export type { TrafficProps } from './traffic.svelte';

package/dist/layer/tile-layer/traffic/index.js

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

package/dist/layer/tile-layer/traffic/traffic.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents, useLayerAttributes } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+
+  type TrafficEvents = MapEventProps<AMap.TileLayer.TrafficEventType, AMap.TileLayer.Traffic>
+  type TrafficInitOptions = AMap.TileLayer.TrafficOptions & Instance<AMap.TileLayer.Traffic>
+
+  export type TrafficProps = TrafficInitOptions & TrafficEvents
+
+  const trafficEvents: AMap.TileLayer.TrafficEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: TrafficProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(trafficEvents))
+
+  const traffic = $state.raw<AMap.TileLayer.Traffic>(new AMap.TileLayer.Traffic(snapshot(restProps)))
+
+  $effect(() => {
+    instance = traffic
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    traffic.setMap(map)
+
+    return () => {
+      traffic.setMap(null)
+    }
+  })
+
+  useLayerAttributes(() => traffic, restProps)
+
+  createEventListeners<AMap.TileLayer.TrafficEventType, AMap.TileLayer.Traffic>(
+    () => traffic,
+    () => props,
+    trafficEvents
+  )
+
+  onDestroy(() => traffic.destroy())
+</script>

package/dist/layer/tile-layer/traffic/traffic.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type TrafficEvents = MapEventProps<AMap.TileLayer.TrafficEventType, AMap.TileLayer.Traffic>;
+type TrafficInitOptions = AMap.TileLayer.TrafficOptions & Instance<AMap.TileLayer.Traffic>;
+export type TrafficProps = TrafficInitOptions & TrafficEvents;
+declare const Traffic: import("svelte").Component<TrafficProps, {}, "instance">;
+type Traffic = ReturnType<typeof Traffic>;
+export default Traffic;

package/dist/layer/tile-layer/wms/index.d.ts

@@ -0,0 +1,2 @@
+export type { WMSProps } from './wms.svelte';
+export { default as WMS } from './wms.svelte';

package/dist/layer/tile-layer/wms/index.js

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

package/dist/layer/tile-layer/wms/wms.svelte

@@ -0,0 +1,66 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type WMSAttributes = Omit<WMSInitOptions, 'map' | 'instance'>
+  type WMSEvents = MapEventProps<AMap.TileLayer.WMSEventType, AMap.TileLayer.WMS>
+  type WMSInitOptions = AMap.TileLayer.WMSOptions & Instance<AMap.TileLayer.WMS>
+
+  export type WMSProps = WMSInitOptions & WMSEvents
+
+  const wmsEvents: AMap.TileLayer.WMSEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: WMSProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(wmsEvents))
+
+  const wms = $state.raw<AMap.TileLayer.WMS>(new AMap.TileLayer.WMS(snapshot(restProps)))
+
+  $effect(() => {
+    instance = wms
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    wms.setMap(map)
+
+    return () => {
+      wms.setMap(null)
+    }
+  })
+
+  useTileLayerAttributes<AMap.TileLayer.WMS, WMSAttributes, 'TileLayer.WMS'>(() => wms, restProps)
+
+  $effect(() => {
+    if (restProps.params !== undefined) {
+      wms.setParams(snapshot(restProps.params))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.url !== undefined) {
+      wms.setUrl(restProps.url)
+    }
+  })
+
+  createEventListeners<AMap.TileLayer.WMSEventType, AMap.TileLayer.WMS>(
+    () => wms,
+    () => props,
+    wmsEvents
+  )
+
+  onDestroy(() => wms.destroy())
+</script>

package/dist/layer/tile-layer/wms/wms.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type WMSEvents = MapEventProps<AMap.TileLayer.WMSEventType, AMap.TileLayer.WMS>;
+type WMSInitOptions = AMap.TileLayer.WMSOptions & Instance<AMap.TileLayer.WMS>;
+export type WMSProps = WMSInitOptions & WMSEvents;
+declare const Wms: import("svelte").Component<WMSProps, {}, "instance">;
+type Wms = ReturnType<typeof Wms>;
+export default Wms;

package/dist/layer/tile-layer/wmts/index.d.ts

@@ -0,0 +1,2 @@
+export type { WMTSProps } from './wmts.svelte';
+export { default as WMTS } from './wmts.svelte';

package/dist/layer/tile-layer/wmts/index.js

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

package/dist/layer/tile-layer/wmts/wmts.svelte

@@ -0,0 +1,66 @@
+<script lang="ts">
+  import type { MapEventProps } from '@cn-map/gaode-shared/types'
+  import type { Instance } from '../../../types/index.js'
+  import { eventsToProps } from '@cn-map/gaode-shared/utils'
+  import { onDestroy } from 'svelte'
+  import { createEventListeners } from '../../../hooks/index.js'
+  import { layerEvents } from '../../layer'
+  import { useMapInstance } from '../../../map'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import useTileLayerAttributes from '../tile-layer/use-attributes.svelte'
+
+  type WMTSAttributes = Omit<WMTSInitOptions, 'map' | 'instance'>
+  type WMTSEvents = MapEventProps<AMap.TileLayer.WMTSEventType, AMap.TileLayer.WMTS>
+  type WMTSInitOptions = AMap.TileLayer.WMTSOptions & Instance<AMap.TileLayer.WMTS>
+
+  export type WMTSProps = WMTSInitOptions & WMTSEvents
+
+  const wmtsEvents: AMap.TileLayer.WMTSEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: WMTSProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(wmtsEvents))
+
+  const wmts = $state.raw<AMap.TileLayer.WMTS>(new AMap.TileLayer.WMTS(snapshot(restProps)))
+
+  $effect(() => {
+    instance = wmts
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    wmts.setMap(map)
+
+    return () => {
+      wmts.setMap(null)
+    }
+  })
+
+  useTileLayerAttributes<AMap.TileLayer.WMTS, WMTSAttributes, 'TileLayer.WMTS'>(() => wmts, restProps)
+
+  $effect(() => {
+    if (restProps.params !== undefined) {
+      wmts.setParams(snapshot(restProps.params))
+    }
+  })
+
+  $effect(() => {
+    if (restProps.url !== undefined) {
+      wmts.setUrl(restProps.url)
+    }
+  })
+
+  createEventListeners<AMap.TileLayer.WMTSEventType, AMap.TileLayer.WMTS>(
+    () => wmts,
+    () => props,
+    wmtsEvents
+  )
+
+  onDestroy(() => wmts.destroy())
+</script>

package/dist/layer/tile-layer/wmts/wmts.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type WMTSEvents = MapEventProps<AMap.TileLayer.WMTSEventType, AMap.TileLayer.WMTS>;
+type WMTSInitOptions = AMap.TileLayer.WMTSOptions & Instance<AMap.TileLayer.WMTS>;
+export type WMTSProps = WMTSInitOptions & WMTSEvents;
+declare const Wmts: import("svelte").Component<WMTSProps, {}, "instance">;
+type Wmts = ReturnType<typeof Wmts>;
+export default Wmts;

package/dist/layer/vector-layer/context.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor, Nullable } from '@cn-map/gaode-shared/types';
+type VectorLayerContext = Accessor<Nullable<AMap.VectorLayer>>;
+export declare const getVectorLayerContext: () => VectorLayerContext, setVectorLayerContext: (context: VectorLayerContext) => VectorLayerContext, hasVectorLayerContext: () => boolean;
+export declare function useVectorLayer(): VectorLayerContext;
+/**
+ * 获取VectorLayer实例
+ */
+export declare function useVectorLayerInstance(): VectorLayerContext;
+export {};