@swr-data-lab/components 1.13.0 → 1.13.2

package/dist/maplibre/MapStyle/index.d.ts

@@ -0,0 +1,2 @@
+export { SWRDataLabLight };
+import SWRDataLabLight from './SWRDataLabLight';

package/dist/maplibre/MapStyle/tokens.d.ts

@@ -0,0 +1,20 @@
+declare const tokens: {
+    sans_regular: string[];
+    sans_medium: string[];
+    sans_bold: string[];
+    background: string;
+    water: string;
+    water_light: string;
+    marsh: string;
+    grass: string;
+    grass_dark: string;
+    street_primary: string;
+    street_primary_outline: string;
+    street_secondary: string;
+    street_secondary_outline: string;
+    street_tertiary: string;
+    street_tertiary_outline: string;
+    label_primary: string;
+    label_secondary: string;
+};
+export default tokens;

package/dist/maplibre/MapStyle/tokens.js

@@ -0,0 +1,20 @@
+const tokens = {
+    sans_regular: ['SWR Sans Regular'],
+    sans_medium: ['SWR Sans Medium'],
+    sans_bold: ['SWR Sans Bold'],
+    background: 'hsl(0, 0%, 100%)',
+    water: 'hsl(210, 41%, 87%)',
+    water_light: 'hsl(210, 41%, 90%)',
+    marsh: 'hsl(200, 14%, 97%)',
+    grass: 'hsl(149, 37%, 97%)',
+    grass_dark: 'hsl(149, 37%, 93%)',
+    street_primary: 'hsl(0, 0%, 95%)',
+    street_primary_outline: 'hsla(0, 0%, 0%, 20%)',
+    street_secondary: 'hsl(0, 0%, 95%)',
+    street_secondary_outline: 'hsl(0, 0%, 50%)',
+    street_tertiary: 'hsl(0, 0%, 95%)',
+    street_tertiary_outline: 'hsl(0, 0%, 50%)',
+    label_primary: 'rgb(10, 10, 11)',
+    label_secondary: 'hsl(240, 2%, 20%)'
+};
+export default tokens;

package/dist/maplibre/NavigationControl/NavigationControl.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">import maplibre, {} from 'maplibre-gl';
+import MapControl from '../MapControl/MapControl.svelte';
+const { showCompass = false, visualizePitch = false, position = 'bottom-left' } = $props();
+</script>
+
+<MapControl control={new maplibre.NavigationControl({ showCompass, visualizePitch })} {position} />
+
+<style>
+</style>

package/dist/maplibre/NavigationControl/NavigationControl.svelte.d.ts

@@ -0,0 +1,12 @@
+import { type ControlPosition } from 'maplibre-gl';
+interface NavigationControlProps {
+    showCompass?: boolean;
+    /**
+     * Show 3d tilt in the compass control. Requires `showCompass` to be `true`
+     */
+    visualizePitch?: boolean;
+    position?: ControlPosition;
+}
+declare const NavigationControl: import("svelte").Component<NavigationControlProps, {}, "">;
+type NavigationControl = ReturnType<typeof NavigationControl>;
+export default NavigationControl;

package/dist/maplibre/NavigationControl/index.d.ts

@@ -0,0 +1,2 @@
+export default NavigationControl;
+import NavigationControl from './NavigationControl.svelte';

package/dist/maplibre/ScaleControl/ScaleControl.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">import maplibre, {} from 'maplibre-gl';
+import MapControl from '../MapControl/MapControl.svelte';
+let { maxWidth = 100, unit = 'metric', position = 'bottom-left' } = $props();
+</script>
+
+<MapControl control={new maplibre.ScaleControl({ maxWidth, unit })} {position} />
+
+<style>
+</style>

package/dist/maplibre/ScaleControl/ScaleControl.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type ControlPosition, type Unit } from 'maplibre-gl';
+interface ScaleControlProps {
+    maxWidth?: number | undefined;
+    position?: ControlPosition;
+    unit?: Unit;
+}
+declare const ScaleControl: import("svelte").Component<ScaleControlProps, {}, "">;
+type ScaleControl = ReturnType<typeof ScaleControl>;
+export default ScaleControl;

package/dist/maplibre/ScaleControl/index.d.ts

@@ -0,0 +1,2 @@
+export default ScaleControl;
+import ScaleControl from './ScaleControl.svelte';

package/dist/maplibre/Source/MapSource.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">import { onDestroy } from 'svelte';
+import {} from 'maplibre-gl';
+import { getMapContext, createSourceContext } from '../context.svelte.js';
+let { id, sourceSpec, source = $bindable(), children } = $props();
+let firstRun = true;
+// Get map context
+const { map, styleLoaded } = $derived(getMapContext());
+// Create source context
+const sourceContext = createSourceContext();
+// 1. Add the source to the map using the spec, then get the
+// actual source object back from the map instance
+$effect(() => {
+    if (map && styleLoaded) {
+        // See: https://svelte.dev/docs/svelte/$state#$state.snapshot
+        map.addSource(id, $state.snapshot(sourceSpec));
+        source = map.getSource(id);
+        firstRun = true;
+    }
+});
+// 2. Do extra stuff with the source object
+$effect(() => {
+    if (source) {
+    }
+});
+$effect(() => {
+    source;
+    firstRun = false;
+});
+onDestroy(() => {
+    if (map && styleLoaded) {
+        const layers = map?.getStyle().layers;
+        layers
+            .filter((l) => l.type !== 'background' && l.source == id)
+            .forEach((l) => {
+            map?.removeLayer(l.id);
+        });
+        map.removeSource(id);
+        source = undefined;
+    }
+});
+</script>
+
+{@render children?.()}

package/dist/maplibre/Source/MapSource.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type Snippet } from 'svelte';
+import { type Map, type SourceSpecification } from 'maplibre-gl';
+type Source = maplibregl.VectorTileSource;
+interface MapSourceProps {
+    id: string;
+    sourceSpec: SourceSpecification;
+    source?: Source;
+    onLoad?: (map: Map, url?: string, data?: string) => undefined;
+    children?: Snippet;
+}
+declare const MapSource: import("svelte").Component<MapSourceProps, {}, "source">;
+type MapSource = ReturnType<typeof MapSource>;
+export default MapSource;

package/dist/maplibre/Source/index.d.ts

@@ -0,0 +1,2 @@
+export default MapSource;
+import MapSource from './MapSource.svelte';

package/dist/maplibre/Source/source.d.ts

@@ -0,0 +1,28 @@
+import type { Map, SourceSpecification } from 'maplibre-gl';
+/**
+ * Add a source to the map.
+ *
+ * @param map - The map instance
+ * @param sourceId - The ID of the source to add
+ * @param source - The source specification object
+ * @param okToAdd - Callback to check if the source should still be added
+ * @param cb - Callback when the source has been added
+ *
+ * This properly handles the case where an old source with the same ID is still being removed.
+ */
+export declare function addSource(map: Map, sourceId: string, source: SourceSpecification, okToAdd: (sourceId: string) => boolean, cb: () => void): void;
+/**
+ * A helper function that removes a source from the map after all of the layers inside it have
+ * had a chance to remove themselves.
+ *
+ * @param {Readable<Map|undefined>} mapStore - The store containing the Map instance
+ * @param {string} sourceId - The ID of the source to remove
+ * @param {unknown} sourceObj - The source object that was originally added
+ *
+ * Waits one tick to ensure layers have a chance to be removed, then checks if the
+ * source with the given ID is still the same object as was originally added.
+ *
+ * If so, it removes the source from the map. This avoids removing a source that was
+ * already replaced by another source reusing the same ID.
+ */
+export declare function removeSource(map: Map, sourceId: string, sourceObj: unknown): void;

package/dist/maplibre/Source/source.js

@@ -0,0 +1,76 @@
+import { tick } from 'svelte';
+/**
+ * Add a source to the map.
+ *
+ * @param map - The map instance
+ * @param sourceId - The ID of the source to add
+ * @param source - The source specification object
+ * @param okToAdd - Callback to check if the source should still be added
+ * @param cb - Callback when the source has been added
+ *
+ * This properly handles the case where an old source with the same ID is still being removed.
+ */
+export function addSource(map, sourceId, source, okToAdd, cb) {
+    // If there was an old source with the same ID, then remove it. This can happen when removing a source and adding a new source in quick succession.
+    let removed = false;
+    if (map.getSource(sourceId)) {
+        removed = true;
+        map.removeSource(sourceId);
+    }
+    const doAddSource = () => {
+        if (!okToAdd(sourceId)) {
+            // in case the component was destroyed or the id changed while waiting to call this
+            return;
+        }
+        map.addSource(sourceId, source);
+        cb();
+    };
+    if (removed) {
+        // Source removal happens quickly but asynchronously, and we have no way to really interlock on when it happens, so just loop until it does.
+        const waitForRemoval = () => {
+            if (!sourceId) {
+                return;
+            }
+            if (map.getSource(sourceId)) {
+                // The source hasn't been removed yet, so keep waiting.
+                setTimeout(waitForRemoval, 1);
+            }
+            else {
+                doAddSource();
+            }
+        };
+        waitForRemoval();
+    }
+    else {
+        // If we don't have an existing source to remove (i.e. the normal case) then
+        // just add the source right away.
+        doAddSource();
+    }
+}
+/**
+ * A helper function that removes a source from the map after all of the layers inside it have
+ * had a chance to remove themselves.
+ *
+ * @param {Readable<Map|undefined>} mapStore - The store containing the Map instance
+ * @param {string} sourceId - The ID of the source to remove
+ * @param {unknown} sourceObj - The source object that was originally added
+ *
+ * Waits one tick to ensure layers have a chance to be removed, then checks if the
+ * source with the given ID is still the same object as was originally added.
+ *
+ * If so, it removes the source from the map. This avoids removing a source that was
+ * already replaced by another source reusing the same ID.
+ */
+export function removeSource(map, sourceId, sourceObj) {
+    tick().then(() => {
+        // Wait a tick so that the layers inside this source can all be removed.
+        // But make sure that the source wasn't already replaced with another source with the same ID.
+        if (!map.loaded()) {
+            return;
+        }
+        let remainingSource = map.getSource(sourceId);
+        if (remainingSource === sourceObj) {
+            map.removeSource(sourceId);
+        }
+    });
+}

package/dist/maplibre/Tooltip/Tooltip.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">import { onDestroy } from 'svelte';
+import maplibre, {} from 'maplibre-gl';
+import { getMapContext } from '../context.svelte.js';
+import { resetPopupEventListener } from '../utils';
+let { position, children, offset = 20, maxWidth = 360, showCloseButton = false, closeOnClick = true, mouseEvents = false, onClose, onOpen } = $props();
+const { map } = $derived(getMapContext());
+let tooltip = new maplibre.Popup({
+    closeButton: showCloseButton,
+    closeOnClick: closeOnClick,
+    maxWidth: `${maxWidth}px`,
+    offset: offset
+});
+let el = $state();
+$effect(() => {
+    if (position && el && map) {
+        tooltip.setLngLat(position).setDOMContent(el).addTo(map);
+    }
+    else {
+        tooltip.remove();
+    }
+});
+// Bind events
+$effect(() => resetPopupEventListener(tooltip, 'open', onOpen));
+$effect(() => resetPopupEventListener(tooltip, 'close', onClose));
+onDestroy(() => tooltip.remove());
+</script>
+
+<div bind:this={el} class="container" class:mouseEvents>
+	{@render children?.()}
+</div>
+
+<style>
+	.container {
+		background: white;
+		padding: 0.75em;
+		border-radius: 2px;
+		border: 1px solid rgba(0, 0, 0, 0.75);
+		border-radius: var(--br-small);
+		filter: drop-shadow(2px 2px 2px rgba(0, 0, 0, 0.1));
+		pointer-events: none;
+	}
+
+	.mouseEvents {
+		pointer-events: all;
+	}
+</style>

package/dist/maplibre/Tooltip/Tooltip.svelte.d.ts

@@ -0,0 +1,25 @@
+import { type Snippet } from 'svelte';
+import { type Listener, type LngLatLike } from 'maplibre-gl';
+interface TooltipProps {
+    position: LngLatLike | undefined;
+    children?: Snippet;
+    maxWidth?: number;
+    showCloseButton?: boolean;
+    /**
+     * Close the tooltip if the user clicks anywhere on the map
+     */
+    closeOnClick?: boolean;
+    /**
+     * y axis offset (px)
+     */
+    offset?: number;
+    /**
+     * Toggle mouse events on the tooltip element. Should be false if the tooltip appears on hover to avoid flickering.
+     */
+    mouseEvents?: boolean;
+    onClose?: Listener | undefined;
+    onOpen?: Listener | undefined;
+}
+declare const Tooltip: import("svelte").Component<TooltipProps, {}, "">;
+type Tooltip = ReturnType<typeof Tooltip>;
+export default Tooltip;

package/dist/maplibre/Tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export default Tooltip;
+import Tooltip from './Tooltip.svelte';

package/dist/maplibre/VectorLayer/VectorLayer.svelte

@@ -0,0 +1,73 @@
+<script lang="ts">import { getMapContext } from '../context.svelte.js';
+import { onDestroy } from 'svelte';
+import { resetLayerEventListener } from '../utils.js';
+const { id, sourceId, sourceLayer, visible = true, placeBelow = 'label-place-capital', type, paint, layout, hovered = $bindable(), selected = $bindable(), minZoom = 0, maxZoom = 24, onclick, onmousemove, onmouseleave } = $props();
+const { map, styleLoaded } = $derived(getMapContext());
+let beforeId = $state();
+let prevSelected = $state();
+let prevHovered = $state();
+const layerSpec = {
+    id,
+    type,
+    source: sourceId,
+    'source-layer': sourceLayer,
+    layout: $state.snapshot(layout) ?? {},
+    paint: $state.snapshot(paint) ?? {},
+    minzoom: minZoom,
+    maxzoom: maxZoom
+};
+$effect(() => {
+    if (map && styleLoaded) {
+        const style = map.getStyle();
+        beforeId = style.layers.find((l) => {
+            return l.id === placeBelow;
+        })?.id;
+    }
+});
+$effect(() => {
+    if (map && styleLoaded && beforeId) {
+        map.addLayer(layerSpec, beforeId);
+    }
+});
+$effect(() => resetLayerEventListener(map, 'click', id, onclick));
+$effect(() => resetLayerEventListener(map, 'mousemove', id, onmousemove));
+$effect(() => resetLayerEventListener(map, 'mouseleave', id, onmouseleave));
+// Set hovered feature state
+$effect(() => {
+    if (styleLoaded) {
+        if (hovered) {
+            if (prevHovered) {
+                map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: prevHovered }, { hovered: false });
+            }
+            map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: hovered.id }, { hovered: true });
+            prevHovered = hovered.id;
+        }
+        else {
+            if (prevHovered) {
+                map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: prevHovered }, { hovered: false });
+            }
+        }
+    }
+});
+// Set selected feature state
+$effect(() => {
+    if (styleLoaded) {
+        if (selected) {
+            if (prevSelected) {
+                map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: prevSelected }, { selected: false });
+            }
+            map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: selected.id }, { selected: true });
+            prevSelected = selected.id;
+        }
+        else {
+            if (prevSelected) {
+                map?.setFeatureState({ source: sourceId, sourceLayer: sourceLayer, id: prevSelected }, { selected: false });
+            }
+        }
+    }
+});
+onDestroy(() => {
+    if (map && map.getLayer(id))
+        map.removeLayer(id);
+});
+</script>

package/dist/maplibre/VectorLayer/VectorLayer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { CircleLayoutProps, CirclePaintProps, FillLayoutProps, FillPaintProps, LineLayoutProps, SymbolPaintProps, SymbolLayoutProps, LinePaintProps, MapGeoJSONFeature, MapLayerMouseEvent } from 'maplibre-gl';
+interface VectorLayerProps {
+    id: string;
+    sourceId: string;
+    sourceLayer: string;
+    type: 'line' | 'fill' | 'circle' | 'symbol';
+    placeBelow: string;
+    visible?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    paint?: LinePaintProps | FillPaintProps | CirclePaintProps | SymbolPaintProps;
+    layout?: LineLayoutProps | FillLayoutProps | CircleLayoutProps | SymbolLayoutProps;
+    hovered?: MapGeoJSONFeature | undefined;
+    selected?: MapGeoJSONFeature | undefined;
+    onclick: (e: MapLayerMouseEvent) => any;
+    onmousemove: (e: MapLayerMouseEvent) => any;
+    onmouseleave: (e: MapLayerMouseEvent) => any;
+}
+declare const VectorLayer: import("svelte").Component<VectorLayerProps, {}, "hovered" | "selected">;
+type VectorLayer = ReturnType<typeof VectorLayer>;
+export default VectorLayer;

package/dist/maplibre/VectorLayer/index.d.ts

@@ -0,0 +1,2 @@
+export default VectorLayer;
+import VectorLayer from './VectorLayer.svelte';

package/dist/maplibre/VectorTileSource/VectorTileSource.svelte

@@ -0,0 +1,13 @@
+<script lang="ts">import {} from 'svelte';
+import {} from 'maplibre-gl';
+import MapSource from '../Source/MapSource.svelte';
+const { minZoom = 0, maxZoom = 24, id, url } = $props();
+const sourceSpec = {
+    type: 'vector',
+    tiles: [url],
+    maxzoom: maxZoom,
+    minzoom: minZoom
+};
+</script>
+
+<MapSource {id} {sourceSpec} />

package/dist/maplibre/VectorTileSource/VectorTileSource.svelte.d.ts

@@ -0,0 +1,11 @@
+import { type Snippet } from 'svelte';
+interface VectorTileSourceProps {
+    id: string;
+    url: string;
+    minZoom?: number;
+    maxZoom?: number;
+    children?: Snippet;
+}
+declare const VectorTileSource: import("svelte").Component<VectorTileSourceProps, {}, "">;
+type VectorTileSource = ReturnType<typeof VectorTileSource>;
+export default VectorTileSource;

package/dist/maplibre/VectorTileSource/index.d.ts

@@ -0,0 +1,2 @@
+export default VectorTileSource;
+import VectorTileSource from './VectorTileSource.svelte';

package/dist/maplibre/WithLinkLocation/WithLinkLocation.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">import { onMount, setContext } from 'svelte';
+import { MaptilerGeocoderAPI } from '../GeocoderControl/GeocoderAPIs';
+import {} from '../types';
+const { key, service = 'maptiler', countries = 'de', languages = 'de', urlParameter = 'location', children } = $props();
+const countriesArr = Array.isArray(countries) ? countries : [countries];
+const languagesArr = Array.isArray(languages) ? languages : [languages];
+let geocoder;
+if (service === 'maptiler') {
+    geocoder = new MaptilerGeocoderAPI(key);
+}
+let location = $state();
+function bboxToArea(bbox) {
+    return (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]);
+}
+onMount(async () => {
+    const params = new URLSearchParams(window.location.search);
+    if (params.has(urlParameter)) {
+        const config = {
+            countries: countriesArr.join(','),
+            language: languagesArr.join(','),
+            query: params.get(urlParameter)?.toString(),
+            limit: 1
+        };
+        const res = await geocoder.forwardGeocode(config);
+        if (res.features[0].bbox && res.features[0].geometry.type === 'Point') {
+            location = {
+                lat: res.features[0].geometry.coordinates[1],
+                lng: res.features[0].geometry.coordinates[0],
+                zoom: 11 - bboxToArea(res.features[0].bbox) * 5.5
+            };
+        }
+    }
+    else {
+        location = false;
+    }
+});
+$effect.pre(() => {
+    setContext('initialLocation', location);
+});
+</script>
+
+{#if location !== undefined}
+	{@render children?.()}
+{/if}

package/dist/maplibre/WithLinkLocation/WithLinkLocation.svelte.d.ts

@@ -0,0 +1,19 @@
+import { type Snippet } from 'svelte';
+import { type GeocodingCountry, type GeocodingLanguage, type GeocodingService } from '../types';
+interface WithLinkLocationProps {
+    service?: GeocodingService;
+    /**
+     * API key for selected geocoding `service`
+     */
+    key: string;
+    /**
+     * Limit search to one or more countries
+     */
+    countries?: GeocodingLanguage | GeocodingCountry[];
+    languages?: GeocodingLanguage | GeocodingLanguage[];
+    urlParameter?: string;
+    children: Snippet;
+}
+declare const WithLinkLocation: import("svelte").Component<WithLinkLocationProps, {}, "">;
+type WithLinkLocation = ReturnType<typeof WithLinkLocation>;
+export default WithLinkLocation;

package/dist/maplibre/WithLinkLocation/index.d.ts

@@ -0,0 +1,2 @@
+export default WithLinkLocation;
+import WithLinkLocation from './WithLinkLocation.svelte';

package/dist/maplibre/context.svelte.d.ts

@@ -0,0 +1,33 @@
+import type { Map as MapLibre, Marker, LayerSpecification } from 'maplibre-gl';
+export declare class Box<T> {
+    value: T;
+    constructor(initialValue: T);
+}
+export declare class MapContext {
+    _map: MapLibre | null;
+    minzoom: number;
+    maxzoom: number;
+    styleLoaded: boolean;
+    private _listener?;
+    get map(): maplibregl.Map | null;
+    set map(value: maplibregl.Map | null);
+    private _onstyledata;
+}
+export declare class SourceContext {
+    _source: unknown;
+    loaded: boolean;
+    minzoom: number;
+    maxzoom: number;
+    get source(): unknown;
+}
+export declare class LayerContext {
+    layer: LayerSpecification;
+}
+export declare function setPopupTarget(value: Box<Marker | string | undefined>): void;
+export declare function getPopupTarget(): Box<Marker | string> | undefined;
+export declare function createMapContext(): MapContext;
+export declare function getMapContext(): MapContext;
+export declare function createSourceContext(): SourceContext;
+export declare function getSourceContext(): SourceContext;
+export declare function getLayerContext(): LayerContext;
+export declare function setLayerContext(value: string): void;

package/dist/maplibre/context.svelte.js

@@ -0,0 +1,73 @@
+import { getContext, setContext } from 'svelte';
+const MAP_CONTEXT_KEY = Symbol.for('map-context');
+const SOURCE_CONTEXT_KEY = Symbol.for('source-context');
+const LAYER_CONTEXT_KEY = Symbol.for('layer-context');
+const POPUP_TARGET_KEY = Symbol.for('popup-target');
+export class Box {
+    value = $state();
+    constructor(initialValue) {
+        this.value = initialValue;
+    }
+}
+export class MapContext {
+    _map = $state(null);
+    minzoom = $state(0);
+    maxzoom = $state(24);
+    styleLoaded = $state(false);
+    _listener = undefined;
+    get map() {
+        return this._map;
+    }
+    set map(value) {
+        // Unbind any old event listeners
+        if (this._listener) {
+            this._map?.off('styledata', this._listener);
+            this._listener = undefined;
+        }
+        // Set new map instance and bind new event listeners
+        this._map = value;
+        if (this._map) {
+            this._listener = this._onstyledata.bind(this);
+            this._map.on('styledata', this._listener);
+        }
+    }
+    _onstyledata(e) {
+        this.styleLoaded = true;
+    }
+}
+export class SourceContext {
+    _source = $state();
+    loaded = $state(false);
+    minzoom = $state(0);
+    maxzoom = $state(24);
+    get source() {
+        return this._source;
+    }
+}
+export class LayerContext {
+    layer = $state();
+}
+export function setPopupTarget(value) {
+    setContext(POPUP_TARGET_KEY, value);
+}
+export function getPopupTarget() {
+    return getContext(POPUP_TARGET_KEY);
+}
+export function createMapContext() {
+    return setContext(MAP_CONTEXT_KEY, new MapContext());
+}
+export function getMapContext() {
+    return getContext(MAP_CONTEXT_KEY);
+}
+export function createSourceContext() {
+    return setContext(SOURCE_CONTEXT_KEY, new SourceContext());
+}
+export function getSourceContext() {
+    return getContext(SOURCE_CONTEXT_KEY);
+}
+export function getLayerContext() {
+    return getContext(LAYER_CONTEXT_KEY);
+}
+export function setLayerContext(value) {
+    setContext(LAYER_CONTEXT_KEY, value);
+}