@accelint/map-toolkit 0.3.1 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @accelint/map-toolkit
 
+## 0.4.1
+
+### Patch Changes
+
+- bb73a1e: Ensure dependencies all follow the same semver range across devtk, maptk, and designtk.
+- Updated dependencies [bb73a1e]
+  - @accelint/core@0.5.2
+  - @accelint/bus@3.0.2
+  - @accelint/geo@0.4.2
+
+## 0.4.0
+
+### Minor Changes
+
+- 8802d14: Add map-cursor controller to map-toolkit.
+
+### Patch Changes
+
+- 34c42a0: Swap bundling to tsdown and auto generate exports entries in package.json.
+- Updated dependencies [34c42a0]
+  - @accelint/core@0.5.1
+  - @accelint/bus@3.0.1
+  - @accelint/geo@0.4.1
+
 ## 0.3.1
 
 ### Patch Changes
@@ -8,62 +32,62 @@
   - @accelint/geo@0.4.0
 
 ## 0.3.0
+
 ### Minor Changes
 
 - 7131cc0: Add `useCursorCoordinates`, a hook to retrieve the current coordinates for the mouse hovered position
 - 874edd5: ## Breaking Change: Structured Clone Constraint
-  
+
   The event bus payload is now constrained to values that are serializable by the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm). This constraint aligns the TypeScript types with the actual runtime behavior of the `BroadcastChannel` API.
-  
+
   ### What this means
-  
+
   You can no longer pass the following types in event payloads:
-  
   - Functions
   - Symbols
   - DOM nodes
   - Prototype chains (class instances lose their methods)
   - Properties with `undefined` values (they're omitted)
-  
+
   ### How to migrate
-  
+
   **❌ Before:**
-  
+
   ```typescript
-  bus.emit('user-action', {
-    callback: () => console.log('done'), // ❌ Function
+  bus.emit("user-action", {
+    callback: () => console.log("done"), // ❌ Function
     userData: userClass, // ❌ Class instance with methods
-    element: document.getElementById('foo'), // ❌ DOM node
+    element: document.getElementById("foo"), // ❌ DOM node
   });
   ```
-  
+
   **✅ After:**
-  
+
   ```typescript
   // Option 1: Send only data, handle logic separately
-  bus.emit('user-action', {
-    actionType: 'complete', // ✅ Primitive
+  bus.emit("user-action", {
+    actionType: "complete", // ✅ Primitive
     userData: { id: userClass.id, name: userClass.name }, // ✅ Plain object
-    elementId: 'foo', // ✅ Reference by ID
+    elementId: "foo", // ✅ Reference by ID
   });
-  
+
   // Option 2: Use event types to trigger behavior
-  bus.on('user-action-complete', () => {
-    console.log('done'); // Handle callback logic in listener
+  bus.on("user-action-complete", () => {
+    console.log("done"); // Handle callback logic in listener
   });
   ```
-  
+
   ### Supported types
-  
   - Primitives (string, number, boolean, null, BigInt)
   - Plain objects and arrays
   - Date, RegExp, Map, Set
   - Typed arrays (Uint8Array, etc.)
   - ArrayBuffer, Blob, File
-  
+
   ### Finding issues
-  
+
   TypeScript will now catch most violations at compile time. Runtime errors from `BroadcastChannel.postMessage()` indicate non-serializable values that slipped through.
+
 - e8535c4: Adds ViewportSize component that shows the width and height of the viewport and updates with changes.
   Adds useViewportState for more fine-grained control of viewport data (lat/lon/zoom/bounds). Exports `useEffectEvent` ponyfill from `@accelint/bus/react`.
 
@@ -73,10 +97,11 @@
 - 99f6cd5: Add map-mode/store getCurrentModeOwner method to access the current map mode owner.
 - 80db585: BREAKING CHANGES:
   Design Toolkit no longer exports `tv`, this is now available from Design Foundation
-  
+
   Created new package @accelint/design-foundation that houses all of the Tailwind tokens, variants, base styles and utilities for easier reuse without having a dependency on the larger Design Toolkit
-  
+
   Updated Map Toolkit Storybook and NextJS demo app styles to import the new Design Foundation
+
 - f157e42: update picking info to remove more unserializable properties in map-toolkit
 - 7539bbb: update vite config in map-toolkit to re-enable base-map render in storybook preview
 - 86a95cf: refactor map mode to use module useSyncExternalStore pattern instead of class.

package/catalog-info.yaml

@@ -11,15 +11,14 @@ metadata:
 
     Dependencies:
 
-    accelint_biome-config@1.0.2, accelint_bus@3.0.0,
-    accelint_constellation-tracker@1.0.1, accelint_core@0.5.0,
-    accelint_design-foundation@1.0.0, accelint_design-toolkit@8.1.0,
-    accelint_geo@0.4.0, accelint_typescript-config@0.1.4,
-    accelint_vitest-config@0.1.5
+    accelint_biome-config@1.0.2, accelint_bus@3.0.2, accelint_core@0.5.2,
+    accelint_design-foundation@2.0.0, accelint_design-toolkit@9.0.0,
+    accelint_geo@0.4.1, accelint_typescript-config@0.1.4,
+    accelint_vitest-config@0.1.6
   annotations:
     backstage.io/edit-url: https://github.com/gohypergiant/standard-toolkit/blob/main/packages/map-toolkit/catalog-info.yaml
     backstage.io/techdocs-ref: dir:.
-    package/version: 0.3.1
+    package/version: 0.4.1
     github.com/project-slug: gohypergiant/standard-toolkit
   links:
     - url: https://github.com/gohypergiant/standard-toolkit/tree/main/packages/map-toolkit
@@ -38,7 +37,6 @@ spec:
   dependsOn:
     - component:accelint_biome-config
     - component:accelint_bus
-    - component:accelint_constellation-tracker
     - component:accelint_core
     - component:accelint_design-foundation
     - component:accelint_design-toolkit

package/dist/cursor-coordinates/index.d.ts

@@ -1,3 +1,14 @@
-export { CoordinateFormatTypes, clearCursorCoordinateState, useCursorCoordinates } from './use-cursor-coordinates.js';
-import '@accelint/geo';
-import '@accelint/core';
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { CoordinateFormatTypes, clearCursorCoordinateState, useCursorCoordinates } from "./use-cursor-coordinates.js";
+export { type CoordinateFormatTypes, clearCursorCoordinateState, useCursorCoordinates };

package/dist/cursor-coordinates/index.js

@@ -1,3 +1,16 @@
-export { clearCursorCoordinateState, useCursorCoordinates } from './use-cursor-coordinates.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { clearCursorCoordinateState, useCursorCoordinates } from "./use-cursor-coordinates.js";
+
+export { clearCursorCoordinateState, useCursorCoordinates };

package/dist/cursor-coordinates/use-cursor-coordinates.d.ts

@@ -1,6 +1,19 @@
-import { coordinateSystems } from '@accelint/geo';
-import { UniqueId } from '@accelint/core';
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
 
+import { coordinateSystems } from "@accelint/geo";
+import { UniqueId } from "@accelint/core";
+
+//#region src/cursor-coordinates/use-cursor-coordinates.d.ts
 /**
  * Supported coordinate format types for displaying map coordinates.
  *
@@ -69,8 +82,9 @@ declare function clearCursorCoordinateState(instanceId: UniqueId): void;
  * ```
  */
 declare function useCursorCoordinates(id?: UniqueId): {
-    formattedCoord: string;
-    setFormat: (format: CoordinateFormatTypes) => void;
+  formattedCoord: string;
+  setFormat: (format: CoordinateFormatTypes) => void;
 };
-
-export { type CoordinateFormatTypes, clearCursorCoordinateState, useCursorCoordinates };
+//#endregion
+export { CoordinateFormatTypes, clearCursorCoordinateState, useCursorCoordinates };
+//# sourceMappingURL=use-cursor-coordinates.d.ts.map

package/dist/cursor-coordinates/use-cursor-coordinates.js

@@ -1,161 +1,280 @@
-import 'client-only';
-import { Broadcast } from '@accelint/bus';
-import { createCoordinate, coordinateSystems } from '@accelint/geo';
-import { useContext, useSyncExternalStore, useMemo } from 'react';
-import { MapEvents } from '../deckgl/base-map/events.js';
-import { MapContext } from '../deckgl/base-map/provider.js';
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
 
+
+'use client';
+
+import { MapEvents } from "../deckgl/base-map/events.js";
+import { MapContext } from "../deckgl/base-map/provider.js";
+import { Broadcast } from "@accelint/bus";
+import { coordinateSystems, createCoordinate } from "@accelint/geo";
+import { useContext, useMemo, useSyncExternalStore } from "react";
+
+//#region src/cursor-coordinates/use-cursor-coordinates.ts
 const bus = Broadcast.getInstance();
 const create = createCoordinate(coordinateSystems.dd, "LONLAT");
 const MAX_LONGITUDE = 180;
 const LONGITUDE_RANGE = 360;
 const COORDINATE_PRECISION = 8;
 const DEFAULT_COORDINATE = "--, --";
+/**
+* Prepares coordinates for display by normalizing longitude and formatting with cardinal directions.
+* Normalizes longitude to -180 to 180 range and formats both longitude and latitude with
+* compass directions (E/W for longitude, N/S for latitude).
+*
+* @param coord - Tuple of [longitude, latitude] coordinates
+* @returns Formatted string in the format "LON.NNNNNNNN E/W / LAT.NNNNNNNN N/S"
+*/
 const prepareCoord = (coord) => {
-  let lon = coord[0];
-  lon = ((lon + MAX_LONGITUDE) % LONGITUDE_RANGE + LONGITUDE_RANGE) % LONGITUDE_RANGE - MAX_LONGITUDE;
-  const lat = coord[1];
-  const lonStr = `${Math.abs(lon).toFixed(COORDINATE_PRECISION)} ${lon < 0 ? "W" : "E"}`;
-  const latStr = `${Math.abs(lat).toFixed(COORDINATE_PRECISION)} ${lat < 0 ? "S" : "N"}`;
-  return `${lonStr} / ${latStr}`;
+	let lon = coord[0];
+	lon = ((lon + MAX_LONGITUDE) % LONGITUDE_RANGE + LONGITUDE_RANGE) % LONGITUDE_RANGE - MAX_LONGITUDE;
+	const lat = coord[1];
+	return `${`${Math.abs(lon).toFixed(COORDINATE_PRECISION)} ${lon < 0 ? "W" : "E"}`} / ${`${Math.abs(lat).toFixed(COORDINATE_PRECISION)} ${lat < 0 ? "S" : "N"}`}`;
 };
+/**
+* Type guard to validate that a value is a proper coordinate tuple.
+* Checks that the value is an array with exactly two finite numbers.
+*
+* @param value - Value to validate as a coordinate
+* @returns True if value is a valid [longitude, latitude] tuple
+*/
 function isValidCoordinate(value) {
-  return Array.isArray(value) && value.length === 2 && value.every(Number.isFinite);
+	return Array.isArray(value) && value.length === 2 && value.every(Number.isFinite);
 }
+/**
+* Store for cursor coordinate state keyed by instanceId
+*/
 const coordinateStore = /* @__PURE__ */ new Map();
+/**
+* Track React component subscribers per instanceId (for fan-out notifications).
+* Each Set contains onStoreChange callbacks from useSyncExternalStore.
+*/
 const componentSubscribers = /* @__PURE__ */ new Map();
+/**
+* Cache of bus unsubscribe functions (1 per instanceId).
+* This ensures we only have one bus listener per map, regardless of
+* how many React components subscribe to it.
+*/
 const busUnsubscribers = /* @__PURE__ */ new Map();
+/**
+* Cache of subscription functions per instanceId to avoid recreating on every render
+*/
 const subscriptionCache = /* @__PURE__ */ new Map();
+/**
+* Cache of snapshot functions per instanceId to maintain referential stability
+*/
 const snapshotCache = /* @__PURE__ */ new Map();
+/**
+* Cache of server snapshot functions per instanceId to maintain referential stability.
+* Server snapshots always return default coordinate since coordinate state is client-only.
+*/
+const serverSnapshotCache = /* @__PURE__ */ new Map();
+/**
+* Ensures a single bus listener exists for the given instanceId.
+* All React subscribers will be notified via fan-out when the bus event fires.
+* This prevents creating N bus listeners for N React components.
+*
+* @param instanceId - The unique identifier for the map
+*/
 function ensureBusListener(instanceId) {
-  if (busUnsubscribers.has(instanceId)) {
-    return;
-  }
-  const unsub = bus.on(MapEvents.hover, (data) => {
-    const eventId = data.payload.id;
-    if (instanceId !== eventId) {
-      return;
-    }
-    const coords = data.payload.info.coordinate;
-    const state = coordinateStore.get(instanceId);
-    if (state) {
-      if (isValidCoordinate(coords)) {
-        state.coordinate = coords;
-      } else {
-        state.coordinate = null;
-      }
-      const subscribers = componentSubscribers.get(instanceId);
-      if (subscribers) {
-        for (const onStoreChange of subscribers) {
-          onStoreChange();
-        }
-      }
-    }
-  });
-  busUnsubscribers.set(instanceId, unsub);
+	if (busUnsubscribers.has(instanceId)) return;
+	const unsub = bus.on(MapEvents.hover, (data) => {
+		if (instanceId !== data.payload.id) return;
+		const coords = data.payload.info.coordinate;
+		const state = coordinateStore.get(instanceId);
+		if (state) {
+			if (isValidCoordinate(coords)) state.coordinate = coords;
+			else state.coordinate = null;
+			const subscribers = componentSubscribers.get(instanceId);
+			if (subscribers) for (const onStoreChange of subscribers) onStoreChange();
+		}
+	});
+	busUnsubscribers.set(instanceId, unsub);
 }
+/**
+* Cleans up the bus listener if no React subscribers remain.
+*
+* @param instanceId - The unique identifier for the map
+*/
 function cleanupBusListenerIfNeeded(instanceId) {
-  const subscribers = componentSubscribers.get(instanceId);
-  if (!subscribers || subscribers.size === 0) {
-    const unsub = busUnsubscribers.get(instanceId);
-    if (unsub) {
-      unsub();
-      busUnsubscribers.delete(instanceId);
-    }
-    coordinateStore.delete(instanceId);
-    componentSubscribers.delete(instanceId);
-    subscriptionCache.delete(instanceId);
-    snapshotCache.delete(instanceId);
-  }
+	const subscribers = componentSubscribers.get(instanceId);
+	if (!subscribers || subscribers.size === 0) {
+		const unsub = busUnsubscribers.get(instanceId);
+		if (unsub) {
+			unsub();
+			busUnsubscribers.delete(instanceId);
+		}
+		coordinateStore.delete(instanceId);
+		componentSubscribers.delete(instanceId);
+		subscriptionCache.delete(instanceId);
+		snapshotCache.delete(instanceId);
+		serverSnapshotCache.delete(instanceId);
+	}
 }
+/**
+* Creates or retrieves a cached subscription function for a given instanceId.
+* Uses a fan-out pattern: 1 bus listener -> N React subscribers.
+* Automatically cleans up coordinate state when the last subscriber unsubscribes.
+*
+* @param instanceId - The unique identifier for the map
+* @returns A subscription function for useSyncExternalStore
+*/
 function getOrCreateSubscription(instanceId) {
-  const subscription = subscriptionCache.get(instanceId) ?? ((onStoreChange) => {
-    ensureBusListener(instanceId);
-    let subscriberSet = componentSubscribers.get(instanceId);
-    if (!subscriberSet) {
-      subscriberSet = /* @__PURE__ */ new Set();
-      componentSubscribers.set(instanceId, subscriberSet);
-    }
-    subscriberSet.add(onStoreChange);
-    return () => {
-      const currentSubscriberSet = componentSubscribers.get(instanceId);
-      if (currentSubscriberSet) {
-        currentSubscriberSet.delete(onStoreChange);
-      }
-      cleanupBusListenerIfNeeded(instanceId);
-    };
-  });
-  subscriptionCache.set(instanceId, subscription);
-  return subscription;
+	const subscription = subscriptionCache.get(instanceId) ?? ((onStoreChange) => {
+		ensureBusListener(instanceId);
+		let subscriberSet = componentSubscribers.get(instanceId);
+		if (!subscriberSet) {
+			subscriberSet = /* @__PURE__ */ new Set();
+			componentSubscribers.set(instanceId, subscriberSet);
+		}
+		subscriberSet.add(onStoreChange);
+		return () => {
+			const currentSubscriberSet = componentSubscribers.get(instanceId);
+			if (currentSubscriberSet) currentSubscriberSet.delete(onStoreChange);
+			cleanupBusListenerIfNeeded(instanceId);
+		};
+	});
+	subscriptionCache.set(instanceId, subscription);
+	return subscription;
 }
+/**
+* Creates or retrieves a cached snapshot function for a given instanceId.
+* The function must read from the store on every call to get current state.
+*
+* @param instanceId - The unique identifier for the map
+* @returns A snapshot function for useSyncExternalStore that returns formatted coordinate string
+*/
 function getOrCreateSnapshot(instanceId) {
-  let cached = snapshotCache.get(instanceId);
-  if (!cached) {
-    cached = () => {
-      const state = coordinateStore.get(instanceId);
-      if (!state) {
-        return DEFAULT_COORDINATE;
-      }
-      if (!state.coordinate) {
-        return DEFAULT_COORDINATE;
-      }
-      const coord = create(prepareCoord(state.coordinate));
-      return coord[state.format]();
-    };
-    snapshotCache.set(instanceId, cached);
-  }
-  return cached;
+	let cached = snapshotCache.get(instanceId);
+	if (!cached) {
+		cached = () => {
+			const state = coordinateStore.get(instanceId);
+			if (!state) return DEFAULT_COORDINATE;
+			if (!state.coordinate) return DEFAULT_COORDINATE;
+			return create(prepareCoord(state.coordinate))[state.format]();
+		};
+		snapshotCache.set(instanceId, cached);
+	}
+	return cached;
+}
+/**
+* Creates or retrieves a cached server snapshot function for a given instanceId.
+* Server snapshots always return the default coordinate since coordinate state is client-only.
+* Required for SSR/RSC compatibility with useSyncExternalStore.
+*
+* @param instanceId - The unique identifier for the map
+* @returns A server snapshot function for useSyncExternalStore
+*/
+function getOrCreateServerSnapshot(instanceId) {
+	const serverSnapshot = serverSnapshotCache.get(instanceId) ?? (() => DEFAULT_COORDINATE);
+	serverSnapshotCache.set(instanceId, serverSnapshot);
+	return serverSnapshot;
 }
+/**
+* Updates the format for a given map instance and notifies subscribers.
+*
+* @param instanceId - The unique identifier for the map
+* @param format - The new coordinate format to use
+*/
 function setFormatForInstance(instanceId, format) {
-  const state = coordinateStore.get(instanceId);
-  if (state) {
-    state.format = format;
-    const subscribers = componentSubscribers.get(instanceId);
-    if (subscribers) {
-      for (const onStoreChange of subscribers) {
-        onStoreChange();
-      }
-    }
-  }
+	const state = coordinateStore.get(instanceId);
+	if (state) {
+		state.format = format;
+		const subscribers = componentSubscribers.get(instanceId);
+		if (subscribers) for (const onStoreChange of subscribers) onStoreChange();
+	}
 }
+/**
+* Manually clear cursor coordinate state for a specific instanceId.
+* This is typically not needed as cleanup happens automatically when all subscribers unmount.
+* Use this only in advanced scenarios where manual cleanup is required.
+*
+* @param instanceId - The unique identifier for the map to clear
+*
+* @example
+* ```tsx
+* // Manual cleanup (rarely needed)
+* clearCursorCoordinateState('my-map-instance');
+* ```
+*/
 function clearCursorCoordinateState(instanceId) {
-  const unsub = busUnsubscribers.get(instanceId);
-  if (unsub) {
-    unsub();
-    busUnsubscribers.delete(instanceId);
-  }
-  coordinateStore.delete(instanceId);
-  componentSubscribers.delete(instanceId);
-  subscriptionCache.delete(instanceId);
-  snapshotCache.delete(instanceId);
+	const unsub = busUnsubscribers.get(instanceId);
+	if (unsub) {
+		unsub();
+		busUnsubscribers.delete(instanceId);
+	}
+	coordinateStore.delete(instanceId);
+	componentSubscribers.delete(instanceId);
+	subscriptionCache.delete(instanceId);
+	snapshotCache.delete(instanceId);
+	serverSnapshotCache.delete(instanceId);
 }
+/**
+* React hook that tracks and formats the cursor hover position coordinates on a map.
+*
+* Subscribes to map hover events via the event bus and converts coordinates to various
+* geographic formats (Decimal Degrees, DMS, MGRS, UTM, etc.). The hook automatically
+* filters events to only process those from the specified map instance.
+*
+* Uses `useSyncExternalStore` for concurrent-safe updates and efficient fan-out pattern
+* where multiple components can subscribe to the same map's coordinates with a single
+* bus listener.
+*
+* @param id - Optional map instance ID. If not provided, attempts to use the ID from MapProvider context.
+* @returns Object containing the formatted coordinate string and format setter function
+* @property formattedCoord - The formatted coordinate string (defaults to "--, --" when no position)
+* @property setFormat - Function to change the coordinate format system
+* @throws {Error} When no id is provided and hook is used outside MapProvider context
+*
+* @example
+* ```tsx
+* import { uuid } from '@accelint/core';
+* import { useCursorCoordinates } from '@accelint/map-toolkit/cursor-coordinates';
+*
+* const MAP_ID = uuid();
+*
+* function CoordinateDisplay() {
+*   const { formattedCoord, setFormat } = useCursorCoordinates(MAP_ID);
+*
+*   return (
+*     <div>
+*       <select onChange={(e) => setFormat(e.target.value as CoordinateFormatTypes)}>
+*         <option value="dd">Decimal Degrees</option>
+*         <option value="ddm">Degrees Decimal Minutes</option>
+*         <option value="dms">Degrees Minutes Seconds</option>
+*         <option value="mgrs">MGRS</option>
+*         <option value="utm">UTM</option>
+*       </select>
+*       <div>{formattedCoord}</div>
+*     </div>
+*   );
+* }
+* ```
+*/
 function useCursorCoordinates(id) {
-  const contextId = useContext(MapContext);
-  const actualId = id ?? contextId;
-  if (!actualId) {
-    throw new Error(
-      "useCursorCoordinates requires either an id parameter or to be used within a MapProvider"
-    );
-  }
-  if (!coordinateStore.has(actualId)) {
-    coordinateStore.set(actualId, {
-      coordinate: null,
-      format: "dd"
-    });
-  }
-  const formattedCoord = useSyncExternalStore(
-    getOrCreateSubscription(actualId),
-    getOrCreateSnapshot(actualId)
-  );
-  return useMemo(
-    () => ({
-      formattedCoord,
-      setFormat: (format) => setFormatForInstance(actualId, format)
-    }),
-    [formattedCoord, actualId]
-  );
+	const contextId = useContext(MapContext);
+	const actualId = id ?? contextId;
+	if (!actualId) throw new Error("useCursorCoordinates requires either an id parameter or to be used within a MapProvider");
+	if (!coordinateStore.has(actualId)) coordinateStore.set(actualId, {
+		coordinate: null,
+		format: "dd"
+	});
+	const formattedCoord = useSyncExternalStore(getOrCreateSubscription(actualId), getOrCreateSnapshot(actualId), getOrCreateServerSnapshot(actualId));
+	return useMemo(() => ({
+		formattedCoord,
+		setFormat: (format) => setFormatForInstance(actualId, format)
+	}), [formattedCoord, actualId]);
 }
 
+//#endregion
 export { clearCursorCoordinateState, useCursorCoordinates };
-//# sourceMappingURL=use-cursor-coordinates.js.map
 //# sourceMappingURL=use-cursor-coordinates.js.map