@cn-map/gaode-svelte 0.0.0 → 0.0.1

package/dist/loca/legend/legend.svelte

@@ -0,0 +1,36 @@
+<script lang="ts">
+  import type { Instance } from '../../types/index.js'
+  import { useLocaInstance } from '../loca'
+  import { omitProps, snapshot } from '../../utils/index.js'
+
+  export type LegendProps = Loca.LegendOptions & Instance<Loca.Legend>
+
+  let { instance = $bindable(), ...props }: LegendProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+  const restProps = omitProps(() => props, 'loca')
+
+  const legend = $state.raw<Loca.Legend>(new Loca.Legend(snapshot(restProps)))
+
+  $effect(() => {
+    instance = legend
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    legend.addTo(loca)
+
+    return () => {
+      legend.remove()
+    }
+  })
+
+  $effect(() => {
+    legend.setStyle({ style: restProps.style, title: restProps.title })
+  })
+</script>

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

@@ -0,0 +1,5 @@
+import type { Instance } from '../../types/index.ts';
+export type LegendProps = Loca.LegendOptions & Instance<Loca.Legend>;
+declare const Legend: import("svelte").Component<LegendProps, {}, "instance">;
+type Legend = ReturnType<typeof Legend>;
+export default Legend;

package/dist/loca/light/ambient-light/ambient-light.svelte

@@ -0,0 +1,41 @@
+<script lang="ts">
+  import type { Instance } from '../../../types/index.js'
+  import type { LightProps } from '../light'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+
+  export type AmbientLightProps = Loca.AmbientLightProperty & LightProps & Instance<Loca.AmbientLight>
+
+  let { instance = $bindable(), ...props }: AmbientLightProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+  const restProps = omitProps(() => props, 'loca')
+
+  const ambientLight = $state.raw<Loca.AmbientLight>(new Loca.AmbientLight(snapshot(restProps)))
+
+  $effect(() => {
+    instance = ambientLight
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.addLight(ambientLight)
+
+    return () => {
+      loca.removeLight(ambientLight)
+    }
+  })
+
+  $effect(() => {
+    ambientLight.color = restProps.color
+  })
+
+  $effect(() => {
+    ambientLight.intensity = restProps.intensity
+  })
+</script>

package/dist/loca/light/ambient-light/ambient-light.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { Instance } from '../../../types/index.ts';
+import type { LightProps } from '../light';
+export type AmbientLightProps = Loca.AmbientLightProperty & LightProps & Instance<Loca.AmbientLight>;
+declare const AmbientLight: import("svelte").Component<AmbientLightProps, {}, "instance">;
+type AmbientLight = ReturnType<typeof AmbientLight>;
+export default AmbientLight;

package/dist/loca/light/ambient-light/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AmbientLight } from './ambient-light.svelte';
+export type { AmbientLightProps } from './ambient-light.svelte';

package/dist/loca/light/ambient-light/index.js

@@ -0,0 +1 @@
+export { default as AmbientLight } from './ambient-light.svelte';

package/dist/loca/light/directional-light/directional-light.svelte

@@ -0,0 +1,49 @@
+<script lang="ts">
+  import type { Instance } from '../../../types/index.js'
+  import type { LightProps } from '../light'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+
+  export type DirectionalLightProps = Loca.DirectionalLightProperty & LightProps & Instance<Loca.DirectionalLight>
+
+  let { instance = $bindable(), ...props }: DirectionalLightProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+  const restProps = omitProps(() => props, 'loca')
+
+  const directionalLight = $state.raw<Loca.DirectionalLight>(new Loca.DirectionalLight(snapshot(restProps)))
+
+  $effect(() => {
+    instance = directionalLight
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.addLight(directionalLight)
+
+    return () => {
+      loca.removeLight(directionalLight)
+    }
+  })
+
+  $effect(() => {
+    directionalLight.color = restProps.color
+  })
+
+  $effect(() => {
+    directionalLight.intensity = restProps.intensity
+  })
+
+  $effect(() => {
+    directionalLight.target = restProps.target
+  })
+
+  $effect(() => {
+    directionalLight.position = restProps.position
+  })
+</script>

package/dist/loca/light/directional-light/directional-light.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { Instance } from '../../../types/index.ts';
+import type { LightProps } from '../light';
+export type DirectionalLightProps = Loca.DirectionalLightProperty & LightProps & Instance<Loca.DirectionalLight>;
+declare const DirectionalLight: import("svelte").Component<DirectionalLightProps, {}, "instance">;
+type DirectionalLight = ReturnType<typeof DirectionalLight>;
+export default DirectionalLight;

package/dist/loca/light/directional-light/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DirectionalLight } from './directional-light.svelte';
+export type { DirectionalLightProps } from './directional-light.svelte';

package/dist/loca/light/directional-light/index.js

@@ -0,0 +1 @@
+export { default as DirectionalLight } from './directional-light.svelte';

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

@@ -0,0 +1,3 @@
+export { AmbientLight, type AmbientLightProps } from './ambient-light';
+export { DirectionalLight, type DirectionalLightProps } from './directional-light';
+export { PointLight, type PointLightProps } from './point-light';

package/dist/loca/light/index.js

@@ -0,0 +1,3 @@
+export { AmbientLight } from './ambient-light';
+export { DirectionalLight } from './directional-light';
+export { PointLight } from './point-light';

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

@@ -0,0 +1 @@
+export type { LightProps } from './types';

package/dist/loca/light/light/index.js

@@ -0,0 +1 @@
+export {};

package/dist/loca/light/light/types.d.ts

@@ -0,0 +1,3 @@
+export interface LightProps {
+    loca?: Loca.Container;
+}

package/dist/loca/light/light/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export { default as PointLight } from './point-light.svelte';
+export type { PointLightProps } from './point-light.svelte';

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

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

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

@@ -0,0 +1,49 @@
+<script lang="ts">
+  import type { Instance } from '../../../types/index.js'
+  import type { LightProps } from '../light'
+  import { useLocaInstance } from '../../loca'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+
+  export type PointLightProps = Loca.PointLightProperty & LightProps & Instance<Loca.PointLight>
+
+  let { instance = $bindable(), ...props }: PointLightProps = $props()
+
+  const loca = $derived.by(useLocaInstance(() => props.loca))
+  const restProps = omitProps(() => props, 'loca')
+
+  const pointLight = $state.raw<Loca.PointLight>(new Loca.PointLight(snapshot(restProps)))
+
+  $effect(() => {
+    instance = pointLight
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!loca) return
+
+    loca.addLight(pointLight)
+
+    return () => {
+      loca.removeLight(pointLight)
+    }
+  })
+
+  $effect(() => {
+    pointLight.color = restProps.color
+  })
+
+  $effect(() => {
+    pointLight.intensity = restProps.intensity
+  })
+
+  $effect(() => {
+    pointLight.distance = restProps.distance
+  })
+
+  $effect(() => {
+    pointLight.position = restProps.position
+  })
+</script>

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

@@ -0,0 +1,6 @@
+import type { Instance } from '../../../types/index.ts';
+import type { LightProps } from '../light';
+export type PointLightProps = Loca.PointLightProperty & LightProps & Instance<Loca.PointLight>;
+declare const PointLight: import("svelte").Component<PointLightProps, {}, "instance">;
+type PointLight = ReturnType<typeof PointLight>;
+export default PointLight;

package/dist/loca/loca/context.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor, Nullable } from '@cn-map/gaode-shared/types';
+type LocaContext = Accessor<Nullable<Loca.Container>>;
+export declare const getLocaContext: () => LocaContext, setLocaContext: (context: LocaContext) => LocaContext, hasLocaContext: () => boolean;
+export declare function useLoca(): LocaContext;
+/**
+ * 获取Loca实例，优先使用 props.loca，否则回退到上下文中的Loca实例
+ */
+export declare function useLocaInstance(locaInProps: Accessor<Loca.Container | null | undefined>): LocaContext;
+export {};

package/dist/loca/loca/context.js

@@ -0,0 +1,15 @@
+import { lostContextError } from '@cn-map/gaode-shared/utils';
+import { createContext } from 'svelte';
+export const [getLocaContext, setLocaContext, hasLocaContext] = createContext();
+export function useLoca() {
+    if (!hasLocaContext()) {
+        throw lostContextError('`Loca.Container`');
+    }
+    return getLocaContext();
+}
+/**
+ * 获取Loca实例，优先使用 props.loca，否则回退到上下文中的Loca实例
+ */
+export function useLocaInstance(locaInProps) {
+    return () => locaInProps() ?? (hasLocaContext() ? getLocaContext()() : null);
+}

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

@@ -0,0 +1,3 @@
+export { useLoca, useLocaInstance } from './context';
+export { default as Loca } from './loca.svelte';
+export type { LocaProps } from './loca.svelte';

package/dist/loca/loca/index.js

@@ -0,0 +1,2 @@
+export { useLoca, useLocaInstance } from './context';
+export { default as Loca } from './loca.svelte';

package/dist/loca/loca/loca.svelte

@@ -0,0 +1,49 @@
+<script lang="ts">
+  import type { Nullable } from '@cn-map/gaode-shared/types'
+  import type { Snippet } from 'svelte'
+  import type { Instance } from '../../types/index.js'
+  import { useMapInstance } from '../../map'
+  import { setLocaContext } from './context'
+
+  export type LocaProps = Omit<Loca.LocaOptions, 'map'>
+    & Partial<Pick<Loca.LocaOptions, 'map'>> & { children?: Snippet } & Instance<Loca.Container>
+
+  let { instance = $bindable(), children, ...props }: LocaProps = $props()
+
+  const map = $derived.by(useMapInstance(() => props.map))
+
+  let loca = $state.raw<Nullable<Loca.Container>>(null)
+
+  setLocaContext(() => loca)
+
+  $effect(() => {
+    instance = loca
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!map) return
+
+    try {
+      loca = new Loca.Container({ map })
+    } catch (e) {
+      console.error('init loca error', e)
+    }
+
+    return () => {
+      if (loca?.map) {
+        // @ts-expect-error loca register event "firstPaint" on map
+        AMap.Event.clearListeners(loca.map, 'firstPaint')
+        loca.destroy()
+      }
+      loca = null
+    }
+  })
+</script>
+
+{#if children}
+  {@render children()}
+{/if}

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

@@ -0,0 +1,8 @@
+import type { Snippet } from 'svelte';
+import type { Instance } from '../../types/index.ts';
+export type LocaProps = Omit<Loca.LocaOptions, 'map'> & Partial<Pick<Loca.LocaOptions, 'map'>> & {
+    children?: Snippet;
+} & Instance<Loca.Container>;
+declare const Loca: import("svelte").Component<LocaProps, {}, "instance">;
+type Loca = ReturnType<typeof Loca>;
+export default Loca;

package/dist/loca/source/data-source/context.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor, Nullable } from '@cn-map/gaode-shared/types';
+type DataSourceContext = Accessor<Nullable<Loca.GeoBufferSource | Loca.GeoJSONSource>>;
+export declare const getDataSourceContext: () => DataSourceContext, setDataSourceContext: (context: DataSourceContext) => DataSourceContext, hasDataSourceContext: () => boolean;
+export declare function useDataSource(): DataSourceContext;
+/**
+ * 获取数据源实例，优先使用 props.source，否则回退到上下文中的数据源实例
+ */
+export declare function useDataSourceInstance(dataSourceInProps: Accessor<Loca.GeoBufferSource | Loca.GeoJSONSource | null | undefined>): Accessor<Nullable<Loca.GeoBufferSource | Loca.GeoJSONSource>>;
+export {};

package/dist/loca/source/data-source/context.js

@@ -0,0 +1,15 @@
+import { lostContextError } from '@cn-map/gaode-shared/utils';
+import { createContext } from 'svelte';
+export const [getDataSourceContext, setDataSourceContext, hasDataSourceContext] = createContext();
+export function useDataSource() {
+    if (!hasDataSourceContext()) {
+        throw lostContextError('`Loca.GeoBufferSource`/`Loca.GeoJSONSource`');
+    }
+    return getDataSourceContext();
+}
+/**
+ * 获取数据源实例，优先使用 props.source，否则回退到上下文中的数据源实例
+ */
+export function useDataSourceInstance(dataSourceInProps) {
+    return () => dataSourceInProps() ?? (hasDataSourceContext() ? getDataSourceContext()() : null);
+}

package/dist/loca/source/data-source/data-source.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Accessor } from '@cn-map/gaode-shared/types';
+export interface DataSourceProps {
+    layer?: Loca.Layer;
+}
+interface SourceWithController<Data> {
+    abort?: () => void;
+    dataset: Loca.DatasetEle<any>[];
+    layers: Loca.Layer[];
+    load: () => void;
+    options: {
+        data?: Data;
+        url?: string;
+    };
+    status: Loca.DataSourceStatus;
+    url: string | undefined;
+}
+type SourceControllerProps<Data> = Readonly<{
+    data?: Data;
+    url?: string;
+}>;
+export declare function useAttributes<Data>(getSource: Accessor<SourceWithController<Data>>, getProps: Accessor<SourceControllerProps<Data>>): void;
+export {};

package/dist/loca/source/data-source/data-source.svelte.js

@@ -0,0 +1,73 @@
+import { snapshot } from "../../../utils/index.js";
+function hasData(data) {
+    return data !== undefined;
+}
+function hasUrl(url) {
+    return typeof url === 'string' && url.length > 0;
+}
+function toSnapshot(data, url) {
+    if (hasData(data)) {
+        return {
+            mode: 'data',
+            value: snapshot(data),
+        };
+    }
+    if (hasUrl(url)) {
+        return {
+            mode: 'url',
+            value: url,
+        };
+    }
+    return {
+        mode: 'idle',
+        value: undefined,
+    };
+}
+function reloadSource(source) {
+    for (const layer of source.layers) {
+        layer.ll?.destroy();
+    }
+    source.abort?.();
+    source.load();
+}
+export function useAttributes(getSource, getProps) {
+    let prevSnapshot;
+    $effect(() => {
+        const source = getSource();
+        const props = getProps();
+        const next = toSnapshot(props.data, props.url);
+        const prev = prevSnapshot;
+        if (next.mode === 'data') {
+            source.options.data = next.value;
+        }
+        else {
+            delete source.options.data;
+        }
+        if (next.mode === 'url') {
+            source.options.url = next.value;
+            source.url = next.value;
+        }
+        else {
+            delete source.options.url;
+            source.url = undefined;
+        }
+        if (next.mode === 'idle') {
+            if (prev && prev.mode !== 'idle') {
+                source.abort?.();
+                source.dataset = [];
+                for (const layer of source.layers) {
+                    layer.receiveDataset?.(source.dataset);
+                }
+            }
+        }
+        else if (!prev) {
+            if (source.status !== 'loading' && source.dataset.length === 0) {
+                source.load();
+            }
+        }
+        else if (prev.mode !== next.mode || prev.value !== next.value) {
+            reloadSource(source);
+        }
+        prevSnapshot = next;
+    });
+}

package/dist/loca/source/data-source/index.d.ts

@@ -0,0 +1,3 @@
+export { setDataSourceContext, useDataSource, useDataSourceInstance } from './context';
+export type { DataSourceProps } from './data-source.svelte';
+export { useAttributes } from './data-source.svelte';

package/dist/loca/source/data-source/index.js

@@ -0,0 +1,2 @@
+export { setDataSourceContext, useDataSource, useDataSourceInstance } from './context';
+export { useAttributes } from './data-source.svelte';

package/dist/loca/source/geo-buffer-source/geo-buffer-source.svelte

@@ -0,0 +1,56 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { Instance } from '../../../types/index.js'
+  import type { DataSourceProps } from '../data-source'
+  import { patchGeoBufferSource } from '@cn-map/gaode-shared/patch'
+  import { onDestroy } from 'svelte'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { setDataSourceContext, useAttributes } from '../data-source'
+
+  patchGeoBufferSource()
+
+  type GeoBufferSourceInitOptions = Loca.GeoBufferSourceOptions & DataSourceProps & Instance<Loca.GeoBufferSource>
+
+  export type GeoBufferSourceProps = GeoBufferSourceInitOptions & { children?: Snippet }
+
+  let { instance = $bindable(), layer, children, ...props }: GeoBufferSourceProps = $props()
+
+  const restProps = omitProps(() => props)
+  const geoBufferSource = $state.raw<Loca.GeoBufferSource>(new Loca.GeoBufferSource(snapshot(restProps)))
+
+  setDataSourceContext(() => geoBufferSource)
+
+  $effect(() => {
+    instance = geoBufferSource
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!layer) return
+
+    layer.setSource(geoBufferSource)
+
+    return () => {
+      if (!layer) return
+      geoBufferSource.Mr(layer)
+    }
+  })
+
+  onDestroy(() => {
+    // @ts-expect-error patch
+    geoBufferSource.abort()
+    geoBufferSource.destroy()
+  })
+
+  useAttributes(
+    () => geoBufferSource,
+    () => props
+  )
+</script>
+
+{#if children}
+  {@render children()}
+{/if}

package/dist/loca/source/geo-buffer-source/geo-buffer-source.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import type { Instance } from '../../../types/index.ts';
+import type { DataSourceProps } from '../data-source';
+type GeoBufferSourceInitOptions = Loca.GeoBufferSourceOptions & DataSourceProps & Instance<Loca.GeoBufferSource>;
+export type GeoBufferSourceProps = GeoBufferSourceInitOptions & {
+    children?: Snippet;
+};
+declare const GeoBufferSource: import("svelte").Component<GeoBufferSourceProps, {}, "instance">;
+type GeoBufferSource = ReturnType<typeof GeoBufferSource>;
+export default GeoBufferSource;

package/dist/loca/source/geo-buffer-source/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GeoBufferSource } from './geo-buffer-source.svelte';
+export type { GeoBufferSourceProps } from './geo-buffer-source.svelte';

package/dist/loca/source/geo-buffer-source/index.js

@@ -0,0 +1 @@
+export { default as GeoBufferSource } from './geo-buffer-source.svelte';

package/dist/loca/source/geo-json-source/geo-json-source.svelte

@@ -0,0 +1,56 @@
+<script lang="ts">
+  import type { Snippet } from 'svelte'
+  import type { Instance } from '../../../types/index.js'
+  import type { DataSourceProps } from '../data-source'
+  import { patchGeoJSONSource } from '@cn-map/gaode-shared/patch'
+  import { onDestroy } from 'svelte'
+  import { omitProps, snapshot } from '../../../utils/index.js'
+  import { setDataSourceContext, useAttributes } from '../data-source'
+
+  patchGeoJSONSource()
+
+  type GeoJSONSourceInitOptions = Loca.GeoJSONSourceOptions & DataSourceProps & Instance<Loca.GeoJSONSource>
+
+  export type GeoJSONSourceProps = GeoJSONSourceInitOptions & { children?: Snippet }
+
+  let { instance = $bindable(), layer, children, ...props }: GeoJSONSourceProps = $props()
+
+  const restProps = omitProps(() => props)
+  const geoJSONSource = $state.raw<Loca.GeoJSONSource>(new Loca.GeoJSONSource(snapshot(restProps)))
+
+  setDataSourceContext(() => geoJSONSource)
+
+  $effect(() => {
+    instance = geoJSONSource
+
+    return () => {
+      instance = null
+    }
+  })
+
+  $effect(() => {
+    if (!layer) return
+
+    layer.setSource(geoJSONSource)
+
+    return () => {
+      if (!layer) return
+      geoJSONSource.Mr(layer)
+    }
+  })
+
+  onDestroy(() => {
+    // @ts-expect-error patch
+    geoJSONSource.abort()
+    geoJSONSource.destroy()
+  })
+
+  useAttributes(
+    () => geoJSONSource,
+    () => props
+  )
+</script>
+
+{#if children}
+  {@render children()}
+{/if}

package/dist/loca/source/geo-json-source/geo-json-source.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import type { Instance } from '../../../types/index.ts';
+import type { DataSourceProps } from '../data-source';
+type GeoJSONSourceInitOptions = Loca.GeoJSONSourceOptions & DataSourceProps & Instance<Loca.GeoJSONSource>;
+export type GeoJSONSourceProps = GeoJSONSourceInitOptions & {
+    children?: Snippet;
+};
+declare const GeoJsonSource: import("svelte").Component<GeoJSONSourceProps, {}, "instance">;
+type GeoJsonSource = ReturnType<typeof GeoJsonSource>;
+export default GeoJsonSource;

package/dist/loca/source/geo-json-source/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GeoJSONSource } from './geo-json-source.svelte';
+export type { GeoJSONSourceProps } from './geo-json-source.svelte';

package/dist/loca/source/geo-json-source/index.js

@@ -0,0 +1 @@
+export { default as GeoJSONSource } from './geo-json-source.svelte';

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

@@ -0,0 +1,3 @@
+export { useDataSource } from './data-source';
+export { GeoBufferSource, type GeoBufferSourceProps } from './geo-buffer-source';
+export { GeoJSONSource, type GeoJSONSourceProps } from './geo-json-source';

package/dist/loca/source/index.js

@@ -0,0 +1,3 @@
+export { useDataSource } from './data-source';
+export { GeoBufferSource } from './geo-buffer-source';
+export { GeoJSONSource } from './geo-json-source';