@cn-map/gaode-svelte 0.0.0 → 0.0.1

package/dist/layer/district-layer/country/country.svelte

@@ -0,0 +1,57 @@
+<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 useDistrictLayerAttributes from '../district-layer/use-attributes.svelte'
+
+  type CountryAttributes = Omit<CountryInitOptions, 'map' | 'instance'>
+  type CountryEvents = MapEventProps<AMap.DistrictLayer.CountryEventType, AMap.DistrictLayer.Country>
+  type CountryInitOptions = AMap.DistrictLayer.CountryOptions & Instance<AMap.DistrictLayer.Country>
+
+  export type CountryProps = CountryInitOptions & CountryEvents
+
+  const countryEvents: AMap.DistrictLayer.CountryEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: CountryProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(countryEvents))
+
+  const country = $state.raw<AMap.DistrictLayer.Country>(new AMap.DistrictLayer.Country(snapshot(restProps)))
+
+  $effect(() => {
+    instance = country
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    country.setMap(map)
+
+    return () => {
+      country.setMap(null)
+    }
+  })
+
+  useDistrictLayerAttributes<AMap.DistrictLayer.Country, CountryAttributes, 'DistrictLayer.Country'>(
+    () => country,
+    restProps
+  )
+
+  createEventListeners<AMap.DistrictLayer.CountryEventType, AMap.DistrictLayer.Country>(
+    () => country,
+    () => props,
+    countryEvents
+  )
+
+  onDestroy(() => country.destroy())
+</script>

package/dist/layer/district-layer/country/country.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type CountryEvents = MapEventProps<AMap.DistrictLayer.CountryEventType, AMap.DistrictLayer.Country>;
+type CountryInitOptions = AMap.DistrictLayer.CountryOptions & Instance<AMap.DistrictLayer.Country>;
+export type CountryProps = CountryInitOptions & CountryEvents;
+declare const Country: import("svelte").Component<CountryProps, {}, "instance">;
+type Country = ReturnType<typeof Country>;
+export default Country;

package/dist/layer/district-layer/country/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Country } from './country.svelte';
+export type { CountryProps } from './country.svelte';

package/dist/layer/district-layer/country/index.js

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

package/dist/layer/district-layer/district-layer/district-layer.svelte

@@ -0,0 +1,70 @@
+<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 DistrictLayerEvents = MapEventProps<AMap.DistrictLayerEventType, AMap.DistrictLayer>
+  type DistrictLayerInitOptions = AMap.DistrictLayerOptions & Instance<AMap.DistrictLayer>
+
+  export type DistrictLayerProps = DistrictLayerInitOptions & DistrictLayerEvents
+
+  const districtLayerEvents: AMap.DistrictLayerEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: DistrictLayerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(districtLayerEvents))
+
+  const districtLayer = $state.raw<AMap.DistrictLayer>(new AMap.DistrictLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = districtLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    districtLayer.setMap(map)
+
+    return () => {
+      districtLayer.setMap(null)
+    }
+  })
+
+  useLayerAttributes(() => districtLayer, restProps)
+
+  $effect(() => {
+    if (restProps.adcode !== undefined) {
+      districtLayer.setAdcode(restProps.adcode)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.SOC !== undefined) {
+      districtLayer.setSOC(restProps.SOC)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.styles !== undefined) {
+      districtLayer.setStyles(snapshot(restProps.styles))
+    }
+  })
+
+  createEventListeners<AMap.DistrictLayerEventType, AMap.DistrictLayer>(
+    () => districtLayer,
+    () => props,
+    districtLayerEvents
+  )
+
+  onDestroy(() => districtLayer.destroy())
+</script>

package/dist/layer/district-layer/district-layer/district-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 DistrictLayerEvents = MapEventProps<AMap.DistrictLayerEventType, AMap.DistrictLayer>;
+type DistrictLayerInitOptions = AMap.DistrictLayerOptions & Instance<AMap.DistrictLayer>;
+export type DistrictLayerProps = DistrictLayerInitOptions & DistrictLayerEvents;
+declare const DistrictLayer: import("svelte").Component<DistrictLayerProps, {}, "instance">;
+type DistrictLayer = ReturnType<typeof DistrictLayer>;
+export default DistrictLayer;

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

@@ -0,0 +1,2 @@
+export { default as DistrictLayer } from './district-layer.svelte';
+export type { DistrictLayerProps } from './district-layer.svelte';

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

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

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

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

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

@@ -0,0 +1,20 @@
+import { useLayerAttributes } from '../../layer';
+import { snapshot } from "../../../utils/index.js";
+export default function (districtLayer, props) {
+    useLayerAttributes(districtLayer, props);
+    $effect(() => {
+        if (props.adcode !== undefined) {
+            districtLayer().setAdcode(props.adcode);
+        }
+    });
+    $effect(() => {
+        if (props.SOC !== undefined) {
+            districtLayer().setSOC(props.SOC);
+        }
+    });
+    $effect(() => {
+        if (props.styles !== undefined) {
+            districtLayer().setStyles(snapshot(props.styles));
+        }
+    });
+}

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

@@ -0,0 +1,4 @@
+export { Country, type CountryProps } from './country';
+export { DistrictLayer, type DistrictLayerProps } from './district-layer';
+export { Province, type ProvinceProps } from './province';
+export { World, type WorldProps } from './world';

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

@@ -0,0 +1,4 @@
+export { Country } from './country';
+export { DistrictLayer } from './district-layer';
+export { Province } from './province';
+export { World } from './world';

package/dist/layer/district-layer/province/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Province } from './province.svelte';
+export type { ProvinceProps } from './province.svelte';

package/dist/layer/district-layer/province/index.js

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

package/dist/layer/district-layer/province/province.svelte

@@ -0,0 +1,57 @@
+<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 useDistrictLayerAttributes from '../district-layer/use-attributes.svelte'
+
+  type ProvinceAttributes = Omit<ProvinceInitOptions, 'map' | 'instance'>
+  type ProvinceEvents = MapEventProps<AMap.DistrictLayer.ProvinceEventType, AMap.DistrictLayer.Province>
+  type ProvinceInitOptions = AMap.DistrictLayer.ProvinceOptions & Instance<AMap.DistrictLayer.Province>
+
+  export type ProvinceProps = ProvinceInitOptions & ProvinceEvents
+
+  const provinceEvents: AMap.DistrictLayer.ProvinceEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: ProvinceProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(provinceEvents))
+
+  const province = $state.raw<AMap.DistrictLayer.Province>(new AMap.DistrictLayer.Province(snapshot(restProps)))
+
+  $effect(() => {
+    instance = province
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    province.setMap(map)
+
+    return () => {
+      province.setMap(null)
+    }
+  })
+
+  useDistrictLayerAttributes<AMap.DistrictLayer.Province, ProvinceAttributes, 'DistrictLayer.Province'>(
+    () => province,
+    restProps
+  )
+
+  createEventListeners<AMap.DistrictLayer.ProvinceEventType, AMap.DistrictLayer.Province>(
+    () => province,
+    () => props,
+    provinceEvents
+  )
+
+  onDestroy(() => province.destroy())
+</script>

package/dist/layer/district-layer/province/province.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type ProvinceEvents = MapEventProps<AMap.DistrictLayer.ProvinceEventType, AMap.DistrictLayer.Province>;
+type ProvinceInitOptions = AMap.DistrictLayer.ProvinceOptions & Instance<AMap.DistrictLayer.Province>;
+export type ProvinceProps = ProvinceInitOptions & ProvinceEvents;
+declare const Province: import("svelte").Component<ProvinceProps, {}, "instance">;
+type Province = ReturnType<typeof Province>;
+export default Province;

package/dist/layer/district-layer/world/index.d.ts

@@ -0,0 +1,2 @@
+export type { WorldProps } from './world.svelte';
+export { default as World } from './world.svelte';

package/dist/layer/district-layer/world/index.js

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

package/dist/layer/district-layer/world/world.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 useDistrictLayerAttributes from '../district-layer/use-attributes.svelte'
+
+  type WorldAttributes = Omit<WorldInitOptions, 'map' | 'instance'>
+  type WorldEvents = MapEventProps<AMap.DistrictLayer.WorldEventType, AMap.DistrictLayer.World>
+  type WorldInitOptions = AMap.DistrictLayer.WorldOptions & Instance<AMap.DistrictLayer.World>
+
+  export type WorldProps = WorldInitOptions & WorldEvents
+
+  const worldEvents: AMap.DistrictLayer.WorldEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: WorldProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(worldEvents))
+
+  const world = $state.raw<AMap.DistrictLayer.World>(new AMap.DistrictLayer.World(snapshot(restProps)))
+
+  $effect(() => {
+    instance = world
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    world.setMap(map)
+
+    return () => {
+      world.setMap(null)
+    }
+  })
+
+  useDistrictLayerAttributes<AMap.DistrictLayer.World, WorldAttributes, 'DistrictLayer.World'>(() => world, restProps)
+
+  createEventListeners<AMap.DistrictLayer.WorldEventType, AMap.DistrictLayer.World>(
+    () => world,
+    () => props,
+    worldEvents
+  )
+
+  onDestroy(() => world.destroy())
+</script>

package/dist/layer/district-layer/world/world.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { MapEventProps } from '@cn-map/gaode-shared/types';
+import type { Instance } from '../../../types/index.ts';
+type WorldEvents = MapEventProps<AMap.DistrictLayer.WorldEventType, AMap.DistrictLayer.World>;
+type WorldInitOptions = AMap.DistrictLayer.WorldOptions & Instance<AMap.DistrictLayer.World>;
+export type WorldProps = WorldInitOptions & WorldEvents;
+declare const World: import("svelte").Component<WorldProps, {}, "instance">;
+type World = ReturnType<typeof World>;
+export default World;

package/dist/layer/gl-custom-layer/gl-custom-layer.svelte

@@ -0,0 +1,65 @@
+<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 { 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 { layerEvents, useLayerAttributes } from '../layer'
+
+  type GLCustomLayerEvents = MapEventProps<AMap.GLCustomLayerEventType, AMap.GLCustomLayer>
+  type GLCustomLayerInitOptions = AMap.GLCustomLayerOptions & Instance<AMap.GLCustomLayer>
+
+  export type GLCustomLayerProps = GLCustomLayerInitOptions & GLCustomLayerEvents & { children?: Snippet }
+
+  const glCustomLayerEvents: AMap.GLCustomLayerEventType[] = layerEvents
+
+  let { instance = $bindable(), children, ...props }: GLCustomLayerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(glCustomLayerEvents))
+
+  const glCustomLayer = $state.raw<AMap.GLCustomLayer>(new AMap.GLCustomLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = glCustomLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    glCustomLayer.setMap(map)
+
+    return () => {
+      glCustomLayer.setMap(null)
+    }
+  })
+
+  useLayerAttributes(() => glCustomLayer, restProps)
+
+  $effect(() => {
+    glCustomLayer.init = restProps.init || glCustomLayer.init
+  })
+
+  $effect(() => {
+    glCustomLayer.render = restProps.render || glCustomLayer.render
+  })
+
+  createEventListeners<AMap.GLCustomLayerEventType, AMap.GLCustomLayer>(
+    () => glCustomLayer,
+    () => props,
+    glCustomLayerEvents
+  )
+
+  onDestroy(() => glCustomLayer.destroy())
+</script>
+
+{#if children}
+  {@render children()}
+{/if}

package/dist/layer/gl-custom-layer/gl-custom-layer.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 GLCustomLayerEvents = MapEventProps<AMap.GLCustomLayerEventType, AMap.GLCustomLayer>;
+type GLCustomLayerInitOptions = AMap.GLCustomLayerOptions & Instance<AMap.GLCustomLayer>;
+export type GLCustomLayerProps = GLCustomLayerInitOptions & GLCustomLayerEvents & {
+    children?: Snippet;
+};
+declare const GlCustomLayer: import("svelte").Component<GLCustomLayerProps, {}, "instance">;
+type GlCustomLayer = ReturnType<typeof GlCustomLayer>;
+export default GlCustomLayer;

package/dist/layer/gl-custom-layer/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GLCustomLayer } from './gl-custom-layer.svelte';
+export type { GLCustomLayerProps } from './gl-custom-layer.svelte';

package/dist/layer/gl-custom-layer/index.js

@@ -0,0 +1 @@
+export { default as GLCustomLayer } from './gl-custom-layer.svelte';

package/dist/layer/heat-map/heat-map.svelte

@@ -0,0 +1,65 @@
+<script lang="ts">
+  import type { Instance } from '../../types/index.js'
+  import { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+
+  type HeatMapAttributes = AMap.HeatMapOptions & { dataset?: AMap.HeatMapDataSet | AMap.HeatMapDataSetLive }
+  type HeatMapInitOptions = HeatMapAttributes & { map?: AMap.Map } & Instance<AMap.HeatMap>
+
+  export type HeatMapProps = HeatMapInitOptions
+
+  let { instance = $bindable(), ...props }: HeatMapProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map')
+
+  const heatMap = $state.raw<AMap.HeatMap>(new AMap.HeatMap(null, snapshot(restProps)))
+
+  $effect(() => {
+    instance = heatMap
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    heatMap.setMap(map)
+
+    return () => {
+      heatMap._renderLayer._render.setMap(null)
+      heatMap._renderLayer._render.render.destroy()
+      heatMap.setMap(null)
+    }
+  })
+
+  const rest = omitProps(() => restProps, ['visible', 'zIndex', 'dataset'])
+
+  $effect(() => {
+    if (restProps.visible !== undefined) {
+      if (restProps.visible) {
+        heatMap.show()
+      } else {
+        heatMap.hide()
+      }
+    }
+  })
+
+  $effect(() => {
+    if (restProps.zIndex !== undefined) {
+      heatMap.setzIndex(restProps.zIndex)
+    }
+  })
+
+  $effect(() => {
+    if (restProps.dataset) {
+      heatMap.setDataSet(snapshot(restProps.dataset))
+    }
+  })
+
+  $effect(() => {
+    heatMap.setOptions(snapshot(rest))
+  })
+</script>

package/dist/layer/heat-map/heat-map.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { Instance } from '../../types/index.ts';
+type HeatMapAttributes = AMap.HeatMapOptions & {
+    dataset?: AMap.HeatMapDataSet | AMap.HeatMapDataSetLive;
+};
+type HeatMapInitOptions = HeatMapAttributes & {
+    map?: AMap.Map;
+} & Instance<AMap.HeatMap>;
+export type HeatMapProps = HeatMapInitOptions;
+declare const HeatMap: import("svelte").Component<HeatMapInitOptions, {}, "instance">;
+type HeatMap = ReturnType<typeof HeatMap>;
+export default HeatMap;

package/dist/layer/heat-map/index.d.ts

@@ -0,0 +1,2 @@
+export { default as HeatMap } from './heat-map.svelte';
+export type { HeatMapProps } from './heat-map.svelte';

package/dist/layer/heat-map/index.js

@@ -0,0 +1 @@
+export { default as HeatMap } from './heat-map.svelte';

package/dist/layer/image-layer/image-layer.svelte

@@ -0,0 +1,64 @@
+<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 { useMapInstance } from '../../map'
+  import { omitProps, snapshot } from '../../utils/index.js'
+  import { layerEvents, useLayerAttributes } from '../layer'
+
+  type ImageLayerEvents = MapEventProps<AMap.ImageLayerEventType, AMap.ImageLayer>
+  type ImageLayerInitOptions = AMap.ImageLayerOptions & Instance<AMap.ImageLayer>
+
+  export type ImageLayerProps = ImageLayerInitOptions & ImageLayerEvents
+
+  const imageLayerEvents: AMap.ImageLayerEventType[] = layerEvents
+
+  let { instance = $bindable(), ...props }: ImageLayerProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+  const restProps = omitProps(() => props, 'map', ...eventsToProps(imageLayerEvents))
+
+  const imageLayer = $state.raw<AMap.ImageLayer>(new AMap.ImageLayer(snapshot(restProps)))
+
+  $effect(() => {
+    instance = imageLayer
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    imageLayer.setMap(map)
+
+    return () => {
+      imageLayer.setMap(null)
+    }
+  })
+
+  useLayerAttributes(() => imageLayer, restProps)
+
+  $effect(() => {
+    if (!map) return
+
+    imageLayer.setBounds(restProps.bounds)
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    imageLayer.setImageUrl(restProps.url || restProps.tileUrl)
+  })
+
+  createEventListeners<AMap.ImageLayerEventType, AMap.ImageLayer>(
+    () => imageLayer,
+    () => props,
+    imageLayerEvents
+  )
+
+  onDestroy(() => imageLayer.destroy())
+</script>

package/dist/layer/image-layer/image-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 ImageLayerEvents = MapEventProps<AMap.ImageLayerEventType, AMap.ImageLayer>;
+type ImageLayerInitOptions = AMap.ImageLayerOptions & Instance<AMap.ImageLayer>;
+export type ImageLayerProps = ImageLayerInitOptions & ImageLayerEvents;
+declare const ImageLayer: import("svelte").Component<ImageLayerProps, {}, "instance">;
+type ImageLayer = ReturnType<typeof ImageLayer>;
+export default ImageLayer;

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

@@ -0,0 +1,2 @@
+export { default as ImageLayer } from './image-layer.svelte';
+export type { ImageLayerProps } from './image-layer.svelte';

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

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

package/dist/layer/index.d.ts

@@ -0,0 +1,14 @@
+export { Buildings, type BuildingsProps } from './buildings';
+export { CanvasLayer, type CanvasLayerProps } from './canvas-layer';
+export { CustomLayer, type CustomLayerProps } from './custom-layer';
+export { Country, type CountryProps, DistrictLayer, type DistrictLayerProps, Province, type ProvinceProps, World, type WorldProps, } from './district-layer';
+export { GLCustomLayer, type GLCustomLayerProps } from './gl-custom-layer';
+export { HeatMap, type HeatMapProps } from './heat-map';
+export { ImageLayer, type ImageLayerProps } from './image-layer';
+export { IndoorMap, type IndoorMapProps } from './indoor-map';
+export { LabelsLayer, type LabelsLayerProps, useLabelsLayer } from './labels-layer';
+export { LayerGroup, type LayerGroupProps } from './layer-group';
+export { Mapbox, type MapboxProps } from './mapbox';
+export { MapboxVectorTileLayer, type MapboxVectorTileLayerProps } from './mapbox-vector-tile-layer';
+export { Flexible, type FlexibleProps, Mark, type MarkProps, RoadNet, type RoadNetProps, Satellite, type SatelliteProps, TileLayer, type TileLayerProps, Traffic, type TrafficProps, WMS, type WMSProps, WMTS, type WMTSProps, } from './tile-layer';
+export { useVectorLayer, VectorLayer, type VectorLayerProps } from './vector-layer';

package/dist/layer/index.js

@@ -0,0 +1,14 @@
+export { Buildings } from './buildings';
+export { CanvasLayer } from './canvas-layer';
+export { CustomLayer } from './custom-layer';
+export { Country, DistrictLayer, Province, World, } from './district-layer';
+export { GLCustomLayer } from './gl-custom-layer';
+export { HeatMap } from './heat-map';
+export { ImageLayer } from './image-layer';
+export { IndoorMap } from './indoor-map';
+export { LabelsLayer, useLabelsLayer } from './labels-layer';
+export { LayerGroup } from './layer-group';
+export { Mapbox } from './mapbox';
+export { MapboxVectorTileLayer } from './mapbox-vector-tile-layer';
+export { Flexible, Mark, RoadNet, Satellite, TileLayer, Traffic, WMS, WMTS, } from './tile-layer';
+export { useVectorLayer, VectorLayer } from './vector-layer';

package/dist/layer/indoor-map/index.d.ts

@@ -0,0 +1,2 @@
+export { default as IndoorMap } from './indoor-map.svelte';
+export type { IndoorMapProps } from './indoor-map.svelte';

package/dist/layer/indoor-map/index.js

@@ -0,0 +1 @@
+export { default as IndoorMap } from './indoor-map.svelte';